Approvers are told; oh run approve and oh run reject dc59d1b56c3d

/// Tell the people who may approve a job of `run` that has just become

/// ready (its dependencies all passed) and waits for them (oxygenflow#57).

/// Told once: the job's log notes it.

async fn tell_approvers(app: &Shared, row: &db::repos::RepoRow, run: &fdb::Run) {

    const TOLD: &str = "waiting for approval; the people who may approve were told";

    let Ok(jobs) = fdb::jobs(&app.db, run.id).await else { return };

    for job in jobs.iter().filter(|j| j.status == "queued" && j.approval == "waiting") {

        if !job.depends_on().iter().all(|d| jobs.iter().any(|j| &j.name == d && j.status == "passed")) {

            continue;

        }

        let already = fdb::log(&app.db, job.id, 0, 50).await.unwrap_or_default().iter().any(|l| l.text == TOLD);

        if already {

            continue;

        }

        let mut targets = Vec::new();

        for a in db::accounts::accounts(&app.db).await.unwrap_or_default().iter().filter(|a| !a.blocked()) {

            if may_decide(app, row, run, job, a).await.is_ok() {

                targets.push((a.id, db::notify::Reason::Participating));

            }

        }

        let record = flow_core::api::Record { t: 0, stream: "flow".into(), text: TOLD.into() };

        fdb::append_log(&app.db, job.id, &[record], MAX_RECORDS as i64).await.ok();

        let title = format!("{}/{} run #{}: {} waits for your approval", row.owner, row.name, run.number, job.name);

        let url = format!("/{}/{}/flow/{}", row.owner, row.name, run.number);

        crate::notify::tell(app, "flow.approval", &title, &url, &run.actor, Some(row.id), targets).await;

    }

}

    let some_passed = changed.iter().any(|j| j.status == "passed");

    }

    if some_passed {

        tell_approvers(app, &row, &run).await;

    // Those who may approve are told, once; the pusher (others-only) and

    // someone without the role are not.

    let told = |id: i64| {

        let db = h.app.db.clone();

        async move { db::notify::inbox(&db, id, 20).await.unwrap().into_iter().filter(|n| n.kind == "flow.approval").count() }

    };

    assert_eq!((told(carol.id).await, told(andy.id).await, told(bob.id).await), (1, 0, 0));

    assert_eq!(told(carol.id).await, 1, "told once");

    /// Approve a job that waits for a person (oxygenflow#57)

    Approve {

        number: i64,

        #[arg(long)]

        job: String,

    },

    /// Reject a job that waits for a person: it ends cancelled

    Reject {

        number: i64,

        #[arg(long)]

        job: String,

    },

}

/// `oh run approve|reject N --job NAME` (oxygenflow#57).

fn decide_job(c: &Client, base: &str, number: i64, job: &str, verb: &str, json: bool) -> Result<()> {

    let done: serde_json::Value = c.send("POST", &format!("{base}/flow/runs/{number}/jobs/{job}/{verb}"), &serde_json::json!({}))?;

    if json {

        println!("{done}");

    } else {

        println!("{} run #{number}: {}", ui::ok("✔"), done["said"].as_str().unwrap_or(""));

    }

    Ok(())

        RunCmd::Approve { number, job } => decide_job(c, &base, number, &job, "approve", json)?,

        RunCmd::Reject { number, job } => decide_job(c, &base, number, &job, "reject", json)?,