Refactoring services

Container/Setting/SiteSettingContainer.php

 use Lc\SovBundle\Factory\Setting\SiteSettingFactory;
 use Lc\SovBundle\Repository\Setting\SiteSettingRepositoryQuery;
 use Lc\SovBundle\Repository\Setting\SiteSettingStore;
+use Lc\SovBundle\Solver\Setting\SettingSolver;
 
 class SiteSettingContainer
 {
     protected SiteSettingDefinition $definition;
     protected SiteSettingRepositoryQuery $repositoryQuery;
     protected SiteSettingStore $store;
+    protected SettingSolver $settingSolver;
 
     public function __construct(
             SiteSettingFactory $factory,
             SiteSettingDefinition $definition,
             SiteSettingRepositoryQuery $repositoryQuery,
-            SiteSettingStore $store
+            SiteSettingStore $store,
+            SettingSolver $settingSolver
     ) {
         $this->factory = $factory;
         $this->definition = $definition;
         $this->repositoryQuery = $repositoryQuery;
         $this->store = $store;
+        $this->settingSolver = $settingSolver;
     }
 
     public function getFactory(): SiteSettingFactory
     {
         return $this->store;
     }
+
+    public function getSettingSolver(): SettingSolver
+    {
+        return $this->settingSolver;
+    }
 }

Container/Ticket/TicketContainer.php

 use Lc\SovBundle\Factory\Ticket\TicketFactory;
 use Lc\SovBundle\Repository\Ticket\TicketRepositoryQuery;
 use Lc\SovBundle\Repository\Ticket\TicketStore;
+use Lc\SovBundle\Solver\Ticket\TicketSolver;
 
 class TicketContainer
 {
     protected TicketBuilder $builder;
     protected TicketRepositoryQuery $repositoryQuery;
     protected TicketStore $store;
+    protected TicketSolver $solver;
 
     public function __construct(
             TicketFactory $factory,
             TicketBuilder $builder,
             TicketRepositoryQuery $repositoryQuery,
-            TicketStore $store
+            TicketStore $store,
+            TicketSolver $solver
     ) {
         $this->factory = $factory;
         $this->builder = $builder;
         $this->repositoryQuery = $repositoryQuery;
         $this->store = $store;
+        $this->solver = $solver;
     }
 
     public function getFactory(): TicketFactory
     {
         return $this->store;
     }
+
+    public function getSolver(): TicketSolver
+    {
+        return $this->solver;
+    }
 }

Controller/AbstractAdminController.php

                         RequestStack::class => RequestStack::class,
                         EntityManagerInterface::class => EntityManagerInterface::class,
                         FilterManager::class => FilterManager::class,
-
                         FileContainer::class => FileContainer::class,
                         NewsletterContainer::class => NewsletterContainer::class,
                         ReminderContainer::class => ReminderContainer::class,
         $context = $this->get(AdminContextProvider::class)->getContext();
 
         return $context->getCrudControllers()->findCrudFqcnByEntityFqcn(
-                $this->get('em')->getEntityName($interface)
+                $this->get(EntityManagerInterface::class)->getEntityName($interface)
         );
     }
 

Controller/Setting/SettingAdminController.php

 
 class SettingAdminController extends AbstractController
 {
+    protected EntityManagerInterface $entityManager;
+
+    public function __construct(EntityManagerInterface $entityManager)
+    {
+        $this->entityManager = $entityManager;
+    }
 
     /**
      * @Route("/admin/setting/site", name="sov_admin_setting_site")

Controller/Ticket/TicketAdminController.php

             ChoiceField::new('type')
                 ->autocomplete()
                 ->setChoices(
-                    $translatorAdmin->transChoices(TicketModel::getTypeChoices(), 'Ticket', 'type')
+                    $translatorAdmin->transChoices($this->get(TicketContainer::class)->getSolver()->getTypeChoices(), 'Ticket', 'type')
                 ),
             ChoiceField::new('status')
                 ->autocomplete()
                 ->setChoices(
-                        $translatorAdmin->transChoices(TicketModel::getStatusChoices(), 'Ticket', 'status')
+                        $translatorAdmin->transChoices($this->get(TicketContainer::class)->getSolver()->getStatusChoices(), 'Ticket', 'status')
 
                 )
                 ->setTemplatePath('@LcSov/admin/ticket/field/status.html.twig')

EventSubscriber/SiteSettingEventSubscriber.php

 use Lc\SovBundle\Factory\Site\SiteFactory;
 use Lc\SovBundle\Repository\Setting\SiteSettingRepository;
 use Lc\SovBundle\Repository\Site\SiteRepository;
+use Lc\SovBundle\Repository\Site\SiteStore;
+use Lc\SovBundle\Solver\Setting\SettingSolver;
 use Symfony\Component\EventDispatcher\EventSubscriberInterface;
 use Symfony\Component\HttpKernel\KernelEvents;
 
 class SiteSettingEventSubscriber implements EventSubscriberInterface
 {
-    protected $em;
-    protected $siteSettingDefinition;
-    protected $siteSettingFactory;
-    protected $siteSettingRepository;
-    protected $siteRepository;
-    protected $siteFactory;
+    protected EntityManagerInterface $entityManager;
+    protected SiteSettingDefinitionInterface $siteSettingDefinition;
+    protected SiteSettingFactory $siteSettingFactory;
+    protected SiteSettingRepository $siteSettingRepository;
+    protected SiteStore $siteStore;
+    protected SiteFactory $siteFactory;
+    protected SettingSolver $settingSolver;
 
     public function __construct(
-            EntityManagerInterface $em,
+            EntityManagerInterface $entityManager,
             SiteSettingRepository $siteSettingRepository,
-            SiteRepository $siteRepository,
+            SiteStore $siteStore,
             SiteSettingDefinitionInterface $siteSettingDefinition,
             SiteSettingFactory $siteSettingFactory,
-            SiteFactory $siteFactory
+            SiteFactory $siteFactory,
+            SettingSolver $settingSolver
     ) {
-        $this->em = $em;
+        $this->entityManager = $entityManager;
         $this->siteSettingDefinition = $siteSettingDefinition;
         $this->siteSettingFactory = $siteSettingFactory;
         $this->siteSettingRepository = $siteSettingRepository;
-        $this->siteRepository = $siteRepository;
+        $this->siteStore = $siteStore;
         $this->siteFactory = $siteFactory;
+        $this->settingSolver = $settingSolver;
     }
 
     public static function getSubscribedEvents()
         $site = $this->getSiteDefault();
         if (!$site) {
             $site = $this->siteFactory->create('default');
-            $this->em->persist($site);
-            $this->em->flush($site);
+            $this->entityManager->persist($site);
+            $this->entityManager->flush($site);
         }
 
         $settings = $this->siteSettingDefinition->getSettings();
 
         foreach ($settings as $category => $settingList) {
             foreach ($settingList as $settingName => $setting) {
-                $entitySetting = $site->getSetting($settingName);
+                $entitySetting = $this->settingSolver->getSetting($site, $settingName);
 
                 if (!$entitySetting) {
 
 
                     $entitySetting = $factory->create($site, $setting['name'], $text, $date, $file);
 
-                    $this->em->persist($entitySetting);
+                    $this->entityManager->persist($entitySetting);
                 } else {
                     $methodGetValue = 'get' . ucfirst($setting['field']);
                     if ($entitySetting->$methodGetValue() === null
                             && $setting['default'] !== null) {
                         $methodSetValue = 'set' . ucfirst($setting['field']);
                         $entitySetting->$methodSetValue($setting['default']);
-                        $this->em->update($entitySetting);
+                        $this->entityManager->update($entitySetting);
                     }
                 }
             }
         }
 
-        $this->em->flush();
+        $this->entityManager->flush();
     }
 
     public function getSiteDefault()
     {
-        return $this->siteRepository->findOneByDevAlias('default');
+        return $this->siteStore->getOneByDevAlias('default');
     }
 
 }

Model/Setting/EntitySettingTrait.php

-<?php
-
-namespace Lc\SovBundle\Model\Setting;
-
-//TODO à déplacer dans un solver
-
-trait EntitySettingTrait
-{
-    public function getSetting($name): ?SettingModel
-    {
-        if ($this->getSettings()) {
-            foreach ($this->getSettings() as $setting) {
-                if ($setting->getName() == $name) {
-                    return $setting;
-                }
-            }
-        }
-
-        return null;
-    }
-
-    public function getSettingValue($name): ?string
-    {
-        if ($this->getSettings()) {
-            foreach ($this->getSettings() as $setting) {
-                if ($setting->getName() == $name) {
-                    return $setting->getValue();
-                }
-            }
-        }
-
-        return null;
-    }
-
-}

Model/Site/NewsModel.php

 
 
     /**
-     * @ORM\ManyToOne(targetEntity="Lc\SovBundle\Newsletter\NewsletterInsterface", inversedBy="news")
+     * @ORM\ManyToOne(targetEntity="Lc\SovBundle\Model\Newsletter\NewsletterInterface", inversedBy="news")
      */
     protected $newsletter;
 
     /**
-     * @ORM\ManyToOne(targetEntity="Lc\SovBundle\File\FileInsterface", cascade={"persist", "remove"})
+     * @ORM\ManyToOne(targetEntity="Lc\SovBundle\Model\File\FileInterface", cascade={"persist", "remove"})
      */
     protected $image;
 

Model/Site/SiteModel.php

 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\SovBundle\Model\Setting\EntitySettingTrait;
 use Lc\SovBundle\Model\Setting\SiteSettingInterface;
 use Lc\SovBundle\Doctrine\EntityInterface;
 use Lc\SovBundle\Doctrine\Extension\DevAliasInterface;
 
 abstract class SiteModel implements SiteInterface, EntityInterface, DevAliasInterface
 {
-    use EntitySettingTrait;
     use DevAliasTrait;
 
     /**

Repository/AbstractStore.php

         return $query->findOne();
     }
 
-    public function getOneByDevAlias(string $devAlias, bool $isOnline = true, $query = null)
+    public function getOneByDevAlias(string $devAlias, $query = null)
     {
         $query = $this->createDefaultQuery($query);
         $query->filterByDevAlias($devAlias);
+        return $query->findOne();
+    }
 
-        if ($isOnline) {
-            $query->filterIsOnline();
-        }
+    public function getOneOnlineByDevAlias(string $devAlias, $query = null)
+    {
+        $query = $this->createDefaultQuery($query);
+        $query
+                ->filterByDevAlias($devAlias)
+                ->filterIsOnline();
 
         return $query->findOne();
     }

Repository/StoreInterface.php

 
     public function getOneBySlug(string $slug, bool $isOnline = true, $query = null);
 
-    public function getOneByDevAlias(string $devAlias, bool $isOnline = true, $query = null);
+    public function getOneByDevAlias(string $devAlias, $query = null);
 
     public function get($query = null);
 

Solver/Setting/SettingSolver.php

 
 namespace Lc\SovBundle\Solver\Setting;
 
+use Lc\SovBundle\Doctrine\EntityInterface;
 use Lc\SovBundle\Model\Setting\SettingInterface;
-use Lc\SovBundle\Model\Ticket\TicketInterface;
-use Lc\SovBundle\Model\Ticket\TicketModel;
+use Lc\SovBundle\Model\Setting\SettingModel;
 
 class SettingSolver
 {
-    public function getValue(SettingInterface $setting)
+    public function getSetting(EntityInterface $entity, string $name): ?SettingModel
+    {
+        if ($entity->getSettings()) {
+            foreach ($entity->getSettings() as $setting) {
+                if ($setting->getName() == $name) {
+                    return $setting;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public function getSettingValue(EntityInterface $entity, string $name): ?string
+    {
+        $setting = $this->getSetting($entity, $name);
+
+        if($setting) {
+            return $this->getValue($setting);
+        }
+
+        return null;
+    }
+
+    public function getValue(SettingInterface $setting): ?string
     {
         if ($setting->getText()) {
             return $setting->getText();
         } elseif ($setting->getFile()) {
             return $setting->getFile();
         }
+
+        return null;
     }
 }