Upload 3 files

app.py

@@ -16,6 +16,7 @@ from database import set_db_path, init_schema, create_video, update_video_status
 from api_client import APIClient
 from utils import ensure_dirs, save_bytes, save_text, human_size
 from auth import initialize_auth_system, render_login_form, render_sidebar, require_login
+from mobile_verification import render_mobile_verification_screen, get_user_permissions
 
 
 def _get_video_duration(path: str) -> float:
@@ -129,11 +130,33 @@ if not st.session_state.user:
     render_login_form()
     st.stop()
 
+# Post-login: Verificación por móvil si es necesaria
+if st.session_state.user and 'sms_verified' not in st.session_state:
+    st.session_state.sms_verified = None
+
+if st.session_state.user:
+    username = st.session_state.user['username']
+    role = st.session_state.user['role']
+    
+    # Obtener permisos para ver si requiere SMS
+    permissions = get_user_permissions(role, st.session_state.get('sms_verified'))
+    
+    # Si requiere SMS y aún no está verificado/omitido, mostrar pantalla de verificación
+    if permissions["requires_sms"] and st.session_state.sms_verified is None:
+        result = render_mobile_verification_screen(username, role)
+        if result is None:
+            # Aún en proceso de verificación
+            st.stop()
+        # Si result es True o False, ya se ha completado/omitido y continúa
+
 # --- Pages ---
 if page == "Processar vídeo nou":
     require_login(render_login_form)
-    if role != "verd":
-        st.error("No tens permisos per processar nous vídeos. Canvia d'usuari o sol·licita permisos.")
+    
+    # Verificar permisos
+    permissions = get_user_permissions(role, st.session_state.get('sms_verified'))
+    if not permissions["procesar_videos"]:
+        st.error("No tens permisos per processar nous vídeos. Verifica el teu mòbil per obtenir accés complet.")
         st.stop()
 
     st.header("Processar un nou clip de vídeo")

auth.py

@@ -6,6 +6,12 @@ import sys
 import streamlit as st
 from datetime import datetime
 from database import get_user, create_user, update_user_password, get_all_users
+from mobile_verification import (
+    initialize_sms_state,
+    render_mobile_verification_screen,
+    get_user_permissions,
+    show_verification_status_in_sidebar
+)
 
 
 def log(msg: str):
@@ -28,6 +34,7 @@ def create_default_users_if_needed():
         ("groc", "groc123", "groc"),
         ("taronja", "taronja123", "taronja"),
         ("blau", "blau123", "blau"),
+        ("vermell", "vermell123", "vermell"),
     ]
     for username, password, role in users_to_create:
         try:
@@ -48,6 +55,9 @@ def initialize_auth_system(db_path: str):
         create_default_users_if_needed()
         st.session_state['users_synced'] = True
 
+    # Inicializar estado de verificación SMS
+    initialize_sms_state()
+
     # Diagnóstico de base de datos
     if 'diag_logged' not in st.session_state:
         log("\n--- DIAGNÓSTICO DE BASE DE DATOS ---")
@@ -120,14 +130,41 @@ def render_sidebar():
         st.title("Veureu")
         if st.session_state.user:
             st.write(f"Usuari: **{st.session_state.user['username']}** (rol: {st.session_state.user['role']})")
+            
+            # Mostrar estado de verificación SMS
+            show_verification_status_in_sidebar()
+            
             if st.button("Tancar sessió"):
                 st.session_state.user = None
+                st.session_state.sms_verified = None
                 st.rerun()
         
         if st.session_state.user:
+            # Obtener permisos del usuario
+            permissions = get_user_permissions(
+                role,
+                st.session_state.get('sms_verified')
+            )
+            
+            # Construir opciones de navegación según permisos
+            page_options = []
+            
+            if permissions["analizar"]:
+                page_options.append("Analitzar video-transcripcions")
+            
+            if permissions["procesar_videos"]:
+                page_options.append("Processar vídeo nou")
+            
+            if permissions["estadisticas"]:
+                page_options.append("Estadístiques")
+            
+            # Si no hay opciones disponibles, mostrar solo análisis
+            if not page_options:
+                page_options = ["Analitzar video-transcripcions"]
+            
             page = st.radio(
                 "Navegació",
-                ["Analitzar video-transcripcions", "Processar vídeo nou", "Estadístiques"],
+                page_options,
                 index=0
             )
         else:

mobile_verification.py

@@ -0,0 +1,311 @@
+"""
+Módulo de verificación por móvil/SMS para usuarios que requieren validación adicional.
+
+Este módulo gestiona:
+- Mostrar términos y condiciones de uso
+- Solicitar número de teléfono móvil
+- Enviar código de verificación por SMS (simulado en demo)
+- Verificar código introducido por el usuario
+"""
+
+import sys
+import random
+import streamlit as st
+from datetime import datetime
+from typing import Optional, Tuple
+
+
+def log(msg: str):
+    """Helper per logging amb timestamp"""
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    sys.stderr.write(f"[{timestamp}] {msg}\n")
+    sys.stderr.flush()
+
+
+def initialize_sms_state():
+    """Inicializa el estado de verificación SMS si no existe"""
+    if 'sms_step' not in st.session_state:
+        st.session_state.sms_step = 'phone'  # 'phone' o 'verify'
+    if 'sms_code' not in st.session_state:
+        st.session_state.sms_code = None
+    if 'sms_phone' not in st.session_state:
+        st.session_state.sms_phone = None
+    if 'sms_verified' not in st.session_state:
+        st.session_state.sms_verified = None  # None=pendiente, True=verificado, False=omitido
+
+
+def send_sms_code(phone_number: str) -> bool:
+    """
+    Simula el envío de código SMS (en producción usaría un servicio real como Twilio).
+    
+    Args:
+        phone_number: Número de teléfono completo con código de país
+        
+    Returns:
+        True si el envío fue exitoso, False en caso de error
+    """
+    try:
+        # Generar código aleatorio de 6 dígitos
+        code = f"{random.randint(100000, 999999)}"
+        st.session_state.sms_code = code
+        
+        log(f"[SMS] Código generado para {phone_number}: {code}")
+        
+        # En producción aquí iría la llamada a un servicio real de SMS
+        # Por ejemplo, usando Twilio:
+        # client = TwilioClient(account_sid, auth_token)
+        # message = client.messages.create(
+        #     body=f"El teu codi de verificació Veureu és: {code}",
+        #     from_=twilio_phone,
+        #     to=phone_number
+        # )
+        
+        return True
+        
+    except Exception as e:
+        log(f"[SMS] Error enviando código: {e}")
+        return False
+
+
+def get_terms_and_conditions() -> str:
+    """Retorna el texto completo de términos y condiciones"""
+    return """
+    ### **Condicions d'ús del sistema Veureu**
+    
+    En iniciar sessió i pujar un vídeo al sistema Veureu, l'usuari declara i accepta el següent:
+    
+    **📋 Declaracions:**
+    - Declara ser titular dels drets d'ús i difusió del vídeo, o disposar de l'autorització expressa dels titulars.
+    - Declara que totes les persones identificables en el vídeo han atorgat el seu consentiment informat per a la seva utilització amb finalitats d'accessibilitat i audiodescripció.
+    - Declara que el vídeo no conté:
+      - Contingut violent, sexual o d'odi,
+      - Informació confidencial o de caràcter sensible,
+      - Imatges de menors sense consentiment parental verificable.
+    
+    **✅ Acceptacions:**
+    - Accepta que es processi el vídeo exclusivament amb finalitats de generació i validació d'audiodescripcions, conforme a la normativa UNE-153010:2020 i al RGPD.
+    - Accepta que el sistema pugui enviar les dades necessàries a proveïdors tecnològics externs (p. ex., models d'IA) que actuen com a encarregats de tractament, sota clàusules contractuals tipus i sense reutilització de dades.
+    - Accepta que les accions realitzades (pujada, acceptació, validació, revocació) siguin registrades en un sistema immutable (AWS QLDB) mitjançant identificadors no personals.
+    - Pot exercir en qualsevol moment el seu dret a revocar el consentiment mitjançant el botó "Revocar permisos", el que eliminarà el material audiovisual i deixarà constància de la revocació en el registre.
+    - Accepta que, fins a la validació interna del material per part de l'equip Veureu, el vídeo romandrà en estat "pendent de validació" i no serà utilitzat públicament.
+    """
+
+
+def render_mobile_verification_screen(username: str, role: str) -> Optional[bool]:
+    """
+    Renderiza la pantalla de verificación por móvil post-login.
+    
+    Args:
+        username: Nombre de usuario autenticado
+        role: Rol del usuario
+        
+    Returns:
+        True si el usuario completó la verificación
+        False si omitió la verificación (solo modo análisis)
+        None si aún está en proceso
+    """
+    st.title("Veureu — Audiodescripció")
+    st.markdown(f"Benvingut/da, **{username}**")
+    
+    # Mensaje explicativo según el rol
+    if role in ["groc", "blau"]:
+        st.info("""
+        ### 📱 Verificació per WhatsApp/SMS requerida
+        
+        Per accedir a les funcions completes del sistema (pujar vídeos, validar contingut), 
+        cal verificar el seu número de mòbil i acceptar les condicions d'ús.
+        
+        **Si únicament vol analitzar i modificar les audiodescripcions existents, pot ometre aquest pas.**
+        """)
+    
+    # Ventana desplegable con términos y verificación SMS
+    with st.expander("📋 Verificació per WhatsApp/SMS", expanded=True):
+        # Términos y condiciones
+        st.markdown(get_terms_and_conditions())
+        
+        st.markdown("---")
+        st.markdown("#### 📱 Dades de verificació")
+        
+        # Selector de país y número de teléfono
+        col_country, col_phone = st.columns([1, 3])
+        with col_country:
+            country_code = st.selectbox("País", [
+                ("🇪🇸 +34", "+34"), 
+                ("🇫🇷 +33", "+33"), 
+                ("🇬🇧 +44", "+44"),
+                ("🇩🇪 +49", "+49"),
+                ("🇮🇹 +39", "+39")
+            ], format_func=lambda x: x[0])[1]
+        
+        with col_phone:
+            phone_number = st.text_input(
+                "Número de telèfon" + (" (opcional)" if role == "groc" else ""),
+                placeholder="600 123 000",
+                max_chars=15
+            )
+        
+        # Checkbox para aceptar términos
+        accept_terms = st.checkbox(
+            "✅ Accepto les condicions d'ús i la política de privadesa",
+            key="mobile_accept_terms"
+        )
+        
+        # Botón para enviar código
+        if st.button(
+            "📤 Enviar codi de verificació",
+            type="primary",
+            disabled=not (phone_number and accept_terms)
+        ):
+            full_phone = f"{country_code}{phone_number}"
+            if send_sms_code(full_phone):
+                st.session_state.sms_step = 'verify'
+                st.session_state.sms_phone = full_phone
+                st.success(f"✅ Codi enviat a {full_phone}")
+                st.rerun()
+            else:
+                st.error("❌ Error enviant el codi. Torna-ho a intentar.")
+        
+        # Si se envió el SMS, mostrar campo para verificar código
+        if st.session_state.sms_step == 'verify':
+            st.markdown("#### 🔓 Verificació del codi")
+            
+            # Mostrar código en modo demo
+            if st.session_state.sms_code:
+                st.info(f"💡 **Mode demo**: El codi és '{st.session_state.sms_code}'")
+            
+            col_code, col_resend = st.columns([2, 1])
+            with col_code:
+                verification_code = st.text_input(
+                    "Codi de 6 dígits",
+                    max_chars=6,
+                    placeholder="000000",
+                    key="mobile_verification_code"
+                )
+            
+            with col_resend:
+                st.markdown("<br>", unsafe_allow_html=True)
+                if st.button("🔄 Reenviar", key="mobile_resend"):
+                    if send_sms_code(st.session_state.sms_phone):
+                        st.success("✅ Nou codi enviat")
+                    else:
+                        st.error("❌ Error enviant el codi")
+            
+            if st.button("🔓 Verificar i continuar", type="primary"):
+                if verification_code == st.session_state.sms_code:
+                    st.session_state.sms_verified = True
+                    st.session_state.sms_phone_verified = st.session_state.sms_phone
+                    # Resetear estado SMS
+                    st.session_state.sms_step = 'phone'
+                    st.session_state.sms_code = None
+                    st.session_state.sms_phone = None
+                    st.success("✅ Verificació completada! Ara pot accedir a totes les funcions.")
+                    log(f"[SMS] Usuario {username} verificado correctamente")
+                    st.rerun()
+                    return True
+                else:
+                    st.error(f"❌ Codi incorrecte. El codi correcte és: {st.session_state.sms_code}")
+    
+    # Botones de acción principales
+    st.markdown("---")
+    col_continue, col_skip = st.columns([1, 1])
+    
+    with col_continue:
+        if st.session_state.sms_verified is True:
+            if st.button("🚪 Accedir amb permisos complets", type="primary"):
+                st.success("✅ Accedint a l'aplicació amb permisos complets...")
+                st.rerun()
+                return True
+    
+    with col_skip:
+        # Solo mostrar botón de omitir para roles que no requieren verificación obligatoria
+        if role in ["groc", "blau"]:
+            if st.button("⏭️ Continuar sense verificació (només anàlisi)"):
+                st.session_state.sms_verified = False
+                st.info("✅ Sessió iniciada. Pot accedir a les funcions d'anàlisi d'audiodescripcions.")
+                log(f"[SMS] Usuario {username} omitió verificación SMS")
+                st.rerun()
+                return False
+    
+    return None
+
+
+def get_user_permissions(role: str, sms_verified: Optional[bool]) -> dict:
+    """
+    Retorna los permisos del usuario según su rol y estado de verificación SMS.
+    
+    Args:
+        role: Rol del usuario (verd, groc, blau, taronja, vermell)
+        sms_verified: Estado de verificación SMS (True, False, None)
+        
+    Returns:
+        Diccionario con permisos booleanos
+    """
+    # Permisos base por rol (sin verificación SMS)
+    base_permissions = {
+        "verd": {
+            "analizar": True,
+            "procesar_videos": True,
+            "valorar": True,
+            "validar": True,
+            "estadisticas": True,
+            "requires_sms": False
+        },
+        "groc": {
+            "analizar": True,
+            "procesar_videos": True,  # Requiere SMS si no está verificado
+            "valorar": True,
+            "validar": False,
+            "estadisticas": True,
+            "requires_sms": True
+        },
+        "blau": {
+            "analizar": True,
+            "procesar_videos": False,  # No puede subir videos nunca
+            "valorar": True,
+            "validar": True,  # Requiere SMS si no está verificado
+            "estadisticas": True,
+            "requires_sms": True
+        },
+        "taronja": {
+            "analizar": True,
+            "procesar_videos": False,
+            "valorar": True,
+            "validar": False,
+            "estadisticas": True,
+            "requires_sms": False
+        },
+        "vermell": {
+            "analizar": True,
+            "procesar_videos": False,
+            "valorar": False,
+            "validar": False,
+            "estadisticas": True,
+            "requires_sms": False
+        }
+    }
+    
+    permissions = base_permissions.get(role, base_permissions["vermell"]).copy()
+    
+    # Ajustar permisos según verificación SMS
+    if permissions["requires_sms"]:
+        if sms_verified is False:  # Omitió verificación
+            # Solo análisis permitido
+            permissions["procesar_videos"] = False
+            permissions["validar"] = False
+        elif sms_verified is None:  # Pendiente de verificación
+            # Pendiente: no dar acceso a funciones que requieren SMS
+            permissions["procesar_videos"] = False
+            permissions["validar"] = False
+        # Si sms_verified is True, mantener permisos originales
+    
+    return permissions
+
+
+def show_verification_status_in_sidebar():
+    """Muestra el estado de verificación SMS en la barra lateral"""
+    if st.session_state.get('sms_verified') is True:
+        st.success("📱 Verificació SMS activada")
+    elif st.session_state.get('sms_verified') is False:
+        st.warning("⚠️ Només mode anàlisi")
+    else:
+        st.info("⏳ Verificació pendent")