Upload 10 files

app.py

@@ -3,6 +3,7 @@ import yaml
 import shutil
 from pathlib import Path
 import uuid
+from datetime import datetime
 try:
     import tomllib
 except ModuleNotFoundError:  # Py<3.11
@@ -73,7 +74,7 @@ def _load_yaml(path="config.yaml") -> dict:
 CFG = _load_yaml("config.yaml")
 
 # Ajuste de variables según tu esquema YAML
-# Para la interfaz demo, usaremos siempre la carpeta "temp" local
+# Para la interfaz demo, usaremos sempre la carpeta "temp" local
 DATA_DIR = "temp"
 BACKEND_BASE_URL = CFG.get("api", {}).get("base_url", "http://localhost:8000")
 TTS_URL = "https://veureu-tts.hf.space"  # Forzar URL correcta
@@ -82,7 +83,11 @@ print(f"🔧 Tipo de TTS_URL: {type(TTS_URL)}")
 print(f"🔧 Longitud de TTS_URL: {len(TTS_URL)}")
 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
-BLOCKCHAIN_ENABLED = bool(CFG.get("blockchain", {}).get("enabled", 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))
+MONTHLY_DIGEST_ENABLED = bool(COMPLIANCE_CFG.get("monthly_digest_enabled", False))
 API_TOKEN = CFG.get("api", {}).get("token") or os.getenv("API_SHARED_TOKEN")
 
 # Cliente del backend (engine)
@@ -98,7 +103,19 @@ DB_PATH = os.path.join(DATA_DIR, "users.db")
 set_db_path(DB_PATH)
 
 # Configurar si els esdeveniments s'han de registrar a SQLite o a AWS QLDB
-set_blockchain_enabled(BLOCKCHAIN_ENABLED)
+set_blockchain_enabled(PRIVATE_BLOCKCHAIN_ENABLE)
+
+# Si està habilitat el registre públic i el digest mensual, publicar al
+# principi de cada mes un digest global via servei de compliance.
+if PUBLIC_BLOCKCHAIN_ENABLE and MONTHLY_DIGEST_ENABLED:
+    try:
+        today = datetime.utcnow().date()
+        if today.day == 1:
+            period = today.strftime("%Y-%m")
+            compliance_client.publish_monthly_digest(period)
+    except Exception:
+        # No bloquejar l'app per errors de blockchain/compliance
+        pass
 
 init_schema()
 

compliance_client.py

@@ -92,6 +92,20 @@ class ComplianceClient:
     
     def is_authenticated(self) -> bool:
         """Verifica si el usuario actual está autenticado"""
+        # Primero verificar si hay autenticación tradicional
+        if 'user' in st.session_state and st.session_state.user:
+            logger.info(f"Usuario ya autenticado tradicionalmente: {st.session_state.user.get('username', 'unknown')}")
+            # Crear token automático para usuarios tradicionales
+            if 'auth_token' not in st.session_state:
+                st.session_state.auth_token = f"traditional_token_{int(time.time())}"
+                st.session_state.current_user = {
+                    "email": f"{st.session_state.user.get('username', 'unknown')}@veureu.local",
+                    "name": st.session_state.user.get('username', 'Unknown'),
+                    "method": "traditional"
+                }
+            return True
+        
+        # Si no hay autenticación tradicional, verificar por token
         if "auth_token" not in st.session_state:
             return False
         
@@ -113,6 +127,11 @@ class ComplianceClient:
     
     def get_current_user(self) -> Optional[str]:
         """Obtiene email del usuario actual"""
+        # Primero verificar autenticación tradicional
+        if 'user' in st.session_state and st.session_state.user:
+            return f"{st.session_state.user.get('username', 'unknown')}@veureu.local"
+        
+        # Si no, verificar autenticación por token
         if self.is_authenticated():
             return st.session_state.get("current_user", {}).get("email")
         return None
@@ -122,6 +141,11 @@ class ComplianceClient:
         print("[OAuth] show_login_button llamado")  # Forzar salida a log del Space
         logger.info("[OAuth] show_login_button llamado")
         
+        # Si ya hay usuario autenticado tradicionalmente, no mostrar login
+        if 'user' in st.session_state and st.session_state.user:
+            logger.info(f"[OAuth] Usuario ya autenticado tradicionalmente: {st.session_state.user.get('username', 'unknown')}")
+            return True
+        
         # Verificar si OAuth está configurado en el servicio
         try:
             health_response = self._make_request("GET", "/")
@@ -162,7 +186,7 @@ class ComplianceClient:
             st.markdown(f"""
             ### 🔐 Iniciar sessió
             
-            Per continuar, necessites iniciar sessió amb el teu compte de Google.
+            Per continuar, necessitas iniciar sessió amb el teu compte de Google.
             
             <a href="{login_url}" target="_top">
                 <button style="
@@ -229,6 +253,29 @@ class ComplianceClient:
             logger.error("[OAuth] login_url és None: comprova COMPLIANCE_SERVICE_URL i l'estat del servei de compliance")
         
         return False
+
+    # === VERIFICACIÓ PER TELÈFON / WHATSAPP ===
+
+    def create_phone_verification_session(
+        self,
+        *,
+        page: str,
+        user_id: Optional[str] = None,
+        email: Optional[str] = None,
+        action: Optional[str] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """Crea una sessió de verificació de telèfon al backend de compliance.
+
+        Endpoint: POST /phone_verification/create_session
+        """
+
+        payload: Dict[str, Any] = {
+            "page": page,
+            "user_id": user_id,
+            "email": email,
+            "action": action,
+        }
+        return self._make_request("POST", "/phone_verification/create_session", payload)
     
     def _show_demo_login(self) -> bool:
         """Muestra formulario de login por SMS en ventana desplegable cuando OAuth no está configurado"""

config.yaml

@@ -5,6 +5,8 @@ app:
   # tamaño máximo de subida en MB
   max_upload_mb: 500
 
+data_origin: "internal"
+
 api:
   # URL pública de tu space engine (puedes interpolar la var de entorno)
   base_url: "${API_BASE_URL}"
@@ -39,7 +41,9 @@ ui:
   page_icon: "🎧"
   wide_layout: true
 
-blockchain:
-  # Habilita o deshabilita el registre d'esdeveniments a AWS QLDB/Polygon
-  enabled: false
+compliance:
+  # Controla la integració amb AWS QLDB (registre privat) i Polygon (registre públic)
+  private_blockchain_enable: false
+  public_blockchain_enable: false
+  monthly_digest_enabled: false
 

mobile_verification.py

@@ -14,6 +14,8 @@ import streamlit as st
 from datetime import datetime
 from typing import Optional, Tuple
 
+from compliance_client import compliance_client
+
 
 def log(msg: str):
     """Helper per logging amb timestamp"""
@@ -150,20 +152,48 @@ def render_mobile_verification_screen(username: str, role: str) -> Optional[bool
             key="mobile_accept_terms"
         )
         
-        # Botón para enviar código
+        # Botón para enviar código (SMS demo) i, en paral·lel, registrar sessió per WhatsApp al backend
         if st.button(
             "📤 Enviar codi de verificació",
             type="primary",
             disabled=not (phone_number and accept_terms)
         ):
             full_phone = f"{country_code}{phone_number}"
+
+            # 1) Flux SMS demo local (no canvia)
             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.")
+
+            # 2) Crear sessió de verificació per WhatsApp al backend de compliance
+            try:
+                user_obj = st.session_state.get("user") or {}
+                user_id = str(user_obj.get("id")) if isinstance(user_obj, dict) and "id" in user_obj else None
+                email = None  # es pot afegir més endavant si hi ha email disponible
+
+                resp = compliance_client.create_phone_verification_session(
+                    page="demo/mobile_verification",
+                    user_id=user_id,
+                    email=email,
+                    action="accept_terms_mobile_verification",
+                )
+
+                if resp and "session_code" in resp:
+                    session_code = resp["session_code"]
+                    expires_at = resp.get("expires_at")
+                    st.info(
+                        "📱 **Verificació per WhatsApp (registre de firma)**\n\n"
+                        "Envia un WhatsApp des del teu mòbil al **número oficial del projecte** amb el text:\n\n"
+                        f"`ACEPTO {session_code}`\n\n"
+                        "Tens fins a **5 minuts** per enviar-lo."
+                    )
+                else:
+                    log("[COMPLIANCE] No s'ha pogut crear la sessió de verificació per telèfon")
+            except Exception as e:
+                log(f"[COMPLIANCE] Error cridant create_phone_verification_session: {e}")
         
         # Si se envió el SMS, mostrar campo para verificar código
         if st.session_state.sms_step == 'verify':

persistent_data_gate.py

@@ -22,6 +22,38 @@ def _load_data_origin(base_dir: Path) -> str:
     return origin
 
 
+def _load_compliance_flags(base_dir: Path) -> dict:
+    """Llegeix flags de la secció 'compliance' de demo/config.yaml.
+
+    Retorna un dict amb claus:
+    - private_blockchain_enable
+    - public_blockchain_enable
+    - monthly_digest_enabled
+    """
+
+    cfg_path = base_dir / "config.yaml"
+    flags = {
+        "private_blockchain_enable": False,
+        "public_blockchain_enable": False,
+        "monthly_digest_enabled": False,
+    }
+
+    try:
+        import yaml
+
+        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))
+        flags["monthly_digest_enabled"] = bool(comp.get("monthly_digest_enabled", False))
+    except Exception:
+        # Manté valors per defecte en cas d'error
+        return flags
+
+    return flags
+
+
 def ensure_temp_databases(base_dir: Path, api_client) -> None:
     """Garantiza que las BDs *.db estén presentes en demo/temp antes del login.
 
@@ -30,6 +62,8 @@ 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))
     temp_dir = base_dir / "temp"
     temp_dir.mkdir(parents=True, exist_ok=True)
 
@@ -198,7 +232,48 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
         except Exception:
             pass
 
-    # --- 2) Nous vídeos a videos.db associats a la sessió ---
+    # --- 2) Digest d'esdeveniments per a la sessió (public blockchain) ---
+    if public_blockchain_enable:
+        events_db = temp_dir / "events.db"
+        try:
+            import sqlite3
+            import hashlib
+            import json
+
+            with sqlite3.connect(str(events_db)) as econn:
+                econn.row_factory = sqlite3.Row
+                cur = econn.cursor()
+
+                # Comprovar que existeix la taula events
+                cur.execute(
+                    "SELECT name FROM sqlite_master WHERE type='table' AND name='events'"
+                )
+                if cur.fetchone():
+                    cur.execute(
+                        "SELECT * FROM events WHERE session = ?", (session_id,)
+                    )
+                    rows = cur.fetchall()
+                    if rows:
+                        payload = []
+                        for r in rows:
+                            payload.append({k: r[k] for k in r.keys()})
+
+                        serialized = json.dumps(
+                            payload, sort_keys=True, separators=(",", ":")
+                        )
+                        digest_hash = hashlib.sha256(
+                            serialized.encode("utf-8")
+                        ).hexdigest()
+                        # Simular publicació a Polygon: log amb prefix clar
+                        print(
+                            f"[POLYGON EVENTS DIGEST] session={session_id} "
+                            f"events={len(payload)} hash={digest_hash}"
+                        )
+        except Exception:
+            # No aturar el procés si hi ha errors en el càlcul del digest
+            pass
+
+    # --- 3) Nous vídeos a videos.db associats a la sessió ---
     videos_db = temp_dir / "videos.db"
     new_sha1s: set[str] = set()