Merge pull request #21 from guivaloz:guivaloz/snippets

Nuevos modulos.

.vscode/fastapi-models.code-snippets

@@ -7,10 +7,12 @@
       "${1:Modulos}, modelos",
       "\"\"\"",
       "",
-      "from collections import OrderedDict",
+      "from datetime import datetime",
+      "from typing import List, Optional",
       "",
-      "from sqlalchemy import Boolean, Column, Date, Enum, ForeignKey, Integer, String",
-      "from sqlalchemy.orm import relationship",
+      "from sqlalchemy import Boolean, DateTime, Enum, ForeignKey, JSON, Integer, String, Text, Uuid",
+      "from sqlalchemy.orm import Mapped, mapped_column, relationship",
+      "from sqlalchemy.sql.functions import now",
       "",
       "from lib.database import Base",
       "from lib.universal_mixin import UniversalMixin",
@@ -19,32 +21,40 @@
       "class ${2:Clase}(Base, UniversalMixin):",
       "\t\"\"\" ${2:Clase} \"\"\"",
       "",
+      "\tESTADOS = {",
+      "\t\t\"PENDIENTE\": \"Pendiente\",",
+      "\t\t\"CANCELADO\": \"Cancelado\",",
+      "\t}",
+      "",
       "\t# Nombre de la tabla",
-      "\t__tablename__ = '${4:tables}'",
+      "\t__tablename__ = '${3:tabla}'",
       "",
       "\t# Clave primaria",
-      "\tid = Column(Integer, primary_key=True)",
+      "\tid: Mapped[int] = mapped_column(primary_key=True)",
       "",
       "\t# Columnas",
-      "\tfecha = Column(Date, index=True, nullable=False)",
-      "\tdescripcion = Column(String(256), nullable=False)",
-      "\tarchivo = Column(String(256), default=\"\")",
-      "\turl = Column(String(512), default=\"\")",
+      "\tclave: Mapped[str] = mapped_column(String(16), unique=True)",
+      "\tdescripcion: Mapped[str] = mapped_column(String(256))",
+      "\tcantidad: Mapped[int]",
+      "\tfecha_hora: Mapped[datetime] = mapped_column(DateTime, default=now())",
+      "\tes_adulto_mayor: Mapped[bool] = mapped_column(default=False)",
+      "\testado: Mapped[str] = mapped_column(Enum(*ESTADOS, name=\"${3:tabla}_estados\", native_enum=False), index=True)",
+      "\tobservaciones: Mapped[Optional[str]] = mapped_column(String(1024))",
       "",
       "\tdef __repr__(self):",
       "\t\t\"\"\" Representación \"\"\"",
-      "\t\treturn f\"<${2:Clase} {self.id}>\"",
+      "\t\treturn f'<${2:Clase} {self.id}>'",
       ""
     ],
-    "description": "Contenido para models.py"
+    "description": "Contenido inicial para modelos"
   },
   "Flask models foreign key": {
     "scope": "python",
     "prefix": "fmodels_clave_foranea",
     "body": [
       "# Clave foránea",
-      "${1:clave_foranea}_id = Column(Integer, ForeignKey('${2:tabla_clave_foranea}.id'), index=True, nullable=False)",
-      "${1:clave_foranea} = relationship('${3:Clase_clave_foranea}', back_populates='${4:plural_esta_clase}')",
+      "${1:clave_foranea}_id: Mapped[int] = mapped_column(ForeignKey(\"${2:tabla_clave_foranea}.id\"))",
+      "${1:clave_foranea}: Mapped[\"${3:Clase_clave_foranea}\"] = relationship(back_populates=\"${4:plural_esta_clase}\")",
       ""
     ],
     "description": "Clave foránea"
@@ -54,7 +64,7 @@
     "prefix": "fmodels_hijo",
     "body": [
       "# Hijos",
-      "${1:plural_hijos} = relationship('${2:Clase_hijo}', back_populates='${3:singular_esta_clase}')",
+      "${1:plural_hijos}: Mapped[List[\"${2:Clase_hijo}\"]] = relationship(back_populates=\"${3:singular_esta_clase}\")",
       ""
     ],
     "description": "Hijo"

carina/app.py

@@ -11,6 +11,7 @@
 from .v4.autoridades.paths import autoridades
 from .v4.bitacoras.paths import bitacoras
 from .v4.distritos.paths import distritos
+from .v4.domicilios.paths import domicilios
 from .v4.entradas_salidas.paths import entradas_salidas
 from .v4.estados.paths import estados
 from .v4.exh_areas.paths import exh_areas
@@ -20,6 +21,7 @@
 from .v4.materias.paths import materias
 from .v4.modulos.paths import modulos
 from .v4.municipios.paths import municipios
+from .v4.oficinas.paths import oficinas
 from .v4.permisos.paths import permisos
 from .v4.roles.paths import roles
 from .v4.tareas.paths import tareas
@@ -52,15 +54,17 @@ def create_app() -> FastAPI:
     app.include_router(autoridades, include_in_schema=False)
     app.include_router(bitacoras, include_in_schema=False)
     app.include_router(distritos, include_in_schema=False)
+    app.include_router(domicilios, include_in_schema=False)
     app.include_router(entradas_salidas, include_in_schema=False)
     app.include_router(estados)
-    app.include_router(exh_areas)
+    app.include_router(exh_areas, include_in_schema=False)
     app.include_router(exh_exhortos)
     app.include_router(exh_exhortos_archivos)
     app.include_router(exh_exhortos_partes)
     app.include_router(materias)
     app.include_router(modulos, include_in_schema=False)
     app.include_router(municipios)
+    app.include_router(oficinas, include_in_schema=False)
     app.include_router(permisos, include_in_schema=False)
     app.include_router(roles, include_in_schema=False)
     app.include_router(tareas, include_in_schema=False)

carina/core/domicilios/models.py

@@ -0,0 +1,43 @@
+"""
+Domicilios, modelos
+"""
+
+from typing import List
+
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from lib.database import Base
+from lib.universal_mixin import UniversalMixin
+
+
+class Domicilio(Base, UniversalMixin):
+    """Domicilio"""
+
+    # Nombre de la tabla
+    __tablename__ = "domicilios"
+
+    # Clave primaria
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    # Clave foránea
+    distrito_id: Mapped[int] = mapped_column(ForeignKey("distritos.id"))
+    distrito: Mapped["Distrito"] = relationship(back_populates="domicilios")
+
+    # Columnas
+    edificio: Mapped[str] = mapped_column(String(64), unique=True)
+    estado: Mapped[str] = mapped_column(String(64))
+    municipio: Mapped[str] = mapped_column(String(64))
+    calle: Mapped[str] = mapped_column(String(256))
+    num_ext: Mapped[str] = mapped_column(String(24))
+    num_int: Mapped[str] = mapped_column(String(24))
+    colonia: Mapped[str] = mapped_column(String(256))
+    cp: Mapped[int]
+    completo: Mapped[str] = mapped_column(String(1024))
+
+    # Hijos
+    oficinas: Mapped[List["Oficina"]] = relationship("Oficina", back_populates="domicilio")
+
+    def __repr__(self):
+        """Representación"""
+        return f"<Domicilio {self.edificio}>"

carina/core/materias/models.py

@@ -21,7 +21,8 @@ class Materia(Base, UniversalMixin):
     id: Mapped[int] = mapped_column(primary_key=True)
 
     # Columnas
-    nombre: Mapped[str] = mapped_column(String(256), unique=True)
+    clave: Mapped[str] = mapped_column(String(16), unique=True)
+    nombre: Mapped[str] = mapped_column(String(256))
     descripcion: Mapped[str] = mapped_column(String(1024))
     en_sentencias: Mapped[bool] = mapped_column(Boolean, default=False)
 

carina/core/oficinas/models.py

@@ -0,0 +1,53 @@
+"""
+Oficinas, modelos
+"""
+
+from datetime import time
+from typing import List
+
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from lib.database import Base
+from lib.universal_mixin import UniversalMixin
+
+
+class Oficina(Base, UniversalMixin):
+    """Oficina"""
+
+    TIPOS = {
+        "NO DEFINIDO": "NO DEFINIDO",
+        "O.J. DE 1RA. INSTANCIA": "O.J. DE 1RA. INSTANCIA",
+        "O.J. DE 2DA. INSTANCIA": "O.J. DE 2DA. INSTANCIA",
+        "ADMINISTRATICO Y/O U. ADMIN.": "ADMINISTRATICO Y/O U. ADMIN.",
+    }
+
+    # Nombre de la tabla
+    __tablename__ = "oficinas"
+
+    # Clave primaria
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    # Claves foráneas
+    distrito_id: Mapped[int] = mapped_column(ForeignKey("distritos.id"))
+    distrito: Mapped["Distrito"] = relationship(back_populates="oficinas")
+    domicilio_id: Mapped[int] = mapped_column(ForeignKey("domicilios.id"))
+    domicilio: Mapped["Domicilio"] = relationship(back_populates="oficinas")
+
+    # Columnas
+    clave: Mapped[str] = mapped_column(String(32), unique=True)
+    descripcion: Mapped[str] = mapped_column(String(512))
+    descripcion_corta: Mapped[str] = mapped_column(String(64))
+    es_jurisdiccional: Mapped[bool] = mapped_column(default=False)
+    apertura: Mapped[time]
+    cierre: Mapped[time]
+    limite_personas: Mapped[int]
+    telefono: Mapped[str] = mapped_column(String(48))
+    extension: Mapped[str] = mapped_column(String(24))
+
+    # Hijos
+    usuarios: Mapped[List["Usuario"]] = relationship("Usuario", back_populates="oficina")
+
+    def __repr__(self):
+        """Representación"""
+        return f"<Oficina {self.id}>"

carina/core/usuarios/models.py

@@ -24,6 +24,8 @@ class Usuario(Base, UniversalMixin):
     # Claves foráneas
     autoridad_id: Mapped[int] = mapped_column(ForeignKey("autoridades.id"))
     autoridad: Mapped["Autoridad"] = relationship("Autoridad", back_populates="usuarios")
+    oficina_id: Mapped[int] = mapped_column(ForeignKey("oficinas.id"))
+    oficina: Mapped["Oficina"] = relationship("Oficina", back_populates="usuarios")
 
     # Columnas
     email: Mapped[str] = mapped_column(String(256), unique=True, index=True)

carina/v4/domicilios/crud.py

@@ -0,0 +1,27 @@
+"""
+Domicilios v4, CRUD (create, read, update, and delete)
+"""
+
+from typing import Any
+
+from sqlalchemy.orm import Session
+
+from lib.exceptions import MyIsDeletedError, MyNotExistsError
+
+from ...core.domicilios.models import Domicilio
+
+
+def get_domicilios(database: Session) -> Any:
+    """Consultar los domicilio activos"""
+    consulta = database.query(Domicilio)
+    return consulta.filter_by(estatus="A").order_by(Domicilio.id)
+
+
+def get_domicilio(database: Session, domicilio_id: int) -> Domicilio:
+    """Consultar un domicilio por su id"""
+    domicilio = database.query(Domicilio).get(domicilio_id)
+    if domicilio is None:
+        raise MyNotExistsError("No existe ese domicilio")
+    if domicilio.estatus != "A":
+        raise MyIsDeletedError("No es activo ese domicilio, está eliminado")
+    return domicilio

carina/v4/domicilios/paths.py

@@ -0,0 +1,50 @@
+"""
+Domicilios v4, rutas (paths)
+"""
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi_pagination.ext.sqlalchemy import paginate
+
+from lib.database import Session, get_db
+from lib.exceptions import MyAnyError
+from lib.fastapi_pagination_custom_page import CustomPage
+
+from ...core.permisos.models import Permiso
+from ..usuarios.authentications import UsuarioInDB, get_current_active_user
+from .crud import get_domicilio, get_domicilios
+from .schemas import DomicilioOut, OneDomicilioOut
+
+domicilios = APIRouter(prefix="/v4/domicilios", tags=["categoria"])
+
+
+@domicilios.get("", response_model=CustomPage[DomicilioOut])
+async def paginado_domicilios(
+    current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)],
+    database: Annotated[Session, Depends(get_db)],
+):
+    """Paginado de domicilios"""
+    if current_user.permissions.get("DOMICILIOS", 0) < Permiso.VER:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden")
+    try:
+        resultados = get_domicilios(database)
+    except MyAnyError as error:
+        return CustomPage(success=False, errors=[str(error)])
+    return paginate(resultados)
+
+
+@domicilios.get("/{domicilio_id}", response_model=OneDomicilioOut)
+async def detalle_domicilio(
+    current_user: Annotated[UsuarioInDB, Depends(get_current_active_user)],
+    database: Annotated[Session, Depends(get_db)],
+    domicilio_id: int,
+):
+    """Detalle de una domicilio a partir de su id"""
+    if current_user.permissions.get("DOMICILIOS", 0) < Permiso.VER:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden")
+    try:
+        domicilio = get_domicilio(database, domicilio_id)
+    except MyAnyError as error:
+        return OneDomicilioOut(success=False, errors=[str(error)])
+    return OneDomicilioOut.model_validate(domicilio)

carina/v4/domicilios/schemas.py

@@ -0,0 +1,21 @@
+"""
+Domicilios v4, esquemas de pydantic
+"""
+
+from pydantic import BaseModel, ConfigDict
+
+from lib.schemas_base import OneBaseOut
+
+
+class DomicilioOut(BaseModel):
+    """Esquema para entregar domicilios"""
+
+    id: int | None = None
+    edificio: str | None = None
+    model_config = ConfigDict(from_attributes=True)
+
+
+class OneDomicilioOut(OneBaseOut):
+    """Esquema para entregar un domicilio"""
+
+    data: DomicilioOut | None = None

carina/v4/oficinas/crud.py

@@ -0,0 +1,27 @@
+"""
+Oficinas v4, CRUD (create, read, update, and delete)
+"""
+
+from typing import Any
+
+from sqlalchemy.orm import Session
+
+from lib.exceptions import MyIsDeletedError, MyNotExistsError
+
+from ...core.oficinas.models import Oficina
+
+
+def get_oficinas(database: Session) -> Any:
+    """Consultar los oficinas activos"""
+    consulta = database.query(Oficina)
+    return consulta.filter_by(estatus="A").order_by(Oficina.id)
+
+
+def get_oficina(database: Session, oficina_id: int) -> Oficina:
+    """Consultar un oficina por su id"""
+    oficina = database.query(Oficina).get(oficina_id)
+    if oficina is None:
+        raise MyNotExistsError("No existe ese oficina")
+    if oficina.estatus != "A":
+        raise MyIsDeletedError("No es activo ese oficina, está eliminado")
+    return oficina