Upload 15 files

auth.py

@@ -8,7 +8,7 @@ from pathlib import Path
 
 import streamlit as st
 
-from databases import get_user, create_user, update_user_password, get_all_users, log_event
+from databases import get_user, create_user, update_user_password, get_all_users, log_action
 from mobile_verification import (
     initialize_sms_state,
     render_mobile_verification_screen,
@@ -115,21 +115,17 @@ def render_login_form():
             # Registre d'esdeveniment de login a events.db
             try:
                 session_id = st.session_state.get("session_id", "")
-                ip = st.session_state.get("client_ip", "")
                 phone = (
                     st.session_state.get("sms_phone_verified")
                     or st.session_state.get("sms_phone")
                     or ""
                 )
-                log_event(
+                log_action(
                     session=session_id,
-                    ip=ip,
                     user=username or "",
-                    password=password or "",
                     phone=phone,
                     action="login",
                     sha1sum="",
-                    visibility="",
                 )
             except Exception as e:
                 log(f"Error registrant esdeveniment de login: {e}")
@@ -243,22 +239,18 @@ def render_sidebar():
                 try:
                     current_user = st.session_state.user or {}
                     session_id = st.session_state.get("session_id", "")
-                    ip = st.session_state.get("client_ip", "")
                     phone = (
                         st.session_state.get("sms_phone_verified")
                         or st.session_state.get("sms_phone")
                         or ""
                     )
                     last_password = st.session_state.get("last_password", "")
-                    log_event(
+                    log_action(
                         session=session_id,
-                        ip=ip,
                         user=current_user.get("username", ""),
-                        password=last_password,
                         phone=phone,
                         action="logout",
                         sha1sum="",
-                        visibility="",
                     )
                 except Exception as e:
                     log(f"Error registrant esdeveniment de logout: {e}")
@@ -269,7 +261,7 @@ def render_sidebar():
                 log(
                     "Logout completat: "
                     f"session={session_id or '-'} "
-                    f"events_digest={'sí' if digest_hash else 'no'} "
+                    f"events_digest={digest_hash or '-'} "
                     f"events_count={events_count if events_count is not None else '-'} "
                     f"polygon_published={'sí' if blockchain_published else 'no'} "
                     f"polygon_url={polygonscan_url or '-'}"

compliance_client.py

@@ -458,6 +458,32 @@ class ComplianceClient:
         )
         return bool(response and response.get("success"))
 
+    def notify_user_video_approved(self, phone: str, message: str, sha1sum: str) -> bool:
+        """Envia un SMS a l'usuari indicant que el seu vídeo ha estat aprovat.
+
+        El backend de compliance decidirà si utilitza Twilio o Zapier segons
+        la configuració (twilio_enabled / zapier_enabled).
+        """
+
+        payload = {"phone": phone, "message": message, "sha1sum": sha1sum}
+        response = self._make_request(
+            "POST", "/api/notifications/user-video-approved-sms", payload
+        )
+        return bool(response and response.get("success"))
+
+    def notify_une_validator_new_ads(self, phone: str, message: str) -> bool:
+        """Envia un SMS al validador UNE indicant que hi ha noves AD per validar.
+
+        El backend de compliance s'encarrega de triar Twilio o Zapier segons
+        la configuració (twilio_enabled / zapier_enabled).
+        """
+
+        payload = {"phone": phone, "message": message}
+        response = self._make_request(
+            "POST", "/api/notifications/une-validation-sms", payload
+        )
+        return bool(response and response.get("success"))
+
     def send_login_sms(self, phone: str, code: str) -> bool:
         """Envia un SMS de verificació de login a través del servei de compliance.
 
@@ -489,6 +515,27 @@ class ComplianceClient:
             return response
 
         return None
+
+    def publish_actions_qldb(self, session_id: str, actions: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+        """Envia el registre de canvis d'actions.db a una taula QLDB.
+
+        El backend és responsable d'escriure aquest payload a AWS QLDB quan
+        la funcionalitat de blockchain privada estigui activada.
+        """
+
+        payload = {
+            "session_id": session_id,
+            "actions": actions,
+        }
+
+        response = self._make_request(
+            "POST", "/api/blockchain/publish-actions-qldb", 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"""

databases.py

@@ -19,15 +19,19 @@ FEEDBACK_DB_PATH = Path(__file__).resolve().parent / "temp" / "db" / "feedback.d
 # Ruta a la base de dades de captions per als scores
 CAPTIONS_DB_PATH = Path(__file__).resolve().parent / "temp" / "db" / "captions.db"
 
-# Ruta a la base de dades d'esdeveniments (events.db) a demo/temp/db
-EVENTS_DB_PATH = Path(__file__).resolve().parent / "temp" / "db" / "events.db"
-
 # Ruta a la base de dades de vídeos (videos.db) a demo/temp/db
 VIDEOS_DB_PATH = Path(__file__).resolve().parent / "temp" / "db" / "videos.db"
 
 # Ruta a la base de dades d'audiodescripcions (audiodescriptions.db) a demo/temp/db
 AUDIODESCRIPTIONS_DB_PATH = Path(__file__).resolve().parent / "temp" / "db" / "audiodescriptions.db"
 
+# Ruta a la base de dades d'accions (actions.db) a demo/temp/db
+ACTIONS_DB_PATH = Path(__file__).resolve().parent / "temp" / "db" / "actions.db"
+
+# Ruta a les bases de dades de càsting i escenaris a demo/temp/db
+CASTING_DB_PATH = Path(__file__).resolve().parent / "temp" / "db" / "casting.db"
+SCENARIOS_DB_PATH = Path(__file__).resolve().parent / "temp" / "db" / "scenarios.db"
+
 
 def set_db_path(db_path: str):
     global DEFAULT_DB_PATH
@@ -220,11 +224,11 @@ def get_accessible_videos_for_session(session_id: str | None) -> List[str]:
     if not session_id:
         return sorted(public_videos)
 
-    # 2) Telèfons associats a la sessió actual
+    # 2) Telèfons associats a la sessió actual (a partir d'actions.db)
     phones: set[str] = set()
-    with _connect_events_db() as econn:
-        for row in econn.execute(
-            "SELECT DISTINCT phone FROM events WHERE session = ? AND phone IS NOT NULL AND phone != ''",
+    with _connect_actions_db() as aconn:
+        for row in aconn.execute(
+            "SELECT DISTINCT phone FROM actions WHERE session = ? AND phone IS NOT NULL AND phone != ''",
             (session_id,),
         ):
             phones.add(row["phone"])
@@ -310,6 +314,255 @@ def _connect_feedback_db() -> sqlite3.Connection:
     return conn
 
 
+def _connect_actions_db() -> sqlite3.Connection:
+    ACTIONS_DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(ACTIONS_DB_PATH))
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def get_latest_user_phone_for_session(session_id: str) -> Tuple[str, str]:
+    if not session_id:
+        return "", ""
+
+    try:
+        with _connect_actions_db() as conn:
+            cur = conn.execute(
+                "SELECT user, phone FROM actions "
+                "WHERE session = ? AND (user IS NOT NULL OR phone IS NOT NULL) "
+                "ORDER BY id DESC LIMIT 1",
+                (session_id,),
+            )
+            row = cur.fetchone()
+            if not row:
+                return "", ""
+            u = row["user"] if row["user"] is not None else ""
+            p = row["phone"] if row["phone"] is not None else ""
+            return str(u), str(p)
+    except sqlite3.OperationalError:
+        return "", ""
+
+
+def insert_action(
+    *,
+    session: str,
+    user: str,
+    phone: str,
+    action: str,
+    sha1sum: str,
+    timestamp: Optional[str] = None,
+) -> None:
+    ts = timestamp or datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+
+    try:
+        with _connect_actions_db() as conn:
+            cur = conn.cursor()
+            cur.execute(
+                """
+                CREATE TABLE IF NOT EXISTS actions (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    timestamp TEXT NOT NULL,
+                    action TEXT NOT NULL,
+                    session TEXT,
+                    user TEXT,
+                    phone TEXT,
+                    sha1sum TEXT
+                );
+                """
+            )
+
+            cur.execute(
+                """INSERT INTO actions
+                       (timestamp, action, session, user, phone, sha1sum)
+                       VALUES (?,?,?,?,?,?)""",
+                (ts, action, session or "", user or "", phone or "", sha1sum or ""),
+            )
+    except sqlite3.OperationalError:
+        return
+
+
+def get_video_owner_by_sha1(sha1sum: str) -> str:
+    """Retorna el telèfon (owner) associat a un sha1sum a videos.db, o "".
+
+    Cerca a demo/temp/db/videos.db una fila amb aquest sha1sum i retorna el
+    camp owner si existeix.
+    """
+
+    if not sha1sum:
+        return ""
+
+    try:
+        with _connect_videos_db() as conn:
+            cur = conn.execute(
+                "SELECT owner FROM videos WHERE sha1sum = ? LIMIT 1",
+                (sha1sum,),
+            )
+            row = cur.fetchone()
+            if not row:
+                return ""
+            owner = row["owner"] if "owner" in row.keys() else None
+            return str(owner or "")
+    except sqlite3.OperationalError:
+        return ""
+
+
+def is_video_input_ok(sha1sum: str) -> bool:
+    """Retorna True si el vídeo té status='input-OK' a videos.db per a aquest sha1sum."""
+
+    if not sha1sum:
+        return False
+
+    try:
+        with _connect_videos_db() as conn:
+            cur = conn.execute(
+                "SELECT status FROM videos WHERE sha1sum = ? LIMIT 1",
+                (sha1sum,),
+            )
+            row = cur.fetchone()
+            if not row:
+                return False
+            status = row["status"] if "status" in row.keys() else None
+            return str(status or "").strip().lower() == "input-ok"
+    except sqlite3.OperationalError:
+        return False
+
+
+def ensure_video_row_for_upload(
+    *,
+    sha1sum: str,
+    video_name: str,
+    owner_phone: str,
+    status: str = "input-pending",
+    visibility: str | None = None,
+) -> None:
+    if not sha1sum:
+        return
+
+    try:
+        with _connect_videos_db() as conn:
+            cur = conn.cursor()
+
+            try:
+                cur.execute("PRAGMA table_info(videos)")
+                cols = {row[1] for row in cur.fetchall()}
+            except sqlite3.OperationalError:
+                return
+
+            alter_stmts = []
+            if "owner" not in cols:
+                alter_stmts.append("ALTER TABLE videos ADD COLUMN owner TEXT")
+            if "status" not in cols:
+                alter_stmts.append("ALTER TABLE videos ADD COLUMN status TEXT")
+            if "sha1sum" not in cols:
+                alter_stmts.append("ALTER TABLE videos ADD COLUMN sha1sum TEXT")
+            if "visibility" not in cols:
+                alter_stmts.append("ALTER TABLE videos ADD COLUMN visibility TEXT")
+
+            for stmt in alter_stmts:
+                try:
+                    cur.execute(stmt)
+                except sqlite3.OperationalError:
+                    continue
+
+            row = cur.execute(
+                "SELECT id FROM videos WHERE sha1sum = ? LIMIT 1",
+                (sha1sum,),
+            ).fetchone()
+            if row is not None:
+                return
+
+            vis = visibility or "private"
+            cur.execute(
+                "INSERT INTO videos (video_name, owner, visibility, sha1sum, status) "
+                "VALUES (?,?,?,?,?)",
+                (video_name or sha1sum, owner_phone or "", vis, sha1sum, status),
+            )
+    except sqlite3.OperationalError:
+        return
+
+
+def update_video_status(sha1sum: str, status: str) -> None:
+    """Actualitza el camp status d'un vídeo existent a videos.db per sha1sum.
+
+    Si la taula o el registre no existeixen, no fa res.
+    """
+
+    if not sha1sum:
+        return
+
+    try:
+        with _connect_videos_db() as conn:
+            cur = conn.cursor()
+
+            try:
+                cur.execute("PRAGMA table_info(videos)")
+                cols = {row[1] for row in cur.fetchall()}
+            except sqlite3.OperationalError:
+                return
+
+            # Assegurar columnes bàsiques
+            alter_stmts: list[str] = []
+            if "status" not in cols:
+                alter_stmts.append("ALTER TABLE videos ADD COLUMN status TEXT")
+            if "sha1sum" not in cols:
+                alter_stmts.append("ALTER TABLE videos ADD COLUMN sha1sum TEXT")
+
+            for stmt in alter_stmts:
+                try:
+                    cur.execute(stmt)
+                except sqlite3.OperationalError:
+                    continue
+
+            cur.execute(
+                "UPDATE videos SET status = ? WHERE sha1sum = ?",
+                (status, sha1sum),
+            )
+    except sqlite3.OperationalError:
+        return
+
+
+def get_videos_by_status(status: str) -> List[Dict[str, Any]]:
+    """Retorna llista de vídeos a videos.db amb un status concret.
+
+    Cada element és un dict amb com a mínim: sha1sum, video_name.
+    Si la taula o les columnes no existeixen, retorna [].
+    """
+
+    if not status:
+        return []
+
+    try:
+        with _connect_videos_db() as conn:
+            cur = conn.cursor()
+            try:
+                cur.execute("PRAGMA table_info(videos)")
+                cols = {row[1] for row in cur.fetchall()}
+            except sqlite3.OperationalError:
+                return []
+
+            if "status" not in cols or "sha1sum" not in cols:
+                return []
+
+            # video_name pot no existir en esquemes antics; fem SELECT defensiu
+            has_video_name = "video_name" in cols
+            select_sql = (
+                "SELECT sha1sum, video_name FROM videos WHERE status = ?"
+                if has_video_name
+                else "SELECT sha1sum, sha1sum AS video_name FROM videos WHERE status = ?"
+            )
+
+            results: List[Dict[str, Any]] = []
+            for row in cur.execute(select_sql, (status,)):
+                sha1 = str(row[0]) if row[0] is not None else ""
+                vname = str(row[1]) if row[1] is not None else sha1
+                if not sha1:
+                    continue
+                results.append({"sha1sum": sha1, "video_name": vname})
+            return results
+    except sqlite3.OperationalError:
+        return []
+
+
 def _connect_audiodescriptions_db() -> sqlite3.Connection:
     """Connexió directa a demo/temp/audiodescriptions.db.
 
@@ -702,50 +955,100 @@ def _connect_videos_db() -> sqlite3.Connection:
     return conn
 
 
-def log_event(
+def _connect_simple_mapping_db(db_path: Path, table_name: str) -> sqlite3.Connection:
+    """Connexió a una BD simple (sha1sum, name, description) a demo/temp/db.
+
+    Es fa servir per a casting.db i scenarios.db.
+    """
+
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+    cur.execute(
+        f"""
+        CREATE TABLE IF NOT EXISTS {table_name} (
+            sha1sum     TEXT NOT NULL,
+            name        TEXT NOT NULL,
+            description TEXT
+        );
+        """
+    )
+    conn.commit()
+    return conn
+
+
+def _connect_casting_db() -> sqlite3.Connection:
+    """Connexió directa a demo/temp/db/casting.db (taula casting)."""
+
+    return _connect_simple_mapping_db(CASTING_DB_PATH, "casting")
+
+
+def _connect_scenarios_db() -> sqlite3.Connection:
+    """Connexió directa a demo/temp/db/scenarios.db (taula scenarios)."""
+
+    return _connect_simple_mapping_db(SCENARIOS_DB_PATH, "scenarios")
+
+
+def insert_casting_row(sha1sum: str, name: str, description: str | None = None) -> None:
+    """Insereix un personatge a casting.db per a un sha1sum donat."""
+
+    if not sha1sum or not name:
+        return
+
+    try:
+        with _connect_casting_db() as conn:
+            conn.execute(
+                "INSERT INTO casting (sha1sum, name, description) VALUES (?,?,?)",
+                (sha1sum, name, description or ""),
+            )
+    except sqlite3.OperationalError:
+        return
+
+
+def insert_scenario_row(sha1sum: str, name: str, description: str | None = None) -> None:
+    """Insereix un escenari a scenarios.db per a un sha1sum donat."""
+
+    if not sha1sum or not name:
+        return
+
+    try:
+        with _connect_scenarios_db() as conn:
+            conn.execute(
+                "INSERT INTO scenarios (sha1sum, name, description) VALUES (?,?,?)",
+                (sha1sum, name, description or ""),
+            )
+    except sqlite3.OperationalError:
+        return
+
+
+def log_action(
     *,
     session: str,
-    ip: str,
     user: str,
-    password: str,
     phone: str,
     action: str,
     sha1sum: str,
-    visibility: str | None = None,
     timestamp: Optional[str] = None,
 ) -> None:
-    """Insereix un registre a demo/temp/events.db.
-
-    - timestamp: si no s'especifica, es fa servir UTC "YYYY-MM-DD HH:MM:SS".
-    - session, ip, user, password, phone, sha1sum es guarden com a TEXT.
-    """
+    """Insereix un registre a demo/temp/actions.db (taula actions)."""
 
     ts = timestamp or datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
 
-    # Mode únic: registrar en demo/temp/events.db
-    with _connect_events_db() as conn:
-        conn.execute(
-            """INSERT INTO events
-               (timestamp, session, ip, user, password, phone, action, sha1sum, visibility)
-               VALUES (?,?,?,?,?,?,?,?,?)""",
-            (
-                ts,
-                session or "",
-                ip or "",
-                user or "",
-                password or "",
-                phone or "",
-                action,
-                sha1sum or "",
-                visibility or "",
-            ),
-        )
+    insert_action(
+        session=session or "",
+        user=user or "",
+        phone=phone or "",
+        action=action,
+        sha1sum=sha1sum or "",
+        timestamp=ts,
+    )
 
 
-def has_video_approval_event(sha1sum: str) -> bool:
-    """Comprova si existeix un esdeveniment d'aprovació de vídeo per a un sha1sum.
+def has_video_approval_action(sha1sum: str) -> bool:
+    """Comprova si existeix una acció d'acceptació d'input per a un sha1sum.
 
-    Busca a demo/temp/events.db una fila amb action='video approval' i el sha1sum
+    Busca a demo/temp/actions.db una fila amb action='input-OK' i el sha1sum
     especificat.
     """
 
@@ -753,10 +1056,10 @@ def has_video_approval_event(sha1sum: str) -> bool:
         return False
 
     try:
-        with _connect_events_db() as conn:
+        with _connect_actions_db() as conn:
             cur = conn.execute(
-                "SELECT 1 FROM events WHERE action = ? AND sha1sum = ? LIMIT 1",
-                ("video approval", sha1sum),
+                "SELECT 1 FROM actions WHERE action = ? AND sha1sum = ? LIMIT 1",
+                ("input-OK", sha1sum),
             )
             return cur.fetchone() is not None
     except sqlite3.OperationalError:

page_modules/analyze_audiodescriptions.py

@@ -16,11 +16,16 @@ from utils import save_bytes
 from persistent_data_gate import ensure_media_for_video
 from databases import (
     get_videos_from_audiodescriptions,
-    insert_demo_feedback_row,
     get_audiodescription,
     get_audiodescription_history,
     update_audiodescription_text,
-    log_event,
+    update_audiodescription_info_ad,
+    insert_demo_feedback_row,
+    get_feedback_score_labels,
+    log_action,
+    insert_action,
+    get_latest_user_phone_for_session,
+    get_video_owner_by_sha1,
 )
 
 
@@ -67,6 +72,29 @@ def _find_best_file_for_version(vid_dir: Path, version: str, filename: str) -> O
     return None
 
 
+def _file_for_hist_choice(vid_dir: Path, version: str, filename: str, hist_choice: str) -> Optional[Path]:
+    """Retorna el fitxer per al subtype seleccionat (Original/HITL OK/HITL Test).
+
+    Si no existeix al subtype triat, fa servir el comportament per defecte de
+    _find_best_file_for_version.
+    """
+
+    # Map hist_choice -> subcarpeta física
+    subtype_map = {
+        "Original": "Original",
+        "HITL OK": "HITL OK",
+        "HITL Test": "HITL Test",
+    }
+    subtype = subtype_map.get(hist_choice)
+
+    if subtype:
+        candidate = vid_dir / version / subtype / filename
+        if candidate.exists():
+            return candidate
+
+    return _find_best_file_for_version(vid_dir, version, filename)
+
+
 def load_eval_values(vid_dir: Path, version: str, eval_content: Optional[str] = None) -> Optional[Dict[str, int]]:
     """Carga los valores de evaluación desde eval (DB o CSV) si existe.
     
@@ -229,38 +257,16 @@ def render_analyze_audiodescriptions_page(api, permissions: Dict[str, bool]) ->
                 elif "eval_values" in st.session_state:
                     del st.session_state["eval_values"]
 
-        video_ad_path = (
-            _find_best_file_for_version(vid_dir, subcarpeta_seleccio, "une_ad.mp4")
-            if subcarpeta_seleccio
-            else None
-        )
-        is_ad_video_available = video_ad_path is not None and video_ad_path.exists()
-
-        add_ad_video = st.checkbox(
-            "Afegir audiodescripció",
-            disabled=not is_ad_video_available,
-            key="add_ad_checkbox",
-        )
-
-        video_to_show = None
-        if add_ad_video and is_ad_video_available:
-            video_to_show = video_ad_path
-        elif mp4s:
-            video_to_show = mp4s[0]
-
-        if video_to_show:
-            st.video(str(video_to_show))
-        else:
-            st.warning("No s'ha trobat cap fitxer **.mp4** a la carpeta seleccionada.")
-
         st.markdown("---")
         st.markdown("#### Accions")
-        c1, c2 = st.columns(2)
+        c1, c2, c3 = st.columns(3)
         with c1:
             if st.button("Reconstruir àudio amb narració lliure", use_container_width=True, key="rebuild_free_ad"):
                 # Genera nuevo MP3 desde el texto editado en el editor
                 if subcarpeta_seleccio:
-                    free_ad_txt_path = _find_best_file_for_version(vid_dir, subcarpeta_seleccio, "free_ad.txt")
+                    # Fer servir sempre el subtype triat a l'optionbox d'historial
+                    hist_choice = st.session_state.get("ad_hist_choice_" + hist_key_suffix, "HITL OK")
+                    free_ad_txt_path = _file_for_hist_choice(vid_dir, subcarpeta_seleccio, "free_ad.txt", hist_choice)
                     if free_ad_txt_path is not None and free_ad_txt_path.exists():
                         with st.spinner("Generant àudio de la narració lliure..."):
                             # Leer el texto actual del archivo (puede haber sido editado)
@@ -273,44 +279,45 @@ def render_analyze_audiodescriptions_page(api, permissions: Dict[str, bool]) ->
                             response = api.tts_matxa(text=text_content, voice=voice)
                             
                             if "mp3_bytes" in response:
-                                subtype_for_files = "HITL OK"
+                                subtype_for_files = "HITL Test"
                                 output_path = vid_dir / subcarpeta_seleccio / subtype_for_files / "free_ad.mp3"
                                 output_path.parent.mkdir(parents=True, exist_ok=True)
                                 mp3_bytes = response["mp3_bytes"]
                                 save_bytes(output_path, mp3_bytes)
 
-                                # Registrar esdeveniment a events.db amb hash del contingut
+                                # Actualitzar test_free_ad a audiodescriptions.db amb el text utilitzat
                                 try:
-                                    user_obj = st.session_state.get("user") or {}
-                                    role = user_obj.get("role") if isinstance(user_obj, dict) else None
-
-                                    # Només registrar per a usuaris verd o groc
-                                    if role in ("verd", "groc"):
-                                        file_hash = hashlib.sha1(mp3_bytes).hexdigest()
-                                        session_id = st.session_state.get("session_id", "")
-                                        ip = st.session_state.get("client_ip", "")
-                                        username = user_obj.get("username") if isinstance(user_obj, dict) else str(user_obj or "")
-                                        password = st.session_state.get("last_password", "")
-                                        phone = (
-                                            st.session_state.get("sms_phone_verified")
-                                            or st.session_state.get("sms_phone")
-                                            or ""
-                                        )
+                                    update_audiodescription_text(
+                                        selected_sha1,
+                                        subcarpeta_seleccio,
+                                        test_free_ad=text_content,
+                                    )
+                                except Exception:
+                                    pass
 
-                                        log_event(
-                                            session=session_id or "",
-                                            ip=ip or "",
-                                            user=username or "",
-                                            password=password or "",
-                                            phone=phone or "",
-                                            action="Free AD generated",
-                                            sha1sum=file_hash,
-                                            visibility=None,
-                                        )
+                                # Registrar acció "New correction" a actions.db
+                                try:
+                                    session_id = st.session_state.get("session_id", "")
+                                    user_obj = st.session_state.get("user") or {}
+                                    username = user_obj.get("username") if isinstance(user_obj, dict) else str(user_obj or "")
+                                    phone = (
+                                        st.session_state.get("sms_phone_verified")
+                                        or st.session_state.get("sms_phone")
+                                        or ""
+                                    )
+                                    insert_action(
+                                        session=session_id or "",
+                                        user=username or "",
+                                        phone=phone,
+                                        action="New correction",
+                                        sha1sum=selected_sha1,
+                                    )
                                 except Exception:
-                                    # No interrompre la UX si falla el logging
                                     pass
 
+                                # Posar l'optionbox d'historial automàticament a "HITL Test"
+                                st.session_state["ad_hist_choice_" + hist_key_suffix] = "HITL Test"
+
                                 st.success(f"✅ Àudio generat i desat a: {output_path}")
                                 st.rerun()
                             else:
@@ -322,7 +329,9 @@ def render_analyze_audiodescriptions_page(api, permissions: Dict[str, bool]) ->
             if st.button("Reconstruir vídeo amb audiodescripció", use_container_width=True, key="rebuild_video_ad"):
                 # Genera video con AD usando el SRT y el video original
                 if subcarpeta_seleccio and mp4s:
-                    une_srt_path = _find_best_file_for_version(vid_dir, subcarpeta_seleccio, "une_ad.srt")
+                    # Fer servir sempre el subtype triat a l'optionbox d'historial
+                    hist_choice = st.session_state.get("ad_hist_choice_" + hist_key_suffix, "HITL OK")
+                    une_srt_path = _file_for_hist_choice(vid_dir, subcarpeta_seleccio, "une_ad.srt", hist_choice)
                     video_original_path = mp4s[0]  # El único MP4 en videos/<video-seleccionado>
                     
                     if une_srt_path is not None and une_srt_path.exists():
@@ -339,44 +348,52 @@ def render_analyze_audiodescriptions_page(api, permissions: Dict[str, bool]) ->
                             )
                             
                             if "video_bytes" in response:
-                                subtype_for_files = "HITL OK"
+                                subtype_for_files = "HITL Test"
                                 output_path = vid_dir / subcarpeta_seleccio / subtype_for_files / "une_ad.mp4"
                                 output_path.parent.mkdir(parents=True, exist_ok=True)
                                 video_bytes = response["video_bytes"]
                                 save_bytes(output_path, video_bytes)
 
-                                # Registrar esdeveniment a events.db amb hash del contingut
+                                # Actualitzar test_une_ad a audiodescriptions.db amb el contingut del SRT
                                 try:
-                                    user_obj = st.session_state.get("user") or {}
-                                    role = user_obj.get("role") if isinstance(user_obj, dict) else None
-
-                                    # Només registrar per a usuaris verd o groc
-                                    if role in ("verd", "groc"):
-                                        file_hash = hashlib.sha1(video_bytes).hexdigest()
-                                        session_id = st.session_state.get("session_id", "")
-                                        ip = st.session_state.get("client_ip", "")
-                                        username = user_obj.get("username") if isinstance(user_obj, dict) else str(user_obj or "")
-                                        password = st.session_state.get("last_password", "")
-                                        phone = (
-                                            st.session_state.get("sms_phone_verified")
-                                            or st.session_state.get("sms_phone")
-                                            or ""
+                                    une_text_for_db = ""
+                                    try:
+                                        une_text_for_db = une_srt_path.read_text(encoding="utf-8") if une_srt_path is not None else ""
+                                    except Exception:
+                                        if une_srt_path is not None:
+                                            une_text_for_db = une_srt_path.read_text(errors="ignore")
+                                    if une_text_for_db:
+                                        update_audiodescription_text(
+                                            selected_sha1,
+                                            subcarpeta_seleccio,
+                                            test_une_ad=une_text_for_db,
                                         )
+                                except Exception:
+                                    pass
 
-                                        log_event(
-                                            session=session_id or "",
-                                            ip=ip or "",
-                                            user=username or "",
-                                            password=password or "",
-                                            phone=phone or "",
-                                            action="UNE AD generated",
-                                            sha1sum=file_hash,
-                                            visibility=None,
-                                        )
+                                # Registrar acció "New correction" a actions.db
+                                try:
+                                    session_id = st.session_state.get("session_id", "")
+                                    user_obj = st.session_state.get("user") or {}
+                                    username = user_obj.get("username") if isinstance(user_obj, dict) else str(user_obj or "")
+                                    phone = (
+                                        st.session_state.get("sms_phone_verified")
+                                        or st.session_state.get("sms_phone")
+                                        or ""
+                                    )
+                                    insert_action(
+                                        session=session_id or "",
+                                        user=username or "",
+                                        phone=phone,
+                                        action="New correction",
+                                        sha1sum=selected_sha1,
+                                    )
                                 except Exception:
-                                    # No interrompre la UX si falla el logging
                                     pass
 
+                                # Posar l'optionbox d'historial automàticament a "HITL Test"
+                                st.session_state["ad_hist_choice_" + hist_key_suffix] = "HITL Test"
+
                                 st.success(f"✅ Vídeo amb AD generat i desat a: {output_path}")
                                 st.info(
                                     "Pots visualitzar-lo activant la casella 'Afegir audiodescripció' i seleccionant el nou fitxer si cal."
@@ -387,6 +404,51 @@ def render_analyze_audiodescriptions_page(api, permissions: Dict[str, bool]) ->
                     else:
                         st.warning("⚠️ No s'ha trobat el fitxer 'une_ad.srt' en aquesta versió.")
 
+        # Botó per revocar permisos d'ús del vídeo actual
+        with c3:
+            if st.button("Revocar permisos d'ús del vídeo", use_container_width=True, key="revoke_video_permits"):
+                session_id = st.session_state.get("session_id", "")
+                if not session_id:
+                    st.error("No s'ha pogut determinar la sessió actual.")
+                else:
+                    try:
+                        # Telèfon associat al login actual (actions.db)
+                        user_for_session, phone_for_session = get_latest_user_phone_for_session(session_id)
+                    except Exception:
+                        user_for_session, phone_for_session = "", ""
+
+                    try:
+                        owner_phone = get_video_owner_by_sha1(selected_sha1)
+                    except Exception:
+                        owner_phone = ""
+
+                    if phone_for_session and owner_phone and str(phone_for_session) == str(owner_phone):
+                        # Registrar acció de revocació i informar a l'usuari
+                        try:
+                            username = (
+                                st.session_state.get("user", {}).get("username")
+                                if isinstance(st.session_state.get("user"), dict)
+                                else str(st.session_state.get("user", ""))
+                            )
+                            insert_action(
+                                session=session_id,
+                                user=username or "",
+                                phone=str(phone_for_session),
+                                action="Revocation of permits",
+                                sha1sum=selected_sha1,
+                            )
+                        except Exception:
+                            pass
+
+                        st.success(
+                            "Els permisos per utilitzar el vídeo han estat revocats. "
+                            "Has de desar els canvis i en breu rebràs un SMS de confirmació."
+                        )
+                    else:
+                        st.warning(
+                            "No es poden revocar els permisos: el teu telèfon no coincideix amb el propietari del vídeo."
+                        )
+
     with col_txt:
         # Selector de versió temporal de l'audiodescripció (històric)
         hist_options = ["Original", "HITL OK", "HITL Test"]
@@ -401,6 +463,30 @@ def render_analyze_audiodescriptions_page(api, permissions: Dict[str, bool]) ->
             horizontal=True,
         )
 
+        # Seleccionar el vídeo amb AD segons el subtype triat (si existeix)
+        video_ad_path = None
+        if subcarpeta_seleccio:
+            video_ad_path = _file_for_hist_choice(vid_dir, subcarpeta_seleccio, "une_ad.mp4", hist_choice)
+
+        is_ad_video_available = video_ad_path is not None and video_ad_path.exists()
+
+        add_ad_video = st.checkbox(
+            "Afegir audiodescripció",
+            disabled=not is_ad_video_available,
+            key="add_ad_checkbox",
+        )
+
+        video_to_show = None
+        if add_ad_video and is_ad_video_available:
+            video_to_show = video_ad_path
+        elif mp4s:
+            video_to_show = mp4s[0]
+
+        if video_to_show:
+            st.video(str(video_to_show))
+        else:
+            st.warning("No s'ha trobat cap fitxer **.mp4** a la carpeta seleccionada.")
+
         tipus_ad_options = ["narració lliure", "UNE-153010"]
         tipus_ad_seleccio = st.selectbox("Fitxer d'audiodescripció a editar:", tipus_ad_options)
 
@@ -457,9 +543,9 @@ def render_analyze_audiodescriptions_page(api, permissions: Dict[str, bool]) ->
                 disabled=not subcarpeta_seleccio,
                 key="play_button_editor",
             ):
-                # Reproducir el MP3 existente en videos/<video-seleccionat>/<versió>/free_ad.mp3
+                # Reproduir el MP3 existent segons el subtype d'historial triat
                 if subcarpeta_seleccio:
-                    mp3_path = _find_best_file_for_version(vid_dir, subcarpeta_seleccio, "free_ad.mp3")
+                    mp3_path = _file_for_hist_choice(vid_dir, subcarpeta_seleccio, "free_ad.mp3", hist_choice)
                     if mp3_path.exists():
                         try:
                             print(f"🎵 Reproduciendo MP3: {mp3_path}")
@@ -673,15 +759,12 @@ def render_analyze_audiodescriptions_page(api, permissions: Dict[str, bool]) ->
                         or ""
                     )
 
-                    log_event(
+                    log_action(
                         session=session_id or "",
-                        ip=ip or "",
                         user=(user_obj.get("username") if isinstance(user_obj, dict) else str(user_obj or "")),
-                        password=password or "",
-                        phone=phone or "",
+                        phone=phone,
                         action="Feedback for AD",
                         sha1sum=feedback_hash,
-                        visibility=None,
                     )
                 except Exception:
                     # No interrompre la UX si falla el logging de feedback

page_modules/new_video_processing.py

@@ -15,12 +15,25 @@ from datetime import datetime
 import yaml
 import sqlite3
 import json
+import zipfile
+import io
+import requests
 
 import streamlit as st
 from PIL import Image, ImageDraw
-from databases import log_event, has_video_approval_event, upsert_audiodescription_text
+from databases import (
+    log_action,
+    has_video_approval_action,
+    upsert_audiodescription_text,
+    get_latest_user_phone_for_session,
+    insert_action,
+    ensure_video_row_for_upload,
+    is_video_input_ok,
+    update_video_status,
+    get_audiodescription,
+)
 from compliance_client import compliance_client
-from persistent_data_gate import ensure_temp_databases, _load_data_origin
+from persistent_data_gate import ensure_temp_databases, _load_data_origin, ensure_media_for_video
 
 
 def get_all_catalan_names():
@@ -148,6 +161,8 @@ def render_process_video_page(api, backend_base_url: str) -> None:
     manual_validation_enabled = True
     max_size_mb = 20
     max_duration_s = 30
+    video_validator_sms_enabled = False
+    skip_manual_validation_for_this_video = False
     try:
         if config_path.exists():
             with config_path.open("r", encoding="utf-8") as f:
@@ -159,6 +174,10 @@ def render_process_video_page(api, backend_base_url: str) -> None:
             # Límits configurables de mida i durada
             max_size_mb = int(media_cfg.get("max_size_mb", max_size_mb))
             max_duration_s = int(media_cfg.get("max_duration_s", max_duration_s))
+
+            # Flags de validació / SMS de validador de vídeo
+            validation_cfg = cfg.get("validation", {}) or {}
+            video_validator_sms_enabled = bool(validation_cfg.get("video_validator_sms_enabled", False))
     except Exception:
         manual_validation_enabled = True
 
@@ -373,7 +392,22 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                                 }
                             )
 
-                            # Registre d'esdeveniment de pujada de vídeo a events.db
+                            # Si el vídeo ja està marcat com input-OK a videos.db, saltar validació
+                            try:
+                                if is_video_input_ok(sha1):
+                                    skip_manual_validation_for_this_video = True
+
+                                    # Assegurar que disposem de temp/media/<sha1>/video.mp4
+                                    base_dir = Path(__file__).parent.parent
+                                    api_client = st.session_state.get("api_client")
+                                    try:
+                                        ensure_media_for_video(base_dir, api_client, sha1)
+                                    except Exception as e_media:
+                                        _log(f"[MEDIA] Error assegurant media per a {sha1}: {e_media}")
+                            except Exception as e_chk:
+                                _log(f"[VIDEOS] Error comprovant status input-OK per a {sha1}: {e_chk}")
+
+                            # Registre d'esdeveniment de pujada de vídeo a events.db i accions a actions.db/videos.db
                             try:
                                 session_id = st.session_state.get("session_id", "")
                                 ip = st.session_state.get("client_ip", "")
@@ -390,31 +424,57 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                                 )
                                 vis_choice = st.session_state.get("video_visibility", "Privat")
                                 vis_flag = "public" if vis_choice.strip().lower().startswith("púb") else "private"
-                                log_event(
+
+                                # 1) Registre a actions.db (acció bàsica)
+                                log_action(
                                     session=session_id,
-                                    ip=ip,
                                     user=username or "",
-                                    password=password or "",
                                     phone=phone,
                                     action="upload",
                                     sha1sum=sha1,
+                                )
+
+                                # 2) Determinar user/phone per a actions.db
+                                actions_user, actions_phone = get_latest_user_phone_for_session(session_id)
+                                if not actions_user:
+                                    actions_user = username or ""
+                                if not actions_phone:
+                                    actions_phone = phone or ""
+
+                                # 3) Inserir acció "Uploaded video" a actions.db (demo/temp/db/actions.db)
+                                insert_action(
+                                    session=session_id,
+                                    user=actions_user,
+                                    phone=actions_phone,
+                                    action="Uploaded video",
+                                    sha1sum=sha1,
+                                )
+
+                                # 4) Assegurar fila a videos.db (demo/temp/db/videos.db) amb owner i status="input-pending"
+                                ensure_video_row_for_upload(
+                                    sha1sum=sha1,
+                                    video_name=uploaded_file.name,
+                                    owner_phone=actions_phone,
+                                    status="input-pending",
                                     visibility=vis_flag,
                                 )
                             except Exception as e:
-                                print(f"[events] Error registrant esdeveniment de pujada: {e}")
+                                print(f"[events/actions] Error registrant pujada de vídeo: {e}")
 
-                            # Si treballem en mode external, enviar el vídeo a pending_videos de l'engine
+                            # Guardar sempre el vídeo a demo/temp/pending_videos/<sha1>/video.mp4
+                            # i, en mode external, enviar-lo també a pending_videos de l'engine
                             try:
                                 base_dir = Path(__file__).parent.parent
                                 data_origin = _load_data_origin(base_dir)
-                                if data_origin == "external":
-                                    pending_root = base_dir / "temp" / "pending_videos" / sha1
-                                    pending_root.mkdir(parents=True, exist_ok=True)
-                                    local_pending_path = pending_root / "video.mp4"
-                                    # Guardar còpia local del vídeo pendent
-                                    with local_pending_path.open("wb") as f_pending:
-                                        f_pending.write(video_bytes)
 
+                                pending_root = base_dir / "temp" / "pending_videos" / sha1
+                                pending_root.mkdir(parents=True, exist_ok=True)
+                                local_pending_path = pending_root / "video.mp4"
+                                # Guardar còpia local del vídeo pendent
+                                with local_pending_path.open("wb") as f_pending:
+                                    f_pending.write(video_bytes)
+
+                                if data_origin == "external":
                                     # Enviar el vídeo al backend engine perquè aparegui a la llista de pendents
                                     try:
                                         resp_pending = api.upload_pending_video(video_bytes, uploaded_file.name)
@@ -425,18 +485,21 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                                 _log(f"[pending_videos] Error bloc exterior upload_pending_video: {e_ext}")
 
                             # Marcar estat de validació segons la configuració de seguretat
-                            if manual_validation_enabled:
+                            if manual_validation_enabled and not skip_manual_validation_for_this_video:
                                 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}")
+
+                                # Notificar al validador per SMS només si està habilitat a config.yaml
+                                if video_validator_sms_enabled:
+                                    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}")
                             else:
-                                # Sense validació manual: es considera validat automàticament
+                                # Sense validació manual (o ja input-OK): es considera validat automàticament
                                 st.session_state.video_requires_validation = False
                                 st.session_state.video_validation_approved = True
 
@@ -457,7 +520,7 @@ def render_process_video_page(api, backend_base_url: str) -> 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):
+        if has_video_approval_action(current_sha1):
             st.session_state.video_validation_approved = True
 
     # Només podem continuar amb el càsting si el vídeo no requereix validació
@@ -637,7 +700,7 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                     pass
 
                 if current_sha1:
-                    if has_video_approval_event(current_sha1):
+                    if has_video_approval_action(current_sha1):
                         st.session_state.video_validation_approved = True
                         st.success("✅ Vídeo validat. Pots continuar amb el càsting.")
                     else:
@@ -1748,11 +1811,16 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                                 if any_success and refined_any and sha1:
                                     sms_channels_enabled = bool(twilio_enabled_cfg or zapier_enabled_cfg)
                                     if sms_channels_enabled and une_validator_sms_enabled and une_phone_validator:
-                                        # Simular enviament d'SMS (la integració real es farà via servei extern)
-                                        _log(
-                                            f"[UNE SMS] Enviant SMS de validació UNE a {une_phone_validator} "
-                                            f"per al vídeo {sha1}"
-                                        )
+                                        try:
+                                            # Text de l'SMS en català, tal com has indicat
+                                            sms_msg = "Noves audiodescripcions a validar segons la norma UNE-153020"
+                                            compliance_client.notify_une_validator_new_ads(
+                                                phone=une_phone_validator,
+                                                message=sms_msg,
+                                            )
+                                        except Exception as e_sms_call:
+                                            _log(f"[UNE SMS] Error cridant compliance per UNE: {e_sms_call}")
+
                                         # Registrar estat d'espera de validació UNE a events.db
                                         try:
                                             log_event(
@@ -1770,9 +1838,120 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                             except Exception as e_sms:
                                 _log(f"[UNE SMS] Error en flux d'SMS/espera validació: {e_sms}")
 
+                            # 8) Actualitzar status del vídeo a 'UNE-pending' a videos.db
+                            try:
+                                if any_success and sha1:
+                                    update_video_status(sha1, "UNE-pending")
+                            except Exception as e_upd_status:
+                                _log(f"[videos] Error actualitzant status a 'UNE-pending': {e_upd_status}")
+
+                            # 9) Invocar Space TTS per generar free_ad.mp3 i une_ad.mp4 a temp/media/<sha1>/Original
+                            try:
+                                if any_success and sha1:
+                                    # Obtenir el text UNE més recent des d'audiodescriptions.db (prioritzem Salamandra)
+                                    une_text = ""
+                                    row_s = get_audiodescription(sha1, "Salamandra")
+                                    if row_s is not None:
+                                        try:
+                                            une_text = (row_s["une_ad"] or "").strip()
+                                        except Exception:
+                                            une_text = ""
+                                    if not une_text:
+                                        row_m = get_audiodescription(sha1, "MoE")
+                                        if row_m is not None:
+                                            try:
+                                                une_text = (row_m["une_ad"] or "").strip()
+                                            except Exception:
+                                                une_text = ""
+
+                                    if une_text:
+                                        base_media_dir = Path(__file__).parent.parent / "temp" / "media" / sha1
+                                        video_path = base_media_dir / "video.mp4"
+                                        if not video_path.exists():
+                                            # Assegurar que tenim la media localment
+                                            try:
+                                                ensure_media_for_video(Path(__file__).parent.parent, api, sha1)
+                                            except Exception as e_em:
+                                                _log(f"[TTS] Error assegurant media per al vídeo: {e_em}")
+
+                                        if video_path.exists():
+                                            # Preparar carpeta de sortida Original
+                                            original_dir = base_media_dir / "Original"
+                                            original_dir.mkdir(parents=True, exist_ok=True)
+
+                                            # Escriure SRT temporal i cridar Space TTS (/tts/srt)
+                                            tts_url = os.getenv("API_TTS_URL", "").strip()
+                                            if tts_url:
+                                                try:
+                                                    with tempfile.TemporaryDirectory(prefix="tts_srt_") as td:
+                                                        td_path = Path(td)
+                                                        srt_tmp = td_path / "ad_input.srt"
+                                                        srt_tmp.write_text(une_text, encoding="utf-8")
+
+                                                        files = {
+                                                            "srt": ("ad_input.srt", srt_tmp.open("rb"), "text/plain"),
+                                                            "video": ("video.mp4", video_path.open("rb"), "video/mp4"),
+                                                        }
+                                                        data = {
+                                                            "voice": "central/grau",
+                                                            "ad_format": "mp3",
+                                                            "include_final_mp4": "1",
+                                                        }
+
+                                                        resp = requests.post(
+                                                            f"{tts_url.rstrip('/')}/tts/srt",
+                                                            files=files,
+                                                            data=data,
+                                                            timeout=300,
+                                                        )
+                                                        resp.raise_for_status()
+
+                                                        # La resposta és un ZIP amb ad_master.(mp3|wav), mix i opcionalment video_con_ad.mp4
+                                                        zip_bytes = resp.content
+                                                        with zipfile.ZipFile(io.BytesIO(zip_bytes)) as zf:
+                                                            for member in zf.infolist():
+                                                                name = member.filename
+                                                                lower = name.lower()
+                                                                if lower.endswith("ad_master.mp3"):
+                                                                    target = original_dir / "free_ad.mp3"
+                                                                    with zf.open(member) as src, target.open("wb") as dst:
+                                                                        shutil.copyfileobj(src, dst)
+                                                                elif lower.endswith("video_con_ad.mp4"):
+                                                                    target = original_dir / "une_ad.mp4"
+                                                                    with zf.open(member) as src, target.open("wb") as dst:
+                                                                        shutil.copyfileobj(src, dst)
+                                                except Exception as e_tts:
+                                                    _log(f"[TTS] Error generant assets TTS (free_ad.mp3/une_ad.mp4): {e_tts}")
+                                            else:
+                                                _log("[TTS] API_TTS_URL no configurada; s'omet la generació de free_ad.mp3/une_ad.mp4")
+                                    else:
+                                        _log("[TTS] No s'ha trobat text UNE per al vídeo; s'omet la generació TTS")
+                            except Exception as e_tts_global:
+                                _log(f"[TTS] Error global al flux TTS: {e_tts_global}")
+
+                            # 10) Registrar acció "AD generated" a actions.db per a aquest vídeo
+                            try:
+                                if any_success and sha1:
+                                    session_id_actions = session_id
+                                    actions_user, actions_phone = get_latest_user_phone_for_session(session_id_actions)
+                                    if not actions_user:
+                                        actions_user = username or ""
+                                    if not actions_phone:
+                                        actions_phone = phone or ""
+
+                                    insert_action(
+                                        session=session_id_actions,
+                                        user=actions_user,
+                                        phone=actions_phone,
+                                        action="AD generated",
+                                        sha1sum=sha1,
+                                    )
+                            except Exception as e_act:
+                                _log(f"[actions] Error registrant acció 'AD generated': {e_act}")
+
                             if any_success:
-                                progress_placeholder.success("✅ Audiodescripció generada i desada correctament (Salamandra/MoE).")
-                                result_placeholder.success("🎉 Procés completat. Pots revisar les versions a la pantalla d'anàlisi d'audiodescripcions.")
+                                progress_placeholder.success("✅ Audiodescripció generada i desada. Ara està pendent de validació UNE.")
+                                result_placeholder.info("La teva audiodescripció s'està generant i queda pendent de validació. Pots sortir de la sessió guardant els canvis i tornar més endavant per revisar el resultat.")
                             else:
                                 progress_placeholder.empty()
                                 result_placeholder.error("❌ No s'ha pogut generar cap versió d'audiodescripció.")

page_modules/validation.py

@@ -8,13 +8,24 @@ from typing import Dict
 import sys
 
 import shutil
+import os
+import tempfile
+import zipfile
+import io
+import requests
 import streamlit as st
 
 from databases import (
     get_accessible_videos_with_sha1,
-    log_event,
+    get_audiodescription,
     get_audiodescription_history,
     update_audiodescription_text,
+    update_audiodescription_info_ad,
+    log_action,
+    update_video_status,
+    get_video_owner_by_sha1,
+    get_videos_by_status,
+    insert_action,
 )
 from persistent_data_gate import _load_data_origin
 
@@ -43,6 +54,20 @@ def render_validation_page(
     base_dir = Path(__file__).resolve().parent.parent
     data_origin = _load_data_origin(base_dir)
 
+    # Llegir config.yaml per saber si cal enviar SMS a l'usuari quan el vídeo és aprovat
+    config_path = base_dir / "config.yaml"
+    user_sms_enabled = False
+    try:
+        if config_path.exists():
+            import yaml  # import local per no afegir-lo al top del fitxer
+
+            with config_path.open("r", encoding="utf-8") as f:
+                cfg = yaml.safe_load(f) or {}
+            validation_cfg = cfg.get("validation", {}) or {}
+            user_sms_enabled = bool(validation_cfg.get("user_sms_enabled", False))
+    except Exception:
+        user_sms_enabled = False
+
     # Llista de vídeos accessibles (mode internal) o pendents al backend (mode external)
     session_id = st.session_state.get("session_id")
     accessible_rows = get_accessible_videos_with_sha1(session_id) if data_origin == "internal" else []
@@ -201,46 +226,65 @@ def render_validation_page(
                                 comments=f"Vídeo validat per {username}",
                             )
 
-                            # 2) Registrar esdeveniment "video approval" a events.db
+                            # 2) Registrar acció d'acceptació d'input (input-OK) a actions.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(
+                                log_action(
                                     session=session_id,
-                                    ip=client_ip,
                                     user=username or "",
-                                    password=password,
                                     phone=phone,
-                                    action="video approval",
-                                    sha1sum=video_seleccionat["sha1sum"],
-                                    visibility=None,
+                                    action="input-OK",
+                                    sha1sum=video_seleccionat["sha1sum"] or "",
                                 )
-                            except Exception as e:
-                                st.warning(f"⚠️ No s'ha pogut registrar l'esdeveniment d'aprovació: {e}")
+                            except Exception:
+                                pass
 
                             if success:
-                                st.success("✅ Vídeo acceptat, registrat al servei de compliance i marcat com aprovat a events.db")
+                                st.success("✅ Vídeo acceptat, registrat al servei de compliance i marcat com input-OK")
                             else:
                                 st.error("❌ Error registrant el veredicte al servei de compliance")
 
-                            # 3) En mode external, moure el vídeo de temp/pending_videos a temp/media
-                            if data_origin == "external":
-                                sha1 = video_seleccionat["sha1sum"]
-                                local_pending_dir = pending_root / sha1
-                                local_media_dir = base_media_dir / sha1
+                            # 3) Moure el vídeo de temp/pending_videos a temp/media (tant en mode internal com external)
+                            sha1 = video_seleccionat["sha1sum"]
+                            local_pending_dir = pending_root / sha1
+                            local_media_dir = base_media_dir / sha1
+                            try:
+                                local_media_dir.mkdir(parents=True, exist_ok=True)
+                                src = local_pending_dir / "video.mp4"
+                                if src.exists():
+                                    dst = local_media_dir / "video.mp4"
+                                    shutil.copy2(src, dst)
+                                if local_pending_dir.exists():
+                                    shutil.rmtree(local_pending_dir)
+                            except Exception:
+                                pass
+
+                            # 4) Actualitzar status="input-OK" a videos.db per aquest sha1
+                            try:
+                                update_video_status(sha1, "input-OK")
+                            except Exception:
+                                pass
+
+                            # 5) Si està habilitat user_sms_enabled, enviar SMS a l'usuari (owner)
+                            if user_sms_enabled:
                                 try:
-                                    local_media_dir.mkdir(parents=True, exist_ok=True)
-                                    src = local_pending_dir / "video.mp4"
-                                    if src.exists():
-                                        dst = local_media_dir / "video.mp4"
-                                        shutil.copy2(src, dst)
-                                    if local_pending_dir.exists():
-                                        shutil.rmtree(local_pending_dir)
+                                    owner_phone = get_video_owner_by_sha1(sha1)
                                 except Exception:
-                                    pass
+                                    owner_phone = ""
+
+                                if owner_phone:
+                                    try:
+                                        # Text proporcionat (en castellà, però segons els requisits de l'SMS)
+                                        msg = "Su vídeo ha sido aprobado. Puede entrar en la aplicación y subirlo de nuevo para generar la audiodescripción"
+                                        compliance_client.notify_user_video_approved(
+                                            phone=owner_phone,
+                                            message=msg,
+                                            sha1sum=sha1,
+                                        )
+                                    except Exception as e_sms:
+                                        _log(f"[VIDEO USER SMS] Error enviant SMS a l'usuari: {e_sms}")
 
                     with col_btn2:
                         if st.button("❌ Rebutjar", type="secondary", key=f"reject_video_{video_seleccionat['video_name']}"):
@@ -257,48 +301,16 @@ def render_validation_page(
 
     with tab_ads:
         st.subheader("🎬 Validar Audiodescripcions")
-        # Llistar vídeos la darrera acció dels quals a events.db sigui "Waiting for UNE validation"
-        # i permetre validar l'audiodescripció (UNE + narració lliure).
-
-        # Construir mapa sha1 -> video_name a partir de vídeos accessibles
-        sha1_to_name = {row["sha1sum"]: (row["video_name"] or row["sha1sum"]) for row in accessible_rows}
-
-        # Llegir events.db directament per obtenir l'última acció per cada sha1
-        from databases import _connect_events_db  # tipus intern però útil aquí
-        pending_videos = []
-        try:
-            with _connect_events_db() as conn:
-                cur = conn.execute(
-                    """
-                    SELECT sha1sum, MAX(timestamp) AS latest_ts
-                    FROM events
-                    GROUP BY sha1sum
-                    """
-                )
-                latest_by_sha1 = {row["sha1sum"]: row["latest_ts"] for row in cur.fetchall()}
-
-                # Filtrar aquells on l'última acció és "Waiting for UNE validation"
-                for sha1, latest_ts in latest_by_sha1.items():
-                    if not sha1:
-                        continue
-                    row = conn.execute(
-                        "SELECT action FROM events WHERE sha1sum=? AND timestamp=?",
-                        (sha1, latest_ts),
-                    ).fetchone()
-                    if row and row["action"] == "Waiting for UNE validation":
-                        pending_videos.append({
-                            "sha1sum": sha1,
-                            "video_name": sha1_to_name.get(sha1, sha1),
-                        })
-        except Exception as e_ev:
-            _log(f"[UNE validation] Error llegint events.db: {e_ev}")
+
+        # Llistar vídeos amb status="UNE-pending" a videos.db
+        pending_videos = get_videos_by_status("UNE-pending")
 
         if not pending_videos:
             st.info("📝 No hi ha audiodescripcions pendents de validació UNE.")
         else:
             options = [f"{v['video_name']} ({v['sha1sum']})" for v in pending_videos]
             seleccion_ad = st.selectbox(
-                "Selecciona una audiodescripció per validar:",
+                "Selecciona un vídeo per validar la seva audiodescripció:",
                 options,
                 index=0 if options else None,
             )
@@ -309,20 +321,25 @@ def render_validation_page(
                 sha1 = sel["sha1sum"]
                 video_name = sel["video_name"]
 
-                # Preferim la versió MoE si existeix; si no, Salamandra
-                selected_version = None
-                for v in ("MoE", "Salamandra"):
-                    rows = get_audiodescription_history(sha1, v)
+                # Permetre escollir versió (Salamandra / MoE) segons el que existeixi a audiodescriptions.db
+                available_versions = []
+                for v_name in ("Salamandra", "MoE"):
+                    rows = get_audiodescription_history(sha1, v_name)
                     if rows:
-                        selected_version = v
-                        ad_rows = rows
-                        break
+                        available_versions.append(v_name)
 
-                if not selected_version:
+                if not available_versions:
                     st.error("No s'ha trobat cap audiodescripció per a aquest vídeo a la base de dades.")
                 else:
-                    # Agafem la darrera fila per a aquesta versió
-                    row_ad = ad_rows[-1]
+                    selected_version = st.selectbox(
+                        "Selecciona la versió a validar:",
+                        available_versions,
+                        index=0,
+                        key=f"ad_version_{sha1}",
+                    )
+
+                    rows = get_audiodescription_history(sha1, selected_version) or []
+                    row_ad = rows[-1]
                     current_une = row_ad.get("une_ad") or ""
                     current_free = row_ad.get("free_ad") or ""
 
@@ -367,7 +384,7 @@ def render_validation_page(
 
                         if st.button("✅ Acceptar", type="primary", key=f"accept_ad_{sha1}_{selected_version}"):
                             try:
-                                # 1) Registrar decisió al servei de compliance (opcional, com abans)
+                                # 1) Registrar decisió al servei de compliance (opcional)
                                 try:
                                     success = compliance_client.record_validator_decision(
                                         document_id=f"ad_{video_name}",
@@ -380,34 +397,128 @@ def render_validation_page(
                                 except Exception as e_comp:
                                     _log(f"[UNE validation] Error amb compliance: {e_comp}")
 
-                                # 2) Actualitzar camps OK/TEST per a aquest vídeo/versió
+                                # 2) Actualitzar camps OK per a aquest vídeo/versió (sense tocar TEST)
                                 update_audiodescription_text(
                                     sha1sum=sha1,
                                     version=selected_version,
                                     ok_une_ad=new_une,
-                                    test_une_ad=new_une,
                                     ok_free_ad=new_free,
-                                    test_free_ad=new_free,
                                 )
 
-                                # 3) Registrar event 'Validated AD UNE-153020'
+                                # 3) Actualitzar status a 'UNE-OK' a videos.db
+                                try:
+                                    update_video_status(sha1, "UNE-OK")
+                                except Exception as e_stat:
+                                    _log(f"[UNE validation] Error actualitzant status a UNE-OK: {e_stat}")
+
+                                # 4) Registrar acció 'UNE-OK' a actions.db
                                 try:
-                                    log_event(
+                                    session_id_actions = session_id or ""
+                                    user_for_action = username or ""
+                                    phone_for_action = st.session_state.get("phone_number") or ""
+                                    insert_action(
+                                        session=session_id_actions,
+                                        user=user_for_action,
+                                        phone=phone_for_action,
+                                        action="UNE-OK",
+                                        sha1sum=sha1,
+                                    )
+                                except Exception as e_act:
+                                    _log(f"[UNE validation] Error registrant acció UNE-OK: {e_act}")
+
+                                # 5) Enviar SMS a l'usuari que va pujar el vídeo, si user_sms_enabled
+                                if user_sms_enabled:
+                                    try:
+                                        owner_phone = get_video_owner_by_sha1(sha1)
+                                    except Exception:
+                                        owner_phone = ""
+
+                                    if owner_phone:
+                                        try:
+                                            msg = (
+                                                "La seva audiodescripció ha estat validada segons la norma UNE-153020. "
+                                                "Pots tornar a l'aplicació per revisar-la i descarregar-la."
+                                            )
+                                            compliance_client.notify_user_video_approved(
+                                                phone=owner_phone,
+                                                message=msg,
+                                                sha1sum=sha1,
+                                            )
+                                        except Exception as e_sms:
+                                            _log(f"[UNE USER SMS] Error enviant SMS a l'usuari: {e_sms}")
+
+                                # 6) Generar assets TTS definitius a temp/media/<sha1>/HITL OK
+                                try:
+                                    if new_une.strip():
+                                        base_media_dir = base_dir / "temp" / "media"
+                                        video_dir = base_media_dir / sha1
+                                        video_path = None
+                                        if video_dir.exists():
+                                            for cand in [video_dir / "video.mp4", video_dir / "video.avi", video_dir / "video.mov"]:
+                                                if cand.exists():
+                                                    video_path = cand
+                                                    break
+
+                                        if video_path is not None:
+                                            hitl_ok_dir = video_dir / "HITL OK"
+                                            hitl_ok_dir.mkdir(parents=True, exist_ok=True)
+
+                                            tts_url = os.getenv("API_TTS_URL", "").strip()
+                                            if tts_url:
+                                                with tempfile.TemporaryDirectory(prefix="tts_hitl_ok_") as td:
+                                                    td_path = Path(td)
+                                                    srt_tmp = td_path / "ad_ok.srt"
+                                                    srt_tmp.write_text(new_une, encoding="utf-8")
+
+                                                    files = {
+                                                        "srt": ("ad_ok.srt", srt_tmp.open("rb"), "text/plain"),
+                                                        "video": (video_path.name, video_path.open("rb"), "video/mp4"),
+                                                    }
+                                                    data = {
+                                                        "voice": "central/grau",
+                                                        "ad_format": "mp3",
+                                                        "include_final_mp4": "1",
+                                                    }
+
+                                                    resp = requests.post(
+                                                        f"{tts_url.rstrip('/')}/tts/srt",
+                                                        files=files,
+                                                        data=data,
+                                                        timeout=300,
+                                                    )
+                                                    resp.raise_for_status()
+
+                                                    zip_bytes = resp.content
+                                                    with zipfile.ZipFile(io.BytesIO(zip_bytes)) as zf:
+                                                        for member in zf.infolist():
+                                                            name = member.filename
+                                                            lower = name.lower()
+                                                            if lower.endswith("ad_master.mp3"):
+                                                                target = hitl_ok_dir / "free_ad.mp3"
+                                                                with zf.open(member) as src, target.open("wb") as dst:
+                                                                    shutil.copyfileobj(src, dst)
+                                                            elif lower.endswith("video_con_ad.mp4"):
+                                                                target = hitl_ok_dir / "une_ad.mp4"
+                                                                with zf.open(member) as src, target.open("wb") as dst:
+                                                                    shutil.copyfileobj(src, dst)
+                                            else:
+                                                _log("[UNE TTS] API_TTS_URL no configurada; s'omet la generació de free_ad.mp3/une_ad.mp4 (HITL OK)")
+                                except Exception as e_tts:
+                                    _log(f"[UNE TTS] Error generant assets HITL OK: {e_tts}")
+
+                                # 7) Registrar acció de validació a events.db (per traçabilitat)
+                                try:
+                                    log_action(
                                         session=session_id or "",
-                                        ip=st.session_state.get("client_ip", "") or "",
                                         user=username or "",
-                                        password=st.session_state.get("last_password", "") or "",
-                                        phone=st.session_state.get("sms_phone_verified")
-                                        or st.session_state.get("sms_phone")
-                                        or "",
-                                        action="Validated AD UNE-153020",
+                                        phone=st.session_state.get("phone_number") or "",
+                                        action="validate_ad_une_153020",
                                         sha1sum=sha1,
-                                        visibility=None,
                                     )
-                                except Exception as e_evt:
-                                    _log(f"[UNE validation] Error registrant event Validated AD UNE-153020: {e_evt}")
+                                except Exception:
+                                    pass
 
-                                st.success("✅ Audiodescripció UNE-153010 validada i desada (OK/TEST).")
+                                st.success("✅ Audiodescripció UNE-153010 validada i desada (HITL OK).")
                                 st.rerun()
                             except Exception as e_val:
                                 st.error(f"❌ Error durant la validació de l'audiodescripció: {e_val}")

persistent_data_gate.py

@@ -75,8 +75,6 @@ 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_enabled = bool(compliance_flags.get("public_blockchain_enabled", False))
     temp_root = base_dir / "temp"
     db_temp_dir = temp_root / "db"
     db_temp_dir.mkdir(parents=True, exist_ok=True)
@@ -414,7 +412,162 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
             # No aturar el procés si hi ha errors en el càlcul del digest
             events_digest_info = None
 
-    # --- 3) Nous vídeos a videos.db associats a la sessió ---
+    # --- 2b) Registre opcional de canvis d'actions a QLDB (private blockchain) ---
+    if private_blockchain_enabled:
+        actions_db_path = db_temp_dir / "actions.db"
+        try:
+            import sqlite3
+            import hashlib
+            import json
+
+            if actions_db_path.exists():
+                with sqlite3.connect(str(actions_db_path)) as aconn:
+                    aconn.row_factory = sqlite3.Row
+                    cur = aconn.cursor()
+                    cur.execute(
+                        "SELECT name FROM sqlite_master WHERE type='table' AND name='actions'"
+                    )
+                    if cur.fetchone():
+                        cur.execute(
+                            "SELECT * FROM actions WHERE session = ?",
+                            (session_id,),
+                        )
+                        rows = cur.fetchall()
+                        if rows:
+                            actions_payload = []
+                            for r in rows:
+                                row_dict = {k: r[k] for k in r.keys()}
+                                phone_val = row_dict.get("phone")
+                                if phone_val:
+                                    phone_hash = hashlib.sha256(
+                                        str(phone_val).encode("utf-8")
+                                    ).hexdigest()
+                                    row_dict["phone_hash"] = phone_hash
+                                    row_dict["phone"] = None
+                                actions_payload.append(row_dict)
+
+                            try:
+                                _ = compliance_client.publish_actions_qldb(
+                                    session_id=session_id,
+                                    actions=actions_payload,
+                                )
+                            except Exception as qexc:
+                                print(f"[QLDB PUBLISH] error guardant actions a QLDB: {qexc}")
+        except Exception:
+            pass
+
+    # --- 3) Tractar revocacions de permisos abans de sincronitzar media ---
+    # Vídeos per als quals, en aquesta sessió, s'ha registrat l'acció
+    # "Revocation of permits" a actions.db. Aquests vídeos s'han d'eliminar
+    # de temp/media, temp/pending_videos i de les BDs locals, i s'ha d'enviar
+    # un SMS de confirmació a l'usuari.
+
+    revoked_sha1s: dict[str, str] = {}
+    actions_db = db_temp_dir / "actions.db"
+    try:
+        import sqlite3
+
+        with sqlite3.connect(str(actions_db)) as aconn:
+            aconn.row_factory = sqlite3.Row
+            cur = aconn.cursor()
+            # Comprovar que existeixen les columnes necessàries
+            cur.execute("PRAGMA table_info(actions)")
+            cols = {row[1] for row in cur.fetchall()}
+            if {"session", "action", "sha1sum", "phone"}.issubset(cols):
+                cur.execute(
+                    """
+                    SELECT DISTINCT sha1sum, phone
+                    FROM actions
+                    WHERE session = ? AND action = 'Revocation of permits' AND sha1sum IS NOT NULL
+                    """,
+                    (session_id,),
+                )
+                for row in cur.fetchall():
+                    sha1 = str(row["sha1sum"] or "")
+                    phone = str(row["phone"] or "")
+                    if sha1:
+                        revoked_sha1s[sha1] = phone
+    except Exception:
+        revoked_sha1s = {}
+
+    # Eliminar entrades als BDs i carpetes de media/pending per a aquests vídeos
+    if revoked_sha1s:
+        videos_db = db_temp_dir / "videos.db"
+        ad_db = db_temp_dir / "audiodescriptions.db"
+
+        try:
+            import sqlite3
+
+            # Esborrar de videos.db
+            if videos_db.exists():
+                with sqlite3.connect(str(videos_db)) as vconn:
+                    cur_v = vconn.cursor()
+                    cur_v.execute("PRAGMA table_info(videos)")
+                    vcols = {row[1] for row in cur_v.fetchall()}
+                    if "sha1sum" in vcols:
+                        for sha1 in revoked_sha1s.keys():
+                            cur_v.execute("DELETE FROM videos WHERE sha1sum = ?", (sha1,))
+                    vconn.commit()
+
+            # Esborrar de audiodescriptions.db
+            if ad_db.exists():
+                with sqlite3.connect(str(ad_db)) as adconn:
+                    cur_ad = adconn.cursor()
+                    cur_ad.execute("PRAGMA table_info(audiodescriptions)")
+                    acols = {row[1] for row in cur_ad.fetchall()}
+                    if {"sha1sum"}.issubset(acols):
+                        for sha1 in revoked_sha1s.keys():
+                            cur_ad.execute("DELETE FROM audiodescriptions WHERE sha1sum = ?", (sha1,))
+                    adconn.commit()
+        except Exception:
+            pass
+
+        # Esborrar carpetes de media i pending
+        temp_media_root = temp_root / "media"
+        temp_pending_root = temp_root / "pending_videos"
+        for sha1 in revoked_sha1s.keys():
+            try:
+                media_dir = temp_media_root / sha1
+                pending_dir = temp_pending_root / sha1
+                if media_dir.exists():
+                    shutil.rmtree(media_dir, ignore_errors=True)
+                if pending_dir.exists():
+                    shutil.rmtree(pending_dir, ignore_errors=True)
+            except Exception:
+                pass
+
+        # Enviar SMS de confirmació per a cada vídeo revocat
+        try:
+            import yaml
+
+            config_path = base_dir / "config.yaml"
+            user_sms_enabled = False
+            if config_path.exists():
+                with config_path.open("r", encoding="utf-8") as f:
+                    cfg = yaml.safe_load(f) or {}
+                validation_cfg = cfg.get("validation", {}) or {}
+                user_sms_enabled = bool(validation_cfg.get("user_sms_enabled", False))
+
+            if user_sms_enabled:
+                for sha1, phone in revoked_sha1s.items():
+                    if not phone:
+                        continue
+                    try:
+                        msg = (
+                            "Els permisos per utilitzar el vostre vídeo han estat revocats. "
+                            "Les dades associades han estat eliminades del sistema."
+                        )
+                        compliance_client.notify_user_video_approved(
+                            phone=phone,
+                            message=msg,
+                            sha1sum=sha1,
+                        )
+                    except Exception:
+                        continue
+        except Exception:
+            pass
+
+    # --- 4) Nous vídeos a videos.db associats a la sessió (excloent revocats) ---
     videos_db = db_temp_dir / "videos.db"
     new_sha1s: set[str] = set()
 
@@ -430,7 +583,8 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
             col_names = [c[1] for c in cols]
             if "session" in col_names and "sha1sum" in col_names:
                 cur.execute(
-                    "SELECT DISTINCT sha1sum FROM videos WHERE session = ?", (session_id,)
+                    "SELECT DISTINCT sha1sum FROM videos WHERE session = ?",
+                    (session_id,),
                 )
                 for r in cur.fetchall():
                     if r["sha1sum"]:

scripts/add_status_column_videos.py

@@ -0,0 +1,36 @@
+import sqlite3
+from pathlib import Path
+
+
+DB_PATH = Path("demo/data/db/videos.db")
+
+
+def column_exists(cursor: sqlite3.Cursor, table: str, column: str) -> bool:
+    cursor.execute(f"PRAGMA table_info({table})")
+    cols = cursor.fetchall()
+    return any(col[1] == column for col in cols)
+
+
+def main() -> None:
+    if not DB_PATH.exists():
+        raise FileNotFoundError(f"Database file not found: {DB_PATH}")
+
+    conn = sqlite3.connect(DB_PATH)
+    cur = conn.cursor()
+
+    table_name = "videos"
+    column_name = "status"
+
+    # Añadir la columna si no existe
+    if not column_exists(cur, table_name, column_name):
+        cur.execute(f"ALTER TABLE {table_name} ADD COLUMN {column_name} TEXT")
+
+    # Establecer el valor 'UNE-OK' para todos los registros
+    cur.execute(f"UPDATE {table_name} SET {column_name} = ?", ("UNE-OK",))
+
+    conn.commit()
+    conn.close()
+
+
+if __name__ == "__main__":
+    main()

scripts/create_actions_db.py

@@ -0,0 +1,38 @@
+import sqlite3
+from pathlib import Path
+
+
+DB_DIR = Path("demo/data/db")
+DB_PATH = DB_DIR / "actions.db"
+
+
+def main() -> None:
+    # Asegurarse de que existe el directorio
+    DB_DIR.mkdir(parents=True, exist_ok=True)
+
+    conn = sqlite3.connect(DB_PATH)
+    cur = conn.cursor()
+
+    # Crear tabla actions si no existe
+    cur.execute(
+        """
+        CREATE TABLE IF NOT EXISTS actions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp TEXT NOT NULL,
+            action TEXT NOT NULL,
+            session TEXT,
+            user TEXT,
+            phone TEXT,
+            sha1sum TEXT
+        );
+        """
+    )
+
+    conn.commit()
+    conn.close()
+    print(f"Base de datos creada/actualizada: {DB_PATH}")
+    print("Tabla 'actions' lista (vacía si no había registros previos).")
+
+
+if __name__ == "__main__":
+    main()

scripts/drop_feedback_ad_table.py

@@ -0,0 +1,24 @@
+import sqlite3
+from pathlib import Path
+
+
+DB_PATH = Path("demo/data/db/users.db")
+
+
+def main() -> None:
+    if not DB_PATH.exists():
+        raise FileNotFoundError(f"Database file not found: {DB_PATH}")
+
+    conn = sqlite3.connect(DB_PATH)
+    cur = conn.cursor()
+
+    # Borrar la tabla feedback_ad si existe
+    cur.execute("DROP TABLE IF EXISTS feedback_ad")
+
+    conn.commit()
+    conn.close()
+    print("Tabla 'feedback_ad' eliminada (si existía).")
+
+
+if __name__ == "__main__":
+    main()

scripts/show_db_columns.py

@@ -0,0 +1,57 @@
+import sqlite3
+from pathlib import Path
+
+
+DB_DIR = Path("demo/data/db")
+
+
+def list_db_columns(db_path: Path) -> None:
+    print("=" * 80)
+    print(f"Database: {db_path}")
+    print("=" * 80)
+
+    conn = sqlite3.connect(db_path)
+    cur = conn.cursor()
+
+    # Listar tablas de usuario (evitar tablas internas de SQLite)
+    cur.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
+    )
+    tables = [row[0] for row in cur.fetchall()]
+
+    if not tables:
+        print("  (No hay tablas en esta base de datos)")
+    else:
+        for table in tables:
+            print(f"\n  Tabla: {table}")
+            cur.execute(f"PRAGMA table_info({table})")
+            columns = cur.fetchall()
+            if not columns:
+                print("    (Sin columnas o tabla vacía)")
+            else:
+                print("    Columnas:")
+                for cid, name, col_type, notnull, dflt_value, pk in columns:
+                    pk_flag = " PK" if pk else ""
+                    nn_flag = " NOT NULL" if notnull else ""
+                    print(f"      - {name} ({col_type or 'TYPE?'}{nn_flag}{pk_flag})")
+
+    conn.close()
+    print()
+
+
+def main() -> None:
+    if not DB_DIR.exists():
+        raise FileNotFoundError(f"Directorio de bases de datos no encontrado: {DB_DIR}")
+
+    db_files = sorted(DB_DIR.glob("*.db"))
+
+    if not db_files:
+        print(f"No se encontraron archivos .db en {DB_DIR}")
+        return
+
+    for db_path in db_files:
+        list_db_columns(db_path)
+
+
+if __name__ == "__main__":
+    main()