src/Controller/Api/InterventionPlace/InterventionPlaceHierarchyController.php line 96

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Api\InterventionPlace;
  5. use App\Dto\InterventionPlace;
  6. use App\Dto\InterventionPlaceKpi;
  7. use App\Service\HierarchyService;
  8. use App\Repository\UserRepository;
  9. use App\Repository\CityGeolocRepository;
  10. use App\Repository\NmdAdresseRepository;
  11. use Doctrine\ORM\EntityManagerInterface;
  12. use Symfony\Component\HttpFoundation\Request;
  13. use Symfony\Component\Routing\Annotation\Route;
  14. use Symfony\Component\HttpKernel\KernelInterface;
  15. use Symfony\Component\HttpFoundation\JsonResponse;
  16. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  17. use App\Port\NmdAdressePort;
  18. use Symfony\Component\HttpFoundation\Response;
  20. class InterventionPlaceHierarchyController extends AbstractController
  21. {
  22.     private NmdAdressePort $adresseRepository;
  23.     private $cityGeolocRepository;
  24.     private $entityManager;
  25.     private $userRepository;
  27.     public function __construct(
  28.         NmdAdressePort $adresseRepository,
  29.         CityGeolocRepository $cityGeolocRepository,
  30.         EntityManagerInterface $entityManager,
  31.         UserRepository $userRepository
  32.     ) {
  33.         $this->adresseRepository = $adresseRepository;
  34.         $this->cityGeolocRepository = $cityGeolocRepository;
  35.         $this->entityManager = $entityManager;
  36.         $this->userRepository = $userRepository;
  37.     }
  39.     public function __invoke(int $cpv,  Request $request): JsonResponse
  40.     {
  41.         $codeCluster = $request->query->get('codeCluster', null);
  42.         $codeInsee = $request->query->get('codeInsee', null);
  43.         $page = $request->query->get('page', 1);
  44.         $fttb = $request->query->get('fttb');
  45.         $adsl = $request->query->get('adsl');
  46.         $mobMono = $request->query->get('mobMono');
  47.         $mobMultiThd = $request->query->get('mobMultiThd');
  48.         $mobMultiAdsl = $request->query->get('mobMultiAdsl');
  49.         $thd = $request->query->get('thd');
  50.         $limit = 25;
  51.         $result = $this->adresseRepository->getInterventionPlaceKpiByStreet(
  52.             $cpv,
  53.             $codeCluster,
  54.             $codeInsee,
  55.             $page,
  56.             $limit,
  57.             $fttb,
  58.             $adsl,
  59.             $mobMono,
  60.             $mobMultiThd,
  61.             $mobMultiAdsl,
  62.             $thd
  63.         );
  65.         if (empty($result)) {
  66.             return new JsonResponse(
  67.                 [],
  68.                 200
  69.             );
  70.         }
  71.         $parameters = [
  72.             'cpv' => $cpv,
  73.             'code_cluster' => null
  74.         ];
  75.         $finalResult = $this->generateResult($result, $parameters);
  76.         if ($codeCluster != null) {
  77.             $parameters = [
  78.                 'code_cluster' => $codeCluster,
  79.                 'cod_insee' => null
  80.             ];
  81.             $finalResult = $this->generateResult($result, $parameters);
  82.         }
  83.         if ($codeInsee != null) {
  84.             $parameters = [
  85.                 'cod_insee' => $codeInsee,
  86.                 'nom_voie' => null
  87.             ];
  88.             $finalResult = $this->generateResult($result, $parameters);
  89.         }
  91.         return new JsonResponse($finalResult, 200);
  92.     }
  93.     /**
  94.      * @Route("/api/interventions-places-details", name="api_get_interventions_places_details", methods={"GET"})
  95.      */
  96.     public function getInterventionPlacesDetails(Request $request): Response
  97.     {
  98.         $cpv = $request->query->get('cpv', null);
  99.         $codeCluster = $request->query->get('codeCluster', null);
  100.         $codeInsee = $request->query->get('codeInsee', null);
  101.         $page = $request->query->get('page', 1);
  102.         $fttb = $request->query->get('fttb','no');
  103.         $adsl = $request->query->get('adsl','no');
  104.         $mobMono = $request->query->get('mobMono','no');
  105.         $mobMultiThd = $request->query->get('mobMultiThd','no');
  106.         $mobMultiAdsl = $request->query->get('mobMultiAdsl','no');
  107.         $thd = $request->query->get('thd','no');
  108.         $exportCsv = (int) $request->query->get('exportCsv', 0);
  110.        
  112.         $result = $this->adresseRepository->getInterventionPlaceDetails(
  113.             $cpv,
  114.             $codeCluster,
  115.             $codeInsee,
  116.             $fttb,
  117.             $adsl,
  118.             $mobMono,
  119.             $mobMultiThd,
  120.             $mobMultiAdsl,
  121.             $thd
  122.         );
  123.         if (empty($result)) {
  124.             return new JsonResponse([], 200);
  125.         }
  127.         // Si on demande un CSV → téléchargement
  128.         if ($exportCsv === 1) {
  130.             // Création du flux CSV
  131.             $handle = fopen('php://temp', 'r+');
  133.             // Ajout de l'en-tête
  134.             fputcsv($handle, array_keys($result[0]), ';');
  136.             // Ajout des données
  137.             foreach ($result as $row) {
  138.                 fputcsv($handle, $row, ';');
  139.             }
  141.             rewind($handle);
  142.             $content = stream_get_contents($handle);
  143.             fclose($handle);
  145.             // Réponse CSV → téléchargement
  146.             return new Response(
  147.                 $content,
  148.                 200,
  149.                 [
  150.                     'Content-Type' => 'text/csv; charset=utf-8',
  151.                     'Content-Disposition' => 'attachment; filename="prises_parc_details.csv"',
  152.                 ]
  153.             );
  154.         }
  156.         // Sinon JSON normal
  157.         return new JsonResponse($result, 200);
  158.     }
  160.     public function generateResult($result, $parameters)
  161.     {
  162.         // Extraire les clés primaires et secondaires directement
  163.         $primaryKey = key($parameters);
  164.         $secondaryKey = key(array_slice($parameters, 1, 1, true)); // Récupérer la 2ème clé
  166.         // Structure de base pour le résultat final
  167.         $finalResult = [
  168.             $primaryKey => $parameters[$primaryKey],
  169.             $secondaryKey => []
  170.         ];
  172.         // Champs supplémentaires basés sur les clés primaires
  173.         $additionalFields = [
  174.             'cpv' => [],
  175.             'code_cluster' => ['ville'],
  176.             'cod_insee' => ['ville', 'nom_voie']
  177.         ];
  179.         // Parcourir chaque ligne du résultat
  180.         foreach ($result as $row) {
  181.             $data = [
  182.                 "nb_fyr_fttb" => (int)$row["nb_fyr_fttb"],
  183.                 "nb_fyr_adsl" => (int)$row["nb_fyr_adsl"],
  184.                 "nb_fyr_mob_mono" => (int)$row["nb_fyr_mob_mono"],
  185.                 "nb_fyr_mob_multi_thd" => (int)$row["nb_fyr_mob_multi_thd"],
  186.                 "nb_fyr_mob_multi_adsl" => (int)$row["nb_fyr_mob_multi_adsl"],
  187.                 "nb_fyr_thd" => (int)$row["nb_fyr_thd"]
  188.             ];
  190.             // Ajouter les champs spécifiques selon la clé primaire
  191.             if (isset($additionalFields[$primaryKey])) {
  192.                 foreach ($additionalFields[$primaryKey] as $field) {
  193.                     $data[$field] = $row[$field];
  194.                 }
  195.             }
  197.             // Si la clé primaire est 'code_cluster', ajouter lbl_cluster à la structure
  198.             if ($primaryKey === 'code_cluster') {
  199.                 $lblCluster = $row["lbl_cluster"]; // Récupérer la valeur de lbl_cluster
  200.                 $secondaryValue = $row[$secondaryKey];
  202.                 // Récupérer le polygon pour ce cod_insee (valeur secondaire)
  203.                 $polygon = $this->getPolygonsByCodeInsee($secondaryValue);
  204.                 $formattedPolygon = null;
  206.                 if ($polygon) {
  207.                     // Décoder la chaîne JSON échappée
  208.                     $polygonDecoded = json_decode($polygon, true);
  210.                     // Vérifier si le décodage a réussi
  211.                     if (json_last_error() === JSON_ERROR_NONE) {
  212.                         // Extraire 'type' et 'coordinates'
  213.                         $polygonType = $polygonDecoded['type'] ?? null;
  214.                         $polygonCoordinates = $polygonDecoded['coordinates'] ?? null;
  216.                         // Réécrire proprement les données (ici, nous nous concentrons sur 'type' et 'coordinates')
  217.                         $formattedPolygon = [
  218.                             'type' => $polygonType,
  219.                             'coordinates' => $polygonCoordinates
  220.                         ];
  221.                     }
  222.                 }
  224.                 // Ajouter les autres données sous la clé secondaire
  225.                 $finalResult[$secondaryKey][] = [
  226.                     $secondaryValue => [
  227.                         "data" => $data,
  228.                         "polygon" => $formattedPolygon // Ajouter le polygon formaté
  229.                     ]
  230.                 ];
  232.                 // Réorganiser lbl_cluster à la deuxième position dans la structure
  233.                 $finalResult = $this->reorderResult($finalResult, $lblCluster);
  234.             } else {
  235.                 // Par défaut, lbl_cluster reste dans 'data'
  236.                 $data["lbl_cluster"] = $row["lbl_cluster"];
  237.                 $finalResult[$secondaryKey][] = [
  238.                     $row[$secondaryKey] => ["data" => $data]
  239.                 ];
  240.             }
  241.         }
  243.         return $finalResult;
  244.     }
  247.     // Fonction pour réorganiser lbl_cluster à la 2ème position
  248.     private function reorderResult($finalResult, $lblCluster)
  249.     {
  250.         // Réorganiser lbl_cluster à la 2ème position
  251.         $temp = [
  252.             'code_cluster' => $finalResult['code_cluster'], // Conserver la clé primaire
  253.             'lbl_cluster' => $lblCluster, // Ajouter lbl_cluster à la 2ème position
  254.             'cod_insee' => $finalResult['cod_insee'], // Conserver le reste des éléments
  255.         ];
  257.         return $temp;
  258.     }
  262.     /**
  263.      * @Route("/api/interventions-places-kpi-json/{cpv}/{codeCluster}", name="api_get_clusters_details_by_cpv_and_code_cluster", methods={"GET"})
  264.      */
  265.     public function getInterventionPlaceKpiFromJson(int $cpv, string $codeCluster, KernelInterface $kernel, Request $request): JsonResponse
  266.     {
  267.         $codeInsee = null;
  268.         if ($request->query->get('codeInsee') != null) {
  269.             $codeInsee = $request->query->get('codeInsee');
  270.         }
  272.         $baseDir = $kernel->getProjectDir() . "/fileAttached/prisesParcJson/{$cpv}/";
  273.         if ($codeInsee !== null) {
  274.             $filePath = "$baseDir/migrableKpiByStreet/{$codeCluster}/{$codeInsee}.json";
  275.         } else {
  276.             $filePath = "$baseDir/migrableKpiByCodeInsee/{$codeCluster}.json";
  277.         }
  278.         if (!file_exists($filePath)) {
  279.             return new JsonResponse(['error' => 'Fichier non trouvé'], 404);
  280.         }
  282.         $jsonData = json_decode(file_get_contents($filePath), true);
  284.         if ($jsonData === null) {
  285.             return new JsonResponse(['error' => 'Erreur de lecture du JSON'], 500);
  286.         }
  288.         return new JsonResponse($jsonData, 200);
  289.     }
  291.     private function getPolygonsByCodeInsee($codeInsee)
  292.     {
  293.         $geoCity = $this->cityGeolocRepository->findOneBy(['codeInsee' => $codeInsee]);
  294.         return  $geoCity->getPolygon() ?? null;
  295.     }
  298.     /**
  299.      * @Route("/api/interventions-places-hierarchy/{cpv}/{userId}", name="api_get_intervention_places_hierarchy_from_json", methods={"GET"})
  300.      */
  301.     public function getInterventionPlaceHierarchyFromJson(
  302.         int $cpv,
  303.         $userId,
  304.         KernelInterface $kernel,
  305.         Request $request,
  306.         HierarchyService $hierarchyService,
  307.         UserRepository $userRepository
  308.     ): JsonResponse {
  309.         $userId = $request->query->get('userId', $userId);
  310.         $codeCluster = $request->query->get('codeCluster', null);
  311.         $codeInsee = $request->query->get('codeInsee', null);
  313.         $user = $userRepository->findOneBy(['id' => $userId]);
  314.         if (!$user) {
  315.             return new JsonResponse(['error' => 'Utilisateur non trouvé'], 404);
  316.         }
  318.         $projectDir = $kernel->getProjectDir();
  319.         $baseDir = "$projectDir/fileAttached/geo_map/prises_parc/{$cpv}";
  321.         $jsonData = $this->loadHierarchyData($user, $userId, $baseDir, $hierarchyService);
  323.         if (empty($jsonData)) {
  324.             return new JsonResponse(['error' => 'Fichier non trouvé ou vide'], 404);
  325.         }
  326.         #Filtres
  327.         if ($codeCluster) {
  328.             $cluster = array_filter($jsonData, function ($c) use ($codeCluster) {
  329.                 if ($c['clusterCode'] == $codeCluster) {
  330.                     return $c;
  331.                 }
  332.             });
  334.             if (empty($cluster)) {
  335.                 return new JsonResponse([], 200);
  336.             }
  338.             if ($codeInsee) {
  339.                 $ville = array_filter(array_values($cluster)[0]['villes'], function ($v) use ($codeInsee) {
  340.                     if ($v['cod_insee'] == $codeInsee) {
  341.                         return $v;
  342.                     }
  343.                 });
  345.                 if (empty($ville)) {
  346.                     return new JsonResponse([], 200);
  347.                 }
  349.                 return new JsonResponse(array_values($ville), 200);
  350.             }
  352.             return new JsonResponse(array_values($cluster)[0], 200);
  353.         }
  355.         return new JsonResponse($jsonData, 200);
  356.     }
  358.     /**
  359.      * Charge les données hiérarchiques (fusionnées ou non selon le rôle)
  360.      */
  361.     private function loadHierarchyData($user, int $userId, string $baseDir, HierarchyService $hierarchyService): array
  362.     {
  363.         if (in_array('ROLE_MANAGER', $user->getRoles()) || in_array('ROLE_DIRECTOR', $user->getRoles())) {
  364.             return $this->loadAndMergeDistributedFiles($userId, $baseDir, $hierarchyService);
  365.         }
  367.         $filePath = "{$baseDir}/hiearchy_prises_parc_cluster_ville.json";
  368.         if (!file_exists($filePath)) {
  369.             return [];
  370.         }
  372.         $jsonData = json_decode(file_get_contents($filePath), true);
  373.         return is_array($jsonData) ? $jsonData : [];
  374.     }
  376.     /**
  377.      * Fusionne les fichiers distribués des utilisateurs hiérarchiques
  378.      */
  379.     private function loadAndMergeDistributedFiles(int $userId, string $baseDir, HierarchyService $hierarchyService): array
  380.     {
  381.         $mergedData = [];
  383.         $userIds = array_merge(
  384.             [$userId],
  385.             array_map(fn($p) => (int) $p['id'], $hierarchyService->getHierarchyDescendante($userId))
  386.         );
  388.         foreach ($userIds as $uid) {
  389.             $filePath = "{$baseDir}/distributed_by_user/{$uid}/distributed_hierarchy_cluster_city.json";
  391.             if (!file_exists($filePath)) {
  392.                 continue;
  393.             }
  395.             $data = json_decode(file_get_contents($filePath), true);
  396.             if (!is_array($data)) {
  397.                 continue;
  398.             }
  400.             foreach ($data as $cluster) {
  401.                 $clusterKey = $cluster['clusterCode'];
  403.                 if (!isset($mergedData[$clusterKey])) {
  404.                     $mergedData[$clusterKey] = $cluster;
  405.                 } else {
  406.                     $mergedData[$clusterKey]['total_prises'] += $cluster['total_prises'];
  408.                     foreach ($cluster['villes'] as $ville) {
  409.                         $insee = $ville['cod_insee'];
  410.                         $villeExistante = false;
  412.                         foreach ($mergedData[$clusterKey]['villes'] as &$v) {
  413.                             if ($v['cod_insee'] === $insee) {
  414.                                 $v['total_prises'] += $ville['total_prises'];
  415.                                 $villeExistante = true;
  416.                                 break;
  417.                             }
  418.                         }
  420.                         if (!$villeExistante) {
  421.                             $mergedData[$clusterKey]['villes'][] = $ville;
  422.                         }
  423.                     }
  424.                 }
  425.             }
  426.         }
  428.         return array_values($mergedData);
  429.     }
  433.     /**
  434.      * @Route("/api/interventions-places-streets/{cpv}/{codeCluster}/{codeInsee}", name="api_get_intervention_places_voies_from_json", methods={"GET"})
  435.      */
  436.     public function getInterventionPlaceVoiesFromJson(
  437.         int $cpv,
  438.         string $codeCluster,
  439.         $codeInsee,
  440.         KernelInterface $kernel,
  441.         HierarchyService $hierarchyService,
  442.         UserRepository $userRepository,
  443.         Request $request
  444.     ): JsonResponse {
  446.         $userId = $request->query->get('userId', null);
  447.         $user = null;
  448.         if ($userId) {
  449.             $user = $userRepository->findOneBy(['id' => $userId]);
  450.             if (!$user) {
  451.                 return new JsonResponse(['error' => 'Utilisateur non trouvé'], 404);
  452.             }
  453.         }
  455.         $projectDir = $kernel->getProjectDir();
  456.         $baseDir = "$projectDir/fileAttached/geo_map/prises_parc/{$cpv}";
  458.         $jsonData = $this->loadVoiesData($user, $userId, $baseDir, $codeCluster, $codeInsee, $hierarchyService);
  460.         if (empty($jsonData)) {
  461.             return new JsonResponse(['error' => 'Fichier non trouvé ou vide'], 404);
  462.         }
  464.         return new JsonResponse($jsonData, 200);
  465.     }
  469.     /**
  470.      * Retourne les données de voies en les fusionnant si nécessaire
  471.      */
  472.     private function loadVoiesData($user,  $userId, string $baseDir, string $codeCluster, string $codeInsee, HierarchyService $hierarchyService): array
  473.     {
  474.         $merged = [];
  475.         if ($user) {
  476.             if (in_array('ROLE_MANAGER', $user->getRoles()) || in_array('ROLE_DIRECTOR', $user->getRoles())) {
  477.                 $userIds = array_merge(
  478.                     [$userId],
  479.                     array_map(fn($u) => (int) $u['id'], $hierarchyService->getHierarchyDescendante($userId))
  480.                 );
  482.                 foreach ($userIds as $uid) {
  483.                     $filePath = "{$baseDir}/distributed_by_user/voies/{$uid}/{$codeCluster}/{$codeInsee}/liste_voies.json";
  484.                     if (!file_exists($filePath)) {
  485.                         continue;
  486.                     }
  488.                     $data = json_decode(file_get_contents($filePath), true);
  489.                     if (!is_array($data)) {
  490.                         continue;
  491.                     }
  493.                     $merged = $this->mergeVoiesData($merged, $data);
  494.                 }
  496.                 return array_values($merged); // Réindexé
  497.             }
  498.         }
  500.         $filePath = "{$baseDir}/voies/{$codeCluster}/{$codeInsee}/liste_voies.json";
  501.         if (!file_exists($filePath)) {
  502.             return [];
  503.         }
  505.         $jsonData = json_decode(file_get_contents($filePath), true);
  506.         return is_array($jsonData) ? $jsonData : [];
  507.     }
  509.     /**
  510.      * Fusionne plusieurs tableaux de voies selon `nom_voie + code_iris`
  511.      */
  512.     private function mergeVoiesData(array $merged, array $data): array
  513.     {
  514.         foreach ($data as $voie) {
  515.             $key = $voie['nom_voie'] . '|' . $voie['code_iris'];
  517.             if (!isset($merged[$key])) {
  518.                 $merged[$key] = $voie;
  519.             } else {
  520.                 $merged[$key]['total_prises'] += $voie['total_prises'];
  522.                 // Fusionner les numéros de voie (data)
  523.                 $existingNums = array_column($merged[$key]['data'], 'numr_voie');
  524.                 foreach ($voie['data'] as $num) {
  525.                     if (!in_array($num['numr_voie'], $existingNums)) {
  526.                         $merged[$key]['data'][] = $num;
  527.                     }
  528.                 }
  529.             }
  530.         }
  532.         return $merged;
  533.     }
  537.     /**
  538.      * @Route("/api/interventions-places-hierarchy-migrable/{cpv}", name="api_get_intervention_places_hierarchy_migrable_from_json", methods={"GET"})
  539.      */
  540.     public function getInterventionPlaceHierarchyMigrableFromJson(int $cpv, KernelInterface $kernel, Request $request): JsonResponse
  541.     {
  542.         $userId = $request->query->get('userId', null);
  543.         $codeCluster = $request->query->get('codeCluster', null);
  544.         $codeInsee = $request->query->get('codeInsee', null);
  545.         if ($userId) {
  546.             $filePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_parc/{$cpv}/{$userId}/migrables/hiearchy_prises_parc_cluster_ville_migrable.json";
  547.         }
  548.         $filePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_parc/{$cpv}/migrables/hiearchy_prises_parc_cluster_ville_migrable.json";
  550.         if (!file_exists($filePath)) {
  551.             return new JsonResponse(['error' => 'Fichier non trouvé'], 404);
  552.         }
  554.         // Lire et décoder le fichier JSON
  555.         $jsonData = json_decode(file_get_contents($filePath), true);
  557.         if ($jsonData === null) {
  558.             return new JsonResponse(['error' => 'Erreur de lecture du JSON'], 404);
  559.         }
  560.         // Si codeCluster est fourni, rechercher le cluster correspondant
  561.         if ($codeCluster) {
  562.             $cluster = array_filter($jsonData, function ($c) use ($codeCluster) {
  563.                 return $c['clusterCode'] === $codeCluster;
  564.             });
  566.             if (empty($cluster)) {
  567.                 return new JsonResponse([], 200);
  568.             }
  570.             // Si codeInsee est fourni, rechercher la ville correspondante
  571.             if ($codeInsee) {
  572.                 $ville = array_filter(array_values($cluster)[0]['villes'], function ($v) use ($codeInsee) {
  573.                     return $v['cod_insee'] == $codeInsee;
  574.                 });
  576.                 if (empty($ville)) {
  577.                     return new JsonResponse([], 200);
  578.                 }
  580.                 // Retourner seulement l’objet, pas un tableau avec un index
  581.                 return new JsonResponse(array_values($ville)[0], 200);
  582.             }
  585.             return new JsonResponse(array_values($cluster)[0], 200);
  586.         }
  587.         return new JsonResponse($jsonData, 200);
  588.     }
  590.     /**
  591.      * @Route("/api/interventions-places-streets-migrable/{cpv}/{codeCluster}/{codeInsee}", name="api_get_intervention_places_voies_migrable_from_json", methods={"GET"})
  592.      */
  593.     public function getInterventionPlaceVoiesMigrableFromJson(int $cpv, string $codeCluster, $codeInsee, KernelInterface $kernel, Request $request): JsonResponse
  594.     {
  595.         $userId = $request->query->get('userId', null);
  596.         $nomVoie = $request->query->get('nomVoie', null);
  597.         if ($userId) {
  598.             $filePath = $kernel->getProjectDir() . "/fileAttached/distribution/prises_parc/{$cpv}/{$userId}/migrables/voies/{$codeCluster}/{$codeInsee}/liste_voies_migrable.json";
  599.         }
  600.         $filePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_parc/{$cpv}/migrables/voies/{$codeCluster}/{$codeInsee}/liste_voies_migrable.json";
  602.         if (!file_exists($filePath)) {
  603.             return new JsonResponse(['error' => 'Fichier non trouvé'], 404);
  604.         }
  606.         // Lire et décoder le fichier JSON
  607.         $jsonData = json_decode(file_get_contents($filePath), true);
  609.         if ($jsonData === null) {
  610.             return new JsonResponse(['error' => 'Erreur de lecture du JSON'], 404);
  611.         }
  613.         // Filtrer par nomVoie si fourni
  614.         if ($nomVoie !== null && is_array($jsonData)) {
  615.             $jsonData = array_filter($jsonData, function ($voie) use ($nomVoie) {
  616.                 return isset($voie['nom_voie']) && strtolower($voie['nom_voie']) === strtolower($nomVoie);
  617.             });
  618.             $jsonData = array_values($jsonData); // Réindexer le tableau
  619.         }
  621.         // Renvoi des données paginées
  622.         return new JsonResponse($jsonData, 200);
  623.     }
  625.     /**
  626.      * @Route("/api/interventions-places-arret-cu/{cpv}", name="api_get_intervention_places_arret_cu_from_json", methods={"GET"})
  627.      */
  628.     public function getArretCufromJson(int $cpv, KernelInterface $kernel, Request $request): JsonResponse
  629.     {
  630.         // Récupérer les paramètres de la requête
  631.         $userId = $request->query->get('userId', null);
  632.         $annee = $request->query->get('annee', null);
  633.         $mois = $request->query->get('mois', null);
  634.         $codeCluster = $request->query->get('codeCluster', null);
  635.         $codeInsee = $request->query->get('codeInsee', null);
  637.         // Définir le chemin du fichier JSON
  638.         if ($userId) {
  639.             $filePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_parc/{$cpv}/{$userId}/arret_cu/arret_cu.json";
  640.         } else {
  641.             $filePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_parc/{$cpv}/arret_cu/arret_cu.json";
  642.         }
  644.         // Vérifier si le fichier existe
  645.         if (!file_exists($filePath)) {
  646.             return new JsonResponse([], 200);
  647.         }
  649.         // Lire et décoder le fichier JSON
  650.         $jsonData = json_decode(file_get_contents($filePath), true);
  652.         // Vérifier si la lecture du JSON a échoué
  653.         if ($jsonData === null) {
  654.             return new JsonResponse([], 200);
  655.         }
  656.         if ($annee !== null && isset($jsonData[$annee])) {
  657.             $jsonDataAnnee = $jsonData[$annee];
  658.             // Check if the month is set and filter by month
  659.             if ($mois !== null && isset($jsonDataAnnee[$mois])) {
  660.                 $jsonDataMois = $jsonDataAnnee[$mois];
  662.                 // Check if the cluster code is set and filter by cluster
  663.                 if ($codeCluster !== null && isset($jsonDataMois['clusters'])) {
  664.                     $clusterData = null;
  665.                     foreach ($jsonDataMois['clusters'] as $c) {
  666.                         if ($c['code_cluster'] == $codeCluster) {
  667.                             $clusterData = $c;
  668.                             break;
  669.                         }
  670.                     }
  671.                     if ($codeInsee !== null && isset($clusterData['villes'])) {
  672.                         $villeData = null;
  673.                         foreach ($clusterData['villes'] as $villeItem) {
  674.                             if ($villeItem['cod_insee'] == $codeInsee) {
  675.                                 $villeData = $villeItem;
  676.                                 break;
  677.                             }
  678.                         }
  680.                         return new JsonResponse($villeData ?? [], 200);
  681.                     }
  682.                     return new JsonResponse($clusterData ?? [], 200);
  683.                 }
  684.                 // After filtering, return the data
  685.                 return new JsonResponse($jsonDataMois ?? [], 200);
  686.             } else {
  687.                 return new JsonResponse(['error' => 'Mois non défini'], 200);
  688.             }
  690.             // If no month is specified, return the data for the year
  691.             return new JsonResponse($jsonDataAnnee ?? [], 200);
  692.         }
  693.         // Renvoi des données filtrées sous forme de réponse JSON
  694.         return new JsonResponse($jsonData, 200);
  695.     }
  698.     /**
  699.      * @Route("/api/interventions-places-arret-cu-v2/{cpv}", name="api_get_intervention_places_arret_cu_from_json_v2", methods={"GET"})
  700.      */
  701.     public function getInterventionPlaceArretCuFromJsonV2(int $cpv, KernelInterface $kernel, Request $request): JsonResponse
  702.     {
  703.         // Récupérer les paramètres de la requête
  704.         $userId = $request->query->get('userId', null);
  705.         $codeCluster = $request->query->get('codeCluster', null);
  706.         $codeInsee = $request->query->get('codeInsee', null);
  708.         // Définir le chemin du fichier JSON
  709.         if ($userId) {
  710.             $filePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_parc/{$cpv}/{$userId}/arret_cu/arret_cu.json";
  711.         } else {
  712.             $filePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_parc/{$cpv}/arret_cu_v2/arret_cu.json";
  713.         }
  715.         // Vérifier si le fichier existe
  716.         if (!file_exists($filePath)) {
  717.             return new JsonResponse([], 200);
  718.         }
  720.         // Lire et décoder le fichier JSON
  721.         $jsonData = json_decode(file_get_contents($filePath), true);
  723.         // Vérifier si la lecture du JSON a échoué
  724.         if ($jsonData === null) {
  725.             return new JsonResponse([], 200);
  726.         }
  727.         if ($codeCluster) {
  728.             $cluster = array_filter($jsonData, function ($c) use ($codeCluster) {
  729.                 if ($c['code_cluster'] == $codeCluster) {
  730.                     return $c;
  731.                 }
  732.             });
  733.             if (count($cluster) < 1) {
  734.                 return new JsonResponse([], 200);
  735.             }
  737.             // Si codeInsee est fourni, rechercher la ville correspondante
  738.             if ($codeInsee) {
  739.                 $ville = array_filter(array_values($cluster)[0]['villes'], function ($v) use ($codeInsee) {
  740.                     if ($v['cod_insee'] == $codeInsee) {
  741.                         return $v;
  742.                     }
  743.                 });
  744.                 if (count($ville) < 1) {
  745.                     return new JsonResponse([], 200);
  746.                 }
  747.                 return new JsonResponse(array_values($ville), 200);
  748.             }
  750.             return new JsonResponse(array_values($cluster)[0], 200);
  751.         }
  752.         // Renvoi des données filtrées sous forme de réponse JSON
  753.         return new JsonResponse($jsonData, 200);
  754.     }
  755.     /**
  756.      * @Route("/api/interventions-places-arret-cu-streets/{cpv}/{codeCluster}/{codeInsee}", name="api_get_intervention_places_arret_cu_streets_from_json", methods={"GET"})
  757.      */
  758.     public function getInterventionPlaceArretCuStreetsFromJson(int $cpv, string $codeCluster, string $codeInsee, KernelInterface $kernel, Request $request): JsonResponse
  759.     {
  760.         $userId = $request->query->get('userId', null);
  761.         $annee = $request->query->get('annee', null);
  762.         $mois = $request->query->get('mois', null);
  763.         if ($userId) {
  764.             $filePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_parc/{$cpv}/{$userId}/arret_cu/voies/{$codeCluster}/{$codeInsee}/liste_voies.json";
  765.         }
  766.         $filePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_parc/{$cpv}/arret_cu/voies/{$codeCluster}/{$codeInsee}/liste_voies.json";
  768.         if (!file_exists($filePath)) {
  769.             return new JsonResponse([], 200);
  770.         }
  772.         // Vérifier si le fichier existe
  773.         if (!file_exists($filePath)) {
  774.             return new JsonResponse([], 200);
  775.         }
  777.         // Lire et décoder le fichier JSON
  778.         $jsonData = json_decode(file_get_contents($filePath), true);
  780.         // Vérifier si la lecture du JSON a échoué
  781.         if ($jsonData === null) {
  782.             return new JsonResponse([], 200);
  783.         }
  784.         if ($annee !== null && isset($jsonData[$annee])) {
  785.             $jsonDataAnnee = $jsonData[$annee];
  786.             // Check if the month is set and filter by month
  787.             if ($mois !== null && isset($jsonDataAnnee[$mois])) {
  788.                 $jsonDataMois = $jsonDataAnnee[$mois];
  789.                 return new JsonResponse($jsonDataMois, 200);
  790.             }
  791.         }
  792.         return new JsonResponse($jsonData, 200);
  793.     }
  794. }