BGC-192 @fixed image des sequences

assets/exclusive/js/back-office/learning_path/learning_path_editor.js

@@ -1188,9 +1188,10 @@ function showFormEditSequenceItem(action, sequenceItem) {
 
         // Dévérouillage de la page
         $(document).phxUnlock();
-        
-        // Envoi event pour informer que le formulaire est affiché
-        sequenceItem.trigger("logiprolearningpathsequenceformopen");
+        if (sequenceItem)
+        {
+            sequenceItem.trigger("logiprolearningpathsequenceformopen");
+        }
     });
 }
 

config/services.yaml

@@ -120,11 +120,6 @@ services:
     tags:
         - { name: twig.extension }
 
-  # Service de duplication des entités
-  Logipro\Phoenix\Service\EntityDuplicator:
-    public: true
-    arguments: ['@service_container']
-
   Logipro\Phoenix\EntityListener\ImageListener:
 
   phoenix.bundle.learningpath:

src/Phoenix/Service/EntityDuplicator.php

@@ -9,36 +9,40 @@ use Logipro\Phoenix\Entity\SequenceItem\ActivityPackage;
 use Logipro\Phoenix\Entity\SequenceItem\SequenceItem;
 use Logipro\Phoenix\Exception\PhoenixException;
 use Logipro\Phoenix\Package\Common\AbstractPackageFile;
-use Symfony\Component\DependencyInjection\ContainerAwareInterface;
-use Symfony\Component\DependencyInjection\ContainerAwareTrait;
-use Symfony\Component\DependencyInjection\ContainerInterface;
 use Logipro\Phoenix\Entity\Session\Session;
 use Symfony\Component\Security\Core\Security;
 use Logipro\Phoenix\Entity\ProgramItem;
 use Doctrine\Common\Collections\ArrayCollection;
+use Logipro\Bundle\SCORMBundle\Services\ScormEngine;
+use Symfony\Component\Translation\TranslatorInterface;
+use Doctrine\ORM\EntityManagerInterface;
 
 /**
  * Service de duplication des entités.
  */
-class EntityDuplicator implements ContainerAwareInterface
+class EntityDuplicator
 {
-    use ContainerAwareTrait;
-
     private $security;
     private $fileUploader;
+    private $entityManager;
+    private $translator;
+    private $scormEngine;
 
     /**
      * Constructeur.
-     * @param ContainerInterface $container
      */
     public function __construct(
-        ContainerInterface $container,
         Security $security,
-        FileUploader $fileUploader
+        FileUploader $fileUploader,
+        EntityManagerInterface $entityManager,
+        TranslatorInterface $translator,
+        ScormEngine $scormEngine
     ) {
-        $this->setContainer($container);
         $this->security = $security;
         $this->fileUploader = $fileUploader;
+        $this->entityManager = $entityManager;
+        $this->translator = $translator;
+        $this->scormEngine = $scormEngine;
     }
 
     /**
@@ -49,29 +53,7 @@ class EntityDuplicator implements ContainerAwareInterface
      */
     public function duplicateLearningPath(LearningPath $learningPath, Session $session = null, bool $isTemplate = false): LearningPath
     {
-        $em = $this->getDoctrine()->getManager();
-
-        $newLearningPath = null;
-
-        // Si c'est une duplication de template
-        if ($isTemplate) {
-            $title = '[copie] ' . $learningPath->getTitle();
-            $newLearningPath = $this->cloneLearningPath($learningPath, true);
-            $newLearningPath->setTitle($title);
-        } else {
-            $newLearningPath = $this->cloneLearningPath($learningPath);
-        }
-
-        $autor = $this->security->getUser();
-        $newLearningPath->setCreatingUser($autor);
-
-        if ($session) {
-            $newLearningPath->setSession($session);
-            $session->setLearningPath($newLearningPath);
-        }
-
-        $em->persist($newLearningPath);
-        $em->flush();
+        $newLearningPath = $this->cloneLearningPath($learningPath, $session, $isTemplate);
 
         // Duplication des cours au niveau du moteur SCORM
         $this->duplicateScormCoursesFromPaths($learningPath, $newLearningPath);
@@ -79,7 +61,7 @@ class EntityDuplicator implements ContainerAwareInterface
         return $newLearningPath;
     }
 
-    private function cloneLearningPath(LearningPath $learningPath, bool $isTemplate = false): LearningPath
+    protected function cloneLearningPath(LearningPath $learningPath, Session $session = null, bool $isTemplate = false): LearningPath
     {
         //FIXME Peut-on copier un parcours qui n'est pas un gabarit ?
         if (!$learningPath->isTemplate()) {
@@ -89,6 +71,9 @@ class EntityDuplicator implements ContainerAwareInterface
         // Clonage du parcours (et de ses éléments enfants en cascade)
         $pathCopy = clone $learningPath;
 
+        $autor = $this->security->getUser();
+        $pathCopy->setCreatingUser($autor);
+
         // Copie les séquences
         $sequences = new ArrayCollection();
         foreach ($learningPath->getSequences() as $sequence) {
@@ -112,10 +97,22 @@ class EntityDuplicator implements ContainerAwareInterface
         $pathCopy->setTemplate($learningPath);
         $pathCopy->setIsTemplate($isTemplate);
 
+        if ($isTemplate) {
+            $pathCopy->setTitle('[copie] ' . $learningPath->getTitle());
+        }
+
+        if ($session) {
+            $pathCopy->setSession($session);
+            $session->setLearningPath($pathCopy);
+        }
+
+        $this->entityManager->persist($pathCopy);
+        $this->entityManager->flush();
+
         return $pathCopy;
     }
 
-    private function cloneSequence(Sequence $sequence): Sequence
+    protected function cloneSequence(Sequence $sequence): Sequence
     {
         $sequenceCopy = clone $sequence;
         // Copie les éléments
@@ -144,13 +141,13 @@ class EntityDuplicator implements ContainerAwareInterface
         return $sequenceCopy;
     }
 
-    private function cloneProgramItem(ProgramItem $programItem): ProgramItem
+    protected function cloneProgramItem(ProgramItem $programItem): ProgramItem
     {
         // FIXME à corriger
         return clone $programItem;
     }
 
-    private function cloneSequenceItem(SequenceItem $sequenceItem): SequenceItem
+    protected function cloneSequenceItem(SequenceItem $sequenceItem): SequenceItem
     {
         // FIXME à corriger
         return clone $sequenceItem;
@@ -168,14 +165,13 @@ class EntityDuplicator implements ContainerAwareInterface
     {
         // Vérification de l'existance des parcours
         if (empty($originalPath) || empty($newPath)) {
-            throw new PhoenixException($this->container->get('translator')->trans('exception_duplicator_no_learning_path'));
+            throw new PhoenixException($this->translator->trans('exception_duplicator_no_learning_path'));
         }
 
-        $em = $this->getDoctrine()->getManager();
-        $sequenceRepository = $em->getRepository(Sequence::class);
+        $sequenceRepository = $this->entityManager->getRepository(Sequence::class);
 
         // Récupération du service ScormEngine
-        $scormEngine = $this->container->get('scorm.services.engine');
+        $scormEngine = $this->scormEngine;
 
         // On récupère les séquences par repository avec classement croissant des id
         $originalSequences = $sequenceRepository->findBy(array('learningPath' => $originalPath), array('sequenceId' => 'asc'));
@@ -183,7 +179,7 @@ class EntityDuplicator implements ContainerAwareInterface
 
         // Vérification de l'existance des séquences
         if (empty($originalSequences) || empty($newSequences)) {
-            throw new PhoenixException($this->container->get('translator')->trans('exception_duplicator_no_sequences'));
+            throw new PhoenixException($this->translator->trans('exception_duplicator_no_sequences'));
         }
 
         // Pour chaque Sequence
@@ -197,7 +193,7 @@ class EntityDuplicator implements ContainerAwareInterface
 
             // Vérification de l'existance des items
             if (empty($originalItems) || empty($newItems)) {
-                throw new PhoenixException($this->container->get('translator')->trans('exception_duplicator_no_items'));
+                throw new PhoenixException($this->translator->trans('exception_duplicator_no_items'));
             }
 
             // Pour chaque item
@@ -208,24 +204,10 @@ class EntityDuplicator implements ContainerAwareInterface
                     $new  = $newItems[$j];
                     $response = $scormEngine->duplicateCourse($original->getSequenceItemId(), $new->getSequenceItemId());
                     if (400 == $response['code']) {
-                        throw new PhoenixException($this->container->get('translator')->trans('exception_duplicator_engine_course'));
+                        throw new PhoenixException($this->translator->trans('exception_duplicator_engine_course'));
                     }
                 }
             }
         }
     }
-
-    /**
-     *
-     * @throws \LogicException
-     * @return ManagerRegistry
-     */
-    protected function getDoctrine(): ManagerRegistry
-    {
-        if (!$this->container->has('doctrine')) {
-            throw new \LogicException('The DoctrineBundle is not registered in your application. Try running "composer require symfony/orm-pack".');
-        }
-
-        return $this->container->get('doctrine');
-    }
 }

src/Phoenix/Service/FileUploader.php

@@ -175,20 +175,25 @@ implements FileUploaderInterface
 		return uniqid() . '.' . pathinfo($oldFileName, PATHINFO_EXTENSION);
 	}
 
-	public function cloneFile(AbstractEntity $entity, string $propertyName): string
+	public function cloneFile(AbstractEntity $entity, string $propertyName)
 	{
 		$filesystem = new Filesystem();
 		$oldFileName = $this->getEntityValue($entity, $propertyName);
-		$newFileName = $this->generateNewName($oldFileName);
-
-		try {
-			$filesystem->copy(
-				$this->buildUploadPublicPath($oldFileName, $entity, $propertyName),
-				$this->buildUploadPublicPath($newFileName, $entity, $propertyName)
-			);
-		} catch (\Exception $exp) {
-			dd($exp->getMessage());
+		$newFileName = null;
+		if ($oldFileName)
+		{
+			$newFileName = $this->generateNewName($oldFileName);
+
+			try {
+				$filesystem->copy(
+					$this->buildUploadPublicPath($oldFileName, $entity, $propertyName),
+					$this->buildUploadPublicPath($newFileName, $entity, $propertyName)
+				);
+			} catch (\Exception $exp) {
+				dd($exp->getMessage());
+			}
 		}
+		
 
 		return $newFileName;
 	}

tests/Phoenix/Service/EntityDuplicatorForTest.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Logipro\Phoenix\tests\Phoenix\Service;
+
+use Logipro\Phoenix\Service\EntityDuplicator;
+use Logipro\Phoenix\Entity\LearningPath;
+use Logipro\Phoenix\Entity\Session\Session;
+
+class EntityDuplicatorForTest extends EntityDuplicator
+{
+    public function cloneLearningPath(LearningPath $learningPath, Session $session = null, bool $isTemplate = false): LearningPath
+    {
+        return parent::cloneLearningPath($learningPath, $session, $isTemplate);
+    }
+}

tests/Phoenix/Service/EntityDuplicatorTest.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace Logipro\Phoenix\tests\Phoenix\Service;
+
+use PHPUnit\Framework\TestCase;
+use Logipro\Phoenix\Entity\LearningPath;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\Security\Core\Security;
+use Logipro\Phoenix\Service\FileUploader;
+use Logipro\Phoenix\Repository\SequenceRepository;
+use Logipro\Bundle\SCORMBundle\Services\ScormEngine;
+use Symfony\Component\Translation\TranslatorInterface;
+use Logipro\Phoenix\Exception\PhoenixException;
+use Logipro\Phoenix\Entity\Sequence;
+use Logipro\Phoenix\tests\Phoenix\Service\EntityDuplicatorForTest;
+use Doctrine\ORM\EntityManagerInterface;
+
+/**
+ * Service de duplication des entités.
+ */
+class EntityDuplicatEntityDuplicatorTest extends TestCase
+{
+    /**
+     * test si le nom de l'image d'une sequence dupliqué est différent après le clonnage
+     * et si le nom est donné par le service fileUploader
+     */
+    public function testDuplicateLearningPathCopySequenceImage()
+    {
+        $securityMock = $this->createMock(Security::class);
+        $fileUploaderMock = $this->createMock(FileUploader::class);
+
+        $newName = 'newName';
+        $fileUploaderMock->method('cloneFile')->willReturn($newName);
+
+        $entityManagerMock = $this->createMock(EntityManagerInterface::class);
+        $repositoryMock = $this->createMock(SequenceRepository::class);
+        $translatorMock = $this->createMock(TranslatorInterface::class);
+        $scormEngineMock = $this->createMock(ScormEngine::class);
+
+        $learningPath = new LearningPath();
+        $learningPath->setIsTemplate(true);
+
+        $sequence = new Sequence();
+        $sequence->setImage('oldName');
+        $learningPath->setSequences([
+            $sequence
+        ]);
+        $service = new EntityDuplicatorForTest(
+            $securityMock,
+            $fileUploaderMock,
+            $entityManagerMock,
+            $translatorMock,
+            $scormEngineMock
+        );
+
+        $learningPathCopy = $service->cloneLearningPath($learningPath);
+
+        $sequencesClone = $learningPathCopy->getSequences();
+        $firstSequenceClone = $sequencesClone->first();
+        $this->assertSame(
+            $firstSequenceClone->getImage(),
+            $newName
+        );
+    }
+}