Refactoring services #885

backend/controllers/BackendController.php

 
 namespace backend\controllers;
 
-class BackendController extends \common\controllers\CommonController 
+use common\logic\PointSale\PointSale\PointSale;
+use common\logic\Product\Product\Product;
+use common\controllers\CommonController;
+
+class BackendController extends CommonController
 {
     /**
      * Vérifie si l'utilisateur a au moins saisi un produit et un point de vente.
      */
     public function checkProductsPointsSale()
     {
-        if (!ProductModel::searchCount() || !PointSaleModel::searchCount()) {
+        if (!Product::searchCount() || !PointSale::searchCount()) {
             $this->redirect(['site/index', 'error_products_points_sale' => 1]);
         }
     }

backend/controllers/TaxRateAdminController.php

 
 namespace backend\controllers;
 
+use common\logic\Config\TaxRate\TaxRate;
 use Yii;
 use yii\web\NotFoundHttpException;
 use yii\filters\VerbFilter;
  */
 class TaxRateAdminController extends BackendController
 {
-
-        public function behaviors()
-        {
-                return [
-                        'verbs' => [
-                                'class' => VerbFilter::className(),
-                                'actions' => [
-                                        'delete' => ['post'],
-                                ],
-                        ],
-                        'access' => [
-                                'class' => AccessControl::className(),
-                                'rules' => [
-                                        [
-                                                'allow' => true,
-                                                'roles' => ['@'],
-                                                'matchCallback' => function ($rule, $action) {
-                                                        return UserModel::getCurrentStatus() == UserModel::STATUS_ADMIN;
-                                                }
-                                        ]
-                                ],
-                        ],
-                ];
-        }
-
-        /**
-         * Liste les taxes.
-         *
-         * @return mixed
-         */
-        public function actionIndex()
-        {
-                $dataProviderTaxRate = new ActiveDataProvider([
-                        'query' => TaxRateModel::find()
-                ]);
-
-                return $this->render('index', [
-                        'dataProviderTaxRate' => $dataProviderTaxRate,
-                ]);
-        }
-
-        /**
-         * Crée une taxe.
-         *
-         * @return mixed
-         */
-        public function actionCreate()
-        {
-                $model = new TaxRate();
-
-                if ($model->load(Yii::$app->request->post()) && $model->save()) {
-                        Yii::$app->getSession()->setFlash('success', 'Taxe créé.');
-                        return $this->redirect(['index']);
-                } else {
-                        return $this->render('create', [
-                                'model' => $model,
-                        ]);
-                }
-        }
-
-        /**
-         * Édition d'une taxe.
-         *
-         * @return mixed
-         */
-        public function actionUpdate($id)
-        {
-
-
-                $model = $this->findModel($id);
-
-                if ($model->load(Yii::$app->request->post()) && $model->save()) {
-                        Yii::$app->getSession()->setFlash('success', 'Taxe édité.');
-                        return $this->redirect(['index']);
-                } else {
-                        return $this->render('update', [
-                                'model' => $model,
-                        ]);
-                }
+    public function behaviors()
+    {
+        return [
+            'verbs' => [
+                'class' => VerbFilter::class,
+                'actions' => [
+                    'delete' => ['post'],
+                ],
+            ],
+            'access' => [
+                'class' => AccessControl::class,
+                'rules' => [
+                    [
+                        'allow' => true,
+                        'roles' => ['@'],
+                        'matchCallback' => function ($rule, $action) {
+                            return $this->isUserCurrentAdmin();
+                        }
+                    ]
+                ],
+            ],
+        ];
+    }
+
+    public function actionIndex()
+    {
+        $dataProviderTaxRate = new ActiveDataProvider([
+            'query' => TaxRate::find()
+        ]);
+
+        return $this->render('index', [
+            'dataProviderTaxRate' => $dataProviderTaxRate,
+        ]);
+    }
+
+    public function actionCreate()
+    {
+        $model = $this->getLogic()->getTaxRateContainer()->getFactory()->create();
+
+        if ($model->load(Yii::$app->request->post()) && $model->save()) {
+            $this->setFlash('success', 'Taxe créé.');
+            return $this->redirect(['index']);
+        } else {
+            return $this->render('create', [
+                'model' => $model,
+            ]);
         }
-
-        /**
-         * Supprime une commande récurrente.
-         *
-         * @param integer $id
-         */
-        public function actionDelete($id)
-        {
-                $taxeRate = TaxRateModel::searchOne([
-                        'id' => $id
-                ]) ;
-                $taxeRate->delete();
-
-                Yii::$app->getSession()->setFlash('success', 'Taxe supprimé');
-                return $this->redirect(['tax-rate-admin/index']);
+    }
+
+    public function actionUpdate($id)
+    {
+        $model = $this->findModel($id);
+
+        if ($model->load(Yii::$app->request->post()) && $model->save()) {
+            $this->setFlash('success', 'Taxe édité.');
+            return $this->redirect(['index']);
+        } else {
+            return $this->render('update', [
+                'model' => $model,
+            ]);
         }
-
-
-        /**
-         * Finds the Developpement model based on its primary key value.
-         * If the model is not found, a 404 HTTP exception will be thrown.
-         * @param integer $id
-         * @return Developpement the loaded model
-         * @throws NotFoundHttpException if the model cannot be found
-         */
-        protected function findModel($id)
-        {
-                if (($model = TaxRateModel::findOne($id)) !== null) {
-                        return $model;
-                } else {
-                        throw new NotFoundHttpException('The requested page does not exist.');
-                }
+    }
+
+    public function actionDelete(int $id)
+    {
+        $taxeRate = TaxRate::searchOne([
+            'id' => $id
+        ]);
+        $taxeRate->delete();
+
+        Yii::$app->getSession()->setFlash('success', 'Taxe supprimé');
+        return $this->redirect(['tax-rate-admin/index']);
+    }
+
+    protected function findModel($id)
+    {
+        if (($model = TaxRate::findOne($id)) !== null) {
+            return $model;
+        } else {
+            throw new NotFoundHttpException('The requested page does not exist.');
         }
+    }
 
 }

backend/views/producer/update.php

                 <div class="panel-body">
                     <h4>Facturation</h4>
                     <?= $form->field($model, 'id_tax_rate_default')
-                        ->dropDownList(ArrayHelper::map(TaxRateModel::find()->all(), 'id', function ($model) {
+                        ->dropDownList(ArrayHelper::map(TaxRate::find()->all(), 'id', function ($model) {
                             return $model->name;
                         }))
                         ->label('TVA à appliquer par défaut'); ?>

backend/views/product/_form.php

                         $producer = \common\helpers\GlobalParam::getCurrentProducer();
                         $taxRateDefault = $producer->taxRate;
 
-                        $taxRateNamesArray = array_merge(array(0 => 'Tva par défaut'), ArrayHelper::map(TaxRateModel::find()->all(), 'id', function ($model) {
+                        $taxRateNamesArray = array_merge(array(0 => 'Tva par défaut'), ArrayHelper::map(TaxRate::find()->all(), 'id', function ($model) {
                                 return $model->name;
                         }));
-                        $taxRateValuesArray = array_merge(array(0 => $taxRateDefault->value), ArrayHelper::map(TaxRateModel::find()->all(), 'id', function ($model) {
+                        $taxRateValuesArray = array_merge(array(0 => $taxRateDefault->value), ArrayHelper::map(TaxRate::find()->all(), 'id', function ($model) {
                                 return $model->value;
                         }));
                         foreach ($taxRateValuesArray as $key => $taxRateValue) {

common/components/BusinessLogic.php

 
 use common\logic\Config\TaxRate\TaxRateContainer;
 use common\logic\Distribution\Distribution\DistributionContainer;
+use common\logic\Distribution\PointSaleDistribution\PointSaleDistributionContainer;
+use common\logic\Distribution\ProductDistribution\ProductDistributionContainer;
 use common\logic\Document\Document\DocumentContainer;
 use common\logic\Order\Order\OrderContainer;
 use common\logic\Order\OrderStatusHistory\OrderStatusHistoryContainer;
             $this->getProducerPriceRangeContainer(),
             $this->getUserProducerContainer(),
             $this->getOrderSatusHistoryContainer(),
+            $this->getPointSaleDistributionContainer(),
+            $this->getProductDistributionContainer(),
             $this->getProductCategoryContainer(),
             $this->getProductPointSaleContainer(),
             $this->getProductOrderContainer(),
         return new ProductSubscriptionContainer();
     }
 
+    public function getPointSaleDistributionContainer(): PointSaleDistributionContainer
+    {
+        return new PointSaleDistributionContainer();
+    }
+
+    public function getProductDistributionContainer(): ProductDistributionContainer
+    {
+        return new ProductDistributionContainer();
+    }
+
     /*
      * Hiérarchie des apps
      */

common/controllers/CommonController.php

 namespace common\controllers;
 
 use common\components\BusinessLogic;
+use common\logic\User\User\UserModel;
 use yii;
 
 class CommonController extends \yii\web\Controller 
         return Yii::$app->urlManagerBackend;
     }
 
-    public function getUser()
+    public function getUserCurrent()
     {
         return Yii::$app->getUser();
     }
 
+    public function isUserCurrentAdmin()
+    {
+        return $this->getLogic()->getUserContainer()->getSolver()->isAdmin($this->getUserCurrent());
+    }
+
     public function getRequest()
     {
         return Yii::$app->request;

common/forms/LoginForm.php

 
 namespace common\forms;
 
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\logic\User\User\UserModel;
 use Yii;
 use yii\base\Model;
             ['id_producer', 'integer'],
             ['id_producer', function($attribute, $params) {
                     if ($this->id_producer) {
-                        $producer = ProducerModel::findOne($this->id_producer);
+                        $producer = Producer::findOne($this->id_producer);
                         if (!$producer) {
                             $this->addError($attribute, 'Ce producteur n\'existe pas.');
                         }

common/helpers/CSV.php

 
 namespace common\helpers;
 
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 
 class CSV
 {
 
     public static function array2csv(array &$array)
     {
-        $separator = ProducerModel::getConfig('option_csv_separator') ?: ';';
+        $separator = Producer::getConfig('option_csv_separator') ?: ';';
 
         if (count($array) == 0) {
             return null;

common/helpers/GlobalParam.php

 
 namespace common\helpers;
 
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\models\Producer;
 
 class GlobalParam
     public static function getCurrentProducer()
     {
         if (\Yii::$app->params['producer'] == false) {
-            \Yii::$app->params['producer'] = ProducerModel::searchOne();
+            \Yii::$app->params['producer'] = Producer::searchOne();
         }
         return \Yii::$app->params['producer'];
     }

common/helpers/Tiller.php

 
 namespace common\helpers;
 
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use linslin\yii2\curl;
 
 class Tiller
     public function __construct()
     {
         $this->curl = new curl\Curl();
-        $this->producer_tiller = ProducerModel::getConfig('tiller');
-        $this->provider_token = ProducerModel::getConfig('tiller_provider_token');
-        $this->restaurant_token = ProducerModel::getConfig('tiller_restaurant_token');
+        $this->producer_tiller = Producer::getConfig('tiller');
+        $this->provider_token = Producer::getConfig('tiller_provider_token');
+        $this->restaurant_token = Producer::getConfig('tiller_restaurant_token');
     }
 
     public function getOrders($date)

common/logic/Config/TaxRate/TaxRateModel.php → common/logic/Config/TaxRate/TaxRate.php

  * This is the model class for table "tax_rate".
  *
  */
-class TaxRateModel extends ActiveRecordCommon
+class TaxRate extends ActiveRecordCommon
 {
     /**
      * @inheritdoc

common/logic/Config/TaxRate/TaxRateContainer.php

 {
     public function getEntityFqcn(): string
     {
-        return TaxRateModel::class;
+        return TaxRate::class;
     }
 
     public function getServices(): array

common/logic/Config/TaxRate/TaxRateFactory.php

 
 use common\logic\BaseService;
 use common\logic\FactoryInterface;
-use Stripe\TaxRate;
 
 class TaxRateFactory extends BaseService implements FactoryInterface
 {

common/logic/Config/TaxRate/TaxRateRepository.php

     public function getAsArray(): array
     {
         $taxRateArrayReturn = [];
-        $taxRateArray = TaxRateModel::find()->all();
+        $taxRateArray = TaxRate::find()->all();
 
         foreach($taxRateArray as $taxRate) {
             $taxRateArrayReturn[$taxRate->id] = $taxRate;

common/logic/Development/DevelopmentPriority/DevelopmentPriorityModel.php

 
 namespace common\logic\Development\DevelopmentPriority;
 
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\components\ActiveRecordCommon ;
 
 /**
 
     public function getProducer() 
     {
-        return $this->hasOne(ProducerModel::class, ['id' => 'id_producer']);
+        return $this->hasOne(Producer::class, ['id' => 'id_producer']);
     }
 
     /**

common/logic/Distribution/Distribution/Distribution.php

+<?php
+
+/**
+ * Copyright distrib (2018)
+ *
+ * contact@opendistrib.net
+ *
+ * Ce logiciel est un programme informatique servant à aider les producteurs
+ * à distribuer leur production en circuits courts.
+ *
+ * Ce logiciel est régi par la licence CeCILL soumise au droit français et
+ * respectant les principes de diffusion des logiciels libres. Vous pouvez
+ * utiliser, modifier et/ou redistribuer ce programme sous les conditions
+ * de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA
+ * sur le site "http://www.cecill.info".
+ *
+ * En contrepartie de l'accessibilité au code source et des droits de copie,
+ * de modification et de redistribution accordés par cette licence, il n'est
+ * offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,
+ * seule une responsabilité restreinte pèse sur l'auteur du programme,  le
+ * titulaire des droits patrimoniaux et les concédants successifs.
+ *
+ * A cet égard  l'attention de l'utilisateur est attirée sur les risques
+ * associés au chargement,  à l'utilisation,  à la modification et/ou au
+ * développement et à la reproduction du logiciel par l'utilisateur étant
+ * donné sa spécificité de logiciel libre, qui peut le rendre complexe à
+ * manipuler et qui le réserve donc à des développeurs et des professionnels
+ * avertis possédant  des  connaissances  informatiques approfondies.  Les
+ * utilisateurs sont donc invités à charger  et  tester  l'adéquation  du
+ * logiciel à leurs besoins dans des conditions permettant d'assurer la
+ * sécurité de leurs systèmes et ou de leurs données et, plus généralement,
+ * à l'utiliser et l'exploiter dans les mêmes conditions de sécurité.
+ *
+ * Le fait que vous puissiez accéder à cet en-tête signifie que vous avez
+ * pris connaissance de la licence CeCILL, et que vous en avez accepté les
+ * termes.
+ */
+
+namespace common\logic\Distribution\Distribution;
+
+use common\logic\Distribution\PointSaleDistribution\PointSaleDistribution;
+use common\logic\Distribution\ProductDistribution\ProductDistribution;
+use common\logic\Order\Order\OrderModel;
+use common\logic\Producer\Producer\Producer;
+use common\helpers\GlobalParam;
+use common\components\ActiveRecordCommon;
+use common\logic\Product\Product\Product;
+
+/**
+ * This is the model class for table "distribution".
+ *
+ */
+class Distribution extends ActiveRecordCommon
+{
+    /**
+     * @inheritdoc
+     */
+    public static function tableName()
+    {
+        return 'distribution';
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function rules()
+    {
+        return [
+            [['date'], 'required'],
+            [['date'], 'safe'],
+            [['active'], 'integer']
+        ];
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function attributeLabels()
+    {
+        return [
+            'id' => 'ID',
+            'date' => 'Date',
+            'active' => 'Actif',
+        ];
+    }
+
+    /*
+     * Relations
+     */
+
+    public function getProducer()
+    {
+        return $this->hasOne(Producer::class, ['id' => 'id_producer']);
+    }
+
+    public function getOrder()
+    {
+        return $this->hasMany(OrderModel::class, ['id_distribution' => 'id']);
+    }
+
+    public function getProductDistribution()
+    {
+        return $this->hasMany(ProductDistribution::class, ['id_distribution' => 'id']);
+    }
+
+    public function getPointSaleDistribution()
+    {
+        return $this->hasMany(PointSaleDistribution::class, ['id_distribution' => 'id']);
+    }
+
+    /**
+     * Lie un produit aux jours de distribution futurs.
+     *
+     * @param Product $product
+     */
+    public static function linkProductIncomingDistributions($product)
+    {
+        $distributionsArray = self::getIncomingDistributions();
+        foreach ($distributionsArray as $distribution) {
+            $distribution->linkProduct($product);
+        }
+    }
+
+    /**
+     * Lie un point de vente aux jours de distribution futurs.
+     *
+     * @param PointSale $pointSale
+     */
+    public static function linkPointSaleIncomingDistributions($pointSale)
+    {
+        $distributionsArray = self::getIncomingDistributions();
+        foreach ($distributionsArray as $distribution) {
+            $distribution->linkPointSale($pointSale);
+        }
+    }
+
+    /**
+     *
+     * @param type $pointSale
+     */
+    public function linkPointSale($pointSale)
+    {
+        $pointSaleDistribution = PointSaleDistribution::searchOne([
+            'id_distribution' => $this->id,
+            'id_point_sale' => $pointSale->id
+        ]);
+
+        if (!$pointSaleDistribution) {
+            $pointSaleDistribution = new PointSaleDistribution();
+            $pointSaleDistribution->id_distribution = $this->id;
+            $pointSaleDistribution->id_point_sale = $pointSale->id;
+        }
+
+        $dayDistribution = date('N', strtotime($this->date));
+        $daysArray = [
+            1 => 'monday',
+            2 => 'tuesday',
+            3 => 'wednesday',
+            4 => 'thursday',
+            5 => 'friday',
+            6 => 'saturday',
+            7 => 'sunday',
+        ];
+
+        $pointSaleDistribution->delivery = 0;
+        $deliveryDay = 'delivery_' . $daysArray[$dayDistribution];
+        if ($pointSale->$deliveryDay) {
+            $pointSaleDistribution->delivery = 1;
+        }
+
+        $pointSaleDistribution->save();
+    }
+
+    public function isPointSaleActive($distribution, $pointSaleId)
+    {
+        $pointSaleActive = false;
+
+        if ($distribution->pointSaleDistribution) {
+            foreach ($distribution->pointSaleDistribution as $pointSaleDistribution) {
+                if ($pointSaleDistribution->id_point_sale == $pointSaleId && $pointSaleDistribution->delivery) {
+                    $pointSaleActive = true;
+                }
+            }
+        }
+
+        return $pointSaleActive;
+    }
+
+    /**
+     * Active ou désactive la distribution.
+     */
+    public function active($active = true)
+    {
+        PointSaleDistribution::setAll($this->id, true);
+        $this->active = (int)$active;
+        $this->save();
+
+        if ($active) {
+            // ajout des abonnements
+            SubscriptionModel::addAll($this->date);
+        }
+    }
+
+}

common/logic/Distribution/Distribution/DistributionBuilder.php

 
 namespace common\logic\Distribution\Distribution;
 
+use common\helpers\GlobalParam;
 use common\logic\BaseService;
 use common\logic\BuilderInterface;
+use common\logic\Distribution\PointSaleDistribution\PointSaleDistribution;
+use common\logic\Distribution\PointSaleDistribution\PointSaleDistributionBuilder;
+use common\logic\Distribution\PointSaleDistribution\PointSaleDistributionRepository;
+use common\logic\Distribution\ProductDistribution\ProductDistribution;
+use common\logic\Order\Order\OrderModel;
+use common\logic\Producer\Producer\Producer;
+use common\logic\Product\Product\Product;
 
 class DistributionBuilder extends BaseService implements BuilderInterface
 {
+    protected DistributionRepository $distributionRepository;
+    protected PointSaleDistributionRepository $pointSaleDistributionRepository;
+    protected PointSaleDistributionBuilder $pointSaleDistributionBuilder;
 
+    public function __construct()
+    {
+        $this->distributionRepository = $this->loadService(DistributionRepository::class);
+        $this->pointSaleDistributionRepository = $this->loadService(PointSaleDistributionRepository::class);
+        $this->pointSaleDistributionBuilder = $this->loadService(PointSaleDistributionBuilder::class);
+    }
+
+    public function instanciate(Producer $producer, string $date, bool $delivery = true): Distribution
+    {
+        $distribution = new Distribution();
+
+        $distribution->id_producer = $producer->id;
+        $distribution->date = $date;
+        $distribution->delivery = (int) $delivery;
+
+        return $distribution;
+    }
+
+    public function create(Producer $producer, string $date, int $delivery = 1): Distribution
+    {
+        $distribution = $this->instanciate($producer, $date, 1);
+        $distribution->save();
+
+        return $distribution;
+    }
+
+    public function createIfNotExist(Producer $producer, string $date, int $delivery = 1)
+    {
+        $distribution = $this->distributionRepository->getOne($producer, $date);
+
+        if (!$distribution) {
+            $distribution = $this->create($producer, $date, 1);
+        }
+
+        return $distribution;
+    }
+
+    /**
+     * Initialise un jour de production.
+     */
+    // initDistribution
+    public function init(string $date, Producer $producer = null): Distribution
+    {
+        $distribution = null;
+        if ($date != '') {
+            if (!$producer) {
+                $producer = GlobalParam::getCurrentProducer();
+            }
+            $distribution = $this->createIfNotExist($producer, $date, 1);
+        }
+
+        if ($distribution) {
+            $this->initPointSaleDistribution($distribution);
+            $this->initProductDistribution($distribution);
+        }
+
+        return $distribution;
+    }
+
+    public function initPointSaleDistribution(Distribution $distribution): void
+    {
+        $countPointSaleDistribution = $this->pointSaleDistributionRepository->countByDistribution($distribution);
+        if (!$countPointSaleDistribution) {
+            $this->pointSaleDistributionBuilder->initAll($distribution, true);
+        }
+    }
+
+    public function initProductDistribution(Distribution $distribution)
+    {
+        $products = Product::searchAll();
+
+        $productsDistribution = ProductDistribution::searchAll([
+            'id_distribution' => $distribution->id
+        ]);
+        if (!count($productsDistribution)) {
+            foreach ($products as $product) {
+                $this->linkProduct($distribution, $product);
+            }
+        }
+    }
+
+    /**
+     * Lie un produit à la distribution.
+     */
+    public function linkProduct(Distribution $distribution, Product $product): ProductDistribution
+    {
+        $productDistribution = ProductDistribution::searchOne([
+            'id_distribution' => $this->id,
+            'id_product' => $product->id
+        ]);
+
+        if (!$productDistribution) {
+            $productDistribution = new ProductDistribution();
+            $productDistribution->id_distribution = $this->id;
+            $productDistribution->id_product = $product->id;
+        }
+
+        $dayDistribution = date('N', strtotime($this->date));
+        $daysArray = [
+            1 => 'monday',
+            2 => 'tuesday',
+            3 => 'wednesday',
+            4 => 'thursday',
+            5 => 'friday',
+            6 => 'saturday',
+            7 => 'sunday',
+        ];
+
+        $productDistribution->active = 0;
+        $day = $daysArray[$dayDistribution];
+        if ($product->active && $product->$day) {
+            $productDistribution->active = 1;
+        }
+
+        $productDistribution->quantity_max = $product->quantity_max;
+        $fieldQuantityMax = 'quantity_max_' . $day;
+        if (isset($product->$fieldQuantityMax) && $product->$fieldQuantityMax > 0) {
+            $productDistribution->quantity_max = $product->$fieldQuantityMax;
+        }
+        $productDistribution->save();
+
+        // update prices product order
+        $ordersArray = OrderModel::searchAll([
+            'distribution.date' => $this->date,
+            'distribution.id_producer' => $this->id_producer
+        ],
+            [
+                'conditions' => 'date_delete IS NULL AND origin != "user"'
+            ]);
+        if ($ordersArray) {
+            foreach ($ordersArray as $order) {
+                foreach ($order->productOrder as $productOrder) {
+                    if ($productOrder->id_product == $product->id) {
+                        $productOrder->price = $product->price;
+
+                        $user = false;
+                        $userProducer = false;
+                        if (isset($order->user) && $order->user) {
+                            $user = $order->user;
+                            $userProducer = UserProducerModel::searchOne([
+                                'id_user' => $user->id,
+                                'id_producer' => $order->distribution->id_producer
+                            ]);
+                        }
+
+                        $productOrder->price = $product->getPrice([
+                            'user' => $user,
+                            'user_producer' => $userProducer,
+                            'point_sale' => $order->pointSale,
+                            'quantity' => $productOrder->quantity
+                        ]);
+
+                        $productOrder->save();
+                    }
+                }
+            }
+        }
+
+        return $productDistribution;
+    }
 }

common/logic/Distribution/Distribution/DistributionContainer.php

 {
     public function getEntityFqcn(): string
     {
-        return DistributionModel::class;
+        return Distribution::class;
     }
 
     public function getServices(): array
     {
         return [
-            DistributionFactory::class,
             DistributionSolver::class,
             DistributionRepository::class,
             DistributionBuilder::class
         ];
     }
 
-    public function getFactory(): DistributionFactory
-    {
-        return new DistributionFactory();
-    }
-
     public function getSolver(): DistributionSolver
     {
         return new DistributionSolver();

common/logic/Distribution/Distribution/DistributionFactory.php

-<?php
-
-namespace common\logic\Distribution\Distribution;
-
-use common\logic\BaseService;
-use common\logic\FactoryInterface;
-
-class DistributionFactory extends BaseService implements FactoryInterface
-{
-    public function create(): DistributionModel
-    {
-        $distribution = new DistributionModel();
-
-        return $distribution;
-    }
-}

common/logic/Distribution/Distribution/DistributionModel.php

-<?php
-
-/**
- * Copyright distrib (2018)
- *
- * contact@opendistrib.net
- *
- * Ce logiciel est un programme informatique servant à aider les producteurs
- * à distribuer leur production en circuits courts.
- *
- * Ce logiciel est régi par la licence CeCILL soumise au droit français et
- * respectant les principes de diffusion des logiciels libres. Vous pouvez
- * utiliser, modifier et/ou redistribuer ce programme sous les conditions
- * de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA
- * sur le site "http://www.cecill.info".
- *
- * En contrepartie de l'accessibilité au code source et des droits de copie,
- * de modification et de redistribution accordés par cette licence, il n'est
- * offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,
- * seule une responsabilité restreinte pèse sur l'auteur du programme,  le
- * titulaire des droits patrimoniaux et les concédants successifs.
- *
- * A cet égard  l'attention de l'utilisateur est attirée sur les risques
- * associés au chargement,  à l'utilisation,  à la modification et/ou au
- * développement et à la reproduction du logiciel par l'utilisateur étant
- * donné sa spécificité de logiciel libre, qui peut le rendre complexe à
- * manipuler et qui le réserve donc à des développeurs et des professionnels
- * avertis possédant  des  connaissances  informatiques approfondies.  Les
- * utilisateurs sont donc invités à charger  et  tester  l'adéquation  du
- * logiciel à leurs besoins dans des conditions permettant d'assurer la
- * sécurité de leurs systèmes et ou de leurs données et, plus généralement,
- * à l'utiliser et l'exploiter dans les mêmes conditions de sécurité.
- *
- * Le fait que vous puissiez accéder à cet en-tête signifie que vous avez
- * pris connaissance de la licence CeCILL, et que vous en avez accepté les
- * termes.
- */
-
-namespace common\logic\Distribution\Distribution;
-
-use common\logic\Producer\Producer\ProducerModel;
-use common\helpers\GlobalParam;
-use common\components\ActiveRecordCommon;
-
-/**
- * This is the model class for table "production".
- *
- * @property integer $id
- * @property string $date
- * @property integer $active
- */
-class DistributionModel extends ActiveRecordCommon
-{
-        /**
-         * @inheritdoc
-         */
-        public static function tableName()
-        {
-                return 'distribution';
-        }
-
-        public function getProducer()
-        {
-                return $this->hasOne(ProducerModel::class, ['id' => 'id_producer']);
-        }
-
-        /**
-         * @inheritdoc
-         */
-        public function rules()
-        {
-                return [
-                        [['date'], 'required'],
-                        [['date'], 'safe'],
-                        [['active'], 'integer']
-                ];
-        }
-
-        /**
-         * @inheritdoc
-         */
-        public function attributeLabels()
-        {
-                return [
-                        'id' => 'ID',
-                        'date' => 'Date',
-                        'active' => 'Actif',
-                ];
-        }
-
-        /*
-         * Relations
-         */
-
-        public function getOrder()
-        {
-                return $this->hasMany(OrderModel::className(), ['id_distribution' => 'id']);
-        }
-
-        public function getProductDistribution()
-        {
-                return $this->hasMany(ProductDistributionModel::className(), ['id_distribution' => 'id']);
-        }
-
-        public function getPointSaleDistribution()
-        {
-                return $this->hasMany(PointSaleDistributionModel::className(), ['id_distribution' => 'id']) ;
-        }
-
-        /**
-         * Retourne les options de base nécessaires à la fonction de recherche.
-         *
-         * @return array
-         */
-        public static function defaultOptionsSearch()
-        {
-                return [
-                        'with' => [],
-                        'join_with' => [],
-                        'orderby' => 'date ASC',
-                        'attribute_id_producer' => 'distribution.id_producer'
-                ];
-        }
-
-
-        public function getDate(): string
-        {
-            return $this->date;
-        }
-
-
-        /**
-         * Retourne si un produit est actif ou non.
-         *
-         * @param integer $idProduit
-         * @return boolean
-         */
-        public function isActiveProduct($idProduit)
-        {
-                if ($idProduit &&
-                        isset($this->productDistribution) &&
-                        count($this->productDistribution) > 0) {
-
-                        foreach ($this->productDistribution as $productDistribution) {
-                                if ($productDistribution['id_product'] == $idProduit &&
-                                        $productDistribution['active']) {
-                                        return true;
-                                }
-                        }
-                }
-
-                return false;
-        }
-
-        /**
-         * Initialise un jour de production.
-         *
-         * @param string $date
-         * @return Production
-         */
-        public static function initDistribution($date, $idProducer = 0)
-        {
-                $distribution = null;
-                if ($date != '') {
-
-                        $paramsDistribution = [
-                                'date' => $date
-                        ];
-                        if ($idProducer) {
-                                $paramsDistribution['distribution.id_producer'] = (int)$idProducer;
-                        } else {
-                                $idProducer = GlobalParam::getCurrentProducerId();
-                        }
-
-                        $distribution = DistributionModel::searchOne($paramsDistribution);
-
-                        if (!$distribution) {
-                                $distribution = new Distribution;
-                                $distribution->date = $date;
-                                $distribution->delivery = 1;
-                                $distribution->id_producer = $idProducer;
-                                $distribution->save();
-                        }
-                }
-
-                // point_sale_distribution à définir s'ils ne sont pas initialisés
-                if ($distribution) {
-
-                        $countPointSaleDistribution = PointSaleDistributionModel::searchCount([
-                                'id_distribution' => $distribution->id
-                        ]);
-
-                        if (!$countPointSaleDistribution) {
-                                PointSaleDistributionModel::setAll($distribution->id, true);
-                        }
-                }
-
-                // init produits sélectionnés pour cette production
-                $products = ProductModel::searchAll();
-
-                if ($distribution) {
-                        $productsDistribution = ProductDistributionModel::searchAll([
-                                'id_distribution' => $distribution->id
-                        ]);
-                        if (!count($productsDistribution)) {
-                                foreach ($products as $product) {
-                                        $distribution->linkProduct($product);
-                                }
-                        }
-                        $distribution->linkProductGift();
-                }
-
-                return $distribution;
-        }
-
-        /**
-         * Retourne les distributions futures.
-         *
-         * @return array
-         */
-        public static function getIncomingDistributions()
-        {
-                $distributionsArray = DistributionModel::find()
-                        ->where('date > \'' . date('Y-m-d') . '\'')
-                        ->andWhere([
-                                'id_producer' => GlobalParam::getCurrentProducerId(),
-                                'active' => 1
-                        ])
-                        ->orderBy('date ASC')
-                        ->all();
-
-                return $distributionsArray;
-        }
-
-        public static function filterDistributionsByDateDelay($distributionsArray)
-        {
-                $producer = GlobalParam::getCurrentProducer() ;
-                $dateToday = date('Y-m-d') ;
-
-                foreach($distributionsArray as $keyDistribution => $distribution) {
-
-                        $dateDistribution = $distribution->date ;
-                        $dayDistribution = strtolower(date('l', strtotime($dateDistribution))) ;
-                        $fieldDayDistributionDelay = 'order_delay_'.$dayDistribution ;
-                        $fieldDayDistributionDeadline = 'order_deadline_'.$dayDistribution ;
-
-                        $delay = $producer->order_delay ;
-                        $deadline = $producer->order_deadline ;
-
-                        if($producer->$fieldDayDistributionDelay) {
-                                $delay = $producer->$fieldDayDistributionDelay ;
-                        }
-
-                        if($producer->$fieldDayDistributionDeadline) {
-                                $deadline = $producer->$fieldDayDistributionDeadline ;
-                        }
-
-                        $countDaysTodayDistribution = number_format((strtotime($dateDistribution) - strtotime($dateToday)) / (24 * 60 * 60) , 0);
-
-                        if(date('H') >= $deadline) {
-                                $countDaysTodayDistribution -- ;
-                        }
-
-                        if($countDaysTodayDistribution < $delay) {
-                                unset($distributionsArray[$keyDistribution]) ;
-                        }
-                }
-
-                $newDistributionsArray = [] ;
-                foreach($distributionsArray as $distribution) {
-                        $newDistributionsArray[] = $distribution ;
-                }
-
-                return $newDistributionsArray ;
-        }
-
-        /**
-         * Lie un produit aux jours de distribution futurs.
-         *
-         * @param Product $product
-         */
-        public static function linkProductIncomingDistributions($product)
-        {
-                $distributionsArray = self::getIncomingDistributions();
-                foreach ($distributionsArray as $distribution) {
-                        $distribution->linkProduct($product);
-                }
-        }
-
-        /**
-         * Lie un produit à la distribution.
-         *
-         * @param Product $product
-         */
-        public function linkProduct($product)
-        {
-                $productDistribution = ProductDistributionModel::searchOne([
-                        'id_distribution' => $this->id,
-                        'id_product' => $product->id
-                ]);
-
-                if (!$productDistribution) {
-                        $productDistribution = new ProductDistribution();
-                        $productDistribution->id_distribution = $this->id;
-                        $productDistribution->id_product = $product->id;
-                }
-
-                $dayDistribution = date('N', strtotime($this->date));
-                $daysArray = [
-                        1 => 'monday',
-                        2 => 'tuesday',
-                        3 => 'wednesday',
-                        4 => 'thursday',
-                        5 => 'friday',
-                        6 => 'saturday',
-                        7 => 'sunday',
-                ];
-
-                $productDistribution->active = 0;
-                $day = $daysArray[$dayDistribution];
-                if ($product->active && $product->$day) {
-                        $productDistribution->active = 1;
-                }
-
-                $productDistribution->quantity_max = $product->quantity_max;
-                $fieldQuantityMax = 'quantity_max_'.$day ;
-                if(isset($product->$fieldQuantityMax) && $product->$fieldQuantityMax > 0) {
-                        $productDistribution->quantity_max = $product->$fieldQuantityMax ;
-                }
-                $productDistribution->save();
-
-                // update prices product order
-                $ordersArray = OrderModel::searchAll([
-                        'distribution.date' => $this->date,
-                        'distribution.id_producer' => $this->id_producer
-                ],
-                [
-                        'conditions' => 'date_delete IS NULL AND origin != "user"'
-                ]);
-                if($ordersArray) {
-                        foreach($ordersArray as $order) {
-                                foreach($order->productOrder as $productOrder) {
-                                        if($productOrder->id_product == $product->id) {
-                                                $productOrder->price = $product->price ;
-
-                                                $user = false;
-                                                $userProducer = false;
-                                                if(isset($order->user) && $order->user) {
-                                                    $user = $order->user;
-                                                    $userProducer = UserProducerModel::searchOne([
-                                                        'id_user' => $user->id,
-                                                        'id_producer' => $order->distribution->id_producer
-                                                    ]) ;
-                                                }
-
-                                                $productOrder->price = $product->getPrice([
-                                                    'user' => $user,
-                                                    'user_producer' => $userProducer,
-                                                    'point_sale' => $order->pointSale,
-                                                    'quantity' => $productOrder->quantity
-                                                ]);
-
-                                                $productOrder->save() ;
-                                        }
-                                }
-                        }
-                }
-
-                return $productDistribution;
-        }
-
-        /**
-         * Lie le produit "Don" à la distribution
-         */
-        public function linkProductGift()
-        {
-                $productGift = ProductModel::getProductGift();
-
-                if ($productGift) {
-                        $productDistribution = ProductDistributionModel::searchOne([
-                                'id_distribution' => $this->id,
-                                'id_product' => $productGift->id
-                        ]);
-
-                        if (!$productDistribution) {
-                                $productDistribution = new ProductDistribution();
-                                $productDistribution->id_distribution = $this->id;
-                                $productDistribution->id_product = $productGift->id;
-                                $productDistribution->active = 1;
-                                $productDistribution->save();
-                        }
-                }
-        }
-
-        /**
-         * Lie un point de vente aux jours de distribution futurs.
-         *
-         * @param PointSale $pointSale
-         */
-        public static function linkPointSaleIncomingDistributions($pointSale)
-        {
-                $distributionsArray = self::getIncomingDistributions();
-                foreach ($distributionsArray as $distribution) {
-                        $distribution->linkPointSale($pointSale);
-                }
-        }
-
-        /**
-         *
-         * @param type $pointSale
-         */
-        public function linkPointSale($pointSale)
-        {
-                $pointSaleDistribution = PointSaleDistributionModel::searchOne([
-                        'id_distribution' => $this->id,
-                        'id_point_sale' => $pointSale->id
-                ]);
-
-                if (!$pointSaleDistribution) {
-                        $pointSaleDistribution = new PointSaleDistribution();
-                        $pointSaleDistribution->id_distribution = $this->id;
-                        $pointSaleDistribution->id_point_sale = $pointSale->id;
-                }
-
-                $dayDistribution = date('N', strtotime($this->date));
-                $daysArray = [
-                        1 => 'monday',
-                        2 => 'tuesday',
-                        3 => 'wednesday',
-                        4 => 'thursday',
-                        5 => 'friday',
-                        6 => 'saturday',
-                        7 => 'sunday',
-                ];
-
-                $pointSaleDistribution->delivery = 0;
-                $deliveryDay = 'delivery_' . $daysArray[$dayDistribution];
-                if ($pointSale->$deliveryDay) {
-                        $pointSaleDistribution->delivery = 1;
-                }
-
-                $pointSaleDistribution->save();
-        }
-
-        public function isPointSaleActive($distribution, $pointSaleId)
-        {
-                $pointSaleActive = false ;
-
-                if($distribution->pointSaleDistribution) {
-                        foreach($distribution->pointSaleDistribution as $pointSaleDistribution) {
-                                if($pointSaleDistribution->id_point_sale == $pointSaleId && $pointSaleDistribution->delivery) {
-                                        $pointSaleActive = true ;
-                                }
-                        }
-                }
-
-                return $pointSaleActive ;
-        }
-
-        /**
-         * Active ou désactive la distribution.
-         */
-        public function active($active = true)
-        {
-                PointSaleDistributionModel::setAll($this->id, true);
-                $this->active = (int)$active;
-                $this->save();
-
-                if ($active) {
-                        // ajout des abonnements
-                        SubscriptionModel::addAll($this->date);
-                }
-        }
-
-}

common/logic/Distribution/Distribution/DistributionRepository.php

 
 namespace common\logic\Distribution\Distribution;
 
+use common\helpers\GlobalParam;
 use common\logic\BaseService;
+use common\logic\Producer\Producer\Producer;
 use common\logic\RepositoryInterface;
 
 class DistributionRepository extends BaseService implements RepositoryInterface
 {
+    /**
+     * Retourne les options de base nécessaires à la fonction de recherche.
+     */
+    public function defaultOptionsSearch(): array
+    {
+        return [
+            'with' => [],
+            'join_with' => [],
+            'orderby' => 'date ASC',
+            'attribute_id_producer' => 'distribution.id_producer'
+        ];
+    }
 
+    public function getOne(Producer $producer, string $date)
+    {
+        $paramsDistribution = [
+            'date' => $date,
+            'distribution.id_producer' => $producer->id
+        ];
+
+        return Distribution::searchOne($paramsDistribution);
+    }
+
+    /**
+     * Récupère les distributions futures.
+     */
+    public function getIncomingDistributions(): array
+    {
+        $distributionsArray = Distribution::find()
+            ->where('date > \'' . date('Y-m-d') . '\'')
+            ->andWhere([
+                'id_producer' => GlobalParam::getCurrentProducerId(),
+                'active' => 1
+            ])
+            ->orderBy('date ASC')
+            ->all();
+
+        return $distributionsArray;
+    }
 }

common/logic/Distribution/Distribution/DistributionSolver.php

 
 namespace common\logic\Distribution\Distribution;
 
+use common\helpers\GlobalParam;
 use common\logic\BaseService;
+use common\logic\Product\Product\Product;
 use common\logic\SolverInterface;
 
 class DistributionSolver extends BaseService implements SolverInterface
 {
+    /**
+     * Déduit si un produit est actif ou non
+     */
+    public function isActiveProduct(Distribution $distribution, Product $product): bool
+    {
+        if ($product->id
+            && isset($distribution->productDistribution)
+            && count($distribution->productDistribution) > 0) {
 
+            foreach ($distribution->productDistribution as $productDistribution) {
+                if ($productDistribution['id_product'] == $product->id
+                    && $productDistribution['active']) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /*
+     * Filtre les distributions par délai de commande.
+     */
+    public function filterDistributionsByDateDelay(array $distributionsArray): array
+    {
+        $producer = GlobalParam::getCurrentProducer();
+        $dateToday = date('Y-m-d');
+
+        foreach ($distributionsArray as $keyDistribution => $distribution) {
+
+            $dateDistribution = $distribution->date;
+            $dayDistribution = strtolower(date('l', strtotime($dateDistribution)));
+            $fieldDayDistributionDelay = 'order_delay_' . $dayDistribution;
+            $fieldDayDistributionDeadline = 'order_deadline_' . $dayDistribution;
+
+            $delay = $producer->order_delay;
+            $deadline = $producer->order_deadline;
+
+            if ($producer->$fieldDayDistributionDelay) {
+                $delay = $producer->$fieldDayDistributionDelay;
+            }
+
+            if ($producer->$fieldDayDistributionDeadline) {
+                $deadline = $producer->$fieldDayDistributionDeadline;
+            }
+
+            $countDaysTodayDistribution = number_format((strtotime($dateDistribution) - strtotime($dateToday)) / (24 * 60 * 60), 0);
+
+            if (date('H') >= $deadline) {
+                $countDaysTodayDistribution--;
+            }
+
+            if ($countDaysTodayDistribution < $delay) {
+                unset($distributionsArray[$keyDistribution]);
+            }
+        }
+
+        $newDistributionsArray = [];
+        foreach ($distributionsArray as $distribution) {
+            $newDistributionsArray[] = $distribution;
+        }
+
+        return $newDistributionsArray;
+    }
 }

common/logic/Distribution/PointSaleDistribution/PointSaleDistributionModel.php → common/logic/Distribution/PointSaleDistribution/PointSaleDistribution.php

 use common\components\ActiveRecordCommon ;
 
 /**
- * This is the model class for table "production_point_vente".
+ * This is the model class for table "point_sale_distribution".
  *
- * @property integer $id_distribution
- * @property integer $id_point_sale
- * @property integer $delivery
  */
-class PointSaleDistributionModel extends ActiveRecordCommon
+class PointSaleDistribution extends ActiveRecordCommon
 {
-
     var $points_sale_distribution;
 
     /**
         ] ;
     }
 
-    /**
-     * Définit les jours de livraisons des points de vente pour un jour de 
-     * production donné.
-     * 
-     * @param integer $id_production
-     * @param boolean $bool_livraison
-     */
-    public static function setAll($idDistribution, $boolDelivery) 
-    {   
-        // liaison PointSale / Distribution    
-        $arrPointsSale = PointSaleModel::find()
-            ->with(['pointSaleDistribution' => function($q) use ($idDistribution) {
-                $q->where(['id_distribution' => $idDistribution]);
-            }])
-            ->where([
-                'id_producer' => GlobalParam::getCurrentProducerId(),
-            ])
-            ->all();
-        
-        foreach ($arrPointsSale as $pointSale) {
-            if(!$pointSale->pointSaleDistribution) {
-                $pointSaleDistribution = new PointSaleDistribution();
-                $pointSaleDistribution->id_distribution = $idDistribution;
-                $pointSaleDistribution->id_point_sale = $pointSale->id;
-                $pointSaleDistribution->save();
-            }
-        }
-
-        $distribution = DistributionModel::findOne($idDistribution);
-
-        if ($distribution) {
-            $day = date('N', strtotime($distribution->date));
-
-            $arrPointsSaleDistribution = self::searchAll([
-                'id_distribution' => $idDistribution
-            ]) ;
-                    
-            foreach ($arrPointsSaleDistribution as $pointSaleDistribution) {
-                if ($boolDelivery &&
-                    (($day == 1 && $pointSaleDistribution->pointSale->delivery_monday) ||
-                    ($day == 2 && $pointSaleDistribution->pointSale->delivery_tuesday) ||
-                    ($day == 3 && $pointSaleDistribution->pointSale->delivery_wednesday) ||
-                    ($day == 4 && $pointSaleDistribution->pointSale->delivery_thursday) ||
-                    ($day == 5 && $pointSaleDistribution->pointSale->delivery_friday) ||
-                    ($day == 6 && $pointSaleDistribution->pointSale->delivery_saturday) ||
-                    ($day == 7 && $pointSaleDistribution->pointSale->delivery_sunday)
-                )) {
-                    $pointSaleDistribution->delivery = 1;
-                } else {
-                    $pointSaleDistribution->delivery = 0;
-                }
-
-                $pointSaleDistribution->save();
-            }
-        }
-    }
-
 }

common/logic/Distribution/PointSaleDistribution/PointSaleDistributionBuilder.php

+<?php
+
+namespace common\logic\Distribution\PointSaleDistribution;
+
+use common\helpers\GlobalParam;
+use common\logic\BaseService;
+use common\logic\BuilderInterface;
+use common\logic\Distribution\Distribution\Distribution;
+use common\logic\PointSale\PointSale\PointSale;
+
+class PointSaleDistributionBuilder extends BaseService implements BuilderInterface
+{
+    /*
+     * Instancie un PointSaleDistribution.
+     */
+    public function instanciate(Distribution $distribution, PointSale $pointSale): PointSaleDistribution
+    {
+        $pointSaleDistribution = new PointSaleDistribution();
+
+        $pointSaleDistribution->id_distribution = $distribution->id;
+        $pointSaleDistribution->id_point_sale = $pointSale->id;
+
+        return $pointSaleDistribution;
+    }
+
+    /*
+     * Crée un PointSaleDistribution.
+     */
+    public function create(Distribution $distribution, PointSale $pointSale): PointSaleDistribution
+    {
+        $pointSaleDistribution = $this->instanciate($distribution, $pointSale);
+        $pointSaleDistribution->save();
+
+        return $pointSaleDistribution;
+    }
+
+    /**
+     * Initialise les PointSaleDistribution pour une distribution donnée.
+     */
+    // setAll
+    public function initAll(Distribution $distribution, bool $delivery): void
+    {
+        $arrPointsSale = PointSale::find()
+            ->with(['pointSaleDistribution' => function($q) use ($distribution) {
+                $q->where(['id_distribution' => $distribution->id]);
+            }])
+            ->where([
+                'id_producer' => GlobalParam::getCurrentProducerId(),
+            ])
+            ->all();
+
+        foreach ($arrPointsSale as $pointSale) {
+            if(!$pointSale->pointSaleDistribution) {
+                $this->create($distribution, $pointSale);
+            }
+        }
+
+        $distribution = Distribution::findOne($distribution->id);
+        if ($distribution) {
+
+            $arrPointsSaleDistribution = PointSaleDistribution::searchAll([
+                'id_distribution' => $distribution->id
+            ]) ;
+            foreach ($arrPointsSaleDistribution as $pointSaleDistribution) {
+                $this->initDelivery($pointSaleDistribution, $delivery);
+            }
+        }
+    }
+
+    public function initDelivery(PointSaleDistribution $pointSaleDistribution, bool $delivery)
+    {
+        $day = date('N', strtotime($pointSaleDistribution->distribution->date));
+
+        if ($delivery &&
+            (($day == 1 && $pointSaleDistribution->pointSale->delivery_monday) ||
+                ($day == 2 && $pointSaleDistribution->pointSale->delivery_tuesday) ||
+                ($day == 3 && $pointSaleDistribution->pointSale->delivery_wednesday) ||
+                ($day == 4 && $pointSaleDistribution->pointSale->delivery_thursday) ||
+                ($day == 5 && $pointSaleDistribution->pointSale->delivery_friday) ||
+                ($day == 6 && $pointSaleDistribution->pointSale->delivery_saturday) ||
+                ($day == 7 && $pointSaleDistribution->pointSale->delivery_sunday)
+            )) {
+            $pointSaleDistribution->delivery = 1;
+        } else {
+            $pointSaleDistribution->delivery = 0;
+        }
+
+        $pointSaleDistribution->save();
+    }
+}

common/logic/Distribution/PointSaleDistribution/PointSaleDistributionContainer.php

+<?php
+
+namespace common\logic\Distribution\PointSaleDistribution;
+
+use common\logic\ContainerInterface;
+
+class PointSaleDistributionContainer implements ContainerInterface
+{
+    public function getEntityFqcn(): string
+    {
+        return PointSaleDistribution::class;
+    }
+
+    public function getServices(): array
+    {
+        return [
+            PointSaleDistributionRepository::class,
+            PointSaleDistributionBuilder::class,
+        ];
+    }
+
+    public function getRepository(): PointSaleDistributionRepository
+    {
+        return new PointSaleDistributionRepository();
+    }
+
+    public function getBuilder(): PointSaleDistributionBuilder
+    {
+        return new PointSaleDistributionBuilder();
+    }
+}

common/logic/Distribution/PointSaleDistribution/PointSaleDistributionFactory.php

-<?php
-
-namespace common\logic\Distribution\PointSaleDistribution;
-
-use common\logic\BaseService;
-use common\logic\FactoryInterface;
-
-class PointSaleDistributionFactory extends BaseService implements FactoryInterface
-{
-    public function create(): PointSaleDistributionModel
-    {
-        $pointSaleDistribution = new PointSaleDistributionModel();
-
-        return $pointSaleDistribution;
-    }
-}

common/logic/Distribution/PointSaleDistribution/PointSaleDistributionRepository.php

+<?php
+
+namespace common\logic\Distribution\PointSaleDistribution;
+
+use common\logic\BaseService;
+use common\logic\Distribution\Distribution\Distribution;
+use common\logic\RepositoryInterface;
+
+class PointSaleDistributionRepository extends BaseService implements RepositoryInterface
+{
+    public function countByDistribution(Distribution $distribution): int
+    {
+        return PointSaleDistribution::searchCount([
+            'id_distribution' => $distribution->id
+        ]);
+    }
+
+}

common/logic/Distribution/ProductDistribution/ProductDistributionModel.php → common/logic/Distribution/ProductDistribution/ProductDistribution.php

  * @property integer $id_product
  * @property integer $active
  */
-class ProductDistributionModel extends ActiveRecordCommon
+class ProductDistribution extends ActiveRecordCommon
 {
 
     /**
      */
     public static function searchByDistribution($idDistribution) 
     {
-        $arrayProductsDistribution = ProductDistributionModel::searchAll([
+        $arrayProductsDistribution = ProductDistribution::searchAll([
             'id_distribution' => $idDistribution
         ]) ;
        

common/logic/Distribution/ProductDistribution/ProductDistributionFactory.php → common/logic/Distribution/ProductDistribution/ProductDistributionBuilder.php

 use common\logic\BaseService;
 use common\logic\FactoryInterface;
 
-class ProductDistributionFactory extends BaseService implements FactoryInterface
+class ProductDistributionBuilder extends BaseService implements FactoryInterface
 {
-    public function create(): ProductDistributionModel
+    public function create(): ProductDistribution
     {
-        $productDistribution = new ProductDistributionModel();
+        $productDistribution = new ProductDistribution();
 
         return $productDistribution;
     }

common/logic/Distribution/ProductDistribution/ProductDistributionContainer.php

+<?php
+
+namespace common\logic\Distribution\ProductDistribution;
+
+use common\logic\ContainerInterface;
+
+class ProductDistributionContainer implements ContainerInterface
+{
+    public function getEntityFqcn(): string
+    {
+        return ProductDistribution::class;
+    }
+
+    public function getServices(): array
+    {
+        return [
+            ProductDistributionRepository::class,
+            ProductDistributionBuilder::class,
+        ];
+    }
+
+    public function getRepository(): ProductDistributionRepository
+    {
+        return new ProductDistributionRepository();
+    }
+
+    public function getBuilder(): ProductDistributionBuilder
+    {
+        return new ProductDistributionBuilder();
+    }
+}

common/logic/Distribution/ProductDistribution/ProductDistributionRepository.php

+<?php
+
+namespace common\logic\Distribution\ProductDistribution;
+
+use common\logic\BaseService;
+use common\logic\RepositoryInterface;
+
+class ProductDistributionRepository extends BaseService implements RepositoryInterface
+{
+
+}

common/logic/Document/Document/DocumentModel.php

 
 use common\components\ActiveRecordCommon;
 use common\helpers\GlobalParam;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use kartik\mpdf\Pdf;
 use yii\base\ErrorException;
 
 
     public function getProducer()
     {
-        return $this->hasOne(ProducerModel::class, ['id' => 'id_producer']);
+        return $this->hasOne(Producer::class, ['id' => 'id_producer']);
     }
 
     public function relationOrders($fieldIdDocument)
             $classLower = 'delivery_note';
         }
 
-        $prefix = ProducerModel::getConfig('document_' . $classLower . '_prefix');
+        $prefix = Producer::getConfig('document_' . $classLower . '_prefix');
         $oneDocumentExist = $class::searchOne(['status' => DocumentModel::STATUS_VALID], ['orderby' => 'reference DESC']);
 
         if ($oneDocumentExist) {
 
             return $prefix . $numReference;
         } else {
-            $firstReference = ProducerModel::getConfig('document_' . $classLower . '_first_reference');
+            $firstReference = Producer::getConfig('document_' . $classLower . '_first_reference');
 
             if (strlen($firstReference) > 0) {
                 return $firstReference;
         $contentFooter .= '</div>';
 
         $marginBottom = 10;
-        if (strlen(ProducerModel::getConfig('document_infos_bottom')) > 0) {
+        if (strlen(Producer::getConfig('document_infos_bottom')) > 0) {
             $marginBottom = 40;
         }
 
     public function isDisplayOrders()
     {
         $displayOrders = ($this->getClass() == 'Invoice') ?
-            ProducerModel::getConfig('document_display_orders_invoice') :
-            ProducerModel::getConfig('document_display_orders_delivery_note');
+            Producer::getConfig('document_display_orders_invoice') :
+            Producer::getConfig('document_display_orders_delivery_note');
 
         return $displayOrders;
     }
 
     public function initTaxCalculationMethod()
     {
-        $producerTaxCalculationMethod = ProducerModel::getConfig('option_tax_calculation_method');
+        $producerTaxCalculationMethod = Producer::getConfig('option_tax_calculation_method');
 
         if ($producerTaxCalculationMethod) {
             $this->tax_calculation_method = $producerTaxCalculationMethod;

common/logic/Order/Order/OrderModel.php

 
 use common\helpers\GlobalParam;
 use common\helpers\Price;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\logic\User\CreditHistory\CreditHistoryModel;
 use common\logic\User\User\UserModel;
 use Yii;
         }
 
         // delete
-        if (ProducerModel::getConfig('option_behavior_cancel_order') == ProducerModel::BEHAVIOR_DELETE_ORDER_DELETE ||
-                (ProducerModel::getConfig(
+        if (Producer::getConfig('option_behavior_cancel_order') == Producer::BEHAVIOR_DELETE_ORDER_DELETE ||
+                (Producer::getConfig(
                                 'option_behavior_cancel_order'
-                        ) == ProducerModel::BEHAVIOR_DELETE_ORDER_STATUS && strlen($this->date_delete)) ||
+                        ) == Producer::BEHAVIOR_DELETE_ORDER_STATUS && strlen($this->date_delete)) ||
                 $force) {
             ProductOrderModel::deleteAll(['id_order' => $this->id]);
             return parent::delete();
         } // status 'delete'
-        elseif (ProducerModel::getConfig('option_behavior_cancel_order') == ProducerModel::BEHAVIOR_DELETE_ORDER_STATUS) {
+        elseif (Producer::getConfig('option_behavior_cancel_order') == Producer::BEHAVIOR_DELETE_ORDER_STATUS) {
             $this->date_delete = date('Y-m-d H:i:s');
             return $this->save();
         }
     {
         $html = '';
 
-        $creditActive = ProducerModel::getConfig('credit');
+        $creditActive = Producer::getConfig('credit');
         $html .= $this->getAmountWithTax(self::AMOUNT_TOTAL, true);
 
         if ($creditActive) {
         $todayHour = date('G');
         $dayDistribution = strtolower(date('l', strtotime($this->distribution->date)));
 
-        $orderDelay = ProducerModel::getConfig(
+        $orderDelay = Producer::getConfig(
                 'order_delay',
                 $this->distribution->id_producer
         );
-        $orderDelaySpecific = ProducerModel::getConfig(
+        $orderDelaySpecific = Producer::getConfig(
                 'order_delay_' . $dayDistribution,
                 $this->distribution->id_producer
         );
             $orderDelay = $orderDelaySpecific;
         }
 
-        $orderDeadline = ProducerModel::getConfig(
+        $orderDeadline = Producer::getConfig(
                 'order_deadline',
                 $this->distribution->id_producer
         );
-        $orderDeadlineSpecific = ProducerModel::getConfig(
+        $orderDeadlineSpecific = Producer::getConfig(
                 'order_deadline_' . $dayDistribution,
                 $this->distribution->id_producer
         );
     public function initReference()
     {
         $idProducer = GlobalParam::getCurrentProducerId();
-        $producer = ProducerModel::findOne($idProducer);
+        $producer = Producer::findOne($idProducer);
 
-        if (!$this->reference && $producer->option_order_reference_type == ProducerModel::ORDER_REFERENCE_TYPE_YEARLY) {
+        if (!$this->reference && $producer->option_order_reference_type == Producer::ORDER_REFERENCE_TYPE_YEARLY) {
             $lastOrder = OrderModel::find()->innerJoinWith('distribution', true)
                     ->where(['>=', 'distribution.date', date('Y') . '-01-01'])
                     ->andWhere([

common/logic/Order/ProductOrder/ProductOrderModel.php

 
         public function getTaxRate()
         {
-                return $this->hasOne(TaxRateModel::className(), ['id' => 'id_tax_rate']);
+                return $this->hasOne(TaxRate::className(), ['id' => 'id_tax_rate']);
         }
 
         /**

common/logic/PointSale/PointSale/PointSaleModel.php → common/logic/PointSale/PointSale/PointSale.php

 namespace common\logic\PointSale\PointSale;
 
 use common\helpers\GlobalParam;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use yii\helpers\Html;
 use common\components\ActiveRecordCommon;
 
  * @property integer $id_producer
  * @property integer $default
  */
-class PointSaleModel extends ActiveRecordCommon
+class PointSale extends ActiveRecordCommon
 {
         var $orders = [];
         var $revenues = 0;
         public function processPointProduction()
         {
                 if ($this->point_production) {
-                        PointSaleModel::updateAll(
+                        PointSale::updateAll(
                                 ['point_production' => 0],
                                 ['id_producer' => $this->id_producer]
                         );
         {
                 return strlen($this->credit_functioning) > 0 ?
                         $this->credit_functioning :
-                        ProducerModel::getConfig('credit_functioning');
+                        Producer::getConfig('credit_functioning');
         }
 
         /**
         public static function populateDropdownList()
         {
                 $pointSalesArrayDropdown = ['' => '--'] ;
-                $pointSalesArray = PointSaleModel::find()->where('id_producer = ' . GlobalParam::getCurrentProducerId())->all() ;
+                $pointSalesArray = PointSale::find()->where('id_producer = ' . GlobalParam::getCurrentProducerId())->all() ;
 
                 foreach($pointSalesArray as $pointSale) {
                         $pointSalesArrayDropdown[$pointSale['id']] = $pointSale['name'] ;

common/logic/PointSale/PointSale/PointSaleContainer.php

 {
     public function getEntityFqcn(): string
     {
-        return PointSaleModel::class;
+        return PointSale::class;
     }
 
     public function getServices(): array

common/logic/PointSale/PointSale/PointSaleFactory.php

 
 class PointSaleFactory extends BaseService implements FactoryInterface
 {
-    public function create(): PointSaleModel
+    public function create(): PointSale
     {
-        $pointSale = new PointSaleModel();
+        $pointSale = new PointSale();
 
         return $pointSale;
     }

common/logic/PointSale/PointSale/PointSaleSearch.php

 
 use common\helpers\GlobalParam;
 
-class PointSaleSearch extends PointSaleModel
+class PointSaleSearch extends PointSale
 {
     var $delivery ;
     var $access_type ;
     {
         $optionsSearch = self::defaultOptionsSearch() ;
         
-        $query = PointSaleModel::find()
+        $query = PointSale::find()
             ->with($optionsSearch['with'])
             ->innerJoinWith($optionsSearch['join_with'], true)
             ->where([

common/logic/Producer/Producer/ProducerModel.php → common/logic/Producer/Producer/Producer.php

 namespace common\logic\Producer\Producer;
 
 use common\logic\User\User\UserModel;
-use common\logic\Config\TaxRate\TaxRateModel;
+use common\logic\Config\TaxRate\TaxRate;
 use common\logic\User\UserProducer\UserProducerModel;
 use common\components\ActiveRecordCommon;
 
  * This is the model class for table "producer".
  *
  */
-class ProducerModel extends ActiveRecordCommon
+class Producer extends ActiveRecordCommon
 {
     const CREDIT_FUNCTIONING_MANDATORY = 'mandatory';
     const CREDIT_FUNCTIONING_OPTIONAL = 'optional';
                 'code',
                 function ($attribute, $params) {
                     $code = $this->$attribute;
-                    $producer = ProducerModel::findOne(['code' => $code]);
+                    $producer = Producer::findOne(['code' => $code]);
                     if ($producer && $producer->id != $this->id) {
                         $this->addError($attribute, 'Ce code est déjà utilisé par un autre producteur.');
                     }
 
     public function getTaxRate()
     {
-        return $this->hasOne(TaxRateModel::class, ['id' => 'id_tax_rate_default']);
+        return $this->hasOne(TaxRate::class, ['id' => 'id_tax_rate_default']);
     }
 
     // ---

common/logic/Producer/Producer/ProducerBuilder.php

         $this->producerSolver = $this->loadService(ProducerSolver::class);
     }
 
-    public function init(ProducerModel $producer): void
+    public function init(Producer $producer): void
     {
         $this->initSlug($producer);
         $this->initCode($producer);
     }
 
-    public function initSlug(ProducerModel $producer): void
+    public function initSlug(Producer $producer): void
     {
         $cptSlug = 0 ;
         do {
         } while($this->producerRepository->getOneBySlug($producer->slug)) ;
     }
 
-    public function initCode(ProducerModel $producer): void
+    public function initCode(Producer $producer): void
     {
         $producer->code = Password::generate();
     }
         return $userProducer;
     }
 
-    public function updateOpendistribVersion(ProducerModel $producer)
+    public function updateOpendistribVersion(Producer $producer)
     {
         $versionsArray = Opendistrib::getVersions();
         $producer->latest_version_opendistrib = array_values($versionsArray)[0];
         }
     }
 
-    public function savePrivateKeyApiStripe(ProducerModel $producer): void
+    public function savePrivateKeyApiStripe(Producer $producer): void
     {
         $this->savePrivateKeyStripe(
             $this->producerSolver->getFilenamePrivateKeyApiStripe($producer),
         );
     }
 
-    public function savePrivateKeyEndpointStripe(ProducerModel $producer): bool
+    public function savePrivateKeyEndpointStripe(Producer $producer): bool
     {
         $this->savePrivateKeyStripe(
             $this->producerSolver->getFilenamePrivateKeyEndpointStripe($producer),

common/logic/Producer/Producer/ProducerContainer.php

 {
     public function getEntityFqcn(): string
     {
-        return ProducerModel::class;
+        return Producer::class;
     }
 
     public function getServices(): array

common/logic/Producer/Producer/ProducerFactory.php

 {
     public function create()
     {
-        $producer = new ProducerModel();
+        $producer = new Producer();
 
-        $producer->order_deadline = ProducerModel::ORDER_DEADLINE_DEFAULT;
-        $producer->order_delay = ProducerModel::ORDER_DELAY_DEFAULT;
+        $producer->order_deadline = Producer::ORDER_DEADLINE_DEFAULT;
+        $producer->order_delay = Producer::ORDER_DELAY_DEFAULT;
 
         return $producer;
     }

common/logic/Producer/Producer/ProducerRepository.php

 
     public function getOneById($id)
     {
-        return ProducerModel::searchOne(['id' => $id]);
+        return Producer::searchOne(['id' => $id]);
     }
 
     public function getOneBySlug($slug)
     {
-        return ProducerModel::searchOne(['slug' => $slug]);
+        return Producer::searchOne(['slug' => $slug]);
     }
 
     public function queryActive()
     {
-        return ProducerModel::find()
+        return Producer::find()
             ->where([
                 'active' => true,
             ])
      */
     public function getOneDemoAccount()
     {
-        return ProducerModel::find()->where('name LIKE \'Démo\'')->one();
+        return Producer::find()->where('name LIKE \'Démo\'')->one();
     }
 
     /**
      */
     public static function getPopulateDropdown()
     {
-        $producers = ProducerModel::find()
+        $producers = Producer::find()
             ->where([
                 'active' => true,
             ])
     /**
      * Retourne le CA du producteur pour un mois donné
      */
-    public function getTurnover(ProducerModel $producer, string $period = '', bool $format = false)
+    public function getTurnover(Producer $producer, string $period = '', bool $format = false)
     {
         if (!$period) {
             $period = date('Y-m');
         }
     }
 
-    public function getAmountToBeBilledByMonth(ProducerModel $producer, $month, $format = false)
+    public function getAmountToBeBilledByMonth(Producer $producer, $month, $format = false)
     {
         $turnover = $this->getTurnover($producer, $month);
         return $this->producerPriceRangeRepository->getAmountToBeBilledByTurnover($turnover, $format);
     }
 
-    public function getSummaryAmountsToBeBilled(ProducerModel $producer, $label, $numberOfMonths = 1)
+    public function getSummaryAmountsToBeBilled(Producer $producer, $label, $numberOfMonths = 1)
     {
         $text = '';
         $numMonthCurrent = date('m');
         return $text;
     }
 
-    public function getAmountBilledLastMonth(ProducerModel $producer)
+    public function getAmountBilledLastMonth(Producer $producer)
     {
         if ($this->producerSolver->isBillingTypeClassic($producer)) {
             $month = date('Y-m', strtotime('-1 month'));
         return 0;
     }
 
-    public function getOnlinePaymentMinimumAmount(ProducerModel $producer)
+    public function getOnlinePaymentMinimumAmount(Producer $producer)
     {
         $onlinePaymentMinimumAmount = $this->getConfig('option_online_payment_minimum_amount');
         if (!$onlinePaymentMinimumAmount) {
-            $onlinePaymentMinimumAmount = ProducerModel::ONLINE_PAYMENT_MINIMUM_AMOUNT_DEFAULT;
+            $onlinePaymentMinimumAmount = Producer::ONLINE_PAYMENT_MINIMUM_AMOUNT_DEFAULT;
         }
 
         return $onlinePaymentMinimumAmount;

common/logic/Producer/Producer/ProducerSolver.php

 
 class ProducerSolver extends BaseService implements SolverInterface
 {
+    public function getCurrent()
+    {
+
+    }
+
     /**
      * Retourne true si le compte est un compte de démo.
-     *
      */
-    public function isDemo(ProducerModel $producer): bool
+    public function isDemo(Producer $producer): bool
     {
         if (strpos($producer->name, 'Démo') !== false) {
             return true;
         return false;
     }
 
-    public function getFullAddress(ProducerModel $producer, $nl2br = false)
+    public function getFullAddress(Producer $producer, $nl2br = false)
     {
         $address = '';
         $address .= $producer->name . "\n";
         return $address;
     }
 
-    public function getHtmlLogo(ProducerModel $producer)
+    public function getHtmlLogo(Producer $producer)
     {
         $html = '';
 
         return $html;
     }
 
-    public function getUrlLogo(ProducerModel $producer): string
+    public function getUrlLogo(Producer $producer): string
     {
         return \Yii::$app->urlManagerProducer->getHostInfo() . '/' . \Yii::$app->urlManagerProducer->baseUrl . '/uploads/' . $producer->logo;
     }
 
-    public function getEmailOpendistrib(ProducerModel $producer): string
+    public function getEmailOpendistrib(Producer $producer): string
     {
         return $producer->slug . '@opendistrib.net';
     }
 
-    public function getMainContact(ProducerModel $producer): ?UserModel
+    public function getMainContact(Producer $producer): ?UserModel
     {
         if ($producer->contact) {
             foreach ($producer->contact as $contact) {
         return null;
     }
 
-    public function isUpToDateWithOpendistribVersion(ProducerModel $producer): bool
+    public function isUpToDateWithOpendistribVersion(Producer $producer): bool
     {
         return $producer->latest_version_opendistrib == GlobalParam::getOpendistribVersion();
     }
 
-    public function isBillingTypeClassic(ProducerModel $producer): bool
+    public function isBillingTypeClassic(Producer $producer): bool
     {
-        return $producer->option_billing_type == ProducerModel::BILLING_TYPE_CLASSIC;
+        return $producer->option_billing_type == Producer::BILLING_TYPE_CLASSIC;
     }
 
-    public function isBillingTypeFreePrice(ProducerModel $producer)
+    public function isBillingTypeFreePrice(Producer $producer)
     {
-        return $producer->option_billing_type == ProducerModel::BILLING_TYPE_FREE_PRICE;
+        return $producer->option_billing_type == Producer::BILLING_TYPE_FREE_PRICE;
     }
 
     /**
      * le producteur.
      *
      */
-    public function getFreePrice(ProducerModel $producer, $format = true)
+    public function getFreePrice(Producer $producer, $format = true)
     {
         if (!is_null($producer->free_price)) {
             if ($format) {
         }
     }
 
-    public function getSpecificDelays(ProducerModel $producer): array
+    public function getSpecificDelays(Producer $producer): array
     {
         $array = [];
         $daysArray = [
         return $array;
     }
 
-    public function hasSpecificDelays(ProducerModel $producer): bool
+    public function hasSpecificDelays(Producer $producer): bool
     {
         $daysArray = [
             'monday',
         return false;
     }
 
-    public function getFilenamePrivateKeyApiStripe(ProducerModel $producer)
+    public function getFilenamePrivateKeyApiStripe(Producer $producer)
     {
         return '../../common/config/stripe/api-' . $producer->id . '.key';
     }
 
-    public function getFilenamePrivateKeyEndpointStripe(ProducerModel $producer)
+    public function getFilenamePrivateKeyEndpointStripe(Producer $producer)
     {
         return '../../common/config/stripe/endpoint-' . $producer->id . '.key';
     }
         return '';
     }
 
-    public function getPrivateKeyApiStripe(ProducerModel $producer)
+    public function getPrivateKeyApiStripe(Producer $producer)
     {
         return $this->getPrivateKeyStripe($this->getFilenamePrivateKeyApiStripe($producer));
     }
 
-    public function getPrivateKeyEndpointStripe(ProducerModel $producer)
+    public function getPrivateKeyEndpointStripe(Producer $producer)
     {
         return $this->getPrivateKeyStripe($this->getFilenamePrivateKeyEndpointStripe($producer));
     }
 
-    public function isOnlinePaymentActive(ProducerModel $producer)
+    public function isOnlinePaymentActive(Producer $producer)
     {
         return $producer->online_payment
             || ($producer->option_stripe_mode_test
                     && \Yii::$app->user->identity->status > 10);
     }
 
-    public function isOnlinePaymentActiveAndTypeOrder(ProducerModel $producer): bool
+    public function isOnlinePaymentActiveAndTypeOrder(Producer $producer): bool
     {
         return $this->isOnlinePaymentActive($producer)
             && $producer->option_online_payment_type == 'order';
     }
 
-    public function isBillingFrequencyMonthly(ProducerModel $producer): bool
+    public function isBillingFrequencyMonthly(Producer $producer): bool
     {
-        return $producer->option_billing_frequency == ProducerModel::BILLING_FREQUENCY_MONTHLY;
+        return $producer->option_billing_frequency == Producer::BILLING_FREQUENCY_MONTHLY;
     }
 
-    public function isBillingFrequencyQuarterly(ProducerModel $producer): bool
+    public function isBillingFrequencyQuarterly(Producer $producer): bool
     {
-        return $producer->option_billing_frequency == ProducerModel::BILLING_FREQUENCY_QUARTERLY;
+        return $producer->option_billing_frequency == Producer::BILLING_FREQUENCY_QUARTERLY;
     }
 
-    public function isBillingFrequencyBiannual(ProducerModel $producer): bool
+    public function isBillingFrequencyBiannual(Producer $producer): bool
     {
-        return $producer->option_billing_frequency == ProducerModel::BILLING_FREQUENCY_BIANNUAL;
+        return $producer->option_billing_frequency == Producer::BILLING_FREQUENCY_BIANNUAL;
     }
 
 }

common/logic/Producer/Producer/ProducerUtils.php

 
 class ProducerUtils extends BaseService implements UtilsInterface
 {
-    public function sendEmailNewProducer(ProducerModel $producer)
+    public function sendEmailNewProducer(Producer $producer)
     {
         \Yii::$app->mailer->compose(
             [

common/logic/Product/Product/ProductModel.php → common/logic/Product/Product/Product.php

 use common\helpers\Debug;
 use common\helpers\GlobalParam;
 use common\helpers\Price;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use Yii;
 use common\components\ActiveRecordCommon;
 
  * This is the model class for table "product".
  *
  */
-class ProductModel extends ActiveRecordCommon
+class Product extends ActiveRecordCommon
 {
     public $total = 0;
     public $apply_distributions = true;
     public function afterFind()
     {
         if ($this->taxRate == null) {
-            $producer = ProducerModel::searchOne(['id' => GlobalParam::getCurrentProducerId()]);
+            $producer = Producer::searchOne(['id' => GlobalParam::getCurrentProducerId()]);
             if ($producer) {
                 $this->populateRelation('taxRate', $producer->taxRate);
             }
         }
 
-        $this->wording_unit = ProductModel::strUnit($this->unit);
+        $this->wording_unit = Product::strUnit($this->unit);
         $this->price_with_tax = $this->getPriceWithTax();
 
         parent::afterFind();
 
     public function getTaxRate()
     {
-        return $this->hasOne(TaxRateModel::className(), ['id' => 'id_tax_rate']);
+        return $this->hasOne(TaxRate::className(), ['id' => 'id_tax_rate']);
     }
 
     public function getProductPrice()
      */
     public static function searchByDistribution($idDistribution)
     {
-        return ProductModel::find()
+        return Product::find()
             ->leftJoin('product_distribution', 'product.id = product_distribution.id_product')
             ->where([
                 'id_producer' => GlobalParam::getCurrentProducerId(),
      */
     public static function getProductGift()
     {
-        $productGift = ProductModel::find()
+        $productGift = Product::find()
             ->where([
                 'product.id_producer' => 0
             ])

common/logic/Product/Product/ProductContainer.php

 {
     public function getEntityFqcn(): string
     {
-        return ProductModel::class;
+        return Product::class;
     }
 
     public function getServices(): array

common/logic/Product/Product/ProductFactory.php

 
 class ProductFactory extends BaseService implements FactoryInterface
 {
-    public function create(): ProductModel
+    public function create(): Product
     {
-        $product = new ProductModel();
+        $product = new Product();
 
         return $product;
     }

common/logic/Product/Product/ProductSearch.php

 use common\helpers\GlobalParam;
 use yii\data\ActiveDataProvider;
 
-class ProductSearch extends ProductModel
+class ProductSearch extends Product
 {
     public function rules() 
     {
     {
         $optionsSearch = self::defaultOptionsSearch() ;
         
-        $query = ProductModel::find()
+        $query = Product::find()
             ->with($optionsSearch['with'])
             ->innerJoinWith($optionsSearch['join_with'], true)
             ->where(['product.id_producer' => GlobalParam::getCurrentProducerId()])

common/logic/Subscription/Subscription/SubscriptionModel.php

 namespace common\logic\Subscription\Subscription;
 
 use common\helpers\GlobalParam;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\logic\User\CreditHistory\CreditHistoryModel;
 use common\logic\User\UserProducer\UserProducerModel;
 use Yii;
     public function getProducer()
     {
         return $this->hasOne(
-            ProducerModel::class,
+            Producer::class,
             ['id' => 'id_producer']
         );
     }
 
                 $order->auto_payment = 0;
                 if($this->auto_payment == self::AUTO_PAYMENT_DEDUCTED) {
-                    if ($order->id_user && ProducerModel::getConfig('credit') && $pointSale->credit) {
-                        if ($creditFunctioning == ProducerModel::CREDIT_FUNCTIONING_OPTIONAL) {
+                    if ($order->id_user && Producer::getConfig('credit') && $pointSale->credit) {
+                        if ($creditFunctioning == Producer::CREDIT_FUNCTIONING_OPTIONAL) {
                             $order->auto_payment = 0;
-                        } elseif ($creditFunctioning == ProducerModel::CREDIT_FUNCTIONING_MANDATORY) {
+                        } elseif ($creditFunctioning == Producer::CREDIT_FUNCTIONING_MANDATORY) {
                             $order->auto_payment = 1;
-                        } elseif ($creditFunctioning == ProducerModel::CREDIT_FUNCTIONING_USER) {
+                        } elseif ($creditFunctioning == Producer::CREDIT_FUNCTIONING_USER) {
                             $user = UserModel::findOne($order->id_user);
                             $userProducer = UserProducerModel::searchOne([
                                 'id_user' => $order->id_user,
             ':id_subscription' => $this->id
         ];
 
-        $orderDeadline = ProducerModel::getConfig('order_deadline');
+        $orderDeadline = Producer::getConfig('order_deadline');
         $hour = date('G');
 
         if ($hour >= $orderDeadline) {
         $orders->params($params);
 
         $ordersArray = $orders->all();
-        $configCredit = ProducerModel::getConfig('credit');
+        $configCredit = Producer::getConfig('credit');
 
         $countOrdersDeleted = 0;
         if ($ordersArray && count($ordersArray)) {

common/logic/User/User/UserBuilder.php

 
 use common\logic\BaseService;
 use common\logic\BuilderInterface;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 
 class UserBuilder extends BaseService implements BuilderInterface
 {
         $user->generateAuthKey();
     }
 
-    public function initProducer(UserModel $user, ProducerModel $producer)
+    public function initProducer(UserModel $user, Producer $producer)
     {
         $user->id_producer = $producer->id;
         $user->status = UserModel::STATUS_PRODUCER;

common/logic/User/User/UserContainer.php

     {
         return [
             UserFactory::class,
+            UserSolver::class,
             UserRepository::class,
             UserBuilder::class,
             UserUtils::class,
         return new UserFactory();
     }
 
+    public function getSolver(): UserSolver
+    {
+        return new UserSolver();
+    }
+
     public function getRepository(): UserRepository
     {
         return new UserRepository();

common/logic/User/User/UserRepository.php

 
 use common\helpers\GlobalParam;
 use common\logic\BaseService;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\logic\RepositoryInterface;
 use common\logic\User\UserProducer\UserProducerRepository;
 use yii\db\Query;
      * Retourne le crédit de l'utilisateur pour un producteur donné.
      *
      */
-    public function getCredit(UserModel $user, ProducerModel $producer): float
+    public function getCredit(UserModel $user, Producer $producer): float
     {
         $userProducer = $this->userProducerRepository->getOne($user, $producer);
 

common/logic/User/User/UserUtils.php

 
 use common\helpers\GlobalParam;
 use common\logic\BaseService;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\logic\UtilsInterface;
 
 class UserUtils extends BaseService implements UtilsInterface
 {
-    public function sendEmailSignup(UserModel $user, ProducerModel $producer)
+    public function sendEmailSignup(UserModel $user, Producer $producer)
     {
         \Yii::$app->mailer->compose(
             [
     public function sendMailWelcome(UserModel $user, string $password): void
     {
         if (strlen($user->email)) {
-            $producer = ProducerModel::findOne(GlobalParam::getCurrentProducerId());
+            $producer = Producer::findOne(GlobalParam::getCurrentProducerId());
             \Yii::$app->mailer->compose();
             $mail = \Yii::$app->mailer->compose(
                 ['html' => 'createUserAdmin-html', 'text' => 'createUserAdmin-text'], ['user' => $user, 'producer' => $producer, 'password' => $password]

common/logic/User/UserProducer/UserProducerBuilder.php

 use common\logic\BaseService;
 use common\logic\BuilderInterface;
 use common\logic\Order\Order\OrderModel;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\logic\User\CreditHistory\CreditHistoryModel;
 use common\logic\User\CreditHistory\CreditHistorySolver;
 
 
     public function isCreditLimitCrossed($oldCredit, $newCredit)
     {
-        $creditLimitReminder = ProducerModel::getConfig('credit_limit_reminder');
+        $creditLimitReminder = Producer::getConfig('credit_limit_reminder');
 
         return !is_null($creditLimitReminder) &&
             $oldCredit > $creditLimitReminder

common/logic/User/UserProducer/UserProducerModel.php

 
 namespace common\logic\User\UserProducer;
 
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\logic\User\User\UserModel;
 use Yii;
 use common\components\ActiveRecordCommon;
 
     public function getProducer()
     {
-        return $this->hasOne(ProducerModel::class, ['id' => 'id_producer']);
+        return $this->hasOne(Producer::class, ['id' => 'id_producer']);
     }
 
     public function getUser()

common/logic/User/UserProducer/UserProducerRepository.php

 namespace common\logic\User\UserProducer;
 
 use common\logic\BaseService;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\logic\RepositoryInterface;
 use common\logic\User\User\UserModel;
 
 class UserProducerRepository extends BaseService implements RepositoryInterface
 {
-    public function getOne(UserModel $user, ProducerModel $producer)
+    public function getOne(UserModel $user, Producer $producer)
     {
         return UserProducerModel::searchOne([
             'id_user' => $user->id,

common/mail/orderConfirm-html.php

 
 use common\helpers\GlobalParam ;
 use yii\helpers\Html;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\models\Order;
 
 ?>
     <?php endif; ?>
     <?php if(strlen($pointSale->locality) > 0): ?> situé à <?= Html::encode($pointSale->locality) ?><?php endif ?>.</p>
 
-<?php $payment_infos = ProducerModel::getConfig('option_payment_info') ; ?>
+<?php $payment_infos = Producer::getConfig('option_payment_info') ; ?>
 <?php if($payment_infos && strlen($payment_infos) > 0): ?>
         <p><strong>Informations de paiement :</strong><br />
         <?= nl2br(Html::encode($payment_infos)); ?></p>
 <?php endif; ?>
 
-<?php $order_infos = ProducerModel::getConfig('order_infos') ; ?>
+<?php $order_infos = Producer::getConfig('order_infos') ; ?>
 <?php if($order_infos && strlen($order_infos) > 0): ?>
         <p><strong>Informations générales :</strong><br />
         <?= nl2br(Html::encode($order_infos)); ?></p>

common/mail/orderConfirm-text.php

  */
 
 use common\helpers\GlobalParam ;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 
 $producer = GlobalParam::getCurrentProducer() ;
 
 
 Elle sera à retirer le <?= date('d/m/Y',strtotime($distribution->date)) ?> au point de retrait <?= $pointSale->name ?> <?php if($order->pointSale->is_bread_box && $order->pointSale->bread_box_code): ?> (Code : <?= $order->pointSale->bread_box_code; ?>) <?php endif; ?> <?php if(strlen($pointSale->locality) > 0): ?> situé à <?= Html::encode($pointSale->locality) ?><?php endif ?>.
 
-<?php $payment_infos = ProducerModel::getConfig('option_payment_info') ; ?>
+<?php $payment_infos = Producer::getConfig('option_payment_info') ; ?>
 <?php if($payment_infos && strlen($payment_infos) > 0): ?>
         Informations de paiement :
         <?= $payment_infos ?>
 <?php endif; ?>
 
-<?php $order_infos = ProducerModel::getConfig('order_infos') ; ?>
+<?php $order_infos = Producer::getConfig('order_infos') ; ?>
 <?php if($order_infos && strlen($order_infos) > 0): ?>
         Informations générales :
         <?= $order_infos ?>

common/mail/paymentError-html.php

  */
 
 use yii\helpers\Html;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 
 ?>
 
 
 <p>Vous pouvez retrouver le lien de paiement dans votre <a href="<?= Yii::$app->urlManagerProducer->createAbsoluteUrl(['credit/history','slug_producer' => $producer->slug]) ?>">historique de commandes</a>.</p>
 
-<?php $payment_infos = ProducerModel::getConfig('option_payment_info') ; ?>
+<?php $payment_infos = Producer::getConfig('option_payment_info') ; ?>
 <?php if($payment_infos && strlen($payment_infos) > 0): ?>
     <p><strong>Informations de paiement :</strong><br />
         <?= nl2br(Html::encode($payment_infos)); ?></p>
 <?php endif; ?>
 
-<?php $order_infos = ProducerModel::getConfig('order_infos') ; ?>
+<?php $order_infos = Producer::getConfig('order_infos') ; ?>
 <?php if($order_infos && strlen($order_infos) > 0): ?>
     <p><strong>Informations générales :</strong><br />
         <?= nl2br(Html::encode($order_infos)); ?></p>

console/migrations/m190205_164612_ajout_produit_don_aux_distributions_existantes.php

 class m190205_164612_ajout_produit_don_aux_distributions_existantes extends Migration {
 
     public function up() {
-        $distributionsArray = common\logic\Distribution\Distribution\DistributionModel::find()->all() ;
+        $distributionsArray = common\logic\Distribution\Distribution\Distribution::find()->all() ;
         foreach($distributionsArray as $distribution) {
-            $distribution->linkProductGift() ;
+
         }
     }
 

console/migrations/m190226_084104_lien_utilisateur_point_de_vente.php

 
 use yii\db\Migration;
 
-use common\logic\Producer\Producer\ProducerModel;
-use common\logic\PointSale\PointSale\PointSaleModel;
+use common\logic\Producer\Producer\Producer;
+use common\logic\PointSale\PointSale\PointSale;
 use common\logic\PointSale\UserPointSale\UserPointSaleModel;
 
 class m190226_084104_lien_utilisateur_point_de_vente extends Migration
 {
     public function up()
     {
-        $producersArray = ProducerModel::find()->all() ;
+        $producersArray = Producer::find()->all() ;
         
         foreach($producersArray as $producer) {
-            $pointsSaleArray = PointSaleModel::find()
+            $pointsSaleArray = PointSale::find()
                 ->where([
                     'id_producer' => $producer->id
                 ])

console/migrations/m190515_122438_ajout_champs_price_product_subscription.php

 use yii\db\Migration;
 use yii\db\mysql\Schema;
 use common\logic\Subscription\ProductSubscription\ProductSubscriptionModel;
-use common\logic\Product\Product\ProductModel;
+use common\logic\Product\Product\Product;
 
 class m190515_122438_ajout_champs_price_product_subscription extends Migration {
 
         $this->addColumn('product_subscription', 'price', Schema::TYPE_FLOAT. ' DEFAULT 0') ;
         
         $productsSubscriptionsArray = ProductSubscriptionModel::find()->all() ;
-        $productsArray = ProductModel::find()->all() ;
+        $productsArray = Product::find()->all() ;
         
         foreach($productsSubscriptionsArray as $productSubscription) {
             foreach($productsArray as $product) {

console/migrations/m190522_091006_option_comportement_annulation_commande.php

 
 use yii\db\Migration;
 use yii\db\mysql\Schema;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 
 class m190522_091006_option_comportement_annulation_commande extends Migration {
 
     public function up() {
-        $this->addColumn('producer', 'option_behavior_cancel_order', Schema::TYPE_STRING.' DEFAULT \''.ProducerModel::BEHAVIOR_DELETE_ORDER_STATUS.'\'') ;
+        $this->addColumn('producer', 'option_behavior_cancel_order', Schema::TYPE_STRING.' DEFAULT \''.Producer::BEHAVIOR_DELETE_ORDER_STATUS.'\'') ;
     }
 
     public function down() {

console/migrations/m200601_073309_add_producer_options.php

 
 use yii\db\Migration;
 use yii\db\Schema;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 
 class m200601_073309_add_producer_options extends Migration
 {
         public function safeUp()
         {
-                $this->addColumn('producer', 'behavior_home_point_sale_day_list', Schema::TYPE_STRING.' DEFAULT \''.ProducerModel::BEHAVIOR_HOME_POINT_SALE_DAY_LIST_WEEK.'\'');
-                $this->addColumn('producer', 'behavior_order_select_distribution', Schema::TYPE_STRING.' DEFAULT \''.ProducerModel::BEHAVIOR_ORDER_SELECT_DISTRIBUTION_CALENDAR.'\'');
+                $this->addColumn('producer', 'behavior_home_point_sale_day_list', Schema::TYPE_STRING.' DEFAULT \''.Producer::BEHAVIOR_HOME_POINT_SALE_DAY_LIST_WEEK.'\'');
+                $this->addColumn('producer', 'behavior_order_select_distribution', Schema::TYPE_STRING.' DEFAULT \''.Producer::BEHAVIOR_ORDER_SELECT_DISTRIBUTION_CALENDAR.'\'');
         }
 
         public function safeDown()

console/migrations/m220915_072309_producer_add_option_billing_frequency.php

 
 use yii\db\Migration;
 use yii\db\Schema;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 
 /**
  * Class m220915_072309_producer_add_option_billing_frequency
      */
     public function safeUp()
     {
-        $this->addColumn('producer', 'option_billing_frequency', Schema::TYPE_STRING.' DEFAULT \''.ProducerModel::BILLING_FREQUENCY_MONTHLY.'\'');
+        $this->addColumn('producer', 'option_billing_frequency', Schema::TYPE_STRING.' DEFAULT \''.Producer::BILLING_FREQUENCY_MONTHLY.'\'');
     }
 
     /**

console/migrations/m220915_083713_producer_add_options_billing.php

 
 use yii\db\Migration;
 use yii\db\Schema;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 
 /**
  * Class m220915_083713_producer_add_options_billing
      */
     public function safeUp()
     {
-        $this->addColumn('producer', 'option_billing_type', Schema::TYPE_STRING.' DEFAULT \''.ProducerModel::BILLING_TYPE_CLASSIC.'\'');
+        $this->addColumn('producer', 'option_billing_type', Schema::TYPE_STRING.' DEFAULT \''.Producer::BILLING_TYPE_CLASSIC.'\'');
         $this->addColumn('producer', 'option_billing_reduction', Schema::TYPE_BOOLEAN.' DEFAULT 0');
     }
 

frontend/forms/SignupForm.php

 
 namespace frontend\forms;
 
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\logic\User\User\UserModel;
-use common\logic\Config\TaxRate\TaxRateModel;
+use common\logic\Config\TaxRate\TaxRate;
 use yii\base\Model;
 
 /**
             ['id_producer', 'integer'],
             ['id_producer', function ($attribute, $params) {
                 if ($this->id_producer) {
-                    $producer = ProducerModel::findOne($this->id_producer);
+                    $producer = Producer::findOne($this->id_producer);
                     if (!$producer) {
                         $this->addError($attribute, 'Ce producteur n\'existe pas.');
                     }
                 return $this->option_user_producer == 'user';
             }],
             ['code', 'required', 'message' => 'Champs obligatoire', 'when' => function ($model) {
-                $producer = ProducerModel::findOne($this->id_producer);
+                $producer = Producer::findOne($this->id_producer);
                 if ($producer) {
                     return strlen($producer->code);
                 } else {
             }],
             ['code', function ($attribute, $params) {
                 $code = $this->$attribute;
-                $producer = ProducerModel::findOne($this->id_producer);
+                $producer = Producer::findOne($this->id_producer);
 
                 if ($producer && strtolower(trim($code)) != strtolower(trim($producer->code))) {
                     $this->addError($attribute, 'Code incorrect');
             }],
 //            ['free_price', 'number'],
             ['id_tax_rate_default', 'exist',
-                'targetClass' => TaxRateModel::className(),
+                'targetClass' => TaxRate::className(),
                 'targetAttribute' => ['id_tax_rate_default' => 'id']],
             ['verifyCode', 'captcha', 'message' => 'Veuillez recopier le code de vérification'],
         ];

frontend/views/layouts/main.php

 use yii\widgets\Breadcrumbs;
 use common\widgets\Alert;
 use common\helpers\Url;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\logic\User\User\UserModel;
 
 /* @var $this \yii\web\View */
 
 $producer = null;
 if (!Yii::$app->user->isGuest && \Yii::$app->user->identity->id_producer > 0) {
-    $producer = ProducerModel::searchOne(['id' => \Yii::$app->user->identity->id_producer]);
+    $producer = Producer::searchOne(['id' => \Yii::$app->user->identity->id_producer]);
 }
 
 ?>
         <div class="container">
             <?php
 
-            $producersArray = ProducerModel::find()
+            $producersArray = Producer::find()
                 ->joinWith(['userProducer user_producer'])
                 ->where([
                     'user_producer.id_user' => UserModel::getCurrentId(),

frontend/views/site/signup.php

                         <?= $form->field($model, 'postcode') ?>
                         <?= $form->field($model, 'city') ?>
                         <?= $form->field($model, 'id_tax_rate_default')
-                                ->dropDownList(ArrayHelper::map(TaxRateModel::find()->all(), 'id', function($model) { return $model->name; }), [
+                                ->dropDownList(ArrayHelper::map(TaxRate::find()->all(), 'id', function($model) { return $model->name; }), [
                                     'prompt' => '--',
                                 ])
                                 ->label('TVA à appliquer par défaut'); ?>

producer/controllers/OrderController.php

 namespace producer\controllers;
 
 use common\helpers\Mailjet;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\logic\User\CreditHistory\CreditHistoryModel;
 use common\logic\User\User\UserModel;
 use common\logic\User\UserProducer\UserProducerModel;
      */
     public function _verifyProducerActive($idProducer)
     {
-        $producer = ProducerModel::findOne($idProducer);
+        $producer = Producer::findOne($idProducer);
         if ($producer && !$producer->active) {
             throw new NotFoundHttpException('Ce producteur est actuellement hors ligne.');
         }
             $order->changeOrderStatus('new-order', 'user');
 
             // ajout de l'utilisateur à l'établissement
-            ProducerModel::addUser($user->id, $distribution->id_producer);
+            Producer::addUser($user->id, $distribution->id_producer);
 
             // suppression de tous les enregistrements ProductOrder
             if (!is_null($order)) {
             $pointSale->linkUser($user->id);
 
             // credit
-            $credit = ProducerModel::getConfig('credit');
-            $creditLimit = ProducerModel::getConfig('credit_limit');
+            $credit = Producer::getConfig('credit');
+            $creditLimit = Producer::getConfig('credit_limit');
             $creditFunctioning = $pointSale->getCreditFunctioning();
             $creditUser = $user->getCredit($distribution->id_producer);
             $order = OrderModel::searchOne([
             $amountRemaining = $order->getAmount(OrderModel::AMOUNT_REMAINING);
 
             if ($credit && $pointSale->credit &&
-                    (($creditFunctioning == ProducerModel::CREDIT_FUNCTIONING_OPTIONAL && $posts['use_credit']) ||
-                            $creditFunctioning == ProducerModel::CREDIT_FUNCTIONING_MANDATORY ||
-                            ($creditFunctioning == ProducerModel::CREDIT_FUNCTIONING_USER && $userProducer->credit_active)
+                    (($creditFunctioning == Producer::CREDIT_FUNCTIONING_OPTIONAL && $posts['use_credit']) ||
+                            $creditFunctioning == Producer::CREDIT_FUNCTIONING_MANDATORY ||
+                            ($creditFunctioning == Producer::CREDIT_FUNCTIONING_USER && $userProducer->credit_active)
                     )) {
                 $order->changeOrderStatus('waiting-paiement-by-credit', 'user');
 
              */
             if ($isNewOrder) {
                 // au client
-                if (ProducerModel::getConfig('option_email_confirm')) {
+                if (Producer::getConfig('option_email_confirm')) {
                     Mailjet::sendMail($paramsEmail);
                 }
 
                 // au producteur
                 $contactProducer = $producer->getMainContact();
-                if (ProducerModel::getConfig('option_email_confirm_producer') && $contactProducer && strlen(
+                if (Producer::getConfig('option_email_confirm_producer') && $contactProducer && strlen(
                                 $contactProducer->email
                         )) {
                     $paramsEmail['to_email'] = $contactProducer->email;
         $orderUser = $this->_getOrderUser($date, $pointSaleId);
 
         // Producteur
-        $producer = ProducerModel::searchOne([
+        $producer = Producer::searchOne([
                                                 'id' => $this->getProducer()->id
                                         ]);
         $json['producer'] = [
         $distributionsArray = DistributionModel::filterDistributionsByDateDelay($distributionsArray);
 
         // Filtre par point de vente
-        if ($pointSaleId && $producer->option_order_entry_point == ProducerModel::ORDER_ENTRY_POINT_POINT_SALE) {
+        if ($pointSaleId && $producer->option_order_entry_point == Producer::ORDER_ENTRY_POINT_POINT_SALE) {
             $distributionsArrayFilterPointSale = [];
             for ($i = 0; $i < count($distributionsArray); $i++) {
                 $distribution = $distributionsArray[$i];
                     ':date' => $dateMini
             ];
 
-            if ($pointSaleId && $producer->option_order_entry_point == ProducerModel::ORDER_ENTRY_POINT_POINT_SALE) {
+            if ($pointSaleId && $producer->option_order_entry_point == Producer::ORDER_ENTRY_POINT_POINT_SALE) {
                 $conditionsOrdersUser[] = 'order.id_point_sale = :id_point_sale';
                 $paramsOrdersUser[':id_point_sale'] = $pointSaleId;
             }
                                                 ]);
 
         if($user && !$userProducer) {
-            $userProducer = ProducerModel::addUser($user->id, $producer->id);
+            $userProducer = Producer::addUser($user->id, $producer->id);
         }
 
         $json['user'] = false;
                 ->orderBy('code ASC, restricted_access ASC, is_bread_box ASC, `default` DESC, name ASC')
                 ->all();
 
-        $creditFunctioningProducer = ProducerModel::getConfig('credit_functioning');
+        $creditFunctioningProducer = Producer::getConfig('credit_functioning');
         $position = 0;
 
         foreach ($pointsSaleArray as &$pointSale) {

producer/controllers/ProducerBaseController.php

 namespace producer\controllers;
 
 use common\controllers\CommonController;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use common\logic\User\User\UserModel;
 use common\logic\User\UserProducer\UserProducerModel;
 
             return $this->producer ;
         }
         else {
-            $producer = ProducerModel::find()
+            $producer = Producer::find()
                 ->with('contact')
                 ->where(['slug' => \Yii::$app->getRequest()->getQueryParam('slug_producer')])
                 ->one() ;

producer/models/CreditForm.php

 
 namespace producer\models;
 
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 use Yii;
 use yii\base\Model;
 
     {
         return [
             [['amount'], 'required'],
-            [['amount'], 'double', 'min' => ProducerModel::getOnlinePaymentMinimumAmount()],
+            [['amount'], 'double', 'min' => Producer::getOnlinePaymentMinimumAmount()],
         ];
     }
 

producer/views/credit/add.php

 
 use yii\helpers\Html;
 use yii\widgets\ActiveForm;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 
 $this->setTitle('Créditer mon compte');
 $this->setPageTitle('Crédit mon compte');
             'template' => '{label}<div class="input-group input-group-lg">{input}<span class="input-group-addon"><span class="glyphicon glyphicon-euro"></span></span></div>{hint}',
     ])
             ->label('Quel montant souhaitez-vous créditer ?')
-            ->hint('Montant minimum : '.ProducerModel::getOnlinePaymentMinimumAmount().' €'); ?>
+            ->hint('Montant minimum : '.Producer::getOnlinePaymentMinimumAmount().' €'); ?>
 
     <div class="form-group">
         <?= Html::submitButton('<span class="glyphicon glyphicon-lock"></span> Payer', ['class' => 'btn btn-primary']

producer/views/order/_form.php

 */
 
 use yii\widgets\ActiveForm;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 
 ?>
 <div class="order-form">
 
     <?php if($idProducer): ?>
     <?php
-        $producer = ProducerModel::findOne($idProducer);
+        $producer = Producer::findOne($idProducer);
     ?>
     <div id="bar-fixed" class="<?php if($producer->credit): ?>credit<?php else: ?>no-credit<?php endif; ?>">
         <div class="container">

producer/views/order/order.php

 */
 
 use common\helpers\GlobalParam ;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 
 \producer\assets\VuejsOrderOrderAsset::register($this);
 
         <div>
             <div id="steps">
                 <ul>
-                    <?php if($producer->option_order_entry_point == ProducerModel::ORDER_ENTRY_POINT_DATE): ?>
+                    <?php if($producer->option_order_entry_point == Producer::ORDER_ENTRY_POINT_DATE): ?>
                         <step-date
                                 first="true"
                                 :step="step"
                             Chargement ...
                         </div>
                         <div v-else>
-                            <?php if($producer->behavior_order_select_distribution == ProducerModel::BEHAVIOR_ORDER_SELECT_DISTRIBUTION_LIST ): ?>
+                            <?php if($producer->behavior_order_select_distribution == Producer::BEHAVIOR_ORDER_SELECT_DISTRIBUTION_LIST ): ?>
                                 <div style="display:none ;">
                             <?php endif; ?>
                             <div id="legend">
                                         @dayclick='dayClick'
                                 ></v-calendar>
                             </div>
-                            <?php if($producer->behavior_order_select_distribution == ProducerModel::BEHAVIOR_ORDER_SELECT_DISTRIBUTION_LIST ): ?>
+                            <?php if($producer->behavior_order_select_distribution == Producer::BEHAVIOR_ORDER_SELECT_DISTRIBUTION_LIST ): ?>
                                 </div>
                             <?php endif; ?>
 
-                            <?php if($producer->behavior_order_select_distribution == ProducerModel::BEHAVIOR_ORDER_SELECT_DISTRIBUTION_LIST ): ?>
+                            <?php if($producer->behavior_order_select_distribution == Producer::BEHAVIOR_ORDER_SELECT_DISTRIBUTION_LIST ): ?>
                                     <div id="distributions-list">
                                         <?php $incomingDistributions = DistributionModel::getIncomingDistributions(); ?>
                                         <?php foreach($incomingDistributions as $distribution): ?>

producer/views/site/index.php

 termes.
 */
 
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 
 $producer = $this->context->getProducer() ;
 $this->setTitle('Accueil');
 
                         $producer = \Yii::$app->controller->getProducer() ;
 
-                        if($producer->behavior_home_point_sale_day_list == ProducerModel::BEHAVIOR_HOME_POINT_SALE_DAY_LIST_WEEK) {
+                        if($producer->behavior_home_point_sale_day_list == Producer::BEHAVIOR_HOME_POINT_SALE_DAY_LIST_WEEK) {
                                 $arrayDays = [
                                     'monday' => 'Lundi',
                                     'tuesday' => 'Mardi',
 
                                 return $html  ;
                         }
-                        elseif($producer->behavior_home_point_sale_day_list == ProducerModel::BEHAVIOR_HOME_POINT_SALE_DAY_LIST_INCOMING_DISTRIBUTIONS) {
+                        elseif($producer->behavior_home_point_sale_day_list == Producer::BEHAVIOR_HOME_POINT_SALE_DAY_LIST_INCOMING_DISTRIBUTIONS) {
                                 $html = '' ;
                                 $incomingDistributions = DistributionModel::getIncomingDistributions();
                                 $cpt = 0 ;

producer/views/subscription/_form.php

 termes.
 */
 
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 
 \producer\assets\VuejsSubscriptionFormAsset::register($this) ;
 
     
     <h3><span>Paiement</span></h3>
 
-    <?php if(ProducerModel::getConfig('credit')): ?>
+    <?php if(Producer::getConfig('credit')): ?>
     <div class="form-group field-subscriptionform-auto_payment">
         <label><input type="checkbox" id="subscriptionform-auto_payment" name="SubscriptionForm[auto_payment]" v-model="autoPayment"> Paiement automatique</label> 
         <div class="hint-block">Cochez cette case si vous souhaitez que votre Crédit soit automatiquement débité.</div> 

producer/views/subscription/index.php

 use yii\helpers\Html;
 use yii\grid\GridView;
 use common\helpers\GlobalParam;
-use common\logic\Producer\Producer\ProducerModel;
+use common\logic\Producer\Producer\Producer;
 
 $this->setTitle('Abonnements') ;
 $this->addButton(['label' => '<span class="glyphicon glyphicon-plus"></span> Ajouter', 'url' => 'subscription/form', 'class' => 'btn btn-primary']) ;
     ],
 ] ;
     
-if(ProducerModel::getConfig('credit')) {
+if(Producer::getConfig('credit')) {
     $columns[] = [
         'format' => 'raw',
         'label' => 'Paiement automatique',