deploy from github actions

app/models/user.py

@@ -20,6 +20,7 @@ class User(Base):
     username_changes_this_month = Column(Integer, default=0)
     last_username_change_at = Column(DateTime, nullable=True)
     is_forum_banned = Column(Boolean, default=False)
+    last_monthly_credit_month = Column(String, nullable=True, default=None)  # Formato: "YYYY-MM"
     
     devices = relationship("Device", back_populates="user")
     tasks = relationship("Task", back_populates="user")

app/routers/auth.py

@@ -159,6 +159,15 @@ async def get_current_user(
                 detail="Session invalidated. Logged in from another device.",
                 headers={"WWW-Authenticate": "Bearer"},
             )
+
+    # Verificación quirúrgica de recarga mensual de 10 créditos (1 de cada mes / primer acceso del mes)
+    current_month = datetime.utcnow().strftime("%Y-%m")
+    if getattr(user, "last_monthly_credit_month", None) != current_month:
+        try:
+            from app.utils.credits import grant_monthly_credits_to_user
+            grant_monthly_credits_to_user(db, user, year_month=current_month, amount=10)
+        except Exception as e_month:
+            logger.warning(f"Error aplicando recarga mensual perezosa a usuario {user.id}: {e_month}")
             
     return user
 
@@ -201,11 +210,13 @@ def register_user(user: UserCreate, db: Session = Depends(get_db)):
 
     # Crear usuario
     hashed_password = get_password_hash(user.password)
+    current_month = datetime.utcnow().strftime("%Y-%m")
     new_user = User(
         username=reg_username,
         email=user.email,
         hashed_password=hashed_password,
-        credits=10  # Créditos iniciales de prueba
+        credits=10,  # Créditos iniciales de registro
+        last_monthly_credit_month=current_month
     )
     db.add(new_user)
     db.commit()
@@ -278,6 +289,15 @@ async def login_for_access_token(
             headers={"WWW-Authenticate": "Bearer"},
         )
 
+    # Verificación quirúrgica de recarga mensual de 10 créditos al iniciar sesión
+    current_month = datetime.utcnow().strftime("%Y-%m")
+    if getattr(user, "last_monthly_credit_month", None) != current_month:
+        try:
+            from app.utils.credits import grant_monthly_credits_to_user
+            grant_monthly_credits_to_user(db, user, year_month=current_month, amount=10)
+        except Exception as e_month:
+            logger.warning(f"Error aplicando recarga mensual al login de usuario {user.id}: {e_month}")
+
     # ==========================================
     # GESTIÓN DE DISPOSITIVOS
     # ==========================================

app/routers/lyrics.py

@@ -98,7 +98,7 @@ def list_groups(db: Session = Depends(get_db), current_user: User = Depends(get_
 
 @router.get("/repertorios", response_model=List[RepertorioOut])
 def list_repertorios(db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
-    return db.query(Repertorio).filter(Repertorio.created_by == current_user.id).all()
+    return db.query(Repertorio).filter(Repertorio.created_by == current_user.id, Repertorio.group_id == None).all()
 
 @router.get("/{lyric_id}", response_model=LyricOut)
 def get_lyric(lyric_id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):

app/utils/credits.py

@@ -236,6 +236,97 @@ def reward_public_worker_owner(
     return True
 
 
+def grant_monthly_credits_to_user(
+    db: Session,
+    user: User,
+    year_month: str = None,
+    amount: int = 10
+) -> bool:
+    """
+    Otorga de forma quirúrgica e idempotente los 10 créditos mensuales a una cuenta registrada.
+    
+    Garantías de seguridad:
+    - Validación 100% en backend (imposible de manipular o inyectar desde el frontend).
+    - Doble capa de protección contra duplicados (campo last_monthly_credit_month + registro en CreditTransaction).
+    - Notificación en tiempo real por WebSocket.
+    """
+    if not user:
+        return False
+        
+    if year_month is None:
+        year_month = datetime.utcnow().strftime("%Y-%m")
+
+    # 1. Comprobar si ya se le otorgó en el modelo User
+    if getattr(user, "last_monthly_credit_month", None) == year_month:
+        return False
+
+    # 2. Comprobar además en CreditTransaction por idempotencia a nivel de tabla
+    ref_id = f"monthly_grant_{year_month}"
+    existing_tx = db.query(CreditTransaction).filter(
+        CreditTransaction.user_id == user.id,
+        CreditTransaction.reference_id == ref_id
+    ).first()
+    if existing_tx:
+        user.last_monthly_credit_month = year_month
+        db.commit()
+        return False
+
+    if user.credits is None:
+        user.credits = 0
+
+    # 3. Aplicar los 10 créditos base mensuales
+    user.credits += amount
+    user.last_monthly_credit_month = year_month
+
+    # 4. Registrar la transacción en el historial
+    tx = CreditTransaction(
+        user_id=user.id,
+        amount=amount,
+        concept=f"recarga_mensual_{year_month}",
+        reference_id=ref_id,
+        credit_type="base",
+        created_at=datetime.utcnow()
+    )
+    db.add(tx)
+    db.commit()
+    db.refresh(user)
+
+    logger.info(f"[Monthly Credits] +{amount} créditos mensuales aplicados exitosamente al usuario '{user.username}' (ID: {user.id}) para el mes {year_month}.")
+    _notify_credits_update(user)
+    return True
+
+
+def process_all_users_monthly_credits(db: Session, year_month: str = None, amount: int = 10) -> dict:
+    """
+    Recorre todas las cuentas registradas activas y aplica la recarga mensual de 10 créditos
+    con total idempotencia.
+    """
+    if year_month is None:
+        year_month = datetime.utcnow().strftime("%Y-%m")
+
+    users = db.query(User).filter(User.is_suspended == False).all()
+    granted = 0
+    skipped = 0
+
+    for u in users:
+        try:
+            if grant_monthly_credits_to_user(db, u, year_month=year_month, amount=amount):
+                granted += 1
+            else:
+                skipped += 1
+        except Exception as e_user:
+            logger.error(f"[Monthly Credits Bulk] Error procesando usuario {u.id}: {e_user}")
+            db.rollback()
+
+    logger.info(f"[Monthly Credits Bulk] Resumen mes {year_month}: {granted} cuentas recargadas con +{amount} créditos, {skipped} omitidas (ya tenían recarga).")
+    return {
+        "year_month": year_month,
+        "granted": granted,
+        "skipped": skipped,
+        "total_users": len(users)
+    }
+
+
 def _notify_credits_update(user: User):
     """Envía mensaje WebSocket al cliente con el desglose de créditos."""
     try:

cleanup.py

@@ -237,6 +237,40 @@ def clean_expired_sync_queue(max_age_days=7, dry_run=False):
         return 0
 
 
+# ==========================================
+# RECARGA MENSUAL DE CRÉDITOS (DÍA 1 DE CADA MES)
+# ==========================================
+
+def apply_monthly_credits_maintenance(dry_run=False):
+    """
+    Aplica la recarga mensual de 10 créditos a todas las cuentas registradas el día 1 de cada mes.
+    Idempotente: no duplica si ya recibieron su cuota de este mes.
+    """
+    if datetime.utcnow().day != 1:
+        return {"status": "omitted_not_day_1"}
+        
+    logger.info("Es el 1 de mes: Verificando recarga mensual de 10 créditos para todas las cuentas...")
+    if dry_run:
+        logger.info("  [DRY-RUN] Se otorgarían 10 créditos a las cuentas registradas.")
+        return {"dry_run": True}
+        
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    if current_dir not in sys.path:
+        sys.path.insert(0, current_dir)
+        
+    try:
+        from app.database import SessionLocal
+        from app.utils.credits import process_all_users_monthly_credits
+        db = SessionLocal()
+        res = process_all_users_monthly_credits(db, amount=10)
+        db.close()
+        logger.info(f"Recarga mensual completada: {res}")
+        return res
+    except Exception as e:
+        logger.error(f"Error ejecutando process_all_users_monthly_credits desde cleanup.py: {e}")
+        return {"error": str(e)}
+
+
 # ==========================================
 # MAIN
 # ==========================================
@@ -268,6 +302,8 @@ def main():
     cleaned_logs = clean_logs(max_age_days=30, dry_run=args.dry_run)  # Logs: 30 días
     logger.info("")
     cleaned_sync = clean_expired_sync_queue(max_age_days=args.days, dry_run=args.dry_run)  # HF/Expira
+    logger.info("")
+    monthly_credits_res = apply_monthly_credits_maintenance(dry_run=args.dry_run)  # 10 créditos día 1
     
     logger.info("")
     logger.info("=" * 50)
@@ -277,6 +313,7 @@ def main():
     logger.info(f"Procesados limpiados: {cleaned_processed}")
     logger.info(f"Logs limpiados:       {cleaned_logs}")
     logger.info(f"HF/Nube limpiados:    {cleaned_sync}")
+    logger.info(f"Créditos mensuales:   {monthly_credits_res}")
     logger.info("=" * 50)
     
     if args.dry_run:

main.py

@@ -58,6 +58,7 @@ _migrations = [
     "ALTER TABLE tasks ADD COLUMN IF NOT EXISTS tuning_info TEXT",
     "ALTER TABLE tasks ADD COLUMN IF NOT EXISTS chords TEXT",
     "ALTER TABLE tasks ADD COLUMN IF NOT EXISTS cloud_url TEXT",
+    "ALTER TABLE users ADD COLUMN IF NOT EXISTS last_monthly_credit_month VARCHAR(20)",
 ]
 from sqlalchemy import text as _sql_text
 for _mig_sql in _migrations:

tasks.py

@@ -155,6 +155,10 @@ else:
                 'task': 'limpiar_stems_expirados_task',
                 'schedule': 21600.0,  # Cada 6 horas
             },
+            'recarga-mensual-creditos-cada-6-horas': {
+                'task': 'aplicar_recarga_mensual_creditos_task',
+                'schedule': 21600.0,  # Cada 6 horas (idempotente)
+            },
         },
         timezone='UTC',
     )
@@ -2214,6 +2218,31 @@ def limpiar_stems_expirados_task():
         db.close()
 
 
+@celery_app.task(name="aplicar_recarga_mensual_creditos_task")
+def aplicar_recarga_mensual_creditos_task():
+    """
+    Aplica 10 créditos adicionales a todas las cuentas registradas en Melodix el día 1 de cada mes.
+    Totalmente idempotente: si ya los recibieron para el mes en curso (YYYY-MM), se omite de forma segura.
+    """
+    from app.database import SessionLocal
+    from app.utils.credits import process_all_users_monthly_credits
+    from datetime import datetime
+
+    now = datetime.utcnow()
+    # Ejecutar principalmente el 1 de cada mes o para sincronizar mes en curso
+    logger.info(f"[Monthly Credits Task] Iniciando recarga mensual para {now.strftime('%Y-%m')} (Día actual: {now.day})...")
+    db = SessionLocal()
+    try:
+        res = process_all_users_monthly_credits(db, amount=10)
+        logger.info(f"[Monthly Credits Task] Resultado: {res}")
+        return res
+    except Exception as e:
+        logger.error(f"[Monthly Credits Task] Error en aplicar_recarga_mensual_creditos_task: {e}", exc_info=True)
+        return {"error": str(e)}
+    finally:
+        db.close()
+
+
 def sync_local_task_to_cloud(task_id, stems_to_upload, acordes, stems, user_id, song_name, artist):
     logger.info(f"[{task_id}] Iniciando sincronización de respaldo a la nube en background (desde backup)...")
     try:

tests/test_monthly_credits_grant.py

@@ -0,0 +1,124 @@
+import unittest
+import os
+import sys
+from datetime import datetime
+
+# Add parent directory to path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from app.database import Base
+from app.models.user import User, CreditTransaction
+from app.models.process import Task
+from app.models.lyrics import UserGroup
+from app.utils.credits import grant_monthly_credits_to_user, process_all_users_monthly_credits
+
+TEST_DB_URL = "sqlite:///./test_monthly_credits.db"
+
+class TestMonthlyCreditsGrant(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        if os.path.exists("./test_monthly_credits.db"):
+            os.remove("./test_monthly_credits.db")
+        cls.engine = create_engine(TEST_DB_URL, connect_args={"check_same_thread": False})
+        Base.metadata.create_all(bind=cls.engine)
+        cls.SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=cls.engine)
+
+    @classmethod
+    def tearDownClass(cls):
+        if os.path.exists("./test_monthly_credits.db"):
+            try:
+                os.remove("./test_monthly_credits.db")
+            except Exception:
+                pass
+
+    def setUp(self):
+        self.db = self.SessionLocal()
+
+    def tearDown(self):
+        self.db.close()
+
+    def test_single_user_monthly_credits_grant_and_idempotency(self):
+        """
+        Prueba que un usuario recibe 10 créditos para el mes actual,
+        y que intentos subsecuentes en el mismo mes son rechazados sin duplicar créditos.
+        """
+        user = User(
+            username="monthly_user_1",
+            email="m1@test.com",
+            credits=5,
+            bonus_credits=2,
+            last_monthly_credit_month="2026-07"  # Mes anterior
+        )
+        self.db.add(user)
+        self.db.commit()
+        self.db.refresh(user)
+
+        # 1. Aplicar recarga mensual para 2026-08 (mes en curso)
+        applied = grant_monthly_credits_to_user(self.db, user, year_month="2026-08", amount=10)
+        self.assertTrue(applied)
+        self.assertEqual(user.credits, 15)  # 5 + 10
+        self.assertEqual(user.bonus_credits, 2)
+        self.assertEqual(user.total_credits, 17)
+        self.assertEqual(user.last_monthly_credit_month, "2026-08")
+
+        # 2. Verificar registro en CreditTransaction
+        tx = self.db.query(CreditTransaction).filter(
+            CreditTransaction.user_id == user.id,
+            CreditTransaction.reference_id == "monthly_grant_2026-08"
+        ).first()
+        self.assertIsNotNone(tx)
+        self.assertEqual(tx.amount, 10)
+        self.assertEqual(tx.concept, "recarga_mensual_2026-08")
+        self.assertEqual(tx.credit_type, "base")
+
+        # 3. Intentar aplicar nuevamente para el MISMO mes (Idempotencia / Protección contra duplicados)
+        applied_again = grant_monthly_credits_to_user(self.db, user, year_month="2026-08", amount=10)
+        self.assertFalse(applied_again)
+        self.assertEqual(user.credits, 15)  # No debe haber cambiado
+        
+        # Verificar que solo existe UNA transacción para ese mes
+        tx_count = self.db.query(CreditTransaction).filter(
+            CreditTransaction.user_id == user.id,
+            CreditTransaction.reference_id == "monthly_grant_2026-08"
+        ).count()
+        self.assertEqual(tx_count, 1)
+
+        # 4. Transición al siguiente mes (2026-09)
+        next_month_applied = grant_monthly_credits_to_user(self.db, user, year_month="2026-09", amount=10)
+        self.assertTrue(next_month_applied)
+        self.assertEqual(user.credits, 25)  # 15 + 10
+        self.assertEqual(user.last_monthly_credit_month, "2026-09")
+
+    def test_bulk_process_all_users_monthly_credits(self):
+        """
+        Prueba que process_all_users_monthly_credits procesa todas las cuentas registradas
+        otorgando exactamente 10 créditos solo a quienes no los hayan recibido ese mes.
+        """
+        u1 = User(username="bulk_user_a", email="ua@test.com", credits=10, last_monthly_credit_month="2026-07")
+        u2 = User(username="bulk_user_b", email="ub@test.com", credits=20, last_monthly_credit_month="2026-08")  # Ya tiene
+        u3 = User(username="bulk_user_c", email="uc@test.com", credits=0, last_monthly_credit_month=None)
+        self.db.add_all([u1, u2, u3])
+        self.db.commit()
+
+        res = process_all_users_monthly_credits(self.db, year_month="2026-08", amount=10)
+        
+        self.assertEqual(res["year_month"], "2026-08")
+        # u1 y u3 deben recibir los 10 créditos. u2 (y los del test anterior) se omiten
+        self.assertGreaterEqual(res["granted"], 2)
+        
+        self.db.refresh(u1)
+        self.db.refresh(u2)
+        self.db.refresh(u3)
+
+        self.assertEqual(u1.credits, 20)  # 10 + 10
+        self.assertEqual(u2.credits, 20)  # Sin cambios (ya tenía 2026-08)
+        self.assertEqual(u3.credits, 10)  # 0 + 10
+
+        # Ejecutar inmediatamente por segunda vez: 0 otorgados, todos omitidos
+        res2 = process_all_users_monthly_credits(self.db, year_month="2026-08", amount=10)
+        self.assertEqual(res2["granted"], 0)
+
+if __name__ == "__main__":
+    unittest.main()