src/Controller/GisserverController.php line 123

  1. <?php
  2. //src/Controller/GisserverController.php
  4. namespace App\Controller;
  6. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  7. use Symfony\Component\HttpFoundation\Response;
  8. use Symfony\Component\HttpFoundation\JsonResponse;
  9. use Symfony\Component\HttpFoundation\Request;
  10. use Doctrine\DBAL\DriverManager;
  11. use Doctrine\DBAL\Driver\PDO\PgSQL;
  12. use Psr\Log\LoggerInterface;
  13. use PDO;
  15. class GisserverController extends AbstractController
  16. {
  18.     private const TIMEOUT = 240;
  20.     private LoggerInterface $logger;
  22.     public function __construct(LoggerInterface $logger)
  23.     {
  24.         $this->logger = $logger;
  25.     }
  26.     
  27.     /**
  28.      * Obtener conexión DBAL
  29.      */
  30.     private function getConnection()
  31.     {
  32.         $databaseUrl = $_ENV['DATABASE_URL_GIS'];
  33.         
  34.         $connectionParams = [
  35.             'url' => $databaseUrl,
  36.             'driverOptions' => [PDO::ATTR_TIMEOUT => intval(self::TIMEOUT)]
  37.         ];
  38.         
  39.         return DriverManager::getConnection($connectionParams);
  40.     }
  42.     public function geoJson(Request $request)
  43.     {
  44.         $layerTable = $request->get('typeName');
  45.         $SrsName = $request->get('SrsName', 'EPSG:4326');
  46.         $fields = $request->get('PropertyName');
  48.         $srsCode = $this->extractSRID($SrsName);
  50.         $fieldsKey = empty($fields) ? 'all' : md5($fields);
  51.         $cacheDir = $this->getParameter('kernel.project_dir') . "/var/cache/geojson";
  52.         $cacheFile = "{$cacheDir}/{$layerTable}_{$srsCode}_{$fieldsKey}.json";
  53.         
  54.         if (file_exists($cacheFile)) 
  55.         {
  56.             $response = new Response(file_get_contents($cacheFile));
  57.             $response->headers->set('Content-Type', 'application/json');
  58.             $response->headers->set('Access-Control-Allow-Origin', '*');
  59.             $response->headers->set('Cache-Control', 'public, max-age=3600');
  60.             $response->headers->set('X-Cache', 'HIT');
  61.             return $response;
  62.         }
  64.         if ($fields == null || $fields == '') {
  65.             $fields = '*';
  66.         }
  67.         else
  68.         {
  69.             $fields = 'id,geom,'.$fields;
  70.         }
  72.         try 
  73.         {
  74.             $this->connection = $this->getConnection();
  76.             $sql = "
  77.                 SELECT jsonb_build_object(
  78.                     'type', 'FeatureCollection',
  79.                     'features', jsonb_agg(features.feature)
  80.                 ) as geojson
  81.                 FROM (
  82.                     SELECT jsonb_build_object(
  83.                         'type', 'Feature',
  84.                         'id', id,
  85.                         'geometry', ST_AsGeoJSON(ST_Transform(geom, {$srsCode}))::jsonb,
  86.                         'properties', to_jsonb(row) - 'geom'
  87.                     ) AS feature
  88.                     FROM (
  89.                         SELECT {$fields}
  90.                         FROM \"{$layerTable}\"
  91.                     ) row
  92.                 ) features
  93.             ";
  94.             
  95.             $result = $this->connection->executeQuery($sql);
  96.             $data = $result->fetchAssociative();
  98.             $geojson = $data['geojson'] ?? '{"type":"FeatureCollection","features":[]}';
  99.         
  100.             if (!is_dir($cacheDir)) {
  101.                 mkdir($cacheDir, 0755, true);
  102.             }
  103.             file_put_contents($cacheFile, $geojson);
  104.             
  105.             $response = new Response($geojson);
  106.             $response->headers->set('Content-Type', 'application/json');
  107.             $response->headers->set('Access-Control-Allow-Origin', '*');
  108.             $response->headers->set('Cache-Control', 'public, max-age=3600');
  109.             $response->headers->set('X-Cache', 'MISS');
  111.             return $response;
  113.         } catch (\Exception $e) {
  114.             return $this->json([
  115.                 'error' => 'Error al obtener GeoJSON',
  116.                 'message' => $e->getMessage()
  117.             ], Response::HTTP_INTERNAL_SERVER_ERROR);
  118.         }
  119.         
  120.     }
  122.     #[Route('/gis/tiles/{tabla}/{z}/{x}/{y}.pbf', name: 'gis_tiles', methods: ['GET'])]
  123.     public function tiles(string $tabla, int $z, int $x, int $y, Request $request): Response
  124.     {
  125.         $fields = $request->get('fields');
  126.         $arrFields = explode(',',$fields);
  127.         $comarca = $request->get('comarca'); // Obtener el parámetro comarca
  128.         
  129.         foreach ($arrFields as $i => $f) {
  130.             $arrFields[$i] = '"' . trim($f) . '"';
  131.         }
  133.         $fieldsQuoted = implode(', ', $arrFields);
  135.         $tabla = urldecode($tabla);
  137.         // Determinar qué materialized view usar según el zoom
  138.         $materializedView = $this->getMaterializedViewName($tabla, $z);
  139.         
  140.         $this->logger->info("Preparando generación de tiles", [
  141.             'tabla_solicitada' => $tabla,
  142.             'zoom' => $z,
  143.             'x' => $x,
  144.             'y' => $y,
  145.             'vista_candidata' => $materializedView,
  146.             'comarca_filtro' => $comarca
  147.         ]);
  148.         
  149.         try 
  150.         {
  151.             $conDbal = $this->getConnection();
  153.             // Verificar si existe la materialized view
  154.             $viewExists = $this->checkMaterializedViewExists($conDbal, $materializedView);
  155.             
  156.             if (!$viewExists) {
  157.                 $this->logger->warning("Materialized view {$materializedView} no existe, usando tabla original {$tabla}");
  158.                 $materializedView = $tabla;
  159.             }
  161.             $this->logger->info("Vista/Tabla que se usará para executeQuery", [
  162.                 'fuente_datos' => $materializedView,
  163.                 'es_vista_materializada' => $viewExists,
  164.                 'zoom' => $z
  165.             ]);
  167.             // Construir la cláusula WHERE con el filtro de comarca si se proporciona
  168.             $whereClause = "ST_Intersects(geom_3857, ST_TileEnvelope(:z, :x, :y))";
  169.             
  170.             if (!empty($comarca)) {
  171.                 $whereClause .= " AND comarca = :comarca";
  172.             }
  174.             $sql = "
  175.                 WITH mvtgeom AS (
  176.                     SELECT 
  177.                         id,
  178.                         {$fieldsQuoted},
  179.                         ST_AsMVTGeom(
  180.                             geom_3857,
  181.                             ST_TileEnvelope(:z, :x, :y),
  182.                             4096,
  183.                             64,
  184.                             true
  185.                         ) AS geom
  186.                     FROM \"{$materializedView}\"
  187.                     WHERE {$whereClause}
  188.                 )
  189.                 SELECT ST_AsMVT(mvtgeom, :layer, 4096, 'geom') as mvt
  190.                 FROM mvtgeom
  191.                 WHERE geom IS NOT NULL
  192.             ";
  194.             $this->logger->debug("SQL generado", [
  195.                 'sql' => str_replace([':z', ':x', ':y', ':layer', ':comarca'], [$z, $x, $y, $tabla, $comarca ?? NULL], $sql),
  196.                 'fuente' => $materializedView,
  197.                 'comarca' => $comarca ?? NULL
  198.             ]);
  200.             $stmt = $conDbal->prepare($sql);
  201.             $stmt->bindValue('layer', $tabla);
  202.             $stmt->bindValue('z', $z);
  203.             $stmt->bindValue('x', $x);
  204.             $stmt->bindValue('y', $y);
  206.             // Bindear el parámetro comarca si existe
  207.             if (!empty($comarca)) {
  208.                 $stmt->bindValue('comarca', $comarca, \PDO::PARAM_STR);
  209.             }
  210.             
  211.             $result = $stmt->executeQuery();
  212.             $data = $result->fetchAssociative();
  214.             $this->logger->info("Resultado MVT", [
  215.                 'fuente_usada' => $materializedView,
  216.                 'has_mvt' => isset($data['mvt']),
  217.                 'mvt_empty' => empty($data['mvt']),
  218.                 'mvt_type' => gettype($data['mvt'] ?? null),
  219.                 'comarca_aplicada' => $comarca ?? 'N/A'
  220.             ]);
  222.             if ($data && !empty($data['mvt'])) 
  223.             {
  224.                 $mvtField = $data['mvt'];
  225.                 if (is_resource($mvtField)) {
  226.                     $mvt = stream_get_contents($mvtField);
  227.                 } elseif (is_string($mvtField) && str_starts_with($mvtField, '\\x')) {
  228.                     $mvt = hex2bin(substr($mvtField, 2));
  229.                 } else {
  230.                     $mvt = (string)$mvtField;
  231.                 }
  232.                 
  233.                 if ($mvt === '' || $mvt === null) {
  234.                     $this->logger->warning("MVT vacío", ['fuente' => $materializedView, 'comarca' => $comarca ?? 'N/A']);
  235.                     return new Response('', 204, [
  236.                         'Content-Type' => 'application/x-protobuf'
  237.                     ]);
  238.                 }
  239.                 
  240.                 $response = new Response($mvt);
  241.                 $response->headers->set('Content-Type', 'application/x-protobuf');
  242.                 $response->headers->set('Content-Length', strlen($mvt));
  243.                 $response->headers->set('Cache-Control', 'public, max-age=86400');
  244.                 $response->headers->set('Access-Control-Allow-Origin', '*');
  245.                 $response->headers->set('X-Cache', 'MISS');
  246.                 $response->headers->set('X-Source', $materializedView);
  247.                 
  248.                 $this->logger->info("Tile generado exitosamente", [
  249.                     'fuente' => $materializedView,
  250.                     'bytes' => strlen($mvt),
  251.                     'comarca' => $comarca ?? 'N/A'
  252.                 ]);
  253.                 
  254.                 return $response;
  255.             }
  256.             
  257.             $this->logger->warning("No hay datos para el tile", [
  258.                 'fuente' => $materializedView,
  259.                 'zoom' => $z,
  260.                 'tile' => "{$x}/{$y}",
  261.                 'comarca' => $comarca ?? 'N/A'
  262.             ]);
  263.             
  264.             return new Response('', 204, [
  265.                 'Content-Type' => 'application/x-protobuf'
  266.             ]);
  267.             
  268.         } catch (\Exception $e) {
  269.             $this->logger->error("Error en tiles", [
  270.                 'tabla' => $tabla,
  271.                 'fuente_intentada' => $materializedView ?? 'desconocida',
  272.                 'error' => $e->getMessage(),
  273.                 'comarca' => $comarca ?? 'N/A'
  274.             ]);
  275.             return new Response(
  276.                 'Error: ' . $e->getMessage(), 
  277.                 Response::HTTP_INTERNAL_SERVER_ERROR
  278.             );
  279.         }
  280.     }
  282.     /**
  283.      * Determina qué materialized view usar según el zoom level
  284.      */
  285.     private function getMaterializedViewName(string $tabla, int $z): string
  286.     {
  287.         if ($z <= 8) {
  288.             return "{$tabla}_mvt_z0_8";      // Tolerancia 200m
  289.         } elseif ($z <= 10) {
  290.             return "{$tabla}_mvt_z9_10";     // Tolerancia 75m
  291.         } elseif ($z <= 12) {
  292.             return "{$tabla}_mvt_z11_12";    // Tolerancia 30m
  293.         } elseif ($z <= 14) {
  294.             return "{$tabla}_mvt_z13_14";    // Tolerancia 10m
  295.         } elseif ($z <= 16) {
  296.             return "{$tabla}_mvt_z15_16";    // Tolerancia 3m
  297.         } elseif ($z <= 18) {
  298.             return "{$tabla}_mvt_z17_18";    // Tolerancia 1m
  299.         } else {
  300.             return $tabla;                    // Original sin simplificar
  301.         }
  302.     }
  304.     /**
  305.      * Verifica si existe una materialized view
  306.      */
  307.     private function checkMaterializedViewExists($connection, string $viewName): bool
  308.     {
  309.         $sql = "
  310.             SELECT EXISTS (
  311.                 SELECT 1 
  312.                 FROM pg_matviews 
  313.                 WHERE matviewname = :viewName
  314.             ) as exists
  315.         ";
  316.         
  317.         try {
  318.             $stmt = $connection->prepare($sql);
  319.             $stmt->bindValue('viewName', $viewName);
  320.             $result = $stmt->executeQuery();
  321.             $data = $result->fetchAssociative();
  322.             
  323.             return (bool) $data['exists'];
  324.         } catch (\Exception $e) {
  325.             $this->logger->error("Error verificando materialized view: " . $e->getMessage());
  326.             return false;
  327.         }
  328.     }
  330.     private function extractSRID(string $srsName): int
  331.     {
  332.         $parts = explode(':', $srsName);
  333.         return isset($parts[1]) ? intval($parts[1]) : 4326;
  334.     }
  336. }