365 lines
17 KiB
Python
365 lines
17 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,
|
|
)
|
|
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)
|
|
|