Files

409 lines
18 KiB
Python

# ==============================================================================
# Servicio de Negocio de Control de Accesos (Ingreso, Salida y Búsquedas)
# ==============================================================================
from datetime import datetime
from typing import List, Dict, Any, Optional
from fastapi import HTTPException, status
from app.schemas.access_schema import (
EntryRequest,
ExitRequest,
TicketResponse,
ActiveTicketDTO,
PersonSearchDTO,
LotSearchDTO,
PersonPoliciesDTO,
VehicleDetailsDTO,
LotResidentDTO,
PreauthorizationDTO,
VehicleSearchResultDTO,
MassExitRequestDTO,
MassExitResultDTO,
)
from app.repositories.access_repository import AccessRepository
from app.services.hardware_service import HardwareService
class AccessService:
@staticmethod
def procesar_ingreso(req: EntryRequest) -> TicketResponse:
"""
Ejecuta la regla de negocio para registrar el ingreso:
1. Valida documento, nombre y lote (obligatorios).
2. Valida patente y seguro vigente si Conductor.
3. Valida ART si motivo laboral / servicios.
4. Verifica antipassback del titular.
5. Obtiene o crea la entidad Per / PerDocCatVal.
6. Genera el TicketID canónico.
7. Persiste en tck, tckprx, tckper, mvthist y tablas relacionales (perpolreg, Aut).
8. Encola la apertura de barrera en pdtmdl si fue solicitada.
"""
# 1. Validar Documento
doc_clean = (req.documento or "").strip()
if not doc_clean or len(doc_clean) < 4:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="Falta número de documento válido (mínimo 4 caracteres).",
)
# 2. Validar Nombre
nombre_clean = (req.nombre or "").strip()
if not nombre_clean:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="Falta el nombre de la persona (campo obligatorio).",
)
# 3. Validar Lote de Destino (Paridad estricta pct_view.py:3183 `if self.lote_id <= 0: return False`)
if not req.lote_id or req.lote_id <= 0:
if req.lote_codigo and req.lote_codigo.strip():
lote_encontrado = AccessRepository.buscar_lote_por_codigo(req.lote_codigo.strip())
if lote_encontrado:
req.lote_id = lote_encontrado["LoteID"]
elif req.lote_codigo.strip().isdigit() and int(req.lote_codigo.strip()) > 0:
req.lote_id = int(req.lote_codigo.strip())
if not req.lote_id or req.lote_id <= 0:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="Falta Seleccionar Lote de Destino (obligatorio según normativa de guardia).",
)
# 4. Validar restricción del lote (Categoría 26 en LotCatVal)
if req.lote_id and req.lote_id > 0:
permiso = AccessRepository.obtener_permiso_lote(req.lote_id)
if permiso.get("estado") == "Restringido" and not req.forzar_ingreso_lote_restringido:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"Acceso Bloqueado: {permiso.get('detalle', 'Lote Restringido')}. Por políticas del consorcio no se autoriza el ingreso sin anulación manual de restricción.",
)
es_conductor = req.tipo_ingreso.upper() == "CONDUCTOR" or bool(req.patente and req.tipo_ingreso.upper() != "PEATON")
# 5. Validaciones Conductor (Patente y Seguro)
if es_conductor:
pat_clean = (req.patente or "").strip().upper()
if not pat_clean:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="Falta la patente del vehículo (obligatoria para conductores).",
)
# Validar seguro automotor si viene fecha de vencimiento
if req.seguro_hasta:
sh = req.seguro_hasta.strip().split()[0].replace('/', '-')
if sh in ("1900-01-01", "01-01-1900", "-"):
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Acceso Bloqueado: Seguro Automotor Inválido. La póliza tiene fecha no válida (1900-01-01).",
)
dt_vence = None
for fmt in ("%Y-%m-%d", "%d-%m-%Y"):
try:
dt_vence = datetime.strptime(sh, fmt).date()
break
except ValueError:
pass
if dt_vence and dt_vence < datetime.now().date():
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"Acceso Bloqueado: Seguro Automotor Inválido. La póliza de seguro del vehículo ({pat_clean}) se encuentra VENCIDA ({dt_vence.strftime('%d/%m/%Y')}). Por políticas de seguridad, no se autoriza el ingreso de vehículos sin cobertura vigente.",
)
# 6. Validar ART si es trabajador / contratista / proveedor / servicio
motivo_upper = (req.motivo or "").upper()
if any(m in motivo_upper for m in ["TRABAJADOR", "SERVICIO", "PROVEEDOR", "OBRA"]):
if req.art_hasta:
ah = req.art_hasta.strip().split()[0].replace('/', '-')
if ah not in ("1900-01-01", "01-01-1900", "-"):
dt_art = None
for fmt in ("%Y-%m-%d", "%d-%m-%Y"):
try:
dt_art = datetime.strptime(ah, fmt).date()
break
except ValueError:
pass
if dt_art and dt_art < datetime.now().date():
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"Acceso Bloqueado: Cobertura ART / Accidentes Personales VENCIDA ({dt_art.strftime('%d/%m/%Y')}). Para personal de trabajo o servicios se exige póliza vigente.",
)
# 7. Búsqueda preliminar para verificación de antipassback
persona_existente = AccessRepository.buscar_persona_por_documento(doc_clean)
if persona_existente:
pid = persona_existente["PersonaID"]
if AccessRepository.verificar_antipassback(pid):
raise HTTPException(
status_code=status.HTTP_409_CONFLICT,
detail=f"Antipassback detectado: La persona con DNI {doc_clean} ya posee un ingreso activo en el predio.",
)
# 8. Búsqueda o creación de la persona
persona_id = AccessRepository.buscar_o_crear_persona(
documento=doc_clean,
apellido=req.apellido or "",
nombre=req.nombre or "",
sexo=req.sexo or "M",
)
# 9. Generación del TicketID
ticket_id = AccessRepository.generar_ticket_id()
# Inspección de baúl en garita (Paridad pct_view.py:2739)
if getattr(req, 'baul_inspeccionado', False) and es_conductor:
if "[BAUL INSPECCIONADO - OK]" not in (req.motivo or ""):
req.motivo = f"{(req.motivo or '').strip()} [BAUL INSPECCIONADO - OK]".strip()
# 10. Registro transaccional en base de datos
AccessRepository.registrar_ticket_ingreso(req, persona_id, ticket_id)
# 11. Apertura física de barrera o molinete vía pdtmdl (Regla de escritorio pct_view.py:2861-2868)
# Si es Peatón: NO debe enviar pulso a barrera vehicular. Pero si el acceso está configurado como
# Puerta (1), Molinete (2) o Molinete Club (7), SÍ debe enviar el pulso para destrabar el paso peatonal.
tipo_acc_mod = HardwareService.obtener_tipo_acceso(req.modulo_ingreso_id)
es_acceso_peatonal = tipo_acc_mod in (1, 2, 7)
es_conductor = req.tipo_ingreso.upper() == "CONDUCTOR"
debe_abrir = es_conductor or es_acceso_peatonal
barrier_opened = False
if req.abrir_barrera and req.modulo_ingreso_id and debe_abrir:
ok, _ = HardwareService.encolar_apertura(req.modulo_ingreso_id, ticket_id)
barrier_opened = ok
ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
if es_conductor:
msg = "Ingreso autorizado y registrado correctamente"
elif es_acceso_peatonal:
msg = "Ingreso peatonal registrado. Molinete/puerta habilitado."
else:
msg = "Ingreso peatonal registrado correctamente (barrera vehicular no accionada)."
return TicketResponse(
status="ok",
ticket_id=ticket_id,
message=msg,
barrier_opened=barrier_opened,
fecha_hora=ahora,
)
@staticmethod
def procesar_salida(req: ExitRequest) -> TicketResponse:
"""
Ejecuta la regla de negocio para registrar la salida:
1. Valida existencia del ticket en tck.
2. Desacopla personas que permanecen a tickets peatonales independientes.
3. Mueve a tckhst y mvthist, liberando el ticket de tck.
4. Encola la apertura de barrera/molinete en pdtmdl si corresponde (pct_view.py:3088-3093).
"""
ok = AccessRepository.registrar_ticket_salida(
ticket_id=req.ticket_id,
modulo_salida_id=req.modulo_salida_id,
persona_id=req.persona_id or 0,
patente=req.patente_salida or "",
personas_ids_permanecen=req.personas_ids_permanecen,
integrantes_verificados=req.integrantes_verificados,
)
if not ok:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Ticket activo {req.ticket_id} no encontrado o ya fue egresado.",
)
# Accionamiento de hardware para Salida (Regla de escritorio pct_view.py:3088-3093)
# Para Molinete y Puerta (peatonal), siempre abrir; para barreras solo si es Conductor / Vehicular.
tipo_acc_sal = HardwareService.obtener_tipo_acceso(req.modulo_salida_id)
es_acceso_peatonal_sal = tipo_acc_sal in (1, 2, 7)
if req.tipo_salida:
es_conductor_sal = req.tipo_salida.upper() == "CONDUCTOR"
else:
es_conductor_sal = bool(req.patente_salida and req.patente_salida.strip())
debe_abrir_sal = es_conductor_sal or es_acceso_peatonal_sal
barrier_opened = False
if req.abrir_barrera and req.modulo_salida_id and debe_abrir_sal:
hw_ok, _ = HardwareService.encolar_apertura(req.modulo_salida_id, req.ticket_id)
barrier_opened = hw_ok
ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
if es_conductor_sal:
salida_msg = "Salida registrada exitosamente"
elif es_acceso_peatonal_sal:
salida_msg = "Salida peatonal registrada. Molinete/puerta habilitado."
else:
salida_msg = "Salida peatonal registrada exitosamente (barrera vehicular no accionada)."
return TicketResponse(
status="ok",
ticket_id=req.ticket_id,
message=salida_msg,
barrier_opened=barrier_opened,
fecha_hora=ahora,
)
@staticmethod
def obtener_permiso_lote(lote_id: int, persona_id: int = 0) -> dict:
"""Verifica restricciones de lote (Cat 26) y relación de persona (LotPer)."""
return AccessRepository.obtener_permiso_lote(lote_id, persona_id)
@staticmethod
def obtener_residentes_lote(lote_id: int) -> List[LotResidentDTO]:
"""Obtiene el padrón de residentes y teléfonos vinculados a un lote (LotPer JOIN Per)."""
filas = AccessRepository.obtener_residentes_lote(lote_id)
return [
LotResidentDTO(
persona_id=int(r.get("PersonaID") or r.get("persona_id") or 0),
apellido=str(r.get("Apellido") or r.get("apellido") or "").strip(),
nombre=str(r.get("Nombre") or r.get("nombre") or "").strip(),
documento=str(r.get("Documento") or r.get("documento") or "").strip(),
perfil=str(r.get("Perfil") or r.get("perfil") or "Residente").strip(),
estado=str(r.get("Estado") or r.get("estado") or "Activo").strip(),
telefonos=str(r.get("Telefonos") or r.get("telefonos") or "").strip() or None,
)
for r in filas
]
@staticmethod
def obtener_ocupantes_ticket(ticket_id: int) -> list:
"""Obtiene la lista de ocupantes (conductor y acompañantes) vinculados a un ticket."""
return AccessRepository.obtener_ocupantes_ticket(ticket_id)
@staticmethod
def obtener_tickets_activos() -> List[ActiveTicketDTO]:
"""Obtiene la lista de tickets que se encuentran actualmente dentro del predio."""
filas = AccessRepository.listar_tickets_activos()
resultado = []
for f in filas:
f_ing = f["FechaHoraIngreso"]
f_ing_str = f_ing.strftime("%Y-%m-%d %H:%M:%S") if isinstance(f_ing, datetime) else str(f_ing)
resultado.append(
ActiveTicketDTO(
ticket_id=f["TicketID"],
persona_id=f["PersonaID"],
documento=str(f.get("Documento") or ""),
apellido=str(f.get("Apellido") or ""),
nombre=str(f.get("Nombre") or ""),
patente=f.get("Patente"),
lote_codigo=f.get("LoteCodigo"),
modulo_ingreso=str(f.get("ModuloIngreso") or "Módulo Desconocido"),
fecha_ingreso=f_ing_str,
ocupantes=int(f.get("CantidadOcupantes") or 1),
cacheo_salida=str(f.get("CacheoSalida") or "0") == "1",
)
)
return resultado
@staticmethod
def buscar_personas(term: str) -> List[PersonSearchDTO]:
"""Búsqueda predictiva con autocompletado de personas."""
if not term or len(term.strip()) < 2:
return []
filas = AccessRepository.buscar_personas_predictivo(term)
return [
PersonSearchDTO(
persona_id=f["PersonaID"],
documento=str(f.get("Documento") or ""),
apellido=str(f.get("Apellido") or ""),
nombre=str(f.get("Nombre") or ""),
sexo=str(f.get("Sexo") or "M"),
)
for f in filas
]
@staticmethod
def buscar_lotes(term: str) -> List[LotSearchDTO]:
"""Búsqueda predictiva con autocompletado de lotes."""
if not term or len(term.strip()) < 1:
return []
filas = AccessRepository.buscar_lotes_predictivo(term)
return [
LotSearchDTO(
lote_id=f["LoteID"],
codigo=str(f["Codigo"]),
propietario=None,
)
for f in filas
]
@staticmethod
def obtener_ultimos_movimientos(limite: int = 50) -> List[dict]:
"""Retorna los últimos movimientos reales registrados en SQL Server mvthist."""
from app.schemas.access_schema import MovementHistoryDTO
filas = AccessRepository.listar_ultimos_movimientos(limite)
resultado = []
for f in filas:
fh = f["FechaHora"]
fh_str = fh.strftime("%Y-%m-%d %H:%M:%S") if isinstance(fh, datetime) else str(fh)
resultado.append(
MovementHistoryDTO(
mvt_hist_id=f["MvtHistID"],
ticket_id=f["TicketID"] or 0,
sentido=str(f["Sentido"] or "Ingreso"),
patente=f.get("Patente"),
apellido=f.get("Apellido"),
nombre=f.get("Nombre"),
documento=f.get("Documento"),
lote_codigo=None,
modulo_nombre=f.get("ModuloNombre"),
fecha_hora=fh_str,
entidad=f.get("Entidad"),
)
)
return resultado
@staticmethod
def obtener_polizas_y_vehiculos_persona(documento: str) -> Optional[PersonPoliciesDTO]:
"""Obtiene el perfil extendido de coberturas, patentes y pólizas de la persona."""
datos = AccessRepository.buscar_polizas_y_vehiculos_persona(documento)
if not datos:
return None
return PersonPoliciesDTO(**datos)
@staticmethod
def obtener_datos_vehiculo(patente: str) -> Optional[VehicleDetailsDTO]:
"""Obtiene el seguro automotor y titular asignado de un vehículo por su patente."""
datos = AccessRepository.buscar_datos_vehiculo(patente)
if not datos:
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,
)