Merge branch 'develop'

backend/controllers/DistributionController.php

         $orderManager = $this->getOrderManager();
         $productManager = $this->getProductManager();
         $userManager = $this->getUserManager();
-        $pointSaleManager = $this->getPointSaleManager();
 
         $producer = $this->getProducerCurrent();
         $format = 'Y-m-d';
             $distribution = $distributionManager->createDistributionIfNotExist($date);
             $ordersArray = $orderManager->findOrdersByDistribution($distribution);
             $ordersArrayObject = $ordersArray;
-            $productsArray = $productManager->findProductsByDistribution($distribution);
+            $productsArray = $productManager->findProductsByDistribution($distribution, false);
 
             $json['products'] = $this->buildAjaxInfosResponseProducts($distribution, $productsArray, $ordersArray);
             $json['distribution'] = $this->buildAjaxInfosResponseDistribution($distribution, $ordersArrayObject, $productsArray);
 
             if (!isset($product->productDistribution[0])) {
                 $productDistributionAdd = $distributionManager->addProduct($distribution, $product);
-                $jsonProduct['productDistribution'][0] = $productDistributionAdd->getAttributes();
-                $product->populateRelation('productDistribution', [$productDistributionAdd]);
+                if($productDistributionAdd) {
+                    $jsonProduct['productDistribution'][0] = $productDistributionAdd->getAttributes();
+                    $product->populateRelation('productDistribution', [$productDistributionAdd]);
+                }
             }
             else {
                 foreach($product->productDistribution as $key => $productDistribution) {
                 }
             }
 
-            if (!is_numeric($product->productDistribution[0]->quantity_max)) {
+            if (!isset($product->productDistribution[0]) || !is_numeric($product->productDistribution[0]->quantity_max)) {
                 $jsonProduct['quantity_remaining'] = null;
             } else {
                 $jsonProduct['quantity_remaining'] = $product->productDistribution[0]->quantity_max - $quantityOrder;
                 $oneProductUnactivated = false;
                 foreach ($order->productOrder as $productOrder) {
                     foreach ($productsArray as $product) {
-                        if ($productOrder->id_product == $product['id'] && !$product['productDistribution'][0]['active']) {
+                        if ($productOrder->id_product == $product['id'] && isset($product['productDistribution'][0]) && !$product['productDistribution'][0]['active']) {
                             $oneProductUnactivated = true;
                         }
                     }

backend/controllers/DocumentController.php

         if($documentManager->isDocumentInvoice($document) && $documentManager->isStatusValid($document)) {
             $payment = $paymentManager->instanciatePayment(
                 Payment::TYPE_PAYMENT,
-                number_format($documentManager->getAmountWithTax($document), 3),
+                number_format($documentManager->getAmountWithTax($document, Order::INVOICE_AMOUNT_TOTAL), 2),
                 $this->getProducerCurrent(),
                 null,
                 null,
                 MeanPayment::TRANSFER,
                 null,
+                null,
                 $document
             );
             $payment->amount = number_format($payment->amount, 2);
 
             if ($document) {
                 $ordersArray = [];
-                $productsArray = $productManager->findProducts();
+                $productsArray = $productManager->findProducts(false);
 
                 foreach ($document->orders as $order) {
                     $orderManager->initOrder($order);

backend/controllers/ProducerController.php

 use yii\filters\VerbFilter;
 use yii\filters\AccessControl;
 use common\helpers\Upload;
+use yii\web\UploadedFile;
 
 /**
  * UserController implements the CRUD actions for User model.
      */
     public function actionUpdate()
     {
-        $producerManager = $this->getProducerManager();
+        $producerContainer = $this->getProducerContainer();
+        $producerBuilder = $producerContainer->getBuilder();
         $request = Yii::$app->request;
         $model = $this->findModel(GlobalParam::getCurrentProducerId());
+
         $logoFilenameOld = $model->logo;
         $photoFilenameOld = $model->photo;
-        if (strlen($model->option_dashboard_date_start)) {
-            $model->option_dashboard_date_start = date('d/m/Y', strtotime($model->option_dashboard_date_start));
-        }
-        if (strlen($model->option_dashboard_date_end)) {
-            $model->option_dashboard_date_end = date('d/m/Y', strtotime($model->option_dashboard_date_end));
-        }
+        $producerBuilder->initOptionDashboardDatesDisplay($model);
 
-        if ($model->load(\Yii::$app->request->post()) && $model->save()) {
+        if ($model->load(\Yii::$app->request->post())) {
 
-            if (strlen($model->option_dashboard_date_start)) {
-                $model->option_dashboard_date_start = date(
-                    'Y-m-d',
-                    strtotime(str_replace('/', '-', $model->option_dashboard_date_start)
-                    ));
-                $model->save();
-            }
-
-            if (strlen($model->option_dashboard_date_end)) {
-                $model->option_dashboard_date_end = date(
-                    'Y-m-d',
-                    strtotime(str_replace('/', '-', $model->option_dashboard_date_end))
-                );
-                $model->save();
-            }
+            $model->logoFile = UploadedFile::getInstance($model, 'logoFile');
+            $model->photoFile = UploadedFile::getInstance($model, 'photoFile');
 
-            Upload::uploadFile($model, 'logo', $logoFilenameOld);
-            Upload::uploadFile($model, 'photo', $photoFilenameOld);
+            if($model->validate()) {
 
-            $deleteLogo = $request->post('delete_logo', 0);
-            if ($deleteLogo) {
-                $model->logo = '';
+                $producerBuilder->processUploadImage($model, 'logo', $logoFilenameOld, $request->post('delete_logo', 0));
+                $producerBuilder->processUploadImage($model, 'photo', $photoFilenameOld, $request->post('delete_photo', 0));
+                $producerBuilder->initOptionDashboardDatesBeforeSave($model);
+                $producerBuilder->savePrivateKeysStripe($model);
                 $model->save();
-            }
 
-            $deletePhoto = $request->post('delete_photo', 0);
-            if ($deletePhoto) {
-                $model->photo = '';
-                $model->save();
+                $this->setFlash('success', 'Paramètres mis à jour.');
+                return $this->redirect(['update', 'id' => $model->id, 'edit_ok' => true]);
             }
+        }
 
-            $producerManager->savePrivateKeyApiStripe($model);
-            $producerManager->savePrivateKeyEndpointStripe($model);
-
-            $model->option_stripe_private_key = '';
-            $model->option_stripe_endpoint_secret = '';
-            $model->save();
-
-            $this->setFlash('success', 'Paramètres mis à jour.');
-            return $this->redirect(['update', 'id' => $model->id, 'edit_ok' => true]);
-        } else {
-            if ($model->load(\Yii::$app->request->post())) {
-                $this->setFlash('error', 'Le formulaire comporte des erreurs.');
-            }
-            return $this->render('update', [
-                'model' => $model,
-            ]);
+        if ($model->load(\Yii::$app->request->post())) {
+            $this->setFlash('error', 'Le formulaire comporte des erreurs.');
         }
+
+        return $this->render('update', [
+            'model' => $model,
+        ]);
     }
 
     /**

backend/controllers/ProductController.php

 
         $model = $productManager->instanciateProduct();
 
-        $model->active = 1;
+        $model->status = Product::STATUS_ONLINE;
         $model->id_producer = GlobalParam::getCurrentProducerId();
         $model->monday = 1;
         $model->tuesday = 1;
         $model->sunday = 1;
         $model->available_on_points_sale = 1;
 
-        if ($model->load(\Yii::$app->request->post()) && $productManager->saveCreate($model)) {
+        if ($model->load(\Yii::$app->request->post())) {
 
-            $lastProductOrder = Product::find()->where('id_producer = :id_producer')->params([':id_producer' => GlobalParam::getCurrentProducerId()])->orderBy('order DESC')->one();
-            if ($lastProductOrder) {
-                $model->order = ++$lastProductOrder->order;
-            }
+            $model->photoFile = UploadedFile::getInstance($model, 'photoFile');
+            if($model->validate()) {
 
-            Upload::uploadFile($model, 'photo');
-            $productManager->saveUpdate($model);
+                $lastProductOrder = Product::find()->where('id_producer = :id_producer')->params([':id_producer' => GlobalParam::getCurrentProducerId()])->orderBy('order DESC')->one();
+                if ($lastProductOrder) {
+                    $model->order = ++$lastProductOrder->order;
+                }
+                $productManager->create($model);
 
-            $this->processAvailabilityPointsSale($model);
-            $distributionManager->addProductIncomingDistributions($model);
+                if($model->photoFile) {
+                    Upload::uploadFile($model, 'photoFile', 'photo');
+                }
 
-            $this->setFlash('success', 'Produit <strong>' . Html::encode($model->name) . '</strong> ajouté');
+                $this->processAvailabilityPointsSale($model);
+                $distributionManager->addProductIncomingDistributions($model);
 
-            return $this->redirect(['index']);
-        } else {
-            return $this->render('create', [
-                'model' => $model,
-            ]);
+                $this->setFlash('success', 'Produit <strong>' . Html::encode($model->name) . '</strong> ajouté');
+
+                return $this->redirect(['index']);
+            }
         }
+
+        return $this->render('create', [
+            'model' => $model,
+        ]);
     }
 
     /**
 
         $photoFilenameOld = $model->photo;
 
-        if ($model->load(\Yii::$app->request->post()) && $productManager->saveUpdate($model)) {
+        if (Yii::$app->request->isPost && $model->load(\Yii::$app->request->post())) {
 
-            Upload::uploadFile($model, 'photo', $photoFilenameOld);
+            $model->photoFile = UploadedFile::getInstance($model, 'photoFile');
 
-            $deletePhoto = $request->post('delete_photo', 0);
-            if ($deletePhoto) {
-                $model->photo = '';
-                $model->save();
-            }
+            if($model->validate()) {
+                if($model->photoFile) {
+                    Upload::uploadFile($model, 'photoFile', 'photo', $photoFilenameOld);
+                }
 
-            $this->processAvailabilityPointsSale($model);
+                $deletePhoto = $request->post('delete_photo', 0);
+                if ($deletePhoto) {
+                    $model->photo = '';
+                    $model->save();
+                }
 
-            if ($model->apply_distributions) {
-                $distributionManager->addProductIncomingDistributions($model);
-            }
+                $this->processAvailabilityPointsSale($model);
+                if ($model->apply_distributions) {
+                    $distributionManager->addProductIncomingDistributions($model);
+                }
+                $productManager->update($model);
 
-            $this->setFlash('success', 'Produit <strong>' . Html::encode($model->name) . '</strong> modifié');
-            return $this->redirect(['index']);
+                $this->setFlash('success', 'Produit <strong>' . Html::encode($model->name) . '</strong> modifié');
+                return $this->redirect(['index']);
+            }
         }
 
         return $this->render('update/update', [
      */
     public function actionDelete(int $id, bool $confirm = false)
     {
+        $productContainer = $this->getProductContainer();
+        $productDistributionContainer = $this->getProductDistributionContainer();
         $product = $this->findModel($id);
 
         if ($confirm) {
-            $product->delete();
-            ProductDistribution::deleteAll(['id_product' => $id]);
+            $productContainer->getBuilder()->updateStatusDeleted($product);
+            $productDistributionContainer->getBuilder()->disableProductDistributionsIncomingByProduct($product);
 
             $this->setFlash('success', 'Produit <strong>' . Html::encode($product->name) . '</strong> supprimé');
         } else {
         }
     }
 
-    public function actionAjaxToggleActive($id, $active)
+    public function actionAjaxToggleStatus($id, $status)
     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
 
         $distributionManager = $this->getDistributionManager();
 
         $product = $this->findModel($id);
-        $product->active = (int) $active;
+        $product->status = (int) $status;
         $product->save();
 
         $distributionManager->addProductIncomingDistributions($product);
 
-        return ['success', 'id' => $id, 'active' => $active];
+        return ['success', 'id' => $id, 'status' => $status];
     }
 
     /**

backend/controllers/SubscriptionController.php

         $subscriptionManager = $this->getSubscriptionManager();
         $productSubscriptionManager = $this->getProductSubscriptionManager();
         $productManager = $this->getProductManager();
-        $orderManager = $this->getOrderManager();
         $distributionManager = $this->getDistributionManager();
+        $orderManager = $this->getOrderManager();
 
         $model = new SubscriptionForm;
         $model->isAdmin = true;
         $productManager = $this->getProductManager();
 
         $productsQuery = Product::find()
-            ->where(['id_producer' => GlobalParam::getCurrentProducerId(),]);
+            ->where(['id_producer' => GlobalParam::getCurrentProducerId()])
+            ->andWhere('status >= :status')
+            ->addParams(['status' => Product::STATUS_OFFLINE]);
 
         if ($idSubscription) {
             $productsQuery->joinWith(['productSubscription' => function ($query) use ($idSubscription) {

backend/controllers/UserController.php

             if ($creditForm->load(\Yii::$app->request->post()) && $creditForm->validate()) {
 
                 $paymentContainer->getUtils()
-                    ->creditOrDebitUser($creditForm->type, $user, $creditForm->amount, $creditForm->mean_payment, $user);
+                    ->creditOrDebitUser($creditForm->type, $user, $creditForm->amount, $creditForm->mean_payment, $this->getUserCurrent(), $creditForm->comment);
 
                 if($creditForm->send_mail) {
                     $paymentContainer->getNotifier()
                         ->notifyUserCreditMovement($user, $creditForm->type, $creditForm->amount);
+                    if(!$user->email) {
+                        $this->addFlash('error', "L'utilisateur n'a pas pu être prévenu car son adresse email n'est pas définie.");
+                    }
                 }
 
-                $this->setFlash('success', 'Crédit mis à jour.');
+                $this->addFlash('success', 'Crédit mis à jour.');
 
                 return $this->refresh();
             }

backend/models/CreditForm.php

 
         if ($this->validate()) {
             $user = $userManager->findOneUserById($this->id_user);
-            $paymentManager->creditOrDebitUser($this->type, $user, $this->amount, $this->mean_payment, $userManager->getCurrent());
+            $paymentManager->creditOrDebitUser($this->type, $user, $this->amount, $this->mean_payment, $userManager->getCurrent(), $this->comment);
             
             // on prévient l'utilisateur que son compte vient d'être crédité
             if($this->send_mail) {

backend/models/MailForm.php

                         ->where([
                             'id_producer' => GlobalParam::getCurrentProducerId(),
                         ])
+                        ->andWhere('status >= :status')
+                        ->addParams(['status' => Product::STATUS_OFFLINE])
                         ->innerJoinWith(['productDistribution' => function($query) use($distribution) {
                             $query->andOnCondition([
                                 'product_distribution.id_distribution' => $distribution->id,

backend/views/distribution/index.php

                                     </tr>
                                 </thead>
                                 <tbody>
-                                    <tr v-for="product in products">
+                                    <tr v-for="product in products" v-if="getProductDistribution(product)">
                                         <td>
-                                            <button class="btn btn-success" v-if="product.productDistribution[0].active == 1"><span class="glyphicon glyphicon-ok"></span></button>
+                                            <button class="btn btn-success" v-if="getProductDistribution(product).active == 1"><span class="glyphicon glyphicon-ok"></span></button>
                                             <button class="btn btn-default" v-else data-active-product="1" :data-id-product="product.id" @click="productActiveClick"><span class="glyphicon glyphicon-ok"></span></button>
-                                            <button class="btn btn-danger" v-if="product.productDistribution[0].active == 0"><span class="glyphicon glyphicon-remove"></span></button>
+                                            <button class="btn btn-danger" v-if="getProductDistribution(product).active == 0"><span class="glyphicon glyphicon-remove"></span></button>
                                             <button class="btn btn-default" v-else data-active-product="0" :data-id-product="product.id" @click="productActiveClick"><span class="glyphicon glyphicon-remove"></span></button>
                                         </td>
                                         <td>{{ product.name }}</td>
                                         </td>
                                         <td class="quantity-max">
                                             <div class="input-group">
-                                                <input type="text" class="form-control quantity-max" placeholder="&infin;" :data-id-product="product.id" v-model="product.productDistribution[0].quantity_max" @keyup="productQuantityMaxChange"  />
+                                                <input type="text" class="form-control quantity-max" placeholder="&infin;" :data-id-product="product.id" v-model="getProductDistribution(product).quantity_max" @keyup="productQuantityMaxChange"  />
                                                 <span class="input-group-addon">{{ (product.unit == 'piece') ? 'p.' : ' '+((product.unit == 'g' || product.unit == 'kg') ? 'kg' : 'litre(s)') }}</span>
                                             </div>
                                         </td>
                                     <a href="javascript:void(0);" @click="orderPaymentModalClick" :data-id-order="order.id">
                                         <order-state-payment :order="order" :producer="producer"></order-state-payment>
                                     </a>
-                                    <span class="glyphicon glyphicon-time" title="Débit automatique du crédit la veille de la distribution" v-if="order.auto_payment && (order.amount_paid == 0 || order.amount_paid < order.amount)"></span>
+                                    <span class="glyphicon glyphicon-time" title="Débit automatique du crédit la veille de la distribution" v-if="order.amount != 0 && order.auto_payment && (order.amount_paid == 0 || order.amount_paid < order.amount)"></span>
                                 </td>
                                 <td class="column-credit" v-if="!idActivePointSale || (pointSaleActive && pointSaleActive.credit == 1)">
                                     <template v-if="order.isCreditContext">
                                 <td colspan="6">
                                     <strong><span class="glyphicon glyphicon-menu-right"></span> Produits</strong>
                                     <ul>
-                                        <li v-for="product in products" v-if="order.productOrder[product.id].quantity > 0">
-                                            {{ product.name }} : {{ order.productOrder[product.id].quantity }} {{ order.productOrder[product.id].unit == 'piece' ? ' pièce(s)' : ' '+order.productOrder[product.id].unit }} <span v-if="product.productDistribution[0].active == 0" class="glyphicon glyphicon-warning-sign" title="Ce produit n'est pas activé"></span>
+                                        <li v-for="product in products" v-if="getProductDistribution(product) && order.productOrder[product.id].quantity > 0">
+                                            {{ product.name }} : {{ order.productOrder[product.id].quantity }} {{ order.productOrder[product.id].unit == 'piece' ? ' pièce(s)' : ' '+order.productOrder[product.id].unit }} <span v-if="getProductDistribution(product).active == 0" class="glyphicon glyphicon-warning-sign" title="Ce produit n'est pas activé"></span>
                                         </li>
                                     </ul>
                                     <div v-if="order.comment && order.comment.length > 0" class="comment">
                         </tr>
                     </thead>
                     <tbody>
-                        <tr v-for="product in products" :class="(order.productOrder[product.id].quantity > 0) ? 'product-ordered' : ''">
+                        <tr v-for="product in products" v-if="product.status >= 0 || order.productOrder[product.id].quantity > 0" :class="(order.productOrder[product.id].quantity > 0) ? 'product-ordered' : ''">
                             <td>
                                 <span class="label label-success" v-if="loadingUpdateProductOrder || order.productOrder[product.id].active">Actif</span>
                                 <span class="label label-danger" v-else>Inactif</span>
         </div>
         <div slot="footer">
             <div class="actions-form">
+                <button class="modal-default-button btn btn-danger" @click="$emit('close')">Fermer</button>
+
                 <button class="modal-default-button btn btn-primary" @click="submitFormUpdate" v-if="order.id">Modifier</button>
                 <button class="modal-default-button btn btn-primary" @click="submitFormCreate" v-if="!order.id">Créer</button>
 
-                <button class="modal-default-button btn btn-danger" @click="$emit('close')">Fermer</button>
-
                 <div class="right">
                     <button class="modal-default-button btn btn-info btn-update-prices" @click="updateProductOrderPrices(true)">Recharger les prix</button>
                     <button v-if="order.id" class="modal-default-button btn btn-info btn-update-prices" @click="updateInvoicePrices(true)">

backend/views/document/_form.php

 
     <?php if ($action == 'update' && $documentClass == 'Invoice'): ?>
 
-        <?= $this->render('form/_payment', ['model' => $model]); ?>
+        <?= $this->render('form/_payment', ['model' => $model, 'payment' => $payment]); ?>
 
         <div v-if="(deliveryNoteUpdateArray && deliveryNoteUpdateArray.length > 0) || (deliveryNoteCreateArray && deliveryNoteCreateArray.length > 0)">
             <div class="panel panel-default">
                 <select class="form-control" v-model="productAddId"
                         @change="changeProductAdd">
                     <option value="0" selected="selected">--</option>
-                    <option v-for="product in productsArray" :value="product.id">
+                    <option v-for="product in productsArray" v-if="product.status >= 0" :value="product.id">
                         {{ product.name }}
                     </option>
                 </select>

backend/views/producer/update.php

 
                     <h4>Apparence</h4>
                     <?= $form->field($model, 'background_color_logo') ?>
-                    <?= $form->field($model, 'logo')->fileInput() ?>
+                    <?= $form->field($model, 'logoFile')->fileInput() ?>
                     <?php
                     if (strlen($model->logo)) {
                         echo '<img src="' . Yii::$app->urlManagerProducer->getHostInfo() . '/' . Yii::$app->urlManagerProducer->baseUrl . '/uploads/' . $model->logo . '" width="200px" /><br />';
                         echo '<input type="checkbox" name="delete_logo" id="delete_logo" /> <label for="delete_logo">Supprimer le logo</label><br /><br />';
                     }
                     ?>
-                    <?= $form->field($model, 'photo')->fileInput()->hint('Format idéal : 900 x 150 px') ?>
+                    <?= $form->field($model, 'photoFile')->fileInput()->hint('Format idéal : 900 x 150 px') ?>
                     <?php
                     if (strlen($model->photo)) {
                         echo '<img src="' . Yii::$app->urlManagerProducer->getHostInfo() . '/' . Yii::$app->urlManagerProducer->baseUrl . '/uploads/' . $model->photo . '" width="400px" /><br />';

backend/views/product/_form.php

 
         <div>
                 <div class="col-md-8">
-                        <?= $form->field($model, 'active')->radioList([1 => 'Oui', 0 => 'Non']) ?>
+                        <?= $form->field($model, 'status')->radioList([1 => 'Oui', 0 => 'Non']) ?>
                         <?= $form->field($model, 'name')->textInput(['maxlength' => 255]) ?>
                         <?= $form->field($model, 'reference')->textInput(['maxlength' => 255]) ?>
                         <?= $form->field($model, 'id_product_category')->dropDownList($productCategoryManager->populateProductCategoriesDropdownList()); ?>
                         ?>
                 </div>
                 <div class="col-md-4">
-                        <?= $form->field($model, 'photo')->fileInput() ?>
+                        <?= $form->field($model, 'photoFile')->fileInput() ?>
                         <?php
                         if (strlen($model->photo)) {
                                 echo '<img class="photo-product" src="' . Image::getThumbnailSmall($model->photo, true). '"  width="200px" /><br />';

backend/views/product/index.php

                 }
             ],
             [
-                'attribute' => 'active',
+                'attribute' => 'status',
+                'label' => 'Actif',
                 'headerOptions' => ['class' => 'active column-hide-on-mobile'],
                 'filterOptions' => ['class' => 'column-hide-on-mobile'],
                 'contentOptions' => ['class' => 'center column-hide-on-mobile'],
                     return Toggle::widget(
                         [
                             'name' => 'active',
-                            'checked' => $model->active,
+                            'checked' => $model->status,
                             'options' => [
                                 'data-id' => $model->id,
                                 'data-on' => 'Oui',

backend/views/user/credit.php

                         return '';
                     }
                 ],
+                [
+                    'label' => 'Commentaire',
+                    'format' => 'raw',
+                    'value' => function ($model) {
+                        return nl2br($model->comment);
+                    }
+                ],
             ],
         ]); ?>
     </div>

backend/web/css/screen.css

   /* line 148, ../sass/_responsive.scss */
   .distribution-index #orders table button.dropdown-toggle,
   .distribution-index #orders table button.btn-moins,
-  .distribution-index #orders table button.btn-plus {
-    padding: 15px;
+  .distribution-index #orders table button.btn-plus,
+  .distribution-index #orders table .btn {
+    padding: 10px;
   }
-  /* line 155, ../sass/_responsive.scss */
+  /* line 156, ../sass/_responsive.scss */
   .distribution-index #orders table .column-origin,
   .distribution-index #orders table .column-point-sale,
   .distribution-index #orders table .column-state-payment,
   .distribution-index #orders table .column-payment,
+  .distribution-index #orders table .column-credit,
   .distribution-index #orders table .column-tiller,
   .distribution-index #orders table .column-delivery-note {
     display: none;

backend/web/js/backend.js

     $('body.product-index .toggle input').change(function() {
         var id = $(this).data('id');
         var checked = $(this).prop('checked');
-
-        var active = 0;
-        if(checked) {
-            active = 1;
-        }
-
-        $.get(UrlManager.getBaseUrl() + 'product/ajax-toggle-active', {
+        $.get(UrlManager.getBaseUrl() + 'product/ajax-toggle-status', {
             id: id,
-            active: active
+            status: checked ? 1 : 0
         });
-
     })
 }
 

backend/web/js/vuejs/distribution-index.js

         initCountActiveProducts: function () {
             this.countActiveProducts = 0;
             for (var i = 0; i < this.products.length; i++) {
-                if (this.products[i].productDistribution[0].active == 1) {
+                if (this.products[i].productDistribution && this.products[i].productDistribution[0].active == 1) {
                     this.countActiveProducts++;
                 }
             }
                 });
 
             for (i = 0; i < this.products.length; i++) {
-                if (this.products[i].id == idProduct) {
+                if (this.products[i].productDistribution && this.products[i].id == idProduct) {
                     this.products[i].productDistribution[0].active = activeProduct;
                 }
             }
             return false;
         },
         isProductMaximumQuantityExceeded: function (product) {
-            return product.productDistribution[0].quantity_max
+            return
+                this.getProductDistribution(product)
+                && this.getProductDistribution(product).quantity_max
                 && product.quantity_ordered
-                && product.quantity_ordered > product.productDistribution[0].quantity_max;
+                && product.quantity_ordered > this.getProductDistribution(product).quantity_max;
         },
         pointSaleActiveClick: function (event) {
             var idPointSale = event.currentTarget.getAttribute('data-id-point-sale');
         },
         getUnitCoefficient: function(unit) {
             return this.units[unit].coefficient;
+        },
+        getProductDistribution: function(product) {
+            if(typeof product.productDistribution !== 'undefined' && product.productDistribution[0]) {
+                return product.productDistribution[0];
+            }
+
+            return null;
         }
     },
 });
                 productQuantityOrder += this.getProductQuantityProductOrder(this.order, product);
             }
 
-            quantityRemaining = product.productDistribution[0].quantity_max - productQuantityOrder;
+            quantityRemaining = this.getProductDistribution(product).quantity_max - productQuantityOrder;
             if(unit != 'piece') {
                 quantityRemaining = quantityRemaining.toFixed(2);
             }
         },
         getUnitCoefficient: function(unit) {
             return this.units[unit].coefficient;
+        },
+        getProductDistribution: function(product) {
+            if(typeof product.productDistribution !== 'undefined' && product.productDistribution[0]) {
+                return product.productDistribution[0];
+            }
         }
     }
 });

backend/web/sass/_responsive.scss

 
         button.dropdown-toggle,
         button.btn-moins,
-        button.btn-plus {
-          padding: 15px;
+        button.btn-plus,
+        .btn {
+          padding: 10px;
         }
 
         //.column-checkbox,
           //.column-amount,
         .column-state-payment,
         .column-payment,
+        .column-credit,
         .column-tiller,
           //.column-actions,
         .column-delivery-note {

common/config/params.php

  */
 
 return [
-        'version' => '23.9.E',
+        'version' => '23.10.A',
         'siteName' => 'Opendistrib',
         'adminEmail' => 'contact@opendistrib.net',
         'supportEmail' => 'contact@opendistrib.net',

common/forms/SubscriptionForm.php

 use common\logic\Product\Product\Model\Product;
 use common\logic\Subscription\ProductSubscription\Model\ProductSubscription;
 use common\logic\Subscription\Subscription\Model\Subscription;
+use common\logic\Subscription\Subscription\Wrapper\SubscriptionManager;
 use Yii;
 use yii\base\Model;
 
      */
     public function save() 
     {
+        $subscriptionManager = SubscriptionManager::getInstance();
+
         if ($this->id) {
             $subscription =  Subscription::searchOne(['id' => $this->id]) ;
         } 
         else {
-            $subscription = new Subscription ;
+            $subscription = $subscriptionManager->instanciateSubscription() ;
         }
 
         if ($subscription) {
             $subscription->saturday = $this->saturday;
             $subscription->sunday = $this->sunday;
             $subscription->week_frequency = $this->week_frequency;
-            $subscription->auto_payment = Subscription::AUTO_PAYMENT_DEDUCTED;
+            $subscription->auto_payment = $this->auto_payment;
+            if(is_null($subscription->auto_payment)) {
+                $subscription->auto_payment = Subscription::AUTO_PAYMENT_DEDUCTED;
+            }
             $subscription->comment = $this->comment;
 
             $subscription->save();

common/helpers/Opendistrib.php

             }
         }
 
-        rsort($versionsArray);
+        rsort($versionsArray,  SORT_NATURAL);
 
         return $versionsArray;
     }

common/helpers/Upload.php

 
 class Upload
 {
-    public static function uploadFile($model, $champs, $filename_old = '')
+    public static function uploadFile($model, $champsFile, $champs, $filename_old = '')
     {
-        $file = UploadedFile::getInstance($model, $champs);
+        $file = $model->$champsFile;
         if ($file) {
             $file_name = $file->baseName . '-' . uniqid();
             $file_name_extension = $file_name . '.' . $file->extension;
             $model->$champs = $filename_old;
         }
 
+        $model->$champsFile = null;
+
         $model->save();
     }
 }

common/logic/AbstractBuilder.php

     {
         return $model->save();
     }
-}
+
+    /**
+     * Status
+     */
+
+    public function updateStatusOnline(Model $model)
+    {
+        $model->status = StatusInterface::STATUS_ONLINE;
+        $this->update($model);
+    }
+
+    public function updateStatusOffline(Model $model)
+    {
+        $model->status = StatusInterface::STATUS_OFFLINE;
+        $this->update($model);
+    }
+
+    public function updateStatusDeleted(Model $model)
+    {
+        $model->status = StatusInterface::STATUS_DELETED;
+        $this->update($model);
+    }
+}

common/logic/AbstractRepository.php

         return $this->query;
     }
 
-    public function createDefaultQuery(): RepositoryQueryInterface
+    public function createDefaultQuery(bool $filterStatus = true): RepositoryQueryInterface
     {
         $this->createQuery();
-
+        if($filterStatus) {
+            $this->defaultStatus();
+        }
         $this->defaultWith();
         $this->defaultJoinWith();
         $this->defaultFilterProducerContext();
         return $this->query;
     }
 
+    public function defaultStatus(): void
+    {
+        $class = new \ReflectionClass($this->query->getDefinition()->getEntityFqcn());
+        if($class->implementsInterface('common\logic\StatusInterface')) {
+            $this->query->filterIsStatusOnlineAndOffline();
+        }
+    }
+
     public function defaultWith(): void
     {
         $defaultOptions = $this->getDefaultOptionsSearch();

common/logic/AbstractRepositoryQuery.php

         $this->definition = $this->loadService($serviceClass);
     }
 
+    public function getDefinition()
+    {
+        return $this->definition;
+    }
+
     public function baseQuery(): ActiveQuery
     {
         $class = $this->definition->getEntityFqcn();
         return $this;
     }
 
+    public function filterIsStatusOnline()
+    {
+        $this->andWhere(['status' => StatusInterface::STATUS_ONLINE]);
+        return $this;
+    }
+
+    public function filterIsStatusOnlineAndOffline()
+    {
+        $this->andWhere('status >= :status')->addParams(['status' => StatusInterface::STATUS_OFFLINE]);
+        return $this;
+    }
+
+    public function filterIsStatusDeleted()
+    {
+        $this->andWhere(['status' => StatusInterface::STATUS_DELETED]);
+        return $this;
+    }
+
     public function getDataProvider(int $pageSize): ActiveDataProvider
     {
         return new ActiveDataProvider([

common/logic/Distribution/Distribution/Service/DistributionBuilder.php

 use common\logic\PointSale\PointSale\Model\PointSale;
 use common\logic\Product\Product\Model\Product;
 use common\logic\Product\Product\Repository\ProductRepository;
+use common\logic\Product\Product\Service\ProductSolver;
 use common\logic\User\UserProducer\Repository\UserProducerRepository;
 
 class DistributionBuilder extends AbstractBuilder
     protected OrderRepository $orderRepository;
     protected UserProducerRepository $userProducerRepository;
     protected ProductOrderBuilder $productOrderBuilder;
+    protected ProductSolver $productSolver;
 
     public function loadDependencies(): void
     {
         $this->orderRepository = $this->loadService(OrderRepository::class);
         $this->userProducerRepository = $this->loadService(UserProducerRepository::class);
         $this->productOrderBuilder = $this->loadService(ProductOrderBuilder::class);
+        $this->productSolver = $this->loadService(ProductSolver::class);
     }
 
     public function instanciateDistribution(string $date, bool $delivery = true): Distribution
         return $distribution;
     }
 
-    // initDistribution
     public function createDistribution(string $date, bool $delivery = true): Distribution
     {
         $distribution = $this->instanciateDistribution($date, $delivery);
-
-        $this->saveCreate($distribution);
-
+        $this->create($distribution);
         $this->createPointSaleDistributions($distribution);
         $this->createProductDistributions($distribution);
 
     /**
      * Ajoute un produit à une distribution.
      */
-    public function addProduct(Distribution $distribution, Product $product): ProductDistribution
+    public function addProduct(Distribution $distribution, Product $product): ?ProductDistribution
     {
-        $productDistribution = $this->productDistributionBuilder->createProductDistributionIfNotExist($distribution, $product);
-        $this->productDistributionBuilder->updateProductDistribution($productDistribution);
-        $this->updateOrderProductPrices($distribution, $product);
+        if($this->productSolver->isStatusOnlineOrOffline($product)) {
+            $productDistribution = $this->productDistributionBuilder->createProductDistributionIfNotExist($distribution, $product);
+            $this->productDistributionBuilder->updateProductDistribution($productDistribution);
+            $this->updateOrderProductPrices($distribution, $product);
+            return $productDistribution;
+        }
 
-        return $productDistribution;
+        return null;
     }
 
     /**

common/logic/Distribution/ProductDistribution/Service/ProductDistributionBuilder.php

 
 use common\logic\AbstractBuilder;
 use common\logic\Distribution\Distribution\Model\Distribution;
+use common\logic\Distribution\Distribution\Repository\DistributionRepository;
 use common\logic\Distribution\Distribution\Service\DistributionSolver;
 use common\logic\Distribution\ProductDistribution\Model\ProductDistribution;
 use common\logic\Distribution\ProductDistribution\Repository\ProductDistributionRepository;
     protected ProductDistributionRepository $productDistributionRepository;
     protected DistributionSolver $distributionSolver;
     protected ProductSolver $productSolver;
+    protected DistributionRepository $distributionRepository;
 
     public function loadDependencies(): void
     {
         $this->productDistributionRepository = $this->loadService(ProductDistributionRepository::class);
         $this->distributionSolver = $this->loadService(DistributionSolver::class);
         $this->productSolver = $this->loadService(ProductSolver::class);
+        $this->distributionRepository = $this->loadService(DistributionRepository::class);
     }
 
     public function instanciateProductDistribution(Distribution $distribution, Product $product): ProductDistribution
         $productDistribution->active = $active;
         $this->update($productDistribution);
     }
+
+    public function disableProductDistributionsIncomingByProduct(Product $product)
+    {
+        $distributionsIncomingArray = $this->distributionRepository->findDistributionsIncoming(true);
+        foreach($distributionsIncomingArray as $distribution) {
+            ProductDistribution::updateAll([
+                'id_product' => $product->id,
+                'id_distribution' => $distribution->id,
+                'active' => false
+            ]);
+        }
+    }
 }

common/logic/Document/Invoice/Service/InvoiceSolver.php

 use common\helpers\Price;
 use common\logic\Document\Document\Service\DocumentSolver;
 use common\logic\Document\Invoice\Model\Invoice;
+use common\logic\Order\Order\Model\Order;
 
 class InvoiceSolver extends DocumentSolver
 {
 
     public function isInvoicePaid(Invoice $invoice): bool
     {
-        return $this->getInvoiceAmountPaid($invoice) >= Price::numberTwoDecimals($this->getAmountWithTax($invoice));
+        return $this->getInvoiceAmountPaid($invoice) >= Price::numberTwoDecimals($this->getAmountWithTax($invoice, Order::INVOICE_AMOUNT_TOTAL));
     }
 }

common/logic/Order/Order/Repository/OrderRepository.php

         $titleLabel = '';
 
         if(!$amountPaid) {
-            if($isOrderPaid) {
+            if($isOrderPaid && $amountTotal != 0) {
                 $label = 'Facture payée';
             }
-            elseif($this->isCreditAutoPayment($order)) {
+            elseif($this->isCreditAutoPayment($order) && $amountTotal != 0) {
                 if($order->subscription && $order->subscription->auto_payment == 0) {
                     $label = 'Crédit désactivé';
                 }
                     $label = 'Crédit non débité';
                 }
             }
+            elseif($amountTotal == 0) {
+                $label = 'Gratuit';
+            }
             else {
                 $label = 'Non réglé';
             }
             $classLabel = 'warning';
             $titleLabel = 'Paiement en surplus';
         }
-        elseif($isOrderPaid) {
+        elseif(($isOrderPaid && $amountTotal != 0) || $amountTotal == 0) {
             $classLabel = 'success';
         }
         elseif($orderPaymentStatus == Order::PAYMENT_UNPAID) {

common/logic/Order/Order/Service/OrderBuilder.php

                 $order->user,
                 $this->userSolver->getCurrent(),
                 MeanPayment::CREDIT,
+                null,
                 $order
             );
         }

common/logic/Payment/Model/Payment.php

             [['amount'], 'double'],
             [['date_transaction'], 'date', 'format' => 'php:Y-m-d'],
             [['type', 'mean_payment'], 'string', 'max' => 255],
-            [['comment'], 'string', 'max' => 2048],
+            [['comment', 'summary'], 'string', 'max' => 2048],
         ];
     }
 
             'id_producer' => 'Producteur',
             'mean_payment' => 'Moyen de paiement',
             'comment' => 'Commentaire',
+            'summary' => 'Résumé',
             'date_transaction' => 'Date transaction'
         ];
     }
 
         return $this;
     }
+
+    public function getSummary(): ?string
+    {
+        return $this->summary;
+    }
+
+    public function setSummary(?string $summary): self
+    {
+        $this->summary = $summary;
+
+        return $this;
+    }
 }

common/logic/Payment/Service/PaymentBuilder.php

         User $user = null,
         User $userAction = null,
         string $meanPayment = null,
+        string $comment = null,
         Order $order = null,
         Invoice $invoice = null
     ): Payment
         $payment->type = $type;
         $payment->amount = round($amount, 2);
         $payment->populateProducer($producer);
+        $payment->setMeanPayment($meanPayment);
+        $payment->setComment($comment);
 
         if($user) {
             $payment->populateUser($user);
             $payment->populateInvoice($invoice);
         }
 
-        if($meanPayment) {
-            $payment->mean_payment = $meanPayment;
-        }
-
         return $payment;
     }
 
         User $user = null,
         User $userAction = null,
         string $meanPayment = null,
+        string $comment = null,
         Order $order = null,
         Invoice $invoice = null
     ): ?Payment
             return null;
         }
 
-        $payment = $this->instanciatePayment($type, $amount, $producer, $user, $userAction, $meanPayment, $order, $invoice);
-        $payment->setComment($payment->getComment() . $this->orderSolver->getPaymentComment($payment));
+        $payment = $this->instanciatePayment($type, $amount, $producer, $user, $userAction, $meanPayment, $comment, $order, $invoice);
+        $payment->setSummary($this->orderSolver->getPaymentComment($payment));
         $this->create($payment);
 
         return $payment;

common/logic/Payment/Service/PaymentNotifier.php

 
     public function notifyUserCreditMovement(User $user, string $type, float $amount)
     {
-        $producer = $this->getProducerContext();
-        $credit = $this->userRepository->getCredit($user, true);
-
-        $this->mailer->sendFromProducer(
-            'Mouvement de crédit',
-            'creditUser',
-            [
-                'user' => $user,
-                'producer' => $producer,
-                'credit' => $credit,
-                'type' => $type,
-                'amount' => $amount
-            ],
-            $user->email,
-            $producer
-        );
+        if($user->email) {
+            $producer = $this->getProducerContext();
+            $credit = $this->userRepository->getCredit($user, true);
+
+            $this->mailer->sendFromProducer(
+                'Mouvement de crédit',
+                'creditUser',
+                [
+                    'user' => $user,
+                    'producer' => $producer,
+                    'credit' => $credit,
+                    'type' => $type,
+                    'amount' => $amount
+                ],
+                $user->email,
+                $producer
+            );
+
+            return true;
+        }
+
+        return false;
     }
 }

common/logic/Payment/Service/PaymentUtils.php

         $this->producerSolver = $this->loadService(ProducerSolver::class);
     }
 
-    public function creditUser(User $user, float $amount, string $meanPayment, User $userAction): void
+    public function creditUser(User $user, float $amount, string $meanPayment, User $userAction, string $comment = null): void
     {
         $this->paymentBuilder->createPayment(
             Payment::TYPE_CREDIT,
             $this->getProducerContext(),
             $user,
             $userAction,
-            $meanPayment
+            $meanPayment,
+            $comment
         );
     }
 
-    public function debitUser(User $user, float $amount, string $meanPayment, User $userAction): void
+    public function debitUser(User $user, float $amount, string $meanPayment, User $userAction, string $comment = null): void
     {
         $this->paymentBuilder->createPayment(
             Payment::TYPE_DEBIT,
             $this->getProducerContext(),
             $user,
             $userAction,
-            $meanPayment
+            $meanPayment,
+            $comment
         );
     }
 
-    public function creditOrDebitUser(string $type, User $user, float $amount, string $meanPayment, User $userAction): void
+    public function creditOrDebitUser(string $type, User $user, float $amount, string $meanPayment, User $userAction, string $comment): void
     {
         if($type == Payment::TYPE_CREDIT) {
-            $this->creditUser($user, $amount, $meanPayment, $userAction);
+            $this->creditUser($user, $amount, $meanPayment, $userAction, $comment);
         }
         elseif($type == Payment::TYPE_DEBIT) {
-            $this->debitUser($user, $amount, $meanPayment, $userAction);
+            $this->debitUser($user, $amount, $meanPayment, $userAction, $comment);
         }
         else {
             throw new ErrorException('$type a une valeur incorrect');
                 $order->user,
                 $userAction,
                 $meanPayment,
+                null,
                 $order
             );
         }
                 $order->user,
                 $userAction,
                 MeanPayment::CREDIT,
+                null,
                 $order
             );
         }
                 $order->user,
                 $userAction,
                 $meanPayment,
+                null,
                 $order
             );
         }
                 $order->user,
                 $userAction,
                 MeanPayment::CREDIT,
+                null,
                 $order
             );
         }
                 $order->user,
                 $userAction,
                 MeanPayment::CREDIT,
+                null,
                 $order
             );
         }

common/logic/PointSale/PointSale/Repository/PointSaleRepositoryQuery.php

 use common\logic\AbstractRepositoryQuery;
 use common\logic\PointSale\PointSale\Model\PointSale;
 use common\logic\PointSale\PointSale\Service\PointSaleDefinition;
+use common\logic\StatusInterface;
 use yii\db\ActiveQuery;
 
 class PointSaleRepositoryQuery extends AbstractRepositoryQuery
 
     public function filterIsOnline(): self
     {
-        $this->andWhere(['status' => 1]);
+        $this->andWhere(['status' => StatusInterface::STATUS_ONLINE]);
 
         return $this;
     }

common/logic/Producer/Producer/Model/Producer.php

 use common\logic\User\User\Model\User;
 use common\logic\User\UserProducer\Model\UserProducer;
 use common\components\ActiveRecordCommon;
+use yii\web\UploadedFile;
 
 /**
  * This is the model class for table "producer".
         self::BILLING_TYPE_FREE_PRICE => 'Prix libre',
     ];
 
-    var $secret_key_payplug;
-
     const ONLINE_PAYMENT_MINIMUM_AMOUNT_DEFAULT = 25;
 
     const ORDER_DEADLINE_DEFAULT = 20;
     const ORDER_DELAY_DEFAULT = 1;
 
+    var $secret_key_payplug;
+
+    /**
+     * @var UploadedFile
+     */
+    public $logoFile;
+    /**
+     * @var UploadedFile
+     */
+    public $photoFile;
+
     /**
      * @inheritdoc
      */
                     return $model->tiller == true;
                 }
             ],
+            [['logoFile', 'photoFile'], 'file', 'extensions' => 'png, jpg, jpeg', 'mimeTypes' => 'image/png, image/jpeg'],
             [
                 [
                     'order_delay',

common/logic/Producer/Producer/Service/ProducerBuilder.php

 
 use common\helpers\Opendistrib;
 use common\helpers\Password;
+use common\helpers\Upload;
 use common\logic\AbstractBuilder;
 use common\logic\Producer\Producer\Model\Producer;
 use common\logic\Producer\Producer\Repository\ProducerRepository;
             $producer->option_stripe_endpoint_secret
         );
     }
+
+    public function savePrivateKeysStripe(Producer $producer)
+    {
+        $this->savePrivateKeyApiStripe($producer);
+        $this->savePrivateKeyEndpointStripe($producer);
+
+        $producer->option_stripe_private_key = '';
+        $producer->option_stripe_endpoint_secret = '';
+
+        $producer->save();
+    }
+
+    public function initOptionDashboardDatesBeforeSave(Producer $producer): void
+    {
+        $this->initOptionDashboardDateStartEndBeforeSave($producer, true);
+        $this->initOptionDashboardDateStartEndBeforeSave($producer, false);
+    }
+
+    private function initOptionDashboardDateStartEndBeforeSave(Producer $producer, bool $dateStart): void
+    {
+        $field = 'option_dashboard_date_'.($dateStart ? 'start' : 'end');
+        if ($producer->$field && strlen($producer->$field)) {
+            $producer->$field = date(
+                'Y-m-d',
+                strtotime(str_replace('/', '-', $producer->$field))
+            );
+        }
+    }
+
+    public function initOptionDashboardDatesDisplay(Producer $producer, bool $dateStart = true): void
+    {
+        $this->initOptionDashboardDateStartEndDisplay($producer, true);
+        $this->initOptionDashboardDateStartEndDisplay($producer, false);
+    }
+
+    private function initOptionDashboardDateStartEndDisplay(Producer $producer, bool $dateStart): void
+    {
+        $field = 'option_dashboard_date_'.($dateStart ? 'start' : 'end');
+        if (strlen($producer->$field)) {
+            $producer->$field = date('d/m/Y', strtotime($producer->$field));
+        }
+    }
+
+    public function processUploadImage(Producer $producer, string $name, string $filenameOld, bool $deleteImage)
+    {
+        Upload::uploadFile($producer, $name.'File', $name, $filenameOld);
+        if ($deleteImage) {
+            $producer->$name = '';
+            $producer->save();
+        }
+    }
 }

common/logic/Product/Product/Model/Product.php

 use common\logic\Product\ProductPointSale\Model\ProductPointSale;
 use common\logic\Product\ProductPrice\Model\ProductPrice;
 use common\components\ActiveRecordCommon;
+use common\logic\StatusInterface;
 use common\logic\Subscription\ProductSubscription\Model\ProductSubscription;
+use yii\web\UploadedFile;
 
 /**
  * This is the model class for table "product".
  *
  */
-class Product extends ActiveRecordCommon
+class Product extends ActiveRecordCommon implements StatusInterface
 {
     public $total = 0;
     public $apply_distributions = true;
-
     public $price_with_tax = 0;
     public $wording_unit = '';
-
     public $pointsSale;
 
+    /**
+     * @var UploadedFile
+     */
+    public $photoFile;
+
     public static $unitsArray = [
         'piece' => [
             'unit' => 'piece',
     {
         return [
             [['name', 'id_producer'], 'required'],
-            [['active', 'order', 'id_producer', 'id_tax_rate', 'id_product_category'], 'integer'],
+            [['order', 'id_producer', 'id_tax_rate', 'id_product_category', 'status'], 'integer'],
             [['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday', 'unavailable', 'apply_distributions', 'available_on_points_sale'], 'boolean'],
             [['price', 'weight', 'step', 'quantity_max', 'quantity_max_monday', 'quantity_max_tuesday', 'quantity_max_wednesday', 'quantity_max_thursday', 'quantity_max_friday', 'quantity_max_saturday', 'quantity_max_sunday'], 'number'],
-            [['photo'], 'file'],
+            [['photoFile'], 'file', 'extensions' => 'png, jpg, jpeg', 'mimeTypes' => 'image/png, image/jpeg'],
             [['name', 'reference', 'description', 'photo', 'unit'], 'string', 'max' => 255],
             [['recipe'], 'string', 'max' => 1000],
             ['step', 'required', 'message' => 'Champs obligatoire', 'when' => function ($model) {
             'name' => 'Nom',
             'reference' => 'Référence',
             'description' => 'Description',
-            'active' => 'Actif',
-            'photo' => 'Photo',
+            'photoFile' => 'Photo',
             'price' => 'Prix (€) TTC',
             'weight' => 'Poids',
             'recipe' => 'Recette',
             'step' => 'Pas',
             'id_tax_rate' => 'TVA',
             'id_product_category' => 'Catégorie',
-            'available_on_points_sale' => 'Par défaut'
+            'available_on_points_sale' => 'Par défaut',
+            'status' => 'Actif',
         ];
     }
 

common/logic/Product/Product/Model/ProductSearch.php

     public function rules() 
     {
         return [
-            [['active', 'order', 'quantity_max', 'id_producer'], 'integer'],
+            [['order', 'quantity_max', 'id_producer', 'status'], 'integer'],
             [['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday', 'unavailable'], 'boolean'],
             [['price', 'weight'], 'number'],
             [[ 'photo'], 'file'],
             ->with($optionsSearch['with'])
             ->innerJoinWith($optionsSearch['join_with'], true)
             ->where(['product.id_producer' => GlobalParam::getCurrentProducerId()])
-            ->orderBy('product.order ASC')
-            ;
+            ->andWhere('status >= :status')->addParams(['status' => Product::STATUS_OFFLINE])
+            ->orderBy('product.order ASC');
         
         $dataProvider = new ActiveDataProvider([
             'query' => $query,
-            'sort' => ['attributes' => ['order', 'photo', 'name', 'description','active']],
+            'sort' => ['attributes' => ['order', 'photo', 'name', 'description','status']],
             'pagination' => [
                 'pageSize' => 1000,
             ],
         $query->andFilterWhere(['like', 'product.name', $this->name]) ;
         $query->andFilterWhere(['like', 'product.description', $this->description]) ;
         
-        if(isset($this->active) && is_numeric($this->active)) {
+        if(isset($this->status) && is_numeric($this->status)) {
             $query->andWhere([
-                'product.active' => $this->active
+                'product.status' => $this->status
             ]) ;    
         }
         

common/logic/Product/Product/Repository/ProductRepository.php

             ->findOne();
     }
 
-    public function findProducts(): array
+    public function findProducts(bool $filterStatus = true): array
     {
-        return $this->createDefaultQuery()->find();
+        return $this->createDefaultQuery($filterStatus)->find();
     }
 
     /**
         return $this->createDefaultQuery()->count();
     }
 
-    public function queryProductsByDistribution(Distribution $distribution)
+    public function queryProductsByDistribution(Distribution $distribution, bool $filterStatus = true)
     {
-        return $this->createDefaultQuery()
+        return $this->createDefaultQuery($filterStatus)
             ->joinWith([
                 'productDistribution' => function ($query) use ($distribution) {
                     $query->andOnCondition(
     /**
      * Retourne les produits d'une production donnée.
      */
-    public function findProductsByDistribution(Distribution $distribution)
+    public function findProductsByDistribution(Distribution $distribution, bool $filterStatus = true)
     {
-        $productArray = $this->queryProductsByDistribution($distribution)->find();
+        $productArray = $this->queryProductsByDistribution($distribution, $filterStatus)->find();
         return $this->buildProductsArrayById($productArray);
     }
 
     public function queryProductsByProductCategory(ProductCategory $productCategory)
     {
         return $this->createDefaultQuery()
-            ->filterIsActive()
+            ->filterIsStatusOnline()
             ->filterByProductCategory($productCategory);
     }
 
     public function countProductsWithoutCategory(Producer $producer): int
     {
         return $this->createDefaultQuery()
-            ->filterIsActive()
+            ->filterIsStatusOnline()
             ->filterByProductCategory(null)
             ->count();
     }

common/logic/Product/Product/Repository/ProductRepositoryQuery.php

 use common\logic\Distribution\Distribution\Model\Distribution;
 use common\logic\Product\Product\Service\ProductDefinition;
 use common\logic\Product\ProductCategory\Model\ProductCategory;
+use common\logic\StatusInterface;
 
 class ProductRepositoryQuery extends AbstractRepositoryQuery
 {
         return $this;
     }
 
-    public function filterIsActive(): self
-    {
-        $this->andWhere(['product.active' => true]);
-        return $this;
-    }
-
     public function filterByProductCategory(ProductCategory $productCategory = null) : self
     {
         if($productCategory) {

common/logic/Product/Product/Service/ProductBuilder.php

     public function createProduct(): Product
     {
         $product = $this->instanciateProduct();
-        $this->saveCreate($product);
+        $this->create($product);
 
         return $product;
     }

common/logic/Product/Product/Service/ProductSolver.php

 
     public function isProductActiveByDay(Product $product, string $day): bool
     {
-        return $product->active && $product->$day;
+        return $product->status && $product->$day;
     }
 
     public function getProductFieldNameQuantityMax(string $day): string
         $potentialRevenues = 0;
 
         foreach($productsArray as $product) {
-            if ($product['productDistribution'][0]['active'] && $product['productDistribution'][0]['quantity_max']) {
+            if (isset($product['productDistribution'][0]) && $product['productDistribution'][0]['active'] && $product['productDistribution'][0]['quantity_max']) {
                 $potentialRevenues += $product['productDistribution'][0]['quantity_max'] * $product['price'];
             }
         }
         $potentialWeight = 0;
 
         foreach($productsArray as $product) {
-            if ($product['productDistribution'][0]['active'] && $product['productDistribution'][0]['quantity_max']) {
+            if (isset($product['productDistribution'][0]) && $product['productDistribution'][0]['active'] && $product['productDistribution'][0]['quantity_max']) {
                 $potentialWeight += $product['productDistribution'][0]['quantity_max'] * $product['weight'] / 1000;
             }
         }
 
         return $potentialWeight;
     }
+
+    public function isStatusOnlineOrOffline(Product $product): bool
+    {
+        return $product->status >= Product::STATUS_OFFLINE;
+    }
 }

common/logic/StatusInterface.php

+<?php
+
+namespace common\logic;
+
+interface StatusInterface
+{
+    const STATUS_DELETED = -1;
+    const STATUS_OFFLINE = 0;
+    const STATUS_ONLINE = 1;
+}

common/logic/Subscription/Subscription/Service/SubscriptionBuilder.php

     public function instanciateSubscription(): Subscription
     {
         $subscription = new Subscription();
+        $subscription->auto_payment = Subscription::AUTO_PAYMENT_DEDUCTED;
 
         return $subscription;
     }

common/versions/23.10.A.php

+<?php
+
+require_once dirname(__FILE__).'/_macros.php';
+
+version(
+    '03/10/2023',
+    [
+        [
+
+        ],
+        [
+            "[Administration] Distributions > commandes : accès boutons d'action en version mobile",
+            "[Administration] Utilisateurs > historique crédit : remise en place colonne commentaire",
+            "[Administration] Distributions > liste commandes : libellé 'Gratuit' si montant à 0€",
+            "[Administration] Abonnements : correctif champs débit automatique non mis à jour lors de la modification",
+        ]
+    ],
+    [
+        [],
+        [
+            "[Administration] Produits : gestion statut 'supprimé'",
+            "[Administration] Correctif problème upload images webp"
+        ]
+    ],
+);
+
+?>

console/migrations/m230929_065700_rename_column_product_active_status.php

+<?php
+
+use yii\db\Migration;
+use yii\db\Schema;
+
+/**
+ * Class m230929_065700_rename_column_product_active_status
+ */
+class m230929_065700_rename_column_product_active_status extends Migration
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function safeUp()
+    {
+        $this->renameColumn('product', 'active', 'status');
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function safeDown()
+    {
+        $this->renameColumn('product', 'status', 'active');
+    }
+}

console/migrations/m231002_142915_add_column_payment_summary.php

+<?php
+
+use yii\db\Migration;
+use yii\db\Schema;
+
+/**
+ * Class m231002_142915_add_column_payment_summary
+ */
+class m231002_142915_add_column_payment_summary extends Migration
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function safeUp()
+    {
+        $this->addColumn('payment', 'summary', Schema::TYPE_TEXT);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function safeDown()
+    {
+        $this->dropColumn('payment', 'summary');
+    }
+}

producer/controllers/OrderController.php

         $productsArray = Product::find()
             ->where([
                 'id_producer' => $producer->id,
-                'product.active' => 1,
+                'product.status' => 1,
             ]);
 
         $productsArray = $productsArray->joinWith([

producer/controllers/SiteController.php

         $queryProducts = Product::find()
             ->andWhere([
                 'id_producer' => $this->getProducerCurrent()->id,
-                'active' => true,
+                'status' => Product::STATUS_ONLINE,
                 'id_product_category' => null,
             ])
             ->with('productPointSale')

producer/web/js/vuejs/subscription-form.js

             }
         },
         checkProductAvailable: function (product) {
-            var available = product.active &&
+            var available = product.status &&
                 (!this.monday || (this.monday && product.monday)) &&
                 (!this.tuesday || (this.tuesday && product.tuesday)) &&
                 (!this.wednesday || (this.wednesday && product.wednesday)) &&