deploy from github actions

app/models/lyrics.py

@@ -89,6 +89,8 @@ class Lyric(Base):
     group_id = Column(Integer, ForeignKey("groups.id"))
     created_by = Column(Integer, ForeignKey("users.id"))
     transpose_offset = Column(Integer, default=0, nullable=True)
+    is_repertoire_only = Column(Boolean, default=False, nullable=True)
+    parent_lyric_id = Column(Integer, ForeignKey("lyrics.id", ondelete="SET NULL"), nullable=True)
     created_at = Column(DateTime, default=datetime.utcnow)
     updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
 

app/routers/alabanza.py

@@ -556,6 +556,15 @@ def expulsar_miembro(grupo_id: int, miembro_id: int, db: Session = Depends(get_d
             if l.group_id == grupo_id:
                 l.group_id = l.groups_shared[0].id if l.groups_shared else None
 
+    # Eliminar referencias en los repertorios de este grupo para las letras del usuario expulsado
+    kicked_lyric_ids = [l.id for l in db.query(Lyric.id).filter(Lyric.created_by == miembro_id).all()]
+    group_rep_ids = [r.id for r in db.query(Repertorio.id).filter(Repertorio.group_id == grupo_id).all()]
+    if kicked_lyric_ids and group_rep_ids:
+        db.query(RepertorioLyric).filter(
+            RepertorioLyric.repertorio_id.in_(group_rep_ids),
+            RepertorioLyric.lyric_id.in_(kicked_lyric_ids)
+        ).delete(synchronize_session=False)
+
     kicked_tasks = db.query(Task).filter(Task.user_id == miembro_id, Task.groups_shared.any(Group.id == grupo_id)).all()
     for t in kicked_tasks:
         group_to_remove = db.query(Group).filter(Group.id == grupo_id).first()
@@ -606,6 +615,15 @@ def salir_del_grupo(grupo_id: int, db: Session = Depends(get_db), current_user:
             if l.group_id == grupo_id:
                 l.group_id = l.groups_shared[0].id if l.groups_shared else None
 
+    # Eliminar referencias en los repertorios de este grupo para las letras del usuario que sale
+    left_lyric_ids = [l.id for l in db.query(Lyric.id).filter(Lyric.created_by == current_user.id).all()]
+    group_rep_ids = [r.id for r in db.query(Repertorio.id).filter(Repertorio.group_id == grupo_id).all()]
+    if left_lyric_ids and group_rep_ids:
+        db.query(RepertorioLyric).filter(
+            RepertorioLyric.repertorio_id.in_(group_rep_ids),
+            RepertorioLyric.lyric_id.in_(left_lyric_ids)
+        ).delete(synchronize_session=False)
+
     left_tasks = db.query(Task).filter(Task.user_id == current_user.id, Task.groups_shared.any(Group.id == grupo_id)).all()
     for t in left_tasks:
         group_to_remove = db.query(Group).filter(Group.id == grupo_id).first()
@@ -869,7 +887,11 @@ def get_grupo_letras(grupo_id: int, db: Session = Depends(get_db), current_user:
     if ug.role != "admin" and not ug.perm_ver_letras:
         raise HTTPException(status_code=403, detail="No tienes permisos para ver las letras de este grupo")
         
-    lyrics = db.query(Lyric).filter(Lyric.groups_shared.any(Group.id == grupo_id)).all()
+    from sqlalchemy import or_
+    lyrics = db.query(Lyric).filter(
+        Lyric.groups_shared.any(Group.id == grupo_id),
+        or_(Lyric.is_repertoire_only == False, Lyric.is_repertoire_only.is_(None))
+    ).all()
     return [
         {
             "id": l.id,

app/routers/lyrics.py

@@ -1,6 +1,6 @@
 from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
-from typing import List
+from typing import List, Optional
 from app.database import get_db
 from app.models.lyrics import Lyric, Group, UserGroup, Repertorio, RepertorioLyric, Invitation
 from app.models.user import User
@@ -43,8 +43,12 @@ def create_lyric(lyric: LyricCreate, db: Session = Depends(get_db), current_user
 
 @router.get("/all", response_model=List[LyricOut])
 def list_lyrics(db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
-    # Listar letras creadas por el usuario actual
-    return db.query(Lyric).filter(Lyric.created_by == current_user.id).all()
+    # Listar letras creadas por el usuario actual que no sean exclusivamente de repertorio
+    from sqlalchemy import or_
+    return db.query(Lyric).filter(
+        Lyric.created_by == current_user.id,
+        or_(Lyric.is_repertoire_only == False, Lyric.is_repertoire_only.is_(None))
+    ).all()
 
 # --- GROUPS ENDPOINTS ---
 
@@ -116,7 +120,15 @@ def get_lyric(lyric_id: int, db: Session = Depends(get_db), current_user: User =
     return db_lyric
 
 @router.put("/{lyric_id}", response_model=LyricOut)
-def update_lyric(lyric_id: int, lyric_update: LyricCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+def update_lyric(
+    lyric_id: int,
+    lyric_update: LyricCreate,
+    edit_context_group_id: Optional[int] = None,
+    edit_context_repertoire_id: Optional[int] = None,
+    update_references: Optional[bool] = None,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
     db_lyric = db.query(Lyric).filter(Lyric.id == lyric_id).first()
     if not db_lyric:
         raise HTTPException(status_code=404, detail="Lyric not found")
@@ -141,24 +153,222 @@ def update_lyric(lyric_id: int, lyric_update: LyricCreate, db: Session = Depends
 
     if not is_authorized:
         raise HTTPException(status_code=403, detail="Not authorized to edit this lyric")
-    
-    for key, value in lyric_update.dict().items():
-        setattr(db_lyric, key, value)
-        
-    if db_lyric.group_id is not None:
-        group = db.query(Group).filter(Group.id == db_lyric.group_id).first()
-        if group and group not in db_lyric.groups_shared:
-            db_lyric.groups_shared.append(group)
-        
-    db.commit()
-    db.refresh(db_lyric)
-    for gid in db_lyric.group_ids:
-        try:
-            from app.routers.alabanza import broadcast_to_group
-            broadcast_to_group(gid, {"type": "group_updated", "grupo_id": gid}, db)
-        except Exception:
-            pass
-    return db_lyric
+
+    # --- CASO 1: Edición con Contexto de Repertorio ---
+    if edit_context_repertoire_id is not None:
+        repertoire = db.query(Repertorio).filter(Repertorio.id == edit_context_repertoire_id).first()
+        if not repertoire:
+            raise HTTPException(status_code=404, detail="Repertorio no encontrado")
+            
+        if db_lyric.is_repertoire_only:
+            # Actualizar directamente si ya es exclusivo de repertorios
+            for key, value in lyric_update.dict().items():
+                setattr(db_lyric, key, value)
+            db.commit()
+            db.refresh(db_lyric)
+            return db_lyric
+        else:
+            # Crear clon para el repertorio
+            cloned_lyric = Lyric(
+                title=lyric_update.title,
+                artist=lyric_update.artist,
+                content=lyric_update.content,
+                key=lyric_update.key,
+                bpm=lyric_update.bpm,
+                transpose_offset=lyric_update.transpose_offset,
+                group_id=repertoire.group_id,
+                created_by=db_lyric.created_by,
+                is_repertoire_only=True,
+                parent_lyric_id=db_lyric.id
+            )
+            db.add(cloned_lyric)
+            db.flush()
+            
+            # Compartir con el grupo si el repertorio pertenece a uno
+            if repertoire.group_id is not None:
+                group = db.query(Group).filter(Group.id == repertoire.group_id).first()
+                if group:
+                    cloned_lyric.groups_shared.append(group)
+            
+            # Actualizar relación en repertorio_lyrics
+            rep_lyric = db.query(RepertorioLyric).filter(
+                RepertorioLyric.repertorio_id == edit_context_repertoire_id,
+                RepertorioLyric.lyric_id == db_lyric.id
+            ).first()
+            if rep_lyric:
+                order = rep_lyric.order
+                db.delete(rep_lyric)
+                db.flush()
+                new_rep_lyric = RepertorioLyric(
+                    repertorio_id=edit_context_repertoire_id,
+                    lyric_id=cloned_lyric.id,
+                    order=order
+                )
+                db.add(new_rep_lyric)
+            
+            db.commit()
+            db.refresh(cloned_lyric)
+            
+            if repertoire.group_id is not None:
+                try:
+                    from app.routers.alabanza import broadcast_to_group
+                    broadcast_to_group(repertoire.group_id, {"type": "group_updated", "grupo_id": repertoire.group_id}, db)
+                except Exception:
+                    pass
+            return cloned_lyric
+
+    # --- CASO 2: Edición con Contexto de Grupo ---
+    elif edit_context_group_id is not None:
+        group = db.query(Group).filter(Group.id == edit_context_group_id).first()
+        if not group:
+            raise HTTPException(status_code=404, detail="Grupo no encontrado")
+            
+        is_exclusive_to_group = db_lyric.group_id == edit_context_group_id and len(db_lyric.group_ids) <= 1 and not db_lyric.is_repertoire_only
+        if is_exclusive_to_group:
+            for key, value in lyric_update.dict().items():
+                setattr(db_lyric, key, value)
+            db.commit()
+            db.refresh(db_lyric)
+            try:
+                from app.routers.alabanza import broadcast_to_group
+                broadcast_to_group(edit_context_group_id, {"type": "group_updated", "grupo_id": edit_context_group_id}, db)
+            except Exception:
+                pass
+            return db_lyric
+        else:
+            # Crear clon para el grupo
+            cloned_lyric = Lyric(
+                title=lyric_update.title,
+                artist=lyric_update.artist,
+                content=lyric_update.content,
+                key=lyric_update.key,
+                bpm=lyric_update.bpm,
+                transpose_offset=lyric_update.transpose_offset,
+                group_id=edit_context_group_id,
+                created_by=db_lyric.created_by,
+                is_repertoire_only=False,
+                parent_lyric_id=db_lyric.id
+            )
+            cloned_lyric.groups_shared.append(group)
+            db.add(cloned_lyric)
+            db.flush()
+            
+            # Desvincular original del grupo
+            if group in db_lyric.groups_shared:
+                db_lyric.groups_shared.remove(group)
+                if db_lyric.group_id == edit_context_group_id:
+                    db_lyric.group_id = db_lyric.groups_shared[0].id if db_lyric.groups_shared else None
+            
+            # Actualizar todos los repertorios de este grupo que apuntaban a la original
+            group_rep_ids = [r.id for r in db.query(Repertorio.id).filter(Repertorio.group_id == edit_context_group_id).all()]
+            if group_rep_ids:
+                rep_lyrics = db.query(RepertorioLyric).filter(
+                    RepertorioLyric.repertorio_id.in_(group_rep_ids),
+                    RepertorioLyric.lyric_id == db_lyric.id
+                ).all()
+                for rl in rep_lyrics:
+                    order = rl.order
+                    rep_id = rl.repertorio_id
+                    db.delete(rl)
+                    db.flush()
+                    new_rl = RepertorioLyric(
+                        repertorio_id=rep_id,
+                        lyric_id=cloned_lyric.id,
+                        order=order
+                    )
+                    db.add(new_rl)
+            
+            db.commit()
+            db.refresh(cloned_lyric)
+            try:
+                from app.routers.alabanza import broadcast_to_group
+                broadcast_to_group(edit_context_group_id, {"type": "group_updated", "grupo_id": edit_context_group_id}, db)
+            except Exception:
+                pass
+            return cloned_lyric
+
+    # --- CASO 3: Edición desde el Catálogo Personal (Creador original) ---
+    else:
+        has_shared_references = len(db_lyric.groups_shared) > 0
+        if has_shared_references and update_references is False:
+            # Clonar la letra original con el contenido actual (viejo) para los grupos y repertorios
+            old_cloned_lyric = Lyric(
+                title=db_lyric.title,
+                artist=db_lyric.artist,
+                content=db_lyric.content,
+                key=db_lyric.key,
+                bpm=db_lyric.bpm,
+                transpose_offset=db_lyric.transpose_offset,
+                group_id=db_lyric.group_id,
+                created_by=db_lyric.created_by,
+                is_repertoire_only=False,
+                parent_lyric_id=db_lyric.id
+            )
+            shared_groups = list(db_lyric.groups_shared)
+            for g in shared_groups:
+                old_cloned_lyric.groups_shared.append(g)
+            db.add(old_cloned_lyric)
+            db.flush()
+            
+            # Desvincular original de los grupos
+            db_lyric.groups_shared.clear()
+            db_lyric.group_id = None
+            
+            # Actualizar referencias de repertorios de esos grupos para que usen el clon viejo
+            shared_group_ids = [g.id for g in shared_groups]
+            if shared_group_ids:
+                group_rep_ids = [r.id for r in db.query(Repertorio.id).filter(Repertorio.group_id.in_(shared_group_ids)).all()]
+                if group_rep_ids:
+                    rep_lyrics = db.query(RepertorioLyric).filter(
+                        RepertorioLyric.repertorio_id.in_(group_rep_ids),
+                        RepertorioLyric.lyric_id == db_lyric.id
+                    ).all()
+                    for rl in rep_lyrics:
+                        order = rl.order
+                        rep_id = rl.repertorio_id
+                        db.delete(rl)
+                        db.flush()
+                        new_rl = RepertorioLyric(
+                            repertorio_id=rep_id,
+                            lyric_id=old_cloned_lyric.id,
+                            order=order
+                        )
+                        db.add(new_rl)
+            
+            # Guardar los nuevos cambios en la original (personal)
+            for key, value in lyric_update.dict().items():
+                if key != "group_id":
+                    setattr(db_lyric, key, value)
+            
+            db.commit()
+            db.refresh(db_lyric)
+            
+            for gid in shared_group_ids:
+                try:
+                    from app.routers.alabanza import broadcast_to_group
+                    broadcast_to_group(gid, {"type": "group_updated", "grupo_id": gid}, db)
+                except Exception:
+                    pass
+            return db_lyric
+        else:
+            # Edición directa (in-place)
+            for key, value in lyric_update.dict().items():
+                setattr(db_lyric, key, value)
+                
+            if db_lyric.group_id is not None:
+                group = db.query(Group).filter(Group.id == db_lyric.group_id).first()
+                if group and group not in db_lyric.groups_shared:
+                    db_lyric.groups_shared.append(group)
+            
+            db.commit()
+            db.refresh(db_lyric)
+            for gid in db_lyric.group_ids:
+                try:
+                    from app.routers.alabanza import broadcast_to_group
+                    broadcast_to_group(gid, {"type": "group_updated", "grupo_id": gid}, db)
+                except Exception:
+                    pass
+            return db_lyric
 
 @router.delete("/{lyric_id}")
 def delete_lyric(lyric_id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):

app/schemas/lyrics.py

@@ -11,6 +11,8 @@ class LyricBase(BaseModel):
     bpm: Optional[int] = None
     group_id: Optional[int] = None
     transpose_offset: Optional[int] = 0
+    is_repertoire_only: Optional[bool] = False
+    parent_lyric_id: Optional[int] = None
 
 class LyricCreate(LyricBase):
     pass

migrate_contextual_lyrics.py

@@ -0,0 +1,33 @@
+import os
+import psycopg2
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Usar DATABASE_URL del archivo .env
+DATABASE_URL = os.getenv("DATABASE_URL")
+
+# Fallback
+if not DATABASE_URL:
+    DATABASE_URL = "postgresql://postgres.egkydqberhebzkqtltic:Isaac%23105%2Amay%40@aws-1-us-east-1.pooler.supabase.com:6543/postgres"
+
+def migrate():
+    print("Conectando a la base de datos...")
+    conn = psycopg2.connect(DATABASE_URL)
+    cur = conn.cursor()
+    
+    print("Agregando columnas 'is_repertoire_only' y 'parent_lyric_id' a la tabla 'lyrics'...")
+    try:
+        cur.execute("ALTER TABLE lyrics ADD COLUMN IF NOT EXISTS is_repertoire_only BOOLEAN DEFAULT FALSE;")
+        cur.execute("ALTER TABLE lyrics ADD COLUMN IF NOT EXISTS parent_lyric_id INTEGER NULL REFERENCES lyrics(id) ON DELETE SET NULL;")
+        conn.commit()
+        print("Columnas agregadas exitosamente.")
+    except Exception as e:
+        print("Error al agregar columnas:", e)
+        conn.rollback()
+        
+    cur.close()
+    conn.close()
+
+if __name__ == "__main__":
+    migrate()