src/Service/SearchService.php line 35

  1. <?php
  3. namespace App\Service;
  5. use App\Dto\SearchResult;
  6. use App\Entity\Coleccion;
  7. use App\Entity\Composicion;
  8. use App\Entity\Destacada;
  9. use App\Entity\Modelo;
  10. use App\Entity\Programa;
  11. use App\Repository\ColeccionRepository;
  12. use App\Repository\ComposicionRepository;
  13. use App\Repository\DestacadaRepository;
  14. use App\Repository\ModeloRepository;
  15. use App\Repository\ProgramaRepository;
  17. class SearchService
  18. {
  19.     public function __construct(
  20.         private ModeloRepository $modeloRepository,
  21.         private ColeccionRepository $coleccionRepository,
  22.         private ComposicionRepository $composicionRepository,
  23.         private ProgramaRepository $programaRepository,
  24.         private DestacadaRepository $destacadaRepository
  25.     ) {}
  27.     /**
  28.      * Realiza una búsqueda global en todas las entidades
  29.      * 
  30.      * @param string $term Término de búsqueda
  31.      * @param int $finalLimit Límite de resultados finales
  32.      * @param int $perEntityLimit Límite de resultados por entidad (para ordenar después)
  33.      * @return SearchResult[]
  34.      */
  35.     public function globalSearch(string $term, int $finalLimit = 10, int $perEntityLimit = null): array
  36.     {
  37.         // Si no se especifica límite por entidad, usar el triple del límite final
  38.         $perEntityLimit = $perEntityLimit ?? ($finalLimit * 3);
  39.         
  40.         $results = [];
  42.         // Buscar en Modelos
  43.         $modelos = $this->modeloRepository->searchByTerm($term, $perEntityLimit);
  44.         foreach ($modelos as $modelo) {
  45.             $results[] = $this->createSearchResultFromModelo($modelo);
  46.         }
  48.         // Buscar en Colecciones
  49.         $colecciones = $this->coleccionRepository->searchByTerm($term, $perEntityLimit);
  50.         foreach ($colecciones as $coleccion) {
  51.             $results[] = $this->createSearchResultFromColeccion($coleccion);
  52.         }
  54.         // Buscar en Composiciones
  55.         $composiciones = $this->composicionRepository->searchByTerm($term, $perEntityLimit);
  56.         foreach ($composiciones as $composicion) {
  57.             $results[] = $this->createSearchResultFromComposicion($composicion);
  58.         }
  60.         // Buscar en Programas
  61.         $programas = $this->programaRepository->searchByTerm($term, $perEntityLimit);
  62.         foreach ($programas as $programa) {
  63.             $results[] = $this->createSearchResultFromPrograma($programa);
  64.         }
  66.         // Buscar en Destacadas
  67.         $destacadas = $this->destacadaRepository->searchByTerm($term, $perEntityLimit);
  68.         foreach ($destacadas as $destacada) {
  69.             $results[] = $this->createSearchResultFromDestacada($destacada);
  70.         }
  72.         // Ordenar resultados por relevancia
  73.         usort($results, function (SearchResult $a, SearchResult $b) use ($term) {
  74.             $termLower = strtolower($term);
  75.             $aNameLower = strtolower($a->getNombre());
  76.             $bNameLower = strtolower($b->getNombre());
  77.             $aDescLower = strtolower($a->getDescripcion() ?? '');
  78.             $bDescLower = strtolower($b->getDescripcion() ?? '');
  80.             // 1. Coincidencia exacta en el nombre
  81.             $aExact = ($aNameLower === $termLower) ? 1 : 0;
  82.             $bExact = ($bNameLower === $termLower) ? 1 : 0;
  83.             if ($aExact !== $bExact) {
  84.                 return $bExact - $aExact;
  85.             }
  87.             // 2. Comienza con el término en el nombre
  88.             $aStarts = str_starts_with($aNameLower, $termLower) ? 1 : 0;
  89.             $bStarts = str_starts_with($bNameLower, $termLower) ? 1 : 0;
  90.             if ($aStarts !== $bStarts) {
  91.                 return $bStarts - $aStarts;
  92.             }
  94.             // 3. Contiene el término en el nombre (antes que en descripción)
  95.             $aInName = str_contains($aNameLower, $termLower) ? 1 : 0;
  96.             $bInName = str_contains($bNameLower, $termLower) ? 1 : 0;
  97.             if ($aInName !== $bInName) {
  98.                 return $bInName - $aInName;
  99.             }
  101.             // 4. Contiene el término en la descripción (menor prioridad)
  102.             $aInDesc = str_contains($aDescLower, $termLower) ? 1 : 0;
  103.             $bInDesc = str_contains($bDescLower, $termLower) ? 1 : 0;
  104.             if ($aInDesc !== $bInDesc) {
  105.                 return $bInDesc - $aInDesc;
  106.             }
  108.             // 5. Orden alfabético
  109.             return strcmp($aNameLower, $bNameLower);
  110.         });
  112.         // Limitar los resultados finales
  113.         return array_slice($results, 0, $finalLimit);
  114.     }
  116.     private function createSearchResultFromModelo(Modelo $modelo): SearchResult
  117.     {
  118.         return new SearchResult(
  119.             type: 'modelo',
  120.             id: $modelo->getId(),
  121.             nombre: $modelo->getNombre(),
  122.             descripcion: $modelo->getDescripcion(),
  123.             metadata: [
  124.                 'coleccion' => $modelo->getColeccion()?->getNombre(),
  125.                 'ancho' => $modelo->getAncho(),
  126.                 'alto' => $modelo->getAlto(),
  127.                 'fondo' => $modelo->getFondo(),
  128.             ]
  129.         );
  130.     }
  132.     private function createSearchResultFromColeccion(Coleccion $coleccion): SearchResult
  133.     {
  134.         return new SearchResult(
  135.             type: 'coleccion',
  136.             id: $coleccion->getId(),
  137.             nombre: $coleccion->getNombre(),
  138.             descripcion: $coleccion->getDescripcion(),
  139.             metadata: [
  140.                 'programa' => $coleccion->getPrograma()?->getNombre(),
  141.             ]
  142.         );
  143.     }
  145.     private function createSearchResultFromComposicion(Composicion $composicion): SearchResult
  146.     {
  147.         return new SearchResult(
  148.             type: 'composicion',
  149.             id: $composicion->getId(),
  150.             nombre: $composicion->getNombre(),
  151.             descripcion: null,
  152.             metadata: [
  153.                 'modelo' => $composicion->getModelo()?->getNombre(),
  154.                 'precio' => $composicion->getPrecio(),
  155.             ]
  156.         );
  157.     }
  159.     private function createSearchResultFromPrograma(Programa $programa): SearchResult
  160.     {
  161.         return new SearchResult(
  162.             type: 'programa',
  163.             id: $programa->getId(),
  164.             nombre: $programa->getNombre(),
  165.             descripcion: $programa->getDescripcion(),
  166.             metadata: []
  167.         );
  168.     }
  170.     private function createSearchResultFromDestacada(Destacada $destacada): SearchResult
  171.     {
  172.         return new SearchResult(
  173.             type: 'destacada',
  174.             id: $destacada->getId(),
  175.             nombre: $destacada->getNombre(),
  176.             descripcion: null,
  177.             metadata: [
  178.                 'activo' => $destacada->getActivo(),
  179.             ]
  180.         );
  181.     }
  182. }