db update: auth middleware, modelos, routers y config

.env.example

@@ -14,4 +14,11 @@ ALGORITHM=HS256
 ACCESS_TOKEN_EXPIRE_MINUTES=60
 
 # Entorno: development / production
-ENVIRONMENT=development
+ENVIRONMENT=development
+
+# Almacenamiento de archivos adjuntos (Supabase Storage)
+# Crea un bucket PUBLICO en Supabase y pega aqui la URL del proyecto y la service_role key.
+# Si se dejan vacias, POST /archivos responde 503 (no configurado).
+SUPABASE_URL=https://TU_PROYECTO.supabase.co
+SUPABASE_SERVICE_KEY=tu_service_role_key
+SUPABASE_BUCKET=archivos

app/auth_middleware.py

@@ -33,11 +33,12 @@ async def get_current_user(
     return user
 
 
-def create_access_token(user_id: str, rol_id: int) -> str:
+def create_access_token(user_id: str, rol_id: int, pais_id: int | None = None) -> str:
     expire = datetime.now(timezone.utc) + timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
     payload = {
         "sub": user_id,
         "rol": rol_id,
+        "pais_id": pais_id,
         "exp": expire,
     }
     return jwt.encode(payload, settings.SECRET_KEY, algorithm=settings.ALGORITHM)

app/config.py

@@ -8,6 +8,11 @@ class Settings(BaseSettings):
     ACCESS_TOKEN_EXPIRE_MINUTES: int = 60
     ENVIRONMENT: str = "production"
 
+    # Almacenamiento de archivos (Supabase Storage)
+    SUPABASE_URL: str = ""
+    SUPABASE_SERVICE_KEY: str = ""
+    SUPABASE_BUCKET: str = "archivos"
+
     class Config:
         env_file = ".env"
 

app/main.py

@@ -8,7 +8,7 @@ from app.routers import (
     estadisticas_paises, roles, configuracion, usuarios,
     ciudades_mision, ingresos, miembros_info_adicional,
     saldos_caja_banco, traslados, auth, continentes,
-    estudios_diarios, estadisticas,
+    estudios_diarios, estadisticas, archivos,
 )
 
 app = FastAPI(
@@ -134,6 +134,61 @@ async def startup():
             await conn.execute(text("""
                 ALTER TABLE cotizaciones ADD COLUMN IF NOT EXISTS ciudad_id INTEGER
             """))
+            # Correlativo de recibos por pais+anio+mes (RC-001)
+            await conn.execute(text("""
+                ALTER TABLE ingresos ADD COLUMN IF NOT EXISTS numero VARCHAR(20)
+            """))
+            # Backfill idempotente: solo rellena los que aun no tienen numero
+            await conn.execute(text("""
+                WITH numbered AS (
+                    SELECT id, 'RC-' || LPAD((ROW_NUMBER() OVER (
+                        PARTITION BY pais_id, anio, mes ORDER BY fecha, id))::text, 3, '0') AS num
+                    FROM ingresos
+                )
+                UPDATE ingresos i SET numero = n.num
+                FROM numbered n WHERE i.id = n.id AND i.numero IS NULL
+            """))
+            # Codigos contables de caja/banco
+            await conn.execute(text("""
+                ALTER TABLE saldos_caja_banco ADD COLUMN IF NOT EXISTS codigo_contable_caja VARCHAR(20)
+            """))
+            await conn.execute(text("""
+                ALTER TABLE saldos_caja_banco ADD COLUMN IF NOT EXISTS codigo_contable_banco VARCHAR(20)
+            """))
+            # Tabla de archivos adjuntos (ingresos/gastos)
+            await conn.execute(text("""
+                CREATE TABLE IF NOT EXISTS public.archivos (
+                    id              SERIAL PRIMARY KEY,
+                    tipo            VARCHAR(20) NOT NULL,
+                    referencia_id   INTEGER NOT NULL,
+                    nombre_original TEXT,
+                    content_type    VARCHAR(100),
+                    tamano_bytes    BIGINT,
+                    storage_path    TEXT,
+                    url             TEXT NOT NULL,
+                    fecha_creacion  TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                    CONSTRAINT chk_archivos_tipo CHECK (tipo IN ('ingreso', 'gasto'))
+                )
+            """))
+            await conn.execute(text("""
+                CREATE INDEX IF NOT EXISTS idx_archivos_ref ON public.archivos (tipo, referencia_id)
+            """))
+            # Proteger contactos con estudios: recrear FK contacto_id como RESTRICT
+            await conn.execute(text("""
+                DO $$ DECLARE existing text; BEGIN
+                    SELECT conname INTO existing FROM pg_constraint c
+                    WHERE c.conrelid='estudios_diarios'::regclass AND c.contype='f'
+                      AND (SELECT attname FROM pg_attribute
+                           WHERE attrelid=c.conrelid AND attnum=c.conkey[1])='contacto_id';
+                    IF existing IS NOT NULL THEN
+                        IF (SELECT confdeltype FROM pg_constraint WHERE conname=existing) <> 'r' THEN
+                            EXECUTE format('ALTER TABLE estudios_diarios DROP CONSTRAINT %I', existing);
+                            ALTER TABLE estudios_diarios ADD CONSTRAINT estudios_diarios_contacto_id_fkey
+                                FOREIGN KEY (contacto_id) REFERENCES contactos(id) ON DELETE RESTRICT;
+                        END IF;
+                    END IF;
+                END $$
+            """))
 
             # ── Claves foraneas (idempotentes) ─────────────────────────────
             # Postgres no soporta ADD CONSTRAINT IF NOT EXISTS para FK, por eso
@@ -205,6 +260,7 @@ app.include_router(auth.router)
 app.include_router(continentes.router)
 app.include_router(estudios_diarios.router)
 app.include_router(estadisticas.router)
+app.include_router(archivos.router)
 
 
 @app.get("/", tags=["Estado"])

app/models.py

@@ -339,6 +339,7 @@ class Ingreso(Base):
     __tablename__ = "ingresos"
 
     id = Column(Integer, primary_key=True)
+    numero = Column(String(20))
     pais_id = Column(Integer, ForeignKey("paises.id", ondelete="SET NULL"))
     mes = Column(Integer, nullable=False)
     anio = Column(Integer, nullable=False)
@@ -376,6 +377,8 @@ class SaldoCajaBanco(Base):
     pais_id = Column(Integer, ForeignKey("paises.id", ondelete="SET NULL"))
     saldo_caja = Column(Numeric(15, 2), nullable=False, default=0)
     saldo_banco = Column(Numeric(15, 2), nullable=False, default=0)
+    codigo_contable_caja = Column(String(20))
+    codigo_contable_banco = Column(String(20))
     updated_at = Column(DateTime, default=datetime.utcnow, nullable=False)
 
     pais_rel = relationship("Pais", back_populates="saldos")
@@ -411,7 +414,7 @@ class EstudioDiario(Base):
     id = Column(Integer, primary_key=True)
     miembro_id = Column(String(30), ForeignKey("miembros.id", ondelete="CASCADE"), nullable=False)
     pais_id = Column(Integer, ForeignKey("paises.id", ondelete="SET NULL"))
-    contacto_id = Column(Integer, ForeignKey("contactos.id", ondelete="SET NULL"))
+    contacto_id = Column(Integer, ForeignKey("contactos.id", ondelete="RESTRICT"))
     mes = Column(Integer, nullable=False)
     anio = Column(Integer, nullable=False)
     dia = Column(Integer, nullable=False)
@@ -426,3 +429,21 @@ class EstudioDiario(Base):
     miembro_rel = relationship("Miembro", back_populates="estudios_diarios")
     pais_rel = relationship("Pais")
     contacto_rel = relationship("Contacto")
+
+
+class Archivo(Base):
+    __tablename__ = "archivos"
+
+    id = Column(Integer, primary_key=True)
+    tipo = Column(String(20), nullable=False)          # 'ingreso' | 'gasto'
+    referencia_id = Column(Integer, nullable=False)     # id del ingreso o gasto asociado
+    nombre_original = Column(Text)
+    content_type = Column(String(100))
+    tamano_bytes = Column(BigInteger)
+    storage_path = Column(Text)
+    url = Column(Text, nullable=False)
+    fecha_creacion = Column(DateTime, default=datetime.utcnow, nullable=False)
+
+    __table_args__ = (
+        CheckConstraint("tipo IN ('ingreso', 'gasto')", name="chk_archivos_tipo"),
+    )

app/routers/archivos.py

@@ -0,0 +1,96 @@
+import uuid
+
+import httpx
+from fastapi import APIRouter, Depends, HTTPException, Query, UploadFile, File, Form
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from app.database import get_db
+from app.config import settings
+from app.models import Archivo, Ingreso, GastoReal
+from app.schemas import ArchivoOut
+
+router = APIRouter(prefix="/archivos", tags=["Archivos"])
+
+TIPOS_VALIDOS = {"ingreso", "gasto"}
+
+
+async def _validar_referencia(db: AsyncSession, tipo: str, referencia_id: int):
+    modelo = Ingreso if tipo == "ingreso" else GastoReal
+    obj = await db.get(modelo, referencia_id)
+    if not obj:
+        raise HTTPException(404, f"No existe un {tipo} con id {referencia_id}")
+
+
+async def _subir_a_supabase(path: str, contenido: bytes, content_type: str) -> str:
+    if not settings.SUPABASE_URL or not settings.SUPABASE_SERVICE_KEY:
+        raise HTTPException(
+            503,
+            "Almacenamiento de archivos no configurado (faltan SUPABASE_URL / SUPABASE_SERVICE_KEY).",
+        )
+    base = settings.SUPABASE_URL.rstrip("/")
+    bucket = settings.SUPABASE_BUCKET
+    upload_url = f"{base}/storage/v1/object/{bucket}/{path}"
+    headers = {
+        "Authorization": f"Bearer {settings.SUPABASE_SERVICE_KEY}",
+        "Content-Type": content_type or "application/octet-stream",
+        "x-upsert": "true",
+    }
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.post(upload_url, content=contenido, headers=headers)
+    if resp.status_code not in (200, 201):
+        raise HTTPException(502, f"Error al subir el archivo al almacenamiento: {resp.text}")
+    return f"{base}/storage/v1/object/public/{bucket}/{path}"
+
+
+@router.get("", response_model=list[ArchivoOut])
+async def listar(
+    tipo: str | None = Query(None),
+    referencia_id: int | None = Query(None),
+    db: AsyncSession = Depends(get_db),
+):
+    q = select(Archivo).order_by(Archivo.fecha_creacion.desc())
+    if tipo:
+        q = q.where(Archivo.tipo == tipo)
+    if referencia_id:
+        q = q.where(Archivo.referencia_id == referencia_id)
+    result = await db.execute(q)
+    return result.scalars().all()
+
+
+@router.post("", response_model=ArchivoOut, status_code=201)
+async def subir(
+    tipo: str = Form(...),
+    referencia_id: int = Form(...),
+    file: UploadFile = File(...),
+    db: AsyncSession = Depends(get_db),
+):
+    if tipo not in TIPOS_VALIDOS:
+        raise HTTPException(422, "tipo debe ser 'ingreso' o 'gasto'")
+    await _validar_referencia(db, tipo, referencia_id)
+
+    contenido = await file.read()
+    nombre = file.filename or "archivo"
+    path = f"{tipo}/{referencia_id}/{uuid.uuid4().hex}_{nombre}"
+    url = await _subir_a_supabase(path, contenido, file.content_type)
+
+    obj = Archivo(
+        tipo=tipo,
+        referencia_id=referencia_id,
+        nombre_original=nombre,
+        content_type=file.content_type,
+        tamano_bytes=len(contenido),
+        storage_path=path,
+        url=url,
+    )
+    db.add(obj)
+    await db.flush()
+    await db.refresh(obj)
+    return obj
+
+
+@router.delete("/{id}", status_code=204)
+async def eliminar(id: int, db: AsyncSession = Depends(get_db)):
+    obj = await db.get(Archivo, id)
+    if not obj:
+        raise HTTPException(404, "Archivo no encontrado")
+    await db.delete(obj)

app/routers/auth.py

@@ -3,7 +3,7 @@ from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 from app.database import get_db
-from app.models import Usuario, Rol
+from app.models import Usuario, Rol, Pais
 from app.schemas import LoginRequest, TokenResponse, UsuarioLoginOut
 from app.auth_middleware import create_access_token
 
@@ -39,7 +39,12 @@ async def login(data: LoginRequest, db: AsyncSession = Depends(get_db)):
     rol_obj = rol_result.scalar_one_or_none()
     rol_nombre = rol_obj.nombre if rol_obj else ""
 
-    token = create_access_token(user.id, user.rol)
+    pais_nombre = None
+    if user.pais_id is not None:
+        pais_obj = await db.get(Pais, user.pais_id)
+        pais_nombre = pais_obj.nombre if pais_obj else None
+
+    token = create_access_token(user.id, user.rol, user.pais_id)
     usuario_out = UsuarioLoginOut(
         id=user.id,
         nombre=user.nombre,
@@ -47,6 +52,8 @@ async def login(data: LoginRequest, db: AsyncSession = Depends(get_db)):
         rol_id=user.rol,
         rol_nombre=rol_nombre,
         activo=user.activo,
+        pais_id=user.pais_id,
+        pais_nombre=pais_nombre,
     )
     return TokenResponse(token=token, usuario=usuario_out)
 

app/routers/contactos.py

@@ -2,6 +2,7 @@ from fastapi import APIRouter, Depends, HTTPException, Query
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 from sqlalchemy.orm import selectinload
+from sqlalchemy.exc import IntegrityError
 from app.database import get_db
 from app.models import Contacto, Pais
 from app.schemas import ContactoCreate, ContactoUpdate, ContactoOut
@@ -88,3 +89,11 @@ async def eliminar(id: int, db: AsyncSession = Depends(get_db)):
     if not obj:
         raise HTTPException(404, "Contacto no encontrado")
     await db.delete(obj)
+    try:
+        await db.flush()
+    except IntegrityError:
+        await db.rollback()
+        raise HTTPException(
+            409,
+            "No se puede eliminar el contacto porque tiene estudios biblicos registrados.",
+        )

app/routers/ingresos.py

@@ -8,6 +8,21 @@ from app.schemas import IngresoCreate, IngresoUpdate, IngresoOut
 router = APIRouter(prefix="/ingresos", tags=["Ingresos"])
 
 
+async def _siguiente_numero(db: AsyncSession, pais_id: int | None, anio: int, mes: int) -> str:
+    """Correlativo por pais + anio + mes, formato RC-001. Robusto ante huecos/borrados."""
+    q = select(Ingreso.numero).where(Ingreso.anio == anio, Ingreso.mes == mes)
+    q = q.where(Ingreso.pais_id.is_(None) if pais_id is None else Ingreso.pais_id == pais_id)
+    result = await db.execute(q)
+    maximo = 0
+    for (numero,) in result.all():
+        if numero and numero.startswith("RC-"):
+            try:
+                maximo = max(maximo, int(numero[3:]))
+            except ValueError:
+                pass
+    return f"RC-{maximo + 1:03d}"
+
+
 @router.get("", response_model=list[IngresoOut])
 async def listar(
     pais_id: int | None = Query(None),
@@ -43,6 +58,7 @@ async def obtener(id: int, db: AsyncSession = Depends(get_db)):
 @router.post("", response_model=IngresoOut, status_code=201)
 async def crear(data: IngresoCreate, db: AsyncSession = Depends(get_db)):
     obj = Ingreso(**data.model_dump())
+    obj.numero = await _siguiente_numero(db, data.pais_id, data.anio, data.mes)
     db.add(obj)
     await db.flush()
     await db.refresh(obj)

app/schemas.py

@@ -574,6 +574,7 @@ class IngresoUpdate(BaseModel):
 
 class IngresoOut(IngresoBase):
     id: int
+    numero: Optional[str] = None
     fecha_creacion: datetime
     model_config = {"from_attributes": True}
 
@@ -612,6 +613,8 @@ class SaldoCajaBancoBase(BaseModel):
     pais_id: Optional[int] = None
     saldo_caja: Decimal = Decimal("0")
     saldo_banco: Decimal = Decimal("0")
+    codigo_contable_caja: Optional[str] = None
+    codigo_contable_banco: Optional[str] = None
 
 class SaldoCajaBancoCreate(SaldoCajaBancoBase):
     pass
@@ -620,6 +623,8 @@ class SaldoCajaBancoUpdate(BaseModel):
     pais_id: Optional[int] = None
     saldo_caja: Optional[Decimal] = None
     saldo_banco: Optional[Decimal] = None
+    codigo_contable_caja: Optional[str] = None
+    codigo_contable_banco: Optional[str] = None
 
 class SaldoCajaBancoOut(SaldoCajaBancoBase):
     id: int
@@ -736,6 +741,8 @@ class UsuarioLoginOut(BaseModel):
     rol_id: int
     rol_nombre: str
     activo: bool
+    pais_id: Optional[int] = None
+    pais_nombre: Optional[str] = None
     model_config = {"from_attributes": True}
 
 class TokenResponse(BaseModel):
@@ -743,6 +750,20 @@ class TokenResponse(BaseModel):
     usuario: UsuarioLoginOut
 
 
+# ── Archivos ───────────────────────────────────────────────────────────────
+
+class ArchivoOut(BaseModel):
+    id: int
+    tipo: str
+    referencia_id: int
+    nombre_original: Optional[str] = None
+    content_type: Optional[str] = None
+    tamano_bytes: Optional[int] = None
+    url: str
+    fecha_creacion: datetime
+    model_config = {"from_attributes": True}
+
+
 # ── Estadisticas Agregadas ────────────────────────────────────────────────
 
 class SerieData(BaseModel):

requirements.txt

@@ -7,3 +7,5 @@ pydantic[email]==2.10.3
 pydantic-settings==2.6.1
 python-jose[cryptography]==3.3.0
 passlib[bcrypt]==1.7.4
+python-multipart==0.0.12
+httpx==0.27.2