Upload 13 files

app.py

@@ -85,8 +85,14 @@ print(f"🔧 TTS_URL repr: {repr(TTS_URL)}")
 USE_MOCK = bool(CFG.get("app", {}).get("use_mock", False))  # si no la tienes en el yaml, queda False
 
 COMPLIANCE_CFG = CFG.get("compliance", {}) or {}
-PRIVATE_BLOCKCHAIN_ENABLE = bool(COMPLIANCE_CFG.get("private_blockchain_enable", False))
-PUBLIC_BLOCKCHAIN_ENABLE = bool(COMPLIANCE_CFG.get("public_blockchain_enable", False))
+PRIVATE_BLOCKCHAIN_ENABLE = bool(
+    COMPLIANCE_CFG.get("private_blockchain_enabled",
+                       COMPLIANCE_CFG.get("private_blockchain_enable", False))
+)
+PUBLIC_BLOCKCHAIN_ENABLE = bool(
+    COMPLIANCE_CFG.get("public_blockchain_enabled",
+                       COMPLIANCE_CFG.get("public_blockchain_enable", False))
+)
 MONTHLY_DIGEST_ENABLED = bool(COMPLIANCE_CFG.get("monthly_digest_enabled", False))
 API_TOKEN = CFG.get("api", {}).get("token") or os.getenv("API_SHARED_TOKEN")
 

auth.py

@@ -16,6 +16,8 @@ from mobile_verification import (
     show_verification_status_in_sidebar
 )
 from persistent_data_gate import confirm_changes_and_logout
+from compliance_client import compliance_client
+import yaml
 
 
 def log(msg: str):
@@ -211,12 +213,59 @@ def render_sidebar():
                     base_dir = Path(__file__).parent
                     session_id = st.session_state.get("session_id", "")
                     api_client = st.session_state.get("api_client")
-                    confirm_changes_and_logout(base_dir, api_client, session_id)
+                    digest_info = confirm_changes_and_logout(base_dir, api_client, session_id)
                 except Exception:
-                    pass
+                    digest_info = None
 
+                # Llegir flag public_blockchain_enabled de config.yaml
+                try:
+                    cfg_path = Path(__file__).parent / "config.yaml"
+                    with cfg_path.open("r", encoding="utf-8") as f:
+                        cfg = yaml.safe_load(f) or {}
+                    comp_cfg = cfg.get("compliance", {}) or {}
+                    public_blockchain_enabled = bool(
+                        comp_cfg.get(
+                            "public_blockchain_enabled",
+                            comp_cfg.get("public_blockchain_enable", False),
+                        )
+                    )
+                except Exception:
+                    public_blockchain_enabled = False
+
+                blockchain_published = False
+                polygonscan_url = None
+
+                if public_blockchain_enabled and digest_info and digest_info.get("events_digest"):
+                    try:
+                        session_id = st.session_state.get("session_id", "")
+                        resp = compliance_client.publish_events_digest(
+                            session_id=session_id,
+                            digest_hash=digest_info["events_digest"],
+                        )
+                        if resp:
+                            polygonscan_url = resp.get("transaction_url")
+                            blockchain_published = bool(resp.get("transaction_hash"))
+                    except Exception:
+                        blockchain_published = False
+
+                # Netejar sessió d'usuari
                 st.session_state.user = None
                 st.session_state.sms_verified = None
+
+                # Mostrar missatge segons estat de publicació
+                if public_blockchain_enabled and blockchain_published and polygonscan_url:
+                    st.success(
+                        "✅ Els canvis s'han desat i s'han publicat a la cadena de blocs de Polygon. "
+                        f"Pots consultar la transacció a: {polygonscan_url}"
+                    )
+                elif public_blockchain_enabled:
+                    st.info(
+                        "✅ Els canvis s'han desat, però no s'ha pogut completar la publicació "
+                        "a la cadena de blocs de Polygon en aquest moment."
+                    )
+                else:
+                    st.info("✅ Canvis desats (sense publicació a blockchain).")
+
                 st.rerun()
         else:
             page = None

compliance_client.py

@@ -441,6 +441,40 @@ class ComplianceClient:
             return document_id
         
         return None
+
+    def notify_video_upload(self, video_name: str, sha1sum: str) -> bool:
+        """Notifica al servei de compliance que s'ha pujat un nou vídeo.
+
+        Això desencadena l'enviament d'un SMS al validor de vídeos.
+        """
+
+        payload = {"video_name": video_name, "sha1sum": sha1sum}
+        response = self._make_request(
+            "POST", "/api/notifications/video-upload-sms", payload
+        )
+        return bool(response and response.get("success"))
+
+    def publish_events_digest(self, session_id: str, digest_hash: str) -> Optional[Dict[str, Any]]:
+        """Publica el digest d'esdeveniments d'una sessió en blockchain.
+
+        Retorna un dict amb, si té èxit:
+        - transaction_hash
+        - transaction_url
+        """
+
+        payload = {
+            "session_id": session_id,
+            "digest_hash": digest_hash,
+        }
+
+        response = self._make_request(
+            "POST", "/api/blockchain/publish-events-digest", payload
+        )
+
+        if response:
+            return response
+
+        return None
     
     def send_validation_request(self, validation_request: Dict[str, Any]) -> bool:
         """Envía solicitud de validación a validadores"""

config.yaml

@@ -15,16 +15,6 @@ api:
   # URL pública de tu space tts
   tts_url: "${API_TTS_URL}"
 
-storage:
-  # directorio raíz de almacenamiento dentro del space
-  root_dir: "data"
-  uploads_dir: "uploads"
-  results_dir: "results"
-
-sqlite:
-  # base de datos SQLite local del space
-  path: "data/users.db"
-
 security:
   # coste de bcrypt (más alto = más seguro pero más lento)
   bcrypt_rounds: 12
@@ -43,7 +33,7 @@ ui:
 
 compliance:
   # Controla la integració amb AWS QLDB (registre privat) i Polygon (registre públic)
-  private_blockchain_enable: false
-  public_blockchain_enable: false
+  private_blockchain_enabled: false
+  public_blockchain_enabled: true
   monthly_digest_enabled: false
 

databases.py

@@ -573,6 +573,28 @@ def log_event(
             print(f"[QLDB EVENTS ERROR] No s'ha pogut registrar l'esdeveniment: {e}")
 
 
+def has_video_approval_event(sha1sum: str) -> bool:
+    """Comprova si existeix un esdeveniment d'aprovació de vídeo per a un sha1sum.
+
+    Busca a demo/temp/events.db una fila amb action='video approval' i el sha1sum
+    especificat.
+    """
+
+    if not sha1sum:
+        return False
+
+    try:
+        with _connect_events_db() as conn:
+            cur = conn.execute(
+                "SELECT 1 FROM events WHERE action = ? AND sha1sum = ? LIMIT 1",
+                ("video approval", sha1sum),
+            )
+            return cur.fetchone() is not None
+    except sqlite3.OperationalError:
+        # Si la taula encara no existeix, no hi ha aprovacions
+        return False
+
+
 def get_feedback_video_stats(agg: str = "mitjana") -> List[Dict[str, Any]]:
     """Retorna estadístiques agregades per vídeo de demo/data/feedback.db.
 

mobile_verification.py

@@ -9,7 +9,9 @@ Este módulo gestiona:
 """
 
 import sys
+import os
 import random
+import string
 import streamlit as st
 from datetime import datetime
 from typing import Optional, Tuple
@@ -47,25 +49,44 @@ def send_sms_code(phone_number: str) -> bool:
         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)}"
+        # Generar codi aleatori de 4 lletres en majúscules (A-Z)
+        code = "".join(random.choice(string.ascii_uppercase) for _ in range(4))
         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
-        # )
-        
+
+        # Normalitzar telèfon: si no porta prefix, assumir +34
+        normalized_phone = phone_number.strip().replace(" ", "")
+        if not normalized_phone.startswith("+"):
+            normalized_phone = "+34" + normalized_phone
+
+        log(f"[SMS] Codi generat per a {normalized_phone}: {code}")
+
+        # Enviament via webhook de Zapier si està configurat
+        zapier_url = os.getenv("ZAPIER_WEBHOOK_CATCH")
+        if zapier_url:
+            try:
+                import requests
+
+                message = f"El teu codi secret de validació és: {code}"
+                payload = {
+                    "phone": normalized_phone,
+                    "message": message,
+                    "code": code,
+                }
+                resp = requests.post(zapier_url, json=payload, timeout=10)
+                if not resp.ok:
+                    log(f"[SMS] Error HTTP enviant codi via Zapier: {resp.status_code} {resp.text}")
+                    return False
+            except Exception as exc:
+                log(f"[SMS] Excepció enviant codi via Zapier: {exc}")
+                return False
+        else:
+            log("[SMS] ZAPIER_WEBHOOK_CATCH no definit; no s'ha pogut enviar l'SMS")
+            return False
+
         return True
-        
+
     except Exception as e:
-        log(f"[SMS] Error enviando código: {e}")
+        log(f"[SMS] Error generant/enviant codi: {e}")
         return False
 
 
@@ -198,17 +219,13 @@ def render_mobile_verification_screen(username: str, role: str) -> Optional[bool
         # 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",
+                    "Codi de 4 lletres",
+                    max_chars=4,
+                    placeholder="ABCD",
                     key="mobile_verification_code"
                 )
             
@@ -221,7 +238,7 @@ def render_mobile_verification_screen(username: str, role: str) -> Optional[bool
                         st.error("❌ Error enviant el codi")
             
             if st.button("🔓 Verificar i continuar", type="primary"):
-                if verification_code == st.session_state.sms_code:
+                if verification_code.strip().upper() == str(st.session_state.sms_code).strip().upper():
                     st.session_state.sms_verified = True
                     st.session_state.sms_phone_verified = st.session_state.sms_phone
                     # Resetear estado SMS
@@ -233,7 +250,7 @@ def render_mobile_verification_screen(username: str, role: str) -> Optional[bool
                     st.rerun()
                     return True
                 else:
-                    st.error(f"❌ Codi incorrecte. El codi correcte és: {st.session_state.sms_code}")
+                    st.error("❌ El codi no és correcte. Torna-ho a intentar.")
     
     # Botones de acción principales
     st.markdown("---")

page_modules/process_video.py

@@ -13,7 +13,9 @@ from pathlib import Path
 
 import streamlit as st
 from PIL import Image, ImageDraw
-from databases import log_event
+from databases import log_event, has_video_approval_event
+from compliance_client import compliance_client
+from persistent_data_gate import ensure_temp_databases
 
 
 def get_all_catalan_names():
@@ -233,6 +235,10 @@ def render_process_video_page(api, backend_base_url: str) -> None:
         st.session_state.diarization_info = {}
     if "characters_saved" not in st.session_state:
         st.session_state.characters_saved = False
+    if "video_requires_validation" not in st.session_state:
+        st.session_state.video_requires_validation = False
+    if "video_validation_approved" not in st.session_state:
+        st.session_state.video_validation_approved = False
 
     # --- 1. Subida del vídeo ---
     MAX_SIZE_MB = 20
@@ -365,6 +371,17 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                             except Exception as e:
                                 print(f"[events] Error registrant esdeveniment de pujada: {e}")
 
+                            # Marcar vídeo com pendent de validació i enviar SMS al validor
+                            st.session_state.video_requires_validation = True
+                            st.session_state.video_validation_approved = False
+                            try:
+                                compliance_client.notify_video_upload(
+                                    video_name=uploaded_file.name,
+                                    sha1sum=sha1,
+                                )
+                            except Exception as sms_exc:
+                                print(f"[VIDEO SMS] Error enviant notificació al validor: {sms_exc}")
+
                             st.rerun()
                     finally:
                         if temp_path.exists():
@@ -374,6 +391,17 @@ def render_process_video_page(api, backend_base_url: str) -> None:
         st.success(f"Vídeo '{st.session_state.video_uploaded['original_name']}' pujat i processat correctament.")
         if st.session_state.video_uploaded["was_truncated"]:
             st.warning("El vídeo s'ha truncat a 4 minuts.")
+        if st.session_state.get("video_requires_validation") and not st.session_state.get("video_validation_approved"):
+            st.info("Per favor, espera a la revisió humana del vídeo.")
+
+    # Comprovar si hi ha aprovació de vídeo a events.db per al sha1sum actual
+    current_sha1 = None
+    if st.session_state.get("video_uploaded"):
+        current_sha1 = st.session_state.video_uploaded.get("sha1sum")
+    if current_sha1 and st.session_state.get("video_requires_validation") and not st.session_state.get("video_validation_approved"):
+        if has_video_approval_event(current_sha1):
+            st.session_state.video_validation_approved = True
+
 
     # --- 2. Form de detecció amb sliders ---
     st.markdown("---")
@@ -401,7 +429,10 @@ def render_process_video_page(api, backend_base_url: str) -> None:
         with col_btn:
             max_frames = st.number_input("Nombre de frames a processar", min_value=10, max_value=500, value=100, step=10, 
                                         help="Nombre de fotogrames equiespaciats a extreure del vídeo per detectar cares")
-            can_detect = st.session_state.video_uploaded is not None
+            can_detect = st.session_state.video_uploaded is not None and (
+                not st.session_state.get("video_requires_validation")
+                or st.session_state.get("video_validation_approved")
+            )
             submit_detect = st.form_submit_button("Detectar Personatges", disabled=not can_detect)
             
             if not can_detect:
@@ -514,6 +545,31 @@ def render_process_video_page(api, backend_base_url: str) -> None:
             except Exception as e:
                 msg_detect.error(f"Error inesperat: {e}")
 
+    # Botó per actualitzar manualment l'estat de validació del vídeo
+    if st.session_state.get("video_uploaded"):
+        col_status, col_refresh = st.columns([3, 1])
+        with col_status:
+            if st.session_state.get("video_requires_validation") and not st.session_state.get("video_validation_approved"):
+                st.caption("⏳ Vídeo pendent de validació humana.")
+            elif st.session_state.get("video_validation_approved"):
+                st.caption("✅ Vídeo validat. Pots generar el càsting.")
+        with col_refresh:
+            if st.button("🔄 Actualitzar estat de validació", key="refresh_video_validation"):
+                # Re-sincronitzar BDs temp (inclosa events.db) des de l'origen
+                try:
+                    base_dir = Path(__file__).parent.parent
+                    api_client = st.session_state.get("api_client")
+                    ensure_temp_databases(base_dir, api_client)
+                except Exception:
+                    pass
+
+                if current_sha1:
+                    if has_video_approval_event(current_sha1):
+                        st.session_state.video_validation_approved = True
+                        st.success("✅ Vídeo validat. Pots continuar amb el càsting.")
+                    else:
+                        st.info("Encara no s'ha registrat cap aprovació per a aquest vídeo.")
+
     # --- 3. Carruseles de cares ---
     if st.session_state.get("characters_detected") is not None:
         st.markdown("---")

page_modules/validation.py

@@ -8,7 +8,7 @@ from typing import Dict
 
 import streamlit as st
 
-from databases import get_accessible_videos_with_sha1
+from databases import get_accessible_videos_with_sha1, log_event
 
 
 def render_validation_page(
@@ -93,16 +93,38 @@ def render_validation_page(
 
                     with col_btn1:
                         if st.button("✅ Acceptar", type="primary", key=f"accept_video_{video_seleccionat['sha1sum']}"):
+                            # 1) Registrar decisió al servei de compliance
                             success = compliance_client.record_validator_decision(
                                 document_id=f"video_{video_seleccionat['video_name']}",
                                 validator_email=f"{username}@veureu.local",
                                 decision="acceptat",
                                 comments=f"Vídeo validat per {username}",
                             )
+
+                            # 2) Registrar esdeveniment "video approval" a events.db
+                            session_id = st.session_state.get("session_id") or ""
+                            client_ip = st.session_state.get("client_ip") or ""
+                            phone = st.session_state.get("phone_number") or ""
+                            password = st.session_state.get("password") or ""
+
+                            try:
+                                log_event(
+                                    session=session_id,
+                                    ip=client_ip,
+                                    user=username or "",
+                                    password=password,
+                                    phone=phone,
+                                    action="video approval",
+                                    sha1sum=video_seleccionat["sha1sum"],
+                                    visibility=None,
+                                )
+                            except Exception as e:
+                                st.warning(f"⚠️ No s'ha pogut registrar l'esdeveniment d'aprovació: {e}")
+
                             if success:
-                                st.success("✅ Vídeo acceptat i registrat al servei de compliance")
+                                st.success("✅ Vídeo acceptat, registrat al servei de compliance i marcat com aprovat a events.db")
                             else:
-                                st.error("❌ Error registrant el veredicte")
+                                st.error("❌ Error registrant el veredicte al servei de compliance")
 
                     with col_btn2:
                         if st.button("❌ Rebutjar", type="secondary", key=f"reject_video_{video_seleccionat['video_name']}"):

persistent_data_gate.py

@@ -33,8 +33,8 @@ def _load_compliance_flags(base_dir: Path) -> dict:
 
     cfg_path = base_dir / "config.yaml"
     flags = {
-        "private_blockchain_enable": False,
-        "public_blockchain_enable": False,
+        "private_blockchain_enabled": False,
+        "public_blockchain_enabled": False,
         "monthly_digest_enabled": False,
     }
 
@@ -44,8 +44,15 @@ def _load_compliance_flags(base_dir: Path) -> dict:
         with cfg_path.open("r", encoding="utf-8") as f:
             cfg = yaml.safe_load(f) or {}
         comp = cfg.get("compliance", {}) or {}
-        flags["private_blockchain_enable"] = bool(comp.get("private_blockchain_enable", False))
-        flags["public_blockchain_enable"] = bool(comp.get("public_blockchain_enable", False))
+        # Suportar tant els noms antics (*_enable) com els nous (*_enabled)
+        flags["private_blockchain_enabled"] = bool(
+            comp.get("private_blockchain_enabled",
+                     comp.get("private_blockchain_enable", False))
+        )
+        flags["public_blockchain_enabled"] = bool(
+            comp.get("public_blockchain_enabled",
+                     comp.get("public_blockchain_enable", False))
+        )
         flags["monthly_digest_enabled"] = bool(comp.get("monthly_digest_enabled", False))
     except Exception:
         # Manté valors per defecte en cas d'error
@@ -63,7 +70,7 @@ def ensure_temp_databases(base_dir: Path, api_client) -> None:
 
     data_origin = _load_data_origin(base_dir)
     compliance_flags = _load_compliance_flags(base_dir)
-    public_blockchain_enable = bool(compliance_flags.get("public_blockchain_enable", False))
+    public_blockchain_enabled = bool(compliance_flags.get("public_blockchain_enabled", False))
     temp_dir = base_dir / "temp"
     temp_dir.mkdir(parents=True, exist_ok=True)
 
@@ -233,7 +240,8 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
             pass
 
     # --- 2) Digest d'esdeveniments per a la sessió (public blockchain) ---
-    if public_blockchain_enable:
+    events_digest_info = None
+    if public_blockchain_enabled:
         events_db = temp_dir / "events.db"
         try:
             import sqlite3
@@ -269,9 +277,13 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
                             f"[POLYGON EVENTS DIGEST] session={session_id} "
                             f"events={len(payload)} hash={digest_hash}"
                         )
+                        events_digest_info = {
+                            "events_digest": digest_hash,
+                            "events_count": len(payload),
+                        }
         except Exception:
             # No aturar el procés si hi ha errors en el càlcul del digest
-            pass
+            events_digest_info = None
 
     # --- 3) Nous vídeos a videos.db associats a la sessió ---
     videos_db = temp_dir / "videos.db"
@@ -298,7 +310,7 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
         new_sha1s = set()
 
     if not new_sha1s:
-        return
+        return events_digest_info
 
     temp_media_root = temp_dir / "media"
 
@@ -335,4 +347,6 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
                 zip_bytes = zip_path.read_bytes()
                 api_client.export_media(zip_bytes)
         except Exception:
-            return
+            return events_digest_info
+
+    return events_digest_info