Intégration app product

Controller/Config/TaxRateAdminController.php

 use EasyCorp\Bundle\EasyAdminBundle\Field\NumberField;
 use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
 use Lc\CaracoleBundle\Controller\AdminControllerTrait;
+use Lc\CaracoleBundle\Factory\Config\TaxRateFactory;
 use Lc\SovBundle\Controller\AbstractAdminController;
 
 abstract class TaxRateAdminController extends AbstractAdminController
 {
     use AdminControllerTrait;
 
-    public function configureCrud(Crud $crud): Crud
-    {
-        return $crud->setSearchFields(['id', 'title', 'value']);
-    }
-
     public function configureFields(string $pageName): iterable
     {
         return [
-                IntegerField::new('id', 'ID')->hideOnForm(),
                 TextField::new('title'),
                 NumberField::new('value')
         ];
     }
+
+    public function configureCrud(Crud $crud): Crud
+    {
+        return $crud->setSearchFields(['id', 'title', 'value']);
+    }
+
+    public function createEntity(string $entityFqcn)
+    {
+        $factory = new TaxRateFactory();
+        return $factory->create();
+    }
 }

Controller/Config/UnitAdminController.php

 use EasyCorp\Bundle\EasyAdminBundle\Field\NumberField;
 use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
 use Lc\CaracoleBundle\Controller\AdminControllerTrait;
+use Lc\CaracoleBundle\Factory\Config\UnitFactory;
 use Lc\SovBundle\Controller\AbstractAdminController;
 
 abstract class UnitAdminController extends AbstractAdminController
     public function configureFields(string $pageName): iterable
     {
         return [
-                IntegerField::new('id', 'ID')->hideOnForm(),
                 TextField::new('unit'),
                 TextField::new('wording'),
                 TextField::new('wordingUnit'),
                 AssociationField::new('unitReference'),
         ];
     }
+
+    public function createEntity(string $entityFqcn)
+    {
+        $factory = new UnitFactory();
+        return $factory->create();
+    }
 }

Controller/Credit/CreditHistoryAdminController.php

 use EasyCorp\Bundle\EasyAdminBundle\Provider\AdminContextProvider;
 use EasyCorp\Bundle\EasyAdminBundle\Router\AdminUrlGenerator;
 use Lc\CaracoleBundle\Controller\AdminControllerTrait;
+use Lc\CaracoleBundle\Factory\Credit\CreditHistoryFactory;
 use Lc\CaracoleBundle\Model\Credit\CreditHistoryInterface;
 use Lc\CaracoleBundle\Model\Credit\CreditHistoryModel;
 use Lc\CaracoleBundle\Model\User\UserMerchantInterface;
         }
     }
 
+    public function createEntity(string $entityFqcn)
+    {
+        $factory = new CreditHistoryFactory();
+        return $factory->create();
+    }
+
     public function persistEntity(EntityManagerInterface $entityManager, $entityInstance): void
     {
         $entityInstance->setUserMerchant($this->getUserMerchant());

Controller/Merchant/MerchantAdminController.php

 use EasyCorp\Bundle\EasyAdminBundle\Field\NumberField;
 use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
 use Lc\CaracoleBundle\Controller\AdminControllerTrait;
+use Lc\CaracoleBundle\Factory\Merchant\MerchantFactory;
 use Lc\CaracoleBundle\Field\Address\AddressField;
 use Lc\SovBundle\Controller\AbstractAdminController;
 use Lc\SovBundle\Field\CKEditorField;
         );
     }
 
+    public function createEntity(string $entityFqcn)
+    {
+        $factory = new MerchantFactory();
+        return $factory->create();
+    }
+
 }

Controller/Newsletter/NewsletterAdminController.php

 namespace Lc\CaracoleBundle\Controller\Newsletter;
 
 use Lc\CaracoleBundle\Controller\AdminControllerTrait;
+use Lc\CaracoleBundle\Factory\Newsletter\NewsletterFactory;
 use Lc\SovBundle\Controller\Newsletter\NewsletterAdminController as SovNewsletterAdminController;
 
 abstract class NewsletterAdminController extends SovNewsletterAdminController
 {
-
     use AdminControllerTrait;
 
+    public function createEntity(string $entityFqcn)
+    {
+        $factory = new NewsletterFactory();
+        $factory->setMerchant($this->get('merchant_resolver')->getCurrent());
+        return $factory->create();
+    }
 }

Controller/PointSale/PointSaleAdminController.php

 use EasyCorp\Bundle\EasyAdminBundle\Field\NumberField;
 use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
 use Lc\CaracoleBundle\Controller\AdminControllerTrait;
+use Lc\CaracoleBundle\Factory\PointSale\PointSaleFactory;
 use Lc\CaracoleBundle\Field\Address\AddressField;
 use Lc\SovBundle\Controller\AbstractAdminController;
+use Lc\SovBundle\Field\BooleanField;
 use Lc\SovBundle\Field\StatusField;
 
 abstract class PointSaleAdminController extends AbstractAdminController
 
     public function configureFields(string $pageName): iterable
     {
-        $panel = parent::configureFields($pageName);
 
         return array_merge(
                 [
                         NumberField::new('orderAmountMin')
                                 ->setCustomOption('appendHtml','€')
                                 ->hideOnIndex(),
-                        StatusField::new('status'),
+                        NumberField::new('deliveryPrice')
+                                ->setCustomOption('appendHtml','€')
+                                ->hideOnIndex(),
+                        BooleanField::new('isPublic'),
+                        BooleanField::new('isDepository'),
+                        StatusField::new('status')
+                                ->hideOnIndex(),
                         FormField::addPanel('address'),
                         AddressField::new('address')
                                 ->setRequired(true)
                 ],
-                $panel
+                $this->getSeoPanel(),
+                $this->getConfPanel(),
         );
     }
 
+    public function createEntity(string $entityFqcn)
+    {
+        $factory = new PointSaleFactory();
+        $currentMerchant = $this->get('merchant_resolver')->getCurrent();
+        return $factory->create($currentMerchant);
+    }
 }

Controller/Reminder/ReminderAdminController.php

 namespace Lc\CaracoleBundle\Controller\Reminder;
 
 use Lc\CaracoleBundle\Controller\AdminControllerTrait;
+use Lc\CaracoleBundle\Factory\Reminder\ReminderFactory;
 use Lc\SovBundle\Controller\Reminder\ReminderAdminController as SovReminderAdminController;
 
 class ReminderAdminController extends SovReminderAdminController
 
     public function createEntity(string $crudAction = null, string $crudControllerFqcn = null, int $entityId = null)
     {
-        return $this->reminderFactory
+        $factory = new ReminderFactory();
+        return $factory
                 ->setMerchant($this->get('merchant_resolver')->getCurrent())
                 ->setSection($this->get('section_resolver')->getCurrent())
                 ->create($crudAction, $crudControllerFqcn, $entityId);

Controller/Section/OpeningAdminController.php

 use EasyCorp\Bundle\EasyAdminBundle\Field\ChoiceField;
 use EasyCorp\Bundle\EasyAdminBundle\Field\TimeField;
 use Lc\CaracoleBundle\Controller\AdminControllerTrait;
+use Lc\CaracoleBundle\Factory\Section\OpeningFactory;
 use Lc\SovBundle\Controller\AbstractAdminController;
 
 abstract class OpeningAdminController extends AbstractAdminController
         return $crud;
     }
 
+    public function createEntity(string $entityFqcn)
+    {
+        $factory = new OpeningFactory();
+        $currentSection = $this->get('section_resolver')->getCurrent();
+        return $factory->create($currentSection);
+    }
+
 }

Controller/Section/SectionAdminController.php

 use EasyCorp\Bundle\EasyAdminBundle\Field\NumberField;
 use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
 use Lc\CaracoleBundle\Controller\AdminControllerTrait;
+use Lc\CaracoleBundle\Factory\Section\SectionFactory;
 use Lc\CaracoleBundle\Form\Section\OpeningsFormType;
 use Lc\CaracoleBundle\Model\Section\SectionModel;
 use Lc\SovBundle\Controller\AbstractAdminController;
 
     public function configureFields(string $pageName): iterable
     {
-        $panel = parent::configureFields($pageName);
-
         return array_merge(
                 [
                         FormField::addPanel('general'),
                         TextField::new('title'),
                         ChoiceField::new('cycle')
                                 ->setRequired(true)
+                                ->hideOnIndex()
                                 ->setChoices(
                                         [
                                                 'Jour' => SectionModel::CYCLE_DAY,
                         BooleanField::new('isDefault', 'Section par défaut'),
                         StatusField::new('status'),
                 ],
-                $panel
+                $this->getSeoPanel(),
+                $this->getConfPanel(),
         );
     }
 
+    public function createEntity(string $entityFqcn)
+    {
+        $factory = new SectionFactory();
+        $currentMerchant = $this->get('merchant_resolver')->getCurrent();
+        return $factory->create($currentMerchant);
+    }
+
 }

Controller/Site/NewsAdminController.php

 namespace Lc\CaracoleBundle\Controller\Site;
 
 use Lc\CaracoleBundle\Controller\AdminControllerTrait;
+use Lc\CaracoleBundle\Factory\Site\NewsFactory;
 use Lc\SovBundle\Controller\Site\NewsAdminController as SovNewsAdminController;
 
 abstract class NewsAdminController extends SovNewsAdminController
 {
-
     use AdminControllerTrait;
 
+    public function createEntity(string $entityFqcn)
+    {
+        $factory = new NewsFactory();
+        $currentMerchant = $this->get('merchant_resolver')->getCurrent();
+        $factory->setMerchant($currentMerchant);
+        return $factory->create();
+    }
 }

Controller/Site/PageAdminController.php

 namespace Lc\CaracoleBundle\Controller\Site;
 
 use Lc\CaracoleBundle\Controller\AdminControllerTrait;
+use Lc\CaracoleBundle\Factory\Site\PageFactory;
 use Lc\SovBundle\Controller\Site\PageAdminController as SovPageAdminController;
 
 abstract class PageAdminController extends SovPageAdminController
 {
-
     use AdminControllerTrait;
 
+    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/User/GroupUserAdminController.php

 namespace Lc\CaracoleBundle\Controller\User;
 
 use Lc\CaracoleBundle\Controller\AdminControllerTrait;
+use Lc\CaracoleBundle\Factory\User\GroupUserFactory;
 use Lc\SovBundle\Controller\User\GroupUserAdminController as SovGroupUserAdminController;
 
 abstract class GroupUserAdminController extends SovGroupUserAdminController
 {
-
     use AdminControllerTrait;
 
+    public function createEntity(string $entityFqcn)
+    {
+        $factory = new GroupUserFactory();
+        $currentMerchant = $this->get('merchant_resolver')->getCurrent();
+        $factory->setMerchant($currentMerchant);
+        return $factory->create();
+    }
 }

Factory/Address/AddressFactory.php

 namespace Lc\CaracoleBundle\Factory\Address;
 
 use App\Entity\Address\Address;
-use Lc\CaracoleBundle\Factory\MerchantFactoryTrait;
 use Lc\CaracoleBundle\Model\Address\AddressInterface;
+use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class AddressFactory extends AbstractFactory implements AddressFactoryInterface
+class AddressFactory extends AbstractFactory
 {
-    use MerchantFactoryTrait;
 
-    public function create(): AddressInterface
+    public function create(MerchantInterface $merchant = null): AddressInterface
     {
         $address = new Address();
 
-        $address->setMerchant($this->merchant);
+        $address->setMerchant($merchant);
 
         return $address;
     }

Factory/Address/AddressFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Address;
-
-interface AddressFactoryInterface
-{
-
-}

Factory/Config/TaxRateFactory.php

 use Lc\CaracoleBundle\Model\Config\TaxRateInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class TaxRateFactory extends AbstractFactory implements TaxRateFactoryInterface
+class TaxRateFactory extends AbstractFactory
 {
     public function create(): TaxRateInterface
     {

Factory/Config/TaxRateFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Config;
-
-interface TaxRateFactoryInterface
-{
-
-}

Factory/Config/UnitFactory.php

 use Lc\CaracoleBundle\Model\Config\UnitInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class UnitFactory extends AbstractFactory implements UnitFactoryInterface
+class UnitFactory extends AbstractFactory
 {
     public function create(): UnitInterface
     {

Factory/Config/UnitFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Config;
-
-interface UnitFactoryInterface
-{
-
-}

Factory/Credit/CreditHistoryFactory.php

 namespace Lc\CaracoleBundle\Factory\Credit;
 
 use App\Entity\Credit\CreditHistory;
-use Lc\CaracoleBundle\Factory\CreditHistory\CreditHistoryFactoryInterface;
 use Lc\CaracoleBundle\Model\Credit\CreditHistoryInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class CreditHistoryFactory extends AbstractFactory implements CreditHistoryFactoryInterface
+class CreditHistoryFactory extends AbstractFactory
 {
     public function create(): CreditHistoryInterface
     {

Factory/Credit/CreditHistoryFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Credit;
-
-interface CreditHistoryFactoryInterface
-{
-
-}

Factory/File/DocumentFactory.php

 use Lc\CaracoleBundle\Model\File\DocumentInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class DocumentFactory extends AbstractFactory implements DocumentFactoryInterface
+class DocumentFactory extends AbstractFactory
 {
     use MerchantFactoryTrait;
 

Factory/File/DocumentFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\File;
-
-interface DocumentFactoryInterface
-{
-
-}

Factory/Merchant/MerchantFactory.php

 use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class MerchantFactory extends AbstractFactory implements MerchantFactoryInterface
+class MerchantFactory extends AbstractFactory
 {
     public function create(): MerchantInterface
     {

Factory/Merchant/MerchantFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Merchant;
-
-interface MerchantFactoryInterface
-{
-
-}

Factory/Newsletter/NewsletterFactory.php

 
 namespace Lc\CaracoleBundle\Factory\Newsletter;
 
-use App\Entity\Newsletter\Newsletter;
 use Lc\CaracoleBundle\Factory\MerchantFactoryTrait;
 use Lc\SovBundle\Model\Newsletter\NewsletterInterface;
 use Lc\SovBundle\Factory\Newsletter\NewsletterFactory as SovNewsletterFactory;

Factory/Order/OrderPaymentFactory.php

 use Lc\CaracoleBundle\Model\Order\OrderPaymentInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class OrderPaymentFactory extends AbstractFactory implements OrderPaymentFactoryInterface
+class OrderPaymentFactory extends AbstractFactory
 {
     public function create(): OrderPaymentInterface
     {

Factory/Order/OrderPaymentFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Order;
-
-interface OrderPaymentFactoryInterface
-{
-
-}

Factory/Order/OrderProductFactory.php

 use Lc\CaracoleBundle\Model\Order\OrderProductInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class OrderProductFactory extends AbstractFactory implements OrderProductFactoryInterface
+class OrderProductFactory extends AbstractFactory
 {
     public function create(): OrderProductInterface
     {

Factory/Order/OrderProductFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Order;
-
-interface OrderProductFactoryInterface
-{
-
-}

Factory/Order/OrderProductReductionCatalogFactory.php

 use Lc\CaracoleBundle\Model\Order\OrderProductReductionCatalogInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class OrderProductReductionCatalogFactory extends AbstractFactory implements OrderProductReductionCatalogFactoryInterface
+class OrderProductReductionCatalogFactory extends AbstractFactory
 {
     public function create(): OrderProductReductionCatalogInterface
     {

Factory/Order/OrderProductReductionCatalogFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Order;
-
-interface OrderProductReductionCatalogFactoryInterface
-{
-
-}

Factory/Order/OrderProductRefundFactory.php

 use Lc\CaracoleBundle\Model\Order\OrderProductRefundInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class OrderProductRefundFactory extends AbstractFactory implements OrderProductRefundFactoryInterface
+class OrderProductRefundFactory extends AbstractFactory
 {
     public function create(): OrderProductRefundInterface
     {

Factory/Order/OrderProductRefundFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Order;
-
-interface OrderProductRefundFactoryInterface
-{
-
-}

Factory/Order/OrderReductionCartFactory.php

 use Lc\CaracoleBundle\Model\Order\OrderReductionCartInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class OrderReductionCartFactory extends AbstractFactory implements OrderReductionCartFactoryInterface
+class OrderReductionCartFactory extends AbstractFactory
 {
     public function create(): OrderReductionCartInterface
     {

Factory/Order/OrderReductionCartFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Order;
-
-interface OrderReductionCartFactoryInterface{
-
-}

Factory/Order/OrderReductionCreditFactory.php

 use Lc\CaracoleBundle\Model\Order\OrderReductionCreditInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class OrderReductionCreditFactory extends AbstractFactory implements OrderReductionCreditFactoryInterface
+class OrderReductionCreditFactory extends AbstractFactory
 {
     public function create(): OrderReductionCreditInterface
     {

Factory/Order/OrderReductionCreditFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Order;
-
-interface OrderReductionCreditFactoryInterface
-{
-
-}

Factory/Order/OrderRefundFactory.php

 use Lc\CaracoleBundle\Model\Order\OrderRefundInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class OrderRefundFactory extends AbstractFactory implements OrderRefundFactoryInterface
+class OrderRefundFactory extends AbstractFactory
 {
     public function create(): OrderRefundInterface
     {

Factory/Order/OrderRefundFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Order;
-
-interface OrderRefundFactoryInterface
-{
-
-}

Factory/Order/OrderShopFactory.php

 use App\Entity\Order\OrderShop;
 use Lc\CaracoleBundle\Factory\MerchantFactoryTrait;
 use Lc\CaracoleBundle\Factory\SectionFactoryTrait;
+use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\CaracoleBundle\Model\Order\OrderShopInterface;
+use Lc\CaracoleBundle\Model\Section\SectionInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class OrderShopFactory extends AbstractFactory implements OrderShopFactoryInterface
+class OrderShopFactory extends AbstractFactory
 {
-    use MerchantFactoryTrait;
-    use SectionFactoryTrait;
 
-    public function create(): OrderShopInterface
+    public function create(MerchantInterface $merchant, SectionInterface $section): OrderShopInterface
     {
         $orderShop = new OrderShop();
 
-        $orderShop->setMerchant($this->merchant);
-        $orderShop->setSection($this->section);
+        $orderShop->setMerchant($merchant);
+        $orderShop->setSection($section);
 
         return $orderShop;
     }

Factory/Order/OrderShopFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Order;
-
-interface OrderShopFactoryInterface
-{
-
-}

Factory/Order/OrderStatusFactory.php

 use Lc\CaracoleBundle\Model\Order\OrderStatusInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class OrderStatusFactory extends AbstractFactory implements OrderStatusFactoryInterface
+class OrderStatusFactory extends AbstractFactory
 {
     public function create(): OrderStatusInterface
     {

Factory/Order/OrderStatusFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Order;
-
-interface OrderStatusFactoryInterface
-{
-
-}

Factory/Order/OrderStatusHistoryFactory.php

 use Lc\CaracoleBundle\Model\Order\OrderStatusHistoryInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class OrderStatusHistoryFactory extends AbstractFactory implements OrderStatusHistoryFactoryInterface
+class OrderStatusHistoryFactory extends AbstractFactory
 {
     public function create(): OrderStatusHistoryInterface
     {

Factory/Order/OrderStatusHistoryFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Order;
-
-interface OrderStatusHistoryFactoryInterface
-{
-
-}

Factory/PointSale/PointSaleFactory.php

 namespace Lc\CaracoleBundle\Factory\PointSale;
 
 use App\Entity\PointSale\PointSale;
-use Lc\CaracoleBundle\Factory\MerchantFactoryTrait;
+use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\CaracoleBundle\Model\PointSale\PointSaleInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class PointSaleFactory extends AbstractFactory implements PointSaleFactoryInterface
+class PointSaleFactory extends AbstractFactory
 {
-    use MerchantFactoryTrait;
 
-    public function create(): PointSaleInterface
+    public function create(MerchantInterface $merchant): PointSaleInterface
     {
         $pointSale = new PointSale();
 
-        $pointSale->addMerchant($this->merchant);
+        $pointSale->addMerchant($merchant);
 
         return $pointSale;
     }

Factory/PointSale/PointSaleFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\PointSale;
-
-interface PointSaleFactoryInterface
-{
-
-}

Factory/Product/ProductCategoryFactory.php

 namespace Lc\CaracoleBundle\Factory\Product;
 
 use App\Entity\Product\ProductCategory;
-use Lc\CaracoleBundle\Factory\MerchantFactoryTrait;
-use Lc\CaracoleBundle\Factory\SectionFactoryTrait;
+use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\CaracoleBundle\Model\Product\ProductCategoryInterface;
+use Lc\CaracoleBundle\Model\Section\SectionInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class ProductCategoryFactory extends AbstractFactory implements ProductCategoryFactoryInterface
+class ProductCategoryFactory extends AbstractFactory
 {
-    use MerchantFactoryTrait;
-    use SectionFactoryTrait;
 
-    public function create(): ProductCategoryInterface
+    public function create(MerchantInterface $merchant, SectionInterface $section): ProductCategoryInterface
     {
         $productCategory = new ProductCategory();
 
-        $productCategory->setMerchant($this->merchant);
-        $productCategory->setSection($this->section);
+        $productCategory->setMerchant($merchant);
+        $productCategory->setSection($section);
 
         return $productCategory;
     }

Factory/Product/ProductCategoryFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Product;
-
-interface ProductCategoryFactoryInterface
-{
-
-}

Factory/Product/ProductFactory.php

 use Lc\CaracoleBundle\Model\Product\ProductInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class ProductFactory extends AbstractFactory implements ProductFactoryInterface
+class ProductFactory extends AbstractFactory
 {
     public function create(): ProductInterface
     {

Factory/Product/ProductFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Product;
-
-interface ProductFactoryInterface
-{
-
-}

Factory/Product/ProductFamilyFactory.php

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

Factory/Product/ProductFamilyFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Product;
-
-interface ProductFamilyFactoryInterface
-{
-
-}

Factory/Reduction/ReductionCartFactory.php

 namespace Lc\CaracoleBundle\Factory\Reduction;
 
 use App\Entity\Reduction\ReductionCart;
-use Lc\CaracoleBundle\Factory\MerchantFactoryTrait;
+use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\CaracoleBundle\Model\Reduction\ReductionCartInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class ReductionCartFactory extends AbstractFactory implements ReductionCartFactoryInterface
+class ReductionCartFactory extends AbstractFactory
 {
-    use MerchantFactoryTrait;
 
-    public function create(): ReductionCartInterface
+    public function create(MerchantInterface $merchant): ReductionCartInterface
     {
         $reductionCart = new ReductionCart();
 
-        $reductionCart->setMerchant($this->merchant);
+        $reductionCart->setMerchant($merchant);
 
         return $reductionCart;
     }

Factory/Reduction/ReductionCartFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Reduction;
-
-interface ReductionCartFactoryInterface
-{
-
-}

Factory/Reduction/ReductionCatalogFactory.php

 namespace Lc\CaracoleBundle\Factory\Reduction;
 
 use App\Entity\Reduction\ReductionCatalog;
-use Lc\CaracoleBundle\Factory\MerchantFactoryTrait;
+use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\CaracoleBundle\Model\Reduction\ReductionCatalogInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class ReductionCatalogFactory extends AbstractFactory implements ReductionCatalogFactoryInterface
+class ReductionCatalogFactory extends AbstractFactory
 {
-    use MerchantFactoryTrait;
 
-    public function create(): ReductionCatalogInterface
+    public function create(MerchantInterface $merchant): ReductionCatalogInterface
     {
         $reductionCatalog = new ReductionCatalog();
 
-        $reductionCatalog->setMerchant($this->merchant);
+        $reductionCatalog->setMerchant($merchant);
 
         return $reductionCatalog;
     }

Factory/Reduction/ReductionCatalogFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Reduction;
-
-interface ReductionCatalogFactoryInterface
-{
-
-}

Factory/Reduction/ReductionCreditFactory.php

 namespace Lc\CaracoleBundle\Factory\Reduction;
 
 use App\Entity\Reduction\ReductionCredit;
-use Lc\CaracoleBundle\Factory\MerchantFactoryTrait;
+use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\CaracoleBundle\Model\Reduction\ReductionCreditInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class ReductionCreditFactory extends AbstractFactory implements ReductionCreditFactoryInterface
+class ReductionCreditFactory extends AbstractFactory
 {
-    use MerchantFactoryTrait;
 
-    public function create(): ReductionCreditInterface
+    public function create(MerchantInterface $merchant): ReductionCreditInterface
     {
         $reductionCredit = new ReductionCredit();
 
-        $reductionCredit->setMerchant($this->merchant);
+        $reductionCredit->setMerchant($merchant);
 
         return $reductionCredit;
     }

Factory/Reduction/ReductionCreditFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Reduction;
-
-interface ReductionCreditFactoryInterface
-{
-
-}

Factory/Section/OpeningFactory.php

 namespace Lc\CaracoleBundle\Factory\Section;
 
 use App\Entity\Section\Opening;
-use Lc\CaracoleBundle\Factory\SectionFactoryTrait;
+use Lc\CaracoleBundle\Model\Section\SectionInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 use Lc\SovBundle\Model\User\GroupUserInterface;
 
-class OpeningFactory extends AbstractFactory implements OpeningFactoryInterface
+class OpeningFactory extends AbstractFactory
 {
-    use SectionFactoryTrait;
 
     public function create(
+            SectionInterface $section,
             int $day,
             \DateTime $timeStart = null,
             \DateTime $timeEnd = null,
     ): Opening {
         $opening = new Opening();
 
-        $opening->setSection($this->section);
+        $opening->setSection($section);
         $opening->setDay($day);
         $opening->setTimeStart($timeStart);
         $opening->setTimeEnd($timeEnd);

Factory/Section/OpeningFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Section;
-
-interface OpeningFactoryInterface
-{
-
-}

Factory/Section/SectionFactory.php

 namespace Lc\CaracoleBundle\Factory\Section;
 
 use App\Entity\Section\Section;
-use Lc\CaracoleBundle\Factory\MerchantFactoryTrait;
-use Lc\CaracoleBundle\Factory\SectionFactoryTrait;
+use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\CaracoleBundle\Model\Section\SectionInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class SectionFactory extends AbstractFactory implements SectionFactoryInterface
+class SectionFactory extends AbstractFactory
 {
-    use MerchantFactoryTrait;
 
-    public function create(): SectionInterface
+    public function create(MerchantInterface $merchant): SectionInterface
     {
         $section = new Section();
 
-        $section->setMerchant($this->merchant);
+        $section->setMerchant($merchant);
 
         return $section;
     }

Factory/Section/SectionFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\Section;
-
-interface SectionFactoryInterface
-{
-
-}

Factory/User/GroupUserFactory.php

 
 namespace Lc\CaracoleBundle\Factory\User;
 
-use App\Entity\User\GroupUser;
 use Lc\CaracoleBundle\Factory\MerchantFactoryTrait;
-use Lc\SovBundle\Factory\AbstractFactory;
 use Lc\SovBundle\Model\User\GroupUserInterface;
+use Lc\SovBundle\Factory\User\GroupUserFactory as SovGroupUserFactory;
 
-class GroupUserFactory extends AbstractFactory implements GroupUserFactoryInterface
+class GroupUserFactory extends SovGroupUserFactory
 {
     use MerchantFactoryTrait;
 
     public function create(): GroupUserInterface
     {
-        $groupUser = new GroupUser();
+        $groupUser = parent::create();
 
         $groupUser->setMerchant($this->merchant);
 

Factory/User/GroupUserFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\User;
-
-interface GroupUserFactoryInterface
-{
-
-}

Factory/User/UserMerchantFactory.php

 namespace Lc\CaracoleBundle\Factory\User;
 
 use App\Entity\User\UserMerchant;
-use Lc\CaracoleBundle\Factory\MerchantFactoryTrait;
+use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
 use Lc\CaracoleBundle\Model\User\UserMerchantInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
 class UserMerchantFactory extends AbstractFactory
 {
-    use MerchantFactoryTrait;
 
-    public function create(): UserMerchantInterface
+    public function create(MerchantInterface $merchant): UserMerchantInterface
     {
         $userMerchant = new UserMerchant();
 
-        $userMerchant->setMerchant($this->merchant);
+        $userMerchant->setMerchant($merchant);
 
         return $userMerchant;
     }

Factory/User/VisitorFactory.php

 use Lc\CaracoleBundle\Model\User\VisitorInterface;
 use Lc\SovBundle\Factory\AbstractFactory;
 
-class VisitorFactory extends AbstractFactory implements VisitorFactoryInterface
+class VisitorFactory extends AbstractFactory
 {
     public function create(): VisitorInterface
     {

Factory/User/VisitorFactoryInterface.php

-<?php
-
-namespace Lc\CaracoleBundle\Factory\User;
-
-interface VisitorFactoryInterface
-{
-
-}

Model/Newsletter/NewsletterModel.php

 
 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\Newsletter\NewsletterModel as SovNewsletterModel;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class NewsletterModel extends SovNewsletterModel implements FilterMerchantInterface
+abstract class NewsletterModel extends SovNewsletterModel implements FilterMerchantInterface, 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;
     }
+
+    public function getSection(): ?SectionInterface
+    {
+        return $this->section;
+    }
+
+    public function setSection(?SectionInterface $section): self
+    {
+        $this->section = $section;
+
+        return $this;
+    }
 }

Repository/Address/AddressStore.php

 
 namespace Lc\CaracoleBundle\Repository\Address;
 
-class AddressStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class AddressStore extends AbstractStore
 {
     protected AddressRepositoryQuery $query;
 

Repository/Config/TaxRateStore.php

 namespace Lc\CaracoleBundle\Repository\Config;
 
 use Lc\CaracoleBundle\Resolver\MerchantResolver;
+use Lc\SovBundle\Repository\AbstractStore;
 
-class TaxRateStore
+class TaxRateStore extends AbstractStore
 {
     protected TaxRateRepositoryQuery $query;
     protected MerchantResolver $merchantResolver;

Repository/Config/UnitStore.php

 
 namespace Lc\CaracoleBundle\Repository\Config;
 
-class UnitStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class UnitStore extends AbstractStore
 {
     protected UnitRepositoryQuery $query;
 

Repository/Credit/CreditHistoryStore.php

 
 namespace Lc\CaracoleBundle\Repository\Credit;
 
-class CreditHistoryStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class CreditHistoryStore extends AbstractStore
 {
     protected CreditHistoryRepositoryQuery $query;
 

Repository/File/DocumentStore.php

 
 namespace Lc\CaracoleBundle\Repository\File;
 
-class DocumentStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class DocumentStore extends AbstractStore
 {
     protected DocumentRepositoryQuery $query;
 

Repository/Merchant/MerchantStore.php

 
 namespace Lc\CaracoleBundle\Repository\Merchant;
 
-class MerchantStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class MerchantStore extends AbstractStore
 {
     protected MerchantRepositoryQuery $query;
 

Repository/Order/OrderPaymentStore.php

 
 namespace Lc\CaracoleBundle\Repository\Order;
 
-class OrderPaymentStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class OrderPaymentStore extends AbstractStore
 {
     protected OrderPaymentRepositoryQuery $query;
 

Repository/Order/OrderProductReductionCatalogStore.php

 
 namespace Lc\CaracoleBundle\Repository\Order;
 
-class OrderProductReductionCatalogStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class OrderProductReductionCatalogStore extends AbstractStore
 {
     protected OrderProductReductionCatalogRepositoryQuery $query;
 

Repository/Order/OrderProductRefundStore.php

 
 namespace Lc\CaracoleBundle\Repository\Order;
 
-class OrderProductRefundStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class OrderProductRefundStore extends AbstractStore
 {
     protected OrderProductRefundRepositoryQuery $query;
 

Repository/Order/OrderProductStore.php

 
 namespace Lc\CaracoleBundle\Repository\Order;
 
-class OrderProductStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class OrderProductStore extends AbstractStore
 {
     protected OrderProductRepositoryQuery $query;
 

Repository/Order/OrderReductionCartStore.php

 
 namespace Lc\CaracoleBundle\Repository\Order;
 
-class OrderReductionCartStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class OrderReductionCartStore extends AbstractStore
 {
     protected OrderReductionCartRepositoryQuery $query;
 

Repository/Order/OrderReductionCreditStore.php

 
 namespace Lc\CaracoleBundle\Repository\Order;
 
-class OrderReductionCreditStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class OrderReductionCreditStore extends AbstractStore
 {
     protected OrderReductionCreditRepositoryQuery $query;
 

Repository/Order/OrderRefundStore.php

 
 namespace Lc\CaracoleBundle\Repository\Order;
 
-class OrderRefundStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class OrderRefundStore extends AbstractStore
 {
     protected OrderRefundRepositoryQuery $query;
 

Repository/Order/OrderShopStore.php

 
 namespace Lc\CaracoleBundle\Repository\Order;
 
-class OrderShopStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class OrderShopStore extends AbstractStore
 {
     protected OrderShopRepositoryQuery $query;
 

Repository/Order/OrderStatusHistoryStore.php

 
 namespace Lc\CaracoleBundle\Repository\Order;
 
-class OrderStatusHistoryStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class OrderStatusHistoryStore extends AbstractStore
 {
     protected OrderStatusHistoryRepositoryQuery $query;
 

Repository/Order/OrderStatusStore.php

 
 namespace Lc\CaracoleBundle\Repository\Order;
 
-class OrderStatusStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class OrderStatusStore extends AbstractStore
 {
     protected OrderStatusRepositoryQuery $query;
 

Repository/PointSale/PointSaleRepositoryQuery.php

     public function filterByMerchant(MerchantInterface $merchant)
     {
         return $this
-                ->andWhere(':merchant MEMBER OF .merchant')
+                ->andWhere(':merchant MEMBER OF .merchants')
                 ->setParameter(':merchant', $merchant);
     }
 }

Repository/PointSale/PointSaleStore.php

 
 namespace Lc\CaracoleBundle\Repository\PointSale;
 
-class PointSaleStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class PointSaleStore extends AbstractStore
 {
     protected PointSaleRepositoryQuery $query;
 

Repository/Product/ProductCategoryStore.php

 
 namespace Lc\CaracoleBundle\Repository\Product;
 
-class ProductCategoryStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class ProductCategoryStore extends AbstractStore
 {
     protected ProductCategoryRepositoryQuery $query;
 

Repository/Product/ProductFamilyStore.php

 
 namespace Lc\CaracoleBundle\Repository\Product;
 
-class ProductFamilyStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class ProductFamilyStore extends AbstractStore
 {
     protected ProductFamilyRepositoryQuery $query;
 

Repository/Product/ProductStore.php

 
 namespace Lc\CaracoleBundle\Repository\Product;
 
-class ProductStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class ProductStore extends AbstractStore
 {
     protected ProductRepositoryQuery $query;
 

Repository/Reduction/ReductionCartStore.php

 
 namespace Lc\CaracoleBundle\Repository\Reduction;
 
-class ReductionCartStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class ReductionCartStore extends AbstractStore
 {
     protected ReductionCartRepositoryQuery $query;
 

Repository/Reduction/ReductionCatalogStore.php

 
 namespace Lc\CaracoleBundle\Repository\Reduction;
 
-class ReductionCatalogStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class ReductionCatalogStore extends AbstractStore
 {
     protected ReductionCatalogRepositoryQuery $query;
 

Repository/Reduction/ReductionCreditStore.php

 
 namespace Lc\CaracoleBundle\Repository\Reduction;
 
-class ReductionCreditStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class ReductionCreditStore extends AbstractStore
 {
     protected ReductionCreditRepositoryQuery $query;
 

Repository/Section/OpeningStore.php

 
 namespace Lc\CaracoleBundle\Repository\Section;
 
-class OpeningStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class OpeningStore extends AbstractStore
 {
     protected OpeningRepositoryQuery $query;
 

Repository/Section/SectionStore.php

 
 namespace Lc\CaracoleBundle\Repository\Section;
 
-class SectionStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class SectionStore extends AbstractStore
 {
     protected SectionRepositoryQuery $query;
 

Repository/Setting/MerchantSettingStore.php

 
 namespace Lc\CaracoleBundle\Repository\Setting;
 
-class MerchantSettingStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class MerchantSettingStore extends AbstractStore
 {
     protected MerchantSettingRepositoryQuery $query;
 

Repository/Setting/SectionSettingStore.php

 
 namespace Lc\CaracoleBundle\Repository\Setting;
 
-class SectionSettingStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class SectionSettingStore extends AbstractStore
 {
     protected SectionSettingRepositoryQuery $query;
 

Repository/User/GroupUserStore.php

 
 namespace Lc\CaracoleBundle\Repository\User;
 
-class GroupUserStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class GroupUserStore extends AbstractStore
 {
     protected GroupUserRepositoryQuery $query;
 

Repository/User/UserMerchantStore.php

 
 namespace Lc\CaracoleBundle\Repository\User;
 
-class UserMerchantStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class UserMerchantStore extends AbstractStore
 {
     protected UserMerchantRepositoryQuery $query;
 

Repository/User/VisitorStore.php

 
 namespace Lc\CaracoleBundle\Repository\User;
 
-class VisitorStore
+use Lc\SovBundle\Repository\AbstractStore;
+
+class VisitorStore extends AbstractStore
 {
     protected VisitorRepositoryQuery $query;