forgetop-server 1.12.0

//! Write actions for the dashboard. Each resolves the capability-scoped source for a connection
//! and calls through to the provider — the same calls the TUI makes. All of these sit behind the
//! session-token auth layer (see `lib.rs`); the server binds localhost-only, so a merge or a
//! state change can't be triggered by another origin.

use std::sync::Arc;

use forgetop_core::domain::{ApprovalDecision, LineComment, Notification, NotificationDetail, ReviewVote};
use forgetop_core::provider::{ItemRef, MergeOptions, MergeStrategy, NotificationSource};
use forgetop_core::service::{ConfigService, SectionService};
use serde::Deserialize;

use crate::dto;

/// Why an action couldn't be performed: the connection/capability wasn't found (→ 404), or the
/// provider call itself failed (→ 502).
pub enum ActionError {
    NotFound,
    Failed(String),
}

fn failed(e: impl std::fmt::Display) -> ActionError {
    ActionError::Failed(e.to_string())
}

// ---- source resolvers ----
//
// Work-item and pipeline resolvers live in `dto` (shared with the read/detail endpoints);
// only the notification resolver is action-only.

async fn notif_source(sections: &SectionService, conn: &str) -> Option<Arc<dyn NotificationSource>> {
    sections.notification_feeds().await.ok()?.into_iter().find(|f| f.connection.connection_id() == conn).map(|f| f.source)
}

// ---- request bodies ----

#[derive(Deserialize)]
pub struct PrVoteReq {
    pub conn: String,
    pub id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    pub vote: ReviewVote,
}

#[derive(Deserialize)]
pub struct PrMergeReq {
    pub conn: String,
    pub id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    #[serde(default)]
    pub strategy: MergeStrategy,
    #[serde(default)]
    pub delete_source_ref: bool,
}

#[derive(Deserialize)]
pub struct PrRevertReq {
    pub conn: String,
    pub id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
}

#[derive(Deserialize)]
pub struct PrCommentReq {
    pub conn: String,
    pub id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    pub body: String,
}

#[derive(Deserialize)]
pub struct PrReplyReq {
    pub conn: String,
    pub id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    pub thread_id: String,
    pub body: String,
}

#[derive(Deserialize)]
pub struct PrReviewReq {
    pub conn: String,
    pub id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    pub event: ReviewVote,
    #[serde(default)]
    pub comments: Vec<LineComment>,
}

#[derive(Deserialize)]
pub struct PrResolveThreadReq {
    pub conn: String,
    pub id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    pub thread_id: String,
    /// `true` resolves the thread, `false` reopens it.
    pub resolved: bool,
}

#[derive(Deserialize)]
pub struct PrDraftReq {
    pub conn: String,
    pub id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    /// `true` converts to a draft, `false` marks it ready for review.
    pub draft: bool,
}

#[derive(Deserialize)]
pub struct PrClosedReq {
    pub conn: String,
    pub id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    /// `true` closes without merging, `false` reopens.
    pub closed: bool,
}

#[derive(Deserialize)]
pub struct PrRequestReviewerReq {
    pub conn: String,
    pub id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    /// The reviewer's id (from the reviewable-users list).
    pub user_id: String,
}

#[derive(Deserialize)]
pub struct WiStateReq {
    pub conn: String,
    pub id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    pub state: String,
}

#[derive(Deserialize)]
pub struct WiCommentReq {
    pub conn: String,
    pub id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    pub body: String,
}

#[derive(Deserialize)]
pub struct WiAssigneeReq {
    pub conn: String,
    pub id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    /// The chosen assignee's id (from the assignable-users list), or `None` to unassign.
    pub assignee_id: Option<String>,
}

#[derive(Deserialize)]
pub struct WiUpdateReq {
    pub conn: String,
    pub id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    pub title: Option<String>,
    pub description: Option<String>,
}

#[derive(Deserialize)]
pub struct PipelineApprovalReq {
    pub conn: String,
    pub run_id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    pub approval_id: String,
    pub decision: ApprovalDecision,
    #[serde(default)]
    pub comment: Option<String>,
}

#[derive(Deserialize)]
pub struct PipelineTriggerReq {
    pub conn: String,
    pub definition_id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    #[serde(default)]
    pub branch: Option<String>,
}

#[derive(Deserialize)]
pub struct PipelineCancelReq {
    pub conn: String,
    pub run_id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
}

#[derive(Deserialize)]
pub struct PipelineRerunReq {
    pub conn: String,
    pub run_id: String,
    /// The item's **connection-relative** repository. Optional: a single-repository connection
    /// still resolves without it, which is what keeps links written before this change working.
    #[serde(default)]
    pub repo: Option<String>,
    /// Re-run only the failed jobs (the provider must support it).
    #[serde(default)]
    pub failed_only: bool,
}

#[derive(Deserialize)]
pub struct NotifReadReq {
    pub conn: String,
    pub id: String,
}

/// Several notifications on one connection — a thread's members, for "mark read" and "done".
#[derive(Deserialize)]
pub struct NotifIdsReq {
    pub conn: String,
    pub ids: Vec<String>,
}

// ---- actions ----

pub async fn pr_vote(sections: &SectionService, req: PrVoteReq) -> Result<(), ActionError> {
    let source = dto::pr_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.vote(&ItemRef::maybe(req.repo, req.id), req.vote).await.map_err(failed)
}

pub async fn pr_merge(sections: &SectionService, req: PrMergeReq) -> Result<(), ActionError> {
    let source = dto::pr_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    let options = MergeOptions { strategy: req.strategy, delete_source_ref: req.delete_source_ref };
    source.merge(&ItemRef::maybe(req.repo, req.id), &options).await.map_err(failed)
}

pub async fn pr_revert(sections: &SectionService, req: PrRevertReq) -> Result<(), ActionError> {
    let source = dto::pr_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.revert(&ItemRef::maybe(req.repo, req.id)).await.map_err(failed)
}

pub async fn pr_comment(sections: &SectionService, req: PrCommentReq) -> Result<(), ActionError> {
    let source = dto::pr_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.add_comment(&ItemRef::maybe(req.repo, req.id), &req.body).await.map_err(failed)
}

pub async fn pr_reply(sections: &SectionService, req: PrReplyReq) -> Result<(), ActionError> {
    let source = dto::pr_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.reply_to_thread(&ItemRef::maybe(req.repo, req.id), &req.thread_id, &req.body).await.map_err(failed)
}

pub async fn pr_review(sections: &SectionService, req: PrReviewReq) -> Result<(), ActionError> {
    let source = dto::pr_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.submit_review(&ItemRef::maybe(req.repo, req.id), req.event, &req.comments).await.map_err(failed)
}

pub async fn pr_resolve_thread(sections: &SectionService, req: PrResolveThreadReq) -> Result<(), ActionError> {
    let source = dto::pr_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.resolve_thread(&ItemRef::maybe(req.repo, req.id), &req.thread_id, req.resolved).await.map_err(failed)
}

pub async fn pr_set_draft(sections: &SectionService, req: PrDraftReq) -> Result<(), ActionError> {
    let source = dto::pr_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.set_draft(&ItemRef::maybe(req.repo, req.id), req.draft).await.map_err(failed)
}

pub async fn pr_set_closed(sections: &SectionService, req: PrClosedReq) -> Result<(), ActionError> {
    let source = dto::pr_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.set_closed(&ItemRef::maybe(req.repo, req.id), req.closed).await.map_err(failed)
}

/// The people who can be asked to review a pull request (for the request-reviewer menu).
pub async fn pr_reviewers(sections: &SectionService, conn: &str, item: &ItemRef) -> Option<Vec<forgetop_core::domain::User>> {
    let source = dto::pr_source(sections, conn).await?;
    Some(source.reviewable_users(item).await.unwrap_or_default())
}

pub async fn pr_request_reviewer(sections: &SectionService, req: PrRequestReviewerReq) -> Result<(), ActionError> {
    let source = dto::pr_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.request_reviewer(&ItemRef::maybe(req.repo, req.id), &req.user_id).await.map_err(failed)
}

/// The states a work item can move to (for the transition menu).
pub async fn wi_states(sections: &SectionService, conn: &str, item: &ItemRef) -> Option<Vec<String>> {
    let source = dto::wi_source(sections, conn).await?;
    Some(source.available_states(item).await.unwrap_or_default())
}

pub async fn wi_set_state(sections: &SectionService, req: WiStateReq) -> Result<(), ActionError> {
    let source = dto::wi_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.set_state(&ItemRef::maybe(req.repo, req.id), &req.state).await.map_err(failed)
}

pub async fn wi_comment(sections: &SectionService, req: WiCommentReq) -> Result<(), ActionError> {
    let source = dto::wi_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.add_comment(&ItemRef::maybe(req.repo, req.id), &req.body).await.map_err(failed)
}

pub async fn wi_assignees(sections: &SectionService, conn: &str, item: &ItemRef) -> Option<Vec<forgetop_core::domain::User>> {
    let source = dto::wi_source(sections, conn).await?;
    Some(source.assignable_users(item).await.unwrap_or_default())
}

pub async fn wi_set_assignee(sections: &SectionService, req: WiAssigneeReq) -> Result<(), ActionError> {
    let source = dto::wi_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.set_assignee(&ItemRef::maybe(req.repo, req.id), req.assignee_id.as_deref()).await.map_err(failed)
}

pub async fn wi_update(sections: &SectionService, req: WiUpdateReq) -> Result<(), ActionError> {
    let source = dto::wi_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.update_fields(&ItemRef::maybe(req.repo, req.id), req.title.as_deref(), req.description.as_deref()).await.map_err(failed)
}

pub async fn pipeline_approval(sections: &SectionService, req: PipelineApprovalReq) -> Result<(), ActionError> {
    let source = dto::pipe_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.respond_approval(&ItemRef::maybe(req.repo, req.run_id), &req.approval_id, req.decision, req.comment.as_deref()).await.map_err(failed)
}

pub async fn pipeline_trigger(sections: &SectionService, req: PipelineTriggerReq) -> Result<(), ActionError> {
    let source = dto::pipe_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.trigger(&ItemRef::maybe(req.repo, req.definition_id), req.branch.as_deref()).await.map_err(failed)
}

pub async fn pipeline_cancel(sections: &SectionService, req: PipelineCancelReq) -> Result<(), ActionError> {
    let source = dto::pipe_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.cancel_run(&ItemRef::maybe(req.repo, req.run_id)).await.map_err(failed)
}

/// Re-runs a run. `Ok(Some(id))` is the new run's id when the provider started a separate run;
/// `Ok(None)` when the same run was re-queued as its next attempt.
pub async fn pipeline_rerun(sections: &SectionService, req: PipelineRerunReq) -> Result<Option<String>, ActionError> {
    let source = dto::pipe_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.rerun_run(&ItemRef::maybe(req.repo, req.run_id), req.failed_only).await.map_err(failed)
}

pub async fn notif_read(sections: &SectionService, req: NotifReadReq) -> Result<(), ActionError> {
    let source = notif_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    source.mark_read(&req.id).await.map_err(failed)
}

/// Marks each of `ids` read at the forge, best-effort: one failing doesn't stop the rest. Ids the
/// current rows already show as read are skipped (on GitHub every call counts against the hourly
/// budget). Fails only when every call it made failed.
pub async fn notif_read_many(sections: &SectionService, rows: &[dto::NotifRow], req: &NotifIdsReq) -> Result<(), ActionError> {
    let source = notif_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    let (mut tried, mut failed) = (0, 0);
    let mut first_error = None;
    for id in &req.ids {
        let known = rows.iter().find(|r| r.connection_id == req.conn && r.notification.id == *id);
        if known.is_some_and(|r| !r.notification.unread) {
            continue;
        }
        tried += 1;
        if let Err(e) = source.mark_read(id).await {
            failed += 1;
            first_error.get_or_insert(e.to_string());
        }
    }
    match first_error {
        Some(e) if failed == tried => Err(ActionError::Failed(e)),
        _ => Ok(()),
    }
}

/// "Done" on a thread: its members are marked done at the forge, then dismissed locally under the
/// key the TUI uses, merged into the saved list so neither frontend drops the other's. Ids the
/// current rows don't know are marked done but not dismissed — there is no `updated_at` to key
/// them by.
pub async fn notif_done(sections: &SectionService, config: &ConfigService, rows: &[dto::NotifRow], req: &NotifIdsReq) -> Result<(), ActionError> {
    // Every id, read or not: done is the forge's own "done" (GitHub mark-as-done, GitLab's
    // to-do done) — a read notification stays listed until this. Best-effort per id, failing
    // only when every call failed.
    let source = notif_source(sections, &req.conn).await.ok_or(ActionError::NotFound)?;
    let mut first_error = None;
    let mut misses = 0;
    for id in &req.ids {
        if let Err(e) = source.mark_done(id).await {
            misses += 1;
            first_error.get_or_insert(e.to_string());
        }
    }
    if let Some(e) = first_error.filter(|_| misses == req.ids.len()) {
        return Err(ActionError::Failed(e));
    }
    let keys: Vec<String> = req
        .ids
        .iter()
        .filter_map(|id| rows.iter().find(|r| r.connection_id == req.conn && r.notification.id == *id))
        .map(|r| r.dismiss_key.clone())
        .collect();
    config.dismiss_notifications(keys).await.map_err(failed)
}

/// The actor and excerpt of one notification its feed entry left out (GitHub's latest comment).
pub async fn notif_detail(sections: &SectionService, conn: &str, n: &Notification) -> Result<NotificationDetail, ActionError> {
    let source = notif_source(sections, conn).await.ok_or(ActionError::NotFound)?;
    source.detail(n).await.map_err(failed)
}