feat(application): wrapup generate/get/list use cases

crates/application/src/wrapup/commands.rs

@@ -0,0 +1,8 @@
+use chrono::NaiveDate;
+use uuid::Uuid;
+
+pub struct RequestWrapUpCommand {
+    pub user_id: Option<Uuid>,
+    pub start_date: NaiveDate,
+    pub end_date: NaiveDate,
+}

crates/application/src/wrapup/generate.rs

@@ -0,0 +1,47 @@
+use domain::errors::DomainError;
+use domain::events::DomainEvent;
+use domain::models::wrapup::WrapUpStatus;
+use domain::value_objects::{UserId, WrapUpId};
+
+use crate::context::AppContext;
+use crate::wrapup::commands::RequestWrapUpCommand;
+
+pub async fn execute(ctx: &AppContext, cmd: RequestWrapUpCommand) -> Result<WrapUpId, DomainError> {
+    let existing = ctx
+        .repos
+        .wrapup_repo
+        .find_existing(cmd.user_id, cmd.start_date, cmd.end_date)
+        .await?;
+
+    if let Some(ref rec) = existing {
+        if rec.status == WrapUpStatus::Ready || rec.status == WrapUpStatus::Generating {
+            return Ok(rec.id.clone());
+        }
+    }
+
+    let id = WrapUpId::generate();
+    let record = domain::models::wrapup::WrapUpRecord {
+        id: id.clone(),
+        user_id: cmd.user_id,
+        start_date: cmd.start_date,
+        end_date: cmd.end_date,
+        status: WrapUpStatus::Pending,
+        report_json: None,
+        error_message: None,
+        created_at: chrono::Utc::now().naive_utc(),
+        completed_at: None,
+    };
+    ctx.repos.wrapup_repo.create(&record).await?;
+
+    ctx.services
+        .event_publisher
+        .publish(&DomainEvent::WrapUpRequested {
+            wrapup_id: id.clone(),
+            user_id: cmd.user_id.map(UserId::from_uuid),
+            start_date: cmd.start_date,
+            end_date: cmd.end_date,
+        })
+        .await?;
+
+    Ok(id)
+}

crates/application/src/wrapup/get_wrapup.rs

@@ -0,0 +1,9 @@
+use domain::errors::DomainError;
+use domain::models::wrapup::WrapUpRecord;
+use domain::value_objects::WrapUpId;
+
+use crate::context::AppContext;
+
+pub async fn execute(ctx: &AppContext, id: WrapUpId) -> Result<Option<WrapUpRecord>, DomainError> {
+    ctx.repos.wrapup_repo.get_by_id(&id).await
+}

crates/application/src/wrapup/list_wrapups.rs

@@ -0,0 +1,20 @@
+use uuid::Uuid;
+
+use domain::errors::DomainError;
+use domain::models::wrapup::WrapUpRecord;
+
+use crate::context::AppContext;
+
+pub struct ListWrapUpsQuery {
+    pub user_id: Option<Uuid>,
+}
+
+pub async fn execute(
+    ctx: &AppContext,
+    query: ListWrapUpsQuery,
+) -> Result<Vec<WrapUpRecord>, DomainError> {
+    match query.user_id {
+        Some(uid) => ctx.repos.wrapup_repo.list_for_user(uid).await,
+        None => ctx.repos.wrapup_repo.list_global().await,
+    }
+}

crates/application/src/wrapup/mod.rs

@@ -1,2 +1,6 @@
+pub mod commands;
 pub mod compute;
+pub mod generate;
+pub mod get_wrapup;
+pub mod list_wrapups;
 pub mod queries;