Refactoring services

Model/Order/OrderShopModel.php

      */
     protected $cycleNumber;
 
+    /**
+     * @ORM\Column(type="datetime", nullable=true)
+     */
+    protected $orderShopCreatedAt;
+
+    /**
+     * @ORM\Column(type="integer", nullable=true)
+     */
+    protected $idValidOrder;
     /**
      * @ORM\ManyToOne(targetEntity="App\Entity\Address\Address")
      */
         return $this;
     }
 
+    public function getOrderShopCreatedAt(): ?\DateTimeInterface
+    {
+        return $this->orderShopCreatedAt;
+    }
+
+    public function setOrderShopCreatedAt(?\DateTimeInterface $orderShopCreatedAt): self
+    {
+        $this->orderShopCreatedAt = $orderShopCreatedAt;
+
+        return $this;
+    }
+
+    public function getIdValidOrder(): ?int
+    {
+        return $this->idValidOrder;
+    }
+
+    public function setIdValidOrder(?int $idValidOrder): self
+    {
+        $this->idValidOrder = $idValidOrder;
+
+        return $this;
+    }
+
+
     public function getDeliveryAddress(): ?AddressInterface
     {
         return $this->deliveryAddress;

Repository/Config/TaxRateStore.php

         $this->query = $query;
     }
 
-    public function getAsArray(MerchantInterface $merchant)
+    public function getAsArray(MerchantInterface $merchant, $query = null)
     {
-        $taxRates = $this->query->create()->find();
+        $taxRates = $this->createQuery($query)->find();
 
         $taxRatesList = [];
 

Repository/Config/UnitStore.php

         $this->query = $query;
     }
 
-    public function getAsArray()
+    public function getAsArray($query = null)
     {
-        $query = $this->query->create();
+        $query = $this->createQuery($query);
 
         foreach ($query->find() as $unit) {
             $unitsList[$unit->getId()]['unit'] = $unit->getUnit();

Repository/Credit/CreditHistoryStore.php

     }
 
     //findAllByDateStartEnd
-    public function getByDateStartEnd(DateTime $dateStart, DateTime $dateEnd): array
+    public function getByDateStartEnd(DateTime $dateStart, DateTime $dateEnd, $query = null): array
     {
-        $query = $this->query->create();
+        $query = $this->createQuery($query);
 
         $query
                 ->filterByJoinUserMerchant($this->merchant)
     }
 
     //findAllByUserMerchant
-    public function getByUserMerchant(UserMerchant $userMerchant): array
+    public function getByUserMerchant(UserMerchant $userMerchant, $query = null): array
     {
-        $query = $this->query->create();
+        $query = $this->createQuery($query);
 
         $query
                 ->filterByUserMerchant($userMerchant)

Repository/Merchant/MerchantStore.php

         $this->query = $query;
     }
 
+    public function getOnline($query = null)
+    {
+        $query = $this->createQuery($query);
+        $query->filterIsOnline();
+        return $query->find();
+    }
+
 }

Repository/MerchantRepositoryQueryTrait.php

     {
         return $this->andWhereMerchant($this->id, $merchant);
     }
-}
+}

Repository/Order/OrderShopRepositoryQuery.php

 use Lc\CaracoleBundle\Model\Address\AddressInterface;
 use Lc\CaracoleBundle\Model\Order\OrderReductionCartInterface;
 use Lc\CaracoleBundle\Model\Order\OrderReductionCreditInterface;
+use Lc\CaracoleBundle\Model\Reduction\ReductionCartInterface;
+use Lc\CaracoleBundle\Model\Reduction\ReductionCreditInterface;
 use Lc\CaracoleBundle\Model\User\VisitorInterface;
 use Lc\CaracoleBundle\Repository\SectionRepositoryQueryTrait;
 use Lc\SovBundle\Model\User\UserInterface;
     protected bool $isJoinOrderReductionCredits = false;
     protected bool $isJoinOrderReductionCarts = false;
     protected bool $isJoinOrderStatus = false;
+    protected bool $isJoinMerchant = false;
+    protected bool $isJoinSection = false;
     protected bool $isJoinComplementaryOrderShops = false;
     protected bool $isJoinDeliveryPointSale = false;
 
     public function selectParam($select): self
     {
         return $this
-            ->addSelect($select);
+                ->addSelect($select);
     }
 
     public function selectCount(): self
     {
         return $this
-            ->select('count(r.id) as total');
+                ->select('count(r.id) as total');
     }
 
     public function filterByUser(UserInterface $user): self
     {
         return $this
-            ->andWhere('.user = :user')
-            ->setParameter('user', $user);
+                ->andWhere('.user = :user')
+                ->setParameter('user', $user);
+    }
+
+    public function filterIsMerchantOnline(): self
+    {
+        $this->joinMerchant();
+        return $this
+                ->andWhere('merchant.status = :status')
+                ->setParameter(':status', 1);
     }
 
     public function filterByDateStart(string $dateField, DateTime $dateStart): self
     {
         return $this
-            ->andWhere('.' . $dateField . ' >= :dateStart')
-            ->setParameter('dateStart', $dateStart);
+                ->andWhere('.' . $dateField . ' >= :dateStart')
+                ->setParameter('dateStart', $dateStart);
     }
 
     public function filterByDateEnd(string $dateField, DateTime $dateEnd): self
     {
         return $this
-            ->andWhere('.' . $dateField . ' <= :dateEnd')
-            ->setParameter('dateEnd', $dateEnd);
+                ->andWhere('.' . $dateField . ' <= :dateEnd')
+                ->setParameter('dateEnd', $dateEnd);
     }
 
     public function filterByVisitor(VisitorInterface $visitor): self
     {
         return $this
-            ->andWhere('.visitor = :visitor')
-            ->setParameter('visitor', $visitor);
+                ->andWhere('.visitor = :visitor')
+                ->setParameter('visitor', $visitor);
     }
 
     public function filterByAddress(AddressInterface $address): self
     {
         return $this
-            ->andWhere('.deliveryAddress = :address OR .invoiceAddress = :address')
-            ->setParameter('address', $address);
+                ->andWhere('.deliveryAddress = :address OR .invoiceAddress = :address')
+                ->setParameter('address', $address);
     }
 
     public function filterByStatus(array $statusArray): self
         $this->joinOrderStatus();
 
         return $this
-            ->andWhere('os.alias IN (:alias)')
-            ->setParameter('alias', $statusArray);
+                ->andWhere('os.alias IN (:alias)')
+                ->setParameter('alias', $statusArray);
     }
 
-    public function filterByReductionCredit(OrderReductionCreditInterface $reductionCredit): self
+    public function filterByReductionCredit(ReductionCreditInterface $reductionCredit): self
     {
         $this->joinOrderReductionCredits();
 
         return $this
-            ->andWhere('orc.reductionCredit = :reductionCredit')
-            ->setParameter('reductionCredit', $reductionCredit);
+                ->andWhere('orc.reductionCredit = :reductionCredit')
+                ->setParameter('reductionCredit', $reductionCredit);
     }
 
-    public function filterByReductionCart(OrderReductionCartInterface $reductionCart): self
+    public function filterByReductionCart(ReductionCartInterface $reductionCart): self
     {
         $this->joinOrderReductionCarts();
 
         return $this
-            ->andWhere('orcart.reductionCart = :reductionCart')
-            ->setParameter('reductionCart', $reductionCart);
+                ->andWhere('orcart.reductionCart = :reductionCart')
+                ->setParameter('reductionCart', $reductionCart);
     }
 
     public function filterByCycleNumber(int $cycleNumber): self
     {
         return $this
-            ->andWhere('.cycleNumber = :cycleNumber')
-            ->setParameter('cycleNumber', $cycleNumber);
+                ->andWhere('.cycleNumber = :cycleNumber')
+                ->setParameter('cycleNumber', $cycleNumber);
     }
 
     public function filterIsNotMainOrderShop(): self
     {
         return $this
-            ->andWhere('.mainOrderShop = false OR  .mainOrderShop IS NULL');
+                ->andWhere('.mainOrderShop = false OR  .mainOrderShop IS NULL');
     }
 
     public function filterIsNullMainOrderShop(): self
     {
         return $this
-            ->andWhere('.mainOrderShop IS NULL');
+                ->andWhere('.mainOrderShop IS NULL');
     }
 
     public function selectOrderReductionCarts(): self
             $this->isJoinOrderReductionCredits = true;
 
             return $this
-                ->innerJoin('.orderReductionCredits', 'orc');
+                    ->innerJoin('.orderReductionCredits', 'orc');
         }
         return $this;
     }
             $this->isJoinOrderStatus = true;
 
             return $this
-                ->leftJoin('.orderStatus', 'os');
+                    ->leftJoin('.orderStatus', 'os');
         }
         return $this;
     }
             $this->isJoinOrderReductionCarts = true;
 
             return $this
-                ->leftJoin('.orderReductionCarts', 'orcart');
+                    ->leftJoin('.orderReductionCarts', 'orcart');
+        }
+        return $this;
+    }
+
+    public function joinMerchant(): self
+    {
+        $this->joinSection();
+        if (!$this->isJoinMerchant) {
+            $this->isJoinMerchant = true;
+
+            return $this
+                    ->leftJoin('s.merchant', 'merchant');
+        }
+        return $this;
+    }
+
+    public function joinSection(): self
+    {
+        if (!$this->isJoinSection) {
+            $this->isJoinSection = true;
+
+            return $this
+                    ->leftJoin('.section', 's');
         }
         return $this;
     }
             $this->isJoinComplementaryOrderShops = true;
 
             return $this
-                ->leftJoin('.complementaryOrderShops', 'complementaryOrderShops');
+                    ->leftJoin('.complementaryOrderShops', 'complementaryOrderShops');
         }
         return $this;
     }
             $this->isJoinDeliveryPointSale = true;
 
             return $this
-                ->leftJoin('.deliveryPointSale', 'pointSale');
+                    ->leftJoin('.deliveryPointSale', 'pointSale');
         }
         return $this;
     }

Repository/Order/OrderShopStore.php

 use Lc\CaracoleBundle\Model\Order\OrderReductionCreditInterface;
 use Lc\CaracoleBundle\Model\Order\OrderShopInterface;
 use Lc\CaracoleBundle\Model\Order\OrderStatusModel;
+use Lc\CaracoleBundle\Model\Reduction\ReductionCartInterface;
+use Lc\CaracoleBundle\Model\Reduction\ReductionCreditInterface;
 use Lc\CaracoleBundle\Model\Section\SectionInterface;
 use Lc\CaracoleBundle\Repository\Merchant\MerchantStore;
 use Lc\CaracoleBundle\Repository\Reduction\ReductionCreditStore;
     }
 
     // getOrderShopsOfWeek
-    public function getByCycle(SectionInterface $section, $params = [])
+    public function getByCurrentCycle($params = [])
     {
         $orderShops = $this->getBy(
                 array_merge(
                         [
-                                'section' => $section,
-                                'cycleNumber' => $this->getCycleNumberCurrentOrder($section),
+                                'section' => $this->section,
+                                'cycleNumber' => $this->getCycleNumberCurrentOrder($this->section),
                                 'isValid' => true,
                         ],
                         $params
     }
 
     // getOrderShopsOfWeekByUser
-    public function getByCycleAndUser(SectionInterface $section, UserInterface $user, array $params = [])
+    public function getByCurrentCycleAndUser(UserInterface $user, array $params = [])
     {
-        return $this->getByCycle(
-                $section,
+        return $this->getByCurrentCycle(
                 array_merge(
                         [
                                 'user' => $user,
-                                'cycleNumber' => $this->getCycleNumberCurrentOrder($section),
+                                'cycleNumber' => $this->getCycleNumberCurrentOrder($this->section),
                                 'excludeComplementaryOrderShops' => true
                         ],
                         $params
 
     //public $countOrderShopsOfWeek = null;
 
-    public function countByCycle(SectionInterface $section, bool $excludeComplementaryOrderShops = true)
+    public function countByCurrentCycle(bool $excludeComplementaryOrderShops = true)
     {
-        return $this->getByCycle(
-                $section,
+        return $this->getByCurrentCycle(
                 [
                         'count' => true,
                         'excludeComplementaryOrderShops' => $excludeComplementaryOrderShops
 
         // @TODO : optimisation à remettre en place
         /*if (is_null($this->countOrderShopsOfWeek)) {
-            $this->countOrderShopsOfWeek = $this->getByCycle(
+            $this->countOrderShopsOfWeek = $this->getByCurrentCycle(
                     $section,
                     [
                             'count' => true,
     // countValidOrderShopByUserAllMerchant
     public function countValidByUserAllMerchant($user): int
     {
-        $totalOrder = 0;
-
-        foreach ($this->merchantStore->getRepositoryQuery()->findAll() as $merchant) {
-            $totalOrder += $this->countValidByUser($user, $merchant);
-        }
-
-        return $totalOrder;
+        return $this->countBy(
+                [
+                        'user' => $user,
+                        'isValid' => true,
+                        // @TODO : à tester
+                        'isMerchantOnline' => true,
+                        'excludeComplementaryOrderShops' => true
+                ]
+        );
     }
 
-    public function countValidByUser(UserInterface $user, MerchantInterface $merchant = null): int
+    public function countValidByUser(UserInterface $user): int
     {
-        return $this->getBy(
+        return $this->countBy(
                 [
                         'user' => $user,
                         'isValid' => true,
-                        'merchant' => $merchant,
-                        'excludeComplementaryOrderShops' => true,
-                        'count' => true
+                        'section' => $this->section,
+                        'excludeComplementaryOrderShops' => true
+                ]
+        );
+    }
+
+    public function countValidByCurrentCycle(): int
+    {
+        return $this->countBy(
+                [
+                        'cycleNumber' => $this->getCycleNumberCurrentOrder($this->section),
+                        'isValid' => true,
+                        'section' => $this->section,
+                        'excludeComplementaryOrderShops' => true
                 ]
         );
     }
 
     // countValidOrderWithReductionCredit
     public function countValidWithReductionCredit(
-            OrderReductionCreditInterface $reductionCredit,
+            ReductionCreditInterface $reductionCredit,
             UserInterface $user = null
-    ): string {
+    ): int {
         $query = $this->query->create();
 
         if ($user) {
 
     // countValidOrderWithReductionCart
     public function countValidWithReductionCart(
-            OrderReductionCartInterface $reductionCart
+            ReductionCartInterface $reductionCart
     ): int {
         $query = $this->query->create();
         $query
     }
 
     // countValidOrderWithReductionCartPerUser
-    public function countValidWithReductionCartPerUser(
-            OrderReductionCartInterface $reductionCart,
+    public function countValidWithReductionCartByUser(
+            ReductionCartInterface $reductionCart,
             UserInterface $user
-    ): string {
+    ): int {
         $query = $this->query->create();
 
         $query
                 ->filterByStatus(OrderStatusModel::$statusAliasAsValid)
                 ->filterBySection($this->section);
 
-        $results = $query->find();
-
-        if ($results) {
-            return $results[0];
-        }
+        return $query->findOne();
 
-        return null;
     }
 
     // findLastOrderValidOfWeek
-    public function getOneLastValidOfCycle(int $cycleNumber): ?OrderShopInterface
+    public function getOneLastValidByCycle(int $cycleNumber): ?OrderShopInterface
     {
         $query = $this->query->create();
 
                 ->filterByCycleNumber($cycleNumber)
                 ->filterByStatus(OrderStatusModel::$statusAliasAsValid)
                 ->filterIsNotMainOrderShop()
-                ->orderBy('.weekId', 'DESC')
+                ->orderBy('.cycleId', 'DESC')
                 ->filterBySection($this->section);
 
         return $query->findOne();
             $query->filterBySection($this->section);
         }
 
+        if (isset($params['isMerchantOnline'])) {
+            $query->filterIsMerchantOnline();
+        }
+
         if (isset($params['select'])) {
             $query->selectParam($params['select']);
         }
 
 
 
+    public function isReductionGiftUsed(ReductionCreditInterface $reductionGift)
+    {
+        if ($this->countValidWithReductionCredit($reductionGift)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public function isReductionCreditUsed(ReductionCreditInterface $reductionCredit, UserInterface $user = null)
+    {
+        if ($this->countValidWithReductionCredit($reductionCredit, $user)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public function isReductionCreditAddedToOrder(
+            OrderShopInterface $orderShop,
+            ReductionCreditInterface $reductionCredit
+    ) {
+        foreach ($orderShop->getOrderReductionCredits() as $orderReductionCredit) {
+            if ($orderReductionCredit->getReductionCredit() == $reductionCredit) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     /*
    public function getCartCurrent(SectionInterface $section, UserInterface $user = null, VisitorInterface $visitor = null)
    {

Repository/Product/ProductCategoryRepository.php

     {
         parent::__construct($registry, ProductCategory::class);
     }
+
+
 }

Repository/Product/ProductCategoryRepositoryQuery.php

         return $this->andWhere('pf.status = 1');
     }
 
-    public function filterByCurrentDay(): self
-    {
-        return $this->andWhere('e.displaySpecificDay IS NULL OR e.displaySpecificDay = :dayToday')
-                ->setParameter('dayToday', date('N'));
-    }
+
 }

Repository/Product/ProductCategoryStore.php

     {
         $this->query = $query;
     }
-
-    public function getParents()
-    {
-        $query = $this->query->create();
-        if ($this->section) {
-            $query->filterBySection($this->section);
-        }
-        $query->filterIsParent();
-
-        return $query->find();
-    }
-
-    //findAllByParent
-    public function getByParent(
-            ProductCategoryInterface $parentCategory,
-            bool $withOffline = false,
-            bool $withEmptyCategories = true,
-            bool $filterBySpecificDay = false
-    ): array {
-
-        $query = $this->query->create();
-        $query->filterByParent($parentCategory);
-
-        if ($withOffline) {
-            $query->filterIsOnlineAndOffline();
-        } else {
-            $query->filterIsOnline();
-        }
-
-        if (!$withEmptyCategories) {
-            $query->hasProductFamilyOnline();
-        }
-
-        if ($filterBySpecificDay) {
-            $query->filterBySpecificDay();
-        }
-
-        $query->orderBy('position', 'asc');
-
-        return $query->find();
-    }
+    
 
 }

Repository/Reduction/ReductionCartStore.php

     // getReductionCartRemainingQuantity
     public function getRemainingQuantity(ReductionCartInterface $reductionCart): float
     {
-        return $reductionCart->getAvailableQuantity() - $this->orderShopStore->countValidOrderWithReductionCart(
+        return $reductionCart->getAvailableQuantity() - $this->orderShopStore->countValidWithReductionCart(
                         $reductionCart
                 );
     }
     // getReductionCartUsedQuantityPerUser
     public function getUsedQuantityByUser(ReductionCartInterface $reductionCart, UserInterface $user): float
     {
-        return $this->orderShopStore->countValidWithReductionCartPerUser($reductionCart, $user);
+        return $this->orderShopStore->countValidWithReductionCartByUser($reductionCart, $user);
     }
 
     // getReductionCartUsedQuantity
     public function getUsedQuantity(ReductionCartInterface $reductionCart): float
     {
-        return $this->orderShopStore->countValidWithReductionCartPerUser($reductionCart);
+        return $this->orderShopStore->countValidWithReductionCart($reductionCart);
     }
 
     // getReductionCartRemainingQuantityPerUser
     {
         if ($reductionCart->getAvailableQuantityPerUser()) {
             return $reductionCart->getAvailableQuantityPerUser(
-                    ) - $this->orderShopStore->countValidWithReductionCartPerUser($reductionCart, $user);
+                    ) - $this->orderShopStore->countValidWithReductionCartByUser($reductionCart, $user);
         }
 
         return false;
     }
 
     // findAllAvailableForUser / getReductionCartsAvailableByUser
-    public function getAvailablesByUser(UserInterface $user)
+    public function getAvailableByUser(UserInterface $user)
     {
         $reductionCarts = $this->query->find();
 

Repository/Reduction/ReductionCatalogRepositoryQuery.php

                 ->setParameter(':productFamily', $productFamily);
     }
 
-    public function filterStatus(bool $status)
-    {
-        return $this
-                ->andWhere('.status = :status')
-                ->setParameter(':status', $status);
-    }
 }

Repository/Reduction/ReductionCatalogStore.php

     public function getByProductFamily($productFamily){
         $query = $this->query->create();
         $query->filterProductFamily($productFamily);
-        $query->filterStatus(true);
+        $query->filterIsOnline();
         return $query->findOne();
 
     }

Repository/Reduction/ReductionCreditRepositoryQuery.php

         parent::__construct($repository, 'r', $paginator);
     }
 
-    public function filterStatusOnline()
-    {
-        return $this->andWhere('.status = 1');
-    }
-
     public function filterByUser(UserInterface $user)
     {
         return $this

Repository/Reduction/ReductionCreditStore.php

         $query = $this->query->create();
 
         $query
-                ->filterStatusOnline()
                 ->filterByType($type)
                 ->filterByUser($user);
 
         return $query->find();
     }
 
-    public function isReductionGiftUsed(ReductionCreditInterface $reductionGift)
-    {
-        if ($this->orderShopStore->countValidOrderWithReductionCredit($reductionGift)) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    public function isReductionCreditUsed(ReductionCreditInterface $reductionCredit, UserInterface $user = null)
-    {
-        if ($this->orderShopStore->countValidOrderWithReductionCredit($reductionCredit, $user)) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    public function isReductionCreditAddedToOrder(
-            OrderShopInterface $orderShop,
-            ReductionCreditInterface $reductionCredit
-    ) {
-        foreach ($orderShop->getOrderReductionCredits() as $orderReductionCredit) {
-            if ($orderReductionCredit->getReductionCredit() == $reductionCredit) {
-                return true;
-            }
-        }
 
-        return false;
-    }
 }

Repository/Reminder/ReminderStore.php

             $query->filterByMerchant($this->merchant);
         }
 
+        if ($this->section) {
+            $query->filterBySection($this->section);
+        }
+
         return parent::getByUser($user, $query);
     }
 
             $query->filterByMerchant($this->merchant);
         }
 
+        if ($this->section) {
+            $query->filterBySection($this->section);
+        }
+
         return parent::getByEasyAdminConfigAndUser($crudAction, $crudControllerFqcn, $user, $entityId, $query);
     }
 }

Repository/SectionRepositoryQueryTrait.php

     {
         return $this->andWhereSection($this->id, $section);
     }
-}
+}

Repository/SectionStoreTrait.php

 
         return $this;
     }
+
+    public function getParents()
+    {
+        $query = $this->query->create();
+        if ($this->section) {
+            $query->filterBySection($this->section);
+        }
+        $query->filterIsParent();
+
+        return $query->find();
+    }
+
 }

Repository/Site/NewsRepositoryQuery.php

 
 namespace Lc\CaracoleBundle\Repository\Site;
 
-use Lc\CaracoleBundle\Repository\MerchantRepositoryQueryTrait;
+use Lc\CaracoleBundle\Repository\SectionRepositoryQueryTrait;
 use Lc\SovBundle\Repository\Site\NewsRepositoryQuery as SovNewsRepositoryQuery;
 
 class NewsRepositoryQuery extends SovNewsRepositoryQuery
 {
-    use MerchantRepositoryQueryTrait;
+    use SectionRepositoryQueryTrait;
 
 }

Repository/Site/NewsStore.php

 
 namespace Lc\CaracoleBundle\Repository\Site;
 
-use Lc\CaracoleBundle\Repository\MerchantStoreTrait;
+use Lc\CaracoleBundle\Repository\SectionStoreTrait;
 use Lc\SovBundle\Repository\Site\NewsStore as SovNewsStore;
 
 class NewsStore extends SovNewsStore
 {
-    use MerchantStoreTrait;
+    use SectionStoreTrait;
 
     public function getLatests(int $maxResults = 0, $query = null): array
     {
             $query = $this->query->create();
         }
 
-        if ($this->merchant) {
-            $query->filterByMerchant($this->merchant);
+        if ($this->section) {
+            $query->filterBySection($this->section);
         }
 
         return parent::getLatests($maxResults, $query);

Repository/Site/PageStore.php

     }
 
     // findPage
-    public function getOnePage(string $devAlias): ?PageInterface
+    public function getOneByDevAlias(string $devAlias): ?PageInterface
     {
         $query = $this->query->create();
 

Repository/Ticket/TicketRepositoryQuery.php

 
 namespace Lc\CaracoleBundle\Repository\Ticket;
 
-use Lc\CaracoleBundle\Repository\MerchantRepositoryQueryTrait;
+use Lc\CaracoleBundle\Repository\SectionRepositoryQueryTrait;
 use Lc\SovBundle\Repository\Ticket\TicketRepositoryQuery as SovTicketRepositoryQuery;
 
 class TicketRepositoryQuery extends SovTicketRepositoryQuery
 {
-    use MerchantRepositoryQueryTrait;
+    use SectionRepositoryQueryTrait;
 
 }

Repository/Ticket/TicketStore.php

 
 namespace Lc\CaracoleBundle\Repository\Ticket;
 
-use Lc\CaracoleBundle\Repository\MerchantStoreTrait;
+use Lc\CaracoleBundle\Repository\SectionStoreTrait;
+use Lc\SovBundle\Model\User\UserInterface;
 use Lc\SovBundle\Repository\Ticket\TicketStore as SovTicketStore;
 
 class TicketStore extends SovTicketStore
 {
-    use MerchantStoreTrait;
+    use SectionStoreTrait;
 
-    public function getByUser($user, $query = null): array
+    public function getByUser(UserInterface $user, $query = null): array
     {
-        if (is_null($query)) {
-            $query = $this->query->create();
-        }
-
-        if ($this->merchant) {
-            $query->filterByMerchant($this->merchant);
-        }
-
+        $query = $this->createQuery($query);
+        $query->filterBySection($this->section);
         return parent::getByUser($user, $query);
     }
 
-    public function getAllOpen(int $limit = 0, $query = null): array
+    public function getOpen(int $limit = 0, $query = null): array
     {
-        if (is_null($query)) {
-            $query = $this->query->create();
-        }
-
-        if ($this->merchant) {
-            $query->filterByMerchant($this->merchant);
-        }
-
-        return parent::getAllOpen($limit, $query);
+        $query = $this->createQuery($query);
+        $query->filterBySection($this->section);
+        return parent::getOpen($limit, $query);
     }
 
-    public function countAllOpen($query = null): string
+    public function countOpen($query = null): string
     {
-        if (is_null($query)) {
-            $query = $this->query->create();
-        }
-
-        if ($this->merchant) {
-            $query->filterByMerchant($this->merchant);
-        }
-
-        return parent::countAllOpen($query);
+        $query = $this->createQuery($query);
+        $query->filterBySection($this->section);
+        return parent::countOpen($query);
     }
 
 }

Repository/User/UserMerchantStore.php

     }
 
     // getUserMerchant
-    public function getOneByUser(UserInterface $user): UserMerchantInterface
+    public function getOneByUser(UserInterface $user, $query = null): UserMerchantInterface
     {
-        $query = $this->query->create();
+        $query = $this->createQuery($query);
 
         $query
                 ->filterByMerchant($this->merchant)
         return $query->findOne();
     }
 
-    public function isCreditActiveByUser(UserInterface $user): bool
+    public function isCreditActiveByUser(UserInterface $user, $query = null): bool
     {
-        $userMerchant = $this->getOneByUser($user);
+        $userMerchant = $this->getOneByUser($user, $query);
         return $this->userMerchantSolver->isCreditActive($userMerchant);
     }
+    
 }

Repository/User/UserRepositoryQuery.php

             ->andWhere('um.active = 1');
     }
 
-    public function filterByJoinUserMerchant(Merchant $merchant): self
+    public function filterByMerchant(Merchant $merchant): self
     {
         $this->joinUserMerchants();
         return $this

Repository/User/UserStore.php

 {
     use MerchantStoreTrait;
 
-    public function getByNewsletter(Newsletter $newsletter, $query = null): array
-    {
-        if (is_null($query)) {
-            $query = $this->query->create();
-        }
-
-        if ($this->merchant) {
-            $query
-                ->filterByJoinUserMerchant($this->merchant)
-                ->filterMerchantIsActive();
-        }
-
-        return parent::getByNewsletter($newsletter, $query);
-    }
 }

Repository/User/VisitorStore.php

         $this->query = $query;
     }
 
-    public function getOneByCookie(string $cookie)
+    public function getOneByCookie(string $cookie, $query = null)
     {
-        $query = $this->query->create();
-
+        $query = $this->createQuery($query);
         $query->filterByCookie($cookie);
-
         return $query->findOne();
     }
 }

Resolver/MerchantResolver.php

 
     public function getMerchantUser(UserInterface $user = null)
     {
-        $merchants = $this->merchantStore->findAll();
+        $merchants = $this->merchantStore->getOnline();
 
         if ($user) {
             return $user->getMerchant();

Resolver/OpeningResolver.php

     protected array $messages = [];
     protected SectionResolver $sectionResolver;
     protected Security $security;
-    //protected OrderShopStore $orderShopStore;
+    protected OrderShopStore $orderShopStore;
 
-    public function __construct(SectionResolver $sectionResolver, Security $security /*, OrderShopStore $orderShopStore*/)
+    public function __construct(SectionResolver $sectionResolver, Security $security, OrderShopStore $orderShopStore)
     {
         $this->sectionResolver = $sectionResolver;
         $this->security = $security;
-        //$this->orderShopStore = $orderShopStore;
+        $this->orderShopStore = $orderShopStore;
     }
 
     public function isOpenSale(
-            SectionInterface $section = null,
+            SectionInterface $section,
             UserInterface $user = null,
             \DateTime $date = null,
             string $context = null
         // Initialisation
         $this->messages = [];
 
-        if (is_null($section)) {
-            $section = $this->sectionResolver->getCurrent();
-        }
-
-        if (is_null($user)) {
-            $user = $this->security->getUser();
-        }
-
         if (is_null($date)) {
             $date = new \DateTime();
         }
         }
 
         // Période de fermeture des commandes issue de la configuration de la section (congés)
-        if($this->isClosingPeriod($section)) {
+        if($this->isClosingPeriod($section, $date)) {
             $this->addMessage(
                     'Les commandes sont fermées (période de fermeture des commandes dans la configuration de la section).'
             );
     }
 
     // isHolidays
-    public function isClosingPeriod(Section $section, \DateTime $date)
+    public function isClosingPeriod(SectionInterface $section, \DateTime $date)
     {
         $orderClosedStart = $section->getSettingValue(SectionSettingDefinition::SETTING_ORDER_CLOSED_START);
         $orderClosedEnd = $section->getSettingValue(SectionSettingDefinition::SETTING_ORDER_CLOSED_END);
     // isMaximumOrderWeekAchieved
     public function isMaximumOrderCycleAchieved(SectionInterface $section)
     {
-        // @TODO : countValidByCycle
-        //$countOrderShopCycle = $this->orderShopStore->countValidByCycle($section);
-        $countOrderShopCycle = 0 ;
+
+        $countOrderShopCycle = $this->orderShopStore->countValidByCurrentCycle();
         $orderMaximumPerCycle = $section->getSettingValue(SectionSettingDefinition::SETTING_ORDER_MAXIMUM_PER_CYCLE);
         if ($orderMaximumPerCycle && $countOrderShopCycle >= $orderMaximumPerCycle) {
             return true;