diff --git a/pjecz_hercules_api_oauth2/dependencies/authentications.py b/pjecz_hercules_api_oauth2/dependencies/authentications.py index 3bb0349..d565588 100644 --- a/pjecz_hercules_api_oauth2/dependencies/authentications.py +++ b/pjecz_hercules_api_oauth2/dependencies/authentications.py @@ -13,7 +13,7 @@ from sqlalchemy.exc import MultipleResultsFound, NoResultFound from ..models.usuarios import Usuario -from ..schemas.usuario import UsuarioInDB +from ..schemas.usuarios import UsuarioInDB from ..settings import Settings, get_settings from .database import Session, get_db from .exceptions import MyAnyError, MyAuthenticationError, MyIsDeletedError, MyNotExistsError, MyNotValidParamError @@ -94,7 +94,7 @@ def decode_token(token: str, settings: Settings) -> dict: return payload -async def get_current_user( +async def get_current_active_user( database: Annotated[Session, Depends(get_db)], settings: Annotated[Settings, Depends(get_settings)], token: Annotated[str, Depends(oauth2_scheme)], diff --git a/pjecz_hercules_api_oauth2/main.py b/pjecz_hercules_api_oauth2/main.py index 5a41563..5f27bab 100644 --- a/pjecz_hercules_api_oauth2/main.py +++ b/pjecz_hercules_api_oauth2/main.py @@ -13,6 +13,8 @@ from .dependencies.exceptions import MyAnyError from .routers.autoridades import autoridades from .routers.distritos import distritos +from .routers.edictos import edictos +from .routers.listas_de_acuerdos import listas_de_acuerdos from .routers.materias import materias from .routers.materias_tipos_juicios import materias_tipos_juicios from .routers.modulos import modulos @@ -21,7 +23,9 @@ from .routers.sentencias import sentencias from .routers.usuarios import usuarios from .routers.usuarios_roles import usuarios_roles -from .schemas.usuario import Token +from .routers.web_paginas import web_paginas +from .routers.web_ramas import web_ramas +from .schemas.usuarios import Token from .settings import Settings, get_settings # FastAPI @@ -35,6 +39,8 @@ # Rutas app.include_router(autoridades) app.include_router(distritos) +app.include_router(edictos) +app.include_router(listas_de_acuerdos) app.include_router(materias) app.include_router(materias_tipos_juicios) app.include_router(modulos) @@ -43,6 +49,8 @@ app.include_router(sentencias) app.include_router(usuarios) app.include_router(usuarios_roles) +app.include_router(web_paginas) +app.include_router(web_ramas) # Paginación add_pagination(app) diff --git a/pjecz_hercules_api_oauth2/models/autoridades.py b/pjecz_hercules_api_oauth2/models/autoridades.py index 64e5a95..efb99f3 100644 --- a/pjecz_hercules_api_oauth2/models/autoridades.py +++ b/pjecz_hercules_api_oauth2/models/autoridades.py @@ -55,6 +55,8 @@ class Autoridad(Base, UniversalMixin): directorio_sentencias: Mapped[str] = mapped_column(String(256)) # Hijos + edictos: Mapped[List["Edicto"]] = relationship("Edicto", back_populates="autoridad") + listas_de_acuerdos: Mapped[List["ListaDeAcuerdo"]] = relationship("ListaDeAcuerdo", back_populates="autoridad") sentencias: Mapped[List["Sentencia"]] = relationship("Sentencia", back_populates="autoridad") usuarios: Mapped[List["Usuario"]] = relationship("Usuario", back_populates="autoridad") @@ -63,11 +65,26 @@ def distrito_clave(self): """Clave del distrito""" return self.distrito.clave + @property + def distrito_nombre(self): + """Nombre del distrito""" + return self.distrito.nombre + @property def distrito_nombre_corto(self): """Nombre corto del distrito""" return self.distrito.nombre_corto + @property + def materia_clave(self): + """Clave de la materia""" + return self.materia.clave + + @property + def materia_nombre(self): + """Nombre de la materia""" + return self.materia.nombre + def __repr__(self): """Representación""" - return f"" + return f"" diff --git a/pjecz_hercules_api_oauth2/models/distritos.py b/pjecz_hercules_api_oauth2/models/distritos.py index bd20c0e..74b4002 100644 --- a/pjecz_hercules_api_oauth2/models/distritos.py +++ b/pjecz_hercules_api_oauth2/models/distritos.py @@ -33,4 +33,4 @@ class Distrito(Base, UniversalMixin): def __repr__(self): """Representación""" - return f"" + return f"" diff --git a/pjecz_hercules_api_oauth2/models/edictos.py b/pjecz_hercules_api_oauth2/models/edictos.py new file mode 100644 index 0000000..5ff37ec --- /dev/null +++ b/pjecz_hercules_api_oauth2/models/edictos.py @@ -0,0 +1,77 @@ +""" +Edictos, modelos +""" + +from datetime import date, datetime +from typing import Optional + +from sqlalchemy import JSON, ForeignKey, String +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from ..dependencies.database import Base +from ..dependencies.universal_mixin import UniversalMixin + + +class Edicto(Base, UniversalMixin): + """Edicto""" + + # Nombre de la tabla + __tablename__ = "edictos" + + # Clave primaria + id: Mapped[int] = mapped_column(primary_key=True) + + # Clave foránea + autoridad_id: Mapped[int] = mapped_column(ForeignKey("autoridades.id")) + autoridad: Mapped["Autoridad"] = relationship(back_populates="edictos") + + # Columnas + fecha: Mapped[date] = mapped_column(index=True) + descripcion: Mapped[str] = mapped_column(String(256)) + expediente: Mapped[str] = mapped_column(String(16)) + numero_publicacion: Mapped[str] = mapped_column(String(16)) + archivo: Mapped[str] = mapped_column(String(256), default="") + url: Mapped[str] = mapped_column(String(512), default="") + es_declaracion_de_ausencia: Mapped[bool] = mapped_column(default=False) + + # Columnas para Retrieval-Augmented Generation (RAG) + rag_fue_analizado_tiempo: Mapped[Optional[datetime]] + rag_analisis: Mapped[Optional[dict]] = mapped_column(JSON) + rag_fue_sintetizado_tiempo: Mapped[Optional[datetime]] + rag_sintesis: Mapped[Optional[dict]] = mapped_column(JSON) + rag_fue_categorizado_tiempo: Mapped[Optional[datetime]] + rag_categorias: Mapped[Optional[dict]] = mapped_column(JSON) + + @property + def distrito_clave(self): + """Distrito clave""" + return self.autoridad.distrito.clave + + @property + def distrito_nombre(self): + """Distrito nombre""" + return self.autoridad.distrito.nombre + + @property + def distrito_nombre_corto(self): + """Distrito nombre corto""" + return self.autoridad.distrito.nombre_corto + + @property + def autoridad_clave(self): + """Autoridad clave""" + return self.autoridad.clave + + @property + def autoridad_descripcion(self): + """Autoridad descripción""" + return self.autoridad.descripcion + + @property + def autoridad_descripcion_corta(self): + """Autoridad descripción corta""" + return self.autoridad.descripcion_corta + + def __repr__(self): + """Representación""" + return f"" diff --git a/pjecz_hercules_api_oauth2/models/listas_de_acuerdos.py b/pjecz_hercules_api_oauth2/models/listas_de_acuerdos.py new file mode 100644 index 0000000..0da3af1 --- /dev/null +++ b/pjecz_hercules_api_oauth2/models/listas_de_acuerdos.py @@ -0,0 +1,74 @@ +""" +Listas de Acuerdos, modelos +""" + +from datetime import date, datetime +from typing import Optional + +from sqlalchemy import JSON, ForeignKey, String +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from ..dependencies.database import Base +from ..dependencies.universal_mixin import UniversalMixin + + +class ListaDeAcuerdo(Base, UniversalMixin): + """ListaDeAcuerdo""" + + # Nombre de la tabla + __tablename__ = "listas_de_acuerdos" + + # Clave primaria + id: Mapped[int] = mapped_column(primary_key=True) + + # Clave foránea + autoridad_id: Mapped[int] = mapped_column(ForeignKey("autoridades.id")) + autoridad: Mapped["Autoridad"] = relationship(back_populates="listas_de_acuerdos") + + # Columnas + fecha: Mapped[date] = mapped_column(index=True) + descripcion: Mapped[str] = mapped_column(String(256)) + archivo: Mapped[str] = mapped_column(String(256), default="") + url: Mapped[str] = mapped_column(String(512), default="") + + # Columnas para Retrieval-Augmented Generation (RAG) + rag_fue_analizado_tiempo: Mapped[Optional[datetime]] + rag_analisis: Mapped[Optional[dict]] = mapped_column(JSON) + rag_fue_sintetizado_tiempo: Mapped[Optional[datetime]] + rag_sintesis: Mapped[Optional[dict]] = mapped_column(JSON) + rag_fue_categorizado_tiempo: Mapped[Optional[datetime]] + rag_categorias: Mapped[Optional[dict]] = mapped_column(JSON) + + @property + def distrito_clave(self): + """Distrito clave""" + return self.autoridad.distrito.clave + + @property + def distrito_nombre(self): + """Distrito nombre""" + return self.autoridad.distrito.nombre + + @property + def distrito_nombre_corto(self): + """Distrito nombre corto""" + return self.autoridad.distrito.nombre_corto + + @property + def autoridad_clave(self): + """Autoridad clave""" + return self.autoridad.clave + + @property + def autoridad_descripcion(self): + """Autoridad descripción""" + return self.autoridad.descripcion + + @property + def autoridad_descripcion_corta(self): + """Autoridad descripción corta""" + return self.autoridad.descripcion_corta + + def __repr__(self): + """Representación""" + return f"" diff --git a/pjecz_hercules_api_oauth2/models/materias.py b/pjecz_hercules_api_oauth2/models/materias.py index b0e1ba2..5f200af 100644 --- a/pjecz_hercules_api_oauth2/models/materias.py +++ b/pjecz_hercules_api_oauth2/models/materias.py @@ -32,4 +32,4 @@ class Materia(Base, UniversalMixin): def __repr__(self): """Representación""" - return f"" + return f"" diff --git a/pjecz_hercules_api_oauth2/models/materias_tipos_juicios.py b/pjecz_hercules_api_oauth2/models/materias_tipos_juicios.py index a8375e5..29e3c50 100644 --- a/pjecz_hercules_api_oauth2/models/materias_tipos_juicios.py +++ b/pjecz_hercules_api_oauth2/models/materias_tipos_juicios.py @@ -42,4 +42,4 @@ def materia_nombre(self): def __repr__(self): """Representación""" - return f"" + return f"" diff --git a/pjecz_hercules_api_oauth2/models/sentencias.py b/pjecz_hercules_api_oauth2/models/sentencias.py index 6f19b18..4c5e9aa 100644 --- a/pjecz_hercules_api_oauth2/models/sentencias.py +++ b/pjecz_hercules_api_oauth2/models/sentencias.py @@ -33,7 +33,7 @@ class Sentencia(Base, UniversalMixin): expediente: Mapped[str] = mapped_column(String(16)) expediente_anio: Mapped[int] expediente_num: Mapped[int] - fecha: Mapped[date] = mapped_column(Date(), index=True) + fecha: Mapped[date] = mapped_column(index=True) descripcion: Mapped[str] = mapped_column(String(1024)) es_perspectiva_genero: Mapped[bool] = mapped_column(default=False) archivo: Mapped[str] = mapped_column(String(256), default="", server_default="") @@ -47,11 +47,6 @@ class Sentencia(Base, UniversalMixin): rag_fue_categorizado_tiempo: Mapped[Optional[datetime]] rag_categorias: Mapped[Optional[dict]] = mapped_column(JSON) - @property - def distrito_id(self): - """Distrito ID""" - return self.autoridad.distrito_id - @property def distrito_clave(self): """Distrito clave""" @@ -83,9 +78,9 @@ def autoridad_descripcion_corta(self): return self.autoridad.descripcion_corta @property - def materia_id(self): - """Materia ID""" - return self.materia_tipo_juicio.materia_id + def materia_clave(self): + """Clave de la materia""" + return self.materia_tipo_juicio.materia.clave @property def materia_nombre(self): @@ -99,4 +94,4 @@ def materia_tipo_juicio_descripcion(self): def __repr__(self): """Representación""" - return f"" + return f"" diff --git a/pjecz_hercules_api_oauth2/models/web_paginas.py b/pjecz_hercules_api_oauth2/models/web_paginas.py new file mode 100644 index 0000000..5c14572 --- /dev/null +++ b/pjecz_hercules_api_oauth2/models/web_paginas.py @@ -0,0 +1,50 @@ +""" +Web Páginas, modelos +""" + +from datetime import date, datetime +from typing import Optional + +from sqlalchemy import Enum, ForeignKey, String, Text +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from ..dependencies.database import Base +from ..dependencies.universal_mixin import UniversalMixin + + +class WebPagina(Base, UniversalMixin): + """WebPagina""" + + ESTADOS = { + "BORRADOR": "BORRADOR", + "PUBLICAR": "PUBLICAR", + "ARCHIVAR": "ARCHIVAR", + } + + # Nombre de la tabla + __tablename__ = "web_paginas" + + # Clave primaria + id: Mapped[int] = mapped_column(primary_key=True) + + # Clave foránea + web_rama_id: Mapped[int] = mapped_column(ForeignKey("web_ramas.id")) + web_rama: Mapped["WebRama"] = relationship(back_populates="web_paginas") + + # Columnas + clave: Mapped[str] = mapped_column(String(16), unique=True) + titulo: Mapped[str] = mapped_column(String(256)) + resumen: Mapped[Optional[str]] = mapped_column(String(1024)) + ruta: Mapped[str] = mapped_column(String(256)) + fecha_modificacion: Mapped[date] + responsable: Mapped[Optional[str]] = mapped_column(String(256)) + etiquetas: Mapped[Optional[str]] = mapped_column(String(256)) + vista_previa: Mapped[Optional[str]] = mapped_column(String(256)) + contenido: Mapped[str] = mapped_column(Text) + estado: Mapped[str] = mapped_column(Enum(*ESTADOS, name="web_paginas_estados", native_enum=False), index=True) + tiempo_publicar: Mapped[Optional[datetime]] + tiempo_archivar: Mapped[Optional[datetime]] + + def __repr__(self): + """Representación""" + return f"" diff --git a/pjecz_hercules_api_oauth2/models/web_ramas.py b/pjecz_hercules_api_oauth2/models/web_ramas.py new file mode 100644 index 0000000..551c7aa --- /dev/null +++ b/pjecz_hercules_api_oauth2/models/web_ramas.py @@ -0,0 +1,32 @@ +""" +Web Ramas, modelos +""" + +from typing import List + +from sqlalchemy import String +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from ..dependencies.database import Base +from ..dependencies.universal_mixin import UniversalMixin + + +class WebRama(Base, UniversalMixin): + """WebRama""" + + # Nombre de la tabla + __tablename__ = "web_ramas" + + # Clave primaria + id: Mapped[int] = mapped_column(primary_key=True) + + # Columnas + clave: Mapped[str] = mapped_column(String(16), unique=True) + nombre: Mapped[str] = mapped_column(String(256)) + + # Hijos + web_paginas: Mapped[List["WebPagina"]] = relationship("WebPagina", back_populates="web_rama") + + def __repr__(self): + """Representación""" + return f"" diff --git a/pjecz_hercules_api_oauth2/routers/autoridades.py b/pjecz_hercules_api_oauth2/routers/autoridades.py index cf32fe4..09e1566 100644 --- a/pjecz_hercules_api_oauth2/routers/autoridades.py +++ b/pjecz_hercules_api_oauth2/routers/autoridades.py @@ -8,7 +8,7 @@ from fastapi_pagination.ext.sqlalchemy import paginate from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound -from ..dependencies.authentications import get_current_user +from ..dependencies.authentications import get_current_active_user from ..dependencies.database import Session, get_db from ..dependencies.fastapi_pagination_custom_page import CustomPage from ..dependencies.safe_string import safe_clave @@ -16,15 +16,15 @@ from ..models.distritos import Distrito from ..models.materias import Materia from ..models.permisos import Permiso -from ..schemas.autoridad import AutoridadOut, OneAutoridadOut -from ..schemas.usuario import UsuarioInDB +from ..schemas.autoridades import AutoridadOut, OneAutoridadOut +from ..schemas.usuarios import UsuarioInDB autoridades = APIRouter(prefix="/api/v5/autoridades", tags=["autoridades"]) @autoridades.get("/{clave}", response_model=OneAutoridadOut) async def detalle( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], clave: str, ): @@ -46,12 +46,12 @@ async def detalle( @autoridades.get("", response_model=CustomPage[AutoridadOut]) async def paginado( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], distrito_clave: str = None, - materia_clave: str = None, es_jurisdiccional: bool = None, es_notaria: bool = None, + materia_clave: str = None, ): """Paginado de autoridades""" if current_user.permissions.get("AUTORIDADES", 0) < Permiso.VER: @@ -63,14 +63,14 @@ async def paginado( except ValueError: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="No es válida la clave del distrito") consulta = consulta.join(Distrito).filter(Distrito.clave == distrito_clave).filter(Distrito.estatus == "A") + if es_jurisdiccional is not None: + consulta = consulta.filter(Autoridad.es_jurisdiccional == es_jurisdiccional) + if es_notaria is not None: + consulta = consulta.filter(Autoridad.es_notaria == es_notaria) if materia_clave is not None: try: materia_clave = safe_clave(materia_clave) except ValueError: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="No es válida la clave del materia") consulta = consulta.join(Materia).filter(Materia.clave == materia_clave).filter(Materia.estatus == "A") - if es_jurisdiccional is not None: - consulta = consulta.filter(Autoridad.es_jurisdiccional == es_jurisdiccional) - if es_notaria is not None: - consulta = consulta.filter(Autoridad.es_notaria == es_notaria) return paginate(consulta.filter(Autoridad.estatus == "A").order_by(Autoridad.clave)) diff --git a/pjecz_hercules_api_oauth2/routers/distritos.py b/pjecz_hercules_api_oauth2/routers/distritos.py index 2db6786..faa30d2 100644 --- a/pjecz_hercules_api_oauth2/routers/distritos.py +++ b/pjecz_hercules_api_oauth2/routers/distritos.py @@ -8,21 +8,21 @@ from fastapi_pagination.ext.sqlalchemy import paginate from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound -from ..dependencies.authentications import get_current_user +from ..dependencies.authentications import get_current_active_user from ..dependencies.database import Session, get_db from ..dependencies.fastapi_pagination_custom_page import CustomPage from ..dependencies.safe_string import safe_clave from ..models.distritos import Distrito from ..models.permisos import Permiso -from ..schemas.distrito import DistritoOut, OneDistritoOut -from ..schemas.usuario import UsuarioInDB +from ..schemas.distritos import DistritoOut, OneDistritoOut +from ..schemas.usuarios import UsuarioInDB distritos = APIRouter(prefix="/api/v5/distritos", tags=["distritos"]) @distritos.get("/{clave}", response_model=OneDistritoOut) async def detalle( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], clave: str, ): @@ -44,7 +44,7 @@ async def detalle( @distritos.get("", response_model=CustomPage[DistritoOut]) async def paginado( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], ): """Paginado de distritos""" diff --git a/pjecz_hercules_api_oauth2/routers/edictos.py b/pjecz_hercules_api_oauth2/routers/edictos.py new file mode 100644 index 0000000..26d134d --- /dev/null +++ b/pjecz_hercules_api_oauth2/routers/edictos.py @@ -0,0 +1,72 @@ +""" +Edictos +""" + +from datetime import date, datetime +from typing import Annotated + +from fastapi import APIRouter, Depends, HTTPException, status +from fastapi_pagination.ext.sqlalchemy import paginate + +from ..dependencies.authentications import get_current_active_user +from ..dependencies.database import Session, get_db +from ..dependencies.fastapi_pagination_custom_page import CustomPage +from ..dependencies.safe_string import safe_clave +from ..models.autoridades import Autoridad +from ..models.edictos import Edicto +from ..models.permisos import Permiso +from ..schemas.edictos import EdictoOut, EdictoRAGOut, OneEdictoOut +from ..schemas.usuarios import UsuarioInDB + +edictos = APIRouter(prefix="/api/v5/edictos", tags=["edictos"]) + + +@edictos.get("/{edicto_id}", response_model=OneEdictoOut) +async def detalle( + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], + database: Annotated[Session, Depends(get_db)], + edicto_id: int, +): + """Detalle de una edicto a partir de su ID""" + if current_user.permissions.get("EDICTOS", 0) < Permiso.VER: + raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden") + edicto = database.query(Edicto).get(edicto_id) + if edicto is None: + return OneEdictoOut(success=False, message="No existe esa edicto") + if edicto.estatus != "A": + return OneEdictoOut(success=False, message="No es activa esa edicto, está eliminada") + return OneEdictoOut(success=True, message="Detalle de una edicto", data=EdictoRAGOut.model_validate(edicto)) + + +@edictos.get("", response_model=CustomPage[EdictoOut]) +async def paginado( + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], + database: Annotated[Session, Depends(get_db)], + autoridad_clave: str = None, + creado: date = None, + creado_desde: date = None, + creado_hasta: date = None, +): + """Paginado de edictos""" + if current_user.permissions.get("EDICTOS", 0) < Permiso.VER: + raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden") + consulta = database.query(Edicto) + if autoridad_clave is not None: + try: + autoridad_clave = safe_clave(autoridad_clave) + except ValueError: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="No es válida la clave") + consulta = consulta.join(Autoridad).filter(Autoridad.clave == autoridad_clave).filter(Autoridad.estatus == "A") + if creado is not None: + consulta = consulta.filter(Edicto.creado >= datetime(creado.year, creado.month, creado.day, 0, 0, 0)) + consulta = consulta.filter(Edicto.creado <= datetime(creado.year, creado.month, creado.day, 23, 59, 59)) + else: + if creado_desde is not None: + consulta = consulta.filter( + Edicto.creado >= datetime(creado_desde.year, creado_desde.month, creado_desde.day, 0, 0, 0) + ) + if creado_hasta is not None: + consulta = consulta.filter( + Edicto.creado <= datetime(creado_hasta.year, creado_hasta.month, creado_hasta.day, 23, 59, 59) + ) + return paginate(consulta.filter(Edicto.estatus == "A").order_by(Edicto.id.desc())) diff --git a/pjecz_hercules_api_oauth2/routers/listas_de_acuerdos.py b/pjecz_hercules_api_oauth2/routers/listas_de_acuerdos.py new file mode 100644 index 0000000..e4ee7c0 --- /dev/null +++ b/pjecz_hercules_api_oauth2/routers/listas_de_acuerdos.py @@ -0,0 +1,74 @@ +""" +Listas de Acuerdos +""" + +from datetime import date, datetime +from typing import Annotated + +from fastapi import APIRouter, Depends, HTTPException, status +from fastapi_pagination.ext.sqlalchemy import paginate + +from ..dependencies.authentications import get_current_active_user +from ..dependencies.database import Session, get_db +from ..dependencies.fastapi_pagination_custom_page import CustomPage +from ..dependencies.safe_string import safe_clave +from ..models.autoridades import Autoridad +from ..models.listas_de_acuerdos import ListaDeAcuerdo +from ..models.permisos import Permiso +from ..schemas.listas_de_acuerdos import ListaDeAcuerdoOut, ListaDeAcuerdoRAGOut, OneListaDeAcuerdoOut +from ..schemas.usuarios import UsuarioInDB + +listas_de_acuerdos = APIRouter(prefix="/api/v5/listas_de_acuerdos", tags=["listas de acuerdos"]) + + +@listas_de_acuerdos.get("/{lista_de_acuerdo_id}", response_model=OneListaDeAcuerdoOut) +async def detalle( + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], + database: Annotated[Session, Depends(get_db)], + lista_de_acuerdo_id: int, +): + """Detalle de una lista de acuerdos a partir de su ID""" + if current_user.permissions.get("LISTAS DE ACUERDOS", 0) < Permiso.VER: + raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden") + lista_de_acuerdo = database.query(ListaDeAcuerdo).get(lista_de_acuerdo_id) + if lista_de_acuerdo is None: + return OneListaDeAcuerdoOut(success=False, message="No existe esa lista de acuerdos") + if lista_de_acuerdo.estatus != "A": + return OneListaDeAcuerdoOut(success=False, message="No es activa esa lista de acuerdos, está eliminada") + return OneListaDeAcuerdoOut( + success=True, message="Detalle de una lista de acuerdos", data=ListaDeAcuerdoRAGOut.model_validate(lista_de_acuerdo) + ) + + +@listas_de_acuerdos.get("", response_model=CustomPage[ListaDeAcuerdoOut]) +async def paginado( + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], + database: Annotated[Session, Depends(get_db)], + autoridad_clave: str = None, + creado: date = None, + creado_desde: date = None, + creado_hasta: date = None, +): + """Paginado de listas_de_acuerdos""" + if current_user.permissions.get("LISTAS DE ACUERDOS", 0) < Permiso.VER: + raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden") + consulta = database.query(ListaDeAcuerdo) + if autoridad_clave is not None: + try: + autoridad_clave = safe_clave(autoridad_clave) + except ValueError: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="No es válida la clave") + consulta = consulta.join(Autoridad).filter(Autoridad.clave == autoridad_clave).filter(Autoridad.estatus == "A") + if creado is not None: + consulta = consulta.filter(ListaDeAcuerdo.creado >= datetime(creado.year, creado.month, creado.day, 0, 0, 0)) + consulta = consulta.filter(ListaDeAcuerdo.creado <= datetime(creado.year, creado.month, creado.day, 23, 59, 59)) + else: + if creado_desde is not None: + consulta = consulta.filter( + ListaDeAcuerdo.creado >= datetime(creado_desde.year, creado_desde.month, creado_desde.day, 0, 0, 0) + ) + if creado_hasta is not None: + consulta = consulta.filter( + ListaDeAcuerdo.creado <= datetime(creado_hasta.year, creado_hasta.month, creado_hasta.day, 23, 59, 59) + ) + return paginate(consulta.filter(ListaDeAcuerdo.estatus == "A").order_by(ListaDeAcuerdo.id.desc())) diff --git a/pjecz_hercules_api_oauth2/routers/materias.py b/pjecz_hercules_api_oauth2/routers/materias.py index e4e1c42..b621ecb 100644 --- a/pjecz_hercules_api_oauth2/routers/materias.py +++ b/pjecz_hercules_api_oauth2/routers/materias.py @@ -8,21 +8,21 @@ from fastapi_pagination.ext.sqlalchemy import paginate from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound -from ..dependencies.authentications import get_current_user +from ..dependencies.authentications import get_current_active_user from ..dependencies.database import Session, get_db from ..dependencies.fastapi_pagination_custom_page import CustomPage from ..dependencies.safe_string import safe_clave from ..models.materias import Materia from ..models.permisos import Permiso -from ..schemas.materia import MateriaOut, OneMateriaOut -from ..schemas.usuario import UsuarioInDB +from ..schemas.materias import MateriaOut, OneMateriaOut +from ..schemas.usuarios import UsuarioInDB materias = APIRouter(prefix="/api/v5/materias", tags=["materias"]) @materias.get("/{clave}", response_model=OneMateriaOut) async def detalle( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], clave: str, ): @@ -44,7 +44,7 @@ async def detalle( @materias.get("", response_model=CustomPage[MateriaOut]) async def paginado( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], ): """Paginado de materias""" diff --git a/pjecz_hercules_api_oauth2/routers/materias_tipos_juicios.py b/pjecz_hercules_api_oauth2/routers/materias_tipos_juicios.py index 0cff39e..bbd886c 100644 --- a/pjecz_hercules_api_oauth2/routers/materias_tipos_juicios.py +++ b/pjecz_hercules_api_oauth2/routers/materias_tipos_juicios.py @@ -1,5 +1,5 @@ """ -Materias Tipos de Juicios, API v1 +Materias Tipos de Juicios """ from typing import Annotated @@ -7,22 +7,22 @@ from fastapi import APIRouter, Depends, HTTPException, status from fastapi_pagination.ext.sqlalchemy import paginate -from ..dependencies.authentications import get_current_user +from ..dependencies.authentications import get_current_active_user from ..dependencies.database import Session, get_db from ..dependencies.fastapi_pagination_custom_page import CustomPage from ..dependencies.safe_string import safe_clave from ..models.materias import Materia from ..models.materias_tipos_juicios import MateriaTipoJuicio from ..models.permisos import Permiso -from ..schemas.materia_tipo_juicio import MateriaTipoJuicioOut -from ..schemas.usuario import UsuarioInDB +from ..schemas.materias_tipos_juicios import MateriaTipoJuicioOut +from ..schemas.usuarios import UsuarioInDB materias_tipos_juicios = APIRouter(prefix="/api/v5/materias_tipos_juicios", tags=["materias"]) @materias_tipos_juicios.get("", response_model=CustomPage[MateriaTipoJuicioOut]) async def paginado( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], materia_clave: str = None, ): diff --git a/pjecz_hercules_api_oauth2/routers/modulos.py b/pjecz_hercules_api_oauth2/routers/modulos.py index 08b4188..7014236 100644 --- a/pjecz_hercules_api_oauth2/routers/modulos.py +++ b/pjecz_hercules_api_oauth2/routers/modulos.py @@ -1,5 +1,5 @@ """ -Modulos, API v1 +Modulos """ from typing import Annotated @@ -7,20 +7,20 @@ from fastapi import APIRouter, Depends, HTTPException, status from fastapi_pagination.ext.sqlalchemy import paginate -from ..dependencies.authentications import get_current_user +from ..dependencies.authentications import get_current_active_user from ..dependencies.database import Session, get_db from ..dependencies.fastapi_pagination_custom_page import CustomPage from ..models.modulos import Modulo from ..models.permisos import Permiso -from ..schemas.modulo import ModuloOut -from ..schemas.usuario import UsuarioInDB +from ..schemas.modulos import ModuloOut +from ..schemas.usuarios import UsuarioInDB modulos = APIRouter(prefix="/api/v5/modulos", tags=["sistema"]) @modulos.get("", response_model=CustomPage[ModuloOut]) async def paginado( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], ): """Paginado de modulos""" diff --git a/pjecz_hercules_api_oauth2/routers/permisos.py b/pjecz_hercules_api_oauth2/routers/permisos.py index c4a70f4..76c1c31 100644 --- a/pjecz_hercules_api_oauth2/routers/permisos.py +++ b/pjecz_hercules_api_oauth2/routers/permisos.py @@ -1,5 +1,5 @@ """ -Permisos, API v1 +Permisos """ from typing import Annotated @@ -7,21 +7,21 @@ from fastapi import APIRouter, Depends, HTTPException, status from fastapi_pagination.ext.sqlalchemy import paginate -from ..dependencies.authentications import get_current_user +from ..dependencies.authentications import get_current_active_user from ..dependencies.database import Session, get_db from ..dependencies.fastapi_pagination_custom_page import CustomPage from ..models.modulos import Modulo from ..models.permisos import Permiso from ..models.roles import Rol -from ..schemas.permiso import PermisoOut -from ..schemas.usuario import UsuarioInDB +from ..schemas.permisos import PermisoOut +from ..schemas.usuarios import UsuarioInDB permisos = APIRouter(prefix="/api/v5/permisos", tags=["sistema"]) @permisos.get("", response_model=CustomPage[PermisoOut]) async def paginado( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], modulo_id: int = None, rol_id: int = None, diff --git a/pjecz_hercules_api_oauth2/routers/roles.py b/pjecz_hercules_api_oauth2/routers/roles.py index 45b3173..75721fd 100644 --- a/pjecz_hercules_api_oauth2/routers/roles.py +++ b/pjecz_hercules_api_oauth2/routers/roles.py @@ -1,5 +1,5 @@ """ -Roles, API v1 +Roles """ from typing import Annotated @@ -7,20 +7,20 @@ from fastapi import APIRouter, Depends, HTTPException, status from fastapi_pagination.ext.sqlalchemy import paginate -from ..dependencies.authentications import get_current_user +from ..dependencies.authentications import get_current_active_user from ..dependencies.database import Session, get_db from ..dependencies.fastapi_pagination_custom_page import CustomPage from ..models.permisos import Permiso from ..models.roles import Rol -from ..schemas.rol import RolOut -from ..schemas.usuario import UsuarioInDB +from ..schemas.roles import RolOut +from ..schemas.usuarios import UsuarioInDB roles = APIRouter(prefix="/api/v5/roles", tags=["sistema"]) @roles.get("", response_model=CustomPage[RolOut]) async def paginado( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], ): """Paginado de roles""" diff --git a/pjecz_hercules_api_oauth2/routers/sentencias.py b/pjecz_hercules_api_oauth2/routers/sentencias.py index 1c31761..d82aaf7 100644 --- a/pjecz_hercules_api_oauth2/routers/sentencias.py +++ b/pjecz_hercules_api_oauth2/routers/sentencias.py @@ -1,29 +1,30 @@ """ -Sentencias, API v1 +Sentencias """ -from datetime import date, datetime, timezone +from datetime import date, datetime from typing import Annotated +import pytz from fastapi import APIRouter, Depends, HTTPException, status from fastapi_pagination.ext.sqlalchemy import paginate -from ..dependencies.authentications import get_current_user +from ..dependencies.authentications import get_current_active_user from ..dependencies.database import Session, get_db from ..dependencies.fastapi_pagination_custom_page import CustomPage from ..dependencies.safe_string import safe_clave from ..models.autoridades import Autoridad from ..models.permisos import Permiso from ..models.sentencias import Sentencia -from ..schemas.sentencia import OneSentenciaOut, SentenciaCompleteOut, SentenciaOut, SentenciaRAGIn -from ..schemas.usuario import UsuarioInDB +from ..schemas.sentencias import OneSentenciaOut, SentenciaOut, SentenciaRAGIn, SentenciaRAGOut +from ..schemas.usuarios import UsuarioInDB sentencias = APIRouter(prefix="/api/v5/sentencias", tags=["sentencias"]) @sentencias.get("/{sentencia_id}", response_model=OneSentenciaOut) async def detalle( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], sentencia_id: int, ): @@ -35,14 +36,12 @@ async def detalle( return OneSentenciaOut(success=False, message="No existe esa sentencia") if sentencia.estatus != "A": return OneSentenciaOut(success=False, message="No es activa esa sentencia, está eliminada") - return OneSentenciaOut( - success=True, message="Detalle de una sentencia", data=SentenciaCompleteOut.model_validate(sentencia) - ) + return OneSentenciaOut(success=True, message="Detalle de una sentencia", data=SentenciaRAGOut.model_validate(sentencia)) @sentencias.get("", response_model=CustomPage[SentenciaOut]) async def paginado( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], autoridad_clave: str = None, creado: date = None, @@ -76,7 +75,7 @@ async def paginado( @sentencias.put("/rag", response_model=OneSentenciaOut) async def actualizar_rag( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], rag: SentenciaRAGIn, ): @@ -91,22 +90,22 @@ async def actualizar_rag( hay_cambios = False if rag.analisis is not None and sentencia.rag_analisis != rag.analisis: sentencia.rag_analisis = rag.analisis - sentencia.rag_fue_analizado_tiempo = datetime.now(tz=timezone.utc) + sentencia.rag_fue_analizado_tiempo = datetime.now(tz=pytz.utc) hay_cambios = True if rag.sintesis is not None and sentencia.rag_sintesis != rag.sintesis: sentencia.rag_sintesis = rag.sintesis - sentencia.rag_fue_sintetizado_tiempo = datetime.now(tz=timezone.utc) + sentencia.rag_fue_sintetizado_tiempo = datetime.now(tz=pytz.utc) hay_cambios = True if rag.categorias is not None and sentencia.rag_categorias != rag.categorias: sentencia.rag_categorias = rag.categorias - sentencia.rag_fue_categorizado_tiempo = datetime.now(tz=timezone.utc) + sentencia.rag_fue_categorizado_tiempo = datetime.now(tz=pytz.utc) hay_cambios = True if hay_cambios is False: return OneSentenciaOut( success=False, message="No hay cambios en las columnas RAG de la sentencia", errors=[], - data=SentenciaCompleteOut.model_validate(sentencia), + data=SentenciaRAGOut.model_validate(sentencia), ) database.add(sentencia) database.commit() @@ -114,5 +113,5 @@ async def actualizar_rag( success=True, message="Se actualizó la sentencia", errors=[], - data=SentenciaCompleteOut.model_validate(sentencia), + data=SentenciaRAGOut.model_validate(sentencia), ) diff --git a/pjecz_hercules_api_oauth2/routers/usuarios.py b/pjecz_hercules_api_oauth2/routers/usuarios.py index a9b7d07..ca2b8d2 100644 --- a/pjecz_hercules_api_oauth2/routers/usuarios.py +++ b/pjecz_hercules_api_oauth2/routers/usuarios.py @@ -1,5 +1,5 @@ """ -Usuarios, v1 +Usuarios """ from typing import Annotated @@ -7,21 +7,21 @@ from fastapi import APIRouter, Depends, HTTPException, status from fastapi_pagination.ext.sqlalchemy import paginate -from ..dependencies.authentications import get_current_user +from ..dependencies.authentications import get_current_active_user from ..dependencies.database import Session, get_db from ..dependencies.fastapi_pagination_custom_page import CustomPage from ..dependencies.safe_string import safe_clave, safe_email from ..models.autoridades import Autoridad from ..models.permisos import Permiso from ..models.usuarios import Usuario -from ..schemas.usuario import OneUsuarioOut, UsuarioInDB, UsuarioOut +from ..schemas.usuarios import OneUsuarioOut, UsuarioInDB, UsuarioOut usuarios = APIRouter(prefix="/api/v5/usuarios", tags=["sistema"]) @usuarios.get("/{email}", response_model=OneUsuarioOut) async def detalle( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], email: str, ): @@ -42,7 +42,7 @@ async def detalle( @usuarios.get("", response_model=CustomPage[UsuarioOut]) async def paginado( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], autoridad_clave: str = None, ): diff --git a/pjecz_hercules_api_oauth2/routers/usuarios_roles.py b/pjecz_hercules_api_oauth2/routers/usuarios_roles.py index b1e5436..ad0de93 100644 --- a/pjecz_hercules_api_oauth2/routers/usuarios_roles.py +++ b/pjecz_hercules_api_oauth2/routers/usuarios_roles.py @@ -1,5 +1,5 @@ """ -Usuarios-Roles, API v1 +Usuarios-Roles """ from typing import Annotated @@ -7,22 +7,22 @@ from fastapi import APIRouter, Depends, HTTPException, status from fastapi_pagination.ext.sqlalchemy import paginate -from ..dependencies.authentications import get_current_user +from ..dependencies.authentications import get_current_active_user from ..dependencies.database import Session, get_db from ..dependencies.fastapi_pagination_custom_page import CustomPage from ..dependencies.safe_string import safe_email from ..models.permisos import Permiso from ..models.usuarios import Usuario from ..models.usuarios_roles import UsuarioRol -from ..schemas.usuario import UsuarioInDB -from ..schemas.usuario_rol import UsuarioRolOut +from ..schemas.usuarios import UsuarioInDB +from ..schemas.usuarios_roles import UsuarioRolOut usuarios_roles = APIRouter(prefix="/api/v5/usuarios_roles", tags=["sistema"]) @usuarios_roles.get("", response_model=CustomPage[UsuarioRolOut]) async def paginado( - current_user: Annotated[UsuarioInDB, Depends(get_current_user)], + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], database: Annotated[Session, Depends(get_db)], rol_id: int = None, usuario_email: str = None, diff --git a/pjecz_hercules_api_oauth2/routers/web_paginas.py b/pjecz_hercules_api_oauth2/routers/web_paginas.py new file mode 100644 index 0000000..136c3fa --- /dev/null +++ b/pjecz_hercules_api_oauth2/routers/web_paginas.py @@ -0,0 +1,62 @@ +""" +Web Páginas +""" + +from typing import Annotated + +from fastapi import APIRouter, Depends, HTTPException, status +from fastapi_pagination.ext.sqlalchemy import paginate +from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound + +from ..dependencies.authentications import get_current_active_user +from ..dependencies.database import Session, get_db +from ..dependencies.fastapi_pagination_custom_page import CustomPage +from ..dependencies.safe_string import safe_clave +from ..models.permisos import Permiso +from ..models.web_paginas import WebPagina +from ..models.web_ramas import WebRama +from ..schemas.usuarios import UsuarioInDB +from ..schemas.web_paginas import OneWebPaginaOut, WebPaginaOut + +web_paginas = APIRouter(prefix="/api/v5/web_paginas", tags=["sitio web"]) + + +@web_paginas.get("/{clave}", response_model=OneWebPaginaOut) +async def detalle( + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], + database: Annotated[Session, Depends(get_db)], + clave: str, +): + """Detalle de una página web a partir de su clave""" + if current_user.permissions.get("WEB PAGINAS", 0) < Permiso.VER: + raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden") + try: + clave = safe_clave(clave) + except ValueError: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="No es válida la clave") + try: + web_pagina = database.query(WebPagina).filter_by(clave=clave).one() + except (MultipleResultsFound, NoResultFound): + return OneWebPaginaOut(success=False, message="No existe esa página web") + if web_pagina.estatus != "A": + return OneWebPaginaOut(success=False, message="No está habilitada esa página web") + return OneWebPaginaOut(success=True, message=f"Detalle de {clave}", data=WebPaginaOut.model_validate(web_pagina)) + + +@web_paginas.get("", response_model=CustomPage[WebPaginaOut]) +async def paginado( + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], + database: Annotated[Session, Depends(get_db)], + web_rama_clave: str = None, +): + """Paginado de páginas web""" + if current_user.permissions.get("WEB PAGINAS", 0) < Permiso.VER: + raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden") + consulta = database.query(WebPagina) + if web_rama_clave is not None: + try: + web_rama_clave = safe_clave(web_rama_clave) + except ValueError: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="No es válida la clave") + consulta = consulta.join(WebRama).filter(WebRama.clave == web_rama_clave).filter(WebRama.estatus == "A") + return paginate(consulta.filter(WebPagina.estatus == "A").order_by(WebPagina.clave)) diff --git a/pjecz_hercules_api_oauth2/routers/web_ramas.py b/pjecz_hercules_api_oauth2/routers/web_ramas.py new file mode 100644 index 0000000..6c61fd5 --- /dev/null +++ b/pjecz_hercules_api_oauth2/routers/web_ramas.py @@ -0,0 +1,53 @@ +""" +Web Ramas +""" + +from typing import Annotated + +from fastapi import APIRouter, Depends, HTTPException, status +from fastapi_pagination.ext.sqlalchemy import paginate +from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound + +from ..dependencies.authentications import get_current_active_user +from ..dependencies.database import Session, get_db +from ..dependencies.fastapi_pagination_custom_page import CustomPage +from ..dependencies.safe_string import safe_clave +from ..models.permisos import Permiso +from ..models.web_ramas import WebRama +from ..schemas.usuarios import UsuarioInDB +from ..schemas.web_ramas import OneWebRamaOut, WebRamaOut + +web_ramas = APIRouter(prefix="/api/v5/web_ramas", tags=["sitio web"]) + + +@web_ramas.get("/{clave}", response_model=OneWebRamaOut) +async def detalle( + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], + database: Annotated[Session, Depends(get_db)], + clave: str, +): + """Detalle de una rama web a partir de su clave""" + if current_user.permissions.get("WEB RAMAS", 0) < Permiso.VER: + raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden") + try: + clave = safe_clave(clave) + except ValueError: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="No es válida la clave") + try: + web_rama = database.query(WebRama).filter_by(clave=clave).one() + except (MultipleResultsFound, NoResultFound): + return OneWebRamaOut(success=False, message="No existe ese rama web") + if web_rama.estatus != "A": + return OneWebRamaOut(success=False, message="No está habilitado ese rama web") + return OneWebRamaOut(success=True, message=f"Detalle de {clave}", data=WebRamaOut.model_validate(web_rama)) + + +@web_ramas.get("", response_model=CustomPage[WebRamaOut]) +async def paginado( + current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)], + database: Annotated[Session, Depends(get_db)], +): + """Paginado de web_ramas""" + if current_user.permissions.get("WEB RAMAS", 0) < Permiso.VER: + raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden") + return paginate(database.query(WebRama).filter_by(estatus="A").order_by(WebRama.clave)) diff --git a/pjecz_hercules_api_oauth2/schemas/autoridad.py b/pjecz_hercules_api_oauth2/schemas/autoridad.py deleted file mode 100644 index 5c8ed96..0000000 --- a/pjecz_hercules_api_oauth2/schemas/autoridad.py +++ /dev/null @@ -1,37 +0,0 @@ -""" -Autoridades, esquemas de pydantic -""" - -from pydantic import BaseModel, ConfigDict - -from ..dependencies.schemas_base import OneBaseOut - - -class AutoridadOut(BaseModel): - """Esquema para entregar autoridades para paginado""" - - id: int | None = None - clave: str | None = None - descripcion: str | None = None - descripcion_corta: str | None = None - distrito_id: int | None = None - distrito_clave: str | None = None - distrito_nombre_corto: str | None = None - directorio_edictos: str | None = None - directorio_glosas: str | None = None - directorio_listas_de_acuerdos: str | None = None - directorio_sentencias: str | None = None - es_extinto: bool | None = None - es_cemasc: bool | None = None - es_defensoria: bool | None = None - es_jurisdiccional: bool | None = None - es_notaria: bool | None = None - es_organo_especializado: bool | None = None - organo_jurisdiccional: str | None = None - model_config = ConfigDict(from_attributes=True) - - -class OneAutoridadOut(OneBaseOut): - """Esquema para entregar una autoridad""" - - data: AutoridadOut | None = None diff --git a/pjecz_hercules_api_oauth2/schemas/autoridades.py b/pjecz_hercules_api_oauth2/schemas/autoridades.py new file mode 100644 index 0000000..7a02d16 --- /dev/null +++ b/pjecz_hercules_api_oauth2/schemas/autoridades.py @@ -0,0 +1,37 @@ +""" +Autoridades, esquemas de pydantic +""" + +from pydantic import BaseModel, ConfigDict + +from ..dependencies.schemas_base import OneBaseOut + + +class AutoridadOut(BaseModel): + """Esquema para entregar autoridades para paginado""" + + clave: str + descripcion: str + descripcion_corta: str + distrito_clave: str + distrito_nombre_corto: str + materia_clave: str + materia_nombre: str + directorio_edictos: str + directorio_glosas: str + directorio_listas_de_acuerdos: str + directorio_sentencias: str + es_extinto: bool + es_cemasc: bool + es_defensoria: bool + es_jurisdiccional: bool + es_notaria: bool + es_organo_especializado: bool + organo_jurisdiccional: str + model_config = ConfigDict(from_attributes=True) + + +class OneAutoridadOut(OneBaseOut): + """Esquema para entregar una autoridad""" + + data: AutoridadOut | None = None diff --git a/pjecz_hercules_api_oauth2/schemas/distrito.py b/pjecz_hercules_api_oauth2/schemas/distritos.py similarity index 60% rename from pjecz_hercules_api_oauth2/schemas/distrito.py rename to pjecz_hercules_api_oauth2/schemas/distritos.py index cddf643..c8f0aa4 100644 --- a/pjecz_hercules_api_oauth2/schemas/distrito.py +++ b/pjecz_hercules_api_oauth2/schemas/distritos.py @@ -10,13 +10,12 @@ class DistritoOut(BaseModel): """Esquema para entregar distritos""" - id: int | None = None - clave: str | None = None - es_distrito_judicial: bool | None = None - es_distrito: bool | None = None - es_jurisdiccional: bool | None = None - nombre_corto: str | None = None - nombre: str | None = None + clave: str + nombre: str + nombre_corto: str + es_distrito_judicial: bool + es_distrito: bool + es_jurisdiccional: bool model_config = ConfigDict(from_attributes=True) diff --git a/pjecz_hercules_api_oauth2/schemas/edictos.py b/pjecz_hercules_api_oauth2/schemas/edictos.py new file mode 100644 index 0000000..730529d --- /dev/null +++ b/pjecz_hercules_api_oauth2/schemas/edictos.py @@ -0,0 +1,53 @@ +""" +Edictos, esquemas de pydantic +""" + +from datetime import date, datetime + +from pydantic import BaseModel, ConfigDict + +from ..dependencies.schemas_base import OneBaseOut + + +class EdictoRAGIn(BaseModel): + """Esquema para recibir los datos RAG del edicto""" + + id: int + analisis: dict | None + sintesis: dict | None + categorias: dict | None + + +class EdictoOut(BaseModel): + """Esquema para entregar edictos para paginado""" + + id: int + distrito_clave: str + distrito_nombre: str + distrito_nombre_corto: str + autoridad_clave: str + autoridad_descripcion: str + autoridad_descripcion_corta: str + fecha: date + descripcion: str + expediente: str + numero_publicacion: str + es_declaracion_de_ausencia: bool = False + rag_fue_analizado_tiempo: datetime | None = None + rag_fue_sintetizado_tiempo: datetime | None = None + rag_fue_categorizado_tiempo: datetime | None = None + model_config = ConfigDict(from_attributes=True) + + +class EdictoRAGOut(EdictoOut): + """Agregar los campos RAG para cuando se entrega un edicto""" + + rag_analisis: dict | None = None + rag_sintesis: dict | None = None + rag_categorias: dict | None = None + + +class OneEdictoOut(OneBaseOut): + """Esquema para entregar un edicto""" + + data: EdictoRAGOut | None = None diff --git a/pjecz_hercules_api_oauth2/schemas/listas_de_acuerdos.py b/pjecz_hercules_api_oauth2/schemas/listas_de_acuerdos.py new file mode 100644 index 0000000..11f74e4 --- /dev/null +++ b/pjecz_hercules_api_oauth2/schemas/listas_de_acuerdos.py @@ -0,0 +1,50 @@ +""" +Listas de Acuerdos, esquemas de pydantic +""" + +from datetime import date, datetime + +from pydantic import BaseModel, ConfigDict + +from ..dependencies.schemas_base import OneBaseOut + + +class ListaDeAcuerdoRAGIn(BaseModel): + """Esquema para recibir los datos RAG de la lista de acuerdos""" + + id: int + analisis: dict | None + sintesis: dict | None + categorias: dict | None + + +class ListaDeAcuerdoOut(BaseModel): + """Esquema para entregar listas de acuerdos para paginado""" + + id: int + distrito_clave: str + distrito_nombre: str + distrito_nombre_corto: str + autoridad_clave: str + autoridad_descripcion: str + autoridad_descripcion_corta: str + fecha: date + descripcion: str + rag_fue_analizado_tiempo: datetime | None = None + rag_fue_sintetizado_tiempo: datetime | None = None + rag_fue_categorizado_tiempo: datetime | None = None + model_config = ConfigDict(from_attributes=True) + + +class ListaDeAcuerdoRAGOut(ListaDeAcuerdoOut): + """Agregar los campos RAG para cuando se entrega una lista de acuerdos""" + + rag_analisis: dict | None = None + rag_sintesis: dict | None = None + rag_categorias: dict | None = None + + +class OneListaDeAcuerdoOut(OneBaseOut): + """Esquema para entregar una lista de acuerdos""" + + data: ListaDeAcuerdoRAGOut | None = None diff --git a/pjecz_hercules_api_oauth2/schemas/materia.py b/pjecz_hercules_api_oauth2/schemas/materias.py similarity index 70% rename from pjecz_hercules_api_oauth2/schemas/materia.py rename to pjecz_hercules_api_oauth2/schemas/materias.py index 07bea82..46c2536 100644 --- a/pjecz_hercules_api_oauth2/schemas/materia.py +++ b/pjecz_hercules_api_oauth2/schemas/materias.py @@ -10,11 +10,10 @@ class MateriaOut(BaseModel): """Esquema para entregar materias""" - id: int | None = None - clave: str | None = None - nombre: str | None = None - descripcion: str | None = None - en_sentencias: bool | None = None + clave: str + nombre: str + descripcion: str + en_sentencias: bool model_config = ConfigDict(from_attributes=True) diff --git a/pjecz_hercules_api_oauth2/schemas/materia_tipo_juicio.py b/pjecz_hercules_api_oauth2/schemas/materias_tipos_juicios.py similarity index 71% rename from pjecz_hercules_api_oauth2/schemas/materia_tipo_juicio.py rename to pjecz_hercules_api_oauth2/schemas/materias_tipos_juicios.py index b5ca9b9..cc83431 100644 --- a/pjecz_hercules_api_oauth2/schemas/materia_tipo_juicio.py +++ b/pjecz_hercules_api_oauth2/schemas/materias_tipos_juicios.py @@ -10,11 +10,10 @@ class MateriaTipoJuicioOut(BaseModel): """Esquema para entregar tipos de juicios""" - id: int | None = None - materia_id: int | None = None - materia_clave: str | None = None - materia_nombre: str | None = None - descripcion: str | None = None + id: int + materia_clave: str + materia_nombre: str + descripcion: str model_config = ConfigDict(from_attributes=True) diff --git a/pjecz_hercules_api_oauth2/schemas/modulo.py b/pjecz_hercules_api_oauth2/schemas/modulos.py similarity index 66% rename from pjecz_hercules_api_oauth2/schemas/modulo.py rename to pjecz_hercules_api_oauth2/schemas/modulos.py index 82ad6e1..fc61281 100644 --- a/pjecz_hercules_api_oauth2/schemas/modulo.py +++ b/pjecz_hercules_api_oauth2/schemas/modulos.py @@ -10,12 +10,12 @@ class ModuloOut(BaseModel): """Esquema para entregar modulos""" - id: int | None = None - nombre_corto: str | None = None - nombre: str | None = None - icono: str | None = None - ruta: str | None = None - en_navegacion: bool | None = None + id: int + nombre_corto: str + nombre: str + icono: str + ruta: str + en_navegacion: bool model_config = ConfigDict(from_attributes=True) diff --git a/pjecz_hercules_api_oauth2/schemas/permiso.py b/pjecz_hercules_api_oauth2/schemas/permisos.py similarity index 63% rename from pjecz_hercules_api_oauth2/schemas/permiso.py rename to pjecz_hercules_api_oauth2/schemas/permisos.py index 094c999..7d36a75 100644 --- a/pjecz_hercules_api_oauth2/schemas/permiso.py +++ b/pjecz_hercules_api_oauth2/schemas/permisos.py @@ -10,13 +10,13 @@ class PermisoOut(BaseModel): """Esquema para entregar permisos""" - id: int | None = None - rol_id: int | None = None - rol_nombre: str | None = None - modulo_id: int | None = None - modulo_nombre: str | None = None - nombre: str | None = None - nivel: int | None = None + id: int + rol_id: int + rol_nombre: str + modulo_id: int + modulo_nombre: str + nombre: str + nivel: int model_config = ConfigDict(from_attributes=True) diff --git a/pjecz_hercules_api_oauth2/schemas/rol.py b/pjecz_hercules_api_oauth2/schemas/roles.py similarity index 86% rename from pjecz_hercules_api_oauth2/schemas/rol.py rename to pjecz_hercules_api_oauth2/schemas/roles.py index 22696db..2e90dd0 100644 --- a/pjecz_hercules_api_oauth2/schemas/rol.py +++ b/pjecz_hercules_api_oauth2/schemas/roles.py @@ -10,8 +10,8 @@ class RolOut(BaseModel): """Esquema para entregar roles""" - id: int | None = None - nombre: str | None = None + id: int + nombre: str model_config = ConfigDict(from_attributes=True) diff --git a/pjecz_hercules_api_oauth2/schemas/sentencia.py b/pjecz_hercules_api_oauth2/schemas/sentencia.py deleted file mode 100644 index 0e448cf..0000000 --- a/pjecz_hercules_api_oauth2/schemas/sentencia.py +++ /dev/null @@ -1,64 +0,0 @@ -""" -Sentencias, esquemas de pydantic -""" - -from datetime import date, datetime - -from pydantic import BaseModel, ConfigDict - -from ..dependencies.schemas_base import OneBaseOut - - -class SentenciaRAGIn(BaseModel): - """Esquema para recibir una actualización de la sentencia""" - - id: int - analisis: dict | None - sintesis: dict | None - categorias: dict | None - - -class SentenciaOut(BaseModel): - """Esquema para entregar sentencias para paginado""" - - id: int | None = None - distrito_clave: str | None = None - autoridad_clave: str | None = None - materia_nombre: str | None = None - materia_tipo_juicio_descripcion: str | None = None - sentencia: str | None = None - sentencia_fecha: date | None = None - expediente: str | None = None - expediente_anio: int | None = None - expediente_num: int | None = None - fecha: date | None = None - descripcion: str | None = None - es_perspectiva_genero: bool | None = None - rag_fue_analizado_tiempo: datetime | None = None - rag_fue_sintetizado_tiempo: datetime | None = None - rag_fue_categorizado_tiempo: datetime | None = None - archivo: str | None = None - url: str | None = None - model_config = ConfigDict(from_attributes=True) - - -class SentenciaCompleteOut(SentenciaOut): - """Esquema para entregar una sentencia en detalle""" - - distrito_id: int | None = None - distrito_nombre: str | None = None - distrito_nombre_corto: str | None = None - autoridad_id: int | None = None - autoridad_descripcion: str | None = None - autoridad_descripcion_corta: str | None = None - materia_id: int | None = None - materia_tipo_juicio_id: int | None = None - rag_analisis: dict | None = None - rag_sintesis: dict | None = None - rag_categorias: dict | None = None - - -class OneSentenciaOut(OneBaseOut): - """Esquema para entregar una sentencia""" - - data: SentenciaCompleteOut | None = None diff --git a/pjecz_hercules_api_oauth2/schemas/sentencias.py b/pjecz_hercules_api_oauth2/schemas/sentencias.py new file mode 100644 index 0000000..802e2c0 --- /dev/null +++ b/pjecz_hercules_api_oauth2/schemas/sentencias.py @@ -0,0 +1,60 @@ +""" +Sentencias, esquemas de pydantic +""" + +from datetime import date, datetime + +from pydantic import BaseModel, ConfigDict + +from ..dependencies.schemas_base import OneBaseOut + + +class SentenciaRAGIn(BaseModel): + """Esquema para recibir los datos RAG de la sentencia""" + + id: int + analisis: dict | None + sintesis: dict | None + categorias: dict | None + + +class SentenciaOut(BaseModel): + """Esquema para entregar sentencias para paginado""" + + id: int + distrito_clave: str + distrito_nombre: str + distrito_nombre_corto: str + autoridad_clave: str + autoridad_descripcion: str + autoridad_descripcion_corta: str + materia_clave: str + materia_nombre: str + materia_tipo_juicio_id: int + materia_tipo_juicio_descripcion: str + sentencia: str + sentencia_fecha: date + expediente: str + expediente_anio: int + expediente_num: int + fecha: date + descripcion: str + es_perspectiva_genero: bool + rag_fue_analizado_tiempo: datetime | None = None + rag_fue_sintetizado_tiempo: datetime | None = None + rag_fue_categorizado_tiempo: datetime | None = None + model_config = ConfigDict(from_attributes=True) + + +class SentenciaRAGOut(SentenciaOut): + """Agregar los campos RAG para cuando se entrega una sentencia""" + + rag_analisis: dict | None = None + rag_sintesis: dict | None = None + rag_categorias: dict | None = None + + +class OneSentenciaOut(OneBaseOut): + """Esquema para entregar una sentencia""" + + data: SentenciaRAGOut | None = None diff --git a/pjecz_hercules_api_oauth2/schemas/usuario.py b/pjecz_hercules_api_oauth2/schemas/usuarios.py similarity index 97% rename from pjecz_hercules_api_oauth2/schemas/usuario.py rename to pjecz_hercules_api_oauth2/schemas/usuarios.py index e2706d6..602907c 100644 --- a/pjecz_hercules_api_oauth2/schemas/usuario.py +++ b/pjecz_hercules_api_oauth2/schemas/usuarios.py @@ -19,7 +19,6 @@ class Token(BaseModel): class UsuarioOut(BaseModel): """Esquema para entregar usuarios""" - id: int | None = None apellido_paterno: str | None = None apellido_materno: str | None = None autoridad_clave: str | None = None diff --git a/pjecz_hercules_api_oauth2/schemas/usuario_rol.py b/pjecz_hercules_api_oauth2/schemas/usuarios_roles.py similarity index 100% rename from pjecz_hercules_api_oauth2/schemas/usuario_rol.py rename to pjecz_hercules_api_oauth2/schemas/usuarios_roles.py diff --git a/pjecz_hercules_api_oauth2/schemas/web_paginas.py b/pjecz_hercules_api_oauth2/schemas/web_paginas.py new file mode 100644 index 0000000..e974963 --- /dev/null +++ b/pjecz_hercules_api_oauth2/schemas/web_paginas.py @@ -0,0 +1,31 @@ +""" +Web Páginas, esquemas de pydantic +""" + +from datetime import date + +from pydantic import BaseModel, ConfigDict + +from ..dependencies.schemas_base import OneBaseOut + + +class WebPaginaOut(BaseModel): + """Esquema para items de WebPagina""" + + clave: str + contenido: str + etiquetas: str | None = None + estado: str + fecha_modificacion: date + responsable: str | None = None + resumen: str | None = None + ruta: str + titulo: str + vista_previa: str | None = None + model_config = ConfigDict(from_attributes=True) + + +class OneWebPaginaOut(OneBaseOut): + """Esquema para entregar una WebPagina""" + + data: WebPaginaOut | None = None diff --git a/pjecz_hercules_api_oauth2/schemas/web_ramas.py b/pjecz_hercules_api_oauth2/schemas/web_ramas.py new file mode 100644 index 0000000..2b67eee --- /dev/null +++ b/pjecz_hercules_api_oauth2/schemas/web_ramas.py @@ -0,0 +1,21 @@ +""" +Web Ramas, esquemas de pydantic +""" + +from pydantic import BaseModel, ConfigDict + +from ..dependencies.schemas_base import OneBaseOut + + +class WebRamaOut(BaseModel): + """Esquema para entregar WebRama""" + + clave: str + nombre: str + model_config = ConfigDict(from_attributes=True) + + +class OneWebRamaOut(OneBaseOut): + """Esquema para entregar una WebRama""" + + data: WebRamaOut | None = None diff --git a/tests/test_autoridades.py b/tests/test_autoridades.py index 7940e72..8b43776 100644 --- a/tests/test_autoridades.py +++ b/tests/test_autoridades.py @@ -38,13 +38,13 @@ def test_get_autoridades(self): # Validar los datos self.assertEqual(type(contenido["data"]), list) for item in contenido["data"]: - self.assertEqual("id" in item, True) self.assertEqual("clave" in item, True) - self.assertEqual("descripcion" in item, True) - self.assertEqual("descripcion_corta" in item, True) - self.assertEqual("distrito_id" in item, True) self.assertEqual("distrito_clave" in item, True) self.assertEqual("distrito_nombre_corto" in item, True) + self.assertEqual("materia_clave" in item, True) + self.assertEqual("materia_nombre" in item, True) + self.assertEqual("descripcion" in item, True) + self.assertEqual("descripcion_corta" in item, True) self.assertEqual("directorio_edictos" in item, True) self.assertEqual("directorio_glosas" in item, True) self.assertEqual("directorio_listas_de_acuerdos" in item, True) @@ -87,10 +87,8 @@ def test_get_autoridad_by_clave(self): item = contenido["data"] self.assertEqual("clave" in item, True) self.assertEqual(item["clave"] == clave, True) - self.assertEqual("id" in item, True) self.assertEqual("descripcion" in item, True) self.assertEqual("descripcion_corta" in item, True) - self.assertEqual("distrito_id" in item, True) self.assertEqual("distrito_clave" in item, True) self.assertEqual("distrito_nombre_corto" in item, True) self.assertEqual("directorio_edictos" in item, True) diff --git a/tests/test_distritos.py b/tests/test_distritos.py index 92231c4..0f8baf6 100644 --- a/tests/test_distritos.py +++ b/tests/test_distritos.py @@ -38,13 +38,12 @@ def test_get_distritos(self): # Validar los datos self.assertEqual(type(contenido["data"]), list) for item in contenido["data"]: - self.assertEqual("id" in item, True) self.assertEqual("clave" in item, True) + self.assertEqual("nombre" in item, True) + self.assertEqual("nombre_corto" in item, True) self.assertEqual("es_distrito_judicial" in item, True) self.assertEqual("es_distrito" in item, True) self.assertEqual("es_jurisdiccional" in item, True) - self.assertEqual("nombre_corto" in item, True) - self.assertEqual("nombre" in item, True) def test_get_distrito_by_clave(self): """Test get distrito by clave""" @@ -76,12 +75,11 @@ def test_get_distrito_by_clave(self): item = contenido["data"] self.assertEqual("clave" in item, True) self.assertEqual(item["clave"] == clave, True) - self.assertEqual("id" in item, True) + self.assertEqual("nombre" in item, True) + self.assertEqual("nombre_corto" in item, True) self.assertEqual("es_distrito_judicial" in item, True) self.assertEqual("es_distrito" in item, True) self.assertEqual("es_jurisdiccional" in item, True) - self.assertEqual("nombre_corto" in item, True) - self.assertEqual("nombre" in item, True) if __name__ == "__main__": diff --git a/tests/test_edictos.py b/tests/test_edictos.py new file mode 100644 index 0000000..59b7892 --- /dev/null +++ b/tests/test_edictos.py @@ -0,0 +1,59 @@ +""" +Unit tests for edictos +""" + +import unittest + +import requests + +from tests import config, oauth2_token + + +class TestEdictos(unittest.TestCase): + """Tests Edictos class""" + + def test_get_edictos(self): + """Test get edictos""" + + # Consultar + try: + response = requests.get( + url=f"{config['api_base_url']}/api/v5/edictos", + headers={"Authorization": f"Bearer {oauth2_token}"}, + timeout=config["timeout"], + ) + except requests.exceptions.RequestException as error: + self.fail(error) + self.assertEqual(response.status_code, 200) + + # Validar el contenido de la respuesta + contenido = response.json() + self.assertEqual("success" in contenido, True) + self.assertEqual("message" in contenido, True) + self.assertEqual("data" in contenido, True) + + # Validar que se haya tenido éxito + self.assertEqual(contenido["success"], True) + + # Validar los datos + self.assertEqual(type(contenido["data"]), list) + for item in contenido["data"]: + self.assertEqual("id" in item, True) + self.assertEqual("distrito_clave" in item, True) + self.assertEqual("distrito_nombre" in item, True) + self.assertEqual("distrito_nombre_corto" in item, True) + self.assertEqual("autoridad_clave" in item, True) + self.assertEqual("autoridad_descripcion" in item, True) + self.assertEqual("autoridad_descripcion_corta" in item, True) + self.assertEqual("fecha" in item, True) + self.assertEqual("descripcion" in item, True) + self.assertEqual("expediente" in item, True) + self.assertEqual("numero_publicacion" in item, True) + self.assertEqual("es_declaracion_de_ausencia" in item, True) + self.assertEqual("rag_fue_analizado_tiempo" in item, True) + self.assertEqual("rag_fue_sintetizado_tiempo" in item, True) + self.assertEqual("rag_fue_categorizado_tiempo" in item, True) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_listas_de_acuerdos.py b/tests/test_listas_de_acuerdos.py new file mode 100644 index 0000000..8529996 --- /dev/null +++ b/tests/test_listas_de_acuerdos.py @@ -0,0 +1,56 @@ +""" +Unit tests for listas de acuerdos +""" + +import unittest + +import requests + +from tests import config, oauth2_token + + +class TestListasDeAcuerdos(unittest.TestCase): + """Tests Listas de Acuerdos class""" + + def test_get_listas_de_acuerdos(self): + """Test get listas de acuerdos""" + + # Consultar + try: + response = requests.get( + url=f"{config['api_base_url']}/api/v5/listas_de_acuerdos", + headers={"Authorization": f"Bearer {oauth2_token}"}, + timeout=config["timeout"], + ) + except requests.exceptions.RequestException as error: + self.fail(error) + self.assertEqual(response.status_code, 200) + + # Validar el contenido de la respuesta + contenido = response.json() + self.assertEqual("success" in contenido, True) + self.assertEqual("message" in contenido, True) + self.assertEqual("data" in contenido, True) + + # Validar que se haya tenido éxito + self.assertEqual(contenido["success"], True) + + # Validar los datos + self.assertEqual(type(contenido["data"]), list) + for item in contenido["data"]: + self.assertEqual("id" in item, True) + self.assertEqual("distrito_clave" in item, True) + self.assertEqual("distrito_nombre" in item, True) + self.assertEqual("distrito_nombre_corto" in item, True) + self.assertEqual("autoridad_clave" in item, True) + self.assertEqual("autoridad_descripcion" in item, True) + self.assertEqual("autoridad_descripcion_corta" in item, True) + self.assertEqual("fecha" in item, True) + self.assertEqual("descripcion" in item, True) + self.assertEqual("rag_fue_analizado_tiempo" in item, True) + self.assertEqual("rag_fue_sintetizado_tiempo" in item, True) + self.assertEqual("rag_fue_categorizado_tiempo" in item, True) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_materias.py b/tests/test_materias.py index adc0172..9b7f63c 100644 --- a/tests/test_materias.py +++ b/tests/test_materias.py @@ -38,7 +38,6 @@ def test_get_materias(self): # Validar los datos self.assertEqual(type(contenido["data"]), list) for item in contenido["data"]: - self.assertEqual("id" in item, True) self.assertEqual("clave" in item, True) self.assertEqual("nombre" in item, True) self.assertEqual("descripcion" in item, True) @@ -74,7 +73,6 @@ def test_get_materia_by_clave(self): item = contenido["data"] self.assertEqual("clave" in item, True) self.assertEqual(item["clave"] == clave, True) - self.assertEqual("id" in item, True) self.assertEqual("nombre" in item, True) self.assertEqual("descripcion" in item, True) self.assertEqual("en_sentencias" in item, True) diff --git a/tests/test_materias_tipos_juicios.py b/tests/test_materias_tipos_juicios.py index 2f1d020..62995b7 100644 --- a/tests/test_materias_tipos_juicios.py +++ b/tests/test_materias_tipos_juicios.py @@ -39,7 +39,6 @@ def test_get_materias_tipos_juicios(self): self.assertEqual(type(contenido["data"]), list) for item in contenido["data"]: self.assertEqual("id" in item, True) - self.assertEqual("materia_id" in item, True) self.assertEqual("materia_clave" in item, True) self.assertEqual("materia_nombre" in item, True) self.assertEqual("descripcion" in item, True) diff --git a/tests/test_modulos.py b/tests/test_modulos.py index 4967c76..bb25009 100644 --- a/tests/test_modulos.py +++ b/tests/test_modulos.py @@ -38,6 +38,7 @@ def test_get_modulos(self): # Validar los datos self.assertEqual(type(contenido["data"]), list) for item in contenido["data"]: + self.assertEqual("id" in item, True) self.assertEqual("nombre_corto" in item, True) self.assertEqual("nombre" in item, True) self.assertEqual("icono" in item, True) diff --git a/tests/test_permisos.py b/tests/test_permisos.py index 3137583..ee0e8af 100644 --- a/tests/test_permisos.py +++ b/tests/test_permisos.py @@ -38,6 +38,7 @@ def test_get_permisos(self): # Validar los datos self.assertEqual(type(contenido["data"]), list) for item in contenido["data"]: + self.assertEqual("id" in item, True) self.assertEqual("rol_id" in item, True) self.assertEqual("rol_nombre" in item, True) self.assertEqual("modulo_id" in item, True) diff --git a/tests/test_roles.py b/tests/test_roles.py index 5756a14..c110c58 100644 --- a/tests/test_roles.py +++ b/tests/test_roles.py @@ -38,6 +38,7 @@ def test_get_roles(self): # Validar los datos self.assertEqual(type(contenido["data"]), list) for item in contenido["data"]: + self.assertEqual("id" in item, True) self.assertEqual("nombre" in item, True) diff --git a/tests/test_sentencias.py b/tests/test_sentencias.py index 0a80bdb..caa0a81 100644 --- a/tests/test_sentencias.py +++ b/tests/test_sentencias.py @@ -54,8 +54,6 @@ def test_get_sentencias(self): self.assertEqual("rag_fue_analizado_tiempo" in item, True) self.assertEqual("rag_fue_sintetizado_tiempo" in item, True) self.assertEqual("rag_fue_categorizado_tiempo" in item, True) - self.assertEqual("archivo" in item, True) - self.assertEqual("url" in item, True) if __name__ == "__main__": diff --git a/tests/test_usuarios_roles.py b/tests/test_usuarios_roles.py index 4565967..f2b5e33 100644 --- a/tests/test_usuarios_roles.py +++ b/tests/test_usuarios_roles.py @@ -38,6 +38,7 @@ def test_get_usuarios_roles(self): # Validar los datos self.assertEqual(type(contenido["data"]), list) for item in contenido["data"]: + self.assertEqual("id" in item, True) self.assertEqual("rol_id" in item, True) self.assertEqual("rol_nombre" in item, True) self.assertEqual("usuario_id" in item, True) diff --git a/tests/test_web_paginas.py b/tests/test_web_paginas.py new file mode 100644 index 0000000..5805f56 --- /dev/null +++ b/tests/test_web_paginas.py @@ -0,0 +1,54 @@ +""" +Unit Tests Web Paginas +""" + +import unittest + +import requests + +from tests import config, oauth2_token + + +class TestWebPaginas(unittest.TestCase): + """Tests WebPaginas class""" + + def test_get_web_paginas(self): + """Test get web_paginas""" + + # Consultar + try: + response = requests.get( + url=f"{config['api_base_url']}/api/v5/web_paginas", + headers={"Authorization": f"Bearer {oauth2_token}"}, + timeout=config["timeout"], + ) + except requests.exceptions.RequestException as error: + self.fail(error) + self.assertEqual(response.status_code, 200) + + # Validar el contenido de la respuesta + contenido = response.json() + self.assertEqual("success" in contenido, True) + self.assertEqual("message" in contenido, True) + self.assertEqual("data" in contenido, True) + + # Validar que se haya tenido éxito + self.assertEqual(contenido["success"], True) + + # Validar los datos + self.assertEqual(type(contenido["data"]), list) + for item in contenido["data"]: + self.assertEqual("clave" in item, True) + self.assertEqual("contenido" in item, True) + self.assertEqual("etiquetas" in item, True) + self.assertEqual("estado" in item, True) + self.assertEqual("fecha_modificacion" in item, True) + self.assertEqual("responsable" in item, True) + self.assertEqual("resumen" in item, True) + self.assertEqual("ruta" in item, True) + self.assertEqual("titulo" in item, True) + self.assertEqual("vista_previa" in item, True) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_web_ramas.py b/tests/test_web_ramas.py new file mode 100644 index 0000000..c190b13 --- /dev/null +++ b/tests/test_web_ramas.py @@ -0,0 +1,46 @@ +""" +Unit Tests Web Ramas +""" + +import unittest + +import requests + +from tests import config, oauth2_token + + +class TestWebRamas(unittest.TestCase): + """Tests WebRamas class""" + + def test_get_web_ramas(self): + """Test get web_ramas""" + + # Consultar + try: + response = requests.get( + url=f"{config['api_base_url']}/api/v5/web_ramas", + headers={"Authorization": f"Bearer {oauth2_token}"}, + timeout=config["timeout"], + ) + except requests.exceptions.RequestException as error: + self.fail(error) + self.assertEqual(response.status_code, 200) + + # Validar el contenido de la respuesta + contenido = response.json() + self.assertEqual("success" in contenido, True) + self.assertEqual("message" in contenido, True) + self.assertEqual("data" in contenido, True) + + # Validar que se haya tenido éxito + self.assertEqual(contenido["success"], True) + + # Validar los datos + self.assertEqual(type(contenido["data"]), list) + for item in contenido["data"]: + self.assertEqual("clave" in item, True) + self.assertEqual("nombre" in item, True) + + +if __name__ == "__main__": + unittest.main()