Refactoring frontend

Container/Address/AddressContainer.php

 use Lc\CaracoleBundle\Factory\Address\AddressFactory;
 use Lc\CaracoleBundle\Repository\Address\AddressRepositoryQuery;
 use Lc\CaracoleBundle\Repository\Address\AddressStore;
+use Lc\CaracoleBundle\Solver\Address\AddressSolver;
 
 class AddressContainer
 {
     protected AddressFactory $factory;
+    protected AddressSolver $solver;
     protected AddressRepositoryQuery $repositoryQuery;
     protected AddressStore $store;
     protected AddressBuilder $builder;
 
     public function __construct(
             AddressFactory $factory,
+            AddressSolver $solver,
             AddressRepositoryQuery $repositoryQuery,
             AddressStore $store,
             AddressBuilder $builder
     ) {
         $this->factory = $factory;
+        $this->solver = $solver;
         $this->repositoryQuery = $repositoryQuery;
         $this->store = $store;
         $this->builder = $builder;
         return $this->factory;
     }
 
+    public function getSolver(): AddressSolver
+    {
+        return $this->solver;
+    }
+
     public function getRepositoryQuery(): AddressRepositoryQuery
     {
         return $this->repositoryQuery;

Container/Product/ProductFamilyContainer.php

 use Lc\CaracoleBundle\Factory\Product\ProductFamilyFactory;
 use Lc\CaracoleBundle\Repository\Product\ProductFamilyRepositoryQuery;
 use Lc\CaracoleBundle\Repository\Product\ProductFamilyStore;
+use Lc\CaracoleBundle\Solver\Product\ProductFamilySolver;
 
 class ProductFamilyContainer
 {
     protected ProductFamilyFactory $factory;
+    protected ProductFamilySolver $solver;
     protected ProductFamilyRepositoryQuery $repositoryQuery;
     protected ProductFamilyStore $store;
 
     public function __construct(
             ProductFamilyFactory $factory,
+            ProductFamilySolver $solver,
             ProductFamilyRepositoryQuery $repositoryQuery,
             ProductFamilyStore $store
     ) {
         $this->factory = $factory;
+        $this->solver = $solver;
         $this->repositoryQuery = $repositoryQuery;
         $this->store = $store;
     }
         return $this->factory;
     }
 
+    public function getSolver(): ProductFamilySolver
+    {
+        return $this->solver;
+    }
+
     public function getRepositoryQuery(): ProductFamilyRepositoryQuery
     {
         return $this->repositoryQuery;

Container/User/VisitorContainer.php

 
 namespace Lc\CaracoleBundle\Container\User;
 
+use Lc\CaracoleBundle\Builder\User\VisitorBuilder;
 use Lc\CaracoleBundle\Factory\User\VisitorFactory;
 use Lc\CaracoleBundle\Repository\User\VisitorRepositoryQuery;
 use Lc\CaracoleBundle\Repository\User\VisitorStore;
+use Lc\CaracoleBundle\Resolver\VisitorResolver;
+use Lc\CaracoleBundle\Solver\User\VisitorSolver;
 
 class VisitorContainer
 {
     protected VisitorFactory $factory;
+    protected VisitorSolver $solver;
     protected VisitorRepositoryQuery $repositoryQuery;
     protected VisitorStore $store;
+    protected VisitorResolver $resolver;
+    protected VisitorBuilder $visitorBuilder;
 
     public function __construct(
             VisitorFactory $factory,
+            VisitorSolver $solver,
             VisitorRepositoryQuery $repositoryQuery,
-            VisitorStore $store
+            VisitorStore $store,
+            VisitorResolver $resolver,
+            VisitorBuilder $builder
     ) {
         $this->factory = $factory;
+        $this->solver = $solver;
         $this->repositoryQuery = $repositoryQuery;
         $this->store = $store;
+        $this->resolver = $resolver;
+        $this->builder = $builder;
     }
 
     public function getFactory(): VisitorFactory
         return $this->factory;
     }
 
+    public function getSolver(): VisitorSolver
+    {
+        return $this->solver;
+    }
+
     public function getRepositoryQuery(): VisitorRepositoryQuery
     {
         return $this->repositoryQuery;
         return $this->store;
     }
 
+    public function getResolver(): VisitorResolver
+    {
+        return $this->resolver;
+    }
+
+    public function getBuilder(): VisitorBuilder
+    {
+        return $this->builder;
+    }
+
 }

Model/User/UserModel.php

 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Gedmo\Mapping\Annotation as Gedmo;
 use Lc\CaracoleBundle\Model\Address\AddressInterface;
-use Lc\CaracoleBundle\Model\PointSale\PointSaleInterface;
 use Lc\SovBundle\Model\Newsletter\NewsletterInterface;
 use Lc\CaracoleBundle\Model\Order\OrderShopInterface;
 use Lc\CaracoleBundle\Model\Product\ProductFamilyInterface;
 use Lc\CaracoleBundle\Model\Reduction\ReductionCreditInterface;
 use Lc\SovBundle\Model\User\UserModel as SovUserModel;
 use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
-use Lc\SovBundle\Model\Ticket\TicketInterface;
 
 /**
  * @ORM\MappedSuperclass()

Model/User/VisitorModel.php

 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
 use Lc\CaracoleBundle\Model\Order\OrderShopInterface;
+use Lc\SovBundle\Doctrine\EntityInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class VisitorModel
+abstract class VisitorModel implements EntityInterface
 {
     /**
      * @ORM\Column(type="string", length=255)

Repository/Product/ProductFamilyStore.php

         $query = $this->createDefaultQuery($query);
 
         $query
-                ->filterPropertyOrganicLabel()
+                ->filterIsOrganicLabel()
                 ->filterIsOnline();
 
         $results = $query->find();
     public function getFavorite($user = null, $organizeByParentCategory = true, $query = null)
     {
         if ($user) {
-            return $this->getWithReductions($user->getProductFamiliesFavorites(), $user, false, $organizeByParentCategory);
+            return $this->getWithReductions($user->getFavoriteProductFamilies(), $user, false, $organizeByParentCategory);
         }
 
         return [];
 
     // setReductionForProductFamilies
     public function getWithReductions(
-            array $productFamilies,
+            $productFamilies,
             UserInterface $user = null,
             $organizeByCategory = false,
             $organizeByParentCategory = false,
         }
 
         if ($productFamilies) {
-            $reductionCatalogs = $this->reductionCatalogStore->getByProductFamilies(
+            $reductionCatalogs = $this->reductionCatalogStore->getByProductFamiliesConditions(
                     $conditions,
                     $user
             );

Repository/Reduction/ReductionCatalogRepositoryQuery.php

 
 class ReductionCatalogRepositoryQuery extends AbstractRepositoryQuery
 {
-    protected bool $isJoinProductFamilies;
-    protected bool $isJoinProductFamily;
-    protected bool $isJoinProductCategories;
+    protected bool $isJoinProductFamilies = false;
+    protected bool $isJoinProductFamily = false;
+    protected bool $isJoinProductCategories = false;
     use SectionRepositoryQueryTrait;
 
     public function __construct(ReductionCatalogRepository $repository, PaginatorInterface $paginator)
     public function filterConditionDate()
     {
         return $this
-                ->andWhere('e.permanent = 1 OR (e.dateStart <= :now AND e.dateEnd >= :now)')
+                ->andWhere('.permanent = 1 OR ( .dateStart <= :now AND .dateEnd >= :now)')
                 ->setParameter(':now', new \DateTime());
     }
 
     {
         if ($user) {
             return $this
-                    ->andWhere(':user MEMBER OF e.users OR e.users is empty')
+                    ->andWhere(':user MEMBER OF .users OR .users is empty')
                     ->setParameter('user', $user);
         } else {
             return $this
-                    ->andWhere('e.users is empty');
+                    ->andWhere('.users is empty');
         }
     }
 
     {
         if ($user) {
             return $this
-                    ->andWhere(':groupUser MEMBER OF e.groupUsers OR e.groupUsers is empty')
+                    ->andWhere(':groupUser MEMBER OF .groupUsers OR .groupUsers is empty')
                     ->setParameter('groupUser', $user->getGroupUsers());
         } else {
             return $this
-                    ->andWhere('e.groupUsers is empty');
+                    ->andWhere('.groupUsers is empty');
         }
     }
 
         $this->joinProductFamilies();
         $this->joinProductFamily();
         return $this
-                ->andWhere(':productFamilies MEMBER OF e.productFamilies OR e.productFamilies is empty')
+                ->andWhere(':productFamilies MEMBER OF .productFamilies OR .productFamilies is empty')
                 ->setParameter('productFamilies', $productFamilies);
     }
 
         $this->joinProductFamilies();
         $this->joinProductFamily();
         return $this
-                ->andWhere(':productFamily MEMBER OF e.productFamilies OR e.productFamilies is empty')
+                ->andWhere(':productFamily MEMBER OF .productFamilies OR .productFamilies is empty')
                 ->setParameter('productFamily', $productFamily);
     }
 
     {
         $this->joinProductCategories();
         return $this
-                ->andWhere(':productCategory MEMBER OF e.productCategories OR e.productCategories is empty')
+                ->andWhere(':productCategory MEMBER OF .productCategories OR .productCategories is empty')
                 ->setParameter('productCategory', $productCategories);
     }
 

Repository/User/VisitorRepositoryQuery.php

         parent::__construct($repository, 'r', $paginator);
     }
 
-    public function filterByCookie(string $cookie)
+    public function filterByCookie(string $cookie = null)
     {
         return $this
                 ->andWhere('.cookie LIKE :cookie')

Repository/User/VisitorStore.php

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

Resolver/MerchantResolver.php

 
     public function getMerchantUser(UserInterface $user = null)
     {
+        if(is_null($user)) {
+            $user = $this->security->getUser();
+        }
+
         $merchants = $this->merchantStore->getOnline();
 
         if ($user) {
-            return $user->getMerchant();
+            return $user->getFavoriteMerchant();
         } else {
             $merchantCurrentId = $this->requestStack->getCurrentRequest()->cookies->getInt(
                     $this->parameterBag->get('app.cookie_name_merchant_current')

Resolver/OpeningResolver.php

         $this->messages[] = $message;
     }
 
-    public function isOpenSaleOnlyComplementaryOrders(Section $section, UserInterface $user)
+    public function isOpenSaleOnlyComplementaryOrders(Section $section = null, UserInterface $user = null)
     {
+        if(is_null($section)) {
+            $section = $this->sectionResolver->getCurrent();
+        }
+
+        if(is_null($user)) {
+            $user = $this->security->getUser();
+        }
+
         // @TODO : ajouter une option dans les sections (permettre les commandes complémentaires ou non)
         $orderShopsUser = $this->orderShopStore->setSection($section)->getByCurrentCycleAndUser($user);
 

Resources/views/adminlte/layout.html.twig

 {% block navbar_header %}
     {{ parent() }}
 
-    {% set section_current = section_resolver.getCurrent() %}
+    {% set section_current = section_current() %}
     {% set is_display_switch_section = display_switch_section is defined and display_switch_section %}
 
     <nav class="carac navbar navbar-expand navbar-light main-header{% if is_display_switch_section %} display-section-switch{% endif %}" {% if is_display_switch_section %}style="border-color: {{ section_current.color }};"{% endif %}>
 {% block append_body %}
     {# modal switch merchant #}
     {% set user = app.user %}
-    {% set merchant_current = merchant_resolver.getCurrent() %}
+    {% set merchant_current = merchant_current() %}
 
     {% if(user.favoriteMerchant != merchant_current) %}
         {# modal affichée uniquement si la sessionStorage.visit_merchant n'est pas défini (js) #}

Solver/Order/OrderShopSolver.php

     }
 
     // isProductAvailable
-    public function isAvailable(ProductInterface $product, $quantityOrder = 0, $checkCart = false, $orderShop = null)
+    public function isProductAvailable(ProductInterface $product, $quantityOrder = 0, $checkCart = false, $orderShop = null)
     {
         if ($product->getStatus() != 1 || $product->getProductFamily()->getStatus() != 1 || !$this->productSolver->isProductSaleStatusOn($product)) {
             return false;
     public function isOneProductAvailableAddCart(OrderShopInterface $orderShop, $products): bool
     {
         foreach ($products as $product) {
-            if ($this->isAvailable($product, 1, true, $orderShop)) {
+            if ($this->isProductAvailable($product, 1, true, $orderShop)) {
                 return true;
             }
         }

Solver/User/VisitorSolver.php

+<?php
+
+namespace Lc\CaracoleBundle\Solver\User;
+
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
+
+class VisitorSolver
+{
+    protected ParameterBagInterface $parameterBag;
+
+    public function __construct(ParameterBagInterface $parameterBag)
+    {
+        $this->parameterBag = $parameterBag;
+    }
+
+    // getCookieNameVisitor
+    public function getCookieName()
+    {
+        return $this->parameterBag->get('app.cookie_name_visitor');
+    }
+}

Twig/StoreTwigExtension.php

 
 namespace Lc\CaracoleBundle\Twig;
 
+use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
+use Lc\CaracoleBundle\Model\Order\OrderShopInterface;
+use Lc\CaracoleBundle\Model\Section\SectionInterface;
+use Lc\CaracoleBundle\Model\User\UserMerchantInterface;
 use Lc\CaracoleBundle\Repository\Config\TaxRateStore;
 use Lc\CaracoleBundle\Repository\Config\UnitStore;
 use Lc\CaracoleBundle\Repository\Merchant\MerchantRepositoryQuery;
 use Lc\CaracoleBundle\Resolver\MerchantResolver;
 use Lc\CaracoleBundle\Resolver\SectionResolver;
 use Lc\ShopBundle\Context\UnitInterface;
+use Lc\SovBundle\Solver\Setting\SettingSolver;
 use Twig\Extension\AbstractExtension;
 use Twig\TwigFunction;
 
     protected TaxRateStore $taxRateStore;
     protected ProductCategoryStore $productCategoryStore;
     protected OrderShopStore $orderShopStore;
+    protected SettingSolver $settingSolver;
 
     public function __construct(
             MerchantResolver $merchantResolver,
             UnitStore $unitStore,
             TaxRateStore $taxRateStore,
             ProductCategoryStore $productCategoryStore,
-            OrderShopStore $orderShopStore
+            OrderShopStore $orderShopStore,
+            SettingSolver $settingSolver
     ) {
         $this->merchantResolver = $merchantResolver;
         $this->sectionResolver = $sectionResolver;
         $this->taxRateStore = $taxRateStore;
         $this->productCategoryStore = $productCategoryStore;
         $this->orderShopStore = $orderShopStore;
+        $this->settingSolver = $settingSolver;
     }
 
     public function getFunctions()
                 new TwigFunction('carac_tax_rates', [$this, 'getTaxRates']),
                 new TwigFunction('carac_reduction_cart_codes', [$this, 'getTaxRates']),
                 new TwigFunction('carac_product_categories', [$this, 'getProductCategories']),
-        );
-    }
 
-    public function getProductCategories()
-    {
-        return $this->productCategoryStore
-                ->setSection($this->sectionResolver->getCurrent())
-                ->getParent(false);
+
+                new TwigFunction('cart_current', [$this, 'getCartCurrent']),
+                new TwigFunction('merchant_current', [$this, 'getMerchantCurrent']),
+                new TwigFunction('user_merchant_current', [$this, 'getUserMerchantCurrent']),
+                new TwigFunction('section_current', [$this, 'getSectionCurrent']),
+                new TwigFunction('merchant_setting', [$this, 'getMerchantSetting']),
+                new TwigFunction('merchant_setting_current', [$this, 'getMerchantSettingCurrent']),
+                new TwigFunction('section_setting', [$this, 'getSectionSetting']),
+                new TwigFunction('section_setting_current', [$this, 'getSectionSettingCurrent']),
+        );
     }
 
     public function getSections()
                 ->getOnline();
     }
 
-    public function getSectionCurrent()
+    public function getMerchants()
+    {
+        return $this->merchantStore->getOnline();
+    }
+
+    public function getSectionCurrent(): SectionInterface
     {
         return $this->sectionResolver->getCurrent();
     }
 
-    public function getCartCurrent()
+    public function getCartCurrent(): OrderShopInterface
     {
         return $this->orderShopStore
                 ->setSection($this->sectionResolver->getCurrent())
                 ->getOneCartCurrent();
     }
 
-    public function getMerchants()
+    public function getMerchantCurrent(): MerchantInterface
     {
-        return $this->merchantStore->getOnline();
+        return $this->merchantResolver->getCurrent();
+    }
+
+    public function getUserMerchantCurrent(): UserMerchantInterface
+    {
+        $this->merchantResolver->getUserMerchant();
+    }
+
+    public function getMerchantSetting(MerchantInterface $merchant, string $settingName): string
+    {
+        return $this->settingSolver->getSettingValue($merchant, $settingName);
+    }
+
+    public function getMerchantSettingCurrent(string $settingName): string
+    {
+        return $this->settingSolver->getSettingValue($this->getMerchantCurrent(), $settingName);
+    }
+
+    public function getSectionSetting(SectionInterface $section, string $settingName): string
+    {
+        return $this->settingSolver->getSettingValue($section, $settingName);
+    }
+
+    public function getSectionSettingCurrent(string $settingName): string
+    {
+        return $this->settingSolver->getSettingValue($this->getSectionCurrent(), $settingName);
+    }
+
+    public function getProductCategories()
+    {
+        return $this->productCategoryStore
+                ->setSection($this->sectionResolver->getCurrent())
+                ->getParent(false);
     }
 
     public function getReminders($params = [])
         //TODO mettre à jour une fois les repo fait
         return array();
     }
-
-
 }