No Description
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

ScormEngine.php 42KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279
  1. <?php
  2. namespace Logipro\Bundle\SCORMBundle\Services;
  3. use Doctrine\ORM\EntityManagerInterface;
  4. use Logipro\Bundle\SCORMBundle\Entity\Course;
  5. use Logipro\Bundle\SCORMBundle\Entity\Learner;
  6. use Logipro\Bundle\SCORMBundle\Entity\MapCourseZipfile;
  7. use Logipro\Bundle\SCORMBundle\Entity\Registration;
  8. use Logipro\Bundle\SCORMBundle\Entity\RegistrationAttempt;
  9. use Logipro\Bundle\SCORMBundle\Entity\ZipFile;
  10. use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004Track;
  11. use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004MapTrackItem;
  12. use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004AttemptProgressInformation;
  13. use Logipro\Bundle\SCORMBundle\Entity\Scorm2004\Scorm2004Interaction;
  14. use Logipro\Bundle\SCORMBundle\LearningModels\DOMSCORM12;
  15. use Logipro\Bundle\SCORMBundle\LearningModels\DOMSCORM2004;
  16. use Logipro\Bundle\SCORMBundle\Player\SCORM2004\Scorm2004PlayerLogic;
  17. use Logipro\Bundle\SCORMBundle\Package\PackageValidator;
  18. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  19. use Symfony\Component\HttpFoundation\Cookie;
  20. use Symfony\Component\HttpFoundation\Response;
  21. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  22. use Symfony\Component\Routing\RouterInterface;
  23. /**
  24. * Service de communication du moteur
  25. */
  26. class ScormEngine
  27. {
  28. /**
  29. * Service de routing
  30. * Necessaire pour l'API
  31. * @var RouterInterface
  32. */
  33. protected $router;
  34. /**
  35. * Service permettant d'accéder aux paramètres du container
  36. * @var ParameterBagInterface
  37. */
  38. protected $parameters;
  39. protected $packageFolder;
  40. protected $contentFolder;
  41. protected $contentUrlPrefix;
  42. /**
  43. * la variable de session passé automatiquement par le kernel
  44. * du fait de sa déclaration ET de sa présence dans la déclaration de service
  45. * (ici services.xml) Presence de la ligne <argument type="service" id="session"/>
  46. *
  47. * @var SessionInterface
  48. */
  49. protected $session;
  50. /**
  51. * @var EntityManagerInterface
  52. */
  53. protected $em;
  54. /**
  55. * la response est créée ou modifiée pour inserer un cookie dans le header
  56. * lors de la lecture du paquet (ce cookie est uniquement utilisé dans un mecanisme de
  57. * blocage de sécurité)
  58. *
  59. * @var Response
  60. */
  61. private $response;
  62. public function __construct(RouterInterface $router, ParameterBagInterface $parameters, SessionInterface $session, EntityManagerInterface $em)
  63. {
  64. // Récupération des services
  65. $this->router = $router;
  66. $this->parameters = $parameters;
  67. $this->session = $session;
  68. $this->em = $em;
  69. // Définitions des params
  70. $this->packageFolder = $this->parameters->get('logipro_scorm.package_folder');
  71. $this->contentFolder = $this->parameters->get('logipro_scorm.content_folder');
  72. $this->contentUrlPrefix = $this->parameters->get('logipro_scorm.content_url_prefix');
  73. }
  74. // COURS
  75. /**
  76. * Crée un cours à partir d'un package identifié par un chemin
  77. *
  78. * @param string $courseKey
  79. * @param string $zipPath
  80. * @param bool $analyse
  81. * @param string $versioningRule
  82. *
  83. * @return array
  84. */
  85. public function createCourse(string $courseKey, string $zipPath, bool $analyse = false, string $versioningRule = Course::VERSIONING_RULE_DEFAULT)
  86. {
  87. // Création de la structure de la réponse
  88. $response = array(
  89. 'code' => 200,
  90. 'isSuccessfullyCreated' => false,
  91. 'error' => '',
  92. 'parserErrors' => array(),
  93. 'course' => array(
  94. 'courseKey' => '',
  95. 'maxVersion' => 0,
  96. 'versioningRule' => $versioningRule
  97. ),
  98. 'metadata' => array(
  99. 'isAlreadyExisting' => false,
  100. 'standard' => '',
  101. 'title' => '',
  102. 'duration' => ''
  103. )
  104. );
  105. // Controle sur la clef fournie (elle doit etre non null et non existante en BD)
  106. if (!empty($courseKey)) {
  107. $course = $this->requireCourse($courseKey);
  108. if ($course) {
  109. $response['code'] = 400;
  110. $response['error'] = 'La clef de cours existe déjà. Utiliser \'updateCourse\' pour mettre à jour un cours existant';
  111. return $response;
  112. }
  113. // ZIP
  114. // Test de l'existence du fichier à uploader
  115. if (!file_exists($zipPath)) {
  116. $response['code'] = 400;
  117. $response['error'] = 'Le chemin ne pointe pas vers un paquet valide';
  118. return $response;
  119. }
  120. // Validation du Package
  121. $validation = PackageValidator::validatePackage($zipPath);
  122. if (!$validation['validation']['status']) {
  123. $response['code'] = 400;
  124. $response['error'] = $validation['validation']['error'];
  125. return $response;
  126. }
  127. $response['metadata']['standard'] = $validation['standard'];
  128. $response['metadata']['title'] = $validation['title'];
  129. $response['metadata']['duration'] = $validation['duration'];
  130. // Récupération de la signature du zip
  131. $hash = md5_file($zipPath);
  132. // Test de l'existence de la signature
  133. $repository = $this->em->getRepository(ZipFile::class);
  134. $zipFile = $repository->findOneBy(['zipFileprint' => $hash]);
  135. $response['metadata']['isAlreadyExisting'] = !empty($zipFile);
  136. // On s'arrete ici si seule l'analyse du paquet est demandée
  137. if ($analyse) {
  138. return $response;
  139. }
  140. // si le fichier n'existe pas déjà on le crée et on le stock coté moteur
  141. if (empty($zipFile)) {
  142. $response['metadata']['isAlreadyExisting'] = false;
  143. //upload du fichier coté moteur
  144. $uploadDate = new \DateTime('NOW');
  145. $fileName = pathinfo($zipPath)['filename'];
  146. $filePath = $this->packageFolder . '/' . $hash;
  147. if (copy($zipPath, $filePath) === false) {
  148. // Si la copie plante, on retourne une erreur
  149. $response['code'] = 400;
  150. $response['error'] = 'Erreur lors de la copie du fichier zip';
  151. return $response;
  152. }
  153. $endUploadDate = new \DateTime('NOW');
  154. // Création d'un objet permettant de traiter le fichier zip
  155. $zipFile = new ZipFile();
  156. $zipFile->setZipFileName($fileName);
  157. $zipFile->setZipFileprint($hash);
  158. $zipFile->setUploadDate($uploadDate);
  159. $zipFile->setEndUploadDate($endUploadDate);
  160. $zipFile->setStandard($validation['standard']);
  161. $zipFile->setImportStatus(ZipFile::IMPORT_STATUS_PROCESSING);
  162. $this->em->persist($zipFile);
  163. $this->em->flush();
  164. // Une fois l'objet ZipFile créé, on l'extrait
  165. $zipFile->extractZipFile($this->packageFolder, $this->contentFolder);
  166. }
  167. // COURS
  168. // Création du cours
  169. $course = new Course();
  170. $course->setCourseKey($courseKey);
  171. $course->setVersionRule($versioningRule);
  172. $this->em->persist($course);
  173. // Métadonées du cours
  174. $response['course']['courseKey'] = $course->getCourseKey();
  175. $response['course']['maxVersion'] = $course->getMaxVersion();
  176. // Mapping Zip/Cours
  177. $mapping = new MapCourseZipfile();
  178. $mapping->setCourse($course);
  179. $mapping->setZipFile($zipFile);
  180. $mapping->setVersion($response['course']['maxVersion']);
  181. $this->em->persist($mapping);
  182. $this->em->flush();
  183. $response['isSuccessfullyCreated'] = true;
  184. }
  185. return $response;
  186. }
  187. /**
  188. * Remplace le package d'un cours
  189. *
  190. * @param string $courseKey
  191. * @param string $zipPath
  192. * @param bool $analyse
  193. * @param string $versioningRule
  194. *
  195. * @return array
  196. */
  197. public function updateCourse(string $courseKey, string $zipPath, bool $analyse = false, string $versioningRule = Course::VERSIONING_RULE_DEFAULT)
  198. {
  199. // Création de la structure de la réponse
  200. $response = array(
  201. 'code' => 200,
  202. 'isSuccessfullyUpdated' => false,
  203. 'error' => '',
  204. 'parserErrors' => array(),
  205. 'course' => array(
  206. 'courseKey' => '',
  207. 'maxVersion' => 0,
  208. 'versioningRule' => $versioningRule
  209. ),
  210. 'metadata' => array(
  211. 'isAlreadyExisting' => false,
  212. 'standard' => '',
  213. 'title' => '',
  214. 'duration' => ''
  215. )
  216. );
  217. // Controle sur la clef fournie (elle doit etre non null et non existante en BD)
  218. if (!empty($courseKey)) {
  219. $course = $this->requireCourse($courseKey);
  220. if (empty($course)) {
  221. $response['code'] = 400;
  222. $response['error'] = 'La clef de cours ne fait référence à aucun cours existant';
  223. return $response;
  224. }
  225. // ZIP
  226. // Test de l'existence du fichier à uploader
  227. if (!file_exists($zipPath)) {
  228. $response['code'] = 400;
  229. $response['error'] = 'le chemin ne pointe pas vers un paquet valide';
  230. return $response;
  231. }
  232. // Validation du Package
  233. $validation = PackageValidator::validatePackage($zipPath);
  234. if (!$validation['validation']['status']) {
  235. return $response;
  236. }
  237. $response['metadata']['standard'] = $validation['standard'];
  238. $response['metadata']['title'] = $validation['title'];
  239. // Récupération de la signature du zip
  240. $hash = md5_file($zipPath);
  241. // Test de l'existence de la signature
  242. $repository = $this->em->getRepository(ZipFile::class);
  243. $zipFile = $repository->findOneBy(['zipFileprint' => $hash]);
  244. $response['metadata']['isAlreadyExisting'] = !empty($zipFile);
  245. // On s'arrete ici si seule l'analyse du paquet est demandée
  246. if ($analyse) {
  247. return $response;
  248. }
  249. // si le fichier n'existe pas déjà on le crée et on le stock coté moteur
  250. if (empty($zipFile)) {
  251. $response['metadata']['isAlreadyExisting'] = false;
  252. //upload du fichier coté moteur
  253. $uploadDate = new \DateTime('NOW');
  254. $fileName = pathinfo($zipPath)['filename'];
  255. $filePath = $this->packageFolder . '/' . $hash;
  256. if (copy($zipPath, $filePath) === false) {
  257. // Si la copie plante, on retourne une erreur
  258. $response['code'] = 400;
  259. $response['error'] = 'Erreur lors de la copie du fichier zip';
  260. return $response;
  261. }
  262. $endUploadDate = new \DateTime('NOW');
  263. // Création d'un objet permettant de traiter le fichier zip
  264. $zipFile = new ZipFile();
  265. $zipFile->setZipFileName($fileName);
  266. $zipFile->setZipFileprint($hash);
  267. $zipFile->setUploadDate($uploadDate);
  268. $zipFile->setEndUploadDate($endUploadDate);
  269. $zipFile->setStandard($validation['standard']);
  270. $zipFile->setImportStatus(ZipFile::IMPORT_STATUS_PROCESSING);
  271. $this->em->persist($zipFile);
  272. // Une fois l'objet ZipFile créé, on l'extrait
  273. $zipFile->extractZipFile($this->packageFolder, $this->contentFolder);
  274. }
  275. // COURS
  276. // MaJ du cours
  277. $course->setVersionRule($versioningRule);
  278. $newMaxVersion = $course->getMaxVersion();
  279. $newMaxVersion++;
  280. $course->setMaxVersion($newMaxVersion);
  281. $this->em->persist($course);
  282. // Métadonées du cours
  283. $response['course']['courseKey'] = $course->getCourseKey();
  284. $response['course']['maxVersion'] = $newMaxVersion;
  285. // Mapping Zip/Cours
  286. $mapping = new MapCourseZipfile();
  287. $mapping->setCourse($course);
  288. $mapping->setZipFile($zipFile);
  289. $mapping->setVersion($newMaxVersion);
  290. $this->em->persist($mapping);
  291. $this->em->flush();
  292. $response['isSuccessfullyUpdated'] = true;
  293. }
  294. return $response;
  295. }
  296. /**
  297. * Copie un cours à partir d'un cours existant
  298. *
  299. * @param string $orginalCourseKey
  300. * @param string $newCourseKey
  301. * @param bool $analyse
  302. * @param string $versioningRule
  303. *
  304. * @return array
  305. */
  306. public function duplicateCourse(string $orginalCourseKey, string $newCourseKey)
  307. {
  308. // Création de la structure de la réponse
  309. $response = array(
  310. 'code' => 200,
  311. 'isSuccessfullyCreated' => false,
  312. 'error' => '',
  313. 'course' => array(
  314. 'courseKey' => '',
  315. 'maxVersion' => 0,
  316. 'versioningRule' => ''
  317. )
  318. );
  319. // Contrôle que la clef du cours existant est fournie
  320. if (empty($orginalCourseKey)) {
  321. $response['code'] = 400;
  322. $response['error'] = 'La clef d\'un cours existant à dupliquer est requise.';
  323. return $response;
  324. }
  325. // Contrôle que la clef du nouveau cours est fournie
  326. if (empty($newCourseKey)) {
  327. $response['code'] = 400;
  328. $response['error'] = 'La clef du nouveau cours dupliqué est requise.';
  329. return $response;
  330. }
  331. // Contrôle de l'existence du cours à dupliquer
  332. $originalCourse = $this->requireCourse($orginalCourseKey);
  333. if (empty($originalCourse)) {
  334. $response['code'] = 400;
  335. $response['error'] = 'Le cours que vous souhaitez dupliquer est inexistant.';
  336. return $response;
  337. }
  338. // Contrôle de la disponibilité de la clef pour le nouveau cours
  339. $newCourse = $this->requireCourse($newCourseKey);
  340. if ($newCourse) {
  341. $response['code'] = 400;
  342. $response['error'] = 'La clef du nouveau cours existe déjà. Utilser \'updateCourse\' pour mettre à jour un cours existant.';
  343. return $response;
  344. }
  345. // COURS
  346. $newCourse = clone $originalCourse;
  347. $newCourse->setCourseKey($newCourseKey);
  348. $newCourse->setMaxVersion(1);
  349. $this->em->persist($newCourse);
  350. // Récupération de l'objet Zip
  351. $mappingRepository = $this->em->getRepository(MapCourseZipfile::class);
  352. $originalMapping = $mappingRepository->findOneBy(array('course' => $originalCourse), array('mapCourseZipfileId' => 'desc'));
  353. $zipFile = $originalMapping->getZipFile();
  354. // Mapping Zip/Cours
  355. $mapping = new MapCourseZipfile();
  356. $mapping->setCourse($newCourse);
  357. $mapping->setZipFile($zipFile);
  358. $mapping->setVersion($newCourse->getMaxVersion());
  359. $this->em->persist($mapping);
  360. $this->em->flush();
  361. // Réponse
  362. $response['course']['courseKey'] = $newCourse->getCourseKey();
  363. $response['course']['maxVersion'] = $newCourse->getMaxVersion();
  364. $response['course']['versioningRule'] = $newCourse->getVersionRule();
  365. $response['isSuccessfullyCreated'] = true;
  366. return $response;
  367. }
  368. /**
  369. * Remplace la règle de versionning d'un cours
  370. *
  371. * @param string $courseKey
  372. * @param string $versionRule
  373. *
  374. * @return string
  375. */
  376. public function updateCourseVersionRule(string $courseKey, string $versionRule)
  377. {
  378. $course = $this->requireCourse($courseKey);
  379. if ($course) {
  380. $course->setVersionRule($versionRule);
  381. $this->em->persist($course);
  382. $this->em->flush();
  383. return $course->getCourseKey();
  384. }
  385. return null;
  386. }
  387. /**
  388. * Supprime une activité
  389. *
  390. * @return bool
  391. */
  392. public function deleteCourse(string $courseKey)
  393. {
  394. $course = $this->requireCourse($courseKey);
  395. if ($course) {
  396. $this->em->remove($course);
  397. $this->em->flush();
  398. return true;
  399. }
  400. return false;
  401. }
  402. /**
  403. * retourne le numéro de version de l'activité
  404. */
  405. public function getCourseCurrentVersion(string $courseKey)
  406. {
  407. $course = $this->requireCourse($courseKey);
  408. if ($course) {
  409. return $course->getMaxVersion();
  410. }
  411. return null;
  412. }
  413. /**
  414. * retourne la règle de versionnig
  415. */
  416. public function getCourseVersionRule(string $courseKey)
  417. {
  418. $course = $this->requireCourse($courseKey);
  419. if ($course) {
  420. return $course->getVersionRule();
  421. }
  422. return null;
  423. }
  424. public function getCourses() : array
  425. {
  426. $repository = $this->em->getRepository(Course::class);
  427. $courses = $repository->findAll();
  428. return $courses;
  429. }
  430. // LEARNER
  431. /**
  432. * Création d'un apprenant
  433. *
  434. * @param string $learnerKey
  435. * @param string $familyName
  436. * @param string $givenName
  437. * @return int
  438. */
  439. public function createLearner(string $learnerKey, string $familyName, string $givenName)
  440. {
  441. // Création de la structure de la réponse
  442. $response = array(
  443. 'code' => 400,
  444. 'isAlreadyExisting' => false,
  445. 'error' => '',
  446. 'learner' => array(
  447. 'learnerKey' => '',
  448. 'familyName' => '',
  449. 'givenName' => ''
  450. )
  451. );
  452. if (!empty($learnerKey)) {
  453. $learner = $this->requireLearner($learnerKey);
  454. if (empty($learner)) {
  455. $familyName = $familyName ?? '';
  456. $givenName = $givenName ?? '';
  457. $learner = new Learner();
  458. $learner->setLearnerKey($learnerKey);
  459. $learner->setFamilyName($familyName);
  460. $learner->setGivenName($givenName);
  461. $this->em->persist($learner);
  462. $this->em->flush();
  463. } else {
  464. $response['isAlreadyExisting'] = true;
  465. }
  466. $response['code'] = 200;
  467. $response['learner']['learnerKey'] = $learner->getLearnerKey();
  468. $response['learner']['familyName'] = $learner->getFamilyName();
  469. $response['learner']['givenName'] = $learner->getGivenName();
  470. } else {
  471. $response['error'] = 'La clef d\'identification est necessaire';
  472. }
  473. return $response;
  474. }
  475. /**
  476. * Modification d'un apprenant
  477. *
  478. * @param string $learnerKey
  479. * @param string $familyName
  480. * @param string $givenName
  481. * @return int
  482. */
  483. public function updateLearner(string $learnerKey, string $familyName, string $givenName)
  484. {
  485. if (!empty($learnerKey)) {
  486. $learner = $this->requireLearner($learnerKey);
  487. if ($learner) {
  488. $learner->setFamilyName($familyName);
  489. $learner->setGivenName($givenName);
  490. $this->em->persist($learner);
  491. $this->em->flush();
  492. }
  493. }
  494. return $learner->getLearnerKey();
  495. }
  496. /**
  497. * récupération d'un apprenant
  498. *
  499. * @param string $learnerKey
  500. *
  501. * @return Learner
  502. */
  503. public function getLearner(string $learnerKey)
  504. {
  505. $learner = $this->requireLearner($learnerKey);
  506. return $learner;
  507. }
  508. public function getLearners()
  509. {
  510. $repository = $this->em->getRepository(Learner::class);
  511. $learners = $repository->findAll();
  512. return $learners;
  513. }
  514. /**
  515. * supprime un apprenant
  516. *
  517. * @param string $learnerKey
  518. *
  519. * @return bool
  520. */
  521. public function deleteLearner(string $learnerKey)
  522. {
  523. $learner = $this->requireLearner($learnerKey);
  524. if ($learner) {
  525. $this->em->remove($learner);
  526. $this->em->flush();
  527. return true;
  528. }
  529. return false;
  530. }
  531. // REGISTRATION
  532. /**
  533. * création d'une inscription
  534. *
  535. * @param string $registrationKey
  536. * @param string $courseKey
  537. * @param string $learnerKey
  538. *
  539. * @return string
  540. */
  541. public function createRegistration(string $registrationKey, string $courseKey, string $learnerKey)
  542. {
  543. // Création de la structure de la réponse
  544. $response = array(
  545. 'code' => 400,
  546. 'isAlreadyExisting' => false,
  547. 'error' => '',
  548. 'registration' => array(
  549. 'registrationKey' => '',
  550. 'courseKey' => '',
  551. 'learnerKey' => ''
  552. )
  553. );
  554. if (!empty($registrationKey)) {
  555. $registration = $this->requireRegistration($registrationKey);
  556. $course = $this->requireCourse($courseKey);
  557. $learner = $this->requireLearner($learnerKey);
  558. if ($course && $learner) {
  559. if (empty($registration)) {
  560. $registration = new Registration();
  561. $registration->setRegistrationKey($registrationKey);
  562. $registration->setCourse($course);
  563. $registration->setLearner($learner);
  564. $this->em->persist($registration);
  565. $this->em->flush();
  566. } else {
  567. $response['isAlreadyExisting'] = true;
  568. }
  569. $response['code'] = 200;
  570. $response['registration']['registrationKey'] = $registration->getRegistrationKey();
  571. $response['registration']['courseKey'] = $registration->getCourse();
  572. $response['registration']['learnerKey'] = $registration->getLearner();
  573. } else {
  574. $response['error'] = 'Le cours et l\'apprenant doivent exister';
  575. }
  576. } else {
  577. $response['error'] = 'La clef d\'identification est necessaire';
  578. }
  579. return $response;
  580. }
  581. /**
  582. * Renvoie les variables necessaire pour l'affichage du contenu du lecteur
  583. * dans le cadre d'une inscription (pour un apprenant et pour un cours)
  584. *
  585. * @param string $registrationKey
  586. * @param string $data
  587. *
  588. * @return array
  589. */
  590. public function getPlayerVariables(string $registrationKey, string $data = null, Response $response = null) : array
  591. {
  592. $result = array();
  593. // Vérification de l'existance de l'inscription
  594. $registration = $this->requireRegistration($registrationKey);
  595. if (empty($registration)) {
  596. // Erreur : une inscription valide doit être passée
  597. return null;
  598. }
  599. // Récupération du cours et des infos de version
  600. $course = $registration->getCourse();
  601. $maxVersion = $course->getMaxVersion();
  602. $versionRule = $course->getVersionRule();
  603. // Récupération du registrationAttempt courant
  604. $attemptRepository = $this->em->getRepository(RegistrationAttempt::class);
  605. $currentAttempt = $attemptRepository->findOneBy(array('registration' => $registration), array('registrationAttemptId' => 'desc'));
  606. $needCreation = empty($currentAttempt);
  607. $currentVersion = $needCreation ? null : $currentAttempt->getCourseVersion();
  608. // Vérification de l'existance d'un essai
  609. // et, si oui, de la présence d'une nouvelle version si la règle de versionning impose un restart
  610. if ($needCreation || ($versionRule == Course::VERSIONING_RULE_RESTART && $currentVersion < $maxVersion)) {
  611. $newAttempt = new RegistrationAttempt();
  612. $newAttempt->setCourseVersion($maxVersion);
  613. $newAttempt->setRegistration($registration);
  614. $this->em->persist($newAttempt);
  615. $this->em->flush();
  616. $currentAttempt = $newAttempt;
  617. $currentVersion = $maxVersion;
  618. if (!$needCreation) {
  619. // TODO Indiquer dans la réponse que l'on a effectué une modification de version pour l'apprenant
  620. $data = null;
  621. }
  622. }
  623. // Récupération du zip correspondant et ainsi de la version du standard utilisée
  624. $mapCourseZipRepository = $this->em->getRepository(MapCourseZipfile::class);
  625. $mapCourseZip = $mapCourseZipRepository->findOneBy(array('course' => $course, 'version' => $currentVersion));
  626. $zipFile = $mapCourseZip->getZipFile();
  627. $standard = $zipFile->getStandard();
  628. // Traitement des données en fonction du standard
  629. $variables = null;
  630. switch ($standard) {
  631. case DOMSCORM2004::SCORM_2004:
  632. $playerLogic = new Scorm2004PlayerLogic($this->router, $this->parameters, $this->em);
  633. $variables = $playerLogic->getScorm2004PlayerVariables($registrationKey, $zipFile, $currentAttempt, $data);
  634. break;
  635. case DOMSCORM12::SCORM_12:
  636. default:
  637. return null;
  638. }
  639. if ($variables['result'] == 'player') {
  640. // Construction d'un URL protégé
  641. $courseKey = $zipFile->getZipFileprint();
  642. $this->prepareContentAccess($courseKey, $response);
  643. $protection = $this->getBaseUrl($courseKey);
  644. $url = $variables['player']['content'];
  645. $url = $protection . '/' . $url;
  646. $variables['player']['content'] = $url;
  647. } else {
  648. $this->response = new Response();
  649. }
  650. return $variables;
  651. }
  652. /**
  653. * Récupération du pourcentage de complétion d'un cours
  654. *
  655. * La complétion d'un cours est soit définie par le module lui meme
  656. * (possibilité d'avoir une pondération de la contribution de chaque item au taux de complétion)
  657. *
  658. * Soit elle correspond au rapport du nombre d'items complétés
  659. * sur le nombre d'items terminaux(consultables par l'apprenant)
  660. *
  661. * @param string $registrationKey
  662. *
  663. * @return float
  664. */
  665. public function getCompletion(string $registrationKey)
  666. {
  667. // Vérification de l'existance de l'inscription
  668. $registration = $this->requireRegistration($registrationKey);
  669. if (empty($registration)) {
  670. return 0;
  671. }
  672. // Récupération du dernier essai moteur pour cette inscription
  673. $registrationAttemptRepository = $this->em->getRepository(RegistrationAttempt::class);
  674. $lastAttempt = $registrationAttemptRepository->findOneBy(array('registration' => $registration), array('registrationAttemptId' => 'desc'));
  675. // DETECTER AVANT LE TYPE DE SCORM POUR SAVOIR QUEL STANDARD
  676. // CODE SCORM 2004
  677. // On récupère le track correspondant
  678. $track2004Repository = $this->em->getRepository(Scorm2004Track::class);
  679. $track2004 = $track2004Repository->findOneBy(array('registrationAttempt' => $lastAttempt));
  680. if (empty($track2004)) {
  681. return 0;
  682. }
  683. // Dans un premier temps on détermine si la complétion peut être remontée
  684. // en se basant sur l'état de complétion de l'ensemble des items terminaux
  685. $mapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
  686. $attemptItemRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation::class);
  687. $mapTrackItems = $mapTrackItemRepository->findBy(array('scorm2004Track' => $track2004));
  688. if (!empty($mapTrackItems)) {
  689. $numCompletedItems = 0;
  690. $numFinalItems = 0;
  691. foreach ($mapTrackItems as $item) {
  692. // Si les items sont terminaux
  693. if ($item->getAvailableOrder() > -1) {
  694. $numFinalItems ++;
  695. $identifier = $item->getItemIdentifier();
  696. $attemptItem = $attemptItemRepository->findOneBy(array('scorm2004Track'=> $track2004, 'item_identifier' => $identifier), array('attempt_id' => 'desc'));
  697. if (!empty($attemptItem)) {
  698. $progressStatus = $attemptItem->getProgressStatus();
  699. $completionStatus = $attemptItem->getCompletionStatus();
  700. if (true == $progressStatus && true == $completionStatus) {
  701. $numCompletedItems ++;
  702. }
  703. }
  704. }
  705. }
  706. if ($numFinalItems != 0) {
  707. $completion = 100.0 * ($numCompletedItems / $numFinalItems);
  708. $completion = round($completion, 2);
  709. // Si on obtient une valeur de complétion elle est retournée
  710. if ($completion > 0) {
  711. return $completion;
  712. }
  713. }
  714. }
  715. // Si aucune complétion n'a été déterminée précédement
  716. // on controle que l'on aie pas un taux de complétion présent au niveau de l'organisation
  717. $organization = $track2004->getOrganizationId();
  718. if (empty($organization)) {
  719. return 0;
  720. }
  721. //Récupération du dernier essai SCORM sur l'organisation
  722. $lastOrganizationAttempt = $attemptItemRepository->findOneBy(array('scorm2004Track'=> $track2004, 'item_identifier' => $organization), array('attempt_id' => 'desc'));
  723. if (empty($lastOrganizationAttempt)) {
  724. return 0;
  725. }
  726. // Récupération de la valeur continue de complétion de l'essai
  727. $completionAmount = $lastOrganizationAttempt->getCompletionAmount();
  728. if ($completionAmount > 0) {
  729. return round(100.0 * $completionAmount, 2);
  730. }
  731. // Récupération de la valeur binaire de complétion de l'essai
  732. $progressStatus = $lastOrganizationAttempt->getProgressStatus();
  733. $completionStatus = $lastOrganizationAttempt->getCompletionStatus();
  734. if (true == $progressStatus && true == $completionStatus) {
  735. return 100;
  736. }
  737. // Pas de complétion récupérable
  738. return 0;
  739. }
  740. /**
  741. * Récupération du score moyen d'un cours
  742. *
  743. * @param string $registrationKey
  744. */
  745. public function getAverageScore(string $registrationKey)
  746. {
  747. // Vérification de l'existance de l'inscription
  748. $registration = $this->requireRegistration($registrationKey);
  749. if (empty($registration)) {
  750. return null;
  751. }
  752. // Récupération du dernier essai pour cette inscription
  753. $registrationAttemptRepository = $this->em->getRepository(RegistrationAttempt::class);
  754. $lastAttempt = $registrationAttemptRepository->findOneBy(array('registration' => $registration), array('registrationAttemptId' => 'desc'));
  755. // DETECTER AVANT LE TYPE DE SCORM POUR SAVOIR QUEL STANDARD
  756. // CODE SCORM 2004
  757. // On récupère le track correspondant
  758. $track2004Repository = $this->em->getRepository(Scorm2004Track::class);
  759. $track2004 = $track2004Repository->findOneBy(array('registrationAttempt' => $lastAttempt));
  760. if (empty($track2004)) {
  761. return null;
  762. }
  763. $mapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
  764. $mapTrackItems = $mapTrackItemRepository->findBy(array('scorm2004Track' => $track2004));
  765. $averageScore = null;
  766. if (!empty($mapTrackItems)) {
  767. $scoreSum = 0;
  768. $scoreNum = 0;
  769. foreach ($mapTrackItems as $item) {
  770. $scoreMax = $item->getScoreMax();
  771. // Si pas de score max, pas de score valide
  772. if ($scoreMax > 0) {
  773. $score = $item->getScoreRaw();
  774. $score = $score * 100 / $scoreMax;
  775. $score = max(min($score, 100), 0);
  776. $scoreNum ++;
  777. $scoreSum += $score;
  778. }
  779. }
  780. if ($scoreNum > 0) {
  781. $averageScore = $scoreSum / $scoreNum;
  782. $averageScore = round($averageScore, 2);
  783. }
  784. }
  785. return $averageScore;
  786. }
  787. /**
  788. * Récupération des interactions d'un cours
  789. * Elles sont rangées par item
  790. *
  791. * @param string $registrationKey
  792. */
  793. public function getInteractions(string $registrationKey)
  794. {
  795. // Vérification de l'existance de l'inscription
  796. $registration = $this->requireRegistration($registrationKey);
  797. if (empty($registration)) {
  798. return null;
  799. }
  800. // Récupération du dernier essai pour cette inscription
  801. $registrationAttemptRepository = $this->em->getRepository(RegistrationAttempt::class);
  802. $lastAttempt = $registrationAttemptRepository->findOneBy(array('registration' => $registration), array('registrationAttemptId' => 'desc'));
  803. // DETECTER AVANT LE TYPE DE SCORM POUR SAVOIR QUEL STANDARD
  804. // CODE SCORM 2004
  805. // On récupère le track correspondant
  806. $track2004Repository = $this->em->getRepository(Scorm2004Track::class);
  807. $track2004 = $track2004Repository->findOneBy(array('registrationAttempt' => $lastAttempt));
  808. if (empty($track2004)) {
  809. return null;
  810. }
  811. $mapTrackItemRepository = $this->em->getRepository(Scorm2004MapTrackItem::class);
  812. // Récupération des données pour chaque items
  813. $mapTrackItems = $mapTrackItemRepository->findBy(array('scorm2004Track' => $track2004));
  814. $interactions = array();
  815. if (!empty($mapTrackItems)) {
  816. // Récupération du DOM afin d'avoir des infos sur les items
  817. $domScorm2004 = $lastAttempt->getDOM($this->packageFolder);
  818. $attemptItemRepository = $this->em->getRepository(Scorm2004AttemptProgressInformation::class);
  819. $interactionRepository = $this->em->getRepository(Scorm2004Interaction::class);
  820. // Pour chaque item
  821. foreach ($mapTrackItems as $item) {
  822. // On récupère l'identifiant de l'item
  823. $identifier = $item->getItemIdentifier();
  824. // On récupère le dernier AttemptProgressInfo en cours
  825. $attemptItem = $attemptItemRepository->findOneBy(array('scorm2004Track'=> $track2004, 'item_identifier' => $identifier), array('attempt_id' => 'desc'));
  826. // On récupère les interactions pour cet item et cet Attempt
  827. $itemInteractions = $interactionRepository->findBy(array('scorm2004Track' => $track2004, 'scorm2004AttemptProgressInformation' => $attemptItem, 'itemIdentifier' => $identifier), array('interaction_id' => 'asc'));
  828. // Si il existe des interactions
  829. if (!empty($itemInteractions)) {
  830. $result = array();
  831. // On récupère le nom de l'item
  832. $result['title'] = $domScorm2004->getTitle($identifier);
  833. // On Récupère le Score sur le mapTrackItem
  834. $score = null;
  835. $scoreMax = $item->getScoreMax();
  836. // Si pas de score max, pas de score valide
  837. if ($scoreMax > 0) {
  838. $score = $item->getScoreRaw();
  839. $score = $score * 100 / $scoreMax;
  840. $score = max(min($score, 100), 0);
  841. }
  842. $result['score'] = $score;
  843. // On récupère le Lesson Status (si on peut / voir Dans AI quoi envoyé pour avoir un résultat neutre à l'affichage)
  844. $status = $attemptItem->getSuccessStatus();
  845. $result['lessonStatus'] = $status;
  846. // On ajoute les objets interactions
  847. $result['interactions'] = $itemInteractions;
  848. // On ajoute ce lot d'interaction aux interactions du cours
  849. $interactions[] = $result;
  850. }
  851. }
  852. }
  853. if (count($interactions) > 0) {
  854. return $interactions;
  855. }
  856. return null;
  857. }
  858. /**
  859. * supprime une inscription
  860. *
  861. * @param string $registrationKey
  862. *
  863. * @return string
  864. */
  865. public function deleteRegistration(string $registrationKey)
  866. {
  867. $registration = $this->requireRegistration($registrationKey);
  868. if ($registration) {
  869. $this->em->remove($registration);
  870. $this->em->flush();
  871. return true;
  872. }
  873. return false;
  874. }
  875. /**
  876. * supprime les données d'apprentissage d'un apprenant pour une inscription
  877. *
  878. * @param string $learnerKey
  879. *
  880. * @return bool
  881. */
  882. public function resetRegistraitonData(string $registrationKey)
  883. {
  884. $trackRepository = $this->em->getRepository(Registration::class);
  885. $registration = $this->requireRegistration($registrationKey);
  886. if ($registration) {
  887. // Récupération des Registrations Attempts
  888. $attempts = $this->getAttempts($registrationKey);
  889. // Efface les RegistrationAttempts
  890. // Les objets SCORM seront effacés en cascade
  891. foreach ($attempts as $attempt) {
  892. $this->em->remove($attempt);
  893. }
  894. // Création d'un nouveau RegistrationAttempt
  895. $course = $registration->getCourse();
  896. $attempt = new RegistrationAttempt();
  897. $attempt->setCourseVersion($course->getMaxVersion());
  898. $attempt->setRegistration($registration);
  899. $this->em->persist($attempt);
  900. $this->em->flush();
  901. return true;
  902. }
  903. return false;
  904. }
  905. public function getRegistrations()
  906. {
  907. $repository = $this->em->getRepository(Registration::class);
  908. $registrations = $repository->findAll();
  909. return $registrations;
  910. }
  911. // ATTEMPT
  912. /**
  913. * Récupération des essais
  914. *
  915. * @param string $registrationKey
  916. *
  917. * @return string
  918. */
  919. public function getAttempts(string $registrationKey)
  920. {
  921. $registration = $this->requireRegistration($registrationKey);
  922. if ($registration) {
  923. $attempts = $registration->getRegistrationAttempts();
  924. return ($attempts);
  925. }
  926. return null;
  927. }
  928. /**
  929. * Récupération de l'id de l'essai en cours
  930. *
  931. * @param string $registrationKey
  932. *
  933. * @return int
  934. */
  935. public function getCurrentAttempt(string $registrationKey)
  936. {
  937. $registration = $this->requireRegistration($registrationKey);
  938. if ($registration) {
  939. $attemptRepository = $this->em->getRepository(RegistrationAttempt::class);
  940. $currentAttempt = $attemptRepository->findCurrentAttemptByRegistration($registration);
  941. return $currentAttempt->registrationAttemptId();
  942. }
  943. return null;
  944. }
  945. /**
  946. * Récupération de la version de l'activité pour l'essai
  947. *
  948. * @param int $attemptId
  949. *
  950. * @return int
  951. */
  952. public function getAttemptCourseVersion(int $attemptId)
  953. {
  954. $attempt = $this->requireRegistrationAttempt($attemptId);
  955. if ($attempt) {
  956. return $attempt->getCourseVersion();
  957. }
  958. return null;
  959. }
  960. /**
  961. * Récupération des statistiques liées à un essai
  962. *
  963. * @param int $attemptId
  964. *
  965. * @return array
  966. */
  967. public function getAttemptStats(int $attemptId)
  968. {
  969. }
  970. // TOOLS
  971. /**
  972. * Undocumented function
  973. *
  974. * @param string $courseKey
  975. * @param Response $response
  976. * @return void
  977. */
  978. private function prepareContentAccess(string $courseKey, Response $response = null) : void
  979. {
  980. if (!$this->session->has('scormkey')) {
  981. $scormkey = rand();
  982. $this->session->set('scormkey', $scormkey);
  983. } else {
  984. $scormkey = $this->session->get('scormkey');
  985. }
  986. if (null === $response) {
  987. $this->response = new Response();
  988. } else {
  989. $this->response = $response;
  990. }
  991. $pathCookie = $this->contentUrlPrefix."/$scormkey/$courseKey/";
  992. $md5cookiekey = md5($scormkey);
  993. $cookie = new Cookie('SCORMBundle', $md5cookiekey, 0, $pathCookie);
  994. $this->response->headers->setCookie($cookie);
  995. }
  996. /**
  997. * il FAUT utiliser la Response de l'objet ScormEngine pour bénéficier du cookie
  998. * de sécurité (sans cela blocage complet de l'acces à la ressource)
  999. *
  1000. * @return Response
  1001. */
  1002. public function getResponse() : Response
  1003. {
  1004. return $this->response;
  1005. }
  1006. /**
  1007. * renvoi l'url de base permettant d'acceder à un fichier de la ressource
  1008. * Format :
  1009. * /content/nomdupaquet/clefautorisation
  1010. *
  1011. * Example :
  1012. * /content/
  1013. *
  1014. * @return string
  1015. */
  1016. public function getBaseUrl($courseKey) : string
  1017. {
  1018. return $this->contentUrlPrefix.'/'.$this->session->get('scormkey').'/'.$courseKey;
  1019. }
  1020. /**
  1021. * Retourne l'activité
  1022. *
  1023. * @param string $courseKey
  1024. * @return Course
  1025. */
  1026. protected function requireCourse(string $courseKey)
  1027. {
  1028. $repository = $this->em->getRepository(Course::class);
  1029. $course = $repository->findOneBy(array('courseKey' => $courseKey));
  1030. return $course;
  1031. }
  1032. /**
  1033. * Retourne l'apprenant
  1034. *
  1035. * @param string $learnerKey
  1036. * @return Learner
  1037. */
  1038. protected function requireLearner(string $learnerKey)
  1039. {
  1040. $repository = $this->em->getRepository(Learner::class);
  1041. $learner = $repository->findOneBy(array('learnerKey' => $learnerKey));
  1042. return $learner;
  1043. }
  1044. /**
  1045. * Retourne l'inscription
  1046. *
  1047. * @param string $registrationKey
  1048. *
  1049. * @return Registration
  1050. */
  1051. protected function requireRegistration(string $registrationKey)
  1052. {
  1053. $repository = $this->em->getRepository(Registration::class);
  1054. $registration = $repository->findOneBy(array('registrationKey' => $registrationKey));
  1055. return $registration;
  1056. }
  1057. /**
  1058. * Retourne un essais relatif à une inscription
  1059. *
  1060. * @param int $attemptId
  1061. *
  1062. * @return RegistrationAttempt
  1063. */
  1064. protected function requireRegistrationAttempt(int $attemptId)
  1065. {
  1066. $repository = $this->em->getRepository(RegistrationAttempt::class);
  1067. $attempt = $repository->find($attemptId);
  1068. return $attempt;
  1069. }
  1070. }