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

Controller/Credit/CreditHistoryAdminController.php

 abstract class CreditHistoryAdminController extends AbstractAdminController
 {
     use AdminControllerTrait;
-
-    protected $em;
-    protected $translatorAdmin;
-
-    public function __construct(EntityManagerInterface $entityManager, TranslatorAdmin $translatorAdmin)
-    {
-        $this->em = $entityManager;
-        $this->translatorAdmin = $translatorAdmin;
-    }
-
+    
     public function overrideGlobalActions(?ActionCollection $actions): void
     {
         parent::overrideGlobalActions($actions);
 
     public function configureFields(string $pageName): iterable
     {
+        $translatorAdmin = $this->get('translator_admin');
         return [
                 IdField::new('id')->hideOnForm(),
                 ChoiceField::new('type')->setChoices(
                         array(
-                                $this->translatorAdmin->transField(
+                                $translatorAdmin->transField(
                                         'typeOptions.'.CreditHistoryModel::TYPE_CREDIT,
                                         'CreditHistory'
                                 ) => CreditHistoryModel::TYPE_CREDIT,
 
-                                $this->translatorAdmin->transField(
+                                $translatorAdmin->transField(
                                         'typeOptions.'.CreditHistoryModel::TYPE_DEBIT,
                                         'CreditHistory'
                                 ) => CreditHistoryModel::TYPE_DEBIT,
                 DateField::new('paidAt'),
                 ChoiceField::new('meanPayment')->setChoices(
                         array(
-                                $this->translatorAdmin->transField(
+                                $translatorAdmin->transField(
                                         'meanPaymentOptions.'.CreditHistoryModel::MEAN_PAYMENT_CASH,
                                         'CreditHistory'
                                 ) => CreditHistoryModel::MEAN_PAYMENT_CASH,
 
-                                $this->translatorAdmin->transField(
+                                $translatorAdmin->transField(
                                         'meanPaymentOptions.'.CreditHistoryModel::MEAN_PAYMENT_CHEQUE,
                                         'CreditHistory'
                                 ) => CreditHistoryModel::MEAN_PAYMENT_CHEQUE,
 
-                                $this->translatorAdmin->transField(
+                                $translatorAdmin->transField(
                                         'meanPaymentOptions.'.CreditHistoryModel::MEAN_PAYMENT_CREDIT,
                                         'CreditHistory'
                                 ) => CreditHistoryModel::MEAN_PAYMENT_CREDIT,
 
-                                $this->translatorAdmin->transField(
+                                $translatorAdmin->transField(
                                         'meanPaymentOptions.'.CreditHistoryModel::MEAN_PAYMENT_CREDIT_CARD,
                                         'CreditHistory'
                                 ) => CreditHistoryModel::MEAN_PAYMENT_CREDIT_CARD,
 
-                                $this->translatorAdmin->transField(
+                                $translatorAdmin->transField(
                                         'meanPaymentOptions.'.CreditHistoryModel::MEAN_PAYMENT_TRANSFER,
                                         'CreditHistory'
                                 ) => CreditHistoryModel::MEAN_PAYMENT_TRANSFER,

Controller/Product/ProductCategoryAdminController.php

+<?php
+
+namespace Lc\CaracoleBundle\Controller\Product;
+
+use EasyCorp\Bundle\EasyAdminBundle\Field\AssociationField;
+use EasyCorp\Bundle\EasyAdminBundle\Field\FormField;
+use EasyCorp\Bundle\EasyAdminBundle\Field\NumberField;
+use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
+use Lc\CaracoleBundle\Controller\AdminControllerTrait;
+use Lc\CaracoleBundle\Field\Address\AddressField;
+use Lc\SovBundle\Controller\AbstractAdminController;
+use Lc\SovBundle\Field\BooleanField;
+use Lc\SovBundle\Field\CKEditorField;
+use Lc\SovBundle\Field\StatusField;
+
+abstract class ProductCategoryAdminController extends AbstractAdminController
+{
+    use AdminControllerTrait;
+
+    public function configureFields(string $pageName): iterable
+    {
+        return array_merge(
+                [
+                        FormField::addPanel('general'),
+                        TextField::new('title'),
+                        AssociationField::new('parent'),
+                        CKEditorField::new('description'),
+                        BooleanField::new('saleStatus'),
+                        StatusField::new('status'),
+
+                ],
+                $this->getSeoPanel(),
+                $this->getConfPanel()
+        );
+    }
+
+}

Controller/Product/ProductFamilyAdminController.php

+<?php
+
+namespace Lc\CaracoleBundle\Controller\Product;
+
+use EasyCorp\Bundle\EasyAdminBundle\Field\AssociationField;
+use EasyCorp\Bundle\EasyAdminBundle\Field\FormField;
+use EasyCorp\Bundle\EasyAdminBundle\Field\NumberField;
+use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
+use Lc\CaracoleBundle\Controller\AdminControllerTrait;
+use Lc\CaracoleBundle\Field\Address\AddressField;
+use Lc\SovBundle\Controller\AbstractAdminController;
+use Lc\SovBundle\Field\BooleanField;
+use Lc\SovBundle\Field\CKEditorField;
+use Lc\SovBundle\Field\StatusField;
+
+abstract class ProductFamilyAdminController extends AbstractAdminController
+{
+    use AdminControllerTrait;
+
+
+}

Controller/Site/PageAdminController.php

     public function createEntity(string $entityFqcn)
     {
         $factory = new PageFactory();
-        $currentMerchant = $this->get('merchant_resolver')->getCurrent();
         $currentSection = $this->get('section_resolver')->getCurrent();
-        $factory->setMerchant($currentMerchant);
         $factory->setSection($currentSection);
         return $factory->create();
     }

Controller/Ticket/TicketAdminController.php

 
 namespace Lc\CaracoleBundle\Controller\Ticket;
 
-use EasyCorp\Bundle\EasyAdminBundle\Config\KeyValueStore;
 use Lc\CaracoleBundle\Controller\AdminControllerTrait;
 use Lc\SovBundle\Controller\Ticket\TicketAdminController as SovTicketAdminController;
+use Lc\CaracoleBundle\Factory\Ticket\TicketFactory;
 
 class TicketAdminController extends SovTicketAdminController
 {
     use AdminControllerTrait;
 
-    public function createEntityFromFactory()
+    public function createEntity(string $entityFqcn)
     {
-        return $this->ticketFactory
-                ->setMerchant($this->get('merchant_resolver')->getCurrent())
-                ->create();
+        $merchantResolver = $this->get('merchant_resolver');
+        $factory = new TicketFactory();
+        $factory->setMerchant($merchantResolver->getCurrent());
+        return $factory->create();
     }
+
 }

Controller/User/UserMerchantAdminController.php

 use Lc\CaracoleBundle\Form\User\UserMerchantFormType;
 use Lc\CaracoleBundle\Model\Credit\CreditHistoryInterface;
 use Lc\SovBundle\Controller\AbstractAdminController;
+use Lc\SovBundle\Field\BooleanField;
 use Lc\SovBundle\Field\ToggleField;
 use Lc\SovBundle\Model\User\UserInterface;
 use Lc\SovBundle\Translation\TranslatorAdmin;

Doctrine/Extension/ReductionTrait.php

 trait ReductionTrait
 {
 
-        /**
-         * @ORM\Column(type="float", nullable=true)
-         */
-        protected $value;
 
-        /**
-         * @ORM\Column(type="string", length=20, nullable=true)
-         */
-        protected $unit;
 
-        /**
-         * @ORM\Column(type="string", length=20, nullable=true)
-         */
-        protected $behaviorTaxRate;
+    /**
+     * @ORM\Column(type="float", nullable=true)
+     */
+    protected $value;
 
+    /**
+     * @ORM\Column(type="string", length=20, nullable=true)
+     */
+    protected $unit;
 
-        public function getValue(): ?float
-        {
-                return $this->value;
-        }
+    /**
+     * @ORM\Column(type="string", length=20, nullable=true)
+     */
+    protected $behaviorTaxRate;
 
-        public function setValue(?float $value): self
-        {
-                $this->value = $value;
 
-                return $this;
-        }
+    public function getValue(): ?float
+    {
+        return $this->value;
+    }
 
-        public function getUnit(): ?string
-        {
-                return $this->unit;
-        }
+    public function setValue(?float $value): self
+    {
+        $this->value = $value;
 
-        public function setUnit(?string $unit): self
-        {
-                $this->unit = $unit;
+        return $this;
+    }
 
-                return $this;
-        }
+    public function getUnit(): ?string
+    {
+        return $this->unit;
+    }
 
-        public function getBehaviorTaxRate(): ?string
-        {
-                return $this->behaviorTaxRate;
-        }
+    public function setUnit(?string $unit): self
+    {
+        $this->unit = $unit;
 
-        public function setBehaviorTaxRate(?string $behaviorTaxRate): self
-        {
-                $this->behaviorTaxRate = $behaviorTaxRate;
+        return $this;
+    }
 
-                return $this;
-        }
+    public function getBehaviorTaxRate(): ?string
+    {
+        return $this->behaviorTaxRate;
+    }
+
+    public function setBehaviorTaxRate(?string $behaviorTaxRate): self
+    {
+        $this->behaviorTaxRate = $behaviorTaxRate;
+
+        return $this;
+    }
 }

Factory/Product/ProductFamilyFactory.php

 namespace Lc\CaracoleBundle\Factory\Product;
 
 use App\Entity\Product\ProductFamily;
+use Lc\CaracoleBundle\Factory\SectionFactoryTrait;
 use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\CaracoleBundle\Model\Product\ProductFamilyInterface;
 use Lc\CaracoleBundle\Model\Section\SectionInterface;
 class ProductFamilyFactory extends AbstractFactory
 {
 
-    public function create(MerchantInterface $merchant, SectionInterface $section): ProductFamilyInterface
+    use SectionFactoryTrait;
+
+    public function create(SectionInterface $section = null): ProductFamilyInterface
     {
         $productFamily = new ProductFamily();
 
-        $productFamily->setMerchant($merchant);
-        $productFamily->setSection($section);
+        if(is_null($section)) {
+            $productFamily->setSection($this->section);
+        }else{
+            $productFamily->setSection($section);
+        }
 
         return $productFamily;
     }

Factory/Site/PageFactory.php

 
 class PageFactory extends SovPageFactory
 {
-    use MerchantFactoryTrait;
     use SectionFactoryTrait;
 
     public function create(): PageInterface
     {
         $page = parent::create();
 
-        $page->setMerchant($this->merchant);
         $page->setSection($this->section);
 
         return $page;

Model/Config/TaxRateModel.php

 abstract class TaxRateModel extends AbstractLightEntity
 {
 
+    const BEHAVIOR_TAX_RATE_INCLUDED = 'tax-included';
+    const BEHAVIOR_TAX_RATE_EXCLUDED = 'tax-excluded';
+
+    public function getBehaviorTaxRateChoices(): array
+    {
+        return [
+                self::BEHAVIOR_TAX_RATE_EXCLUDED,
+                self::BEHAVIOR_TAX_RATE_INCLUDED,
+        ];
+    }
+
+
     /**
      * @ORM\Column(type="string", length=255)
      */

Model/Config/UnitModel.php

  */
 abstract class UnitModel extends AbstractLightEntity
 {
+
+    const UNIT_PERCENT = 'percent';
+    const UNIT_AMOUNT = 'amount';
+
+
+    public function getUnitAmountChoices(): array
+    {
+        return [
+                self::UNIT_PERCENT,
+                self::UNIT_AMOUNT,
+        ];
+    }
+
     /**
      * @ORM\Column(type="string", length=32)
      */

Model/Newsletter/NewsletterModel.php

 /**
  * @ORM\MappedSuperclass()
  */
-abstract class NewsletterModel extends SovNewsletterModel implements FilterMerchantInterface, FilterSectionInterface
+abstract class NewsletterModel extends SovNewsletterModel implements FilterSectionInterface
 {
-    /**
-     * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", inversedBy="newsletters")
-     */
-    protected $merchant;
-
     /**
      * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Section\SectionInterface", inversedBy="newsletters")
      */
     protected $section;
 
-    public function getMerchant(): ?MerchantInterface
-    {
-        return $this->merchant;
-    }
-
-    public function setMerchant(?MerchantInterface $merchant): self
-    {
-        $this->merchant = $merchant;
-
-        return $this;
-    }
 
     public function getSection(): ?SectionInterface
     {

Model/Order/OrderShopModel.php

 use Doctrine\Common\Collections\Collection;
 use Gedmo\Mapping\Annotation as Gedmo;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterSectionInterface;
 use Lc\CaracoleBundle\Model\Address\AddressInterface;
 use Lc\CaracoleBundle\Model\Credit\CreditHistoryInterface;
 use Lc\CaracoleBundle\Model\File\DocumentInterface;
 use Lc\CaracoleBundle\Model\File\DocumentModel;
-use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\CaracoleBundle\Model\Section\SectionInterface;
 use Lc\SovBundle\Model\Ticket\TicketInterface;
 use Lc\CaracoleBundle\Model\User\VisitorInterface;
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class OrderShopModel extends AbstractLightEntity implements FilterMerchantInterface
+abstract class OrderShopModel extends AbstractLightEntity implements FilterSectionInterface
 {
-    /**
-     * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", inversedBy="productFamilies")
-     * @ORM\JoinColumn(nullable=false)
-     */
-    protected $merchant;
-
     /**
      * @ORM\ManyToOne(targetEntity="Lc\SovBundle\Model\User\UserInterface", inversedBy="orders", fetch="EAGER")
      */
         return null;
     }
 
-    public function getMerchant(): ?MerchantInterface
-    {
-        return $this->merchant;
-    }
-
-    public function setMerchant(?MerchantInterface $merchant): self
-    {
-        $this->merchant = $merchant;
-
-        return $this;
-    }
-
     public function getUser(): ?UserInterface
     {
         return $this->user;

Model/Product/ProductCategoryModel.php

 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
-use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterSectionInterface;
 use Lc\CaracoleBundle\Model\Section\SectionInterface;
 use Lc\SovBundle\Doctrine\Extension\TreeInterface;
 use Lc\SovBundle\Doctrine\Pattern\AbstractFullEntity;
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class ProductCategoryModel extends AbstractFullEntity implements TreeInterface, FilterMerchantInterface
+abstract class ProductCategoryModel extends AbstractFullEntity implements TreeInterface, FilterSectionInterface
 {
 
     /**
-     * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", inversedBy="productCategories")
+     * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Section\SectionInterface")
      * @ORM\JoinColumn(nullable=false)
      */
-    protected $merchant;
+    protected $section;
 
     /**
      * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Product\ProductCategoryInterface", inversedBy="childrens")
     protected $saleStatus;
 
 
-    /**
-     * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Section\SectionInterface", inversedBy="productCategories")
-     * @ORM\JoinColumn(nullable=false)
-     */
-    protected $section;
-
     public function __construct()
     {
         $this->childrens = new ArrayCollection();
         return $title;
     }
 
+    public function getSection(): SectionInterface
+    {
+        return $this->section;
+    }
+
+    public function setSection(SectionInterface $section): self
+    {
+        $this->section = $section;
+
+        return $this;
+    }
+
+
     public function getParent(): ?self
     {
         return $this->parent;
         return $count;
     }
 
-    public function getMerchant(): ?MerchantInterface
-    {
-        return $this->merchant;
-    }
-
-    public function setMerchant(?MerchantInterface $merchant): self
-    {
-        $this->merchant = $merchant;
-
-        return $this;
-    }
-
     public function getSaleStatus(): ?bool
     {
         return $this->saleStatus;
         return $this;
     }
 
-    public function getSection(): ?SectionInterface
-    {
-        return $this->section;
-    }
-
-    public function setSection(?SectionInterface $section): self
-    {
-        $this->section = $section;
-
-        return $this;
-    }
-
 }

Model/Product/ProductFamilyModel.php

 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterSectionInterface;
 use Lc\CaracoleBundle\Doctrine\Extension\PriceInterface;
 use Lc\CaracoleBundle\Doctrine\Extension\ProductPropertyTrait;
 use Lc\CaracoleBundle\Doctrine\Extension\ProductPropertyInterface;
 use Gedmo\Mapping\Annotation as Gedmo;
-use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\CaracoleBundle\Model\Reduction\ReductionCatalogInterface;
 use Lc\CaracoleBundle\Model\Section\SectionInterface;
 use Lc\SovBundle\Doctrine\Pattern\AbstractFullEntity;
  * @ORM\MappedSuperclass()
  */
 abstract class ProductFamilyModel extends AbstractFullEntity implements ProductPropertyInterface, PriceInterface,
-                                                                        FilterMerchantInterface
+                                                                        FilterSectionInterface
 {
 
     use ProductPropertyTrait;
     const BEHAVIOR_COUNT_STOCK_BY_PRODUCT_FAMILY = 'by-product-family';
     const BEHAVIOR_COUNT_STOCK_BY_PRODUCT = 'by-product';
 
+    public function getBehaviorCountStockChoices(): array
+    {
+        return [
+                self::BEHAVIOR_COUNT_STOCK_BY_MEASURE,
+                self::BEHAVIOR_COUNT_STOCK_BY_PRODUCT,
+                self::BEHAVIOR_COUNT_STOCK_BY_PRODUCT_FAMILY,
+                self::BEHAVIOR_COUNT_STOCK_UNLIMITED,
+        ];
+    }
+
+
+
     const BEHAVIOR_DISPLAY_SALE_BY_MEASURE = 'by-measure';
     const BEHAVIOR_DISPLAY_SALE_BY_QUANTITY = 'by-quantity';
 
+    public function getBehaviorDisplaySaleChoices(): array
+    {
+        return [
+                self::BEHAVIOR_DISPLAY_SALE_BY_MEASURE,
+                self::BEHAVIOR_DISPLAY_SALE_BY_QUANTITY,
+        ];
+    }
+
+
     const BEHAVIOR_STOCK_WEEK_RENEWABLE = 'renewable';
     const BEHAVIOR_STOCK_WEEK_RENEWABLE_VALIDATION = 'renewable-with-validation';
     const BEHAVIOR_STOCK_WEEK_NON_RENEWABLE = 'non-renewable';
 
+    public function getBehaviorStockWeekChoices(): array
+    {
+        return [
+                self::BEHAVIOR_STOCK_WEEK_NON_RENEWABLE,
+                self::BEHAVIOR_STOCK_WEEK_RENEWABLE,
+                self::BEHAVIOR_STOCK_WEEK_RENEWABLE_VALIDATION,
+        ];
+    }
+
+
     const WARNING_MESSAGE_TYPE_SUCCESS = 'success';
     const WARNING_MESSAGE_TYPE_ERROR = 'error';
     const WARNING_MESSAGE_TYPE_WARNING = 'warning';
     const WARNING_MESSAGE_TYPE_INFO = 'info';
 
+    public function getWaringMessageTypeChoices(): array
+    {
+        return [
+                self::WARNING_MESSAGE_TYPE_ERROR,
+                self::WARNING_MESSAGE_TYPE_INFO,
+                self::WARNING_MESSAGE_TYPE_SUCCESS,
+                self::WARNING_MESSAGE_TYPE_WARNING,
+        ];
+    }
     const BEHAVIOR_ADD_TO_CART_SIMPLE = 'simple';
     const BEHAVIOR_ADD_TO_CART_MULTIPLE = 'multiple';
 
+    public function getBehaviorAddToCartChoices(): array
+    {
+        return [
+                self::BEHAVIOR_ADD_TO_CART_MULTIPLE,
+                self::BEHAVIOR_ADD_TO_CART_SIMPLE,
+        ];
+    }
     const BEHAVIOR_PRICE_BY_PIECE = 'by-piece';
     const BEHAVIOR_PRICE_BY_REFERENCE_UNIT = 'by-reference-unit';
 
+    public function getBehaviorPriceChoices(): array
+    {
+        return [
+                self::BEHAVIOR_PRICE_BY_PIECE,
+                self::BEHAVIOR_PRICE_BY_REFERENCE_UNIT,
+        ];
+    }
     const PROPERTY_ORGANIC_LABEL_AB = 'ab';
     const PROPERTY_ORGANIC_LABEL_NP = 'nature-progres';
     const PROPERTY_ORGANIC_LABEL_HVE = 'hve';
+    const PROPERTY_ORGANIC_LABEL_TRVR = 'trvr';
+
+    public function getPropertyOrganicLabelChoices(): array
+    {
+        return [
+                self::PROPERTY_ORGANIC_LABEL_AB,
+                self::PROPERTY_ORGANIC_LABEL_NP,
+                self::PROPERTY_ORGANIC_LABEL_HVE,
+                self::PROPERTY_ORGANIC_LABEL_TRVR,
+        ];
+    }
+
 
     const TYPE_EXPIRATION_DATE_DLC = 'dlc';
     const TYPE_EXPIRATION_DATE_DDM = 'ddm';
     const TYPE_EXPIRATION_DATE_DLUO = 'dluo';
 
+    public function getTypeExpirationDateChoices(): array
+    {
+        return [
+                self::TYPE_EXPIRATION_DATE_DLC,
+                self::TYPE_EXPIRATION_DATE_DDM,
+                self::TYPE_EXPIRATION_DATE_DLUO,
+        ];
+    }
+
+
     const BEHAVIOR_EXPIRATION_DATE_BY_PRODUCT_FAMILY = 'by-product-family';
     const BEHAVIOR_EXPIRATION_DATE_BY_PRODUCT = 'by-product';
 
+    public function getBehaviorExpirationDateChoices():array{
+        return [
+                self::BEHAVIOR_EXPIRATION_DATE_BY_PRODUCT_FAMILY,
+                self::BEHAVIOR_EXPIRATION_DATE_BY_PRODUCT
+        ];
+    }
+
+
     //Champ hydraté par ProductFamilyUtils
     protected $reductionCatalog;
 
+
     /**
      * @Gedmo\Blameable(on="create")
      * @ORM\ManyToOne(targetEntity="Lc\SovBundle\Model\User\UserInterface")
      */
     protected $updatedBy;
 
-    /**
-     * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", inversedBy="productFamilies")
-     * @ORM\JoinColumn(nullable=false)
-     */
-    protected $merchant;
-
     /**
      * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Product\ProductCategoryInterface", inversedBy="productFamilies")
      */
      */
     protected $saleStatus;
 
+
     /**
-     * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Section\SectionInterface", inversedBy="productFamilies")
+     * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Section\SectionInterface")
+     * @ORM\JoinColumn(nullable=false)
      */
-    protected $sections;
+    protected $section;
 
     public function __construct()
     {
         return $this->getTitle();
     }
 
+    public function getSection(): SectionInterface
+    {
+        return $this->section;
+    }
+
+    public function setSection(SectionInterface $section): self
+    {
+        $this->section = $section;
+
+        return $this;
+    }
+
     public function getAvailableQuantityInherited()
     {
         $availableQuantity = 0;
         if ($this->getTaxRate()) {
             return $this->getTaxRate();
         } else {
-            return $this->getMerchant()->getTaxRate();
+            return $this->getSection()->getMerchant()->getTaxRate();
         }
     }
-
-    public function getMerchant(): ?MerchantInterface
-    {
-        return $this->merchant;
-    }
-
-    public function setMerchant(?MerchantInterface $merchant): self
-    {
-        $this->merchant = $merchant;
-
-        return $this;
-    }
-
     public function getActiveProducts(): ?bool
     {
         return $this->activeProducts;
         return $this;
     }
 
-    /**
-     * @return Collection|SectionInterface[]
-     */
-    public function getSections(): Collection
-    {
-        return $this->sections;
-    }
-
-    public function addSection(SectionInterface $section): self
-    {
-        if (!$this->sections->contains($section)) {
-            $this->sections[] = $section;
-        }
-
-        return $this;
-    }
-
-    public function removeSection(SectionInterface $section): self
-    {
-        if ($this->sections->contains($section)) {
-            $this->sections->removeElement($section);
-        }
-
-        return $this;
-    }
 
     public function getFieldBuyingPrice()
     {

Model/Reminder/ReminderModel.php

      */
     protected $section;
 
-    public function getMerchant(): MerchantInterface
-    {
-        return $this->merchant;
-    }
-
-    public function setMerchant(MerchantInterface $merchant): self
-    {
-        $this->merchant = $merchant;
-
-        return $this;
-    }
-
     public function getSection(): ?SectionInterface
     {
         return $this->section;

Model/Site/PageModel.php

 namespace Lc\CaracoleBundle\Model\Site;
 
 use Doctrine\ORM\Mapping as ORM;
-use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
 use Lc\CaracoleBundle\Doctrine\Extension\FilterSectionInterface;
-use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\CaracoleBundle\Model\Section\SectionInterface;
 use Lc\SovBundle\Model\Site\PageModel as SovPageModel;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class PageModel extends SovPageModel implements FilterMerchantInterface, FilterSectionInterface
+abstract class PageModel extends SovPageModel implements FilterSectionInterface
 {
 
-    /**
-     * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", inversedBy="pages")
-     * @ORM\JoinColumn(nullable=false)
-     */
-    protected $merchant;
-
     /**
      * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Section\SectionInterface", inversedBy="pages")
+     * @ORM\JoinColumn(nullable=false)
      */
     protected $section;
 
 
-    public function getMerchant(): ?MerchantInterface
-    {
-        return $this->merchant;
-    }
-
-    public function setMerchant(?MerchantInterface $merchant): self
-    {
-        $this->merchant = $merchant;
-
-        return $this;
-    }
-
-    public function getSection(): ?SectionInterface
+    public function getSection(): SectionInterface
     {
         return $this->section;
     }
 
-    public function setSection(?SectionInterface $section): self
+    public function setSection(SectionInterface $section): self
     {
         $this->section = $section;
 

Repository/Config/TaxRateStore.php

 
 namespace Lc\CaracoleBundle\Repository\Config;
 
+use Lc\CaracoleBundle\Resolver\MerchantResolver;
 use Lc\SovBundle\Repository\AbstractStore;
 
 class TaxRateStore extends AbstractStore
 {
     protected TaxRateRepositoryQuery $query;
+    protected MerchantResolver $merchantResolver;
 
-    public function __construct(TaxRateRepositoryQuery $query)
+    public function __construct(TaxRateRepositoryQuery $query, MerchantResolver $merchantResolver)
     {
         $this->query = $query;
+        $this->merchantResolver = $merchantResolver;
+    }
+
+
+    public function getAsArray()
+    {
+        $query = $this->query->create();
+
+        $taxRatesList = array();
+        foreach ($query->find() as $taxRate) {
+            $taxRatesList[$taxRate->getId()]['title'] = $taxRate->getTitle();
+            $taxRatesList[$taxRate->getId()]['value'] = $taxRate->getValue();
+        }
+
+        $taxRatesList['default']['title'] = $this->merchantResolver->getCurrent()->getTaxRate()->getTitle();
+        $taxRatesList['default']['value'] = $this->merchantResolver->getCurrent()->getTaxRate()->getValue();
+
+        return $taxRatesList;
     }
 }

Repository/Config/UnitStore.php

     {
         $this->query = $query;
     }
+
+    public function getAsArray(){
+        $query = $this->query->create();
+
+        foreach ($query->find() as $unit) {
+            $unitsList[$unit->getId()]['unit'] = $unit->getUnit();
+            $unitsList[$unit->getId()]['wordingUnit'] = $unit->getWordingUnit();
+            $unitsList[$unit->getId()]['wording'] = $unit->getWording();
+            $unitsList[$unit->getId()]['wordingShort'] = $unit->getWordingShort();
+            $unitsList[$unit->getId()]['coefficient'] = $unit->getCoefficient();
+            $unitsList[$unit->getId()]['unitReference'] = $unit->getUnitReference()->getId();
+        }
+
+        return $unitsList;
+
+    }
 }

Repository/MerchantRepositoryQueryTrait.php

 namespace Lc\CaracoleBundle\Repository;
 
 use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
+use Lc\CaracoleBundle\Model\Section\SectionInterface;
 
 trait MerchantRepositoryQueryTrait
 {
     public function filterByMerchant(MerchantInterface $merchant)
     {
-        return $this
-            ->andWhere('.merchant = :merchant')
-            ->setParameter(':merchant', $merchant);
+        return  $this->andWhere('.merchant = :merchant')->setParameter(':merchant', $merchant);
     }
 }

Repository/MerchantStoreTrait.php

+<?php
+
+namespace Lc\CaracoleBundle\Repository;
+
+use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
+
+trait MerchantStoreTrait
+{
+    protected MerchantInterface $merchant;
+
+    public function setMerchant(MerchantInterface $merchant):self
+    {
+        $this->merchant = $merchant;
+
+        return $this;
+    }
+}

Repository/Order/OrderShopRepositoryQuery.php

 
 class OrderShopRepositoryQuery extends AbstractRepositoryQuery
 {
-    use MerchantRepositoryQueryTrait;
     use SectionRepositoryQueryTrait;
 
     public function __construct(OrderShopRepository $repository, PaginatorInterface $paginator)

Repository/Product/ProductCategoryRepositoryQuery.php

 
 class ProductCategoryRepositoryQuery extends AbstractRepositoryQuery
 {
-    use MerchantRepositoryQueryTrait;
     use SectionRepositoryQueryTrait;
 
     public function __construct(ProductCategoryRepository $repository, PaginatorInterface $paginator)
     {
         parent::__construct($repository, 'r', $paginator);
     }
+
+    public function filterIsParent(){
+        return $this->andWhere('.parent is NULL');
+
+    }
 }

Repository/Product/ProductCategoryStore.php

 
 namespace Lc\CaracoleBundle\Repository\Product;
 
+use Lc\CaracoleBundle\Repository\SectionStoreTrait;
 use Lc\SovBundle\Repository\AbstractStore;
 
 class ProductCategoryStore extends AbstractStore
 {
+    use SectionStoreTrait;
+
     protected ProductCategoryRepositoryQuery $query;
 
     public function __construct(ProductCategoryRepositoryQuery $query)
     {
         $this->query = $query;
     }
+
+    public function getParents(){
+
+        $query = $this->query->create();
+        if($this->section) {
+            $query->filterBySection($this->section);
+        }
+        $query->filterIsParent();
+        return $query->find();
+    }
 }

Repository/Product/ProductFamilyRepositoryQuery.php

 
 class ProductFamilyRepositoryQuery extends AbstractRepositoryQuery
 {
-    use MerchantRepositoryQueryTrait;
     use SectionRepositoryQueryTrait;
 
     public function __construct(ProductFamilyRepository $repository, PaginatorInterface $paginator)

Repository/Reduction/ReductionCatalogRepositoryQuery.php

 namespace Lc\CaracoleBundle\Repository\Reduction;
 
 use Knp\Component\Pager\PaginatorInterface;
+use Lc\CaracoleBundle\Model\Product\ProductFamilyInterface;
 use Lc\CaracoleBundle\Repository\MerchantRepositoryQueryTrait;
 use Lc\SovBundle\Repository\AbstractRepositoryQuery;
 
     {
         parent::__construct($repository, 'r', $paginator);
     }
+
+    public function filterProductFamily(ProductFamilyInterface $productFamily)
+    {
+        return $this
+                ->andWhere('.productFamily = :productFamily')
+                ->setParameter(':productFamily', $productFamily);
+    }
+
+    public function filterStatus(bool $status)
+    {
+        return $this
+                ->andWhere('.status = :status')
+                ->setParameter(':status', $status);
+    }
 }

Repository/Reduction/ReductionCatalogStore.php

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

Repository/Reminder/ReminderStore.php

 
 use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\CaracoleBundle\Model\Section\SectionInterface;
+use Lc\CaracoleBundle\Repository\MerchantStoreTrait;
+use Lc\CaracoleBundle\Repository\SectionStoreTrait;
 use Lc\SovBundle\Repository\Reminder\ReminderStore as SovReminderStore;
 
 class ReminderStore extends SovReminderStore
 {
-    protected MerchantInterface $merchant;
-    protected SectionInterface $section;
-
-    public function setMerchant(MerchantInterface $merchant)
-    {
-        $this->merchant = $merchant;
-
-        return $this;
-    }
-
-    public function setSection(SectionInterface $section)
-    {
-        $this->section = $section;
-
-        return $this;
-    }
+    use SectionStoreTrait;
+    use MerchantStoreTrait;
 
     public function get($params = [], $query = null)
     {

Repository/SectionRepositoryQueryTrait.php

 {
     public function filterBySection(SectionInterface $section)
     {
-        return $this
-            ->andWhere('.section = :section')
-            ->setParameter(':section', $section);
+        $this->andWhere('.section = :section')->setParameter(':section', $section);
     }
 }

Repository/SectionStoreTrait.php

+<?php
+
+namespace Lc\CaracoleBundle\Repository;
+
+use Lc\CaracoleBundle\Model\Section\SectionInterface;
+
+trait SectionStoreTrait
+{
+    protected SectionInterface $section;
+
+    public function setSection(SectionInterface $section):self
+    {
+        $this->section = $section;
+
+        return $this;
+    }
+}

Repository/Site/PageRepositoryQuery.php

 
 class PageRepositoryQuery extends SovPageRepositoryQuery
 {
-    use MerchantRepositoryQueryTrait;
     use SectionRepositoryQueryTrait;
 
 }

Resources/assets/app/admin/switchmerchant/switchmerchant_admin.scss

 
   .fa {
     position: relative;
-    top: -4px;
+    top: 3px;
     right: 7px;
   }
 

Resources/translations/admin.fr.yaml

 
 menu:
   pointsale: Points de vente
+  product_category: Catégories
   setting: Paramètres
-  setting_merchant: Marchand
-  setting_section: Section
+  setting_merchant: Marchands
+  setting_section: Sections
   section_openings: Ouvertures
   admin: Administration
   admin_merchant: Marchands
     panels:
       address: Adresse
     fields:
+      parent: Parent
+      saleStatus: En vente
+      subtitle: Sous-titre
       address: Adresse
       merchant: Marchand
       taxRate: Règle de taxe
     fields:
       timeStart: Heure d'ouverture
       timeEnd: Heure de fermeture
+  ProductCategory:
+    label: Catégorie
+    label_plurial: Catégories
 
 form:
   user_merchant:

Twig/StoreTwigExtension.php

 
 namespace Lc\CaracoleBundle\Twig;
 
+use Lc\CaracoleBundle\Repository\Config\TaxRateStore;
+use Lc\CaracoleBundle\Repository\Config\UnitStore;
 use Lc\CaracoleBundle\Repository\Merchant\MerchantRepositoryQuery;
 use Lc\CaracoleBundle\Repository\Reminder\ReminderStore;
 use Lc\CaracoleBundle\Repository\Section\SectionRepository;
 use Lc\CaracoleBundle\Repository\Section\SectionRepositoryQuery;
 use Lc\CaracoleBundle\Resolver\MerchantResolver;
 use Lc\CaracoleBundle\Resolver\SectionResolver;
+use Lc\ShopBundle\Context\UnitInterface;
 use Twig\Extension\AbstractExtension;
 use Twig\TwigFunction;
 
     protected ReminderStore $reminderStore;
     protected MerchantResolver $merchantResolver;
     protected SectionResolver $sectionResolver;
+    protected UnitStore $unitStore;
+    protected TaxRateStore $taxRateStore;
 
     public function __construct(
             MerchantResolver $merchantResolver,
             SectionResolver $sectionResolver,
             MerchantRepositoryQuery $merchantRepositoryQuery,
             SectionRepositoryQuery $sectionRepositoryQuery,
-            ReminderStore $reminderStore
+            ReminderStore $reminderStore,
+            UnitStore $unitStore,
+            TaxRateStore $taxRateStore
     ) {
         $this->merchantResolver = $merchantResolver;
         $this->sectionResolver = $sectionResolver;
         $this->merchantRepositoryQuery = $merchantRepositoryQuery;
         $this->sectionRepositoryQuery = $sectionRepositoryQuery;
         $this->reminderStore = $reminderStore;
+        $this->unitStore = $unitStore;
+        $this->taxRateStore = $taxRateStore;
     }
 
     public function getFunctions()
                 new TwigFunction('carac_sections', [$this, 'getSections']),
                 new TwigFunction('carac_merchants', [$this, 'getMerchants']),
                 new TwigFunction('carac_reminders', [$this, 'getReminders']),
+                new TwigFunction('carac_units', [$this, 'getUnits']),
+                new TwigFunction('carac_tax_rates', [$this, 'getTaxRates']),
         );
     }
 
                 ->get($params);
     }
 
+    public function getUnits(){
+
+        return $this->unitStore->getAsArray();
+    }
+
+    public function getTaxRates(){
+
+        return $this->taxRateStore->getAsArray();
+    }
+
 }