@fixed evaluations

Form/JupyterCreateType.php

@@ -21,11 +21,11 @@ class JupyterCreateType extends AbstractType
 			'required' => true,
 		));
 
-		/*$builder->add('isAssesment', SwitchType::class, array(
+		$builder->add('isAssesment', SwitchType::class, array(
 			'required' => false, 
 			'label_attr' => array('class' => 'checkbox-custom'),
 			'label' => 'Evaluation'
-		));*/
+		));
 	}
 
 	public function configureOptions(OptionsResolver $resolver)

Form/JupyterUpdateType.php

@@ -40,11 +40,11 @@ class JupyterUpdateType extends SequenceItemUpdateType
 			'required' => false
 		));
 
-		/*$builder->add('isAssesment', SwitchType::class, array(
+		$builder->add('isAssesment', SwitchType::class, array(
 			'required' => false, 
 			'label_attr' => array('class' => 'checkbox-custom'),
 			'label' => 'Evaluation'
-		));*/
+		));
 
 		
 		$builder->add('isOptional', SwitchType::class, array(

Resources/views/back-office/formCreate.html.twig

@@ -5,11 +5,11 @@
             <label for="jupyter_create_title" class="required">Titre</label>
             {{ form_widget(form.title)}}
         </div>
-<!--
+
         <div class="form-group">
-            {# form_row(form.isAssesment) #}
+            {{ form_row(form.isAssesment) }}
         </div>
-        -->
+
     </fieldset>
 </div>
 

Resources/views/back-office/formUpdate.html.twig

@@ -16,7 +16,7 @@
         </div>
         <div class="form-group">
             {{ form_row(form.isOptional) }}
-            {# form_row(form.isAssesment) #}
+            {{ form_row(form.isAssesment) }}
         </div>
     </fieldset>
 

Services/PhoenixServices.php

@@ -23,6 +23,8 @@ use Logipro\Bundle\PhoenixJupyterBundle\Services\ApiLayer\ApiLayerService;
 use Logipro\Bundle\PhoenixJupyterBundle\Services\Uploader\NotebookUploader;
 
 use Symfony\Component\HttpFoundation\JsonResponse;
+use Logipro\Bundle\PhoenixJupyterBundle\Entity\JupyterSubmission;
+use Logipro\Phoenix\Entity\Sequence;
 
 class PhoenixServices extends Services
 {
@@ -30,67 +32,60 @@ class PhoenixServices extends Services
 	private $isAvalaible;
 	private $layoutPath = '@LogiproPhoenixJupyter/back-office/';
 
-	public function __construct
-	(
+	public function __construct(
 		FormFactoryInterface $formFactory,
 		EntityManagerInterface $manager,
 		RouterInterface $router,
 		ApiLayerService $layer,
 		NotebookUploader $uploader
-	)
-	{
-		parent::__construct($formFactory,$manager,$router);
+	) {
+		parent::__construct($formFactory, $manager, $router);
 
 		$this->layer = $layer;
 		$this->uploader = $uploader;
 	}
 
-    /**
-     * retourne le chemin de la classe de l'entité du bundle
-     * @return string
-     */
-    public function getEntityClass() : string
-    {
-        return JupyterVirtualClassroom::class;
+	/**
+	 * retourne le chemin de la classe de l'entité du bundle
+	 * @return string
+	 */
+	public function getEntityClass(): string
+	{
+		return JupyterVirtualClassroom::class;
 	}
-	
+
 	public function serviceIsAvalaible()
 	{
-		if (is_null($this->isAvalaible))
-		{
+		if (is_null($this->isAvalaible)) {
 			$this->isAvalaible = $this->layer->serviceIsAvalaible();
 		}
 		return $this->isAvalaible;
 	}
 
-    protected function getApiService()
-    {
-		if (!$this->isAvalaible)
-		{
+	protected function getApiService()
+	{
+		if (!$this->isAvalaible) {
 			$this->isAvalaible = $this->layer->serviceIsAvalaible();
 		}
-		
-		if ($this->isAvalaible)
-		{
+
+		if ($this->isAvalaible) {
 			return $this->layer;
-		}
-		else
-		{
+		} else {
 			throw new \Exception('Service Jupyter indisponible');
 		}
 		return null;
-    }
-
-    /**
-     * créé le serveur distant jupyter et persist le token si créé
-     *
-     * @param JupyterVirtualClassroom $jupyter
-     * @param string $fromurl
-     * @param string $notebookContent
-     * 
-     * @return string
-     */
-    private function createTrainerJupyterServer(JupyterVirtualClassroom $jupyter,$fromurl = null,$notebookContent = null,$useUrl = true) : string
+	}
+
+	/**
+	 * créé le serveur distant jupyter et persist le token si créé
+	 *
+	 * @param JupyterVirtualClassroom $jupyter
+	 * @param string $fromurl
+	 * @param string $notebookContent
+	 * 
+	 * @return string
+	 */
+	private function createTrainerJupyterServer(JupyterVirtualClassroom $jupyter, $fromurl = null, $notebookContent = null, $useUrl = true): string
 	{
 		ignore_user_abort(true);
 
@@ -98,49 +93,45 @@ class PhoenixServices extends Services
 		$trainer = $jupyter->getTrainer();
 		$repository = $this->getRepository(JupyterToken::class);
 		$token = $repository->findOneBy(array('person' => $trainer));
-		if (is_null($token))
-		{
+		if (is_null($token)) {
 			$token = new JupyterToken();
 			$token->setPerson($trainer);
 		}
 		// test si l'utilisateur a déja un token
 		$manager = $this->getManager();
 		$layer = $this->getApiService();
-		$url = $layer->createTrainerServerIfNoneAndSetContent($jupyter,$token,$fromurl,$notebookContent,$useUrl);
+		$url = $layer->createTrainerServerIfNoneAndSetContent($jupyter, $token, $fromurl, $notebookContent, $useUrl);
 
 		// persiste l'entité créé
-		if ($token && !$token->getTokenId())
-		{
+		if ($token && !$token->getTokenId()) {
 			$manager->persist($token);
-        }
-        return $url;
-    }
+		}
+		return $url;
+	}
 
-    /**
+	/**
 	 * retourne le token d'un utilisateur
 	 * 
 	 * @param Person $person
 	 * @return JupyterToken/null
 	 */
-	protected function getToken(Person $person)
+	protected function getToken(Person $person): JupyterToken
 	{
 		$tokenRepository = $this->getRepository(JupyterToken::class);
 		return $tokenRepository->findOneBy(array('person' => $person));
 	}
 
 	/**
-     * demarre le serveur
-     * 
+	 * demarre le serveur
+	 * 
 	 * @return array: isStarted: dit si le serveur était déja démarré, result: dit si le serveur a été démarré
 	 */
 	protected function startServer(Person $person)
 	{
 		$layer = $this->getApiService();
-		if ($layer)
-		{
+		if ($layer) {
 			$token = $this->getToken($person);
-			if ($token)
-			{
+			if ($token) {
 				$response = $layer->startServer($token);
 				return $response;
 			}
@@ -149,13 +140,13 @@ class PhoenixServices extends Services
 	}
 
 
-    /**
-     * retourne les informations du formateur à partir de la classe
-     *
-     * @param JupyterVirtualClassroom $sequenceItem
-     * @return Array
-     */
-    protected function getTrainerDatasBySequenceItem(JupyterVirtualClassroom $sequenceItem) : array
+	/**
+	 * retourne les informations du formateur à partir de la classe
+	 *
+	 * @param JupyterVirtualClassroom $sequenceItem
+	 * @return Array
+	 */
+	protected function getTrainerDatasBySequenceItem(JupyterVirtualClassroom $sequenceItem): array
 	{
 		$idTrainer = 0;
 		$initials = '';
@@ -165,17 +156,16 @@ class PhoenixServices extends Services
 		$avatar = '';
 		$visibleInformation = '';
 
-        $trainer = $sequenceItem->getTrainer();
-        
-        // test si le formateu est présent
-		if ($trainer) 
-		{
+		$trainer = $sequenceItem->getTrainer();
+
+		// test si le formateu est présent
+		if ($trainer) {
 			$idTrainer = $trainer->getPersonId();
 			$initials = $trainer->getInitials();
 			$fullName = $trainer->getFullName();
 			$email = $trainer->getEmail();
 			$telephone = $trainer->getTelephone();
-			$avatar = "";//$this->renderString("{{ phx_get_avatar(phx_uploader_asset(person,'imageFile'), initials, 'sm')|raw }}" , array('person' => $trainer, 'initials' => $trainer->getInitials()));
+			$avatar = ""; //$this->renderString("{{ phx_get_avatar(phx_uploader_asset(person,'imageFile'), initials, 'sm')|raw }}" , array('person' => $trainer, 'initials' => $trainer->getInitials()));
 			$visibleInformation = $trainer->getVisibleInformation();
 		}
 
@@ -191,80 +181,75 @@ class PhoenixServices extends Services
 	}
 
 
-    /**
-     * retourne le bouton pour ajouter le JupyterVirtualClassroom au parcours
-     * 
-     * @return ButtonLayer
-     */
-    public function getButton() : ButtonLayer
-    {
-        $button = new ButtonLayer();
-
-        $button->setImage('icon-jupyter.svg');
-        $button->setText('Jupyter');
-        $button->setClass('ali-EditorJupyterCreate');
-        $button->setHelp('Notebook Jupyter');
-
-        return $button;
-    }
-
-    /**
-     * retourne le code html de la modal pour ajouter un JupyterVirtualClassroom au aprcours
-     * 
-     * @return ModalLayer
-     */
-    public function getModalAdd() : ModalLayer
-    {
-        $modal  = new ModalLayer();
-		
+	/**
+	 * retourne le bouton pour ajouter le JupyterVirtualClassroom au parcours
+	 * 
+	 * @return ButtonLayer
+	 */
+	public function getButton(): ButtonLayer
+	{
+		$button = new ButtonLayer();
+
+		$button->setImage('icon-jupyter.svg');
+		$button->setText('Jupyter');
+		$button->setClass('ali-EditorJupyterCreate');
+		$button->setHelp('Notebook Jupyter');
+
+		return $button;
+	}
+
+	/**
+	 * retourne le code html de la modal pour ajouter un JupyterVirtualClassroom au aprcours
+	 * 
+	 * @return ModalLayer
+	 */
+	public function getModalAdd(): ModalLayer
+	{
+		$modal  = new ModalLayer();
+
 		$jupyter = new JupyterVirtualClassroom();
-        $form = $this->createForm(JupyterCreateType::class, $jupyter);
+		$form = $this->createForm(JupyterCreateType::class, $jupyter);
 
-        $modal->setTitle('Créer une activité Jupyter');
+		$modal->setTitle('Créer une activité Jupyter');
 		$modal->setCss('test_css.css');
 		$modal->setScript('back-office.js');
-		
-        $modal->setForm($form->createView());
-        $modal->setLayout($this->layoutPath . 'formCreate.html.twig');
-
-        return $modal;
-    }
-
-    /**
-     * valide le formulaire du ModalLayer et retourne l'identifiant du nouveau JupyterVirtualClassroom
-     * 
-     * @param Request $request
-     * @param Sequence $sequence
-     * @param int $order
-     * 
-     * @return int
-     */
-    public function validateModalAdd(Request $request,$sequence,$order)
-    {
-        $jupyter = new JupyterVirtualClassroom();
+
+		$modal->setForm($form->createView());
+		$modal->setLayout($this->layoutPath . 'formCreate.html.twig');
+
+		return $modal;
+	}
+
+	/**
+	 * valide le formulaire du ModalLayer et retourne l'identifiant du nouveau JupyterVirtualClassroom
+	 * 
+	 * @param Request $request
+	 * @param Sequence $sequence
+	 * @param int $order
+	 * 
+	 * @return int
+	 */
+	public function validateModalAdd(Request $request, Sequence $sequence, $order)
+	{
+		$jupyter = new JupyterVirtualClassroom();
 		$jupyter->setSequence($sequence);
 
 		$form = $this->createForm(JupyterCreateType::class, $jupyter);
 
 		// Traitement du POST
-		if ($request->isMethod('POST'))
-		{
+		if ($request->isMethod('POST')) {
 			// envoi post non ajax => 404
-			if (!$request->isXmlHttpRequest())
-			{
+			if (!$request->isXmlHttpRequest()) {
 				throw $this->createNotFoundException();
 			}
 
 			$form->handleRequest($request);
-			if ($form->isSubmitted())
-			{
-				if ($form->isValid())
-				{
+			if ($form->isSubmitted()) {
+				if ($form->isValid()) {
 					// créé la classe distante
 					$repository = $this->getRepository(Trainer::class);
 					$trainer = $jupyter->getTrainer();
-					if ($trainer)
-					{
+					if ($trainer) {
 						$jupyter->setTrainer($trainer);
 						$this->createTrainerJupyterServer($jupyter);
 					}
@@ -276,117 +261,110 @@ class PhoenixServices extends Services
 					$manager->flush();
 
 					return $jupyter->getSequenceItemId();
-				}
-				else
-				{
+				} else {
 					throw new \InvalidArgumentException($form->getErrors(true));
 				}
-			}
-			else
-			{
+			} else {
 				throw new \InvalidArgumentException($form->getErrors(true));
 			}
 		}
 		return null;
-    }
-
-    /**
-     * retourne les variables necessaire pour l'affichage du bloc au niveau du parcours
-     * 
-     * @return array
-     */
-    public function getBlocVariables($item)
-    {
-        return array(
-            'sequenceItemClass' => 'ali-SequenceJupyterClassroom',
-            'label' => 'Jupyter',
-            'imageClass' => 'ali-EditorJupyterEdit',
-            'image' => "bundles/logiprophoenixjupyter/images/icon-jupyter.svg",
-            'description' => 'toto',
-            'bottom_layout' => '@LogiproPhoenixJupyter/back-office/blocBottom.html.twig'
-        );
-    }
-
-    public function getLearningSpaceBlocVariables($item)
-    {
-        return array(
-            'middle_layout' => '@LogiproPhoenixJupyter/learning_space/blocMiddle.html.twig',
-            'bottom_layout' => '@LogiproPhoenixJupyter/learning_space/blocBottom.html.twig',
-            'hide_trainer' => true,
-            'image' => "bundles/logiprophoenixjupyter/images/icon-ls-jupyter.svg",
-            'type' => ($item->getIsAssesment())?'JupyterEval':'Jupyter',
-            'type_name' => ($item->getIsAssesment())?'Évaluation':'Jupyter',
-            'notebookname' => basename($item->getUrl()),
-        );
-    }
-
-    public function getLearningSpaceScript()
-    {
-        return 'bundles/logiprophoenixjupyter/Js/learning-space.js';
-    }
-
-    public function getLearningSpaceCss()
-    {
-        return 'bundles/logiprophoenixjupyter/Css/learning-space.css';
-    }
-
-
-    /**
-     * retourne le FormLayer pour l'édition du JupyterVirtualClassroom
-     * 
-     * @param JupyterVirtualClassroom $jupyterVirtualClassroom
-     * 
-     * @return FormLayer
-     */
-    public function getHtmlEdit(JupyterVirtualClassroom $jupyterVirtualClassroom) : FormLayer
-    {
-        $formLayer  = new FormLayer();
+	}
+
+	/**
+	 * retourne les variables necessaire pour l'affichage du bloc au niveau du parcours
+	 * 
+	 * @return array
+	 */
+	public function getBlocVariables($item)
+	{
+		return array(
+			'sequenceItemClass' => 'ali-SequenceJupyterClassroom',
+			'label' => 'Jupyter',
+			'imageClass' => 'ali-EditorJupyterEdit',
+			'image' => "bundles/logiprophoenixjupyter/images/icon-jupyter.svg",
+			'description' => 'toto',
+			'bottom_layout' => '@LogiproPhoenixJupyter/back-office/blocBottom.html.twig'
+		);
+	}
+
+	public function getLearningSpaceBlocVariables($item)
+	{
+		return array(
+			'middle_layout' => '@LogiproPhoenixJupyter/learning_space/blocMiddle.html.twig',
+			'bottom_layout' => '@LogiproPhoenixJupyter/learning_space/blocBottom.html.twig',
+			'hide_trainer' => true,
+			'image' => "bundles/logiprophoenixjupyter/images/icon-ls-jupyter.svg",
+			'type' => ($item->getIsAssesment()) ? 'JupyterEval' : 'Jupyter',
+			'type_name' => ($item->getIsAssesment()) ? 'Évaluation' : 'Jupyter',
+			'notebookname' => basename($item->getUrl()),
+		);
+	}
+
+	public function getLearningSpaceScript()
+	{
+		return 'bundles/logiprophoenixjupyter/Js/learning-space.js';
+	}
+
+	public function getLearningSpaceCss()
+	{
+		return 'bundles/logiprophoenixjupyter/Css/learning-space.css';
+	}
+
+
+	/**
+	 * retourne le FormLayer pour l'édition du JupyterVirtualClassroom
+	 * 
+	 * @param JupyterVirtualClassroom $jupyterVirtualClassroom
+	 * 
+	 * @return FormLayer
+	 */
+	public function getHtmlEdit(JupyterVirtualClassroom $jupyterVirtualClassroom): FormLayer
+	{
+		$formLayer  = new FormLayer();
 
 		$options['search_action'] = $this->generateUrl('nbo_user_search_trainer');
 		$options['replacement_value'] = $this->getTrainerDatasBySequenceItem($jupyterVirtualClassroom);
 
-		$form = $form = $this->createForm(JupyterUpdateType::class, $jupyterVirtualClassroom,$options);
+		$form = $form = $this->createForm(JupyterUpdateType::class, $jupyterVirtualClassroom, $options);
 
 		$formLayer->setForm($form);
 		$formLayer->setLayout($this->layoutPath . 'formUpdate.html.twig');
 
-        return $formLayer;
-    }
+		return $formLayer;
+	}
 
-    public function getRoutes()
-    {
-        return '@LogiproPhoenixJupyterBundle/Resources/config/routes.yaml';
-    }
+	public function getRoutes()
+	{
+		return '@LogiproPhoenixJupyterBundle/Resources/config/routes.yaml';
+	}
 
-    public function preFlush($request,$form,$sequenceItem)
-    {
+	public function preFlush($request, $form, $sequenceItem)
+	{
 		$personId = $form->get('person_id')->getData();
-        
-        // met en place le formateur
+
+		// met en place le formateur
 		$trainerRepository = $this->getRepository(Trainer::class);
 		$trainer = $trainerRepository->find($personId);
-		if ($trainer)
-		{
+		if ($trainer) {
 			$sequenceItem->setTrainer($trainer);
-		}
-		else {
+		} else {
 			$sequenceItem->removeTrainer();
 		}
 
-        // récupére kes informations de l'ancien formateur
+		// récupére kes informations de l'ancien formateur
 		$oldEntityData = $this->getManager()->getUnitOfWork()->getOriginalEntityData($sequenceItem);
 		$oldTrainer = $oldEntityData['trainer'];
 		$oldTitle = $oldEntityData['title'];
 
-        // test s'il y a un upload
+		// test s'il y a un upload
 		$upload = null;
 		$uploadedFile = $form['notebook']->getData();
-		if ($uploadedFile)
-		{
+		if ($uploadedFile) {
 			$upload = $this->uploader->upload($uploadedFile);
 		}
-		
-		
+
+
 		// calcul si le formateur a changé
 		$currentTrainer = $sequenceItem->getTrainer();
 		$trainerChanged = $oldTrainer != $currentTrainer;
@@ -398,91 +376,79 @@ class PhoenixServices extends Services
 		$mustStopServer = array();
 
 		// si le titre change ou si le formateur change ou si l'upload est rempli
-		if ($upload || $trainerChanged || $titleChanged)
-		{
+		if ($upload || $trainerChanged || $titleChanged) {
 			// calcul le contenu du notebook
 			$content = null;
-			if ($upload)
-			{
+			if ($upload) {
 				$content = $upload;
 			}
 			// on tente de récupérer le contenu du notebook de l'ancien formateur
-			elseif ($oldTrainer)
-			{
+			elseif ($oldTrainer) {
 				$response = $this->startServer($oldTrainer);
-				if (!$response['isStarted'])
-				{
+				if (!$response['isStarted']) {
 					$mustStopServer[] = $oldTrainer;
 				}
 			}
 
 			// si l'item a un formateur
-			if ($currentTrainer)
-			{
+			if ($currentTrainer) {
 				$fromUrl = null;
-				if ($oldTrainer)
-				{
+				if ($oldTrainer) {
 					$fromUrl = $oldEntityData['url'];
 				}
-				
+
 				// met en place le compte et le contenu du notebook
-				$url = $this->createTrainerJupyterServer($sequenceItem,$fromUrl,$content,false);
+				$url = $this->createTrainerJupyterServer($sequenceItem, $fromUrl, $content, false);
 
 				// calcul le nouvel url si le formateur a changé et/ou si le titre a changé
 				$sequenceItem->setUrl($url);
 			}
 			// il y avait un formateur et on l'a supprimé, donc le formateur n'a plu le notebook
-			elseif ($oldTrainer)
-			{
+			elseif ($oldTrainer) {
 				$layer = $this->getApiService();
-				$$oldToken = $this->getToken($oldTrainer);
-				if ($$oldToken)
-				{
+				$oldToken = $this->getToken($oldTrainer);
+				if ($$oldToken) {
 					$oldSequenceItem = new JupyterVirtualClassroom();
 					$oldSequenceItem->setUrl($oldEntityData['url']);
 					$oldSequenceItem->setSequence($sequenceItem->getSequence());
-					$layer->deleteNotebook($$oldToken,$oldSequenceItem);
+					$layer->deleteNotebook($$oldToken, $oldSequenceItem);
 				}
 			}
 		}
-		foreach ($mustStopServer as $token)
-		{
+		foreach ($mustStopServer as $token) {
 			// fixme a dev
 			//$layer->stopServer($token);
 		}
-    }
+	}
 
-    public function getManifestPath()
-    {
-        return 'vendor/logipro/PhoenixJupyterBundle/Resources/public/bundles/logiprophoenixjupyter/manifest.json';
-    }
+	public function getManifestPath()
+	{
+		return 'vendor/logipro/PhoenixJupyterBundle/Resources/public/bundles/logiprophoenixjupyter/manifest.json';
+	}
 
 
-    public function startTrainerServer(JupyterVirtualClassroom $classRoom) : string
-    {
+	public function startTrainerServer(JupyterVirtualClassroom $classRoom): string
+	{
 		// récupère le token du formateur
 		$trainer = $classRoom->getTrainer();
 		$jupyterToken = null;
-		if ($trainer)
-		{
+		if ($trainer) {
 			$jupyterToken = $this->getToken($trainer);
 		}
-		
+
 
 		// si pas de token, on tente de créé le serveur
 		$tokenExist = !is_null($jupyterToken);
-		if (!$tokenExist)
-		{
+		if (!$tokenExist) {
 			$jupyterToken = $this->createTrainerJupyterServer($classRoom);
-			$manager->flush();
-        }
-        
-        // demarre le serveur du formateur
+			$this->getManager()->flush();
+		}
+
+		// demarre le serveur du formateur
 		$this->startServer($classRoom->getTrainer());
 
-        // redirige sur jupyter
-		if ($jupyterToken)
-		{
+		// redirige sur jupyter
+		if ($jupyterToken) {
 			// calcul l'url d'accès au notebook
 			$apiService = $this->getApiService();
 			$classroomUrl = $apiService->getFolderUrlByNotebookUrl($classRoom->getUrl());
@@ -491,24 +457,22 @@ class PhoenixServices extends Services
 			$endUrl = $classroomUrl . '?token=' . $jupyterToken->getToken();
 
 			// ajoute le protocole
-			$scheme = parse_url ($_SERVER['JUPYTER_API_URL'],PHP_URL_SCHEME);
-			if (strpos('http',$endUrl) === false)
-			{
+			$scheme = parse_url($_SERVER['JUPYTER_API_URL'], PHP_URL_SCHEME);
+			if (strpos('http', $endUrl) === false) {
 				$endUrl = $scheme . '://' . $endUrl;
-            }
-            return $endUrl;
+			}
+			return $endUrl;
 		}
-        return "";
+		return "";
 	}
 
-	private function createStudentServer(Person $person,JupyterVirtualClassroom $sequenceItem) : string
+	private function createStudentServer(Person $person, JupyterVirtualClassroom $sequenceItem): string
 	{
 		$personToken = $this->getToken($person);
 		$trainerToken = $this->getToken($sequenceItem->getTrainer());
 
 		// créé le token apprenant s'il n'en a pas
-		if (!$personToken)
-		{
+		if (!$personToken) {
 			$personToken = new jupyterToken();
 			$personToken->setPerson($person);
 		}
@@ -516,39 +480,33 @@ class PhoenixServices extends Services
 		// créé le serveur de l'apprenant + met en place son cours
 		$layer = $this->getApiService();
 
-		/*if ($sequenceItem->getIsAssesment())
-		{
+		if ($sequenceItem->getIsAssesment()) {
 			// cours d'évaluation
-			$url = $layer->createStudentAssesmentServerIfNone($sequenceItem,$trainerToken,$personToken);
-		}
-		else
-		{*/
+			$url = $layer->createStudentAssesmentServerIfNone($sequenceItem, $trainerToken, $personToken);
+		} else {
 			// cours classique
-			$url = $layer->createStudentServerIfNoneAndSetContent($sequenceItem,$trainerToken,$personToken,true);
-		//}
+			$url = $layer->createStudentServerIfNoneAndSetContent($sequenceItem, $trainerToken, $personToken, true);
+		}
 
 		// persist le token s'il vient d'être créé
 		$manager = $this->getManager();
-		if (!$personToken->getTokenId())
-		{
+		if (!$personToken->getTokenId()) {
 			$manager->persist($personToken);
 		}
 
 		return $url;
-
 	}
-	
-	public function startStudentServer(JupyterVirtualClassroom $sequenceItem,Person $person) : string
+
+	public function startStudentServer(JupyterVirtualClassroom $sequenceItem, Person $person): string
 	{
 		// recherche l'inscription dans la classe jupyter
 		$jupyterClassroomRegistrationRepository = $this->getRepository(JupyterClassroomRegistration::class);
 
 		// recherche l'url pour l'apprenant de l'inscription
-		$jupyterClassroomRegistration = $jupyterClassroomRegistrationRepository->getLastClassroomRegistration($sequenceItem,$person);
+		$jupyterClassroomRegistration = $jupyterClassroomRegistrationRepository->getLastClassroomRegistration($sequenceItem, $person);
 		$registrationExist = !is_null($jupyterClassroomRegistration);
 
-		if (!$registrationExist)
-		{
+		if (!$registrationExist) {
 			// créé une nouvelle ClassroomRegistration pour cet apprenant
 			$jupyterClassroomRegistration = new JupyterClassroomRegistration();
 			$jupyterClassroomRegistration->setPerson($person);
@@ -557,12 +515,11 @@ class PhoenixServices extends Services
 			// récupère le contenu de la classe du formateur
 			$trainer = $sequenceItem->getTrainer();
 			$trainerToken = $this->getToken($trainer);
-			if (!$trainerToken)
-			{
+			if (!$trainerToken) {
 				throw new \Exception();
 			}
 
-			$url = $this->createStudentServer($person,$sequenceItem);
+			$url = $this->createStudentServer($person, $sequenceItem);
 
 			// met en place l'url de la ClassroomRegistration
 			$jupyterClassroomRegistration->setUrl($url);
@@ -575,28 +532,25 @@ class PhoenixServices extends Services
 
 		// demarre le serveur de l'apprenant
 		$response = $this->startServer($person);
-		
+
 		// récupère le token de l'apprenant
 		$personToken = $this->getToken($person);
 
 		// redirige sur jupyter
 		$classroomRegistrationUrl = $jupyterClassroomRegistration->getUrl();
 		$endUrl = $classroomRegistrationUrl . '?token=' . $personToken->getToken();
-		
+
 		// test si le notebook existe encore
-		if ($registrationExist)
-		{
+		if ($registrationExist) {
 			// s'il n'existe pas => on redirige l'utilisateur sur le dossier
 			$layer = $this->getApiService();
-			if (!$layer->notebookExist($personToken,$classroomRegistrationUrl))
-			{
+			if (!$layer->notebookExist($personToken, $classroomRegistrationUrl)) {
 				$endUrl = $layer->getFolderUrlByNotebookUrl($classroomRegistrationUrl);
 			}
 		}
 
-		$scheme = parse_url ($_SERVER['JUPYTER_API_URL'],PHP_URL_SCHEME);
-		if (strpos('http',$endUrl) === false)
-		{
+		$scheme = parse_url($_SERVER['JUPYTER_API_URL'], PHP_URL_SCHEME);
+		if (strpos('http', $endUrl) === false) {
 			$endUrl = $scheme . '://' . $endUrl;
 		}
 
@@ -611,7 +565,7 @@ class PhoenixServices extends Services
 	 * @param JupyterVirtualClassroom $sequenceItem
 	 * @return void
 	 */
-	public function sendStudentNotebookAndGetScore(JupyterVirtualClassroom $sequenceItem,Person $person)
+	public function sendStudentNotebookAndGetScore(JupyterVirtualClassroom $sequenceItem, Person $person)
 	{
 		$personToken = $this->getToken($person);
 
@@ -620,14 +574,13 @@ class PhoenixServices extends Services
 		// créé le serveur de l'apprenant + met en place son cours
 		$layer = $this->getApiService();
 		// met en place le score automatiquement
-		$data = $layer->sendStudentNotebook($trainerToken,$personToken,$sequenceItem);
+		$data = $layer->sendStudentNotebook($trainerToken, $personToken, $sequenceItem);
 
 		$jupyterClassroomRegistrationRepository = $this->getRepository(JupyterClassroomRegistration::class);
 
 		// recherche l'url pour l'apprenant de l'inscription
-		$jupyterClassroomRegistration = $jupyterClassroomRegistrationRepository->getLastClassroomRegistration($sequenceItem,$person);
-		if ($jupyterClassroomRegistration)
-		{
+		$jupyterClassroomRegistration = $jupyterClassroomRegistrationRepository->getLastClassroomRegistration($sequenceItem, $person);
+		if ($jupyterClassroomRegistration) {
 			// création de la soumission
 			$manager = $this->getManager();
 
@@ -639,7 +592,7 @@ class PhoenixServices extends Services
 		}
 
 		// supprime le notebook
-		$layer->deleteNotebook($personToken,$sequenceItem);
+		$layer->deleteNotebook($personToken, $sequenceItem);
 		$jupyterClassroomRegistration->setUrl(null);
 
 		$manager->flush();
@@ -647,23 +600,21 @@ class PhoenixServices extends Services
 		return $submission->getScoreFormat();
 	}
 
-	public function resetNotebook(JupyterVirtualClassroom $sequenceItem,Person $person) : bool
+	public function resetNotebook(JupyterVirtualClassroom $sequenceItem, Person $person): bool
 	{
 		$layer = $this->getApiService();
-		
+
 		$personToken = $this->getToken($person);
-		
+
 		$trainerToken = $this->getToken($sequenceItem->getTrainer());
 
 		// recherche l'url pour l'apprenant de l'inscription
 		$jupyterClassroomRegistrationRepository = $this->getRepository(JupyterClassroomRegistration::class);
-		$jupyterClassroomRegistration = $jupyterClassroomRegistrationRepository->getLastClassroomRegistration($sequenceItem,$person);
-		if (!$jupyterClassroomRegistration)
-		{
+		$jupyterClassroomRegistration = $jupyterClassroomRegistrationRepository->getLastClassroomRegistration($sequenceItem, $person);
+		if (!$jupyterClassroomRegistration) {
 			return false;
 		}
 
-		return $layer->resetNotebook($trainerToken,$personToken,$sequenceItem->getUrl(),$jupyterClassroomRegistration->getUrl());
+		return $layer->resetNotebook($trainerToken, $personToken, $sequenceItem->getUrl(), $jupyterClassroomRegistration->getUrl());
 	}
-    
 }