Refactoring services #885

backend/controllers/AccessController.php

 
 use common\helpers\GlobalParam;
 use common\models\Producer ;
-use common\models\UserModel ;
-use common\models\UserModelSearch ;
+use common\models\ User ;
+use common\models\ UserSearch ;
 use backend\models\AccessUserProducerForm ;
 
 /**
                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::hasAccessBackend();
+                            return  User::hasAccessBackend();
                         }
                     ]
                 ],
      */
     public function actionIndex() 
     {
-        $userSearch = new UserModelSearch ;
+        $userSearch = new  UserSearch ;
         $usersArray = $userSearch->search()->query->all() ;
         
         $modelAccessUserProducerForm = new AccessUserProducerForm ;
             Yii::$app->getSession()->setFlash('success', 'Droits ajoutés à l\'utilisateur');
         }
         
-        $usersAccessArray = UserModel::find()
+        $usersAccessArray =  User::find()
             ->where([
                 'id_producer' => GlobalParam::getCurrentProducerId(),
-                'status' => UserModel::STATUS_PRODUCER
+                'status' =>  User::STATUS_PRODUCER
             ])
             ->all() ;
         
-        $producer = ProducerModel::searchOne() ;
+        $producer = Producer::searchOne() ;
 
         return $this->render('index', [
             'usersArray' => $usersArray,
      */
     public function actionDelete($idUser) 
     {
-        $user = UserModel::searchOne([
+        $user =  User::searchOne([
             'id' => $idUser
         ]) ;
         
         if($user) {
             $user->id_producer = 0 ;
-            $user->status = UserModel::STATUS_ACTIVE ;
+            $user->status =  User::STATUS_ACTIVE ;
             $user->save() ;
             Yii::$app->getSession()->setFlash('success', 'Droits de l\'utilisateur supprimé.');
         }

backend/controllers/CommunicateAdminController.php

 
 use backend\models\MailForm ;
 use yii\web\NotFoundHttpException ;
-use common\models\UserModel ;
+use common\models\ User ;
 
 /**
  * UserController implements the CRUD actions for User model.
                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::getCurrentStatus() == UserModel::STATUS_ADMIN;
+                            return  User::getCurrentStatus() ==  User::STATUS_ADMIN;
                         }
                     ]
                 ],
     public function actionIndex($section = 'producers') 
     {
         if($section == 'producers') {
-            $producers = ProducerModel::find()->where(['producer.active' => 1])->with(['contact'])->all() ;
+            $producers = Producer::find()->where(['producer.active' => 1])->with(['contact'])->all() ;
             $usersArray = [];
             $users = [] ;
             foreach ($producers as $producer) {
             }
         }
         elseif($section == 'users') {
-            $users = UserModel::find()
+            $users =  User::find()
                 ->where([
-                    'user.status' => UserModel::STATUS_ACTIVE
+                    'user.status' =>  User::STATUS_ACTIVE
                 ])
                 ->all() ;
             $usersArray = [];

backend/controllers/CommunicateController.php

                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::hasAccessBackend();
+                            return  User::hasAccessBackend();
                         }
                     ]
                 ],
      */
     public function actionIndex() 
     {
-        $producer = ProducerModel::searchOne() ;
-        $pointsSaleArray = PointSaleModel::searchAll() ; 
+        $producer = Producer::searchOne() ;
+        $pointsSaleArray = PointSale::searchAll() ; 
         
         return $this->render('index', [
             'producer' => $producer,
      */
     public function actionInstructions() 
     {
-        $producer = ProducerModel::searchOne() ;
+        $producer = Producer::searchOne() ;
 
         // get your HTML raw content without any layouts or scripts
         $content = $this->renderPartial('instructions_multi', [

backend/controllers/CronController.php

                 $dateTime = strtotime("+7 day");
                 $dayStr = strtolower(date('l', $dateTime));
                 $fieldDeliveryDay = 'delivery_' . $dayStr;
-                $pointsSaleArray = PointSaleModel::searchAll(['point_sale.id_producer' => $producer->id]);
+                $pointsSaleArray = PointSale::searchAll(['point_sale.id_producer' => $producer->id]);
                 $activeDistribution = false;
                 foreach ($pointsSaleArray as $pointSale) {
                     if ($pointSale->$fieldDeliveryDay) {
                 }
             }
 
-            $arrayProducers = ProducerModel::searchAll();
+            $arrayProducers = Producer::searchAll();
 
             foreach ($arrayProducers as $producer) {
                 $countOrders = 0;
                          * Paiement des commandes (paiement automatique)
                          */
 
-                        $arrayOrders = OrderModel::searchAll([
+                        $arrayOrders = Order::searchAll([
                                                                 'distribution.date' => $date,
                                                                 'distribution.id_producer' => $producer->id
                                                         ], [
                                                                 'conditions' => 'date_delete IS NULL'
                                                         ]);
 
-                        $configCredit = ProducerModel::getConfig('credit', $producer->id);
+                        $configCredit = Producer::getConfig('credit', $producer->id);
 
                         if ($arrayOrders && is_array($arrayOrders)) {
                             foreach ($arrayOrders as $order) {
                                 if ($order->auto_payment && $configCredit) {
-                                    if ($order->getAmount(OrderModel::AMOUNT_REMAINING) > 0) {
+                                    if ($order->getAmount(Order::AMOUNT_REMAINING) > 0) {
                                         $order->saveCreditHistory(
-                                                CreditHistoryModel::TYPE_PAYMENT,
-                                                $order->getAmount(OrderModel::AMOUNT_REMAINING),
+                                                 CreditHistory::TYPE_PAYMENT,
+                                                $order->getAmount(Order::AMOUNT_REMAINING),
                                                 $order->distribution->id_producer,
                                                 $order->id_user,
-                                                UserModel::ID_USER_SYSTEM
+                                                 User::ID_USER_SYSTEM
                                         );
                                         $countOrders++;
                                     }
                          * Envoi des commandes par email au producteur
                          */
 
-                        if (!strlen($forceDate) && ProducerModel::getConfig('option_notify_producer_order_summary', $producer->id)) {
-                            $arrayOrders = OrderModel::searchAll([
+                        if (!strlen($forceDate) && Producer::getConfig('option_notify_producer_order_summary', $producer->id)) {
+                            $arrayOrders = Order::searchAll([
                                                                     'distribution.date' => $date,
                                                                     'distribution.id_producer' => $producer->id
                                                             ], [
                             $mail->setSubject($subject);
 
                             // envoi des emails à tous les comptes users (statut producer) associés à ce producteur
-                            $userArray = UserModel::searchAll([
+                            $userArray =  User::searchAll([
                                                                  'id_producer' => $producer->id,
-                                                                 'status' => UserModel::STATUS_PRODUCER
+                                                                 'status' =>  User::STATUS_PRODUCER
                                                          ]);
 
                             foreach ($userArray as $user) {

backend/controllers/DeliveryNoteController.php

                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::hasAccessBackend();
+                            return  User::hasAccessBackend();
                         }
                     ]
                 ],

backend/controllers/DevelopmentController.php

                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::hasAccessBackend() ;
+                            return  User::hasAccessBackend() ;
                         }
                     ]
                 ],

backend/controllers/DistributionController.php

 use common\models\Producer;
 use common\models\Order;
 use common\models\ProductCategory;
-use common\models\UserModel;
+use common\models\ User;
 use common\models\Subscription;
 use common\helpers\Price;
 use common\models\PointSaleDistribution;
-use common\logic\UserProducer\UserProducerModel;
+use common\logic\UserProducer\ UserProducer;
 use DateTime;
 
 class DistributionController extends BackendController
                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::getCurrentStatus() == UserModel::STATUS_ADMIN
-                                || UserModel::getCurrentStatus() == UserModel::STATUS_PRODUCER;
+                            return  User::getCurrentStatus() ==  User::STATUS_ADMIN
+                                ||  User::getCurrentStatus() ==  User::STATUS_PRODUCER;
                         }
                     ]
                 ],
 
         $orderUpdate = null;
         if ($idOrderUpdate) {
-            $orderUpdate = OrderModel::searchOne(['id' => $idOrderUpdate]);
+            $orderUpdate = Order::searchOne(['id' => $idOrderUpdate]);
         }
 
         return $this->render('index', [
             ];
 
             // commandes
-            $ordersArray = OrderModel::searchAll([
+            $ordersArray = Order::searchAll([
                 'distribution.id' => $distribution->id,
             ], [
                 'orderby' => 'user.lastname ASC, user.name ASC'
             $json['distribution']['weight'] = number_format($weight, 2);
 
             // products
-            $productsQuery = ProductModel::find()
+            $productsQuery =  Product::find()
                 ->orWhere(['id_producer' => GlobalParam::getCurrentProducerId(),])
                 ->joinWith([
                     'taxRate',
             $potentialWeight = 0;
 
             foreach ($productsArray as &$theProduct) {
-                $quantityOrder = OrderModel::getProductQuantity($theProduct['id'], $ordersArray);
+                $quantityOrder = Order::getProductQuantity($theProduct['id'], $ordersArray);
                 $theProduct['quantity_ordered'] = $quantityOrder;
 
                 if (!isset($theProduct['productDistribution'][0])) {
                     $productOrderArray = [];
                     foreach ($order->productOrder as $productOrder) {
                         $productOrderArray[$productOrder->id_product] = [
-                            'quantity' => $productOrder->quantity * ProductModel::$unitsArray[$productOrder->unit]['coefficient'],
+                            'quantity' => $productOrder->quantity *  Product::$unitsArray[$productOrder->unit]['coefficient'],
                             'unit' => $productOrder->unit,
                             'price' => number_format($productOrder->price, 3),
                             'invoice_price' => number_format($productOrder->invoice_price, 2),
                             'wording' => $creditHistoryService->getStrWording($creditHistory),
                             'debit' => ($creditHistoryService->isTypeDebit($creditHistory) ? '- ' . $creditHistoryService->getAmount(
                                     $creditHistory,
-                                    OrderModel::AMOUNT_TOTAL,
+                                    Order::AMOUNT_TOTAL,
                                     true
                                 ) : ''),
                             'credit' => ($creditHistoryService->isTypeCredit($creditHistory) ? '+ ' . $creditHistoryService->getAmount(
                                     $creditHistory,
-                                    OrderModel::AMOUNT_TOTAL,
+                                    Order::AMOUNT_TOTAL,
                                     true
                                 ) : '')
                         ];
                     $order = array_merge($order->getAttributes(), [
                         'selected' => false,
                         'weight' => $order->weight,
-                        'amount' => Price::numberTwoDecimals($order->getAmountWithTax(OrderModel::AMOUNT_TOTAL)),
-                        'amount_paid' => Price::numberTwoDecimals($order->getAmount(OrderModel::AMOUNT_PAID)),
-                        'amount_remaining' => Price::numberTwoDecimals($order->getAmount(OrderModel::AMOUNT_REMAINING)),
-                        'amount_surplus' => Price::numberTwoDecimals($order->getAmount(OrderModel::AMOUNT_SURPLUS)),
+                        'amount' => Price::numberTwoDecimals($order->getAmountWithTax(Order::AMOUNT_TOTAL)),
+                        'amount_paid' => Price::numberTwoDecimals($order->getAmount(Order::AMOUNT_PAID)),
+                        'amount_remaining' => Price::numberTwoDecimals($order->getAmount(Order::AMOUNT_REMAINING)),
+                        'amount_surplus' => Price::numberTwoDecimals($order->getAmount(Order::AMOUNT_SURPLUS)),
                         'user' => (isset($order->user)) ? array_merge(
                             $order->user->getAttributes(),
                             $arrayCreditUser
             $json['orders'] = $ordersArray;
 
             // points de vente
-            $pointsSaleArray = PointSaleModel::find()
+            $pointsSaleArray = PointSale::find()
                 ->joinWith([
                     'pointSaleDistribution' => function ($q) use ($distribution) {
                         $q->where(['id_distribution' => $distribution->id]);
             $json['points_sale'] = $pointsSaleArray;
 
             // bons de livraison
-            $deliveryNotesArray = DeliveryNoteModel::searchAll([
+            $deliveryNotesArray = DeliveryNote::searchAll([
                 'distribution.date' => $date,
             ], [
                 'join_with' => ['user AS user_delivery_note', 'orders', 'producer']
             ];
 
             // utilisateurs
-            $usersArray = UserModel::findBy()->all();
+            $usersArray =  User::findBy()->all();
 
             $json['users'] = $usersArray;
 
             }
 
             // abonnements manquants
-            $arraySubscriptions = SubscriptionModel::searchByDate($date);
+            $arraySubscriptions =  Subscription::searchByDate($date);
             $json['missing_subscriptions'] = [];
             if ($distribution->active) {
                 foreach ($arraySubscriptions as $subscription) {
     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
 
-        $user = UserModel::findOne(['id' => $idUser]);
+        $user =  User::findOne(['id' => $idUser]);
         $favoritePointSale = $user->getFavoritePointSale();
         $idFavoritePointSale = 0;
         if ($favoritePointSale) {
     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
 
-        $order = OrderModel::searchOne(['id' => $idOrder]);
+        $order = Order::searchOne(['id' => $idOrder]);
         $distribution = DistributionModel::findOne($idDistribution);
-        $user = UserModel::findOne($idUser);
-        $pointSale = PointSaleModel::findOne($idPointSale);
+        $user =  User::findOne($idUser);
+        $pointSale = PointSale::findOne($idPointSale);
 
-        $productsArray = ProductModel::find()
+        $productsArray =  Product::find()
             ->where([
                 'id_producer' => GlobalParam::getCurrentProducerId(),
             ])->joinWith([
             $productOrderArray[$product['id']] = [
                 'quantity' => $quantity,
                 'unit' => $product->unit,
-                'unit_coefficient' => ProductModel::$unitsArray[$product->unit]['coefficient'],
+                'unit_coefficient' =>  Product::$unitsArray[$product->unit]['coefficient'],
                 'prices' => $priceArray,
                 'active' => $product->productDistribution[0]->active
                     && (!$pointSale || $product->isAvailableOnPointSale($pointSale)),
 
     public function actionAjaxUpdateInvoicePrices($idOrder)
     {
-        $order = OrderModel::searchOne([
+        $order = Order::searchOne([
             'id' => (int)$idOrder
         ]);
 
         if ($order && $order->distribution->id_producer == GlobalParam::getCurrentProducerId()) {
             $userProducer = null;
             if ($order->id_user) {
-                $userProducer = UserProducerModel::searchOne([
+                $userProducer =  UserProducer::searchOne([
                     'id_user' => $order->id_user,
                     'id_producer' => GlobalParam::getCurrentProducerId()
                 ]);
             $idProducer = GlobalParam::getCurrentProducerId();
         }
 
-        $ordersArray = OrderModel::searchAll(
+        $ordersArray = Order::searchAll(
             [
                 'distribution.date' => $date,
                 'distribution.id_producer' => $idProducer
 
         if ($distribution) {
             $selectedProductsArray = ProductDistributionModel::searchByDistribution($distribution->id);
-            $pointsSaleArray = PointSaleModel::searchAll([
+            $pointsSaleArray = PointSale::searchAll([
                 'point_sale.id_producer' => $idProducer
             ]);
 
             }
 
             // produits
-            $productsArray = ProductModel::find()
+            $productsArray =  Product::find()
                 ->joinWith([
                     'productDistribution' => function ($q) use ($distribution) {
                         $q->where(['id_distribution' => $distribution->id]);
                     'pointsSaleArray' => $pointsSaleArray,
                     'productsArray' => $productsArray,
                     'ordersArray' => $ordersArray,
-                    'producer' => ProducerModel::searchOne(['id' => $idProducer])
+                    'producer' => Producer::searchOne(['id' => $idProducer])
                 ]);
 
                 $dateStr = date('d/m/Y', strtotime($date));
             } elseif ($type == 'csv') {
                 $datas = [];
 
-                $optionCsvExportAllProducts = ProducerModel::getConfig('option_csv_export_all_products');
-                $optionCsvExportByPiece = ProducerModel::getConfig('option_csv_export_by_piece');
+                $optionCsvExportAllProducts = Producer::getConfig('option_csv_export_all_products');
+                $optionCsvExportByPiece = Producer::getConfig('option_csv_export_by_piece');
 
                 // produits en colonne
                 $productsNameArray = ['', 'Commentaire'];
                 $cpt = 2;
                 foreach ($productsArray as $product) {
                     $productsHasQuantity[$product->id] = 0;
-                    foreach (ProductModel::$unitsArray as $unit => $dataUnit) {
-                        $quantity = OrderModel::getProductQuantity($product->id, $ordersArray, true, $unit);
+                    foreach ( Product::$unitsArray as $unit => $dataUnit) {
+                        $quantity = Order::getProductQuantity($product->id, $ordersArray, true, $unit);
                         if ($quantity) {
                             $productsHasQuantity[$product->id] += $quantity;
                         }
                             $productUnit = $product->unit;
                         }
 
-                        $productName .= ' (' . ProductModel::strUnit($productUnit, 'wording_short', true) . ')';
+                        $productName .= ' (' .  Product::strUnit($productUnit, 'wording_short', true) . ')';
 
                         $productsNameArray[] = $productName;
                         $productsIndexArray[$product->id] = $cpt++;
 
                             if ($optionCsvExportByPiece) {
                                 foreach ($order->productOrder as $productOrder) {
-                                    $orderLine[$productsIndexArray[$productOrder->id_product]] = OrderModel::getProductQuantityPieces(
+                                    $orderLine[$productsIndexArray[$productOrder->id_product]] = Order::getProductQuantityPieces(
                                         $productOrder->id_product,
                                         [$order]
                                     );
                                     }
                                     $orderLine[$productsIndexArray[$productOrder->id_product]] .= $productOrder->quantity;
                                     if ($productOrder->product->unit != $productOrder->unit) {
-                                        $orderLine[$productsIndexArray[$productOrder->id_product]] .= ProductModel::strUnit(
+                                        $orderLine[$productsIndexArray[$productOrder->id_product]] .=  Product::strUnit(
                                             $productOrder->unit,
                                             'wording_short',
                                             true
         ]);
 
         if ($distribution) {
-            $ordersArray = OrderModel::searchAll(
+            $ordersArray = Order::searchAll(
                 [
                     'distribution.date' => $date,
                     'distribution.id_producer' => $idProducer
             );
 
             $selectedProductsArray = ProductDistributionModel::searchByDistribution($distribution->id);
-            $pointsSaleArray = PointSaleModel::searchAll([
+            $pointsSaleArray = PointSale::searchAll([
                 'point_sale.id_producer' => $idProducer
             ]);
 
             }
 
             // catégories
-            $categoriesArray = ProductCategoryModel::searchAll(
+            $categoriesArray =  ProductCategory::searchAll(
                 ['id_producer' => $idProducer],
                 ['orderby' => 'product_category.position ASC']
             );
             array_unshift($categoriesArray, null);
 
             // produits
-            $productsArray = ProductModel::find()
+            $productsArray =  Product::find()
                 ->joinWith([
                     'productDistribution' => function ($q) use ($distribution) {
                         $q->where(['id_distribution' => $distribution->id]);
                 'categoriesArray' => $categoriesArray,
                 'productsArray' => $productsArray,
                 'ordersArray' => $ordersArrayPaged,
-                'producer' => ProducerModel::searchOne(['id' => $idProducer])
+                'producer' => Producer::searchOne(['id' => $idProducer])
             ]);
 
             $dateStr = date('d/m/Y', strtotime($date));
     public function actionReportTerredepains($date, $key)
     {
         if ($key == 'ef572cc148c001f0180c4a624189ed30') {
-            $producer = ProducerModel::searchOne([
+            $producer = Producer::searchOne([
                 'producer.slug' => 'terredepains'
             ]);
 
             $idProducer = $producer->id;
 
-            $ordersArray = OrderModel::searchAll(
+            $ordersArray = Order::searchAll(
                 [
                     'distribution.date' => $date,
                     'distribution.id_producer' => $idProducer
 
             if ($distribution) {
                 $selectedProductsArray = ProductDistributionModel::searchByDistribution($distribution->id);
-                $pointsSaleArray = PointSaleModel::searchAll([
+                $pointsSaleArray = PointSale::searchAll([
                     'point_sale.id_producer' => $idProducer
                 ]);
 
                 }
 
                 // produits
-                $productsArray = ProductModel::find()
+                $productsArray =  Product::find()
                     ->joinWith([
                         'productDistribution' => function ($q) use ($distribution) {
                             $q->where(['id_distribution' => $distribution->id]);
                 $productsHasQuantity = [];
                 $cpt = 1;
                 foreach ($productsArray as $product) {
-                    $theUnit = ProductModel::strUnit($product->unit, 'wording_short', true);
+                    $theUnit =  Product::strUnit($product->unit, 'wording_short', true);
                     $theUnit = ($theUnit == 'p.') ? '' : ' (' . $theUnit . ')';
                     $productsNameArray[] = $product->name . $theUnit;
                     $productsIndexArray[$product->id] = $cpt++;
                                         }
                                         $orderLine[$productsIndexArray[$productOrder->id_product]] .= $productOrder->quantity;
                                         if ($productOrder->product->unit != $productOrder->unit) {
-                                                $orderLine[$productsIndexArray[$productOrder->id_product]] .= ProductModel::strUnit($productOrder->unit, 'wording_short', true);
+                                                $orderLine[$productsIndexArray[$productOrder->id_product]] .=  Product::strUnit($productOrder->unit, 'wording_short', true);
                                         }
                                 }
                                 $datas[] = $this->_lineOrderReportCSV($orderLine, $cpt - 1, true);
     {
         $totalsPointSaleArray = [$label];
         foreach ($productsArray as $product) {
-            foreach (ProductModel::$unitsArray as $unit => $dataUnit) {
-                $quantity = OrderModel::getProductQuantity($product->id, $ordersArray, false, $unit);
+            foreach ( Product::$unitsArray as $unit => $dataUnit) {
+                $quantity = Order::getProductQuantity($product->id, $ordersArray, false, $unit);
                 if ($quantity) {
                     $index = $productsIndexArray[$product->id];
                     if (!isset($totalsPointSaleArray[$index])) {
                     $totalsPointSaleArray[$index] .= $quantity;
 
                     if ($product->unit != $unit) {
-                        $totalsPointSaleArray[$index] .= '' . ProductModel::strUnit($unit, 'wording_short', true);
+                        $totalsPointSaleArray[$index] .= '' .  Product::strUnit($unit, 'wording_short', true);
                     }
                 }
             }
 
         foreach ($productsArray as $product) {
             $quantity = 0;
-            foreach (ProductModel::$unitsArray as $unit => $dataUnit) {
-                $quantityProduct = OrderModel::getProductQuantity($product->id, $ordersArray, false, $unit);
+            foreach ( Product::$unitsArray as $unit => $dataUnit) {
+                $quantityProduct = Order::getProductQuantity($product->id, $ordersArray, false, $unit);
 
                 if ($unit == 'piece') {
                     $quantity += $quantityProduct;
         $dateSaturday = date('Y-m-d', strtotime('Saturday', $start));
         $dateSunday = date('Y-m-d', strtotime('Sunday', $start));
 
-        $pointsSaleArray = PointSaleModel::searchAll();
+        $pointsSaleArray = PointSale::searchAll();
 
         $activeMonday = false;
         $activeTuesday = false;
     public function actionAjaxProcessAddSubscriptions($date)
     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
-        SubscriptionModel::addAll($date, true);
+         Subscription::addAll($date, true);
         return ['success'];
     }
 
     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
         $return = [];
-        $producerTiller = ProducerModel::getConfig('tiller');
+        $producerTiller = Producer::getConfig('tiller');
 
         if ($producerTiller) {
             $tiller = new Tiller();
             $isSynchro = $tiller->isSynchro($date);
 
             if (!$isSynchro) {
-                $orders = OrderModel::searchAll([
+                $orders = Order::searchAll([
                     'distribution.date' => $date,
                     'order.tiller_synchronization' => 1
                 ], [
                                 [
                                     'type' => $typePaymentTiller,
                                     'amount' => $order->getAmountWithTax(
-                                            OrderModel::AMOUNT_TOTAL
+                                            Order::AMOUNT_TOTAL
                                         ) * 100,
                                     'status' => 'ACCEPTED',
                                     'date' => $strDate
 
             if (is_array($idOrders) && count($idOrders) > 0) {
                 foreach ($idOrders as $idOrder) {
-                    $order = OrderModel::searchOne([
+                    $order = Order::searchOne([
                         'id' => (int)$idOrder
                     ]);
 
                     if ($order && $order->distribution->id_producer == GlobalParam::getCurrentProducerId()) {
-                        $deliveryNote = DeliveryNoteModel::searchOne([
+                        $deliveryNote = DeliveryNote::searchOne([
                             'id' => (int)$order->id_delivery_note
                         ]);
 
 
             if (is_array($idOrders) && count($idOrders) > 0) {
                 foreach ($idOrders as $idOrder) {
-                    $order = OrderModel::searchOne([
+                    $order = Order::searchOne([
                         'id' => (int)$idOrder
                     ]);
 
                         $deliveryNote = null;
                         $idDeliveryNote = $order->id_delivery_note;
                         if ($idDeliveryNote) {
-                            $deliveryNote = DeliveryNoteModel::searchOne([
+                            $deliveryNote = DeliveryNote::searchOne([
                                 'id' => (int)$idDeliveryNote
                             ]);
                         }
                             $order->save();
 
                             // init invoice prices
-                            $user = UserModel::searchOne([
+                            $user =  User::searchOne([
                                 'id' => $deliveryNote->id_user
                             ]);
-                            $userProducer = UserProducerModel::searchOne([
+                            $userProducer =  UserProducer::searchOne([
                                 'id_user' => $deliveryNote->id_user,
                                 'id_producer' => GlobalParam::getCurrentProducerId()
                             ]);
             if (is_array($idOrders) && count($idOrders) > 0) {
                 // récupération première commande pour obtenir des infos
                 reset($idOrders);
-                $firstOrder = OrderModel::searchOne([
+                $firstOrder = Order::searchOne([
                     'id' => (int)$idOrders[key($idOrders)]
                 ]);
 
                 $deliveryNote = null;
                 $isUpdate = false;
                 $i = 0;
-                $ordersArray = OrderModel::searchAll([
+                $ordersArray = Order::searchAll([
                     'id' => $idOrders,
                 ]);
                 do {
                     $order = $ordersArray[$i];
                     if ($order->distribution->id_producer == GlobalParam::getCurrentProducerId() && $order->id_delivery_note > 0) {
-                        $deliveryNote = DeliveryNoteModel::searchOne([
+                        $deliveryNote = DeliveryNote::searchOne([
                             'id' => $order->id_delivery_note
                         ]);
                         $isUpdate = true;
                     $i++;
                 } while ($deliveryNote == null && isset($ordersArray[$i]));
 
-                if ($deliveryNote && $deliveryNote->status == DocumentModel::STATUS_VALID) {
+                if ($deliveryNote && $deliveryNote->status == Document::STATUS_VALID) {
                     return [
                         'return' => 'error',
                         'alert' => [
 
                         if ($firstOrder->pointSale->id_user) {
                             $deliveryNote->id_user = $firstOrder->pointSale->id_user;
-                            $user = UserModel::searchOne([
+                            $user =  User::searchOne([
                                 'id' => $deliveryNote->id_user
                             ]);
-                            $userProducer = UserProducerModel::searchOne([
+                            $userProducer =  UserProducer::searchOne([
                                 'id_user' => $deliveryNote->id_user,
                                 'id_producer' => GlobalParam::getCurrentProducerId()
                             ]);
                         } else {
-                            $user = new UserModel;
-                            $user->type = UserModel::TYPE_LEGAL_PERSON;
+                            $user = new  User;
+                            $user->type =  User::TYPE_LEGAL_PERSON;
                             $user->name_legal_person = $firstOrder->pointSale->name;
                             $user->address = $firstOrder->pointSale->address;
                             $user->id_producer = 0;
                             }
                             $user->save();
 
-                            $userProducer = new UserProducerModel;
+                            $userProducer = new  UserProducer;
                             $userProducer->id_user = $user->id;
                             $userProducer->id_producer = GlobalParam::getCurrentProducerId();
                             $userProducer->credit = 0;
                         $deliveryNote->save();
                     } else {
                         // réinitialisation des order.id_delivery_note
-                        OrderModel::updateAll([
+                        Order::updateAll([
                             'id_delivery_note' => null
                         ], [
                             'id_delivery_note' => $deliveryNote->id
                     }
 
                     if (!isset($user) || !$user) {
-                        $user = UserModel::searchOne([
+                        $user =  User::searchOne([
                             'id' => $deliveryNote->id_user
                         ]);
-                        $userProducer = UserProducerModel::searchOne([
+                        $userProducer =  UserProducer::searchOne([
                             'id_user' => $deliveryNote->id_user,
                             'id_producer' => GlobalParam::getCurrentProducerId()
                         ]);
 
                     // affectation du BL aux commandes
                     foreach ($idOrders as $idOrder) {
-                        $order = OrderModel::searchOne([
+                        $order = Order::searchOne([
                             'id' => (int)$idOrder
                         ]);
                         if ($order && $order->distribution->id_producer == GlobalParam::getCurrentProducerId()) {
                         }
 
                         // init invoice price
-                        $order = OrderModel::searchOne(['id' => $idOrder]);
+                        $order = Order::searchOne(['id' => $idOrder]);
                         if ($order) {
                             $order->initInvoicePrices([
                                 'user' => $user,

backend/controllers/DocumentController.php

 use common\models\PointSale;
 use common\models\Product;
 use common\models\Quotation;
-use common\models\UserModel;
+use common\models\ User;
 use common\models\Document;
 use common\helpers\GlobalParam;
 use common\models\Order;
-use common\logic\UserProducer\UserProducerModel;
+use common\logic\UserProducer\ UserProducer;
 use kartik\mpdf\Pdf;
 use yii\base\UserException;
 use yii;
                                         'allow' => true,
                                         'roles' => ['@'],
                                         'matchCallback' => function ($rule, $action) {
-                                            return UserModel::hasAccessBackend();
+                                            return  User::hasAccessBackend();
                                         }
                                 ]
                         ],
         set_time_limit(0);
 
         $validatedDocumentsArray = array_merge(
-            QuotationModel::find()->where(['status' => DocumentModel::STATUS_VALID])->all(),
-            DeliveryNoteModel::find()->where(['status' => DocumentModel::STATUS_VALID])->all(),
-            InvoiceModel::find()->where(['status' => DocumentModel::STATUS_VALID])->all()
+            Quotation::find()->where(['status' => Document::STATUS_VALID])->all(),
+            DeliveryNote::find()->where(['status' => Document::STATUS_VALID])->all(),
+            Invoice::find()->where(['status' => Document::STATUS_VALID])->all()
         );
 
         foreach($validatedDocumentsArray as $document) {
         if ($model->getClass() == 'Invoice') {
             if ($model->deliveryNotes && is_array($model->deliveryNotes) && count($model->deliveryNotes)) {
                 foreach ($model->deliveryNotes as $key => $idDeliveryNote) {
-                    OrderModel::updateAll([
+                    Order::updateAll([
                                              'id_invoice' => $model->id
                                      ], [
                                              'id_delivery_note' => $idDeliveryNote
         $model->delete();
 
         if ($this->getClass() == 'DeliveryNote') {
-            OrderModel::updateAll([
+            Order::updateAll([
                                      'order.id_delivery_note' => null
                              ], [
                                      'order.id_delivery_note' => $id
         }
 
         if ($this->getClass() == 'Quotation') {
-            OrderModel::updateAll([
+            Order::updateAll([
                                      'order.id_quotation' => null
                              ], [
                                      'order.id_quotation' => $id
         }
 
         if ($this->getClass() == 'Invoice') {
-            OrderModel::updateAll([
+            Order::updateAll([
                                      'order.id_invoice' => null
                              ], [
                                      'order.id_invoice' => $id
                     '', // Réf.
                     $productOrder->product->name, // Désignation *
                     $productOrder->quantity, // Qté *
-                    '', // ProductModel::strUnit($productOrder->unit, 'wording'), // Unité
+                    '', //  Product::strUnit($productOrder->unit, 'wording'), // Unité
                     $price, // PU HT *
                     '', // Remise
                     $productOrder->taxRate->value * 100, // TVA
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
 
         if ($idUser > 0) {
-            $user = UserModel::searchOne([
+            $user =  User::searchOne([
                                             'id' => $idUser
                                     ]);
 
                         'orderby' => 'distribution.date ASC',
                         'join_with' => ['user AS user_delivery_note', 'orders', 'producer']
                     ];
-                    $deliveryNotesCreateArray = DeliveryNoteModel::searchAll([
+                    $deliveryNotesCreateArray = DeliveryNote::searchAll([
                                                                           'id_user' => $user->id,
-                                                                          'status' => DocumentModel::STATUS_VALID
+                                                                          'status' => Document::STATUS_VALID
                                                                   ], $options);
-                    $deliveryNotesUpdateArray = DeliveryNoteModel::searchAll([
+                    $deliveryNotesUpdateArray = DeliveryNote::searchAll([
                                                                           'id_user' => $user->id,
-                                                                          'status' => DocumentModel::STATUS_VALID,
+                                                                          'status' => Document::STATUS_VALID,
                                                                           'order.id_invoice' => $idDocument
                                                                   ], $options);
                     $json['delivery_note_create_array'] = $this->initDeliveryNoteArray('create', $deliveryNotesCreateArray);
             $deliveryNote->getAttributes(),
             [
                 'url' => Yii::$app->urlManager->createUrl(['delivery-note/update', 'id' => $deliveryNote->id]),
-                'total' => $deliveryNote->getAmountWithTax(OrderModel::INVOICE_AMOUNT_TOTAL)
+                'total' => $deliveryNote->getAmountWithTax(Order::INVOICE_AMOUNT_TOTAL)
             ]
         );
 
     {
         $classDocument = $this->getClass();
 
-        if ($id > 0 && DocumentModel::isValidClass($classDocument)) {
+        if ($id > 0 && Document::isValidClass($classDocument)) {
             $document = $classDocument::searchOne([
                                                           'id' => $id
                                                   ]);
     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
 
-        if ($idDocument > 0 && DocumentModel::isValidClass($classDocument)) {
+        if ($idDocument > 0 && Document::isValidClass($classDocument)) {
             $document = $classDocument::searchOne([
                                                           'id' => $idDocument
                                                   ]);
     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
 
-        if ($idDocument > 0 && DocumentModel::isValidClass($classDocument)) {
+        if ($idDocument > 0 && Document::isValidClass($classDocument)) {
             $document = $classDocument::searchOne([
                                                           'id' => $idDocument
                                                   ]);
 
             if ($document) {
-                $productsArray = ProductModel::searchAll([], [
+                $productsArray =  Product::searchAll([], [
                         'orderby' => 'product.order ASC'
                 ]);
 
                     );
                 }
 
-                $userProducer = UserProducerModel::searchOne([
+                $userProducer =  UserProducer::searchOne([
                                                                 'id_user' => $document->user->id,
                                                                 'id_producer' => GlobalParam::getCurrentProducerId()
                                                         ]);
-                $pointSale = PointSaleModel::searchOne([
+                $pointSale = PointSale::searchOne([
                                                           'id_user' => $document->user->id
                                                   ]);
 
                         'order',
                         function ($product) use ($document, $userProducer, $pointSale) {
                             return array_merge($product->getAttributes(), [
-                                    'unit_coefficient' => ProductModel::$unitsArray[$product->unit]['coefficient'],
+                                    'unit_coefficient' =>  Product::$unitsArray[$product->unit]['coefficient'],
                                     'prices' => $product->getPriceArray($userProducer->user, $pointSale),
                                     'wording_unit' => $product->wording_unit,
                                     'tax_rate' => $product->taxRate->value
                         'orders' => $ordersArray,
                         'total' => ($document->getClass() == 'Invoice' || $document->getClass(
                                 ) == 'DeliveryNote') ? $document->getAmount(
-                                OrderModel::INVOICE_AMOUNT_TOTAL
-                        ) : $document->getAmount(OrderModel::AMOUNT_TOTAL),
+                                Order::INVOICE_AMOUNT_TOTAL
+                        ) : $document->getAmount(Order::AMOUNT_TOTAL),
                         'total_with_tax' => ($document->getClass() == 'Invoice' || $document->getClass(
                                 ) == 'DeliveryNote') ? $document->getAmountWithTax(
-                                OrderModel::INVOICE_AMOUNT_TOTAL
-                        ) : $document->getAmountWithTax(OrderModel::AMOUNT_TOTAL),
+                                Order::INVOICE_AMOUNT_TOTAL
+                        ) : $document->getAmountWithTax(Order::AMOUNT_TOTAL),
                         'invoice_url' => ($document->getClass() == 'DeliveryNote' && $document->getInvoice()) ? Yii::$app->urlManager->createUrl(['invoice/update', 'id' => $document->getInvoice()->id]) : null
                 ];
             }
             $document = $classDocument::searchOne([
                                                           'id' => $idDocument
                                                   ]);
-            $product = ProductModel::searchOne([
+            $product =  Product::searchOne([
                                                   'id' => $idProduct
                                           ]);
 
                     $order->id_point_sale = null;
                     $order->id_distribution = null;
                     $order->status = 'tmp-order';
-                    $order->origin = OrderModel::ORIGIN_ADMIN;
+                    $order->origin = Order::ORIGIN_ADMIN;
                     $order->date = date('Y-m-d H:i:s');
                     $fieldIdDocument = 'id_' . $classDocument::tableName();
                     $order->$fieldIdDocument = $document->id;
                     $productOrder = new ProductOrder;
                     $productOrder->id_order = $order->id;
                     $productOrder->id_product = $idProduct;
-                    $quantity = $quantity / ProductModel::$unitsArray[$product->unit]['coefficient'];
+                    $quantity = $quantity /  Product::$unitsArray[$product->unit]['coefficient'];
                     $productOrder->quantity = $quantity;
                     $productOrder->price = (float)$price;
                     $productOrder->unit = $product->unit;
     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
 
-        $productOrder = ProductOrderModel::searchOne([
+        $productOrder = ProductOrder::searchOne([
                                                         'id' => $idProductOrder
                                                 ]);
 

backend/controllers/InvoiceController.php

     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
 
-        $invoice = InvoiceModel::searchOne(['id' => $idInvoice]);
+        $invoice = Invoice::searchOne(['id' => $idInvoice]);
 
         if($invoice && $invoice->isStatusDraft()) {
-            OrderModel::updateAll([
+            Order::updateAll([
                 'id_invoice' => null
             ], [
                 'id_delivery_note' => $idDeliveryNote
     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
 
-        $invoice = InvoiceModel::searchOne(['id' => $idInvoice]);
-        $deliveryNote = DeliveryNoteModel::searchOne(['id' => $idDeliveryNote]);
+        $invoice = Invoice::searchOne(['id' => $idInvoice]);
+        $deliveryNote = DeliveryNote::searchOne(['id' => $idDeliveryNote]);
 
         if($invoice && $invoice->isStatusDraft() && $deliveryNote) {
-            OrderModel::updateAll([
+            Order::updateAll([
                 'id_invoice' => $idInvoice
             ], [
                 'id_delivery_note' => $idDeliveryNote

backend/controllers/OrderController.php

 use common\models\Order;
 use common\models\ProductOrder;
 use common\models\Product;
-use common\models\UserModel;
+use common\models\ User;
 use common\models\ProductDistribution;
 use common\models\Distribution;
 use common\models\Producer;
-use common\logic\UserProducer\UserProducerModel;
+use common\logic\UserProducer\ UserProducer;
 
 class OrderController extends BackendController
 {
                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::getCurrentStatus() == UserModel::STATUS_ADMIN
-                                || UserModel::getCurrentStatus() == UserModel::STATUS_PRODUCER;
+                            return  User::getCurrentStatus() ==  User::STATUS_ADMIN
+                                ||  User::getCurrentStatus() ==  User::STATUS_PRODUCER;
                         }
                     ]
                 ],
     {
         if ($date != '') {
             // commandes
-            $orders = OrderModel::searchAll([
+            $orders = Order::searchAll([
                 'distribution.date' => $date
             ]);
 
                     foreach ($point->orders as $order) {
 
                         // suppression des product_order
-                        ProductOrderModel::deleteAll(['id_order' => $order->id]);
+                        ProductOrder::deleteAll(['id_order' => $order->id]);
 
                         // création des commande_produit modifiés
                         foreach ($products as $product) {
      */
     public function actionIndex($date = '', $returnData = false)
     {
-        if (!ProductModel::searchCount() || !PointSaleModel::searchCount()) {
+        if (! Product::searchCount() || !PointSale::searchCount()) {
             $this->redirect(['site/index', 'error_products_points_sale' => 1]);
         }
 
 
         // users
         $arrayUsers = [0 => '--'];
-        $users = UserModel::searchAll([], ['orderby' => 'lastname, name ASC']);
+        $users =  User::searchAll([], ['orderby' => 'lastname, name ASC']);
 
         foreach ($users as $user) {
             $arrayUsers[$user->id] = $user->name . ' ' . $user->lastname;
 
         // points de vente
         if ($distribution) {
-            $arrayPointsSale = PointSaleModel::find()
+            $arrayPointsSale = PointSale::find()
                 ->joinWith(['pointSaleDistribution' => function ($q) use ($distribution) {
                     $q->where(['id_distribution' => $distribution->id]);
                 }])
                 ])
                 ->all();
         } else {
-            $arrayPointsSale = PointSaleModel::searchAll();
+            $arrayPointsSale = PointSale::searchAll();
         }
 
         // produits
-        $arrayProducts = ProductModel::searchAll();
+        $arrayProducts =  Product::searchAll();
 
         // gestion des commandes
         $this->processOrderForm($distribution, $date, $arrayPointsSale, $arrayProducts, $users);
 
         // commandes
-        $arrayOrders = OrderModel::searchAll([
+        $arrayOrders = Order::searchAll([
             'distribution.date' => $date,
         ]);
 
 
         // produits
         if ($distribution) {
-            $arrayProducts = ProductModel::searchByDistribution($distribution->id);
+            $arrayProducts =  Product::searchByDistribution($distribution->id);
         }
 
         // poids total de la production et CA potentiel
     public function actionDownload($date = '', $idPointSale = 0, $global = 0)
     {
         // commandes
-        $ordersArray = OrderModel::searchAll([
+        $ordersArray = Order::searchAll([
             'distribution.date' => $date
         ]);
 
         // points de vente
-        $pointsSaleArray = PointSaleModel::searchAll();
+        $pointsSaleArray = PointSale::searchAll();
         foreach ($pointsSaleArray as $pointSale) {
             $pv->initOrders($ordersArray);
         }
 
         // produits
-        $productsArray = ProductModel::find()->orderBy('order ASC')->all();
+        $productsArray =  Product::find()->orderBy('order ASC')->all();
 
         $distribution = DistributionModel::find()
             ->where('date LIKE \':date\'')
                     $strProducts = '';
                     foreach ($productsArray as $product) {
                         if (isset($selectedProductsArray[$product->id]['active']) && $selectedProductsArray[$product->id]['active']) {
-                            $quantity = OrderModel::getProductQuantity($product->id, $pointSale->orders);
+                            $quantity = Order::getProductQuantity($product->id, $pointSale->orders);
                             $strQuantity = '';
                             if ($quantity) {
                                 $strQuantity = $quantity;
             $strProducts = '';
             foreach ($productsArray as $product) {
                 if (isset($selectedProductsArray[$product->id]['active']) && $selectedProductsArray[$product->id]['active']) {
-                    $quantity = OrderModel::getProductQuantity($product->id, $ordersArray);
+                    $quantity = Order::getProductQuantity($product->id, $ordersArray);
                     $strQuantity = '';
                     if ($quantity) {
                         $strQuantity = $quantity;
                 $dataAdd = [$pointSale->name];
                 foreach ($products as $product) {
                     if (isset($selectedProductsArray[$product->id]['active']) && $selectedProductsArray[$product->id]['active']) {
-                        $dataAdd[] = OrderModel::getProductQuantity($product->id, $pointSale->orders);
+                        $dataAdd[] = Order::getProductQuantity($product->id, $pointSale->orders);
                     }
                 }
                 $data[] = $dataAdd;
         $dataAdd = ['Total'];
         foreach ($products as $product) {
             if (isset($selectedProductsArray[$product->id]['active']) && $selectedProductsArray[$product->id]['active']) {
-                $dataAdd[] = OrderModel::getProductQuantity($product->id, $orders);
+                $dataAdd[] = Order::getProductQuantity($product->id, $orders);
             }
         }
         $data[] = $dataAdd;
 
         if ($active) {
             // add commandes automatiques
-            SubscriptionModel::addAll($date);
+             Subscription::addAll($date);
         }
 
         if ($redirect) {
         $dateSaturday = date('Y-m-d', strtotime('Saturday', $start));
         $dateSunday = date('Y-m-d', strtotime('Sunday', $start));
 
-        $pointsSaleArray = PointSaleModel::searchAll();
+        $pointsSaleArray = PointSale::searchAll();
 
         $activeMonday = false;
         $activeTuesday = false;
     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
 
-        $order = OrderModel::searchOne([
+        $order = Order::searchOne([
             'id' => $idOrder
         ]);
 
      */
     public function actionDelete($date, $idOrder)
     {
-        $order = OrderModel::searchOne(['id' => $idOrder]);
+        $order = Order::searchOne(['id' => $idOrder]);
 
         if ($order) {
 
             // remboursement de la commande
-            if ($order->id_user && $order->getAmount(OrderModel::AMOUNT_PAID) && ProducerModel::getConfig('credit')) {
+            if ($order->id_user && $order->getAmount(Order::AMOUNT_PAID) && Producer::getConfig('credit')) {
                 $order->saveCreditHistory(
-                    CreditHistoryModel::TYPE_REFUND,
-                    $order->getAmount(OrderModel::AMOUNT_PAID),
+                     CreditHistory::TYPE_REFUND,
+                    $order->getAmount(Order::AMOUNT_PAID),
                     $order->distribution->id_producer,
                     $order->id_user,
-                    UserModel::getCurrentId()
+                     User::getCurrentId()
                 );
             }
 
             $order->delete();
-            ProductOrderModel::deleteAll(['id_order' => $idOrder]);
+            ProductOrder::deleteAll(['id_order' => $idOrder]);
         }
 
         $this->redirect(['index', 'date' => $date]);
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
 
         $products = json_decode($products);
-        $pointSale = PointSaleModel::findOne($idPointSale);
+        $pointSale = PointSale::findOne($idPointSale);
         $distribution = DistributionModel::searchOne([
             'date' => $date
         ]);
             $order->id_point_sale = $idPointSale;
             $order->mean_payment = $meanPayment;
             $order->id_distribution = $distribution->id;
-            $order->origin = OrderModel::ORIGIN_ADMIN;
+            $order->origin = Order::ORIGIN_ADMIN;
             $order->comment = $comment;
             $order->status = 'tmp-order';
 
                 $order->id_user = $idUser;
 
                 // commentaire du point de vente
-                $userPointSale = UserPointSaleModel::searchOne([
+                $userPointSale = UserPointSale::searchOne([
                     'id_point_sale' => $idPointSale,
                     'id_user' => $idUser
                 ]);
             $userProducer = false;
             if (isset($order->user) && $order->user) {
                 $user = $order->user;
-                $userProducer = UserProducerModel::searchOne([
+                $userProducer =  UserProducer::searchOne([
                     'id_user' => $user->id,
                     'id_producer' => $order->distribution->id_producer
                 ]);
             }
 
             foreach ($products as $key => $dataProductOrder) {
-                $product = ProductModel::findOne($key);
-                $quantity = $dataProductOrder->quantity / ProductModel::$unitsArray[$dataProductOrder->unit]['coefficient'];
+                $product =  Product::findOne($key);
+                $quantity = $dataProductOrder->quantity /  Product::$unitsArray[$dataProductOrder->unit]['coefficient'];
                 if ($product && $quantity) {
                     $productOrder = new ProductOrder;
                     $productOrder->id_order = $order->id;
                 }
             }
 
-            $order = OrderModel::searchOne(['id' => $order->id]);
+            $order = Order::searchOne(['id' => $order->id]);
             if ($order && $processCredit) {
                 $order->processCredit();
             }
 
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
 
-        $order = OrderModel::searchOne(['id' => $idOrder]);
+        $order = Order::searchOne(['id' => $idOrder]);
 
         if ($order &&
             $order->distribution->id_producer == GlobalParam::getCurrentProducerId()) {
                 $order->id_user = $idUser;
 
                 // commentaire du point de vente
-                $userPointSale = UserPointSaleModel::searchOne([
+                $userPointSale = UserPointSale::searchOne([
                     'id_point_sale' => $order->id_point_sale,
                     'id_user' => $idUser
                 ]);
                 $order->id_user = 0;
             }
 
-            $user = UserModel::searchOne(['id' => $order->id_user]);
+            $user =  User::searchOne(['id' => $order->id_user]);
             $userProducer = false;
             if ($user) {
-                $userProducer = UserProducerModel::searchOne([
+                $userProducer =  UserProducer::searchOne([
                     'id_user' => $user->id,
                     'id_producer' => $order->distribution->id_producer
                 ]);
 
             $products = json_decode($products);
             foreach ($products as $key => $dataProductOrder) {
-                $productOrder = ProductOrderModel::findOne([
+                $productOrder = ProductOrder::findOne([
                     'id_order' => $idOrder,
                     'id_product' => $key
                 ]);
 
                 $quantity = $dataProductOrder->quantity
-                    / ProductModel::$unitsArray[$dataProductOrder->unit]['coefficient'];
+                    /  Product::$unitsArray[$dataProductOrder->unit]['coefficient'];
 
                 if ($quantity) {
                     if ($productOrder) {
                         $productOrder->quantity = $quantity;
                         $productOrder->price = $dataProductOrder->price;
                     } else {
-                        $product = ProductModel::findOne($key);
+                        $product =  Product::findOne($key);
 
                         if ($product) {
                             $productOrder = new ProductOrder;
 
             $order->save();
 
-            $order = OrderModel::searchOne(['id' => $order->id]);
+            $order = Order::searchOne(['id' => $order->id]);
             if ($order && $processCredit) {
                 // Si changement d'user : on rembourse l'ancien user
-                $amountPaid = $order->getAmount(OrderModel::AMOUNT_PAID);
+                $amountPaid = $order->getAmount(Order::AMOUNT_PAID);
                 if($oldIdUser != $idUser && $amountPaid > 0) {
                     $order->saveCreditHistory(
-                        CreditHistoryModel::TYPE_REFUND,
+                         CreditHistory::TYPE_REFUND,
                         $amountPaid,
                         GlobalParam::getCurrentProducerId(),
                         $oldIdUser,
-                        UserModel::getCurrentId()
+                         User::getCurrentId()
                     );
-                    $order = OrderModel::searchOne(['id' => $order->id]);
+                    $order = Order::searchOne(['id' => $order->id]);
                 }
 
                 $order->processCredit();
     public function actionPaymentStatus($idOrder)
     {
         $creditHistoryService = \Yii::$app->logic->getCreditHistoryContainer()->getService();
-        $order = OrderModel::searchOne(['id' => $idOrder]);
+        $order = Order::searchOne(['id' => $idOrder]);
 
         if ($order) {
             $html = '';
 
             if ($order->id_user) {
-                $userProducer = UserProducerModel::find()
+                $userProducer =  UserProducer::find()
                     ->where([
                         'id_user' => $order->id_user,
                         'id_producer' => $order->distribution->id_producer
                     ])
                     ->one();
 
-                $amountPaid = $order->getAmount(OrderModel::AMOUNT_PAID);
+                $amountPaid = $order->getAmount(Order::AMOUNT_PAID);
 
                 if (abs($order->amount - $amountPaid) < 0.0001) {
                     $html .= '<span class="label label-success">Payé</span>';
-                    $buttonsCredit = Html::a('Rembourser ' . $order->getAmountWithTax(OrderModel::AMOUNT_TOTAL, true), 'javascript:void(0);', ['class' => 'btn btn-default btn-xs rembourser', 'data-montant' => $order->amount, 'data-type' => 'refund']);
+                    $buttonsCredit = Html::a('Rembourser ' . $order->getAmountWithTax(Order::AMOUNT_TOTAL, true), 'javascript:void(0);', ['class' => 'btn btn-default btn-xs rembourser', 'data-montant' => $order->amount, 'data-type' => 'refund']);
                 } elseif ($order->amount > $amountPaid) {
                     $amountToPay = $order->amount - $amountPaid;
                     $html .= '<span class="label label-danger">Non payé</span> reste <strong>' . number_format($amountToPay, 2) . ' €</strong> à payer';
                     . '</span>';
 
                 // historique
-                $history = CreditHistoryModel::find()
+                $history =  CreditHistory::find()
                     ->with('userAction')
                     ->where(['id_order' => $idOrder])
                     ->all();
                             . '<td>' . date('d/m/Y H:i:s', strtotime($creditHistoryService->getDate($creditHistory))) . '</td>'
                             . '<td>' . Html::encode($creditHistoryService->getStrUserAction($creditHistory)) . '</td>'
                             . '<td>' . $creditHistoryService->getStrWording($creditHistory) . '</td>'
-                            . '<td>' . ($creditHistoryService->isTypeDebit($creditHistory) ? '- ' . $creditHistoryService->getAmountWithTax($creditHistory, OrderModel::AMOUNT_TOTAL, true) : '') . '</td>'
-                            . '<td>' . ($creditHistoryService->isTypeCredit($creditHistory) ? '+ ' . $creditHistoryService->getAmountWithTax($creditHistory, OrderModel::AMOUNT_TOTAL, true) : '') . '</td>'
+                            . '<td>' . ($creditHistoryService->isTypeDebit($creditHistory) ? '- ' . $creditHistoryService->getAmountWithTax($creditHistory, Order::AMOUNT_TOTAL, true) : '') . '</td>'
+                            . '<td>' . ($creditHistoryService->isTypeCredit($creditHistory) ? '+ ' . $creditHistoryService->getAmountWithTax($creditHistory, Order::AMOUNT_TOTAL, true) : '') . '</td>'
                             . '</tr>';
                     }
                 } else {
     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
 
-        $order = OrderModel::searchOne([
+        $order = Order::searchOne([
             'id' => $idOrder
         ]);
 
                 $amount,
                 GlobalParam::getCurrentProducerId(),
                 $order->id_user,
-                UserModel::getCurrentId()
+                 User::getCurrentId()
             );
         }
 
     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
 
-        $order = OrderModel::searchOne([
+        $order = Order::searchOne([
             'id' => (int)$idOrder
         ]);
 

backend/controllers/PointSaleController.php

                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::hasAccessBackend();
+                            return  User::hasAccessBackend();
                         }
                     ],
                 ],
      */
     public function actionUpdate($id) 
     {
-        $model = PointSaleModel::find()
+        $model = PointSale::find()
                 ->with('userPointSale')
                 ->where(['id' => $id])
                 ->one();
      */
     public function initForm($id = 0) 
     {
-        $users = UserModel::findBy()
+        $users =  User::findBy()
             ->leftJoin('user_point_sale', 'user_point_sale.id_user = user.id AND user_point_sale.id_point_sale = :id_point_sale',[':id_point_sale' => $id])
             ->orderBy('user_point_sale.id_point_sale DESC, lastname ASC, name ASC')
             ->all();
             $pointSale->save();
 
             // Suppression du lien entre les utilisateurs et le point de vente
-            UserPointSaleModel::deleteAll(['id_point_sale' => $id]);
+            UserPointSale::deleteAll(['id_point_sale' => $id]);
 
             // Suppression du lien PointSaleDistribution pour toutes les distributions à venir
-            $incomingDistributions = DistributionModel::getIncomingDistributions();
+            $incomingDistributions = DistributionModel::getIncoming();
             foreach ($incomingDistributions as $distribution) {
                 PointSaleDistributionModel::deleteAll(['id_point_sale' => $id, 'id_distribution' => $distribution->id]);
             }
 
             // Suppression de toutes les commandes à venir de ce point de vente
-            $ordersArray = OrderModel::searchAll(
+            $ordersArray = Order::searchAll(
                 [
                     'id_point_sale' => $id,
                 ],
     {
         $pointSale = $this->findModel($id) ;
         if($pointSale) {
-            PointSaleModel::updateAll(['default' => 0], 'id_producer = :id_producer', [':id_producer' => GlobalParam::getCurrentProducerId()]) ;
+            PointSale::updateAll(['default' => 0], 'id_producer = :id_producer', [':id_producer' => GlobalParam::getCurrentProducerId()]) ;
             if(!$pointSale->default) {
                 $pointSale->default = 1 ;
                 $pointSale->save() ;
      */
     protected function findModel($id) 
     {
-        if (($model = PointSaleModel::findOne($id)) !== null) {
+        if (($model = PointSale::findOne($id)) !== null) {
             return $model;
         } 
         else {

backend/controllers/ProducerAdminController.php

 
 use common\helpers\GlobalParam;
 use Yii;
-use common\models\UserModel;
+use common\models\ User;
 use yii\web\NotFoundHttpException;
 use yii\filters\VerbFilter;
 use yii\filters\AccessControl;
                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::getCurrentStatus() == UserModel::STATUS_ADMIN;
+                            return  User::getCurrentStatus() ==  User::STATUS_ADMIN;
                         }
                     ]
                 ],
     public function actionIndex() 
     {
         $dataProviderProducer = new ActiveDataProvider([
-            'query' => ProducerModel::find()
+            'query' => Producer::find()
                     ->with('userProducer', 'user')
                     ->orderBy('active DESC, free_price DESC'),
             'pagination' => [
             ],
         ]);
 
-        $producersArray = ProducerModel::find()->where('active = 1')->all();
+        $producersArray = Producer::find()->where('active = 1')->all();
 
         $sumPrices = 0;
         foreach($producersArray as $producer) {
         $fromProducerId = (int) $fromProducerId;
         $toProducerId = (int) $toProducerId;
         $count = 0;
-        $usersArray = UserModel::findBy(['id_producer' => $fromProducerId])->all();
+        $usersArray =  User::findBy(['id_producer' => $fromProducerId])->all();
 
         foreach($usersArray as $user) {
             $idUser = $user['user_id'];
 
             $countOrders = 0;
             if($withOrders) {
-                $countOrders = OrderModel::searchCount([
+                $countOrders = Order::searchCount([
                     'id_user' => $idUser,
                     'distribution.id_producer' => $fromProducerId
                 ], ['conditions' => 'date_delete IS NULL']);
             }
 
             if(($withOrders && $countOrders) || !$withOrders) {
-                ProducerModel::addUser($idUser, $toProducerId);
+                Producer::addUser($idUser, $toProducerId);
                 $count ++;
             }
         }
      */
     public function actionBill($idProducer) 
     {
-        $producer = ProducerModel::findOne($idProducer);
+        $producer = Producer::findOne($idProducer);
 
         if ($producer) {
             $period = date('Y-m', strtotime('-1 month'));
 
-            $last_invoice = InvoiceModel::getLastInvoice() ;
+            $last_invoice = Invoice::getLastInvoice() ;
             if (!$last_invoice) {
                 $reference = 'BAP000001';
             } else {
     public function actionBilling() 
     {
         $dataProviderInvoice = new ActiveDataProvider([
-            'query' => InvoiceModel::find()
+            'query' => Invoice::find()
                     ->with('producer')
                     ->orderBy('reference DESC'),
             'pagination' => [
     public function actionProducerInstallTaxUpdatePrices($idProducer)
     {
             // product
-            $productsArray = ProductModel::searchAll([
+            $productsArray =  Product::searchAll([
                 'id_producer' => $idProducer
             ]) ;
 
      * @throws NotFoundHttpException
      */
     protected function findModel($id) {
-        if (($model = ProducerModel::findOne($id)) !== null) {
+        if (($model = Producer::findOne($id)) !== null) {
             return $model;
         } else {
             throw new NotFoundHttpException('The requested page does not exist.');

backend/controllers/ProducerController.php

                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::hasAccessBackend();
+                            return  User::hasAccessBackend();
                         }
                     ]
                 ],
     public function actionBilling()
     {
         $datasInvoices = new ActiveDataProvider([
-            'query' => InvoiceModel::find()
+            'query' => Invoice::find()
                 ->where(['id_producer' => GlobalParam::getCurrentProducerId()])
                 ->orderBy('reference DESC'),
             'pagination' => [
             ],
         ]);
 
-        $producer = ProducerModel::findOne(GlobalParam::getCurrentProducerId());
+        $producer = Producer::findOne(GlobalParam::getCurrentProducerId());
 
         if ($producer->load(Yii::$app->request->post())) {
             $producer->save();
         }
 
         $dataProviderPrices = new ActiveDataProvider([
-            'query' => ProducerPriceRangeModel::find()
+            'query' =>  ProducerPriceRange::find()
                 ->orderBy('id ASC'),
             'pagination' => [
                 'pageSize' => 100,
      */
     protected function findModel($id)
     {
-        if (($model = ProducerModel::findOne($id)) !== null) {
+        if (($model = Producer::findOne($id)) !== null) {
             return $model;
         } else {
             throw new NotFoundHttpException('The requested page does not exist.');

backend/controllers/ProducerPriceRangeAdminController.php

                                                 'allow' => true,
                                                 'roles' => ['@'],
                                                 'matchCallback' => function ($rule, $action) {
-                                                        return UserModel::getCurrentStatus() == UserModel::STATUS_ADMIN;
+                                                        return  User::getCurrentStatus() ==  User::STATUS_ADMIN;
                                                 }
                                         ]
                                 ],
         public function actionIndex()
         {
                 $dataProvider = new ActiveDataProvider([
-                        'query' => ProducerPriceRangeModel::find()->orderBy('range_begin ASC')
+                        'query' =>  ProducerPriceRange::find()->orderBy('range_begin ASC')
                 ]);
 
                 return $this->render('index', [
          */
         public function actionDelete($id)
         {
-                $producerPriceRange = ProducerPriceRangeModel::searchOne([
+                $producerPriceRange =  ProducerPriceRange::searchOne([
                         'id' => $id
                 ]) ;
             $producerPriceRange->delete();
          */
         protected function findModel($id)
         {
-                if (($model = ProducerPriceRangeModel::findOne($id)) !== null) {
+                if (($model =  ProducerPriceRange::findOne($id)) !== null) {
                         return $model;
                 } else {
                         throw new NotFoundHttpException('The requested page does not exist.');

backend/controllers/ProductCategoryController.php

                                                 'allow' => true,
                                                 'roles' => ['@'],
                                                 'matchCallback' => function ($rule, $action) {
-                                                        return UserModel::hasAccessBackend();
+                                                        return  User::hasAccessBackend();
                                                 }
                                         ],
                                 ],
                 $productCategory = $this->findModel($id);
 
                 $productCategory->delete();
-                ProductModel::updateAll(['id_product_category' => null], ['id_product_category' => $id]);
+                 Product::updateAll(['id_product_category' => null], ['id_product_category' => $id]);
                 Yii::$app->getSession()->setFlash('success', 'Catégorie <strong>' . Html::encode($productCategory->name) . '</strong> supprimée.');
 
                 return $this->redirect(['index']);
          */
         protected function findModel($id)
         {
-                if (($model = ProductCategoryModel::findOne($id)) !== null) {
+                if (($model =  ProductCategory::findOne($id)) !== null) {
                         return $model;
                 } else {
                         throw new NotFoundHttpException('The requested page does not exist.');

backend/controllers/ProductController.php

 use common\models\ProductPrice;
 use common\models\ProductPriceSearch;
 use common\models\ProductSearch;
-use common\models\UserModelSearch;
+use common\models\ UserSearch;
 use Yii;
 use yii\filters\AccessControl;
 use common\models\Product;
 use common\models\Distribution;
-use common\models\UserModel;
-use common\logic\UserProducer\UserProducerModel;
+use common\models\ User;
+use common\logic\UserProducer\ UserProducer;
 use yii\data\ActiveDataProvider;
 use yii\web\Controller;
 use yii\web\NotFoundHttpException;
                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::hasAccessBackend();
+                            return  User::hasAccessBackend();
                         }
                     ]
                 ],
 
         if ($model->load(Yii::$app->request->post()) && $model->save()) {
 
-            $lastProductOrder = ProductModel::find()->where('id_producer = :id_producer')->params([':id_producer' => GlobalParam::getCurrentProducerId()])->orderBy('order DESC')->one();
+            $lastProductOrder =  Product::find()->where('id_producer = :id_producer')->params([':id_producer' => GlobalParam::getCurrentProducerId()])->orderBy('order DESC')->one();
             if ($lastProductOrder) {
                 $model->order = ++$lastProductOrder->order;
             }
      */
     public function processAvailabilityPointsSale($model)
     {
-        ProductPointSaleModel::deleteAll(['id_product' => $model->id]);
+        ProductPointSale::deleteAll(['id_product' => $model->id]);
 
         if (is_array($model->pointsSale) && count($model->pointsSale)) {
             foreach ($model->pointsSale as $key => $val) {
-                $pointSale = PointSaleModel::findOne($val);
+                $pointSale = PointSale::findOne($val);
                 if ($pointSale) {
                     $productPointSale = new ProductPointSale;
                     $productPointSale->id_product = $model->id;
             'id_product' => $id
         ]));
 
-        $userProducerWithProductPercent = UserProducerModel::searchAll([], [
+        $userProducerWithProductPercent =  UserProducer::searchAll([], [
             'join_with' => ['user'],
             'conditions' => 'user_producer.product_price_percent != 0',
         ]);
 
-        $pointSaleWithProductPercent = PointSaleModel::searchAll([], [
+        $pointSaleWithProductPercent = PointSale::searchAll([], [
             'conditions' => 'point_sale.product_price_percent != 0'
         ]);
 
                 'from_quantity' => $model->from_quantity ? $model->from_quantity : null,
             ];
 
-            $productPriceExist = ProductPriceModel::findOne($conditionsProductPriceExist);
+            $productPriceExist =  ProductPrice::findOne($conditionsProductPriceExist);
 
             if ($productPriceExist) {
                 $productPriceExist->delete();
      */
     protected function findModel($id)
     {
-        if (($model = ProductModel::findOne($id)) !== null) {
+        if (($model =  Product::findOne($id)) !== null) {
             return $model;
         } else {
             throw new NotFoundHttpException('The requested page does not exist.');
 
     protected function findModelProductPrice($id)
     {
-        if (($model = ProductPriceModel::findOne($id)) !== null) {
+        if (($model =  ProductPrice::findOne($id)) !== null) {
             return $model;
         } else {
             throw new NotFoundHttpException('The requested page does not exist.');

backend/controllers/QuotationController.php

                                                 'allow' => true,
                                                 'roles' => ['@'],
                                                 'matchCallback' => function ($rule, $action) {
-                                                        return UserModel::hasAccessBackend();
+                                                        return  User::hasAccessBackend();
                                                 }
                                         ]
                                 ],
                         $invoice->name = str_replace(['Devis', 'devis'], 'Facture', $quotation->name);
                         $invoice->save() ;
 
-                        OrderModel::updateAll([
+                        Order::updateAll([
                                 'order.id_invoice' => $invoice->id
                         ], [
                                 'order.id_quotation' => $id

backend/controllers/ReportController.php

                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::hasAccessBackend() ;
+                            return  User::hasAccessBackend() ;
                         }
                     ]
                 ],
     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
                
-        $usersArray = UserModel::findBy()->all() ;
-        $pointsSaleArray = PointSaleModel::searchAll() ;
+        $usersArray =  User::findBy()->all() ;
+        $pointsSaleArray = PointSale::searchAll() ;
         
         // distributions
         $firstDistribution = DistributionModel::searchOne([], [

backend/controllers/SiteController.php

                                                 'allow' => true,
                                                 'roles' => ['@'],
                                                 'matchCallback' => function ($rule, $action) {
-                                                        return UserModel::hasAccessBackend() ;
+                                                        return  User::hasAccessBackend() ;
                                                 }
                                         ],
                                         [
                                                 'allow' => true,
                                                 'roles' => ['@'],
                                                 'matchCallback' => function ($rule, $action) {
-                                                        return UserModel::getCurrentStatus() == UserModel::STATUS_ADMIN ;
+                                                        return  User::getCurrentStatus() ==  User::STATUS_ADMIN ;
                                                 }
                                         ],
                                 ],
         {
 
                 // commandes
-                $optionDashboardNumberDistributions = ProducerModel::getConfig('option_dashboard_number_distributions') ;
+                $optionDashboardNumberDistributions = Producer::getConfig('option_dashboard_number_distributions') ;
                 $dashboardNumberDistributions = $optionDashboardNumberDistributions ? $optionDashboardNumberDistributions : 3 ;
 
-                $optionDashboardDateStart = ProducerModel::getConfig('option_dashboard_date_start') ;
-                $optionDashboardDateEnd = ProducerModel::getConfig('option_dashboard_date_end') ;
+                $optionDashboardDateStart = Producer::getConfig('option_dashboard_date_start') ;
+                $optionDashboardDateEnd = Producer::getConfig('option_dashboard_date_end') ;
 
                 $queryDistributions = DistributionModel::find()->with('order') ;
 
                         $paramsOrders[':date_start'] = date('Y-m-d 00:00:00') ;
                 }
 
-                $ordersArray = OrderModel::searchAll([],[
+                $ordersArray = Order::searchAll([],[
                         'orderby' => 'date DESC',
-                        'conditions' => $conditionsOrders.' AND (origin = \'' . OrderModel::ORIGIN_USER . '\' OR origin = \'' . OrderModel::ORIGIN_ADMIN . '\' OR (origin = \'' . OrderModel::ORIGIN_AUTO . '\' AND (date_update IS NOT NULL OR date_delete IS NOT NULL)))',
+                        'conditions' => $conditionsOrders.' AND (origin = \'' . Order::ORIGIN_USER . '\' OR origin = \'' . Order::ORIGIN_ADMIN . '\' OR (origin = \'' . Order::ORIGIN_AUTO . '\' AND (date_update IS NOT NULL OR date_delete IS NOT NULL)))',
                         'params' => $paramsOrders,
                 ]);
 
                 // clients
-                $usersArray = UserModel::findBy()
+                $usersArray =  User::findBy()
                         ->orderBy('created_at DESC')
                         ->limit(5)
                         ->all();
 
-                $usersNegativeCredit = UserModel::findBy(['id_producer' => GlobalParam::getCurrentProducerId()])
+                $usersNegativeCredit =  User::findBy(['id_producer' => GlobalParam::getCurrentProducerId()])
                         ->andWhere('user_producer.credit < 0')
                         ->all();
 
                 // paramètres
                 $producer = GlobalParam::getCurrentProducer();
 
-                $productsCount = ProductModel::searchCount() ;
-                $pointsSaleCount = PointSaleModel::searchCount() ;
+                $productsCount =  Product::searchCount() ;
+                $pointsSaleCount = PointSale::searchCount() ;
 
                 return $this->render('index', [
                         'distributionsArray' => $distributionsArray,

backend/controllers/StatsController.php

                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::hasAccessBackend() ;
+                            return  User::hasAccessBackend() ;
                         }
                     ]
                 ],
     {
         if(!$year) $year = date('Y') ;
         
-        $productsArray = ProductModel::searchAll() ;
+        $productsArray =  Product::searchAll() ;
         
         $dataProducts = [] ;
         

backend/controllers/SubscriptionController.php

                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::hasAccessBackend() ;
+                            return  User::hasAccessBackend() ;
                         }
                     ]
                 ],
         $model->id_producer = GlobalParam::getCurrentProducerId();
 
         if($idOrder) {
-            $order = OrderModel::searchOne(['id' => $idOrder]);
+            $order = Order::searchOne(['id' => $idOrder]);
             if ($order) {
                 $model->id_user = $order->id_user;
                 $model->username = $order->username;
                 $dateDay = strtolower(date('l',strtotime($order->distribution->date))) ;
                 $model->$dateDay = 1 ;
                 $model->week_frequency = 1 ;
-                if($model->id_user && ProducerModel::getConfig('credit')) {
+                if($model->id_user && Producer::getConfig('credit')) {
                     $model->auto_payment = 1 ;
                 }
                 
         }
         
         // produits
-        $productsArray = ProductModel::searchAll([], [
+        $productsArray =  Product::searchAll([], [
             'orderby' => 'product.order ASC'
         ]) ;
                 
         {
             Yii::$app->getSession()->setFlash('success', 'Abonnement ajouté');
             
-            $subscription = SubscriptionModel::findOne($model->id) ;
+            $subscription =  Subscription::findOne($model->id) ;
             $matchedDistributionsArray = $subscription->searchMatchedIncomingDistributions() ;
             if(count($matchedDistributionsArray)) {
                 return $this->redirect(['subscription/update-distributions', 'idSubscription' => $subscription->id]);
         // form
         $model = new SubscriptionForm;
         $model->isAdmin = true ;
-        $subscription = SubscriptionModel::findOne($id);
+        $subscription =  Subscription::findOne($id);
         
         if ($subscription) {
             $model->id = $id;
             }
 
             // produits
-            $arrayProductsSubscription = ProductSubscriptionModel::searchAll([
+            $arrayProductsSubscription =  ProductSubscription::searchAll([
                 'id_subscription' => $model->id
             ]) ;
             
         }
 
         // produits
-        $productsArray = ProductModel::searchAll([], [
+        $productsArray =  Product::searchAll([], [
             'orderby' => 'product.order ASC'
         ]) ;
 
 
             if ($model->save()) {
 
-                $subscription = SubscriptionModel::findOne($model->id) ;
+                $subscription =  Subscription::findOne($model->id) ;
 
                 $messageOrdersDeleted = '';
                 if($model->date_end) {
      */
     public function actionDelete($id) 
     {
-        $subscription = SubscriptionModel::searchOne([
+        $subscription =  Subscription::searchOne([
             'subscription.id' => $id
         ]) ;
         $subscription->deleteOrdersIncomingDistributions() ;
         $subscription->delete();
-        ProductSubscriptionModel::deleteAll(['id_subscription' => $id]);
+         ProductSubscription::deleteAll(['id_subscription' => $id]);
         Yii::$app->getSession()->setFlash('success', 'Abonnement supprimé');
         return $this->redirect(['subscription/index']);
     }
 
     public function actionUpdateDistributions($idSubscription, $generate = false, $update = false) 
     {
-        $subscription = SubscriptionModel::findOne($idSubscription) ;
+        $subscription =  Subscription::findOne($idSubscription) ;
         $matchedDistributionsArray = $subscription->searchMatchedIncomingDistributions() ;
         
         if($generate) {
     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
         
-        $productsQuery = ProductModel::find()
+        $productsQuery =  Product::find()
                 ->where(['id_producer' => GlobalParam::getCurrentProducerId(),]) ;
         
         if($idSubscription) {
                 'price' => $theProduct['price']
             ] ;*/
 
-            $theProduct['wording_unit'] = ProductModel::strUnit($theProduct['unit'], 'wording_short');
+            $theProduct['wording_unit'] =  Product::strUnit($theProduct['unit'], 'wording_short');
 
             if(isset($theProduct['productSubscription'][0])) {
                 /*if($theProduct['productSubscription'][0]['unit'] != $theProduct['unit']) {
                     $theProduct['units'][] = [
                         'unit' => $theProduct['productSubscription'][0]['unit'],
-                        'wording_unit' => ProductModel::strUnit($theProduct['productSubscription'][0]['unit'], 'wording_short'),
+                        'wording_unit' =>  Product::strUnit($theProduct['productSubscription'][0]['unit'], 'wording_short'),
                         'step' => $theProduct['productSubscription'][0]['step'],
                         'price' => $theProduct['productSubscription'][0]['price'],
                     ] ;
                     $theProduct['step'] = $theProduct['productSubscription'][0]['step'] ;
                     $theProduct['price'] = $theProduct['productSubscription'][0]['price'] ;
                 }*/
-                $theProduct['quantity'] = $theProduct['productSubscription'][0]['quantity'] * ProductModel::$unitsArray[$theProduct['unit']]['coefficient'] ;
+                $theProduct['quantity'] = $theProduct['productSubscription'][0]['quantity'] *  Product::$unitsArray[$theProduct['unit']]['coefficient'] ;
             }
             else {
                 $theProduct['quantity'] = '' ;

backend/controllers/UserController.php

 use backend\models\CreditForm;
 use common\helpers\GlobalParam;
 use common\helpers\Mailjet;
-use common\models\UserModel;
-use common\models\Producer;
-use common\models\Distribution;
 use backend\models\MailForm;
-use common\models\UserGroup;
-use common\logic\UserProducer\UserProducerModel;
-use common\models\UserPointSale;
-use common\models\PointSale;
-use common\models\UserUserGroup;
+use common\helpers\Password;
+use common\logic\Distribution\Distribution\Distribution;
+use common\logic\Order\Order\OrderSearch;
+use common\logic\PointSale\PointSale\PointSale;
+use common\logic\PointSale\UserPointSale\UserPointSale;
+use common\logic\Producer\Producer\Producer;
+use common\logic\User\CreditHistory\CreditHistory;
+use common\logic\User\User\UserSearch;
+use common\logic\User\UserGroup\UserGroup;
+use common\logic\User\UserGroup\UserUserGroup;
+use common\logic\User\UserProducer\UserProducer;
+use yii\base\UserException;
+use yii\debug\models\search\User;
+use yii\filters\AccessControl;
+use yii\filters\VerbFilter;
+use \Yii;
+use yii\web\NotFoundHttpException;
 
 /**
  * UserController implements the CRUD actions for User model.
     {
         return [
             'verbs' => [
-                'class' => VerbFilter::className(),
+                'class' => VerbFilter::class,
                 'actions' => [
                 ],
             ],
             'access' => [
-                'class' => AccessControl::className(),
+                'class' => AccessControl::class,
                 'rules' => [
                     [
                         'allow' => true,
                         'roles' => ['@'],
                         'matchCallback' => function ($rule, $action) {
-                            return UserModel::hasAccessBackend();
+                            return $this->isUserCurrentAdmin();
                         }
                     ]
                 ],
     public function actionIndex(
         $idPointSale = 0, $sectionSubscribers = false, $sectionInactiveUsers = false)
     {
-        $searchModel = new UserSearch;
+        $searchModel = new UserSearch();
         $dataProvider = $searchModel->search([
             'UserSearch' => array_merge(
                 [
             )
         ]);
 
-        $producer = ProducerModel::searchOne([
+        $producer = Producer::searchOne([
             'id' => GlobalParam::getCurrentProducerId()
         ]);
 
-        $pointsSaleArray = PointSaleModel::searchAll();
+        $pointsSaleArray = PointSale::searchAll();
 
         return $this->render('index', [
             'searchModel' => $searchModel,
 
         if ($model->id) {
             // init points de vente sélectionnés
-            $userPointSaleArray = UserPointSaleModel::searchAll([
+            $userPointSaleArray = UserPointSale::searchAll([
                 'id_user' => $model->id
             ]);
             if ($userPointSaleArray && count($userPointSaleArray) > 0) {
             }
 
             // init groupes d'utilisateurs sélectionnés
-            $userUserGroupsArray = UserUserGroupModel::searchAll([
+            $userUserGroupsArray = UserUserGroup::searchAll([
                 'id_user' => $model->id
             ]);
             if ($userUserGroupsArray && count($userUserGroupsArray) > 0) {
             }
 
             // product price percent
-            $userProducer = UserProducerModel::searchOne([
+            $userProducer =  UserProducer::searchOne([
                 'id_producer' => GlobalParam::getCurrentProducerId(),
                 'id_user' => $model->id
             ]);
         }
 
         // points de vente
-        $pointsSaleArray = PointSaleModel::find()
+        $pointsSaleArray = PointSale::find()
             ->where([
                 'id_producer' => GlobalParam::getCurrentProducerId(),
                 'status' => 1
             ->all();
 
         // groupes d'utilisateurs
-        $userGroupsArray = UserGroupModel::find()
+        $userGroupsArray =  UserGroup::find()
             ->where([
                 'id_producer' => GlobalParam::getCurrentProducerId(),
             ])
      */
     public function actionCreate()
     {
-        $model = new UserModel();
+        $model = new  User();
 
         $userExist = false;
         $posts = Yii::$app->request->post();
 
         if ($posts && isset($posts['User']['email']) && strlen($posts['User']['email']) > 0) {
-            $userExist = UserModel::searchOne([
+            $userExist =  User::searchOne([
                 'email' => $posts['User']['email']
             ]);
         }
 
         if ($userExist) {
-            ProducerModel::addUser($userExist->id, GlobalParam::getCurrentProducerId());
+            Producer::addUser($userExist->id, GlobalParam::getCurrentProducerId());
             $this->processLinkPointSale($userExist);
             $this->processLinkUserGroup($userExist);
             Yii::$app->getSession()->setFlash('success', "L'utilisateur que vous souhaitez créer possède déjà un compte sur la plateforme. Il vient d'être lié à votre établissement.");
                 $model->save();
 
                 // liaison etablissement / user
-                $useProducer = new UserProducerModel();
+                $useProducer = new  UserProducer();
                 $useProducer->id_user = $model->id;
                 $useProducer->id_producer = GlobalParam::getCurrentProducerId();
                 $useProducer->credit = 0;
                 $this->processProductPricePercent($model);
 
                 Yii::$app->getSession()->setFlash('success', 'Utilisateur créé.');
-                $model = new UserModel();
+                $model = new  User();
             }
         }
 
 
         // Moodification du profil
         $previousMail = $model->email;
-        $user = UserModel::find()->with('userProducer')->where(['id' => $model['id']])->one();
-        $userBelongToProducer = UserProducerModel::findOne(['id_user' => $id, 'id_producer' => GlobalParam::getCurrentProducerId()]);
+        $user =  User::find()->with('userProducer')->where(['id' => $model['id']])->one();
+        $userBelongToProducer =  UserProducer::findOne(['id_user' => $id, 'id_producer' => GlobalParam::getCurrentProducerId()]);
         if ($userBelongToProducer) {
             if ($model->load(Yii::$app->request->post()) && $model->save()) {
 
     /**
      * Lie un utilisateur aux points de vente sélectionnés.
      *
-     * @param UserModel $modelUser
+     * @param  User $modelUser
      */
     public function processLinkPointSale($modelUser)
     {
         $posts = Yii::$app->request->post();
-        UserPointSaleModel::deleteAll([
+        UserPointSale::deleteAll([
             'id_user' => $modelUser->id
         ]);
         if (is_array($modelUser->points_sale) && count($modelUser->points_sale) > 0) {
             foreach ($modelUser->points_sale as $pointSaleId) {
-                $userPointSale = UserPointSaleModel::searchOne([
+                $userPointSale = UserPointSale::searchOne([
                     'id_user' => $modelUser->id,
                     'id_point_sale' => $pointSaleId
                 ]);
     /**
      * Lie un utilisateur aux groupes d'utilisateurs sélectionnés.
      *
-     * @param UserModel $modelUser
+     * @param  User $modelUser
      */
     public function processLinkUserGroup($modelUser)
     {
         $posts = Yii::$app->request->post();
-        UserUserGroupModel::deleteAll([
+        UserUserGroup::deleteAll([
             'id_user' => $modelUser->id
         ]);
 
         if (is_array($modelUser->user_groups) && count($modelUser->user_groups) > 0) {
             foreach ($modelUser->user_groups as $userGroupId) {
 
-                $userUserGroup = UserUserGroupModel::searchOne([
+                $userUserGroup = UserUserGroup::searchOne([
                     'id_user' => $modelUser->id,
                     'id_user_group' => $userGroupId
                 ]);
 
     public function processProductPricePercent($model)
     {
-        $userProducer = UserProducerModel::searchOne([
+        $userProducer =  UserProducer::searchOne([
             'id_producer' => GlobalParam::getCurrentProducerId(),
             'id_user' => $model->id
         ]);
      */
     public function actionDelete($id)
     {
-        $userProducer = UserProducerModel::findOne([
+        $userProducer =  UserProducer::findOne([
             'id_user' => $id,
             'id_producer' => GlobalParam::getCurrentProducerId()
         ]);
             $usersPointSaleLink = 1;
         }
 
-        $users = UserModel::findBy([
+        $users =  User::findBy([
             'id_producer' => GlobalParam::getCurrentProducerId(),
             'id_point_sale' => $idPointSale,
             'users_point_sale_link' => $usersPointSaleLink,
                 $usersArray[] = $user['email'];
         }
 
-        $pointsSaleArray = PointSaleModel::find()->where(['id_producer' => GlobalParam::getCurrentProducerId()])->all();
+        $pointsSaleArray = PointSale::find()->where(['id_producer' => GlobalParam::getCurrentProducerId()])->all();
 
         $pointSale = null;
         if ($idPointSale) {
-            $pointSale = PointSaleModel::findOne(['id' => $idPointSale]);
+            $pointSale = PointSale::findOne(['id' => $idPointSale]);
         }
 
         $mailForm = new MailForm();
             return $this->redirect(['mail', 'idPointSale' => $idPointSale]);
         }
 
-        $incomingDistributions = DistributionModel::getIncomingDistributions();
+        $incomingDistributions = Distribution::getIncoming();
         $incomingDistributionsArray = ['0' => '--'];
         foreach ($incomingDistributions as $distribution) {
             $incomingDistributionsArray[$distribution->id] = strftime('%A %d %B %Y', strtotime($distribution->date));
      */
     public function actionCredit($id)
     {
-        $user = UserModel::find()->with('userProducer')->where(['id' => $id])->one();
-        $userProducer = UserProducerModel::findOne(['id_user' => $id, 'id_producer' => GlobalParam::getCurrentProducerId()]);
+        $user =  User::find()->with('userProducer')->where(['id' => $id])->one();
+        $userProducer =  UserProducer::findOne(['id_user' => $id, 'id_producer' => GlobalParam::getCurrentProducerId()]);
 
-        if (($userProducer) || UserModel::getCurrentStatus() == UserModel::STATUS_ADMIN) {
+        if (($userProducer) ||  User::getCurrentStatus() ==  User::STATUS_ADMIN) {
 
             $creditForm = new CreditForm();
             if ($creditForm->load(Yii::$app->request->post()) && $creditForm->validate()) {
                 $creditForm = new CreditForm;
             }
 
-            $history = CreditHistoryModel::find()
+            $history =  CreditHistory::find()
                 ->with(['order', 'userAction'])
                 ->where([
                     'id_user' => $user->id,
      */
     public function actionOrders($id)
     {
-        $user = UserModel::findOne($id);
-        $searchModel = new OrderSearch;
+        $user =  User::findOne($id);
+        $searchModel = new OrderSearch();
         $dataProvider = $searchModel->search(array_merge(Yii::$app->request->queryParams, ['id_user' => $id]));
 
         return $this->render('orders', [
      */
     public function actionStateCredit($idUser, $state)
     {
-        $userProducer = UserProducerModel::searchOne([
+        $userProducer =  UserProducer::searchOne([
             'id_user' => $idUser
         ]);
 
     /**
      * Finds the User model based on its primary key value.
      * If the model is not found, a 404 HTTP exception will be thrown.
-     * @param integer $id
-     * @return UserModel the loaded model
-     * @throws NotFoundHttpException if the model cannot be found
      */
     protected function findModel($id)
     {
-        if (($model = UserModel::findOne($id)) !== null) {
+        if (($model =  User::findOne($id)) !== null) {
             return $model;
         } else {
             throw new NotFoundHttpException('The requested page does not exist.');

backend/controllers/UserGroupController.php

                                                 'allow' => true,
                                                 'roles' => ['@'],
                                                 'matchCallback' => function ($rule, $action) {
-                                                        return UserModel::hasAccessBackend();
+                                                        return  User::hasAccessBackend();
                                                 }
                                         ],
                                 ],
                 $userGroup = $this->findModel($id);
 
                 $userGroup->delete();
-                UserUserGroupModel::deleteAll(['id_user_group' => $id]);
+                User UserGroup::deleteAll(['id_user_group' => $id]);
                 Yii::$app->getSession()->setFlash('success', 'Groupe d\'utilisateur <strong>' . Html::encode($userGroup->name) . '</strong> supprimé.');
 
                 return $this->redirect(['index']);
          */
         protected function findModel($id)
         {
-                if (($model = UserGroupModel::findOne($id)) !== null) {
+                if (($model =  UserGroup::findOne($id)) !== null) {
                         return $model;
                 } else {
                         throw new NotFoundHttpException('The requested page does not exist.');

backend/models/AccessUserProducerForm.php

 use common\helpers\GlobalParam;
 use Yii;
 use yii\base\Model;
-use common\models\UserModel ;
+use common\models\ User ;
 use common\models\Producer ;
-use common\logic\UserProducer\UserProducerModel ;
+use common\logic\UserProducer\ UserProducer ;
 
 /**
  * ContactForm is the model behind the contact form.
     
     public function save() 
     {
-        $user = UserModel::searchOne([
+        $user =  User::searchOne([
             'id' => $this->id_user
         ]) ;
         
         if($user) {
             $user->id_producer = GlobalParam::getCurrentProducerId() ;
-            if($user->status != UserModel::STATUS_PRODUCER && $user->status != UserModel::STATUS_ADMIN) {
-                $user->status = UserModel::STATUS_PRODUCER ;
+            if($user->status !=  User::STATUS_PRODUCER && $user->status !=  User::STATUS_ADMIN) {
+                $user->status =  User::STATUS_PRODUCER ;
             }
             return $user->save(); 
         }

backend/models/CreditForm.php

 use Yii;
 use yii\base\Model;
 use common\models\CreditHistory ;
-use common\models\UserModel ;
+use common\models\ User ;
 use common\models\Producer ;
-use common\logic\UserProducer\UserProducerModel ;
+use common\logic\UserProducer\ UserProducer ;
 use common\helpers\Mail ;
 
 /**
             
             // on prévient l'utilisateur que son compte vient d'être crédité
             if($this->send_mail) {
-                $user = UserModel::findOne($this->id_user) ;
+                $user =  User::findOne($this->id_user) ;
                 $producer = GlobalParam::getCurrentProducer() ;
-                $userProducer = UserProducerModel::searchOne([
+                $userProducer =  UserProducer::searchOne([
                     'id_user' => $this->id_user
                 ]);
 

backend/models/MailForm.php

 '.$linkOrder ;
 
                 if($this->integrate_product_list) {
-                    $productsArray = ProductModel::find()
+                    $productsArray =  Product::find()
                         ->where([
                             'id_producer' => GlobalParam::getCurrentProducerId(),
                         ])
                             }
                             if($product->price) {
                                 $productDescription .= ' / '.Price::format($product->getPriceWithTax()) ;
-                                $productDescription .= ' ('.ProductModel::strUnit($product->unit, 'wording_unit').')' ;
+                                $productDescription .= ' ('. Product::strUnit($product->unit, 'wording_unit').')' ;
                             }
 
                             $messageAutoText .= '- '.$productDescription.'

backend/views/access/index.php

         </div>
         <div class="panel-body">
             <?php $form = ActiveForm::begin(); ?>
-            <?= $form->field($modelAccessUserProducerForm, 'id_user')->dropDownList(UserModel::populateDropdownList(), ['class' => 'select2'])->label(''); ?>
+            <?= $form->field($modelAccessUserProducerForm, 'id_user')->dropDownList( User::populateDropdownList(), ['class' => 'select2'])->label(''); ?>
             <?= Html::submitButton('Ajouter', ['class' => 'btn btn-success']) ?>
             <?php ActiveForm::end(); ?>
         </div>

backend/views/delivery-note/index.php

 ?>
 
 <div class="delivery-note-index">
-        <?php if(DeliveryNoteModel::searchCount()): ?>
+        <?php if(DeliveryNote::searchCount()): ?>
                 <?= GridView::widget([
                         'filterModel' => $searchModel,
                         'dataProvider' => $dataProvider,
                                 [
                                         'attribute' => 'id_point_sale',
                                         'header' => 'Point de vente',
-                                        'filter' => ArrayHelper::map(PointSaleModel::searchAll([], ['as_array'=>true]), 'id', 'name'),
+                                        'filter' => ArrayHelper::map(PointSale::searchAll([], ['as_array'=>true]), 'id', 'name'),
                                         'format' => 'html',
                                         'value' => function($model) {
                                                 $pointSale = $model->getPointSale() ;
                                         'attribute' => 'amount',
                                         'header' => 'Montant',
                                         'value' => function($deliveryNote) {
-                                                return $deliveryNote->getAmountWithTax(OrderModel::INVOICE_AMOUNT_TOTAL, true) ;
+                                                return $deliveryNote->getAmountWithTax(Order::INVOICE_AMOUNT_TOTAL, true) ;
                                         }
                                 ],
                                 [

backend/views/development/development.php

 use yii\grid\GridView;
 use common\models\Development;
 use common\models\DevelopmentPriority;
-use common\models\UserModel;
+use common\models\ User;
 use common\helpers\Url;
 use common\helpers\GlobalParam;
 
         ];
 
 
-        if (UserModel::hasAccessBackend()) {
+        if ( User::hasAccessBackend()) {
 
                 $columns[] = [
                         'header' => 'Priorité',
                 ];
         }
 
-        if (UserModel::getCurrentStatus() == UserModel::STATUS_ADMIN) {
+        if ( User::getCurrentStatus() ==  User::STATUS_ADMIN) {
                 $columns[] = [
                         'class' => 'yii\grid\ActionColumn',
                         'template' => '{update}',

backend/views/development/index.php

 use yii\grid\GridView;
 use common\models\Development;
 use common\models\DevelopmentPriority;
-use common\models\UserModel;
+use common\models\ User;
 use common\helpers\Url;
 use common\helpers\GlobalParam;
 

backend/views/distribution/report-bourlingue.php

                         $add = false;
                         foreach ($order->productOrder as $productOrder) {
                             if($product->id == $productOrder->id_product) {
-                                $unit = (ProductModel::strUnit($productOrder->unit, 'wording_short', true) == 'p.') ? '' : ' '.ProductModel::strUnit($productOrder->unit, 'wording_short', true) ;
+                                $unit = ( Product::strUnit($productOrder->unit, 'wording_short', true) == 'p.') ? '' : ' '. Product::strUnit($productOrder->unit, 'wording_short', true) ;
                                 $strProducts .= $product->name . ' (' .$productOrder->quantity .$unit.')<br />';
                                 $add = true;
                             }
                         $credit = '' ;
 
                         if(isset($order->user) && $order->user->id) {
-                            $userProducer = UserProducerModel::searchOne([
+                            $userProducer =  UserProducer::searchOne([
                                     'id_user' => $order->user->id
                             ]);
 
                 $strProducts = '';
                 $cpt = 0 ;
                 foreach ($productsArray as $product) {
-                    foreach(ProductModel::$unitsArray as $unit => $dataUnit) {
-                        $quantity = OrderModel::getProductQuantity($product->id, $pointSale->orders, false, $unit);
+                    foreach( Product::$unitsArray as $unit => $dataUnit) {
+                        $quantity = Order::getProductQuantity($product->id, $pointSale->orders, false, $unit);
                         if ($quantity) {
-                            $theUnit = (ProductModel::strUnit($unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'.ProductModel::strUnit($unit, 'wording_short', true) ;
+                            $theUnit = ( Product::strUnit($unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'. Product::strUnit($unit, 'wording_short', true) ;
                             $strProducts .= $product->name . ' (' .$quantity .$theUnit.')<br />';
                         }
                     }
 
         $cpt = 0 ;
         foreach ($productsArray as $product) {
-            foreach(ProductModel::$unitsArray as $unit => $dataUnit) {
-                $quantity = OrderModel::getProductQuantity($product->id, $pointSale->orders, false, $unit);
+            foreach( Product::$unitsArray as $unit => $dataUnit) {
+                $quantity = Order::getProductQuantity($product->id, $pointSale->orders, false, $unit);
                 if ($quantity) {
-                    $theUnit = (ProductModel::strUnit($unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'.ProductModel::strUnit($unit, 'wording_short', true) ;
+                    $theUnit = ( Product::strUnit($unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'. Product::strUnit($unit, 'wording_short', true) ;
                     $html .= $product->name . ' (' .$quantity .$theUnit.')<br />';
                 }
             }
 
 $cpt = 0 ;
 foreach ($productsArray as $product) {
-    foreach(ProductModel::$unitsArray as $unit => $dataUnit) {
-        $quantity = OrderModel::getProductQuantity($product->id, $ordersArray, false, $unit);
+    foreach( Product::$unitsArray as $unit => $dataUnit) {
+        $quantity = Order::getProductQuantity($product->id, $ordersArray, false, $unit);
         if ($quantity) {
-            $theUnit = (ProductModel::strUnit($unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'.ProductModel::strUnit($unit, 'wording_short', true) ;
+            $theUnit = ( Product::strUnit($unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'. Product::strUnit($unit, 'wording_short', true) ;
             $html .= $product->name . ' (' .$quantity .$theUnit.')<br />';
         }
     }

backend/views/distribution/report-grid.php

                         foreach ($orders as $order) {
                                 $html .= '<tr>';
                                 $strUser = $order->getStrUser();
-                                if ($producer->option_order_reference_type == ProducerModel::ORDER_REFERENCE_TYPE_YEARLY && $order->reference && strlen($order->reference) > 0) {
+                                if ($producer->option_order_reference_type == Producer::ORDER_REFERENCE_TYPE_YEARLY && $order->reference && strlen($order->reference) > 0) {
                                         $strUser .= '<br />' . $order->reference;
                                 }
 
                         $quantity = '' ;
                         foreach($order->productOrder as $productOrder) {
                                 if($product->id == $productOrder->id_product) {
-                                        $unit = (ProductModel::strUnit($productOrder->unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'.ProductModel::strUnit($productOrder->unit, 'wording_short', true) ;
+                                        $unit = ( Product::strUnit($productOrder->unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'. Product::strUnit($productOrder->unit, 'wording_short', true) ;
 
                                         $quantity .= $productOrder->quantity .$unit ;
                                         if($productOrder->quantity > 1) {

backend/views/distribution/report.php

                     }
 
                     // référence
-                    if($producer->option_order_reference_type == ProducerModel::ORDER_REFERENCE_TYPE_YEARLY && $order->reference && strlen($order->reference) > 0) {
+                    if($producer->option_order_reference_type == Producer::ORDER_REFERENCE_TYPE_YEARLY && $order->reference && strlen($order->reference) > 0) {
                         $strUser .= '<br />'.$order->reference ;
                     }
 
                         $add = false;
                         foreach ($order->productOrder as $productOrder) {
                             if($product->id == $productOrder->id_product) {
-                                $unit = (ProductModel::strUnit($productOrder->unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'.ProductModel::strUnit($productOrder->unit, 'wording_short', true) ;
+                                $unit = ( Product::strUnit($productOrder->unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'. Product::strUnit($productOrder->unit, 'wording_short', true) ;
                                 $strProducts .= '('.$productOrder->quantity .$unit.') '.$product->getNameExport() . '<br />';
                                 $add = true;
                             }
                         $credit = '' ;
 
                         if(isset($order->user) && $order->user->id) {
-                            $userProducer = UserProducerModel::searchOne([
+                            $userProducer =  UserProducer::searchOne([
                                     'id_user' => $order->user->id
                             ]);
 
                     
                     $html .= '<td><strong>'.number_format($order->amount_with_tax, 2) . ' € ';
 
-                    if($order->getPaymentStatus() == OrderModel::PAYMENT_PAID)
+                    if($order->getPaymentStatus() == Order::PAYMENT_PAID)
                     {
                         $html .= '(payé)' ;
                     }
-                    elseif($order->getPaymentStatus() == OrderModel::PAYMENT_UNPAID && $order->getAmount(OrderModel::AMOUNT_PAID))
+                    elseif($order->getPaymentStatus() == Order::PAYMENT_UNPAID && $order->getAmount(Order::AMOUNT_PAID))
                     {
-                        $html .= '(reste '.$order->getAmount(OrderModel::AMOUNT_REMAINING, true).' à payer)' ;
+                        $html .= '(reste '.$order->getAmount(Order::AMOUNT_REMAINING, true).' à payer)' ;
                     }
-                    elseif($order->getPaymentStatus() == OrderModel::PAYMENT_SURPLUS)
+                    elseif($order->getPaymentStatus() == Order::PAYMENT_SURPLUS)
                     {
-                        $html .= '(surplus : '.$order->getAmount(OrderModel::PAYMENT_SURPLUS, true).' à rembourser)' ;
+                        $html .= '(surplus : '.$order->getAmount(Order::PAYMENT_SURPLUS, true).' à rembourser)' ;
                     }
                     
                     $html .= '</strong></td>' ;
                 $strProducts = '';
                 $cpt = 0 ;
                 foreach ($productsArray as $product) {
-                    foreach(ProductModel::$unitsArray as $unit => $dataUnit) {
-                        $quantity = OrderModel::getProductQuantity($product->id, $pointSale->orders, false, $unit);
+                    foreach( Product::$unitsArray as $unit => $dataUnit) {
+                        $quantity = Order::getProductQuantity($product->id, $pointSale->orders, false, $unit);
                         if ($quantity) {
-                            $theUnit = (ProductModel::strUnit($unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'.ProductModel::strUnit($unit, 'wording_short', true) ;
+                            $theUnit = ( Product::strUnit($unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'. Product::strUnit($unit, 'wording_short', true) ;
                             $strProducts .= '(' .$quantity .$theUnit.') '.$product->getNameExport() . '<br />';
                         }
                     }
 
         $cpt = 0 ;
         foreach ($productsArray as $product) {
-            foreach(ProductModel::$unitsArray as $unit => $dataUnit) {
-                $quantity = OrderModel::getProductQuantity($product->id, $pointSale->orders, false, $unit);
+            foreach( Product::$unitsArray as $unit => $dataUnit) {
+                $quantity = Order::getProductQuantity($product->id, $pointSale->orders, false, $unit);
                 if ($quantity) {
-                    $theUnit = (ProductModel::strUnit($unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'.ProductModel::strUnit($unit, 'wording_short', true) ;
+                    $theUnit = ( Product::strUnit($unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'. Product::strUnit($unit, 'wording_short', true) ;
                     $html .= '(' .$quantity .$theUnit.') '.$product->getNameExport() . '<br />';
                 }
             }
 
 $cpt = 0 ;
 foreach ($productsArray as $product) {
-    foreach(ProductModel::$unitsArray as $unit => $dataUnit) {
-        $quantity = OrderModel::getProductQuantity($product->id, $ordersArray, false, $unit);
+    foreach( Product::$unitsArray as $unit => $dataUnit) {
+        $quantity = Order::getProductQuantity($product->id, $ordersArray, false, $unit);
         if ($quantity) {
-            $theUnit = (ProductModel::strUnit($unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'.ProductModel::strUnit($unit, 'wording_short', true) ;
+            $theUnit = ( Product::strUnit($unit, 'wording_short', true) == 'p.') ? '' : '&nbsp;'. Product::strUnit($unit, 'wording_short', true) ;
             $html .= '(' .$quantity .$theUnit.') '.$product->name . '<br />';
         }
     }

backend/views/document/_download_product_line.php

                 </td>
         <?php endif; ?>
         <td class="align-center">
-            <?= $productOrder->quantity * ProductModel::$unitsArray[$productOrder->unit]['coefficient'] ?>
+            <?= $productOrder->quantity *  Product::$unitsArray[$productOrder->unit]['coefficient'] ?>
         </td>
-        <td class="align-center"><?= ProductModel::strUnit($productOrder->unit, 'wording') ?></td>
+        <td class="align-center"><?=  Product::strUnit($productOrder->unit, 'wording') ?></td>
         <?php if($displayPrices): ?>
                 <?php if($producer->taxRate->value != 0): ?>
                         <td class="align-center"><?= $productOrder->taxRate->value * 100 ?> %</td>

backend/views/document/_form.php

                         'template' => '{label} <a href="' . Yii::$app->urlManager->createUrl(['user/create']) . '" class="btn btn-xs btn-default">Nouvel utilisateur <span class="glyphicon glyphicon-plus"></span></a><div>{input}</div>{hint}',
                     ])
                         ->dropDownList(
-                            UserModel::populateDropdownList(),
+                             User::populateDropdownList(),
                             [
                                 '@change' => 'changeUser',
                                 'v-model' => 'idUser',
                            class="btn btn-sm btn-default"><span class="glyphicon glyphicon-repeat"></span> Regénérer (PDF)</a>
                     <?php endif; ?>
 
-                    <?php if ($model->getClass() == 'Invoice' && ProducerModel::getConfig('option_export_evoliz')): ?>
+                    <?php if ($model->getClass() == 'Invoice' && Producer::getConfig('option_export_evoliz')): ?>
                         <a href="<?= Yii::$app->urlManager->createUrl([Yii::$app->controller->getControllerUrl() . '/export-csv-evoliz', 'id' => $model->id]) ?>"
                            class="btn btn-sm btn-default"><span class="glyphicon glyphicon-save-file"></span> Export Evoliz
                             (CSV)</a>

backend/views/document/download.php

 <?php
 
-$displayPrices = Yii::$app->controller->getClass() != 'DeliveryNote' || (Yii::$app->controller->getClass() == 'DeliveryNote' && ProducerModel::getConfig('document_display_prices_delivery_note'));
-$displayProductDescription = ProducerModel::getConfig('document_display_product_description');
-$documentPriceDecimals = (int) ProducerModel::getConfig('option_document_price_decimals');
+$displayPrices = Yii::$app->controller->getClass() != 'DeliveryNote' || (Yii::$app->controller->getClass() == 'DeliveryNote' && Producer::getConfig('document_display_prices_delivery_note'));
+$displayProductDescription = Producer::getConfig('document_display_product_description');
+$documentPriceDecimals = (int) Producer::getConfig('option_document_price_decimals');
 
 ?>
 
                     <?php endforeach; ?>
                 <?php endif; ?>
                 <?php if ($displayPrices): ?>
-                    <?php $typeAmount = $document->isInvoicePrice() ? OrderModel::INVOICE_AMOUNT_TOTAL : OrderModel::AMOUNT_TOTAL; ?>
+                    <?php $typeAmount = $document->isInvoicePrice() ? Order::INVOICE_AMOUNT_TOTAL : Order::AMOUNT_TOTAL; ?>
 
                     <?php if ($producer->taxRate->value != 0): ?>
 

backend/views/invoice/index.php

 
 <div class="invoice-index">
 
-        <?php if(InvoiceModel::searchCount()): ?>
+        <?php if(Invoice::searchCount()): ?>
                 <?= GridView::widget([
                         'filterModel' => $searchModel,
                         'dataProvider' => $dataProvider,
                                         'attribute' => 'amount',
                                         'header' => 'Montant',
                                         'value' => function($invoice) {
-                                            return $invoice->getAmountWithTax(OrderModel::INVOICE_AMOUNT_TOTAL, true) ;
+                                            return $invoice->getAmountWithTax(Order::INVOICE_AMOUNT_TOTAL, true) ;
                                         }
                                 ],
                                 [

backend/views/layouts/header.php

 
 use yii\helpers\Html;
 use common\models\Producer;
-use common\models\UserModel;
+use common\models\ User;
 use yii\widgets\ActiveForm;
 use yii\helpers\ArrayHelper;
 use common\helpers\GlobalParam;
         <div class="navbar-custom-menu">
                 <?php
 
-                $usersArray = UserModel::findBy(['id_producer' => GlobalParam::getCurrentProducerId()])
+                $usersArray =  User::findBy(['id_producer' => GlobalParam::getCurrentProducerId()])
                         ->andWhere('CAST(FROM_UNIXTIME(user.created_at) AS date) > \'' . date("Y-m-d", strtotime("-7 days")) . '\'')
                         ->orderBy('created_at DESC')
                         ->all();
 
                     <?php
 
-                    $usersNegativeCreditArray = UserModel::findBy(['id_producer' => GlobalParam::getCurrentProducerId()])
+                    $usersNegativeCreditArray =  User::findBy(['id_producer' => GlobalParam::getCurrentProducerId()])
                             ->andWhere('user_producer.credit < 0')
                             ->orderBy('lastname, name ASC')
                             ->all();
                                             <?php foreach ($usersNegativeCreditArray as $user): ?>
                                                 <li>
                                                     <a href="<?= Yii::$app->urlManagerBackend->createUrl(['user/credit', 'id' => $user['user_id']]); ?>">
-                                                        <h5><?= UserModel::getUsernameFromArray($user); ?>
+                                                        <h5><?=  User::getUsernameFromArray($user); ?>
                                                             <small>
                                                                 <i class="fa fa-euro"></i> <?= Price::format($user['credit']); ?>
                                                             </small>
 
                 </li>
 
-                    <?php if (UserModel::isCurrentProducer() || UserModel::isCurrentAdmin()): ?>
+                    <?php if ( User::isCurrentProducer() ||  User::isCurrentAdmin()): ?>
                         <li class="dropdown producer-menu">
                             <a href="#" class="dropdown-toggle" data-toggle="dropdown">
 
                             </a>
 
                             <ul class="dropdown-menu">
-                                    <?php if (UserModel::isCurrentAdmin()): ?>
+                                    <?php if ( User::isCurrentAdmin()): ?>
                                         <li>
                                             <a href="<?= Yii::$app->urlManagerProducer->createAbsoluteUrl(['site/index', 'slug_producer' => GlobalParam::getCurrentProducer()->slug]); ?>">
                                                 <i class="fa fa-th-large"></i>
                                             </a>
                                         </li>
                                         <li class="header">&nbsp;<strong>Autres producteurs</strong></li>
-                                            <?php $producersArray = ProducerModel::find()->orderBy('name ASC')->all(); ?>
+                                            <?php $producersArray = Producer::find()->orderBy('name ASC')->all(); ?>
                                             <?php foreach ($producersArray as $producer): ?>
                                             <li>
                                                 <a href="<?= Yii::$app->urlManagerBackend->createUrl(['site/change-producer', 'id' => $producer->id]); ?>"><?= Html::encode($producer->name) ?></a>
                 <li class="dropdown user user-menu">
                     <a href="#" class="dropdown-toggle" data-toggle="dropdown">
                         <i class="fa fa-user"></i>
-                        <span class="hidden-xs"><?= Html::encode(UserModel::getCurrent()->name . ' ' . UserModel::getCurrent()->lastname); ?></span>
+                        <span class="hidden-xs"><?= Html::encode( User::getCurrent()->name . ' ' .  User::getCurrent()->lastname); ?></span>
                         <i class="fa fa-caret-down"></i>
                     </a>
                     <ul class="dropdown-menu">

backend/views/layouts/left.php

             [
                 'options' => ['class' => 'sidebar-menu tree', 'data-widget' => 'tree'],
                 'items' => [
-                    ['label' => 'Tableau de bord', 'icon' => 'dashboard', 'url' => ['/site/index'], 'visible' => UserModel::isCurrentProducer()],
-                    ['label' => 'Distributions', 'icon' => 'calendar', 'url' => ['/distribution/index'], 'visible' => UserModel::isCurrentProducer()],
+                    ['label' => 'Tableau de bord', 'icon' => 'dashboard', 'url' => ['/site/index'], 'visible' =>  User::isCurrentProducer()],
+                    ['label' => 'Distributions', 'icon' => 'calendar', 'url' => ['/distribution/index'], 'visible' =>  User::isCurrentProducer()],
                     [
                         'label' => 'Produits',
                         'icon' => 'clone',
                         'url' => ['/product/index'],
-                        'visible' => UserModel::isCurrentProducer(),
+                        'visible' =>  User::isCurrentProducer(),
                         'active' => Yii::$app->controller->id == 'product',
                         'items' => [
-                            ['label' => 'Liste', 'icon' => 'th-list', 'url' => ['/product/index'], 'visible' => UserModel::isCurrentProducer()],
-                            ['label' => 'Catégories', 'icon' => 'book', 'url' => ['/product-category/index'], 'visible' => UserModel::isCurrentProducer()],
+                            ['label' => 'Liste', 'icon' => 'th-list', 'url' => ['/product/index'], 'visible' =>  User::isCurrentProducer()],
+                            ['label' => 'Catégories', 'icon' => 'book', 'url' => ['/product-category/index'], 'visible' =>  User::isCurrentProducer()],
                         ]
                     ],
-                    ['label' => 'Points de vente', 'icon' => 'map-marker', 'url' => ['/point-sale/index'], 'visible' => UserModel::isCurrentProducer(), 'active' => Yii::$app->controller->id == 'point-sale'],
+                    ['label' => 'Points de vente', 'icon' => 'map-marker', 'url' => ['/point-sale/index'], 'visible' =>  User::isCurrentProducer(), 'active' => Yii::$app->controller->id == 'point-sale'],
                     [
                         'label' => 'Utilisateurs',
                         'icon' => 'users',
                         'url' => ['/user/index'],
                         'items' => [
-                            ['label' => 'Liste', 'icon' => 'th-list', 'url' => ['/user/index'], 'visible' => UserModel::isCurrentProducer()],
-                            ['label' => 'Groupes', 'icon' => 'users', 'url' => ['/user-group/index'], 'visible' => UserModel::isCurrentProducer()],
+                            ['label' => 'Liste', 'icon' => 'th-list', 'url' => ['/user/index'], 'visible' =>  User::isCurrentProducer()],
+                            ['label' => 'Groupes', 'icon' => 'users', 'url' => ['/user-group/index'], 'visible' =>  User::isCurrentProducer()],
                         ],
                     ],
-                    ['label' => 'Abonnements', 'icon' => 'repeat', 'url' => ['/subscription/index'], 'visible' => UserModel::isCurrentProducer(), 'active' => Yii::$app->controller->id == 'subscription'],
-                    ['label' => 'Communiquer', 'icon' => 'bullhorn', 'url' => ['/communicate/index'], 'visible' => UserModel::isCurrentProducer()],
+                    ['label' => 'Abonnements', 'icon' => 'repeat', 'url' => ['/subscription/index'], 'visible' =>  User::isCurrentProducer(), 'active' => Yii::$app->controller->id == 'subscription'],
+                    ['label' => 'Communiquer', 'icon' => 'bullhorn', 'url' => ['/communicate/index'], 'visible' =>  User::isCurrentProducer()],
                     [
                         'label' => 'Documents',
                         'icon' => 'clone',
                         'url' => ['/delivery-note/index'],
                         'items' => [
-                            ['label' => 'Bons de livraison', 'icon' => 'sticky-note-o', 'url' => ['/delivery-note/index'], 'visible' => UserModel::isCurrentProducer()],
-                            ['label' => 'Factures', 'icon' => 'sticky-note-o', 'url' => ['/invoice/index'], 'visible' => UserModel::isCurrentProducer()],
-                            ['label' => 'Devis', 'icon' => 'sticky-note-o', 'url' => ['/quotation/index'], 'visible' => UserModel::isCurrentProducer()],
+                            ['label' => 'Bons de livraison', 'icon' => 'sticky-note-o', 'url' => ['/delivery-note/index'], 'visible' =>  User::isCurrentProducer()],
+                            ['label' => 'Factures', 'icon' => 'sticky-note-o', 'url' => ['/invoice/index'], 'visible' =>  User::isCurrentProducer()],
+                            ['label' => 'Devis', 'icon' => 'sticky-note-o', 'url' => ['/quotation/index'], 'visible' =>  User::isCurrentProducer()],
                         ],
                     ],
                     [
                         'icon' => 'line-chart',
                         'url' => ['/stats/index'],
                         'items' => [
-                            ['label' => 'Chiffre d\'affaire', 'icon' => 'line-chart', 'url' => ['/stats/index'], 'visible' => UserModel::isCurrentProducer()],
-                            ['label' => 'Rapports', 'icon' => 'pencil-square-o', 'url' => ['/report/index'], 'visible' => UserModel::isCurrentProducer()],
-                            ['label' => 'Produits', 'icon' => 'table', 'url' => ['/stats/products'], 'visible' => UserModel::isCurrentProducer()],
+                            ['label' => 'Chiffre d\'affaire', 'icon' => 'line-chart', 'url' => ['/stats/index'], 'visible' =>  User::isCurrentProducer()],
+                            ['label' => 'Rapports', 'icon' => 'pencil-square-o', 'url' => ['/report/index'], 'visible' =>  User::isCurrentProducer()],
+                            ['label' => 'Produits', 'icon' => 'table', 'url' => ['/stats/products'], 'visible' =>  User::isCurrentProducer()],
                         ],
                     ],
-                    ['label' => 'Paramètres', 'icon' => 'cog', 'url' => ['/producer/update'], 'visible' => UserModel::isCurrentProducer()],
-                    ['label' => 'Accès', 'icon' => 'lock', 'url' => ['/access/index'], 'visible' => UserModel::isCurrentProducer()],
+                    ['label' => 'Paramètres', 'icon' => 'cog', 'url' => ['/producer/update'], 'visible' =>  User::isCurrentProducer()],
+                    ['label' => 'Accès', 'icon' => 'lock', 'url' => ['/access/index'], 'visible' =>  User::isCurrentProducer()],
                     [
                             'label' => 'Développement',
                             'icon' => 'code',
                             'url' => ['/development/index'],
-                            'visible' => UserModel::isCurrentProducer(),
+                            'visible' =>  User::isCurrentProducer(),
                             'active' => Yii::$app->controller->id == 'development',
                             'template'=>'<a href="{url}">{icon} {label}'.$newVersionOpendistribTemplate.'</a>'
                     ],
-                    ['label' => 'Tarifs', 'icon' => 'euro', 'url' => ['/producer/billing'], 'visible' => UserModel::isCurrentProducer()],
+                    ['label' => 'Tarifs', 'icon' => 'euro', 'url' => ['/producer/billing'], 'visible' =>  User::isCurrentProducer()],
 
-                    ['label' => 'Administration', 'options' => ['class' => 'header'], 'visible' => UserModel::isCurrentAdmin()],
-                    ['label' => 'Producteurs', 'icon' => 'th-list', 'url' => ['/producer-admin/index'], 'visible' => UserModel::isCurrentAdmin()],
-                    ['label' => 'Tranches de prix', 'icon' => 'eur', 'url' => ['/producer-price-range-admin/index'], 'visible' => UserModel::isCurrentAdmin()],
-                    ['label' => 'Taxes', 'icon' => 'eur', 'url' => ['/tax-rate-admin/index'], 'visible' => UserModel::isCurrentAdmin()],
-                    ['label' => 'Communiquer', 'icon' => 'bullhorn', 'url' => ['/communicate-admin/index'], 'visible' => UserModel::isCurrentAdmin()],
+                    ['label' => 'Administration', 'options' => ['class' => 'header'], 'visible' =>  User::isCurrentAdmin()],
+                    ['label' => 'Producteurs', 'icon' => 'th-list', 'url' => ['/producer-admin/index'], 'visible' =>  User::isCurrentAdmin()],
+                    ['label' => 'Tranches de prix', 'icon' => 'eur', 'url' => ['/producer-price-range-admin/index'], 'visible' =>  User::isCurrentAdmin()],
+                    ['label' => 'Taxes', 'icon' => 'eur', 'url' => ['/tax-rate-admin/index'], 'visible' =>  User::isCurrentAdmin()],
+                    ['label' => 'Communiquer', 'icon' => 'bullhorn', 'url' => ['/communicate-admin/index'], 'visible' =>  User::isCurrentAdmin()],
 
-                    ['label' => 'Outils', 'options' => ['class' => 'header'], 'visible' => UserModel::isCurrentAdmin()],
-                    ['label' => 'Gii', 'icon' => 'file-code-o', 'url' => ['/gii'], 'visible' => UserModel::isCurrentAdmin()],
-                    ['label' => 'Debug', 'icon' => 'dashboard', 'url' => ['/debug'], 'visible' => UserModel::isCurrentAdmin()],
-                    ['label' => 'Login', 'url' => ['site/login'], 'visible' => !UserModel::isCurrentConnected()],
+                    ['label' => 'Outils', 'options' => ['class' => 'header'], 'visible' =>  User::isCurrentAdmin()],
+                    ['label' => 'Gii', 'icon' => 'file-code-o', 'url' => ['/gii'], 'visible' =>  User::isCurrentAdmin()],
+                    ['label' => 'Debug', 'icon' => 'dashboard', 'url' => ['/debug'], 'visible' =>  User::isCurrentAdmin()],
+                    ['label' => 'Login', 'url' => ['site/login'], 'visible' => ! User::isCurrentConnected()],
                 ],
             ]
         ) ?>

backend/views/layouts/main-old.php

 use yii\bootstrap\NavBar;
 use yii\widgets\Breadcrumbs;
 use common\models\Producer;
-use common\models\UserModel;
+use common\models\ User;
 use yii\widgets\ActiveForm;
 use yii\helpers\ArrayHelper;
 use common\helpers\Url;
 
 $producer = null;
 if (!Yii::$app->user->isGuest) {
-        $producer = ProducerModel::findOne(GlobalParam::getCurrentProducerId());
+        $producer = Producer::findOne(GlobalParam::getCurrentProducerId());
 }
 
 ?>
                 $menuItems[] = ['label' => 'Connexion', 'url' => ['/site/login']];
         } else {
 
-                if (Yii::$app->user->identity->status == UserModel::STATUS_ADMIN) {
+                if (Yii::$app->user->identity->status ==  User::STATUS_ADMIN) {
                         $menuItems[] = [
                                 'label' => '<span class="glyphicon glyphicon-asterisk"></span>',
                                 'url' => '#',
             <?php endif; ?>
             <?php if (!Yii::$app->user->isGuest): ?>
                 <div class="name-producer">
-                        <?php if (UserModel::getCurrentStatus() == UserModel::STATUS_PRODUCER): ?>
+                        <?php if ( User::getCurrentStatus() ==  User::STATUS_PRODUCER): ?>
                             <span><?= Html::encode(Yii::$app->user->identity->getNameProducer()); ?></span>
-                        <?php elseif (UserModel::getCurrentStatus() == UserModel::STATUS_ADMIN): ?>
+                        <?php elseif ( User::getCurrentStatus() ==  User::STATUS_ADMIN): ?>
                                 <?php $form = ActiveForm::begin(['id' => 'select-producer']); ?>
                                 <?=
                                 Html::dropDownList('select_producer', GlobalParam::getCurrentProducerId(), ArrayHelper::map(ProducerModel::find()->orderBy('name ASC')->all(), 'id', function ($model, $defaultValue) {
                         <?php endif; ?>
 
                         <?php
-                        $producer = ProducerModel::findOne(GlobalParam::getCurrentProducerId());
+                        $producer = Producer::findOne(GlobalParam::getCurrentProducerId());
                         if (!$producer->active):
                                 ?>
                             <span class="label label-danger" data-toggle="tooltip" data-placement="bottom"

backend/views/order/report.php

                     
                     $html .= '<td><strong>'.number_format($order->amount, 2) . ' € ';
 
-                    if($order->getPaymentStatus() == OrderModel::PAYMENT_PAID)
+                    if($order->getPaymentStatus() == Order::PAYMENT_PAID)
                     {
                         $html .= '(payé)' ;
                     }
-                    elseif($order->getPaymentStatus() == OrderModel::PAYMENT_UNPAID && $order->getAmount(OrderModel::AMOUNT_PAID))
+                    elseif($order->getPaymentStatus() == Order::PAYMENT_UNPAID && $order->getAmount(Order::AMOUNT_PAID))
                     {
-                        $html .= '(reste '.$order->getAmount(OrderModel::AMOUNT_REMAINING, true).' à payer)' ;
+                        $html .= '(reste '.$order->getAmount(Order::AMOUNT_REMAINING, true).' à payer)' ;
                     }
-                    elseif($order->getPaymentStatus() == OrderModel::PAYMENT_SURPLUS)
+                    elseif($order->getPaymentStatus() == Order::PAYMENT_SURPLUS)
                     {
-                        $html .= '(surplus : '.$order->getAmount(OrderModel::PAYMENT_SURPLUS, true).' à rembourser)' ;
+                        $html .= '(surplus : '.$order->getAmount(Order::PAYMENT_SURPLUS, true).' à rembourser)' ;
                     }
                     
                     $html .= '</strong></td>' ;
                 
                 $strProducts = '';
                 foreach ($productsArray as $product) {
-                    $quantity = OrderModel::getProductQuantity($product->id, $pointSale->orders);
+                    $quantity = Order::getProductQuantity($product->id, $pointSale->orders);
                     $strQuantity = '';
                     if ($quantity) {
                         $strQuantity = $quantity;
     {
         $html .= '<tr><td>'.$pointSale->name.'</td><td>' ;
         foreach ($productsArray as $product) {
-            $quantity = OrderModel::getProductQuantity($product->id, $pointSale->orders);
+            $quantity = Order::getProductQuantity($product->id, $pointSale->orders);
             $strQuantity = ($quantity) ? $quantity : '' ;
                 
             if(strlen($strQuantity)) {
 // total
 $html .= '<tr><td><strong>Total</strong></td><td>' ;
 foreach ($productsArray as $product) {
-    $quantity = OrderModel::getProductQuantity($product->id, $ordersArray);
+    $quantity = Order::getProductQuantity($product->id, $ordersArray);
     if($quantity) {
          $html .= $quantity . '&nbsp;'.$product->name.', ' ;
     }

backend/views/point-sale/_form.php

                 <?= $form->field($model, 'id_user', [
                         'template' => '{label} <a href="' . Yii::$app->urlManager->createUrl(['user/create']) . '" class="btn btn-xs btn-default">Nouvel utilisateur <span class="glyphicon glyphicon-plus"></span></a><div>{input}</div>{hint}',
                 ])
-                        ->dropDownList(UserModel::populateDropdownList(), ['class' => 'select2'])
+                        ->dropDownList( User::populateDropdownList(), ['class' => 'select2'])
                         ->hint('Utilisé lors de la facturation'); ?>
 
                 <?php
 
                 <?= $form->field($model, 'credit_functioning')
                         ->dropDownList([
-                                '' => 'Paramètres globaux (' . ProducerModel::$creditFunctioningArray[ProducerModel::getConfig('credit_functioning')] . ')',
-                                ProducerModel::CREDIT_FUNCTIONING_OPTIONAL => ProducerModel::$creditFunctioningArray[ProducerModel::CREDIT_FUNCTIONING_OPTIONAL],
-                                ProducerModel::CREDIT_FUNCTIONING_MANDATORY => ProducerModel::$creditFunctioningArray[ProducerModel::CREDIT_FUNCTIONING_MANDATORY],
-                                ProducerModel::CREDIT_FUNCTIONING_USER => ProducerModel::$creditFunctioningArray[ProducerModel::CREDIT_FUNCTIONING_USER],
+                                '' => 'Paramètres globaux (' . Producer::$creditFunctioningArray[ProducerModel::getConfig('credit_functioning')] . ')',
+                                Producer::CREDIT_FUNCTIONING_OPTIONAL => Producer::$creditFunctioningArray[ProducerModel::CREDIT_FUNCTIONING_OPTIONAL],
+                                Producer::CREDIT_FUNCTIONING_MANDATORY => Producer::$creditFunctioningArray[ProducerModel::CREDIT_FUNCTIONING_MANDATORY],
+                                Producer::CREDIT_FUNCTIONING_USER => Producer::$creditFunctioningArray[ProducerModel::CREDIT_FUNCTIONING_USER],
                         ], [])->hint(ProducerModel::HINT_CREDIT_FUNCTIONING); ?>
 
                 <?php /*$form->field($model, 'product_price_percent')
-                        ->dropDownList(ProductPriceModel::percentValues(), [])->hint('Pourcentage appliqué aux prix de chaque produit dans ce point de vente.');*/ ?>
+                        ->dropDownList( ProductPrice::percentValues(), [])->hint('Pourcentage appliqué aux prix de chaque produit dans ce point de vente.');*/ ?>
 
                 <?= $form->field($model, 'maximum_number_orders')->textInput() ?>
 
 
                         <?= Html::activeCheckboxList($model, 'users', ArrayHelper::map($users, 'user_id', function ($model_user, $defaultValue) use ($model) {
 
-                                return Html::encode(UserModel::getUsernameFromArray($model_user)) . '<br />'
+                                return Html::encode( User::getUsernameFromArray($model_user)) . '<br />'
                                         . Html::activeTextInput(
                                                 $model,
                                                 'users_comment[' . $model_user['user_id'] . ']',

backend/views/point-sale/index.php

                                                  ],
                                                  'format' => 'raw',
                                                  'value' => function ($model) {
-                                                     $count = UserPointSaleModel::find()->where(
+                                                     $count = UserPointSale::find()->where(
                                                              ['id_point_sale' => $model->id]
                                                      )->count();
                                                      $html = '';
                                                  'format' => 'raw',
                                                  'value' => function ($model) {
                                                      if ($model->credit && isset(ProducerModel::$creditFunctioningArray[$model->credit_functioning])) {
-                                                         return '<span class="glyphicon glyphicon-euro"></span> ' . ProducerModel::$creditFunctioningArray[$model->credit_functioning];
+                                                         return '<span class="glyphicon glyphicon-euro"></span> ' . Producer::$creditFunctioningArray[$model->credit_functioning];
                                                      }
 
                                                      return '';

backend/views/producer-admin/billing.php

 
 use yii\helpers\Html;
 use yii\grid\GridView;
-use common\models\UserModel ;
+use common\models\ User ;
 use common\models\Etablissement ;
 
 $this->title = 'Facturation';

backend/views/producer-admin/index.php

 
 use yii\helpers\Html;
 use yii\grid\GridView;
-use common\models\UserModel ;
+use common\models\ User ;
 use common\models\Producer ;
 use common\models\Distribution ;
 
                 else {
                     foreach($model->user as $u)
                     {
-                        if($u->status == UserModel::STATUS_PRODUCER)
+                        if($u->status ==  User::STATUS_PRODUCER)
                         {
                             return Html::encode($u->lastname.' '.$u->name)
                                 .'<br />'.Html::encode($u->email)

backend/views/producer-price-range-admin/index.php

 
 use yii\helpers\Html;
 use yii\grid\GridView;
-use common\models\UserModel;
+use common\models\ User;
 use common\models\Producer;
 use common\models\Distribution;
 

backend/views/producer/billing.php

 
 use yii\helpers\Html;
 use yii\grid\GridView;
-use common\models\UserModel ;
+use common\models\ User ;
 use common\models\Producer ;
 use yii\bootstrap\ActiveForm;
 

backend/views/producer/update.php

 
 <script>
     var appInitValues = {
-        isAdmin: <?= (int)UserModel::isCurrentAdmin() ?>
+        isAdmin: <?= (int) User::isCurrentAdmin() ?>
     };
 </script>
 
                     ?>
                     <?= $form->field($model, 'behavior_home_point_sale_day_list')
                         ->dropDownList([
-                            ProducerModel::BEHAVIOR_HOME_POINT_SALE_DAY_LIST_WEEK => 'Jours de la semaine',
-                            ProducerModel::BEHAVIOR_HOME_POINT_SALE_DAY_LIST_INCOMING_DISTRIBUTIONS => 'Distributions à venir',
+                            Producer::BEHAVIOR_HOME_POINT_SALE_DAY_LIST_WEEK => 'Jours de la semaine',
+                            Producer::BEHAVIOR_HOME_POINT_SALE_DAY_LIST_INCOMING_DISTRIBUTIONS => 'Distributions à venir',
                         ]); ?>
                 </div>
             </div>
                     <h4>Tunnel de commande</h4>
                     <?= $form->field($model, 'option_order_entry_point')
                         ->dropDownList([
-                            ProducerModel::ORDER_ENTRY_POINT_DATE => 'Date',
-                            ProducerModel::ORDER_ENTRY_POINT_POINT_SALE => 'Point de vente',
+                            Producer::ORDER_ENTRY_POINT_DATE => 'Date',
+                            Producer::ORDER_ENTRY_POINT_POINT_SALE => 'Point de vente',
                         ], []); ?>
                     <?= $form->field($model, 'behavior_order_select_distribution')
                         ->dropDownList([
-                            ProducerModel::BEHAVIOR_ORDER_SELECT_DISTRIBUTION_CALENDAR => 'Calendrier',
-                            ProducerModel::BEHAVIOR_ORDER_SELECT_DISTRIBUTION_LIST => 'Liste',
+                            Producer::BEHAVIOR_ORDER_SELECT_DISTRIBUTION_CALENDAR => 'Calendrier',
+                            Producer::BEHAVIOR_ORDER_SELECT_DISTRIBUTION_LIST => 'Liste',
                         ]); ?>
                     <?= $form->field($model, 'option_delivery')
                         ->dropDownList([
                     <h4>Divers</h4>
                     <?= $form->field($model, 'option_order_reference_type')
                         ->dropDownList([
-                            ProducerModel::ORDER_REFERENCE_TYPE_NONE => '--',
-                            ProducerModel::ORDER_REFERENCE_TYPE_YEARLY => 'Annuelle',
+                            Producer::ORDER_REFERENCE_TYPE_NONE => '--',
+                            Producer::ORDER_REFERENCE_TYPE_YEARLY => 'Annuelle',
                         ], []); ?>
                     <?= $form->field($model, 'option_behavior_cancel_order')
                         ->dropDownList([
-                            ProducerModel::BEHAVIOR_DELETE_ORDER_DELETE => 'Suppression de la commande',
-                            ProducerModel::BEHAVIOR_DELETE_ORDER_STATUS => 'Passage de la commande en statut "supprimé"',
+                            Producer::BEHAVIOR_DELETE_ORDER_DELETE => 'Suppression de la commande',
+                            Producer::BEHAVIOR_DELETE_ORDER_STATUS => 'Passage de la commande en statut "supprimé"',
                         ], []); ?>
                 </div>
             </div>
 
                     <?= $form->field($model, 'credit_functioning')
                         ->dropDownList([
-                            ProducerModel::CREDIT_FUNCTIONING_OPTIONAL => ProducerModel::$creditFunctioningArray[ProducerModel::CREDIT_FUNCTIONING_OPTIONAL],
-                            ProducerModel::CREDIT_FUNCTIONING_MANDATORY => ProducerModel::$creditFunctioningArray[ProducerModel::CREDIT_FUNCTIONING_MANDATORY],
-                            ProducerModel::CREDIT_FUNCTIONING_USER => ProducerModel::$creditFunctioningArray[ProducerModel::CREDIT_FUNCTIONING_USER],
+                            Producer::CREDIT_FUNCTIONING_OPTIONAL => Producer::$creditFunctioningArray[ProducerModel::CREDIT_FUNCTIONING_OPTIONAL],
+                            Producer::CREDIT_FUNCTIONING_MANDATORY => Producer::$creditFunctioningArray[ProducerModel::CREDIT_FUNCTIONING_MANDATORY],
+                            Producer::CREDIT_FUNCTIONING_USER => Producer::$creditFunctioningArray[ProducerModel::CREDIT_FUNCTIONING_USER],
                         ], [])->hint(ProducerModel::HINT_CREDIT_FUNCTIONING); ?>
 
                     <?= $form->field($model, 'use_credit_checked_default')

backend/views/product/_form.php

                         <?= $form->field($model, 'active')->radioList([1 => 'Oui', 0 => 'Non']) ?>
                         <?= $form->field($model, 'name')->textInput(['maxlength' => 255]) ?>
                         <?= $form->field($model, 'reference')->textInput(['maxlength' => 255]) ?>
-                        <?= $form->field($model, 'id_product_category')->dropDownList(ProductCategoryModel::populateDropdownList()); ?>
+                        <?= $form->field($model, 'id_product_category')->dropDownList( ProductCategory::populateDropdownList()); ?>
                         <?= $form->field($model, 'description')->textInput(['maxlength' => 255]) ?>
                         <?= $form->field($model, 'recipe')->textarea()->label('Description longue') ?>
 
                         <?= $form->field($model, 'unit')
-                                ->dropDownList(ArrayHelper::map(ProductModel::$unitsArray, 'unit', 'wording'))
+                                ->dropDownList(ArrayHelper::map( Product::$unitsArray, 'unit', 'wording'))
                                 ->label('Unité (pièce, poids ou volume)'); ?>
 
 
                             <?= $form->field($model, 'available_on_points_sale')->radioList([1 => 'Disponible', 0 => 'Indisponible']) ?>
 
                             <strong id="label-availability-points-sale">Et <span><?php if($model->available_on_points_sale): ?>indisponible<?php else: ?>disponible<?php endif; ?></span> sur les points de vente</strong>
-                            <?php $pointSaleArray = PointSaleModel::find()
+                            <?php $pointSaleArray = PointSale::find()
                                     ->where(['id_producer' => GlobalParam::getCurrentProducerId()])
                                     ->orderBy('is_bread_box ASC, name ASC')
                                     ->all(); ?>

backend/views/product/index.php

                 'value' => function ($model) {
                     $return = '';
                     if ($model->price) {
-                        $return = Price::format($model->getPriceWithTax()) . ' (' . ProductModel::strUnit($model->unit, 'wording_unit', true) . ')';
+                        $return = Price::format($model->getPriceWithTax()) . ' (' .  Product::strUnit($model->unit, 'wording_unit', true) . ')';
                     }
 
                     return $return;

backend/views/product/update/prices/_form.php

 use common\models\TaxRate;
 use common\models\Producer;
 use common\helpers\GlobalParam;
-use common\models\UserModel ;
+use common\models\ User ;
 
 
 ?>
                 'options' => ['enctype' => 'multipart/form-data']
         ]); ?>
 
-        <?= $form->field($model, 'id_user')->dropDownList(UserModel::populateDropdownList()); ?>
-        <?= $form->field($model, 'id_user_group')->dropDownList(UserGroupModel::populateDropdownList()); ?>
-        <?= $form->field($model, 'id_point_sale')->dropDownList(PointSaleModel::populateDropdownList()); ?>
-        <?= $form->field($model, 'from_quantity')->label('À partir de la quantité ('.ProductModel::strUnit(ProductModel::getRefUnit($modelProduct->unit), 'wording').')'); ?>
+        <?= $form->field($model, 'id_user')->dropDownList( User::populateDropdownList()); ?>
+        <?= $form->field($model, 'id_user_group')->dropDownList( UserGroup::populateDropdownList()); ?>
+        <?= $form->field($model, 'id_point_sale')->dropDownList(PointSale::populateDropdownList()); ?>
+        <?= $form->field($model, 'from_quantity')->label('À partir de la quantité ('. Product::strUnit( Product::getRefUnit($modelProduct->unit), 'wording').')'); ?>
 
         <?php
             $producer = GlobalParam::getCurrentProducer();
                 'template' => '
                         <div class="row">
                         <div class="col-xs-6">
-                            <label for="product-price" class="control-label without-tax">Prix ('.ProductModel::strUnit(ProductModel::getRefUnit($modelProduct->unit), 'wording_unit').') HT</label>
+                            <label for="product-price" class="control-label without-tax">Prix ('. Product::strUnit( Product::getRefUnit($modelProduct->unit), 'wording_unit').') HT</label>
                             <div class="input-group">
                             {input} <span class="input-group-addon"><span class="glyphicon glyphicon-euro"></span></span>
                             </div>
                         </div>
                         <div class="col-xs-6">
-                            <label for="productprice-price-with-tax" class="control-label with-tax">Prix ('.ProductModel::strUnit(ProductModel::getRefUnit($modelProduct->unit), 'wording_unit').') TTC</label>
+                            <label for="productprice-price-with-tax" class="control-label with-tax">Prix ('. Product::strUnit( Product::getRefUnit($modelProduct->unit), 'wording_unit').') TTC</label>
                             <div class="input-group">
                                 <input type="text" id="productprice-price-with-tax" class="form-control" name="" value="" data-tax-rate-value="'.$taxRateValue.'">
                                 <span class="input-group-addon"><span class="glyphicon glyphicon-euro"></span></span>

backend/views/product/update/prices/list.php

                                                 'attribute' => 'from_quantity',
                                                 'value' => function ($productPrice) {
                                                     if($productPrice->from_quantity) {
-                                                        return $productPrice->from_quantity.' '.ProductModel::strUnit(ProductModel::getRefUnit($productPrice->product->unit), 'wording');
+                                                        return $productPrice->from_quantity.' '. Product::strUnit( Product::getRefUnit($productPrice->product->unit), 'wording');
                                                     }
 
                                                     return '' ;

backend/views/quotation/index.php

 ?>
 
 <div class="quotation-index">
-        <?php if(QuotationModel::searchCount()): ?>
+        <?php if(Quotation::searchCount()): ?>
                 <?= GridView::widget([
                         'filterModel' => $searchModel,
                         'dataProvider' => $dataProvider,
                                         'attribute' => 'amount',
                                         'header' => 'Montant',
                                         'value' => function($invoice) {
-                                                return $invoice->getAmountWithTax(OrderModel::AMOUNT_TOTAL, true) ;
+                                                return $invoice->getAmountWithTax(Order::AMOUNT_TOTAL, true) ;
                                         }
                                 ],
                                 [

backend/views/site/index.php

                                 </td>
                                 <td><?= $order->getCartSummary() ; ?></td>
                                 <td><?= $order->getPointSaleSummary() ; ?></td>
-                                <td><?= $order->getAmountWithTax(OrderModel::AMOUNT_TOTAL, true) ; ?></td>
+                                <td><?= $order->getAmountWithTax(Order::AMOUNT_TOTAL, true) ; ?></td>
                                 <td class="history"><?= $order->getStrHistory() ; ?></td>
                             </tr>
                             <?php endforeach; ?>

backend/views/subscription/_form.php

 use yii\helpers\Html;
 use yii\widgets\ActiveForm;
 use yii\helpers\ArrayHelper ;
-use common\models\UserModel ;
+use common\models\ User ;
 use common\models\PointSale ;
 use common\helpers\GlobalParam ;
 
         <?= $form->field($model, 'id')->hiddenInput() ?>
     <?php endif; ?>
     <div class="col-md-5" id="bloc-select-user">
-        <?= $form->field($model, 'id_user')->dropDownList(UserModel::populateDropdownList(), ['class' => 'select2']); ?>
+        <?= $form->field($model, 'id_user')->dropDownList( User::populateDropdownList(), ['class' => 'select2']); ?>
     </div>
     <div class="col-md-1" id="or-user">
         <span>OU</span>
     <div class="clr"></div>
     
     <?= $form->field($model, 'id_producer')->hiddenInput() ?>
-    <?= $form->field($model, 'id_point_sale')->dropDownList(ArrayHelper::map(PointSaleModel::searchAll(), 'id', function($model, $defaultValue) {
+    <?= $form->field($model, 'id_point_sale')->dropDownList(ArrayHelper::map(PointSale::searchAll(), 'id', function($model, $defaultValue) {
         return $model['name'];
     }), ['prompt' => '--','class' => 'form-control user-id']) ?>
     <?= $form->field($model, 'date_begin') ?>
 
     <?= $form->field($model, 'auto_payment')
         ->dropDownList([
-                SubscriptionModel::AUTO_PAYMENT_DEDUCTED => 'Déduit',
-                SubscriptionModel::AUTO_PAYMENT_YES => 'Oui',
-                SubscriptionModel::AUTO_PAYMENT_NO => 'Non'
+                 Subscription::AUTO_PAYMENT_DEDUCTED => 'Déduit',
+                 Subscription::AUTO_PAYMENT_YES => 'Oui',
+                 Subscription::AUTO_PAYMENT_NO => 'Non'
         ])
         ->hint('Attention, un compte client existant doit être spécifié en haut de ce formulaire.') ?>
     

backend/views/subscription/index.php

 $this->addBreadcrumb($this->getTitle()) ;
 $this->addButton(['label' => 'Nouvel abonnement <span class="glyphicon glyphicon-plus"></span>', 'url' => 'subscription/create', 'class' => 'btn btn-primary']) ;
 
-$subscriptionsArray = SubscriptionModel::searchAll() ;
+$subscriptionsArray =  Subscription::searchAll() ;
 
 
 
                     foreach($model->productSubscription as $productSubscription)
                     {
                         if(isset($productSubscription->product)) {
-                            $html .= Html::encode($productSubscription->product->name).' ('.($productSubscription->quantity * ProductModel::$unitsArray[$productSubscription->product->unit]['coefficient']).'&nbsp;'.ProductModel::strUnit($productSubscription->product->unit, 'wording_short').')<br />' ;
+                            $html .= Html::encode($productSubscription->product->name).' ('.($productSubscription->quantity *  Product::$unitsArray[$productSubscription->product->unit]['coefficient']).'&nbsp;'. Product::strUnit($productSubscription->product->unit, 'wording_short').')<br />' ;
                         }
                         else {
                             $html .= 'Produit non défini<br />'  ;
                 'attribute' => 'id_point_sale',
                 'label' => 'Point de vente',
                 'format' => 'raw',
-                'filter' => ArrayHelper::map(PointSaleModel::find()->where(['id_producer' => GlobalParam::getCurrentProducerId()])->asArray()->all(), 'id', 'name'),
+                'filter' => ArrayHelper::map(PointSale::find()->where(['id_producer' => GlobalParam::getCurrentProducerId()])->asArray()->all(), 'id', 'name'),
                 'value' => function($model) {
                     return Html::encode($model->pointSale->name) ;
                 }

backend/views/tax-rate-admin/index.php

 
 use yii\helpers\Html;
 use yii\grid\GridView;
-use common\models\UserModel;
+use common\models\ User;
 use common\models\Producer;
 use common\models\Distribution;
 

backend/views/user/_form.php

                 ]); ?>
 
                 <?= $form->field($model, 'type')
-                        ->dropDownList(UserModel::getTypeChoicesArray(), [
+                        ->dropDownList( User::getTypeChoicesArray(), [
                             'v-model' => 'type'
                         ]) ; ?>
                 <?= $form->field($model, 'name_legal_person', ['options' => ['v-show' => "type == 'legal-person'"]])->textInput() ?>
                 ?>
 
                 <?php /* $form->field($model, 'product_price_percent')
-                        ->dropDownList(ProductPriceModel::percentValues(), [])->hint('Pourcentage appliqué aux prix de chaque produit pour cet utilisateur.');*/ ?>
+                        ->dropDownList( ProductPrice::percentValues(), [])->hint('Pourcentage appliqué aux prix de chaque produit pour cet utilisateur.');*/ ?>
 
                 <div class="form-group">
                         <?= Html::submitButton($model->isNewRecord ? 'Ajouter' : 'Modifier', ['class' => $model->isNewRecord ? 'btn btn-success' : 'btn btn-primary']) ?>

backend/views/user/credit.php

 <div class="user-credit">
     
     <?php
-        $producer = ProducerModel::searchOne([
+        $producer = Producer::searchOne([
             'id' => GlobalParam::getCurrentProducerId()
         ]);
         
             <div class="panel-body">
                 <?php $form = ActiveForm::begin(); ?>
                 <?= $form->field($creditForm, 'type')->dropDownList([
-                    CreditHistoryModel::TYPE_CREDIT => 'Crédit',
-                    CreditHistoryModel::TYPE_DEBIT => 'Débit',
+                     CreditHistory::TYPE_CREDIT => 'Crédit',
+                     CreditHistory::TYPE_DEBIT => 'Débit',
                 ]) ?>
                 <?= $form->field($creditForm, 'amount')->textInput() ?>
                 <?= $form->field($creditForm, 'mean_payment')->dropDownList([

backend/views/user/index.php

 
 use yii\helpers\Html;
 use yii\grid\GridView;
-use common\models\UserModel;
+use common\models\ User;
 use common\models\Order;
 
 $this->setTitle('Utilisateurs');
             'attribute' => 'username',
             'label' => 'Nom',
             'value' => function ($model) {
-                return UserModel::getUsernameFromArray($model);
+                return  User::getUsernameFromArray($model);
             }
         ],
         [
             'attribute' => 'type',
             'label' => 'Type',
             'value' => function ($model) {
-                $typeArray = UserModel::getTypeChoicesArray();
+                $typeArray =  User::getTypeChoicesArray();
                 if(isset($typeArray[$model['type']])) {
                     return $typeArray[$model['type']];
                 }
             'buttons' => [
                 'orders' => function ($url, $model) {
                     $url = Yii::$app->urlManager->createUrl(['user/orders', 'id' => $model['id']]);
-                    $countOrders = OrderModel::searchCount([
+                    $countOrders = Order::searchCount([
                         'id_user' => $model['id'],
                     ], ['conditions' => 'date_delete IS NULL']);
 
             'format' => 'raw',
             'value' => function ($model) use ($producer) {
 
-                $userProducer = UserProducerModel::searchOne([
+                $userProducer =  UserProducer::searchOne([
                     'id_user' => $model->id
                 ]);
                 $credit = $userProducer ? $userProducer->credit : 0;
             'buttons' => [
                 'update' => function ($url, $model) {
                     $url = Yii::$app->urlManager->createUrl(['user/update', 'id' => $model->id]);
-                    $user = UserModel::find()->with('userProducer')->where(['id' => $model->id])->one();
+                    $user =  User::find()->with('userProducer')->where(['id' => $model->id])->one();
                     return Html::a('<span class="glyphicon glyphicon-pencil"></span>', $url, [
                         'title' => Yii::t('app', 'Modifier'), 'class' => 'btn btn-default'
                     ]);

common/config/main.php

                 ],
                 'user' => [
                         'class' => 'yii\web\User',
-                        'identityClass' => 'common\logic\User\User\UserModel',
+                        'identityClass' => 'common\logic\User\User\User',
                         'enableAutoLogin' => true,
                         'identityCookie' => [
                                 'name' => 'distrib',

common/controllers/CommonController.php

 namespace common\controllers;
 
 use common\components\BusinessLogic;
-use common\logic\User\User\UserModel;
+use common\logic\User\User\User;
 use yii;
 
 class CommonController extends \yii\web\Controller 

common/forms/LoginForm.php

 namespace common\forms;
 
 use common\logic\Producer\Producer\Producer;
-use common\logic\User\User\UserModel;
+use common\logic\User\User\User;
 use Yii;
 use yii\base\Model;
 
      * Finds user by [[username]]
      *
      */
-    public function getUser(): UserModel
+    public function getUser(): User
     {
         if ($this->_user === false) {
-            $this->_user = UserModel::searchOne(
+            $this->_user = User::searchOne(
                 ['email' => $this->email],
                 [
                     'conditions' => 'type LIKE :type_individual OR type LIKE :type_legal_person',
-                    'params' => [':type_individual' => UserModel::TYPE_INDIVIDUAL, ':type_legal_person' => UserModel::TYPE_LEGAL_PERSON]
+                    'params' => [':type_individual' => User::TYPE_INDIVIDUAL, ':type_legal_person' => User::TYPE_LEGAL_PERSON]
                 ]
             );
         }

common/forms/SubscriptionForm.php

     public function save() 
     {
         if ($this->id) {
-            $subscription = SubscriptionModel::searchOne(['id' => $this->id]) ;
+            $subscription =  Subscription::searchOne(['id' => $this->id]) ;
         } 
         else {
             $subscription = new Subscription ;
 
             // produits
             if ($this->id) {
-                $productsSubscriptionsArray = ProductSubscriptionModel::findAll(['id_subscription' => $this->id]) ;
-                ProductSubscriptionModel::deleteAll(['id_subscription' => $this->id]);
+                $productsSubscriptionsArray =  ProductSubscription::findAll(['id_subscription' => $this->id]) ;
+                 ProductSubscription::deleteAll(['id_subscription' => $this->id]);
             }
 
             foreach ($this->products as $nameInput => $quantity) {
                 if ($quantity) {
                     $idProduct = (int) str_replace('product_', '', $nameInput);
-                    $product = ProductModel::findOne($idProduct) ;
+                    $product =  Product::findOne($idProduct) ;
 
                     $newProductSubscription = new ProductSubscription;
                     $newProductSubscription->id_subscription = $subscription->id;
                     $newProductSubscription->id_product = $idProduct;
-                    $newProductSubscription->quantity = $quantity / ProductModel::$unitsArray[$product->unit]['coefficient'];
+                    $newProductSubscription->quantity = $quantity /  Product::$unitsArray[$product->unit]['coefficient'];
 
                     $newProductSubscription->save();
                 }

common/helpers/Price.php

                 return floatval($priceWithTax) / ($taxRate + 1);
         }
 
-        public static function getPriceWithTax($priceWithoutTax, $taxRate, $taxCalculationMethod = DocumentModel::TAX_CALCULATION_METHOD_DEFAULT)
+        public static function getPriceWithTax($priceWithoutTax, $taxRate, $taxCalculationMethod = Document::TAX_CALCULATION_METHOD_DEFAULT)
         {
             $vat = self::getVat($priceWithoutTax, $taxRate, $taxCalculationMethod);
 
             return self::numberTwoDecimals(self::round($priceWithoutTax + $vat));
         }
 
-        public static function getVat($priceTotalWithoutTax, $taxRate, $taxCalculationMethod = DocumentModel::TAX_CALCULATION_METHOD_DEFAULT)
+        public static function getVat($priceTotalWithoutTax, $taxRate, $taxCalculationMethod = Document::TAX_CALCULATION_METHOD_DEFAULT)
         {
             $vat = $priceTotalWithoutTax * $taxRate;
 
-            if($taxCalculationMethod == DocumentModel::TAX_CALCULATION_METHOD_SUM_OF_ROUNDINGS) {
+            if($taxCalculationMethod == Document::TAX_CALCULATION_METHOD_SUM_OF_ROUNDINGS) {
                 $vat = self::round($vat);
             }
 

common/helpers/Tiller.php

     {
         if ($this->producer_tiller) {
             $ordersTiller = $this->getOrders($date);
-            $ordersOpendistrib = OrderModel::searchAll([
+            $ordersOpendistrib = Order::searchAll([
                                                           'distribution.date' => $date,
                                                           'order.tiller_synchronization' => 1
                                                   ], [
                         foreach ($ordersTiller->orders as $orderTiller) {
                             if ($orderOpendistrib->tiller_external_id == $orderTiller->id) {
                                 $amountTotalOrderOpendistrib = (int)round(
-                                        $orderOpendistrib->getAmountWithTax(OrderModel::AMOUNT_TOTAL) * 100
+                                        $orderOpendistrib->getAmountWithTax(Order::AMOUNT_TOTAL) * 100
                                 );
                                 if ($amountTotalOrderOpendistrib == (int)$orderTiller->currentPayedAmount
                                         || $amountTotalOrderOpendistrib == (int)$orderTiller->currentBill) {

common/logic/Distribution/Distribution/Distribution.php

 
 use common\logic\Distribution\PointSaleDistribution\PointSaleDistribution;
 use common\logic\Distribution\ProductDistribution\ProductDistribution;
-use common\logic\Order\Order\OrderModel;
+use common\logic\Order\Order\Order;
 use common\logic\Producer\Producer\Producer;
 use common\helpers\GlobalParam;
 use common\components\ActiveRecordCommon;
     {
         return [
             [['date'], 'required'],
+            [['active'], 'integer'],
             [['date'], 'safe'],
-            [['active'], 'integer']
         ];
     }
 
 
     public function getOrder()
     {
-        return $this->hasMany(OrderModel::class, ['id_distribution' => 'id']);
+        return $this->hasMany(Order::class, ['id_distribution' => 'id']);
     }
 
     public function getProductDistribution()
      */
     public static function linkProductIncomingDistributions($product)
     {
-        $distributionsArray = self::getIncomingDistributions();
+        $distributionsArray = self::getIncoming();
         foreach ($distributionsArray as $distribution) {
             $distribution->linkProduct($product);
         }
      */
     public static function linkPointSaleIncomingDistributions($pointSale)
     {
-        $distributionsArray = self::getIncomingDistributions();
+        $distributionsArray = self::getIncoming();
         foreach ($distributionsArray as $distribution) {
             $distribution->linkPointSale($pointSale);
         }
 
         if ($active) {
             // ajout des abonnements
-            SubscriptionModel::addAll($this->date);
+             Subscription::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\Distribution\ProductDistribution\ProductDistributionBuilder;
+use common\logic\Distribution\ProductDistribution\ProductDistributionRepository;
+use common\logic\Order\Order\Order;
+use common\logic\Order\Order\OrderRepository;
 use common\logic\Producer\Producer\Producer;
 use common\logic\Product\Product\Product;
+use common\logic\Product\Product\ProductRepository;
+use common\logic\User\UserProducer\UserProducer;
 
 class DistributionBuilder extends BaseService implements BuilderInterface
 {
     protected DistributionRepository $distributionRepository;
     protected PointSaleDistributionRepository $pointSaleDistributionRepository;
     protected PointSaleDistributionBuilder $pointSaleDistributionBuilder;
+    protected ProductRepository $productRepository;
+    protected ProductDistributionRepository $productDistributionRepository;
+    protected ProductDistributionBuilder $productDistributionBuilder;
+    protected OrderRepository $orderRepository;
 
     public function __construct()
     {
         $this->distributionRepository = $this->loadService(DistributionRepository::class);
         $this->pointSaleDistributionRepository = $this->loadService(PointSaleDistributionRepository::class);
         $this->pointSaleDistributionBuilder = $this->loadService(PointSaleDistributionBuilder::class);
+        $this->productRepository = $this->loadService(ProductRepository::class);
+        $this->productDistributionRepository = $this->loadService(ProductDistributionRepository::class);
+        $this->orderRepository = $this->loadService(OrderRepository::class);
     }
 
     public function instanciate(Producer $producer, string $date, bool $delivery = true): Distribution
         return $distribution;
     }
 
-    public function create(Producer $producer, string $date, int $delivery = 1): Distribution
+    // initDistribution
+    public function create(Producer $producer, string $date, bool $delivery = true): Distribution
     {
-        $distribution = $this->instanciate($producer, $date, 1);
+        $distribution = $this->instanciate($producer, $date, $delivery);
         $distribution->save();
 
+        $this->initPointSaleDistribution($distribution);
+        $this->initProductDistribution($distribution);
+
         return $distribution;
     }
 
         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);
+            $this->pointSaleDistributionBuilder->createAll($distribution, true);
         }
     }
 
-    public function initProductDistribution(Distribution $distribution)
+    public function initProductDistribution(Distribution $distribution): void
     {
-        $products = Product::searchAll();
+        $productArray = $this->productRepository->get();
+        $countProductDistribution = $this->productDistributionRepository->countByDistribution($distribution);
 
-        $productsDistribution = ProductDistribution::searchAll([
-            'id_distribution' => $distribution->id
-        ]);
-        if (!count($productsDistribution)) {
-            foreach ($products as $product) {
+        if (!$countProductDistribution) {
+            foreach ($productArray as $product) {
                 $this->linkProduct($distribution, $product);
             }
         }
      */
     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;
-        }
+        $productDistribution = $this->productDistributionBuilder->createIfNotExist($distribution, $product);
+        $this->updateOrderProductPrices($distribution, $product);
 
-        $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;
-        }
+        return $productDistribution;
+    }
+
+    public function updateOrderProductPrices(Distribution $distribution, Product $product): void
+    {
+        $ordersArray = $this->orderRepository->getByDistribution($distribution, 'AND origin != "user"');
 
-        $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) {
                         $userProducer = false;
                         if (isset($order->user) && $order->user) {
                             $user = $order->user;
-                            $userProducer = UserProducerModel::searchOne([
+                            $userProducer = UserProducer::searchOne([
                                 'id_user' => $user->id,
                                 'id_producer' => $order->distribution->id_producer
                             ]);
                 }
             }
         }
-
-        return $productDistribution;
     }
 }

common/logic/Distribution/Distribution/DistributionRepository.php

     /**
      * Récupère les distributions futures.
      */
-    public function getIncomingDistributions(): array
+    public function getIncoming(): array
     {
         $distributionsArray = Distribution::find()
             ->where('date > \'' . date('Y-m-d') . '\'')

common/logic/Distribution/Distribution/DistributionSolver.php

 
 class DistributionSolver extends BaseService implements SolverInterface
 {
+    public function getDayAsString(Distribution $distribution): string
+    {
+        $dayDistribution = date('N', strtotime($distribution->date));
+
+        $daysArray = [
+            1 => 'monday',
+            2 => 'tuesday',
+            3 => 'wednesday',
+            4 => 'thursday',
+            5 => 'friday',
+            6 => 'saturday',
+            7 => 'sunday',
+        ];
+
+        return $daysArray[$dayDistribution];
+    }
+
     /**
      * Déduit si un produit est actif ou non
      */

common/logic/Distribution/PointSaleDistribution/PointSaleDistribution.php

 
     public function getPointSale() 
     {
-        return $this->hasOne(PointSaleModel::className(), ['id' => 'id_point_sale']);
+        return $this->hasOne(PointSale::className(), ['id' => 'id_point_sale']);
     }
     
     /**

common/logic/Distribution/PointSaleDistribution/PointSaleDistributionBuilder.php

      * Initialise les PointSaleDistribution pour une distribution donnée.
      */
     // setAll
-    public function initAll(Distribution $distribution, bool $delivery): void
+    public function createAll(Distribution $distribution, bool $delivery): void
     {
         $arrPointsSale = PointSale::find()
             ->with(['pointSaleDistribution' => function($q) use ($distribution) {

common/logic/Distribution/ProductDistribution/ProductDistribution.php

     
     public function getProduct() 
     {
-        return $this->hasOne(ProductModel::className(), ['id' => 'id_product']);
+        return $this->hasOne( Product::className(), ['id' => 'id_product']);
     }
     
     public function getDistribution() 
             'id_distribution' => $idDistribution
         ]) ;
        
-        $orders = OrderModel::searchAll([
+        $orders = Order::searchAll([
             'distribution.id' => $idDistribution
         ]) ;
 
                     'active' => (int) $productDistribution->active,
                     'unavailable' => (int) $productDistribution->product->unavailable,
                     'quantity_max' => $productDistribution->quantity_max,
-                    'quantity_order' => OrderModel::getProductQuantity($productDistribution->id_product, $orders),
-                    'quantity_remaining' => $productDistribution->quantity_max - OrderModel::getProductQuantity($productDistribution->id_product, $orders)
+                    'quantity_order' => Order::getProductQuantity($productDistribution->id_product, $orders),
+                    'quantity_remaining' => $productDistribution->quantity_max - Order::getProductQuantity($productDistribution->id_product, $orders)
                 ];
             }
         }

common/logic/Distribution/ProductDistribution/ProductDistributionBuilder.php

 namespace common\logic\Distribution\ProductDistribution;
 
 use common\logic\BaseService;
+use common\logic\Distribution\Distribution\Distribution;
+use common\logic\Distribution\Distribution\DistributionSolver;
 use common\logic\FactoryInterface;
+use common\logic\Product\Product\Product;
 
 class ProductDistributionBuilder extends BaseService implements FactoryInterface
 {
-    public function create(): ProductDistribution
+    protected ProductDistributionRepository $productDistributionRepository;
+    protected DistributionSolver $distributionSolver;
+
+    public function __construct()
+    {
+        $this->productDistributionRepository = $this->loadService(ProductDistributionRepository::class);
+        $this->distributionSolver = $this->loadService(DistributionSolver::class);
+    }
+
+    public function instanciate(Distribution $distribution, Product $product): ProductDistribution
     {
         $productDistribution = new ProductDistribution();
 
+        $productDistribution->populateRelation('distribution', $distribution);
+        $productDistribution->id_distribution = $distribution->id;
+
+        $productDistribution->populateRelation('product', $product);
+        $productDistribution->id_product = $product->id;
+
         return $productDistribution;
     }
+
+    public function create(Distribution $distribution, Product $product): ProductDistribution
+    {
+        $productDistribution = $this->instanciate($distribution, $product);
+
+        $this
+            ->initActive($productDistribution)
+            ->initQuantityMax($productDistribution);
+
+        $productDistribution->save();
+    }
+
+    public function createIfNotExist(Distribution $distribution, Product $product): ProductDistribution
+    {
+        $productDistribution = $this->productDistributionRepository->getOne($distribution, $product);
+        if(!$productDistribution) {
+            $productDistribution = $this->create($distribution, $product);
+        }
+
+        return $productDistribution;
+    }
+
+    public function initActive(ProductDistribution $productDistribution): ProductDistribution
+    {
+        $day = $this->distributionSolver->getDayAsString($productDistribution->distribution);
+
+        $productDistribution->active = 0;
+        if ($productDistribution->product->active && $productDistribution->product->$day) {
+            $productDistribution->active = 1;
+        }
+
+        return $productDistribution;
+    }
+
+    public function initQuantityMax(ProductDistribution $productDistribution): ProductDistribution
+    {
+        $product = $productDistribution->product;
+        $day = $this->distributionSolver->getDayAsString($productDistribution->distribution);
+
+        $productDistribution->quantity_max = $product->quantity_max;
+        $fieldQuantityMax = 'quantity_max_' . $day;
+        if (isset($product->$fieldQuantityMax) && $product->$fieldQuantityMax > 0) {
+            $productDistribution->quantity_max = $product->$fieldQuantityMax;
+        }
+
+        return $productDistribution;
+    }
+
 }

common/logic/Distribution/ProductDistribution/ProductDistributionRepository.php

 namespace common\logic\Distribution\ProductDistribution;
 
 use common\logic\BaseService;
+use common\logic\Distribution\Distribution\Distribution;
+use common\logic\Product\Product\Product;
 use common\logic\RepositoryInterface;
 
 class ProductDistributionRepository extends BaseService implements RepositoryInterface
 {
+    public function countByDistribution(Distribution $distribution): int
+    {
+        return ProductDistribution::searchCount([
+            'id_distribution' => $distribution->id
+        ]);
+    }
 
+    public function getOne(Distribution $distribution, Product $product): ?ProductDistribution
+    {
+        return ProductDistribution::searchOne([
+            'id_distribution' => $distribution->id,
+            'id_product' => $product->id
+        ]);
+    }
 }

common/logic/Document/DeliveryNote/DeliveryNoteModel.php → common/logic/Document/DeliveryNote/DeliveryNote.php

  * @property string $city
  * @property string $postcode
  */
-class DeliveryNoteModel extends Document
+class DeliveryNote extends Document
 {
 
         /**
             $idInvoice = $this->getInvoiceId();
 
             if($idInvoice) {
-                $invoice = InvoiceModel::searchOne([
+                $invoice = Invoice::searchOne([
                     'id' => $idInvoice
                 ]);
             }

common/logic/Document/DeliveryNote/DeliveryNoteContainer.php

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

common/logic/Document/DeliveryNote/DeliveryNoteFactory.php

 
 class DeliveryNoteFactory extends BaseService implements FactoryInterface
 {
-    public function create(): DeliveryNoteModel
+    public function create(): DeliveryNote
     {
-        $deliveryNote = new DeliveryNoteModel();
+        $deliveryNote = new DeliveryNote();
 
         return $deliveryNote;
     }

common/logic/Document/DeliveryNote/DeliveryNoteSearch.php

 use common\helpers\GlobalParam;
 use yii\data\ActiveDataProvider;
 
-class DeliveryNoteSearch extends DeliveryNoteModel
+class DeliveryNoteSearch extends DeliveryNote
 {
         public $id_point_sale ;
         public $date_distribution ;
         {
                 $optionsSearch = self::defaultOptionsSearch();
 
-                $query = DeliveryNoteModel::find()
+                $query = DeliveryNote::find()
                         ->with($optionsSearch['with'])
                         ->joinWith($optionsSearch['join_with'])
                         ->where(['delivery_note.id_producer' => GlobalParam::getCurrentProducerId()])

common/logic/Document/Document/DocumentModel.php → common/logic/Document/Document/Document.php

 use kartik\mpdf\Pdf;
 use yii\base\ErrorException;
 
-class DocumentModel extends ActiveRecordCommon
+class Document extends ActiveRecordCommon
 {
     const STATUS_DRAFT = 'draft';
     const STATUS_VALID = 'valid';
 
     public function getUser()
     {
-        return $this->hasOne(UserModel::className(), ['id' => 'id_user']);
+        return $this->hasOne( User::className(), ['id' => 'id_user']);
     }
 
     public function getProducer()
 
     public function relationOrders($fieldIdDocument)
     {
-        $defaultOptionsSearch = OrderModel::defaultOptionsSearch();
+        $defaultOptionsSearch = Order::defaultOptionsSearch();
 
-        return $this->hasMany(OrderModel::className(), [$fieldIdDocument => 'id'])
+        return $this->hasMany(Order::className(), [$fieldIdDocument => 'id'])
             ->with($defaultOptionsSearch['with'])
             ->joinWith($defaultOptionsSearch['join_with'])
             ->orderBy('distribution.date ASC');
      * Méthodes
      */
 
-    public function getAmount($type = OrderModel::AMOUNT_TOTAL, $format = false)
+    public function getAmount($type = Order::AMOUNT_TOTAL, $format = false)
     {
         return $this->_getAmountGeneric($type, false, $format);
     }
 
-    public function getAmountWithTax($type = OrderModel::AMOUNT_TOTAL, $format = false)
+    public function getAmountWithTax($type = Order::AMOUNT_TOTAL, $format = false)
     {
         return $this->_getAmountGeneric($type, true, $format);
     }
 
-    protected function _getAmountGeneric($type = OrderModel::AMOUNT_TOTAL, $withTax = true, $format = false)
+    protected function _getAmountGeneric($type = Order::AMOUNT_TOTAL, $withTax = true, $format = false)
     {
         $amount = 0;
         $totalVat = 0;
         }
 
         $prefix = Producer::getConfig('document_' . $classLower . '_prefix');
-        $oneDocumentExist = $class::searchOne(['status' => DocumentModel::STATUS_VALID], ['orderby' => 'reference DESC']);
+        $oneDocumentExist = $class::searchOne(['status' => Document::STATUS_VALID], ['orderby' => 'reference DESC']);
 
         if ($oneDocumentExist) {
             $reference = $oneDocumentExist->reference;
 
     public function changeStatus($status)
     {
-        if ($status == DocumentModel::STATUS_VALID) {
+        if ($status == Document::STATUS_VALID) {
             $this->status = $status;
             $this->reference = $this->generateReference();
         }

common/logic/Document/Document/DocumentContainer.php

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

common/logic/Document/Invoice/InvoiceModel.php → common/logic/Document/Invoice/Invoice.php

 
 namespace common\logic\Document\Invoice;
 
-use common\logic\Document\Document\DocumentModel;
+use common\logic\Document\Document\Document;
 
 /**
  * This is the model class for table "invoice".
  * @property string $city
  * @property string $postcode
  */
-class InvoiceModel extends DocumentModel
+class Invoice extends Document
 {
 
         public $deliveryNotes ;

common/logic/Document/Invoice/InvoiceContainer.php

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

common/logic/Document/Invoice/InvoiceFactory.php

 
 class InvoiceFactory extends BaseService implements FactoryInterface
 {
-    public function create(): InvoiceModel
+    public function create(): Invoice
     {
-        $invoice = new InvoiceModel();
+        $invoice = new Invoice();
 
         return $invoice;
     }

common/logic/Document/Invoice/InvoiceSearch.php

 
 use common\helpers\GlobalParam;
 
-class InvoiceSearch extends InvoiceModel
+class InvoiceSearch extends Invoice
 {
     var $username;
 
     {
         $optionsSearch = self::defaultOptionsSearch();
 
-        $query = InvoiceModel::find()
+        $query = Invoice::find()
             ->with($optionsSearch['with'])
             ->joinWith($optionsSearch['join_with'])
             ->where(['invoice.id_producer' => GlobalParam::getCurrentProducerId()])

common/logic/Document/Quotation/QuotationModel.php → common/logic/Document/Quotation/Quotation.php

 
 namespace common\logic\Document\Quotation;
 
-use common\logic\Document\Document\DocumentModel;
+use common\logic\Document\Document\Document;
 
 /**
  * This is the model class for table "quotation".
  * @property string $city
  * @property string $postcode
  */
-class QuotationModel extends DocumentModel
+class Quotation extends Document
 {
 
         /**

common/logic/Document/Quotation/QuotationContainer.php

 use common\logic\Document\Document\DocumentBuilder;
 use common\logic\Document\Document\DocumentSolver;
 use common\logic\Document\Quotation\QuotationFactory;
-use common\logic\Document\Quotation\QuotationModel;
+use common\logic\Document\Quotation\Quotation;
 
 class QuotationContainer implements ContainerInterface
 {
     public function getEntityFqcn(): string
     {
-        return QuotationModel::class;
+        return Quotation::class;
     }
 
     public function getServices(): array

common/logic/Document/Quotation/QuotationFactory.php

 
 class QuotationFactory extends BaseService implements FactoryInterface
 {
-    public function create(): QuotationModel
+    public function create(): Quotation
     {
-        $quotation = new QuotationModel();
+        $quotation = new Quotation();
 
         return $quotation;
     }

common/logic/Document/Quotation/QuotationSearch.php

 use common\helpers\GlobalParam;
 use yii\data\ActiveDataProvider;
 
-class QuotationSearch extends QuotationModel
+class QuotationSearch extends Quotation
 {
 
         public function rules()
         {
                 $optionsSearch = self::defaultOptionsSearch();
 
-                $query = QuotationModel::find()
+                $query = Quotation::find()
                         ->with($optionsSearch['with'])
                         ->joinWith($optionsSearch['join_with'])
                         ->where(['quotation.id_producer' => GlobalParam::getCurrentProducerId()])

common/logic/Order/Order/OrderModel.php → common/logic/Order/Order/Order.php

 use common\helpers\GlobalParam;
 use common\helpers\Price;
 use common\logic\Producer\Producer\Producer;
-use common\logic\User\CreditHistory\CreditHistoryModel;
-use common\logic\User\User\UserModel;
+use common\logic\User\CreditHistory\CreditHistory;
+use common\logic\User\User\User;
 use Yii;
 use yii\helpers\Html;
 use common\components\ActiveRecordCommon;
  * This is the model class for table "order".
  *
  */
-class OrderModel extends ActiveRecordCommon
+class Order extends ActiveRecordCommon
 {
     var $amount = 0;
     var $amount_with_tax = 0;
 
     public function getUser()
     {
-        return $this->hasOne(UserModel::className(), ['id' => 'id_user']);
+        return $this->hasOne(User::className(), ['id' => 'id_user']);
     }
 
     public function getProductOrder()
     {
-        return $this->hasMany(ProductOrderModel::className(), ['id_order' => 'id'])
+        return $this->hasMany(ProductOrder::className(), ['id_order' => 'id'])
                 ->orderBy(['product.order' => SORT_ASC])
                 ->joinWith('product');
     }
 
     public function getPointSale()
     {
-        return $this->hasOne(PointSaleModel::className(), ['id' => 'id_point_sale'])
+        return $this->hasOne(PointSale::className(), ['id' => 'id_point_sale'])
                 ->with('userPointSale');
     }
 
     public function getCreditHistory()
     {
-        return $this->hasMany(CreditHistoryModel::class, ['id_order' => 'id']);
+        return $this->hasMany(CreditHistory::class, ['id_order' => 'id']);
     }
 
     public function getSubscription()
     {
-        return $this->hasOne(SubscriptionModel::className(), ['id' => 'id_subscription'])
+        return $this->hasOne( Subscription::className(), ['id' => 'id_subscription'])
                 ->with('productSubscription');
     }
 
     public function getInvoice()
     {
-        return $this->hasOne(InvoiceModel::className(), ['id' => 'id_invoice']);
+        return $this->hasOne(Invoice::className(), ['id' => 'id_invoice']);
     }
 
     public function getQuotation()
     {
-        return $this->hasOne(QuotationModel::className(), ['id' => 'id_quotation']);
+        return $this->hasOne(Quotation::className(), ['id' => 'id_quotation']);
     }
 
     public function getDeliveryNote()
     {
-        return $this->hasOne(DeliveryNoteModel::className(), ['id' => 'id_delivery_note']);
+        return $this->hasOne(DeliveryNote::className(), ['id' => 'id_delivery_note']);
     }
 
     /**
      * Initialise le montant total, le montant déjà payé et le poids de la
      * commande.
      */
-    public function init($taxCalculationMethod = DocumentModel::TAX_CALCULATION_METHOD_DEFAULT)
+    public function init($taxCalculationMethod = Document::TAX_CALCULATION_METHOD_DEFAULT)
     {
         $this->initAmount($taxCalculationMethod);
         $this->initPaidAmount();
      * Initialise le montant de la commande.
      *
      */
-    public function initAmount($taxCalculationMethod = DocumentModel::TAX_CALCULATION_METHOD_DEFAULT)
+    public function initAmount($taxCalculationMethod = Document::TAX_CALCULATION_METHOD_DEFAULT)
     {
         $this->amount = 0;
         $this->amount_with_tax = 0;
         if (isset($this->creditHistory)) {
             $history = $this->creditHistory;
         } else {
-            $history = CreditHistoryModel::find()
+            $history = CreditHistory::find()
                     ->where(['id_order' => $this->id])
                     ->all();
         }
 
         if (count($history)) {
             foreach ($history as $ch) {
-                if ($ch->type == CreditHistoryModel::TYPE_PAYMENT) {
+                if ($ch->type == CreditHistory::TYPE_PAYMENT) {
                     $this->paid_amount += $ch->amount;
-                } elseif ($ch->type == CreditHistoryModel::TYPE_REFUND) {
+                } elseif ($ch->type == CreditHistory::TYPE_REFUND) {
                     $this->paid_amount -= $ch->amount;
                 }
             }
     public function delete($force = false)
     {
         // remboursement si l'utilisateur a payé pour cette commande
-        $amountPaid = $this->getAmount(OrderModel::AMOUNT_PAID);
+        $amountPaid = $this->getAmount(Order::AMOUNT_PAID);
         if ($amountPaid > 0.01) {
             $this->saveCreditHistory(
-                    CreditHistoryModel::TYPE_REFUND,
+                    CreditHistory::TYPE_REFUND,
                     $amountPaid,
                     GlobalParam::getCurrentProducerId(),
                     $this->id_user,
-                    UserModel::getCurrentId()
+                    User::getCurrentId()
             );
         }
 
                                 'option_behavior_cancel_order'
                         ) == Producer::BEHAVIOR_DELETE_ORDER_STATUS && strlen($this->date_delete)) ||
                 $force) {
-            ProductOrderModel::deleteAll(['id_order' => $this->id]);
+            ProductOrder::deleteAll(['id_order' => $this->id]);
             return parent::delete();
         } // status 'delete'
         elseif (Producer::getConfig('option_behavior_cancel_order') == Producer::BEHAVIOR_DELETE_ORDER_STATUS) {
     public function addOrderStatusHistory($newStatus, $origin)
     {
         $orderStatusHistory = new OrderStatusHistory();
-        $orderStatusHistory->id_user = UserModel::getCurrentId();
+        $orderStatusHistory->id_user = User::getCurrentId();
         $orderStatusHistory->id_order = $this->id;
         $orderStatusHistory->status = $newStatus;
         $orderStatusHistory->origin = $origin;
      */
     public function getDataJson()
     {
-        $order = OrderModel::searchOne(['order.id' => $this->id]);
+        $order = Order::searchOne(['order.id' => $this->id]);
 
         $jsonOrder = [];
         if ($order) {
         $creditHistory->id_producer = $idProducer;
         $creditHistory->id_user_action = $idUserAction;
         $creditHistory->populateRelation('order', $this);
-        $creditHistory->populateRelation('user', UserModel::find()->where(['id' => $this->id_user])->one());
+        $creditHistory->populateRelation('user', User::find()->where(['id' => $this->id_user])->one());
 
         $creditHistoryService->save($creditHistory);
     }
             if ($paymentStatus == self::PAYMENT_PAID) {
                 return true;
             } elseif ($paymentStatus == self::PAYMENT_SURPLUS) {
-                $type = CreditHistoryModel::TYPE_REFUND;
+                $type = CreditHistory::TYPE_REFUND;
                 $amount = $this->getAmount(self::AMOUNT_SURPLUS);
             } elseif ($paymentStatus == self::PAYMENT_UNPAID) {
-                $type = CreditHistoryModel::TYPE_PAYMENT;
+                $type = CreditHistory::TYPE_PAYMENT;
                 $amount = $this->getAmount(self::AMOUNT_REMAINING);
             }
 
                     $amount,
                     GlobalParam::getCurrentProducerId(),
                     $this->id_user,
-                    UserModel::getCurrentId()
+                    User::getCurrentId()
             );
         }
     }
 
     public function setTillerSynchronization()
     {
-        $order = OrderModel::searchOne(['id' => $this->id]);
+        $order = Order::searchOne(['id' => $this->id]);
 
         $paymentStatus = $order->getPaymentStatus();
 
     public function getCartSummary($htmlFormat = true)
     {
         if (!isset($this->productOrder)) {
-            $this->productOrder = ProductOrderModel::find()->where(['id_order' => $this->id])->all();
+            $this->productOrder = ProductOrder::find()->where(['id_order' => $this->id])->all();
         }
 
         $html = '';
         $i = 0;
         foreach ($this->productOrder as $p) {
             if (isset($p->product)) {
-                $html .= Html::encode($p->product->name) . ' (' . $p->quantity . ' ' . ProductModel::strUnit(
+                $html .= Html::encode($p->product->name) . ' (' . $p->quantity . ' ' .  Product::strUnit(
                                 $p->unit,
                                 'wording_short',
                                 true
         if ($creditActive) {
             $html .= '<br />';
             if ($this->paid_amount) {
-                if ($this->getPaymentStatus() == OrderModel::PAYMENT_PAID) {
+                if ($this->getPaymentStatus() == Order::PAYMENT_PAID) {
                     $html .= '<span class="label label-success">Payée</span>';
-                } elseif ($this->getPaymentStatus() == OrderModel::PAYMENT_UNPAID) {
+                } elseif ($this->getPaymentStatus() == Order::PAYMENT_UNPAID) {
                     $html .= '<span class="label label-danger">Non payée</span><br />
                                                 Reste <strong>' . $this->getAmount(
-                                    OrderModel::AMOUNT_REMAINING,
+                                    Order::AMOUNT_REMAINING,
                                     true
                             ) . '</strong> à payer';
-                } elseif ($this->getPaymentStatus() == OrderModel::PAYMENT_SURPLUS) {
+                } elseif ($this->getPaymentStatus() == Order::PAYMENT_SURPLUS) {
                     $html .= '<span class="label label-success">Payée</span>';
                 }
             } else {
                                 $quantity += $po->quantity;
                             } else {
                                 if (isset($po->product) && $po->product->weight > 0) {
-                                    $quantity += ($po->quantity * ProductModel::$unitsArray[$po->unit]['coefficient']) / $po->product->weight;
+                                    $quantity += ($po->quantity *  Product::$unitsArray[$po->unit]['coefficient']) / $po->product->weight;
                                 }
                             }
                         }
         if (is_array($orders)) {
             if (count($orders)) {
                 foreach ($orders as $order) {
-                    if (is_a($order, 'common\logic\Order\Order\OrderModel')) {
+                    if (is_a($order, 'common\logic\Order\Order\Order')) {
                         $order->init();
                     }
                 }
             }
         } else {
             $order = $orders;
-            if (is_a($order, 'common\logic\Order\Order\OrderModel')) {
+            if (is_a($order, 'common\logic\Order\Order\Order')) {
                 return $order->init();
             } // count
             else {
         $producer = Producer::findOne($idProducer);
 
         if (!$this->reference && $producer->option_order_reference_type == Producer::ORDER_REFERENCE_TYPE_YEARLY) {
-            $lastOrder = OrderModel::find()->innerJoinWith('distribution', true)
+            $lastOrder = Order::find()->innerJoinWith('distribution', true)
                     ->where(['>=', 'distribution.date', date('Y') . '-01-01'])
                     ->andWhere([
                                        'distribution.id_producer' => $producer->id

common/logic/Order/Order/OrderContainer.php

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

common/logic/Order/Order/OrderFactory.php

 
 class OrderFactory extends BaseService implements FactoryInterface
 {
-    public function create(): OrderModel
+    public function create(): Order
     {
-        $order = new OrderModel();
+        $order = new Order();
 
         return $order;
     }

common/logic/Order/Order/OrderRepository.php

 namespace common\logic\Order\Order;
 
 use common\logic\BaseService;
+use common\logic\Distribution\Distribution\Distribution;
 use common\logic\RepositoryInterface;
 
 class OrderRepository extends BaseService implements RepositoryInterface
 {
-
+    public function getByDistribution(Distribution $distribution, string $conditionAppend = '')
+    {
+        return Order::searchAll([
+            'distribution.date' => $distribution->date,
+            'distribution.id_producer' => $distribution->id_producer
+        ],
+            [
+                'conditions' => 'date_delete IS NULL ' . $conditionAppend
+            ]);
+    }
 }

common/logic/Order/Order/OrderSearch.php

 
 namespace common\logic\Order\Order ;
 
-class OrderSearch extends OrderModel
+class OrderSearch extends Order
 {
     public function search($params) 
     {
             $paramsSearch['id_user'] = $params['id_user'];
         }
 
-        $query = OrderModel::searchQuery($paramsSearch, [
+        $query = Order::searchQuery($paramsSearch, [
             'orderby' => 'distribution.date DESC'
         ]);
         

common/logic/Order/OrderStatusHistory/OrderStatusHistoryModel.php → common/logic/Order/OrderStatusHistory/OrderStatusHistory.php

  * @property integer $id_order_status
  * @property string $date
  */
-class OrderStatusHistoryModel extends ActiveRecordCommon
+class OrderStatusHistory extends ActiveRecordCommon
 {
         /**
          * @inheritdoc
 
         public function getOrder()
         {
-                return $this->hasOne(UserModel::className(), ['id' => 'id_order']);
+                return $this->hasOne( User::className(), ['id' => 'id_order']);
         }
 
         public function getUser()
         {
-                return $this->hasOne(UserModel::className(), ['id' => 'id_user']);
+                return $this->hasOne( User::className(), ['id' => 'id_user']);
         }
 
         /**

common/logic/Order/OrderStatusHistory/OrderStatusHistoryContainer.php

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

common/logic/Order/OrderStatusHistory/OrderStatusHistoryFactory.php

 
 class OrderStatusHistoryFactory extends BaseService implements FactoryInterface
 {
-    public function create(): OrderStatusHistoryModel
+    public function create(): OrderStatusHistory
     {
-        $orderStatusHistory = new OrderStatusHistoryModel();
+        $orderStatusHistory = new OrderStatusHistory();
 
         return $orderStatusHistory;
     }

common/logic/Order/ProductOrder/ProductOrderModel.php → common/logic/Order/ProductOrder/ProductOrder.php

  * @property double $quantity
  * @property string $unit
  */
-class ProductOrderModel extends ActiveRecordCommon
+class ProductOrder extends ActiveRecordCommon
 {
 
         /**
 
         public function getProduct()
         {
-                return $this->hasOne(ProductModel::className(), ['id' => 'id_product']);
+                return $this->hasOne( Product::className(), ['id' => 'id_product']);
         }
 
         public function getTaxRate()
                 return Price::getPriceWithTax($this->price, $this->taxRate->value);
         }
 
-        public function getPriceByTypeTotal($typeTotal = OrderModel::AMOUNT_TOTAL)
+        public function getPriceByTypeTotal($typeTotal = Order::AMOUNT_TOTAL)
         {
-            if($typeTotal == OrderModel::INVOICE_AMOUNT_TOTAL && $this->invoice_price) {
+            if($typeTotal == Order::INVOICE_AMOUNT_TOTAL && $this->invoice_price) {
                 return $this->invoice_price;
             }
 

common/logic/Order/ProductOrder/ProductOrderContainer.php

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

common/logic/Order/ProductOrder/ProductOrderFactory.php

 
 class ProductOrderFactory extends BaseService implements FactoryInterface
 {
-    public function create(): ProductOrderModel
+    public function create(): ProductOrder
     {
-        $productOrder = new ProductOrderModel();
+        $productOrder = new ProductOrder();
 
         return $productOrder;
     }