Merge branch 'develop' of https://forge.laclic.fr/Laclic/CaracoleBundle into develop

Builder/Order/OrderShopBuilder.php

 use Lc\SovBundle\Translation\FlashBagTranslator;
 use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 use Symfony\Component\HttpFoundation\Session\Flash\FlashBagInterface;
+use Symfony\Contracts\Cache\CacheInterface;
+use Symfony\Contracts\Cache\ItemInterface;
+use Symfony\Contracts\Cache\TagAwareCacheInterface;
 
 class OrderShopBuilder
 {
         return $orderShop;
     }
 
+
+    protected array $cacheCartCurrentBySection = [];
+
     public function createIfNotExist(
             SectionInterface $section,
             UserInterface $user = null,
-            VisitorInterface $visitor = null
+            VisitorInterface $visitor = null,
+            bool $cache = false
     ): OrderShopInterface {
+
+        $cart = null;
+
+        // cache
+        $cacheIdCartCurrent = 'cart_current_'.$section->getId();
+        if($cache && isset($this->cacheCartCurrentBySection[$cacheIdCartCurrent])) {
+            return $this->cacheCartCurrentBySection[$cacheIdCartCurrent];
+        }
+
         $this->orderShopStore->setSection($section);
 
         $cartUser = $this->orderShopStore->getOneCartCurrent($user);
         if ($cartUser && $cartVisitor && $cartUser->getId() != $cartVisitor->getId()) {
             $cart = $this->merge($cartUser, $cartVisitor);
         } else {
-            $cart = $cartUser ?: $cartVisitor;
+            if($cartUser) {
+                $cart = $cartUser;
+            }
+            elseif($cartVisitor) {
+
+                if($user && $cartVisitor && !$cartVisitor->getUser()) {
+                    $cartVisitor->setUser($user);
+                    $this->entityManager->update($cartVisitor);
+                    $this->entityManager->flush();
+                }
+
+                $cart = $cartVisitor;
+            }
         }
 
         if (!$cart) {
         // @TODO : obligé de faire ça sinon le panier ne se met pas à jour quand on ajoute des produits. Pourquoi ?
         $this->entityManager->refresh($cart);
 
+        // cache
+        $this->cacheCartCurrentBySection[$cacheIdCartCurrent] = $cart;
+
         return $cart;
     }
 
                             && $orderProduct->getRedelivery() == $orderProductAdd->getRedelivery()
                             && (string)$this->priceSolver->getPrice($orderProduct)
                             == (string)$this->priceSolver->getPrice($orderProductAdd)
-                            && $orderProduct->getOrderProductReductionCatalog()
-                            && $orderProductAdd->getOrderProductReductionCatalog()
                             && $this->orderProductReductionCatalogSolver->compare(
                                     $orderProduct->getOrderProductReductionCatalog(),
                                     $orderProductAdd->getOrderProductReductionCatalog()

Controller/ControllerTrait.php

         return $this->getOrderShopContainer()->getBuilder()->createIfNotExist(
                 $this->getSectionCurrent(),
                 $this->getUserCurrent(),
-                $this->getVisitorCurrent()
+                $this->getVisitorCurrent(),
+                true
         );
     }
 

Controller/Order/CartController.php

                 $form->handleRequest($request);
 
                 if ($form->isSubmitted() && $form->isValid()) {
+
                     $orderShop = $this->getOrderShopContainer()->getBuilder()->createIfNotExist(
                             $this->getSectionCurrent(),
                             $this->getUserCurrent(),

Controller/Section/OpeningAdminController.php

 
     public function configureFields(string $pageName): iterable
     {
-        $fields = parent::configureFields($pageName);
-
-        return array_merge(
-                [
+        return [
                         ChoiceField::new('day')
                                 ->setRequired(true)
                                 ->setChoices(
                                 ->setRequired(false)
                                 ->setFormat('H:mm'),
                         AssociationField::new('groupUser'),
-                ],
-                $fields
-        );
+                ];
     }
 
     public function configureCrud(Crud $crud): Crud

Form/Order/OrderProductsType.php

             $idProductFamily = $options['data']['id_product_family'];
             $productFamily = $this->productFamilyStore->getOneById($idProductFamily);
 
+            // @TODO : obligé sinon ne fonctionne pas. Problème avec le chargement des relations ?
+            $this->entityManager->refresh($productFamily);
+
             $builder->add('id_product_family', HiddenType::class, [
                     'data' => $productFamily->getId()
             ]);
             if ($productFamily) {
                 if ($productFamily->getActiveProducts()
                         && $productFamily->getBehaviorAddToCart() == 'multiple') {
-                    $cpt = 0;
 
-                    foreach ($this->productFamilySolver->getProductsGroupByTitle($productFamily) as $key => $product) {
+                    $cpt = 0;
+                    foreach ($this->productFamilySolver->getProductsGroupByTitle($productFamily) as $product) {
                         $orderProduct = $this->orderProductFactory->create($product[0], 0);
                         $builder->add('order_product_' . $cpt, OrderProductType::class, [
                                 'data' => $orderProduct
                     $product = null;
                     if ($productFamily->getActiveProducts()) {
                         $products = $this->productFamilySolver->getProductsOnline($productFamily);
+
                         if ($products && count($products) > 0) {
                             $product = $products[0];
                         }

Repository/Order/OrderShopStore.php

     // findCartCurrent
     public function getOneCartCurrent(UserInterface $user = null, VisitorInterface $visitor = null, $query = null): ?OrderShopInterface
     {
+        if(is_null($user) && is_null($visitor)) {
+            return null;
+        }
+
         $query = $this->createDefaultQuery($query);
 
         if (!is_null($user)) {

Repository/Product/ProductCategoryRepositoryQuery.php

 
         return $this;
     }
+
+
+
     public function hasProductFamilyOnline(): self
     {
         $this->joinProductFamilies();

Repository/Product/ProductFamilyRepositoryQuery.php

 
 class ProductFamilyRepositoryQuery extends AbstractRepositoryQuery
 {
-    //use SectionRepositoryQueryTrait;
-
     protected bool $isJoinProductCategories = false;
     protected bool $isJoinProductFamilySectionProperties = false;
     protected bool $isJoinProducts = false;
+    protected bool $isJoinQualityLabels = false;
 
     public function __construct(ProductFamilyRepository $repository, PaginatorInterface $paginator)
     {
         return $this;
     }
 
+    public function joinQualityLabels(bool $addSelect = true): self
+    {
+        if (!$this->isJoinQualityLabels) {
+            $this->isJoinQualityLabels = true;
+
+            $this->leftJoin('.qualityLabels', 'pfql');
+            if ($addSelect) {
+                $this->addSelect('pfql');
+            }
+        }
+        return $this;
+    }
+
     public function filterBySection(SectionInterface $section,bool $addSelectProductFamilySectionProperties = true)
     {
         $this->joinProductFamilySectionProperties($addSelectProductFamilySectionProperties);
         return $this->andWhereEqual('supplier', $supplier);
     }
 
-    public function joinProductCategories(): self
+    public function joinProductCategories(bool $addSelect = false): self
     {
         if (!$this->isJoinProductCategories) {
             $this->isJoinProductCategories = true;
 
             return $this
-                    ->leftJoin('.productCategories', 'cat');
-            //$query->addSelect('cat') ; ???
+                    ->leftJoin('.productCategories', 'cat')
+                    ->addSelect('cat')
+                    ;
         }
         return $this;
     }
             $this->isJoinProducts = true;
 
             return $this
-                    ->innerJoin('.products', 'pfp');
-            //  $query->addSelect('pfp') ; ?????
+                    ->innerJoin('.products', 'pfp')
+                    ->addSelect('pfp')
+                    ;
         }
         return $this;
     }

Repository/Product/ProductFamilyStore.php

 
     public function filtersDefault(RepositoryQueryInterface $query): RepositoryQueryInterface
     {
-        if($this->section) {
-            $query->filterBySection($this->section);
-        }
 
-        if(isset($this->merchant) && $this->merchant) {
-            $query->filterByMerchantViaSection($this->merchant);
-        }
+        $this->addFilterBySectionOptionnal($query);
+        $this->addFilterByMerchantViaSectionOptionnal($query);
 
         return $query;
     }
     {
         $query->joinProductCategories();
         $query->joinProducts();
+        $query->joinQualityLabels();
+
         return $query;
     }
 
 
             if (($onlyOnDiscount && $productFamily->getReductionCatalog()) || !$onlyOnDiscount) {
                 if ($organizeByParentCategory) {
+
                     $productCategories = $productFamily->getProductCategories();
+
                     if ($productCategories && count($productCategories) > 0) {
                         $parentCategory = $productCategories[0]->getParentCategory();
                         if ($this->productCategorySolver->isDisplay($parentCategory, $user)) {

Repository/Product/ProductRepositoryQuery.php

             $this->isJoinProductFamily = true;
 
             return $this
-                    ->innerJoin('.productFamily', 'pf');
-            //$qb->addSelect('pf'); ???
+                    ->innerJoin('.productFamily', 'pf')
+                    ->addSelect('pf');
         }
         return $this;
     }

Repository/Reduction/ReductionCatalogRepositoryQuery.php

     protected bool $isJoinProductFamilies = false;
     protected bool $isJoinProductFamily = false;
     protected bool $isJoinProductCategories = false;
+    protected bool $isJoinUsers = false;
+    protected bool $isJoinGroupUsers = false;
+
     use SectionRepositoryQueryTrait;
 
     public function __construct(ReductionCatalogRepository $repository, PaginatorInterface $paginator)
         parent::__construct($repository, 'r', $paginator);
     }
 
+    public function joinUsers()
+    {
+        if (!$this->isJoinUsers) {
+            $this->isJoinUsers = true;
+
+            return $this
+                    ->leftJoin('.users', 'pf_users')
+                    ->addSelect('pf_users') ;
+        }
+        return $this;
+    }
+
+    public function joinGroupUsers()
+    {
+        if (!$this->isJoinGroupUsers) {
+            $this->isJoinGroupUsers = true;
+
+            return $this
+                    ->leftJoin('.groupUsers', 'pf_groupusers')
+                    ->addSelect('pf_groupusers') ;
+        }
+        return $this;
+    }
+
     public function joinProductFamilies()
     {
         if (!$this->isJoinProductFamilies) {
             $this->isJoinProductFamilies = true;
 
             return $this
-                    ->leftJoin('.productFamilies', 'pfs');
-            //->addSelect('pfs') ;
+                    ->leftJoin('.productFamilies', 'pfs')
+                    ->addSelect('pfs') ;
         }
         return $this;
     }
             $this->isJoinProductFamily = true;
 
             return $this
-                    ->leftJoin('.productFamily', 'pf');
-            //->addSelect('pf') ;
+                    ->leftJoin('.productFamily', 'pf')
+                    ->addSelect('pf') ;
         }
         return $this;
     }
             $this->isJoinProductCategories = true;
 
             return $this
-                    ->leftJoin('.productCategories', 'pcs');
-            //->addSelect('pcs') ;
+                    ->leftJoin('.productCategories', 'pcs')
+                    ->addSelect('pcs') ;
         }
         return $this;
     }
 
-
     public function filterProductFamily(ProductFamilyInterface $productFamily)
     {
         return $this
 
     public function filterConditionUser(UserInterface $user = null)
     {
+        $this->joinUsers();
+
         if ($user) {
             return $this
                     ->andWhere(':user MEMBER OF .users OR .users is empty')
 
     public function filterConditionGroupUser(UserInterface $user = null)
     {
+        $this->joinGroupUsers();
+
         if ($user) {
             return $this
                     ->andWhere(':groupUser MEMBER OF .groupUsers OR .groupUsers is empty')
     {
         $this->joinProductFamilies();
         $this->joinProductFamily();
+
         return $this
                 ->andWhere(':productFamilies MEMBER OF .productFamilies OR .productFamilies is empty')
                 ->setParameter('productFamilies', $productFamilies);
     {
         $this->joinProductFamilies();
         $this->joinProductFamily();
+
         return $this
                 ->andWhere(':productFamily MEMBER OF .productFamilies OR .productFamilies is empty')
                 ->setParameter('productFamily', $productFamily);
     public function filterConditionProductCategories(array $productCategories)
     {
         $this->joinProductCategories();
+
         return $this
                 ->andWhere(':productCategory MEMBER OF .productCategories OR .productCategories is empty')
                 ->setParameter('productCategory', $productCategories);

Resolver/OpeningResolver.php

 
         if (!$this->isOpenSale($section)) {
             $opening = $this->openingSolver->getNextOpeningOfOpening($date, $openingArray);
+
             if ($opening) {
                 return $this->openingSolver->getFormatedDateByFormatAndDelimiterDayTime(
                         $date,
-                        $opening->getTimeStart(),
+                        $opening->getTimeStart() ?: (new \DateTime())->setTime(0, 0),
                         $formatDate,
                         $delimiterDayTime
                 );

Resolver/SectionResolver.php

             }
         } // front
         else {
-            $merchantCurrent = $this->merchantResolver->getCurrent();
-            $sectionStore = $this->sectionStore->setMerchant($merchantCurrent);
-            $sectionCurrent = null;
-            $sectionDefault = $sectionStore->getOneDefault();
-
-            if (isset($requestAttributesArray['section'])) {
-                $sectionCurrent = $sectionStore
-                    ->setMerchant($merchantCurrent)
-                    ->getOneBySlug($requestAttributesArray['section']);
+            if($this->section === null) {
+                $merchantCurrent = $this->merchantResolver->getCurrent();
+                $sectionStore = $this->sectionStore->setMerchant($merchantCurrent);
+                $sectionCurrent = null;
+                $sectionDefault = $sectionStore->getOneDefault();
+
+                if (isset($requestAttributesArray['section'])) {
+                    $sectionCurrent = $sectionStore
+                            ->setMerchant($merchantCurrent)
+                            ->getOneBySlug($requestAttributesArray['section']);
+                }
+
+                $this->section = $sectionCurrent ?: $sectionDefault;
             }
 
-            return $sectionCurrent ?: $sectionDefault;
+            return $this->section;
         }
     }
 

Solver/Order/OrderProductReductionCatalogSolver.php

 
     // compareOrderProductReductionCatalog
     public function compare(
-            OrderProductReductionCatalogInterface $orderProductReductionCatalog,
-            OrderProductReductionCatalogInterface $orderProductReductionCatalogCompare
+            OrderProductReductionCatalogInterface $orderProductReductionCatalog = null,
+            OrderProductReductionCatalogInterface $orderProductReductionCatalogCompare = null
     ): bool {
+
+        if(is_null($orderProductReductionCatalog) && is_null($orderProductReductionCatalogCompare)) {
+            return true;
+        }
+
+        if(is_null($orderProductReductionCatalog) || is_null($orderProductReductionCatalogCompare)) {
+            return false;
+        }
+
         return $orderProductReductionCatalog->getUnit() == $orderProductReductionCatalogCompare->getUnit()
                 && (string)$orderProductReductionCatalog->getValue(
                 ) == (string)$orderProductReductionCatalogCompare->getValue()

Solver/Order/OrderShopSolver.php

                 || (($behaviorCountStock == ProductFamilyModel::BEHAVIOR_COUNT_STOCK_BY_PRODUCT_FAMILY || $behaviorCountStock == ProductFamilyModel::BEHAVIOR_COUNT_STOCK_BY_MEASURE)
                     && $orderProduct->getProduct()->getProductFamily()->getId() == $productFamily->getId())) {
                 if ($byWeight) {
-                    $quantity += $orderProduct->getQuantityOrder() * ($orderProduct->getQuantityProduct() / $orderProduct->getProduct()->getUnitInherited()->getCoefficient());
+                    $quantity += $orderProduct->getQuantityOrder() * ($orderProduct->getQuantityProduct() / $this->productSolver->getUnitInherited($orderProduct->getProduct())->getCoefficient());
                 } else {
                     $quantity += $orderProduct->getQuantityOrder();
                 }

Solver/Section/OpeningSolver.php

         }
 
         $count = 0;
-        $isClosingDay = false;
 
         do {
             if ($count) {
                 $date->modify('+1 day');
             }
             $weekDay = $date->format('N');
-            $isClosingDay = $this->$methodTestDay($weekDay, $openings);
+            $testDay = $this->$methodTestDay($weekDay, $openings);
             $count++;
-        } while (!$isClosingDay && $count <= 7);
+        } while (!$testDay && $count <= 8);
 
-        if ($isClosingDay) {
+        if ($testDay) {
             return $this->getOpeningByWeekday($weekDay, $openings);
         }
 
         return null;
     }
 
-    public function isOpeningDay(int $weekDay, array $openings): bool
+    protected function isOpeningDay(int $weekDay, array $openings): bool
     {
-        return $this->isOpeningOrClosingDay($weekDay, $openings, 'opening');
+        return (bool) $this->getOpeningByWeekday($weekDay, $openings);
     }
 
-    public function isClosingDay(int $weekDay, array $openings): bool
+    protected function isClosingDay(int $weekDay, array $openings): bool
     {
-        return $this->isOpeningOrClosingDay($weekDay, $openings, 'closing');
-    }
-
-    protected function isOpeningOrClosingDay(int $weekDay, array $openings, string $testOpeningOrClosing = 'opening')
-    {
-        if ($testOpeningOrClosing == 'opening') {
-            $methodGetTime = 'getTimeStart';
-        } else {
-            $methodGetTime = 'getTimeEnd';
-        }
-
         $openingDay = $this->getOpeningByWeekday($weekDay, $openings);
-        if ($openingDay && $openingDay->$methodGetTime()) {
+
+        if ($openingDay && $openingDay->getTimeEnd()) {
             return true;
         }
 

Twig/StoreTwigExtension.php

                 new TwigFunction('merchant_setting_current', [$this, 'getMerchantSettingCurrent']),
                 new TwigFunction('section_setting', [$this, 'getSectionSetting']),
                 new TwigFunction('section_setting_current', [$this, 'getSectionSettingCurrent']),
+                new TwigFunction('visitor_current', [$this, 'getVisitorCurrent']),
         );
     }
 
         return $this->orderShopBuilder->createIfNotExist(
                 $this->sectionResolver->getCurrent(),
                 $this->security->getUser(),
-                $this->visitorResolver->getCurrent()
+                $this->visitorResolver->getCurrent(),
+                true
         );
     }
 
         //TODO mettre à jour une fois les repo fait
         return array();
     }
+
+    public function getVisitorCurrent()
+    {
+        return $this->visitorResolver->getCurrent();
+    }
 }