# ============================================================================== # 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, )