src/Controller/APIIctus/APIIctPanierController.php line 467

Open in your IDE?
  1. <?php
  3. namespace App\Controller\APIIctus;
  5. use DateTime;
  6. use App\Entity\User;
  7. use App\Entity\Carte;
  8. use App\Services\Util;
  9. use App\Entity\Ordonnance;
  10. use App\Entity\PrisEnCharge;
  11. use App\Entity\IctusCommande;
  12. use App\Entity\IctusPharmacie;
  13. use App\Entity\Stockpharmacie;
  14. use App\Services\MailerServices;
  15. use App\Entity\IctusCommandeLine;
  16. use App\Services\IctocoinService;
  17. use App\Entity\IctusPanierPatient;
  18. use App\Entity\IctusPanierSpecial;
  19. use App\Repository\UserRepository;
  20. use App\Entity\RemiseUserPharmacie;
  21. use App\Repository\CarteRepository;
  22. use App\Services\api\PanierService;
  23. use App\Services\api\RemiseService;
  24. use App\Repository\AdhererRepository;
  25. use App\Services\NotificationService;
  26. use App\Repository\AssuranceRepository;
  27. use App\Services\FacturePatientService;
  28. use App\Repository\OrdonnanceRepository;
  29. use App\Services\VanillaPaiementSercice;
  30. use Doctrine\ORM\EntityManagerInterface;
  31. use App\Services\CodeRecuperationService;
  32. use App\Repository\TypepaiementRepository;
  33. use App\Repository\IctusCommandeRepository;
  34. use App\Repository\IctusPharmacieRepository;
  35. use App\Repository\StockpharmacieRepository;
  36. use Symfony\Component\HttpFoundation\Request;
  37. use Symfony\Component\Mailer\MailerInterface;
  38. use App\Repository\EtatPrisenchargeRepository;
  39. use Symfony\Component\HttpFoundation\Response;
  40. use App\Repository\IctusEtatPaiementRepository;
  41. use App\Repository\IctusTypePaiementRepository;
  42. use Symfony\Component\Routing\Annotation\Route;
  43. use App\Repository\IctusPanierPatientRepository;
  44. use App\Repository\IctusPanierSpecialRepository;
  45. use App\Repository\IctusTypeLivraisonRepository;
  46. use App\Repository\IctusMobileAppareilRepository;
  47. use App\Repository\RemiseUserPharmacieRepository;
  48. use App\Services\VanillaPayInternationnalService;
  49. use Symfony\Component\HttpFoundation\JsonResponse;
  50. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  51. use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
  52. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  54. #[Route('/api/ictus-shop/panier', name: 'app_api_ictus_shop_panier_')]
  55. class APIIctPanierController extends AbstractController
  56. {
  58.     private $em;
  59.     private $mailerint;
  60.     private $mailTechnicien = "zoanja.rabehaja@sopharmad.mg";
  61.     private $util;
  62.     private $montantTotalPaiementEnLigne = 0;
  63.     private $listeCommandePaiementEnLigne = array();
  64.     private $notifUrl;
  65.     private $redirectUrl;
  67.     public function __construct(EntityManagerInterface $em, MailerInterface $mailerint, Util $util, UrlGeneratorInterface $urlGenerator)
  68.     {
  69.         $this->em = $em;
  70.         $this->mailerint  = $mailerint;
  71.         $this->util       = $util;
  72.         $this->notifUrl   = $_ENV["VANILLA_INT_URL_NOTIF"];
  73.         $this->redirectUrl = $_ENV["VANILLA_INT_URL_REDIRECT"];
  74.     }
  76.     #[Route('/non-authentifier', name: 'non_auth', methods: ['GET'])]
  77.     public function panierNonAuth(Request $request, StockpharmacieRepository $stockpharmacieRepository, PanierService $panierService): Response
  78.     {
  79.         $produitPcie = $request->query->all('produitPcie');
  80.         $produitPcie = array_map('intval', $produitPcie);
  81.         $panierCart  = $panierService->getFull($stockpharmacieRepository, null,$produitPcie);
  82.         $responseData   = [
  83.             'error' => true,
  84.         ];
  85.         if (count($panierService->groupByIdPcie($panierCart)) > 0) {
  87.             $responseData = $panierService->groupByIdPcie($panierCart);
  88.             return $this->json($responseData);
  89.         }
  91.         return $this->json($responseData, 500, [], []);
  92.     }
  94.     /******************Ajouter panier dans MySQL************** */
  95.     //Enregistrement panier direct dans DB MysQl par l'user connectee dans meilleur vente
  96.     #[Route('/ajout-auth-mysql', name: 'app_panier_add_auth', methods: ['POST'])]
  97.     public function ajoutPanierAuthBestSeller(Request $request, IctusPanierPatientRepository $panierRepo, UserRepository $userRepository, StockpharmacieRepository $stockPcieRepo): Response
  98.     {
  100.         // Récupérer les données du corps de la requête
  101.         $data = json_decode($request->getContent(), true);
  102.         // Vérifier si userId est bien envoyé
  103.         if (!isset($data['userId'])) {
  104.             return $this->json(['error' => 'ID utilisateur manquant'], JsonResponse::HTTP_BAD_REQUEST);
  105.         }
  106.         // Vérifier si les produits sont bien envoyés
  107.         if (!isset($data['produit'])) {
  108.             return $this->json(['error' => 'Aucun produit fourni'], JsonResponse::HTTP_BAD_REQUEST);
  109.         }
  110.         // Récupérer l'utilisateur depuis l'ID envoyé
  111.         $user = $userRepository->find($data['userId']);
  112.         if (!$user) {
  113.             return $this->json(['error' => 'Utilisateur non trouvé'], JsonResponse::HTTP_NOT_FOUND);
  114.         }
  115.         if (!isset($data['produit'], $data['quantite'])) {
  116.             return $this->json(['error' => 'Informations du produit manquantes'], JsonResponse::HTTP_BAD_REQUEST);
  117.         }
  118.         // Récupérer le produit en base de données
  119.         $produit = $stockPcieRepo->find($data['produit']);
  120.         if (!$produit) {
  121.             return $this->json(['error' => 'Produit non trouvé'], JsonResponse::HTTP_NOT_FOUND);
  122.         }
  123.         // produit exit panier ou non 
  124.         $existPanier   = $panierRepo->findOneBy(['user' => $user, 'produit_stock_pcie' => $produit]);
  125.         $quantite      = $data['quantite'];
  126.         $tva           = $produit->getTva();
  127.         if (!is_null($existPanier)) {
  128.             $quantite = $existPanier->getQuantite() + $data['quantite'];
  129.         }
  130.         $panier        = (!is_null($existPanier)) ? $existPanier : new IctusPanierPatient();
  131.         // Calculer le prix total
  132.         $prix_unitaire = (!is_null($tva)) ? ($produit->getPrixunitforme() + ($produit->getPrixunitforme() * $tva) / 100) : $produit->getPrixunitforme();
  134.         // Créer une nouvelle entrée dans le panier
  135.         $panier->setProduitStockPcie($produit)
  136.             ->setUser($user)
  137.             ->setQuantite($quantite)
  138.             ->setPrixUnitaire($prix_unitaire)
  139.             ->setTotal($quantite * $prix_unitaire);
  141.         // Persister dans la base de données
  142.         $this->em->persist($panier);
  144.         $this->em->flush();
  146.         return $this->json(['message' => 'Panier enregistré avec succès'], JsonResponse::HTTP_CREATED);
  147.     }
  149.     //Enregistrement panier SQLite dans DB MysQl apres login
  150.     #[Route('/ajout-sqlit-mysql', name: 'app_panier_add_sqlite_to_mysql_apre_login', methods: ['POST'])]
  151.     public function enregistrementPanierDB(
  152.         Request $request,
  153.         StockpharmacieRepository $stockPcieRepo,
  154.         UserRepository $userRepo,
  155.         IctusPanierPatientRepository $panierRepo,
  156.         EntityManagerInterface $em
  157.     ): JsonResponse {
  158.         // Récupérer les données du corps de la requête
  159.         $data = json_decode($request->getContent(), true);
  160.         // Vérifier si userId est bien envoyé
  161.         if (!isset($data['userId'])) {
  162.             return $this->json(['error' => 'ID utilisateur manquant'], JsonResponse::HTTP_BAD_REQUEST);
  163.         }
  165.         // Vérifier si les produits sont bien envoyés
  166.         if (!isset($data['produits']) || !is_array($data['produits'])) {
  167.             return $this->json(['error' => 'Aucun produit fourni'], JsonResponse::HTTP_BAD_REQUEST);
  168.         }
  170.         $user = $userRepo->findOneById($data['userId']);
  171.         if (!$user) {
  172.             return $this->json(['error' => 'Utilisateur: '.$data['userId'].' non trouvé'], JsonResponse::HTTP_NOT_FOUND);
  173.         }
  175.         $paniers = $data['produits'];
  176.         $prixTotal = 0;
  178.         foreach ($paniers as $panierSession) {
  179.             // Vérifier les informations du produit
  180.             if (!isset($panierSession['idProduit'], $panierSession['quantite'])) {
  181.                 return $this->json(['error' => 'Informations du produit manquantes'], JsonResponse::HTTP_BAD_REQUEST);
  182.             }
  184.             // Récupérer le produit en base de données
  185.             $produit = $stockPcieRepo->find($panierSession['idProduit']);
  186.             if (!$produit) {
  187.                 return $this->json(['error' => 'Produit non trouvé'], JsonResponse::HTTP_NOT_FOUND);
  188.             }
  190.             $existPanier   = $panierRepo->findOneBy(['user' => $user, 'produit_stock_pcie' => $produit]);
  191.             $quantite      = $panierSession['quantite'];
  192.             $tva           = $produit->getTva();
  193.             if (!is_null($existPanier)) {
  194.                 $quantite  = $existPanier->getQuantite() + $panierSession['quantite'];
  195.             }
  197.             $panier        = (!is_null($existPanier)) ? $existPanier : new IctusPanierPatient();
  198.             $prix_unitaire = (!is_null($tva)) ? ($produit->getPrixunitforme() + ($produit->getPrixunitforme() * $tva) / 100) : $produit->getPrixunitforme();
  199.             $prixTotal += $quantite * $prix_unitaire;
  201.             // Créer une nouvelle entrée dans le panier
  202.             $panier->setProduitStockPcie($produit)
  203.                 ->setUser($user)
  204.                 ->setQuantite($quantite)
  205.                 ->setPrixUnitaire($prix_unitaire)
  206.                 ->setTotal($quantite * $prix_unitaire);
  208.             // Essayer de persister chaque entrée
  209.             try {
  210.                 $em->persist($panier);
  211.             } catch (\Exception $e) {
  212.                 // Logger l'erreur avec plus de détails
  213.                 return $this->json(['erreur' => 'Erreur lors de l\'ajout au panier: ' . $e->getMessage()], JsonResponse::HTTP_INTERNAL_SERVER_ERROR);
  214.             }
  215.         }
  217.         // Enregistrer tous les paniers en une seule transaction
  218.         try {
  219.             $em->flush();
  220.         } catch (\Exception $e) {
  221.             return $this->json(['erreur' => 'Erreur lors de l\'enregistrement des paniers: ' . $e->getMessage()], JsonResponse::HTTP_INTERNAL_SERVER_ERROR);
  222.         }
  224.         return $this->json(['message' => 'Panier ajouté avec succès', 'total' => $prixTotal], JsonResponse::HTTP_CREATED);
  225.     }
  227.     #[Route('/count-mysql', name: 'app_panier_count_mysql', methods: ['POST'])]
  228.     public function getCountProduitParUser(Request $request, UserRepository $userRepo, IctusPanierPatientRepository $panierRepo)
  229.     {
  230.         $data = json_decode($request->getContent(), true);
  231.         if (!isset($data['userId'])) {
  232.             return $this->json(['error' => 'ID utilisateur manquant'], JsonResponse::HTTP_BAD_REQUEST);
  233.         }
  234.         $user = $userRepo->find($data['userId']);
  236.         if (!$user) {
  237.             return $this->json(['error' => 'Utilisateur non trouvé'], JsonResponse::HTTP_NOT_FOUND);
  238.         }
  240.         $countPanier = $panierRepo->findCountpanierByUser($user);
  241.         return $this->json(["countPanier" => $countPanier]);
  242.     }
  244.     //Liste produit dans panier MySQL pour l'utilisateur connecte
  245.     #[Route('/mysql-user-connecte', name: 'mysql_user_connecte', methods: ['POST'])]
  246.     public function panierMySQLUserConnectee(
  247.         Request $request,
  248.         StockpharmacieRepository $stockpharmacieRepository,
  249.         PanierService $panierService,
  250.         IctusPanierPatientRepository $panierRepo,
  251.         UserRepository $userRepo
  252.     ): Response {
  253.         $data = json_decode($request->getContent(), true);
  255.         if (!isset($data['userId'])) {
  256.             return $this->json(['error' => 'ID utilisateur manquant'], JsonResponse::HTTP_BAD_REQUEST);
  257.         }
  259.         $user             = $userRepo->find($data['userId']);
  260.         $produitPcie      = $panierRepo->findAllByUser($user);
  261.         $coupleIdQuantite = [];
  263.         if (count($produitPcie) > 0) {
  264.             foreach ($produitPcie as $panier) {
  265.                 $idStockPcie                    = $panier->getProduitStockPcie()->getId();
  266.                 $quantite                       = $panier->getQuantite();
  267.                 $coupleIdQuantite[$idStockPcie] = $quantite;
  268.             }
  269.         }
  271.         $panierCart   = $panierService->getFull($stockpharmacieRepository, $user, $coupleIdQuantite);
  272.         $responseData = [
  273.             'error' => true,
  274.         ];
  276.         if (count($panierService->groupByIdPcie($panierCart)) > 0) {
  277.             $responseData = $panierService->groupByIdPcie($panierCart);
  278.             return $this->json($responseData, JsonResponse::HTTP_OK);
  279.         }
  281.         return $this->json(['error' => 'Empty Data'], JsonResponse::HTTP_NOT_FOUND);
  282.     }
  284.     #[Route('/mysql-user-connecte-update-quantite', name: 'mysql_user_connecte_update_quantite', methods: ['POST'])]
  285.     public function updateQuantiteProduitPanier(
  286.         Request $request,
  287.         StockpharmacieRepository $stockpharmacieRepository,
  288.         IctusPanierPatientRepository $panierRepo,
  289.         UserRepository $userRepo
  290.     ): Response {
  291.         $data      = json_decode($request->getContent(), true);
  292.         $panier    = null;
  293.         $stockpcie = null;
  295.         if (!isset($data['userId'])) {
  296.             return $this->json(['error' => 'ID utilisateur manquant'], JsonResponse::HTTP_BAD_REQUEST);
  297.         }
  299.         $user = $userRepo->find($data['userId']);
  300.         if (is_null($user)) {
  301.             return $this->json(['error' => 'User non trouve'], JsonResponse::HTTP_NOT_FOUND);
  302.         }
  304.         if (!isset($data['produit'])) {
  305.             return $this->json(['error' => 'ID Produit manquant'], JsonResponse::HTTP_BAD_REQUEST);
  306.         }
  307.         $stockpcie = $stockpharmacieRepository->findOneById($data['produit']);
  308.         if (is_null($stockpcie)) {
  309.             return $this->json(['error' => 'Produit non trouve'], JsonResponse::HTTP_NOT_FOUND);
  310.         }
  312.         $panier = $panierRepo->findOneBy(['produit_stock_pcie' => $stockpcie, 'user' => $user]);
  313.         /******* */
  314.         $tva           = $stockpcie->getTva();
  315.         $prix_unitaire = (!is_null($tva)) ? ($stockpcie->getPrixunitforme() + ($stockpcie->getPrixunitforme() * $tva) / 100) : $stockpcie->getPrixunitforme();
  316.         $pixTotal      =  $prix_unitaire * $data['quantite'];
  317.         /************ */
  318.         if (!is_null($panier)) {
  319.             $panier->setQuantite($data['quantite'])
  320.                 ->setTotal($pixTotal)
  321.                 ->setPrixUnitaire($prix_unitaire);
  322.             $this->em->flush();
  323.             $newData = [
  324.                 'userId'        => $data['userId'],
  325.                 'produit'       => $data['produit'],
  326.                 'quantite'      => $data['quantite'],
  327.                 'prix_unitaire' => $prix_unitaire,
  328.                 'total'         => $pixTotal
  329.             ];
  330.             return $this->json($newData, JsonResponse::HTTP_OK);
  331.         }
  333.         return $this->json(['error' => 'Empty Data'], JsonResponse::HTTP_NOT_FOUND);
  334.     }
  337.     #[Route('/mysql-user-connecte-delete', name: 'mysql_user_connecte_delete', methods: ['POST'])]
  338.     public function deleteProduitPanierMySQL(
  339.         Request $request,
  340.         StockpharmacieRepository $stockpharmacieRepository,
  341.         IctusPanierPatientRepository $panierRepo,
  342.         UserRepository $userRepo
  343.     ): Response {
  344.         $data      = json_decode($request->getContent(), true);
  345.         $panier    = null;
  346.         $stockpcie = null;
  348.         if (!isset($data['userId'])) {
  349.             return $this->json(['error' => 'ID utilisateur manquant'], JsonResponse::HTTP_BAD_REQUEST);
  350.         }
  352.         $user = $userRepo->find($data['userId']);
  353.         if (is_null($user)) {
  354.             return $this->json(['error' => 'User non trouve'], JsonResponse::HTTP_NOT_FOUND);
  355.         }
  357.         if (!isset($data['produit'])) {
  358.             return $this->json(['error' => 'ID Produit manquant'], JsonResponse::HTTP_BAD_REQUEST);
  359.         }
  360.         $stockpcie = $stockpharmacieRepository->findOneById($data['produit']);
  361.         if (is_null($stockpcie)) {
  362.             return $this->json(['error' => 'Produit non trouve'], JsonResponse::HTTP_NOT_FOUND);
  363.         }
  365.         $panier = $panierRepo->findOneBy(['produit_stock_pcie' => $stockpcie, 'user' => $user]);
  367.         /************ */
  368.         if (!is_null($panier)) {
  369.             $this->em->remove($panier);
  370.             $this->em->flush();
  372.             return $this->json("DATA DELETED OK", JsonResponse::HTTP_OK);
  373.         }
  375.         return $this->json(['error' => 'Empty Data'], JsonResponse::HTTP_NOT_FOUND);
  376.     }
  378.     //Ajouter ordonnace dans un produit panier
  379.     #[Route('/create/ordonnance', name: 'create_ordonnance', methods: ['POST'])]
  380.     public function createOrdonnancePanier(
  381.         Request $request,
  382.         OrdonnanceRepository $ordonaceRepo,
  383.         PanierService $panierService,
  384.         StockpharmacieRepository $stockpharmacieRepository,
  385.         IctusPanierPatientRepository $panierRepo,
  386.         UserRepository $userRepo
  387.     ): Response {
  388.         //$data = json_decode($request->getContent(), true);
  389.         $panierData = $panierService->handleDataPanier($userRepo, $stockpharmacieRepository, $panierRepo, $request);
  390.         if (isset($panierData['error'])) {
  391.             return $this->json($panierData, JsonResponse::HTTP_BAD_REQUEST);
  392.         }
  393.         // Si tout est correct, vous pouvez procéder à la création de l'ordonnance
  394.         $user = $panierData['user'];
  395.         if ($user instanceof User) {
  396.             $panier = $panierData['panier'];
  397.             if (!is_null($panier) && $panier instanceof IctusPanierPatient) {
  398.                 $panier->setOrdonnance($ordonaceRepo->createOrdonnance($panierData['file'], $panierData['titre'], $panierData['user']));
  399.                 $this->em->flush();
  400.             } else {
  401.                 $ordonaceRepo->createOrdonnance($panierData['file'], $panierData['titre'], $panierData['user']);
  402.             }
  403.             return $this->json(['CREATED' => "DATA CREATE OK"], JsonResponse::HTTP_CREATED);
  404.         }
  405.         return $this->json(['error' => 'Empty Data'], JsonResponse::HTTP_NOT_FOUND);
  406.     }
  408.     //allOrdonneByIdUser()
  409.     #[Route('/ordonnance/{id}', name: 'get_ordonnance', methods: ['GET'])]
  410.     public function recupOrdonnanceByUser(User $user, OrdonnanceRepository $ordonaceRepo): Response
  411.     {
  412.         $dataOrdonnances = [];
  414.         if (!is_null($user)) {
  415.             $ordonnances = $ordonaceRepo->findAllOrdonnanceByIdUser($user->getId());
  416.             if (count($ordonnances)) {
  417.                 foreach ($ordonnances as $ordo) {
  418.                     $dataOrd = [
  419.                         'id'     => $ordo->getId(),
  420.                         'userId' => $ordo->getPropriertaire()->getId(),
  421.                         'titre'  => $ordo->getTitre(),
  422.                         'file'   => $ordo->getFichier()
  423.                     ];
  425.                     array_push($dataOrdonnances, $dataOrd);
  426.                 }
  428.                 return $this->json($dataOrdonnances, JsonResponse::HTTP_OK);
  429.             }
  430.         }
  432.         return $this->json(['error' => 'Empty Data'], JsonResponse::HTTP_NOT_FOUND);
  433.     }
  435.     //Update PanierOrdonnace
  436.     #[Route('/update/ordonnance', name: 'update_ordonnance', methods: ['POST'])]
  437.     public function updateOrdonnancePanier(
  438.         Request $request,
  439.         OrdonnanceRepository $ordonaceRepo,
  440.         StockpharmacieRepository $stockpharmacieRepository,
  441.         IctusPanierPatientRepository $panierRepo,
  442.         UserRepository $userRepo
  443.     ): Response {
  444.         $data = json_decode($request->getContent(), true);
  446.         if (!isset($data['produitId'])) {
  447.             return $this->json(['error' => 'Produit manquant'], JsonResponse::HTTP_BAD_REQUEST);
  448.         }
  449.         $stockpcie = $stockpharmacieRepository->findOneById($data['produitId']);
  451.         if (!isset($data['userId'])) {
  452.             return $this->json(['error' => 'ID utilisateur manquant'], JsonResponse::HTTP_BAD_REQUEST);
  453.         }
  455.         $user = $userRepo->find($data['userId']);
  457.         $panier = $panierRepo->findOneBy(['produit_stock_pcie' => $stockpcie, 'user' => $user]);
  459.         if (!isset($data['ordonnanceId'])) {
  460.             return $this->json(['error' => 'Id ordonnance manquant'], JsonResponse::HTTP_BAD_REQUEST);
  461.         }
  463.         $ordonnance = $ordonaceRepo->findOneById($data['ordonnanceId']);
  465.         if ($user instanceof User && $ordonnance instanceof Ordonnance && $panier instanceof IctusPanierPatient) {
  466.             $panier->setOrdonnance($ordonnance);
  467.             $this->em->flush();
  468.             return $this->json(['UPDATED' => "DATA UPDATED OK"], JsonResponse::HTTP_OK);
  469.         }
  470.         return $this->json(['error' => 'Empty Data'], JsonResponse::HTTP_NOT_FOUND);
  471.     }
  473.     /*  url = {base_url}/api/ictus-shop/panier/panier/sendcommande/{userId}/{typeLivraisonId}/{typePaiementId}
  474.         method : GET
  475.      */
  476.     #[Route('/sendcommande/{userId}/{typeLivraisonId}/{typePaiementId}/{assuranceId}', name: 'panier_sendcommande', methods: ['GET'])]
  477.     public function panierSendcommande(
  478.         Request $request, FacturePatientService $facturePatientService, 
  479.         IctusMobileAppareilRepository $mobileAppareilRepo, 
  480.         NotificationService $notificationService, MailerServices $mail, 
  481.         IctocoinService $ictocoinService, VanillaPayInternationnalService $vanillaPayInternationnalService,
  482.         UserRepository $userRepo, IctusPanierPatientRepository $ictusPanierPatientRepo, IctusTypeLivraisonRepository $ictusTypeLivraisonRepo,
  483.         IctusTypePaiementRepository $ictusTypePaiementRepo, IctusPharmacieRepository $ictusPharmacieRepo,
  484.         IctusEtatPaiementRepository $etatPaiementRepo, IctusCommandeRepository $ictusCommandeRepo,
  485.         CodeRecuperationService $codeRecuperationService, $userId, $typeLivraisonId, $typePaiementId,
  486.         AssuranceRepository $assuranceRepo,AdhererRepository $adhererRepo,EtatPrisenchargeRepository $etatPrisenchargeRepo,
  487.         $assuranceId = null
  488.     ){
  489.         if ($request->isMethod('GET')) {
  490.             $tierPayant = null;
  491.             $adherer    = null;
  492.         
  493.             $urlPaiement = null;
  494.             if ($typeLivraisonId != null && $typePaiementId != null && $userId != null) {
  495.                 $user         = $userRepo->find($userId);
  496.                 $token = (new \DateTime())->format('YmdiHs') . $user->getId();
  497.                 $typeLivraison = $ictusTypeLivraisonRepo->find($typeLivraisonId);
  498.                 $typePaiement  = $ictusTypePaiementRepo->find($typePaiementId);
  499.                 //TierPayant
  500.                 if ($assuranceId != "null" && $assuranceId != 0){
  501.                     $tierPayant  = $assuranceRepo->findOneById($assuranceId);
  502.                     $adherer     = $adhererRepo->getConditionsAdhererByAssurance($user, $tierPayant);
  503.                 }
  504.                 //FIN
  505.                 $paniers    = $ictusPanierPatientRepo->findBy(['user' => $user]);
  506.                 if (count($paniers) > 0) {
  507.                     $nbCommandes = $this->sendCommande($paniers, $typePaiement, $typeLivraison, $user, $ictusPanierPatientRepo, $ictusPharmacieRepo, $etatPaiementRepo, $token, $ictusCommandeRepo, $codeRecuperationService, $ictusTypePaiementRepo, $facturePatientService, $ictocoinService, $mail, $notificationService, $mobileAppareilRepo,$etatPrisenchargeRepo, $tierPayant,$adherer);
  508.                     $ictusPanierPatientRepo->removeProduit($user->getId());
  509.                     if ($nbCommandes > 0) {
  510.                         /* Paiement si necessaire */
  511.                         if (count($this->listeCommandePaiementEnLigne) > 0 and $this->montantTotalPaiementEnLigne > 0) {
  512.                             $liste = json_encode($this->listeCommandePaiementEnLigne);
  513.                             $reference = (new DateTime())->format('YmdHis') . $user->getId();
  514.                             if ($typePaiement->getId() == 4) {
  515.                                 $vanilla   = new VanillaPaiementSercice($this->util);
  516.                                 $nomUser   = $user->getNomComplet();
  517.                                 $adresseip = $this->getUserIpAddr();
  518.                                 $urlPaiement = $vanilla->payer($liste, $this->montantWithFrai($this->montantTotalPaiementEnLigne), $nomUser, $reference, $adresseip);
  519.                                 if ($urlPaiement != null) {
  520.                                     $urlPaiement = $urlPaiement->getTargetUrl();
  521.                                 }
  522.                             } else if ($typePaiement->getId() == 5) {
  523.                                 $urlPaiement = $vanillaPayInternationnalService->payer($liste, $this->montantTotalPaiementEnLigne, $reference, $this->notifUrl, $this->redirectUrl);
  524.                                 if ($urlPaiement != null) {
  525.                                     $urlPaiement = $urlPaiement->getTargetUrl();
  526.                                 }
  527.                             }
  528.                         }
  529.                         return $this->json(['success' => 'Success', 'message' => 'Commandes envoyées avec succès', 'nbCommandes' => $nbCommandes, 'urlPaiement' => $urlPaiement], JsonResponse::HTTP_OK);
  530.                     }
  531.                     return $this->json(['error' => 'Error', 'message' => 'Aucun commande envoyée', 'nbCommandes' => $nbCommandes, 'urlPaiement' => $urlPaiement], JsonResponse::HTTP_OK);
  532.                 }
  533.                 return $this->json(['error' => 'Error', 'message' => 'Panier vide', 'nbCommandes' => 0, 'urlPaiement' => $urlPaiement], JsonResponse::HTTP_OK);
  534.             } else {
  535.                 return $this->json(['error' => 'Error', 'message' => 'Parametre manquant', 'nbCommandes' => 0, 'urlPaiement' => $urlPaiement], JsonResponse::HTTP_BAD_REQUEST);
  536.             }
  537.         }
  538.     }
  540.     private function sendCommande(
  541.         $paniers,
  542.         $typePaiement,
  543.         $typeLivraison,
  544.         $user,
  545.         $ictusPanierPatientRepo,
  546.         $ictusPharmacieRepo,
  547.         $etatPaiementRepo,
  548.         $token,
  549.         $ictusCommandeRepo,
  550.         $codeRecuperationService,
  551.         $ictusTypePaiementRepo,
  552.         $facturePatientService,
  553.         $ictocoinService,
  554.         $mail,
  555.         $notificationService,
  556.         $mobileAppareilRepo,
  557.         $etatPrisenchargeRepo,
  558.         $tierPayant,
  559.         $adherer
  560.     ) {
  561.         $etatPaiementDefault = $etatPaiementRepo->findOneById(1);
  562.         $pharmacies = $ictusPanierPatientRepo->getPcieDistinctByPatientAndTypePaiement($user, $typePaiement);
  563.         $nbCommande = 0;
  564.         foreach ($pharmacies as $pharmacie) {
  565.             $paiement = null;
  566.             if ($pharmacie["idTypePaiement"] != null) {
  567.                 $paiement = $typePaiement;
  568.             } else {
  569.                 $paiement = $ictusTypePaiementRepo->findOneById(1);
  570.             }
  571.             $maxReference = $ictusCommandeRepo->findMaxReference($pharmacie["idpharmacie"])[0]["maxReference"];
  572.             if ($maxReference == null) {
  573.                 $maxReference = 0;
  574.             }
  575.             $maxReference = (int)$maxReference + 1;
  576.             $createdAt = new DateTime();
  577.             $createdAt->modify('+2 hours');
  578.             $commande  = new IctusCommande();
  579.             //Tierpayant
  580.             if ($tierPayant != null) {
  581.                 $etatDefault = $etatPrisenchargeRepo->find(1);
  582.                 $prisencharge = new PrisEnCharge();
  583.                 $prisencharge->setAssurance($tierPayant)
  584.                              ->setEtat($etatDefault)
  585.                              ->setPrisencharge($adherer['prisencharge'])
  586.                              ->setRemarque($adherer['remarque'])
  587.                              ->setNumero($adherer['numero'])
  588.                              ->setFirstName($adherer['prenom'])
  589.                              ->setLastname($adherer['nom']);
  590.                 $commande->setPrisencharge($prisencharge);
  591.             }
  592.             //Fin tierPayant
  593.             $codeComplet = $codeRecuperationService->generateCommande();
  594.             $commande->setPharmacie($ictusPharmacieRepo->findOneById(intval($pharmacie["idpharmacie"])))
  595.                 ->setTypeLivraison($typeLivraison)
  596.                 ->setTypePaiement($paiement)
  597.                 ->setUser($user)
  598.                 ->setToken($token)
  599.                 ->setReference($maxReference)
  600.                 ->setEtatpaiement($etatPaiementDefault)
  601.                 ->setCreatedAt($createdAt)
  602.                 ->setIsRecuperer(false)
  603.                 ->setIsValide($pharmacie["isValideAutomatique"])
  604.                 ->setIsValide($pharmacie["isValideAutomatique"])
  605.                 ->setCode($codeComplet['code'])
  606.                 ->setCodeSecret($codeComplet['secret']);
  607.             $this->em->persist($commande);
  608.             $montantTotal = 0;
  609.             foreach ($paniers as $panier) {
  610.                 if ($pharmacie["idpharmacie"] == $panier->getProduitStockPcie()->getIctuspharmacie()->getId()) {
  611.                     $commandeLine = new IctusCommandeLine();
  612.                     $commandeLine->setQuantite($panier->getQuantite())
  613.                         ->setDesignation($panier->getProduitStockPcie()->getNomproduit())
  614.                         ->setCip7($panier->getProduitStockPcie()->getCip7())
  615.                         ->setCip13($panier->getProduitStockPcie()->getCip13())
  616.                         ->setPrixunitaire($panier->getPrixUnitaire() ?? 0)
  617.                         ->setRemise($panier->getProduitStockPcie()->getRemise())
  618.                         ->setOrdonnance($panier->getOrdonnance())
  619.                         ->setCommande($commande)
  620.                         ->setIsValide($pharmacie["isValideAutomatique"]);
  621.                     $this->em->persist($commandeLine);
  622.                     $montantTotal += $panier->getPrixUnitaire() * $panier->getQuantite();
  623.                 }
  624.             }
  625.             $this->em->flush();
  626.             $nbCommande++;
  627.             //Creation facture et ictocoin au cas ou
  628.             if ($pharmacie["isValideAutomatique"] != null) {
  629.                 $this->montantTotalPaiementEnLigne += $montantTotal;
  630.                 array_push($this->listeCommandePaiementEnLigne, "CMD-" . $commande->getId());
  631.                 $facturePatientService->editPatient($commande);
  632.                 $raison = 'Frais de gestion sur la commande du ' . date("d M Y") . ', Référence :/cmd {{' . $commande->getId() . '}}';
  633.                 $montantDebit = $ictocoinService->montantIctocoin($pharmacie["idpharmacie"], $montantTotal);
  634.                 $debitage = $ictocoinService->debiter($pharmacie["idpharmacie"], $montantDebit, $raison);
  635.                 if ($debitage != true) {
  636.                     $templateMail = 'emails/erreurIctocoin.html.twig';
  637.                     $paramsMail = [
  638.                         'type'    => "Débit",
  639.                         'erreur' => "<p>Commande numéro : " . $commande->getId() . "</p><p>Pharmacie id : " . $pharmacie["idpharmacie"] . "</p><p>Montant : " . $montantDebit . "<sup style='margin-left:5px;'>ICTO</sup></p><p>Raison : " . $raison . "</p>"
  640.                     ];
  641.                     $objectMail = "Erreur mouvement Ictocoin";
  642.                     $mail->sendMail($this->mailerint, $this->mailTechnicien, "noreply@ictuspharma.com", $objectMail, $templateMail, $paramsMail);
  643.                 }
  644.             }
  645.             //Notification pharmacie par mail et mobile
  646.             $user_pcie       = $ictusPharmacieRepo->findOneById(intval($pharmacie["idpharmacie"]))->getUsers()[0];
  647.             $mobileAppareils = $mobileAppareilRepo->findAllToArray($user_pcie);
  648.             $array_cfm_token = array_unique((array_column($mobileAppareils, "cfm_tokem")));
  649.             if (count($array_cfm_token) > 0) {
  650.                 $data = [
  651.                     'id_commande'  => intval($commande->getId()),
  652.                     'id_pharmacie' => intval($pharmacie["idpharmacie"]),
  653.                     'reference'    => $commande->getReference()
  654.                 ];
  655.                 foreach ($array_cfm_token as $tk) {
  656.                     $textNotif = 'Référence commande ICTCMD_MG_' . intval($pharmacie["idpharmacie"]) . '_' . $commande->getReference();
  657.                     $notificationService->sendNotification($tk, 'Nouvelle Commande', $textNotif, $data);
  658.                 }
  659.             }
  660.             $templateMail = 'emails/commandePatient.html.twig';
  661.             $paramsMail = [
  662.                 'nomPatient'    => $user->getLastname(),
  663.                 'prenomPatient' => $user->getFirstname(),
  664.                 'mailPatient'   => $user->getEmail(),
  665.                 'refCommande'   => "ICT_CMD_" . $commande->getId(),
  666.                 'linkCommande'  => 'https://www.pharmadexi.com/ictus/commande/patient/detail/' . $commande->getId()
  667.             ];
  668.             $objectMail = "Commande Ictuspharma : ICT_CMD_" . $commande->getId();
  669.             $mail->sendMail($this->mailerint, $pharmacie["mail"], "commande@ictuspharma.com", $objectMail, $templateMail, $paramsMail);
  670.             //Notification patient
  671.             $templateMail = 'emails/confirmationCommandePatient.html.twig';
  672.             $paramsMail = [
  673.                 'nomPatient'    => $user->getLastname(),
  674.                 'pharmacie'    => $pharmacie,
  675.                 'listes' => $paniers,
  676.                 'refCommande'   => "ICT_CMD_" . $commande->getId()
  677.             ];
  678.             $objectMail = "Commande Ictuspharma : ICT_CMD_" . $commande->getId();
  679.             $mail->sendMail($this->mailerint, $user->getEmail(), "commande@ictuspharma.com", $objectMail, $templateMail, $paramsMail);
  680.         }
  681.         return $nbCommande;
  682.     }
  684.     //$paiementRepository->findAll()
  685.     #[Route('/type-paiement', name: 'api_patient_ictus_panier_paiement', methods: ['GET'])]
  686.     public function recupTypePaiement(IctusTypePaiementRepository $typePaiementRepo): Response
  687.     {
  688.         $typePaiements = $typePaiementRepo->findAll();
  689.         if ($typePaiements) {
  690.             $dataTypePaiements = [];
  692.             if (count($typePaiements) > 0) {
  693.                 foreach ($typePaiements as $tp) {
  694.                     $dataTypePaiements[] = [
  695.                         'paiementId'   => $tp->getId(),
  696.                         'designation'  => $tp->getDesignation()
  697.                     ];
  698.                 }
  700.                 return new JsonResponse([
  701.                     'success'       => 'Informations recuperées avec succès',
  702.                     'dataTypePaiements' => $dataTypePaiements
  703.                 ], Response::HTTP_OK);
  704.             }
  705.             return new JsonResponse(['error' => 'Accun type paiement trouvé'], Response::HTTP_NOT_FOUND);
  706.         }
  707.         return new JsonResponse(['error' => 'Type paiement non trouvé'], Response::HTTP_NOT_FOUND);
  708.     }
  710.     //pour le paiement tierspayant ==> assurance
  711.     //$paiementRepository->findAll()
  712.     #[Route('/assurance', name: 'api_patient_ictus_panier_assurance', methods: ['GET'])]
  713.     public function recupAssurance(
  714.         Request $request,
  715.         AssuranceRepository $assuranceRepo,
  716.         UserRepository $userRepository,
  717.         IctusPanierPatientRepository $panierepo,
  718.         CarteRepository $cateRepo
  719.     ): Response {
  720.         $data = [];
  722.         // Support JSON body + fallback query params
  723.         $content = $request->getContent();
  724.         if (!empty($content)) {
  725.             $decoded = json_decode($content, true);
  726.             if (json_last_error() === JSON_ERROR_NONE && is_array($decoded)) {
  727.                 $data = $decoded;
  728.             }
  729.         }
  730.         if (empty($data)) {
  731.             $data = $request->query->all();
  732.         }
  734.         $patientId = $data['user_id'] ?? $data['patient_id'] ?? null;
  735.         if (empty($patientId) || !is_numeric($patientId)) {
  736.             return new JsonResponse(
  737.                 ['error' => 'Paramètre user_id manquant ou invalide'],
  738.                 Response::HTTP_BAD_REQUEST
  739.             );
  740.         }
  742.         $patient = $userRepository->find((int)$patientId);
  743.         if (!$patient) {
  744.             return new JsonResponse(
  745.                 ['error' => 'Patient non trouvé'],
  746.                 Response::HTTP_NOT_FOUND
  747.             );
  748.         }
  750.         // Récupérer les pharmacies distinctes présentes dans le panier
  751.         $latitudePatient = null;
  752.         $longitudePatient = null;
  753.         $pcieDistinct = $panierepo->getPcieDistinctByPatient($patient->getId(), $latitudePatient, $longitudePatient);
  754.         $pharmacyIds = $this->listIdPharmacie($pcieDistinct);
  756.         if (empty($pharmacyIds)) {
  757.             return new JsonResponse([
  758.                 'success' => 'Aucune pharmacie dans le panier',
  759.                 'dataAssurances' => []
  760.             ], Response::HTTP_OK);
  761.         }
  763.         // 1. Cartes du patient avec leur vrai % de prise en charge
  764.         $cartesMap = $cateRepo->findAssuranceNumeroMapByUser($patient);
  766.         // Index rapide : numéro de carte → prise en charge
  767.         $numeroToPriseEnCharge = [];
  768.         foreach ($cartesMap as $info) {
  769.             $numeroToPriseEnCharge[$info['numero']] = $info['prisencharge'] ?? null;
  770.         }
  772.         // 2. Toutes les assurances acceptées par au moins une pharmacie du panier
  773.         $assurances = $assuranceRepo->getDistinctByPharmacie($pharmacyIds);
  775.         $dataAssurances = [];
  777.         foreach ($assurances as $assurance) {
  778.             $myCartes = [];
  780.             // On parcourt TOUTES les cartes de cette assurance
  781.             foreach ($assurance->getCartes() as $carte) {
  782.                 $isPatientCarte = (
  783.                     $carte
  784.                     && $carte->getUser()
  785.                     && $carte->getUser()->getId() === $patient->getId()
  786.                 );
  788.                 // On affiche la carte SEULEMENT si elle appartient au patient
  789.                 if ($isPatientCarte) {
  790.                     $priseEnCharge = $numeroToPriseEnCharge[$carte->getNumero()] ?? null;
  792.                     $myCartes[] = [
  793.                         'carteId'      => $carte->getId(),
  794.                         'userName'     => $carte->getUser()->getNomComplet(),
  795.                         'numero'       => $carte->getNumero(),
  796.                         'prisencharge' => $priseEnCharge,
  797.                     ];
  798.                 }
  799.             }
  801.             // On ajoute TOUJOURS l'assurance (même si $myCartes est vide)
  802.             $dataAssurances[] = [
  803.                 'assuranceId'  => $assurance->getId(),
  804.                 'designation'  => $assurance->getDesignation(),
  805.                 'adresse'      => $assurance->getAdresse() ?? '',
  806.                 'logo'         => $assurance->getLogo() ?? null,
  807.                 'cartes'       => $myCartes, // [] si le patient n'a pas de carte ici
  808.                 //'hasCarte'     => !empty($myCartes), // Bonus : utile côté front
  809.             ];
  810.         }
  812.         return new JsonResponse([
  813.             'success'        => 'Informations récupérées avec succès',
  814.             'dataAssurances' => $dataAssurances
  815.         ], Response::HTTP_OK);
  816.     }
  818.     /**
  819.     * @param array $pcieDistinct
  820.     * @return int[]
  821.     */
  822.     private function listIdPharmacie(array $pcieDistinct): array
  823.     {
  824.         $ids = [];
  825.         foreach ($pcieDistinct as $pcie) {
  826.             // sécuriser la clé existante
  827.             if (isset($pcie['ictuspharmacie_id']) && is_numeric($pcie['ictuspharmacie_id'])) {
  828.                 $id = (int)$pcie['ictuspharmacie_id'];
  829.                 if (!in_array($id, $ids, true)) {
  830.                     $ids[] = $id;
  831.                 }
  832.             }
  833.         }
  834.         return $ids;
  835.     }
  837.     /**
  838.      * @Route("/panier/addremise", name="app_panier_addremise")
  839.      */
  840.     public function addRemise(Request $request, RemiseUserPharmacieRepository $remiseUserPharmacieRepo, RemiseService $remiseService, IctusPharmacieRepository $ictusPharmacieRepo)
  841.     {
  842.         if ($request->isMethod('POST')) {
  843.             $user = $this->getUser();
  844.             $remise = (int)$request->get('remise');
  845.             $pharmacie = $ictusPharmacieRepo->find($request->get('pharmacie'));
  846.             if ($remise >= 0 && $remise <= 100) {
  847.                 $remiseUserPharmacie = $remiseUserPharmacieRepo->findOneBy(['user' => $user, 'pharmacie' => $pharmacie]);
  848.                 if ($remiseUserPharmacie) {
  849.                     $isValide = null;
  850.                     if ($remise == $remiseUserPharmacie->getRemise()) {
  851.                         $isValide = 1;
  852.                     }
  853.                     $remiseUserPharmacie->setRemise($remise)->setIsValide($isValide);
  854.                 } else {
  855.                     $remiseUserPharmacie = new RemiseUserPharmacie();
  856.                     $remiseUserPharmacie->setUser($user)
  857.                         ->setRemise($remise)
  858.                         ->setPharmacie($pharmacie)
  859.                         ->setIsValide(null)
  860.                         ->setCreatedAt(new \DateTimeImmutable());
  861.                 }
  862.                 $this->em->persist($remiseUserPharmacie);
  863.                 $this->em->flush();
  864.                 $remise = array(
  865.                     $pharmacie->getId() => $remise
  866.                 );
  867.                 $remiseService->add($remise);
  868.             }
  870.             return new JsonResponse("ok");
  871.         }
  872.     }
  874.     
  875.     private function getRemiseUser($user, $remiseService, $remiseUserPharmacieRepo)
  876.     {
  877.         $remiseUserPharmacie = $remiseUserPharmacieRepo->findByUser($user);
  878.         if ($remiseUserPharmacie) {
  879.             foreach ($remiseUserPharmacie as $remUP) {
  880.                 $remise = array(
  881.                     $remUP->getPharmacie()->getId() => $remUP->getRemise()
  882.                 );
  883.                 $remiseService->add($remise);
  884.             }
  885.         }
  886.     }
  887.     
  888.     #[Route('/paiements-pcie/{id}', name: 'api_patient_ictus_panier_paiemens_pcie', methods: ['GET'])]
  889.     public function recuptypePaiementPcie(IctusPharmacie $ictusPcie): Response
  890.     {
  891.         if ($ictusPcie != null) {
  892.             $paimentsPcies = $ictusPcie->getIctusPaiementPharmacies();
  893.             if (count($paimentsPcies) > 0) {
  894.                 $dataPaiements = [];
  895.                 foreach ($paimentsPcies as $paiement) {
  896.                     $dataPaiements[] = [
  897.                         'paiementID'  => $paiement->getIctusTypePaiement()->getId(),
  898.                         'designation' => $paiement->getIctusTypePaiement()->getDesignation()
  899.                     ];
  900.                 }
  902.                 return new JsonResponse([
  903.                     'success'           => 'Informations recuperées avec succès',
  904.                     'dataTypePaiements' => $dataPaiements
  905.                 ], Response::HTTP_OK);
  906.             }
  907.         }
  909.         return new JsonResponse(['error' => 'Pharmacie non trouvé'], Response::HTTP_NOT_FOUND);
  910.     }
  912.     #[Route('/somme-total/{id}', name: 'api_patient_ictus_panier_somme_total', methods: ['GET'])]
  913.     public function sommeTotal(User $user, IctusPanierPatientRepository $panierRepo): Response
  914.     {
  915.         if ($user != null) {
  916.             $monPaniers = $panierRepo->findBy(['user' => $user]);
  917.             if (count($monPaniers) > 0) {
  918.                 $sommePanier = 0.0;
  919.                 foreach ($monPaniers as $p) {
  920.                     $sommePanier += ($p->getTotal());
  921.                 }
  923.                 return new JsonResponse([
  924.                     'success'           => 'Informations recuperées avec succès',
  925.                     'sommePanier' => $sommePanier
  926.                 ], Response::HTTP_OK);
  927.             }
  928.         }
  930.         return new JsonResponse(['error' => 'Utilisateur non trouvé'], Response::HTTP_NOT_FOUND);
  931.     }
  933.     //Step 3 dans paiement avant validation cmd
  934.     #[Route('/ajout-assurance', name: 'app_panier_add_assurance', methods: ['POST'])]
  935.     public function addAssurance(
  936.         Request $request,
  937.         EntityManagerInterface $em,
  938.         UserRepository $userRepo,
  939.         AssuranceRepository $assuranceRepo,
  940.         CarteRepository $carteRepo
  941.     ): Response {
  942.         $data = json_decode($request->getContent(), true);
  944.         // Si JSON invalide ou vide
  945.         if (!$data || !is_array($data)) {
  946.             return new JsonResponse([
  947.                 'error' => true,
  948.                 'message' => 'Données JSON invalides'
  949.             ], Response::HTTP_BAD_REQUEST);
  950.         }
  952.         if (empty($data['userId']) || empty($data['assuranceId']) || !isset($data['numeroCarte'])) {
  953.             return new JsonResponse([
  954.                 'error' => true,
  955.                 'message' => 'userId, assuranceId et numeroCarte sont obligatoires'
  956.             ], Response::HTTP_BAD_REQUEST);
  957.         }
  959.         $user = $userRepo->find($data['userId']);
  960.         $assurance = $assuranceRepo->find($data['assuranceId']);
  962.         if (!$user) {
  963.             return new JsonResponse(['error' => true, 'message' => 'Utilisateur non trouvé'], 404);
  964.         }
  965.         if (!$assurance && $data['assuranceId'] == 0) {
  966.             return new JsonResponse(['error' => true, 'message' => 'Assurance non trouvée'], 404);
  967.         }
  969.         $carte = $carteRepo->findOneBy(['user' => $user, 'assurance' => $assurance]);
  971.         if ($carte) {
  972.             // Mise à jour du numéro
  973.             $carte->setNumero((string)$data['numeroCarte']);
  974.         } else {
  975.             // Création nouvelle carte
  976.             $carte = new Carte();
  977.             $carte->setUser($user)
  978.                 ->setAssurance($assurance)
  979.                 ->setNumero((string)$data['numeroCarte']);
  980.         }
  982.         $em->persist($carte);
  983.         $em->flush();
  985.         return new JsonResponse([
  986.             'error' => false,
  987.             'message' => 'Carte sauvegardée avec succès',
  988.             'data' => [
  989.                 'assuranceId' => $assurance->getId(),
  990.                 'designation' => $assurance->getDesignation(),
  991.                 'numeroCarte' => $carte->getNumero()
  992.             ]
  993.         ], Response::HTTP_OK);
  994.     }
  996.     function getUserIpAddr()
  997.     {
  998.         if (!empty($_SERVER['HTTP_CLIENT_IP'])) {
  999.             // IP address from shared internet
  1000.             $ip = $_SERVER['HTTP_CLIENT_IP'];
  1001.         } elseif (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
  1002.             // IP address passed from proxy
  1003.             $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
  1004.         } else {
  1005.             // Regular IP address
  1006.             $ip = $_SERVER['REMOTE_ADDR'];
  1007.         }
  1008.         return $ip;
  1009.     }
  1011.     public function montantWithFrai($val)
  1012.     {
  1013.         $pourcentage = 0;
  1014.         switch (true) {
  1015.             case ($val > 0 && $val <= 10000):
  1016.                 $pourcentage = 2;
  1017.                 break;
  1018.             case ($val > 10000 && $val <= 20000):
  1019.                 $pourcentage = 1.75;
  1020.                 break;
  1021.             case ($val > 20000 && $val <= 30000):
  1022.                 $pourcentage = 1.25;
  1023.                 break;
  1024.             case ($val > 30000 && $val <= 50000):
  1025.                 $pourcentage = 1.5;
  1026.                 break;
  1027.             case ($val > 50000 && $val <= 80000):
  1028.                 $pourcentage = 1.75;
  1029.                 break;
  1030.             case ($val > 80000 && $val <= 120000):
  1031.                 $pourcentage = 1.5;
  1032.                 break;
  1033.             case ($val > 120000 && $val <= 170000):
  1034.                 $pourcentage = 1.40;
  1035.                 break;
  1036.             case ($val > 170000):
  1037.                 $pourcentage = 1.30;
  1038.                 break;
  1039.             default:
  1040.                 $pourcentage = 0;
  1041.                 break;
  1042.         }
  1043.         return $val + ($val * $pourcentage / 100);
  1044.     }
  1045. }