src/Controller/Api/AdresseIncomming/AdresseIncommingHierarchyController.php line 15

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Api\AdresseIncomming;
  5. use DateTime;
  6. use App\Service\HierarchyService;
  7. use App\Repository\UserRepository;
  8. use Symfony\Component\HttpFoundation\Request;
  9. use Symfony\Component\Routing\Annotation\Route;
  10. use Symfony\Component\HttpKernel\KernelInterface;
  11. use App\Repository\NmdAdressesIncommingRepository;
  12. use Symfony\Component\HttpFoundation\JsonResponse;
  13. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  15. class AdresseIncommingHierarchyController extends AbstractController
  16. {
  17.     private $adresseRepository;
  18.     private $userRepository;
  19.     private $hierarchyService;
  21.     public function __construct(
  22.         NmdAdressesIncommingRepository $adresseRepository,
  23.         UserRepository $userRepository,
  24.         HierarchyService $hierarchyService
  25.     ) {
  26.         $this->adresseRepository = $adresseRepository;
  27.         $this->userRepository = $userRepository;
  28.         $this->hierarchyService = $hierarchyService;
  29.     }
  31.     public function __invoke(int $idUser, KernelInterface $kernel, Request $request): JsonResponse
  32.     {
  33.         $user = $this->userRepository->find($idUser);
  34.         if (!$user) {
  35.             return new JsonResponse(['error' => 'Utilisateur introuvable'], 404);
  36.         }
  38.         $userRoles = $user->getRoles();
  39.         $cpv = $request->query->get('cpv');
  40.         $migrable = strtoupper($request->query->get('migrable', 'NON')) === 'OUI';
  42.         // Cas sans cpv et utilisateur avec rôle organisation
  43.         if (!$cpv && in_array('ROLE_ORGANISATION', $userRoles)) {
  44.             $data = $migrable
  45.                 ? $this->adresseRepository->getGlobalHierarchyMigrable()
  46.                 : $this->adresseRepository->getGlobalHierarchy();
  47.             return new JsonResponse($data ?? [], 200);
  48.         }
  50.         // Cas avec rôles manager/director/seller
  51.         if ($this->hasManagementRole($userRoles)) {
  52.             return $this->handleManagerData($idUser, $kernel, $request, $migrable);
  53.         }
  55.         // Cas avec cpv
  56.         return $this->handleHierarchyData($kernel, $request, $cpv, $migrable);
  57.     }
  59.     private function hasManagementRole(array $roles): bool
  60.     {
  61.         $managementRoles = ['ROLE_MANAGER', 'ROLE_DIRECTOR', 'ROLE_SELLER'];
  62.         return !empty(array_intersect($managementRoles, $roles));
  63.     }
  65.     private function handleManagerData(int $idUser, KernelInterface $kernel, Request $request, bool $migrable): JsonResponse
  66.     {
  67.         $userIds = array_unique(array_merge(
  68.             [$idUser],
  69.             array_map(fn($p) => (int) $p['id'], $this->hierarchyService->getHierarchyDescendante($idUser))
  70.         ));
  72.         $cpv = $request->query->get('cpv');
  73.         $baseDir = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_neuves/{$cpv}/distributed_by_user";
  74.         $codeCluster = $request->query->get('codeCluster');
  75.         $codeInsee = $request->query->get('codeInsee');
  77.         if ($codeCluster && $codeInsee) {
  78.             $semaine = $request->query->get('semaine');
  79.             return new JsonResponse(
  80.                 $this->mergeDistributedVoiesFiles($userIds, $baseDir, $codeCluster, $codeInsee, $semaine, $migrable),
  81.                 200
  82.             );
  83.         }
  85.         return new JsonResponse($this->mergeDistributedClusters($userIds, $baseDir, $migrable), 200);
  86.     }
  88.     private function handleHierarchyData(KernelInterface $kernel, Request $request, string $cpv, bool $migrable): JsonResponse
  89.     {
  90.         $baseDir = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_neuves/{$cpv}";
  91.         $hierarchyFile = $migrable
  92.             ? "$baseDir/migrables/hierarchy_cluster_city_migrable.json"
  93.             : "$baseDir/hierarchy_clusters_cities.json";
  95.         if (!file_exists($hierarchyFile)) {
  96.             return new JsonResponse(['error' => "Fichier hiérarchie introuvable"], 200);
  97.         }
  99.         $jsonData = json_decode(file_get_contents($hierarchyFile), true);
  100.         if (empty($jsonData)) {
  101.             return new JsonResponse(['error' => "Fichier hiérarchie vide ou invalide"], 200);
  102.         }
  104.         $semaine = $request->query->get('semaine');
  105.         if (!$semaine) {
  106.             return new JsonResponse($jsonData, 200);
  107.         }
  109.         return $this->filterByHierarchy($jsonData, $request, $kernel, $cpv, $migrable);
  110.     }
  112.     private function filterByHierarchy(array $jsonData, Request $request, KernelInterface $kernel, string $cpv, bool $migrable): JsonResponse
  113.     {
  114.         $semaine = $request->query->get('semaine');
  115.         $jour = $request->query->get('date');
  116.         $codeCluster = $request->query->get('codeCluster');
  117.         $codeInsee = $request->query->get('codeInsee');
  118.         $anneeActuelle = (new \DateTimeImmutable())->format('Y');
  120.         // Récupération des voies si codeCluster & codeInsee & semaine existent
  121.         if ($codeCluster && $codeInsee && $semaine) {
  122.             $baseDir = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_neuves/{$cpv}";
  123.             $hierarchyFile = $migrable
  124.                 ? "$baseDir/migrables/voies/{$anneeActuelle}/S{$semaine}/{$codeCluster}/{$codeInsee}/liste_voies.json"
  125.                 : "$baseDir/voies/{$anneeActuelle}/S{$semaine}/{$codeCluster}/{$codeInsee}/liste_voies.json";
  127.             if (!file_exists($hierarchyFile)) {
  128.                 return new JsonResponse(['error' => "Fichier des voies introuvable"], 200);
  129.             }
  131.             $voiesData = json_decode(file_get_contents($hierarchyFile), true);
  132.             if (empty($voiesData)) {
  133.                 return new JsonResponse(['error' => "Fichier des voies vide ou invalide"], 200);
  134.             }
  135.             return new JsonResponse($voiesData, 200);
  136.         } else {
  137.             //Filter v1 
  138.             $semaines = array_values(array_filter($jsonData, fn($s) => ($s['numero_semaine'] ?? null) == $semaine));
  139.             if (empty($semaines)) {
  140.                 return new JsonResponse([], 200);
  141.             }
  143.             if (!$jour) {
  144.                 return new JsonResponse($semaines, 200);
  145.             }
  147.             $jours = [];
  148.             foreach ($semaines as $sem) {
  149.                 $filteredDays = array_values(array_filter($sem['jours'] ?? [], fn($d) => ($d['date_jour'] ?? null) === $jour));
  150.                 $jours = array_merge($jours, $filteredDays);
  151.             }
  153.             if (empty($jours)) {
  154.                 return new JsonResponse([], 200);
  155.             }
  157.             if (!$codeCluster) {
  158.                 return new JsonResponse($jours, 200);
  159.             }
  161.             $clusters = [];
  162.             foreach ($jours as $day) {
  163.                 $filteredClusters = array_values(array_filter($day['clusters'] ?? [], fn($c) => ($c['clusterCode'] ?? null) === $codeCluster));
  164.                 $clusters = array_merge($clusters, $filteredClusters);
  165.             }
  167.             if (empty($clusters)) {
  168.                 return new JsonResponse([], 200);
  169.             }
  171.             if (!$codeInsee) {
  172.                 return new JsonResponse($clusters[0], 200);
  173.             }
  177.             // Si on arrive ici, on retourne la ville trouvée
  178.             $villes = [];
  179.             foreach ($clusters as $cluster) {
  180.                 $filteredVilles = array_values(array_filter($cluster['villes'] ?? [], fn($v) => ($v['cod_insee'] ?? null) == $codeInsee));
  181.                 $villes = array_merge($villes, $filteredVilles);
  182.             }
  184.             return new JsonResponse($villes[0] ?? [], 200);
  185.         }
  186.     }
  188.     private function mergeDistributedClusters(array $userIds, string $baseDir, bool $isMigrable): array
  189.     {
  190.         $subdir = $isMigrable ? 'distributed_hierarchy_cluster_city_migrable.json' : 'distributed_hierarchy_cluster_city.json';
  192.         foreach ($userIds as $uid) {
  193.             $file = "{$baseDir}/{$uid}/{$subdir}";
  194.             if (!file_exists($file)) continue;
  196.             $data = json_decode(file_get_contents($file), true);
  197.             if (is_array($data)) {
  198.                 return $data;
  199.             }
  200.         }
  201.         return [];
  202.     }
  204.     private function mergeDistributedVoiesFiles(array $userIds, string $baseDir, string $codeCluster, string $codeInsee, ?int $semaine, bool $isMigrable): array
  205.     {
  206.         $subdir = $isMigrable ? 'voies_migrable' : 'voies';
  208.         foreach ($userIds as $uid) {
  209.             $file = "{$baseDir}/{$subdir}/{$uid}/semaine_{$semaine}/{$codeCluster}/{$codeInsee}/liste_voies.json";
  210.             if (!file_exists($file)) continue;
  212.             $data = json_decode(file_get_contents($file), true);
  213.             if (is_array($data)) {
  214.                 return $data;
  215.             }
  216.         }
  217.         return [];
  218.     }
  220.     /**
  221.      * @Route("/api/adresses-incomming-streets/{idUser}", name="api_get_adresse_incoming_streets_from_json", methods={"GET"})
  222.      */
  223.     public function getAdressesIncomingStreetsFromJson(int $idUser, KernelInterface $kernel, Request $request): JsonResponse
  224.     {
  225.         $migrable    = strtoupper($request->query->get('migrable', 'NON'));
  226.         $cpv         = $request->query->get('cpv', null);
  227.         $semaine = $request->query->get('semaine', null);
  228.         $jour = $request->query->get('date', null);
  229.         $codeCluster = $request->query->get('codeCluster', null);
  230.         $codeInsee   = $request->query->get('codeInsee', null);
  231.         $projectDir  = $kernel->getProjectDir();
  232.         $anneeActuelle = (new \DateTimeImmutable())->format('Y');
  233.         $result = []; // Initialisation de la variable résultat
  235.         $user = $this->userRepository->find($idUser);
  236.         if (!$user) {
  237.             $result = ['error' => 'Utilisateur introuvable'];
  238.             return new JsonResponse($result, 404);
  239.         }
  242.         if (!$cpv) {
  243.             $result = ['error' => 'CPV manquant'];
  244.             return new JsonResponse($result, 400);
  245.         }
  247.         $baseDir = "$projectDir/fileAttached/geo_map/prises_neuves/{$cpv}";
  249.         if ($codeCluster && $codeInsee) {
  250.             $voiesFile = $migrable === 'OUI'
  251.                 ? "$baseDir/migrables/voies/$anneeActuelle/$semaine/$jour/$codeCluster/$codeInsee/liste_voies.json"
  252.                 : "$baseDir/voies/$anneeActuelle/$semaine/$jour/$codeCluster/$codeInsee/liste_voies.json";
  254.             if (!file_exists($voiesFile)) {
  255.                 $result = ['error' => "Fichier voies introuvable"];
  256.                 return new JsonResponse($result, 404);
  257.             }
  259.             $voiesData = json_decode(file_get_contents($voiesFile), true);
  260.             if ($voiesData === null && json_last_error() !== JSON_ERROR_NONE) {
  261.                 $result = ['error' => "Fichier voies vide ou invalide"];
  262.                 return new JsonResponse($result, 400);
  263.             }
  265.             $result = $voiesData;
  266.         }
  269.         return new JsonResponse($result, 200);
  270.     }
  272.     /**
  273.      * @Route("/api/adresses-incomming-hierarchy-by-anciennete/{cpv}", name="api_get_adresse_incomming_hierarchy_by_anciennete_from_json", methods={"GET"})
  274.      */
  275.     public function getHierarchyByAncienneteFromJson(
  276.         int $cpv,
  277.         KernelInterface $kernel,
  278.         Request $request
  279.     ): JsonResponse {
  280.         $filePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_neuves/{$cpv}/anciennete/anciennete.json";
  282.         if (!file_exists($filePath)) {
  283.             return new JsonResponse(['error' => 'Fichier non trouvé'], 200);
  284.         }
  286.         $jsonData = json_decode(file_get_contents($filePath), true);
  288.         if ($jsonData === null) {
  289.             return new JsonResponse(['error' => 'Erreur de lecture du JSON'], 200);
  290.         }
  292.         // Récupérer les paramètres de l'intervalle d'ancienneté
  293.         $debutAnciennete = $request->query->get('debutAnciennete', null);
  294.         $finAnciennete = $request->query->get('finAnciennete', null);
  295.         $codeCluster = $request->query->get('codeCluster', null);
  296.         $codeInsee = $request->query->get('codeInsee', null);
  298.         // Vérification des paramètres d'intervalle d'ancienneté
  299.         if ($debutAnciennete != null && $finAnciennete != null && $debutAnciennete <= $finAnciennete) {
  302.             // Convertir debutAnciennete et finAnciennete en nombre (supporter négatif et positif)
  303.             $debutAnciennete = floatval($debutAnciennete);
  304.             $finAnciennete = floatval($finAnciennete);
  306.             // Tableaux pour la combinaison des clusters et totalPrises
  307.             $finalClusters = [];
  308.             $finalTotalPrises = 0;
  310.             // Filtrer et combiner les clusters pour les niveaux d'ancienneté dans l'intervalle
  311.             foreach ($jsonData as $key => $data) {
  312.                 $keyAnciennete = floatval($key); // S'assurer que la clé est un nombre
  313.                 if ($keyAnciennete >= $debutAnciennete && $keyAnciennete <= $finAnciennete) {
  315.                     // Ajouter les clusters de cet ancienneté
  316.                     foreach ($data['clusters'] as $cluster) {
  317.                         $clusterCode = $cluster['code_cluster'];
  318.                         // Si le cluster existe déjà, on additionne le totalPrises
  319.                         if (isset($finalClusters[$clusterCode])) {
  320.                             // Ajouter les villes et additionner les prises des villes existantes
  321.                             foreach ($cluster['villes'] as $ville) {
  322.                                 $villeCode = $ville['cod_insee'];
  323.                                 $foundVille = false;
  325.                                 // Si la ville existe déjà, on additionne son totalPrises
  326.                                 foreach ($finalClusters[$clusterCode]['villes'] as &$existingVille) {
  327.                                     if ($existingVille['cod_insee'] === $villeCode) {
  328.                                         $existingVille['totalPrises'] += $ville['totalPrises'];
  329.                                         $foundVille = true;
  330.                                         break;
  331.                                     }
  332.                                 }
  334.                                 // Si la ville n'existe pas encore, on l'ajoute
  335.                                 if (!$foundVille) {
  336.                                     $finalClusters[$clusterCode]['villes'][] = $ville;
  337.                                 }
  338.                             }
  340.                             // Additionner les totalPrises du cluster
  341.                             $finalClusters[$clusterCode]['totalPrises'] += $cluster['totalPrises'];
  342.                         } else {
  343.                             // Si le cluster n'existe pas encore, on l'ajoute avec ses villes
  344.                             $finalClusters[$clusterCode] = [
  345.                                 'code_cluster' => $cluster['code_cluster'],
  346.                                 'libelle_cluster' => $cluster['libelle_cluster'],
  347.                                 'totalPrises' => $cluster['totalPrises'],
  348.                                 'villes' => $cluster['villes'],
  349.                             ];
  350.                         }
  352.                         // Additionner les prises du cluster à la somme globale
  353.                         $finalTotalPrises += $cluster['totalPrises'];
  354.                     }
  355.                 }
  356.             }
  358.             // Si aucun cluster n'a été trouvé dans l'intervalle, renvoyer une erreur
  359.             if (empty($finalClusters)) {
  360.                 return new JsonResponse('Aucun cluster trouvé dans l\'intervalle d\'ancienneté', 200);
  361.             }
  362.             $jsonDataByAncinneteRange = [
  363.                 'totalPrises' => $finalTotalPrises,
  364.                 'clusters' => array_values($finalClusters),
  365.             ];
  366.             // Si codeCluster est fourni, rechercher le cluster correspondant
  367.             if ($codeCluster) {
  368.                 $cluster = array_filter($jsonDataByAncinneteRange['clusters'], function ($c) use ($codeCluster) {
  369.                     return $c['code_cluster'] === $codeCluster;
  370.                 });
  372.                 if (empty($cluster)) {
  373.                     return new JsonResponse(['Cluster non trouvé'], 200);
  374.                 }
  376.                 $cluster = array_values($cluster)[0]; // Récupérer le premier élément
  378.                 // Si codeInsee est fourni, rechercher la ville correspondante
  379.                 if ($codeInsee) {
  380.                     $ville = array_filter($cluster['villes'], function ($v) use ($codeInsee) {
  381.                         return $v['cod_insee'] === $codeInsee;
  382.                     });
  384.                     if (empty($ville)) {
  385.                         return new JsonResponse(['error' => 'Ville non trouvée'], 200);
  386.                     }
  387.                     return new JsonResponse(array_values($ville)[0], 200);
  388.                 }
  390.                 return new JsonResponse($cluster, 200);
  391.             }
  392.             // Retourner la réponse finale avec totalPrises et clusters combinés
  393.             return new JsonResponse($jsonDataByAncinneteRange, 200);
  394.         }
  395.         return new JsonResponse($jsonData, 200);
  396.     }
  398.     /**
  399.      * @Route("/api/adresses-incomming-streets-by-anciennete/{cpv}/{codeCluster}/{codeInsee}", name="api_get_adresses_incomming_voies_by_anciennete_from_json", methods={"GET"})
  400.      */
  401.     public function getInterventionPlaceVoiesFromJson(int $cpv, string $codeCluster, $codeInsee, KernelInterface $kernel, Request $request): JsonResponse
  402.     {
  404.         $filePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_neuves/{$cpv}/anciennete/voies/{$codeCluster}/{$codeInsee}/liste_voies.json";
  406.         if (!file_exists($filePath)) {
  407.             return new JsonResponse(['error' => 'Fichier non trouvé'], 200);
  408.         }
  409.         $anciennete = $request->query->get('anciennete', null);
  410.         // Lire et décoder le fichier JSON
  411.         $jsonData = json_decode(file_get_contents($filePath), true);
  413.         if ($jsonData === null) {
  414.             return new JsonResponse(['error' => 'Erreur de lecture du JSON'], 200);
  415.         }
  416.         if ($anciennete) {
  417.             if (!isset($jsonData[$anciennete])) {
  418.                 return new JsonResponse(['error' => 'Ancienneté non trouvée'], 200);
  419.             }
  420.             return new JsonResponse($jsonData[$anciennete], 200);
  421.         }
  422.         // Renvoi des données paginées
  423.         return new JsonResponse($jsonData, 200);
  424.     }
  427.     /**
  428.      * @Route("/api/adresses-incomming-hierarchy-arret-cu-v2/{cpv}", name="api_get_adresses_incomming_arret_cu_from_json_v2", methods={"GET"})
  429.      */
  430.     public function getHierrachyByArretCuFromJsonV2(int $cpv, KernelInterface $kernel, Request $request): JsonResponse
  431.     {
  432.         // Récupérer les paramètres de la requête
  433.         $codeCluster = $request->query->get('codeCluster', null);
  434.         $codeInsee   = $request->query->get('codeInsee', null);
  435.         $annee       = $request->query->get('annee', null);
  436.         $mois        = $request->query->get('mois', null);
  438.         // Définir le chemin du fichier JSON principal
  439.         $filePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_neuves/{$cpv}/arret_cu_v2/arret_cu.json";
  441.         if (!file_exists($filePath)) {
  442.             return new JsonResponse([], 200);
  443.         }
  445.         $jsonData = json_decode(file_get_contents($filePath), true);
  446.         if ($jsonData === null) {
  447.             return new JsonResponse([], 200);
  448.         }
  450.         // --- Filtrage par codeCluster ---
  451.         if ($codeCluster) {
  452.             $cluster = array_filter($jsonData, fn($c) => $c['code_cluster'] == $codeCluster);
  453.             if (count($cluster) < 1) {
  454.                 return new JsonResponse([], 200);
  455.             }
  456.             $cluster = array_values($cluster)[0];
  458.             // --- Filtrage par codeInsee ---
  459.             if ($codeInsee) {
  460.                 $ville = array_filter($cluster['villes'], fn($v) => $v['cod_insee'] == $codeInsee);
  461.                 if (count($ville) < 1) {
  462.                     return new JsonResponse([], 200);
  463.                 }
  464.                 $ville = array_values($ville)[0];
  466.                 // --- Ici on ajoute l’appel à la 2e API ---
  467.                 $streetsFilePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_neuves/{$cpv}/arret_cu/voies/{$codeCluster}/{$codeInsee}/liste_voies.json";
  468.                 if (file_exists($streetsFilePath)) {
  469.                     $streetsData = json_decode(file_get_contents($streetsFilePath), true) ?? [];
  471.                     // Filtrage par année et mois si demandé
  472.                     if ($annee !== null && isset($streetsData[$annee])) {
  473.                         $streetsData = $streetsData[$annee];
  474.                         if ($mois !== null && isset($streetsData[$mois])) {
  475.                             $streetsData = $streetsData[$mois];
  476.                         }
  477.                     }
  479.                     // On enrichit la réponse avec les rues
  480.                     $ville['voies'] = $streetsData;
  481.                 }
  483.                 return new JsonResponse($ville, 200);
  484.             }
  486.             return new JsonResponse($cluster, 200);
  487.         }
  489.         return new JsonResponse($jsonData, 200);
  490.     }
  492.     /**
  493.      * @Route("/api/adresses-incomming-hierarchy-arret-cu/{cpv}", name="api_get_adresses_incomming_arret_cu_from_json", methods={"GET"})
  494.      */
  495.     public function getHierarchyArretCufromJson(int $cpv, KernelInterface $kernel, Request $request): JsonResponse
  496.     {
  497.         // Récupérer les paramètres de la requête
  498.         $annee       = $request->query->get('annee', null);
  499.         $mois        = $request->query->get('mois', null);
  500.         $codeCluster = $request->query->get('codeCluster', null);
  501.         $codeInsee   = $request->query->get('codeInsee', null);
  503.         // Définir le chemin du fichier JSON principal
  504.         $filePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_neuves/{$cpv}/arret_cu/arret_cu.json";
  506.         if (!file_exists($filePath)) {
  507.             return new JsonResponse([], 200);
  508.         }
  510.         $jsonData = json_decode(file_get_contents($filePath), true);
  511.         if ($jsonData === null) {
  512.             return new JsonResponse([], 200);
  513.         }
  515.         // Filtrage par année
  516.         if ($annee !== null && isset($jsonData[$annee])) {
  517.             $jsonDataAnnee = $jsonData[$annee];
  519.             // Filtrage par mois
  520.             if ($mois !== null && isset($jsonDataAnnee[$mois])) {
  521.                 $jsonDataMois = $jsonDataAnnee[$mois];
  523.                 // Filtrage par cluster
  524.                 if ($codeCluster !== null && isset($jsonDataMois['clusters'])) {
  525.                     $clusterData = null;
  526.                     foreach ($jsonDataMois['clusters'] as $c) {
  527.                         if ($c['code_cluster'] == $codeCluster) {
  528.                             $clusterData = $c;
  529.                             break;
  530.                         }
  531.                     }
  533.                     // Filtrage par ville (codeInsee)
  534.                     if ($clusterData !== null && $codeInsee !== null && isset($clusterData['villes'])) {
  535.                         $villeData = null;
  536.                         foreach ($clusterData['villes'] as $villeItem) {
  537.                             if ($villeItem['cod_insee'] == $codeInsee) {
  538.                                 $villeData = $villeItem;
  539.                                 break;
  540.                             }
  541.                         }
  543.                         // Si une ville est trouvée → chercher aussi les rues
  544.                         if ($villeData !== null) {
  545.                             $streetsFilePath = $kernel->getProjectDir() . "/fileAttached/geo_map/prises_neuves/{$cpv}/arret_cu/voies/{$codeCluster}/{$codeInsee}/liste_voies.json";
  546.                             if (file_exists($streetsFilePath)) {
  547.                                 $streetsData = json_decode(file_get_contents($streetsFilePath), true) ?? [];
  549.                                 // Filtrage rues par année et mois
  550.                                 if ($annee !== null && isset($streetsData[$annee])) {
  551.                                     $streetsData = $streetsData[$annee];
  552.                                     if ($mois !== null && isset($streetsData[$mois])) {
  553.                                         $streetsData = $streetsData[$mois];
  554.                                     }
  555.                                 }
  557.                                 // Enrichir la ville avec ses voies
  558.                                 $villeData['voies'] = $streetsData;
  559.                             }
  561.                             return new JsonResponse($villeData, 200);
  562.                         }
  564.                         return new JsonResponse([], 200);
  565.                     }
  567.                     return new JsonResponse($clusterData ?? [], 200);
  568.                 }
  570.                 return new JsonResponse($jsonDataMois ?? [], 200);
  571.             } else {
  572.                 return new JsonResponse(['error' => 'Mois non défini'], 404);
  573.             }
  574.         }
  576.         // Si pas de filtre → retourner le JSON complet
  577.         return new JsonResponse($jsonData, 200);
  578.     }
  579. }