Create Insight Generation Feature

Added integration with Messages API and Ollama

src/ai/handlers.rs

@@ -0,0 +1,154 @@
+use actix_web::{HttpResponse, Responder, delete, get, post, web};
+use serde::{Deserialize, Serialize};
+
+use crate::ai::InsightGenerator;
+use crate::data::Claims;
+use crate::database::InsightDao;
+
+#[derive(Debug, Deserialize)]
+pub struct GeneratePhotoInsightRequest {
+    pub file_path: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct GetPhotoInsightQuery {
+    pub path: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct PhotoInsightResponse {
+    pub id: i32,
+    pub file_path: String,
+    pub title: String,
+    pub summary: String,
+    pub generated_at: i64,
+    pub model_version: String,
+}
+
+/// POST /insights/generate - Generate insight for a specific photo
+#[post("/insights/generate")]
+pub async fn generate_insight_handler(
+    _claims: Claims,
+    request: web::Json<GeneratePhotoInsightRequest>,
+    insight_generator: web::Data<InsightGenerator>,
+) -> impl Responder {
+    log::info!(
+        "Manual insight generation triggered for photo: {}",
+        request.file_path
+    );
+
+    // Generate insight
+    match insight_generator
+        .generate_insight_for_photo(&request.file_path)
+        .await
+    {
+        Ok(()) => HttpResponse::Ok().json(serde_json::json!({
+            "success": true,
+            "message": "Insight generated successfully"
+        })),
+        Err(e) => {
+            log::error!("Failed to generate insight: {:?}", e);
+            HttpResponse::InternalServerError().json(serde_json::json!({
+                "error": format!("Failed to generate insight: {:?}", e)
+            }))
+        }
+    }
+}
+
+/// GET /insights?path=/path/to/photo.jpg - Fetch insight for specific photo
+#[get("/insights")]
+pub async fn get_insight_handler(
+    _claims: Claims,
+    query: web::Query<GetPhotoInsightQuery>,
+    insight_dao: web::Data<std::sync::Mutex<Box<dyn InsightDao>>>,
+) -> impl Responder {
+    log::debug!("Fetching insight for {}", query.path);
+
+    let otel_context = opentelemetry::Context::new();
+    let mut dao = insight_dao.lock().expect("Unable to lock InsightDao");
+
+    match dao.get_insight(&otel_context, &query.path) {
+        Ok(Some(insight)) => {
+            let response = PhotoInsightResponse {
+                id: insight.id,
+                file_path: insight.file_path,
+                title: insight.title,
+                summary: insight.summary,
+                generated_at: insight.generated_at,
+                model_version: insight.model_version,
+            };
+            HttpResponse::Ok().json(response)
+        }
+        Ok(None) => HttpResponse::NotFound().json(serde_json::json!({
+            "error": "Insight not found"
+        })),
+        Err(e) => {
+            log::error!("Failed to fetch insight ({}): {:?}", &query.path, e);
+            HttpResponse::InternalServerError().json(serde_json::json!({
+                "error": format!("Failed to fetch insight: {:?}", e)
+            }))
+        }
+    }
+}
+
+/// DELETE /insights?path=/path/to/photo.jpg - Remove insight (will regenerate on next request)
+#[delete("/insights")]
+pub async fn delete_insight_handler(
+    _claims: Claims,
+    query: web::Query<GetPhotoInsightQuery>,
+    insight_dao: web::Data<std::sync::Mutex<Box<dyn InsightDao>>>,
+) -> impl Responder {
+    log::info!("Deleting insight for {}", query.path);
+
+    let otel_context = opentelemetry::Context::new();
+    let mut dao = insight_dao.lock().expect("Unable to lock InsightDao");
+
+    match dao.delete_insight(&otel_context, &query.path) {
+        Ok(()) => HttpResponse::Ok().json(serde_json::json!({
+            "success": true,
+            "message": "Insight deleted successfully"
+        })),
+        Err(e) => {
+            log::error!("Failed to delete insight: {:?}", e);
+            HttpResponse::InternalServerError().json(serde_json::json!({
+                "error": format!("Failed to delete insight: {:?}", e)
+            }))
+        }
+    }
+}
+
+/// GET /insights/all - Get all insights
+#[get("/insights/all")]
+pub async fn get_all_insights_handler(
+    _claims: Claims,
+    insight_dao: web::Data<std::sync::Mutex<Box<dyn InsightDao>>>,
+) -> impl Responder {
+    log::debug!("Fetching all insights");
+
+    let otel_context = opentelemetry::Context::new();
+    let mut dao = insight_dao.lock().expect("Unable to lock InsightDao");
+
+    match dao.get_all_insights(&otel_context) {
+        Ok(insights) => {
+            let responses: Vec<PhotoInsightResponse> = insights
+                .into_iter()
+                .map(|insight| PhotoInsightResponse {
+                    id: insight.id,
+                    file_path: insight.file_path,
+                    title: insight.title,
+                    summary: insight.summary,
+                    generated_at: insight.generated_at,
+                    model_version: insight.model_version,
+                })
+                .collect();
+
+            HttpResponse::Ok().json(responses)
+        }
+        Err(e) => {
+            log::error!("Failed to fetch all insights: {:?}", e);
+            HttpResponse::InternalServerError().json(serde_json::json!({
+                "error": format!("Failed to fetch insights: {:?}", e)
+            }))
+        }
+    }
+}