Refactoring services

Builder/Ticket/TicketBuilder.php

+<?php
+
+namespace Lc\SovBundle\Builder\Ticket;
+
+use Lc\SovBundle\Component\FormComponent;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
+
+class TicketBuilder
+{
+    protected FormComponent $formComponent;
+    protected ParameterBagInterface $parameterBag;
+
+    public function __construct(FormComponent $formComponent, ParameterBagInterface $parameterBag)
+    {
+        $this->formComponent = $formComponent;
+        $this->parameterBag = $parameterBag;
+    }
+
+    // uploadImageTicketMessage
+    public function uploadImageTicketMessage($formTicket)
+    {
+        return $this->formComponent->uploadFile(
+                $formTicket,
+                'image',
+                $this->parameterBag->get('app.ticket_images_directory'),
+                $this->parameterBag->get('app.ticket_images_subdirectory')
+        );
+    }
+}

Builder/User/UserBuilder.php

+<?php
+
+namespace Lc\SovBundle\Builder\User;
+
+use Doctrine\ORM\EntityManagerInterface;
+use Lc\SovBundle\Model\Newsletter\NewsletterInterface;
+use Lc\SovBundle\Model\User\UserInterface;
+
+class UserBuilder
+{
+    protected EntityManagerInterface $entityManager;
+
+    public function __construct(EntityManagerInterface $entityManager)
+    {
+        $this->entityManager = $entityManager;
+    }
+
+    public function setNewsletter(UserInterface $user, NewsletterInterface $newsletter, bool $subscribeNewsletter)
+    {
+        if ($subscribeNewsletter) {
+            $user->addNewsletter($newsletter);
+        } else {
+            $user->removeNewsletter($newsletter);
+        }
+        
+        $this->entityManager->persist($user);
+        $this->entityManager->flush();
+    }
+}

Component/CookieComponent.php

+<?php
+
+namespace Lc\SovBundle\Component;
+
+use Lc\SovBundle\Resolver\UrlResolver;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
+
+class CookieComponent
+{
+    protected UrlResolver $urlResolver;
+    protected ParameterBagInterface $parameterBag;
+
+    public function __construct(UrlResolver $urlResolver, ParameterBagInterface $parameterBag)
+    {
+        $this->urlResolver = $urlResolver;
+        $this->parameterBag = $parameterBag;
+    }
+
+    public function getCookieDomain()
+    {
+        return ($this->urlResolver->isServerLocalhost()) ? null : $this->parameterBag->get('app.cookie_domain_distant');
+    }
+
+    public function cryptCookie($data)
+    {
+        return base64_encode($data);
+    }
+
+    public function decryptCookie($data)
+    {
+        return base64_decode($data);
+    }
+}

Component/EntityComponent.php

+<?php
+
+namespace Lc\SovBundle\Component;
+
+use Doctrine\ORM\EntityManagerInterface;
+use Lc\CaracoleBundle\Model\Product\ProductFamilyInterface;
+use Lc\SovBundle\Doctrine\Extension\SluggableInterface;
+use Lc\SovBundle\Model\File\FileInterface;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
+
+class EntityComponent
+{
+    protected EntityManagerInterface $entityManager;
+    protected ParameterBagInterface $parameterBag;
+
+    public function __construct(
+            EntityManagerInterface $entityManager,
+            ParameterBagInterface $parameterBag
+    ) {
+        $this->entityManager = $entityManager;
+        $this->parameterBag = $parameterBag;
+    }
+
+    public function duplicateEntity($entity, $flush = true)
+    {
+        $newEntity = clone $entity;
+
+        if ($newEntity instanceof FileInterface) {
+            $newEntity = $this->duplicateImage($newEntity);
+        }
+
+        if ($newEntity instanceof ProductFamilyInterface) {
+            // @TODO : à adapter
+            //$newEntity = $this->productFamilyUtils->processBeforePersistProductFamily($newEntity, false, true);
+        }
+
+        if (method_exists($newEntity, 'getAddress') && is_object($newEntity->getAddress())) {
+            $address = $newEntity->getAddress();
+            $newAddress = $this->duplicateEntity($address);
+            $newEntity->setAddress($newAddress);
+            $this->entityManager->persist($newAddress);
+        }
+
+        if ($newEntity instanceof SluggableInterface) {
+            $this->entityManager->persist($newEntity);
+            if ($flush) {
+                $this->entityManager->flush();
+            }
+            $newEntity->setSlug(null);
+        }
+        $this->entityManager->persist($newEntity);
+        if ($flush) {
+            $this->entityManager->flush();
+        }
+
+
+        return $newEntity;
+    }
+
+    public function duplicateEntityToOtherHub($entity, $hub)
+    {
+        $newEntity = $this->duplicateEntity($entity);
+
+        if ($hub) {
+            $newEntity->setMerchant($hub);
+        }
+        $this->entityManager->persist($newEntity);
+        $this->entityManager->flush();
+
+        return $newEntity;
+    }
+
+    public function duplicateImage($entity, $folder = false)
+    {
+        $basePath = $this->parameterBag->get('kernel.project_dir') . '/public/uploads/images/';
+
+        if ($entity->getImage() && file_exists($basePath . $entity->getImage())) {
+            $extension = strtolower(pathinfo($basePath . $entity->getImage(), PATHINFO_EXTENSION));
+
+            if ($extension == "jpg" || $extension == "png" || $extension == "gif") {
+                $newImage = md5(uniqid()) . '.' . $extension;
+                if ($folder) {
+                    $newImage = $folder . '/' . $newImage;
+                }
+                copy($basePath . $entity->getImage(), $basePath . $newImage);
+                $entity->setImage($newImage);
+            } else {
+                $entity->setImage(null);
+            }
+        } else {
+            $entity->setImage(null);
+        }
+        return $entity;
+    }
+}

Component/FormComponent.php

 use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
 use Symfony\Component\Form\Extension\Core\Type\HiddenType;
 use Symfony\Component\Form\FormBuilderInterface;
+use Symfony\Component\HttpFoundation\File\Exception\FileException;
 
 class FormComponent
 {
         ]);
     }
 
+    // uploadImageTicketMessage
+    public function uploadFile($form, $child, $directory, $subdirectory)
+    {
+        $file = $form->get($child)->getData();
+
+        if ($file) {
+            $originalFilename = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME);
+            $newFilename = uniqid().'.'.$file->guessExtension();
+
+            try {
+                $file->move(
+                        $directory,
+                        $newFilename
+                );
+            } catch (FileException $e) {
+                throw new \ErrorException("Une erreur est survenue lors de l'upload du fichier.");
+            }
+
+            return $subdirectory.$newFilename;
+        }
+
+        return false;
+    }
+
 }

Factory/Ticket/TicketFactory.php

 use App\Entity\Ticket\Ticket;
 use Lc\SovBundle\Factory\AbstractFactory;
 use Lc\SovBundle\Model\Ticket\TicketInterface;
+use Lc\SovBundle\Model\Ticket\TicketModel;
 
 class TicketFactory extends AbstractFactory implements TicketFactoryInterface
 {
-
     public function create(): TicketInterface
     {
         $ticket = new Ticket();
 
         $ticketMessageFactory = new TicketMessageFactory();
-        $ticketMessage = $ticketMessageFactory->create() ;
+        $ticketMessage = $ticketMessageFactory->create($ticket) ;
+
+        $ticket->setStatus(TicketModel::TICKET_STATUS_OPEN);
         $ticket->addTicketMessage($ticketMessage) ;
 
         return $ticket;
     }
-
 }

Factory/Ticket/TicketMessageFactory.php

 
 use App\Entity\Ticket\TicketMessage;
 use Lc\SovBundle\Factory\AbstractFactory;
+use Lc\SovBundle\Model\Ticket\TicketInterface;
 use Lc\SovBundle\Model\Ticket\TicketMessageInterface;
 
 class TicketMessageFactory extends AbstractFactory implements TicketMessageFactoryInterface
 {
-    public function create(): TicketMessageInterface
+    public function create(TicketInterface $ticket): TicketMessageInterface
     {
         $ticketMessage = new TicketMessage();
 
+        $ticketMessage->setTicket($ticket);
         $ticketMessage->setStatus(1);
 
         return $ticketMessage;

Model/User/User.php

 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
 use Lc\SovBundle\Doctrine\EntityInterface;
+use Lc\SovBundle\Model\Newsletter\NewsletterInterface;
 use Symfony\Component\Security\Core\User\UserInterface;
 
 /**
      */
     protected $groupUsers;
 
+    // isUserInGroupVip
+    public function isInGroupUserVip()
+    {
+        return $this->isInGroupByDevAlias('vip') ;
+    }
+
+    // isUserInGroup
+    public function isInGroupUser(GroupUserInterface $groupUser)
+    {
+        return $this->isInGroupByDevAlias($groupUser->getDevAlias());
+    }
+
+    // isUserInGroupByDevAlias
+    public function isInGroupByDevAlias(string $groupUserDevAlias)
+    {
+        $groupUsers = $this->getGroupUsers();
+
+        foreach($groupUsers as $groupUser) {
+            if($groupUser->getDevAlias() == $groupUserDevAlias) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function isSubscribedToNewsletter(NewsletterInterface $newsletter)
+    {
+        return $this->getNewsletters()->contains($newsletter);
+    }
+
     public function getEmail(): ?string
     {
         return $this->email;

Repository/Ticket/TicketRepositoryQuery.php

 namespace Lc\SovBundle\Repository\Ticket;
 
 use Knp\Component\Pager\PaginatorInterface;
+use Lc\SovBundle\Model\User\UserInterface;
 use Lc\SovBundle\Repository\AbstractRepositoryQuery;
 
 class TicketRepositoryQuery extends AbstractRepositoryQuery implements TicketRepositoryQueryInterface
     {
         parent::__construct($repository, 'r', $paginator);
     }
+
+    public function filterByUser(UserInterface $user)
+    {
+        return $this
+                ->andWhere('.user = :user')
+                ->setParameter('user', $user);
+    }
 }

Repository/Ticket/TicketStore.php

     {
         $this->query = $query;
     }
+
+    // getTicketsByUser
+    public function getByUser($user)
+    {
+        $query = $this->query->create();
+
+        $query->filterByUser($user);
+
+        return $query->find();
+    }
 }

Repository/User/UserStore.php

 
 namespace Lc\SovBundle\Repository\User;
 
+use Lc\SovBundle\Model\User\UserInterface;
 use Lc\SovBundle\Repository\AbstractStore;
 
 class UserStore extends AbstractStore implements UserStoreInterface

Resolver/UrlResolver.php

         return in_array($_SERVER['REMOTE_ADDR'], ['127.0.0.1', '::1']);
     }
 
-    public function getCookieDomain()
-    {
-        return ($this->isServerLocalhost()) ? null : $this->parameterBag->get('app.cookie_domain_distant');
-    }
-
     public function isBot()
     {
         if (isset($_SERVER['HTTP_USER_AGENT']) && preg_match(