Upload 10 files

app.py

@@ -14,7 +14,7 @@ from databases import set_db_path, init_schema, set_blockchain_enabled
 from api_client import APIClient
 from utils import ensure_dirs
 from auth import initialize_auth_system, render_login_form, render_sidebar, require_login
-from persistent_data_gate import ensure_temp_databases
+from persistent_data_gate import ensure_temp_databases, maybe_publish_monthly_actions_digest
 from mobile_verification import render_mobile_verification_screen, get_user_permissions
 from compliance_client import compliance_client
 from page_modules.new_video_processing import render_process_video_page
@@ -117,17 +117,14 @@ set_db_path(DB_PATH)
 # Configurar si els esdeveniments s'han de registrar a SQLite o a AWS QLDB
 set_blockchain_enabled(PRIVATE_BLOCKCHAIN_ENABLE)
 
-# Si està habilitat el registre públic i el digest mensual, publicar al
-# principi de cada mes un digest global via servei de compliance.
-if PUBLIC_BLOCKCHAIN_ENABLE and MONTHLY_DIGEST_ENABLED:
-    try:
-        today = datetime.utcnow().date()
-        if today.day == 1:
-            period = today.strftime("%Y-%m")
-            compliance_client.publish_monthly_digest(period)
-    except Exception:
-        # No bloquejar l'app per errors de blockchain/compliance
-        pass
+# Si està habilitat el registre públic i el digest mensual, publicar si cal
+# el digest mensual sobre actions.db (es calcula al voltant del mes anterior).
+maybe_publish_monthly_actions_digest(
+    base_dir,
+    compliance_client,
+    public_blockchain_enabled=PUBLIC_BLOCKCHAIN_ENABLE,
+    monthly_digest_enabled=MONTHLY_DIGEST_ENABLED,
+)
 
 init_schema()
 

compliance_client.py

@@ -569,9 +569,18 @@ class ComplianceClient:
     
     # === MÉTODOS DE BLOCKCHAIN (POLYGON) ===
     
-    def publish_monthly_digest(self, period: str) -> Optional[str]:
-        """Publica digest mensual en blockchain"""
-        response = self._make_request("POST", "/api/blockchain/publish-digest", {"period": period})
+    def publish_monthly_digest(self, period: str, digest_hash: str | None = None) -> Optional[str]:
+        """Publica digest mensual en blockchain.
+
+        Si digest_hash no és None, s'envia també al backend perquè el faci
+        servir com a arrel del digest mensual.
+        """
+
+        payload: Dict[str, Any] = {"period": period}
+        if digest_hash:
+            payload["digest_hash"] = digest_hash
+
+        response = self._make_request("POST", "/api/blockchain/publish-digest", payload)
         
         if response:
             tx_hash = response.get("transaction_hash")

databases.py

@@ -275,11 +275,11 @@ def get_accessible_videos_with_sha1(session_id: str | None) -> List[Dict[str, An
         # Ordenem per nom de vídeo per estabilitat
         return sorted(public_rows.values(), key=lambda r: (r["video_name"] or r["sha1sum"]))
 
-    # 2) Telèfons associats a la sessió actual
+    # 2) Telèfons associats a la sessió actual (a partir de 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"])
@@ -930,19 +930,6 @@ def insert_demo_feedback_row(
         )
 
 
-def _connect_events_db() -> sqlite3.Connection:
-    """Connexió directa a demo/temp/events.db.
-
-    Es fa independent de DEFAULT_DB_PATH per mantenir aquesta BD separada
-    de users.db, igual que feedback.db.
-    """
-
-    EVENTS_DB_PATH.parent.mkdir(parents=True, exist_ok=True)
-    conn = sqlite3.connect(str(EVENTS_DB_PATH))
-    conn.row_factory = sqlite3.Row
-    return conn
-
-
 def _connect_videos_db() -> sqlite3.Connection:
     """Connexió directa a demo/temp/videos.db.
 

mobile_verification.py

@@ -108,6 +108,28 @@ def send_sms_code(phone_number: str) -> bool:
                 log("[SMS] Error retornat per compliance en enviar l'SMS de login")
                 return False
 
+            # Registrar SMS de login a actions.db
+            try:
+                from databases import log_action
+
+                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 "")
+                )
+
+                log_action(
+                    session=session_id,
+                    user=username,
+                    phone=normalized_phone,
+                    action="SMS sent for login verification",
+                    sha1sum="",
+                )
+            except Exception:
+                pass
+
             return True
         except Exception as e:
             log(f"[SMS] Error generant/enviant codi via compliance: {e}")

page_modules/machine_room.py

@@ -182,3 +182,28 @@ def render_machine_room_page() -> None:
         _save_config(cfg)
         st.success("Configuració desada correctament. Reinicia la pàgina per veure els canvis aplicats.")
         st.experimental_rerun()
+
+    # Botons d'accions avançades a la part inferior de la pantalla
+    st.markdown("---")
+
+    # Estil bàsic per fer els botons secundaris de color taronja
+    st.markdown(
+        """
+        <style>
+        div[data-testid="baseButton-secondary"] button {
+            background-color: #f97316 !important;
+            border-color: #ea580c !important;
+            color: white !important;
+        }
+        </style>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    col_b1, col_b2, col_b3 = st.columns(3)
+    with col_b1:
+        st.button("Buïdar fitxers temporals", type="secondary", use_container_width=True)
+    with col_b2:
+        st.button("Reconstruir audiodescripcions", type="secondary", use_container_width=True)
+    with col_b3:
+        st.button("Reentrenar refinament", type="secondary", use_container_width=True)

page_modules/new_video_processing.py

@@ -492,10 +492,35 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                                 # Notificar al validador per SMS només si està habilitat a config.yaml
                                 if video_validator_sms_enabled:
                                     try:
-                                        compliance_client.notify_video_upload(
+                                        sms_ok = compliance_client.notify_video_upload(
                                             video_name=uploaded_file.name,
                                             sha1sum=sha1,
                                         )
+                                        if sms_ok:
+                                            try:
+                                                from databases import log_action
+
+                                                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 ""
+                                                )
+                                                log_action(
+                                                    session=session_id,
+                                                    user=username,
+                                                    phone=phone,
+                                                    action="SMS sent to video validator",
+                                                    sha1sum=sha1 or "",
+                                                )
+                                            except Exception:
+                                                pass
                                     except Exception as sms_exc:
                                         print(f"[VIDEO SMS] Error enviant notificació al validor: {sms_exc}")
                             else:
@@ -1814,27 +1839,39 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                                         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(
+                                            sms_ok = compliance_client.notify_une_validator_new_ads(
                                                 phone=une_phone_validator,
                                                 message=sms_msg,
                                             )
+                                            if sms_ok:
+                                                try:
+                                                    from databases import log_action
+
+                                                    log_action(
+                                                        session=session_id or "",
+                                                        user=username or "",
+                                                        phone=str(une_phone_validator or ""),
+                                                        action="SMS sent to UNE validator",
+                                                        sha1sum=sha1 or "",
+                                                    )
+                                                except Exception:
+                                                    pass
                                         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
+                                        # Registrar estat d'espera de validació UNE a actions.db
                                         try:
-                                            log_event(
-                                                session=session_id,
-                                                ip=ip,
+                                            from databases import log_action
+
+                                            log_action(
+                                                session=session_id or "",
                                                 user=username or "",
-                                                password=password or "",
-                                                phone=une_phone_validator,
+                                                phone=str(une_phone_validator or ""),
                                                 action="Waiting for UNE validation",
-                                                sha1sum=sha1,
-                                                visibility=vis_flag,
+                                                sha1sum=sha1 or "",
                                             )
                                         except Exception as e_evt_wait:
-                                            _log(f"[events] Error registrant Waiting for UNE validation: {e_evt_wait}")
+                                            _log(f"[actions] Error registrant Waiting for UNE validation: {e_evt_wait}")
                             except Exception as e_sms:
                                 _log(f"[UNE SMS] Error en flux d'SMS/espera validació: {e_sms}")
 

page_modules/validation.py

@@ -278,11 +278,25 @@ def render_validation_page(
                                     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(
+                                        sms_ok = compliance_client.notify_user_video_approved(
                                             phone=owner_phone,
                                             message=msg,
                                             sha1sum=sha1,
                                         )
+                                        if sms_ok:
+                                            try:
+                                                from databases import log_action
+
+                                                session_id = st.session_state.get("session_id", "")
+                                                log_action(
+                                                    session=session_id,
+                                                    user=username or "",
+                                                    phone=owner_phone,
+                                                    action="SMS sent to user for video approval",
+                                                    sha1sum=sha1 or "",
+                                                )
+                                            except Exception:
+                                                pass
                                     except Exception as e_sms:
                                         _log(f"[VIDEO USER SMS] Error enviant SMS a l'usuari: {e_sms}")
 

persistent_data_gate.py

@@ -109,7 +109,7 @@ def ensure_temp_databases(base_dir: Path, api_client) -> None:
     else:
         # Mode external: descarregar BDs del backend una sola vegada per sessió del servidor
         ext_marker = db_temp_dir / ".external_db_imported"
-        missing = [name for name in ("events.db", "feedback.db", "users.db", "videos.db") if not (db_temp_dir / name).exists()]
+        missing = [name for name in ("feedback.db", "users.db", "videos.db") if not (db_temp_dir / name).exists()]
 
         if ext_marker.exists() and not missing:
             return
@@ -136,6 +136,115 @@ def ensure_temp_databases(base_dir: Path, api_client) -> None:
             return
 
 
+def maybe_publish_monthly_actions_digest(
+    base_dir: Path,
+    compliance_client,
+    public_blockchain_enabled: bool,
+    monthly_digest_enabled: bool,
+) -> None:
+    """Publica, si cal, el digest mensual sobre actions.db a Polygon.
+
+    S'executa després de tenir demo/temp/db poblats. Calcula el hash de totes
+    les accions del mes anterior (segons camp timestamp) i, si encara no s'ha
+    registrat una acció "Monthly Digest sent to Polygon" amb aquest hash,
+    el publica via servei de compliance.
+    """
+
+    if not (public_blockchain_enabled and monthly_digest_enabled):
+        return
+
+    try:
+        from datetime import datetime, date
+        import sqlite3
+        import hashlib
+        import json
+
+        db_temp_dir = base_dir / "temp" / "db"
+        actions_db_path = db_temp_dir / "actions.db"
+        if not actions_db_path.exists():
+            return
+
+        today = datetime.utcnow().date()
+        # Període objectiu: mes anterior
+        if today.month == 1:
+            year = today.year - 1
+            month = 12
+        else:
+            year = today.year
+            month = today.month - 1
+
+        period = f"{year:04d}-{month:02d}"
+
+        # Rang de timestamps per al mes anterior
+        start_ts = f"{period}-01 00:00:00"
+        if month == 12:
+            next_year = year + 1
+            next_month = 1
+        else:
+            next_year = year
+            next_month = month + 1
+        end_period = f"{next_year:04d}-{next_month:02d}"
+        end_ts = f"{end_period}-01 00:00:00"
+
+        with sqlite3.connect(str(actions_db_path)) as conn:
+            conn.row_factory = sqlite3.Row
+            cur = conn.cursor()
+
+            # Assegurar que la taula actions existeix
+            cur.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name='actions'"
+            )
+            if not cur.fetchone():
+                return
+
+            # Llegir totes les accions del període
+            cur.execute(
+                "SELECT * FROM actions WHERE timestamp >= ? AND timestamp < ?",
+                (start_ts, end_ts),
+            )
+            rows = cur.fetchall()
+            if not rows:
+                return
+
+            payload: list[dict[str, Any]] = []
+            for r in rows:
+                payload.append({k: r[k] for k in r.keys()})
+
+            serialized = json.dumps(payload, sort_keys=True, separators=(",", ":"))
+            digest_hash = hashlib.sha256(serialized.encode("utf-8")).hexdigest()
+
+            # Comprovar si ja hem enregistrat aquest digest com enviat
+            cur.execute(
+                "SELECT 1 FROM actions WHERE action = 'Monthly Digest sent to Polygon' AND sha1sum = ? LIMIT 1",
+                (digest_hash,),
+            )
+            if cur.fetchone():
+                return
+
+        # Publicar via servei de compliance
+        try:
+            resp = compliance_client.publish_monthly_digest(period, digest_hash=digest_hash)
+            if resp:
+                try:
+                    from databases import log_action
+
+                    log_action(
+                        session="",  # digest global per període
+                        user="",
+                        phone="",
+                        action="Monthly Digest sent to Polygon",
+                        sha1sum=digest_hash,
+                    )
+                except Exception:
+                    pass
+        except Exception:
+            # No aturar el flux per errors de digest mensual
+            return
+    except Exception:
+        # No ha de bloquejar l'aplicació
+        return
+
+
 def _extract_zip_bytes(zip_bytes: bytes, target_dir: Path) -> None:
     target_dir.mkdir(parents=True, exist_ok=True)
     with zipfile.ZipFile(io.BytesIO(zip_bytes)) as zf:
@@ -349,26 +458,26 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
                                 # No aturar tot el procés per un error puntual
                                 continue
 
-    # --- 2) Digest d'esdeveniments per a la sessió (public blockchain) ---
+    # --- 2) Digest d'accions per a la sessió (public blockchain) ---
     events_digest_info = None
     if public_blockchain_enabled:
-        events_db = db_temp_dir / "events.db"
+        actions_db_path = db_temp_dir / "actions.db"
         try:
             import sqlite3
             import hashlib
             import json
 
-            with sqlite3.connect(str(events_db)) as econn:
-                econn.row_factory = sqlite3.Row
-                cur = econn.cursor()
+            with sqlite3.connect(str(actions_db_path)) as aconn:
+                aconn.row_factory = sqlite3.Row
+                cur = aconn.cursor()
 
-                # Comprovar que existeix la taula events
+                # Comprovar que existeix la taula actions
                 cur.execute(
-                    "SELECT name FROM sqlite_master WHERE type='table' AND name='events'"
+                    "SELECT name FROM sqlite_master WHERE type='table' AND name='actions'"
                 )
                 if cur.fetchone():
                     cur.execute(
-                        "SELECT * FROM events WHERE session = ?", (session_id,)
+                        "SELECT * FROM actions WHERE session = ?", (session_id,)
                     )
                     rows = cur.fetchall()
                     if rows:
@@ -399,6 +508,19 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
                                 print(
                                     f"[POLYGON PUBLISH] ok tx_hash={tx_hash} tx_url={tx_url}"
                                 )
+                                # Registrar publicació del digest a actions.db
+                                try:
+                                    from databases import log_action
+
+                                    log_action(
+                                        session=session_id or "",
+                                        user="",  # no tenim usuari explícit aquí
+                                        phone="",
+                                        action="Polygon events digest published",
+                                        sha1sum=digest_hash,
+                                    )
+                                except Exception:
+                                    pass
                             else:
                                 print("[POLYGON PUBLISH] error: resposta buida o nul·la")
                         except Exception as bexc:
@@ -549,6 +671,8 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
                 user_sms_enabled = bool(validation_cfg.get("user_sms_enabled", False))
 
             if user_sms_enabled:
+                from databases import log_action
+
                 for sha1, phone in revoked_sha1s.items():
                     if not phone:
                         continue
@@ -557,20 +681,27 @@ def confirm_changes_and_logout(base_dir: Path, api_client, session_id: str) -> N
                             "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(
+                        sms_ok = compliance_client.notify_user_video_approved(
                             phone=phone,
                             message=msg,
                             sha1sum=sha1,
                         )
+                        if sms_ok:
+                            try:
+                                log_action(
+                                    session=session_id or "",
+                                    user="",  # desconegut en aquest context
+                                    phone=phone,
+                                    action="SMS sent to user for video revocation",
+                                    sha1sum=sha1 or "",
+                                )
+                            except Exception:
+                                pass
                     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()
-
     try:
         import sqlite3