src/Controller/PersonCivilController.php line 49

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\PersonCivil;
  6. use App\Entity\Application;
  7. use App\Entity\CheckQr;
  8. use App\Entity\Device;
  9. use App\Entity\PersonAppIdentity;
  10. use App\Entity\PersonAuthHistory;
  11. use App\Form\PersonCivilType;
  12. use App\Repository\ApplicationRepository;
  13. use App\Repository\PersonAuthHistoryRepository;
  14. use App\Repository\PersonRepository;
  15. use App\Repository\PersonCivilRepository;
  16. use App\Repository\CheckQrRepository;
  17. use App\Repository\PersonAppIdentityRepository;
  18. use App\Repository\DeviceRepository;
  19. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  20. use Symfony\Component\HttpFoundation\Request;
  21. use Symfony\Component\HttpFoundation\Response;
  22. use Symfony\Component\HttpFoundation\JsonResponse;
  23. use Symfony\Component\Routing\Annotation\Route;
  24. use Symfony\Component\String\Slugger\SluggerInterface;
  25. use Psr\Container\ContainerInterface;
  26. use Symfony\Component\Filesystem\Filesystem;
  27. use App\API\SqrApi as SqrApi;
  28. use Google\Auth\Credentials\ServiceAccountCredentials;
  29. Use Google\Auth\HttpHandler\HttpHandlerFactory;
  31. /**
  32.  * @Route("/person/civil")
  33.  */
  34. class PersonCivilController extends AbstractController
  35. {
  36.     /**
  37.      * @Route("/", name="app_person_civil_index", methods={"GET"})
  38.      */
  39.     public function index(PersonCivilRepository $personCivilRepository): Response
  40.     {
  41.         return $this->render('person_civil/index.html.twig', [
  42.             'person_civils' => $personCivilRepository->findAll(),
  43.         ]);
  44.     }
  45.     
  46.     /**
  47.      * @Route("/get/IDO/info", name="app_person_civil_ido_get_json", methods={"GET", "POST"})
  48.      */
  49.     public function indexJson(Request $request, PersonCivilRepository $personCivilRepository): Response
  50.     {
  51.         $referenceUser = $request->get('referenceUser'); 
  52.         $action = empty($request->get('action'))? "IDO" : $request->get('action'); // IDO, EMAIL, PHONE default IDO
  53.         
  54.         if(!empty($referenceUser))
  55.         {
  56.             switch ($action)
  57.             {
  58.                 case 'IDO':
  59.                     $personCivil = $personCivilRepository->findOneBySqr($referenceUser); //OK
  60.                     break;
  61.                 case 'EMAIL':
  62.                     $personCivil = $personCivilRepository->findOneBy(['email'=>$referenceUser]); //OK
  63.                     break;
  64.                 case 'PHONE':
  65.                     $personCivil = $personCivilRepository->findOneBy(['phone'=>$referenceUser]); //OK
  66.                     break;
  67.                 case 'NOMS':
  68.                     $personCivil = $personCivilRepository->findOneBy(['firstName'=>$referenceUser]); // OK
  69.                     break;
  70.                 /*case 'IDA':
  71.                     $personCivil = $personCivilRepository->findOneBy(['phone'=>$referenceUser]); // NOK
  72.                     break;
  73.                 case 'PSEUDO':
  74.                     $personCivil = $personCivilRepository->findOneBy(['phone'=>$referenceUser]); // NOK
  75.                     break;*/
  76.                 default:
  77.                     # code...
  78.                     break;
  79.             }
  81.             if($personCivil)
  82.             {
  83.                 $userDta [] =  
  84.                 [
  85.                     'civility'=>$personCivil->getCivility(),
  86.                     'abisIdentificationJson'=>$personCivil->getCheckQr()->getPersonBiometrics()[0]->getAbisIdentificationJson(),
  87.                     'firstName'=>$personCivil->getFirstName(),
  88.                     'lastName'=>$personCivil->getLastName(),
  89.                     'dateOfBirth'=>$personCivil->getDateOfBirth()->format("d/m/Y"),
  90.                     'placeOfBirth'=>$personCivil->getPlaceOfBirth(),
  91.                     'email'=>$personCivil->getEmail(),
  92.                     'phone'=>$personCivil->getPhone(),
  93.                     'typeOfIdentificationDocument'=>$personCivil->getTypeOfIdentificationDocument(),
  94.                     'identificationDocumentNumber'=>$personCivil->getIdentificationDocumentNumber(),
  95.                     'dateOfIssue'=>$personCivil->getDateOfIssue(),
  96.                     'dateOfExpirationIssue'=>$personCivil->getDateOfExpirationIssue(),
  97.                     'dateOfProrogation'=>$personCivil->getDateOfProrogation(),
  98.                     'dateOfExpirationProrogation'=>$personCivil->getDateOfExpirationProrogation(),
  99.                     'dateCreated'=>$personCivil->getDateCreated()->format("d/m/Y H:i:s"),
  100.                     'selfie_link'=>"uploads/kyvala/enrolment/".$personCivil->getCheckQr()->getPersonBiometrics()[0]->getFace(),
  101.                     'signature_link'=>"uploads/kyvala/enrolment/".$personCivil->getSignature(),
  102.                     'officeStamp_link'=>"uploads/kyvala/enrolment/".$personCivil->getOfficeStamp(),
  103.                     'nominativeStamp_link'=>"uploads/kyvala/enrolment/".$personCivil->getNominativeStamp(),
  104.                     'officeStampAndSignature_link'=>"uploads/kyvala/enrolment/".$personCivil->getOfficeStampAndSignature(),
  105.                     'nominativeStampAndSignature_link'=>"uploads/kyvala/enrolment/".$personCivil->getNominativeStampAndSignature(),
  106.                     'initials_link'=>"uploads/kyvala/enrolment/".$personCivil->getInitials(),
  107.                     'IDO'=>$personCivil->getCheckQr()->getNumero(),
  108.                     'isEnrolled'=>$personCivil->getCheckQr()->getPersonBiometrics()[0]->isIsEnrolled(),
  109.                     'isDoublon'=>$personCivil->getCheckQr()->getPersonBiometrics()[0]->isIsDoublon(),
  110.                     'abisEncounterId'=>$personCivil->getCheckQr()->getPersonBiometrics()[0]->getAbisEncounterId(),
  111.                     'isPouceGauche'=>$personCivil->getCheckQr()->getPersonBiometrics()[0]->isPouceGauche(),
  112.                     'isPouceDroit'=>$personCivil->getCheckQr()->getPersonBiometrics()[0]->isPouceDroit(),
  113.                     'isIndexDroit'=>$personCivil->getCheckQr()->getPersonBiometrics()[0]->isIndexDroit(),
  114.                     'isIndexGauche'=>$personCivil->getCheckQr()->getPersonBiometrics()[0]->isIndexGauche(),
  115.                     'isMajeurDroit'=>$personCivil->getCheckQr()->getPersonBiometrics()[0]->isMajeurDroit(),
  116.                     'isMajeurGauche'=>$personCivil->getCheckQr()->getPersonBiometrics()[0]->isMajeurGauche(),
  117.                     'isAnnulaireDroit'=>$personCivil->getCheckQr()->getPersonBiometrics()[0]->isAnnulaireDroit(),
  118.                     'isAnnulaireGauche'=>$personCivil->getCheckQr()->getPersonBiometrics()[0]->isAnnulaireGauche(),
  119.                     'isAuriculaireGauche'=>$personCivil->getCheckQr()->getPersonBiometrics()[0]->isAuriculaireGauche(),
  120.                     'isAuriculaireDroit'=>$personCivil->getCheckQr()->getPersonBiometrics()[0]->isAuriculaireDroit(),
  121.                 ];
  123.                 $return = array(
  124.                     'Etat' =>'SUCCESS' , 
  125.                     'Message' =>"Utilisateur retrouvé avec succès", 
  126.                     'userData'=>$userDta
  127.                 );
  129.             }else
  130.             {
  131.                 $return = array(
  132.                     'Etat' =>'FAILED' , 
  133.                     'Message' =>"L'identifiant ne correspond à aucun utilisateur...", 
  134.                 );
  135.             }
  136.             /*
  137.             $person = $personRepository->findOneBySqr($referenceUser);
  138.             if($person)
  139.             {
  140.                 $personCivils = $personCivilRepository->findBy(['person'=>$person]);
  141.                 if ($personCivils) 
  142.                 {
  143.                     $tabEnrol = [];
  144.                     foreach ($personCivils as $key) 
  145.                     {
  146.                         $tabEnrol [] = 
  147.                         [
  148.                             'civility'=>$key->getCivility(),
  149.                             'firstName'=>$key->getFirstName(),
  150.                             'lastName'=>$key->getLastName(),
  151.                             'dateOfBirth'=>$key->getDateOfBirth()->format("d/m/Y"),
  152.                             'placeOfBirth'=>$key->getPlaceOfBirth(),
  153.                             'email'=>$key->getEmail(),
  154.                             'phone'=>$key->getPhone(),                                                                                                                                                                                                                                                                                                                                                                
  155.                             'typeOfIdentificationDocument'=>$key->getTypeOfIdentificationDocument(),
  156.                             'identificationDocumentNumber'=>$key->getIdentificationDocumentNumber(),
  157.                             'dateOfIssue'=>$key->getDateOfIssue(),
  158.                             'dateOfExpirationIssue'=>$key->getDateOfExpirationIssue(),
  159.                             'dateOfProrogation'=>$key->getDateOfProrogation(),
  160.                             'dateOfExpirationProrogation'=>$key->getDateOfExpirationProrogation(),
  161.                             'dateCreated'=>$key->getDateCreated()->format("d/m/Y H:i:s"),
  162.                             'referenceKyvala'=>$key->getCheckQr()->getNumero()
  163.                         ];
  164.                     }
  166.                     $return = array(
  167.                         'Etat' =>'SUCCESS' , 
  168.                         'Message' =>count($personCivils). " enregistrement recupérés avec succès...", 
  169.                         'enrolement'=>$tabEnrol
  170.                     );
  171.                     
  172.                 }else
  173.                 {
  174.                     $return = array(
  175.                         'Etat' =>'FAILED' , 
  176.                         'Message' =>"Aucun enregistrement disponible pour cet utilisateur...", 
  177.                     );
  178.                 }
  179.                 
  180.             }else
  181.             {
  182.                 $return = array(
  183.                     'Etat' =>'FAILED' , 
  184.                     'Message' =>"Aucun utilisateur retrouvé avec cet identifiant...", 
  185.                 );
  186.             }*/
  188.         }else
  189.         {
  190.             $return = array(
  191.                 'Etat' =>'FAILED' , 
  192.                 'Message' =>"Paramètres requis manquants..", 
  193.             );
  194.         }  
  195.         
  196.        return new JsonResponse($return);
  197.     }
  199.     /*Fonction permettant de vérifier l'existance d'utilisateur dans la table personAppIdentity avec la clé d'un projet et l'email et le num tel */
  200.     /**
  201.      * @Route("/user/person/app/identity/check", name="app_person_civil_check_user_identity", methods={"GET", "POST"})
  202.      */
  203.     public function checkUserIdentityJson(Request $request, PersonAppIdentityRepository $personAppIdentityRepository, ApplicationRepository $applicationRepository): Response
  204.     {
  205.         if($_POST)
  206.         {
  207.             $appKey = $request->get("app_key");
  208.             $email = $request->get("email");
  209.             $telephone = $request->get("telephone");
  210.             //$pivot = $request->get("pivot");//TOKEN TELEPHONE EMAIL
  212.             if(!empty($email) && !empty($appKey) && !empty($telephone)) 
  213.             {
  214.                 $application = $applicationRepository->findOneBy(['applicationPass'=>$appKey]);
  215.                 if($application)
  216.                 {
  217.                     $personAppIdTelephone = $personAppIdentityRepository->findOneBy(['telephone'=>$telephone, 'application'=>$application]);
  218.                     $personAppIdEmail = $personAppIdentityRepository->findOneBy(['email'=>$email, 'application'=>$application]);
  219.                     
  220.                     if(!empty($personAppIdTelephone) || !empty($personAppIdEmail))
  221.                     {
  222.                         $return = array(
  223.                             'Etat' =>'SUCCESS',
  224.                             'Message' =>'Utilisateur retrouvé avec succès',
  225.                         );
  226.                     }else
  227.                     {
  228.                         $return = array(
  229.                             'Etat' =>'CORRECT', 
  230.                             'Message' =>"Utilisateur introuvable. Veuillez procéder à l'enrôlement...", 
  231.                         );
  232.                     }
  234.                 }else
  235.                 {
  236.                     $return = array(
  237.                         'Etat' =>'FAILED' , 
  238.                         'Message' =>"Vous n'avez pas l'autorisation pour cette requette", 
  239.                     );
  240.                 }
  242.             }else
  243.             {
  244.                 $return = array(
  245.                     'Etat' =>'FAILED' , 
  246.                     'Message' =>"Paramètres requis manquants", 
  247.                 );
  248.             }
  250.         }else
  251.         {
  252.             $return = array(
  253.                 'Etat' =>'FAILED' , 
  254.                 'Message' =>"La méthode d'envoie ne correspond pas aux attentes", 
  255.             );
  256.         }
  257.         
  258.        return new JsonResponse($return);
  259.     }
  261.     /*Fonction permettant à un utilisateur de s'authentifier par le biais de son telephone, email ou son token*/
  262.     /**
  263.      * @Route("/check/user/token/json", name="app_person_civil_check_user_token", methods={"GET", "POST"})
  264.      */
  265.     public function checkUserTokenJson(Request $request, PersonAppIdentityRepository $personAppIdentityRepository, DeviceRepository $deviceRepository, ContainerInterface $container,CheckQrRepository $checkQrRepository, PersonAuthHistoryRepository $personAuthHistoryRepository, ApplicationRepository $applicationRepository): Response
  266.     {
  267.         if($_POST)
  268.         {
  269.             $appKey = $request->get("app_key");
  270.             $login = $request->get("login");
  271.             $pivot = $request->get("pivot");//TOKEN TELEPHONE EMAIL IDO
  272.             $pin = $request->get("pin");
  274.             $deviceId = $request->get("deviceId");
  275.             $token = $request->get("deviceToken");
  276.             $batteryState = $request->get("batteryState");
  277.             $isBatteryPlugIn = $request->get("isBatteryPlugIn");
  278.             $package = $request->get("packageName");
  279.             $version = $request->get("appVersion");
  280.             $appLongitude = $request->get("appLongitude");
  281.             $appLatitude = $request->get("appLatitude");
  282.             $source = $request->get("source");
  284.             $fs = new Filesystem();
  285.             //$fs->appendToFile('EventLogFiles.txt', "\r\n ".json_encode($error));
  286.             $fs->appendToFile('identyLog.txt', "\r\n ".date("d-m-Y H:i:s").' : '.json_encode($_POST));
  287.             
  288.             if(!empty($login) && !empty($appKey) && !empty($pivot)) 
  289.             {
  290.                 $application = $applicationRepository->findOneBy(['applicationPass'=>$appKey]);
  291.                 if($application)
  292.                 {
  293.                     $fs = new Filesystem();
  294.                     //$fs->appendToFile('EventLogFiles.txt', "\r\n ".json_encode($error));
  295.                     $fs->appendToFile('EventLogFilesConnect.txt', "\r\n ".date("d-m-Y H:i:s").' : '.json_encode($_POST));
  297.                     switch ($pivot)
  298.                     {
  299.                         case 'TOKEN':                           
  300.                             $personAppId = $personAppIdentityRepository->findOneBy(['token'=>$login, 'application'=>$application]);
  301.                             break;
  302.                         case 'TELEPHONE':
  303.                             $personAppId = $personAppIdentityRepository->findOneBy(['telephone'=>$login, 'application'=>$application]);
  304.                             break;
  305.                         case 'EMAIL':
  306.                             $personAppId = $personAppIdentityRepository->findOneBy(['email'=>$login, 'application'=>$application]);
  307.                             break;                        
  308.                         case 'IDO':
  309.                             // working here
  310.                             $qr = $checkQrRepository->findOneBy(['numero'=>$login]);
  311.                             if($qr)
  312.                             {
  313.                                 $personAppId = $personAppIdentityRepository->findOneBy(['userReference'=>$qr, 'application'=>$application]);
  314.                                 // si l'utilisateur n'est pas encore enregistré dans la table de connexion AppPersonIdentity, on le crée
  315.                                 if(empty($personAppId))
  316.                                 {
  317.                                     if($source != "WEB")
  318.                                     {
  319.                                         // device infos persist   
  320.                                         $device = new Device();
  321.                                         $device->setDeviceInfo($deviceId);
  322.                                         $device->setDeviceToken($token);
  323.                                         $device->setGpsLatitude($appLatitude);
  324.                                         $device->setGpsLongitude($appLongitude);
  325.                                         $device->setBatteryState($batteryState);
  326.                                         $device->setIsBatteryPlugIn($isBatteryPlugIn);
  327.                                         $device->setPackage($package);
  328.                                         $device->setAppVersion($version);
  329.                                         $deviceRepository->add($device, false);
  330.                                     }
  331.                                     
  332.                                     $personAppId = new PersonAppIdentity();
  333.                                     $personAppId->setApplication($application);
  334.                                     $personAppId->setTelephone($qr->getPersonCivil()[0]->getPhone());
  335.                                     $personAppId->setEmail($qr->getPersonCivil()[0]->getEmail());
  336.                                     $personAppId->setPin($pin);
  337.                                     $personAppId->setUserReference($qr);
  338.                                     if($source != "WEB")
  339.                                     {   
  340.                                         $personAppId->setToken($token);       
  341.                                         $personAppId->setDevice($device);
  342.                                     }
  343.                                     
  344.                                     // method to flush
  345.                                     $personAppIdentityRepository->add($personAppId, false);
  346.                                 }
  347.                                 
  348.                             }else
  349.                             {
  350.                                 $return = array(
  351.                                     'Etat' =>'FAILED' , 
  352.                                     'Message' =>"L'IDO ne correspond à aucun utilisateur...", 
  353.                                 );
  354.                             }
  355.                             
  356.                             break;  
  357.                         default:
  358.                             $return = array(
  359.                                 'Etat' =>'FAILED' , 
  360.                                 'Message' =>"Le PIVOT ne correspond à aucune option disponible...", 
  361.                             );
  362.                             return new JsonResponse($return);
  363.                             break;
  364.                     }
  365.                     
  366.                     if(!empty($personAppId))
  367.                     {
  368.                         $cle = $this->getParameter('api_key');
  369.                         $piece = 'User login';
  370.                         $proprietaire = $personAppId->getUserReference()->getPersonCivil()[0]->fullName();
  371.                     
  372.                         $post = array(
  373.                             'cle' => $cle,
  374.                             'pieceqr'=> $piece, 
  375.                             'proprietaire' => $proprietaire, 
  376.                         );
  377.                         
  378.                         $api = new SqrApi($container);
  379.                         $res = $api->callAPI($post);
  380.                         //dump($res);die;
  381.                         if($res[0])
  382.                         {
  383.                             $qr = $res[0]->qr;
  384.                             $num = $res[0]->niu;
  385.                             
  386.                             $checkqr = new CheckQr();
  387.                             $checkqr->setLibelle($qr);
  388.                             $checkqr->setNumero($num);
  389.                             //$checkqr->setChemin($newname);
  390.                     
  391.                             // method to flush
  392.                             $checkQrRepository ->add($checkqr, false);
  393.                             //$personRepository->add($person, true);
  394.                         
  395.                             //////////////////////////////////////////////////////////////
  396.                             try 
  397.                             {
  398.                                 if($source != "WEB")
  399.                                 {   
  400.                                     // device infos persist   
  401.                                     $device = new Device();
  402.                                     $device->setDeviceInfo($deviceId);
  403.                                     $device->setDeviceToken($token);
  404.                                     $device->setGpsLatitude($appLatitude);
  405.                                     $device->setGpsLongitude($appLongitude);
  406.                                     $device->setBatteryState($batteryState);
  407.                                     $device->setIsBatteryPlugIn($isBatteryPlugIn);
  408.                                     $device->setPackage($package);
  409.                                     $device->setAppVersion($version);
  410.                                     $deviceRepository->add($device, false);
  411.                                 
  412.                                     //on met à jour le token.
  413.                                     $personAppId->setToken($token);
  414.                                 } 
  415.                                 $personAppIdentityRepository->add($personAppId, false);
  417.                                 $personAuthHistory = new PersonAuthHistory();
  418.                                 
  419.                                 $personAuthHistory->setPersonAppIdentity($personAppId);
  420.                                 $personAuthHistory->setCheckQr($checkqr);
  421.                                 if($source != "WEB")
  422.                                 {   
  423.                                     $personAuthHistory->setDevice($device);
  424.                                 }
  425.                                 $personAuthHistory->setPivot($pivot);
  426.                                 $personAuthHistory->setLogin($login);
  427.                                 $personAuthHistoryRepository->add($personAuthHistory, true);
  428.                                 
  429.                                 $return = array(
  430.                                     'Etat' =>'SUCCESS',
  431.                                     'Message' =>'Utilisateur retrouvé avec succès',
  432.                                     'nom'=>$personAppId->getUserReference()->getPersonCivil()[0]->getFirstName(),
  433.                                     'prenom'=>$personAppId->getUserReference()->getPersonCivil()[0]->getLastName(),
  434.                                     'selfie_link'=>"uploads/kyvala/enrolment/".$personAppId->getUserReference()->getPersonBiometrics()[0]->getFace(),
  435.                                     'signature_link'=>"uploads/kyvala/enrolment/".$personAppId->getUserReference()->getPersonCivil()[0]->getSignature(),
  436.                                     'IDO'=>$personAppId->getUserReference()->getNumero(),
  437.                                     'isPouceGauche'=>$personAppId->getUserReference()->getPersonBiometrics()[0]->isPouceGauche(),
  438.                                     'isPouceDroit'=>$personAppId->getUserReference()->getPersonBiometrics()[0]->isPouceDroit(),
  439.                                     'isIndexDroit'=>$personAppId->getUserReference()->getPersonBiometrics()[0]->isIndexDroit(),
  440.                                     'isIndexGauche'=>$personAppId->getUserReference()->getPersonBiometrics()[0]->isIndexGauche(),
  441.                                     'isMajeurDroit'=>$personAppId->getUserReference()->getPersonBiometrics()[0]->isMajeurDroit(),
  442.                                     'isMajeurGauche'=>$personAppId->getUserReference()->getPersonBiometrics()[0]->isMajeurGauche(),
  443.                                     'isAnnulaireDroit'=>$personAppId->getUserReference()->getPersonBiometrics()[0]->isAnnulaireDroit(),
  444.                                     'isAnnulaireGauche'=>$personAppId->getUserReference()->getPersonBiometrics()[0]->isAnnulaireGauche(),
  445.                                     'isAuriculaireGauche'=>$personAppId->getUserReference()->getPersonBiometrics()[0]->isAuriculaireGauche(),
  446.                                     'isAuriculaireDroit'=>$personAppId->getUserReference()->getPersonBiometrics()[0]->isAuriculaireDroit(),
  447.                                     'sqr'=>$num,
  448.                                     'pin'=>$personAppId->getPin(),
  449.                                     //'gsDateGenerationCrypto'=>$person->getDateCreated()->format("d/m/Y h:i:s")
  450.                                     'gsDateGenerationCrypto'=>$personAppId->getUserReference()->getPersonCivil()[0]->getDateCreated()->format("d/m/Y h:i:s")
  451.                                 );
  453.                             } catch (\Throwable $error) 
  454.                             {
  455.                                 //not actions
  456.                                 $fs = new Filesystem();
  457.                                 //$fs->appendToFile('EventLogFiles.txt', "\r\n ".json_encode($error));
  458.                                 $fs->appendToFile('log/Connection/Exceptions/'.date("Y")."/".date("d-m-Y").'/EventLogFiles.txt', "\r\n ".date("d-m-Y H:i:s").' : '.$error);
  459.                                 $return = array(
  460.                                     'Etat' =>'FAILED' , 
  461.                                     'Message' =>"Une erreur est survenue lors de l'opération. Veuillez essayer ultérieurement SVP", 
  462.                                     'error'=>$error,
  463.                                 );
  464.                             }
  465.                             //////////////////////////////////////////////////////////////
  466.                             
  467.                         }else
  468.                         {
  469.                             $return = array(
  470.                                 'Etat' =>'FAILED' , 
  471.                                 'Message' =>"L'API SQR n'a pas repondu. Veuillez essayer à nouveau", 
  472.                             );
  473.                         }
  475.                     }else
  476.                     {
  477.                         $return = array(
  478.                             'Etat' =>'FAILED' , 
  479.                             'Message' =>"Utilisateur introuvable. Veuillez vérifier votre identifiant...", 
  480.                         );
  481.                     }
  483.                 }else
  484.                 {
  485.                     $return = array(
  486.                         'Etat' =>'FAILED' , 
  487.                         'Message' =>"Vous n'avez pas l'autorisation pour cette requette", 
  488.                     );
  489.                 }
  491.             }else
  492.             {
  493.                 $return = array(
  494.                     'Etat' =>'FAILED' , 
  495.                     'Message' =>"Paramètres requis manquants ici..", 
  496.                 );
  497.             }
  499.         }else
  500.         {
  501.             $return = array(
  502.                 'Etat' =>'FAILED' , 
  503.                 'Message' =>"La méthode d'envoie ne correspond pas aux attentes", 
  504.             );
  505.         }
  506.         
  507.        return new JsonResponse($return);
  508.     }
  509.     
  510.     /**
  511.      * @Route("/new", name="app_person_civil_new", methods={"GET", "POST"})
  512.      */
  513.     public function new(Request $request, PersonCivilRepository $personCivilRepository): Response
  514.     {
  515.         $personCivil = new PersonCivil();
  516.         $form = $this->createForm(PersonCivilType::class, $personCivil);
  517.         $form->handleRequest($request);
  519.         if ($form->isSubmitted() && $form->isValid()) {
  520.             $personCivilRepository->add($personCivil, true);
  522.             return $this->redirectToRoute('app_person_civil_index', [], Response::HTTP_SEE_OTHER);
  523.         }
  525.         return $this->renderForm('person_civil/new.html.twig', [
  526.             'person_civil' => $personCivil,
  527.             'form' => $form,
  528.         ]);
  529.     }
  530.     
  531.     /** ///save/etat/civil/data/json
  532.      * @Route("/new/json", name="app_person_civil_new_json", methods={"GET", "POST"})
  533.      */
  534.     public function newJson(Request $request, PersonCivilRepository $personCivilRepository, SluggerInterface $slugger, ContainerInterface $container, CheckQrRepository $checkQrRepository, PersonRepository $personRepository, ApplicationRepository $applicationRepository, PersonAppIdentityRepository $personAppIdentityRepository, DeviceRepository $deviceRepository ): Response
  535.     {        
  536.         if($_POST)
  537.         {
  538.             // device info
  539.             $deviceId = $request->get("deviceId");
  540.             $token = $request->get("deviceToken");
  541.             $batteryState = $request->get("batteryState");
  542.             $isBatteryPlugIn = $request->get("isBatteryPlugIn");
  543.             $package = $request->get("packageName");
  544.             $version = $request->get("appVersion");
  545.             $appLongitude = $request->get("appLongitude");
  546.             $appLatitude = $request->get("appLatitude");
  547.             
  548.             $personCivil = new PersonCivil();           
  549.             
  550.             $sqrRef = $request->get("sqr");//référence sqr
  551.             $referenceUser = $request->get("referenceUser");//référence de l'utilisateur            
  552.             
  553.             $appKey = $request->get("app_key");
  554.             $pin = $request->get("pin");
  556.             $civilite = $request->get("civilite");
  557.             $nom = $request->get("nom");
  558.             $prenom = $request->get("prenom");
  559.             $dateNaissance = new \DateTime($request->get("dateNaissance"));
  560.             $lieuNaissance = $request->get("lieuNaissance");
  561.             $nationalite = $request->get("nationalite");
  562.             $numeroTelephone = $request->get("numeroTelephone");
  563.             $adresseEmail = $request->get("adresseEmail");
  564.             $typeDocumentIdentite = $request->get("typeDocumentIdentite");
  565.             $numeroDocumentIdentite = $request->get("numeroDocumentIdentite");
  567.             if(!empty($request->get("dateDelivrancedocument"))){
  568.                 $dateDelivrancedocument = new \DateTime($request->get("dateDelivrancedocument"));
  569.             }else{
  570.                 $dateDelivrancedocument=null;
  571.             }
  573.             if(!empty($request->get("dateExpirationDelivranceDocument"))){
  574.                 $dateExpirationDelivranceDocument = new \DateTime($request->get("dateExpirationDelivranceDocument"));
  575.             }else{
  576.                 $dateExpirationDelivranceDocument=null;
  577.             }
  579.             if(!empty($request->get("dateProrogationDocument"))){
  580.                 $dateProrogationDocument = new \DateTime($request->get("dateProrogationDocument"));
  581.             }else{
  582.                 $dateProrogationDocument=null;
  583.             }
  585.             if(!empty($request->get("dateExpirationProrogationDocument"))){
  586.                 $dateExpirationProrogationDocument = new \DateTime($request->get("dateExpirationProrogationDocument"));
  587.             }else{
  588.                 $dateExpirationProrogationDocument = null;
  589.             }
  590.             
  591.             $enrolmentToken = $request->get("enrolmentToken");
  592.             $enrolmentUid = $request->get("enrolmentUid");
  593.             $enrolmentId = $request->get("enrolmentId");
  594.             $enrolmentSource = $request->get("enrolmentSource");
  595.             
  596.             $checkQr = $checkQrRepository->findOneBy(['numero'=>$sqrRef]);
  597.             if($checkQr)
  598.             {
  599.                 $qrDoublon = $personCivilRepository->findOneBy(['checkQr'=>$checkQr]);
  600.                 if(!$qrDoublon)
  601.                 {
  602.                     
  603.                     /** @var UploadedFile $documentIdentiteRecto */            
  604.                     $documentIdentiteRecto = $request->files->get('documentIdentiteRecto');
  606.                     // this condition is needed because the 'brochure' field is not required
  607.                     // so the PDF file must be processed only when a file is uploaded
  608.                     if ($documentIdentiteRecto) 
  609.                     {
  610.                         $originalFilename = pathinfo($documentIdentiteRecto->getClientOriginalName(), PATHINFO_FILENAME);
  611.                         // this is needed to safely include the file name as part of the URL
  612.                         $safeFilename = $slugger->slug($originalFilename);
  613.                         $newFilename = $safeFilename.'-'.uniqid().'.'.$documentIdentiteRecto->guessExtension();
  615.                         // Move the file to the directory where brochures are stored
  616.                         try {
  617.                             $documentIdentiteRecto->move(
  618.                                 $this->getParameter('kyvala_directory').'/'.$sqrRef,
  619.                                 $newFilename
  620.                             );
  621.                         } catch (FileException $e) {
  622.                             // ... handle exception if something happens during file upload
  623.                         }
  624.                         $personCivil->setPictureFrontOfIdentificationDocument($sqrRef.'/'.$newFilename);
  625.                     }
  627.                     /** @var UploadedFile $documentIdentiteVerso */            
  628.                     $documentIdentiteVerso = $request->files->get('documentIdentiteVerso');
  630.                     // this condition is needed because the 'brochure' field is not required
  631.                     // so the PDF file must be processed only when a file is uploaded
  632.                     if ($documentIdentiteVerso) 
  633.                     {
  634.                         $originalFilename = pathinfo($documentIdentiteVerso->getClientOriginalName(), PATHINFO_FILENAME);
  635.                         // this is needed to safely include the file name as part of the URL
  636.                         $safeFilename = $slugger->slug($originalFilename);
  637.                         $newFilename = $safeFilename.'-'.uniqid().'.'.$documentIdentiteVerso->guessExtension();
  639.                         // Move the file to the directory where brochures are stored
  640.                         try {
  641.                             $documentIdentiteVerso->move(
  642.                                 $this->getParameter('kyvala_directory').'/'.$sqrRef,
  643.                                 $newFilename
  644.                             );
  645.                         } catch (FileException $e) {
  646.                             // ... handle exception if something happens during file upload
  647.                         }
  648.                         $personCivil->setPictureBackOfIdentificationDocument($sqrRef.'/'.$newFilename);
  649.                     }
  650.                     
  651.                     /** @var UploadedFile $officeStampAndSignature */            
  652.                     $planLocalisation = $request->files->get('planLocalisation');
  653.                     
  654.                     // this condition is needed because the 'brochure' field is not required
  655.                     // so the PDF file must be processed only when a file is uploaded
  656.                     if ($planLocalisation) 
  657.                     {
  658.                         $originalFilename = pathinfo($planLocalisation->getClientOriginalName(), PATHINFO_FILENAME);
  659.                         // this is needed to safely include the file name as part of the URL
  660.                         $safeFilename = $slugger->slug($originalFilename);
  661.                         $newFilename = $safeFilename.'-'.uniqid().'.'.$planLocalisation->guessExtension();
  663.                         // Move the file to the directory where brochures are stored
  664.                         try {
  665.                             $planLocalisation->move(
  666.                                 $this->getParameter('kyvala_directory').'/'.$sqrRef,
  667.                                 $newFilename
  668.                             );
  669.                         } catch (FileException $e) {
  670.                             // ... handle exception if something happens during file upload
  671.                         }
  672.                         $personCivil->setPictureOfLocalisation($sqrRef.'/'.$newFilename);
  673.                     }
  674.                     
  675.                     /** @var UploadedFile $signature */            
  676.                     $signature = $request->files->get('signature');
  678.                     // this condition is needed because the 'brochure' field is not required
  679.                     // so the PDF file must be processed only when a file is uploaded
  680.                     if ($signature)
  681.                     {
  682.                         $originalFilename = pathinfo($signature->getClientOriginalName(), PATHINFO_FILENAME);
  683.                         // this is needed to safely include the file name as part of the URL
  684.                         $safeFilename = $slugger->slug($originalFilename);
  685.                         $newFilename = $safeFilename.'-'.uniqid().'.'.$signature->guessExtension();
  687.                         // Move the file to the directory where they must be stored
  688.                         try {
  689.                             $signature->move(
  690.                                 $this->getParameter('kyvala_directory').'/'.$sqrRef,
  691.                                 $newFilename
  692.                             );
  693.                         } catch (FileException $e) 
  694.                         {
  695.                             // ... handle exception if something happens during file upload
  696.                         }
  697.                         $personCivil->setSignature($sqrRef.'/'.$newFilename);
  698.                     }
  699.                     
  700.                     try
  701.                     {
  702.                         if (!empty($nom))
  703.                         {
  704.                             if(!empty($referenceUser))
  705.                             {
  706.                                 $person = $personRepository->findOneBySqr($referenceUser);
  707.                                 if($person)
  708.                                 {
  709.                                     $personCivil->setPerson($person);
  710.                                 }
  711.                             }
  713.                             // On enregistre les paramètres de connexion de l'utilisateur dans la table personappidentity pour de futur connexion
  714.                             if(!empty($appKey))
  715.                             {
  716.                                 $application = $applicationRepository->findOneBy(['applicationPass'=>$appKey]);
  717.                                 if($application)
  718.                                 {
  720.                                     // device infos persist   
  721.                                     $device = new Device();
  722.                                     $device->setDeviceInfo($deviceId);
  723.                                     $device->setDeviceToken($token);
  724.                                     $device->setGpsLatitude($appLatitude);
  725.                                     $device->setGpsLongitude($appLongitude);
  726.                                     $device->setBatteryState($batteryState);
  727.                                     $device->setIsBatteryPlugIn($isBatteryPlugIn);
  728.                                     $device->setPackage($package);
  729.                                     $device->setAppVersion($version);
  730.                                     $deviceRepository->add($device, false);
  731.                                     
  732.                                     $personAppIdentity = new PersonAppIdentity();
  733.                                     $personAppIdentity->setApplication($application);
  734.                                     $personAppIdentity->setTelephone($numeroTelephone);
  735.                                     $personAppIdentity->setEmail($adresseEmail);
  736.                                     $personAppIdentity->setPin($pin);
  737.                                     $personAppIdentity->setUserReference($checkQr);
  738.                                     $personAppIdentity->setToken($token);
  739.                                     $personAppIdentity->setDevice($device);
  740.                                     
  741.                                     // method to flush
  742.                                     $personAppIdentityRepository->add($personAppIdentity, false);
  743.                                     
  744.                                 }else
  745.                                 {
  746.                                     $otherMsg = "La clé envoyé ne correspond à aucun message";                            
  747.                                 }                      
  748.                             }
  749.                             
  750.                             $personCivil->setCivility($civilite);
  751.                             $personCivil->setFirstName($nom);
  752.                             $personCivil->setLastName($prenom);
  753.                             $personCivil->setDateOfBirth($dateNaissance);
  754.                             $personCivil->setPlaceOfBirth($lieuNaissance);
  755.                             $personCivil->setNationality($nationalite);
  756.                             $personCivil->setPhone($numeroTelephone);
  757.                             $personCivil->setEmail($adresseEmail);
  758.                             $personCivil->setTypeOfIdentificationDocument($typeDocumentIdentite);
  759.                             $personCivil->setIdentificationDocumentNumber($numeroDocumentIdentite);
  760.                             $personCivil->setDateOfIssue($dateDelivrancedocument);
  761.                             $personCivil->setDateOfExpirationIssue($dateExpirationDelivranceDocument);
  762.                             $personCivil->setDateOfProrogation($dateProrogationDocument);
  763.                             $personCivil->setDateOfExpirationProrogation($dateExpirationProrogationDocument);
  764.                             
  765.                             $personCivil->setEnrolmentUid($enrolmentUid);
  766.                             $personCivil->setEnrolmentId($enrolmentId);
  767.                             $personCivil->setEnrolmentSource($enrolmentSource);
  768.                             $personCivil->setFirebaseToken($enrolmentToken);
  769.                             $personCivil->setFirebasePlateform("MOBILE");
  770.                             $personCivil->setAdresse("");
  771.                                 
  772.                             // spécifier qu'il s'agit d'un enrolement complet
  773.                             $personCivil->setStatus(1);
  774.                             $personCivil->setCheckQr($checkQr);
  775.                                 
  776.                             // method to flush
  777.                             $personCivilRepository->add($personCivil, true);
  779.                             $return = array(
  780.                                 'Etat' =>'SUCCESS' , 
  781.                                 'Message' =>"Votre enregistrement a été effectué avec succès", 
  782.                                 'transaction_id'=> $enrolmentId,
  783.                                 'transaction_uid'=> $enrolmentUid,
  784.                                 'transaction_source'=>$enrolmentSource,
  785.                                 'sqr'=>$sqrRef,
  786.                             );
  788.                             /*
  789.                             // send notification to Firebase
  790.                             if(!empty($personCivil->getFirebaseToken()))
  791.                             {
  792.                                 $this->ParamsWithSendPushNotification($personCivil->getFirebaseToken(),"Votre enrôlement",$civilite." ".$prenom." ".$nom.", Bienvenu(e) sur KYVALA ! Votre enrôlement a été effectué avec succès sous la référence SQR : ".$sqrRef.", Merci de conserver cette référence pour la suite de vos opérations");
  793.                             }
  794.                             */
  796.                         }else
  797.                         {
  798.                             $return = array(
  799.                                 'Etat' =>'FAILED' , 
  800.                                 'Message' =>"Paramètres requis manquants", 
  801.                             );
  802.                         }
  803.                     } catch (\Throwable $error) 
  804.                     {
  805.                         //not actions
  806.                         $fs = new Filesystem();
  807.                         //$fs->appendToFile('EventLogFiles.txt', "\r\n ".json_encode($error));
  808.                         $fs->appendToFile('log/Enrôlement/Exceptions/'.date("Y")."/".date("d-m-Y").'/EventLogFilesBio.txt', "\r\n ".date("d-m-Y H:i:s")." Enrollement exception : ".$error);
  809.                         $return = array(
  810.                             'Etat' =>'FAILED' , 
  811.                             'Message' =>"Une erreur est survenue lors de l'opération. Veuillez essayer ultérieurement SVP", 
  812.                             'error'=>$error,
  813.                         );
  814.                     }
  815.                     //////////////////////////////////////////////////////////////
  816.                 }else
  817.                 {
  818.                     $return = array(
  819.                         'Etat' =>'FAILED',
  820.                         'Message' =>"Ces informations sont déjà enregistrées dans la base de donnée sous la référence ".$sqrRef, 
  821.                     );
  822.                 }
  823.             }else
  824.             {
  825.                 $return = array(
  826.                     'Etat' =>'FAILED',
  827.                     'Message' =>$sqrRef. "Une erreur est survenue lors de l'enregistrement, aucun enregistrement ne correspond à la référence...", 
  828.                 );
  829.             }            
  830.         }else
  831.         {
  832.             $return = array(
  833.                 'Etat' =>'FAILED',
  834.                 'Message' =>"La méthode d'envoie ne correspond pas aux attentes",
  835.             );
  836.         }
  837.         
  838.         //$fs1 = new Filesystem();
  839.         //$fs1->appendToFile('log/Enrôlement/'.date("Y")."/".date("d-m-Y").'/BiometricsFiles.txt', "\r\n ".json_encode($return));
  841.        return new JsonResponse($return);
  842.     }
  844.     
  845.     /** 
  846.      * @Route("/update/signatures/files", name="app_person_civil_update_signatures", methods={"GET", "POST"})
  847.      */
  848.     public function updateSignatures(Request $request, PersonCivilRepository $personCivilRepository, SluggerInterface $slugger ): Response
  849.     {        
  850.         if($_POST)
  851.         {
  852.             // device info
  853.             $userIdo = $request->get("userIdo");                   
  855.             $personIdentified = $personCivilRepository->findOneBySqr($userIdo);
  856.             if($personIdentified)
  857.             {
  858.                 /** @var UploadedFile $signature */            
  859.                 $signature = $request->files->get('signature');
  861.                 // this condition is needed because the 'brochure' field is not required
  862.                 // so the PDF file must be processed only when a file is uploaded
  863.                 if ($signature)
  864.                 {
  865.                     $originalFilename = pathinfo($signature->getClientOriginalName(), PATHINFO_FILENAME);
  866.                     // this is needed to safely include the file name as part of the URL
  867.                     $safeFilename = $slugger->slug($originalFilename);
  868.                     $newFilename = $safeFilename.'-'.uniqid().'.'.$signature->guessExtension();
  870.                     // Move the file to the directory where they must be stored
  871.                     try {
  872.                         $signature->move(
  873.                             $this->getParameter('kyvala_directory').'/'.$userIdo,
  874.                             $newFilename
  875.                         );
  876.                     } catch (FileException $e) 
  877.                     {
  878.                         // ... handle exception if something happens during file upload
  879.                     }
  880.                     $personIdentified->setSignature($userIdo.'/'.$newFilename);
  881.                 }
  883.                 /** @var UploadedFile $officeStamp */            
  884.                 $officeStamp = $request->files->get('officeStamp');
  886.                 // this condition is needed because the 'brochure' field is not required
  887.                 // so the PDF file must be processed only when a file is uploaded
  888.                 if ($officeStamp) 
  889.                 {
  890.                     $originalFilename = pathinfo($officeStamp->getClientOriginalName(), PATHINFO_FILENAME);
  891.                     // this is needed to safely include the file name as part of the URL
  892.                     $safeFilename = $slugger->slug($originalFilename);
  893.                     $newFilename = $safeFilename.'-'.uniqid().'.'.$officeStamp->guessExtension();
  895.                     // Move the file to the directory where brochures are stored
  896.                     try {
  897.                         $officeStamp->move(
  898.                             $this->getParameter('kyvala_directory').'/'.$userIdo,
  899.                             $newFilename
  900.                         );
  901.                     } catch (FileException $e) {
  902.                         // ... handle exception if something happens during file upload
  903.                     }
  904.                     $personIdentified->setOfficeStamp($userIdo.'/'.$newFilename);
  905.                 }
  907.                 /** @var UploadedFile $nominativeStamp */            
  908.                 $nominativeStamp = $request->files->get('nominativeStamp');
  910.                 // this condition is needed because the 'brochure' field is not required
  911.                 // so the PDF file must be processed only when a file is uploaded
  912.                 if ($nominativeStamp) 
  913.                 {
  914.                     $originalFilename = pathinfo($nominativeStamp->getClientOriginalName(), PATHINFO_FILENAME);
  915.                     // this is needed to safely include the file name as part of the URL
  916.                     $safeFilename = $slugger->slug($originalFilename);
  917.                     $newFilename = $safeFilename.'-'.uniqid().'.'.$nominativeStamp->guessExtension();
  919.                     // Move the file to the directory where brochures are stored
  920.                     try {
  921.                         $nominativeStamp->move(
  922.                             $this->getParameter('kyvala_directory').'/'.$userIdo,
  923.                             $newFilename
  924.                         );
  925.                     } catch (FileException $e) {
  926.                         // ... handle exception if something happens during file upload
  927.                     }
  928.                     $personIdentified->setNominativeStamp($userIdo.'/'.$newFilename);
  929.                 }
  930.                 
  931.                 /** @var UploadedFile $officeStampAndSignature */            
  932.                 $officeStampAndSignature = $request->files->get('officeStampAndSignature');
  933.                 
  934.                 // this condition is needed because the 'brochure' field is not required
  935.                 // so the PDF file must be processed only when a file is uploaded
  936.                 if ($officeStampAndSignature) 
  937.                 {
  938.                     $originalFilename = pathinfo($officeStampAndSignature->getClientOriginalName(), PATHINFO_FILENAME);
  939.                     // this is needed to safely include the file name as part of the URL
  940.                     $safeFilename = $slugger->slug($originalFilename);
  941.                     $newFilename = $safeFilename.'-'.uniqid().'.'.$officeStampAndSignature->guessExtension();
  943.                     // Move the file to the directory where brochures are stored
  944.                     try {
  945.                         $officeStampAndSignature->move(
  946.                             $this->getParameter('kyvala_directory').'/'.$userIdo,
  947.                             $newFilename
  948.                         );
  949.                     } catch (FileException $e) {
  950.                         // ... handle exception if something happens during file upload
  951.                     }
  952.                     $personIdentified->setOfficeStampAndSignature($userIdo.'/'.$newFilename);
  953.                 }
  954.                 
  955.                 /** @var UploadedFile $nominativeStampAndSignature */            
  956.                 $nominativeStampAndSignature = $request->files->get('nominativeStampAndSignature');
  957.                 
  958.                 // this condition is needed because the 'brochure' field is not required
  959.                 // so the PDF file must be processed only when a file is uploaded
  960.                 if ($nominativeStampAndSignature) 
  961.                 {
  962.                     $originalFilename = pathinfo($nominativeStampAndSignature->getClientOriginalName(), PATHINFO_FILENAME);
  963.                     // this is needed to safely include the file name as part of the URL
  964.                     $safeFilename = $slugger->slug($originalFilename);
  965.                     $newFilename = $safeFilename.'-'.uniqid().'.'.$nominativeStampAndSignature->guessExtension();
  967.                     // Move the file to the directory where brochures are stored
  968.                     try {
  969.                         $nominativeStampAndSignature->move(
  970.                             $this->getParameter('kyvala_directory').'/'.$userIdo,
  971.                             $newFilename
  972.                         );
  973.                     } catch (FileException $e) {
  974.                         // ... handle exception if something happens during file upload
  975.                     }
  976.                     $personIdentified->setNominativeStampAndSignature($userIdo.'/'.$newFilename);
  977.                 }                    
  978.                 
  979.                 /** @var UploadedFile $initials */            
  980.                 $initials = $request->files->get('initials');
  981.                 
  982.                 // this condition is needed because the 'brochure' field is not required
  983.                 // so the PDF file must be processed only when a file is uploaded
  984.                 if ($initials) 
  985.                 {
  986.                     $originalFilename = pathinfo($initials->getClientOriginalName(), PATHINFO_FILENAME);
  987.                     // this is needed to safely include the file name as part of the URL
  988.                     $safeFilename = $slugger->slug($originalFilename);
  989.                     $newFilename = $safeFilename.'-'.uniqid().'.'.$initials->guessExtension();
  991.                     // Move the file to the directory where brochures are stored
  992.                     try {
  993.                         $initials->move(
  994.                             $this->getParameter('kyvala_directory').'/'.$userIdo,
  995.                             $newFilename
  996.                         );
  997.                     } catch (FileException $e) {
  998.                         // ... handle exception if something happens during file upload
  999.                     }
  1000.                     $personIdentified->setInitials($userIdo.'/'.$newFilename);
  1001.                 }
  1003.                  // method to flush
  1004.                 $personCivilRepository->add($personIdentified, true);
  1006.                 $return = array(
  1007.                     'Etat' =>'SUCCESS' , 
  1008.                     'Message' =>"Vos informations ont été modifié avec succès", 
  1009.                     'ido'=>$userIdo,
  1010.                     'signature_link'=>empty($personIdentified->getSignature()) ? null : "uploads/kyvala/enrolment/".$personIdentified->getSignature() ,
  1011.                     'officeStamp_link'=>empty($personIdentified->getOfficeStamp()) ? null  : "uploads/kyvala/enrolment/".$personIdentified->getOfficeStamp(),
  1012.                     'nominativeStamp_link'=>empty($personIdentified->getNominativeStamp()) ? null : "uploads/kyvala/enrolment/".$personIdentified->getNominativeStamp(),
  1013.                     'officeStampAndSignature_link'=>empty($personIdentified->getOfficeStampAndSignature()) ? null : "uploads/kyvala/enrolment/".$personIdentified->getOfficeStampAndSignature(),
  1014.                     'nominativeStampAndSignature_link'=>empty($personIdentified->getNominativeStampAndSignature()) ? null : "uploads/kyvala/enrolment/".$personIdentified->getNominativeStampAndSignature(),
  1015.                     'initials_link'=>empty($personIdentified->getInitials()) ? null : "uploads/kyvala/enrolment/".$personIdentified->getInitials(),
  1016.                 );
  1017.                     
  1018.             /*
  1019.                 } catch (\Throwable $error) 
  1020.                 {
  1021.                     //not actions
  1022.                     $fs = new Filesystem();
  1023.                     //$fs->appendToFile('EventLogFiles.txt', "\r\n ".json_encode($error));
  1024.                     $fs->appendToFile('log/Enrôlement/Exceptions/'.date("Y")."/".date("d-m-Y").'/EventLogFilesBio.txt', "\r\n ".date("d-m-Y H:i:s")." Enrollement exception : ".$error);
  1025.                     $return = array(
  1026.                         'Etat' =>'FAILED' , 
  1027.                         'Message' =>"Une erreur est survenue lors de l'opération. Veuillez essayer ultérieurement SVP", 
  1028.                         'error'=>$error,
  1029.                     );
  1030.                 }*/
  1031.                 
  1032.             }else
  1033.             {
  1034.                 $return = array(
  1035.                     'Etat' =>'FAILED' , 
  1036.                     'Message' =>"Cet IDO n'est associé à aucun individu enrolé. Veuillez vérifier et essayer à nouveau", 
  1037.                 );
  1038.             }     
  1039.         }else
  1040.         {
  1041.             $return = array(
  1042.                 'Etat' =>'FAILED',
  1043.                 'Message' =>"La méthode d'envoie ne correspond pas aux attentes",
  1044.             );
  1045.         }
  1046.         
  1047.         //$fs1 = new Filesystem();
  1048.         //$fs1->appendToFile('log/Enrôlement/'.date("Y")."/".date("d-m-Y").'/BiometricsFiles.txt', "\r\n ".json_encode($return));
  1050.        return new JsonResponse($return);
  1051.     }
  1053.     /**
  1054.      * @Route("/save/user/from/ido/json", name="app_person_civil_save_from_ido", methods={"GET", "POST"})
  1055.      */
  1056.     public function newUserFromIDOJson(Request $request, PersonCivilRepository $personCivilRepository, SluggerInterface $slugger, ContainerInterface $container, CheckQrRepository $checkQrRepository, PersonRepository $personRepository, ApplicationRepository $applicationRepository, PersonAppIdentityRepository $personAppIdentityRepository, DeviceRepository $deviceRepository ): Response
  1057.     {        
  1058.         if($_POST)
  1059.         {
  1060.             // device info
  1061.             $deviceId = $request->get("deviceId");
  1062.             $token = $request->get("deviceToken");
  1063.             $batteryState = $request->get("batteryState");
  1064.             $isBatteryPlugIn = $request->get("isBatteryPlugIn");
  1065.             $package = $request->get("packageName");
  1066.             $version = $request->get("appVersion");
  1067.             $appLongitude = $request->get("appLongitude");
  1068.             $appLatitude = $request->get("appLatitude");
  1070.             //user info
  1071.             $appKey = $request->get("app_key");
  1072.             $telephone = $request->get("telephone");
  1073.             $email = $request->get("email");
  1074.             $pin = $request->get("pin");
  1075.             $ido = $request->get("ido");
  1076.             
  1077.             $checkQr = $checkQrRepository->findOneBy(['numero'=>$ido]);
  1078.             if($checkQr)
  1079.             {
  1081.                 if (!empty($appKey) &&  !empty($telephone) && !empty($pin)  && !empty($email))
  1082.                 {
  1083.                     // On enregistre les paramètres de connexion de l'utilisateur dans la table personappidentity pour de futur connexion
  1084.                     if(!empty($appKey))
  1085.                     {
  1086.                         $application = $applicationRepository->findOneBy(['applicationPass'=>$appKey]);
  1087.                         if($application)
  1088.                         {
  1089.                             $personAppI = $personAppIdentityRepository->findOneBy(['application'=>$application, 'telephone'=>$telephone, 'email'=>$email, 'userReference'=>$checkQr]);
  1090.                            
  1091.                             if(empty($personAppI))
  1092.                             {
  1093.                                   // device infos persist  
  1094.                                 $device = new Device();
  1095.                                 $device->setDeviceInfo($deviceId);
  1096.                                 $device->setDeviceToken($token);
  1097.                                 $device->setGpsLatitude($appLatitude);
  1098.                                 $device->setGpsLongitude($appLongitude);
  1099.                                 $device->setBatteryState($batteryState);
  1100.                                 $device->setIsBatteryPlugIn($isBatteryPlugIn);
  1101.                                 $device->setPackage($package);
  1102.                                 $device->setAppVersion($version);
  1103.                                 $deviceRepository->add($device, false);
  1104.                                 
  1105.                                 $personAppIdentity = new PersonAppIdentity();
  1106.                                 $personAppIdentity->setApplication($application);
  1107.                                 $personAppIdentity->setTelephone($telephone);
  1108.                                 $personAppIdentity->setEmail($email);
  1109.                                 $personAppIdentity->setPin($pin);
  1110.                                 $personAppIdentity->setUserReference($checkQr);
  1111.                                 $personAppIdentity->setToken($token);
  1112.                                 $personAppIdentity->setDevice($device);
  1113.                                 
  1114.                                 // method to flush
  1115.                                 $personAppIdentityRepository->add($personAppIdentity, true);
  1116.                                 $return = array(
  1117.                                     'Etat' =>'SUCCESS' , 
  1118.                                     'Message' =>"Votre compte as été crée avec succès !!!", 
  1119.                                     'IDO'=>$ido,
  1120.                                 );
  1121.                             }else{
  1122.                                 
  1123.                                 $return = array(
  1124.                                     'Etat' =>'FAILED' , 
  1125.                                     'Message' =>"Un compte existe déjà avec les informations relatif à cet application, ce numéro de téléphone et cet email. !!!", 
  1126.                                     'IDO'=>$ido,
  1127.                                 );
  1128.                             }
  1129.                             
  1130.                             
  1131.                         }else
  1132.                         {
  1133.                             $otherMsg = "La clé d'application envoyé ne correspond à aucun projet";                            
  1134.                         }                      
  1135.                     }
  1136.                     /*
  1137.                     $return = array(
  1138.                         'Etat' =>'SUCCESS' , 
  1139.                         'Message' =>"Votre compte as été crée avec succès !!!", 
  1140.                         'IDO'=>$ido,
  1141.                     );*/
  1143.                 }else
  1144.                 {
  1145.                     $return = array(
  1146.                         'Etat' =>'FAILED' , 
  1147.                         'Message' =>"Paramètres requis manquants", 
  1148.                     );
  1149.                 }
  1151.             }else
  1152.             {
  1153.                 $return = array(
  1154.                     'Etat' =>'FAILED' , 
  1155.                     'Message' =>$sqrRef. "Une erreur est survenue lors de l'enregistrement, aucun enregistrement ne correspond à la référence IDO...", 
  1156.                 );
  1157.             }
  1158.             
  1159.         }else
  1160.         {
  1161.             $return = array(
  1162.                 'Etat' =>'FAILED' , 
  1163.                 'Message' =>"La méthode d'envoie ne correspond pas aux attentes", 
  1164.             );
  1165.         }
  1166.         
  1167.        return new JsonResponse($return);
  1168.     }
  1170.     /**
  1171.      * @Route("/{id}", name="app_person_civil_show", methods={"GET"})
  1172.      */
  1173.     public function show(PersonCivil $personCivil): Response
  1174.     {
  1175.         return $this->render('person_civil/show.html.twig', [
  1176.             'person_civil' => $personCivil,
  1177.         ]);
  1178.     }
  1180.     /**
  1181.      * @Route("/{id}/edit", name="app_person_civil_edit", methods={"GET", "POST"})
  1182.      */
  1183.     public function edit(Request $request, PersonCivil $personCivil, PersonCivilRepository $personCivilRepository): Response
  1184.     {
  1185.         $form = $this->createForm(PersonCivilType::class, $personCivil);
  1186.         $form->handleRequest($request);
  1188.         if ($form->isSubmitted() && $form->isValid()) {
  1189.             $personCivilRepository->add($personCivil, true);
  1191.             return $this->redirectToRoute('app_person_civil_index', [], Response::HTTP_SEE_OTHER);
  1192.         }
  1194.         return $this->renderForm('person_civil/edit.html.twig', [
  1195.             'person_civil' => $personCivil,
  1196.             'form' => $form,
  1197.         ]);
  1198.     }
  1200.     /**
  1201.      * @Route("/{id}", name="app_person_civil_delete", methods={"POST"})
  1202.      */
  1203.     public function delete(Request $request, PersonCivil $personCivil, PersonCivilRepository $personCivilRepository): Response
  1204.     {
  1205.         if ($this->isCsrfTokenValid('delete'.$personCivil->getId(), $request->request->get('_token'))) {
  1206.             $personCivilRepository->remove($personCivil, true);
  1207.         }
  1209.         return $this->redirectToRoute('app_person_civil_index', [], Response::HTTP_SEE_OTHER);
  1210.     }
  1212.     //notifications push avec paramètres
  1213.     public function ParamsWithSendPushNotification($user_notification_token,$title,$message)
  1214.     {
  1215.         //https://www.youtube.com/watch?v=YHniUsrmX9Y
  1216.         $fs = new Filesystem();
  1218.         $credential = new ServiceAccountCredentials(
  1219.             "https://www.googleapis.com/auth/firebase.messaging",
  1220.             json_decode(file_get_contents
  1221.             ("kyvala-45525-firebase-adminsdk-cxpp5-cf78b66d72.json"),true)
  1222.         );
  1224.         $token = $credential->fetchAuthToken(HttpHandlerFactory::build());
  1225.         $accessToken = $token['access_token'];
  1227.         $ch = curl_init("https://fcm.googleapis.com/v1/projects/kyvala-45525/messages:send");
  1229.         curl_setopt($ch, CURLOPT_HTTPHEADER,[
  1230.             'Content-Type: application/json',
  1231.             'Authorization: ' . 'Bearer ' .$accessToken
  1232.         ]);
  1234.         curl_setopt($ch, CURLOPT_POSTFIELDS, '{
  1235.             "message": {
  1236.                 "token":"'.$user_notification_token.'",
  1237.                 "notification": {
  1238.                     "title":"'.$title.'",
  1239.                     "body":"'.$message.'",
  1240.                     "image":"http://poc.kyvala.com/uploads/TOKEN/Token-logo-avec-fond.png"
  1241.                 }
  1242.             }
  1243.         }');
  1245.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  1246.         curl_setopt($ch, CURLOPT_VERBOSE, true);
  1248.         $response = curl_exec($ch);
  1249.         
  1250.         if (curl_errno($ch)) 
  1251.         {
  1252.             print "Error: " . curl_error($ch);
  1253.             $fs->appendToFile('EventLogNotification.txt', "\r\n ".date("d-m-Y H:i:s")." : deviceToken :".$user_notification_token.", Title: ".$title.", Notification: ".$message.", Error:  ".json_encode(curl_error($ch)));
  1254.             exit();
  1255.         }else
  1256.         {
  1257.             $json = json_decode($response, true);
  1258.         }
  1260.         // Show me the result
  1261.         curl_close($ch);
  1262.         //dump($season_data);
  1263.         
  1264.         $fs->appendToFile('EventLogNotification.txt', "\r\n ".date("d-m-Y H:i:s")." : DeviceToken :".$user_notification_token.", Title: ".$title.", Notification: ".$message.", Retours: ".json_encode($response));
  1265.         // return a JSON object to caller
  1266.         return $json;
  1267.     }
  1269.     public function createCryptographe(Request $request, SluggerInterface $slugger)
  1270.     {
  1271.         $sqrRef = $request->get('ref');
  1272.         $nom = $request->get('nom');
  1273.         $prenom = $request->get('prenom');
  1274.         $telephone = $request->get('telephone');
  1275.         $nationalite = $request->get('nationalite');
  1276.         $dateNaiss = $request->get('dateNaiss');
  1277.         $lieuNaiss = $request->get('lieuNaiss');
  1278.         $email = $request->get('email');
  1280.         $demog = $nom.','.$prenom.','.$telephone.','.$nationalite.','.$dateNaiss.','.$lieuNaiss.','.$email;
  1281.         
  1282.         $fs = new Filesystem();
  1283.         $fs->appendToFile($this->getParameter('kyvala_directory').'/'.$sqrRef.'/demog.txt', "\r\n ".$demog);
  1285.         /** @var UploadedFile $pos1 */            
  1286.         $pos1 = $request->files->get('fpr1');
  1288.         // this condition is needed because the 'brochure' field is not required
  1289.         // so the PDF file must be processed only when a file is uploaded
  1290.         if ($pos1) 
  1291.         {
  1292.             $originalFilename = pathinfo($pos1->getClientOriginalName(), PATHINFO_FILENAME);
  1294.             // this is needed to safely include the file name as part of the URL
  1295.             $safeFilename = $slugger->slug($originalFilename);
  1296.             $newFilename = $safeFilename.'-'.uniqid().'.'.$pos1->guessExtension();
  1297.             //dump($newFilename);die;
  1298.             // Move the file to the directory where they must be stored
  1299.             try {
  1300.                 $pos1->move(
  1301.                     $this->getParameter('kyvala_directory').'/'.$sqrRef,
  1302.                     $newFilename
  1303.                 );
  1304.             } catch (FileException $e) 
  1305.             {
  1306.                 // ... handle exception if something happens during file upload
  1307.             }
  1308.             //dump($newFilename);die;
  1309.             //$img = \file_get_contents("http://my.kyvala.com/uploads/kyvala/enrolment/".$newFilename);
  1310.             $fpr1 = $this->getParameter('kyvala_directory')."/".$newFilename;
  1311.         }
  1312.  
  1313.          /** @var UploadedFile $pos2 */            
  1314.          $pos2 = $request->files->get('fpr2');
  1315.  
  1316.          // this condition is needed because the 'brochure' field is not required
  1317.          // so the PDF file must be processed only when a file is uploaded
  1318.          if ($pos2) 
  1319.          {
  1320.              $originalFilename = pathinfo($pos2->getClientOriginalName(), PATHINFO_FILENAME);
  1321.              // this is needed to safely include the file name as part of the URL
  1322.              $safeFilename = $slugger->slug($originalFilename);
  1323.              $newFilename = $safeFilename.'-'.uniqid().'.'.$pos2->guessExtension();
  1324.  
  1325.              // Move the file to the directory where they must be stored
  1326.              try {
  1327.                  $pos2->move(
  1328.                     $this->getParameter('kyvala_directory').'/'.$sqrRef,
  1329.                      $newFilename
  1330.                  );
  1331.              } catch (FileException $e) 
  1332.              {
  1333.                  // ... handle exception if something happens during file upload
  1334.              }
  1335.              
  1336.             $fpr2 = $this->getParameter('kyvala_directory').'/'.$sqrRef.'/'.$newFilename;
  1337.         
  1338.          }      
  1339.  
  1340.          /** @var UploadedFile $pos3 */            
  1341.          $pos3 = $request->files->get('fpr3');
  1342.  
  1343.          // this condition is needed because the 'brochure' field is not required
  1344.          // so the PDF file must be processed only when a file is uploaded
  1345.          if ($pos3) 
  1346.          {
  1347.              $originalFilename = pathinfo($pos3->getClientOriginalName(), PATHINFO_FILENAME);
  1348.              // this is needed to safely include the file name as part of the URL
  1349.              $safeFilename = $slugger->slug($originalFilename);
  1350.              $newFilename = $safeFilename.'-'.uniqid().'.'.$pos3->guessExtension();
  1351.  
  1352.              // Move the file to the directory where they must be stored
  1353.              try {
  1354.                  $pos3->move(
  1355.                      $this->getParameter('kyvala_directory').'/'.$sqrRef,
  1356.                      $newFilename
  1357.                  );
  1358.              } catch (FileException $e) 
  1359.              {
  1360.                  // ... handle exception if something happens during file upload
  1361.              }
  1362.             
  1363.             $fpr3 = $this->getParameter('kyvala_directory').'/'.$sqrRef.'/'.$newFilename;
  1364.         
  1365.          }   
  1366.  
  1367.          /** @var UploadedFile $pos4 */            
  1368.          $pos4 = $request->files->get('fpr4');
  1369.  
  1370.          // this condition is needed because the 'brochure' field is not required
  1371.          // so the PDF file must be processed only when a file is uploaded
  1372.          if ($pos4) 
  1373.          {
  1374.              $originalFilename = pathinfo($pos4->getClientOriginalName(), PATHINFO_FILENAME);
  1375.              // this is needed to safely include the file name as part of the URL
  1376.              $safeFilename = $slugger->slug($originalFilename);
  1377.              $newFilename = $safeFilename.'-'.uniqid().'.'.$pos4->guessExtension();
  1378.  
  1379.              // Move the file to the directory where they must be stored
  1380.              try {
  1381.                  $pos4->move(
  1382.                      $this->getParameter('kyvala_directory').'/'.$sqrRef,
  1383.                      $newFilename
  1384.                  );
  1385.              } catch (FileException $e) 
  1386.              {
  1387.                  // ... handle exception if something happens during file upload
  1388.              }
  1389.              
  1390.             $fpr4 = $this->getParameter('kyvala_directory').'/'.$sqrRef.'/'.$newFilename;
  1391.         
  1392.          }       
  1393.  
  1394.          /** @var UploadedFile $pos5 */            
  1395.          $pos5 = $request->files->get('fpr5');
  1396.  
  1397.          // this condition is needed because the 'brochure' field is not required
  1398.          // so the PDF file must be processed only when a file is uploaded
  1399.          if ($pos5) 
  1400.          {
  1401.              $originalFilename = pathinfo($pos5->getClientOriginalName(), PATHINFO_FILENAME);
  1402.              // this is needed to safely include the file name as part of the URL
  1403.              $safeFilename = $slugger->slug($originalFilename);
  1404.              $newFilename = $safeFilename.'-'.uniqid().'.'.$pos5->guessExtension();
  1405.  
  1406.              // Move the file to the directory where they must be stored
  1407.              try {
  1408.                  $pos5->move(
  1409.                      $this->getParameter('kyvala_directory').'/'.$sqrRef,
  1410.                      $newFilename
  1411.                  );
  1412.              } catch (FileException $e) 
  1413.              {
  1414.                  // ... handle exception if something happens during file upload
  1415.              }
  1416.             $fpr5 = $this->getParameter('kyvala_directory').'/'.$sqrRef.'/'.$newFilename;
  1417.          }   
  1418.  
  1419.          /** @var UploadedFile $pos6 */            
  1420.          $pos6 = $request->files->get('fpl1');
  1421.  
  1422.          // this condition is needed because the 'brochure' field is not required
  1423.          // so the PDF file must be processed only when a file is uploaded
  1424.          if ($pos6) 
  1425.          {
  1426.              $originalFilename = pathinfo($pos6->getClientOriginalName(), PATHINFO_FILENAME);
  1427.              // this is needed to safely include the file name as part of the URL
  1428.              $safeFilename = $slugger->slug($originalFilename);
  1429.              $newFilename = $safeFilename.'-'.uniqid().'.'.$pos6->guessExtension();
  1430.  
  1431.              // Move the file to the directory where they must be stored
  1432.              try {
  1433.                  $pos6->move(
  1434.                      $this->getParameter('kyvala_directory').'/'.$sqrRef,
  1435.                      $newFilename
  1436.                  );
  1437.              } catch (FileException $e) 
  1438.              {
  1439.                  // ... handle exception if something happens during file upload
  1440.              }
  1441.             $fpl1 = $this->getParameter('kyvala_directory').'/'.$sqrRef.'/'.$newFilename;
  1442.         
  1443.          }
  1444.  
  1445.          /** @var UploadedFile $pos7 */            
  1446.          $pos7 = $request->files->get('fpl2');
  1447.  
  1448.          // this condition is needed because the 'brochure' field is not required
  1449.          // so the PDF file must be processed only when a file is uploaded
  1450.          if ($pos7) 
  1451.          {
  1452.              $originalFilename = pathinfo($pos7->getClientOriginalName(), PATHINFO_FILENAME);
  1453.              // this is needed to safely include the file name as part of the URL
  1454.              $safeFilename = $slugger->slug($originalFilename);
  1455.              $newFilename = $safeFilename.'-'.uniqid().'.'.$pos7->guessExtension();
  1456.  
  1457.              // Move the file to the directory where they must be stored
  1458.              try {
  1459.                  $pos7->move(
  1460.                      $this->getParameter('kyvala_directory').'/'.$sqrRef,
  1461.                      $newFilename
  1462.                  );
  1463.              } catch (FileException $e) 
  1464.              {
  1465.                  // ... handle exception if something happens during file upload
  1466.              }
  1467.             
  1468.              $fpl2 = $this->getParameter('kyvala_directory').'/'.$sqrRef.'/'.$newFilename;
  1469.         
  1470.          }
  1471.  
  1472.          /** @var UploadedFile $pos8 */            
  1473.          $pos8 = $request->files->get('fpl3');
  1474.  
  1475.          // this condition is needed because the 'brochure' field is not required
  1476.          // so the PDF file must be processed only when a file is uploaded
  1477.          if ($pos8) 
  1478.          {
  1479.              $originalFilename = pathinfo($pos8->getClientOriginalName(), PATHINFO_FILENAME);
  1480.              // this is needed to safely include the file name as part of the URL
  1481.              $safeFilename = $slugger->slug($originalFilename);
  1482.              $newFilename = $safeFilename.'-'.uniqid().'.'.$pos8->guessExtension();
  1483.  
  1484.              // Move the file to the directory where they must be stored
  1485.             try {
  1486.                  $pos8->move(
  1487.                      $this->getParameter('kyvala_directory').'/'.$sqrRef,
  1488.                      $newFilename
  1489.                  );
  1490.             } catch (FileException $e) 
  1491.             {
  1492.                 // ... handle exception if something happens during file upload
  1493.             }
  1494.             
  1495.             $fpl3 = $this->getParameter('kyvala_directory').'/'.$sqrRef.'/'.$newFilename;
  1496.          }
  1497.  
  1498.          /** @var UploadedFile $pos9 */            
  1499.          $pos9 = $request->files->get('fpl4');
  1500.  
  1501.          // this condition is needed because the 'brochure' field is not required
  1502.          // so the PDF file must be processed only when a file is uploaded
  1503.          if ($pos9) 
  1504.          {
  1505.              $originalFilename = pathinfo($pos9->getClientOriginalName(), PATHINFO_FILENAME);
  1506.              // this is needed to safely include the file name as part of the URL
  1507.              $safeFilename = $slugger->slug($originalFilename);
  1508.              $newFilename = $safeFilename.'-'.uniqid().'.'.$pos9->guessExtension();
  1509.  
  1510.              // Move the file to the directory where they must be stored
  1511.             try {
  1512.                  $pos9->move(
  1513.                      $this->getParameter('kyvala_directory').'/'.$sqrRef,
  1514.                      $newFilename
  1515.                  );
  1516.             } catch (FileException $e) 
  1517.             {
  1518.                 // ... handle exception if something happens during file upload
  1519.             }
  1521.             $fpl4 = $this->getParameter('kyvala_directory').'/'.$sqrRef.'/'.$newFilename;
  1522.          }
  1523.  
  1524.          /** @var UploadedFile $pos10 */            
  1525.          $pos10 = $request->files->get('fpl5');
  1526.  
  1527.          // this condition is needed because the 'brochure' field is not required
  1528.          // so the PDF file must be processed only when a file is uploaded
  1529.          if ($pos10) 
  1530.          {
  1531.             $originalFilename = pathinfo($pos10->getClientOriginalName(), PATHINFO_FILENAME);
  1532.             // this is needed to safely include the file name as part of the URL
  1533.             $safeFilename = $slugger->slug($originalFilename);
  1534.             $newFilename = $safeFilename.'-'.uniqid().'.'.$pos10->guessExtension();
  1535.             
  1536.             // Move the file to the directory where they must be stored
  1537.             try {
  1538.                  $pos10->move(
  1539.                      $this->getParameter('kyvala_directory').'/'.$sqrRef,
  1540.                      $newFilename
  1541.                  );
  1542.             } catch (FileException $e) 
  1543.             {
  1544.                 // ... handle exception if something happens during file upload
  1545.             }
  1547.             $fpl5 = $this->getParameter('kyvala_directory').'/'.$sqrRef.'/'.$newFilename;
  1548.         }
  1550.          /** @var UploadedFile $face */            
  1551.          $face = $request->files->get('face');
  1552.  
  1553.          // this condition is needed because the 'brochure' field is not required
  1554.          // so the PDF file must be processed only when a file is uploaded
  1555.         if ($face) 
  1556.         { 
  1557.             $originalFilename = pathinfo($face->getClientOriginalName(), PATHINFO_FILENAME);
  1558.             // this is needed to safely include the file name as part of the URL
  1559.             $safeFilename = $slugger->slug($originalFilename);
  1560.             $newFilename = $safeFilename.'-'.uniqid().'.'.$face->guessExtension();
  1561.             
  1562.             // Move the file to the directory where they must be stored
  1563.             try {
  1564.                  $face->move(
  1565.                      $this->getParameter('kyvala_directory').'/'.$sqrRef,
  1566.                      $newFilename
  1567.                  );
  1568.             }catch (FileException $e) 
  1569.             {
  1570.                 //... handle exception if something happens during file upload
  1571.             }
  1573.             $face = $this->getParameter('kyvala_directory').'/'.$sqrRef.'/'.$newFilename;
  1574.         }
  1575.         
  1576.         $curl = curl_init();
  1578.         curl_setopt_array($curl, array(
  1579.             CURLOPT_URL => 'https://eval-idencode.tech5.tech/v1/enroll',
  1580.             CURLOPT_RETURNTRANSFER => true,
  1581.             CURLOPT_ENCODING => '',
  1582.             CURLOPT_MAXREDIRS => 10,
  1583.             CURLOPT_TIMEOUT => 0,
  1584.             CURLOPT_FOLLOWLOCATION => true,
  1585.             CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  1586.             CURLOPT_CUSTOMREQUEST => 'POST',
  1587.             CURLOPT_POSTFIELDS => array('face_image'=> new \CURLFILE($face),'pipeline'=> new \CURLFILE($this->getParameter('kyvala_directory').'/pipeline-with-fp-CR.txt'),'demog'=> new \CURLFILE($this->getParameter('kyvala_directory').'/'.$sqrRef.'/demog.txt'),'finger_image_r1'=> new \CURLFILE($fpr1),'finger_image_r2'=> new \CURLFILE($fpr2),'finger_image_r3'=> new \CURLFILE($fpr3),'finger_image_r4'=> new \CURLFILE($fpr4),'finger_image_r5'=> new \CURLFILE($fpr5),'finger_image_l1'=> new \CURLFILE($fpl1),'finger_image_l2'=> new \CURLFILE($fpl2),'finger_image_l3'=> new \CURLFILE($fpl3),'finger_image_l4'=> new \CURLFILE($fpl4),'finger_image_l5'=> new \CURLFILE($fpl5)),
  1588.         ));
  1590.         $response = curl_exec($curl);
  1592.         //On écris le retours de la fonction dans le log
  1593.         $fs->appendToFile($this->getParameter('kyvala_directory').'/'.$sqrRef.'/cryptoGenerationLog.txt', "\r\n ".$response);
  1595.         $response = json_decode($response,true);
  1596.         curl_close($curl);
  1597.         //echo $response;
  1599.         return $response;
  1600.     }
  1601. }