feat(puesto-control): paridad total de validaciones, seguro automotor, ART y UX tablet 9-11 pulgadas

This commit is contained in:
Carlos Tello
2026-10-14 08:20:37 -03:00
parent b2568ed873
commit d80a4dba74
9 changed files with 1387 additions and 52 deletions
+33
View File
@@ -13,6 +13,8 @@ from app.schemas.access_schema import (
LotSearchDTO,
LotPermissionDTO,
TicketOccupantDTO,
PersonPoliciesDTO,
VehicleDetailsDTO,
)
from app.services.access_service import AccessService
from app.services.dni_parser_service import DNIParsingService, DNIParsedResult
@@ -127,3 +129,34 @@ def listar_ocupantes_ticket(
):
"""Retorna todos los integrantes que ingresaron en el vehículo correspondiente a este ticket."""
return AccessService.obtener_ocupantes_ticket(ticket_id)
@router.get("/people/{documento}/details", response_model=PersonPoliciesDTO, summary="Consultar datos completos, patentes y pólizas de persona")
def consultar_datos_persona(
documento: str,
current_user: dict = Depends(obtener_usuario_actual),
):
"""Retorna ficha de persona con patentes asociadas, seguros, ART y licencia."""
res = AccessService.obtener_polizas_y_vehiculos_persona(documento)
if not res:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Persona con DNI {documento} no encontrada.",
)
return res
@router.get("/vehicles/{patente}/details", response_model=VehicleDetailsDTO, summary="Consultar datos de seguro y titular de vehículo")
def consultar_datos_vehiculo(
patente: str,
current_user: dict = Depends(obtener_usuario_actual),
):
"""Retorna póliza de seguro y datos del titular asociado a la patente."""
res = AccessService.obtener_datos_vehiculo(patente)
if not res:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Vehículo con patente {patente} no encontrado en base de datos.",
)
return res
+314 -1
View File
@@ -108,7 +108,8 @@ class AccessRepository:
Registra de manera atómica el ticket en `tck`, `tckprx`, `tckper` y `mvthist`.
"""
ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
rol_id = 1 if req.patente else 2 # 1: Conductor, 2: Peatón
es_conductor = req.tipo_ingreso.upper() == "CONDUCTOR" or bool(req.patente and req.tipo_ingreso.upper() != "PEATON")
rol_id = 1 if es_conductor else 2 # 1: Conductor, 2: Peatón
entidad_final = req.entidad or ("CONDUCTOR..." if rol_id == 1 else "PEATON...")
@@ -121,6 +122,8 @@ class AccessRepository:
(6, "1" if req.cacheo_salida else "0"),
(7, str(req.lote_id or req.lote_codigo or "")),
]
if req.observaciones and req.observaciones.strip():
propiedades.append((10, req.observaciones.strip()))
with db_session() as conn:
cursor = conn.cursor()
@@ -176,6 +179,12 @@ class AccessRepository:
(ticket_id, comp_pid, comp.rol_id, 1 if comp.es_menor else 0),
)
# 6. Persistencia de pólizas, patentes y observaciones en tablas relacionales
try:
AccessRepository.guardar_polizas_y_vehiculo(persona_id, req)
except Exception as e:
print(f"Nota: error al guardar polizas/vehiculo: {e}")
return ticket_id
@staticmethod
@@ -507,3 +516,307 @@ class AccessRepository:
cursor = conn.cursor(as_dict=True)
cursor.execute(query, (patron,))
return cursor.fetchall()
@staticmethod
def buscar_polizas_y_vehiculos_persona(documento: str) -> Optional[Dict[str, Any]]:
"""
Retorna la ficha de la persona con sus patentes asociadas, seguros y pólizas de perpolreg y Aut.
"""
doc_clean = documento.strip()
per = AccessRepository.buscar_persona_por_documento(doc_clean)
if not per:
return None
pid = per["PersonaID"]
resultado: Dict[str, Any] = {
"persona_id": pid,
"documento": doc_clean,
"apellido": per.get("Apellido", "") or "",
"nombre": per.get("Nombre", "") or "",
"sexo": per.get("Sexo", "M") or "M",
"patente_sugerida": None,
"patentes_asociadas": [],
"seguro_empresa": None,
"seguro_poliza": None,
"seguro_desde": None,
"seguro_hasta": None,
"art_empresa": None,
"art_poliza": None,
"art_desde": None,
"art_hasta": None,
"licencia_nro": None,
"licencia_entidad": None,
"licencia_hasta": None,
"observaciones": None,
}
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
# 1. Patentes asociadas en PerAut + Aut
sql_pats = """
SELECT DISTINCT UPPER(a.Patente) AS Patente, a.Aseguradora, a.PolizaNro,
CONVERT(varchar(10), a.PolizaVigenciaDesde, 120) AS FecDesde,
CONVERT(varchar(10), a.PolizaVigenciaHasta, 120) AS FecHasta
FROM Aut a
INNER JOIN PerAut pa ON a.AutoID = pa.AutoID
WHERE pa.PersonaID = %s AND a.Patente IS NOT NULL AND a.Patente <> ''
ORDER BY UPPER(a.Patente)
"""
cursor.execute(sql_pats, (pid,))
pats_rows = cursor.fetchall()
pats = [r["Patente"] for r in pats_rows if r.get("Patente")]
resultado["patentes_asociadas"] = pats
if pats:
resultado["patente_sugerida"] = pats[0]
first_row = pats_rows[0]
if first_row.get("Aseguradora") or first_row.get("PolizaNro"):
resultado["seguro_empresa"] = first_row.get("Aseguradora")
resultado["seguro_poliza"] = first_row.get("PolizaNro")
resultado["seguro_desde"] = first_row.get("FecDesde")
resultado["seguro_hasta"] = first_row.get("FecHasta")
# 2. Pólizas en perpolreg
sql_pol = """
SELECT NroRC, ExpedidoRC,
CONVERT(varchar(10), FechaFinRC, 120) AS FecFinRC,
EmpresaPS, NroPS,
CONVERT(varchar(10), FechaInicioPS, 120) AS FecIniPS,
CONVERT(varchar(10), FechaFinPS, 120) AS FecFinPS,
EmpresaPA, NroPA,
CONVERT(varchar(10), FechaInicioPA, 120) AS FecIniPA,
CONVERT(varchar(10), FechaFinPA, 120) AS FecFinPA
FROM perpolreg
WHERE PersonaID = %s
"""
cursor.execute(sql_pol, (pid,))
row_pol = cursor.fetchone()
if row_pol:
def _clean_str(v):
if not v or str(v).strip().upper() in ('-', 'SPACE', 'NULL', 'NONE'):
return None
return str(v).strip()
def _clean_date(v):
if not v or str(v).strip() in ('1900-01-01', '01-01-1900', '-'):
return None
return str(v).strip().split()[0]
resultado["licencia_nro"] = _clean_str(row_pol.get("NroRC"))
resultado["licencia_entidad"] = _clean_str(row_pol.get("ExpedidoRC"))
resultado["licencia_hasta"] = _clean_date(row_pol.get("FecFinRC"))
if not resultado["seguro_empresa"]:
resultado["seguro_empresa"] = _clean_str(row_pol.get("EmpresaPS"))
resultado["seguro_poliza"] = _clean_str(row_pol.get("NroPS"))
resultado["seguro_desde"] = _clean_date(row_pol.get("FecIniPS"))
resultado["seguro_hasta"] = _clean_date(row_pol.get("FecFinPS"))
resultado["art_empresa"] = _clean_str(row_pol.get("EmpresaPA"))
resultado["art_poliza"] = _clean_str(row_pol.get("NroPA"))
resultado["art_desde"] = _clean_date(row_pol.get("FecIniPA"))
resultado["art_hasta"] = _clean_date(row_pol.get("FecFinPA"))
# 3. Observaciones en PerPrx (PropiedadID = 1)
sql_obs = "SELECT Valor FROM PerPrx WHERE PersonaID = %s AND PropiedadID = 1"
cursor.execute(sql_obs, (pid,))
row_obs = cursor.fetchone()
if row_obs and row_obs.get("Valor"):
resultado["observaciones"] = row_obs["Valor"]
return resultado
@staticmethod
def buscar_datos_vehiculo(patente: str) -> Optional[Dict[str, Any]]:
"""
Busca datos de seguro y titular asociado a una patente.
"""
import re
pat_clean = re.sub(r'[\s\-]', '', str(patente)).upper()
if not pat_clean:
return None
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
sql = """
SELECT TOP 1
a.AutoID, a.Patente, a.Aseguradora, a.PolizaNro,
CONVERT(varchar(10), a.PolizaVigenciaDesde, 120) AS VigenciaDesde,
CONVERT(varchar(10), a.PolizaVigenciaHasta, 120) AS VigenciaHasta,
p.PersonaID, p.Apellido, p.Nombre,
(SELECT TOP 1 d.Documento FROM PerDocCatVal d WHERE d.PersonaID = p.PersonaID ORDER BY d.DocumentoID) AS Documento
FROM Aut a
LEFT JOIN PerAut pa ON a.AutoID = pa.AutoID
LEFT JOIN Per p ON pa.PersonaID = p.PersonaID
WHERE REPLACE(REPLACE(UPPER(LTRIM(RTRIM(a.Patente))), ' ', ''), '-', '') = %s
ORDER BY p.PersonaID DESC
"""
cursor.execute(sql, (pat_clean,))
row = cursor.fetchone()
if not row:
return None
def _clean_str(v):
if not v or str(v).strip().upper() in ('-', 'SPACE', 'NULL', 'NONE'):
return None
return str(v).strip()
def _clean_date(v):
if not v or str(v).strip() in ('1900-01-01', '01-01-1900', '-'):
return None
return str(v).strip().split()[0]
return {
"patente": row.get("Patente") or pat_clean,
"aseguradora": _clean_str(row.get("Aseguradora")),
"poliza_nro": _clean_str(row.get("PolizaNro")),
"vigencia_desde": _clean_date(row.get("VigenciaDesde")),
"vigencia_hasta": _clean_date(row.get("VigenciaHasta")),
"persona_id": row.get("PersonaID"),
"apellido": row.get("Apellido"),
"nombre": row.get("Nombre"),
"documento": row.get("Documento"),
}
@staticmethod
def guardar_polizas_y_vehiculo(persona_id: int, req: EntryRequest) -> bool:
"""
Persiste coberturas en perpolreg, seguro en Aut (si Conductor) y observaciones en PerPrx.
"""
if persona_id <= 0:
return False
def _iso_date(val: Optional[str]) -> str:
if not val:
return "1900-01-01"
v = str(val).strip().split()[0].replace('/', '-')
if v in ("1900-01-01", "01-01-1900", "-", ""):
return "1900-01-01"
parts = v.split('-')
if len(parts) == 3:
if len(parts[0]) == 4:
return f"{int(parts[0]):04d}-{int(parts[1]):02d}-{int(parts[2]):02d}"
elif len(parts[2]) == 4:
return f"{int(parts[2]):04d}-{int(parts[1]):02d}-{int(parts[0]):02d}"
return "1900-01-01"
def _str_clean(val: Optional[str]) -> str:
if not val:
return "-"
v = str(val).strip()
return v if v else "-"
es_conductor = req.tipo_ingreso.upper() == "CONDUCTOR" or bool(req.patente and req.tipo_ingreso.upper() != "PEATON")
with db_session() as conn:
cursor = conn.cursor()
# 1. Si es Conductor y hay patente, gestionar Aut y PerAut
if es_conductor and req.patente:
pat_upper = req.patente.strip().upper()
cursor.execute("SELECT AutoID FROM Aut WHERE UPPER(Patente) = %s", (pat_upper,))
row_aut = cursor.fetchone()
if row_aut:
auto_id = row_aut[0]
if req.seguro_empresa or req.seguro_poliza or req.seguro_hasta:
cursor.execute("""
UPDATE Aut
SET Aseguradora = COALESCE(NULLIF(%s, '-'), Aseguradora),
PolizaNro = COALESCE(NULLIF(%s, '-'), PolizaNro),
PolizaVigenciaDesde = CASE WHEN %s != '1900-01-01' THEN %s ELSE PolizaVigenciaDesde END,
PolizaVigenciaHasta = CASE WHEN %s != '1900-01-01' THEN %s ELSE PolizaVigenciaHasta END
WHERE AutoID = %s
""", (
_str_clean(req.seguro_empresa),
_str_clean(req.seguro_poliza),
_iso_date(req.seguro_desde), _iso_date(req.seguro_desde),
_iso_date(req.seguro_hasta), _iso_date(req.seguro_hasta),
auto_id
))
else:
cursor.execute("SELECT COALESCE(MAX(AutoID), 0) + 1 FROM Aut")
auto_id = cursor.fetchone()[0]
cursor.execute("""
INSERT INTO Aut (AutoID, Patente, Aseguradora, PolizaNro, PolizaVigenciaDesde, PolizaVigenciaHasta)
VALUES (%s, %s, %s, %s, %s, %s)
""", (
auto_id, pat_upper,
_str_clean(req.seguro_empresa),
_str_clean(req.seguro_poliza),
_iso_date(req.seguro_desde),
_iso_date(req.seguro_hasta),
))
# Vincular en PerAut si no existe
cursor.execute("SELECT 1 FROM PerAut WHERE PersonaID = %s AND AutoID = %s", (persona_id, auto_id))
if not cursor.fetchone():
cursor.execute("INSERT INTO PerAut (PersonaID, AutoID) VALUES (%s, %s)", (persona_id, auto_id))
# 2. Gestionar perpolreg
cursor.execute("SELECT 1 FROM perpolreg WHERE PersonaID = %s", (persona_id,))
existe_pol = cursor.fetchone() is not None
if es_conductor:
rc_ini = _iso_date(req.seguro_desde)
rc_fin = _iso_date(req.licencia_hasta)
rc_nro = _str_clean(req.licencia_nro)
rc_ent = _str_clean(req.licencia_entidad)
ps_ini = _iso_date(req.seguro_desde)
ps_fin = _iso_date(req.seguro_hasta)
ps_nro = _str_clean(req.seguro_poliza)
ps_emp = _str_clean(req.seguro_empresa)
pa_ini = _iso_date(req.art_desde)
pa_fin = _iso_date(req.art_hasta)
pa_nro = _str_clean(req.art_poliza)
pa_emp = _str_clean(req.art_empresa)
if existe_pol:
cursor.execute("""
UPDATE perpolreg SET
FechaInicioRC = %s, FechaFinRC = %s, NroRC = %s, ExpedidoRC = %s,
FechaInicioPS = %s, FechaFinPS = %s, NroPS = %s, EmpresaPS = %s,
FechaInicioPA = %s, FechaFinPA = %s, NroPA = %s, EmpresaPA = %s
WHERE PersonaID = %s
""", (rc_ini, rc_fin, rc_nro, rc_ent, ps_ini, ps_fin, ps_nro, ps_emp, pa_ini, pa_fin, pa_nro, pa_emp, persona_id))
else:
cursor.execute("""
INSERT INTO perpolreg (
PersonaID, FechaInicioRC, FechaFinRC, NroRC, ExpedidoRC,
FechaInicioPS, FechaFinPS, NroPS, EmpresaPS,
FechaInicioPA, FechaFinPA, NroPA, EmpresaPA
) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
""", (persona_id, rc_ini, rc_fin, rc_nro, rc_ent, ps_ini, ps_fin, ps_nro, ps_emp, pa_ini, pa_fin, pa_nro, pa_emp))
else:
# Peatón: No sobrescribe ni borra pólizas de auto o licencia existentes
pa_ini = _iso_date(req.art_desde)
pa_fin = _iso_date(req.art_hasta)
pa_nro = _str_clean(req.art_poliza)
pa_emp = _str_clean(req.art_empresa)
if existe_pol:
cursor.execute("""
UPDATE perpolreg SET
FechaInicioPA = %s, FechaFinPA = %s, NroPA = %s, EmpresaPA = %s
WHERE PersonaID = %s
""", (pa_ini, pa_fin, pa_nro, pa_emp, persona_id))
else:
cursor.execute("""
INSERT INTO perpolreg (
PersonaID, FechaInicioRC, FechaFinRC, NroRC, ExpedidoRC,
FechaInicioPS, FechaFinPS, NroPS, EmpresaPS,
FechaInicioPA, FechaFinPA, NroPA, EmpresaPA
) VALUES (%s, '1900-01-01', '1900-01-01', '-', '-', '1900-01-01', '1900-01-01', '-', '-', %s, %s, %s, %s)
""", (persona_id, pa_ini, pa_fin, pa_nro, pa_emp))
# 3. Observaciones en PerPrx (PropiedadID = 1)
if req.observaciones is not None:
obs_val = req.observaciones.strip()
cursor.execute("SELECT 1 FROM PerPrx WHERE PersonaID = %s AND PropiedadID = 1", (persona_id,))
if cursor.fetchone():
cursor.execute("UPDATE PerPrx SET Valor = %s WHERE PersonaID = %s AND PropiedadID = 1", (obs_val, persona_id))
else:
cursor.execute("INSERT INTO PerPrx (PersonaID, PropiedadID, Valor) VALUES (%s, 1, %s)", (persona_id, obs_val))
return True
+51
View File
@@ -21,6 +21,7 @@ class EntryRequest(BaseModel):
apellido: Optional[str] = ""
nombre: Optional[str] = ""
sexo: Optional[str] = "M"
tipo_ingreso: str = Field("CONDUCTOR", description="CONDUCTOR o PEATON")
patente: Optional[str] = Field(None, description="Patente del vehículo (o None si es peatonal)")
lote_id: Optional[int] = Field(None, description="Lote de destino")
lote_codigo: Optional[str] = Field(None, description="Código de lote (ej: 142)")
@@ -32,6 +33,56 @@ class EntryRequest(BaseModel):
abrir_barrera: bool = True
foto_evidencia_b64: Optional[str] = None
integrantes: List[CompanionDTO] = Field(default_factory=list)
# Pólizas de Seguro Automotor (Aut y perpolreg)
seguro_empresa: Optional[str] = None
seguro_poliza: Optional[str] = None
seguro_desde: Optional[str] = None
seguro_hasta: Optional[str] = None
# Póliza ART / Accidentes Personales (perpolreg)
art_empresa: Optional[str] = None
art_poliza: Optional[str] = None
art_desde: Optional[str] = None
art_hasta: Optional[str] = None
# Registro de Conductor / Licencia (perpolreg)
licencia_nro: Optional[str] = None
licencia_entidad: Optional[str] = None
licencia_hasta: Optional[str] = None
observaciones: Optional[str] = None
forzar_ingreso_lote_restringido: bool = False
class PersonPoliciesDTO(BaseModel):
persona_id: int = 0
documento: str = ""
apellido: str = ""
nombre: str = ""
sexo: str = "M"
patente_sugerida: Optional[str] = None
patentes_asociadas: List[str] = Field(default_factory=list)
seguro_empresa: Optional[str] = None
seguro_poliza: Optional[str] = None
seguro_desde: Optional[str] = None
seguro_hasta: Optional[str] = None
art_empresa: Optional[str] = None
art_poliza: Optional[str] = None
art_desde: Optional[str] = None
art_hasta: Optional[str] = None
licencia_nro: Optional[str] = None
licencia_entidad: Optional[str] = None
licencia_hasta: Optional[str] = None
class VehicleDetailsDTO(BaseModel):
patente: str
aseguradora: Optional[str] = None
poliza_nro: Optional[str] = None
vigencia_desde: Optional[str] = None
vigencia_hasta: Optional[str] = None
persona_id: Optional[int] = None
apellido: Optional[str] = None
nombre: Optional[str] = None
documento: Optional[str] = None
class LotPermissionDTO(BaseModel):
+118 -13
View File
@@ -11,6 +11,8 @@ from app.schemas.access_schema import (
ActiveTicketDTO,
PersonSearchDTO,
LotSearchDTO,
PersonPoliciesDTO,
VehicleDetailsDTO,
)
from app.repositories.access_repository import AccessRepository
from app.services.hardware_service import HardwareService
@@ -21,37 +23,123 @@ class AccessService:
def procesar_ingreso(req: EntryRequest) -> TicketResponse:
"""
Ejecuta la regla de negocio para registrar el ingreso:
1. Verifica antipassback del titular.
2. Obtiene o crea la entidad Per / PerDocCatVal.
3. Genera el TicketID canónico.
4. Persiste en tck, tckprx, tckper, mvthist de forma atómica.
5. Encola la apertura de barrera en pdtmdl si fue solicitada.
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. Búsqueda preliminar para verificación de antipassback
persona_existente = AccessRepository.buscar_persona_por_documento(req.documento)
# 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
if not req.lote_id and not (req.lote_codigo and req.lote_codigo.strip()):
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="Falta seleccionar el lote de destino.",
)
# 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 {req.documento} ya posee un ingreso activo en el predio.",
detail=f"Antipassback detectado: La persona con DNI {doc_clean} ya posee un ingreso activo en el predio.",
)
# 2. Búsqueda o creación de la persona
# 8. Búsqueda o creación de la persona
persona_id = AccessRepository.buscar_o_crear_persona(
documento=req.documento,
documento=doc_clean,
apellido=req.apellido or "",
nombre=req.nombre or "",
sexo=req.sexo or "M",
)
# 3. Generación del TicketID
# 9. Generación del TicketID
ticket_id = AccessRepository.generar_ticket_id()
# 4. Registro transaccional en base de datos
# 10. Registro transaccional en base de datos
AccessRepository.registrar_ticket_ingreso(req, persona_id, ticket_id)
# 5. Apertura física de barrera vía pdtmdl
# 11. Apertura física de barrera vía pdtmdl
barrier_opened = False
if req.abrir_barrera and req.modulo_ingreso_id:
ok, _ = HardwareService.encolar_apertura(req.modulo_ingreso_id, ticket_id)
@@ -195,3 +283,20 @@ class AccessService:
)
)
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)