fix(camera-parity-pwa): resolver parpadeo de camara, paridad funcional de acompanantes, lotes, egreso y PWA responsive

This commit is contained in:
Carlos Tello
2026-10-14 07:46:25 -03:00
parent dc8fb54983
commit cfb24d81c4
14 changed files with 1816 additions and 63 deletions
+22
View File
@@ -11,6 +11,8 @@ from app.schemas.access_schema import (
ActiveTicketDTO,
PersonSearchDTO,
LotSearchDTO,
LotPermissionDTO,
TicketOccupantDTO,
)
from app.services.access_service import AccessService
from app.services.dni_parser_service import DNIParsingService, DNIParsedResult
@@ -105,3 +107,23 @@ def parsear_codigo_dni(
detail="No se pudo interpretar el formato del código escaneado.",
)
return res
@router.get("/lots/{lote_id}/permission", response_model=LotPermissionDTO, summary="Validar estado y permisos de lote")
def validar_permiso_lote(
lote_id: int,
persona_id: int = Query(0, description="ID opcional de la persona a validar con el lote"),
current_user: dict = Depends(obtener_usuario_actual),
):
"""Consulta estado del lote (Cat 26) y relación de persona (LotPer)."""
return AccessService.obtener_permiso_lote(lote_id, persona_id)
@router.get("/tickets/{ticket_id}/occupants", response_model=List[TicketOccupantDTO], summary="Listar ocupantes de un ticket")
def listar_ocupantes_ticket(
ticket_id: int,
current_user: dict = Depends(obtener_usuario_actual),
):
"""Retorna todos los integrantes que ingresaron en el vehículo correspondiente a este ticket."""
return AccessService.obtener_ocupantes_ticket(ticket_id)
+204 -19
View File
@@ -178,52 +178,237 @@ class AccessRepository:
return ticket_id
@staticmethod
def obtener_permiso_lote(lote_id: int, persona_id: int = 0) -> Dict[str, Any]:
"""
Verifica restricciones del lote en LotCatVal (Categoría 26) y relación de la persona en LotPer.
Idéntico a pct_repository.py en OnEverAccess de escritorio.
"""
resultado = {
"estado": "Habilitado",
"color": "#155724",
"bg_color": "#d4edda",
"detalle": "Lote Habilitado",
"es_residente": False,
}
try:
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
# 1. Chequear estado del lote en LotCatVal (Categoría 26)
sql_lot = """
SELECT c.Nombre AS Categoria
FROM LotCatVal lc
JOIN CatVal c ON lc.CategoriaID = c.CategoriaID AND lc.ValorID = c.ValorID
WHERE lc.LoteID = %s AND lc.CategoriaID = 26
"""
cursor.execute(sql_lot, (lote_id,))
row_cat = cursor.fetchone()
if row_cat and row_cat.get("Categoria"):
cat_nombre = str(row_cat["Categoria"]).strip()
cat_lower = cat_nombre.lower()
if any(k in cat_lower for k in ["moroso", "restringido", "bloqueado", "deuda", "inhabilitado"]):
resultado["estado"] = "Restringido"
resultado["color"] = "#721c24"
resultado["bg_color"] = "#f8d7da"
resultado["detalle"] = f"Lote con Restricción ({cat_nombre})"
elif any(k in cat_lower for k in ["obra", "construc"]):
resultado["estado"] = "En Obra"
resultado["color"] = "#856404"
resultado["bg_color"] = "#fff3cd"
resultado["detalle"] = f"Lote en Obra ({cat_nombre})"
else:
resultado["detalle"] = f"Lote {cat_nombre}"
# 2. Si se especificó persona, verificar si es residente o autorizado
if persona_id > 0:
sql_per = """
SELECT lp.FechaInicio, lp.FechaFin, pr.Nombre AS Perfil, c.Nombre AS EstadoRel
FROM LotPer lp
LEFT JOIN Prf pr ON lp.PerfilID = pr.PerfilID
LEFT JOIN CatVal c ON lp.ValorID = c.ValorID AND c.CategoriaID = 18
WHERE lp.LoteID = %s AND lp.PersonaID = %s
"""
cursor.execute(sql_per, (lote_id, persona_id))
row_lp = cursor.fetchone()
if row_lp:
resultado["es_residente"] = True
f_fin = row_lp.get("FechaFin")
ahora = datetime.now()
if f_fin and f_fin < ahora:
resultado["detalle"] += f" · Permiso Vencido ({f_fin.strftime('%d/%m/%Y')})"
resultado["color"] = "#856404"
resultado["bg_color"] = "#fff3cd"
else:
perfil = row_lp.get("Perfil") or "Residente"
resultado["detalle"] += f" · {perfil}"
except Exception as e:
print(f"Error al verificar permiso del lote {lote_id}: {e}")
return resultado
@staticmethod
def obtener_ocupantes_ticket(ticket_id: int) -> List[Dict[str, Any]]:
"""
Retorna la lista de ocupantes (titular + acompañantes) vinculados a un ticket en tckper.
"""
ocupantes = []
try:
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
sql = """
SELECT tp.PersonaID,
COALESCE(p.Apellido, '') AS Apellido,
COALESCE(p.Nombre, '') AS Nombre,
COALESCE(pd.Documento, '') AS Documento,
COALESCE(tp.RolID, 2) AS RolID,
COALESCE(tp.EsMenor, 0) AS EsMenor
FROM tckper tp
LEFT JOIN Per p ON tp.PersonaID = p.PersonaID
LEFT JOIN PerDocCatVal pd ON p.PersonaID = pd.PersonaID AND pd.DocumentoID = 100000
WHERE tp.TicketID = %s
ORDER BY tp.RolID ASC, tp.PersonaID ASC
"""
cursor.execute(sql, (ticket_id,))
rows = cursor.fetchall()
for r in rows:
es_menor = bool(r.get("EsMenor") or r.get("RolID") == 3)
rol_id = int(r.get("RolID") or 2)
rol_nom = "Conductor" if rol_id == 1 else ("Menor de Edad" if es_menor else "Acompañante")
ocupantes.append({
"persona_id": int(r.get("PersonaID") or 0),
"documento": str(r.get("Documento") or ""),
"apellido": str(r.get("Apellido") or "").strip(),
"nombre": str(r.get("Nombre") or "").strip(),
"rol_id": rol_id,
"es_menor": es_menor,
"rol_nombre": rol_nom,
})
except Exception as e:
print(f"Error al obtener ocupantes de ticket {ticket_id}: {e}")
return ocupantes
@staticmethod
def desacoplar_acompanantes_a_peaton(ticket_id: int, personas_ids: List[int], modulo_id: int) -> bool:
"""
Desacopla acompañantes que permanecen en el predio a tickets peatonales individuales.
"""
if not personas_ids:
return True
ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
try:
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
# Obtener lote y entidad del ticket padre
cursor.execute("SELECT PropiedadID, Valor FROM tckprx WHERE TicketID = %s", (ticket_id,))
prx_rows = cursor.fetchall()
lote_val = None
entidad_val = None
for prx in prx_rows:
if prx.get("PropiedadID") == 7:
lote_val = prx.get("Valor")
elif prx.get("PropiedadID") == 11:
entidad_val = prx.get("Valor")
for pid in personas_ids:
# Desasociar del ticket del vehículo
cursor.execute("DELETE FROM tckper WHERE TicketID = %s AND PersonaID = %s", (ticket_id, pid))
# Generar ticket peatonal individual
cursor.execute("SELECT COALESCE(MAX(TicketID), 0) + 1 AS NextTid FROM tck")
nuevo_tid = cursor.fetchone()["NextTid"]
cursor.execute("SELECT COALESCE(MAX(Numero), 0) + 1 AS NextNro FROM tck")
nuevo_nro = cursor.fetchone()["NextNro"]
cursor.execute(
"INSERT INTO tck (TicketID, Numero, FechaHoraIngreso, ModuloIngresoID) VALUES (%s, %s, %s, %s)",
(nuevo_tid, nuevo_nro, ahora, modulo_id or 0),
)
cursor.execute(
"INSERT INTO tckper (TicketID, PersonaID, RolID, EsMenor) VALUES (%s, %s, 2, 0)",
(nuevo_tid, pid),
)
if lote_val:
cursor.execute("INSERT INTO tckprx (TicketID, PropiedadID, Valor) VALUES (%s, 7, %s)", (nuevo_tid, str(lote_val)))
if entidad_val:
cursor.execute("INSERT INTO tckprx (TicketID, PropiedadID, Valor) VALUES (%s, 11, %s)", (nuevo_tid, str(entidad_val)))
return True
except Exception as e:
print(f"Error al desacoplar acompañantes a peatón: {e}")
return False
@staticmethod
def registrar_ticket_salida(
ticket_id: int, modulo_salida_id: int, persona_id: int = 0, patente: str = ""
ticket_id: int,
modulo_salida_id: int,
persona_id: int = 0,
patente: str = "",
personas_ids_permanecen: Optional[List[int]] = None,
integrantes_verificados: Optional[List[Any]] = None,
) -> bool:
"""
Cierra un ticket activo moviéndolo a `tckhst`, registrando el egreso en `mvthist`
y liberando los registros de `tck` y `tckper`.
para todos los que salen, desacoplando acompañantes que permanecen, y liberando el ticket de `tck`.
"""
ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
# 1. Desacoplar acompañantes que permanecen
if personas_ids_permanecen:
AccessRepository.desacoplar_acompanantes_a_peaton(ticket_id, personas_ids_permanecen, modulo_salida_id)
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
# Leer datos de ingreso
cursor.execute("SELECT FechaHoraIngreso, ModuloIngresoID FROM tck WHERE TicketID = %s", (ticket_id,))
cursor.execute("SELECT Numero, FechaHoraIngreso, ModuloIngresoID FROM tck WHERE TicketID = %s", (ticket_id,))
tck_row = cursor.fetchone()
if not tck_row:
return False
f_ing = str(tck_row["FechaHoraIngreso"])
nro_tck = tck_row.get("Numero") or 0
mod_ing = tck_row.get("ModuloIngresoID") or 0
# 1. Insertar en tckhst (histórico de tickets)
# 2. Insertar en tckhst (histórico de tickets)
cursor.execute(
"""
INSERT INTO tckhst (TicketID, Numero, FechaHoraIngreso, ModuloIngresoID, FechaHoraSalida, ModuloSalidaID)
VALUES (%s, 0, %s, %s, %s, %s)
VALUES (%s, %s, %s, %s, %s, %s)
""",
(ticket_id, f_ing, mod_ing, ahora, modulo_salida_id),
(ticket_id, nro_tck, f_ing, mod_ing, ahora, modulo_salida_id),
)
# 2. Registrar en mvthist
# 3. Registrar en mvthist para todos los que egresan con este ticket
try:
cursor.execute(
"""
INSERT INTO mvthist (TicketID, PersonaID, Patente, RolID, Entidad, Sentido, ModuloID, FechaHora)
VALUES (%s, %s, %s, 1, 'EGRESO...', 'Salida', %s, %s)
""",
(ticket_id, persona_id or None, patente or None, modulo_salida_id, ahora),
)
except Exception:
pass
# Ocupantes en tckper para este ticket
cursor.execute("""
SELECT tp.PersonaID, tp.RolID, tp.EsMenor,
(SELECT TOP 1 Valor FROM tckprx WHERE TicketID = tp.TicketID AND PropiedadID = 4) AS Patente,
(SELECT TOP 1 Valor FROM tckprx WHERE TicketID = tp.TicketID AND PropiedadID = 7) AS LoteID,
(SELECT TOP 1 Valor FROM tckprx WHERE TicketID = tp.TicketID AND PropiedadID = 11) AS Entidad
FROM tckper tp
WHERE tp.TicketID = %s
""", (ticket_id,))
ocupantes_salida = cursor.fetchall()
# 3. Eliminar de tablas vivas
cursor.execute("DELETE FROM tckper WHERE TicketID = %s", (ticket_id,))
cursor.execute("DELETE FROM tckprx WHERE TicketID = %s", (ticket_id,))
for oc in ocupantes_salida:
oc_pid = oc.get("PersonaID")
oc_pat = patente or oc.get("Patente") or None
oc_lote = oc.get("LoteID") or None
oc_rol = oc.get("RolID") or 1
oc_ent = oc.get("Entidad") or "EGRESO..."
cursor.execute(
"""
INSERT INTO mvthist (TicketID, PersonaID, Patente, LoteID, RolID, Entidad, Sentido, ModuloID, FechaHora)
VALUES (%s, %s, %s, %s, %s, %s, 'Salida', %s, %s)
""",
(ticket_id, oc_pid, oc_pat, oc_lote, oc_rol, oc_ent, modulo_salida_id, ahora),
)
except Exception as e:
print(f"Aviso registrando mvthist salida: {e}")
# 4. Eliminar de tck (manteniendo tckper y tckprx para coherencia histórica con tckhst)
cursor.execute("DELETE FROM tck WHERE TicketID = %s", (ticket_id,))
return True
+20
View File
@@ -34,6 +34,24 @@ class EntryRequest(BaseModel):
integrantes: List[CompanionDTO] = Field(default_factory=list)
class LotPermissionDTO(BaseModel):
estado: str = "Habilitado"
color: str = "#155724"
bg_color: str = "#d4edda"
detalle: str = "Lote Habilitado"
es_residente: bool = False
class TicketOccupantDTO(BaseModel):
persona_id: int
documento: str
apellido: str
nombre: str
rol_id: int = 2
es_menor: bool = False
rol_nombre: str = "Acompañante"
class ExitRequest(BaseModel):
ticket_id: int = Field(..., description="ID del ticket activo a cerrar")
modulo_salida_id: int = Field(..., description="ID del módulo / barrera de salida")
@@ -43,6 +61,8 @@ class ExitRequest(BaseModel):
patente_salida: Optional[str] = None
abrir_barrera: bool = True
personas_ids_permanecen: List[int] = Field(default_factory=list)
integrantes_verificados: List[CompanionDTO] = Field(default_factory=list)
class TicketResponse(BaseModel):
+16 -2
View File
@@ -71,14 +71,17 @@ class AccessService:
"""
Ejecuta la regla de negocio para registrar la salida:
1. Valida existencia del ticket en tck.
2. Mueve a tckhst y mvthist, liberando tckper y tck.
3. Encola la apertura de barrera en pdtmdl si corresponde.
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 en pdtmdl si corresponde.
"""
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(
@@ -100,6 +103,17 @@ class AccessService:
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_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."""
+102
View File
@@ -170,3 +170,105 @@ async def test_flujo_completo_ingreso_y_salida():
cursor.execute("DELETE FROM pdtmdl WHERE ModuloID IN (100004, 100005) AND Extra = %s", (str(ticket_id),))
cursor.execute("DELETE FROM mvthist WHERE TicketID = %s", (ticket_id,))
cursor.execute("DELETE FROM tckhst WHERE TicketID = %s", (ticket_id,))
@pytest.mark.asyncio
async def test_lot_permission_and_occupants_api():
transport = ASGITransport(app=app)
async with AsyncClient(transport=transport, base_url="http://test") as client:
login_res = await client.post(
"/api/v1/auth/login",
json={"username": "guardia", "password": "guardia"},
)
token = login_res.cookies.get("access_token")
# 1. Validar permiso de lote
lot_res = await client.get(
"/api/v1/access/lots/1/permission",
cookies={"access_token": token},
)
assert lot_res.status_code == 200
lot_data = lot_res.json()
assert "estado" in lot_data
assert "color" in lot_data
assert "detalle" in lot_data
# 2. Registrar ingreso con acompañantes
doc_cond = "88112233"
doc_acomp1 = "88112234"
doc_acomp2 = "88112235"
entry_res = await client.post(
"/api/v1/access/entry",
json={
"modulo_ingreso_id": 100004,
"documento": doc_cond,
"apellido": "GARCIA",
"nombre": "ROBERTO",
"patente": "GRC888",
"cantidad_ocupantes": 3,
"abrir_barrera": False,
"integrantes": [
{
"documento": doc_acomp1,
"apellido": "GARCIA",
"nombre": "ANA",
"sexo": "F",
"es_menor": False,
"rol_id": 2,
},
{
"documento": doc_acomp2,
"apellido": "GARCIA",
"nombre": "LUCAS",
"sexo": "M",
"es_menor": True,
"rol_id": 3,
},
],
},
cookies={"access_token": token},
)
assert entry_res.status_code == 200
tid = entry_res.json()["ticket_id"]
# 3. Consultar ocupantes del ticket
occ_res = await client.get(
f"/api/v1/access/tickets/{tid}/occupants",
cookies={"access_token": token},
)
assert occ_res.status_code == 200
ocupantes = occ_res.json()
assert len(ocupantes) >= 2
docs_cargados = [o["documento"] for o in ocupantes]
assert doc_cond in docs_cargados
# 4. Registrar salida verificando al conductor y desacoplando al acompañante que permanece
pid_permanece = next((o["persona_id"] for o in ocupantes if o["documento"] == doc_acomp1), 0)
exit_res = await client.post(
"/api/v1/access/exit",
json={
"ticket_id": tid,
"modulo_salida_id": 100005,
"patente_salida": "GRC888",
"abrir_barrera": False,
"personas_ids_permanecen": [pid_permanece] if pid_permanece else [],
"integrantes_verificados": [],
},
cookies={"access_token": token},
)
assert exit_res.status_code == 200
assert exit_res.json()["status"] == "ok"
# Limpieza
from app.core.database import db_session
with db_session() as conn:
cursor = conn.cursor()
cursor.execute("DELETE FROM PerDocCatVal WHERE Documento IN (%s, %s, %s)", (doc_cond, doc_acomp1, doc_acomp2))
cursor.execute("DELETE FROM Per WHERE Apellido = 'GARCIA'")
cursor.execute("DELETE FROM mvthist WHERE TicketID = %s", (tid,))
cursor.execute("DELETE FROM tckhst WHERE TicketID = %s", (tid,))
cursor.execute("DELETE FROM tckper WHERE TicketID = %s", (tid,))
cursor.execute("DELETE FROM tck WHERE TicketID = %s", (tid,))