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

Builder/Order/OrderShopBuilder.php

             OrderShopInterface $orderShop2,
             $persist = true
     ): OrderShopInterface {
+        //TODO essayer de comprendre prk on doit faire un refresh ici ???
+        $this->entityManager->refresh($orderShop1);
+        $this->entityManager->refresh($orderShop2);
         if ($orderShop1 && $orderShop2) {
             foreach ($orderShop2->getOrderProducts() as $orderProduct) {
                 $orderProductAlreadyInCart = $this->orderShopSolver->hasOrderProductAlreadyInCart($orderShop1, $orderProduct);

Builder/Product/ProductFamilySectionPropertyBuilder.php

         $this->productFamilySectionPropertyStore = $productFamilySectionPropertyStore;
     }
 
-    public function enable(ProductFamilyInterface $productFamily, SectionInterface $section): void
+    public function enable(ProductFamilyInterface $productFamily, SectionInterface $section, bool $flush = true): void
     {
         $productFamilySectionProperty = $this->productFamilySectionPropertyStore
                 ->setSection($section)
             $this->entityManager->create($productFamilySectionProperty);
         }
 
-        $this->entityManager->flush();
+        if($flush) {
+            $this->entityManager->flush();
+        }
     }
 
 }

EventSubscriber/SettingEventSubscriber.php → Builder/Setting/SettingBuilder.php

 <?php
 
-namespace Lc\CaracoleBundle\EventSubscriber;
+namespace Lc\CaracoleBundle\Builder\Setting;
 
 use Doctrine\ORM\EntityManagerInterface;
-use Lc\CaracoleBundle\Definition\MerchantSettingDefinitionInterface;
+use Lc\CaracoleBundle\Definition\MerchantSettingDefinition;
 use Lc\CaracoleBundle\Definition\SectionSettingDefinition;
 use Lc\CaracoleBundle\Factory\Setting\MerchantSettingFactory;
 use Lc\CaracoleBundle\Factory\Setting\SectionSettingFactory;
 use Lc\CaracoleBundle\Model\Section\SectionInterface;
 use Lc\CaracoleBundle\Repository\Merchant\MerchantStore;
-use Lc\CaracoleBundle\Repository\Section\SectionStore;
+use Lc\SovBundle\Definition\SiteSettingDefinition;
+use Lc\SovBundle\Factory\Setting\SiteSettingFactory;
+use Lc\SovBundle\Repository\Site\SiteStore;
 use Lc\SovBundle\Solver\Setting\SettingSolver;
-use Symfony\Component\EventDispatcher\EventSubscriberInterface;
-use Symfony\Component\HttpKernel\KernelEvents;
+use Lc\SovBundle\Builder\Setting\SettingBuilder as SovSettingBuilder;
 
-class SettingEventSubscriber implements EventSubscriberInterface
+class SettingBuilder extends SovSettingBuilder
 {
-    protected EntityManagerInterface $entityManager;
-    protected MerchantSettingDefinitionInterface $merchantSettingDefinition;
-    protected SectionSettingDefinition $sectionSettingDefinition;
     protected MerchantStore $merchantStore;
-    protected SectionStore $sectionStore;
+    protected MerchantSettingDefinition $merchantSettingDefinition;
     protected MerchantSettingFactory $merchantSettingFactory;
+    protected SectionSettingDefinition $sectionSettingDefinition;
     protected SectionSettingFactory $sectionSettingFactory;
-    protected SettingSolver $settingSolver;
 
     public function __construct(
             EntityManagerInterface $entityManager,
-            MerchantSettingDefinitionInterface $merchantSettingDefinition,
-            SectionSettingDefinition $sectionSettingDefinition,
+            SettingSolver $settingSolver,
+            SiteStore $siteStore,
+            SiteSettingDefinition $siteSettingDefinition,
+            SiteSettingFactory $siteSettingFactory,
             MerchantStore $merchantStore,
-            SectionStore $sectionStore,
+            MerchantSettingDefinition $merchantSettingDefinition,
             MerchantSettingFactory $merchantSettingFactory,
-            SectionSettingFactory $sectionSettingFactory,
-            SettingSolver $settingSolver
+            SectionSettingDefinition $sectionSettingDefinition,
+            SectionSettingFactory $sectionSettingFactory
     ) {
-        $this->entityManager = $entityManager;
+        parent::__construct($entityManager, $settingSolver, $siteStore, $siteSettingDefinition, $siteSettingFactory);
+
         $this->merchantStore = $merchantStore;
-        $this->sectionStore = $sectionStore;
         $this->merchantSettingDefinition = $merchantSettingDefinition;
-        $this->sectionSettingDefinition = $sectionSettingDefinition;
         $this->merchantSettingFactory = $merchantSettingFactory;
+        $this->sectionSettingDefinition = $sectionSettingDefinition;
         $this->sectionSettingFactory = $sectionSettingFactory;
-        $this->settingSolver = $settingSolver;
     }
 
-    public static function getSubscribedEvents()
-    {
-        return [
-                KernelEvents::CONTROLLER => ['initSettings']
-        ];
-    }
-
-    public function initSettings()
+    public function initMerchantSettings()
     {
         $merchants = $this->merchantStore->get();
 
         $this->initSettingsGeneric(
-                'merchant',
                 $this->merchantSettingDefinition->getSettings(),
-                //TODO vérifier que ce soit bien les online que l'on souhaite
                 $merchants,
                 $this->merchantSettingFactory
         );
+    }
+
+    public function initSectionSettings()
+    {
+        $merchants = $this->merchantStore->get();
 
         foreach($merchants as $merchant) {
             $this->initSettingsGeneric(
-                    'section',
                     $this->sectionSettingDefinition->getSettings(),
                     $merchant->getSections(),
                     $this->sectionSettingFactory
         }
     }
 
-    public function initSettingsGeneric($type, $settings, $entities, $factory)
+    protected function initSettingsGeneric($settings, $entities, $factory)
     {
         if($entities) {
             foreach ($entities as $entity) {
 
+                $this->entityManager->refresh($entity);
+
                 foreach ($settings as $category => $settingList) {
                     foreach ($settingList as $settingName => $setting) {
+
                         $entitySetting = $this->settingSolver->getSetting($entity, $settingName);
 
                         if (!$entitySetting) {
+
                             // gestion du cas des SectionSetting spécifiques à une section
                             $createEntitySetting = true;
                             if ($entity instanceof SectionInterface && isset($setting['section']) && $setting['section'] != $entity) {
 
                                 $entitySetting = $factory->create($entity, $setting['name'], $text, $date, $file);
 
-                                $this->entityManager->persist($entitySetting);
+                                $this->entityManager->create($entitySetting);
                             }
                         } else {
                             if ($this->settingSolver->getValue($entitySetting) === null

Command/MerchantSettingInitCommand.php

+<?php
+
+namespace Lc\CaracoleBundle\Command;
+
+use Lc\SovBundle\Builder\Setting\SettingBuilder;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+
+class MerchantSettingInitCommand extends Command
+{
+    protected static $defaultName = 'setting:merchant:init';
+    protected static $defaultDescription = 'Initialise les MerchantSetting.';
+
+    protected SettingBuilder $settingBuilder;
+
+    public function __construct(string $name = null, SettingBuilder $settingBuilder)
+    {
+        parent::__construct($name);
+        $this->settingBuilder = $settingBuilder;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $this->io = new SymfonyStyle($input, $output);
+        $this->settingBuilder->initMerchantSettings();
+        $this->io->success('Les MerchantSetting ont bien été initialisées.');
+        return Command::SUCCESS;
+    }
+}

Command/SectionSettingInitCommand.php

+<?php
+
+namespace Lc\CaracoleBundle\Command;
+
+use Lc\SovBundle\Builder\Setting\SettingBuilder;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+
+class SectionSettingInitCommand extends Command
+{
+    protected static $defaultName = 'setting:section:init';
+    protected static $defaultDescription = 'Initialise les SectionSetting.';
+
+    protected SettingBuilder $settingBuilder;
+
+    public function __construct(string $name = null, SettingBuilder $settingBuilder)
+    {
+        parent::__construct($name);
+        $this->settingBuilder = $settingBuilder;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $this->io = new SymfonyStyle($input, $output);
+        $this->settingBuilder->initSectionSettings();
+        $this->io->success('Les SectionSetting ont bien été initialisées.');
+        return Command::SUCCESS;
+    }
+}

Controller/ControllerTrait.php

         return $this->get(SectionResolver::class)->getCurrent(true);
     }
 
+    public function getSectionCurrentVisited(): ?SectionInterface
+    {
+        return $this->get(SectionResolver::class)->getCurrent(false, true);
+    }
+
     public function isOutOfSection()
     {
         return $this->get(SectionResolver::class)->isOutOfSection();
         );
     }
 
+    public function getCartCurrentVisited(): OrderShopInterface
+    {
+        return $this->getOrderShopContainer()->getBuilder()->createIfNotExist(
+                $this->getSectionCurrentVisited(),
+                $this->getUserCurrent(),
+                $this->getVisitorCurrent(),
+                true
+        );
+    }
+
     public function getPriceSolver(): PriceSolver
     {
         return $this->get(PriceSolver::class);

Controller/Merchant/SwitchMerchantController.php

 namespace Lc\CaracoleBundle\Controller\Merchant;
 
 use Lc\CaracoleBundle\Container\Merchant\MerchantContainer;
+use Lc\CaracoleBundle\Controller\AbstractController;
 use Lc\CaracoleBundle\Definition\MerchantSettingDefinition;
 use Lc\CaracoleBundle\Form\Merchant\SwitchMerchantFormType;
-use Lc\CaracoleBundle\Repository\Merchant\MerchantRepository;
-use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\Routing\Annotation\Route;
 
             $context = $form->get('context')->getData();
 
             if ($merchant) {
-                $url = $this->get(MerchantContainer::class)->getSettingSolver()->getSettingValue(
+                $url = $this->getSettingValue(
                         $merchant,
                         MerchantSettingDefinition::SETTING_URL
                 );

Controller/User/UserAdminController.php

             foreach ($entity->getActions() as $action){
                 if($action->getName() == ActionDefinition::SWITCH_USER){
                     $sectionDefault = $this->getSectionContainer()->getStore()->setMerchant($this->getMerchantCurrent())->getOneDefault();
-                    $url = $this->generateUrl($this->getParameter('lc_sov.homepage_route'), array('_switch_user' => $entity->getInstance()->getEmail(), 'section'=> $sectionDefault));
+                    dump($sectionDefault);
+                    $url = $this->generateUrl($this->getParameter('lc_sov.homepage_route'), array('_switch_user' => $entity->getInstance()->getEmail(), 'section'=> $sectionDefault->getSlug()));
                     $action->setLinkUrl($url);
                 }
             }

Definition/Field/Product/ProductCategoryFieldDefinition.php

                 'title',
                 'position',
                 'createdAt',
+                'updatedAt',
                 'status',
                 'saleStatus',
                 'isEligibleTicketRestaurant'

Definition/Field/User/UserMerchantFieldDefinition.php

 use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
 use Lc\CaracoleBundle\Context\MerchantContextTrait;
 use Lc\CaracoleBundle\Field\AssociationField;
+use Lc\CaracoleBundle\Field\Filter\User\UserMerchantEmailFilter;
+use Lc\CaracoleBundle\Field\Filter\User\UserMerchantFirstnameFilter;
+use Lc\CaracoleBundle\Field\Filter\User\UserMerchantLastnameFilter;
 use Lc\SovBundle\Definition\Field\AbstractFieldDefinition;
 
 
 
         return [
                 'id'=> IntegerField::new('id')->onlyOnIndex()->setSortable(true),
-                'lastname'=> TextField::new('user.lastname')->setSortable(true),
-                'firstname'=> TextField::new('user.firstname')->setSortable(true),
-                'email'=> TextField::new('user.email')->setSortable(true),
+                'lastname'=> TextField::new('user.lastname')->setSortable(true)
+                    ->setCustomOption('filter_fqcn', UserMerchantLastnameFilter::class),
+                'firstname'=> TextField::new('user.firstname')->setSortable(true)
+                    ->setCustomOption('filter_fqcn', UserMerchantFirstnameFilter::class),
+                'email'=> TextField::new('user.email')->setSortable(true)
+                    ->setCustomOption('filter_fqcn', UserMerchantEmailFilter::class),
                 'credit'=> NumberField::new('credit')->setSortable(true)
                         ->setTemplatePath('@LcSov/adminlte/crud/field/amount.html.twig')
                         ->setCustomOption('appendHtml', '€'),

EventSubscriber/Product/UpdateProductFamilySectionPropertyEventSubscriber.php

+<?php
+
+namespace Lc\CaracoleBundle\EventSubscriber\Product;
+
+use Doctrine\ORM\EntityManagerInterface;
+
+use Lc\CaracoleBundle\Model\Product\ProductFamilySectionPropertyInterface;
+use Lc\SovBundle\Event\EntityManager\EntityManagerEvent;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+
+class UpdateProductFamilySectionPropertyEventSubscriber implements EventSubscriberInterface
+{
+    protected EntityManagerInterface $entityManager;
+
+    public function __construct(EntityManagerInterface $entityManager)
+    {
+        $this->entityManager = $entityManager;
+    }
+
+    public static function getSubscribedEvents()
+    {
+        return [
+                EntityManagerEvent::PRE_CREATE_EVENT => ['processBeforePersistProductFamilySectionInterface'],
+                EntityManagerEvent::PRE_UPDATE_EVENT => ['processBeforePersistProductFamilySectionInterface'],
+        ];
+    }
+
+    public function processBeforePersistProductFamilySectionInterface(EntityManagerEvent $event)
+    {
+        $productFamilySectionProperty = $event->getEntity();
+
+        if($productFamilySectionProperty instanceof ProductFamilySectionPropertyInterface) {
+            $section = $productFamilySectionProperty->getSection();
+            if($productFamilySectionProperty->getStatus() == 1) {
+                $productCategoryArray = $productFamilySectionProperty->getProductFamily()->getProductCategories();
+                foreach($productCategoryArray as $productCategory) {
+                    if($productCategory->getSection() == $section) {
+                        // mise à jour du statut
+                        $productCategory->setStatus(1);
+                        $this->entityManager->update($productCategory);
+
+                        // mise à jour du statut du parent
+                        $productCategoryParent = $productCategory->getParent();
+                        if($productCategoryParent) {
+                            $productCategoryParent->setStatus(1);
+                            $this->entityManager->update($productCategoryParent);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+}

Field/Filter/User/UserMerchantEmailFilter.php

+<?php
+
+namespace Lc\CaracoleBundle\Field\Filter\User;
+
+use EasyCorp\Bundle\EasyAdminBundle\Dto\FieldDto;
+use Lc\SovBundle\Field\Filter\AssociationFilter;
+use Lc\SovBundle\Repository\RepositoryQueryInterface;
+use Symfony\Component\Form\Extension\Core\Type\TextType;
+use Symfony\Component\Form\FormBuilderInterface;
+
+/**
+ * @author La clic ! <contact@laclic.fr>
+ */
+class UserMerchantEmailFilter extends AssociationFilter
+{
+    public function buildProperty(FormBuilderInterface $builder, FieldDto $fieldDto, $options = array())
+    {
+        $builder->add(
+            $this->getFieldPropertySnake($fieldDto->getProperty()),
+            TextType::class,
+            array(
+                    'required' => false,
+                    'attr' => array(
+                            'class' => ' input-sm',
+                            'form' => 'filters-form',
+                    ),
+            )
+        );
+    }
+
+    public function applyFilter(RepositoryQueryInterface $repositoryQuery, FieldDto $fieldDto, $filteredValue = null)
+    {
+        if ($filteredValue !== null) {
+            $repositoryQuery->filterByEmail('%'.$filteredValue.'%');
+        }
+    }
+
+}

Field/Filter/User/UserMerchantFirstnameFilter.php

+<?php
+
+namespace Lc\CaracoleBundle\Field\Filter\User;
+
+use EasyCorp\Bundle\EasyAdminBundle\Dto\FieldDto;
+use Lc\SovBundle\Field\Filter\AssociationFilter;
+use Lc\SovBundle\Repository\RepositoryQueryInterface;
+use Symfony\Component\Form\Extension\Core\Type\TextType;
+use Symfony\Component\Form\FormBuilderInterface;
+
+/**
+ * @author La clic ! <contact@laclic.fr>
+ */
+class UserMerchantFirstnameFilter extends AssociationFilter
+{
+    public function buildProperty(FormBuilderInterface $builder, FieldDto $fieldDto, $options = array())
+    {
+        $builder->add(
+            $this->getFieldPropertySnake($fieldDto->getProperty()),
+            TextType::class,
+            array(
+                    'required' => false,
+                    'attr' => array(
+                            'class' => ' input-sm',
+                            'form' => 'filters-form',
+                    ),
+            )
+        );
+    }
+
+    public function applyFilter(RepositoryQueryInterface $repositoryQuery, FieldDto $fieldDto, $filteredValue = null)
+    {
+        if ($filteredValue !== null) {
+            $repositoryQuery->filterByFirstname('%'.$filteredValue.'%');
+        }
+    }
+
+}

Field/Filter/User/UserMerchantLastnameFilter.php

+<?php
+
+namespace Lc\CaracoleBundle\Field\Filter\User;
+
+use EasyCorp\Bundle\EasyAdminBundle\Dto\FieldDto;
+use Lc\SovBundle\Field\Filter\AssociationFilter;
+use Lc\SovBundle\Field\Filter\FilterTrait;
+use Lc\SovBundle\Repository\RepositoryQueryInterface;
+use Symfony\Component\Form\Extension\Core\Type\TextType;
+use Symfony\Component\Form\FormBuilderInterface;
+
+/**
+ * @author La clic ! <contact@laclic.fr>
+ */
+class UserMerchantLastnameFilter
+{
+    use FilterTrait;
+    public function buildProperty(FormBuilderInterface $builder, FieldDto $fieldDto, $options = array())
+    {
+
+        $builder->add(
+            $this->getFieldPropertySnake($fieldDto->getProperty()),
+            TextType::class,
+            array(
+                    'required' => false,
+                    'attr' => array(
+                            'class' => ' input-sm',
+                            'form' => 'filters-form',
+                    ),
+            )
+        );
+    }
+
+    public function applyFilter(RepositoryQueryInterface $repositoryQuery, FieldDto $fieldDto, $filteredValue = null)
+    {
+        if ($filteredValue !== null) {
+            $repositoryQuery->filterByLastname('%'.$filteredValue.'%');
+        }
+    }
+
+}

Repository/File/DocumentRepositoryQuery.php

 
 class DocumentRepositoryQuery extends AbstractRepositoryQuery
 {
-    use SectionRepositoryQueryTrait;
+    use MerchantRepositoryQueryTrait;
 
     public function __construct(DocumentRepository $repository, PaginatorInterface $paginator)
     {

Repository/File/DocumentStore.php

 
 class DocumentStore extends AbstractStore
 {
-    use SectionStoreTrait;
     use MerchantStoreTrait;
 
     protected DocumentRepositoryQuery $query;
     {
         $query->filterIsOnlineAndOffline();
 
-        if(isset($this->section) && $this->section) {
-            $query->filterBySection($this->section);
-        }
 
         if(isset($this->merchant) && $this->merchant) {
-            $query->filterByMerchantViaSection($this->merchant);
+            $query->filterByMerchant($this->merchant);
         }
 
         return $query;

Repository/Product/ProductFamilyRepositoryQuery.php

 
             $this->leftJoin('.productFamilySectionProperties', 'productFamilySectionProperties');
             if ($addSelect) {
-                $this->addSelect('productFamilySectionProperties');
+                //NB : Ici le select est en commentaire car si il est actif doctrine n'hydrate pas correectement ProductFamilySectionProperties (si filtre sur section les ProductFamilySectionProperties des autres sections ne sont pas chargé et ça peut être problématique pr la gestion des stocks)
+                //$this->addSelect('productFamilySectionProperties');
             }
         }
         return $this;

Repository/StoreTrait.php

 
 trait StoreTrait
 {
-    public function resetContext(): void
+    public function resetContext(): self
     {
         if(method_exists($this, 'setMerchant')) {
             $this->setMerchant(null);
         if(method_exists($this, 'setSection')) {
             $this->setSection(null);
         }
+        return $this;
     }
 }

Repository/User/UserMerchantRepositoryQuery.php

 {
     use MerchantRepositoryQueryTrait;
 
+    protected $isJoinUser = false;
+
+
     public function __construct(UserMerchantRepository $repository, PaginatorInterface $paginator)
     {
         parent::__construct($repository, 'userMerchant', $paginator);
     public function filterByUser(UserInterface $user)
     {
         return $this
-                ->andWhere('.user = :user')
-                ->setParameter('user', $user);
+            ->andWhere('.user = :user')
+            ->setParameter('user', $user);
+    }
+
+    public function joinUser(): self
+    {
+        if (!$this->isJoinUser) {
+            $this->isJoinUser = true;
+
+            return $this
+                ->leftJoin('.user', 'user');
+        }
+        return $this;
+    }
+
+    public function filterByFirstname(string $firstname)
+    {
+        $this->joinUser();
+
+        return $this
+            ->andWhere('user.firstname LIKE :firstname')
+            ->setParameter('firstname', $firstname);
+    }
+
+    public function filterByLastname(string $lastname)
+    {
+        $this->joinUser();
+
+        return $this
+            ->andWhere('user.lastname LIKE :lastname')
+            ->setParameter('lastname', $lastname);
+    }
+
+    public function filterByEmail(string $email)
+    {
+        $this->joinUser();
+
+        return $this
+            ->andWhere('user.email LIKE :email')
+            ->setParameter('email', $email);
     }
 
     public function filterIsCreditActive()

Resolver/SectionResolver.php

 use Lc\CaracoleBundle\Repository\Section\SectionStore;
 use Lc\SovBundle\Resolver\UrlResolver;
 use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
 use Symfony\Component\Security\Core\Security;
 
 class SectionResolver
                 $sectionCurrent = $sectionStore
                         ->setMerchant($merchantCurrent)
                         ->getOneBySlug($requestAttributesArray['section']);
+                if($sectionCurrent===null){
+                    throw new NotFoundHttpException('Aucun espace n\'a été trouvé');
+                }
             }
 
             if ($sectionCurrent) {

Solver/Config/UnitSolver.php

+<?php
+
+namespace Lc\CaracoleBundle\Solver\Config;
+
+
+
+use Lc\CaracoleBundle\Model\Config\UnitInterface;
+
+class UnitSolver
+{
+
+    public function getWeight(UnitInterface $unit, int $quantityProduct, int $quantity){
+        return ($quantityProduct / $unit->getCoefficient()) * $quantity;
+    }
+
+
+}