[Administration] Gestion suppression produits avec status

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 ($document) {
                 $ordersArray = [];
-                $productsArray = $productManager->findProducts();
+                $productsArray = $productManager->findProducts(false);
 
                 foreach ($document->orders as $order) {
                     $orderManager->initOrder($order);

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;
      */
     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

         $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/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>
                                 <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>

backend/views/document/_form.php

                 <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/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()); ?>

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/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];
+            }
         }
     }
 });

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/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/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;
     {
         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'],
             [['photoFile'], 'file', 'extensions' => 'png, jpg, jpeg', 'mimeTypes' => 'image/png, image/jpeg'],
             'name' => 'Nom',
             'reference' => 'Référence',
             'description' => 'Description',
-            'active' => 'Actif',
             'photoFile' => 'Photo',
             'price' => 'Prix (€) TTC',
             'weight' => 'Poids',
             '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;
+}

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');
+    }
+}

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)) &&