BenoitCier
/
Opendistrib
atdalīts no Laclic/Souke
Vērot 1
Pievienot zvaigznīti 0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
529 Revīzijas
2 Atzari
Koks: 71ddab7c74
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '71ddab7c74'
${ noResults }
Opendistrib/backend/controllers/OrderController.php

1344 rindas
50KB
Neapstrādāts Vainot Vēsture 

  1. <?php

  2. 

  3. /** 

  4. Copyright La boîte à pain (2018) 

  5. 

  6. contact@laboiteapain.net

  7. 

  8. Ce logiciel est un programme informatique servant à aider les producteurs 

  9. à distribuer leur production en circuits courts. 

  10. 

  11. Ce logiciel est régi par la licence CeCILL soumise au droit français et

  12. respectant les principes de diffusion des logiciels libres. Vous pouvez

  13. utiliser, modifier et/ou redistribuer ce programme sous les conditions

  14. de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA 

  15. sur le site "http://www.cecill.info".

  16. 

  17. En contrepartie de l'accessibilité au code source et des droits de copie,

  18. de modification et de redistribution accordés par cette licence, il n'est

  19. offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,

  20. seule une responsabilité restreinte pèse sur l'auteur du programme,  le

  21. titulaire des droits patrimoniaux et les concédants successifs.

  22. 

  23. A cet égard  l'attention de l'utilisateur est attirée sur les risques

  24. associés au chargement,  à l'utilisation,  à la modification et/ou au

  25. développement et à la reproduction du logiciel par l'utilisateur étant 

  26. donné sa spécificité de logiciel libre, qui peut le rendre complexe à 

  27. manipuler et qui le réserve donc à des développeurs et des professionnels

  28. avertis possédant  des  connaissances  informatiques approfondies.  Les

  29. utilisateurs sont donc invités à charger  et  tester  l'adéquation  du

  30. logiciel à leurs besoins dans des conditions permettant d'assurer la

  31. sécurité de leurs systèmes et ou de leurs données et, plus généralement, 

  32. à l'utiliser et l'exploiter dans les mêmes conditions de sécurité. 

  33. 

  34. Le fait que vous puissiez accéder à cet en-tête signifie que vous avez 

  35. pris connaissance de la licence CeCILL, et que vous en avez accepté les

  36. termes.

  37. */

  38. 

  39. namespace backend\controllers;

  40. 

  41. use common\models\Order ;

  42. use common\models\ProductOrder ;

  43. use common\models\Product ;

  44. use common\models\User ;

  45. use common\models\ProductDistribution ;

  46. 

  47. class OrderController extends BackendController 

  48. {

  49.     var $enableCsrfValidation = false;

  50. 

  51.     public function behaviors() 

  52.     {

  53.         return [

  54.             'access' => [

  55.                 'class' => AccessControl::className(),

  56.                 'rules' => [

  57.                     [

  58.                         'actions' => ['report-cron'],

  59.                         'allow' => true,

  60.                         'roles' => ['?']

  61.                     ],

  62.                     [

  63.                         'allow' => true,

  64.                         'roles' => ['@'],

  65.                         'matchCallback' => function ($rule, $action) {

  66.                             return User::getCurrentStatus() == USER::STATUS_ADMIN 

  67.                                 || User::getCurrentStatus() == USER::STATUS_PRODUCER;

  68.                         }

  69.                     ]

  70.                 ],

  71.             ],

  72.         ];

  73.     }

  74. 

  75.     /**

  76.      * Génére un PDF récapitulatif des commandes d'un producteur pour une 

  77.      * date donnée.

  78.      * 

  79.      * @param string $date

  80.      * @param boolean $save

  81.      * @param integer $id_etablissement

  82.      * @return PDF|null

  83.      */

  84.     public function actionReport($date = '', $save = false, $idProducer = 0) 

  85.     {

  86.         if (!Yii::$app->user->isGuest) {

  87.             $idProducer = Producer::getId() ;

  88.         }

  89.             

  90.         $arrayOrders = Order::searchAll([

  91.             'date' => $date,

  92.             'date_delete' => 'NULL'

  93.         ],

  94.         [

  95.             'orderby' => 'comment_point_sale ASC, user.name ASC'

  96.         ]) ;

  97.         

  98.         $distribution = Distribution::searchOne([],[

  99.             'conditions' => 'date LIKE :date',

  100.             'params' => [':date' => $date]

  101.         ]) ;

  102.                 

  103.         if ($distribution) {

  104.             $arraySelectedProducts = ProductDistribution::searchProducts($distribution->id) ; 

  105.             $arrayPointsSale = PointSale::searchAll() ;

  106.                     

  107.             foreach ($arrayPointsSale as $pointSale) {

  108.                 $pointSale->initOrders($orders) ; 

  109.             }

  110.                 

  111.             // produits

  112.             $arrayProducts = Product::searchAll() ;

  113. 

  114.             // get your HTML raw content without any layouts or scripts

  115.             $content = $this->renderPartial('report', [

  116.                 'distribution' => $distribution,

  117.                 'date' => $date,

  118.                 'arraySelectedProducts' => $arraySelectedProducts,

  119.                 'arrayPointsSale' => $arrayPointsSale,

  120.                 'arrayProducts' => $arrayProducts,

  121.                 'arrayOrders' => $arrayOrders

  122.             ]);

  123. 

  124.             $dateStr = date('d/m/Y', strtotime($date));

  125. 

  126.             if ($save) {

  127.                 $destination = Pdf::DEST_FILE;

  128.             } else {

  129.                 $destination = Pdf::DEST_BROWSER;

  130.             }

  131. 

  132.             $pdf = new Pdf([

  133.                 // set to use core fonts only

  134.                 'mode' => Pdf::MODE_UTF8,

  135.                 // A4 paper format

  136.                 'format' => Pdf::FORMAT_A4,

  137.                 // portrait orientation

  138.                 'orientation' => Pdf::ORIENT_PORTRAIT,

  139.                 // stream to browser inline

  140.                 'destination' => $destination,

  141.                 'filename' => Yii::getAlias('@app/web/pdf/Commandes-' . $date . '-' . $idProducert . '.pdf'),

  142.                 // your html content input

  143.                 'content' => $content,

  144.                 // format content from your own css file if needed or use the

  145.                 // enhanced bootstrap css built by Krajee for mPDF formatting 

  146.                 //'cssFile' => '@vendor/kartik-v/yii2-mpdf/assets/kv-mpdf-bootstrap.min.css',

  147.                 // any css to be embedded if required

  148.                 //'cssInline' => '.kv-heading-1{font-size:18px}', 

  149.                 // set mPDF properties on the fly

  150.                 //'options' => ['title' => 'Krajee Report Title'],

  151.                 // call mPDF methods on the fly

  152.                 'methods' => [

  153.                     'SetHeader' => ['Commandes du ' . $dateStr],

  154.                     'SetFooter' => ['{PAGENO}'],

  155.                 ]

  156.             ]);

  157. 

  158.             // return the pdf output as per the destination setting

  159.             return $pdf->render();

  160.         }

  161.         

  162.         return null ;

  163.     }

  164. 

  165.     /**

  166.      * Supprime une commande.

  167.      * 

  168.      * @param string $date

  169.      * @param integer $id_commande

  170.      */

  171.     public function actionDeleteOrder($date, $idOrder) 

  172.     {

  173.         $order = Order::searchOne(['id' =>$idOrder]) ;

  174. 

  175.         if ($order) {

  176. 

  177.             // remboursement de la commande

  178.             if ($order->id_user && $order->getAmount(Order::AMOUNT_PAID) && Producer::getConfig('credit')) {

  179.                 $order->creditHistory(

  180.                     CreditHistory::TYPE_REFUND, 

  181.                     $order->getAmount(Order::AMOUNT_PAID), 

  182.                     $order->distribution->id_producer, 

  183.                     $order->id_user,

  184.                     User::getCurrentId()

  185.                 );

  186.             }

  187. 

  188.             $order->delete();

  189.             ProductOrder::deleteAll(['id_order' => $idOrder]);

  190.         }

  191. 

  192.         $this->redirect(['index', 'date' => $date]);

  193.     }

  194. 

  195.     /**

  196.      * Traite le formulaire d'ajout/modification de commande.

  197.      * 

  198.      * @param Production $production

  199.      * @param string $date

  200.      * @param array $points_vente

  201.      * @param array $produits

  202.      * @param array $users

  203.      */

  204.     public function processOrderForm(

  205.         $distribution, $date, $pointsSale, $products, $users) 

  206.     {

  207.         if ($date != '') {

  208.             // commandes

  209.             $orders = Order::searchAll([

  210.                 'production.date' => $date

  211.             ]) ;

  212. 

  213.             foreach ($pointsSale as $point) {

  214.                 $point->initOrder($orders);

  215. 

  216.                 if (isset($_POST['submit_pv']) && $_POST['submit_pv']) {

  217.                     // modifs 

  218.                     foreach ($point->orders as $order) {

  219. 

  220.                         // suppression des product_order                        

  221.                         ProductOrder::deleteAll(['id_order' => $order->id]) ;

  222. 

  223.                         // création des commande_produit modifiés

  224.                         foreach ($products as $product) {

  225.                             $quantity = Yii::$app->getRequest()->post('product_' . $point->id . '_' . $product->id, 0);

  226.                             if ($quantity) {

  227.                                 $productOrder = new ProductOrder;

  228.                                 $productOrder->id_order = $order->id;

  229.                                 $productOrder->id_product = $product->id;

  230.                                 $productOrder->quantity = $quantity;

  231.                                 $productOrder->price = $p->price;

  232.                                 $productOrder->save();

  233.                             }

  234.                         }

  235.                     }

  236. 

  237.                     $username = Yii::$app->getRequest()->post('username_point_sale_' . $point->id, 0);

  238.                     $date = Yii::$app->getRequest()->post('date_order_point_sale_' . $point->id, 0);

  239.                     $oneProduct = false;

  240.                     foreach ($products as $product) {

  241.                         $quantity = Yii::$app->getRequest()->post('product_point_sale_' . $point->id . '_' . $product->id, 0);

  242.                         if ($quantity) {

  243.                             $oneProduct = true;

  244.                         }

  245.                     }

  246. 

  247.                     if (strlen($username) && $date && $oneProduct) {

  248.                         $order = new Order;

  249.                         $order->id_point_sale = $point->id;

  250.                         $order->id_production = $distribution->id;

  251.                         $order->id_user = 0;

  252.                         $order->username = $username;

  253.                         $arrayDate = explode('/', $date);

  254.                         $order->date = $arrayDate[2] . '-' . $arrayDate[1] . '-' . $arrayDate[0] . ' 00:00:00';

  255.                         $order->save();

  256. 

  257.                         foreach ($products as $product) {

  258.                             $quantity = Yii::$app->getRequest()->post('product_point_sale_' . $point->id . '_' . $product->id, 0);

  259.                             if ($quantity) {

  260.                                 $productOrder = new ProductOrder;

  261.                                 $productOrder->id_order = $order->id;

  262.                                 $productOrder->id_product = $product->id;

  263.                                 $productOrder->quantity = $quantity;

  264.                                 $productOrder->price = $p->price;

  265.                                 $productOrder->save();

  266.                             }

  267.                         }

  268.                     }

  269.                 }

  270.             }

  271.         }

  272.     }

  273. 

  274.     /**

  275.      * Page principale de la gestion des commandes.

  276.      * 

  277.      * @param string $date

  278.      * @param boolean $returnData

  279.      * @return string

  280.      */

  281.     public function actionIndex($date = '', $returnData = false) 

  282.     {

  283.         if (!Product::count() && !PointSale::count()) {

  284.             $this->redirect(['site/index', 'error_products_points_sale' => 1]);

  285.         }

  286. 

  287.         $orders = [];

  288. 

  289.         // users

  290.         $arrayUsers = [0 => '--'];

  291.         $users = User::searchAll([],['orderby' => 'lastname, name ASC']) ;

  292.         

  293.         foreach ($users as $user) {

  294.             $arrayUsers[$user->id] = $user->name . ' ' . $user->lastname;

  295.         }

  296. 

  297.         // création du jour de distribution

  298.         $distribution = Distribution::initDistribution($date) ;

  299. 

  300.         // points de vente

  301.         if ($distribution) {

  302.             $arrayPointsSale = PointSale::find()

  303.                 ->joinWith(['pointSaleDistribution' => function($q) use ($distribution) {

  304.                     $q->where(['id_distribution' => $distribution->id]);

  305.                 }])

  306.                 ->where([

  307.                     'id_producer' => Producer::getId(),

  308.                 ])

  309.                 ->all();

  310.         } else {

  311.             $arrayPointsSale = PointSale::searchAll() ;

  312.         }

  313. 

  314.         // produits

  315.         $arrayProducts = Product::searchAll();

  316. 

  317.         // gestion des commandes

  318.         $this->processOrderForm($distribution, $date, $arrayPointsSale, $arrayProducts, $users);

  319. 

  320.         // commandes

  321.         $arrayOrders = Commande::searchAll([

  322.             'date' => $date,

  323.             'date_delete' => 'NULL'

  324.         ]);

  325. 

  326.         $revenues = 0;

  327.         $weight = 0 ;

  328.         $revenuesDelivered = 0;

  329. 

  330.         foreach ($arrayOrders as $order) {

  331.             

  332.             if(is_null($order->date_delete)) {

  333.                 $revenues += $order->amount;

  334.                 if ($order->id_point_sale != 1) {

  335.                     $revenuesDelivered += $order->amount;

  336.                 }

  337.                     

  338.                 $weight += $order->weight;

  339.             }

  340.         }

  341.         $revenues = number_format($revenues, 2);

  342. 

  343.         // init commandes point de vente

  344.         foreach ($arrayPointsSale as $pointSale) {

  345.             $pointSale->initOrders($arrayOrders);

  346. 

  347.             $dataSelectOrders = [];

  348.             $dataOptionsOrders = [];

  349.             foreach ($pointSale->orders as $order) {

  350.                 if ($order->user) {

  351.                     $dataSelectOrders[$order->id] = $order->user->name . ' ' . $c->user->lastname;

  352.                 } else {

  353.                     $dataSelectOrders[$order->id] = $order->username;

  354.                 }

  355. 

  356.                 $dataOptionsOrders[$order->id] = [];

  357.                 $arrayOptions = [];

  358.                 $arrayOptions[$order->id]['amount'] = $c->montant;

  359.                 $arrayOptions[$order->id]['str_amount'] = number_format($c->montant, 2, ',', '') . ' €';

  360.                 $arrayOptions[$order->id]['amount_paid'] = $c->montant_paye;

  361.                 $arrayOptions[$order->id]['products'] = [];

  362.                 $arrayOptions[$order->id]['comment'] = Html::encode($c->commentaire);

  363.                 foreach ($order->productOrder as $productOrder) {

  364.                     $arrayOptions[$order->id]['products'][$productOrder->id_product] = $productOrder->quantity;

  365.                 }

  366. 

  367.                 $dataOptionsOrders[$order->id]['data-commande'] = json_encode($arrayOptions[$order->id]);

  368.                 $dataOptionsOrders[$order->id]['value'] = $order->id;

  369.             }

  370.             $pointSale->data_select_orders = $dataSelectOrders ; 

  371.             $pointSale->data_options_orders = $dataOptionsOrders ;

  372.         }

  373. 

  374.         // gestion produits selec

  375.         if (isset($_POST['validate_product_selec'])) {

  376. 

  377.             if (isset($_POST['Product'])) {

  378. 

  379.                 foreach ($arrayProducts as $product) {

  380.                     $productDistribution = ProductDistribution::searchOne([

  381.                         'id_distribution' => $distribution->id,

  382.                         'id_product' => $product->id

  383.                     ]) ;

  384.                             

  385.                     if (!$productDistribution) {

  386.                         $productDistribution = new ProductDistribution();

  387.                         $productDistribution->id_distribution = $distribution->id;

  388.                         $productDistribution->id_product = $product->id;

  389.                         $productDistribution->active = 0;

  390. 

  391.                         if (isset($product->quantity_max)) {

  392.                             $productDistribution->quantity_max = $product->quantity_max;

  393.                         }

  394.                         else {

  395.                             $productDistribution->quantity_max = null;

  396.                         }

  397.                             

  398. 

  399.                         $productDistribution->save();

  400.                     }

  401. 

  402.                     if (isset($_POST['Product'][$product->id]['active'])) {

  403.                         $productDistribution->active = 1;

  404.                     } else {

  405.                         $productDistribution->active = 0;

  406.                     }

  407. 

  408.                     if ((isset($_POST['Product'][$product->id]['quantity_max']) && $_POST['Product'][$product->id]['quantity_max'] != '')) {

  409.                         $productDistribution->quantity_max = (int) $_POST['Product'][$product->id]['quantity_max'];

  410.                     } else {

  411.                         $productDistribution->quantity_max = null;

  412.                     }

  413. 

  414.                     $productDistribution->save();

  415.                 }

  416.             }

  417.         }

  418. 

  419.         $arrayProductsSelected = [] ;

  420.         if($distribution) {

  421.             // produits selec pour production

  422.             $arrayProductsSelected = ProductDistribution::searchByDistribution($distribution->id) ;

  423.         }

  424. 

  425.         // produits

  426.         if ($distribution) {

  427.             $arrayProducts = Product::searchByDistribution($distribution->id) ;

  428.         }

  429.             

  430.         // poids total de la production et CA potentiel

  431.         $potentialTurnover = 0;

  432.         $totalWeight = 0;

  433.         foreach ($arrayProductsSelected as $idSelectedProduct => $selectedProduct) {

  434.             if ($selectedProduct['active']) {

  435.                 foreach ($arrayProducts as $product) {

  436.                     if ($product->id == $idSelectedProduct) {

  437.                         $potentialTurnover += $selectedProduct['quantity_max'] * $product->price;

  438.                         $totalWeight += $selectedProduct['quantity_max'] * $product->weight / 1000;

  439.                     }

  440.                 }

  441.             }

  442.         }

  443. 

  444.         // jours de distribution

  445.         $arrayDistributionDays = Distribution::searchAll([

  446.             'active' => 1

  447.         ]) ;

  448. 

  449.         // commandes auto

  450.         $subscriptionForm = new SubscriptionForm;

  451. 

  452.         // productions point vente

  453.         $pointSaleDistribution = new PointSaleDistribution;

  454. 

  455.         $oointsSaleDistribution = [];

  456.         

  457.         if ($distribution) {

  458.             $oointsSaleDistribution = PointSaleDistribution::searchAll() ;

  459.         }

  460. 

  461.         $arrayPointsSaleDistribution = [];

  462.         

  463.         foreach ($arrayPointsSaleDistribution as $pointSaleDistribution) {

  464.             $key = $pointSaleDistribution->id_distribution . '-' . $pointSaleDistribution->id_point_sale;

  465.             if ($pointSaleDistribution->delivery == 1) {

  466.                 $pointSaleDistribution->points_sale_distribution[] = $key;

  467.             }

  468.             if(isset($pointSaleDistribution->pointSale) && strlen($pointSaleDistribution->pointSale->name)) {

  469.                 $arrayPointsSaleDistribution[$key] = Html::encode($pointSaleDistribution->pointSale->name);

  470.             }

  471.         }

  472.         

  473.         // une production de la semaine activée ou non

  474.         $oneDistributionWeekActive = false ;

  475. 	$week = sprintf('%02d',date('W',strtotime($date)));

  476. 	$start = strtotime(date('Y',strtotime($date)).'W'.$week);

  477.         $date_lundi = date('Y-m-d',strtotime('Monday',$start)) ;

  478.         $date_mardi = date('Y-m-d',strtotime('Tuesday',$start)) ;

  479.         $date_mercredi = date('Y-m-d',strtotime('Wednesday',$start)) ;

  480.         $date_jeudi = date('Y-m-d',strtotime('Thursday',$start)) ;

  481.         $date_vendredi = date('Y-m-d',strtotime('Friday',$start)) ;

  482.         $date_samedi = date('Y-m-d',strtotime('Saturday',$start)) ;

  483.         $date_dimanche = date('Y-m-d',strtotime('Sunday',$start)) ;

  484.         

  485.         $production_semaine = Distribution::find()

  486.                 ->andWhere([

  487.                     'id_producer' => Producer::getId(),

  488.                     'active' => 1,

  489.                 ])

  490.                 ->andWhere(['or',

  491.                     ['date' => $date_lundi], 

  492.                     ['date' => $date_mardi],

  493.                     ['date' => $date_mercredi],

  494.                     ['date' => $date_jeudi],

  495.                     ['date' => $date_vendredi],

  496.                     ['date' => $date_samedi],

  497.                     ['date' => $date_dimanche],

  498.                 ])

  499.                 ->one();

  500.         if($production_semaine) {

  501.             $oneDistributionWeekActive = true ;

  502.         }

  503. 	

  504.         $datas = [

  505.             'arrayProducts' => $arrayProducts,

  506.             'arrayPointsSale' => $arrayPointsSale,

  507.             'arrayOrders' => $arrayOrders,

  508.             'date' => $date,

  509.             'distribution' => $distribution,

  510.             'arrayDistributionDays' => $arrayDistributionDays,

  511.             'selectedProducts' => $arrayProductsSelected,

  512.             'users' => $arrayUsers,

  513.             'revenues' => $revenues,

  514.             'revenuesDelivered' => $revenuesDelivered,

  515.             'weight' => $weight,

  516.             'potentialTurnover' => $potentialTurnover,

  517.             'totalWeight' => $totalWeight,

  518.             'subscriptionForm' => $subscriptionForm,

  519.             'pointSaleDistribution' => $pointSaleDistribution,

  520.             'arrayPointsSaleDistribution' => $arrayPointsSaleDistribution,

  521.             'oneDistributionWeekActive' => $oneDistributionWeekActive

  522.         ];

  523. 

  524.         if ($return_data) {

  525.             return $datas;

  526.         } else {

  527.             return $this->render('index', $datas);

  528.         }

  529.     }

  530. 

  531.     /**

  532.      * Génère un fichier d'export des commandes au format CSV. 

  533.      * 

  534.      * @param string $date

  535.      * @param integer $id_point_vente

  536.      * @param boolean $global

  537.      */

  538.     public function actionDownload($date = '', $id_point_vente = 0, $global = 0) 

  539.     {

  540.         // commandes

  541.         $commandes = Order::searchAll([

  542.             'production.date' => $date

  543.         ]) ;

  544. 

  545.         foreach ($commandes as $c)

  546.             $c->init();

  547. 

  548.         // points de vente

  549.         $points_vente = PointSale::searchAll() ;

  550.         foreach ($points_vente as $pv)

  551.             $pv->initOrders($commandes);

  552. 

  553.         // produits

  554.         $produits = Product::find()->orderBy('order ASC')->all();

  555. 

  556.         $production = Distribution::find()->where('date LIKE \'' . $date . '\'')->one();

  557.         $produits_selec = ProductDistribution::searchByDistribution($production->id);

  558. 

  559.         /*

  560.          * export global

  561.          */

  562.         if ($global) {

  563. 

  564.             $data = [];

  565.             $filename = 'export_' . $date . '_global';

  566. 

  567.             $num_jour_semaine = date('w', strtotime($date));

  568.             $arr_jour_semaine = [0 => 'sunday', 1 => 'monday', 2 => 'tuesday', 3 => 'wednesday', 4 => 'thursday', 5 => 'friday', 6 => 'saterday'];

  569.             $champs_horaires_point_vente = 'infos_' . $arr_jour_semaine[$num_jour_semaine];

  570. 

  571.             // par point de vente

  572.             foreach ($points_vente as $pv) {

  573.                 if (count($pv->orders) && strlen($pv->$champs_horaires_point_vente)) {

  574. 

  575.                     $line = [$pv->nom, 'Produits', 'Montant', 'Commentaire'];

  576. 

  577.                     $data[] = $line;

  578. 

  579.                     $res = $this->contentPointSaleCSV($date, $produits, $points_vente, $pv->id);

  580.                     foreach ($res['data'] as $line) {

  581.                         $data[] = $line;

  582.                     }

  583.                 }

  584. 

  585.                 if (count($pv->orders) && strlen($pv->$champs_horaires_point_vente)) {

  586. 

  587.                     $line = ['Total pain'];

  588.                     $str_produits = '';

  589.                     foreach ($produits as $p) {

  590.                         if (!$p->vrac && isset($produits_selec[$p->id]['actif']) && $produits_selec[$p->id]['actif']) {

  591.                             $quantite = Order::getProductQuantity($p->id, $pv->commandes);

  592.                             $str_quantite = '';

  593.                             if ($quantite) {

  594.                                 $str_quantite = $quantite;

  595.                                 $str_produits .= $str_quantite . $p->diminutif . ', ';

  596.                             }

  597.                         }

  598.                     }

  599.                     $line[] = substr($str_produits, 0, strlen($str_produits) - 2);

  600.                     $line[] = number_format($pv->revenues, 2) . ' €';

  601.                     $data[] = $line;

  602. 

  603.                     $line = ['Total vrac'];

  604.                     $str_produits = '';

  605.                     foreach ($produits as $p) {

  606.                         if ($p->vrac && isset($produits_selec[$p->id]['active']) && $produits_selec[$p->id]['active']) {

  607.                             $quantite = Order::getProductQuantity($p->id, $pv->orders);

  608.                             $str_quantite = '';

  609.                             if ($quantite) {

  610.                                 $str_quantite = $quantite;

  611.                                 $str_produits .= $str_quantite . $p->diminutif . ', ';

  612.                             }

  613.                         }

  614.                     }

  615.                     $line[] = substr($str_produits, 0, strlen($str_produits) - 2);

  616.                     $line[] = number_format($pv->revenues, 2) . ' €';

  617.                     $data[] = $line;

  618. 

  619.                     $data[] = [];

  620.                 }

  621.             }

  622. 

  623.             $line = ['Total pain'];

  624.             $str_produits = '';

  625.             foreach ($produits as $p) {

  626.                 if (!$p->vrac && isset($produits_selec[$p->id]['active']) && $produits_selec[$p->id]['active']) {

  627.                     $quantite = Order::getProductQuantity($p->id, $commandes);

  628.                     $str_quantite = '';

  629.                     if ($quantite) {

  630.                         $str_quantite = $quantite;

  631.                         $str_produits .= $str_quantite . '' . $p->diminutif . ', ';

  632.                     }

  633.                 }

  634.             }

  635.             $line[] = substr($str_produits, 0, strlen($str_produits) - 2);

  636. 

  637.             $data[] = $line;

  638. 

  639.             // vrac

  640.             $line = ['Total vrac'];

  641.             $str_produits = '';

  642.             foreach ($produits as $p) {

  643.                 if ($p->vrac && isset($produits_selec[$p->id]['active']) && $produits_selec[$p->id]['active']) {

  644.                     $quantite = Order::getProductQuantity($p->id, $commandes);

  645.                     $str_quantite = '';

  646.                     if ($quantite) {

  647.                         $str_quantite = $quantite;

  648.                         $str_produits .= $str_quantite . '' . $p->diminutif . ', ';

  649.                     }

  650.                 }

  651.             }

  652.             $line[] = substr($str_produits, 0, strlen($str_produits) - 2);

  653. 

  654.             $data[] = $line;

  655. 

  656. 

  657.             $infos = $this->actionIndex($date, true);

  658. 

  659.             CSV::downloadSendHeaders($filename . '.csv');

  660.             echo CSV::array2csv($data);

  661.             die();

  662.         }

  663.         /*

  664.          * export individuel

  665.          */ else {

  666.             if ($commandes && count($commandes)) {

  667. 

  668.                 $data = [];

  669. 

  670.                 // par point de vente

  671.                 if ($id_point_vente) {

  672.                     $res = $this->contentPointSaleCSV($date, $produits, $points_vente, $id_point_vente);

  673.                     $data = $res['data'];

  674.                     $filename = $res['filename'];

  675.                 }

  676.                 // récapitulatif

  677.                 else {

  678.                     $res = $this->contentRecapCSV($date, $produits, $points_vente, $commandes);

  679.                     $filename = 'recapitulatif_' . $date;

  680.                     $data = $res['data'];

  681.                 }

  682. 

  683.                 CSV::downloadSendHeaders($filename . '.csv');

  684.                 echo CSV::array2csv($data);

  685.                 die();

  686.             }

  687.         }

  688.     }

  689. 

  690.     /**

  691.      * Génère le contenu nécessaire aux exports au format CSV.

  692.      * 

  693.      * @see OrderController::actionDownload()

  694.      * @param string $date

  695.      * @param array $produits

  696.      * @param array $points_vente

  697.      * @param array $commandes

  698.      * @return array

  699.      */

  700.     public function contentRecapCSV($date, $produits, $points_vente, $commandes) 

  701.     {

  702.         $data = [];

  703.         $filename = 'recapitulatif_' . $date;

  704. 

  705.         $production = Distribution::find()->where('date LIKE \'' . $date . '\'')->one();

  706.         $produits_selec = ProductDistribution::searchByDistribution($production->id);

  707. 

  708.         // head

  709.         $data[0] = ['Lieu'];

  710.         foreach ($produits as $p) {

  711.             if (isset($produits_selec[$p->id]['active']) && $produits_selec[$p->id]['active']) {

  712.                 $data[0][] = $p->description;

  713.             }

  714.         }

  715. 

  716.         $num_jour_semaine = date('w', strtotime($date));

  717.         $arr_jour_semaine = [0 => 'sunday', 1 => 'monday', 2 => 'tuesday', 3 => 'wednesday', 4 => 'thursday', 5 => 'friday', 6 => 'saterday'];

  718.         $champs_horaires_point_vente = 'infos_' . $arr_jour_semaine[$num_jour_semaine];

  719. 

  720. 

  721.         // datas

  722.         foreach ($points_vente as $pv) {

  723.             if (count($pv->orders) && strlen($pv->$champs_horaires_point_vente)) {

  724.                 $data_add = [$pv->name];

  725.                 foreach ($produits as $p) {

  726.                     if (isset($produits_selec[$p->id]['active']) && $produits_selec[$p->id]['active']) {

  727.                         $data_add[] = Order::getProductQuantity($p->id, $pv->orders);

  728.                     }

  729.                 }

  730.                 $data[] = $data_add;

  731.             }

  732.         }

  733. 

  734.         $data_add = ['Total'];

  735.         foreach ($produits as $p) {

  736.             if (isset($produits_selec[$p->id]['active']) && $produits_selec[$p->id]['active']) {

  737.                 $data_add[] = Order::getProductQuantity($p->id, $commandes);

  738.             }

  739.         }

  740.         $data[] = $data_add;

  741. 

  742.         return [

  743.             'data' => $data,

  744.             'filename' => $filename

  745.         ];

  746.     }

  747. 

  748.     /**

  749.      * Génère le contenu relatif aux points de vente nécessaires aux exports au

  750.      * format CSV.

  751.      * 

  752.      * @param string $date

  753.      * @param array $produits

  754.      * @param array $points_vente

  755.      * @param integer $id_point_vente

  756.      * @return array

  757.      */

  758.     public function contentPointSaleCSV($date, $produits, $points_vente, $id_point_vente) 

  759.     {

  760. 

  761.         $data = [];

  762. 

  763.         $production = Distribution::find()->where('date LIKE \'' . $date . '\'')->one();

  764.         $produits_selec = ProductDistribution::searchByDistribution($production->id);

  765. 

  766.         // head

  767.         /* $data[0] = ['Client', 'Date commande'] ;

  768.           foreach($produits as $p) {

  769.           if(isset($produits_selec[$p->id]['actif']) && $produits_selec[$p->id]['actif']) {

  770.           $data[0][] = $p->description ;

  771.           }

  772.           } */

  773. 

  774.         // datas

  775.         foreach ($points_vente as $pv) {

  776.             if ($pv->id == $id_point_vente) {

  777. 

  778.                 $filename = 'export_' . $date . '_' . strtolower(str_replace(' ', '-', $pv->nom));

  779. 

  780.                 foreach ($pv->orders as $c) {

  781. 

  782.                     $str_user = '';

  783. 

  784.                     // username

  785.                     if ($c->user) {

  786.                         $str_user = $c->user->name . " " . $c->user->lastname; //.' - '.date('d/m', strtotime($c->date)) ;

  787.                     } else {

  788.                         $str_user = $c->username; //.' - '.date('d/m', strtotime($c->date)) ;

  789.                     }

  790. 

  791.                     // téléphone

  792.                     if (isset($c->user) && strlen($c->user->phone)) {

  793.                         $str_user .= ' (' . $c->user->phone . ')';

  794.                     }

  795. 

  796.                     $data_add = [$str_user];

  797. 

  798.                     // produits

  799.                     $str_produits = '';

  800.                     foreach ($produits as $p) {

  801.                         if (isset($produits_selec[$p->id]['active']) && $produits_selec[$p->id]['active']) {

  802.                             $add = false;

  803.                             foreach ($c->productOrder as $cp) {

  804.                                 if ($p->id == $cp->id_produit) {

  805.                                     $str_produits .= $cp->quantity ;

  806.                                     $add = true;

  807.                                 }

  808.                             }

  809.                         }

  810.                     }

  811. 

  812.                     $data_add[] = substr($str_produits, 0, strlen($str_produits) - 2);

  813. 

  814.                     $data_add[] = number_format($c->amount, 2) . ' €';

  815. 

  816.                     $data_add[] = $c->comment;

  817. 

  818.                     $data[] = $data_add;

  819.                 }

  820.             }

  821.         }

  822. 

  823.         return [

  824.             'data' => $data,

  825.             'filename' => $filename

  826.         ];

  827.     }

  828.     

  829.     /**

  830.      * Ajoute les commandes récurrentes pour une date donnée.

  831.      * 

  832.      * @param string $date

  833.      */

  834.     public function actionAddSubscriptions($date) 

  835.     {

  836.         Subscription::addAll($date, true);

  837.         $this->redirect(['index', 'date' => $date]);

  838.     }

  839. 

  840.     /**

  841.      * Change l'état d'un jour de production (activé, désactivé).

  842.      * 

  843.      * @param string $date

  844.      * @param integer $actif

  845.      * @param boolean $redirect

  846.      */

  847.     public function actionChangeState($date, $active, $redirect = true) 

  848.     {

  849.         // changement état

  850.         $distribution = Distribution::initDistribution($date) ;

  851.         $distribution->active = $active;

  852.         $distribution->save();

  853. 

  854.         if ($active) {

  855.             // add commandes automatiques

  856.             Subscription::addAll($date);

  857.         }

  858. 

  859.         if($redirect) {

  860.             $this->redirect(['index', 'date' => $date]);

  861.         }

  862.     }

  863.     

  864.     /**

  865.      * Change l'état d'une semaine de production (activé, désactivé).

  866.      * 

  867.      * @param string $date

  868.      * @param integer $actif

  869.      */

  870.     public function actionChangeStateWeek($date, $active) 

  871.     {    

  872.         $week = sprintf('%02d',date('W',strtotime($date)));

  873. 	$start = strtotime(date('Y',strtotime($date)).'W'.$week);

  874.         $date_lundi = date('Y-m-d',strtotime('Monday',$start)) ;

  875.         $date_mardi = date('Y-m-d',strtotime('Tuesday',$start)) ;

  876.         $date_mercredi = date('Y-m-d',strtotime('Wednesday',$start)) ;

  877.         $date_jeudi = date('Y-m-d',strtotime('Thursday',$start)) ;

  878.         $date_vendredi = date('Y-m-d',strtotime('Friday',$start)) ;

  879.         $date_samedi = date('Y-m-d',strtotime('Saturday',$start)) ;

  880.         $date_dimanche = date('Y-m-d',strtotime('Sunday',$start)) ;

  881.                 

  882.         $points_vente = PointSale::searchAll() ;

  883.                 

  884.         $lundi_active = false ;

  885.         $mardi_active = false ;        

  886.         $mercredi_active = false ;

  887.         $jeudi_active = false ;

  888.         $vendredi_active = false ;

  889.         $samedi_active = false ;

  890.         $dimanche_active = false ;

  891.         

  892.         foreach($points_vente as $pv) {

  893.             if($pv->livraison_lundi) $lundi_active = true ;

  894.             if($pv->livraison_mardi) $mardi_active = true ;

  895.             if($pv->livraison_mercredi) $mercredi_active = true ;

  896.             if($pv->livraison_jeudi) $jeudi_active = true ;

  897.             if($pv->livraison_vendredi) $vendredi_active = true ;

  898.             if($pv->livraison_samedi) $samedi_active = true ;

  899.             if($pv->livraison_dimanche) $dimanche_active = true ;

  900.         }

  901.         

  902.         if($lundi_active || !$active) $this->actionChangeState($date_lundi, $active, false) ;

  903.         if($mardi_active || !$active) $this->actionChangeState($date_mardi, $active, false) ;

  904.         if($mercredi_active || !$active) $this->actionChangeState($date_mercredi, $active, false) ;

  905.         if($jeudi_active || !$active) $this->actionChangeState($date_jeudi, $active, false) ;

  906.         if($vendredi_active || !$active) $this->actionChangeState($date_vendredi, $active, false) ;

  907.         if($samedi_active || !$active) $this->actionChangeState($date_samedi, $active, false) ;

  908.         if($dimanche_active || !$active) $this->actionChangeState($date_dimanche, $active, false) ;

  909. 

  910.         $this->redirect(['index', 'date' => $date]);

  911.     }

  912. 

  913.     /**

  914.      * Met à jour une commande via une requête AJAX.

  915.      * 

  916.      * @param integer $id_commande

  917.      * @param array $produits

  918.      * @param string $date

  919.      * @param string $commentaire

  920.      */

  921.     public function actionAjaxUpdate(

  922.         $idOrder, $products, $date, $comment) 

  923.     {

  924.         $commande = Order::searchOne(['id' => $idOrder]) ;

  925. 

  926.         if ($commande &&

  927.                 $commande->distribution->id_producer == Producer::getId()) {

  928.             

  929.             $produits = json_decode($produits);

  930.             foreach ($produits as $key => $quantite) {

  931.                 $commande_produit = ProductOrder::findOne([

  932.                             'id_commande' => $id_commande,

  933.                             'id_produit' => $key

  934.                         ]);

  935. 

  936.                 if ($quantite) {

  937.                     if ($commande_produit) {

  938. 

  939.                         $commande_produit->quantity = $quantite;

  940.                     } else {

  941. 

  942.                         $produit = Product::findOne($key);

  943. 

  944.                         if ($produit) {

  945.                             $commande_produit = new ProductOrder;

  946.                             $commande_produit->id_order = $idOrder;

  947.                             $commande_produit->id_product = $key;

  948.                             $commande_produit->quantity = $quantite;

  949.                             $commande_produit->price = $produit->price;

  950.                         }

  951.                     }

  952. 

  953.                     $commande_produit->save();

  954.                 } else {

  955.                     if ($commande_produit)

  956.                         $commande_produit->delete();

  957.                 }

  958.             }

  959. 

  960.             $commande->date_update = date('Y-m-d H:i:s');

  961.             $commande->comment = $comment;

  962.             $commande->save();

  963. 

  964.             // data commande

  965.             $json_commande = $commande->getDataJson();

  966. 

  967.             // total point de vente

  968.             $point_vente = PointSale::findOne($commande->id_point_sale);

  969.             $commandes = Order::searchAll([

  970.                 'distribution.date' => $date

  971.             ]) ;

  972.                   

  973.             $point_vente->initOrders($commandes);

  974. 

  975.             echo json_encode([

  976.                 'total_pv' => number_format($point_vente->revenues, 2) . ' €',

  977.                 'json_commande' => $json_commande

  978.             ]);

  979. 

  980.             die();

  981.         }

  982.     }

  983. 

  984.     /**

  985.      * Supprime une commande via une requête AJAX.

  986.      * 

  987.      * @param string $date

  988.      * @param integer $id_commande

  989.      */

  990.     public function actionAjaxDelete($date, $idOrder) 

  991.     {

  992.         $commande = Order::searchOne([

  993.             'id' => $idOrder

  994.         ]) ;

  995.                 

  996.         // delete

  997.         if ($commande) {

  998.             // remboursement si l'utilisateur a payé pour cette commande

  999.             $montant_paye = $commande->getAmount(Order::AMOUNT_PAID);

  1000.             if ($montant_paye > 0.01) {

  1001.                 $commande->creditHistory(

  1002.                     CreditHistory::TYPE_REFUND, 

  1003.                     $montant_paye, 

  1004.                     Producer::getId(), 

  1005.                     $commande->id_user,

  1006.                     User::getCurrentId()

  1007.                 );

  1008.             }

  1009. 

  1010.             $commande->delete();

  1011.             ProductOrder::deleteAll(['id_order' => $idOrder]);

  1012.         }

  1013. 

  1014.         // total point de vente

  1015.         $point_vente = PointSale::findOne($commande->id_point_sale);

  1016.         $commandes = Order::searchAll([

  1017.             'distribution.date' => $date,

  1018.         ]) ;

  1019.                 

  1020.         $point_vente->initOrders($commandes);

  1021. 

  1022.         echo json_encode([

  1023.             'total_pv' => number_format($point_vente->revenues, 2) . ' €',

  1024.         ]);

  1025. 

  1026.         die();

  1027.     }

  1028. 

  1029.     /**

  1030.      * Crée une commande via une requête AJAX.

  1031.      * 

  1032.      * @param string $date

  1033.      * @param integer $id_pv

  1034.      * @param integer $id_user

  1035.      * @param string $username

  1036.      * @param array $produits

  1037.      * @param string $commentaire

  1038.      */

  1039.     public function actionAjaxCreate(

  1040.         $date, $id_pv, $id_user, $username, $produits, $commentaire) 

  1041.     {

  1042.         $produits = json_decode($produits);

  1043.         $point_vente = PointSale::findOne($id_pv);

  1044.         $production = Distribution::searchOne([

  1045.             'date' => $date

  1046.         ]);

  1047. 

  1048.         if (preg_match("/^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])$/", $date) &&

  1049.                 ($id_user || strlen($username)) &&

  1050.                 $point_vente &&

  1051.                 count($produits) &&

  1052.                 $production) {

  1053.             $commande = new Order;

  1054.             $commande->date = date('Y-m-d H:i:s', strtotime($date . ' ' . date('H:i:s')));

  1055.             $commande->id_point_sale = $id_pv;

  1056.             $commande->id_distribution = $production->id;

  1057.             $commande->type = Order::ORIGIN_ADMIN;

  1058.             $commande->comment = $commentaire;

  1059. 

  1060.             if ($id_user) {

  1061.                 $commande->id_user = $id_user;

  1062. 

  1063.                 // commentaire du point de vente

  1064.                 $point_vente_user = UserPointSale::searchOne([

  1065.                     'id_point_sale' => $id_pv,

  1066.                     'id_user' => $id_user

  1067.                 ]) ;

  1068. 

  1069.                 if ($point_vente_user && strlen($point_vente_user->comment)) {

  1070.                     $commande->point_sale_comment = $point_vente_user->comment;

  1071.                 }

  1072.             } else {

  1073.                 $commande->username = $username;

  1074.                 $commande->id_user = 0;

  1075.             }

  1076. 

  1077.             $commande->save();

  1078. 

  1079.             foreach ($produits as $key => $quantite) {

  1080.                 $produit = Product::findOne($key);

  1081.                 if ($produit) {

  1082.                     $commande_produit = new ProductOrder;

  1083.                     $commande_produit->id_order = $commande->id;

  1084.                     $commande_produit->id_product = $key;

  1085.                     $commande_produit->quantity = $quantite;

  1086.                     $commande_produit->price = $produit->price;

  1087.                     $commande_produit->save();

  1088.                 }

  1089.             }

  1090. 

  1091.             // total point de vente

  1092.             $point_vente = PointSale::findOne($commande->id_point_sale);

  1093.             $commandes = Order::searchAll([

  1094.                 'distribution.date' => $date

  1095.             ]) ;

  1096.             

  1097.             $point_vente->initOrders($commandes);

  1098. 

  1099.             // json commande

  1100.             $commande = Order::searchOne([

  1101.                 'id' => $commande->id

  1102.             ]) ;

  1103. 

  1104.             $produits = [];

  1105.             foreach ($commande->productOrder as $cp) {

  1106.                 $produits[$cp->id_product] = $cp->quantity;

  1107.             }

  1108. 

  1109.             $json_commande = json_encode(['montant' => number_format($commande->amount, 2), 'produits' => $produits]);

  1110.             $json_commande = $commande->getDataJson();

  1111. 

  1112.             $str_user = '';

  1113.             if ($commande->user)

  1114.                 $str_user = $commande->user->name . ' ' . $commande->user->lastname;

  1115.             else

  1116.                 $str_user = $commande->username;

  1117. 

  1118.             $str_commentaire = '';

  1119.             if (strlen($commande->comment)) {

  1120.                 $str_commentaire = ' <span class="glyphicon glyphicon-comment"></span>';

  1121.             }

  1122. 

  1123.             $str_label_type_commande = '';

  1124.             if ($commande->type) {

  1125.                 $str_label_type_commande = ' <span class="label label-warning">vous</span>';

  1126.             }

  1127. 

  1128.             echo json_encode([

  1129.                 'id_commande' => $commande->id,

  1130.                 'total_pv' => number_format($point_vente->revenues, 2) . ' €',

  1131.                 'commande' => '<li>'

  1132.                 . '<a class="btn btn-default" href="javascript:void(0);" '

  1133.                 . 'data-pv-id="' . $id_pv . '" '

  1134.                 . 'data-id-commande="' . $commande->id . '" '

  1135.                 . 'data-commande=\'' . $json_commande . '\' '

  1136.                 . 'data-date="' . date('d/m H:i', strtotime($commande->date)) . '">'

  1137.                 . '<span class="montant">' . number_format($commande->amount, 2) . ' €</span>'

  1138.                 . '<span class="user">' . $str_label_type_commande . ' ' . $str_user . '</span>'

  1139.                 . $str_commentaire

  1140.                 . '</a></li>',

  1141.             ]);

  1142.             die();

  1143.         }

  1144.     }

  1145. 

  1146.     /**

  1147.      * Retourne un récapitulatif du total des commandes (potentiel, commandé et

  1148.      * par produits) au format HTML;

  1149.      * 

  1150.      * @param string $date

  1151.      */

  1152.     public function actionAjaxTotalOrders($date) {

  1153. 

  1154.         $production = Distribution::searchOne([

  1155.             'date' => $date

  1156.         ]) ;

  1157. 

  1158.         if ($production) {

  1159.             // produits

  1160.             $produits = Product::searchOne() ;

  1161. 

  1162.             // commandes

  1163.             $commandes = Order::searchAll([

  1164.                 'distribution.date' => $date

  1165.             ]) ;

  1166. 

  1167.             $recettes = 0;

  1168.             $poids_pain = 0;

  1169.             foreach ($commandes as $c) {

  1170.                 $c->init();

  1171.                 

  1172.                 if(is_null($c->date_delete)) {

  1173.                     $recettes += $c->amount;

  1174.                     $poids_pain += $c->weight;

  1175.                 }

  1176.             }

  1177. 

  1178.             // produits selec pour production

  1179.             $produits_selec = ProductDistribution::searchByDistribution($production->id);

  1180. 

  1181.             $ca_potentiel = 0;

  1182.             $poids_total = 0;

  1183.             foreach ($produits_selec as $id_produit_selec => $produit_selec) {

  1184.                 if ($produit_selec['active']) {

  1185.                     foreach ($produits as $produit) {

  1186.                         if ($produit->id == $id_produit_selec) {

  1187.                             $ca_potentiel += $produit_selec['quantity_max'] * $produit->price;

  1188.                             $poids_total += $produit_selec['quantity_max'] * $produit->weight / 1000;

  1189.                         }

  1190.                     }

  1191.                 }

  1192.             }

  1193. 

  1194.             $html_totaux = $this->renderPartial('_total_commandes.php', [

  1195.                 'produits' => $produits,

  1196.                 'commandes' => $commandes,

  1197.                 'produits_selec' => $produits_selec,

  1198.                 'recettes' => $recettes,

  1199.                 'poids_total' => $poids_total,

  1200.                 'ca_potentiel' => $ca_potentiel,

  1201.                 'poids_pain' => $poids_pain,

  1202.             ]);

  1203. 

  1204.             echo json_encode([

  1205.                 'html_totaux' => $html_totaux,

  1206.             ]);

  1207.         }

  1208. 

  1209.         die();

  1210.     }

  1211. 

  1212.     /**

  1213.      * Active ou désactive la livraison dans un point de vente.

  1214.      * 

  1215.      * @param integer $id_production

  1216.      * @param integer $id_point_vente

  1217.      * @param boolean $bool_livraison

  1218.      */

  1219.     public function actionAjaxPointSaleDelivery(

  1220.         $id_production, $id_point_vente, $bool_livraison) 

  1221.     {

  1222. 

  1223.         $production_point_vente = PointSaleDistribution::searchOne([

  1224.             'id_production' => $id_production,

  1225.             'id_point_vente' => $id_point_vente,

  1226.         ]) ;

  1227. 

  1228.         if ($production_point_vente) {

  1229.             $production_point_vente->delivery = $bool_livraison;

  1230.             $production_point_vente->save();

  1231.         }

  1232. 

  1233.         die();

  1234.     }

  1235. 

  1236.     /**

  1237.      * Retourne l'état du paiement (historique, crédit) d'une commande donnée.

  1238.      * 

  1239.      * @param integer $id_commande

  1240.      */

  1241.     public function actionPaymentStatus($id_commande) 

  1242.     {

  1243.         $commande = Commande::searchOne(['id' => $id_commande]) ;

  1244.                 

  1245.         if ($commande) {

  1246.             $commande->init();

  1247.             $html = '';

  1248. 

  1249.             if ($commande->id_user) {

  1250.                 $user_etablissement = UserProducer::find()

  1251.                         ->where([

  1252.                             'id_user' => $commande->id_user,

  1253.                             'id_producer' => $commande->distribution->id_producer

  1254.                         ])

  1255.                         ->one();

  1256. 

  1257.                 $montant_paye = $commande->getAmount();

  1258.                 //$html .= $commande->montant.' | '.$montant_paye ;

  1259. 

  1260.                 if (abs($commande->amount - $montant_paye) < 0.0001) {

  1261.                     $html .= '<span class="label label-success">Payé</span>';

  1262.                     $buttons_credit = Html::a('Rembourser ' . $commande->getAmount(Order::AMOUNT_TOTAL, true), 'javascript:void(0);', ['class' => 'btn btn-default btn-xs rembourser', 'data-montant' => $commande->amount, 'data-type' => 'remboursement']);

  1263.                 } elseif ($commande->amount > $montant_paye) {

  1264.                     $montant_payer = $commande->amount - $montant_paye;

  1265.                     $html .= '<span class="label label-danger">Non payé</span> reste <strong>' . number_format($montant_payer, 2) . ' €</strong> à payer';

  1266.                     $buttons_credit = Html::a('Payer ' . number_format($montant_payer, 2) . ' €', 'javascript:void(0);', ['class' => 'btn btn-default btn-xs payer', 'data-montant' => $montant_payer, 'data-type' => 'paiement']);

  1267.                 } elseif ($commande->amount < $montant_paye) {

  1268.                     $montant_rembourser = $montant_paye - $commande->amount;

  1269.                     $html .= ' <span class="label label-success">Payé</span> <strong>' . number_format($montant_rembourser, 2) . ' €</strong> à rembourser';

  1270.                     $buttons_credit = Html::a('Rembourser ' . number_format($montant_rembourser, 2) . ' €', 'javascript:void(0);', ['class' => 'btn btn-default btn-xs rembourser', 'data-montant' => $montant_rembourser, 'data-type' => 'remboursement']);

  1271.                 }

  1272. 

  1273.                 $html .= '<span class="buttons-credit">'

  1274.                         . 'Crédit pain : <strong>' . number_format($user_etablissement->credit, 2) . '  €</strong><br />'

  1275.                         . $buttons_credit

  1276.                         . '</span>';

  1277. 

  1278.                 // historique

  1279.                 $historique = CreditHistory::find()

  1280.                         ->with('userAction')

  1281.                         ->where(['id_order' => $id_commande])

  1282.                         ->all();

  1283. 

  1284.                 $html .= '<br /><br /><strong>Historique</strong><br /><table class="table table-condensed table-bordered">'

  1285.                         . '<thead><tr><th>Date</th><th>Utilisateur</th><th>Action</th><th>- Débit</th><th>+ Crédit</th></tr></thead>'

  1286.                         . '<tbody>';

  1287. 

  1288.                 if ($historique && is_array($historique) && count($historique)) {

  1289.                     foreach ($historique as $h) {

  1290.                         $html .= '<tr>'

  1291.                                 . '<td>' . date('d/m/Y H:i:s', strtotime($h->date)) . '</td>'

  1292.                                 . '<td>' . Html::encode($h->strUserAction()) . '</td>'

  1293.                                 . '<td>' . $h->getStrLibelle() . '</td>'

  1294.                                 . '<td>' . ($h->isTypeDebit() ? '- '.$h->getAmount(Order::AMOUNT_TOTAL,true) : '') . '</td>'

  1295.                                 . '<td>' . ($h->isTypeCredit() ? '+ '.$h->getAmount(Order::AMOUNT_TOTAL,true) : '') . '</td>'

  1296.                                 . '</tr>';

  1297.                     }

  1298.                 } else {

  1299.                     $html .= '<tr><td colspan="4">Aucun résultat</td></tr>';

  1300.                 }

  1301. 

  1302.                 $html .= '</tbody></table>';

  1303.             } else {

  1304.                 $html .= '<div class="alert alert-warning">Pas de gestion de crédit pain pour cette commande car elle n\'est pas liée à un compte utilisateur.</div>';

  1305.             }

  1306. 

  1307.             echo json_encode([

  1308.                 'html_statut_paiement' => $html,

  1309.                 'json_commande' => $commande->getDataJson()

  1310.             ]);

  1311.         }

  1312. 

  1313.         die();

  1314.     }

  1315. 

  1316.     /**

  1317.      * Effectue le paiement/remboursement d'une commande.

  1318.      * 

  1319.      * @param integer $id_commande

  1320.      * @param string $type

  1321.      * @param float $montant

  1322.      * @return string

  1323.      */

  1324.     public function actionPayment($id_commande, $type, $montant) 

  1325.     {

  1326.         $commande = Order::searchOne([

  1327.             'id' => $id_order

  1328.         ]) ;

  1329.         

  1330.         if ($commande) {

  1331.             $commande->creditHistory(

  1332.                 $type, 

  1333.                 $montant, 

  1334.                 Producer::getId(), 

  1335.                 $commande->id_user,

  1336.                 User::getCurrentId()

  1337.             );

  1338.         }

  1339. 

  1340.         return $this->actionPaymentStatus($id_commande);

  1341.     }

  1342. 

  1343. }

  1344.