src/Controller/WebServiceController.php line 649

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  6. use Symfony\Component\HttpFoundation\RequestStack;
  7. use Doctrine\ORM\Query;
  8. use Symfony\Bundle\FrameworkBundle\Controller\Controller;
  10. use Symfony\Component\Serializer\Encoder\XmlEncoder;
  11. use Symfony\Component\Serializer\Encoder\JsonEncoder;
  12. use Symfony\Component\HttpFoundation\Response;
  13. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  14. use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
  15. #use Symfony\Component\Serializer;
  16. use Symfony\Component\Serializer\Serializer;
  17. use Symfony\Component\Serializer\SerializerInterface;
  18. use Symfony\Component\Validator\Validation;
  19. use Symfony\Component\Filesystem\Filesystem;
  20. use Symfony\Component\Routing\Annotation\Route;
  21. use Symfony\Component\HttpFoundation\JsonResponse;
  23. use phpseclib3\Net\SFTP;
  26. use App\Services\MailService;
  28. use App\Entity\BDDG\Terminal; 
  29. use App\Entity\BDDG\TerminalErreur; 
  30. use App\Entity\BDDG\Periode; 
  31. use App\Entity\BDDG\Tarifs;
  32. use App\Entity\BDDG\Tarif;
  34. use App\Entity\BDPolymorph\Commande;
  35. use App\Entity\BDPolymorph\CommandeService;
  36. use App\Entity\BDPolymorph\TransactionCb;
  37. use App\Entity\BDPolymorph\Solvabilite;
  38. use App\Entity\BDPolymorph\SolvabiliteOk;
  39. use App\Entity\BDPolymorph\Enregistrement;
  40. use App\Entity\BDPolymorph\EnregistrementOk;
  41. use App\Entity\BDPolymorph\InfoRemise;
  43. use App\Entity\BDPolymorph\Log;
  45. use App\Entity\BDDG\TerminalComposant; 
  47. use App\Services\libMQTT\src\ClientMQTT;
  49. class WebServiceController extends AbstractController
  50. {
  51.     /**
  52.      * @Route("/netbase", name="netbase")
  53.      */
  54.      
  55.     protected $requestStack;
  57.     public function __construct(RequestStack $requestStack)
  58.     {
  59.         $this->requestStack = $requestStack;
  60.     }
  62.     public function insertTerminal($_format)
  63.     {
  64.         
  65.         $encoders = [new XmlEncoder(), new JsonEncoder()];
  66.         $normalizers = [new ObjectNormalizer()];
  67.         $serializer = new Serializer($normalizers, $encoders);
  68.         $validator = Validation::createValidator();
  69.     
  70.         //SH 2021.01.21 ajout des terminaux 
  71.         $request = $this->requestStack->getCurrentRequest();
  72.         //$data = $request->getContent();
  73.         //return new Response (var_dump($request->getContent()));
  74.         // create the serializer
  75.         //$serializer = $this->getSerializer($_format);
  76.         //return new Response (var_dump($serializer));
  77.         // build the Commande from a decoded array
  78.         
  79.             $terminal = $serializer->deserialize ($request->getContent(),
  80.                 'App\Entity\BDDG\Terminal',
  81.                 $_format);
  82.     
  83.         //return new Response (var_dump($terminal));
  86.         /*if ($terminal)
  87.         {
  88.             //$validator = $this->get('validator');
  89.             if (0 === count($validator->validate($terminal)))
  90.             {
  91.             
  92.                 $con = $this->getDoctrine()->getConnection();
  93.                 $sql = $con->prepare("insert into terminal (ID_TERMINAL, NOM_TERMINAL, NOM_BORNE, ID_TYPE_CONTROL, COMMENTAIRE_TERMINAL) values (?, ?,?, ?, ?)");
  94.                 $sql->bindValue(1, $terminal->getIdTerminal());
  95.                 $sql->bindValue(2, $terminal->getNomTerminal());
  96.                 $sql->bindValue(3, ' ');
  97.                 $sql->bindValue(4, null);
  98.                 $sql->bindValue(5, null);
  99.                 $sql->execute();
  100.                 
  101.                 $response = new Response('Valid terminal!', 201);
  103.               //provisoire
  104.                 $con1 = $this->getDoctrine()->getConnection();
  105.                 $sql1 = $con1->prepare("insert into zone (ID_TERMINAL, ID_ZONE, NOM_ZONE, NB_PLACE, NB_PLACES_IPARK, XMPP_USER, XMPP_PASSWORD, XMPP_SYNOPTIQUE, XMPP_SYNOPTIQUE_PASSWORD, bnq_site_id, bnq_key) values (?,?,?,?,?,?,?,?,?,?,?)");
  106.                 $sql1->bindValue(1, $terminal->getIdTerminal());
  107.                 $sql1->bindValue(2, 1);
  108.                 $sql1->bindValue(3, $terminal->getNomTerminal());
  109.                 $sql1->bindValue(4, 10);
  110.                 $sql1->bindValue(5, 0);
  111.                 $sql1->bindValue(6, ' ');
  112.                 $sql1->bindValue(7, ' ');
  113.                 $sql1->bindValue(8, ' ');
  114.                 $sql1->bindValue(9, ' ');
  115.                 $sql1->bindValue(10, ' ');
  116.                 $sql1->bindValue(11, ' ');
  117.                 $sql1->execute();
  118.                 //return new Response (var_dump($sql1));
  119.                 return $response;
  120.             }
  121.         }*/
  122.     
  123.         if ($terminal)
  124.         {
  125.             if (0 === count($validator->validate($terminal)))    
  126.             {    
  127.                 $entityManager = $this->getDoctrine()->getManager();
  128.                 if($terminal->getEtatTerminal()==null ) $terminal->setEtatTerminal(0);
  129.                 if($terminal->getIdModePaiement()==null ) $terminal->setIdModePaiement(1);
  130.                 if($terminal->getIp()==null ) $terminal->setIp('11.11.11.11'); //SH 2024.09.03 initialisation adresse ip 
  131.                 $entityManager->merge($terminal);
  132.                 $entityManager->flush();
  133.                 $response = new Response('Valid terminal!', 201);
  134.                 return $response;
  135.             }
  136.         }
  137.         // something went wrong
  138.         $response = new Response('Invalid terminal!', 406);
  139.         return $response;
  140.     }
  141.     
  143.     //SH 2023.03.22 
  144.     public function insertZone($_format)
  145.     {
  146.         $encoders = [new XmlEncoder(), new JsonEncoder()];
  147.         $normalizers = [new ObjectNormalizer()];
  148.         $serializer = new Serializer($normalizers, $encoders);
  149.         $validator = Validation::createValidator();
  150.         $request = $this->requestStack->getCurrentRequest();
  152.         $zone = $serializer->deserialize ($request->getContent(),
  153.             'App\Entity\BDDG\Zone',
  154.             $_format);
  156.         //return new Response (var_dump($zone));
  158.         if ($zone)
  159.         {
  160.             //return new Response (var_dump(count($validator->validate($zone))));
  161.             if (0 === count($validator->validate($zone)))
  162.             {
  163.                 //return new Response (var_dump($zone));
  164.                 if ($zone->getTerminal()==null)
  165.                 {
  166.                     $repository = $this->getDoctrine()->getRepository('App\Entity\BDDG\Terminal');
  167.                     $terminal = $repository->findOneBy(array('idTerminal' => $zone->getIdTerminal()));
  168.                     //return new Response (var_dump($terminal));
  169.                     $zone->setTerminal($terminal);
  170.                     //return new Response (var_dump($zone));
  171.                 }
  172.                 $entityManager = $this->getDoctrine()->getManager();
  173.                 $entityManager->merge($zone);
  174.                 $entityManager->flush();
  175.                 
  176.                 $response = new Response('Valid zone!', 201);
  177.                 return $response;
  178.             }
  179.         }
  180.     
  181.         // something went wrong
  182.         $response = new Response('Invalid zone!', 406);
  183.         return $response;
  184.     }
  185.     
  186.     
  187.     public function insertTerminalService($_format)
  188.     {
  189.         $encoders = [new XmlEncoder(), new JsonEncoder()];
  190.         $normalizers = [new ObjectNormalizer()];
  191.         $serializer = new Serializer($normalizers, $encoders);
  192.         $validator = Validation::createValidator();
  194.         $request = $this->requestStack->getCurrentRequest();
  196.         //return new Response (var_dump($request->getContent()));
  198.         $terminalService  = $serializer->deserialize ($request->getContent(),
  199.             'App\Entity\BDDG\TerminalService',
  200.             $_format);
  202.         //return new Response (var_dump($terminalService));
  204.         if ($terminalService)
  205.         {         
  206.             if (0 === count($validator->validate($terminalService)))
  207.             {        
  208.                 if ($terminalService->getTerminal()==null)
  209.                 {
  210.                     $repository = $this->getDoctrine()->getRepository('App\Entity\BDDG\Terminal');
  211.                     $terminal = $repository->findOneBy(array('idTerminal' => $terminalService->getIdTerminal()));
  212.                     //return new Response (var_dump($terminal));
  213.                     $terminalService->setTerminal($terminal);
  214.                     //return new Response (var_dump($terminalService));
  215.                 }
  216.                 $entityManager = $this->getDoctrine()->getManager();
  217.                 $entityManager->merge($terminalService);
  218.                 $entityManager->flush();
  219.                 
  220.                 $response = new Response('Valid terminal service!', 201);
  221.                 return $response;
  222.             }
  223.         }
  224.     
  225.         // something went wrong
  226.         $response = new Response('Invalid terminal service!', 406);
  227.         return $response;
  228.     }
  231.     //SH 2021.05.03 WS commandes et telecollectes 
  232.     public function insertCommande($_format)
  233.     {            
  234.         $encoders = [new XmlEncoder(), new JsonEncoder()];
  235.         $normalizers = [new ObjectNormalizer()];
  236.         $serializer = new Serializer($normalizers, $encoders);
  237.         $validator = Validation::createValidator();
  238.         $request = $this->requestStack->getCurrentRequest();
  240.         // build the Commande from a decoded array
  241.         //return new Response (var_dump($request->getContent()));
  242.         $commande = $serializer->deserialize ($request->getContent(),
  243.                     'App\Entity\BDPolymorph\Commande',
  244.                    $_format);
  245.         //return new Response (var_dump(date_format($commande->getDateCommande(),"Y/m/d H:i:s")));
  246.         if ($commande) {
  247.             
  248.             if (0 === count($validator->validate($commande))) {
  249.                 //return new Response (var_dump($commandeAdd));
  250.                 $entityManager = $this->getDoctrine()->getManager('polymorph');
  251.                 $query = $entityManager->createQuery(
  252.                         'SELECT c FROM App\Entity\BDPolymorph\Commande c WHERE c.idCommande = :ID_COMMANDE AND c.idTerminal = :ID_TERMINAL'
  253.                  )->setParameter('ID_COMMANDE', $commande->getIdCommande())
  254.                  ->setParameter('ID_TERMINAL', $commande->getIdTerminal());
  255.                 
  256.                  $commandeExists = $query->getResult();
  257.                 
  258.                  if ($commandeExists == null) {
  259.                     
  260.                     $con = $this->getDoctrine()->getConnection('polymorph');
  261.                     $sql = $con->prepare("insert into commande  (ID_COMMANDE, ID_TERMINAL, ID_ZONE, ID_USER, DATE_COMMANDE, IS_ENVOYER_NB, ID_TYPE_RESERVATION, ID_DRAPEAU) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
  262.                     $sql->bindValue(1, $commande->getIdCommande());
  263.                     $sql->bindValue(2, $commande->getIdTerminal());
  264.                     $sql->bindValue(3, $commande->getIdZone());
  265.                     $sql->bindValue(4,  $commande->getIdUser());
  266.                     $sql->bindValue(5,  date_format($commande->getDateCommande(),"Y/m/d H:i:s"));
  267.                     $sql->bindValue(6,  $commande->getIsEnvoyerNb());
  268.                     $sql->bindValue(7,  $commande->getIdTypeReservation());
  269.                     $sql->bindValue(8,  $commande->getIdDrapeau());
  270.                     $sql->execute();
  271.                 }
  272.                 $response = new Response('Valid Commande!', 201);
  273.                 return $response;
  274.             }
  275.         }
  276.         
  277.         $response = new Response('Invalid commande!', 406);
  278.         return $response;
  279.     }
  281.     //fin SH 
  285.     //SH 2021.05.18
  286.     public function insertCommandeService($_format)
  287.     {
  288.         // create the serializer
  289.         //$serializer = $this->getSerializer($_format);
  290.         //return new Response (var_dump('CommandeService'));
  291.         $encoders = [new XmlEncoder(), new JsonEncoder()];
  292.         $normalizers = [new ObjectNormalizer()];
  293.         $serializer = new Serializer($normalizers, $encoders);
  294.         $validator = Validation::createValidator();
  295.         $request = $this->requestStack->getCurrentRequest();
  296.         //return new Response (var_dump($request->getContent())); 
  297.         // build the Commande from a decoded array
  298.         $commandeService = $serializer->deserialize ($request->getContent(),
  299.                 'App\Entity\BDPolymorph\CommandeService',
  300.                 $_format);
  301.          
  302.         if ($commandeService)
  303.         {
  304.         
  305.             if (0 === count($validator->validate($commandeService)))
  306.             {
  307.                 $entityManager = $this->getDoctrine()->getManager('polymorph');
  308.                 $query = $entityManager->createQuery(
  309.                                      'SELECT cs FROM App\Entity\BDPolymorph\CommandeService cs WHERE cs.idCommande = :ID_COMMANDE AND cs.idTerminal = :ID_TERMINAL AND cs.idService = :ID_SERVICE'
  310.                                  )->setParameter('ID_COMMANDE', $commandeService->getIdCommande())
  311.                                  ->setParameter('ID_TERMINAL', $commandeService->getIdTerminal())
  312.                                  ->setParameter('ID_SERVICE', $commandeService->getIdService());
  313.                                  $commandeServiceExists = $query->getResult();
  314.                                     
  315.                  if($commandeServiceExists == null)
  316.                      {
  317.                     
  318.                     $con = $this->getDoctrine()->getConnection('polymorph');
  319.                     $sql = $con->prepare("INSERT INTO commande_service (ID_COMMANDE, ID_TERMINAL, ID_SERVICE, ID_ZONE, ID_TARIF, ID_COMPOSANT, QTE, QTE_UNITAIRE, UNITE, PRIX, ID_TYPE_SERVICE) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
  320.                     $sql->bindValue(1, $commandeService->getIdCommande());
  321.                     $sql->bindValue(2, $commandeService->getIdTerminal());
  322.                     $sql->bindValue(3, $commandeService->getIdService());
  323.                     $sql->bindValue(4, $commandeService->getIdZone());
  324.                     $sql->bindValue(5, $commandeService->getIdTarif());
  325.                     $sql->bindValue(6, $commandeService->getIdComposant());
  326.                     $sql->bindValue(7, $commandeService->getQte());
  327.                     $sql->bindValue(8, $commandeService->getQteUnitaire());
  328.                     $sql->bindValue(9, $commandeService->getUnite());
  329.                     $sql->bindValue(10, $commandeService->getPrix());
  330.                     $sql->bindValue(11, $commandeService->getIdTypeService());
  331.                     $sql->execute();
  332.                 }
  333.                 $response = new Response('Valid Commande!', 201);
  334.                 return $response;
  335.             }
  336.         }
  337.          
  338.         // something went wrong
  339.         $response = new Response('Invalid commande service!', 406);
  340.         return $response;
  341.     }
  343.     public function insertCommandeServiceConso ($_format)
  344.     {
  345.        
  346.         // create the serializer
  347.          $encoders = [new XmlEncoder(), new JsonEncoder()];
  348.         $normalizers = [new ObjectNormalizer()];
  349.         $serializer = new Serializer($normalizers, $encoders);
  350.         $validator = Validation::createValidator();
  351.         $request = $this->requestStack->getCurrentRequest();
  352.     
  353.         // build the Commande from a decoded array
  354.         $commandeServiceConso = $serializer->deserialize ($request->getContent(),
  355.                 'App\Entity\BDPolymorph\CommandeServiceConso',
  356.                 $_format);
  357.     
  358.         if ($commandeServiceConso)
  359.         {
  360.             $validator = $this->get('validator');
  361.             if (0 === count($validator->validate($commandeServiceConso)))
  362.             {
  363.                 // this is a valid Commande instance, persist it
  364.                 $entityManager = $this->getDoctrine()->getManager('polymorph');
  365.                 
  366. //                 $query = $entityManager->createQuery(
  367. //                         'SELECT csc FROM NetBaseEntitiesDBBundle:CommandeServiceConso csc WHERE csc.idCommande = :ID_COMMANDE AND csc.idTerminal = :ID_TERMINAL AND csc.idService = :ID_SERVICE AND csc.idServiceConso = :ID_SERVICE_CONSO'
  368. //                 )->setParameter('ID_COMMANDE', $commandeServiceConso->getIdCommande())
  369. //                 ->setParameter('ID_TERMINAL', $commandeServiceConso->getIdTerminal())
  370. //                 ->setParameter('ID_SERVICE', $commandeServiceConso->getIdService())
  371. //                 ->setParameter('ID_SERVICE_CONSO', $commandeServiceConso->getIdServiceConso());
  372. //                 $commandeServiceConsoExists = $query->getResult();
  373.                  
  374. //                 if($commandeServiceConsoExists == null)
  375. //                 {
  376. //                   $entityManager->persist($commandeServiceConso);
  377. //                   $entityManager->flush();
  378. //                 }
  379.     
  380.                 $entityManager->merge($commandeServiceConso);
  381.                 $entityManager->flush();
  382.                 
  383.                 $response = new Response('Valid commande service conso!', 201);
  384.                 return $response;
  385.             }
  386.         }
  387.     
  388.         // something went wrong
  389.         $response = new Response('Invalid commande service conso!', 406);
  390.         return $response;
  391.     }
  392.     
  393.     public function insertTransactionCb ($_format)
  394.     {       
  395.         // create the serializer
  396.          $encoders = [new XmlEncoder(), new JsonEncoder()];
  397.         $normalizers = [new ObjectNormalizer()];
  398.         $serializer = new Serializer($normalizers, $encoders);
  399.         $validator = Validation::createValidator();
  400.         $request = $this->requestStack->getCurrentRequest();
  401.        // $res = deleteSpecialChar($request->getContent()); 
  402.        $res=str_ireplace(array('', '', '', '' ,'&' ,'|'), '', $request->getContent());
  403.        // $res = $varUneChaine = preg_replace('/([^.a-z0-9]+)/i', '_', $request->getContent());
  404.         //return new Response (var_dump($res)); 
  405.         // build the Commande from a decoded array
  406.         //$transactionCb = $serializer->deserialize ($request->getContent(),
  407.         //        'App\Entity\BDPolymorph\TransactionCb',
  408.         //        $_format);  
  409.         $transactionCb = $serializer->deserialize ($res,
  410.                 'App\Entity\BDPolymorph\TransactionCb',
  411.                 $_format);  
  412.         
  413.         if ($transactionCb)
  414.         {
  415.             
  416.             if (0 === count($validator->validate($transactionCb)))
  417.             {
  418.                 // this is a valid Commande instance, persist it
  419.                 $entityManager = $this->getDoctrine()->getManager('polymorph');
  420.                 
  421.                  $query = $entityManager->createQuery(
  422.                         'SELECT t FROM  App\Entity\BDPolymorph\TransactionCb t WHERE t.idCommande = :ID_COMMANDE AND t.idTerminal = :ID_TERMINAL AND t.idTransaction = :ID_TRANSACTION'
  423.                  )->setParameter('ID_COMMANDE', $transactionCb->getIdCommande())
  424.                  ->setParameter('ID_TERMINAL', $transactionCb->getIdTerminal())
  425.                  ->setParameter('ID_TRANSACTION', $transactionCb->getIdTransaction());
  426.                  $transactionCbExists = $query->getResult();
  427.                 
  428.                  if($transactionCbExists == null)
  429.                  {
  430.                     $con = $this->getDoctrine()->getConnection('polymorph');
  431.                     $sql = $con->prepare("INSERT INTO transaction_cb (ID_TRANSACTION, ID_COMMANDE, ID_TERMINAL, OK, TRAME_SOLVABILITE, TRAME_ENREGISTREMENT, TRAME_TICKET) VALUES (?, ?, ?, ?, ?, ?, ?)");
  432.                     $sql->bindValue(1, $transactionCb->getIdTransaction());
  433.                     $sql->bindValue(2, $transactionCb->getIdCommande());
  434.                     $sql->bindValue(3,  $transactionCb->getIdTerminal());
  435.                     $sql->bindValue(4, $transactionCb->getOk());
  436.                     $sql->bindValue(5,  $transactionCb->getTrameSolvabilite());
  437.                     $sql->bindValue(6, $transactionCb->getTrameEnregistrement());
  438.                     $sql->bindValue(7,  $transactionCb->getTrameTicket());    
  439.                     $sql->execute();
  440.                 }
  441.         
  442.                 $response = new Response('Valid transaction CB!', 201);
  443.                 return $response;
  444.             }
  445.         }
  446.     
  447.         // something went wrong
  448.         $response = new Response('Invalid transaction CB!', 406);
  449.         return $response;
  450.     }
  451.     
  452.     public function insertSolvabilite ($_format)
  453.     {
  454.         // create the serializer
  455.         $encoders = [new XmlEncoder(), new JsonEncoder()];
  456.         $normalizers = [new ObjectNormalizer()];
  457.         $serializer = new Serializer($normalizers, $encoders);
  458.         $validator = Validation::createValidator();
  459.         $request = $this->requestStack->getCurrentRequest();
  460.          $res=str_ireplace(array('', '', '', '' ,'&' ,'|'), '', $request->getContent());
  461.         // build the Commande from a decoded array
  462.         /*$solvabilite = $serializer->deserialize ($request->getContent(),
  463.                 'App\Entity\BDPolymorph\Solvabilite',
  464.                 $_format);*/
  465.         $solvabilite = $serializer->deserialize ($res,
  466.                 'App\Entity\BDPolymorph\Solvabilite',
  467.                 $_format);
  468.     
  469.         if ($solvabilite)
  470.         {
  471.             
  472.             if (0 === count($validator->validate($solvabilite)))
  473.             {
  474.                 // this is a valid Commande instance, persist it
  475.                 $entityManager = $this->getDoctrine()->getManager('polymorph');
  476.                 
  477.                  $query = $entityManager->createQuery(
  478.                          'SELECT s FROM App\Entity\BDPolymorph\Solvabilite s WHERE s.idCommande = :ID_COMMANDE AND s.idTerminal = :ID_TERMINAL AND s.idTransaction = :ID_TRANSACTION'
  479.                  )->setParameter('ID_COMMANDE', $solvabilite->getIdCommande())
  480.                  ->setParameter('ID_TERMINAL', $solvabilite->getIdTerminal())
  481.                  ->setParameter('ID_TRANSACTION', $solvabilite->getIdTransaction());
  482.                  $solvabiliteExists = $query->getResult();
  483.                  
  484.                  if($solvabiliteExists == null)
  485.                  {
  486.                     $con = $this->getDoctrine()->getConnection('polymorph');
  487.                     $sql = $con->prepare("INSERT INTO solvabilite (ID_TRANSACTION, ID_COMMANDE, ID_TERMINAL, LG1, CR, DIAG, TYPECARTE, PRES, PAPIER, LIBELLE, LG2)  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
  488.                     $sql->bindValue(1,$solvabilite->getIdTransaction());
  489.                     $sql->bindValue(2,     $solvabilite->getIdCommande());
  490.                     $sql->bindValue(3,     $solvabilite->getIdTerminal());
  491.                     $sql->bindValue(4,  $solvabilite->getLg1());
  492.                     $sql->bindValue(5,  $solvabilite->getCr());
  493.                     $sql->bindValue(6,  $solvabilite->getDiag());
  494.                     $sql->bindValue(7,  $solvabilite->getTypeCarte());
  495.                     $sql->bindValue(8,  $solvabilite->getPres());
  496.                     $sql->bindValue(9,  $solvabilite->getPapier());
  497.                     $sql->bindValue(10, $solvabilite->getLibelle());
  498.                     $sql->bindValue(11, $solvabilite->getLg2());
  499.                     $sql->execute();
  500.                  }
  501.     
  502.             
  503.                 
  504.                 $response = new Response('Valid solvabilite!', 201);
  505.                 return $response;
  506.             }
  507.         }
  508.     
  509.         // something went wrong
  510.         $response = new Response('Invalid solvabilite!', 406);
  511.         return $response;
  512.     }
  513.     
  514.     public function insertSolvabiliteOk ($_format)
  515.     {
  516.         // create the serializer
  517.          $encoders = [new XmlEncoder(), new JsonEncoder()];
  518.         $normalizers = [new ObjectNormalizer()];
  519.         $serializer = new Serializer($normalizers, $encoders);
  520.         $validator = Validation::createValidator();
  521.         $request = $this->requestStack->getCurrentRequest();
  522.         //return new Response (var_dump($request->getContent())); 
  523.         // build the Commande from a decoded array
  524.         $res=str_ireplace(array('', '', '', '' ,'&' ,'|'), '', $request->getContent());
  525.         /*$solvabiliteOk = $serializer->deserialize ($request->getContent(),
  526.                 'App\Entity\BDPolymorph\SolvabiliteOk',
  527.                 $_format);*/
  528.         $solvabiliteOk = $serializer->deserialize ($res,
  529.                 'App\Entity\BDPolymorph\SolvabiliteOk',
  530.                 $_format);
  531.     
  533.         //return new Response (var_dump($solvabiliteOk->getIdTransaction()));         
  534.         if ($solvabiliteOk)
  535.         {
  536.             
  537.             if (0 === count($validator->validate($solvabiliteOk)))
  538.             {
  539.                 // this is a valid Commande instance, persist it
  540.                 $entityManager = $this->getDoctrine()->getManager('polymorph');
  541.                 
  542.                  $query = $entityManager->createQuery(
  543.                          'SELECT s FROM App\Entity\BDPolymorph\SolvabiliteOk s WHERE s.idCommande = :ID_COMMANDE AND s.idTerminal = :ID_TERMINAL AND s.idTransaction = :ID_TRANSACTION'
  544.                  )->setParameter('ID_COMMANDE', $solvabiliteOk->getIdCommande())
  545.                  ->setParameter('ID_TERMINAL', $solvabiliteOk->getIdTerminal())
  546.                  ->setParameter('ID_TRANSACTION', $solvabiliteOk->getIdTransaction());
  547.                  $solvabiliteOkExists = $query->getResult();
  548.                 
  549.                  if($solvabiliteOkExists == null)
  550.                 {
  551.                     $con = $this->getDoctrine()->getConnection('polymorph');
  552.                     $sql = $con->prepare("INSERT INTO solvabilite_ok (`ID_COMMANDE`, `ID_TERMINAL`, `ID_TRANSACTION`, `MONTANTMAX`, `CODEALPHADELADEV`, `PARTIEFRACDELADEV`)  VALUES (?, ?, ?, ?, ?, ?)");
  553.                     
  554.                     $sql->bindValue(1,     $solvabiliteOk->getIdCommande());
  555.                     $sql->bindValue(2,     $solvabiliteOk->getIdTerminal());
  556.                     $sql->bindValue(3,  $solvabiliteOk->getIdTransaction());
  557.                     $sql->bindValue(4,  $solvabiliteOk->getMontantmax());
  558.                     $sql->bindValue(5,  $solvabiliteOk->getCodealphadeladev());
  559.                     $sql->bindValue(6,  $solvabiliteOk->getPartiefracdeladev());
  560.                     $sql->execute();
  561.                  }
  563.                 
  564.     
  565.                 $response = new Response('Valid solvabilite OK!', 201);
  566.                 return $response;
  567.             }
  568.         }
  569.     
  570.         // something went wrong
  571.         $response = new Response('Invalid solvabilite OK!', 406);
  572.         return $response;
  573.     }
  574.     
  577.     public function insertSolvabiliteKo ($_format)
  578.     {
  579.         // create the serializer
  580.          $encoders = [new XmlEncoder(), new JsonEncoder()];
  581.         $normalizers = [new ObjectNormalizer()];
  582.         $serializer = new Serializer($normalizers, $encoders);
  583.         $validator = Validation::createValidator();
  584.         $request = $this->requestStack->getCurrentRequest();
  585.     
  586.         // build the Commande from a decoded array
  587.         /*solvabiliteKo = $serializer->deserialize ($request->getContent(),
  588.                 'App\Entity\BDPolymorph\SolvabiliteKo',
  589.                 $_format);*/
  590.         $res=str_ireplace(array('', '', '', '' ,'&' ,'|'), '', $request->getContent());
  591.         $solvabiliteOk = $serializer->deserialize ($res,
  592.                 'App\Entity\BDPolymorph\SolvabiliteOk',
  593.                 $_format);
  594.     
  595.         if ($solvabiliteKo)
  596.         {
  597.             $validator = $this->get('validator');
  598.             if (0 === count($validator->validate($solvabiliteKo)))
  599.             {
  600.                 // this is a valid Commande instance, persist it
  601.                 $entityManager = $this->getDoctrine()->getManager('polymorph');
  602.                 
  603. //                 $query = $entityManager->createQuery(
  604. //                         'SELECT s FROM NetBaseEntitiesDBBundle:SolvabiliteKo s WHERE s.idCommande = :ID_COMMANDE AND s.idTerminal = :ID_TERMINAL AND s.idTransaction = :ID_TRANSACTION'
  605. //                 )->setParameter('ID_COMMANDE', $solvabiliteKo->getIdCommande())
  606. //                 ->setParameter('ID_TERMINAL', $solvabiliteKo->getIdTerminal())
  607. //                 ->setParameter('ID_TRANSACTION', $solvabiliteKo->getIdTransaction());
  608. //                 $solvabiliteKoExists = $query->getResult();
  609.                  
  610. //                 if($solvabiliteKoExists == null)
  611. //                 {
  612. //                   $entityManager->persist($solvabiliteKo);
  613. //                   $entityManager->flush();
  614.                   
  615. //                   $query = $entityManager->createQuery(
  616. //                           'SELECT tcb FROM NetBaseEntitiesDBBundle:TerminalCb tcb 
  617. //                           WHERE tcb.idTerminal = :ID_TERMINAL
  618. //                           AND tcb.cbLib = :CB_LIB'
  619. //                   )->setParameter('ID_TERMINAL', $solvabiliteKo->getIdTerminal())
  620. //                   ->setParameter('CB_LIB', $solvabiliteKo->getLabell());
  621. //                   $tcb = $query->getSingleResult();
  622. //                   if ($tcb == null) {
  623. //                       $tcb = new TerminalCb();
  624. //                       $tcb->setIdTerminal($solvabiliteKo->getIdTerminal());
  625. //                       $tcb->setCbLib($solvabiliteKo->getLabell());
  626. //                       $entityManager->persist($tcb);
  627. //                       $entityManager->flush();
  628. //                   }
  629. //                 }
  630.     
  631.                 $entityManager->merge($solvabiliteKo);
  632.                 
  633.                 $tcb = new TerminalCb();
  634.                 $tcb->setIdTerminal($solvabiliteKo->getIdTerminal());
  635.                 $tcb->setCbLib($solvabiliteKo->getLabell());
  636.                 $entityManager->merge($tcb);
  637.                 $entityManager->flush();
  638.                 
  639.                 $response = new Response('Valid solvabilite KO!', 201);
  640.                 return $response;
  641.             }
  642.         }
  643.     
  644.         // something went wrong
  645.         $response = new Response('Invalid solvabilite KO!', 406);
  646.         return $response;
  647.     }
  648.     
  649.     public function insertEnregistrement ($_format)
  650.     {
  651.         // create the serializer
  652.          $encoders = [new XmlEncoder(), new JsonEncoder()];
  653.         $normalizers = [new ObjectNormalizer()];
  654.         $serializer = new Serializer($normalizers, $encoders);
  655.         $validator = Validation::createValidator();
  656.         $request = $this->requestStack->getCurrentRequest();
  657.     
  658.         // build the Commande from a decoded array
  659.         // return new Response (var_dump($request->getContent())); 
  660.         $enregistrement = $serializer->deserialize ($request->getContent(),
  661.                 'App\Entity\BDPolymorph\Enregistrement',
  662.                 $_format);
  663.         // return new Response (var_dump($enregistrement)); 
  664.         if ($enregistrement)
  665.         {
  666.             
  667.             if (0 === count($validator->validate($enregistrement)))
  668.             {
  669.                 // this is a valid Commande instance, persist it
  670.                 $entityManager = $this->getDoctrine()->getManager('polymorph');
  671.                 
  672.                  $query = $entityManager->createQuery(
  673.                          'SELECT e FROM App\Entity\BDPolymorph\Enregistrement e WHERE e.idCommande = :ID_COMMANDE AND e.idTerminal = :ID_TERMINAL AND e.idTransaction = :ID_TRANSACTION'
  674.                  )->setParameter('ID_COMMANDE', $enregistrement->getIdCommande())
  675.                  ->setParameter('ID_TERMINAL', $enregistrement->getIdTerminal())
  676.                  ->setParameter('ID_TRANSACTION', $enregistrement->getIdTransaction());
  677.                  $enregistrementExists = $query->getResult();
  678.                 
  679.                  if($enregistrementExists == null)
  680.                  {
  681.                     $con = $this->getDoctrine()->getConnection('polymorph');
  682.                     $sql = $con->prepare("INSERT INTO enregistrement (ID_COMMANDE, ID_TERMINAL, ID_TRANSACTION, LG, CR, LIBELLE, LG2)  VALUES (?, ?, ?, ?, ?, ?, ?)");
  683.                     
  684.                     $sql->bindValue(1,     $enregistrement->getIdCommande());
  685.                     $sql->bindValue(2,     $enregistrement->getIdTerminal());
  686.                     $sql->bindValue(3,  $enregistrement->getIdTransaction());
  687.                     $sql->bindValue(4,  $enregistrement->getLg());
  688.                     $sql->bindValue(5,  $enregistrement->getCr());
  689.                     $sql->bindValue(6,  $enregistrement->getLibelle());
  690.                     $sql->bindValue(7,  $enregistrement->getLg2());
  691.                     $sql->execute();
  692.                 }
  693.     
  694.                 
  695.                 
  696.                 $response = new Response('Valid enregistrement!', 201);
  697.                 return $response;
  698.             }
  699.         }
  700.     
  701.         // something went wrong
  702.         $response = new Response('Invalid enregistrement!', 406);
  703.         return $response;
  704.     }    
  705.     
  706.     public function insertEnregistrementOk ($_format)
  707.     {
  708.         // create the serializer
  709.          $encoders = [new XmlEncoder(), new JsonEncoder()];
  710.         $normalizers = [new ObjectNormalizer()];
  711.         $serializer = new Serializer($normalizers, $encoders);
  712.         $validator = Validation::createValidator();
  713.         $request = $this->requestStack->getCurrentRequest();
  714.     
  715.         // build the Commande from a decoded array
  716.         $enregistrementOk = $serializer->deserialize ($request->getContent(),
  717.                 'App\Entity\BDPolymorph\EnregistrementOk',
  718.                 $_format);
  719.     
  720.         if ($enregistrementOk)
  721.         {
  722.             
  723.             if (0 === count($validator->validate($enregistrementOk)))
  724.             {
  725.                 // this is a valid Commande instance, persist it
  726.                 $entityManager = $this->getDoctrine()->getManager('polymorph');
  727.                 
  728.                  $query = $entityManager->createQuery(
  729.                          'SELECT e FROM App\Entity\BDPolymorph\EnregistrementOk e WHERE e.idCommande = :ID_COMMANDE AND e.idTerminal = :ID_TERMINAL AND e.idTransaction = :ID_TRANSACTION'
  730.                  )->setParameter('ID_COMMANDE', $enregistrementOk->getIdCommande())
  731.                  ->setParameter('ID_TERMINAL', $enregistrementOk->getIdTerminal())
  732.                  ->setParameter('ID_TRANSACTION', $enregistrementOk->getIdTransaction());
  733.                  $enregistrementOkExists = $query->getResult();
  734.                  
  735.                  if($enregistrementOkExists == null)
  736.                  {
  737.                   
  738.                     $tmpNum = str_replace("?","",$enregistrementOk->getNumcompteprimaireunporteur());
  739.                     if (strlen($tmpNum) > 12)
  740.                         $tmpNum = "############".substr($tmpNum,12); 
  741.                     $enregistrementOk->setNumcompteprimaireunporteur($tmpNum);                   
  742.                     
  743.                     $con = $this->getDoctrine()->getConnection('polymorph');
  744.                     /*$sql = $con->prepare("INSERT INTO enregistrement_ok(ID_COMMANDE,ID_TERMINAL, ID_TRANSACTION, FORMATENTETETICKETTRANSAC, DATELOCALEDELATRANSAC, HEURELOCALEDELATRANSAC, ENSEIGNEACCEPT, TYPEDETRANSAC, NUMCONTRATOUIDACCEPT, NUMSIRET, TYPEACTIVITECOMMERCIALE, TYPEDEPAIEMENT, TYPEDESITE, NUMCOMPTEPRIMAIREUNPORTEUR, TYPEAPPLICATIFDUSYSACCEPT,DATEDEFINDEVALIDUNEAPPCARTE, CODESERVICE, CRYPTOGRAMME, CODENUMERIQUEDELADEV, NUMLOGIQUEDUSYSACCEPT, NUMDETRANSACGENPARLESYSCCEPT, NUMDEREMISE, MODEDELECTUREDUNUMEROPORTEUR, NUMAUTORISATIONUNETRANSAC, CODEFORCAGE, MONTANTDELATRANSAC, CODEALPHADELADEV, PARTIEFRACDELADEV, MONTANTUNETRANSACENCONTREVAL, CODEALPHADELADEVENCONTREVAL, PARTIEFRACDELADEVENCONTREVAL, MONTANTESTIME, FORMATPIEDDETICKETTRANSAC, AID, LABELL)
  745.                                          VALUES ([value-1],[value-2],[value-3],[value-4],[value-5],[value-6],[value-7],[value-8],[value-9],[value-10],[value-11],[value-12],[value-13],[value-14],[value-15],[value-16],[value-17],[value-18],[value-19],[value-20],[value-21],[value-22],[value-23],[value-24],[value-25],[value-26],[value-27],[value-28],[value-29],[value-30],[value-31],[value-32],[value-33],[value-34],[value-35])");*/
  746.                     $sql = $con->prepare("INSERT INTO enregistrement_ok(ID_COMMANDE,ID_TERMINAL, ID_TRANSACTION, FORMATENTETETICKETTRANSAC, DATELOCALEDELATRANSAC, HEURELOCALEDELATRANSAC, ENSEIGNEACCEPT, TYPEDETRANSAC, NUMCONTRATOUIDACCEPT, NUMSIRET, TYPEACTIVITECOMMERCIALE, TYPEDEPAIEMENT, TYPEDESITE, NUMCOMPTEPRIMAIREUNPORTEUR, TYPEAPPLICATIFDUSYSACCEPT,DATEDEFINDEVALIDUNEAPPCARTE, CODESERVICE, CRYPTOGRAMME, CODENUMERIQUEDELADEV, NUMLOGIQUEDUSYSACCEPT, NUMDETRANSACGENPARLESYSCCEPT, NUMDEREMISE, MODEDELECTUREDUNUMEROPORTEUR, NUMAUTORISATIONUNETRANSAC, CODEFORCAGE, MONTANTDELATRANSAC, CODEALPHADELADEV, PARTIEFRACDELADEV, MONTANTUNETRANSACENCONTREVAL, CODEALPHADELADEVENCONTREVAL, PARTIEFRACDELADEVENCONTREVAL, MONTANTESTIME, FORMATPIEDDETICKETTRANSAC, AID, LABELL)
  747.                                          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,?, ?, ?, ?, ?, ?, ?, ? , ?, ?, ?, ?, ?, ?,?, ?, ?, ?, ?, ?, ?)");
  748.                     
  749.                     $sql->bindValue(1,     $enregistrementOk->getIdCommande());
  750.                     $sql->bindValue(2,     $enregistrementOk->getIdTerminal());
  751.                     $sql->bindValue(3,  $enregistrementOk->getIdTransaction());
  752.                     $sql->bindValue(4, rtrim($enregistrementOk->getFormatentetetickettransac()));
  753.                     $sql->bindValue(5,  rtrim($enregistrementOk->getDatelocaledelatransac()));
  754.                     $sql->bindValue(6,  rtrim($enregistrementOk->getHeurelocaledelatransac()));
  755.                     $sql->bindValue(7, rtrim($enregistrementOk->getEnseigneaccept()));
  756.                     $sql->bindValue(8,  rtrim($enregistrementOk->getTypedetransac()));
  757.                     $sql->bindValue(9,  rtrim($enregistrementOk->getNumcontratouidaccept()));
  758.                     $sql->bindValue(10, rtrim($enregistrementOk->getNumsiret()));
  759.                     $sql->bindValue(11, rtrim($enregistrementOk->getTypeactivitecommerciale()));
  760.                     $sql->bindValue(12, rtrim($enregistrementOk->getTypedepaiement()));
  761.                     $sql->bindValue(13, rtrim($enregistrementOk->getTypedesite()));
  762.                     $sql->bindValue(14, rtrim($enregistrementOk->getNumcompteprimaireunporteur()));
  763.                     $sql->bindValue(15,  rtrim($enregistrementOk->getTypeapplicatifdusysaccept()));
  764.                     $sql->bindValue(16,  rtrim($enregistrementOk->getDatedefindevaliduneappcarte()));
  765.                     $sql->bindValue(17,  rtrim($enregistrementOk->getCodeservice()));
  766.                     $sql->bindValue(18,  rtrim($enregistrementOk->getCryptogramme()));
  767.                     $sql->bindValue(19,  rtrim($enregistrementOk->getCodenumeriquedeladev()));
  768.                     $sql->bindValue(20,  rtrim($enregistrementOk->getNumlogiquedusysaccept()));
  769.                     $sql->bindValue(21, rtrim($enregistrementOk->getNumdetransacgenparlesysccept()));
  770.                     $sql->bindValue(22, rtrim($enregistrementOk->getNumderemise()));
  771.                     $sql->bindValue(23,    rtrim($enregistrementOk->getModedelecturedunumeroporteur()));
  772.                     $sql->bindValue(24, rtrim($enregistrementOk->getNumautorisationunetransac()));
  773.                     $sql->bindValue(25, rtrim($enregistrementOk->getCodeforcage()));
  774.                     $sql->bindValue(26,  rtrim($enregistrementOk->getMontantdelatransac()));
  775.                     $sql->bindValue(27,  rtrim($enregistrementOk->getCodealphadeladev()));
  776.                     $sql->bindValue(28,  rtrim($enregistrementOk->getPartiefracdeladev()));
  777.                     $sql->bindValue(29,  rtrim($enregistrementOk->getMontantunetransacencontreval()));
  778.                     $sql->bindValue(30,  rtrim($enregistrementOk->getCodealphadeladevencontreval()));
  779.                     $sql->bindValue(31,  rtrim($enregistrementOk->getPartiefracdeladevencontreval()));
  780.                     $sql->bindValue(32, rtrim($enregistrementOk->getMontantestime()));
  781.                     $sql->bindValue(33, rtrim($enregistrementOk->getFormatpieddetickettransac()));
  782.                     $sql->bindValue(34,    rtrim($enregistrementOk->getAid()));
  783.                     $sql->bindValue(35, rtrim($enregistrementOk->getLabell()));
  784.                     $sql->execute();
  786.                  }
  787.                 
  788.                 
  789.                 $response = new Response('Valid enregistrement OK!', 201);
  790.                 return $response;
  791.             }
  792.         }
  793.     
  794.         // something went wrong
  795.         $response = new Response('Invalid enregistrement OK!', 406);
  796.         return $response;
  797.     }
  798.     
  799.     public function insertEnregistrementKo ($_format)
  800.     {
  801.         // create the serializer
  802.          $encoders = [new XmlEncoder(), new JsonEncoder()];
  803.         $normalizers = [new ObjectNormalizer()];
  804.         $serializer = new Serializer($normalizers, $encoders);
  805.         $validator = Validation::createValidator();
  806.         $request = $this->requestStack->getCurrentRequest();
  807.     
  808.         // build the Commande from a decoded array
  809.         $enregistrementKo = $serializer->deserialize ($request->getContent(),
  810.                 'App\Entity\BDPolymorph\EnregistrementOk',
  811.                 $_format);
  812.     
  813.         if ($enregistrementKo)
  814.         {
  815.             $validator = $this->get('validator');
  816.             if (0 === count($validator->validate($enregistrementKo)))
  817.             {
  818.                 // this is a valid Commande instance, persist it
  819.                 $entityManager = $this->getDoctrine()->getManager('polymorph');
  820.                 
  821. //                 $query = $entityManager->createQuery(
  822. //                         'SELECT e FROM NetBaseEntitiesDBBundle:EnregistrementKo e WHERE e.idCommande = :ID_COMMANDE AND e.idTerminal = :ID_TERMINAL AND e.idTransaction = :ID_TRANSACTION'
  823. //                 )->setParameter('ID_COMMANDE', $enregistrementKo->getIdCommande())
  824. //                 ->setParameter('ID_TERMINAL', $enregistrementKo->getIdTerminal())
  825. //                 ->setParameter('ID_TRANSACTION', $enregistrementKo->getIdTransaction());
  826. //                 $enregistrementKoExists = $query->getResult();
  827.                 
  828. //                 if($enregistrementKoExists == null)
  829. //                 {
  830. //                   $entityManager->persist($enregistrementKo);
  831. //                   $entityManager->flush();
  832.                   
  833. //                   $query = $entityManager->createQuery(
  834. //                           'SELECT tcb FROM NetBaseEntitiesDBBundle:TerminalCb tcb
  835. //                           WHERE tcb.idTerminal = :ID_TERMINAL
  836. //                           AND tcb.cbLib = :CB_LIB'
  837. //                   )->setParameter('ID_TERMINAL', $enregistrementKo->getIdTerminal())
  838. //                   ->setParameter('CB_LIB', $enregistrementKo->getLabell());
  839. //                   $tcb = $query->getSingleResult();
  840. //                   if ($tcb == null) {
  841. //                       $tcb = new TerminalCb();
  842. //                       $tcb->setIdTerminal($enregistrementKo->getIdTerminal());
  843. //                       $tcb->setCbLib($enregistrementKo->getLabell());
  844. //                       $entityManager->persist($tcb);
  845. //                       $entityManager->flush();
  846. //                   }
  847. //                 }
  848.     
  849.                 $entityManager->persist($enregistrementKo);
  850.                 
  851.                 $tcb = new TerminalCb();
  852.                 $tcb->setIdTerminal($enregistrementKo->getIdTerminal());
  853.                 $tcb->setCbLib($enregistrementKo->getLabell());
  854.                 $entityManager->merge($tcb);
  855.                 $entityManager->flush();
  856.                 
  857.                 $response = new Response('Valid enregistrement KO!', 201);
  858.                 return $response;
  859.             }
  860.         }
  861.     
  862.         // something went wrong
  863.         $response = new Response('Invalid enregistrement KO!', 406);
  864.         return $response;
  865.     }
  866.     
  867.     
  868.      
  870.     public function insertUser($_format)
  871.     {
  872.         // create the serializer
  873.         $encoders = [new XmlEncoder(), new JsonEncoder()];
  874.         $normalizers = [new ObjectNormalizer()];
  875.         $serializer = new Serializer($normalizers, $encoders);
  876.         $validator = Validation::createValidator();
  877.         $request = $this->requestStack->getCurrentRequest();
  878.     
  879.         // build the Commande from a decoded array
  880.         $user = $serializer->deserialize ($request->getContent(),
  881.                 'App\Entity\BDPolymorph\Users',
  882.                 $_format);
  883.     
  884.         if ($user)
  885.         {
  886.         
  887.             if (0 === count($validator->validate($user)))
  888.             {
  889.                 // this is a valid Commande instance, persist it
  890.                 $entityManager = $this->getDoctrine()->getManager('polymorph');
  891.                 
  892.                  $query = $entityManager->createQuery(
  893.                          'SELECT u FROM App\Entity\BDPolymorph\Users u WHERE u.idUser = :ID_USER AND u.idTerminal = :ID_TERMINAL'
  894.                  )->setParameter('ID_USER', $user->getIdUser())
  895.                  ->setParameter('ID_TERMINAL', $user->getIdTerminal());
  896.                  $userExists = $query->getResult();
  897.                  
  898.                  if($userExists == null)
  899.                  {
  900.                        if ($user->getDepartement() == '')
  901.                          $user->setDepartement('00');
  902.                        if ($user->getIdPays() == 0)
  903.                            $user->setIdPays(0);
  904.                        if ($user->getPlaque() == '')
  905.                            $user->setPlaque('');
  906.                        if ($user->getInformations() == null)
  907.                         $user->setInformations('');
  908.                     //SH 2023.03.29 suite erreur BD n'accepte pas les dates avant 1970.01.01 datetime a partir de cette dernière date
  909.                     if ((date_format($user->getDateCloture(),"Y/m/d H:i:s")=='1900/01/01 00:00:00') or (date_format($user->getDateCloture(),"Y/m/d H:i:s")=='1899/12/30 00:00:00') )    
  910.                         $user->setDateCloture('1970-01-02 00:00:00');
  912.                     
  914.                     //return new Response (var_dump($user));      
  915.                     $con = $this->getDoctrine()->getConnection('polymorph');
  916.                     $sql = $con->prepare("INSERT INTO users (`ID_USER`, `ID_TERMINAL`, `ID_ZONE`, `CODE_ACCES`, `NOM`, `DATE_DEB`, `ID_ETAT`, `ID_TYPE_USER`, `ID_PRESENCE_USER`, `DATE_CLOTURE`, `DEPARTEMENT`, `PLAQUE`, `ID_PAYS`, `INFORMATIONS`)   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? , ? , ? , ?)");
  917.                     $sql->bindValue(1, $user->getIdUser());
  918.                     $sql->bindValue(2,     $user->getIdTerminal());
  919.                     $sql->bindValue(3,     $user->getIdZone());
  920.                     $sql->bindValue(4,  $user->getCodeAcces());
  921.                     $sql->bindValue(5, $user->getNom());
  922.                     $sql->bindValue(6, date_format($user->getDateDeb(),"Y/m/d H:i:s")) ;
  923.                     $sql->bindValue(7,  $user->getIdEtat());
  924.                     $sql->bindValue(8, $user->getIdTypeUser());
  925.                     $sql->bindValue(9, $user->getIdPresenceUser());
  926.                     $sql->bindValue(10,  date_format($user->getDateCloture(),"Y/m/d H:i:s"));
  927.                     $sql->bindValue(11, $user->getDepartement());
  928.                     $sql->bindValue(12, $user->getPlaque());
  929.                     $sql->bindValue(13,  $user->getIdPays());
  930.                     $sql->bindValue(14, $user->getInformations());
  931.                     $sql->execute();
  932.                  
  933.                  }
  935.                 
  936.                 $response = new Response('Valid user!', 201);
  937.                 return $response;
  938.             }
  939.         }
  940.     
  941.         // something went wrong
  942.         $response = new Response('Invalid user!', 406);
  943.         return $response;
  944.     }
  948.     public function insertEtat($_format)
  949.     {    
  951.         $request = $this->requestStack->getCurrentRequest();    
  952.         $xml = $request->getContent();
  953.         //        $this->ecrire_log($xml);
  954.         //return new Response (var_dump($xml));  
  956.         $xml = simplexml_load_string($xml);
  957.         $json = json_encode($xml);
  958.         $doc = json_decode($json,TRUE);
  959.         //return new response (var_dump($doc['Erreurs']), 201);
  960.         //return new Response (var_dump($doc['Erreurs']));  
  963.         $in = array();
  964.         $erreurs = $doc['Erreurs'];
  965.         if ( is_array($erreurs))
  966.             foreach ($erreurs as $erreur) {
  967.                 array_push($in, $erreur);
  968.                }
  969.         else array_push($in, $erreurs);
  970.         
  971.         if (isset($in)) {
  972.             //$in = $in . ')';
  973.             $idTerminal = $doc['idTerminal'];
  974.     
  975.             $this->majAdresseIp($idTerminal);        
  976.             //$this->ecrire_log('idTerminal : '.$idTerminal.' / IP : '.$_SERVER["REMOTE_ADDR"]);
  977.             
  978.             //return new response ($in . ' ' . $idTerminal, 201);
  979.             $entityManager = $this->getDoctrine()->getManager();
  980.             $repository = $entityManager->getRepository('App\Entity\BDDG\TerminalErreur');
  981.             $erreurs = $repository->findBy(array('idTerminal' => $idTerminal));
  982.             $dateRemontee = new \DateTime('now');
  983.             //return new Response (var_dump($erreurs));  
  984.             // mise à jour des erreur en base
  985.             foreach ($erreurs as $erreur) {
  986.                 if (in_array($erreur->getIdErreur(), $in)) {
  987.                     // l'erreur en base existe, on met à jour
  988.                     $erreur->setDateRemontee($dateRemontee);
  989.                 }
  990.                 else {
  991.                     // l'erreur en base n'existe plus, on l'efface 
  992.                     $entityManager->remove($erreur);
  993.                 }
  994.                 
  995.             }
  996.             $entityManager->flush();
  997.             
  998.             // Ajout des erreurs qui n'existaient pas en base
  999.             foreach ($in as $idErreur) {
  1000.                 $erreur = $repository->findBy(array('idTerminal' => $idTerminal, 'idErreur' => $idErreur));
  1001.                 if (!$erreur) {
  1002.                     $erreur = new TerminalErreur();
  1003.                     $erreur->setIdTerminal($idTerminal);
  1004.                     $erreur->setIdErreur($idErreur);
  1005.                     $erreur->setDateRemontee($dateRemontee);
  1006.                     $erreur->setVisibilite(1);
  1007.                     $entityManager->persist($erreur);
  1008.                 }
  1010.                 //SH 2024.01.18 gestion terminal composant 
  1011.                 if(!(($idErreur>19) && ($idErreur<50) ))
  1012.                 {
  1013.                     $tpe=array(1,2,3,4,5,6,50);
  1014.                     $imp=array(7,8,9,10,51);
  1015.                     $voie=array(11,12,13,14,52);
  1016.                     $digi=array(15,16,17,18,53);
  1017.                     $idComposant=0;
  1018.                     if( in_array($idErreur,$tpe)) $idComposant=1;
  1019.                     else if( in_array($idErreur,$imp)) $idComposant=2;
  1020.                     else if( in_array($idErreur,$voie)) $idComposant=3;
  1021.                     else if( in_array($idErreur,$digi)) $idComposant=4;
  1022.                     
  1023.                     $repComposant=$entityManager->getRepository('App\Entity\BDDG\TerminalComposant');
  1024.                     $etatErreur=$repComposant->findOneBy(array('idTerminal' => $idTerminal, 'idComposant' => $idComposant));
  1025.                     //return new Response (var_dump($idErreur)); 
  1026.                     if (!$etatErreur) {
  1027.                         $etatErreur = new TerminalComposant();
  1028.                         $etatErreur->setIdTerminal($idTerminal);
  1029.                         $etatErreur->setIdComposant($idComposant);
  1030.                     }
  1031.                     //$dateRemontee = new \DateTime('now');
  1032.                     $etatErreur->setDateRemontee($dateRemontee);
  1033.                     $etatErreur->setEtatErreur($idErreur);
  1034.                     //return new Response (var_dump($etatErreur));
  1035.                     $entityManager->persist($etatErreur);
  1036.                     $entityManager->flush();
  1037.                 }
  1038.                 
  1039.                 //fin SH 
  1040.             }
  1041.             
  1042.             $entityManager->flush();
  1043.             
  1044.             
  1045.             
  1046.             //$con = $this->getDoctrine()->getConnection();
  1047.             //$sql = $con->prepare("Delete from Terminal_Erreur where id_terminal = : idTerminal and id_Erreur not in " . $in);
  1048.             //$sql->bindValue('idTerminal', $idTerminal);
  1049.             //$sql->execute();
  1050.         }
  1051.         else return new response ('KO', 201);
  1052.         
  1053.         return new response ('OK', 201);
  1054.     }
  1057.   
  1058.     public function majAdresseIp($idTerminal)
  1059.     {
  1060.         // ML
  1061.         try {
  1062.             $request = $this->requestStack->getCurrentRequest();
  1063.             $newIp = $request->getClientIp();
  1064.             $entityManager = $this->getDoctrine()->getManager();
  1065.     
  1066.             $repository = $this->getDoctrine()->getRepository('App\Entity\BDDG\Terminal');
  1067.             $terminal = $repository->findOneBy(array('idTerminal' => $idTerminal));
  1068.             //return new Response (var_dump($terminal));  
  1069.             if ($terminal != null) {
  1070.                 $oldIp = $terminal->getIp();
  1071.                 $majIp = false;
  1072.            
  1073.                 if ($oldIp == null)
  1074.                     $majIp = true;
  1075.                 elseif ($oldIp != $newIp && preg_match('#^([0-9]{1,3}\.){3}[0-9]{1,3}$#', $oldIp))
  1076.                     $majIp = true;                
  1077.            
  1078.                 if ($majIp) {
  1079.                     $terminal->setIp($newIp);
  1080.                     $entityManager->persist($terminal);
  1081.                     $entityManager->flush();
  1082.                 }
  1083.                 
  1084.             }
  1085.         }
  1086.         catch(\ErrorException $e) {
  1087.         }
  1088.         // end ML
  1089.     }
  1091.     public function insertTelecollecte ($_format)
  1092.     {
  1093.         // create the serializer
  1094.          $encoders = [new XmlEncoder(), new JsonEncoder()];
  1095.         $normalizers = [new ObjectNormalizer()];
  1096.         $serializer = new Serializer($normalizers, $encoders);
  1097.         $validator = Validation::createValidator();
  1098.         $request = $this->requestStack->getCurrentRequest();
  1099.     
  1100.         // build the Commande from a decoded array
  1101.         $telecollecte = $serializer->deserialize ($request->getContent(),
  1102.                 'App\Entity\BDPolymorph\Telecollecte',
  1103.                 $_format);
  1104.         //return new Response (var_dump($telecollecte));  
  1105.         if ($telecollecte)
  1106.         {
  1107.             
  1108.             if (0 === count($validator->validate($telecollecte)))
  1109.             {
  1110.                 // this is a valid Telecollecte instance, persist it
  1111.                 $entityManager = $this->getDoctrine()->getManager('polymorph');
  1112. //                 $query = $entityManager->createQuery(
  1113. //                         'SELECT t FROM NetBaseEntitiesDBBundle:Telecollecte t WHERE t.idTerminal = :ID_TERMINAL AND t.datelocaleuneapplication = :DATELOCALEUNEAPPLICATION AND t.heurelocaleuneapplication = :HEURELOCALEUNEAPPLICATION'
  1114. //                 )->setParameter('ID_TERMINAL', $telecollecte->getIdTerminal())
  1115. //                 ->setParameter('DATELOCALEUNEAPPLICATION', $telecollecte->getDatelocaleuneapplication())
  1116. //                 ->setParameter('HEURELOCALEUNEAPPLICATION', $telecollecte->getHeurelocaleuneapplication());
  1117. //                 $telecollecteExists = $query->getResult();
  1118.     
  1119. //                 if($telecollecteExists == null) {
  1120. //                     //INSERT
  1121. //                     $entityManager->persist($telecollecte);
  1122. //                     $entityManager->flush();
  1123. //                 }
  1124. //                 else {
  1125. //                     //UPDATE
  1126. //                     $telecollecteExists[0]->setLg($telecollecte->getLg());
  1127. //                     $telecollecteExists[0]->setCr($telecollecte->getCr());
  1128. //                     $telecollecteExists[0]->setCodesousfct($telecollecte->getCodesousfct());
  1129. //                     $telecollecteExists[0]->setNbapp($telecollecte->getNbapp());
  1130. //                     $telecollecteExists[0]->setLibelle($telecollecte->getLibelle());
  1131. //                     $telecollecteExists[0]->setCr2($telecollecte->getCr2());
  1132. //                     $telecollecteExists[0]->setLg2($telecollecte->getLg2());
  1133. //                     $telecollecteExists[0]->setFormatenteteticketcompterendu($telecollecte->getFormatenteteticketcompterendu());
  1134. //                     $telecollecteExists[0]->setNcontratidentifiantaccepteur($telecollecte->getNcontratidentifiantaccepteur());
  1135. //                     $telecollecteExists[0]->setNsiret($telecollecte->getNsiret());
  1136. //                     $telecollecteExists[0]->setTypeactivitecommerciale($telecollecte->getTypeactivitecommerciale());
  1137. //                     $telecollecteExists[0]->setTypepaiement($telecollecte->getTypepaiement());
  1138. //                     $telecollecteExists[0]->setTypedesite($telecollecte->getTypedesite());
  1139. //                     $telecollecteExists[0]->setNlogiquesystemeacceptation($telecollecte->getNlogiquesystemeacceptation());
  1140. //                     $telecollecteExists[0]->setLibellereponse($telecollecte->getLibellereponse());
  1141. //                     $telecollecteExists[0]->setFormatpiedticketcompterendu($telecollecte->getFormatpiedticketcompterendu());
  1142. //                     $telecollecteExists[0]->setNbrem($telecollecte->getNbrem());
  1143. //                     $telecollecteExists[0]->setIsEnvoyerNb($telecollecte->getIsEnvoyerNb());
  1144.                     
  1145. //                     $entityManager->persist($telecollecteExists [0]);
  1146. //                     $entityManager->flush();
  1147. //                 }
  1148.     
  1149.                 $entityManager->merge($telecollecte);
  1150.                 $entityManager->flush();
  1151.                 
  1152.                 $response = new Response('Valid telecollecte!', 201);
  1153.                 return $response;
  1154.             }
  1155.         }
  1156.     
  1157.         // something went wrong
  1158.         $response = new Response('Invalid telecollecte!', 406);
  1159.         return $response;
  1160.     }
  1161.     
  1162.     
  1164.     
  1165.    
  1166.   
  1167.     
  1168.     public function insertInfoRemise ($_format)
  1169.     {
  1170.         // create the serializer
  1171.          $encoders = [new XmlEncoder(), new JsonEncoder()];
  1172.         $normalizers = [new ObjectNormalizer()];
  1173.         $serializer = new Serializer($normalizers, $encoders);
  1174.         $validator = Validation::createValidator();
  1175.         $request = $this->requestStack->getCurrentRequest();
  1176.     
  1177.         // build the Commande from a decoded array
  1178.         $infoRemise = $serializer->deserialize ($request->getContent(),
  1179.                 'App\Entity\BDPolymorph\InfoRemise',
  1180.                 $_format);
  1181.        // return new Response (var_dump($infoRemise));  
  1182.         if ($infoRemise)
  1183.         {
  1184.             // ML 2017.06.12 : test traça ip 62.193.56.46
  1185.             /*
  1186.             try 
  1187.             {
  1188.                 $path = "../../testML.txt";
  1189.                 $myfile = fopen($path, "a");            
  1190.                 fwrite($myfile, $infoRemise->getIdTerminal()."\r\n");
  1191.                 fclose($myfile);    
  1192.             
  1193.                 //$this->majAdresseIp($infoRemise->getIdTerminal());    
  1194.             }
  1195.             catch (\Exception $e)
  1196.             {
  1197.             }
  1198.             */
  1199.         
  1200.             $idTerminal=$infoRemise->getIdTerminal();
  1201.             $idRemise=$infoRemise->getIdRemise();
  1202.             $date=$infoRemise->getDatelocaleuneapplication();
  1203.             $heure=$infoRemise->getHeurelocaleuneapplication();
  1204.             
  1205.             if (0 === count($validator->validate($infoRemise)))
  1206.             {
  1207.                 // this is a valid Telecollecte instance, persist it
  1208.                 $entityManager = $this->getDoctrine()->getManager('polymorph');
  1209.             /*    $infoData = new InfoRemise(); 
  1210.                 $infoData->setNseqacquereuruneremisetransac($infoRemise->getNseqacquereuruneremisetransac());
  1211.                 $infoData->setNremise($infoRemise->getNremise());
  1212.                 $infoData->setNombretransactionsdebitremise($infoRemise->getNombretransactionsdebitremise());
  1213.                 $infoData->setCodealphabetiquemonnaiedevise($infoRemise->getCodealphabetiquemonnaiedevise());
  1214.                 $infoData->setMontanttottransacdebitremise($infoRemise->getMontanttottransacdebitremise());
  1215.                 $infoData->setPartiefracmonnaiedevise($infoRemise->getPartiefracmonnaiedevise());
  1216.                 $infoData->setNombretransactionsnonabouties($infoRemise->getNombretransactionsnonabouties()); 
  1217.                 $entityManager->flush();
  1218.                 $infoData->setNremise($idTerminal);
  1219.                 $infoData->setNremise($idRemise);
  1220.                 $infoData->setNremise($date);
  1221.                 $infoData->setNremise($heure);
  1222.                 
  1223.                 return new Response (var_dump($infoData));
  1224.                 $entityManager->persist($infoRemise);
  1225.                 $entityManager->flush();*/
  1226.                  $query = $entityManager->createQuery(
  1227.                          'SELECT i FROM  App\Entity\BDPolymorph\InfoRemise i WHERE i.idTerminal = :ID_TERMINAL AND i.idRemise = :ID_REMISE AND i.datelocaleuneapplication = :DATELOCALEUNEAPPLICATION AND i.heurelocaleuneapplication = :HEURELOCALEUNEAPPLICATION'
  1228.                  )->setParameter('ID_TERMINAL', $infoRemise->getIdTerminal())
  1229.                  ->setParameter('ID_REMISE', $infoRemise->getIdRemise())
  1230.                  ->setParameter('DATELOCALEUNEAPPLICATION', $infoRemise->getDatelocaleuneapplication())
  1231.                  ->setParameter('HEURELOCALEUNEAPPLICATION', $infoRemise->getHeurelocaleuneapplication());
  1232.                  $infoRemiseExists = $query->getResult();
  1233.     
  1234.                  if($infoRemiseExists == null) {
  1235.                      //INSERT
  1236.                      /*$entityManager->persist($infoRemise);
  1237.                      $entityManager->flush();*/
  1238.                      $con = $this->getDoctrine()->getConnection('polymorph');
  1239.                      $sql = $con->prepare("INSERT INTO info_remise (ID_TERMINAL, DATE_HEURE, ID_REMISE, DATELOCALEUNEAPPLICATION, HEURELOCALEUNEAPPLICATION, NSEQACQUEREURUNEREMISETRANSAC, NREMISE, NOMBRETRANSACTIONSDEBITREMISE, CODEALPHABETIQUEMONNAIEDEVISE, MONTANTTOTTRANSACDEBITREMISE, PARTIEFRACMONNAIEDEVISE, NOMBRETRANSACTIONSNONABOUTIES)   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? , ? )");
  1240.                      $sql->bindValue(1, $infoRemise->getIdTerminal());
  1241.                      $sql->bindValue(2, $infoRemise->getDateHeure());
  1242.                      $sql->bindValue(3, $infoRemise->getIdRemise());
  1243.                      $sql->bindValue(4, $infoRemise->getDatelocaleuneapplication());
  1244.                      $sql->bindValue(5, $infoRemise->getHeurelocaleuneapplication());
  1245.                      $sql->bindValue(6, $infoRemise->getNseqacquereuruneremisetransac()) ;
  1246.                      $sql->bindValue(7, $infoRemise->getNremise());
  1247.                      $sql->bindValue(8, $infoRemise->getNombretransactionsdebitremise());
  1248.                      $sql->bindValue(9, $infoRemise->getCodealphabetiquemonnaiedevise());
  1249.                      $sql->bindValue(10,  $infoRemise->getMontanttottransacdebitremise());
  1250.                      $sql->bindValue(11, $infoRemise->getPartiefracmonnaiedevise());
  1251.                      $sql->bindValue(12, $infoRemise->getNombretransactionsnonabouties());
  1252.                      $sql->execute();
  1253.                  }
  1254. //                 else {
  1255. //                     //UPDATE
  1256.                     
  1257. //                     $infoRemiseExists[0]->setNseqacquereuruneremisetransac($infoRemise->getNseqacquereuruneremisetransac());
  1258. //                     $infoRemiseExists[0]->setNremise($infoRemise->getNremise());
  1259. //                     $infoRemiseExists[0]->setNombretransactionsdebitremise($infoRemise->getNombretransactionsdebitremise());
  1260. //                     $infoRemiseExists[0]->setCodealphabetiquemonnaiedevise($infoRemise->getCodealphabetiquemonnaiedevise());
  1261. //                     $infoRemiseExists[0]->setMontanttottransacdebitremise($infoRemise->getMontanttottransacdebitremise());
  1262. //                     $infoRemiseExists[0]->setPartiefracmonnaiedevise($infoRemise->getPartiefracmonnaiedevise());
  1263. //                     $infoRemiseExists[0]->setNombretransactionsnonabouties($infoRemise->getNombretransactionsnonabouties());                    
  1264.                     
  1265. //                     $entityManager->persist($infoRemiseExists [0]);
  1266. //                     $entityManager->flush();
  1267. //                 }
  1268.     
  1269.                 //$entityManager->persist($infoRemise);
  1270.                 //$entityManager->flush();
  1271.                 
  1272.                 $response = new Response('Valid info remise!', 201);
  1273.                 return $response;
  1274.             }
  1275.         }
  1276.     
  1277.         // something went wrong
  1278.         $response = new Response('Invalid info remise!', 406);
  1279.         return $response;
  1280.     }
  1281.     
  1282.     public function insertTarifs ($_format)
  1283.     {
  1284.         // create the serializer
  1285.          $encoders = [new XmlEncoder(), new JsonEncoder()];
  1286.         $normalizers = [new ObjectNormalizer()];
  1287.         $serializer = new Serializer($normalizers, $encoders);
  1288.         $validator = Validation::createValidator();
  1289.         $request = $this->requestStack->getCurrentRequest();
  1290.     
  1291.         // build the Commande from a decoded array
  1292.         $tarifs = $serializer->deserialize ($request->getContent(),
  1293.                 'App\Entity\BDDG\Tarifs',
  1294.                 $_format);
  1295.        
  1296.         //return new Response (var_dump($tarifs));
  1298.         if ($tarifs)
  1299.         {
  1300.             //$validator = $this->get('validator');
  1301.             if (0 === count($validator->validate($tarifs)))
  1302.             {
  1303.                 // this is a valid Telecollecte instance, persist it
  1304.                 if ($tarifs->getService()==null)
  1305.                 {
  1306.                     $repository = $this->getDoctrine()->getRepository('App\Entity\BDDG\TerminalService');
  1307.                     $service = $repository->findOneBy(array('idTerminal' => $tarifs->getIdTerminal() , 'idService' => $tarifs->getIdService()));
  1308.                     //return new Response (var_dump($service));
  1309.                     $tarifs->setService($service);
  1310.                     //return new Response (var_dump($tarifs));
  1311.                 }
  1312.                 $entityManager = $this->getDoctrine()->getManager();
  1313.     
  1314.                 $entityManager->merge($tarifs);
  1315.                 $entityManager->flush();
  1316.                 
  1317.                 $response = new Response('Valid tarifs!', 201);
  1318.                 return $response;
  1319.             }
  1320.         }
  1321.     
  1322.         // something went wrong
  1323.         $response = new Response('Invalid tarifs!', 406);
  1324.         return $response;
  1325.     }
  1326.     
  1327.     public function insertTarif ($_format)
  1328.     {
  1329.         // create the serializer
  1330.          $encoders = [new XmlEncoder(), new JsonEncoder()];
  1331.         $normalizers = [new ObjectNormalizer()];
  1332.         $serializer = new Serializer($normalizers, $encoders);
  1333.         $validator = Validation::createValidator();
  1334.         $request = $this->requestStack->getCurrentRequest();
  1335.     
  1336.         // build the Commande from a decoded array
  1337.         $tarif = $serializer->deserialize ($request->getContent(),
  1338.                 'App\Entity\BDDG\Tarif',
  1339.                 $_format);
  1340.     
  1341.         //return new Response (var_dump($tarif)); 
  1343.         if ($tarif)
  1344.         {
  1345.             //$validator = $this->get('validator');
  1346.             if (0 === count($validator->validate($tarif)))
  1347.             {
  1348.                 // this is a valid Telecollecte instance, persist it
  1349.                 /* 
  1350.                 if ($tarif->getTarifs()==null)
  1351.                 {
  1352.                     $repository = $this->getDoctrine()->getRepository('App\Entity\BDDG\Tarifs');
  1353.                     //return new Response (var_dump($repository));
  1354.                     $tarifs = $repository->findBy(array('idTerminal' => $tarif->getIdTerminal() , 'idZone'=> $tarif->getIdZone()  , 'idService' => $tarif->getIdService(), 'idTarifs' => $tarif->getIdTarifs() ));
  1355.                     return new Response (var_dump($tarifs));
  1356.                     //$tarif->setTarifs($tarifs);
  1357.                     //return new Response (var_dump($tarif));
  1358.                 }
  1359.                 $entityManager = $this->getDoctrine()->getManager();
  1360.                 $entityManager->merge($tarif);
  1361.                 $entityManager->flush();    */
  1362.                 $entityManager = $this->getDoctrine()->getManager();
  1363.                 $query = $entityManager->createQuery(
  1364.                                             'SELECT t FROM App\Entity\BDDG\Tarif t WHERE t.idTarif = :ID_TARIF AND t.idTarifs = :ID_TARIFS AND t.idTerminal = :ID_TERMINAL AND t.idZone = :ID_ZONE AND t.idService = :ID_SERVICE'
  1365.                                     )->setParameter('ID_TARIF', $tarif->getIdTarif())
  1366.                                     ->setParameter('ID_TARIFS', $tarif->getIdTarifs())
  1367.                                     ->setParameter('ID_TERMINAL', $tarif->getIdTerminal())
  1368.                                      ->setParameter('ID_ZONE', $tarif->getIdZone())
  1369.                                      ->setParameter('ID_SERVICE', $tarif->getIdService());
  1370.                                     $tarifExists = $query->getResult();
  1371.                         
  1372.                             if($tarifExists == null) {
  1373.                                 $con = $this->getDoctrine()->getConnection();
  1374.                                 $sql = $con->prepare("insert into tarif (ID_TARIF, ID_TARIFS, ID_TERMINAL, ID_ZONE, ID_SERVICE ,DEVISE ) values (?, ?, ?, ? , ?, ?)");
  1375.                                 $sql->bindValue(1, $tarif->getIdTarif());
  1376.                                 $sql->bindValue(2, $tarif->getIdTarifs());
  1377.                                 $sql->bindValue(3, $tarif->getIdTerminal());
  1378.                                 $sql->bindValue(4, $tarif->getIdZone());
  1379.                                 $sql->bindValue(5, $tarif->getIdService());
  1380.                                 $sql->bindValue(6, $tarif->getDevise());
  1381.                                 $sql->execute();
  1382.                             }
  1383.                              else {
  1384.                                         //UPDATE
  1385.                     
  1386.                                     $tarifExists[0]->setDevise($tarif->getDevise());
  1387.                                     $entityManager->persist($tarifExists [0]);
  1388.                                      $entityManager->flush();
  1389.                             }
  1390.                 $response = new Response('Valid tarif!', 201);
  1391.                 return $response;
  1392.             }
  1393.         }
  1394.     
  1395.         // something went wrong
  1396.         $response = new Response('Invalid tarif!', 406);
  1397.         return $response;
  1398.     }
  1399.     
  1400.     public function insertPeriode ($_format)
  1401.     {
  1402.         // create the serializer
  1403.          $encoders = [new XmlEncoder(), new JsonEncoder()];
  1404.         $normalizers = [new ObjectNormalizer()];
  1405.         $serializer = new Serializer($normalizers, $encoders);
  1406.         $validator = Validation::createValidator();
  1407.         $request = $this->requestStack->getCurrentRequest();
  1408.     
  1409.         // build the Commande from a decoded array
  1410.         $periode = $serializer->deserialize ($request->getContent(),
  1411.                 'App\Entity\BDDG\Periode',
  1412.                 $_format);
  1413.         
  1414.         //return new Response (var_dump($periode));
  1416.         if ($periode)
  1417.         {
  1418.             //$validator = $this->get('validator');
  1419.             if (0 === count($validator->validate($periode)))
  1420.             {
  1421.                 // this is a valid Telecollecte instance, persist it
  1422.                 /*$entityManager = $this->getDoctrine()->getManager();
  1424.                 $entityManager->merge($periode);
  1425.                 $entityManager->flush();*/
  1426.                 $entityManager = $this->getDoctrine()->getManager();
  1427.                 $query = $entityManager->createQuery(
  1428.                          'SELECT p FROM App\Entity\BDDG\Periode p WHERE p.idPeriode = :ID_PERIODE AND p.idTarif = :ID_TARIF AND p.idTarifs = :ID_TARIFS AND p.idTerminal = :ID_TERMINAL AND p.idZone = :ID_ZONE AND p.idService = :ID_SERVICE'
  1429.                  )->setParameter('ID_PERIODE', $periode->getIdPeriode())
  1430.                  ->setParameter('ID_TARIF', $periode->getIdTarif())
  1431.                  ->setParameter('ID_TARIFS', $periode->getIdTarifs())
  1432.                  ->setParameter('ID_TERMINAL', $periode->getIdTerminal())
  1433.                  ->setParameter('ID_ZONE', $periode->getIdZone())
  1434.                  ->setParameter('ID_SERVICE', $periode->getIdService());
  1435.                  $periodeExists = $query->getResult();
  1436.     
  1437.                  if($periodeExists == null) {
  1438. //                     //INSERT
  1439.                  //    $entityManager->persist($periode);
  1440.                     //$entityManager->flush();
  1441.                     $con = $this->getDoctrine()->getConnection();
  1442.                     $sql = $con->prepare("insert into periode (ID_PERIODE , ID_TARIF, ID_TARIFS, ID_TERMINAL, ID_ZONE, ID_SERVICE ,DATE_DEB , DATE_FIN , NOM , QTE , UNITE , QTE_UNITAIRE ,  PRIX ) values (?, ?, ?, ? , ?, ? , ?, ?, ?, ? , ?, ? , ?)");
  1443.                     $sql->bindValue(1, $periode->getIdPeriode());
  1444.                     $sql->bindValue(2, $periode->getIdTarif());
  1445.                     $sql->bindValue(3, $periode->getIdTarifs());
  1446.                     $sql->bindValue(4, $periode->getIdTerminal());
  1447.                     $sql->bindValue(5, $periode->getIdZone());
  1448.                     $sql->bindValue(6, $periode->getIdService());
  1449.                     $sql->bindValue(7, $periode->getDateDeb());
  1450.                     $sql->bindValue(8, $periode->getDateFin());
  1451.                     $sql->bindValue(9, $periode->getNom());
  1452.                     $sql->bindValue(10, $periode->getQte());
  1453.                     $sql->bindValue(11, $periode->getUnite());
  1454.                     $sql->bindValue(12, $periode->getQteUnitaire());
  1455.                     $sql->bindValue(13, $periode->getPrix());
  1456.                     $sql->execute();
  1457.                     /*$Addperiode = new Periode();
  1458.                     $Addperiode->setIdPeriode($periode->getIdPeriode());
  1459.                     $Addperiode->setIdTarif($periode->getIdTarif());
  1460.                     $Addperiode->setIdTarifs($periode->getIdTarifs());
  1461.                     $Addperiode->setIdTerminal($periode->getIdTerminal());
  1462.                     $Addperiode->setIdZone($periode->getIdZone());
  1463.                     $Addperiode->setIdService($periode->getIdService());
  1464.                     $Addperiode->setDateDeb($periode->getDateDeb());
  1465.                      $Addperiode->setDateFin($periode->getDateFin());
  1466.                      $Addperiode->setNom($periode->getNom());
  1467.                      $Addperiode->setQte($periode->getQte());
  1468.                      $Addperiode->setUnite($periode->getUnite());
  1469.                      $Addperiode->setQteUnitaire($periode->getQteUnitaire());
  1470.                      $Addperiode->setPrix($periode->getPrix());                  
  1471.                     $entityManager->persist($Addperiode);
  1472.                     $entityManager->flush();*/
  1473.                     //return new Response (var_dump($Addperiode ));
  1475.                  }
  1476.                  else {
  1477.                      //UPDATE
  1479.                      $periodeExists[0]->setDateDeb($periode->getDateDeb());
  1480.                      $periodeExists[0]->setDateFin($periode->getDateFin());
  1481.                      $periodeExists[0]->setNom($periode->getNom());
  1482.                      $periodeExists[0]->setQte($periode->getQte());
  1483.                      $periodeExists[0]->setUnite($periode->getUnite());
  1484.                      $periodeExists[0]->setQteUnitaire($periode->getQteUnitaire());
  1485.                      $periodeExists[0]->setPrix($periode->getPrix());                  
  1486.                     $entityManager->persist($periodeExists[0]);
  1487.                     $entityManager->flush();
  1488.                  }
  1489.                 
  1490.                 $response = new Response('Valid periode!', 201);
  1491.                 return $response;
  1492.             }
  1493.         }
  1494.     
  1495.         // something went wrong
  1496.         $response = new Response('Invalid periode!', 406);
  1497.         return $response;
  1498.     }
  1500.     //fin SH 
  1502.     //SH 2023.12.06 gestion et activation des logs pour conques
  1503.      public function insertLog($_format)
  1504.     {
  1505.         
  1506.         $encoders = [new XmlEncoder(), new JsonEncoder()];
  1507.         $normalizers = [new ObjectNormalizer()];
  1508.         $serializer = new Serializer($normalizers, $encoders);
  1509.         $validator = Validation::createValidator();
  1510.         $request = $this->requestStack->getCurrentRequest();
  1511.             
  1512.                 // build the Commande from a decoded array
  1513.         $log = $serializer->deserialize ($request->getContent(),
  1514.                     'App\Entity\BDPolymorph\Log',
  1515.                 $_format);
  1516.     
  1517.         if ($log)
  1518.         {
  1519.             
  1520.             if (0 === count($validator->validate($log)))
  1521.             {
  1522.                 // this is a valid Telecollecte instance, persist it
  1523.                 //$entityManager = $this->getDoctrine()->getEntityManager();
  1524.                 $entityManager = $this->getDoctrine()->getManager('polymorph');
  1525. //                 $query = $entityManager->createQuery(
  1526. //                         'SELECT l FROM NetBaseEntitiesDBBundle:Log l WHERE l.idLog = :ID_LOG AND l.idTerminal = :ID_TERMINAL'
  1527. //                 )->setParameter('ID_LOG', $log->getIdLog())
  1528. //                 ->setParameter('ID_TERMINAL', $log->getIdTerminal());
  1529. //                 $logExists = $query->getResult();
  1530.     
  1531. //                 if($logExists == null) {
  1532. //                     //INSERT
  1533. //                     $entityManager->persist($log);
  1534. //                     $entityManager->flush();
  1535. //                 }
  1537.                 // ML 2017.03.17 : recherche et masquage du code urbaflux 0518
  1538.                 $log->setLibelleLog(str_replace("0518","----",$log->getLibelleLog()));
  1539.                 // end ML
  1540.     
  1541.                 $entityManager->merge($log);
  1542.                 $entityManager->flush();
  1543.                 
  1544.                 $response = new Response('Valid log!', 201);
  1545.                 return $response;
  1546.             }
  1547.         }
  1548.     
  1549.         // something went wrong
  1550.         $response = new Response('Invalid log!', 406);
  1551.         return $response;
  1552.     }
  1553.     //fin SH
  1554.    //SH 2023.03.29 
  1555.        public function updatePeriode ($_format)
  1556.     {
  1557.         $request = $this->requestStack->getCurrentRequest();
  1558.         $jsonContent = json_decode($request->getContent(),true);
  1559.         //return new Response (var_dump($jsonContent['idTerminal']));
  1560.         $periode = null ;
  1561.         $repository = $this->getDoctrine()->getRepository('App\Entity\BDDG\Periode');
  1562.         $periode = $repository->findOneBy(array('idTerminal' => $jsonContent['idTerminal'] ,
  1563.                                          'idZone' => $jsonContent['idZone'] , 
  1564.                                          'idService' => $jsonContent['idService'] ,
  1565.                                          'idTarif' => $jsonContent['idTarif'] ,
  1566.                                          'idPeriode' => $jsonContent['idPeriode'] 
  1567.                                         ));
  1570.         if($periode != null)     
  1571.         {
  1572.             $entityManager = $this->getDoctrine()->getManager();                                
  1573.             $periode->setPrix($jsonContent['prix']); 
  1574.             //return new Response (var_dump($periode));
  1575.             $entityManager->persist($periode);
  1576.             $entityManager->flush();
  1577.             $response = new Response('update OK!', 201);
  1579.         }    
  1580.         else $response = new Response('Update KO!', 406);
  1581.         
  1582.         return $response;
  1583.     }
  1584.    //fin SH 
  1585.     
  1586.     //SH 2021.01.22 envoi du info terminal vers serveur statos
  1587.     private function XmlHttp($url,$xmldata)
  1588.     {
  1589.  
  1590.          
  1591.         $ch = curl_init();
  1592.         curl_setopt($ch, CURLOPT_URL, $url);
  1593.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
  1594.         curl_setopt($ch, CURLOPT_TIMEOUT, 60);
  1595.         curl_setopt($ch, CURLOPT_POST, true);
  1596.         curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: text/xml'));
  1597.         curl_setopt($ch, CURLOPT_POSTFIELDS, $xmldata);
  1598.         curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
  1599.         curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
  1600.         curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
  1601.         $result = curl_exec($ch); 
  1602.         curl_close($ch);
  1603.         return $result; 
  1604.     }
  1605.     //fin SH 
  1609.     public function insertEtatComposant ($_format)
  1610.     {
  1611.         $request = $this->requestStack->getCurrentRequest();
  1612.         $jsonContent = json_decode($request->getContent(),true);
  1613.         //return new Response (var_dump($jsonContent));
  1614.         $con= $this->getDoctrine()->getConnection();
  1615.         /*$sql = $con->prepare("SELECT tc.ID_TERMINAL, tc.DATE_REMONTEE , te.LIBELLE_ERREUR , te.COLOR
  1616.         FROM `terminal_composant` tc , type_erreur te , terminal_client c
  1617.         where te.ID_ERREUR=tc.etat_erreur and tc.ID_TERMINAL=c.ID_TERMINAL and c.ID_CLIENT=?");*/
  1618.         $sql = $con->prepare("SELECT *
  1619.         FROM `terminal_composant` tc 
  1620.         where  tc.ID_TERMINAL=? and tc.ID_COMPOSANT=? LIMIT 1");
  1621.         $sql->bindValue(1, $jsonContent['idTerminal']);
  1622.         $sql->bindValue(2, $jsonContent['idComposant']);
  1623.         $sql->execute();
  1624.         $etat = $sql->fetch();
  1625.         $reponse = new Response('KO !', 406);
  1626.         if($etat)
  1627.         {
  1628.             $sql = $con->prepare("update terminal_composant set ETAT_ERREUR=? , ETAT_COMPOSANT=? where ID_TERMINAL=? and ID_COMPOSANT=?");
  1629.             $sql->bindValue(1, $jsonContent['etatErreur']);
  1630.             $sql->bindValue(2, $jsonContent['etatComposant']);
  1631.             $sql->bindValue(3, $jsonContent['idTerminal']);
  1632.             $sql->bindValue(4, $jsonContent['idComposant']);
  1633.             $sql->execute();
  1634.             $response = new Response('Update etat !', 201);
  1635.         }
  1636.         else 
  1637.         {
  1638.             $sql = $con->prepare("insert into terminal_composant (ID_TERMINAL, ID_COMPOSANT, ETAT_ERREUR , ETAT_COMPOSANT) values (?, ?,?,?)");
  1639.             $sql->bindValue(1, $jsonContent['idTerminal']);
  1640.             $sql->bindValue(2, $jsonContent['idComposant']);
  1641.             $sql->bindValue(3, $jsonContent['etatErreur']);
  1642.             $sql->bindValue(4, $jsonContent['etatComposant']);
  1643.             $sql->execute();
  1644.             $response = new Response('Insert etat !', 201);
  1645.             
  1646.         }
  1647.         
  1648.         
  1649.         
  1650.         return $response ;
  1651.     }
  1654.     //SH 2024.10.2024 sauvegarder conso 
  1655.     public function saveConsoElec()
  1656.     {
  1657.            
  1658.         $request = $this->requestStack->getCurrentRequest();
  1659.         $data = $request->request->all();
  1660.         //return new Response (var_dump(count($data)));
  1661.         //$data = json_decode($request->getContent(), true);
  1662.          // Enregistrement des données dans un fichier
  1663.         if ((isset($data['idTerm'])) and (count($data)==5))
  1664.         {
  1665.             $dateActuelle = new \DateTime();
  1666.             $data['dateConso'] = $dateActuelle->format('Y-m-d H:i:s');
  1667.             //return new Response (var_dump($data));
  1668.             file_put_contents('/var/www/public/info/conso.txt', json_encode($data) . PHP_EOL, FILE_APPEND);
  1669.         
  1670.             return $this->json([
  1671.                 'Result' => true ,
  1672.                 'Message' => 'Success'
  1673.             ]);
  1674.         }
  1675.         
  1676.         return $this->json([
  1677.             'Result' => false ,
  1678.             'Message' => 'invalid format'
  1679.         ]);    
  1680.     }
  1683.     public function showConsoElec()
  1684.     {
  1685.            
  1686.         $file = new Filesystem();
  1687.         $file = '/var/www/public/info/conso.txt';
  1688.         $dataFile=file_get_contents($file);
  1690.         $lignes = explode("\n", $dataFile);
  1691.         
  1692.         $infoConso =null;
  1693.         for($i=0;$i<count($lignes)-1;$i++)
  1694.         {
  1695.             $infoConso[$i] = json_decode($lignes[$i], true);
  1696.         }
  1698.         //return new Response (var_dump($infoConso));
  1699.         return $this->render('StatistiquesBundle/listeConso.html.twig',    array('infoConso'=>$infoConso));
  1700.         return $this->json([
  1701.              'Result' => true ,
  1702.              'Message' => 'Success'
  1703.         ]);
  1704.             
  1705.     }
  1706.    
  1707.     public function actionRAZ()
  1708.     {
  1709.         $server = '192.168.1.22';
  1710.         $port=1883;
  1711.         $clientId='api_isipay';
  1712.         $client = new ClientMQTT($server,$port, $clientId);
  1713.         
  1714.         $client->setAuthDetails("urbaflux", "BJdYM#t8ucvN?yZMu");
  1715.         $client->setParamServer($server,$port, $clientId); 
  1716.         $result = $client->connect();
  1717.         
  1718.            //return new Response(var_dump($result));
  1719.         $result = $client->publish('9999/in/RAZ' ,'AYB_RAF' , 0);  
  1720.         $client->close();
  1721.         sleep(5);
  1722.         return $this->redirect('showConso');
  1723.     }
  1724.     //fin SH 
  1727.     /**
  1728.      * @Route("/send-email-photo", name="send_email")
  1729.      */
  1730.     public function alerteStatosPhoto(MailService $mailService)
  1731.     {
  1732.         
  1733.         //$mailService = $this->get('App\Services\MailService');
  1734.         
  1735.         $to = ['s.handi@urbaflux.fr','handisoukaina@urbaflux.fr']; // Destinataire(s)
  1736.         $template = 'emails/emailAlert.html.twig'; // Nom du template Twig
  1737.         $subject = 'Votre sujet d\'email';
  1738.         $context = [
  1739.             'subject' => $subject,
  1740.             'variable1' => 'value1',
  1741.             'variable2' => 'value2',
  1742.             // Autres variables à passer au template
  1743.         ];
  1744.         $pjImages = [
  1745.            'https://statos.netbase.fr/captures/AM_1015_place_1.jpeg', // Chemin absolu de l'image
  1746.            'https://statos.netbase.fr/captures/AM_1015_place_1.jpeg',
  1747.         ];
  1748.         //return new Response(var_dump($pjImages));
  1749.         // Appeler le service pour envoyer l'email
  1750.         $mailService->sendEmailPJ($to, $template, $subject, $context, $pjImages);
  1752.         return new Response('Email envoyé avec succès!');
  1753.     }
  1755.     /**
  1756.      * @Route("/envoiMailAlertUA", name="envoi_mail_alertUA" , methods={"POST"})
  1757.      */
  1758.     public function envoiMailAlertUA(MailService $mailService)
  1759.     {
  1761.         $request = $this->requestStack->getCurrentRequest();
  1762.         $content = $request->getContent();
  1763.         if (!mb_check_encoding($content, 'UTF-8')) {
  1764.             // Forcer l'encodage en UTF-8 si nécessaire
  1765.             $content = mb_convert_encoding($content, 'UTF-8', 'ISO-8859-1');
  1766.         }
  1767.         $data = json_decode($content, true);
  1768.         //return new Response(var_dump($data));
  1769.         if (json_last_error() !== JSON_ERROR_NONE) {
  1770.             return new JsonResponse(['error' => 'Invalid JSON'], 400);
  1771.         }
  1773.         $email_destinataires =str_replace("'", '"', $data['destinataires']) ?? null;
  1774.         $nomTerminal = $data['nomTerminal'] ?? null;
  1775.         $type = $data['type'] ?? null;
  1777.         if(($email_destinataires != '') && ($email_destinataires!=null) )
  1778.         {
  1779.             //$jsonDest = str_replace("'", '"', $email_destinataires);
  1780.             $to=   explode(",", $email_destinataires);
  1781.             $mailService->sendTemplatedEmail($to, 'emails/emailAlertUA.html.twig' ,'Notification Urbacces', $data);
  1782.             return new Response('Notification envoyé avec succès!');
  1783.         }
  1784.         return new Response('Liste des destinataires vide');
  1785.     }
  1787.     /**
  1788.      * @Route("/uploadImageIsipay", name="upload_image_isipay" , methods={"POST"})
  1789.      */
  1791.     public function uploadImage()//: JsonResponse
  1792.     {
  1793.         $request = $this->requestStack->getCurrentRequest();
  1794.         $identifiant = $request->request->get('identifiant');
  1796.         if (!$identifiant) {
  1797.             throw new BadRequestHttpException('Identifiant manquant.');
  1798.         }
  1800.         // Remote server details
  1801.         $host = '192.168.1.38'; // Replace with your server's address
  1802.         $username = 'root';
  1803.         $password = 'Urb@tést!18570';
  1805.         // Connect to the remote server using SFTP
  1806.         //$sftp = new SFTP($host);
  1807.         $sftp = new \phpseclib3\Net\SFTP($host);
  1808.         if (!$sftp->login($username, $password)) {
  1809.             throw new \Exception('Unable to connect to remote server using SFTP.');
  1810.         }
  1812.         $uploadDir = 'isipayImage/' . $identifiant;
  1814.         // Verify if the directory exists on the remote server
  1815.         if (!$sftp->is_dir($uploadDir)) {
  1816.             // Directory doesn't exist, create it
  1817.             if (!$sftp->mkdir($uploadDir)) {
  1818.                 throw new \Exception('Unable to create directory on remote server.');
  1819.             }
  1820.         } else {
  1821.             // Directory exists, clear it by deleting files inside
  1822.             $remoteFiles = $sftp->nlist($uploadDir);
  1823.             foreach ($remoteFiles as $file) {
  1824.                 if ($file !== '.' && $file !== '..') {
  1825.                     $sftp->delete($uploadDir . '/' . $file);
  1826.                 }
  1827.             }
  1828.         }
  1830.         // Handle file uploads
  1831.         $uploadedFiles = [];
  1832.         $imageUrls = [];
  1834.         foreach ($request->files as $key => $uploadedFile) {
  1835.             if ($uploadedFile instanceof UploadedFile) {
  1836.                 $newFilename = uniqid() . '.' . $uploadedFile->guessExtension();
  1837.                 $uploadedFilePath = $uploadDir . '/' . $newFilename;
  1839.                 // Move the file to the remote server
  1840.                 $sftp->put($uploadedFilePath, file_get_contents($uploadedFile->getPathname()));
  1842.                 // Store the file URL
  1843.                 $uploadedFiles[] = '/isipayImage/' . $identifiant . '/' . $newFilename;
  1844.             }
  1845.         }
  1847.         // Handle remote image URLs if provided
  1848.         $imagesDistantes = $request->request->get('images_distantes');
  1849.         if ($imagesDistantes) {
  1850.             $imageUrls = json_decode($imagesDistantes, true);
  1851.             if (!is_array($imageUrls)) {
  1852.                 throw new BadRequestHttpException('Format des images distantes invalide.');
  1853.             }
  1854.         }
  1856.         if (empty($uploadedFiles) && empty($imageUrls)) {
  1857.             throw new BadRequestHttpException('Aucune image valide envoyée.');
  1858.         }
  1860.         return new JsonResponse([
  1861.             'message' => 'Images bien reçues et stockées / référencées !',
  1862.             'files' => $uploadedFiles,
  1863.             'image_urls' => $imageUrls
  1864.         ], Response::HTTP_OK);
  1865.     }
  1866.     /*public function uploadImage()//: JsonResponse
  1867.     {
  1868.         $request = $this->requestStack->getCurrentRequest();
  1869.         $identifiant = $request->request->get('identifiant');
  1870.         //return new Response(var_dump($identifiant));
  1871.         if (!$identifiant) {
  1872.             throw new BadRequestHttpException('Identifiant manquant.');
  1873.         }
  1874.     
  1875.         $uploadDir = 'http://192.168.1.38/public/isipayImage/' . $identifiant;
  1876.         
  1877.         // Vérifier si le dossier existe, sinon le créer
  1878.         $filesystem = new Filesystem();
  1879.         if (!$filesystem->exists($uploadDir)) {
  1880.             $filesystem->mkdir($uploadDir, 0777);
  1881.         } else {
  1882.             return new Response(var_dump($uploadDir));
  1883.             try {
  1884.                 $filesystem->remove(glob($uploadDir . '/*'));
  1885.             } catch (\Exception $exception) {
  1886.                 throw new \Exception("Erreur lors de la suppression des anciens fichiers : " . $exception->getMessage());
  1887.             }
  1888.         }
  1889.     
  1890.         $uploadedFiles = [];
  1891.         $imageUrls = [];
  1892.     
  1893.         foreach ($request->files as $key => $uploadedFile) {
  1894.             if ($uploadedFile instanceof UploadedFile) {
  1895.                 $newFilename = uniqid() . '.' . $uploadedFile->guessExtension();
  1896.                 $uploadedFile->move($uploadDir, $newFilename);
  1897.                 $uploadedFiles[] = '/isipayImage/' . $identifiant . '/' . $newFilename;
  1898.             }
  1899.         }
  1900.     
  1901.         $imagesDistantes = $request->request->get('images_distantes');
  1902.         if ($imagesDistantes) {
  1903.             $imageUrls = json_decode($imagesDistantes, true);
  1904.             if (!is_array($imageUrls)) {
  1905.                 throw new BadRequestHttpException('Format des images distantes invalide.');
  1906.             }
  1907.         }
  1908.     
  1910.         if (empty($uploadedFiles) && empty($imageUrls)) {
  1911.             throw new BadRequestHttpException('Aucune image valide envoyée.');
  1912.         }
  1913.     
  1914.         return new JsonResponse([
  1915.             'message' => 'Images bien reçues et stockées / référencées !',
  1916.             'files' => $uploadedFiles,
  1917.             'image_urls' => $imageUrls
  1918.         ], Response::HTTP_OK);
  1919.     }*/
  1920. }