Upload 6 files

api_client.py

@@ -204,6 +204,49 @@ class APIClient:
             return {"error": str(e)}
 
 
+    # ---- Pending videos (peding_videos) ----
+
+    def upload_pending_video(self, video_bytes: bytes, filename: str) -> dict:
+        """Sube un vídeo pendiente al engine (carpeta /data/peding_videos).
+
+        Usa el endpoint POST /peding_videos/upload_peding_video.
+        """
+
+        url = f"{self.base_url}/peding_videos/upload_peding_video"
+        files = {"video": (filename, io.BytesIO(video_bytes), "video/mp4")}
+        try:
+            r = self.session.post(url, files=files, timeout=self.timeout * 5)
+            r.raise_for_status()
+            return r.json() if r.headers.get("content-type", "").startswith("application/json") else {"status": "ok"}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+
+    def list_pending_videos(self) -> dict:
+        """Llista els vídeos pendents al backend (endpoint GET /peding_videos/list_peding_videos)."""
+
+        url = f"{self.base_url}/peding_videos/list_peding_videos"
+        try:
+            r = self.session.get(url, timeout=self.timeout * 5)
+            r.raise_for_status()
+            return r.json()
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+
+    def download_pending_video(self, sha1sum: str) -> dict:
+        """Descarrega un vídeo pendent per sha1 (GET /peding_videos/download_peding_video)."""
+
+        url = f"{self.base_url}/peding_videos/download_peding_video"
+        params = {"sha1": sha1sum}
+        try:
+            r = self.session.get(url, params=params, timeout=self.timeout * 5)
+            r.raise_for_status()
+            return {"video_bytes": r.content}
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+
+
     def update_databases(self, payload: dict) -> dict:
         """Envia les sentències SQL generades a l'endpoint /update_databases."""
 

page_modules/process_video.py

@@ -15,7 +15,7 @@ import streamlit as st
 from PIL import Image, ImageDraw
 from databases import log_event, has_video_approval_event
 from compliance_client import compliance_client
-from persistent_data_gate import ensure_temp_databases
+from persistent_data_gate import ensure_temp_databases, _load_data_origin
 
 
 def get_all_catalan_names():
@@ -371,6 +371,26 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                             except Exception as e:
                                 print(f"[events] Error registrant esdeveniment de pujada: {e}")
 
+                            # Si treballem en mode external, enviar el vídeo 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)
+
+                                    # Enviar el vídeo al backend engine perquè aparegui a la llista de pendents
+                                    try:
+                                        api.upload_pending_video(video_bytes, uploaded_file.name)
+                                    except Exception:
+                                        pass
+                            except Exception:
+                                pass
+
                             # Marcar vídeo com pendent de validació i enviar SMS al validor
                             st.session_state.video_requires_validation = True
                             st.session_state.video_validation_approved = False

page_modules/validation.py

@@ -6,9 +6,11 @@ from datetime import datetime
 from pathlib import Path
 from typing import Dict
 
+import shutil
 import streamlit as st
 
 from databases import get_accessible_videos_with_sha1, log_event
+from persistent_data_gate import _load_data_origin
 
 
 def render_validation_page(
@@ -25,37 +27,88 @@ def render_validation_page(
 
     tab_videos, tab_ads = st.tabs(["📹 Validar Vídeos", "🎬 Validar Audiodescripcions"])
 
-    # Llista de vídeos accessibles des de demo/temp/videos.db
+    base_dir = Path(__file__).resolve().parent.parent
+    data_origin = _load_data_origin(base_dir)
+
+    # 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)
+    accessible_rows = get_accessible_videos_with_sha1(session_id) if data_origin == "internal" else []
 
-    # Base de media: demo/temp/media/<sha1sum>
-    base_media_dir = Path(__file__).resolve().parent.parent / "temp" / "media"
+    # Rutes base per a media i vídeos pendents
+    base_media_dir = base_dir / "temp" / "media"
+    pending_root = base_dir / "temp" / "pending_videos"
 
     with tab_videos:
         st.subheader("📹 Validar Vídeos Pujats")
 
         video_folders = []
-        for row in accessible_rows:
-            sha1 = row["sha1sum"]
-            video_name = row["video_name"] or row["sha1sum"]
-            folder = base_media_dir / sha1
-            if not folder.exists() or not folder.is_dir():
-                continue
-            video_files = list(folder.glob("*.mp4")) + list(folder.glob("*.avi")) + list(folder.glob("*.mov"))
-            if not video_files:
-                continue
-            mod_time = folder.stat().st_mtime
-            fecha = datetime.fromtimestamp(mod_time).strftime("%Y-%m-%d %H:%M")
-            video_folders.append(
-                {
-                    "sha1sum": sha1,
-                    "video_name": video_name,
-                    "path": str(folder),
-                    "created_at": fecha,
-                    "video_files": video_files,
-                }
-            )
+
+        if data_origin == "internal":
+            # Mode intern: llistar vídeos accessibles des de temp/media
+            for row in accessible_rows:
+                sha1 = row["sha1sum"]
+                video_name = row["video_name"] or row["sha1sum"]
+                folder = base_media_dir / sha1
+                if not folder.exists() or not folder.is_dir():
+                    continue
+                video_files = list(folder.glob("*.mp4")) + list(folder.glob("*.avi")) + list(folder.glob("*.mov"))
+                if not video_files:
+                    continue
+                mod_time = folder.stat().st_mtime
+                fecha = datetime.fromtimestamp(mod_time).strftime("%Y-%m-%d %H:%M")
+                video_folders.append(
+                    {
+                        "sha1sum": sha1,
+                        "video_name": video_name,
+                        "path": str(folder),
+                        "created_at": fecha,
+                        "video_files": video_files,
+                    }
+                )
+        else:
+            # Mode external: llistar vídeos pendents des de l'engine
+            api_client = st.session_state.get("api_client")
+            if api_client is not None:
+                try:
+                    resp = api_client.list_pending_videos()
+                except Exception:
+                    resp = {"error": "exception"}
+
+                pending_list = []
+                if isinstance(resp, dict) and not resp.get("error"):
+                    # Pot ser un dict amb clau "videos" o directament una llista
+                    if isinstance(resp.get("videos"), list):
+                        pending_list = resp["videos"]
+                    elif isinstance(resp.get("items"), list):
+                        pending_list = resp["items"]
+                    elif isinstance(resp.get("results"), list):
+                        pending_list = resp["results"]
+                    elif isinstance(resp, list):
+                        pending_list = resp
+                elif isinstance(resp, list):
+                    pending_list = resp
+
+                for item in pending_list:
+                    sha1 = item.get("sha1") or item.get("video_hash") or item.get("id")
+                    if not sha1:
+                        continue
+                    video_name = item.get("latest_video") or sha1
+                    # Carpeta local on descarregarem el vídeo pendent si cal
+                    folder = pending_root / sha1
+                    if folder.exists():
+                        video_files = list(folder.glob("*.mp4"))
+                    else:
+                        video_files = []
+                    created_at = item.get("created_at") or datetime.utcnow().strftime("%Y-%m-%d %H:%M")
+                    video_folders.append(
+                        {
+                            "sha1sum": sha1,
+                            "video_name": video_name,
+                            "path": str(folder),
+                            "created_at": created_at,
+                            "video_files": video_files,
+                        }
+                    )
 
         if not video_folders:
             st.info("📝 No hi ha vídeos pujats pendents de validació.")
@@ -79,6 +132,28 @@ def render_validation_page(
                     st.markdown(f"**Data:** {video_seleccionat['created_at']}")
                     st.markdown(f"**Arxius:** {len(video_seleccionat['video_files'])} vídeos trobats")
 
+                    # Assegurar que disposem del fitxer local en mode external
+                    if data_origin == "external" and not video_seleccionat["video_files"]:
+                        api_client = st.session_state.get("api_client")
+                        if api_client is not None:
+                            try:
+                                resp = api_client.download_pending_video(video_seleccionat["sha1sum"])
+                            except Exception:
+                                resp = {"error": "exception"}
+
+                            video_bytes = (
+                                resp.get("video_bytes")
+                                if isinstance(resp, dict)
+                                else None
+                            )
+                            if video_bytes:
+                                local_folder = pending_root / video_seleccionat["sha1sum"]
+                                local_folder.mkdir(parents=True, exist_ok=True)
+                                local_path = local_folder / "video.mp4"
+                                with local_path.open("wb") as f:
+                                    f.write(video_bytes)
+                                video_seleccionat["video_files"] = [local_path]
+
                     if video_seleccionat["video_files"]:
                         video_path = str(video_seleccionat["video_files"][0])
                         st.markdown("**Vídeo principal:**")
@@ -126,6 +201,22 @@ def render_validation_page(
                             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
+                                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
+
                     with col_btn2:
                         if st.button("❌ Rebutjar", type="secondary", key=f"reject_video_{video_seleccionat['video_name']}"):
                             success = compliance_client.record_validator_decision(