Refactoring repositories #1084

backend/controllers/DistributionController.php

     {
         \Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
         $userManager = $this->getUserManager();
+        $orderManager = $this->getOrderManager();
 
         $user = $userManager->findOneUserById($idUser);
         $idFavoritePointSale = 0;
 
         if($user) {
-            $favoritePointSale = $userManager->getUserFavoritePointSale($user);
+            $favoritePointSale = $orderManager->getUserFavoritePointSale($user);
             if ($favoritePointSale) {
                 $idFavoritePointSale = $favoritePointSale->id;
             }
         if ($order && $order->distribution->id_producer == GlobalParam::getCurrentProducerId()) {
             $userProducer = null;
             if ($order->id_user) {
-                $userProducer = $userProducerManager->findOneUserProducer($order->user, $this->getProducerCurrent());
+                $userProducer = $userProducerManager->findOneUserProducer($order->user);
             }
             foreach ($order->productOrder as $productOrder) {
                 $invoicePrice = $productManager->getPrice($productOrder->product, [
 
                             // init invoice prices
                             $user = $userManager->findOneUserById($deliveryNote->id_user);
-                            $userProducer = $userProducerManager->findOneUserProducer($user, $producerCurrent);
+                            $userProducer = $userProducerManager->findOneUserProducer($user);
                             $orderManager->updateOrderInvoicePrices($order, [
                                 'user' => $user,
                                 'user_producer' => $userProducer,
                         if ($firstOrder->pointSale->id_user) {
                             $deliveryNote->id_user = $firstOrder->pointSale->id_user;
                             $user = $userManager->findOneUserById($deliveryNote->id_user);
-                            $userProducer = $userProducerManager->findOneUserProducer($user, $producerCurrent);
+                            $userProducer = $userProducerManager->findOneUserProducer($user);
                         } else {
                             $user = new  User();
                             $user->type = User::TYPE_LEGAL_PERSON;
 
                     if (!isset($user) || !$user) {
                         $user = $userManager->findOneUserById($deliveryNote->id_user);
-                        $userProducer = $userProducerManager->findOneUserProducer($user, $producerCurrent);
+                        $userProducer = $userProducerManager->findOneUserProducer($user);
                     }
 
                     // affectation du BL aux commandes

backend/controllers/DocumentController.php

                     );
                 }
 
-                $userProducer = $userProducerManager->findOneUserProducer($document->user, $this->getProducerCurrent());
+                $userProducer = $userProducerManager->findOneUserProducer($document->user);
                 $pointSale = $pointSaleManager->findOnePointSaleByIdUser($document->user->id);
 
                 $productsArray = yii\helpers\ArrayHelper::map(

backend/controllers/OrderController.php

             if (isset($order->user) && $order->user) {
                 $user = $order->user;
 
-                $userProducer = $userProducerManager->findOneUserProducer(
-                    $user,
-                    $producerManager->findOneProducerById($order->distribution->id_producer)
-                );
+                $userProducer = $userProducerManager->findOneUserProducer($user);
             }
 
             foreach ($products as $key => $dataProductOrder) {

backend/controllers/UserController.php

                     $model->user_groups[] = $userUserGroup->id_user_group;
                 }
             }
-            $userProducer = $userProducerManager->findOneUserProducer($model, $producerCurrent);
+            $userProducer = $userProducerManager->findOneUserProducer($model);
             $model->product_price_percent = $userProducer->product_price_percent;
         }
 
     {
         $userManager = $this->getUserManager();
         $producerManager = $this->getProducerManager();
+        $pointSaleManager = $this->getPointSaleManager();
 
         $producerCurrent = $this->getProducerCurrent();
         $model = $userManager->instanciateUser();
 
         $user = $userManager->findOneUserById($id);
         $producer = $this->getProducerCurrent();
-        $userProducer = $userProducerManager->findOneUserProducer($user, $producer);
+        $userProducer = $userProducerManager->findOneUserProducer($user);
 
         if ($userProducer) {
             $userProducer->active = 0;
 
         $user = $userManager->findOneUserById($idUser);
         $producerCurrent = $this->getproducerCurrent();
-        $userProducer = $userProducerManager->findOneUserProducer($user,$producerCurrent);
+        $userProducer = $userProducerManager->findOneUserProducer($user);
 
         if ($userProducer) {
             $userProducer->credit_active = $state;

backend/views/user/_form.php

 
     <div class="col-md-4">
 
-        <?php if($pointSaleBillingArray && count($pointSaleBillingArray) > 0): ?>
+        <?php if(isset($pointSaleBillingArray) && $pointSaleBillingArray && count($pointSaleBillingArray) > 0): ?>
             <h3>Facturation</h3>
             <?php foreach($pointSaleBillingArray as $pointSale): ?>
                 <a href="<?= Yii::$app->urlManager->createUrl(['point-sale/update', 'id' => $pointSale->id]) ?>"><?= $pointSale->name ?></a><br />

backend/views/user/credit.php

     </div>
     
     <div class="col-md-8">
-        <h2>Historique <span class="the-credit"><?= number_format($userManager->getCredit($user, $producer), 2); ?> €</span></h2>
+        <h2>Historique <span class="the-credit"><?= number_format($userManager->getCredit($user), 2); ?> €</span></h2>
         <table class="table table-bordered">
             <thead>
                 <tr>

common/components/BusinessLogic.php

             $this->getCreditHistoryContainer(),
             $this->getProducerPriceRangeContainer(),
             $this->getUserProducerContainer(),
+            $this->getUserPointSaleContainer(),
             $this->getUserContainer(),
             $this->getOrderSatusHistoryContainer(),
             $this->getPointSaleDistributionContainer(),
             $this->getProductOrderContainer(),
             $this->getProductPriceContainer(),
             $this->getProductSubscriptionContainer(),
-            $this->getUserPointSaleContainer(),
             $this->getQuotationContainer(),
             $this->getInvoiceContainer(),
             $this->getDeliveryNoteContainer(),

common/logic/AbstractRepository.php

 
     public function createQuery()
     {
-        return $this->query->createQuery();
+        $this->query->createQuery();
+
+        return $this->query;
     }
 
     public function createDefaultQuery(): RepositoryQueryInterface

common/logic/AbstractRepositoryQuery.php

 
     public function filterById(int $id): self
     {
-        $this->query->andWhere(['id' => $id]);
+        $class = $this->definition->getEntityFqcn();
+        $this->query->andWhere([$class::tableName().'.id' => $id]);
 
         return $this;
     }

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

                         $userProducer = null;
                         if (isset($order->user) && $order->user) {
                             $user = $order->user;
-                            $userProducer = $this->userProducerRepository->findOneUserProducer($user, $distribution->producer);
+                            $userProducer = $this->userProducerRepository->findOneUserProducer($user);
                         }
 
                         $this->productOrderBuilder->updateProductOrderPrice(

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

 
 namespace common\logic\Order\Order\Repository;
 
+use common\helpers\GlobalParam;
 use common\helpers\MeanPayment;
 use common\logic\AbstractRepository;
 use common\logic\Distribution\Distribution\Model\Distribution;
 use common\logic\Distribution\Distribution\Repository\DistributionRepository;
 use common\logic\Distribution\ProductDistribution\Repository\ProductDistributionRepository;
 use common\logic\Order\Order\Model\Order;
-use common\logic\Order\Order\Service\OrderBuilder;
 use common\logic\Order\Order\Service\OrderSolver;
 use common\logic\Order\ProductOrder\Repository\ProductOrderRepository;
 use common\logic\PointSale\PointSale\Model\PointSale;
 use common\logic\PointSale\PointSale\Repository\PointSaleRepository;
+use common\logic\PointSale\UserPointSale\Repository\UserPointSaleRepository;
 use common\logic\Producer\Producer\Model\Producer;
 use common\logic\Producer\Producer\Repository\ProducerRepository;
-use common\logic\Product\Product\Model\Product;
 use common\logic\Product\Product\Service\ProductSolver;
 use common\logic\User\User\Model\User;
-use common\logic\User\UserProducer\Model\UserProducer;
 use common\logic\User\UserProducer\Repository\UserProducerRepository;
 use yii\helpers\Html;
 
     protected UserProducerRepository $userProducerRepository;
     protected DistributionRepository $distributionRepository;
     protected PointSaleRepository $pointSaleRepository;
+    protected UserPointSaleRepository $userPointSaleRepository;
 
     public function loadDependencies(): void
     {
         $this->userProducerRepository = $this->loadService(UserProducerRepository::class);
         $this->distributionRepository = $this->loadService(DistributionRepository::class);
         $this->pointSaleRepository = $this->loadService(PointSaleRepository::class);
+        $this->userPointSaleRepository = $this->loadService(UserPointSaleRepository::class);
     }
 
     public function getDefaultOptionsSearch(): array
                     return 0;
                 }
                 elseif ($creditFunctioning == Producer::CREDIT_FUNCTIONING_USER) {
-                    $userProducer = $this->userProducerRepository->findOneUserProducer(
-                        $order->user,
-                        $distribution->producer
-                    );
+                    $userProducer = $this->userProducerRepository->findOneUserProducer($order->user);
                     if ($userProducer) {
                         return $userProducer->credit_active;
                     }
 
         return 0;
     }
+
+    public function findOneOrderLastByUser(User $user)
+    {
+        return $this->createDefaultQuery()
+            ->filterByUser($user)
+            ->orderBy('order.id DESC')
+            ->findOne();
+    }
+
+    /**
+     * Retourne le point de vente favoris d'un utilisateur : le point de vente auquel le client est lié,
+     * le point de vente de la dernière commande sinon.
+     */
+    public function getUserFavoritePointSale(User $user): ?PointSale
+    {
+        $pointSale = null;
+        $arrayUserPointSale = $this->userPointSaleRepository->findUserPointSalesByUser($user);
+
+        if (count($arrayUserPointSale) == 1) {
+            $pointSale = $this->pointSaleRepository->findOnePointSaleById($arrayUserPointSale[0]->id_point_sale);
+        } else {
+            $lastOrder = $this->findOneOrderLastByUser($user);
+            if ($lastOrder) {
+                $pointSale = $this->pointSaleRepository->findOnePointSaleById($lastOrder->id_point_sale);
+            }
+        }
+
+        return $pointSale;
+    }
 }

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

                         $order->auto_payment = 1;
                     } elseif ($creditFunctioning == Producer::CREDIT_FUNCTIONING_USER) {
 
-                        $userProducer = $this->userProducerRepository->findOneUserProducer($order->user, $subscription->producer);
+                        $userProducer = $this->userProducerRepository->findOneUserProducer($order->user);
 
                         if ($userProducer) {
                             $order->auto_payment = $userProducer->credit_active;

common/logic/PointSale/UserPointSale/Repository/UserPointSaleRepository.php

             self::WITH => [],
             self::JOIN_WITH => [],
             self::ORDER_BY => '',
-            self::ATTRIBUTE_ID_PRODUCER => ''
+            self::ATTRIBUTE_ID_PRODUCER => 'point_sale.id_producer'
         ] ;
     }
 
     public function findUserPointSalesByUser(User $user): array
     {
         return $this->createDefaultQuery()
+            ->joinPointSale()
             ->filterByUser($user)
             ->find();
     }
         }
 
         return $this->createDefaultQuery()
+            ->joinPointSale()
             ->filterByUser($user)
             ->filterByPointSale($pointSale)
             ->findOne();

common/logic/PointSale/UserPointSale/Repository/UserPointSaleRepositoryQuery.php

         $this->loadDefinition(UserPointSaleDefinition::class);
     }
 
-    public function filterByUser(User $user): self
+    public function joinPointSale(): self
     {
-        $this->andWhere(['id_user' => $user->id]);
+        $this->innerJoinWith('pointSale', true);
+        return $this;
+    }
 
+    public function filterByUser(User $user): self
+    {
+        $this->andWhere(['user_point_sale.id_user' => $user->id]);
         return $this;
     }
 
     public function filterByPointSale(PointSale $pointSale): self
     {
         $this->andWhere(['id_point_sale' => $pointSale->id]);
-
         return $this;
     }
 }

common/logic/Producer/Producer/Repository/ProducerRepository.php

 
     public function findOneProducerById(int $id)
     {
-        return $this->createDefaultQuery()
+        return $this->createQuery()
             ->filterById($id)
             ->findOne();
     }
 
     public function findOneProducerBySlug(string $slug)
     {
-        return $this->createDefaultQuery()
+        return $this->createQuery()
             ->filterBySlug($slug)
             ->findOne();
     }
 
     public function queryProducersActive()
     {
-        return $this->createDefaultQuery()
-            ->filterIsActive();
+        return $this->createQuery()->filterIsActive();
     }
 
     /**
      */
     public function findOneProducerDemoAccount()
     {
-        return $this->createDefaultQuery()
+        return $this->createQuery()
             ->filterIsDemoAccount()
             ->findOne();
     }
      */
     public function populateProducerDropdown(): array
     {
-        return $this->createDefaultQuery()
+        $producers = $this->createQuery()
             ->filterIsActive()
             ->orderBy('postcode, city ASC')
             ->find();

common/logic/Producer/Producer/Repository/ProducerRepositoryQuery.php

         $this->loadDefinition(ProducerDefinition::class);
     }
 
-    public function filterBySlug(int $slug): self
+    public function filterBySlug(string $slug): self
     {
         $this->andWhere(['slug' => $slug]);
         return $this;

common/logic/Producer/ProducerPriceRange/Repository/ProducerPriceRangeRepository.php

 
     public function queryProducerPriceRanges()
     {
-        return $this->createDefaultQuery()
-            ->find();
+        return $this->createDefaultQuery();
     }
 
     public function findProducerPriceRanges()
     {
-        return $this->queryProducerPriceRanges()->all();
+        return $this->queryProducerPriceRanges()->find();
     }
 
     public function getAmountToBeBilledByTurnover(float $turnover = null, $format = false)

common/logic/Producer/ProducerPriceRange/Service/ProducerPriceRangeDefinition.php

 namespace common\logic\Producer\ProducerPriceRange\Service;
 
 use common\logic\AbstractDefinition;
+use common\logic\Producer\ProducerPriceRange\Model\ProducerPriceRange;
 
 class ProducerPriceRangeDefinition extends AbstractDefinition
 {
     public function getEntityFqcn(): string
     {
-        return ProducerPriceRangeDefinition::class;
+        return ProducerPriceRange::class;
     }
 }

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

         $priceArray = [];
         $userProducer = null;
         if ($user) {
-            $userProducer = $this->userProducerRepository->findOneUserProducer($user, GlobalParam::getCurrentProducer());
+            $userProducer = $this->userProducerRepository->findOneUserProducer($user);
         }
 
         // specific prices

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

 
     public function filterByProductCategory(ProductCategory $productCategory = null) : self
     {
-        $this->andWhere(['product.id_product_category' => $productCategory->id]);
+        if($productCategory) {
+            $this->andWhere(['product.id_product_category' => $productCategory->id]);
+        }
         return $this;
     }
 }

common/logic/User/User/Repository/UserRepository.php

 
 use common\helpers\GlobalParam;
 use common\logic\AbstractRepository;
-use common\logic\Order\Order\Model\Order;
 use common\logic\PointSale\PointSale\Model\PointSale;
-use common\logic\PointSale\UserPointSale\Model\UserPointSale;
 use common\logic\Producer\Producer\Model\Producer;
 use common\logic\User\User\Model\User;
 use common\logic\User\User\Service\UserSolver;
-use common\logic\User\UserGroup\Model\UserGroup;
 use common\logic\User\UserProducer\Repository\UserProducerRepository;
-use common\logic\User\UserUserGroup\Model\UserUserGroup;
 use yii\db\Query;
 
 class UserRepository extends AbstractRepository
 
     public function findOneUserById($id)
     {
-        return User::searchOne(['id' => $id]);
+        return $this->createDefaultQuery()
+            ->filterById($id)
+            ->findOne();
     }
 
     public function findUsers(): array
         return $usersArrayDropdown;
     }
 
-    /**
-     * Retourne le point de vente favoris d'un utilisateur : le point de vente auquel le client est lié,
-     * le point de vente de la dernière commande sinon.
-     *
-     */
-    public function getUserFavoritePointSale(User $user): ?PointSale
-    {
-        $arrayUserPointSale = UserPointSale::find()
-            ->innerJoinWith('pointSale', true)
-            ->where([
-                'user_point_sale.id_user' => $user->id,
-                'point_sale.id_producer' => GlobalParam::getCurrentProducerId()
-            ])
-            ->all();
-
-        if (count($arrayUserPointSale) == 1) {
-            $pointSale = PointSale::findOne(['id' => $arrayUserPointSale[0]->id_point_sale]);
-        } else {
-            $lastOrder = Order::find()->innerJoinWith('pointSale', true)->where([
-                'order.id_user' => $user->id,
-                'point_sale.id_producer' => GlobalParam::getCurrentProducerId()
-            ])
-                ->orderBy('order.id DESC')
-                ->one();
-
-            if ($lastOrder) {
-                $pointSale = PointSale::findOne(['id' => $lastOrder->id_point_sale]);
-            }
-        }
-
-        if (isset($pointSale)) {
-            return $pointSale;
-        }
-
-        return null;
-    }
-
     /**
      * Retourne le crédit de l'utilisateur pour un producteur donné.
      *
      */
-    public function getCredit(User $user, Producer $producer): float
+    public function getCredit(User $user): float
     {
-        $userProducer = $this->userProducerRepository->findOneUserProducer($user, $producer);
+        $userProducer = $this->userProducerRepository->findOneUserProducer($user);
         return $userProducer ? $userProducer->credit : 0;
     }
 
      * @param array $params
      * @return Query
      */
-    // findBy
     public function queryUsersBy(array $params = [])
     {
         if (!isset($params['id_producer'])) {
     /**
      * Finds user by password reset token
      */
-    // getByPasswordResetToken
     public function findOneUserByPasswordResetToken(string $token)
     {
         if (!$this->userSolver->isPasswordResetTokenValid($token)) {
             return null;
         }
 
-        return User::findOne([
-            'password_reset_token' => $token,
-        ]);
+        return $this->createDefaultQuery()
+            ->filterByPasswordResetToken($token)
+            ->findOne();
     }
 
     /**
      * Recherche un utilisateur via son adresse email.
      */
-    // getOneByEmail
     public function findOneUserByEmail(string $email): ?User
     {
-        return User::searchOne(['email' => $email]);
+        return $this->createDefaultQuery()
+            ->filterByEmail($email)
+            ->findOne();
     }
 
-    // getOneByUsername
     public function findOneUserByUsername(string $username): ?User
     {
-        return User::searchOne(['username' => $username]);
+        return $this->createDefaultQuery()
+            ->filterByUsername($username)
+            ->findOne();
     }
 
     public function findUsersByProducer(Producer $producer)
     {
-        return User::find()
-            ->where([
-                'id_producer' => $producer->id,
-                'status' => User::STATUS_PRODUCER
-            ])
-            ->all();
+        return $this->createDefaultQuery()
+            ->isStatusProducer()
+            ->filterByProducer($producer)
+            ->find();
     }
 
     public function findUsersByStatus(string $status)
     {
-        return User::find()
-            ->where([
-                'user.status' => $status
-            ])
-            ->all();
+        return $this->createDefaultQuery()
+            ->filterByStatus($status)
+            ->find();
     }
 }

common/logic/User/User/Repository/UserRepositoryQuery.php

 namespace common\logic\User\User\Repository;
 
 use common\logic\AbstractRepositoryQuery;
+use common\logic\Producer\Producer\Model\Producer;
+use common\logic\User\User\Model\User;
 use common\logic\User\User\Service\UserDefinition;
 
 class UserRepositoryQuery extends AbstractRepositoryQuery
     {
         $this->loadDefinition(UserDefinition::class);
     }
+
+    public function filterByPasswordResetToken(string $token): self
+    {
+        $this->andWhere(['password_reset_token' => $token]);
+        return $this;
+    }
+
+    public function filterByEmail(string $email): self
+    {
+        $this->andWhere(['email' => $email]);
+        return $this;
+    }
+
+    public function filterByUsername(string $username): self
+    {
+        $this->andWhere(['username' => $username]);
+        return $this;
+    }
+
+    public function filterByProducer(Producer $producer): self
+    {
+        $this->andWhere(['user.id_producer' => $producer->id]);
+        return $this;
+    }
+
+    public function filterByStatus(string $status): self
+    {
+        $this->andWhere(['user.status' => $status]);
+        return $this;
+    }
+
+    public function isStatusProducer(): self
+    {
+        return $this->filterByStatus(User::STATUS_PRODUCER);
+    }
 }

common/logic/User/UserGroup/Repository/UserGroupRepository.php

             self::WITH => [],
             self::JOIN_WITH => [],
             self::ORDER_BY => '',
-            self::ATTRIBUTE_ID_PRODUCER => ''
+            self::ATTRIBUTE_ID_PRODUCER => 'user_group.id_producer'
         ];
     }
 
     public function findOneUserGroupById(int $id)
     {
-        return UserGroup::searchOne(['id' => $id]);
+        return $this->createDefaultQuery()
+            ->filterById($id)
+            ->findOne();
     }
 
     public function findOneUserGroupByName(string $name)
     {
-        return UserGroup::searchOne(['name' => $name]);
+        return $this->createDefaultQuery()
+            ->filterByName($name)
+            ->findOne();
     }
 
     public function findUserGroups()
     {
-        return UserGroup::find()->where('id_producer = ' . GlobalParam::getCurrentProducerId())->all();
+        return $this->createDefaultQuery()->find();
     }
 
     public function populateUserGroupDropdownList(): array

common/logic/User/UserGroup/Repository/UserGroupRepositoryQuery.php

     {
         $this->loadDefinition(UserGroupDefinition::class);
     }
+
+    public function filterByName(string $name): self
+    {
+        $this->andWhere(['name' => $name]);
+        return $this;
+    }
 }

common/logic/User/UserProducer/Repository/UserProducerRepository.php

     public function getDefaultOptionsSearch(): array
     {
         return [
-            self::WITH => [],
+            self::WITH => ['producer'],
             self::JOIN_WITH => [],
             self::ORDER_BY => '',
             self::ATTRIBUTE_ID_PRODUCER => 'user_producer.id_producer'
         ];
     }
 
-    public function findOneUserProducer(User $user, Producer $producer)
+    public function findOneUserProducer(User $user)
     {
-        return UserProducer::searchOne([
-            'id_user' => $user->id,
-            'user_producer.id_producer' => $producer->id
-        ]);
+        return $this->createDefaultQuery()
+            ->filterByUser($user)
+            ->findOne();
     }
 
     public function findUserProducersByUser(User $user, bool $active = true, bool $bookmark = true)
     {
-        return UserProducer::find()
-            ->with(['producer'])
-            ->where([
-                'id_user' => $user->id,
-                'active' => $active,
-                'bookmark' => $bookmark
-            ])
-            ->all();
+        return $this->createDefaultQuery()
+            ->filterByUser($user)
+            ->filterByActive($active)
+            ->filterByBookmark($bookmark)
+            ->find();
     }
 }

common/logic/User/UserProducer/Repository/UserProducerRepositoryQuery.php

 namespace common\logic\User\UserProducer\Repository;
 
 use common\logic\AbstractRepositoryQuery;
+use common\logic\User\User\Model\User;
 use common\logic\User\UserProducer\Model\UserProducer;
 use common\logic\User\UserProducer\Service\UserProducerDefinition;
 use yii\db\ActiveQuery;
     {
         $this->loadDefinition(UserProducerDefinition::class);
     }
+
+    public function filterByUser(User $user): self
+    {
+        $this->andWhere(['id_user' => $user->id]);
+        return $this;
+    }
+
+    public function filterByActive(bool $active): self
+    {
+        $this->andWhere(['active' => $active]);
+        return $this;
+    }
+
+    public function filterByBookmark(bool $bookmark): self
+    {
+        $this->andWhere(['bookmark' => $bookmark]);
+        return $this;
+    }
 }

common/logic/User/UserProducer/Service/UserProducerBuilder.php

 
     public function createUserProducerIfNotExist(User $user, Producer $producer, int $bookmark = 1): UserProducer
     {
-        return $this->userProducerRepository->findOneUserProducer($user, $producer)
+        return $this->userProducerRepository->findOneUserProducer($user)
             ?? $this->createUserProducer($user, $producer, $bookmark);
     }
 
     public function updateCredit(CreditHistory $creditHistory): void
     {
-        $userProducer = $this->userProducerRepository->findOneUserProducer($creditHistory->user, $creditHistory->producer);
+        $userProducer = $this->userProducerRepository->findOneUserProducer($creditHistory->user);
 
         if ($userProducer) {
             $oldCredit = $userProducer->getCredit();

common/logic/User/UserUserGroup/Repository/UserUserGroupRepository.php

             self::JOIN_WITH => [],
             self::ORDER_BY => '',
             self::ATTRIBUTE_ID_PRODUCER => ''
-        ] ;
+        ];
     }
 
     public function findUserUserGroupsByUser(User $user)
     {
-        return UserUserGroup::searchAll([
-            'id_user' => $user->id
-        ]);
+        return $this->createDefaultQuery()
+            ->filterByUser($user)
+            ->find();
     }
 }

common/logic/User/UserUserGroup/Repository/UserUserGroupRepositoryQuery.php

 namespace common\logic\User\UserUserGroup\Repository;
 
 use common\logic\AbstractRepositoryQuery;
+use common\logic\User\User\Model\User;
 use common\logic\User\UserUserGroup\Model\UserUserGroup;
 use common\logic\User\UserUserGroup\Service\UserUserGroupDefinition;
 use yii\db\ActiveQuery;
     {
         $this->loadDefinition(UserUserGroupDefinition::class);
     }
+
+    public function filterByUser(User $user): self
+    {
+        $this->andWhere(['id_user' => $user->id]);
+        return $this;
+    }
 }

frontend/controllers/SiteController.php

     public function getDataProviderPrices()
     {
         return new ActiveDataProvider([
-            'query' => $this->getProducerPriceRangeManager()->queryProducerPriceRanges(),
+            'query' => $this->getProducerPriceRangeManager()->queryProducerPriceRanges()->query(),
             'pagination' => [
                 'pageSize' => 100,
             ],
     public function actionProducers()
     {
         $dataProviderProducers = new ActiveDataProvider([
-            'query' => $this->getProducerManager()->queryProducersActive(),
+            'query' => $this->getProducerManager()->queryProducersActive()->query(),
             'pagination' => [
                 'pageSize' => 100,
             ],

frontend/forms/SignupForm.php

 
             if ($user->save() && $producer) {
                 // Liaison User / Producer
+                \Yii::$app->logic->setProducerContext($producer);
                 $producerManager->addUser($user, $producer);
 
                 // Envoi d'un email de bienvenue à l'utilisateur

producer/controllers/CreditController.php

         $searchModel = new CreditHistorySearch();
         $searchModel->id_user = GlobalParam::getCurrentUserId();
         $dataProvider = $searchModel->search(\Yii::$app->request->queryParams);
-        $userProducer = $this->getUserProducerManager()->findOneUserProducer(GlobalParam::getCurrentUser(), $producer);
+        $userProducer = $this->getUserProducerManager()->findOneUserProducer($this->getUserCurrent());
 
         if (strlen($returnPayment)) {
             if ($returnPayment == 'success') {
                             ]
                         ]);
                     } else {
-                        $userProducer = $this->getUserProducerManager()->findOneUserProducer($user, $producer);
+                        $userProducer = $this->getUserProducerManager()->findOneUserProducer($user);
 
                         Mailjet::sendMail([
                             'from_email' => $producerManager->getEmailOpendistrib($producer),

producer/controllers/OrderController.php

         $errors = [];
 
         if ($order->validate() && count($productsArray) && !$errorDate && !$errorPointSale) {
-            $userProducer = $userProducerManager->findOneUserProducer($user, $producer);
+            $userProducer = $userProducerManager->findOneUserProducer($user);
             $pointSale = $pointSaleManager->findOnePointSaleById($order->id_point_sale);
 
             $order->comment_point_sale = ($pointSale && strlen($pointSaleManager->getComment($pointSale))) ?
             $credit = $producerManager->getConfig('credit');
             $creditLimit = $producerManager->getConfig('credit_limit');
             $creditFunctioning = $producerManager->getPointSaleCreditFunctioning($pointSale);
-            $creditUser = $userManager->getCredit($user, $producer);
+            $creditUser = $userManager->getCredit($user);
             $order = $orderManager->findOneOrderById($order->id);
             $orderManager->initOrder($order);
             $amountRemaining = $orderManager->getOrderAmount($order, Order::AMOUNT_REMAINING);
         $user = GlobalParam::getCurrentUser();
         
         if($user) {
-            $userProducer = $userProducerManager->findOneUserProducer($user, $producer);
+            $userProducer = $userProducerManager->findOneUserProducer($user);
             if (!$userProducer) {
                 $userProducer = $producerManager->addUser($user, $producer);
             }
         $pointSaleManager = $this->getPointSaleManager();
         $userManager = $this->getUserManager();
         $producerManager = $this->getProducerManager();
+        $orderManager = $this->getOrderManager();
 
         $user = GlobalParam::getCurrentUser();
         $pointsSaleArray = PointSale::find();
 
         $favoritePointSale = false;
         if ($user) {
-            $favoritePointSale = $userManager->getUserFavoritePointSale($user);
+            $favoritePointSale = $orderManager->getUserFavoritePointSale($user);
         }
 
         if ($favoritePointSale) {

producer/controllers/SubscriptionController.php

         $productManager = $this->getProductManager();
         $subscriptionManager = $this->getSubscriptionManager();
         $user = GlobalParam::getCurrentUser();
-        $userProducer = $this->getUserProducerManager()->findOneUserProducer(
-            GlobalParam::getCurrentUser(),
-            GlobalParam::getCurrentProducer()
-        );
+        $userProducer = $this->getUserProducerManager()->findOneUserProducer($this->getUserCurrent());
         $pointSale = null;
 
         if ($idSubscription > 0) {