Close and reopen a proposal through the API and oh 71e65fcf95ab

    /// `closed` or `open` (reopen), by its author or with triage access,

    /// as the page's Close and Reopen do (oxygenhub#140).

    #[serde(default, skip_serializing_if = "Option::is_none")]

    pub state: Option<String>,

  state?: string | null;

  owner?: string | null;

  placed?: string;

    if let Some(want) = body.state.as_deref() {

        if Some(me.id) != p.author_id && role < Role::Triage {

            return Err(ApiError(

                StatusCode::FORBIDDEN,

                "only the proposal's author or someone with triage access can close or reopen it".into(),

            ));

        }

        let new_state = match (want, p.state.as_str()) {

            ("closed", "open" | "draft") => "closed",

            ("open", "closed") => "open",

            (w, now) if w == now => now,

            ("closed" | "open", now) => {

                return Err(ApiError(StatusCode::CONFLICT, format!("a proposal that is {now} cannot become {want}")))

            }

            _ => return Err(ApiError(StatusCode::BAD_REQUEST, "state is closed or open".into())),

        };

        if new_state != p.state {

            db::proposals::set_state(&app.db, p.id, new_state, "").await?;

            db::proposals::add_event(&app.db, p.id, &me.username, new_state, "").await.ok();

            crate::hooks::emit(&app, &row, &format!("proposal.{new_state}"), &me.username, serde_json::json!({ "number": number })).await;

        }

    }

/// #140: a proposal is closed and reopened through the API, as the page's

/// buttons do, by its author or someone with triage access.

#[tokio::test(flavor = "multi_thread")]

async fn a_proposal_is_closed_and_reopened_through_the_api() {

    let h = hub().await;

    let app = &h.app;

    let andy = register(app, "andy").await;

    let repo = RepoName::parse("andy/demo").unwrap();

    app.repos.create(&repo, None).unwrap();

    db::repos::create(&app.db, "andy", "demo", "", hub_api::Visibility::Public).await.unwrap();

    let work = tempfile::tempdir().unwrap();

    let mut client = Repo::init(work.path()).unwrap();

    client.create_identity("Andy McCall", "[email protected]", oxy_core::repo::IdentityScope::User).unwrap();

    client.config.set("remote.origin.url", &format!("{}/andy/demo", h.base)).unwrap();

    client.config.set("remote.origin.token", "site").unwrap();

    client.save_config().unwrap();

    write(work.path(), "a.txt", b"one\n");

    client.snapshot("t").unwrap();

    let base = client.commit("base", &[]).unwrap();

    assert!(client.push("origin", false).unwrap().iter().all(|r| r.ok));

    client.bookmark_create("feature", Some(&[base])).unwrap();

    client.bookmark_switch("feature", false).unwrap();

    write(work.path(), "a.txt", b"one\ntwo\n");

    client.snapshot("t").unwrap();

    client.commit("add two", &[]).unwrap();

    assert!(client.push_bookmark("origin", "feature", false).unwrap().iter().all(|r| r.ok));

    let preview = get(app, "/andy/demo/proposals/new?source=feature&target=main", Some(&andy)).await;

    let csrf = csrf_of(&preview.body);

    let r = post(app, "/andy/demo/proposals/new", Some(&andy), &format!("_csrf={csrf}&title=Two&body=&target=main&source=feature")).await;

    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);

    let patch = |json: &'static str, bearer: Option<&'static str>| async move {

        let mut req =

            Request::builder().method("PATCH").uri("/api/v1/repos/andy/demo/proposals/1").header(header::CONTENT_TYPE, "application/json");

        if let Some(b) = bearer {

            req = req.header(header::AUTHORIZATION, format!("Bearer {b}"));

        }

        let res = oxygenhub::router(app.clone()).oneshot(req.body(Body::from(json)).unwrap()).await.unwrap();

        let st = res.status();

        (st, String::from_utf8_lossy(&res.into_body().collect().await.unwrap().to_bytes()).into_owned())

    };

    let state = || async { db::proposals::get(&app.db, 1, 1).await.unwrap().unwrap().state };

    // The site token acts for the first administrator, andy.

    let (st, body) = patch(r#"{"state":"closed"}"#, Some("site")).await;

    assert_eq!(st, StatusCode::OK, "{body}");

    assert_eq!(state().await, "closed");

    assert_eq!(patch(r#"{"state":"closed"}"#, Some("site")).await.0, StatusCode::OK, "closing a closed proposal changes nothing");

    let (st, _) = patch(r#"{"state":"open"}"#, Some("site")).await;

    assert_eq!(st, StatusCode::OK);

    assert_eq!(state().await, "open");

    assert_eq!(patch(r#"{"state":"landed"}"#, Some("site")).await.0, StatusCode::BAD_REQUEST, "landing has its own endpoint");

    assert_ne!(patch(r#"{"state":"closed"}"#, None).await.0, StatusCode::OK, "not without a token");

    assert_eq!(state().await, "open");

}

    /// Close a proposal without landing it, with an optional comment

    Close {

        number: i64,

        /// Say why, as a comment before it closes

        #[arg(long, short = 'm')]

        message: Option<String>,

    },

    /// Reopen a closed proposal

    Reopen { number: i64 },

            let edit = hub_api::ProposalEdit { title, body, labels: None, state: None };

            }

        }

        ProposalCmd::Close { number, message } => {

            if let Some(body) = message {

                c.send_text("POST", &format!("{base}/proposals/{number}/comments"), &NewComment { body, path: None, line: None })?;

            }

            let p: Proposal = c.send("PATCH", &format!("{base}/proposals/{number}"), &serde_json::json!({ "state": "closed" }))?;

            if json {

                println!("{}", serde_json::to_string(&p)?);

            } else {

                println!("{} closed #{} {}", ui::ok("✔"), p.number, p.title);

            }

        }

        ProposalCmd::Reopen { number } => {

            let p: Proposal = c.send("PATCH", &format!("{base}/proposals/{number}"), &serde_json::json!({ "state": "open" }))?;

            if json {

                println!("{}", serde_json::to_string(&p)?);

            } else {

                println!("{} reopened #{} {}", ui::ok("✔"), p.number, p.title);

| `oh proposal close N [-m MSG]` | Close it without landing, with an optional comment saying why |

| `oh proposal reopen N` | Reopen a closed proposal |

Its author, or anyone with triage access, closes and reopens a proposal on its page or with `PATCH /api/v1/repos/{o}/{n}/proposals/{number}` and `{"state": "closed"}` or `{"state": "open"}` (`oh proposal close N [-m MSG]`, `oh proposal reopen N`; #140); asking for the state it already has changes nothing, and landing has its own endpoint. The author or a writer can **ask for a review** from anyone who can read the repository (not the author), under Reviewers on the proposal page or with `POST /api/v1/repos/{o}/{n}/proposals/{number}/reviewers` and `{"reviewers": [...]}`; `DELETE .../reviewers/{username}` withdraws a request. Each person asked gets a notification (`proposal.review_requested`), the timeline records it, the proposal's JSON lists `requested_reviewers`, and a review from that person answers the request. Every review notifies the proposal's author (`proposal.review`). An AI assistant the repository may use (§13.4) can be asked the same way; its answer is a `comment` review recorded via the assistant under the asker's name.