170 lines
7.6 KiB
Python
170 lines
7.6 KiB
Python
"""Búsqueda por contenido en Elasticsearch (índice que arma FSCrawler).
|
|
|
|
Reglas (las mismas que antes, ahora como consulta de Elasticsearch):
|
|
- Cédula: con o sin puntos ("1234567", "1.234.567", "1,234,567") en el contenido,
|
|
o dentro de la ruta/nombre del archivo.
|
|
- Nombre, en cualquier orden:
|
|
* completo: aparecen TODOS los nombres y apellidos cerca entre sí.
|
|
* parcial: aparecen el primer nombre y el primer apellido juntos ("Juan Pérez", "Pérez, Juan").
|
|
|
|
Orden de los resultados: cédula + nombre > cédula > nombre completo > nombre parcial,
|
|
y dentro de cada grupo, el archivo modificado más recientemente primero.
|
|
|
|
Campos que usa (los que genera FSCrawler): content, file.filename, file.extension,
|
|
file.filesize, file.last_modified, path.virtual.
|
|
"""
|
|
import re
|
|
from dataclasses import dataclass
|
|
from datetime import datetime
|
|
|
|
from app import elastic
|
|
from app.config import get_settings
|
|
from app.utils import normalizar, solo_digitos
|
|
|
|
DISTANCIA_COMPLETO = 6 # máximo de palabras entre nombres/apellidos para "completo"
|
|
DISTANCIA_PARCIAL = 2 # "Juan Pérez", "Pérez, Juan", "Juan C. Pérez"
|
|
|
|
# Puntaje fijo por tipo de coincidencia: define el orden sin depender de la relevancia
|
|
PESO_CEDULA, PESO_COMPLETO, PESO_PARCIAL = 1000, 100, 10
|
|
|
|
CAMPOS = ["file.filename", "file.extension", "file.filesize", "file.last_modified", "path.virtual"]
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Palabra:
|
|
original: str # como la escribió el usuario, en minúsculas ("pérez")
|
|
normal: str # sin tildes ("perez")
|
|
|
|
|
|
@dataclass
|
|
class Coincidencia:
|
|
doc_id: str
|
|
nombre: str
|
|
ruta_relativa: str
|
|
carpeta: str
|
|
extension: str
|
|
tamano_bytes: int
|
|
modificado_en: datetime | None
|
|
coincide_cedula: bool
|
|
coincide_nombre: str | None # "completo" | "parcial" | None
|
|
fragmento: str
|
|
|
|
|
|
def _palabras(texto: str | None) -> list[Palabra]:
|
|
# Solo letras y números: el texto del usuario nunca llega crudo a la consulta
|
|
return [Palabra(p, normalizar(p)) for p in re.split(r"[^\w]+", (texto or "").lower().replace("_", " ")) if p]
|
|
|
|
|
|
def validar(cedula: str | None, nombres: str | None,
|
|
apellidos: str | None) -> tuple[str, list[Palabra], list[Palabra]]:
|
|
"""Devuelve (cedula_limpia, palabras_nombres, palabras_apellidos) o lanza ValueError."""
|
|
ced = solo_digitos(cedula or "")
|
|
if cedula and len(ced) < 5:
|
|
raise ValueError("La cédula debe tener al menos 5 dígitos")
|
|
nom, ape = _palabras(nombres), _palabras(apellidos)
|
|
if (nom and not ape) or (ape and not nom):
|
|
raise ValueError("Para buscar por nombre enviá nombres y apellidos juntos")
|
|
if not ced and not nom:
|
|
raise ValueError("Enviá la cédula, o nombres y apellidos (o los tres)")
|
|
return ced, nom, ape
|
|
|
|
|
|
def variantes_cedula(cedula: str) -> list[str]:
|
|
"""'1234567' -> ['1234567', '1.234.567', '1,234,567'].
|
|
Elasticsearch guarda "1.234.567" como una sola palabra, por eso se buscan las tres formas."""
|
|
grupos, resto = [], cedula
|
|
while len(resto) > 3:
|
|
grupos.insert(0, resto[-3:])
|
|
resto = resto[:-3]
|
|
grupos.insert(0, resto)
|
|
return list(dict.fromkeys([cedula, ".".join(grupos), ",".join(grupos)]))
|
|
|
|
|
|
def _regla(p: Palabra) -> dict:
|
|
"""Busca la palabra con y sin tilde. Si el índice ya ignora tildes (asciifolding),
|
|
las dos formas dan lo mismo; si no, al menos coincide lo que se escribió igual."""
|
|
if p.original == p.normal:
|
|
return {"match": {"query": p.normal}}
|
|
return {"any_of": {"intervals": [{"match": {"query": p.original}}, {"match": {"query": p.normal}}]}}
|
|
|
|
|
|
def _cerca(palabras: list[Palabra], distancia: int) -> dict:
|
|
return {"intervals": {"content": {"all_of": {
|
|
"ordered": False, "max_gaps": distancia, "intervals": [_regla(p) for p in palabras]}}}}
|
|
|
|
|
|
def armar_consulta(cedula: str, nombres: list[Palabra], apellidos: list[Palabra], limite: int) -> dict:
|
|
"""Cuerpo de la búsqueda para Elasticsearch (función aparte para poder probarla)."""
|
|
should, resaltar = [], []
|
|
|
|
if cedula:
|
|
variantes = variantes_cedula(cedula)
|
|
filtro = {"bool": {"should": [{"match_phrase": {"content": v}} for v in variantes]
|
|
+ [{"wildcard": {"path.virtual": {"value": f"*{cedula}*"}}}]}}
|
|
should.append({"constant_score": {"filter": filtro, "boost": PESO_CEDULA, "_name": "cedula"}})
|
|
resaltar += [{"match_phrase": {"content": v}} for v in variantes]
|
|
|
|
if nombres:
|
|
todas = nombres + apellidos
|
|
should.append({"constant_score": {"filter": _cerca(todas, DISTANCIA_COMPLETO),
|
|
"boost": PESO_COMPLETO, "_name": "nombre_completo"}})
|
|
should.append({"constant_score": {"filter": _cerca([nombres[0], apellidos[0]], DISTANCIA_PARCIAL),
|
|
"boost": PESO_PARCIAL, "_name": "nombre_parcial"}})
|
|
palabras = " ".join(dict.fromkeys([p.original for p in todas] + [p.normal for p in todas]))
|
|
resaltar.append({"match": {"content": palabras}})
|
|
|
|
# Segunda barrera: carpetas que nunca se devuelven aunque FSCrawler las haya indexado
|
|
excluir = [{"prefix": {"path.virtual": f"/{c}/"}} for c in get_settings().carpetas_excluidas]
|
|
|
|
return {
|
|
"query": {"bool": {"should": should, "minimum_should_match": 1, "must_not": excluir}},
|
|
"sort": ["_score", {"file.last_modified": {"order": "desc", "unmapped_type": "date"}}],
|
|
"size": limite,
|
|
"track_total_hits": True,
|
|
"_source": CAMPOS, # nunca se trae "content": puede pesar megas por documento
|
|
"highlight": {
|
|
"pre_tags": ["«"], "post_tags": ["»"],
|
|
"fields": {"content": {"type": "unified", "fragment_size": 160, "number_of_fragments": 1,
|
|
"highlight_query": {"bool": {"should": resaltar}}}},
|
|
},
|
|
}
|
|
|
|
|
|
def a_ruta_relativa(path_virtual: str) -> str:
|
|
"""FSCrawler guarda '/IPS/planilla.xlsx' relativo a la carpeta que recorre (fs.url)."""
|
|
return path_virtual.lstrip("/")
|
|
|
|
|
|
def _extension(valor: str | None) -> str:
|
|
valor = (valor or "").lower()
|
|
return valor if not valor or valor.startswith(".") else f".{valor}" # FSCrawler guarda "pdf"
|
|
|
|
|
|
def buscar(cedula: str, nombres: list[Palabra], apellidos: list[Palabra],
|
|
limite: int) -> tuple[list[Coincidencia], int]:
|
|
"""Devuelve (las `limite` mejores coincidencias, total de archivos que coinciden)."""
|
|
respuesta = elastic.buscar(armar_consulta(cedula, nombres, apellidos, limite))
|
|
hits = respuesta.get("hits", {})
|
|
total = hits.get("total", {})
|
|
total = total.get("value", 0) if isinstance(total, dict) else int(total)
|
|
|
|
resultados = []
|
|
for h in hits.get("hits", []):
|
|
fuente = h.get("_source", {})
|
|
archivo, ruta = fuente.get("file", {}), fuente.get("path", {})
|
|
nombradas = h.get("matched_queries", []) # lista (o dict en versiones nuevas)
|
|
ruta_rel = a_ruta_relativa(ruta.get("virtual", ""))
|
|
resultados.append(Coincidencia(
|
|
doc_id=h["_id"],
|
|
nombre=archivo.get("filename") or ruta_rel.rsplit("/", 1)[-1],
|
|
ruta_relativa=ruta_rel,
|
|
carpeta=ruta_rel.rsplit("/", 1)[0] if "/" in ruta_rel else "",
|
|
extension=_extension(archivo.get("extension")),
|
|
tamano_bytes=int(archivo.get("filesize") or 0),
|
|
modificado_en=archivo.get("last_modified"),
|
|
coincide_cedula="cedula" in nombradas,
|
|
coincide_nombre=("completo" if "nombre_completo" in nombradas
|
|
else "parcial" if "nombre_parcial" in nombradas else None),
|
|
fragmento=" ".join(" ".join(h.get("highlight", {}).get("content", [""])).split()),
|
|
))
|
|
return resultados, total |