Browse Source

Mise en place de la méthode createCourse

Mael ETIENNE 3 years ago
parent
commit
f734f8ea18

+ 4
- 1
DependencyInjection/Configuration.php View File

@@ -13,7 +13,10 @@ class Configuration implements ConfigurationInterface
13 13
 
14 14
         $treeBuilder->getRootNode()
15 15
             ->children()
16
-                ->node('username_provider', 'scalar')->end()
16
+                ->scalarNode('package_folder')
17
+                ->isRequired()
18
+                ->cannotBeEmpty()
19
+                ->end()
17 20
             ->end()
18 21
         ;
19 22
 

+ 1
- 5
DependencyInjection/LogiproSCORMExtension.php View File

@@ -17,10 +17,6 @@ class LogiproSCORMExtension extends Extension
17 17
         $configuration = new Configuration();
18 18
         $config = $this->processConfiguration($configuration, $configs);
19 19
 
20
-        /**
21
-         * @TODO for real bundle, create an user service for use username provider
22
-         * $definition = $container->getDefinition('logipro_example.user.service');
23
-         * $definition->replaceArgument(0, $config['username_provider']);
24
-         */
20
+        $container->setParameter('logipro_scorm.package_folder', $config['package_folder']);
25 21
     }
26 22
 }

+ 1
- 36
Entity/Course.php View File

@@ -13,11 +13,7 @@ use Symfony\Component\Config\Definition\Exception\Exception;
13 13
  * Représente une activité dans le moteur SCORM.
14 14
  */
15 15
 class Course
16
-{
17
-
18
-    const SCORM_2004    = 'scorm_2004';
19
-    const SCORM_12      = 'scorm_12';
20
-    
16
+{   
21 17
     const VERSIONING_RULE_DEFAULT   = 'versioning_rule_default';
22 18
     const VERSIONING_RULE_RESTART   = 'versioning_rule_restart';
23 19
     
@@ -38,12 +34,6 @@ class Course
38 34
      * @var \DateTime
39 35
      */
40 36
     protected $updateDate;
41
-
42
-    /**
43
-     *
44
-     * @var string
45
-     */
46
-    protected $type = self::SCORM_2004;
47 37
     
48 38
     /**
49 39
      *
@@ -148,31 +138,6 @@ class Course
148 138
         return $this->updateDate;
149 139
     }
150 140
 
151
-    
152
-        /**
153
-     * Get the value of type
154
-     *
155
-     * @return  string
156
-     */
157
-    public function getType()
158
-    {
159
-        return $this->type;
160
-    }
161
-
162
-    /**
163
-     * Set the value of type
164
-     *
165
-     * @param  string  $type
166
-     *
167
-     * @return  self
168
-     */
169
-    public function setType(string $type)
170
-    {
171
-        $this->type = $type;
172
-
173
-        return $this;
174
-    }
175
-
176 141
     /**
177 142
      * Get the value of maxVersion
178 143
      *

+ 14
- 13
Entity/ZipFile.php View File

@@ -9,9 +9,11 @@
9 9
 
10 10
 namespace Logipro\Bundle\SCORMBundle\Entity;
11 11
 
12
+use Logipro\Bundle\SCORMBundle\Entity\ZipFile;
12 13
 use Logipro\Bundle\SCORMBundle\Entity\MapCourseZipfile;
13 14
 use Logipro\Bundle\SCORMBundle\LearningModels\DOMSCORM;
14 15
 use Logipro\Bundle\SCORMBundle\Entity\Common\AbstractEntity;
16
+use Logipro\Bundle\SCORMBundle\LearningModels\DOMLearningModel;
15 17
 use Logipro\Bundle\SCORMBundle\Package\Exception\PackageException;
16 18
 
17 19
 /**
@@ -62,11 +64,10 @@ class ZipFile extends AbstractEntity
62 64
     protected $endUploadDate;
63 65
 
64 66
     /**
65
-     * Chemin du fichier
66 67
      *
67 68
      * @var string
68 69
      */
69
-    protected $filePath;
70
+    protected $standard = DOMSCORM::SCORM_2004;
70 71
 
71 72
     /**
72 73
      * Status d'import
@@ -205,28 +206,28 @@ class ZipFile extends AbstractEntity
205 206
     }
206 207
 
207 208
     /**
208
-     * Get the value of $filePath
209
+     * Get the value of $standard
209 210
      *
210 211
      * @return string
211 212
      */
212
-    public function getFilePath()
213
+    public function getStandard()
213 214
     {
214
-        return $this->filePath;
215
+        return $this->standard;
215 216
     }
216 217
 
217 218
     /**
218
-     * Set the value of $filePath
219
+     * Set the value of $standard
219 220
      *
220
-     * @param string $filePath
221
+     * @param string $standard
221 222
      * @return self
222 223
      */
223
-    public function setFilePath($filePath)
224
+    public function setStandard($standard)
224 225
     {
225
-        $this->filePath = $filePath;
226
+        $this->standard = $standard;
226 227
         return $this;
227 228
     }
228 229
 
229
-      /**
230
+    /**
230 231
      *
231 232
      * Get the value of $importStatus
232 233
      *
@@ -396,11 +397,11 @@ class ZipFile extends AbstractEntity
396 397
  */
397 398
     public function getDOM() : DOMSCORM
398 399
     {
399
-        $dom = DOMLearningModel::getInstance($this->zip_file_id);
400
+        $dom = DOMLearningModel::getInstance($this->zipFileId);
400 401
         
401 402
         if ($dom == null) {
402
-            $XMLManifest = DOMLearningModel::getManifest($this->file_name);
403
-            $dom = DOMLearningModel::setDOM($this->zip_file_id, $XMLManifest);
403
+            $XMLManifest = DOMLearningModel::getManifest($this->zipFileName);
404
+            $dom = DOMLearningModel::setDOM($this->zipFileId, $XMLManifest);
404 405
         }
405 406
         return $dom;
406 407
     }

+ 25
- 11
LearningModels/DOMLearningModel.php View File

@@ -4,13 +4,11 @@ namespace Logipro\Bundle\SCORMBundle\LearningModels;
4 4
 
5 5
 class DOMLearningModel
6 6
 {
7
-    //const SCORM2004 = 2004;
8
-
9 7
     private static $DOMs;
10 8
 
11 9
     final private function __construct()
12 10
     {
13
-// void
11
+        // void
14 12
     }
15 13
 
16 14
     final private function __clone()
@@ -27,27 +25,43 @@ class DOMLearningModel
27 25
      * récupère le DOM représentant un package
28 26
      *
29 27
      * @param string $XMLManifest
30
-     * @param string $version 2004
31 28
      * @return DOMSCORM
32 29
      */
33
-    final public static function getInstance(string $key, string $manifest = null, string $version = '2004') : DOMSCORM
30
+    final public static function getInstance(string $key, string $manifest = null) : DOMSCORM
34 31
     {
35 32
         if (isset($DOMs[$key])) {
36 33
             return self::$DOMs[$key];
37 34
         }
38 35
 
39 36
         if (isset($manifest)) {
40
-            return self::setDOM($key, $manifest, $version);
37
+            return self::setDOM($key, $manifest);
41 38
         }
42
-        return self::$DOMs[$key];
39
+
40
+        return null;
43 41
     }
44 42
 
45
-    public static function setDOM(string $key, string $XMLManifest, string $version) : DOMSCORM
43
+    public static function setDOM(string $key, string $XMLManifest) : DOMSCORM
46 44
     {
47
-        if (substr_compare($version, '2004', 0, 4) == 0) {
48
-            self::$DOMs[$key] = new DOMSCORM2004($XMLManifest);
45
+        $dom = null;
46
+        
47
+        // On définit le standard
48
+        $standard = DOMSCORM::getStandard($XMLManifest);
49
+        switch ($standard) {
50
+            case DOMSCORM::SCORM2004:
51
+                $dom = new DOMSCORM2004($XMLManifest);
52
+                break;
53
+
54
+            case DOMSCORM::SCORM12:
55
+                $dom = null;
56
+                break;
57
+                
58
+            default:
59
+                $dom = null;
49 60
         }
50
-        return self::$DOMs[$key];
61
+
62
+        self::$DOMs[$key] = $dom;
63
+        
64
+        return $dom;
51 65
     }
52 66
 
53 67
     /**

+ 86
- 12
LearningModels/DOMSCORM.php View File

@@ -7,6 +7,9 @@ namespace Logipro\Bundle\SCORMBundle\LearningModels;
7 7
  */
8 8
 abstract class DOMSCORM implements DOMPackageInterface
9 9
 {
10
+    const SCORM_12 = 'SCORM_12';
11
+    const SCORM_2004 = 'SCORM_2004';
12
+    
10 13
     /**
11 14
      * le manifest au format DOM
12 15
      *
@@ -34,19 +37,20 @@ abstract class DOMSCORM implements DOMPackageInterface
34 37
         $this->manifest->loadXML($XMLManifest);
35 38
         $this->xpath = new \DOMXPath($this->manifest);
36 39
        
37
-        $schema = SCORMTools::getSchemaSource();
38
-        $this->manifest->schemaValidateSource($schema, LIBXML_SCHEMA_CREATE);
39
- //       $this->manifest->resolveExternals = true;
40
- //       $this->manifest->substituteEntities = true;
40
+        // $schema = SCORMTools::getSchemaSource();
41
+        // $this->manifest->schemaValidateSource($schema, LIBXML_SCHEMA_CREATE);
42
+        // $this->manifest->resolveExternals = true;
43
+        // $this->manifest->substituteEntities = true;
41 44
     }
42
-/**
43
- * renvoi un item ou une organization (qui se comporte exactement comme l'item et qui a la particularité
44
- * d'etre racine d'un arbre d'item) Normalement tous les objets item ou organization doivent avoir
45
- * un attribut identifier (sinon le schema est à rejeter SCORM2004)
46
- *
47
- * @param string $identifier identifiant de l'item/organization
48
- * @return \DOMElement|null
49
- */
45
+    
46
+    /**
47
+     * renvoi un item ou une organization (qui se comporte exactement comme l'item et qui a la particularité
48
+     * d'etre racine d'un arbre d'item) Normalement tous les objets item ou organization doivent avoir
49
+     * un attribut identifier (sinon le schema est à rejeter SCORM2004)
50
+     *
51
+     * @param string $identifier identifiant de l'item/organization
52
+     * @return \DOMElement|null
53
+     */
50 54
     public function getItemByIdentifier(string $identifier) : ?\DOMElement
51 55
     {
52 56
         $value = null; // valeur de l'attribut
@@ -57,6 +61,38 @@ abstract class DOMSCORM implements DOMPackageInterface
57 61
         return $value;
58 62
     }
59 63
 
64
+    /**
65
+     * Retourne le premier titre trouvé dans le manifest
66
+     *
67
+     * @return string
68
+     */
69
+    public function getTitle()
70
+    {
71
+        $value = null; // valeur de l'attribut
72
+        $nodeList = $this->xpath->query('//*[name()="title"]');
73
+        
74
+        $count = $nodeList->length;
75
+        for ($i = 0; $i < $count; ++$i) {
76
+            $value = $nodeList->item($i);
77
+            if (!empty($value)) {
78
+                break;
79
+            }
80
+        }
81
+
82
+        return $value;
83
+    }
84
+
85
+    /**
86
+     * Retourne le standard du paquet associé au DOM
87
+     * Doit être surchargée
88
+     *
89
+     * @return string
90
+     */
91
+    public function getStandard()
92
+    {
93
+        return false;
94
+    }
95
+
60 96
     /**
61 97
      * extrait le manifest d'un paquet scorm
62 98
      *
@@ -71,4 +107,42 @@ abstract class DOMSCORM implements DOMPackageInterface
71 107
         return $XMLmanifest;
72 108
     }
73 109
 
110
+    public static function defineStandard(string $xmlManifest) : string
111
+    {
112
+        // Création de xpath pour récupérer la balise standard
113
+        $domDoc = new \DOMDocument();
114
+        $domDoc->validateOnParse = true;
115
+        $domDoc->loadXML($xmlManifest);
116
+        $xpath = new \DOMXPath($domDoc);
117
+
118
+        // Récupération du schéma
119
+        $schemaVersion = null;
120
+        $nodeList = $xpath->query('//*[name()="schemaversion"]');
121
+        $count = $nodeList->length;
122
+        for ($i = 0; $i < $count; ++$i) {
123
+            $schemaVersion = $nodeList->item($i);
124
+            if (!empty($schemaVersion)) {
125
+                break;
126
+            }
127
+        }
128
+        // Dans le cas où aucune données n'a été trouvée, on est alors dans le cas d'un paquet SCORM 1.2 (fait n'importe comment),
129
+        // SCORM 2004 impose la présence du schema et de sa version dans les métadonnées du manifest
130
+        $schemaVersion = $schemaVersion ?? '1.2';
131
+
132
+        $standard = null;
133
+        switch ($schemaVersion) {
134
+            //2004 1st Edition does not exists
135
+            case 'CAM 1.3': //2004 2nd Edition (WTF ADL??)
136
+            case '2004 3rd Edition':
137
+            case '2004 4th Edition':
138
+                $standard = self::SCORM_2004;
139
+                break;
140
+                
141
+            case '1.2':
142
+            default:
143
+                $standard = self::SCORM_12;
144
+        }
145
+        
146
+        return $standard;
147
+    }
74 148
 }

+ 15
- 4
LearningModels/DOMSCORM2004.php View File

@@ -7,10 +7,10 @@ use PHPUnit\Runner\Exception;
7 7
 class DOMSCORM2004 extends DOMSCORM
8 8
 {
9 9
 
10
-/**
11
- *  *
12
- * @param string $XMLManifest
13
- */
10
+    /**
11
+     *  *
12
+     * @param string $XMLManifest
13
+     */
14 14
     public function __construct(string $XMLManifest)
15 15
     {
16 16
         parent::__construct($XMLManifest);
@@ -947,4 +947,15 @@ class DOMSCORM2004 extends DOMSCORM
947 947
 
948 948
         return $isPrimary;
949 949
     }
950
+
951
+    /**
952
+     * Retourne le standard du paquet associé au DOM
953
+     * Méthode surchargée
954
+     *
955
+     * @return string
956
+     */
957
+    public function getStandard()
958
+    {
959
+        return DOMSCORM::SCORM_2004;
960
+    }
950 961
 }

+ 42
- 43
LearningModels/SCORMTools.php View File

@@ -13,6 +13,7 @@ class SCORMTools
13 13
      * @var array
14 14
      */
15 15
     private static $attributes = null;
16
+
16 17
     /**
17 18
      * memoire cache des nomtags avec pour clef le nom de l'attribut (utilisé par getAttributeDefaultValue)
18 19
      * les homonymes sont séparés par des virgules
@@ -56,10 +57,9 @@ class SCORMTools
56 57
         libxml_clear_errors();
57 58
         $racine = __DIR__.'/SCORM2004/xsd/4th';
58 59
 
59
-// verification pour chacun des fichier xsd
60
+        // verification pour chacun des fichier xsd
60 61
 
61 62
         $source = SCORMTools::getSchemaSource();
62
-    // CA MARCHE
63 63
 
64 64
         $isValide = $dom->schemaValidateSource($source);
65 65
         SCORMTools::libxmlDisplayErrors($analyse);
@@ -79,14 +79,15 @@ class SCORMTools
79 79
         }
80 80
         return $analyse;
81 81
     }
82
-/**
83
- * construction du fichier xsd permettant d'évaluer le manifest.
84
- * Si un paquet est fournit en entrée ce sont ses xsd qui sont inclus, sinon ce sont les xsd
85
- * par defaut
86
- *
87
- * @param string $packageZipName
88
- * @return string
89
- */
82
+
83
+    /**
84
+     * construction du fichier xsd permettant d'évaluer le manifest.
85
+     * Si un paquet est fournit en entrée ce sont ses xsd qui sont inclus, sinon ce sont les xsd
86
+     * par defaut
87
+     *
88
+     * @param string $packageZipName
89
+     * @return string
90
+     */
90 91
     public static function getSchemaSource(string $packageZipName = null, string $SCORMVersion = null) : string
91 92
     {
92 93
         $files = array(); // clef nom du fichier, valeur namespace (tableau à contrsuire)
@@ -114,14 +115,14 @@ class SCORMTools
114 115
         }
115 116
         //preparation de la chaine de retour
116 117
         $source = '<?xml version="1.0" encoding="utf-8" ?>
117
-<xsd:schema xmlns="http://symfony.com/schema"
118
-    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
119
-    targetNamespace="http://symfony.com/schema"
120
-    elementFormDefault="qualified">
118
+    <xsd:schema xmlns="http://symfony.com/schema"
119
+        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
120
+        targetNamespace="http://symfony.com/schema"
121
+        elementFormDefault="qualified">
121 122
 
122
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace"/>
123
-'.$imports.'
124
-</xsd:schema>';
123
+        <xsd:import namespace="http://www.w3.org/XML/1998/namespace"/>
124
+        '.$imports.'
125
+    </xsd:schema>';
125 126
         return $source;
126 127
     }
127 128
 
@@ -221,21 +222,21 @@ class SCORMTools
221 222
 EOT;
222 223
     }
223 224
 
224
-/**
225
- * renvoi la valeur par défaut d'un attribut, pour les homonymes d'attribut renvoie un tableau
226
- * associatif, la clef étant le nom du tag, la valeur, celle de l'attribut
227
- * Exemple pour 'operator' :
228
- *      ['imsss:ruleCondition' => 'noOp',
229
- *      'imsss:rollupCondition' => 'noOp']
230
- * lorsque le nom de l'attribut est ecrit sous la forme : nomtag/nomattibut la recherche est filtrée
231
- * avec nom tag. Cela permet de resoudre les cas d'homonyme comme est de renvoyer uniuqment la valeur:
232
- *  imsss:rollupConditions@conditionCombination
233
- *  imsss:ruleConditions@conditionCombination
234
- *
235
- * @param string $attributeName
236
- * @param string $SCORMVersion
237
- * @return string|null|array
238
- */
225
+    /**
226
+     * renvoi la valeur par défaut d'un attribut, pour les homonymes d'attribut renvoie un tableau
227
+     * associatif, la clef étant le nom du tag, la valeur, celle de l'attribut
228
+     * Exemple pour 'operator' :
229
+     *      ['imsss:ruleCondition' => 'noOp',
230
+     *      'imsss:rollupCondition' => 'noOp']
231
+     * lorsque le nom de l'attribut est ecrit sous la forme : nomtag/nomattibut la recherche est filtrée
232
+     * avec nom tag. Cela permet de resoudre les cas d'homonyme comme est de renvoyer uniuqment la valeur:
233
+     *  imsss:rollupConditions@conditionCombination
234
+     *  imsss:ruleConditions@conditionCombination
235
+     *
236
+     * @param string $attributeName
237
+     * @param string $SCORMVersion
238
+     * @return string|null|array
239
+     */
239 240
     public static function getAttributeDefaultValue(string $attributeName, string $SCORMVersion = null)
240 241
     {
241 242
         $tagName= null; // initialisation, puis eventuelle isolation du tagName
@@ -304,10 +305,8 @@ EOT;
304 305
         return $values;
305 306
     }
306 307
 
307
-
308 308
     protected function validatePackage(string $XMLManifest) : bool
309 309
     {
310
- 
311 310
     }
312 311
 
313 312
     private static function libxmlDisplayErrors(array &$errorList)
@@ -343,15 +342,15 @@ EOT;
343 342
         libxml_clear_errors();
344 343
     }
345 344
 
346
-/**
347
- * mecanisme d'erreur spécial pour loadXML
348
- *
349
- * @param [type] $errno
350
- * @param [type] $errstr
351
- * @param [type] $errfile
352
- * @param [type] $errline
353
- * @return void
354
- */
345
+    /**
346
+     * mecanisme d'erreur spécial pour loadXML
347
+     *
348
+     * @param [type] $errno
349
+     * @param [type] $errstr
350
+     * @param [type] $errfile
351
+     * @param [type] $errline
352
+     * @return void
353
+     */
355 354
     final public static function handleXmlError($errno, $errstr, $errfile, $errline)
356 355
     {
357 356
         if ($errno==E_WARNING && (substr_count($errstr, "DOMDocument::loadXML()") >0)) {

+ 64
- 0
Package/PackageValidator.php View File

@@ -0,0 +1,64 @@
1
+<?php
2
+
3
+namespace Logipro\Bundle\SCORMBundle\Package;
4
+
5
+class PackageValidator
6
+{
7
+    /**
8
+     * Méthode outil premettant de valider un paquet e-learning
9
+     * le standard est défini et la validation adéquat appliquée
10
+     *
11
+     * @param string $zipPath
12
+     *
13
+     * @return array
14
+     */
15
+    public static function validatePackage($zipPath)
16
+    {
17
+        $response = array(
18
+            'standard' => null,
19
+            'title' => null,
20
+            'validation' => null
21
+        );
22
+
23
+    // Identification du standard
24
+        // Accès au contenu du zip
25
+        $zip = new \ZipArchive();
26
+        $result = $zip->open($zipPath);
27
+
28
+        if ($result !== true) {
29
+            return sprintf("L'ouverture du ZIP a échoué avec le code : %d", $result);
30
+        }
31
+
32
+        // Dans un premier temps on ne considère que SCORM
33
+        // On recherche donc un fichier 'imsmanifest.xml'
34
+
35
+        // Récupération du manifest
36
+        $manifest = $zip->getFromName('imsmanifest.xml');
37
+        $zip->close();
38
+        $zipName = pathinfo($zipPath)['filename'];
39
+
40
+        if ($manifest !== false) {
41
+            // SCORM
42
+            $dom = DOMLearningModel::getInstance($zipName, $manifest);
43
+        } else {
44
+            // Si pas de imsmanifest.xml --> possible autre standard
45
+            return null;
46
+        }
47
+
48
+        // Si standard identifié, on peut passé à la validation du xml
49
+        if ($dom) {
50
+            $response['standard'] = $dom->getStandard();
51
+            $response['title'] = $dom->getTitle();
52
+
53
+// @TODO Validation XML reportée
54
+            // $response['validation'] = $dom->validate();
55
+            $response['validation'] = array(
56
+                'status' => true
57
+            );
58
+        } else {
59
+            return null;
60
+        }
61
+
62
+        return $response;
63
+    }
64
+}

+ 0
- 1
Resources/config/doctrine/Course.orm.xml View File

@@ -13,7 +13,6 @@
13 13
 		
14 14
 		<field name="creationDate" column="creation_date" type="datetimetz" />
15 15
         <field name="updateDate" column="updateDate" type="datetimetz" />
16
-		<field name="type" column="type" type="string" length="50" />
17 16
 		<field name="maxVersion" column="max_version" type="integer" />
18 17
 		<field name="versionRule" column="version_rule" type="string" length="50" />
19 18
 		<field name="courseKey" column="course_key" type="string" length="255" />

+ 1
- 1
Resources/config/doctrine/ZipFile.orm.xml View File

@@ -15,7 +15,7 @@
15 15
 		<field name="zipFileprint" column="zip_fileprint" type="string" length ="50" />
16 16
         <field name="uploadDate" column="upload_date" type="datetime" />
17 17
 		<field name="endUploadDate" column="end_upload_date" type="datetime" />
18
-		<field name="filePath" column="file_path" type="string" length ="255" />
18
+		<field name="standard" column="standard" type="string" length="50" />
19 19
 		<field name="importStatus" column="import_status" type="string" length ="50" />
20 20
 
21 21
 		<!-- liaison entre cours et fichier zip -->

+ 97
- 114
Services/ScormEngine.php View File

@@ -1,16 +1,17 @@
1 1
 <?php
2 2
 namespace Logipro\Bundle\SCORMBundle\Services;
3 3
 
4
-use Logipro\Bundle\SCORMBundle\Entity\Course;
4
+use Doctrine\ORM\EntityManagerInterface;
5 5
 
6 6
 
7
+use Logipro\Bundle\SCORMBundle\Entity\Course;
7 8
 use Logipro\Bundle\SCORMBundle\Entity\Learner;
9
+use Logipro\Bundle\SCORMBundle\Entity\ZipFile;
8 10
 use Doctrine\Common\Persistence\ManagerRegistry;
9
-use Doctrine\ORM\EntityManagerInterface;
10 11
 use Logipro\Bundle\SCORMBundle\Entity\Registration;
11 12
 use Logipro\Bundle\SCORMBundle\Entity\MapCourseZipfile;
13
+use Logipro\Bundle\SCORMBundle\Package\PackageValidator;
12 14
 use Logipro\Bundle\SCORMBundle\Entity\RegistrationAttempt;
13
-use Logipro\Bundle\SCORMBundle\Entity\ZipFile;
14 15
 use Symfony\Component\DependencyInjection\ContainerInterface;
15 16
 use Symfony\Component\DependencyInjection\ContainerAwareTrait;
16 17
 use Logipro\Bundle\SCORMBundle\Package\Common\PackageTypeDetector;
@@ -30,14 +31,18 @@ class ScormEngine implements ContainerAwareInterface
30 31
     // ACTIVITÉ
31 32
 
32 33
     /**
33
-     * Crée une activité à partir d'un package
34
+     * Crée un cours à partir d'un package identifié par un chemin
35
+     *
36
+     * @param string $courseKey
37
+     * @param string $zipPath
38
+     * @param bool $analyse
39
+     * @param string $versioningRule
34 40
      *
35 41
      * @return int
36 42
      */
37
-    public function createCourse(string $zipPath, string $versioningRule = Course::VERSIONING_RULE_DEFAULT)
43
+    public function createCourse(string $courseKey, string $zipPath, bool $analyse, string $versioningRule = Course::VERSIONING_RULE_DEFAULT)
38 44
     {
39
-        $em = $this->getDoctrine()->getManager();
40
-
45
+        // Création de la réponse
41 46
         $response = array(
42 47
             'code' => 200,
43 48
             'isSuccessfullyCreated' => false,
@@ -55,132 +60,110 @@ class ScormEngine implements ContainerAwareInterface
55 60
                 'duration' => ''
56 61
             )
57 62
         );
63
+        
64
+        // Controle sur la clef fournie (elle doit etre non null et non existante en BD)
65
+        if (!empty($courseKey)) {
66
+            $em = $this->getDoctrine()->getManager();
58 67
 
59
-        // Test de la non existance de l'id
60
-        $course = $this->requireCourse($courseId);
61
-        if (!empty($course)) {
62
-            $response['code'] = 400;
63
-            $response['error'] = 'Cours déjà existant';
64
-            return $response;
65
-        }
68
+            $courseRepository = $em->getRepository(Course::class);
69
+            $course = $courseRepository->findOneBy(array('courseKey' => $courseKey));
66 70
 
67
-    // ZIP
68
-        // Test de l'existence du fichier
69
-        if (!file_exists($zipPath)) {
70
-            $response['code'] = 400;
71
-            $response['error'] = 'le chemin ne pointe pas vers un paquet valide';
72
-            return $response;
73
-        }
71
+            if ($course) {
72
+                $response['code'] = 400;
73
+                $response['error'] = 'Clef de cours déjà existante';
74
+                return $response;
75
+            }
74 76
 
75
-        // Récupération de la signature du zip
76
-        $hash = md5_file($zipPath);
77
-
78
-        // Test de l'existence de la signature
79
-        $repository = $em->getRepository(ZipFile::class);
80
-        $zipFile = $repository->findOneBy(['zipFileprint' => $hash]);
81
-        $response['metadata']['isAlreadyExisting'] = true;
82
-
83
-        // si le fichier n'existe pas déjà on le crée et on le stock coté moteur
84
-        if (empty($zipFile)) {
85
-            $response['metadata']['isAlreadyExisting'] = false;
86
-
87
-            //upload du fichier coté moteur
88
-            $uploadDate = new \DateTime('NOW');
89
-            $uploadPath = $this->container->getParameter('kernel.root_dir');
90
-            $fileName = pathinfo($zipPath)['filename'];
91
-            $filePath = $uploadPath . $fileName;
92
-            if (copy($zipPath, $filePath) === false) {
93
-                // Si la copie plante, on retourne une erreur
77
+        // ZIP
78
+            // Test de l'existence du fichier
79
+            if (!file_exists($zipPath)) {
94 80
                 $response['code'] = 400;
95
-                $response['error'] = 'Erreur lors de la copie du fichier zip';
81
+                $response['error'] = 'le chemin ne pointe pas vers un paquet valide';
96 82
                 return $response;
97 83
             }
98
-            $endUploadDate = new \DateTime('NOW');
99
-
100
-            // Création d'un objet permettant de traiter le fichier zip
101
-            $zipFile = new ZipFile();
102
-            $zipFile->setZipFileName($fileName);
103
-            $zipFile->setZipFileprint($hash);
104
-            $zipFile->setUploadDate($uploadDate);
105
-            $zipFile->setEndUploadDate($endUploadDate);
106
-            $zipFile->setFilePath($filePath);
107
-            $zipFile->setImportStatus(ZipFile::IMPORT_STATUS_PROCESSING);
108
-
109
-            $em->persist($zipFile);
110
-        }
111 84
 
112
-        // Recherche des metadonnées du paquet
113
-        $detector = new PackageTypeDetector($zipFile->getFilePath());
114
-        $response['metadata']['standard'] = $detector->detectPackageType();
115
-        $response['metadata']['title'] = $detector->getTitle();
85
+            // Validation du Package
86
+            $validation = PackageValidator::validatePackage($zipPath);
116 87
 
117
-    // COURS
118
-        // Création du cours
119
-        $course = new Course($courseId);
120
-        $course->setType($response['metadata']['standard']);
121
-        $course->setVersionRule($versioningRule);
122
-        $em->persist($course);
88
+            if (!$validation['validation']['status']) {
89
+                return $response;
90
+            }
123 91
 
124
-        // Métadonées du cours
125
-        $response['course']['courseId'] = $courseId;
126
-        $response['course']['maxVersion'] = $course->getMaxVersion();
92
+            $response['metadata']['standard'] = $validation['standard'];
93
+            $response['metadata']['title'] = $validation['title'];
127 94
 
128
-    // Mapping Zip/Cours
95
+            // Récupération de la signature du zip
96
+            $hash = md5_file($zipPath);
129 97
 
130
-        $mapping = new MapCourseZipfile();
131
-        $mapping->setCourse($course);
132
-        $mapping->setZipFile($zipFile);
133
-        $mapping->setVersion($response['course']['maxVersion']);
134
-        $em->persist($mapping);
98
+            // Test de l'existence de la signature
99
+            $repository = $em->getRepository(ZipFile::class);
100
+            $zipFile = $repository->findOneBy(['zipFileprint' => $hash]);
101
+            $response['metadata']['isAlreadyExisting'] = !empty($zipFile);
135 102
 
136
-        $em->flush();
103
+            // On s'arrete ici si seule l'analyse du paquet est demandée
104
+            if ($analyse) {
105
+                return $response;
106
+            }
137 107
 
138
-        $response['isSuccessfullyCreated'] = true;
139
-        return $response;
140
-    }
108
+            // si le fichier n'existe pas déjà on le crée et on le stock coté moteur
109
+            if (empty($zipFile)) {
110
+                $response['metadata']['isAlreadyExisting'] = false;
111
+
112
+                //upload du fichier coté moteur
113
+                $uploadDate = new \DateTime('NOW');
114
+// A remplacer par les config                
115
+                $uploadPath = $this->container->getParameter('kernel.root_dir');
116
+                $fileName = pathinfo($zipPath)['filename'];
117
+                $filePath = $uploadPath . $fileName;
118
+                if (copy($zipPath, $filePath) === false) {
119
+                    // Si la copie plante, on retourne une erreur
120
+                    $response['code'] = 400;
121
+                    $response['error'] = 'Erreur lors de la copie du fichier zip';
122
+                    return $response;
123
+                }
124
+                $endUploadDate = new \DateTime('NOW');
125
+
126
+                // Création d'un objet permettant de traiter le fichier zip
127
+                $zipFile = new ZipFile();
128
+                $zipFile->setZipFileName($fileName);
129
+                $zipFile->setZipFileprint($hash);
130
+                $zipFile->setUploadDate($uploadDate);
131
+                $zipFile->setEndUploadDate($endUploadDate);
132
+                $zipFile->setStandard($validation['standard']);
133
+                $zipFile->setImportStatus(ZipFile::IMPORT_STATUS_PROCESSING);
134
+
135
+                $em->persist($zipFile);
136
+            }
141 137
 
142
-     /**
143
-     * Crée une activité à partir d'un package
144
-     *
145
-     * @return int
146
-     */
147
-    public function createMockCourse(string $courseKey, string $zipPath, string $versioningRule = Course::VERSIONING_RULE_DEFAULT)
148
-    {
149
-        $em = $this->getDoctrine()->getManager();
150
-        
151
-        // Récupération de la signature du zip
152
-        $hash = md5($zipPath);
153
-
154
-        // Test de l'existence de la signature
155
-        $repository = $em->getRepository(ZipFile::class);
156
-        $zipFile = $repository->findOneBy(['zipFileprint' => $hash]);
157
-        $response['metadata']['isAlreadyExisting'] = true;
158
-
159
-        // si le fichier n'existe pas déjà on le crée et on le stock coté moteur
160
-        if (empty($zipFile)) {
161
-            $response['metadata']['isAlreadyExisting'] = false;
162
-
163
-            //upload du fichier coté moteur
164
-            $uploadDate = new \DateTime('NOW');
165
-            $fileName = pathinfo($zipPath)['filename'];
166
-            $endUploadDate = new \DateTime('NOW');
167
-
168
-            // Création d'un objet permettant de traiter le fichier zip
169
-            $zipFile = new ZipFile();
170
-            $zipFile->setZipFileName($fileName);
171
-            $zipFile->setZipFileprint($hash);
172
-            $zipFile->setUploadDate($uploadDate);
173
-            $zipFile->setEndUploadDate($endUploadDate);
174
-            $zipFile->setFilePath('filePath');
175
-            $zipFile->setImportStatus(ZipFile::IMPORT_STATUS_PROCESSING);
176
-
177
-            $em->persist($zipFile);
138
+        // COURS
139
+            // Création du cours
140
+            $course = new Course($courseId);
141
+            $course->setVersionRule($versioningRule);
142
+            $em->persist($course);
143
+
144
+            // Métadonées du cours
145
+            $response['course']['courseId'] = $courseId;
146
+            $response['course']['maxVersion'] = $course->getMaxVersion();
147
+
148
+        // Mapping Zip/Cours
149
+
150
+            $mapping = new MapCourseZipfile();
151
+            $mapping->setCourse($course);
152
+            $mapping->setZipFile($zipFile);
153
+            $mapping->setVersion($response['course']['maxVersion']);
154
+            $em->persist($mapping);
155
+
156
+            $em->flush();
157
+
158
+            $response['isSuccessfullyCreated'] = true;
178 159
         }
179 160
 
161
+        return $response;
162
+    }
163
+
180 164
     // COURS
181 165
         // Création du cours
182 166
         $course = new Course();
183
-        $course->setType(Course::SCORM_2004);
184 167
         $course->setVersionRule($versioningRule);
185 168
         $course->setCourseKey($courseKey);
186 169
         $em->persist($course);

Loading…
Cancel
Save