Refactoring services

Builder/Ticket/TicketBuilder.php

     }
 
     // uploadImageTicketMessage
-    public function uploadImageTicketMessage($formTicket)
+    public function uploadImageTicketMessage($formTicket): ?string
     {
         return $this->formComponent->uploadFile(
                 $formTicket,

Builder/User/UserBuilder.php

         $this->entityManager = $entityManager;
     }
 
-    public function setNewsletter(UserInterface $user, NewsletterInterface $newsletter, bool $subscribeNewsletter)
+    public function setNewsletter(UserInterface $user, NewsletterInterface $newsletter, bool $subscribeNewsletter): void
     {
         if ($subscribeNewsletter) {
             $user->addNewsletter($newsletter);

Component/FormComponent.php

     }
 
     // uploadImageTicketMessage
-    public function uploadFile($form, $child, $directory, $subdirectory)
+    public function uploadFile($form, $child, $directory, $subdirectory): ?string
     {
         $file = $form->get($child)->getData();
 

Controller/AbstractAdminController.php

 use Symfony\Component\Form\Extension\Core\Type\DateType;
 use Symfony\Component\Form\Extension\Core\Type\IntegerType;
 use Symfony\Component\Form\Extension\Core\Type\TextType;
+use Symfony\Component\Form\FormInterface;
 use Symfony\Component\HttpFoundation\JsonResponse;
 use Symfony\Component\HttpFoundation\RequestStack;
 use Symfony\Component\HttpFoundation\Session\SessionInterface;
 
 abstract class AbstractAdminController extends EaAbstractCrudController
 {
-    protected $filtersForm;
+    protected FormInterface $filtersForm;
 
     public static function getSubscribedServices()
     {
         return array_merge(
                 parent::getSubscribedServices(),
                 [
-                        'session' => SessionInterface::class,
-                        'request' => RequestStack::class,
-                        'em' => EntityManagerInterface::class,
-                        'translator_admin' => TranslatorAdmin::class,
-                        'filter_manager' => FilterManager::class,
+                        SessionInterface::class => SessionInterface::class,
+                        RequestStack::class => RequestStack::class,
+                        EntityManagerInterface::class => EntityManagerInterface::class,
+                        TranslatorAdmin::class => TranslatorAdmin::class,
+                        FilterManager::class => FilterManager::class,
 
                         FileContainer::class => FileContainer::class,
                         NewsletterContainer::class => NewsletterContainer::class,

Controller/Newsletter/NewsletterAdminController.php

 
 use EasyCorp\Bundle\EasyAdminBundle\Field\FormField;
 use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
+use Lc\SovBundle\Container\Newsletter\NewsletterContainer;
 use Lc\SovBundle\Controller\AbstractAdminController;
 use Lc\SovBundle\Factory\Newsletter\NewsletterFactory;
 use Lc\SovBundle\Field\BooleanField;
 
     public function createEntity(string $entityFqcn)
     {
-        $factory = new NewsletterFactory();
-        return $factory->create();
+        return $this->get(NewsletterContainer::class)->getFactory()->create();
     }
 
 }

Controller/Reminder/ReminderAdminController.php

 namespace Lc\SovBundle\Controller\Reminder;
 
 use Doctrine\ORM\EntityManagerInterface;
+use Lc\CaracoleBundle\Resolver\MerchantResolver;
+use Lc\CaracoleBundle\Resolver\SectionResolver;
+use Lc\SovBundle\Container\Reminder\ReminderContainer;
 use Lc\SovBundle\Factory\Reminder\ReminderFactory;
-use Lc\SovBundle\Factory\Reminder\ReminderFactoryInterface;
 use Lc\SovBundle\Form\Reminder\ReminderAdminFormType;
-use Lc\SovBundle\Repository\Reminder\ReminderRepositoryQueryInterface;
 use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
 use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
 use Symfony\Component\Form\FormFactoryInterface;
 {
 
     protected EntityManagerInterface $entityManager;
-    protected ReminderRepositoryQueryInterface $reminderRepositoryQuery;
+    protected ReminderContainer $reminderContainer;
     protected FormFactoryInterface $formFactory;
     protected UrlGeneratorInterface $urlGenerator;
     protected MerchantResolver $merchantResolver;
 
     public function __construct(
             EntityManagerInterface $entityManager,
-            ReminderRepositoryQueryInterface $reminderRepositoryQuery,
+            ReminderContainer $reminderContainer,
             FormFactoryInterface $formFactory,
             UrlGeneratorInterface $urlGenerator,
             ParameterBagInterface $parameterBag
     ) {
         $this->entityManager = $entityManager;
-        $this->reminderRepositoryQuery = $reminderRepositoryQuery;
+        $this->reminderContainer = $reminderContainer;
         $this->formFactory = $formFactory;
         $this->urlGenerator = $urlGenerator;
         $this->parameterBag = $parameterBag;
         $id = $request->get('id');
 
         if($id) {
-            $reminder = $this->reminderRepositoryQuery->getRepository()->find($id);
+            $reminder = $this->reminderContainer->getRepositoryQuery()->getRepository()->find($id);
             $action = $this->urlGenerator->generate(
                     $this->parameterBag->get('app.reminder.route_edit'),
                     ['id' => $id]
     public function edit(Request $request)
     {
         $id = $request->get('id');
-        $reminder = $this->reminderRepositoryQuery->getRepository()->find($id);
+        $reminder = $this->reminderContainer->getRepositoryQuery()->getRepository()->find($id);
 
         $form = $this->formFactory->create(ReminderAdminFormType::class, $reminder);
         $form->handleRequest($request);
     public function done(Request $request): JsonResponse
     {
         $id = $request->get('id');
-        $reminder = $this->reminderRepositoryQuery->getRepository()->find($id);
+        $reminder = $this->reminderContainer->getRepositoryQuery()->getRepository()->find($id);
         $done = $request->get('done');
 
         if($done == 'true') {

Controller/Setting/SettingAdminController.php

 namespace Lc\SovBundle\Controller\Setting;
 
 use Doctrine\ORM\EntityManagerInterface;
+use Lc\SovBundle\Container\Setting\SiteSettingContainer;
+use Lc\SovBundle\Container\Site\SiteContainer;
 use Lc\SovBundle\Definition\SiteSettingDefinitionInterface;
 use Lc\SovBundle\Form\Setting\SiteSettingsFormType;
 use Lc\SovBundle\Repository\Setting\SiteSettingRepository;
 
 class SettingAdminController extends AbstractController
 {
-    protected $em;
-    protected $translatorAdmin;
-    protected $siteSettingRepository;
-    protected $siteSettingDefinition;
-    protected $siteRepository;
+    protected EntityManagerInterface $entityManager;
+    protected TranslatorAdmin $translatorAdmin;
+    protected SiteSettingContainer $siteSettingContainer;
+    protected SiteContainer $siteContainer;
 
     public function __construct(
-            EntityManagerInterface $em,
+            EntityManagerInterface $entityManager,
             TranslatorAdmin $translatorAdmin,
-            SiteSettingRepository $siteSettingRepository,
-            SiteSettingDefinitionInterface $siteSettingDefinition,
-            SiteRepository $siteRepository
+            SiteSettingContainer $siteSettingContainer,
+            SiteContainer $siteContainer
     ) {
-        $this->em = $em;
+        $this->entityManager = $entityManager;
         $this->translatorAdmin = $translatorAdmin;
-        $this->siteSettingRepository = $siteSettingRepository;
-        $this->siteSettingDefinition = $siteSettingDefinition;
-        $this->siteRepository = $siteRepository;
+        $this->siteSettingContainer = $siteSettingContainer;
+        $this->siteContainer = $siteContainer;
     }
 
     /**
      */
     public function manageGlobal(Request $request)
     {
-        $site = $this->siteRepository->findOneByDevAlias('default') ;
+        $site = $this->siteContainer->getRepositoryQuery()->getRepository()->findOneByDevAlias('default') ;
         $form = $this->createForm(SiteSettingsFormType::class, $site);
 
         $form->handleRequest($request);
 
         if ($form->isSubmitted() && $form->isValid()) {
 
-            $this->em->update($site);
-            $this->em->flush();
+            $this->entityManager->update($site);
+            $this->entityManager->flush();
 
             $this->addFlash('success', $this->translatorAdmin->transFlashMessage('settings_saved'));
         }
         return $this->render(
                 '@LcSov/admin/setting/edit_site.html.twig' ,
                 [
-                        'setting_definition' => $this->siteSettingDefinition,
+                        'setting_definition' => $this->siteSettingContainer->getDefinition(),
                         'form' => $form->createView()
                 ]
         );

Controller/Site/NewsAdminController.php

 use EasyCorp\Bundle\EasyAdminBundle\Field\FormField;
 use EasyCorp\Bundle\EasyAdminBundle\Field\NumberField;
 use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
+use Lc\SovBundle\Container\Site\NewsContainer;
 use Lc\SovBundle\Controller\AbstractAdminController;
 use Lc\SovBundle\Factory\Site\NewsFactory;
 use Lc\SovBundle\Field\CKEditorField;
 
     public function createEntity(string $entityFqcn)
     {
-        $factory = new NewsFactory();
-        return $factory->create();
+        return $this->get(NewsContainer::class)->getFactory()->create();
     }
 }

Controller/Site/PageAdminController.php

 use EasyCorp\Bundle\EasyAdminBundle\Field\FormField;
 use EasyCorp\Bundle\EasyAdminBundle\Field\NumberField;
 use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
+use Lc\SovBundle\Container\Site\PageContainer;
 use Lc\SovBundle\Controller\AbstractAdminController;
 use Lc\SovBundle\Factory\Site\PageFactory;
 use Lc\SovBundle\Field\CKEditorField;
 
     public function createEntity(string $entityFqcn)
     {
-        $factory = new PageFactory();
-        return $factory->create();
+        return $this->get(PageContainer::class)->getFactory()->create();
     }
 
 }

Controller/Ticket/TicketAdminController.php

 
 namespace Lc\SovBundle\Controller\Ticket;
 
+use Doctrine\ORM\EntityManagerInterface;
 use EasyCorp\Bundle\EasyAdminBundle\Config\Action;
 use EasyCorp\Bundle\EasyAdminBundle\Config\Actions;
 use EasyCorp\Bundle\EasyAdminBundle\Config\Assets;
 use EasyCorp\Bundle\EasyAdminBundle\Field\IntegerField;
 use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
 use EasyCorp\Bundle\EasyAdminBundle\Router\AdminUrlGenerator;
+use Lc\SovBundle\Container\Ticket\TicketContainer;
 use Lc\SovBundle\Factory\Ticket\TicketFactory;
 use Lc\SovBundle\Factory\Ticket\TicketFactoryInterface;
 use Lc\SovBundle\Factory\Ticket\TicketMessageFactory;
 use Lc\SovBundle\Model\Ticket\TicketModel;
 use Lc\SovBundle\Translation\TranslatorAdmin;
 use Symfony\Component\HttpFoundation\JsonResponse;
+use Symfony\Component\HttpFoundation\RequestStack;
 
 class TicketAdminController extends AbstractAdminController
 {
 
     public function createEntity(string $entityFqcn)
     {
-        $factory = new TicketFactory();
-        return $factory->create();
+        return $this->get(TicketContainer::class)->getFactory()->create();
     }
 
     public function configureAssets(Assets $assets): Assets
         if ($form->isSubmitted() && $form->isValid()) {
             $ticket = $form->getData();
 
-            $this->get('em')->persist($ticket);
-            $this->get('em')->flush();
+            $this->get(EntityManagerInterface::class)->create($ticket);
+            $this->get(EntityManagerInterface::class)->flush();
 
             $url = $adminUrlGenerator
                 ->setAction('index')
             ]
         );
 
-        $ticketMessageFactory = new TicketMessageFactory();
-        $ticketMessage = $ticketMessageFactory->create();
+        $ticketMessage = $this->get(TicketContainer::class)->getFactory()->create();
         $formAddTicketMessage = $this->createForm(TicketMessageFormType::class, $ticketMessage);
-        $formAddTicketMessage->handleRequest($this->get('request')->getMasterRequest());
+        $formAddTicketMessage->handleRequest($this->get(RequestStack::class)->getMainRequest());
 
         if ($formAddTicketMessage->isSubmitted() && $formAddTicketMessage->isValid()) {
             $ticketMessage = $formAddTicketMessage->getData();
             $ticketMessage->setTicket($ticket);
             $ticketMessage->setAnswerByAdmin(true);
-            $this->get('em')->persist($ticketMessage);
-            $this->get('em')->flush();
+            $this->get(EntityManagerInterface::class)->create($ticketMessage);
+            $this->get(EntityManagerInterface::class)->flush();
         }
 
         return $this->render(

Controller/User/AccountAdminController.php

 
 namespace Lc\SovBundle\Controller\User;
 
+use Doctrine\ORM\EntityManagerInterface;
 use Lc\SovBundle\Doctrine\EntityManager;
 use Lc\SovBundle\Form\User\ChangePasswordFormType;
 use Lc\SovBundle\Form\User\ProfileFormType;
 
 class AccountAdminController extends AbstractController
 {
-    protected $em;
+    protected EntityManagerInterface $entityManager;
 
-    public function __construct(EntityManager $em)
+    public function __construct(EntityManagerInterface $entityManager)
     {
-        $this->em = $em;
+        $this->entityManager = $entityManager;
     }
 
     /**
         if ($form->isSubmitted() && $form->isValid()) {
             $user = $form->getData();
 
-            $this->em->update($user);
-            $this->em->flush();
+            $this->entityManager->update($user);
+            $this->entityManager->flush();
 
             $this->addFlash('success', new TranslatableMessage('form.account_profile.message.success', [], 'admin'));
         }
 
             $user->setPassword($passwordEncoder->encodePassword($user, $plainPassword));
 
-            $this->em->update($user);
-            $this->em->flush();
+            $this->entityManager->update($user);
+            $this->entityManager->flush();
 
             $this->addFlash('success', new TranslatableMessage('form.account_password.message.success', [], 'admin'));
         }

Controller/User/GroupUserAdminController.php

 namespace Lc\SovBundle\Controller\User;
 
 use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
+use Lc\SovBundle\Container\User\GroupUserContainer;
 use Lc\SovBundle\Controller\AbstractAdminController;
 use Lc\SovBundle\Factory\User\GroupUserFactory;
 
 
     public function createEntity(string $entityFqcn)
     {
-        $factory = new GroupUserFactory();
-        return $factory->create();
+        return $this->get(GroupUserContainer::class)->getFactory()->create();
     }
 }

Controller/User/UserAdminController.php

 use EasyCorp\Bundle\EasyAdminBundle\Field\ChoiceField;
 use EasyCorp\Bundle\EasyAdminBundle\Field\EmailField;
 use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
+use Lc\SovBundle\Container\User\UserContainer;
 use Lc\SovBundle\Controller\AbstractAdminController;
 use Lc\SovBundle\Definition\RolesDefinition;
 use Lc\SovBundle\Definition\RolesDefinitionInterface;
 
 abstract class UserAdminController extends AbstractAdminController
 {
-    protected $rolesDefinition;
+    protected RolesDefinitionInterface $rolesDefinition;
 
     public function __construct(
             SessionInterface $session,
 
     public function createEntity(string $entityFqcn)
     {
-        $factory = new UserFactory();
-        return $factory->create();
+        return $this->get(UserContainer::class)->getFactory()->create();
     }
 }

Repository/Site/NewsStore.php

         $this->query = $query;
     }
 
-//findLatests
+    //findLatests
     public function getLatests(int $maxResults = 0, $query = null): array
     {
         if (is_null($query)) {
 
         return $query->find();
     }
-
-    public function findLatests($maxResults = 0)
-    {
-        $result = $this->findByMerchantQuery()
-            ->orderBy('e.date', 'DESC');
-
-        $result->andWhere('e.status = 1');
-
-        if ($maxResults) {
-            $result->setMaxResults($maxResults);
-        }
-
-        return $result->getQuery()->getResult();
-    }
 }

Repository/Site/PageStore.php

         $this->query = $query;
     }
 
-//findPageBySlug
+    //findPageBySlug
     public function getBySlug(string $slug): ?PageInterface
     {
         $query = $this->query->create();

Repository/Ticket/TicketStore.php

         return $query->find();
     }
 
-//    findAllOpen
-    public function getAllOpen(int $limit = 0, $query = null): array
+    // findAllOpen
+    public function getOpen(int $limit = 0, $query = null): array
     {
         if (is_null($query)) {
             $query = $this->query->create();
         return $query->find();
     }
 
-//countAllOpen
-    public function countAllOpen($query = null): string
+    // countAllOpen
+    public function countOpen($query = null): string
     {
         if (is_null($query)) {
             $query = $this->query->create();

Repository/User/UserRepository.php

         }
 
         $user->setPassword($newEncodedPassword);
-        $this->_em->persist($user);
+        $this->_em->update($user);
         $this->_em->flush();
     }
 

Repository/User/UserRepositoryQuery.php

             ->setParameter('newsletter', $newsletter->getId());
     }
 
-    public function filterLikeRole(string $role): self
+    public function filterByRole(string $role): self
     {
         return $this
             ->andWhere('.roles LIKE :roles')
             ->setParameter('roles', '%"' . $role . '"%');
     }
 
-    public function filterLikeTicketTypeNotification(string $ticketType): self
+    public function filterByTicketTypeNotification(string $ticketType): self
     {
         return $this
             ->andWhere('.ticketTypesNotification LIKE :ticketType')

Repository/User/UserStore.php

     {
         $query = $this->query->create();
         $query
-            ->filterLikeRole($role);
+            ->filterByRole($role);
 
         return $query->find();
     }
     {
         $query = $this->query->create();
         $query
-            ->filterLikeTicketTypeNotification($ticketType);
+            ->filterByTicketTypeNotification($ticketType);
 
         return $query->find();
     }

Resolver/UrlResolver.php

         $this->parameterBag = $parameterBag;
     }
 
-    public function isServerLocalhost()
+    public function isServerLocalhost(): bool
     {
         return in_array($_SERVER['REMOTE_ADDR'], ['127.0.0.1', '::1']);
     }
 
-    public function isBot()
+    public function isBot(): bool
     {
         if (isset($_SERVER['HTTP_USER_AGENT']) && preg_match(
                         '/bot|crawl|slurp|spider/i',

Translation/TranslatorAdmin.php

 
 class TranslatorAdmin
 {
-    protected $translator;
+    protected TranslatorInterface $translator;
 
     const DOMAIN = 'admin';
 
         $this->translator = $translator;
     }
 
-    public function transAction($action)
+    public function transAction($action): string
     {
         return $this->trans('action.' . $action);
     }
 
-    public function transMenu($menu)
+    public function transMenu($menu): string
     {
         return $this->trans('menu.' . $menu);
     }
 
-    public function transFlashMessage($name,  $params = [])
+    public function transFlashMessage($name,  $params = []): string
     {
         return $this->trans('flash_message.' . $name, $params);
     }
         );
     }
 
-    public function transTitle($pageName, $entityClass = null, $params = [])
+    public function transTitle($pageName, $entityClass = null, $params = []): string
     {
         $entityName = $this->getEntityName($entityClass);