feat(parity): implement Bloques 1, 2 y 3 complete feature parity v0.7.0-beta
This commit is contained in:
@@ -1,7 +1,7 @@
|
||||
# ==============================================================================
|
||||
# OnEverControl - Versión del Backend
|
||||
# ==============================================================================
|
||||
__version__ = "0.6.2"
|
||||
__build__ = "2026.10.14"
|
||||
__version__ = "0.7.0-beta"
|
||||
__build__ = "2026.10.29"
|
||||
__app_name__ = "OnEverControl"
|
||||
__description__ = "Cliente Web Reducido para Puesto de Control en Red Local de OnEverAccess"
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
# ==============================================================================
|
||||
# Rutas de Control de Accesos (Ingreso, Egreso, Tickets y Búsquedas)
|
||||
# ==============================================================================
|
||||
from typing import List
|
||||
from typing import List, Dict, Any, Optional
|
||||
from fastapi import APIRouter, Depends, Query, HTTPException, status
|
||||
from pydantic import BaseModel, Field
|
||||
from app.schemas.access_schema import (
|
||||
@@ -16,6 +16,10 @@ from app.schemas.access_schema import (
|
||||
TicketOccupantDTO,
|
||||
PersonPoliciesDTO,
|
||||
VehicleDetailsDTO,
|
||||
PreauthorizationDTO,
|
||||
VehicleSearchResultDTO,
|
||||
MassExitRequestDTO,
|
||||
MassExitResultDTO,
|
||||
)
|
||||
from app.services.access_service import AccessService
|
||||
from app.services.dni_parser_service import DNIParsingService, DNIParsedResult
|
||||
@@ -170,3 +174,63 @@ def consultar_datos_vehiculo(
|
||||
)
|
||||
return res
|
||||
|
||||
|
||||
@router.get("/preauthorizations", response_model=List[PreauthorizationDTO], summary="Listar visitas preautorizadas")
|
||||
def listar_preautorizaciones(
|
||||
q: str = Query("", description="Filtro de búsqueda por visitante, lote o entidad"),
|
||||
solo_vigentes: bool = Query(True, description="Filtrar únicamente preautorizaciones vigentes"),
|
||||
current_user: dict = Depends(obtener_usuario_actual),
|
||||
):
|
||||
"""Retorna listado de visitas preautorizadas activas desde la tabla 'pre'."""
|
||||
return AccessService.listar_preautorizados(busqueda=q, solo_vigentes=solo_vigentes)
|
||||
|
||||
|
||||
@router.post("/preauthorizations/{id}/consume", summary="Consumir visita preautorizada")
|
||||
def consumir_preautorizacion(
|
||||
id: int,
|
||||
current_user: dict = Depends(obtener_usuario_actual),
|
||||
):
|
||||
"""Marca como consumida (o elimina) una preautorización tras generar el ingreso."""
|
||||
ok = AccessService.consumir_preautorizado(id)
|
||||
if not ok:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail=f"No se pudo consumir la preautorización #{id}.",
|
||||
)
|
||||
return {"status": "ok", "message": f"Preautorización #{id} consumida exitosamente."}
|
||||
|
||||
|
||||
@router.get("/people/advanced-search", response_model=List[Dict[str, Any]], summary="Búsqueda avanzada multi-criterio de personas")
|
||||
def buscar_personas_avanzado(
|
||||
q: str = Query("", description="Búsqueda por apellido, nombre, DNI, nro socio o lote"),
|
||||
limite: int = Query(50, ge=1, le=200),
|
||||
current_user: dict = Depends(obtener_usuario_actual),
|
||||
):
|
||||
"""Búsqueda avanzada idéntica a DialogoBuscarPersona de escritorio."""
|
||||
return AccessService.buscar_personas_avanzado(texto=q, limite=limite)
|
||||
|
||||
|
||||
@router.get("/vehicles/search", response_model=List[VehicleSearchResultDTO], summary="Búsqueda predictiva y parcial de vehículos")
|
||||
def buscar_vehiculos(
|
||||
q: str = Query("", description="Búsqueda por patente, marca, modelo o titular"),
|
||||
es_salida: bool = Query(False, description="True si busca vehículos ingresados en el predio"),
|
||||
limite: int = Query(50, ge=1, le=200),
|
||||
current_user: dict = Depends(obtener_usuario_actual),
|
||||
):
|
||||
"""Búsqueda predictiva idéntica a DialogoBuscarPatente de escritorio."""
|
||||
return AccessService.buscar_vehiculos(termino=q, es_salida=es_salida, limite=limite)
|
||||
|
||||
|
||||
@router.post("/mass-exit", response_model=MassExitResultDTO, summary="Ejecutar salida masiva transaccional")
|
||||
def ejecutar_salida_masiva(
|
||||
req: MassExitRequestDTO,
|
||||
current_user: dict = Depends(obtener_usuario_actual),
|
||||
):
|
||||
"""
|
||||
Ejecuta el egreso atómico de múltiples personas/vehículos dentro del predio.
|
||||
Paridad 1:1 con DlgSalidaMasiva de escritorio.
|
||||
"""
|
||||
u_id = current_user.get("user_id", 0)
|
||||
u_nom = current_user.get("username", "Operador")
|
||||
return AccessService.procesar_salida_masiva(req=req, usuario_id=u_id, operador=u_nom)
|
||||
|
||||
|
||||
@@ -46,3 +46,41 @@ async def abrir_barrera_manual(
|
||||
message=f"Comando de apertura encolado para módulo {modulo_id} ({req.motivo})",
|
||||
latencia_ms=res["latencia_ms"],
|
||||
)
|
||||
|
||||
|
||||
@router.post(
|
||||
"/modules/{modulo_id}/close",
|
||||
response_model=HardwareCommandResponse,
|
||||
summary="Cierre manual o forzado de barrera",
|
||||
)
|
||||
async def cerrar_barrera_manual(
|
||||
modulo_id: int,
|
||||
req: ManualOpenRequest,
|
||||
current_user: dict = Depends(obtener_usuario_actual),
|
||||
):
|
||||
"""
|
||||
Encola un comando de cierre forzado inmediato en la tabla pdtmdl (tramas C0..C6).
|
||||
Paridad con pct_repository.py:encolar_comando_cierre_modulo (v1.2.3).
|
||||
"""
|
||||
ok, res = HardwareService.encolar_cierre(modulo_id=modulo_id, ticket_id=req.ticket_id or 0)
|
||||
if not ok:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail=res.get("error", "Error al encolar comando de cierre de hardware"),
|
||||
)
|
||||
|
||||
await ws_manager.broadcast_all({
|
||||
"type": "barrier_closed",
|
||||
"modulo_id": modulo_id,
|
||||
"motivo": req.motivo,
|
||||
"operador": current_user.get("username", "guardia"),
|
||||
})
|
||||
|
||||
return HardwareCommandResponse(
|
||||
status="ok",
|
||||
modulo_id=modulo_id,
|
||||
address=res["address"],
|
||||
payload=res["payload"],
|
||||
message=f"Comando de cierre forzado encolado para módulo {modulo_id} ({req.motivo})",
|
||||
latencia_ms=res["latencia_ms"],
|
||||
)
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
# ==============================================================================
|
||||
# Repositorio de Control de Accesos (SQL Server videoman)
|
||||
# ==============================================================================
|
||||
import re
|
||||
from datetime import datetime
|
||||
from typing import Optional, List, Dict, Any, Tuple
|
||||
from app.core.database import db_session
|
||||
@@ -191,6 +192,13 @@ class AccessRepository:
|
||||
except Exception as e:
|
||||
print(f"Nota: error al guardar polizas/vehiculo: {e}")
|
||||
|
||||
# 7. Consumir preautorización atómicamente si fue provista
|
||||
if getattr(req, "preautorizado_id", None):
|
||||
try:
|
||||
AccessRepository.consumir_preautorizacion(req.preautorizado_id)
|
||||
except Exception as e:
|
||||
print(f"Nota: error al consumir preautorizacion {req.preautorizado_id}: {e}")
|
||||
|
||||
return ticket_id
|
||||
|
||||
@staticmethod
|
||||
@@ -947,3 +955,318 @@ class AccessRepository:
|
||||
|
||||
return True
|
||||
|
||||
@staticmethod
|
||||
def obtener_preautorizados_activos(busqueda: str = "", solo_vigentes: bool = True) -> List[Dict[str, Any]]:
|
||||
"""Consulta visitas preautorizadas activas en la tabla 'pre'."""
|
||||
where_clauses = []
|
||||
params = []
|
||||
|
||||
if solo_vigentes:
|
||||
where_clauses.append("pr.FechaInicio <= DATEADD(day, 1, GETDATE()) AND pr.FechaFin >= DATEADD(day, -1, GETDATE())")
|
||||
|
||||
if busqueda:
|
||||
palabras = [w.strip() for w in busqueda.split() if w.strip()]
|
||||
for w in palabras:
|
||||
p_like = f"%{w}%"
|
||||
where_clauses.append("(pr.Apellido LIKE %s OR pr.Nombre LIKE %s OR pr.Entidad LIKE %s OR pr.Motivo LIKE %s OR l.Lote LIKE %s)")
|
||||
params.extend([p_like, p_like, p_like, p_like, p_like])
|
||||
|
||||
where_sql = ("WHERE " + " AND ".join(where_clauses)) if where_clauses else ""
|
||||
|
||||
sql = f"""
|
||||
SELECT
|
||||
pr.PreautorizadoID AS id,
|
||||
pr.LoteID AS lote_id,
|
||||
ISNULL(l.Lote, 'Sin Lote') AS lote_nombre,
|
||||
ISNULL(pr.Apellido, '') AS apellido,
|
||||
ISNULL(pr.Nombre, '') AS nombre,
|
||||
ISNULL(pr.Entidad, '') AS entidad,
|
||||
ISNULL(pr.Motivo, '') AS motivo,
|
||||
CONVERT(varchar, pr.FechaInicio, 120) AS fecha_inicio,
|
||||
CONVERT(varchar, pr.FechaFin, 120) AS fecha_fin
|
||||
FROM pre pr
|
||||
LEFT JOIN Lot l ON pr.LoteID = l.LoteID
|
||||
{where_sql}
|
||||
ORDER BY pr.FechaInicio DESC
|
||||
"""
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
cursor.execute(sql, tuple(params) if params else None)
|
||||
rows = cursor.fetchall()
|
||||
for r in rows:
|
||||
motivo_val = str(r.get('motivo') or '').strip()
|
||||
doc_val = motivo_val if (motivo_val.isdigit() or (len(motivo_val) <= 12 and not ' ' in motivo_val)) else ""
|
||||
r["documento"] = doc_val
|
||||
return rows
|
||||
|
||||
@staticmethod
|
||||
def consumir_preautorizacion(preautorizado_id: int) -> bool:
|
||||
"""Elimina o da por consumida la preautorización tras generar el ticket."""
|
||||
if not preautorizado_id:
|
||||
return False
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor()
|
||||
cursor.execute("DELETE FROM pre WHERE PreautorizadoID = %s", (preautorizado_id,))
|
||||
return True
|
||||
|
||||
@staticmethod
|
||||
def buscar_personas_avanzado(texto: str, limite: int = 50) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Búsqueda avanzada multi-palabra de personas por Apellido, Nombre, Documento, NroSocio o Lote.
|
||||
Idéntico a DialogoBuscarPersona (pct_dialogs.py).
|
||||
"""
|
||||
palabras = [w.strip() for w in texto.split() if w.strip()] if texto else []
|
||||
where_clauses = []
|
||||
params = []
|
||||
|
||||
for p in palabras:
|
||||
like_str = f"%{p}%"
|
||||
where_clauses.append("""
|
||||
(p.Apellido LIKE %s OR p.Nombre LIKE %s OR EXISTS (
|
||||
SELECT 1 FROM PerDocCatVal d WHERE d.PersonaID = p.PersonaID AND d.Documento LIKE %s
|
||||
) OR CAST(p.NroSocio AS VARCHAR) LIKE %s OR EXISTS (
|
||||
SELECT 1 FROM lotper lp
|
||||
INNER JOIN lot l ON lp.LoteID = l.LoteID
|
||||
WHERE lp.PersonaID = p.PersonaID AND (l.Lote LIKE %s OR CAST(lp.LoteID AS VARCHAR) LIKE %s)
|
||||
))
|
||||
""")
|
||||
params.extend([like_str, like_str, like_str, like_str, like_str, like_str])
|
||||
|
||||
where_sql = ("WHERE " + " AND ".join(where_clauses)) if where_clauses else ""
|
||||
|
||||
sql = f"""
|
||||
SELECT TOP {int(limite)}
|
||||
p.PersonaID,
|
||||
p.Apellido,
|
||||
p.Nombre,
|
||||
p.NroSocio,
|
||||
COALESCE(p.Blacklist, 0) AS Blacklist,
|
||||
(SELECT TOP 1 d.Documento FROM PerDocCatVal d WHERE d.PersonaID = p.PersonaID ORDER BY d.DocumentoID) AS Documento
|
||||
FROM Per p
|
||||
{where_sql}
|
||||
ORDER BY p.Apellido, p.Nombre
|
||||
"""
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
cursor.execute(sql, tuple(params) if params else None)
|
||||
return cursor.fetchall()
|
||||
|
||||
@staticmethod
|
||||
def buscar_vehiculos_coincidencias(termino: str, es_salida: bool = False, limite: int = 50) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Búsqueda predictiva y parcial de vehículos (LIKE %...%) por patente, marca, modelo, o titular.
|
||||
En Salida: busca vehículos con tickets activos dentro del predio.
|
||||
En Entrada: busca en el maestro de vehículos (Aut) con sus conductores/titulares vinculados.
|
||||
Paridad exacta con pct_repository.py:buscar_vehiculos_coincidencias.
|
||||
"""
|
||||
t_clean = re.sub(r'[\s\-]', '', str(termino or "")).upper()
|
||||
patron_like = f"%{t_clean}%" if t_clean else "%"
|
||||
patron_text = f"%{str(termino or '').strip().upper()}%" if termino else "%"
|
||||
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
if es_salida:
|
||||
sql = f"""
|
||||
SELECT TOP ({limite})
|
||||
t.TicketID AS ticket_id,
|
||||
px.Valor AS patente,
|
||||
ISNULL(a.Marca, '') AS marca,
|
||||
ISNULL(a.Modelo, '') AS modelo,
|
||||
p.PersonaID AS persona_id,
|
||||
ISNULL(p.Apellido, '') AS apellido,
|
||||
ISNULL(p.Nombre, '') AS nombre,
|
||||
ISNULL(d.Documento, '') AS documento,
|
||||
COALESCE(
|
||||
(SELECT TOP 1 l.Lote FROM Lot l INNER JOIN tckprx pxl ON CAST(l.LoteID AS VARCHAR) = pxl.Valor WHERE pxl.TicketID = t.TicketID AND pxl.PropiedadID = 7),
|
||||
(SELECT TOP 1 l.Lote FROM Lot l INNER JOIN tckprx pxl ON l.Lote = px.Valor WHERE pxl.TicketID = t.TicketID AND pxl.PropiedadID = 7),
|
||||
(SELECT TOP 1 Valor FROM tckprx WHERE TicketID = t.TicketID AND PropiedadID = 7),
|
||||
''
|
||||
) AS lote,
|
||||
CONVERT(varchar, t.FechaHoraIngreso, 120) AS fecha_ingreso,
|
||||
'' AS vigencia_seguro
|
||||
FROM tck t
|
||||
INNER JOIN tckprx px ON t.TicketID = px.TicketID AND px.PropiedadID = 4
|
||||
LEFT JOIN aut a ON REPLACE(REPLACE(UPPER(LTRIM(RTRIM(a.Patente))), ' ', ''), '-', '') = REPLACE(REPLACE(UPPER(LTRIM(RTRIM(px.Valor))), ' ', ''), '-', '')
|
||||
INNER JOIN tckper tp ON t.TicketID = tp.TicketID AND (tp.RolID = 1 OR tp.RolID IS NULL)
|
||||
INNER JOIN Per p ON tp.PersonaID = p.PersonaID
|
||||
LEFT JOIN PerDocCatVal d ON p.PersonaID = d.PersonaID
|
||||
WHERE (
|
||||
REPLACE(REPLACE(UPPER(LTRIM(RTRIM(px.Valor))), ' ', ''), '-', '') LIKE %s
|
||||
OR UPPER(p.Apellido) LIKE %s
|
||||
OR UPPER(p.Nombre) LIKE %s
|
||||
OR d.Documento LIKE %s
|
||||
OR UPPER(a.Marca) LIKE %s
|
||||
)
|
||||
ORDER BY t.FechaHoraIngreso DESC
|
||||
"""
|
||||
cursor.execute(sql, (patron_like, patron_text, patron_text, patron_like, patron_text))
|
||||
else:
|
||||
sql = f"""
|
||||
SELECT TOP ({limite})
|
||||
0 AS ticket_id,
|
||||
UPPER(LTRIM(RTRIM(a.Patente))) AS patente,
|
||||
ISNULL(a.Marca, '') AS marca,
|
||||
ISNULL(a.Modelo, '') AS modelo,
|
||||
p.PersonaID AS persona_id,
|
||||
ISNULL(p.Apellido, '') AS apellido,
|
||||
ISNULL(p.Nombre, '') AS nombre,
|
||||
ISNULL(d.Documento, '') AS documento,
|
||||
'' AS lote,
|
||||
'' AS fecha_ingreso,
|
||||
CONVERT(varchar, a.PolizaVigenciaHasta, 120) AS vigencia_seguro
|
||||
FROM aut a
|
||||
LEFT JOIN peraut pa ON a.AutoID = pa.AutoID
|
||||
LEFT JOIN Per p ON pa.PersonaID = p.PersonaID
|
||||
LEFT JOIN PerDocCatVal d ON p.PersonaID = d.PersonaID
|
||||
WHERE (
|
||||
REPLACE(REPLACE(UPPER(LTRIM(RTRIM(a.Patente))), ' ', ''), '-', '') LIKE %s
|
||||
OR UPPER(a.Marca) LIKE %s
|
||||
OR UPPER(a.Modelo) LIKE %s
|
||||
OR UPPER(p.Apellido) LIKE %s
|
||||
OR UPPER(p.Nombre) LIKE %s
|
||||
OR d.Documento LIKE %s
|
||||
)
|
||||
ORDER BY a.Patente ASC
|
||||
"""
|
||||
cursor.execute(sql, (patron_like, patron_text, patron_text, patron_text, patron_text, patron_like))
|
||||
|
||||
return cursor.fetchall()
|
||||
|
||||
@staticmethod
|
||||
def ejecutar_salida_masiva(
|
||||
ticket_ids: List[int],
|
||||
usuario_id: int,
|
||||
operador: str,
|
||||
modulo_salida_id: int,
|
||||
motivo: str = "Toque de queda / Cierre de jornada",
|
||||
observaciones: str = "",
|
||||
) -> Tuple[bool, str, int]:
|
||||
"""
|
||||
Ejecuta la salida masiva de múltiples personas/visitas en una única transacción atómica:
|
||||
1. Crea el registro maestro en salida_masiva.
|
||||
2. Registra el desglose en salida_masiva_detalle.
|
||||
3. Cierra y migra cada ticket activo a tckhst.
|
||||
4. Registra los snapshots correspondientes en mvthist con flag 'Salida Masiva'.
|
||||
5. Genera la traza inmutable en auditoria_cambios.
|
||||
Paridad exacta con pct_repository.py:ejecutar_salida_masiva.
|
||||
"""
|
||||
if not ticket_ids:
|
||||
return False, "No se seleccionaron personas para registrar salida masiva.", 0
|
||||
|
||||
ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||||
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
|
||||
# 1. Registro Maestro en salida_masiva
|
||||
sql_master = """
|
||||
INSERT INTO dbo.salida_masiva (
|
||||
FechaHora, UsuarioID, Operador, CantidadPersonas, ModuloSalidaID, Motivo, Observaciones
|
||||
) VALUES (%s, %s, %s, %s, %s, %s, %s)
|
||||
"""
|
||||
cursor.execute(sql_master, (
|
||||
ahora, usuario_id or 0, operador or "Operador",
|
||||
len(ticket_ids), modulo_salida_id or 0,
|
||||
motivo or "Toque de queda / Cierre de jornada",
|
||||
observaciones or "Salida masiva procesada desde Puesto de Control"
|
||||
))
|
||||
|
||||
cursor.execute("SELECT SCOPE_IDENTITY() AS ID")
|
||||
row_id = cursor.fetchone()
|
||||
salida_masiva_id = int(row_id['ID'] if row_id and row_id.get('ID') else 0)
|
||||
|
||||
# 2. Desglose y cierre de cada ticket seleccionado
|
||||
tickets_cerrados = set()
|
||||
for tck_id in ticket_ids:
|
||||
# Obtener datos de la persona vinculada al ticket
|
||||
sql_p = """
|
||||
SELECT TOP 1
|
||||
t.Numero, t.FechaHoraIngreso, t.ModuloIngresoID,
|
||||
tp.PersonaID, p.Apellido, p.Nombre, tp.RolID,
|
||||
(SELECT TOP 1 d.Documento FROM PerDocCatVal d WHERE d.PersonaID = tp.PersonaID ORDER BY d.DocumentoID) AS Documento,
|
||||
(SELECT TOP 1 px.Valor FROM tckprx px WHERE px.TicketID = t.TicketID AND px.PropiedadID = 4) AS Patente,
|
||||
(SELECT TOP 1 px.Valor FROM tckprx px WHERE px.TicketID = t.TicketID AND px.PropiedadID = 7) AS LoteID,
|
||||
(SELECT TOP 1 px.Valor FROM tckprx px WHERE px.TicketID = t.TicketID AND px.PropiedadID = 11) AS Entidad
|
||||
FROM tck t
|
||||
LEFT JOIN tckper tp ON t.TicketID = tp.TicketID AND (tp.RolID = 1 OR tp.RolID IS NULL)
|
||||
LEFT JOIN Per p ON tp.PersonaID = p.PersonaID
|
||||
WHERE t.TicketID = %s
|
||||
"""
|
||||
cursor.execute(sql_p, (tck_id,))
|
||||
p_info = cursor.fetchone() or {}
|
||||
|
||||
p_id = int(p_info.get("PersonaID") or 0)
|
||||
doc = str(p_info.get("Documento") or "")
|
||||
ape = str(p_info.get("Apellido") or "")
|
||||
nom = str(p_info.get("Nombre") or "")
|
||||
lot_id = p_info.get("LoteID")
|
||||
pat = str(p_info.get("Patente") or "")
|
||||
ent = str(p_info.get("Entidad") or "SALIDA MASIVA")
|
||||
rol_id = int(p_info.get("RolID") or 1)
|
||||
|
||||
sql_det = """
|
||||
INSERT INTO dbo.salida_masiva_detalle (
|
||||
SalidaMasivaID, TicketID, PersonaID, Documento, Apellido, Nombre,
|
||||
LoteID, NombreLote, Patente, Entidad, RolID
|
||||
) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||||
"""
|
||||
cursor.execute(sql_det, (
|
||||
salida_masiva_id, tck_id, p_id, doc, ape, nom,
|
||||
int(lot_id) if lot_id and str(lot_id).isdigit() else None,
|
||||
str(lot_id or ""), pat, ent, rol_id
|
||||
))
|
||||
|
||||
if tck_id and tck_id not in tickets_cerrados:
|
||||
num_tck = p_info.get("Numero") or 0
|
||||
f_ing = p_info.get("FechaHoraIngreso")
|
||||
if isinstance(f_ing, str) == False and f_ing is not None:
|
||||
f_ing = f_ing.strftime('%Y-%m-%d %H:%M:%S')
|
||||
mod_ing = p_info.get("ModuloIngresoID") or 0
|
||||
|
||||
cursor.execute("SELECT TicketID FROM tckhst WHERE TicketID = %s", (tck_id,))
|
||||
if cursor.fetchone():
|
||||
nuevo_tck_id = AccessRepository.generar_ticket_id()
|
||||
cursor.execute("UPDATE tckper SET TicketID = %s WHERE TicketID = %s", (nuevo_tck_id, tck_id))
|
||||
cursor.execute("UPDATE tckprx SET TicketID = %s WHERE TicketID = %s", (nuevo_tck_id, tck_id))
|
||||
cursor.execute("UPDATE tck SET TicketID = %s WHERE TicketID = %s", (nuevo_tck_id, tck_id))
|
||||
cursor.execute("UPDATE dbo.salida_masiva_detalle SET TicketID = %s WHERE TicketID = %s AND SalidaMasivaID = %s",
|
||||
(nuevo_tck_id, tck_id, salida_masiva_id))
|
||||
tck_id = nuevo_tck_id
|
||||
|
||||
sql_tckhst = """
|
||||
INSERT INTO tckhst (TicketID, Numero, FechaHoraIngreso, ModuloIngresoID, FechaHoraSalida, ModuloSalidaID)
|
||||
VALUES (%s, %s, %s, %s, %s, %s)
|
||||
"""
|
||||
cursor.execute(sql_tckhst, (tck_id, num_tck, str(f_ing or ahora), mod_ing, ahora, modulo_salida_id or 0))
|
||||
cursor.execute("DELETE FROM tck WHERE TicketID = %s", (tck_id,))
|
||||
tickets_cerrados.add(tck_id)
|
||||
|
||||
sql_mvt = """
|
||||
INSERT INTO mvthist (TicketID, PersonaID, Patente, LoteID, RolID, Entidad, Sentido, ModuloID, FechaHora)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, 'Salida', %s, %s)
|
||||
"""
|
||||
cursor.execute(sql_mvt, (
|
||||
tck_id, p_id,
|
||||
(pat.strip() if pat else None),
|
||||
int(lot_id) if lot_id and str(lot_id).isdigit() else None,
|
||||
rol_id,
|
||||
f"SALIDA MASIVA ({ent})" if ent and ent != '-' else "SALIDA MASIVA",
|
||||
modulo_salida_id or 0,
|
||||
ahora
|
||||
))
|
||||
|
||||
# 3. Trazabilidad en auditoria_cambios
|
||||
sql_audit = """
|
||||
INSERT INTO dbo.auditoria_cambios (
|
||||
Modulo, Entidad, EntidadID, Operacion, CampoModificado, ValorNuevo, UsuarioID, FechaHora
|
||||
) VALUES ('PuestoControl', 'SalidaMasiva', %s, 'SALIDA_MASIVA', 'CantidadPersonas', %s, %s, %s)
|
||||
"""
|
||||
cursor.execute(sql_audit, (
|
||||
str(salida_masiva_id),
|
||||
f"{len(ticket_ids)} personas egresadas ({motivo})",
|
||||
usuario_id or 0,
|
||||
ahora
|
||||
))
|
||||
|
||||
return True, f"Se registró la salida masiva de {len(ticket_ids)} persona(s) exitosamente.", salida_masiva_id
|
||||
|
||||
|
||||
@@ -50,6 +50,7 @@ class EntryRequest(BaseModel):
|
||||
licencia_hasta: Optional[str] = None
|
||||
observaciones: Optional[str] = None
|
||||
forzar_ingreso_lote_restringido: bool = False
|
||||
preautorizado_id: Optional[int] = Field(None, description="ID de preautorización en tabla pre a consumir")
|
||||
|
||||
|
||||
class PersonPoliciesDTO(BaseModel):
|
||||
@@ -71,6 +72,10 @@ class PersonPoliciesDTO(BaseModel):
|
||||
licencia_nro: Optional[str] = None
|
||||
licencia_entidad: Optional[str] = None
|
||||
licencia_hasta: Optional[str] = None
|
||||
observaciones: Optional[str] = None
|
||||
ticket_activo_id: Optional[int] = None
|
||||
ticket_activo_modulo_ingreso: Optional[str] = None
|
||||
ticket_activo_fecha: Optional[str] = None
|
||||
|
||||
|
||||
class VehicleDetailsDTO(BaseModel):
|
||||
@@ -83,6 +88,7 @@ class VehicleDetailsDTO(BaseModel):
|
||||
apellido: Optional[str] = None
|
||||
nombre: Optional[str] = None
|
||||
documento: Optional[str] = None
|
||||
ticket_activo_id: Optional[int] = None
|
||||
|
||||
|
||||
|
||||
@@ -180,4 +186,46 @@ class MovementHistoryDTO(BaseModel):
|
||||
lote_codigo: Optional[str] = None
|
||||
modulo_nombre: Optional[str] = None
|
||||
fecha_hora: str
|
||||
|
||||
|
||||
class PreauthorizationDTO(BaseModel):
|
||||
id: int
|
||||
lote_id: int = 0
|
||||
lote_nombre: str = ""
|
||||
entidad: str = ""
|
||||
apellido: str = ""
|
||||
nombre: str = ""
|
||||
documento: str = ""
|
||||
motivo: str = ""
|
||||
fecha_inicio: str = ""
|
||||
fecha_fin: str = ""
|
||||
|
||||
|
||||
class VehicleSearchResultDTO(BaseModel):
|
||||
patente: str
|
||||
marca: str = ""
|
||||
modelo: str = ""
|
||||
apellido: str = ""
|
||||
nombre: str = ""
|
||||
documento: str = ""
|
||||
lote: str = ""
|
||||
fecha_ingreso: str = ""
|
||||
vigencia_seguro: str = ""
|
||||
ticket_id: Optional[int] = None
|
||||
|
||||
|
||||
class MassExitRequestDTO(BaseModel):
|
||||
ticket_ids: List[int] = Field(..., min_length=1, description="Lista de IDs de tickets activos a egresar")
|
||||
modulo_salida_id: int = Field(..., description="Módulo de salida asignado")
|
||||
motivo: str = Field("Toque de queda / Cierre de jornada", description="Motivo del egreso masivo")
|
||||
observaciones: Optional[str] = ""
|
||||
password_operador: Optional[str] = None
|
||||
|
||||
|
||||
class MassExitResultDTO(BaseModel):
|
||||
status: str
|
||||
egresados_count: int
|
||||
message: str
|
||||
salida_masiva_id: int = 0
|
||||
|
||||
entidad: Optional[str] = None
|
||||
|
||||
@@ -14,6 +14,10 @@ from app.schemas.access_schema import (
|
||||
PersonPoliciesDTO,
|
||||
VehicleDetailsDTO,
|
||||
LotResidentDTO,
|
||||
PreauthorizationDTO,
|
||||
VehicleSearchResultDTO,
|
||||
MassExitRequestDTO,
|
||||
MassExitResultDTO,
|
||||
)
|
||||
from app.repositories.access_repository import AccessRepository
|
||||
from app.services.hardware_service import HardwareService
|
||||
@@ -362,3 +366,43 @@ class AccessService:
|
||||
return None
|
||||
return VehicleDetailsDTO(**datos)
|
||||
|
||||
@staticmethod
|
||||
def listar_preautorizados(busqueda: str = "", solo_vigentes: bool = True) -> List[PreauthorizationDTO]:
|
||||
filas = AccessRepository.obtener_preautorizados_activos(busqueda=busqueda, solo_vigentes=solo_vigentes)
|
||||
return [PreauthorizationDTO(**f) for f in filas]
|
||||
|
||||
@staticmethod
|
||||
def consumir_preautorizado(preautorizado_id: int) -> bool:
|
||||
return AccessRepository.consumir_preautorizacion(preautorizado_id)
|
||||
|
||||
@staticmethod
|
||||
def buscar_personas_avanzado(texto: str, limite: int = 50) -> List[Dict[str, Any]]:
|
||||
return AccessRepository.buscar_personas_avanzado(texto=texto, limite=limite)
|
||||
|
||||
@staticmethod
|
||||
def buscar_vehiculos(termino: str, es_salida: bool = False, limite: int = 50) -> List[VehicleSearchResultDTO]:
|
||||
filas = AccessRepository.buscar_vehiculos_coincidencias(termino=termino, es_salida=es_salida, limite=limite)
|
||||
return [VehicleSearchResultDTO(**f) for f in filas]
|
||||
|
||||
@staticmethod
|
||||
def procesar_salida_masiva(req: MassExitRequestDTO, usuario_id: int, operador: str) -> MassExitResultDTO:
|
||||
ok, msg, salida_id = AccessRepository.ejecutar_salida_masiva(
|
||||
ticket_ids=req.ticket_ids,
|
||||
usuario_id=usuario_id,
|
||||
operador=operador,
|
||||
modulo_salida_id=req.modulo_salida_id,
|
||||
motivo=req.motivo,
|
||||
observaciones=req.observaciones or "",
|
||||
)
|
||||
if not ok:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail=msg,
|
||||
)
|
||||
return MassExitResultDTO(
|
||||
status="ok",
|
||||
egresados_count=len(req.ticket_ids),
|
||||
message=msg,
|
||||
salida_masiva_id=salida_id,
|
||||
)
|
||||
|
||||
|
||||
@@ -2,10 +2,37 @@
|
||||
# Servicio de Parseo y Normalización de DNI Argentino (PDF417 / QR)
|
||||
# Soporta formatos 2009, 2012, 2026 y App Mi Argentina
|
||||
# ==============================================================================
|
||||
from typing import Dict
|
||||
import re
|
||||
from typing import Dict, Tuple, Optional
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
def limpiar_numero_documento(doc_raw: str) -> Tuple[str, Optional[str]]:
|
||||
"""
|
||||
Limpia y normaliza un número de documento DNI argentino.
|
||||
En formatos antiguos (Libreta Cívica, Libreta de Enrolamiento o Formato 2009),
|
||||
el documento suele estar precedido por 'F' (Femenino) o 'M' (Masculino),
|
||||
por ejemplo: 'F5592570' -> ('5592570', 'F'), 'M34247025' -> ('34247025', 'M').
|
||||
Retorna (documento_numerico, sexo_inferido).
|
||||
"""
|
||||
if not doc_raw:
|
||||
return "", None
|
||||
doc_clean = str(doc_raw).strip()
|
||||
doc_sin_puntos = doc_clean.replace(".", "").replace(",", "").replace(" ", "")
|
||||
|
||||
# Patrón: Prefijo F o M seguido de 5 a 9 dígitos
|
||||
m = re.match(r"^([FMfm])(\d{5,9})$", doc_sin_puntos)
|
||||
if m:
|
||||
return m.group(2), m.group(1).upper()
|
||||
|
||||
# Si contiene dígitos precedidos por F/M con posibles espacios o puntos
|
||||
m2 = re.match(r"^([FMfm])[\s\.]*(\d{5,9})$", doc_clean)
|
||||
if m2:
|
||||
return m2.group(2), m2.group(1).upper()
|
||||
|
||||
return doc_sin_puntos if doc_sin_puntos.isdigit() else doc_clean, None
|
||||
|
||||
|
||||
class DNIParsedResult(BaseModel):
|
||||
valido: bool
|
||||
documento: str
|
||||
@@ -27,28 +54,32 @@ class DniParserService:
|
||||
# Limpiar terminadores y retornos de carro
|
||||
raw_clean = raw_text.strip().replace("\r", "").replace("\n", "")
|
||||
|
||||
# Si solo vino un número de documento escrito manualmente (o escaneado directamente)
|
||||
doc_limpio, sexo_directo = limpiar_numero_documento(raw_clean)
|
||||
if 5 <= len(doc_limpio) <= 9 and doc_limpio.isdigit() and '"' not in raw_clean and '@' not in raw_clean:
|
||||
return {"documento": doc_limpio, "apellido": "", "nombre": "", "sexo": sexo_directo or "M"}
|
||||
|
||||
# Algunos escáneres o formatos vienen separados por @ en lugar de comillas dobles
|
||||
text = raw_clean.replace("@", '"')
|
||||
parts = [p.strip() for p in text.split('"')]
|
||||
|
||||
if len(parts) < 5:
|
||||
# Si solo vino un número de documento escrito manualmente
|
||||
digits = "".join(filter(str.isdigit, raw_clean))
|
||||
if 6 <= len(digits) <= 9:
|
||||
return {"documento": digits, "apellido": "", "nombre": "", "sexo": "M"}
|
||||
if 5 <= len(digits) <= 9:
|
||||
return {"documento": digits, "apellido": "", "nombre": "", "sexo": sexo_directo or "M"}
|
||||
return {"documento": "", "apellido": "", "nombre": "", "sexo": "M"}
|
||||
|
||||
doc = nombre = apellido = sexo = ""
|
||||
|
||||
# Heurística para Formato 2009 con comilla inicial
|
||||
if parts[0] == "" and 6 <= len(parts[1]) <= 11 and len(parts) > 2 and parts[2].isalpha() and len(parts[2]) == 1:
|
||||
if parts[0] == "" and 5 <= len(parts[1]) <= 11 and len(parts) > 2 and parts[2].isalpha() and len(parts[2]) == 1:
|
||||
doc = parts[1]
|
||||
if len(parts) > 5:
|
||||
apellido = parts[4]
|
||||
nombre = parts[5]
|
||||
|
||||
# Heurística para Formato 2009 sin comilla inicial
|
||||
elif 6 <= len(parts[0]) <= 11 and len(parts) > 4 and parts[1].isalpha() and len(parts[1]) == 1:
|
||||
elif 5 <= len(parts[0]) <= 11 and len(parts) > 4 and parts[1].isalpha() and len(parts[1]) == 1:
|
||||
doc = parts[0]
|
||||
apellido = parts[3]
|
||||
nombre = parts[4]
|
||||
@@ -73,12 +104,12 @@ class DniParserService:
|
||||
doc = p4
|
||||
|
||||
# Formato App Mi Argentina: parts[3] es código 1=M, 2=F, 3=X y parts[4] es DNI
|
||||
elif p3 in ("1", "2", "3", "0") and p4.isdigit() and 6 <= len(p4) <= 9:
|
||||
elif p3 in ("1", "2", "3", "0") and p4.isdigit() and 5 <= len(p4) <= 9:
|
||||
sexo = "M" if p3 == "1" else ("F" if p3 == "2" else "X")
|
||||
doc = p4
|
||||
|
||||
# Formato 2026: parts[3] es DNI directo
|
||||
elif p3.isdigit() and 6 <= len(p3) <= 9 and not (p4.isdigit() and 6 <= len(p4) <= 9):
|
||||
elif p3.isdigit() and 5 <= len(p3) <= 9 and not (p4.isdigit() and 5 <= len(p4) <= 9):
|
||||
doc = p3
|
||||
if p4.upper() in ("M", "F", "X"):
|
||||
sexo = p4.upper()
|
||||
@@ -86,7 +117,7 @@ class DniParserService:
|
||||
sexo = "M"
|
||||
|
||||
# Desempate general: si parts[4] es DNI numérico
|
||||
elif p4.isdigit() and 6 <= len(p4) <= 9:
|
||||
elif p4.isdigit() and 5 <= len(p4) <= 9:
|
||||
doc = p4
|
||||
if p3 == "1":
|
||||
sexo = "M"
|
||||
@@ -97,6 +128,13 @@ class DniParserService:
|
||||
else:
|
||||
doc = p3
|
||||
|
||||
# Normalizar DNI por si trajo prefijo F/M en Formato 2009 o Libreta Cívica
|
||||
num_limpio, sexo_inf = limpiar_numero_documento(doc)
|
||||
if num_limpio:
|
||||
doc = num_limpio
|
||||
if not sexo and sexo_inf:
|
||||
sexo = sexo_inf
|
||||
|
||||
return {
|
||||
"documento": doc.strip(),
|
||||
"apellido": apellido.upper().strip() if apellido else "",
|
||||
|
||||
@@ -252,3 +252,116 @@ class HardwareService:
|
||||
"trama_ticket": trama_ticket,
|
||||
"latencia_ms": round(latencia, 2),
|
||||
}
|
||||
|
||||
@classmethod
|
||||
def encolar_cierre(cls, modulo_id: int, ticket_id: int = 0) -> Tuple[bool, Dict[str, Any]]:
|
||||
"""
|
||||
Encola un comando de cierre forzado de barrera/molinete en la tabla `pdtmdl`
|
||||
con tramas C0..C6 según tipo_acceso y firmware (PASS vs PARK).
|
||||
Paridad 1:1 con pct_repository.py:encolar_comando_cierre_modulo (v1.2.3).
|
||||
"""
|
||||
t_start = time.perf_counter()
|
||||
mdl = cls.obtener_info_modulo(modulo_id)
|
||||
if not mdl:
|
||||
return False, {"error": f"Módulo {modulo_id} no encontrado en base de datos"}
|
||||
|
||||
cat_map = {}
|
||||
try:
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor()
|
||||
cursor.execute(
|
||||
"SELECT CategoriaID, ValorID FROM MdlCatVal WHERE ModuloID = %s",
|
||||
(modulo_id,),
|
||||
)
|
||||
cat_map = {row[0]: row[1] for row in cursor.fetchall()}
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
tipo_modulo_id = cat_map.get(2, 0)
|
||||
sentido_id = cat_map.get(4, 0)
|
||||
nombre_upper = (mdl.get("Nombre") or "").upper()
|
||||
|
||||
target_id = modulo_id
|
||||
target_mdl = mdl
|
||||
|
||||
if tipo_modulo_id == 6 or mdl.get("Address", 0) >= 90:
|
||||
if (sentido_id == 1 or "ENTRADA" in nombre_upper or "INGRESO" in nombre_upper) and mdl.get("ModuloEntradaID"):
|
||||
target_id = mdl["ModuloEntradaID"]
|
||||
elif (sentido_id == 2 or "SALIDA" in nombre_upper or "EGRESO" in nombre_upper) and mdl.get("ModuloSalidaID"):
|
||||
target_id = mdl["ModuloSalidaID"]
|
||||
|
||||
if target_id != modulo_id:
|
||||
fisico = cls.obtener_info_modulo(target_id)
|
||||
if fisico:
|
||||
target_mdl = fisico
|
||||
|
||||
target_cat_map = {}
|
||||
if target_id != modulo_id:
|
||||
try:
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor()
|
||||
cursor.execute(
|
||||
"SELECT CategoriaID, ValorID FROM MdlCatVal WHERE ModuloID = %s",
|
||||
(target_id,),
|
||||
)
|
||||
target_cat_map = {row[0]: row[1] for row in cursor.fetchall()}
|
||||
except Exception:
|
||||
pass
|
||||
else:
|
||||
target_cat_map = cat_map
|
||||
|
||||
address = target_mdl.get("Address", 1)
|
||||
is_pass = (target_cat_map.get(2, 0) == 1)
|
||||
tipo_acceso = target_cat_map.get(15) or cat_map.get(15, 3)
|
||||
|
||||
if is_pass:
|
||||
if tipo_acceso == 1:
|
||||
payload = "C4"
|
||||
elif tipo_acceso in (2, 7):
|
||||
payload = "C2"
|
||||
elif tipo_acceso in (3, 4):
|
||||
payload = "C1"
|
||||
elif tipo_acceso == 6:
|
||||
payload = "C0"
|
||||
else:
|
||||
payload = "C3"
|
||||
else:
|
||||
if tipo_acceso == 1:
|
||||
payload = "C6"
|
||||
elif tipo_acceso in (2, 7):
|
||||
payload = "C5"
|
||||
elif tipo_acceso in (3, 4):
|
||||
payload = "C1"
|
||||
elif tipo_acceso == 6:
|
||||
payload = "C0"
|
||||
else:
|
||||
payload = "C3"
|
||||
|
||||
trama_comando = formatear_comando_hardware(address, payload)
|
||||
|
||||
sql_insert = """
|
||||
INSERT INTO pdtmdl (PdtMdlID, ModuloID, Comando, Inmediato, Extra)
|
||||
VALUES ((SELECT COALESCE(MAX(PdtMdlID), 0) + 1 FROM pdtmdl), %s, %s, 1, %s)
|
||||
"""
|
||||
extra_info = str(ticket_id or 0)[:20]
|
||||
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor()
|
||||
cursor.execute(sql_insert, (target_id, trama_comando, extra_info))
|
||||
if target_id != modulo_id:
|
||||
cursor.execute(sql_insert, (modulo_id, trama_comando, extra_info))
|
||||
|
||||
latencia = (time.perf_counter() - t_start) * 1000
|
||||
|
||||
return True, {
|
||||
"modulo_id": modulo_id,
|
||||
"modulo_solicitado": modulo_id,
|
||||
"modulo_fisico_target": target_id,
|
||||
"address": address,
|
||||
"address_fisico": address,
|
||||
"tipo_acceso": tipo_acceso,
|
||||
"is_pass": is_pass,
|
||||
"payload": payload,
|
||||
"comando_trama": trama_comando,
|
||||
"latencia_ms": round(latencia, 2),
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user