feat: implement streaming movie discovery and display functionality with new service, handlers, and UI components.

Your Name · Your Name · commit 369dd0c4393b · 2026-03-04T07:12:19.000+01:00
diff --git a/src/domain/services/mod.rs b/src/domain/services/mod.rs
@@ -14,6 +14,7 @@ pub mod mqtt_service;
 pub mod news_service;
 pub mod proxmox_service;
 pub mod slack_service;
+pub mod streaming_service;
 pub mod system_service;
 pub mod trivy_service;
 pub mod weather_service;
diff --git a/src/domain/services/streaming_service.rs b/src/domain/services/streaming_service.rs
@@ -0,0 +1,223 @@
+use aws_sdk_s3::Client as S3Client;
+use chrono::Utc;
+use reqwest::Client;
+use serde_json::{json, Value};
+
+const CACHE_PREFIX: &str = "streaming/";
+const BASE_URL: &str = "https://cinestream.info";
+
+pub async fn get_streaming_data() -> Result<Value, String> {
+    tracing::debug!("🎬 Streaming service: Attempting to get data from cache");
+
+    match get_aggregated_streaming().await {
+        Ok(data) if !data["items"].as_array().map(|a| a.is_empty()).unwrap_or(true) => {
+            tracing::info!("✅ Streaming cache HIT");
+            Ok(data)
+        }
+        _ => {
+            tracing::warn!("⚠️ Streaming cache MISS - fetching fresh data");
+            fetch_fresh_streaming().await
+        }
+    }
+}
+
+pub async fn force_refresh() -> Result<Value, String> {
+    fetch_fresh_streaming().await
+}
+
+async fn fetch_fresh_streaming() -> Result<Value, String> {
+    tracing::info!("🔄 Fetching fresh streaming movies from Cinestream...");
+
+    let client = Client::builder()
+        .timeout(std::time::Duration::from_secs(30))
+        .user_agent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36")
+        .build()
+        .map_err(|e| e.to_string())?;
+
+    let url = format!("{}/films-ajoutes-recemment/1", BASE_URL);
+    let response = client.get(url).send().await.map_err(|e| e.to_string())?;
+    
+    if !response.status().is_success() {
+        return Err(format!("Failed to fetch cinestream: HTTP {}", response.status()));
+    }
+
+    let html = response.text().await.map_err(|e| e.to_string())?;
+    let items = parse_cinestream_html(&html);
+
+    if items.is_empty() {
+        return Err("No movies parsed from cinestream".to_string());
+    }
+
+    let response_data = json!({
+        "items": items,
+        "cached_at": Utc::now().to_rfc3339()
+    });
+
+    // Cache the result in S3
+    if let Ok(s3_client) = create_s3_client().await {
+        let bucket = std::env::var("S3_BUCKET").unwrap_or_else(|_| "kusanagi".to_string());
+        let key = format!("{}latest.json", CACHE_PREFIX);
+        
+        let json_bytes = serde_json::to_vec(&response_data).unwrap_or_default();
+        
+        let _ = s3_client
+            .put_object()
+            .bucket(bucket)
+            .key(key)
+            .body(json_bytes.into())
+            .content_type("application/json")
+            .send()
+            .await;
+    }
+
+    Ok(json!({
+        "items": items,
+        "cached_at": Utc::now().to_rfc3339()
+    }))
+}
+
+fn parse_cinestream_html(html: &str) -> Vec<Value> {
+    let mut movies = Vec::new();
+    
+    // Cinestream uses a grid of <article> elements for movies
+    let mut current_pos = 0;
+    while let Some(article_start) = html[current_pos..].find("<article") {
+        let absolute_start = current_pos + article_start;
+        if let Some(article_end) = html[absolute_start..].find("</article>") {
+            let absolute_end = absolute_start + article_end + 10;
+            let article_content = &html[absolute_start..absolute_end];
+            
+            if let Some(movie) = parse_movie_article(article_content) {
+                movies.push(movie);
+            }
+            
+            current_pos = absolute_end;
+        } else {
+            break;
+        }
+    }
+    
+    movies
+}
+
+fn parse_movie_article(content: &str) -> Option<Value> {
+    // Extract title
+    let title = extract_simple_content(content, "text-lg text-foreground font-bold", "</span>")?;
+
+    // Extract URL
+    let url_start = content.find("href=\"")? + 6;
+    let url_end = content[url_start..].find("\"")?;
+    let path = &content[url_start..url_start + url_end];
+    let url = if path.starts_with("http") {
+        path.to_string()
+    } else {
+        format!("{}{}", BASE_URL, path)
+    };
+
+    // Extract Poster
+    let poster_url = if let Some(img_pos) = content.find("<img") {
+        if let Some(src_pos) = content[img_pos..].find("src=\"") {
+            let src_start = img_pos + src_pos + 5;
+            if let Some(src_end) = content[src_start..].find("\"") {
+                Some(content[src_start..src_start + src_end].replace("&amp;", "&"))
+            } else { None }
+        } else { None }
+    } else { None };
+
+    // Extract Year
+    let year = extract_simple_content(content, "text-muted-foreground\">", "</span>")
+        .unwrap_or_else(|| "N/A".to_string());
+
+    // Extract Genres
+    let genres = extract_simple_content(content, "truncate-multiline\">", "</span>")
+        .unwrap_or_else(|| "".to_string());
+
+    // Extract Language and Quality (Top badges)
+    // <div class="absolute top-1 left-1 ..."><span>TrueFrench</span></div>
+    // <div class="absolute top-1 right-1 ..."><span>HDLight</span></div>
+    
+    let mut language = "Unknown".to_string();
+    let mut quality = "HD".to_string();
+    
+    if let Some(lang_pos) = content.find("top-1 left-1") {
+        if let Some(span_pos) = content[lang_pos..].find("<span>") {
+            let start = lang_pos + span_pos + 6;
+            if let Some(end) = content[start..].find("</span>") {
+                language = content[start..start + end].to_string();
+            }
+        }
+    }
+    
+    if let Some(quality_pos) = content.find("top-1 right-1") {
+        if let Some(span_pos) = content[quality_pos..].find("<span>") {
+            let start = quality_pos + span_pos + 6;
+            if let Some(end) = content[start..].find("</span>") {
+                quality = content[start..start + end].to_string();
+            }
+        }
+    }
+
+    Some(json!({
+        "title": title,
+        "url": url,
+        "poster_url": poster_url,
+        "year": year,
+        "genres": genres,
+        "language": language,
+        "quality": quality,
+        "source": "Cinestream"
+    }))
+}
+
+fn extract_simple_content(html: &str, class_marker: &str, end_tag: &str) -> Option<String> {
+    if let Some(marker_pos) = html.find(class_marker) {
+        let content_start = marker_pos + class_marker.len();
+        // Skip > if we just searched for a class
+        let start = if html[content_start..].starts_with(">") {
+            content_start + 1
+        } else {
+            content_start
+        };
+        
+        if let Some(end_pos) = html[start..].find(end_tag) {
+            return Some(html[start..start + end_pos].trim().to_string());
+        }
+    }
+    None
+}
+
+async fn get_aggregated_streaming() -> Result<Value, String> {
+    let s3_client = create_s3_client().await?;
+    let bucket = std::env::var("S3_BUCKET").unwrap_or_else(|_| "kusanagi".to_string());
+    let key = format!("{}latest.json", CACHE_PREFIX);
+
+    let result = s3_client
+        .get_object()
+        .bucket(bucket)
+        .key(key)
+        .send()
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let body = result.body.collect().await.map_err(|e| e.to_string())?;
+    let val: Value = serde_json::from_slice(&body.into_bytes()).map_err(|e| e.to_string())?;
+    Ok(val)
+}
+
+async fn create_s3_client() -> Result<S3Client, String> {
+    let endpoint = std::env::var("S3_ENDPOINT").unwrap_or_else(|_| "http://192.168.0.170:9010".to_string());
+    let region = std::env::var("S3_REGION").unwrap_or_else(|_| "us-east-1".to_string());
+    let access_key = std::env::var("S3_ACCESS_KEY").map_err(|_| "S3_ACCESS_KEY not set".to_string())?;
+    let secret_key = std::env::var("S3_SECRET_KEY").map_err(|_| "S3_SECRET_KEY not set".to_string())?;
+
+    let credentials = aws_sdk_s3::config::Credentials::new(access_key, secret_key, None, None, "custom");
+    let s3_config = aws_sdk_s3::config::Builder::new()
+        .behavior_version(aws_sdk_s3::config::BehaviorVersion::latest())
+        .region(aws_sdk_s3::config::Region::new(region))
+        .endpoint_url(&endpoint)
+        .credentials_provider(credentials)
+        .force_path_style(true)
+        .build();
+
+    Ok(S3Client::from_conf(s3_config))
+}
diff --git a/src/interfaces/http/handlers/core/mod.rs b/src/interfaces/http/handlers/core/mod.rs
@@ -12,6 +12,7 @@ pub mod mcp;
 pub mod metrics;
 pub mod prometheus;
 pub mod slack;
+pub mod streaming;
 pub mod system;
 pub mod websocket;
 
@@ -26,5 +27,6 @@ pub use mcp::*;
 pub use metrics::metrics_handler as core_metrics_handler;
 pub use prometheus::*;
 pub use slack::*;
+pub use streaming::*;
 pub use system::*;
 pub use websocket::*;
diff --git a/src/interfaces/http/handlers/core/streaming.rs b/src/interfaces/http/handlers/core/streaming.rs
@@ -0,0 +1,31 @@
+use axum::{response::IntoResponse, Json};
+use serde_json::json;
+
+/// Streaming data endpoint
+pub async fn streaming() -> impl IntoResponse {
+    match crate::domain::services::streaming_service::get_streaming_data().await {
+        Ok(data) => Json(data).into_response(),
+        Err(e) => Json(json!({
+            "status": "error",
+            "message": e,
+            "items": []
+        }))
+        .into_response(),
+    }
+}
+
+/// Force refresh streaming data
+pub async fn streaming_refresh() -> impl IntoResponse {
+    match crate::domain::services::streaming_service::force_refresh().await {
+        Ok(data) => Json(json!({
+            "status": "success",
+            "message": "Streaming data refreshed",
+            "items": data["items"],
+            "cached_at": data["cached_at"]
+        })).into_response(),
+        Err(e) => Json(json!({
+            "status": "error",
+            "message": e
+        })).into_response(),
+    }
+}
diff --git a/src/interfaces/http/routes.rs b/src/interfaces/http/routes.rs
@@ -125,6 +125,8 @@ pub fn configure_routes(state: AppState) -> Router {
         .route("/api/argocd/sync", post(argocd_sync))
         .route("/api/news", get(news))
         .route("/api/news/refresh", post(news_refresh))
+        .route("/api/streaming", get(streaming))
+        .route("/api/streaming/refresh", post(streaming_refresh))
         // Kubernetes routes - canonical paths only
         // Use /api/k8s/* paths (not legacy /api/cluster/overview, /api/nodes/status, /api/pods/status)
         // Monitoring routes
diff --git a/static/index.html b/static/index.html
@@ -96,7 +96,8 @@
     <script src="/static/js/security.js?v={{VERSION}}"></script>
     <script src="/static/js/cilium-network.js?v={{VERSION}}"></script>
     <script src="/static/js/mqtt.js?v={{VERSION}}"></script>
-    <script src="/static/js/system.js?v={{VERSION}}"></script>
+    <script system src="/static/js/system.js?v={{VERSION}}"></script>
+    <script streaming src="/static/js/streaming.js?v={{VERSION}}"></script>
 
     <!-- Main Orchestrator -->
     <script src="/static/js/dashboard.js?v={{VERSION}}"></script>
@@ -277,6 +278,12 @@
                             <span class="nav-link-text">News</span>
                         </a>
                     </li>
+                    <li class="nav-item">
+                        <a class="nav-link" data-page="streaming" href="#streaming">
+                            <i class="mdi mdi-play-circle"></i>
+                            <span class="nav-link-text">Streaming</span>
+                        </a>
+                    </li>
                     <!-- Quotas moved to Metrics section -->
                     <li class="nav-item" id="pwa-install-item" style="display: none;">
                         <a class="nav-link" href="#" onclick="installPWA(); return false;">
@@ -500,6 +507,11 @@ <h2 class="section-title">ArgoCD Applications Status</h2>
                 <div class="loading">Loading...</div>
             </section>
 
+            <!-- Streaming Section -->
+            <section class="argocd-section tab-content" data-tab="streaming" style="display: none;">
+                <div class="loading">Loading...</div>
+            </section>
+
             <!-- Backups Section -->
             <section class="argocd-section tab-content" data-tab="backups" style="display: none;">
                 <h2 class="section-title">Tâches Planifiées</h2>
diff --git a/static/js/streaming.js b/static/js/streaming.js
diff --git a/static/js/tab-manager.js b/static/js/tab-manager.js
diff --git a/static/partials/streaming.html b/static/partials/streaming.html
