Retrait de l'utilisation du container dans le code

ClientAPI/ApiScorm2004.php

@@ -19,24 +19,27 @@ use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004ObjectiveProgressInform
 use Logipro\Bundle\SCORMBundle\LearningModels\DOMSCORM2004;
 use Logipro\Bundle\SCORMBundle\Tools\TimeTools;
 use Logipro\Bundle\SCORMBundle\Tools\UnicodeTools;
-use Symfony\Component\DependencyInjection\ContainerInterface;
-use Symfony\Component\DependencyInjection\ContainerAwareTrait;
-use Symfony\Component\DependencyInjection\ContainerAwareInterface;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
 use Symfony\Component\Routing\Generator\UrlGenerator;
+use Symfony\Component\Routing\RouterInterface;
 
-class ApiScorm2004 implements ContainerAwareInterface
+class ApiScorm2004
 {
-    use ContainerAwareTrait;
+    protected $router;
 
-    public function __construct(ContainerInterface $container)
+    protected $parameters;
+
+    protected $em;
+    
+    public function __construct(RouterInterface $router, ParameterBagInterface $parameters, EntityManagerInterface $em)
     {
-        $this->setContainer($container);
+        $this->router = $router;
+        $this->parameters = $parameters;
+        $this->em = $em;
     }
 
     public function getAPI(DOMSCORM2004 $dom, string $registrationKey, string $organization, string $item)
     {
-        $em = $this->getDoctrine()->getManager();
-
         $debugMode = true;
 
         // DATA
@@ -55,7 +58,7 @@ class ApiScorm2004 implements ContainerAwareInterface
         }
 
         // ESSAI
-        $registrationAttemptRepository = $em->getRepository(RegistrationAttempt::class);
+        $registrationAttemptRepository = $this->em->getRepository(RegistrationAttempt::class);
         $registrationAttempt = $registrationAttemptRepository->findOneBy(array('registration' => $registration), array('registrationAttemptId' => 'desc'));
         if (!$registrationAttempt) {
             return;
@@ -69,18 +72,18 @@ class ApiScorm2004 implements ContainerAwareInterface
         $learnerId = $learner->getLearnerId();
 
         // TRACK
-        $trackRepository = $em->getRepository(Scorm2004Track:: class);
+        $trackRepository = $this->em->getRepository(Scorm2004Track:: class);
         $track = $trackRepository->findOneBy(array('organizationId' => $organization, 'registrationAttempt' => $registrationAttempt));
         if (!$track) {
             return;
         }
 
         // MAP ITEM/TRACK
-        $mapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem:: class);
+        $mapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem:: class);
         $mapTrackItem = $mapTrackItemRepository->findOneBy(array('scorm2004Track' => $track, 'item_identifier' => $item));
 
         // Progress Information
-        $attemptInfoRepository = $em->getRepository(Scorm2004AttemptProgressInformation:: class);
+        $attemptInfoRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation:: class);
         $attemptProgressInfo = $attemptInfoRepository->findOneBy(array('scorm2004Track' => $track, 'item_identifier' => $item), array('attempt_id' => 'desc'));
 
         //Nom de l'apprenant
@@ -177,7 +180,7 @@ class ApiScorm2004 implements ContainerAwareInterface
         //============================ Scaled Score : cmi.score.scaled  ==================================================//
         // Le sco est responsable de determiner le scaled score.
         // le mappage pour le score.scaled est fait avec measure_status et normalized_measure.
-        $objectiveInfoRepository = $em->getRepository(Scorm2004ObjectiveProgressInformation::class);
+        $objectiveInfoRepository = $this->em->getRepository(Scorm2004ObjectiveProgressInformation::class);
         $primaryInfo = null;
         if (!empty($primaryObjective)) {
             $primaryInfo = $objectiveInfoRepository->findLocalInfoByObjectiveAndAttempt($primaryObjective, $attemptProgressInfo, $track, true, $dom);
@@ -276,7 +279,7 @@ class ApiScorm2004 implements ContainerAwareInterface
         //                 RECUPERATION DES INTERACTION + OBJECTIFS DES INTERACTION                        //
         //=================================================================================================//
         // on recupère les interactions.
-        $interactionRepository = $em->getRepository(Scorm2004Interaction::class);
+        $interactionRepository = $this->em->getRepository(Scorm2004Interaction::class);
         $interactions = $interactionRepository->findBy(array('scorm2004Track' => $track, 'scorm2004AttemptProgressInformation' => $attemptProgressInfo));
 
         $interactionList = array(); // TABLE QUI VA CONTENIR TOUTES LES INTERACTIONS
@@ -439,7 +442,7 @@ class ApiScorm2004 implements ContainerAwareInterface
         // On recupère les données de data Map.
         $arrayDataMap = array();
         $dataMaps = $dom->getDataMap($item);
-        $noteRepository = $em->getRepository(Scorm2004Note::class);
+        $noteRepository = $this->em->getRepository(Scorm2004Note::class);
 
         if (!empty($dataMaps)) {
             foreach ($dataMaps as $dataMap) {
@@ -475,7 +478,7 @@ class ApiScorm2004 implements ContainerAwareInterface
         //=================================================================================================//
         //                  RECUPERATION DES COMMENTAIRES (comments_from_learner).                         //
         //=================================================================================================//
-        $commentRepository = $em->getRepository(Scorm2004Comment::class);
+        $commentRepository = $this->em->getRepository(Scorm2004Comment::class);
         $learnerComments = $commentRepository->findBy(array('scorm2004Track' => $track, 'resourceIdentifier' => $item, 'learner' => $learner));
 
         $arrayLearnerComments = array();
@@ -517,7 +520,7 @@ class ApiScorm2004 implements ContainerAwareInterface
         //================================================//
 // DEFINIR COMMENT ON FAIT LES COMMITS
         
-        $url = $this->container->get('router')->generate('logipro_scorm_2004_commit', [], UrlGenerator::ABSOLUTE_URL);
+        $url = $this->router->generate('logipro_scorm_2004_commit', [], UrlGenerator::ABSOLUTE_URL);
         $ajaxURL = $this->jsEscape($url);
 
         //=================================================================================================//
@@ -533,7 +536,7 @@ EOT;
         $apiString .= $cmiStructure;
         $apiString .= $scorm2004;
 
-        $ajaxCallbackPath = $this->container->getParameter('logipro_scorm.ajax_callback');
+        $ajaxCallbackPath = $this->parameters->get('logipro_scorm.ajax_callback');
         $ajaxCallback = file_get_contents($ajaxCallbackPath);
         if (!empty($ajaxCallback)) {
             $apiString .= $ajaxCallback;
@@ -880,25 +883,10 @@ EOT;
      */
     protected function requireRegistration(string $registrationKey)
     {
-        $em = $this->getDoctrine()->getManager();
-        $repository = $em->getRepository(Registration::class);
+        $repository = $this->em->getRepository(Registration::class);
 
         $registration = $repository->findOneBy(array('registrationKey' => $registrationKey));
 
         return $registration;
     }
-
-    /**
-     *
-     * @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');
-    }
 }

Controller/ExampleController.php

@@ -1,14 +0,0 @@
-<?php
-
-namespace Logipro\Bundle\SCORMBundle\ExampleBundle\Controller;
-
-use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
-
-class ExampleController extends AbstractController
-{
-    public function view()
-    {
-        //return $this->render('@LogiproExample/Example/example.html.twig');
-        return Response('coucou');
-    }
-}

Controller/Track2004Controller.php

@@ -370,7 +370,7 @@ class Track2004Controller extends AbstractController
         // Récupération des modifications du lecteur pour la réponse ajax
         $packageFolder = $this->container->getParameter('logipro_scorm.package_folder');
         $dom = $registrationAttempt->getDOM($packageFolder);
-        $playerView = new Scorm2004PlayerView($this->container, $dom, $track, $registrationKey, $organization, $item);
+        $playerView = new Scorm2004PlayerView($dom, $track, $registrationKey, $organization, $item);
         $response = $playerView->getNavResponse();
 
         return $this->json($response);

DependencyInjection/LogiproSCORMExtension.php

@@ -17,16 +17,14 @@ class LogiproSCORMExtension extends Extension
         $configuration = new Configuration();
         $config = $this->processConfiguration($configuration, $configs);
 
+        // Définition des paramètres spécifiques au bundle
+        // Les params sont récupérés dans le fichier de config de l'appli cliente
         $container->setParameter('logipro_scorm.package_folder', $config['package_folder']);
         $container->setParameter('logipro_scorm.content_folder', $config['content_folder']);
         $container->setParameter('logipro_scorm.content_url_prefix', $config['content_url_prefix']);
         $container->setParameter('logipro_scorm.ajax_callback', $config['ajax_callback']);
 
-        $definition = $container->getDefinition('Logipro\Bundle\SCORMBundle\Services\ScormEngine');
-        $definition->replaceArgument(0, $config['package_folder']);
-        $definition->replaceArgument(1, $config['content_folder']);
-        $definition->replaceArgument(2, $config['content_url_prefix']);
-
+        // Définition dynamique de l'argument du service à partir du param
         $managerDefinition = $container->getDefinition('Logipro\Bundle\SCORMBundle\Services\Scorm2004ObjectiveProgressInfoManager');
         $managerDefinition->replaceArgument(1, $config['package_folder']);
     }

LearningModels/SCORM2004/SequencingNavigation/DeliveryRequest.php

@@ -2,11 +2,12 @@
 
 namespace Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation;
 
+use Doctrine\ORM\EntityManagerInterface;
 use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004MapTrackItem;
 use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004AttemptProgressInformation;
 use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004ObjectiveProgressInformation;
 use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\SeqNavRequest;
-use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
 
 class DeliveryRequest extends SeqNavRequest
 {
@@ -20,13 +21,14 @@ class DeliveryRequest extends SeqNavRequest
     /**
      * Constructeur
      *
-     * @param ContainerInterface $container
+     * @param ParameterBagInterface $parameters : Service
+     * @param EntityManagerInterface $em : Service
      * @param string $deliveryItem
      * @param string $registrationId
      */
-    public function __construct(ContainerInterface $container, string $deliveryItem, string $registrationId)
+    public function __construct(ParameterBagInterface $parameters, EntityManagerInterface $em, string $deliveryItem, string $registrationId)
     {
-        parent::__construct($container, '', $registrationId, '');
+        parent::__construct($parameters, $em, '', $registrationId, '');
         // Initialisation des variables de l'instance
         $this->deliveryItem = $deliveryItem;
         $this->checkDeliveryItem();
@@ -72,8 +74,7 @@ class DeliveryRequest extends SeqNavRequest
      */
     public function processDelivery(): void
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         
         // Vérifier qu'un item ne soit pas déjà actif
         $mapTrackCurrentItem = $scorm2004MapTrackItemRepository->findOneBy(array('item_identifier' => $this->currentItem, 'scorm2004Track' => $this->scorm2004Track));
@@ -125,7 +126,7 @@ class DeliveryRequest extends SeqNavRequest
                         $attemptProgress->setScorm2004Track($this->scorm2004Track);
                         $attemptProgress->setItemIdentifier($item);
                         
-                        $em->persist($attemptProgress);
+                        $this->em->persist($attemptProgress);
 
                     // COMPORTEMENT HORS NORME
                         // Dans le cas d'un nouvel essais, on RAZ certains attributs relatif au item et au track
@@ -145,7 +146,7 @@ class DeliveryRequest extends SeqNavRequest
                             $objectiveProgress->setScorm2004Track($this->scorm2004Track);
                             
                             // Mise à jours des informations de l'objectif
-                            $em->persist($objectiveProgress);
+                            $this->em->persist($objectiveProgress);
                         }
                     }
                 }
@@ -153,10 +154,10 @@ class DeliveryRequest extends SeqNavRequest
                 // activation de l'item
                 $mapTrackItem->setIsActive(true);
             }
-            $em->persist($mapTrackItem);
+            $this->em->persist($mapTrackItem);
         }
         //die();
-        $em->flush();
+        $this->em->flush();
 
         $this->currentItem = $this->deliveryItem;
         $this->suspendedItem = null;
@@ -180,8 +181,7 @@ class DeliveryRequest extends SeqNavRequest
      */
     protected function clearSuspendedItem($identifiedItem)
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         
         if ($this->suspendedItem) {
             $commonItem = $this->domScorm2004->findCommonAncestor($identifiedItem, $this->suspendedItem);
@@ -196,7 +196,7 @@ class DeliveryRequest extends SeqNavRequest
                     // Si l'item est terminal (n'a pas d'enfant) on annule sa suspension
                     if (empty($children)) {
                         $mapTrackItem->setIsSuspended(false);
-                        $em->persist($mapTrackItem);
+                        $this->em->persist($mapTrackItem);
                     } else {
                         // Si l'item ne possède aucun enfant suspendu, on annule sa suspension
                         $suspension = false;
@@ -211,13 +211,13 @@ class DeliveryRequest extends SeqNavRequest
 
                         if (!$suspension) {
                             $mapTrackItem->setIsSuspended(false);
-                            $em->persist($mapTrackItem);
+                            $this->em->persist($mapTrackItem);
                         }
                     }
                 }
             }
 
-            $em->flush();
+            $this->em->flush();
 
             $this->suspendedItem = null;
             $this->updateTrack2004();

LearningModels/SCORM2004/SequencingNavigation/NavigationRequest.php

@@ -2,11 +2,12 @@
 
 namespace Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation;
 
+use Doctrine\ORM\EntityManagerInterface;
 use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004MapTrackItem;
 use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\SeqNavRequest;
 use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\SequencingRequest;
 use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\TerminationRequest;
-use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
 
 class NavigationRequest extends SeqNavRequest
 {
@@ -42,14 +43,15 @@ class NavigationRequest extends SeqNavRequest
     /**
      * Constructeur
      *
-     * @param ContainerInterface $container
+     * @param ParameterBagInterface $parameters : Service
+     * @param EntityManagerInterface $em : Service
      * @param string $navigationRequest
      * @param string $registrationKey
      * @param string $targetItemId
      */
-    public function __construct(ContainerInterface $container, string $navigationRequest, string $registrationKey, ?string $targetItemId = '')
+    public function __construct(ParameterBagInterface $parameters, EntityManagerInterface $em, string $navigationRequest, string $registrationKey, ?string $targetItemId = '')
     {
-        parent::__construct($container, $navigationRequest, $registrationKey, $targetItemId);
+        parent::__construct($parameters, $em, $navigationRequest, $registrationKey, $targetItemId);
 
         // Initialisation des variables de l'instance
         $this->terminationRequest = null;
@@ -152,8 +154,6 @@ class NavigationRequest extends SeqNavRequest
      */
     protected function processContinue(): void
     {
-        $em = $this->getDoctrine()->getManager();
-
         // Vérifier que la session d'activité aie bien été initiée (cad qu'il existe un plannode courant)
         if (!$this->currentItem) {
 //@TODO mettre en place les var de langue
@@ -172,7 +172,7 @@ class NavigationRequest extends SeqNavRequest
                 $this->sequencingRequest = SequencingRequest::SEQUENCING_CONTINUE;
 
                 // Terminer l'activité en cours si ce n'est pas déjà fait
-                $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+                $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
                 $mapTrackItem = $scorm2004MapTrackItemRepository->findOneBy(array('item_identifier' => $this->currentItem, 'scorm2004Track' => $this->scorm2004Track));
         
                 if ($mapTrackItem->getIsActive()) {
@@ -193,8 +193,6 @@ class NavigationRequest extends SeqNavRequest
      */
     protected function processPrevious(): void
     {
-        $em = $this->getDoctrine()->getManager();
-
         // Vérifier que la session de planNode aie bien été initiée (cad qu'il existe un plannode courant)
         if (!$this->currentItem) {
 //@TODO mettre en place les var de langue
@@ -214,7 +212,7 @@ class NavigationRequest extends SeqNavRequest
                 $this->sequencingRequest = SequencingRequest::SEQUENCING_PREVIOUS;
 
                 // Terminer l'activité en cours si ce n'est pas déjà fait
-                $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+                $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
                 $mapTrackItem = $scorm2004MapTrackItemRepository->findOneBy(array('item_identifier' => $this->currentItem, 'scorm2004Track' => $this->scorm2004Track));
                 if ($mapTrackItem->getIsActive()) {
                     $this->terminationRequest = TerminationRequest::TERMINATION_EXIT;
@@ -251,8 +249,7 @@ class NavigationRequest extends SeqNavRequest
      */
     protected function processChoice(): void
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
 
         // Vérifier l'existence du noeud cible
         if ($this->targetItem) {
@@ -363,8 +360,7 @@ class NavigationRequest extends SeqNavRequest
      */
     protected function processQuit(): void
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
 
         // Vérifier que la session aie bien été initiée
         if ($this->currentItem) {

LearningModels/SCORM2004/SequencingNavigation/NavigationRequestValidator.php

@@ -2,11 +2,12 @@
 
 namespace Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation;
 
+use Doctrine\ORM\EntityManagerInterface;
 use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004MapTrackItem;
 use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004AttemptProgressInformation;
 use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004ObjectiveProgressInformation;
 use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\SeqNavRequest;
-use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
 
 /**
  * Validation des requetes de navigation
@@ -31,14 +32,15 @@ class NavigationRequestValidator extends SeqNavRequest
     /**
      * Constructeur
      *
-     * @param ContainerInterface $container
+     * @param ParameterBagInterface $parameters : Service
+     * @param EntityManagerInterface $em : Service
      * @param string $request : identifiant requete
      * @param string $registrationKey : identifiant de l'inscription
      * @param string $targetItemId
      */
-    public function __construct(ContainerInterface $container, string $registrationKey)
+    public function __construct(ParameterBagInterface $parameters, EntityManagerInterface $em, string $registrationKey)
     {
-        parent::__construct($container, '', $registrationKey, '');
+        parent::__construct($parameters, $em, '', $registrationKey, '');
 
         // arbre applati de l'ensemble des items de la formation
         $root = $this->scorm2004Track->getOrganizationId();
@@ -156,10 +158,9 @@ class NavigationRequestValidator extends SeqNavRequest
      */
     public function defineTableOfContent($currentItem): array
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
-        $scorm2004AttemptProgressInformationRepository = $em->getRepository(Scorm2004AttemptProgressInformation::class);
-        $scorm2004ObjectiveProgressInformationRepository = $em->getRepository(Scorm2004ObjectiveProgressInformation::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004AttemptProgressInformationRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation::class);
+        $scorm2004ObjectiveProgressInformationRepository = $this->em->getRepository(Scorm2004ObjectiveProgressInformation::class);
         
         $toc = array();
 
@@ -395,8 +396,7 @@ class NavigationRequestValidator extends SeqNavRequest
      */
     protected function getNextItemFromTreeTraversalFlow($identifiedItem, $traversalDirection, $previousDirection, $considerChildren)
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         
         $reversedDirection = false;
 

LearningModels/SCORM2004/SequencingNavigation/SeqNavRequest.php

@@ -12,9 +12,7 @@ use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004ObjectiveProgressInform
 use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004Track;
 use Logipro\Bundle\SCORMBundle\LearningModels\DOMSCORM;
 use Logipro\Bundle\SCORMBundle\LearningModels\DOMSCORM2004;
-use Symfony\Component\DependencyInjection\ContainerAwareInterface;
-use Symfony\Component\DependencyInjection\ContainerAwareTrait;
-use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
 
 include_once(__DIR__.'/Scorm2004Const.php');
 
@@ -23,10 +21,8 @@ include_once(__DIR__.'/Scorm2004Const.php');
  * de navigation, terminaison, sequencage, livraison
  *
  */
-class SeqNavRequest implements ContainerAwareInterface
+class SeqNavRequest
 {
-    use ContainerAwareTrait;
-
     /**
      * type de la requete en cours
      *
@@ -82,18 +78,25 @@ class SeqNavRequest implements ContainerAwareInterface
      * @var DOMSCORM2004
      */
     protected $domScorm2004;
+
+    protected $params;
+
+    protected $em;
     
     /**
      * Constructeur
      *
-     * @param ContainerInterface $container
+     * @param ParameterBagInterface $parameters : Service
+     * @param EntityManagerInterface $em : Service
      * @param string $request : identifiant requete
      * @param string $registrationKey : identifiant de l'inscription
      * @param string $targetItemId
      */
-    public function __construct(ContainerInterface $container, string $request, string $registrationKey, ?string $targetItemId)
+    public function __construct(ParameterBagInterface $parameters, EntityManagerInterface $em, string $request, string $registrationKey, ?string $targetItemId)
     {
-        $this->setContainer($container);
+        // Récupération des service
+        $this->params = $parameters;
+        $this->em = $em;
 
         // Initialisation des variables de l'instance
         $this->request = $request;
@@ -101,8 +104,6 @@ class SeqNavRequest implements ContainerAwareInterface
         $this->exception = null;
         $this->targetItem = $targetItemId;
 
-        $em = $this->getDoctrine()->getManager();
-
         // Récupération de l'inscription
         $registration  = $this->requireRegistration($registrationKey);
 
@@ -112,7 +113,7 @@ class SeqNavRequest implements ContainerAwareInterface
         }
 
         // Récupération de l'essai Moteur
-        $attemptRepository = $em->getRepository(RegistrationAttempt::class);
+        $attemptRepository = $this->em->getRepository(RegistrationAttempt::class);
         $currentAttempt = $attemptRepository->findOneBy(array('registration' => $registration), array('registrationAttemptId' => 'desc'));
 
         if (!$currentAttempt) {
@@ -122,13 +123,13 @@ class SeqNavRequest implements ContainerAwareInterface
 
         // Construction du parser
         // On récupère le paquet à partir de l'inscription
-        $packageFolder = $this->container->getParameter('logipro_scorm.package_folder');
+        $packageFolder = $this->params->get('logipro_scorm.package_folder');
         $this->domScorm2004 = $currentAttempt->getDOM($packageFolder);
 
         // Récupération de l'organization consultée
 
         // Récupération du trackScorm2004 lié à l'essai moteur en cours
-        $scorm2004TrackRepository = $em->getRepository(Scorm2004Track::class);
+        $scorm2004TrackRepository = $this->em->getRepository(Scorm2004Track::class);
         $this->scorm2004Track = $scorm2004TrackRepository->findOneBy(array('registrationAttempt' => $currentAttempt));
 
         if (!$this->scorm2004Track) {
@@ -147,13 +148,11 @@ class SeqNavRequest implements ContainerAwareInterface
     */
     protected function updateTrack2004(): void
     {
-        $em = $this->getDoctrine()->getManager();
-
         $this->scorm2004Track->setCurrentItemRef($this->currentItem);
         $this->scorm2004Track->setSuspendedItemRef($this->suspendedItem);
 
-        $em->persist($this->scorm2004Track);
-        $em->flush();
+        $this->em->persist($this->scorm2004Track);
+        $this->em->flush();
     }
 
     /**
@@ -185,10 +184,8 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     protected function endAttempt($identifiedItemId): void
     {
-        $em = $this->getDoctrine()->getManager();
-
         // Récupération des informations de mapping concerant cet item pour le track2004 en cours
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         $mapTrackItem = $scorm2004MapTrackItemRepository->findOneBy(array('item_identifier' => $identifiedItemId, 'scorm2004Track' => $this->scorm2004Track));
 
         // Récupération des enfants de l'item
@@ -196,7 +193,7 @@ class SeqNavRequest implements ContainerAwareInterface
         
         // si l'item est terminal (n'a pas d'enfants)
         if (empty($children)) {
-            $scorm2004AttemptProgressInformationRepository = $em->getRepository(Scorm2004AttemptProgressInformation::class);
+            $scorm2004AttemptProgressInformationRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation::class);
             $itemLastAttempt = $scorm2004AttemptProgressInformationRepository->findOneBy(array('item_identifier' => $identifiedItemId, 'scorm2004Track' => $this->scorm2004Track), array('attempt_id' => 'desc'));
 
             if ($itemLastAttempt) {
@@ -211,8 +208,8 @@ class SeqNavRequest implements ContainerAwareInterface
                             $itemLastAttempt->setProgressStatus(true);
                             $itemLastAttempt->setCompletionStatus(true);
                             // Mise à jour des informations de l'essai
-                            $em->persist($itemLastAttempt);
-                            $em->flush();
+                            $this->em->persist($itemLastAttempt);
+                            $this->em->flush();
                         }
                     }
 
@@ -223,7 +220,7 @@ class SeqNavRequest implements ContainerAwareInterface
                         $rollupObjective = $this->domScorm2004->getPrimaryObjective($identifiedItemId);
                         if ($rollupObjective) {
                             // Récupération des informations de l'objectif de rollup (contenant les infos mappées si existantes)
-                            $scorm2004ObjectiveProgressInformationRepository = $em->getRepository(Scorm2004ObjectiveProgressInformation::class);
+                            $scorm2004ObjectiveProgressInformationRepository = $this->em->getRepository(Scorm2004ObjectiveProgressInformation::class);
                             $objectiveInformationsRead = $scorm2004ObjectiveProgressInformationRepository->findLocalInfoByObjectiveAndAttempt($rollupObjective, $itemLastAttempt, $this->scorm2004Track, true, $this->domScorm2004);
                             if ($objectiveInformationsRead) {
                                 $objectiveProgressStatus = $objectiveInformationsRead->getProgressStatus();
@@ -233,7 +230,7 @@ class SeqNavRequest implements ContainerAwareInterface
                                     $objectiveInformationsWrite->setProgressStatus(true);
                                     $objectiveInformationsWrite->setSatisfiedStatus(true);
                                     // mise à jour
-                                    $em->persist($objectiveInformationsWrite);
+                                    $this->em->persist($objectiveInformationsWrite);
                                 }
                             }
                         }
@@ -265,8 +262,8 @@ class SeqNavRequest implements ContainerAwareInterface
         // AJOUT DE COMPORTEMENT HORS PSEUDOCODE
 
         // ce bean doit etre mis à jour
-        $em->persist($mapTrackItem);
-        $em->flush();
+        $this->em->persist($mapTrackItem);
+        $this->em->flush();
 
         // Application du processus de rollup
         $this->evaluateOverallRollup($identifiedItemId);
@@ -322,8 +319,6 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     protected function evaluateMeasureRollup($identifiedItemId): void
     {
-        $em = $this->getDoctrine()->getManager();
-        
         $totalWeightedMeasure = 0.0;
         $validData = false;
         $countedMeasures = 0.0;
@@ -332,8 +327,8 @@ class SeqNavRequest implements ContainerAwareInterface
         $targetObjective = $this->domScorm2004->getPrimaryObjective($identifiedItemId);
 
         if ($targetObjective) {
-            $scorm2004ObjectiveProgressInformationRepository = $em->getRepository(Scorm2004ObjectiveProgressInformation::class);
-            $scorm2004AttemptProgressInformationRepository = $em->getRepository(Scorm2004AttemptProgressInformation::class);
+            $scorm2004ObjectiveProgressInformationRepository = $this->em->getRepository(Scorm2004ObjectiveProgressInformation::class);
+            $scorm2004AttemptProgressInformationRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation::class);
 
             // Récupération de l'essai en cours pour la mise à jour des objectifs
             $itemLastAttempt = $scorm2004AttemptProgressInformationRepository->findOneBy(array('item_identifier' => $identifiedItemId, 'scorm2004Track' => $this->scorm2004Track), array('attempt_id' => 'desc'));
@@ -390,8 +385,8 @@ class SeqNavRequest implements ContainerAwareInterface
                 }
 
                 // Mise à jour de l'objectif
-                $em->persist($targetObjectiveInformationsWrite);
-                $em->flush();
+                $this->em->persist($targetObjectiveInformationsWrite);
+                $this->em->flush();
             }
         }
     }
@@ -405,8 +400,7 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     protected function evaluateCompletionMeasureRollup($identifiedItemId): void
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004AttemptProgressInformationRepository = $em->getRepository(Scorm2004AttemptProgressInformation::class);
+        $scorm2004AttemptProgressInformationRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation::class);
 
         $totalWeightedMeasure = 0.0;
         $validData = false;
@@ -454,8 +448,8 @@ class SeqNavRequest implements ContainerAwareInterface
         }
 
         // Mise à jour de l'attempt
-        $em->persist($itemLastAttempt);
-        $em->flush();
+        $this->em->persist($itemLastAttempt);
+        $this->em->flush();
     }
 
     /**
@@ -468,9 +462,8 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     protected function evaluateObjectiveRollupUsingMeasure($identifiedItemId): ?bool
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004AttemptProgressInformationRepository = $em->getRepository(Scorm2004AttemptProgressInformation::class);
-        $scorm2004ObjectiveProgressInformationRepository = $em->getRepository(Scorm2004ObjectiveProgressInformation::class);
+        $scorm2004AttemptProgressInformationRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation::class);
+        $scorm2004ObjectiveProgressInformationRepository = $this->em->getRepository(Scorm2004ObjectiveProgressInformation::class);
 
         // Récupération de l'essai en cours pour la mise à jour des objectifs
         $itemLastAttempt = $scorm2004AttemptProgressInformationRepository->findOneBy(array('item_identifier' => $identifiedItemId, 'scorm2004Track' => $this->scorm2004Track), array('attempt_id' => 'desc'));
@@ -513,8 +506,8 @@ class SeqNavRequest implements ContainerAwareInterface
                     }
 
                     // Mise à jour de l'objective
-                    $em->persist($objectiveInformationsWrite);
-                    $em->flush();
+                    $this->em->persist($objectiveInformationsWrite);
+                    $this->em->flush();
 
                     //La méthode a été appliquée
                     return true;
@@ -536,8 +529,6 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     protected function evaluateObjectiveRollupUsingRules($identifiedItemId): void
     {
-        $em = $this->getDoctrine()->getManager();
-
         $rollupRules = $this->domScorm2004->getRollupRules($identifiedItemId);
         // Tri des règles en fonction des actions désirées
         $notSatisfiedRollupRules = array();
@@ -581,7 +572,7 @@ class SeqNavRequest implements ContainerAwareInterface
         if ($targetObjective) {
             // Récupération de l'essai en cours pour la mise à jour des objectifs
 
-            $scorm2004AttemptProgressInformationRepository = $em->getRepository(Scorm2004AttemptProgressInformation::class);
+            $scorm2004AttemptProgressInformationRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation::class);
             $itemLastAttempt = $scorm2004AttemptProgressInformationRepository->findOneBy(array('item_identifier' => $identifiedItemId, 'scorm2004Track' => $this->scorm2004Track), array('attempt_id' => 'desc'));
 
             if (!$itemLastAttempt) {
@@ -590,7 +581,7 @@ class SeqNavRequest implements ContainerAwareInterface
             }
 
             // Récupération des informations de l'objectif de rollup (contenant les infos mappées si existantes)
-            $scorm2004ObjectiveProgressInformationRepository = $em->getRepository(Scorm2004ObjectiveProgressInformation::class);
+            $scorm2004ObjectiveProgressInformationRepository = $this->em->getRepository(Scorm2004ObjectiveProgressInformation::class);
             $objectiveInformationsWrite = $scorm2004ObjectiveProgressInformationRepository->findLocalInfoByObjectiveAndAttempt($targetObjective, $itemLastAttempt, $this->scorm2004Track, false);
             if ($objectiveInformationsWrite) {
                 if ($this->checkRollupRule($identifiedItemId, $notSatisfiedRollupRules)) {
@@ -604,8 +595,8 @@ class SeqNavRequest implements ContainerAwareInterface
                 }
 
                 // Mise à jour des infos de l'objectif
-                $em->persist($objectiveInformationsWrite);
-                $em->flush();
+                $this->em->persist($objectiveInformationsWrite);
+                $this->em->flush();
             }
         }
     }
@@ -620,9 +611,7 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     public function evaluateItemProgressRollupUsingMeasure($identifiedItemId): bool
     {
-        $em = $this->getDoctrine()->getManager();
-        
-        $scorm2004AttemptProgressInformationRepository = $em->getRepository(Scorm2004AttemptProgressInformation::class);
+        $scorm2004AttemptProgressInformationRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation::class);
         $itemLastAttempt = $scorm2004AttemptProgressInformationRepository->findOneBy(array('item_identifier' => $identifiedItemId, 'scorm2004Track' => $this->scorm2004Track), array('attempt_id' => 'desc'));
 
         if ($itemLastAttempt) {
@@ -640,8 +629,8 @@ class SeqNavRequest implements ContainerAwareInterface
                 }
 
                 // Mise à jour des informations de l'essai
-                $em->persist($itemLastAttempt);
-                $em->flush();
+                $this->em->persist($itemLastAttempt);
+                $this->em->flush();
 
                 // La méthode a été appliquée
                 return true;
@@ -661,8 +650,6 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     protected function evaluateItemProgressRollupUsingRules($identifiedItemId): void
     {
-        $em = $this->getDoctrine()->getManager();
-
         $rollupRules = $this->domScorm2004->getRollupRules($identifiedItemId);
         // Tri des règles en fonction des actions désirées
         $incompleteRollupRules = array();
@@ -699,7 +686,7 @@ class SeqNavRequest implements ContainerAwareInterface
             $incompleteRollupRules[] = $defaultIncompletedRule;
         }
 
-        $scorm2004AttemptProgressInformationRepository = $em->getRepository(Scorm2004AttemptProgressInformation::class);
+        $scorm2004AttemptProgressInformationRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation::class);
         $itemLastAttempt = $scorm2004AttemptProgressInformationRepository->findOneBy(array('item_identifier' => $identifiedItemId, 'scorm2004Track' => $this->scorm2004Track), array('attempt_id' => 'desc'));
 
         if ($itemLastAttempt) {
@@ -715,8 +702,8 @@ class SeqNavRequest implements ContainerAwareInterface
             }
 
             // Mise à jour des informations de l'essai
-            $em->persist($itemLastAttempt);
-            $em->flush();
+            $this->em->persist($itemLastAttempt);
+            $this->em->flush();
         }
     }
 
@@ -830,8 +817,7 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     public function checkItemForRollup($item, $action): bool
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         $mapTrackItem = $scorm2004MapTrackItemRepository->findOneBy(array('item_identifier' => $item, 'scorm2004Track' => $this->scorm2004Track));
 
         $included = false;
@@ -991,9 +977,8 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     protected function evaluateSequencingCondition($item, $ruleCondition): string
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
-        $scorm2004ObjectiveProgressInformationRepository = $em->getRepository(Scorm2004ObjectiveProgressInformation::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004ObjectiveProgressInformationRepository = $this->em->getRepository(Scorm2004ObjectiveProgressInformation::class);
 
         $objective = null;
         $objectiveId = null;
@@ -1177,12 +1162,11 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     protected function evaluateUniqueRollupCondition($item, $rollupCondition): string
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
-        $scorm2004ObjectiveProgressInformationRepository = $em->getRepository(Scorm2004ObjectiveProgressInformation::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004ObjectiveProgressInformationRepository = $this->em->getRepository(Scorm2004ObjectiveProgressInformation::class);
 
         // On récupère l'attempt en cours du noeud testé
-        $scorm2004AttemptProgressInformationRepository = $em->getRepository(Scorm2004AttemptProgressInformation::class);
+        $scorm2004AttemptProgressInformationRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation::class);
         $itemLastAttempt = $scorm2004AttemptProgressInformationRepository->findOneBy(array('item_identifier' => $item, 'scorm2004Track' => $this->scorm2004Track), array('attempt_id' => 'desc'));
 
         if (!$itemLastAttempt) {
@@ -1318,9 +1302,8 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     protected function checkLimitConditions($item): bool
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
-        $scorm2004AttemptProgressInformationRepository = $em->getRepository(Scorm2004AttemptProgressInformation::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004AttemptProgressInformationRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation::class);
 
         $sequencingTracked = $this->domScorm2004->getSequencingAttribute('imsss:deliveryControls', 'tracked', $item);
         // l'item doit être suivi afin d'évaluer les conditions limites
@@ -1421,8 +1404,7 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     public function getAvailableChildren($item): array
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         
         $availableChildren = array();
         
@@ -1515,8 +1497,7 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     protected function randomlySelectChildren($identifiedItem, $selectionCount): void
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         
         $children = $this->domScorm2004->getChildren($identifiedItem);
 
@@ -1545,7 +1526,7 @@ class SeqNavRequest implements ContainerAwareInterface
                         $mapTrackChild = $scorm2004MapTrackItemRepository->findOneBy(array('item_identifier' => $nonAvailableChild, 'scorm2004Track' => $this->scorm2004Track));
                         $mapTrackChild->setAvailableOrder(-1);
 
-                        $em->persist($mapTrackChild);
+                        $this->em->persist($mapTrackChild);
                     }
                 }
 
@@ -1556,10 +1537,10 @@ class SeqNavRequest implements ContainerAwareInterface
                     $mapTrackChild = $scorm2004MapTrackItemRepository->findOneBy(array('item_identifier' => $child, 'scorm2004Track' => $this->scorm2004Track));
                     $mapTrackChild->setAvailableOrder($key);
                     
-                    $em->persist($mapTrackChild);
+                    $this->em->persist($mapTrackChild);
                 }
 
-                $em->flush();
+                $this->em->flush();
             }
         }
     }
@@ -1573,8 +1554,7 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     protected function randomlyOrderChildren($identifiedItem): void
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         
         $children = $this->domScorm2004->getChildren($identifiedItem);
 
@@ -1588,9 +1568,9 @@ class SeqNavRequest implements ContainerAwareInterface
                         $mapTrackChild = $scorm2004MapTrackItemRepository->findOneBy(array('item_identifier' => $child, 'scorm2004Track' => $this->scorm2004Track));
                         $mapTrackChild->setAvailableOrder($key);
                         
-                        $em->persist($mapTrackChild);
+                        $this->em->persist($mapTrackChild);
                     }
-                    $em->flush();
+                    $this->em->flush();
                 }
             }
         }
@@ -1675,21 +1655,6 @@ class SeqNavRequest implements ContainerAwareInterface
     }
 
     // SYMFONY
-
-    /**
-     *
-     * @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');
-    }
-
     /**
      * Retourne l'inscription
      *
@@ -1698,8 +1663,7 @@ class SeqNavRequest implements ContainerAwareInterface
      */
     protected function requireRegistration(string $registrationKey): ?Registration
     {
-        $em = $this->getDoctrine()->getManager();
-        $repository = $em->getRepository(Registration::class);
+        $repository = $this->em->getRepository(Registration::class);
 
         $registration = $repository->findOneBy(array('registrationKey' => $registrationKey));
 

LearningModels/SCORM2004/SequencingNavigation/SequencingRequest.php

@@ -2,9 +2,10 @@
 
 namespace Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation;
 
+use Doctrine\ORM\EntityManagerInterface;
 use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004MapTrackItem;
 use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\SeqNavRequest;
-use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
 
 class SequencingRequest extends SeqNavRequest
 {
@@ -42,14 +43,15 @@ class SequencingRequest extends SeqNavRequest
     /**
      * Constructeur
      *
-     * @param ContainerInterface $container
+     * @param ParameterBagInterface $parameters : Service
+     * @param EntityManagerInterface $em : Service
      * @param string $sequencingRequest
      * @param string $registrationId
      * @param string $targetItemId
      */
-    public function __construct(ContainerInterface $container, string $sequencingRequest, string $registrationId, ?string $targetItemId = '')
+    public function __construct(ParameterBagInterface $parameters, EntityManagerInterface $em, string $sequencingRequest, string $registrationId, ?string $targetItemId = '')
     {
-        parent::__construct($container, $sequencingRequest, $registrationId, $targetItemId);
+        parent::__construct($parameters, $em, $sequencingRequest, $registrationId, $targetItemId);
 
         // Initialisation des variables de l'instance
         $this->deliveryRequest = null;
@@ -248,8 +250,7 @@ class SequencingRequest extends SeqNavRequest
      */
     protected function processChoice(): void
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         
         // L'item ciblé doit être valide
         if (!$this->targetItem) {
@@ -526,8 +527,7 @@ class SequencingRequest extends SeqNavRequest
      */
     protected function processRetry(): void
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
 
         // Vérifier que la session d'activité aie bien été initiée
         if (!$this->currentItem) {
@@ -586,8 +586,7 @@ class SequencingRequest extends SeqNavRequest
      */
     protected function processExit(): void
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
 
         // Vérifier que la session d'activité aie bien été initiée
         if (!$this->currentItem) {
@@ -646,8 +645,7 @@ class SequencingRequest extends SeqNavRequest
      */
     protected function getNextItemFromTreeTraversalFlow($identifiedItem, $traversalDirection, $previousDirection, $considerChildren): array
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
 
         $reversedDirection = false;
 
@@ -675,9 +673,9 @@ class SequencingRequest extends SeqNavRequest
             foreach ($availableSiblings as $key => $sibling) {
                 $mapTrackSibling = $scorm2004MapTrackItemRepository->findOneBy(array('item_identifier' => $sibling, 'scorm2004Track' => $this->scorm2004Track));
                 $mapTrackSibling->setAvailableOrder($key);
-                $em->persist($mapTrackSibling);
+                $this->em->persist($mapTrackSibling);
             }
-            $em->flush();
+            $this->em->flush();
         }
 
         $response = array(

LearningModels/SCORM2004/SequencingNavigation/TerminationRequest.php

@@ -2,10 +2,11 @@
 
 namespace Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation;
 
+use Doctrine\ORM\EntityManagerInterface;
 use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004MapTrackItem;
 use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\SeqNavRequest;
 use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\SequencingRequest;
-use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
 
 class TerminationRequest extends SeqNavRequest
 {
@@ -28,13 +29,14 @@ class TerminationRequest extends SeqNavRequest
     /**
      * Constructeur
      *
-     * @param ContainerInterface $container
+     * @param ParameterBagInterface $parameters : Service
+     * @param EntityManagerInterface $em : Service
      * @param string $terminationRequest
      * @param string $registrationKey
      */
-    public function __construct(ContainerInterface $container, string $terminationRequest, string $registrationKey)
+    public function __construct(ParameterBagInterface $parameters, EntityManagerInterface $em, string $terminationRequest, string $registrationKey)
     {
-        parent::__construct($container, $terminationRequest, $registrationKey, '');
+        parent::__construct($parameters, $em, $terminationRequest, $registrationKey, '');
 
         // Initialisation des variables de l'instance
         $this->sequencingRequest = null;
@@ -50,8 +52,7 @@ class TerminationRequest extends SeqNavRequest
      */
     protected function globalProcess(): void
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         
         // Vérifier que la session d'activité aie déjà été initiée
         // sinon il n'y a rien à terminer
@@ -163,8 +164,7 @@ class TerminationRequest extends SeqNavRequest
      */
     protected function processExitAll(): void
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         
         // Si le noeud courant est toujours actif
         // on lui applique le processus de terminaison
@@ -193,8 +193,7 @@ class TerminationRequest extends SeqNavRequest
      */
     protected function processSuspendAll(): void
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         
         // Si l'activité courante est active ou suspendue
         // elle devient l'activité suspendue
@@ -230,9 +229,9 @@ class TerminationRequest extends SeqNavRequest
             $mapTrackItem->setIsActive(false);
             $mapTrackItem->setIsSuspended(true);
             
-            $em->persist($mapTrackItem);
+            $this->em->persist($mapTrackItem);
         }
-        $em->flush();
+        $this->em->flush();
 
         $this->currentItem = $treeRoot;
         $this->updateTrack2004();
@@ -248,14 +247,13 @@ class TerminationRequest extends SeqNavRequest
      */
     protected function processAbandon(): void
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
 
         $mapTrackCurrentItem = $scorm2004MapTrackItemRepository->findOneBy(array('item_identifier' => $this->currentItem, 'scorm2004Track' => $this->scorm2004Track));
         $mapTrackCurrentItem->setIsActive(false);
         
-        $em->persist($mapTrackCurrentItem);
-        $em->flush();
+        $this->em->persist($mapTrackCurrentItem);
+        $this->em->flush();
 
         $this->validationState = true;
     }
@@ -267,8 +265,7 @@ class TerminationRequest extends SeqNavRequest
      */
     protected function processAbandonAll(): void
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
 
         $treeRoot = $this->scorm2004Track->getOrganizationId();
         $path = $this->domScorm2004->getDirectPath($this->currentItem, $treeRoot);
@@ -283,9 +280,9 @@ class TerminationRequest extends SeqNavRequest
             
             $mapTrackItem->setIsActive(false);
             
-            $em->persist($mapTrackItem);
+            $this->em->persist($mapTrackItem);
         }
-        $em->flush();
+        $this->em->flush();
 
         $this->currentItem = $treeRoot;
         $this->updateTrack2004();
@@ -342,8 +339,7 @@ class TerminationRequest extends SeqNavRequest
      */
     protected function evaluatePostConditionRules(): ?array
     {
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         
         // on ne peut pas appliquer de règle de post condition sur un item suspendu
         $mapTrackCurrentItem = $scorm2004MapTrackItemRepository->findOneBy(array('item_identifier' => $this->currentItem, 'scorm2004Track' => $this->scorm2004Track));

Player/SCORM2004/Scorm2004PlayerLogic.php

@@ -18,20 +18,32 @@ use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\Nav
 use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\SeqNavRequest;
 use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\SequencingRequest;
 use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\TerminationRequest;
-use Symfony\Component\DependencyInjection\ContainerInterface;
-use Symfony\Component\DependencyInjection\ContainerAwareTrait;
-use Symfony\Component\DependencyInjection\ContainerAwareInterface;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
+use Symfony\Component\Routing\RouterInterface;
 
 /**
  * Classe traitant la logique nécessaire à l'affichage du lecteur
  * en SCORM2004
  */
-class Scorm2004PlayerLogic implements ContainerAwareInterface
+class Scorm2004PlayerLogic
 {
-    use ContainerAwareTrait;
+    /**
+     * Service de routing
+     * Necessaire pour l'API
+     * @var RouterInterface
+     */
+    protected $router;
+    
+    protected $parameters;
 
-    public function __construct()
+    protected $em;
+    
+    public function __construct(RouterInterface $router, ParameterBagInterface $parameters, EntityManagerInterface $em)
     {
+        // Récupération des services
+        $this->router = $router;
+        $this->parameters = $parameters;
+        $this->em = $em;
     }
 
     /**
@@ -55,7 +67,7 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
             'nav' => '',
             'target' => ''
         );
-        $packageFolder = $this->container->getParameter('logipro_scorm.package_folder');
+        $packageFolder = $this->parameters->get('logipro_scorm.package_folder');
         $dom = $zipFile->getDOM($packageFolder);
 
         // On décrypte et désérialise les infos si fournies
@@ -105,10 +117,8 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
 
         // Si pas de requete de navigation, cas d'une nouvelle entrée sur une organisation
         if (empty($dataArray['nav'])) {
-            $em = $this->getDoctrine()->getManager();
-            
             // Récupération du track
-            $trackRepository = $em->getRepository(Scorm2004Track::class);
+            $trackRepository = $this->em->getRepository(Scorm2004Track::class);
             $track = $trackRepository->findOneBy(array('registrationAttempt' => $attempt), array('track_id' => 'desc'));
 
             // Si pas de track, création du track
@@ -118,7 +128,7 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
 
             
             $suspendedItem = $track->getSuspendedItemRef();
-            $navigationValidator = new NavigationRequestValidator($this->container, $registrationKey);
+            $navigationValidator = new NavigationRequestValidator($this->parameters, $this->em, $registrationKey);
             
             // Si il existe un item suspendu au niveau du track
             if ($suspendedItem) {
@@ -132,15 +142,15 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
                 // On vérifie qu'il n'y ai pas d'item courrant résultant d'une déconnexion sauvage
                 /* if ($track->getCurrentItemRef()) {
                     $track->setCurrentItemRef('');
-                    $em->persist($track);
-                    $em->flush();
+                    $this->em->persist($track);
+                    $this->em->flush();
                 } */
             } else {
                 // Aucune possibilité aux vues de l'état du system
                 // On propose la liste de sélection des items (item spécifique au moteur)
                 $track->setCurrentItemRef($track->getOrganizationId());
-                $em->persist($track);
-                $em->flush();
+                $this->em->persist($track);
+                $this->em->flush();
                 
 // TODO SELECTION ITEM
                 // return SelectionItem;
@@ -170,13 +180,11 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
      */
     protected function createTrack(DOMSCORM2004 $dom, string $registrationKey, RegistrationAttempt $attempt, array $dataArray)
     {
-        $em = $this->getDoctrine()->getManager();
-        
         $track = new Scorm2004Track();
         $track->setRegistrationAttempt($attempt);
         $track->setOrganizationId($dataArray['org']);
-        $em->persist($track);
-        $em->flush();
+        $this->em->persist($track);
+        $this->em->flush();
 
         // ajout d'un mapping pour chaque item de l'organisation
         $items = $dom->getFlatTree($dataArray['org']);
@@ -186,7 +194,7 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
             $map->setItemIdentifier($item);
             $map->setScorm2004Track($track);
 
-            $em->persist($map);
+            $this->em->persist($map);
 
             // récupération des objectifs globaux liés à l'item pour la suite de l'initialisation
             $itemObjectives = $dom->getObjectives($item);
@@ -209,7 +217,7 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
         if ($dom->getIsGlobalToSystem($dataArray['org']) === 'true') {
             $registration = $this->requireRegistration($registrationKey);
             $learner = $registration->getLearner();
-            $objectiveInfoRepository = $em->getRepository(Scorm2004ObjectiveProgressInformation::class);
+            $objectiveInfoRepository = $this->em->getRepository(Scorm2004ObjectiveProgressInformation::class);
 
             foreach ($globalObjectives as $global) {
                 $objectiveInfo = $objectiveInfoRepository->findOneBy(array('objectiveIdentifier' => $global, 'learner' => $learner));
@@ -219,7 +227,7 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
                     $objectiveInfo->setLearner($learner);
                     $objectiveInfo->setIsPrimary(false);
 
-                    $em->persist($objectiveInfo);
+                    $this->em->persist($objectiveInfo);
                 }
             }
         } else {
@@ -229,14 +237,14 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
                 $objectiveInfo->setScorm2004Track($track);
                 $objectiveInfo->setIsPrimary(false);
                 
-                $em->persist($objectiveInfo);
+                $this->em->persist($objectiveInfo);
             }
         }
         
-        $em->flush();
+        $this->em->flush();
 
         // Définition des availableChildren pour chaque item (necessite que toutes les tables de mappage soit créées au préalable)
-        $seqNavRequest = new SeqNavRequest($this->container, '', $registrationKey, '');
+        $seqNavRequest = new SeqNavRequest($this->parameters, $this->em, '', $registrationKey, '');
         foreach ($items as $item => $index) {
             $seqNavRequest->defineAvailableChildren($item, true);
         }
@@ -256,8 +264,6 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
      */
     protected function processOverallSequencing(DOMSCORM2004 $dom, array $data, RegistrationAttempt $attempt)
     {
-        $em = $this->getDoctrine()->getManager();
-
         $registrationKey = $data['regKey'];
         $organization = $data['org'];
         $currentItem = $data['current'];
@@ -265,7 +271,7 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
         $targetItem = $data['target'];
             
         // Récupération du track
-        $trackRepository = $em->getRepository(Scorm2004Track::class);
+        $trackRepository = $this->em->getRepository(Scorm2004Track::class);
         $track = $trackRepository->findOneBy(array('registrationAttempt' => $attempt), array('track_id' => 'desc'));
 
         if (!$track) {
@@ -285,14 +291,14 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
             if ($currentItem != $currentRef) {
                 if ($currentRef) {
                     $track->setCurrentItemRef('');
-                    $em->persist($track);
-                    $em->flush();
+                    $this->em->persist($track);
+                    $this->em->flush();
                 }
             }
         }
 
         /*** Traitement de la requete de navigation ***/
-        $processedNavRequest = new NavigationRequest($this->container, $navigationRequest, $registrationKey, $targetItem);
+        $processedNavRequest = new NavigationRequest($this->parameters, $this->em, $navigationRequest, $registrationKey, $targetItem);
 
         // Si la requete de navigation est invalide
         if (!$processedNavRequest->getValidationState()) {
@@ -317,7 +323,7 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
 
         /*** Traitement de la requete de terminaison ***/
         if ($terminationRequest) {
-            $processedTerminationRequest = new TerminationRequest($this->container, $terminationRequest, $registrationKey);
+            $processedTerminationRequest = new TerminationRequest($this->parameters, $this->em, $terminationRequest, $registrationKey);
 
             // on test la validité du processus de terminaison
             if (!$processedTerminationRequest->getValidationState()) {
@@ -347,7 +353,7 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
 
         /*** Traitement de la requete de sequencage ***/
         if ($sequencingRequest) {
-            $processedSequencingRequest = new SequencingRequest($this->container, $sequencingRequest, $registrationKey, $targetItem);
+            $processedSequencingRequest = new SequencingRequest($this->parameters, $this->em, $sequencingRequest, $registrationKey, $targetItem);
 
             // on test la validité du processus de sequencage
             if (!$processedSequencingRequest->getValidationState()) {
@@ -368,8 +374,8 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
             if ($processedSequencingRequest->getEndSequencingSession()) {
                 // L'activité courante devient non définie
                 $track->setCurrentItemRef('');
-                $em->persist($track);
-                $em->flush();
+                $this->em->persist($track);
+                $this->em->flush();
 
                 // retour à la page d'acceuil de la formation
                 $response = array(
@@ -384,8 +390,8 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
             if ($navigationRequest == NavigationRequest::NAVIGATION_EXIT || $navigationRequest == NavigationRequest::NAVIGATION_ABANDON) {
                 // l'item racine (l'organisation) devient l'item courant
                 $track->setCurrentItemRef($organization);
-                $em->persist($track);
-                $em->flush();
+                $this->em->persist($track);
+                $this->em->flush();
 
 // TODO
                 // Affichage du lecteur sur le Item de sélection (le Item racine)
@@ -402,7 +408,7 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
         /*** traitement de la livraison ***/
         if ($deliveryItem) {
             // Vérification des conditions de livraison
-            $processedDeliveryRequest = new DeliveryRequest($this->container, $deliveryItem, $registrationKey);
+            $processedDeliveryRequest = new DeliveryRequest($this->parameters, $this->em, $deliveryItem, $registrationKey);
 
             // on test la validité du processus de livraison
             if (!$processedDeliveryRequest->getValidationState()) {
@@ -421,7 +427,7 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
             }
 
             // La livraison est possible, on récupère les données nécessaires au lecteur
-            $playerView = new Scorm2004PlayerView($this->container, $dom, $track, $registrationKey, $organization, $deliveryItem);
+            $playerView = new Scorm2004PlayerView($this->router, $this->parameters, $this->em, $dom, $track, $registrationKey, $organization, $deliveryItem);
             $response = $playerView->getResponse();
 
             return $response;
@@ -435,26 +441,24 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
      */
     protected function suspendAfterError(Scorm2004Track $track)
     {
-        $em = $this->getDoctrine()->getManager();
-        
         // passage de l'item courant en item suspendu
         $currentItem = $track->getCurrentItemRef();
 
         $track->setCurrentItemRef('');
         $track->setSuspendedItemRef($currentItem);
-        $em->persist($track);
+        $this->em->persist($track);
 
         // mise en suspension des items actifs
-        $mapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $mapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         $activeMapItems = $mapTrackItemRepository->findBy(array('scorm2004Track' => $track, 'is_active' => true));
 
         foreach ($activeMapItems as $mapItem) {
             $mapItem->setIsActive(false);
             $mapItem->setIsSuspended(true);
-            $em->persist($mapItem);
+            $this->em->persist($mapItem);
         }
 
-        $em->flush();
+        $this->em->flush();
     }
 
     /**
@@ -466,25 +470,10 @@ class Scorm2004PlayerLogic implements ContainerAwareInterface
      */
     protected function requireRegistration(string $registrationKey)
     {
-        $em = $this->getDoctrine()->getManager();
-        $repository = $em->getRepository(Registration::class);
+        $repository = $this->em->getRepository(Registration::class);
 
         $registration = $repository->findOneBy(array('registrationKey' => $registrationKey));
 
         return $registration;
     }
-
-    /**
-     *
-     * @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');
-    }
 }

Player/SCORM2004/Scorm2004PlayerView.php

@@ -11,18 +11,21 @@ use Logipro\Bundle\SCORMBundle\LearningModels\DOMSCORM2004;
 use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\NavigationRequest;
 use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\NavigationRequestValidator;
 use Logipro\Bundle\SCORMBundle\LearningModels\SCORM2004\SequencingNavigation\Scorm2004Const;
-use Symfony\Component\DependencyInjection\ContainerInterface;
-use Symfony\Component\DependencyInjection\ContainerAwareTrait;
-use Symfony\Component\DependencyInjection\ContainerAwareInterface;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
+use Symfony\Component\Routing\RouterInterface;
 
 /**
  * Classe les données nécessaire à l'affichage du lecteur
  * en SCORM2004
  */
-class Scorm2004PlayerView implements ContainerAwareInterface
+class Scorm2004PlayerView
 {
-    use ContainerAwareTrait;
+    protected $router;
+    
+    protected $parameters;
 
+    protected $em;
+    
     protected $response;
 
     protected $dom;
@@ -39,9 +42,12 @@ class Scorm2004PlayerView implements ContainerAwareInterface
 
     protected $tocValidations;
 
-    public function __construct(ContainerInterface $container, DOMSCORM2004 $dom, Scorm2004Track $track, string $registrationKey, string $organization, string $item)
+    public function __construct(RouterInterface $router, ParameterBagInterface $parameters, EntityManagerInterface $em, DOMSCORM2004 $dom, Scorm2004Track $track, string $registrationKey, string $organization, string $item)
     {
-        $this->setContainer($container);
+        // Récupération des services
+        $this->router = $router;
+        $this->parameters = $parameters;
+        $this->em = $em;
 
         $this->dom = $dom;
         $this->track = $track;
@@ -142,7 +148,7 @@ class Scorm2004PlayerView implements ContainerAwareInterface
         }
 
         // Controle de l'état relatif aux requetes de type 'previous' et 'continue' en fonction de l'état du system
-        $navigationRequestValidator = new NavigationRequestValidator($this->container, $this->registrationKey);
+        $navigationRequestValidator = new NavigationRequestValidator($this->parameters, $this->em, $this->registrationKey);
         $this->navUIControls[SCORM2004_HIDE_LMS_UI_PREVIOUS]['enable'] = $navigationRequestValidator->checkPreviousValidity($this->item);
         $this->navUIControls[SCORM2004_HIDE_LMS_UI_CONTINUE]['enable'] = $navigationRequestValidator->checkContinueValidity($this->item);
     }
@@ -168,7 +174,7 @@ class Scorm2004PlayerView implements ContainerAwareInterface
     protected function getToc()
     {
         // Récupération de l'état des plannodes pour une requete de type 'choice' en fonction de l'état du system
-        $navigationRequestValidator = new NavigationRequestValidator($this->container, $this->registrationKey);
+        $navigationRequestValidator = new NavigationRequestValidator($this->parameters, $this->em, $this->registrationKey);
         $this->tocValidations = $navigationRequestValidator->defineTableOfContent($this->item);
         
         $response = array();
@@ -176,8 +182,7 @@ class Scorm2004PlayerView implements ContainerAwareInterface
         // Récupération des enfants disponibles
         $children = $this->dom->getChildren($this->organization);
 
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
 
         if (!empty($children)) {
             foreach ($children as $child) {
@@ -228,8 +233,7 @@ class Scorm2004PlayerView implements ContainerAwareInterface
         // Récupération des enfants disponibles uniquement
         $children = $this->dom->getChildren($item);
         $availableChildren = array();
-        $em = $this->getDoctrine()->getManager();
-        $scorm2004MapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $scorm2004MapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         foreach ($children as $child) {
             $mapTrackItem = $scorm2004MapTrackItemRepository->findOneBy(array('item_identifier' => $child, 'scorm2004Track' => $this->track));
             if ($mapTrackItem && $mapTrackItem->getAvailableOrder() !== -1) {
@@ -320,23 +324,9 @@ class Scorm2004PlayerView implements ContainerAwareInterface
      */
     protected function getApi() : string
     {
-        $apiScorm2004 = new ApiScorm2004($this->container);
+        $apiScorm2004 = new ApiScorm2004($this->router, $this->parameters, $this->em);
         $api = $apiScorm2004->getAPI($this->dom, $this->registrationKey, $this->organization, $this->item);
 
         return $api;
     }
-
-    /**
-     *
-     * @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');
-    }
 }

Resources/config/services.xml

@@ -5,10 +5,10 @@
 
     <services>
         <service id="Logipro\Bundle\SCORMBundle\Services\ScormEngine" class="Logipro\Bundle\SCORMBundle\Services\ScormEngine" public="true">
-            <argument></argument> <!-- will be filled in with package_folder dynamically -->
-            <argument></argument> <!-- will be filled in with content_folder dynamically -->
-            <argument></argument> <!-- will be filled in with content_url_prefix dynamically -->
+            <argument type="service" id="router.default"/>
+            <argument type="service" id="parameter_bag"/>
             <argument type="service" id="session"/>
+            <argument type="service" id="Doctrine\ORM\EntityManagerInterface"/>
         </service>
         <service id="scorm.services.engine" alias="Logipro\Bundle\SCORMBundle\Services\ScormEngine" public="true" />
 

Services/ScormEngine.php

@@ -18,21 +18,31 @@ use Logipro\Bundle\SCORMBundle\LearningModels\DOMSCORM2004;
 use Logipro\Bundle\SCORMBundle\Package\Common\PackageTypeDetector;
 use Logipro\Bundle\SCORMBundle\Player\SCORM2004\Scorm2004PlayerLogic;
 use Logipro\Bundle\SCORMBundle\Package\PackageValidator;
-use Symfony\Component\DependencyInjection\ContainerInterface;
-use Symfony\Component\DependencyInjection\ContainerAwareTrait;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
 use Symfony\Component\DependencyInjection\Reference;
-use Symfony\Component\DependencyInjection\ContainerAwareInterface;
 use Symfony\Component\HttpFoundation\Cookie;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpFoundation\Response;
 use Symfony\Component\HttpFoundation\Session\SessionInterface;
+use Symfony\Component\Routing\RouterInterface;
 
 /**
  * Service de communication du moteur
  */
-class ScormEngine implements ContainerAwareInterface
+class ScormEngine
 {
-    use ContainerAwareTrait;
+    /**
+     * Service de routing
+     * Necessaire pour l'API
+     * @var RouterInterface
+     */
+    protected $router;
+
+    /**
+     * Service permettant d'accéder aux paramètres du container
+     * @var ParameterBagInterface
+     */
+    protected $parameters;
 
     protected $packageFolder;
 
@@ -49,6 +59,11 @@ class ScormEngine implements ContainerAwareInterface
      */
     protected $session;
 
+    /**
+     * @var EntityManagerInterface
+     */
+    protected $em;
+
     /**
      * la response est créée ou modifiée pour inserer un cookie dans le header
      * lors de la lecture du paquet (ce cookie est uniquement utilisé dans un mecanisme de
@@ -58,12 +73,18 @@ class ScormEngine implements ContainerAwareInterface
      */
     private $response;
 
-    public function __construct(string $packageFolder, string $contentFolder, string $contentUrlPrefix, SessionInterface $session)
+    public function __construct(RouterInterface $router, ParameterBagInterface $parameters, SessionInterface $session, EntityManagerInterface $em)
     {
-        $this->packageFolder = $packageFolder;
-        $this->contentFolder = $contentFolder;
-        $this->contentUrlPrefix = $contentUrlPrefix;
+        // Récupération des services
+        $this->router = $router;
+        $this->parameters = $parameters;
         $this->session = $session;
+        $this->em = $em;
+
+        // Définitions des params
+        $this->packageFolder = $this->parameters->get('logipro_scorm.package_folder');
+        $this->contentFolder = $this->parameters->get('logipro_scorm.content_folder');
+        $this->contentUrlPrefix = $this->parameters->get('logipro_scorm.content_url_prefix');
     }
 
     // COURS
@@ -130,11 +151,8 @@ class ScormEngine implements ContainerAwareInterface
             // Récupération de la signature du zip
             $hash = md5_file($zipPath);
 
-            // Récupération de l'entity manager
-            $em = $this->getDoctrine()->getManager();
-
             // Test de l'existence de la signature
-            $repository = $em->getRepository(ZipFile::class);
+            $repository = $this->em->getRepository(ZipFile::class);
             $zipFile = $repository->findOneBy(['zipFileprint' => $hash]);
             $response['metadata']['isAlreadyExisting'] = !empty($zipFile);
 
@@ -168,8 +186,8 @@ class ScormEngine implements ContainerAwareInterface
                 $zipFile->setStandard($validation['standard']);
                 $zipFile->setImportStatus(ZipFile::IMPORT_STATUS_PROCESSING);
 
-                $em->persist($zipFile);
-                $em->flush();
+                $this->em->persist($zipFile);
+                $this->em->flush();
 
                 // Une fois l'objet ZipFile créé, on l'extrait
                 $zipFile->extractZipFile($this->packageFolder, $this->contentFolder);
@@ -180,7 +198,7 @@ class ScormEngine implements ContainerAwareInterface
             $course = new Course();
             $course->setCourseKey($courseKey);
             $course->setVersionRule($versioningRule);
-            $em->persist($course);
+            $this->em->persist($course);
 
             // Métadonées du cours
             $response['course']['courseKey'] = $course->getCourseKey();
@@ -191,9 +209,9 @@ class ScormEngine implements ContainerAwareInterface
             $mapping->setCourse($course);
             $mapping->setZipFile($zipFile);
             $mapping->setVersion($response['course']['maxVersion']);
-            $em->persist($mapping);
+            $this->em->persist($mapping);
 
-            $em->flush();
+            $this->em->flush();
 
             $response['isSuccessfullyCreated'] = true;
         }
@@ -263,11 +281,8 @@ class ScormEngine implements ContainerAwareInterface
             // Récupération de la signature du zip
             $hash = md5_file($zipPath);
 
-            // Récupération de l'entity manager
-            $em = $this->getDoctrine()->getManager();
-
             // Test de l'existence de la signature
-            $repository = $em->getRepository(ZipFile::class);
+            $repository = $this->em->getRepository(ZipFile::class);
             $zipFile = $repository->findOneBy(['zipFileprint' => $hash]);
             $response['metadata']['isAlreadyExisting'] = !empty($zipFile);
 
@@ -301,7 +316,7 @@ class ScormEngine implements ContainerAwareInterface
                 $zipFile->setStandard($validation['standard']);
                 $zipFile->setImportStatus(ZipFile::IMPORT_STATUS_PROCESSING);
 
-                $em->persist($zipFile);
+                $this->em->persist($zipFile);
 
                 // Une fois l'objet ZipFile créé, on l'extrait
                 $zipFile->extractZipFile($this->packageFolder, $this->contentFolder);
@@ -313,7 +328,7 @@ class ScormEngine implements ContainerAwareInterface
             $newMaxVersion = $course->getMaxVersion();
             $newMaxVersion++;
             $course->setMaxVersion($newMaxVersion);
-            $em->persist($course);
+            $this->em->persist($course);
 
             // Métadonées du cours
             $response['course']['courseKey'] = $course->getCourseKey();
@@ -324,9 +339,9 @@ class ScormEngine implements ContainerAwareInterface
             $mapping->setCourse($course);
             $mapping->setZipFile($zipFile);
             $mapping->setVersion($newMaxVersion);
-            $em->persist($mapping);
+            $this->em->persist($mapping);
 
-            $em->flush();
+            $this->em->flush();
 
             $response['isSuccessfullyUpdated'] = true;
         }
@@ -389,18 +404,15 @@ class ScormEngine implements ContainerAwareInterface
             $response['error'] = 'La clef du nouveau cours existe déjà. Utilser \'updateCourse\' pour mettre à jour un cours existant.';
             return $response;
         }
-
-        // Récupération de l'entity manager
-        $em = $this->getDoctrine()->getManager();
         
         // COURS
         $newCourse = clone $originalCourse;
         $newCourse->setCourseKey($newCourseKey);
         $newCourse->setMaxVersion(1);
-        $em->persist($newCourse);
+        $this->em->persist($newCourse);
 
         // Récupération de l'objet Zip
-        $mappingRepository = $em->getRepository(MapCourseZipfile::class);
+        $mappingRepository = $this->em->getRepository(MapCourseZipfile::class);
         $originalMapping = $mappingRepository->findOneBy(array('course' => $originalCourse), array('mapCourseZipfileId' => 'desc'));
         $zipFile = $originalMapping->getZipFile();
 
@@ -410,8 +422,8 @@ class ScormEngine implements ContainerAwareInterface
         $mapping->setZipFile($zipFile);
         $mapping->setVersion($newCourse->getMaxVersion());
              
-        $em->persist($mapping);
-        $em->flush();
+        $this->em->persist($mapping);
+        $this->em->flush();
 
         // Réponse
         $response['course']['courseKey'] = $newCourse->getCourseKey();
@@ -432,15 +444,13 @@ class ScormEngine implements ContainerAwareInterface
      */
     public function updateCourseVersionRule(string $courseKey, string $versionRule)
     {
-        $em = $this->getDoctrine()->getManager();
-        
         $course = $this->requireCourse($courseKey);
 
         if ($course) {
             $course->setVersionRule($versionRule);
 
-            $em->persist($course);
-            $em->flush();
+            $this->em->persist($course);
+            $this->em->flush();
 
             return $course->getCourseKey();
         }
@@ -455,13 +465,11 @@ class ScormEngine implements ContainerAwareInterface
      */
     public function deleteCourse(string $courseKey)
     {
-        $em = $this->getDoctrine()->getManager();
-
         $course = $this->requireCourse($courseKey);
 
         if ($course) {
-            $em->remove($course);
-            $em->flush();
+            $this->em->remove($course);
+            $this->em->flush();
             return true;
         }
         
@@ -498,8 +506,7 @@ class ScormEngine implements ContainerAwareInterface
 
     public function getCourses() : array
     {
-        $em = $this->getDoctrine()->getManager();
-        $repository = $em->getRepository(Course::class);
+        $repository = $this->em->getRepository(Course::class);
         $courses = $repository->findAll();
         
         return $courses;
@@ -533,8 +540,6 @@ class ScormEngine implements ContainerAwareInterface
             $learner = $this->requireLearner($learnerKey);
 
             if (empty($learner)) {
-                $em = $this->getDoctrine()->getManager();
-
                 $familyName = $familyName ?? '';
                 $givenName = $givenName ?? '';
 
@@ -543,8 +548,8 @@ class ScormEngine implements ContainerAwareInterface
                 $learner->setFamilyName($familyName);
                 $learner->setGivenName($givenName);
 
-                $em->persist($learner);
-                $em->flush();
+                $this->em->persist($learner);
+                $this->em->flush();
             } else {
                 $response['isAlreadyExisting'] = true;
             }
@@ -577,8 +582,8 @@ class ScormEngine implements ContainerAwareInterface
                 $learner->setFamilyName($familyName);
                 $learner->setGivenName($givenName);
 
-                $em->persist($learner);
-                $em->flush();
+                $this->em->persist($learner);
+                $this->em->flush();
             }
         }
             return $learner->getLearnerKey();
@@ -593,8 +598,6 @@ class ScormEngine implements ContainerAwareInterface
      */
     public function getLearner(string $learnerKey)
     {
-        $em = $this->getDoctrine()->getManager();
-
         $learner = $this->requireLearner($learnerKey);
 
         return $learner;
@@ -602,8 +605,7 @@ class ScormEngine implements ContainerAwareInterface
 
     public function getLearners()
     {
-        $em = $this->getDoctrine()->getManager();
-        $repository = $em->getRepository(Learner::class);
+        $repository = $this->em->getRepository(Learner::class);
         $learners = $repository->findAll();
 
         return $learners;
@@ -618,13 +620,11 @@ class ScormEngine implements ContainerAwareInterface
      */
     public function deleteLearner(string $learnerKey)
     {
-        $em = $this->getDoctrine()->getManager();
-
         $learner = $this->requireLearner($learnerKey);
 
         if ($learner) {
-            $em->remove($learner);
-            $em->flush();
+            $this->em->remove($learner);
+            $this->em->flush();
             return true;
         }
         
@@ -663,15 +663,13 @@ class ScormEngine implements ContainerAwareInterface
 
             if ($course && $learner) {
                 if (empty($registration)) {
-                    $em = $this->getDoctrine()->getManager();
-
                     $registration = new Registration();
                     $registration->setRegistrationKey($registrationKey);
                     $registration->setCourse($course);
                     $registration->setLearner($learner);
 
-                    $em->persist($registration);
-                    $em->flush();
+                    $this->em->persist($registration);
+                    $this->em->flush();
                 } else {
                     $response['isAlreadyExisting'] = true;
                 }
@@ -708,8 +706,6 @@ class ScormEngine implements ContainerAwareInterface
             // Erreur : une inscription valide doit être passée
             return null;
         }
-
-        $em = $this->getDoctrine()->getManager();
         
         // Récupération du cours et des infos de version
         $course = $registration->getCourse();
@@ -717,7 +713,7 @@ class ScormEngine implements ContainerAwareInterface
         $versionRule = $course->getVersionRule();
 
         // Récupération du registrationAttempt courant
-        $attemptRepository = $em->getRepository(RegistrationAttempt::class);
+        $attemptRepository = $this->em->getRepository(RegistrationAttempt::class);
         $currentAttempt = $attemptRepository->findOneBy(array('registration' => $registration), array('registrationAttemptId' => 'desc'));
 
         $needCreation = empty($currentAttempt);
@@ -730,20 +726,20 @@ class ScormEngine implements ContainerAwareInterface
             $newAttempt->setCourseVersion($maxVersion);
             $newAttempt->setRegistration($registration);
 
-            $em->persist($newAttempt);
-            $em->flush();
+            $this->em->persist($newAttempt);
+            $this->em->flush();
 
             $currentAttempt = $newAttempt;
             $currentVersion = $maxVersion;
 
             if (!$needCreation) {
-// TODO Indiquer dans la réponse que l'on a effectué une modification de version pour l'apprenan
+// TODO Indiquer dans la réponse que l'on a effectué une modification de version pour l'apprenant
                 $data = null;
             }
         }
         
         // Récupération du zip correspondant et ainsi de la version du standard utilisée
-        $mapCourseZipRepository = $em->getRepository(MapCourseZipfile::class);
+        $mapCourseZipRepository = $this->em->getRepository(MapCourseZipfile::class);
         $mapCourseZip = $mapCourseZipRepository->findOneBy(array('course' => $course, 'version' => $currentVersion));
         $zipFile = $mapCourseZip->getZipFile();
         $standard = $zipFile->getStandard();
@@ -752,8 +748,7 @@ class ScormEngine implements ContainerAwareInterface
         $variables = null;
         switch ($standard) {
             case DOMSCORM2004::SCORM_2004:
-                $playerLogic = new Scorm2004PlayerLogic();
-                $playerLogic->setContainer($this->container);
+                $playerLogic = new Scorm2004PlayerLogic($this->router, $this->parameters, $this->em);
                 $variables = $playerLogic->getScorm2004PlayerVariables($registrationKey, $zipFile, $currentAttempt, $data);
                 break;
 
@@ -793,8 +788,6 @@ class ScormEngine implements ContainerAwareInterface
      */
     public function getCompletion(string $registrationKey)
     {
-        $em = $this->getDoctrine()->getManager();
-        
         // Vérification de l'existance de l'inscription
         $registration = $this->requireRegistration($registrationKey);
         if (empty($registration)) {
@@ -802,22 +795,22 @@ class ScormEngine implements ContainerAwareInterface
         }
         
         // Récupération du dernier essai moteur pour cette inscription
-        $registrationAttemptRepository = $em->getRepository(RegistrationAttempt::class);
+        $registrationAttemptRepository = $this->em->getRepository(RegistrationAttempt::class);
         $lastAttempt = $registrationAttemptRepository->findOneBy(array('registration' => $registration), array('registrationAttemptId' => 'desc'));
 
 // DETECTER AVANT LE TYPE DE SCORM POUR SAVOIR QUEL STANDARD
 // CODE SCORM 2004
         // On récupère le track correspondant
-        $track2004Repository = $em->getRepository(Scorm2004Track::class);
+        $track2004Repository = $this->em->getRepository(Scorm2004Track::class);
         $track2004 = $track2004Repository->findOneBy(array('registrationAttempt' => $lastAttempt));
         if (empty($track2004)) {
             return 0;
         }
 
         // Dans un premier temps on détermine si la complétion peut être remontée
-        // en se basant sur l'état de complétion de l'ensemble des items terminaux  
-        $mapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
-        $attemptItemRepository = $em->getRepository(Scorm2004AttemptProgressInformation::class);
+        // en se basant sur l'état de complétion de l'ensemble des items terminaux
+        $mapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
+        $attemptItemRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation::class);
         
         $mapTrackItems = $mapTrackItemRepository->findBy(array('scorm2004Track' => $track2004));
 
@@ -850,7 +843,7 @@ class ScormEngine implements ContainerAwareInterface
             }
         }
 
-        // Si aucune complétion n'a été déterminée précédement 
+        // Si aucune complétion n'a été déterminée précédement
         // on controle que l'on aie pas un taux de complétion présent au niveau de l'organisation
         $organization = $track2004->getOrganizationId();
         if (empty($organization)) {
@@ -887,8 +880,6 @@ class ScormEngine implements ContainerAwareInterface
      */
     public function getAverageScore(string $registrationKey)
     {
-        $em = $this->getDoctrine()->getManager();
-        
         // Vérification de l'existance de l'inscription
         $registration = $this->requireRegistration($registrationKey);
         if (empty($registration)) {
@@ -896,19 +887,19 @@ class ScormEngine implements ContainerAwareInterface
         }
         
         // Récupération du dernier essai pour cette inscription
-        $registrationAttemptRepository = $em->getRepository(RegistrationAttempt::class);
+        $registrationAttemptRepository = $this->em->getRepository(RegistrationAttempt::class);
         $lastAttempt = $registrationAttemptRepository->findOneBy(array('registration' => $registration), array('registrationAttemptId' => 'desc'));
 
 // DETECTER AVANT LE TYPE DE SCORM POUR SAVOIR QUEL STANDARD
 // CODE SCORM 2004
         // On récupère le track correspondant
-        $track2004Repository = $em->getRepository(Scorm2004Track::class);
+        $track2004Repository = $this->em->getRepository(Scorm2004Track::class);
         $track2004 = $track2004Repository->findOneBy(array('registrationAttempt' => $lastAttempt));
         if (empty($track2004)) {
             return null;
         }
         
-        $mapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $mapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         
         $mapTrackItems = $mapTrackItemRepository->findBy(array('scorm2004Track' => $track2004));
 
@@ -948,8 +939,6 @@ class ScormEngine implements ContainerAwareInterface
      */
     public function getInteractions(string $registrationKey)
     {
-        $em = $this->getDoctrine()->getManager();
-        
         // Vérification de l'existance de l'inscription
         $registration = $this->requireRegistration($registrationKey);
         if (empty($registration)) {
@@ -957,19 +946,19 @@ class ScormEngine implements ContainerAwareInterface
         }
         
         // Récupération du dernier essai pour cette inscription
-        $registrationAttemptRepository = $em->getRepository(RegistrationAttempt::class);
+        $registrationAttemptRepository = $this->em->getRepository(RegistrationAttempt::class);
         $lastAttempt = $registrationAttemptRepository->findOneBy(array('registration' => $registration), array('registrationAttemptId' => 'desc'));
 
 // DETECTER AVANT LE TYPE DE SCORM POUR SAVOIR QUEL STANDARD
 // CODE SCORM 2004
         // On récupère le track correspondant
-        $track2004Repository = $em->getRepository(Scorm2004Track::class);
+        $track2004Repository = $this->em->getRepository(Scorm2004Track::class);
         $track2004 = $track2004Repository->findOneBy(array('registrationAttempt' => $lastAttempt));
         if (empty($track2004)) {
             return null;
         }
         
-        $mapTrackItemRepository = $em->getRepository(Scorm2004MapTrackItem::class);
+        $mapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
         
         // Récupération des données pour chaque items
         $mapTrackItems = $mapTrackItemRepository->findBy(array('scorm2004Track' => $track2004));
@@ -978,11 +967,10 @@ class ScormEngine implements ContainerAwareInterface
 
         if (!empty($mapTrackItems)) {
             // Récupération du DOM afin d'avoir des infos sur les items
-            $packageFolder = $this->container->getParameter('logipro_scorm.package_folder');
-            $domScorm2004 = $lastAttempt->getDOM($packageFolder);
+            $domScorm2004 = $lastAttempt->getDOM($this->packageFolder);
 
-            $attemptItemRepository = $em->getRepository(Scorm2004AttemptProgressInformation::class);
-            $interactionRepository = $em->getRepository(Scorm2004Interaction::class);
+            $attemptItemRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation::class);
+            $interactionRepository = $this->em->getRepository(Scorm2004Interaction::class);
 
             // Pour chaque item
             foreach ($mapTrackItems as $item) {
@@ -1045,9 +1033,8 @@ class ScormEngine implements ContainerAwareInterface
         $registration = $this->requireRegistration($registrationKey);
 
         if ($registration) {
-            $em = $this->getDoctrine()->getManager();
-            $em->remove($registration);
-            $em->flush();
+            $this->em->remove($registration);
+            $this->em->flush();
             return true;
         }
         
@@ -1063,9 +1050,7 @@ class ScormEngine implements ContainerAwareInterface
      */
     public function resetRegistraitonData(string $registrationKey)
     {
-        $em = $this->getDoctrine()->getManager();
-
-        $trackRepository = $em->getRepository(Registration::class);
+        $trackRepository = $this->em->getRepository(Registration::class);
 
         $registration = $this->requireRegistration($registrationKey);
 
@@ -1076,7 +1061,7 @@ class ScormEngine implements ContainerAwareInterface
             // Efface les RegistrationAttempts
             // Les objets SCORM seront effacés en cascade
             foreach ($attempts as $attempt) {
-                $em->remove($attempt);
+                $this->em->remove($attempt);
             }
 
             // Création d'un nouveau RegistrationAttempt
@@ -1084,10 +1069,10 @@ class ScormEngine implements ContainerAwareInterface
             $attempt = new RegistrationAttempt();
             $attempt->setCourseVersion($course->getMaxVersion());
             $attempt->setRegistration($registration);
-            $em->persist($attempt);
+            $this->em->persist($attempt);
 
 
-            $em->flush();
+            $this->em->flush();
             return true;
         }
         
@@ -1096,8 +1081,7 @@ class ScormEngine implements ContainerAwareInterface
 
     public function getRegistrations()
     {
-        $em = $this->getDoctrine()->getManager();
-        $repository = $em->getRepository(Registration::class);
+        $repository = $this->em->getRepository(Registration::class);
         $registrations = $repository->findAll();
 
         return $registrations;
@@ -1114,8 +1098,6 @@ class ScormEngine implements ContainerAwareInterface
      */
     public function getAttempts(string $registrationKey)
     {
-        $em = $this->getDoctrine()->getManager();
-
         $registration = $this->requireRegistration($registrationKey);
 
         if ($registration) {
@@ -1135,12 +1117,10 @@ class ScormEngine implements ContainerAwareInterface
      */
     public function getCurrentAttempt(string $registrationKey)
     {
-        $em = $this->getDoctrine()->getManager();
-
         $registration = $this->requireRegistration($registrationKey);
 
         if ($registration) {
-            $attemptRepository = $em->getRepository(RegistrationAttempt::class);
+            $attemptRepository = $this->em->getRepository(RegistrationAttempt::class);
 
             $currentAttempt = $attemptRepository->findCurrentAttemptByRegistration($registration);
 
@@ -1159,8 +1139,6 @@ class ScormEngine implements ContainerAwareInterface
      */
     public function getAttemptCourseVersion(int $attemptId)
     {
-        $em = $this->getDoctrine()->getManager();
-
         $attempt = $this->requireRegistrationAttempt($attemptId);
 
         if ($attempt) {
@@ -1237,20 +1215,6 @@ class ScormEngine implements ContainerAwareInterface
     {
         return $this->contentUrlPrefix.'/'.$this->session->get('scormkey').'/'.$courseKey;
     }
-
-    /**
-     *
-     * @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');
-    }
     
     /**
      * Retourne l'activité
@@ -1260,8 +1224,7 @@ class ScormEngine implements ContainerAwareInterface
      */
     protected function requireCourse(string $courseKey)
     {
-        $em = $this->getDoctrine()->getManager();
-        $repository = $em->getRepository(Course::class);
+        $repository = $this->em->getRepository(Course::class);
         
         $course = $repository->findOneBy(array('courseKey' => $courseKey));
 
@@ -1276,8 +1239,7 @@ class ScormEngine implements ContainerAwareInterface
      */
     protected function requireLearner(string $learnerKey)
     {
-        $em = $this->getDoctrine()->getManager();
-        $repository = $em->getRepository(Learner::class);
+        $repository = $this->em->getRepository(Learner::class);
 
         $learner = $repository->findOneBy(array('learnerKey' => $learnerKey));
 
@@ -1293,8 +1255,7 @@ class ScormEngine implements ContainerAwareInterface
      */
     protected function requireRegistration(string $registrationKey)
     {
-        $em = $this->getDoctrine()->getManager();
-        $repository = $em->getRepository(Registration::class);
+        $repository = $this->em->getRepository(Registration::class);
 
         $registration = $repository->findOneBy(array('registrationKey' => $registrationKey));
 
@@ -1310,8 +1271,7 @@ class ScormEngine implements ContainerAwareInterface
      */
     protected function requireRegistrationAttempt(int $attemptId)
     {
-        $em = $this->getDoctrine()->getManager();
-        $repository = $em->getRepository(RegistrationAttempt::class);
+        $repository = $this->em->getRepository(RegistrationAttempt::class);
 
         $attempt = $repository->find($attemptId);