"""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