OXYGENHUB
# 69e4f27c5633 oxygenhub / crates / hub / src / api / mod.rs
125.1 KiB · Rust · last changed The API for apps: own repositories, organisations, 401, device cancel, richer notifications (closes #302, closes #303, closes #304, closes #305) 11 days ago source blame history raw
b64e2537 Andy McCall ↶ 1 
//! The JSON API (hub spec §12.1) under `/api/v1`: bearer tokens, RFC 7807
2 
//! problems, the same shapes as `oxy --json` where one exists. Reads need
3 
//! `repo:read` (anonymous for public repositories); writes the scope named
4 
//! on each handler.
d23464c0 Andy McCall ↶ 5
b64e2537 Andy McCall ↶ 6 
use crate::auth::{self, Access, Role};
7 
use crate::db::{self, accounts::Account};
d23464c0 Andy McCall ↶ 8 
use crate::repos::{view, RepoError, RepoName};
b64e2537 Andy McCall ↶ 9 
use crate::Shared;
10 
use axum::extract::{Path, Query, State};
11 
use axum::http::{HeaderMap, StatusCode};
d23464c0 Andy McCall ↶ 12 
use axum::response::{IntoResponse, Response};
b64e2537 Andy McCall ↶ 13 
use axum::routing::{get, post};
d23464c0 Andy McCall ↶ 14 
use axum::{Json, Router};
b64e2537 Andy McCall ↶ 15 
use hub_api::*;
16 
use serde::Deserialize;
d23464c0 Andy McCall ↶ 17
2e9188ca Andy McCall ↶ 18 
mod backups;
df71c789 Andy McCall ↶ 19 
pub mod device;
166f6e9b Andy McCall 20 
mod drops;
92a797b2 Andy McCall ↶ 21 
mod images;
ef20fdc1 Andy McCall ↶ 22 
mod projects;
617c2840 Andy McCall ↶ 23 
mod reports;
ef20fdc1 Andy McCall ↶ 24
90326c96 Andy McCall ↶ 25 
/// Any other path under `/api/v1`: a problem document, not the site's page.
e9bfea8e Andy McCall ↶ 26 
/// `GET /api/v1/version`: the hub's version and build, and the Oxygen and
27 
/// OxygenFlow library versions it is built on.
28 
async fn version() -> Json<serde_json::Value> {
29 
    Json(crate::web::home::versions())
30 
}
31
90326c96 Andy McCall ↶ 32 
async fn no_route() -> ApiError {
33 
    ApiError(StatusCode::NOT_FOUND, "no such API route".into())
34 
}
35
17a3a84b Andy McCall ↶ 36 
/// A known route asked with a method it does not take: a problem body
37 
/// rather than axum's empty 405 (oxygenhub#115).
38 
async fn wrong_method(method: axum::http::Method, uri: axum::http::Uri) -> ApiError {
39 
    ApiError(StatusCode::METHOD_NOT_ALLOWED, format!("{} is an API route, but not for {method}", uri.path()))
40 
}
41
5533e91a Andy McCall ↶ 42 
/// The API, with release assets up to `asset_limit` bytes (the web form's
43 
/// limit too; axum's default of 2 MiB refused ordinary builds).
44 
pub fn router(asset_limit: usize) -> Router<Shared> {
d23464c0 Andy McCall ↶ 45 
    Router::new()
90326c96 Andy McCall ↶ 46 
        .fallback(no_route)
026a76d2 Andy McCall ↶ 47 
        .route("/keyless/certify", post(crate::keyless::certify))
8aa5ef38 Andy McCall ↶ 48 
        .route("/agents/grants", get(crate::keyless::grants_list).post(crate::keyless::grants_create))
8dcaeeb8 Andy McCall ↶ 49 
        .route(
50 
            "/repos/{owner}/{name}/terraform/state/{state}",
51 
            axum::routing::any(crate::terraform::state)
52 
                .layer(axum::extract::DefaultBodyLimit::max(crate::terraform::MAX_STATE_BYTES + 4096)),
53 
        )
67523e06 Andy McCall ↶ 54 
        .route("/repos/{owner}/{name}/terraform/state/{state}/versions", axum::routing::get(crate::terraform::versions))
55 
        .route("/repos/{owner}/{name}/terraform/state/{state}/versions/{id}", axum::routing::get(crate::terraform::version))
56 
        .route(
57 
            "/repos/{owner}/{name}/terraform/state/{state}/versions/{id}/restore",
58 
            axum::routing::post(crate::terraform::restore_version),
59 
        )
8aa5ef38 Andy McCall ↶ 60 
        .route("/agents/grants/{id}", axum::routing::delete(crate::keyless::grants_revoke))
42fa9554 Andy McCall ↶ 61 
        .route("/flow/claim", post(crate::flow::claim))
b6b7e4cf Andy McCall ↶ 62 
        .route("/flow/runners/register", post(crate::flow::register))
e9b9619c Andy McCall ↶ 63 
        .route("/flow/runners/heartbeat", post(crate::flow::heartbeat))
750579ec Andy McCall ↶ 64 
        .route("/flow/images/missing", post(images::missing).layer(axum::extract::DefaultBodyLimit::max(images::MAX_ASK_BYTES)))
a46d15e7 Andy McCall ↶ 65 
        .route("/flow/swarm/announce", post(crate::swarm::announce))
92a797b2 Andy McCall ↶ 66 
        .route("/flow/images/chunks/{hash}", axum::routing::put(images::put_chunk).get(images::get_chunk))
67 
        .route(
68 
            "/flow/images/{hash}",
69 
            axum::routing::put(images::put_manifest).get(images::get_manifest).layer(axum::extract::DefaultBodyLimit::max(64 << 20)),
70 
        )
42fa9554 Andy McCall ↶ 71 
        .route("/flow/jobs/{id}/log", post(crate::flow::log))
72 
        .route("/flow/jobs/{id}/finish", post(crate::flow::finish))
4d2e44d7 Andy McCall ↶ 73 
        .route("/flow/jobs/{id}/decline", post(crate::flow::decline))
a3c8288b Andy McCall ↶ 74 
        .route(
75 
            "/flow/jobs/{id}/artifacts/{name}",
76 
            post(crate::flow::artifact).layer(axum::extract::DefaultBodyLimit::max(crate::flow::MAX_ARTIFACT_BYTES + (1 << 20))),
77 
        )
cd437c4f Andy McCall ↶ 78 
        .route("/flow/jobs/{id}/inputs/{index}", get(crate::flow::input))
a36bab6b Andy McCall ↶ 79 
        .route(
80 
            "/flow/jobs/{id}/reports/{name}/files",
81 
            post(crate::flow::report_file).layer(axum::extract::DefaultBodyLimit::max(crate::flow::MAX_ARTIFACT_BYTES + (1 << 20))),
82 
        )
ef20fdc1 Andy McCall ↶ 83 
        .route("/projects/{owner}", get(projects::list).post(projects::create))
84 
        .route("/projects/{owner}/{number}", get(projects::board).patch(projects::edit))
17a3a84b Andy McCall ↶ 85 
        .route("/projects/{owner}/{number}/cards", get(projects::cards).post(projects::add_card))
456f4197 Andy McCall ↶ 86 
        .route("/projects/{owner}/{number}/cards/move", post(projects::move_cards))
ef20fdc1 Andy McCall ↶ 87 
        .route("/projects/{owner}/{number}/cards/{id}", axum::routing::patch(projects::move_card).delete(projects::remove_card))
ecac6e8d Andy McCall ↶ 88 
        .route("/device/code", post(device::code).delete(device::cancel))
df71c789 Andy McCall ↶ 89 
        .route("/device/token", post(device::token))
b66e70b7 Andy McCall ↶ 90 
        .route("/runners", get(runners))
91 
        .route("/runners/queue", get(runner_queue))
92 
        .route("/runners/{id}/jobs", get(runner_jobs))
b64e2537 Andy McCall ↶ 93 
        .route("/user", get(me))
ecac6e8d Andy McCall ↶ 94 
        .route("/user/repos", get(user_repos))
95 
        .route("/user/orgs", get(user_orgs))
60f11b71 Andy McCall ↶ 96 
        .route("/user/token", axum::routing::delete(revoke_own_token))
e9bfea8e Andy McCall ↶ 97 
        .route("/version", get(version))
42a0ba4b Andy McCall ↶ 98 
        .route("/notifications", get(notifications))
99 
        .route("/notifications/read", post(notifications_read_all))
100 
        .route("/notifications/{id}/read", post(notification_read))
b64e2537 Andy McCall ↶ 101 
        .route("/users/{name}", get(user))
166f6e9b Andy McCall 102 
        .route("/users/{name}/drops", get(drops::of_user))
103 
        .route("/drops", get(drops::mine).post(drops::create))
104 
        .route("/drops/{id}", get(drops::view).patch(drops::edit).delete(drops::delete))
b64e2537 Andy McCall ↶ 105 
        .route("/orgs/{name}", get(org))
106 
        .route("/search", get(search))
107 
        .route("/repos", get(list_repos).post(create_repo))
d23464c0 Andy McCall ↶ 108 
        .route("/repos/{owner}/{name}", get(get_repo))
109 
        .route("/repos/{owner}/{name}/bookmarks", get(bookmarks))
ba0a55bb Andy McCall ↶ 110 
        .route("/repos/{owner}/{name}/tags", get(tags).post(create_tag))
111 
        .route("/repos/{owner}/{name}/tags/{tag}", axum::routing::delete(withdraw_tag))
f677d627 Andy McCall ↶ 112 
        .route("/repos/{owner}/{name}/consumers", get(consumers))
eb2a3502 Andy McCall ↶ 113 
        .route("/repos/{owner}/{name}/diffusion", get(diffusion).put(set_diffusion))
d3b048b2 Andy McCall ↶ 114 
        .route("/repos/{owner}/{name}/backup", axum::routing::put(set_backup))
2e9188ca Andy McCall ↶ 115 
        .route("/user/backups", get(backups::user_get).put(backups::user_put))
116 
        .route("/user/backups/test", post(backups::user_test))
117 
        .route("/user/backups/run", post(backups::user_run))
118 
        .route("/user/backups/runs", get(backups::user_runs))
119 
        .route("/orgs/{name}/backups", get(backups::org_get).put(backups::org_put))
120 
        .route("/orgs/{name}/backups/test", post(backups::org_test))
121 
        .route("/orgs/{name}/backups/run", post(backups::org_run))
122 
        .route("/orgs/{name}/backups/runs", get(backups::org_runs))
b64e2537 Andy McCall ↶ 123 
        .route("/repos/{owner}/{name}/history/{r}", get(history))
124 
        .route("/repos/{owner}/{name}/changes/{hash}", get(change))
125 
        .route("/repos/{owner}/{name}/tree/{r}", get(tree_root))
126 
        .route("/repos/{owner}/{name}/tree/{r}/{*path}", get(tree))
127 
        .route("/repos/{owner}/{name}/file/{r}/{*path}", get(file))
128 
        .route("/repos/{owner}/{name}/blame/{r}/{*path}", get(blame))
129 
        .route("/repos/{owner}/{name}/conflicts", get(conflicts))
130 
        .route("/repos/{owner}/{name}/trust", get(trust))
df940d75 Andy McCall ↶ 131 
        .route("/repos/{owner}/{name}/releases/trust/{*tag}", get(release_trust))
b64e2537 Andy McCall ↶ 132 
        .route("/repos/{owner}/{name}/pushes", get(pushes))
133 
        .route("/repos/{owner}/{name}/proposals", get(proposals).post(create_proposal))
739a763a Andy McCall ↶ 134 
        .route("/repos/{owner}/{name}/proposals/{number}", get(proposal).patch(edit_proposal))
1f1eb06a Andy McCall ↶ 135 
        .route("/repos/{owner}/{name}/proposals/{number}/land", post(land_proposal))
86a69b53 Andy McCall ↶ 136 
        .route("/repos/{owner}/{name}/proposals/{number}/auto-land", post(auto_land_on).delete(auto_land_off))
b64e2537 Andy McCall ↶ 137 
        .route("/repos/{owner}/{name}/proposals/{number}/comments", get(proposal_comments).post(proposal_comment))
138 
        .route("/repos/{owner}/{name}/proposals/{number}/reviews", get(proposal_reviews).post(proposal_review))
cc1cd197 Andy McCall ↶ 139 
        .route("/repos/{owner}/{name}/proposals/{number}/reviewers", post(request_reviewers))
7d2eb590 Andy McCall ↶ 140 
        .route("/repos/{owner}/{name}/proposals/{number}/review-requests", post(request_assistant))
cc1cd197 Andy McCall ↶ 141 
        .route("/repos/{owner}/{name}/proposals/{number}/reviewers/{username}", axum::routing::delete(withdraw_reviewer))
b64e2537 Andy McCall ↶ 142 
        .route("/repos/{owner}/{name}/proposals/{number}/checks", get(proposal_checks))
3f02e5ea Andy McCall ↶ 143 
        .route("/repos/{owner}/{name}/proposals/{number}/files", get(proposal_files))
144 
        .route("/repos/{owner}/{name}/proposals/{number}/content/{side}/{*path}", get(proposal_content))
b64e2537 Andy McCall ↶ 145 
        .route("/repos/{owner}/{name}/issues", get(issues).post(create_issue))
76f262e1 Andy McCall ↶ 146 
        .route("/repos/{owner}/{name}/issues/{number}", get(issue).post(issue_state).patch(issue_edit))
b64e2537 Andy McCall ↶ 147 
        .route("/repos/{owner}/{name}/issues/{number}/comments", get(issue_comments).post(issue_comment))
76f262e1 Andy McCall ↶ 148 
        .route("/repos/{owner}/{name}/labels", get(labels).post(create_label))
149 
        .route("/repos/{owner}/{name}/labels/{label}", axum::routing::delete(delete_label))
5ea4872f Andy McCall ↶ 150 
        .route("/repos/{owner}/{name}/milestones", get(milestones).post(create_milestone))
40dd3f86 Andy McCall ↶ 151 
        .route(
152 
            "/repos/{owner}/{name}/coverage",
153 
            get(reports::coverage_list)
154 
                .post(reports::coverage_upload)
155 
                .layer(axum::extract::DefaultBodyLimit::max(crate::coverage::MAX_REPORT + (1 << 20))),
156 
        )
617c2840 Andy McCall ↶ 157 
        .route("/repos/{owner}/{name}/coverage/{id}", get(reports::coverage_one))
158 
        .route("/repos/{owner}/{name}/tests", get(reports::tests_list))
159 
        .route("/repos/{owner}/{name}/tests/{id}", get(reports::tests_one))
5ea4872f Andy McCall ↶ 160 
        .route("/repos/{owner}/{name}/milestones/{title}", axum::routing::patch(edit_milestone))
b64e2537 Andy McCall ↶ 161 
        .route("/repos/{owner}/{name}/hooks", get(hooks).post(create_hook))
62ceb2ee Andy McCall ↶ 162 
        .route("/repos/{owner}/{name}/assistants", get(repo_assistants).post(repo_assistant_put))
163 
        .route("/repos/{owner}/{name}/assistants/prompt", get(repo_prompt).put(repo_prompt_put))
164 
        .route("/repos/{owner}/{name}/assistants/{assistant}", axum::routing::delete(repo_assistant_delete))
165 
        .route("/orgs/{org}/assistants", get(org_assistants).post(org_assistant_put))
166 
        .route("/orgs/{org}/assistants/prompt", get(org_prompt).put(org_prompt_put))
167 
        .route("/orgs/{org}/assistants/{assistant}", axum::routing::delete(org_assistant_delete))
168 
        .route("/admin/assistants", get(site_assistants).post(site_assistant_put))
169 
        .route("/admin/assistants/prompt", get(site_prompt).put(site_prompt_put))
170 
        .route("/admin/assistants/{assistant}", axum::routing::delete(site_assistant_delete))
b64e2537 Andy McCall ↶ 171 
        .route("/repos/{owner}/{name}/hooks/{id}/delete", post(delete_hook))
172 
        .route("/repos/{owner}/{name}/checks", post(post_check))
90326c96 Andy McCall ↶ 173 
        .route("/repos/{owner}/{name}/flow/runs", get(flow_runs).post(start_flow_run))
174 
        .route("/repos/{owner}/{name}/flow/runs/{number}", get(flow_run))
175 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/log", get(flow_job_log))
1edac4b6 Andy McCall ↶ 176 
        .route("/repos/{owner}/{name}/flow/runs/{number}/rerun", post(rerun_flow_run))
e8fa5369 Andy McCall ↶ 177 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/rerun", post(rerun_flow_job))
745d225d Andy McCall ↶ 178 
        .route("/repos/{owner}/{name}/flow/runs/{number}/cancel", post(cancel_flow_run))
b644e175 Andy McCall ↶ 179 
        .route("/repos/{owner}/{name}/deployments", get(list_deployments))
417184c7 Andy McCall ↶ 180 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/approve", post(approve_flow_job))
181 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/reject", post(reject_flow_job))
47e37402 Andy McCall ↶ 182 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/approval", get(flow_job_statement))
183 
        .route("/repos/{owner}/{name}/flow/runs/{number}/jobs/{job}/seal", post(seal_flow_job))
961c10be Andy McCall ↶ 184 
        .route("/repos/{owner}/{name}/checks/required", get(required_checks).put(set_required_checks))
b64e2537 Andy McCall ↶ 185 
        .route("/repos/{owner}/{name}/checks/{state}", get(checks_for_state))
3f4b0ea6 Andy McCall ↶ 186 
        .route("/repos/{owner}/{name}/releases", get(releases).post(create_release))
ced6d3af Andy McCall ↶ 187 
        .route("/repos/{owner}/{name}/releases/{tag}", axum::routing::patch(edit_release))
5533e91a Andy McCall ↶ 188 
        .route(
189 
            "/repos/{owner}/{name}/releases/{tag}/assets",
190 
            post(upload_asset).layer(axum::extract::DefaultBodyLimit::max(asset_limit + (1 << 20))),
191 
        )
17a3a84b Andy McCall ↶ 192 
        // Last: it applies to the routes registered before it.
193 
        .method_not_allowed_fallback(wrong_method)
3f4b0ea6 Andy McCall ↶ 194 
}
195
196 
async fn releases(
197 
    State(app): State<Shared>,
198 
    headers: HeaderMap,
199 
    Path((owner, name)): Path<(String, String)>,
200 
) -> Result<Json<Vec<Release>>, ApiError> {
201 
    let c = caller(&app, &headers).await?;
202 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
203 
    Ok(Json(crate::web::releases::api_views(&app, &repo, &row).await?))
204 
}
205
206 
async fn create_release(
207 
    State(app): State<Shared>,
208 
    headers: HeaderMap,
209 
    Path((owner, name)): Path<(String, String)>,
210 
    Json(body): Json<NewRelease>,
211 
) -> Result<(StatusCode, Json<Release>), ApiError> {
212 
    let c = caller(&app, &headers).await?;
213 
    let me = c.require("repo:write")?.clone();
214 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
215 
    crate::web::releases::create_release(&app, &repo, &row, &me, &body.tag, &body.title, body.notes, body.prerelease)
216 
        .await
217 
        .map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
218 
    let r = crate::web::releases::api_views(&app, &repo, &row)
219 
        .await?
220 
        .into_iter()
221 
        .find(|r| r.tag == body.tag)
222 
        .ok_or_else(|| not_found("no such release"))?;
223 
    Ok((StatusCode::CREATED, Json(r)))
224 
}
225
ced6d3af Andy McCall ↶ 226 
/// `PATCH …/releases/{tag}` (oxygenhub#72): change a release's title,
227 
/// notes or prerelease flag, as the release page's Edit does.
228 
async fn edit_release(
229 
    State(app): State<Shared>,
230 
    headers: HeaderMap,
231 
    Path((owner, name, tag)): Path<(String, String, String)>,
232 
    Json(body): Json<ReleaseEdit>,
233 
) -> Result<Json<Release>, ApiError> {
234 
    let c = caller(&app, &headers).await?;
235 
    let me = c.require("repo:write")?.clone();
236 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
237 
    let r = db::releases::get(&app.db, row.id, &tag).await?.ok_or_else(|| not_found("no such release"))?;
238 
    let title = body.title.as_deref().map(str::trim).filter(|t| !t.is_empty()).unwrap_or(&r.title);
239 
    let notes = body.notes.as_deref().map(str::trim).unwrap_or(&r.notes);
240 
    db::releases::edit(&app.db, r.id, title, notes, body.prerelease.unwrap_or(r.prerelease)).await?;
241 
    db::accounts::audit(&app.db, Some(&me), "release.edited", &format!("{owner}/{name}@{tag}"), "").await.ok();
242 
    let r = crate::web::releases::api_views(&app, &repo, &row)
243 
        .await?
244 
        .into_iter()
245 
        .find(|r| r.tag == tag)
246 
        .ok_or_else(|| not_found("no such release"))?;
247 
    Ok(Json(r))
248 
}
249
3f4b0ea6 Andy McCall ↶ 250 
#[derive(Deserialize)]
251 
struct AssetQuery {
252 
    name: String,
de505df5 Andy McCall ↶ 253 
}
254
3f4b0ea6 Andy McCall ↶ 255 
/// `POST …/releases/{tag}/assets?name=file.tar.gz` with the file as the body.
256 
async fn upload_asset(
257 
    State(app): State<Shared>,
258 
    headers: HeaderMap,
259 
    Path((owner, name, tag)): Path<(String, String, String)>,
260 
    Query(q): Query<AssetQuery>,
261 
    body: axum::body::Bytes,
262 
) -> Result<(StatusCode, Json<Release>), ApiError> {
263 
    let c = caller(&app, &headers).await?;
264 
    c.require("repo:write")?;
265 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
266 
    let r = db::releases::get(&app.db, row.id, &tag).await?.ok_or_else(|| not_found("no such release"))?;
267 
    let ct = headers.get(axum::http::header::CONTENT_TYPE).and_then(|v| v.to_str().ok()).unwrap_or("application/octet-stream").to_string();
268 
    crate::web::releases::store_asset(&app, r.id, &q.name, &ct, &body).await.map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
269 
    let r = crate::web::releases::api_views(&app, &repo, &row)
270 
        .await?
271 
        .into_iter()
272 
        .find(|r| r.tag == tag)
273 
        .ok_or_else(|| not_found("no such release"))?;
274 
    Ok((StatusCode::CREATED, Json(r)))
275 
}
276
42fa9554 Andy McCall ↶ 277 
pub struct ApiError(pub StatusCode, pub String);
b64e2537 Andy McCall ↶ 278
279 
impl IntoResponse for ApiError {
280 
    fn into_response(self) -> Response {
281 
        let body = Problem { status: self.0.as_u16(), title: self.0.canonical_reason().unwrap_or("error").into(), detail: self.1 };
282 
        (self.0, [("content-type", "application/problem+json")], Json(body)).into_response()
de505df5 Andy McCall ↶ 283 
    }
b64e2537 Andy McCall ↶ 284 
}
285
286 
impl From<RepoError> for ApiError {
287 
    fn from(e: RepoError) -> ApiError {
288 
        match e {
289 
            RepoError::NotFound => not_found("no such repository"),
290 
            RepoError::Oxy(oxy_core::repo::RepoError::Msg(m)) => ApiError(StatusCode::NOT_FOUND, m),
291 
            other => ApiError(StatusCode::INTERNAL_SERVER_ERROR, other.to_string()),
292 
        }
293 
    }
294 
}
295
296 
impl From<sqlx::Error> for ApiError {
297 
    fn from(e: sqlx::Error) -> ApiError {
298 
        ApiError(StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
299 
    }
300 
}
301
ef20fdc1 Andy McCall ↶ 302 
pub(crate) fn not_found(what: &str) -> ApiError {
b64e2537 Andy McCall ↶ 303 
    ApiError(StatusCode::NOT_FOUND, what.into())
304 
}
305
ef20fdc1 Andy McCall ↶ 306 
pub(crate) fn forbidden(what: &str) -> ApiError {
b64e2537 Andy McCall ↶ 307 
    ApiError(StatusCode::FORBIDDEN, what.into())
308 
}
309
60f11b71 Andy McCall ↶ 310 
/// The address a request came from: the client's, as the proxy reports
311 
/// it when the hub is behind one (`server.behind_proxy`), else the peer's.
312 
/// Only an address's characters are kept, so it is safe to show.
313 
pub fn client_addr(app: &Shared, headers: &HeaderMap, extensions: &axum::http::Extensions) -> String {
314 
    let from_proxy = || {
315 
        ["cf-connecting-ip", "x-forwarded-for", "x-real-ip"]
316 
            .iter()
317 
            .find_map(|h| headers.get(*h).and_then(|v| v.to_str().ok()).and_then(|v| v.split(',').next()).map(|v| v.trim().to_string()))
318 
    };
319 
    let addr = if app.config.server.behind_proxy {
320 
        from_proxy()
321 
    } else {
322 
        extensions.get::<axum::extract::ConnectInfo<std::net::SocketAddr>>().map(|c| c.0.ip().to_string())
323 
    };
324 
    addr.map(|a| a.chars().filter(|c| c.is_ascii_hexdigit() || matches!(c, '.' | ':')).take(45).collect()).unwrap_or_default()
325 
}
326
327 
/// `DELETE /api/v1/user/token`: revoke the token this request is made
328 
/// with, as `oxy auth logout` does.
329 
async fn revoke_own_token(State(app): State<Shared>, headers: HeaderMap) -> Result<StatusCode, ApiError> {
330 
    let c = caller(&app, &headers).await?;
331 
    let (Some(account), Some(id)) = (c.account.as_ref(), c.token_id) else {
332 
        return Err(ApiError(StatusCode::UNAUTHORIZED, "revoking needs the personal access token to revoke".into()));
333 
    };
334 
    db::accounts::delete_token(&app.db, account.id, id).await?;
335 
    db::accounts::audit(&app.db, Some(account), "token.revoke", &c.token, "").await.ok();
336 
    Ok(StatusCode::NO_CONTENT)
337 
}
338
b64e2537 Andy McCall ↶ 339 
/// Who calls: the account behind a bearer token, with the token's scopes.
340 
pub struct Caller {
341 
    pub account: Option<Account>,
342 
    pub scopes: Vec<String>,
343 
    pub site: bool,
0b20f1ec Andy McCall ↶ 344 
    /// The token's name, for records of what a call did.
345 
    pub token: String,
60f11b71 Andy McCall ↶ 346 
    /// The personal access token's id, when one is used.
347 
    pub token_id: Option<i64>,
05f1a85a Andy McCall ↶ 348 
    /// The token is an agent's (oxygenhub#183): what it does says so.
349 
    pub agent: bool,
b64e2537 Andy McCall ↶ 350 
}
351
352 
impl Caller {
353 
    fn has(&self, scope: &str) -> bool {
354 
        self.site
355 
            || self.scopes.iter().any(|s| {
356 
                s == scope
357 
                    || (scope == "repo:read" && (s == "repo:write" || s == "repo:admin"))
358 
                    || (scope == "repo:write" && s == "repo:admin")
359 
            })
360 
    }
361
362 
    fn require(&self, scope: &str) -> Result<&Account, ApiError> {
ecac6e8d Andy McCall ↶ 363 
        // No token is 401, sign in; a token without the scope is 403 (#303).
364 
        let Some(account) = self.account.as_ref() else {
365 
            return Err(ApiError(StatusCode::UNAUTHORIZED, "a personal access token is required: sign in (`oh auth login`)".into()));
366 
        };
b64e2537 Andy McCall ↶ 367 
        if !self.has(scope) {
368 
            return Err(forbidden(&format!("this token lacks the {scope} scope")));
369 
        }
ecac6e8d Andy McCall ↶ 370 
        Ok(account)
b64e2537 Andy McCall ↶ 371 
    }
372 
}
373
374 
pub async fn caller(app: &Shared, headers: &HeaderMap) -> Result<Caller, ApiError> {
0b20f1ec Andy McCall ↶ 375 
    let Some(t) = oxy_server::bearer_token(headers) else {
05f1a85a Andy McCall ↶ 376 
        return Ok(Caller { account: None, scopes: vec![], site: false, token: String::new(), token_id: None, agent: false });
0b20f1ec Andy McCall ↶ 377 
    };
b64e2537 Andy McCall ↶ 378 
    if app.config.auth.push_tokens.iter().any(|x| auth::mac_equal(x, t)) {
379 
        let admin = db::accounts::accounts(&app.db).await?.into_iter().find(|a| a.is_admin);
0b20f1ec Andy McCall ↶ 380 
        return Ok(Caller {
381 
            account: admin,
382 
            scopes: vec!["repo:admin".into(), "user:read".into(), "checks:write".into()],
383 
            site: true,
384 
            token: "site token".into(),
60f11b71 Andy McCall ↶ 385 
            token_id: None,
05f1a85a Andy McCall ↶ 386 
            agent: false,
0b20f1ec Andy McCall ↶ 387 
        });
b64e2537 Andy McCall ↶ 388 
    }
389 
    let token = db::accounts::token_by_hash(&app.db, &auth::token_hash(t)).await?;
de505df5 Andy McCall ↶ 390 
    match token {
b64e2537 Andy McCall ↶ 391 
        Some(tok) if !tok.expired(db::now_ms()) => {
6a178055 Andy McCall ↶ 392 
            let account = db::accounts::account_by_id(&app.db, tok.account_id).await?.filter(|a| !a.blocked());
b64e2537 Andy McCall ↶ 393 
            db::accounts::touch_token(&app.db, tok.id).await.ok();
60f11b71 Andy McCall ↶ 394 
            Ok(Caller {
395 
                account,
396 
                scopes: tok.scope_list().iter().map(|s| s.to_string()).collect(),
397 
                site: false,
398 
                token: tok.name.clone(),
399 
                token_id: Some(tok.id),
05f1a85a Andy McCall ↶ 400 
                agent: tok.agent,
60f11b71 Andy McCall ↶ 401 
            })
b64e2537 Andy McCall ↶ 402 
        }
de505df5 Andy McCall ↶ 403 
        _ => Err(ApiError(StatusCode::UNAUTHORIZED, "unknown or expired token".into())),
404 
    }
405 
}
406
b64e2537 Andy McCall ↶ 407 
fn repository(app: &Shared, r: &db::repos::RepoRow) -> Repository {
408 
    Repository {
409 
        owner: r.owner.clone(),
410 
        name: r.name.clone(),
411 
        description: r.description.clone(),
412 
        default_bookmark: r.default_bookmark.clone(),
413 
        visibility: r.visibility(),
414 
        created_ms: r.created_ms,
415 
        updated_ms: r.updated_ms,
416 
        clone_url: format!("{}/{}/{}", app.config.base_url(), r.owner, r.name),
417 
    }
418 
}
419
420 
/// A repository the caller may reach with `access`, else 404.
617c2840 Andy McCall ↶ 421 
pub(super) async fn reach(
de505df5 Andy McCall ↶ 422 
    app: &Shared,
b64e2537 Andy McCall ↶ 423 
    c: &Caller,
de505df5 Andy McCall ↶ 424 
    owner: &str,
425 
    name: &str,
b64e2537 Andy McCall ↶ 426 
    access: Access,
427 
) -> Result<(RepoName, db::repos::RepoRow, Role), ApiError> {
428 
    let repo = RepoName::new(owner, name).ok_or_else(|| not_found("no such repository"))?;
429 
    let row = db::repos::get(&app.db, owner, name).await?.ok_or_else(|| not_found("no such repository"))?;
166f6e9b Andy McCall 430 
    // A drop is reached through `/drops` only (#279).
431 
    if row.is_drop() {
432 
        return Err(not_found("no such repository"));
433 
    }
b64e2537 Andy McCall ↶ 434 
    let role = auth::roles::role_for(&app.db, c.account.as_ref(), &row).await?;
435 
    if !auth::roles::allows(role, access) {
436 
        return Err(not_found("no such repository"));
437 
    }
438 
    Ok((repo, row, role.unwrap_or(Role::Read)))
439 
}
440
441 
fn summary(c: &view::ChangeView) -> ChangeSummary {
442 
    ChangeSummary {
443 
        hash: c.hash.clone(),
444 
        message: if c.body.is_empty() { c.title.clone() } else { format!("{}\n\n{}", c.title, c.body) },
445 
        author: Author {
446 
            name: c.author.name.clone(),
447 
            email: c.author.email.clone(),
448 
            key: c.author.key.clone(),
449 
            account: c.author.account.clone(),
760a7dd3 Andy McCall ↶ 450 
            note: Author::note_for(&c.author.key, &c.author.account),
b64e2537 Andy McCall ↶ 451 
        },
452 
        when_ms: c.when_ms,
453 
        deps: c.deps.clone(),
454 
        head: c.head,
8933faff Andy McCall ↶ 455 
        via: c.via.as_ref().map(|v| Via {
456 
            name: v.name.clone(),
457 
            key: v.key.clone(),
458 
            scope: v.scope.clone(),
459 
            expires_ms: v.expires_ms,
460 
            revoked: v.revoked,
461 
        }),
b64e2537 Andy McCall ↶ 462 
        signature: match &c.signature {
463 
            view::SigView::Unsigned => Signature::Unsigned,
464 
            view::SigView::Valid { key, sealed, revoked, .. } => Signature::Valid { key: key.clone(), sealed: *sealed, revoked: *revoked },
465 
            view::SigView::Invalid(why) => Signature::Invalid { reason: why.clone() },
466 
        },
467 
    }
468 
}
469
470 
// ---------------------------------------------------------------- accounts
471
472 
async fn me(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<User>, ApiError> {
473 
    let c = caller(&app, &headers).await?;
474 
    let a = c.require("user:read")?;
475 
    Ok(Json(user_of(&app, a).await?))
476 
}
477
42a0ba4b Andy McCall ↶ 478 
#[derive(Deserialize)]
479 
struct InboxQuery {
480 
    #[serde(default)]
481 
    limit: Option<i64>,
482 
}
483
484 
/// The caller's inbox; reading and clearing it needs `user:read`, since
485 
/// it touches nothing but the caller's own notifications.
486 
async fn notifications(
487 
    State(app): State<Shared>,
488 
    headers: HeaderMap,
489 
    Query(q): Query<InboxQuery>,
490 
) -> Result<Json<hub_api::Inbox>, ApiError> {
491 
    let c = caller(&app, &headers).await?;
492 
    let a = c.require("user:read")?;
493 
    let limit = q.limit.unwrap_or(50).clamp(1, 200);
494 
    let base = app.config.base_url().trim_end_matches('/').to_string();
ecac6e8d Andy McCall ↶ 495 
    let rows = db::notify::inbox(&app.db, a.id, limit).await?;
496 
    // Repositories by id, each looked up once (#305).
497 
    let mut repos: std::collections::HashMap<i64, Option<String>> = std::collections::HashMap::new();
498 
    for id in rows.iter().filter_map(|n| n.repo_id) {
499 
        if let std::collections::hash_map::Entry::Vacant(e) = repos.entry(id) {
500 
            e.insert(db::repos::get_by_id(&app.db, id).await?.map(|r| format!("{}/{}", r.owner, r.name)));
501 
        }
502 
    }
503 
    let absolute = |u: String| if u.starts_with('/') { format!("{base}{u}") } else { u };
504 
    let items = rows
42a0ba4b Andy McCall ↶ 505 
        .into_iter()
506 
        .map(|n| hub_api::Notification {
507 
            id: n.id,
508 
            at_ms: n.at_ms,
ecac6e8d Andy McCall ↶ 509 
            label: crate::notify::label(&n.kind).map(String::from),
42a0ba4b Andy McCall ↶ 510 
            kind: n.kind,
511 
            title: n.title,
ecac6e8d Andy McCall ↶ 512 
            url: absolute(n.url),
42a0ba4b Andy McCall ↶ 513 
            actor: n.actor,
514 
            read: n.read,
ecac6e8d Andy McCall ↶ 515 
            repository: n.repo_id.and_then(|id| repos.get(&id).cloned().flatten()),
516 
            reason: n.reason,
517 
            thread: if n.thread.is_empty() { String::new() } else { absolute(n.thread) },
42a0ba4b Andy McCall ↶ 518 
        })
519 
        .collect();
520 
    Ok(Json(hub_api::Inbox { unread: db::notify::unread(&app.db, a.id).await?, items }))
521 
}
522
523 
async fn notification_read(State(app): State<Shared>, headers: HeaderMap, Path(id): Path<i64>) -> Result<StatusCode, ApiError> {
524 
    let c = caller(&app, &headers).await?;
525 
    let a = c.require("user:read")?;
526 
    db::notify::mark_read(&app.db, a.id, Some(id)).await?;
527 
    Ok(StatusCode::NO_CONTENT)
528 
}
529
530 
async fn notifications_read_all(State(app): State<Shared>, headers: HeaderMap) -> Result<StatusCode, ApiError> {
531 
    let c = caller(&app, &headers).await?;
532 
    let a = c.require("user:read")?;
533 
    db::notify::mark_read(&app.db, a.id, None).await?;
534 
    Ok(StatusCode::NO_CONTENT)
535 
}
536
b64e2537 Andy McCall ↶ 537 
async fn user_of(app: &Shared, a: &Account) -> Result<User, ApiError> {
538 
    let keys = db::accounts::identities_of(&app.db, a.id).await?.into_iter().map(|i| i.key).collect();
539 
    Ok(User { username: a.username.clone(), display_name: a.display_name.clone(), is_admin: a.is_admin, keys, created_ms: a.created_ms })
540 
}
541
542 
async fn user(State(app): State<Shared>, Path(name): Path<String>) -> Result<Json<User>, ApiError> {
543 
    let a = db::accounts::account_by_name(&app.db, &name).await?.ok_or_else(|| not_found("no such account"))?;
544 
    Ok(Json(user_of(&app, &a).await?))
545 
}
546
547 
async fn org(State(app): State<Shared>, Path(name): Path<String>) -> Result<Json<Organisation>, ApiError> {
548 
    let o = db::accounts::org_by_name(&app.db, &name).await?.ok_or_else(|| not_found("no such organisation"))?;
549 
    let members = db::accounts::org_members(&app.db, o.id).await?.into_iter().map(|(a, _)| a.username).collect();
550 
    Ok(Json(Organisation { name: o.name, display_name: o.display_name, description: o.description, members }))
551 
}
552
553 
#[derive(Deserialize)]
554 
struct SearchQuery {
555 
    q: String,
556 
}
557
558 
async fn search(
559 
    State(app): State<Shared>,
560 
    headers: HeaderMap,
561 
    Query(q): Query<SearchQuery>,
562 
) -> Result<Json<Vec<serde_json::Value>>, ApiError> {
563 
    let c = caller(&app, &headers).await?;
564 
    let mut out = Vec::new();
565 
    for h in db::notify::search(&app.db, &q.q, None, 50).await? {
566 
        let Some(row) = db::repos::get_by_id(&app.db, h.repo_id).await? else { continue };
567 
        let role = auth::roles::role_for(&app.db, c.account.as_ref(), &row).await?;
568 
        if !auth::roles::allows(role, Access::Read) {
569 
            continue;
570 
        }
571 
        out.push(
572 
            serde_json::json!({ "kind": h.kind, "repository": row.slug(), "number": h.number, "title": h.title, "snippet": h.snippet }),
573 
        );
574 
    }
575 
    Ok(Json(out))
576 
}
577
578 
// ------------------------------------------------------------ repositories
579
580 
async fn list_repos(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<Repository>>, ApiError> {
581 
    let c = caller(&app, &headers).await?;
582 
    let mut out = Vec::new();
583 
    for r in db::repos::list(&app.db).await? {
584 
        let role = auth::roles::role_for(&app.db, c.account.as_ref(), &r).await?;
585 
        if auth::roles::allows(role, Access::Read) {
586 
            out.push(repository(&app, &r));
587 
        }
de505df5 Andy McCall ↶ 588 
    }
b64e2537 Andy McCall ↶ 589 
    Ok(Json(out))
ecac6e8d Andy McCall ↶ 590 
}
591
592 
#[derive(Deserialize)]
593 
struct UserReposQuery {
594 
    /// Which: `owner`, `organization`, `collaborator`, comma-separated (all three by default).
595 
    #[serde(default)]
596 
    affiliation: Option<String>,
597 
    /// The last `owner/name` of the previous page.
598 
    #[serde(default)]
599 
    after: Option<String>,
600 
    #[serde(default)]
601 
    limit: Option<usize>,
602 
}
603
604 
/// `GET /user/repos` (#302): the caller's repositories, their
605 
/// organisations' and those they collaborate on, by `owner/name`, a page
606 
/// at a time (`?after=owner/name&limit=`, at most 100, default 50).
607 
async fn user_repos(
608 
    State(app): State<Shared>,
609 
    headers: HeaderMap,
610 
    Query(q): Query<UserReposQuery>,
611 
) -> Result<Json<Vec<Repository>>, ApiError> {
612 
    let c = caller(&app, &headers).await?;
613 
    let me = c.require("repo:read")?.clone();
614 
    let wanted: Vec<String> = q
615 
        .affiliation
616 
        .as_deref()
617 
        .unwrap_or("owner,organization,collaborator")
618 
        .split(',')
619 
        .map(|s| s.trim().to_ascii_lowercase())
620 
        .filter(|s| !s.is_empty())
621 
        .collect();
622 
    if let Some(bad) = wanted.iter().find(|w| !["owner", "organization", "collaborator"].contains(&w.as_str())) {
623 
        return Err(ApiError(StatusCode::BAD_REQUEST, format!("unknown affiliation {bad:?}: owner, organization or collaborator")));
624 
    }
625 
    let orgs: Vec<String> = db::accounts::orgs_of(&app.db, me.id).await?.into_iter().map(|(o, _)| o.name).collect();
626 
    let limit = q.limit.unwrap_or(50).clamp(1, 100);
627 
    let mut rows = db::repos::list(&app.db).await?;
628 
    rows.sort_by(|a, b| (&a.owner, &a.name).cmp(&(&b.owner, &b.name)));
629 
    let mut out = Vec::new();
630 
    for r in rows {
631 
        if let Some(after) = q.after.as_deref() {
632 
            if format!("{}/{}", r.owner, r.name).as_str() <= after {
633 
                continue;
634 
            }
635 
        }
636 
        let mine = (wanted.iter().any(|w| w == "owner") && r.owner == me.username)
637 
            || (wanted.iter().any(|w| w == "organization") && orgs.contains(&r.owner))
638 
            || (wanted.iter().any(|w| w == "collaborator") && db::accounts::collaborator_role(&app.db, r.id, me.id).await?.is_some());
639 
        if !mine || !auth::roles::allows(auth::roles::role_for(&app.db, Some(&me), &r).await?, Access::Read) {
640 
            continue;
641 
        }
642 
        out.push(repository(&app, &r));
643 
        if out.len() == limit {
644 
            break;
645 
        }
646 
    }
647 
    Ok(Json(out))
648 
}
649
650 
/// `GET /user/orgs` (#302): the organisations the caller belongs to.
651 
async fn user_orgs(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<hub_api::UserOrg>>, ApiError> {
652 
    let c = caller(&app, &headers).await?;
653 
    let me = c.require("user:read")?;
654 
    let orgs = db::accounts::orgs_of(&app.db, me.id).await?;
655 
    Ok(Json(orgs.into_iter().map(|(o, role)| hub_api::UserOrg { name: o.name, display_name: o.display_name, role }).collect()))
b64e2537 Andy McCall ↶ 656 
}
657
658 
async fn create_repo(
659 
    State(app): State<Shared>,
660 
    headers: HeaderMap,
661 
    Json(body): Json<NewRepository>,
662 
) -> Result<(StatusCode, Json<Repository>), ApiError> {
663 
    let c = caller(&app, &headers).await?;
664 
    let me = c.require("repo:admin")?;
665 
    let name = RepoName::new(&body.owner, &body.name).ok_or_else(|| ApiError(StatusCode::BAD_REQUEST, "invalid owner or name".into()))?;
66fd9d6b Andy McCall ↶ 666 
    if name.name.ends_with(crate::wiki::SUFFIX) {
667 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a name cannot end in .wiki: that is the address of a repository's wiki".into()));
668 
    }
b64e2537 Andy McCall ↶ 669 
    if !auth::roles::may_create_under(&app.db, me, &name.owner).await? {
670 
        return Err(forbidden("you cannot create repositories under that owner"));
671 
    }
672 
    if db::repos::get(&app.db, &name.owner, &name.name).await?.is_some() || app.repos.exists(&name) {
673 
        return Err(ApiError(StatusCode::CONFLICT, "that repository exists".into()));
674 
    }
675 
    app.repos.create(&name, None)?;
676 
    let row = db::repos::create(&app.db, &name.owner, &name.name, &body.description, body.visibility).await?;
677 
    db::accounts::audit(&app.db, Some(me), "repo.created", &name.to_string(), "api").await.ok();
678 
    Ok((StatusCode::CREATED, Json(repository(&app, &row))))
679 
}
680
681 
async fn get_repo(
682 
    State(app): State<Shared>,
683 
    headers: HeaderMap,
684 
    Path((owner, name)): Path<(String, String)>,
685 
) -> Result<Json<Repository>, ApiError> {
686 
    let c = caller(&app, &headers).await?;
687 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
688 
    Ok(Json(repository(&app, &row)))
689 
}
690
691 
async fn bookmarks(
692 
    State(app): State<Shared>,
693 
    headers: HeaderMap,
694 
    Path((owner, name)): Path<(String, String)>,
695 
) -> Result<Json<Vec<Bookmark>>, ApiError> {
696 
    let c = caller(&app, &headers).await?;
697 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
698 
    let default = row.default_bookmark.clone();
699 
    let list = app.repos.read(&repo, move |r, cache| view::bookmarks(r, cache, &default)).await?;
700 
    Ok(Json(list.into_iter().map(|b| Bookmark { name: b.name, heads: b.heads, changes: b.changes, default: b.default }).collect()))
701 
}
702
e7158350 Andy McCall ↶ 703 
#[derive(serde::Deserialize)]
d3b048b2 Andy McCall ↶ 704 
struct BackupSetting {
705 
    /// `owner` (with its owner's), `hourly`, `daily` or `off`.
706 
    backup: String,
707 
}
708
709 
/// `PUT /repos/{owner}/{name}/backup {"backup": ...}`: this repository's
710 
/// backup (docs/backups.md §5). Owners and admins.
711 
async fn set_backup(
712 
    State(app): State<Shared>,
713 
    headers: HeaderMap,
714 
    Path((owner, name)): Path<(String, String)>,
715 
    Json(b): Json<BackupSetting>,
716 
) -> Result<Json<serde_json::Value>, ApiError> {
717 
    let c = caller(&app, &headers).await?;
718 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Maintain).await?;
719 
    let setting = match b.backup.as_str() {
720 
        "owner" => "",
721 
        "hourly" | "daily" | "off" => b.backup.as_str(),
722 
        _ => return Err(ApiError(StatusCode::BAD_REQUEST, "backup is owner, hourly, daily or off".into())),
723 
    };
724 
    db::repos::set_backup(&app.db, row.id, setting).await?;
725 
    db::accounts::audit(&app.db, c.account.as_ref(), "repo.backup", &format!("{owner}/{name}"), &b.backup).await.ok();
726 
    Ok(Json(serde_json::json!({ "backup": b.backup })))
727 
}
728
729 
#[derive(serde::Deserialize)]
e7158350 Andy McCall ↶ 730 
struct DiffusionSetting {
731 
    /// `off`, `green`, `any`, or `default` (the site's).
732 
    follow: String,
f4d6ef41 Andy McCall ↶ 733 
    /// `auto` or `propose`; absent keeps it as it is.
734 
    #[serde(default)]
735 
    land: Option<String>,
e7158350 Andy McCall ↶ 736 
}
737
738 
/// `PUT /repos/{owner}/{name}/diffusion {"follow": ...}`: whether this
739 
/// repository follows the upstreams it pins (#148). Owners and admins.
740 
async fn set_diffusion(
741 
    State(app): State<Shared>,
742 
    headers: HeaderMap,
743 
    Path((owner, name)): Path<(String, String)>,
744 
    Json(d): Json<DiffusionSetting>,
745 
) -> Result<Json<serde_json::Value>, ApiError> {
746 
    let c = caller(&app, &headers).await?;
747 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Maintain).await?;
748 
    let setting = match d.follow.as_str() {
749 
        "off" | "green" | "any" => d.follow.as_str(),
750 
        "default" => "",
751 
        _ => return Err(ApiError(StatusCode::BAD_REQUEST, "follow is off, green, any or default".into())),
f4d6ef41 Andy McCall ↶ 752 
    };
753 
    let land = match d.land.as_deref() {
754 
        Some(l @ ("auto" | "propose")) => Some(l),
755 
        None => None,
756 
        Some(_) => return Err(ApiError(StatusCode::BAD_REQUEST, "land is auto or propose".into())),
e7158350 Andy McCall ↶ 757 
    };
758 
    db::repos::set_diffusion(&app.db, row.id, setting).await?;
f4d6ef41 Andy McCall ↶ 759 
    if let Some(l) = land {
760 
        db::repos::set_diffusion_land(&app.db, row.id, l).await?;
761 
    }
e7158350 Andy McCall ↶ 762 
    db::accounts::audit(
763 
        &app.db,
764 
        c.account.as_ref(),
765 
        "repo.diffusion",
766 
        &format!("{owner}/{name}"),
767 
        if setting.is_empty() { "default" } else { setting },
768 
    )
769 
    .await
770 
    .ok();
771 
    let row = db::repos::get_by_id(&app.db, row.id).await?.unwrap_or(row);
772 
    let rule = crate::diffusion::rule(&app.config.diffusion.follow, &row, None, "");
3776b70d Andy McCall ↶ 773 
    // Turned on: bumped at once to where its upstreams are (#148).
774 
    if rule.follow != crate::diffusion::Follow::Off {
775 
        let (app, row) = (app.clone(), row.clone());
776 
        tokio::spawn(async move { crate::diffusion::catch_up(&app, &row).await });
777 
    }
f4d6ef41 Andy McCall ↶ 778 
    if land == Some("auto") {
779 
        let (app, row) = (app.clone(), row.clone());
780 
        tokio::spawn(async move { crate::diffusion::land_ready(&app, &row).await });
781 
    }
782 
    Ok(Json(
783 
        serde_json::json!({ "follow": rule.follow, "from": rule.from, "land": if row.diffusion_land == "auto" { "auto" } else { "propose" } }),
784 
    ))
e7158350 Andy McCall ↶ 785 
}
786
f677d627 Andy McCall ↶ 787 
/// `GET /repos/{owner}/{name}/consumers`: the repositories that pin this
788 
/// one as a subrepo and that the caller may read, each with its pin and
789 
/// how far behind this repository's default bookmark it is (#148).
790 
async fn consumers(
791 
    State(app): State<Shared>,
792 
    headers: HeaderMap,
793 
    Path((owner, name)): Path<(String, String)>,
794 
) -> Result<Json<Vec<crate::diffusion::Consumer>>, ApiError> {
795 
    let c = caller(&app, &headers).await?;
796 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
797 
    Ok(Json(crate::diffusion::consumers(&app, &row, c.account.as_ref()).await?))
798 
}
799
eb2a3502 Andy McCall ↶ 800 
/// `GET /repos/{owner}/{name}/diffusion`: what this repository takes from
801 
/// and what it diffuses to, as its Diffusion tab shows them (#153).
802 
async fn diffusion(
803 
    State(app): State<Shared>,
804 
    headers: HeaderMap,
805 
    Path((owner, name)): Path<(String, String)>,
806 
) -> Result<Json<hub_api::Diffusion>, ApiError> {
807 
    let c = caller(&app, &headers).await?;
808 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
809 
    let slug = format!("{owner}/{name}");
810 
    let takes_from = crate::diffusion::follows(&app, &row, c.account.as_ref())
811 
        .await
812 
        .iter()
813 
        .map(|(up, p)| p.api(&format!("{}/{}", up.owner, up.name)))
814 
        .collect();
815 
    let diffuses_to = crate::diffusion::consumers(&app, &row, c.account.as_ref()).await?.iter().map(|p| p.api(&slug)).collect();
816 
    Ok(Json(hub_api::Diffusion { takes_from, diffuses_to }))
817 
}
818
b64e2537 Andy McCall ↶ 819 
async fn tags(
820 
    State(app): State<Shared>,
821 
    headers: HeaderMap,
822 
    Path((owner, name)): Path<(String, String)>,
823 
) -> Result<Json<Vec<Tag>>, ApiError> {
824 
    let c = caller(&app, &headers).await?;
825 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
826 
    let list = app.repos.read(&repo, |r, _| view::tags(r)).await?;
827 
    Ok(Json(list.into_iter().map(|t| Tag { name: t.name, heads: t.heads, message: t.message, signer: t.signer }).collect()))
828 
}
829
ba0a55bb Andy McCall ↶ 830 
/// `POST …/tags` (#295): what the Tags page's Create does.
831 
async fn create_tag(
832 
    State(app): State<Shared>,
833 
    headers: HeaderMap,
834 
    Path((owner, name)): Path<(String, String)>,
835 
    Json(body): Json<NewTag>,
836 
) -> Result<(StatusCode, Json<Tag>), ApiError> {
837 
    let c = caller(&app, &headers).await?;
838 
    let me = c.require("repo:write")?.clone();
839 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
840 
    let made = crate::tags::create(
841 
        &app,
842 
        &row,
843 
        &repo,
844 
        &me,
845 
        &body.name,
846 
        body.target.as_deref().unwrap_or(""),
847 
        body.message.as_deref().unwrap_or(""),
848 
    )
849 
    .await
850 
    .map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
851 
    let t = app
852 
        .repos
853 
        .read(&repo, |r, _| view::tags(r))
854 
        .await?
855 
        .into_iter()
856 
        .find(|t| t.name == made.name)
857 
        .ok_or_else(|| not_found("no such tag"))?;
858 
    Ok((StatusCode::CREATED, Json(Tag { name: t.name, heads: t.heads, message: t.message, signer: t.signer })))
859 
}
860
861 
#[derive(Deserialize)]
862 
struct WithdrawQuery {
863 
    #[serde(default)]
864 
    reason: String,
865 
}
866
867 
/// `DELETE …/tags/{tag}?reason=…` (#301): what the Tags page's Withdraw
868 
/// does. Maintainers; refused (409) while a release uses the tag.
869 
async fn withdraw_tag(
870 
    State(app): State<Shared>,
871 
    headers: HeaderMap,
872 
    Path((owner, name, tag)): Path<(String, String, String)>,
873 
    Query(q): Query<WithdrawQuery>,
874 
) -> Result<StatusCode, ApiError> {
875 
    let c = caller(&app, &headers).await?;
876 
    let me = c.require("repo:write")?.clone();
877 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Maintain).await?;
878 
    if db::releases::get(&app.db, row.id, &tag).await?.is_some() {
879 
        return Err(ApiError(StatusCode::CONFLICT, format!("a release uses {tag}: delete the release first")));
880 
    }
881 
    crate::tags::withdraw(&app, &row, &repo, &me, &tag, &q.reason).await.map_err(|m| ApiError(StatusCode::BAD_REQUEST, m))?;
882 
    Ok(StatusCode::NO_CONTENT)
883 
}
884
b64e2537 Andy McCall ↶ 885 
#[derive(Deserialize)]
886 
struct HistoryQuery {
887 
    path: Option<String>,
888 
    offset: Option<usize>,
889 
    limit: Option<usize>,
f28389bd Andy McCall ↶ 890 
    /// A revset (Oxygen's docs/revset_query_language.md) in place of the
891 
    /// reference's whole history; the reference still gives the labels.
892 
    r: Option<String>,
b64e2537 Andy McCall ↶ 893 
}
894
895 
async fn history(
896 
    State(app): State<Shared>,
897 
    headers: HeaderMap,
898 
    Path((owner, name, r)): Path<(String, String, String)>,
899 
    Query(q): Query<HistoryQuery>,
900 
) -> Result<Json<History>, ApiError> {
901 
    let c = caller(&app, &headers).await?;
902 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
903 
    let (offset, limit) = (q.offset.unwrap_or(0), q.limit.unwrap_or(50).min(500));
f28389bd Andy McCall ↶ 904 
    let revset = q.r.clone().filter(|s| !s.trim().is_empty());
905 
    let by_revset = revset.is_some();
b64e2537 Andy McCall ↶ 906 
    let h = app
907 
        .repos
908 
        .read(&repo, move |repo, cache| {
909 
            let target = view::resolve(repo, cache, &r)?;
f28389bd Andy McCall ↶ 910 
            match &revset {
911 
                Some(rs) => view::history_revset(repo, cache, target, rs, offset, limit),
912 
                None => view::history(repo, cache, target, q.path.as_deref(), offset, limit),
913 
            }
b64e2537 Andy McCall ↶ 914 
        })
f28389bd Andy McCall ↶ 915 
        .await
916 
        .map_err(|e| {
917 
            // A revset that does not parse, names nothing, or goes past the
918 
            // budget is the caller's to fix.
919 
            if by_revset {
920 
                ApiError(StatusCode::BAD_REQUEST, e.to_string())
921 
            } else {
922 
                e.into()
923 
            }
924 
        })?;
b64e2537 Andy McCall ↶ 925 
    let mut entries = h.entries;
926 
    crate::web::attribute(&app, &mut entries.iter_mut().collect::<Vec<_>>()).await;
927 
    Ok(Json(History {
928 
        reference: h.target.label,
929 
        heads: h.target.heads.iter().map(|x| x.to_hex()).collect(),
930 
        total: h.total,
931 
        offset: h.offset,
932 
        changes: entries.iter().map(summary).collect(),
933 
    }))
934 
}
935
936 
async fn change(
937 
    State(app): State<Shared>,
938 
    headers: HeaderMap,
939 
    Path((owner, name, hash)): Path<(String, String, String)>,
940 
) -> Result<Json<ChangeDetail>, ApiError> {
941 
    let c = caller(&app, &headers).await?;
942 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
943 
    let d = app
944 
        .repos
945 
        .read(&repo, move |repo, cache| {
946 
            let h = view::resolve_change(repo, cache, &hash)?;
947 
            view::change(repo, cache, &h)
948 
        })
949 
        .await?;
950 
    let mut v = d.view;
951 
    crate::web::attribute(&app, &mut [&mut v]).await;
952 
    let files = crate::web::history::render_files(&d.files, &d.bases)
953 
        .into_iter()
954 
        .map(|f| FileChange { path: f.path, kind: f.kind, from: f.from, added: f.added, removed: f.removed })
955 
        .collect();
956 
    Ok(Json(ChangeDetail {
957 
        body: v.body.clone(),
958 
        change: summary(&v),
959 
        dependents: d.dependents.iter().map(|x| x.hash.clone()).collect(),
960 
        in_bookmarks: d.in_bookmarks,
961 
        in_tags: d.in_tags,
962 
        files,
963 
    }))
964 
}
965
966 
fn entry(e: &view::Entry) -> TreeEntry {
967 
    TreeEntry {
968 
        name: e.name.clone(),
969 
        path: e.path.clone(),
970 
        kind: match e.kind {
971 
            view::EntryKind::Dir => "dir",
972 
            view::EntryKind::File => "file",
973 
            view::EntryKind::Symlink => "symlink",
974 
            view::EntryKind::Subrepo => "subrepo",
975 
        }
976 
        .into(),
977 
        exec: e.exec,
978 
        size: e.size,
979 
        conflicted: e.conflicted,
980 
    }
981 
}
982
983 
async fn tree_root(
984 
    State(app): State<Shared>,
985 
    headers: HeaderMap,
986 
    Path((owner, name, r)): Path<(String, String, String)>,
987 
) -> Result<Json<Vec<TreeEntry>>, ApiError> {
988 
    tree(State(app), headers, Path((owner, name, r, String::new()))).await
989 
}
990
991 
async fn tree(
992 
    State(app): State<Shared>,
993 
    headers: HeaderMap,
994 
    Path((owner, name, r, path)): Path<(String, String, String, String)>,
995 
) -> Result<Json<Vec<TreeEntry>>, ApiError> {
996 
    let c = caller(&app, &headers).await?;
997 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
998 
    let t = app
999 
        .repos
1000 
        .read(&repo, move |repo, cache| {
1001 
            let target = view::resolve(repo, cache, &r)?;
1002 
            view::tree(repo, cache, target, &path)
1003 
        })
1004 
        .await?;
1005 
    Ok(Json(t.entries.iter().map(entry).collect()))
1006 
}
1007
1008 
async fn file(
1009 
    State(app): State<Shared>,
1010 
    headers: HeaderMap,
1011 
    Path((owner, name, r, path)): Path<(String, String, String, String)>,
1012 
) -> Result<Response, ApiError> {
1013 
    let c = caller(&app, &headers).await?;
1014 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1015 
    let limit = app.config.limits.render_limit.0;
1016 
    let f = app
1017 
        .repos
1018 
        .read(&repo, move |repo, cache| {
1019 
            let target = view::resolve(repo, cache, &r)?;
1020 
            view::file(repo, cache, target, &path, limit)
1021 
        })
1022 
        .await?;
1023 
    Ok(crate::web::raw(f.bytes, &f.name, false))
1024 
}
1025
1026 
async fn blame(
1027 
    State(app): State<Shared>,
1028 
    headers: HeaderMap,
1029 
    Path((owner, name, r, path)): Path<(String, String, String, String)>,
1030 
) -> Result<Json<Vec<BlameLine>>, ApiError> {
1031 
    let c = caller(&app, &headers).await?;
1032 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1033 
    let limit = app.config.limits.render_limit.0;
1034 
    let b = app
1035 
        .repos
1036 
        .read(&repo, move |repo, cache| {
1037 
            let target = view::resolve(repo, cache, &r)?;
1038 
            view::blame(repo, cache, target, &path, limit)
1039 
        })
1040 
        .await?;
1041 
    Ok(Json(
1042 
        b.lines
1043 
            .into_iter()
1044 
            .map(|l| BlameLine {
1045 
                line: l.line,
1046 
                change: l.hash.to_hex(),
1047 
                index: l.index,
1048 
                author: l.author,
1049 
                when_ms: l.when_ms,
1050 
                text: String::from_utf8_lossy(&l.text).into_owned(),
1051 
            })
1052 
            .collect(),
1053 
    ))
1054 
}
1055
1056 
async fn conflicts(
1057 
    State(app): State<Shared>,
1058 
    headers: HeaderMap,
1059 
    Path((owner, name)): Path<(String, String)>,
1060 
) -> Result<Json<Vec<Conflict>>, ApiError> {
1061 
    let c = caller(&app, &headers).await?;
1062 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1063 
    let list = app.repos.read(&repo, view::conflicts).await?;
1064 
    Ok(Json(
1065 
        list.into_iter()
1066 
            .map(|c| Conflict {
1067 
                bookmark: c.bookmark,
1068 
                path: c.path,
1069 
                kind: c.kind,
1070 
                contributors: c.contributors.iter().map(|x| x.hash.clone()).collect(),
1071 
            })
1072 
            .collect(),
1073 
    ))
df940d75 Andy McCall ↶ 1074 
}
1075
1076 
/// `GET /repos/{o}/{n}/releases/trust/{tag}`: a release's trust report
1077 
/// (hub spec §9.1), as the page's JSON export.
1078 
async fn release_trust(
1079 
    State(app): State<Shared>,
1080 
    headers: HeaderMap,
1081 
    Path((owner, name, tag)): Path<(String, String, String)>,
1082 
) -> Result<Json<crate::web::release_trust::ReleaseTrust>, ApiError> {
1083 
    let c = caller(&app, &headers).await?;
1084 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1085 
    match crate::web::release_trust::report(&app, &repo, &row, &tag).await.map_err(|m| ApiError(StatusCode::INTERNAL_SERVER_ERROR, m))? {
1086 
        Some(t) => Ok(Json(t)),
1087 
        None => Err(ApiError(StatusCode::NOT_FOUND, format!("no release {tag}"))),
1088 
    }
b64e2537 Andy McCall ↶ 1089 
}
1090
1091 
async fn trust(
1092 
    State(app): State<Shared>,
1093 
    headers: HeaderMap,
1094 
    Path((owner, name)): Path<(String, String)>,
1095 
) -> Result<Json<Trust>, ApiError> {
1096 
    let c = caller(&app, &headers).await?;
1097 
    let (repo, _, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1098 
    let key = app.hub_key.key;
1099 
    let t = app.repos.read(&repo, move |r, cache| view::trust(r, cache, &key)).await?;
1100 
    Ok(Json(Trust {
1101 
        policy: t.policy.map(|p| Policy {
1102 
            serial: p.serial,
1103 
            expires_ms: p.expires_ms,
1104 
            roots: p.roots.iter().map(|k| k.key.clone()).collect(),
1105 
            root_threshold: p.root_threshold,
1106 
            rules: p
1107 
                .rules
1108 
                .iter()
1109 
                .map(|r| Rule {
1110 
                    pattern: r.pattern.clone(),
1111 
                    keys: r.keys.iter().map(|k| k.key.clone()).collect(),
1112 
                    threshold: r.threshold,
1113 
                    require: r.require.clone(),
1114 
                    allow_conflicts: r.allow_conflicts,
1115 
                })
1116 
                .collect(),
1117 
        }),
1118 
        signed: t.verification.signed,
1119 
        sealed: t.verification.sealed,
1120 
        unsigned: t.verification.unsigned,
1121 
        invalid: t.verification.invalid.iter().map(|(h, _)| h.clone()).collect(),
1122 
        hub_key: t.hub_key,
1123 
    }))
1124 
}
1125
1126 
async fn pushes(
1127 
    State(app): State<Shared>,
1128 
    headers: HeaderMap,
1129 
    Path((owner, name)): Path<(String, String)>,
1130 
) -> Result<Json<Vec<Push>>, ApiError> {
1131 
    let c = caller(&app, &headers).await?;
1132 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1133 
    let rows = db::repos::pushes(&app.db, row.id, 200).await?;
1134 
    Ok(Json(
1135 
        rows.into_iter()
1136 
            .map(|p| Push {
1137 
                at_ms: p.at_ms,
1138 
                pusher: p.pusher,
1139 
                reference: p.reference,
1140 
                ok: p.ok,
1141 
                reason: p.reason,
1142 
                old_state: p.old_state,
1143 
                new_state: p.new_state,
1144 
                heads: p.heads,
1145 
                changes: p.changes,
1146 
            })
1147 
            .collect(),
1148 
    ))
de505df5 Andy McCall ↶ 1149 
}
1150
b64e2537 Andy McCall ↶ 1151 
// --------------------------------------------------------------- proposals
1152
0b20f1ec Andy McCall ↶ 1153 
/// `GET /repos/{o}/{n}/proposals?state=open|draft|landed|closed|all`:
1154 
/// open ones (drafts too) by default.
de505df5 Andy McCall ↶ 1155 
async fn proposals(
1156 
    State(app): State<Shared>,
b64e2537 Andy McCall ↶ 1157 
    headers: HeaderMap,
de505df5 Andy McCall ↶ 1158 
    Path((owner, name)): Path<(String, String)>,
0b20f1ec Andy McCall ↶ 1159 
    Query(q): Query<IssuesQuery>,
b64e2537 Andy McCall ↶ 1160 
) -> Result<Json<Vec<Proposal>>, ApiError> {
1161 
    let c = caller(&app, &headers).await?;
1162 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
0b20f1ec Andy McCall ↶ 1163 
    let states: &[&str] = match q.state.as_deref().unwrap_or("open") {
1164 
        "open" => &["open", "draft"],
1165 
        "draft" => &["draft"],
1166 
        "landed" => &["landed"],
1167 
        "closed" => &["closed"],
1168 
        "all" => &["open", "draft", "landed", "closed"],
1169 
        other => return Err(ApiError(StatusCode::BAD_REQUEST, format!("state is open, draft, landed, closed or all, not {other:?}"))),
1170 
    };
46b5e2c5 Andy McCall ↶ 1171 
    // Each proposal's projected state is worked out from the store, which
1172 
    // for a bucket-backed repository is many slow round trips: four at a
1173 
    // time, in order, each under the repository's read lock only. One at
1174 
    // a time took 28 s for a repository on GCS (oxygenhub#171).
1175 
    use futures::StreamExt;
1176 
    let rows = db::proposals::list(&app.db, row.id, states).await?;
1177 
    let out: Vec<Result<Proposal, ApiError>> = futures::stream::iter(rows)
1178 
        .map(|p| {
1179 
            let (app, repo, owner, name, id) = (app.clone(), repo.clone(), owner.clone(), name.clone(), row.id);
1180 
            async move {
3571c519 Andy McCall ↶ 1181 
                let loaded = crate::web::proposals::load_summary(&app, &repo, p).await?;
46b5e2c5 Andy McCall ↶ 1182 
                let v = crate::web::proposals::verdict(&app, &loaded, id).await?;
1183 
                Ok(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, None).await)
1184 
            }
1185 
        })
1186 
        .buffered(4)
1187 
        .collect()
1188 
        .await;
1189 
    Ok(Json(out.into_iter().collect::<Result<Vec<_>, _>>()?))
de505df5 Andy McCall ↶ 1190 
}
1191
1192 
async fn proposal(
1193 
    State(app): State<Shared>,
b64e2537 Andy McCall ↶ 1194 
    headers: HeaderMap,
de505df5 Andy McCall ↶ 1195 
    Path((owner, name, number)): Path<(String, String, i64)>,
b64e2537 Andy McCall ↶ 1196 
) -> Result<Json<Proposal>, ApiError> {
1197 
    let c = caller(&app, &headers).await?;
1198 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1199 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
de505df5 Andy McCall ↶ 1200 
    let source_url = match p.source_repo_id {
1201 
        Some(id) => db::repos::get_by_id(&app.db, id).await?.map(|r| format!("{}/{}", app.config.base_url(), r.slug())),
1202 
        None => None,
1203 
    };
3571c519 Andy McCall ↶ 1204 
    let loaded = crate::web::proposals::load_summary(&app, &repo, p).await?;
de505df5 Andy McCall ↶ 1205 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
1206 
    Ok(Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, source_url).await))
1f1eb06a Andy McCall ↶ 1207 
}
1208
739a763a Andy McCall ↶ 1209 
/// `PATCH /repos/{o}/{n}/proposals/{number}`: change the title or body,
1210 
/// keeping what is not given; the author or a maintainer, as on the page
1211 
/// (oxygenhub#76). The target is changed on the page, which re-projects.
1212 
async fn edit_proposal(
1213 
    State(app): State<Shared>,
1214 
    headers: HeaderMap,
1215 
    Path((owner, name, number)): Path<(String, String, i64)>,
1216 
    Json(body): Json<hub_api::ProposalEdit>,
1217 
) -> Result<Json<Proposal>, ApiError> {
1218 
    let c = caller(&app, &headers).await?;
1219 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
1220 
    let (repo, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1221 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
2291f8cc Andy McCall ↶ 1222 
    let text = body.title.is_some() || body.body.is_some();
1223 
    if text && Some(me.id) != p.author_id && role < Role::Maintain {
739a763a Andy McCall ↶ 1224 
        return Err(ApiError(StatusCode::FORBIDDEN, "only the proposal's author or a maintainer can edit it".into()));
2291f8cc Andy McCall ↶ 1225 
    }
1226 
    if body.labels.is_some() && role < Role::Triage {
1227 
        return Err(forbidden("setting labels needs triage access"));
1228 
    }
1229 
    // Every name is checked before anything changes.
1230 
    let labels = resolve_triage(&app, row.id, body.labels.as_deref(), None, None).await?.labels;
1231 
    if text {
1232 
        let title = match body.title.as_deref().map(str::trim) {
1233 
            Some("") => return Err(ApiError(StatusCode::BAD_REQUEST, "a proposal needs a title".into())),
1234 
            Some(t) => t,
1235 
            None => p.title.as_str(),
1236 
        };
1237 
        let text = body.body.as_deref().map(str::trim).unwrap_or(&p.body);
1238 
        db::proposals::edit(&app.db, p.id, title, text, &p.target).await?;
1239 
        db::proposals::add_event(&app.db, p.id, &me.username, "edited", "").await.ok();
739a763a Andy McCall ↶ 1240 
    }
2291f8cc Andy McCall ↶ 1241 
    if let Some(want) = labels {
1242 
        let have = db::issues::proposal_labels(&app.db, p.id).await?;
1243 
        for l in &have {
1244 
            if !want.iter().any(|w| w.id == l.id) {
1245 
                db::issues::set_proposal_label(&app.db, p.id, l.id, false).await?;
1246 
            }
1247 
        }
1248 
        for w in &want {
1249 
            if !have.iter().any(|l| l.id == w.id) {
1250 
                db::issues::set_proposal_label(&app.db, p.id, w.id, true).await?;
1251 
            }
1252 
        }
1253 
        let names: Vec<&str> = want.iter().map(|l| l.name.as_str()).collect();
1254 
        db::proposals::add_event(&app.db, p.id, &me.username, "set labels", &names.join(", ")).await.ok();
1255 
    }
71e65fcf Andy McCall ↶ 1256 
    if let Some(want) = body.state.as_deref() {
1257 
        if Some(me.id) != p.author_id && role < Role::Triage {
1258 
            return Err(ApiError(
1259 
                StatusCode::FORBIDDEN,
1260 
                "only the proposal's author or someone with triage access can close or reopen it".into(),
1261 
            ));
1262 
        }
1263 
        let new_state = match (want, p.state.as_str()) {
1264 
            ("closed", "open" | "draft") => "closed",
1265 
            ("open", "closed") => "open",
1266 
            (w, now) if w == now => now,
1267 
            ("closed" | "open", now) => {
1268 
                return Err(ApiError(StatusCode::CONFLICT, format!("a proposal that is {now} cannot become {want}")))
1269 
            }
1270 
            _ => return Err(ApiError(StatusCode::BAD_REQUEST, "state is closed or open".into())),
1271 
        };
1272 
        if new_state != p.state {
1273 
            db::proposals::set_state(&app.db, p.id, new_state, "").await?;
1274 
            db::proposals::add_event(&app.db, p.id, &me.username, new_state, "").await.ok();
1275 
            crate::hooks::emit(&app, &row, &format!("proposal.{new_state}"), &me.username, serde_json::json!({ "number": number })).await;
1276 
        }
1277 
    }
739a763a Andy McCall ↶ 1278 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1279 
    let source_url = match p.source_repo_id {
1280 
        Some(id) => db::repos::get_by_id(&app.db, id).await?.map(|r| format!("{}/{}", app.config.base_url(), r.slug())),
1281 
        None => None,
1282 
    };
3571c519 Andy McCall ↶ 1283 
    let loaded = crate::web::proposals::load_summary(&app, &repo, p).await?;
739a763a Andy McCall ↶ 1284 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
1285 
    Ok(Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, source_url).await))
1286 
}
1287
1f1eb06a Andy McCall ↶ 1288 
/// `POST /repos/{o}/{n}/proposals/{number}/land` (repo:write): land it as
1289 
/// the page's Land button does; `409` with the blockers when it cannot.
2a8b6216 Andy McCall ↶ 1290 
/// `{"over_checks": "reason"}` lands over required checks that have not
1291 
/// passed, for maintainers (#261).
1f1eb06a Andy McCall ↶ 1292 
async fn land_proposal(
1293 
    State(app): State<Shared>,
1294 
    headers: HeaderMap,
1295 
    Path((owner, name, number)): Path<(String, String, i64)>,
2a8b6216 Andy McCall ↶ 1296 
    body: axum::body::Bytes,
1f1eb06a Andy McCall ↶ 1297 
) -> Result<Json<Proposal>, ApiError> {
1298 
    let c = caller(&app, &headers).await?;
1299 
    let me = c.require("repo:write")?.clone();
2a8b6216 Andy McCall ↶ 1300 
    let over_checks: Option<String> = if body.iter().all(u8::is_ascii_whitespace) {
1301 
        None
1302 
    } else {
1303 
        serde_json::from_slice::<serde_json::Value>(&body)
1304 
            .map_err(|_| ApiError(StatusCode::BAD_REQUEST, "the body is JSON: {} or {\"over_checks\": \"reason\"}".into()))?
1305 
            .get("over_checks")
1306 
            .and_then(|v| v.as_str())
1307 
            .map(String::from)
1308 
    };
1309 
    let need = if over_checks.is_some() { Access::Maintain } else { Access::Write };
1310 
    let (repo, row, _) = reach(&app, &c, &owner, &name, need).await?;
0b20f1ec Andy McCall ↶ 1311 
    let via = format!("api (token {})", c.token);
2a8b6216 Andy McCall ↶ 1312 
    match crate::web::proposals::land_as(&app, &repo, &row, &me, number, &via, false, over_checks.as_deref()).await {
1f1eb06a Andy McCall ↶ 1313 
        Ok(_) => proposal(State(app), headers, Path((owner, name, number))).await,
1314 
        Err(crate::web::proposals::Landing::NotFound) => Err(not_found("no such proposal")),
1315 
        Err(crate::web::proposals::Landing::Refused(m)) => Err(ApiError(StatusCode::CONFLICT, m)),
1316 
    }
d23464c0 Andy McCall ↶ 1317 
}
1318
86a69b53 Andy McCall ↶ 1319 
/// `POST /repos/{o}/{n}/proposals/{number}/auto-land` (repo:write, #261):
1320 
/// land it when its checks pass; at once if they already have.
1321 
async fn auto_land_on(
1322 
    State(app): State<Shared>,
1323 
    headers: HeaderMap,
1324 
    Path((owner, name, number)): Path<(String, String, i64)>,
1325 
) -> Result<Json<Proposal>, ApiError> {
1326 
    auto_land_set(&app, &headers, &owner, &name, number, true).await?;
1327 
    proposal(State(app), headers, Path((owner, name, number))).await
1328 
}
1329
1330 
/// `DELETE …/auto-land`: it will not land by itself.
1331 
async fn auto_land_off(
1332 
    State(app): State<Shared>,
1333 
    headers: HeaderMap,
1334 
    Path((owner, name, number)): Path<(String, String, i64)>,
1335 
) -> Result<Json<Proposal>, ApiError> {
1336 
    auto_land_set(&app, &headers, &owner, &name, number, false).await?;
1337 
    proposal(State(app), headers, Path((owner, name, number))).await
1338 
}
1339
1340 
async fn auto_land_set(app: &Shared, headers: &HeaderMap, owner: &str, name: &str, number: i64, on: bool) -> Result<(), ApiError> {
1341 
    let c = caller(app, headers).await?;
1342 
    let me = c.require("repo:write")?.clone();
1343 
    let (_, row, _) = reach(app, &c, owner, name, Access::Write).await?;
1344 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1345 
    if !p.is_open() {
1346 
        return Err(ApiError(StatusCode::CONFLICT, format!("the proposal is {}", p.state)));
1347 
    }
1348 
    crate::autoland::set(app, &row, &p, &me, on).await?;
1349 
    Ok(())
1350 
}
1351
3f02e5ea Andy McCall ↶ 1352 
/// The files a proposal changes (hub spec §12.1).
1353 
async fn proposal_files(
1354 
    State(app): State<Shared>,
1355 
    headers: HeaderMap,
1356 
    Path((owner, name, number)): Path<(String, String, i64)>,
1357 
) -> Result<Json<Vec<hub_api::ProposalFile>>, ApiError> {
1358 
    let c = caller(&app, &headers).await?;
1359 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1360 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1361 
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
1362 
    Ok(Json(
1363 
        loaded
1364 
            .files
1365 
            .iter()
1366 
            .map(|f| hub_api::ProposalFile {
1367 
                path: f.path.clone(),
1368 
                from: f.from.clone(),
1369 
                kind: f.kind.clone(),
1370 
                added: f.added,
1371 
                removed: f.removed,
1372 
            })
1373 
            .collect(),
1374 
    ))
1375 
}
1376
1377 
/// One file's bytes on a side of a proposal: `base` is the target's
1378 
/// state, `head` the projected state. 404 when the file does not exist
1379 
/// on that side.
1380 
async fn proposal_content(
1381 
    State(app): State<Shared>,
1382 
    headers: HeaderMap,
1383 
    Path((owner, name, number, side, path)): Path<(String, String, i64, String, String)>,
1384 
) -> Result<Response, ApiError> {
1385 
    let c = caller(&app, &headers).await?;
1386 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1387 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
3571c519 Andy McCall ↶ 1388 
    let loaded = crate::web::proposals::load_summary(&app, &repo, p).await?;
3f02e5ea Andy McCall ↶ 1389 
    let heads = match side.as_str() {
1390 
        "base" => loaded.target_heads,
1391 
        "head" => loaded.heads,
1392 
        _ => return Err(ApiError(StatusCode::BAD_REQUEST, "the side is base or head".into())),
1393 
    };
1394 
    let limit = app.config.limits.render_limit.0;
1395 
    let target = view::RefTarget { label: side, kind: view::RefKind::Change, heads };
1396 
    let f = app.repos.read(&repo, move |repo, cache| view::file(repo, cache, target, &path, limit)).await?;
1397 
    Ok(crate::web::raw(f.bytes, &f.name, false))
1398 
}
1399
b64e2537 Andy McCall ↶ 1400 
async fn create_proposal(
1401 
    State(app): State<Shared>,
1402 
    headers: HeaderMap,
1403 
    Path((owner, name)): Path<(String, String)>,
1404 
    Json(body): Json<NewProposal>,
1405 
) -> Result<(StatusCode, Json<Proposal>), ApiError> {
1406 
    let c = caller(&app, &headers).await?;
1407 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
1408 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1409 
    let created =
1410 
        crate::web::proposals::open_proposal(&app, &repo, &row, &me, &body.title, &body.body, &body.target, &body.source, body.draft)
1411 
            .await
1412 
            .map_err(|e| ApiError(StatusCode::BAD_REQUEST, e))?;
3571c519 Andy McCall ↶ 1413 
    let loaded = crate::web::proposals::load_summary(&app, &repo, created).await?;
b64e2537 Andy McCall ↶ 1414 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
1415 
    Ok((StatusCode::CREATED, Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, None).await)))
1416 
}
d23464c0 Andy McCall ↶ 1417
b64e2537 Andy McCall ↶ 1418 
fn comment_of(c: &db::proposals::CommentRow) -> Comment {
1419 
    Comment {
1420 
        id: c.id,
1421 
        author: c.author.clone(),
1422 
        body: c.body.clone(),
1423 
        created_ms: c.created_ms,
1424 
        path: if c.path.is_empty() { None } else { Some(c.path.clone()) },
1425 
        anchor: if c.anchor_change.is_empty() {
1426 
            None
1427 
        } else {
1428 
            Some(Atom { change: c.anchor_change.clone(), index: c.anchor_index as u32 })
1429 
        },
c0fac31d Andy McCall ↶ 1430 
        line: None,
b64e2537 Andy McCall ↶ 1431 
        resolved: c.resolved,
d23464c0 Andy McCall ↶ 1432 
    }
1433 
}
1434
b64e2537 Andy McCall ↶ 1435 
async fn proposal_comments(
1436 
    State(app): State<Shared>,
1437 
    headers: HeaderMap,
1438 
    Path((owner, name, number)): Path<(String, String, i64)>,
1439 
) -> Result<Json<Vec<Comment>>, ApiError> {
1440 
    let c = caller(&app, &headers).await?;
1441 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1442 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
c0fac31d Andy McCall ↶ 1443 
    let mut out: Vec<Comment> = db::proposals::comments(&app.db, p.id).await?.iter().map(comment_of).collect();
1444 
    // Place anchored comments on their line of the projected state.
1445 
    let paths: std::collections::BTreeSet<String> = out.iter().filter(|c| c.anchor.is_some()).filter_map(|c| c.path.clone()).collect();
1446 
    if !paths.is_empty() {
1447 
        let repo = RepoName::new(&owner, &name).ok_or_else(|| not_found("no such repository"))?;
3571c519 Andy McCall ↶ 1448 
        let heads = crate::web::proposals::load_summary(&app, &repo, p).await?.heads;
c0fac31d Andy McCall ↶ 1449 
        let lines = app
1450 
            .repos
1451 
            .read(&repo, move |r, _| {
1452 
                let mut at = std::collections::HashMap::new();
1453 
                for path in paths {
1454 
                    // A file the projection removed has no lines to place a comment on.
1455 
                    for l in r.blame_in(&path, &heads).unwrap_or_default() {
1456 
                        at.insert((path.clone(), l.hash.to_hex(), l.index), l.line);
1457 
                    }
1458 
                }
1459 
                Ok(at)
1460 
            })
1461 
            .await?;
1462 
        for c in &mut out {
1463 
            if let (Some(path), Some(a)) = (&c.path, &c.anchor) {
1464 
                c.line = lines.get(&(path.clone(), a.change.clone(), a.index)).copied();
1465 
            }
1466 
        }
1467 
    }
1468 
    Ok(Json(out))
b64e2537 Andy McCall ↶ 1469 
}
1470
1471 
async fn proposal_comment(
1472 
    State(app): State<Shared>,
1473 
    headers: HeaderMap,
1474 
    Path((owner, name, number)): Path<(String, String, i64)>,
1475 
    Json(body): Json<NewComment>,
1476 
) -> Result<(StatusCode, Json<Comment>), ApiError> {
1477 
    let c = caller(&app, &headers).await?;
1478 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
1479 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1480 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1481 
    if body.body.trim().is_empty() {
1482 
        return Err(ApiError(StatusCode::BAD_REQUEST, "an empty comment says nothing".into()));
1483 
    }
3f4b0ea6 Andy McCall ↶ 1484 
    let (repo, _) = (RepoName::new(&owner, &name).ok_or_else(|| not_found("no such repository"))?, ());
1485 
    let anchor = match (body.path.as_deref().map(|x| x.trim_matches('/')), body.line) {
1486 
        (Some(path), Some(line)) if !path.is_empty() => {
1487 
            let loaded = crate::web::proposals::load(&app, &repo, p.clone()).await?;
1488 
            let (heads, file) = (loaded.heads.clone(), path.to_string());
1489 
            let atom = app
1490 
                .repos
1491 
                .read(&repo, move |r, cache| {
1492 
                    let projected = cache.load(r, &heads)?;
1493 
                    Ok(crate::repos::proposals::atom_at(&projected, &file, line).map(|(h, i)| (h.to_hex(), i)))
1494 
                })
1495 
                .await?
1496 
                .ok_or_else(|| ApiError(StatusCode::BAD_REQUEST, format!("{path}:{line} is not a line of the projected state")))?;
1497 
            Some((path.to_string(), atom))
1498 
        }
1499 
        _ => None,
1500 
    };
1501 
    let row_c = db::proposals::add_comment(
1502 
        &app.db,
1503 
        p.id,
1504 
        Some(me.id),
1505 
        &me.username,
1506 
        body.body.trim(),
1507 
        anchor.as_ref().map(|(path, _)| path.as_str()).unwrap_or(""),
1508 
        anchor.as_ref().map(|(_, (h, i))| (h.as_str(), *i as i64)),
1509 
    )
1510 
    .await?;
b64e2537 Andy McCall ↶ 1511 
    crate::notify::deliver(
1512 
        &app,
1513 
        crate::notify::Event {
1514 
            kind: "proposal.comment",
1515 
            title: format!("{owner}/{name}#{number}: {}", p.title),
1516 
            url: format!("/{owner}/{name}/proposal/{number}"),
1517 
            actor: &me,
1518 
            repo_id: row.id,
1519 
            thread: Some(("proposal", p.id)),
1520 
            mention_text: &body.body,
1521 
            direct: p.author_id.into_iter().collect(),
1522 
        },
1523 
    )
1524 
    .await;
1525 
    crate::hooks::emit(
1526 
        &app,
1527 
        &row,
1528 
        "comment.proposal",
1529 
        &me.username,
1530 
        serde_json::json!({ "number": number, "comment": comment_of(&row_c) }),
1531 
    )
1532 
    .await;
c0fac31d Andy McCall ↶ 1533 
    let mut created = comment_of(&row_c);
1534 
    created.line = created.anchor.as_ref().and(body.line);
1535 
    Ok((StatusCode::CREATED, Json(created)))
b64e2537 Andy McCall ↶ 1536 
}
1537
1538 
async fn proposal_reviews(
1539 
    State(app): State<Shared>,
1540 
    headers: HeaderMap,
1541 
    Path((owner, name, number)): Path<(String, String, i64)>,
1542 
) -> Result<Json<Vec<Review>>, ApiError> {
1543 
    let c = caller(&app, &headers).await?;
1544 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1545 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
3571c519 Andy McCall ↶ 1546 
    let loaded = crate::web::proposals::load_summary(&app, &repo, p).await?;
b64e2537 Andy McCall ↶ 1547 
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
1548 
    Ok(Json(
1549 
        v.reviews
1550 
            .into_iter()
1551 
            .map(|r| Review {
1552 
                id: r.row.id,
1553 
                author: r.row.author,
1554 
                verdict: r.row.verdict,
1555 
                body: r.row.body,
1556 
                sealed: r.sealed,
1557 
                created_ms: r.row.created_ms,
7d2eb590 Andy McCall ↶ 1558 
                via: r.row.via,
b64e2537 Andy McCall ↶ 1559 
            })
1560 
            .collect(),
1561 
    ))
1562 
}
1563
1564 
async fn proposal_review(
1565 
    State(app): State<Shared>,
1566 
    headers: HeaderMap,
1567 
    Path((owner, name, number)): Path<(String, String, i64)>,
1568 
    Json(body): Json<NewReview>,
1569 
) -> Result<(StatusCode, Json<Review>), ApiError> {
1570 
    let c = caller(&app, &headers).await?;
1571 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
1572 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1573 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1574 
    if !matches!(body.verdict.as_str(), "comment" | "changes" | "approve") {
1575 
        return Err(ApiError(StatusCode::BAD_REQUEST, "verdict is comment, changes or approve".into()));
1576 
    }
1577 
    if body.verdict == "approve" && Some(me.id) == p.author_id {
1578 
        return Err(forbidden("you cannot approve your own proposal"));
1579 
    }
1580 
    let r = db::proposals::add_review(&app.db, p.id, me.id, &me.username, &body.verdict, body.body.trim()).await?;
1581 
    db::proposals::add_event(&app.db, p.id, &me.username, &format!("review.{}", body.verdict), "").await.ok();
cc1cd197 Andy McCall ↶ 1582 
    crate::web::proposals::reviewed(&app, &row, &p, &me, &body.verdict).await;
b64e2537 Andy McCall ↶ 1583 
    crate::hooks::emit(&app, &row, "review", &me.username, serde_json::json!({ "number": number, "verdict": body.verdict })).await;
1584 
    Ok((
1585 
        StatusCode::CREATED,
7d2eb590 Andy McCall ↶ 1586 
        Json(Review { id: r.id, author: r.author, verdict: r.verdict, body: r.body, sealed: false, created_ms: r.created_ms, via: r.via }),
b64e2537 Andy McCall ↶ 1587 
    ))
1588 
}
1589
cc1cd197 Andy McCall ↶ 1590 
/// `POST .../proposals/{number}/reviewers`: ask accounts to review (the
1591 
/// author, or a writer). Answers with everyone asked now.
1592 
async fn request_reviewers(
1593 
    State(app): State<Shared>,
1594 
    headers: HeaderMap,
1595 
    Path((owner, name, number)): Path<(String, String, i64)>,
1596 
    Json(body): Json<ReviewRequest>,
1597 
) -> Result<Json<Vec<String>>, ApiError> {
1598 
    let c = caller(&app, &headers).await?;
1599 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
1600 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1601 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1602 
    if Some(me.id) != p.author_id && role < Role::Write {
1603 
        return Err(forbidden("only the author or a writer asks for reviews"));
1604 
    }
1605 
    if !p.is_open() {
1606 
        return Err(ApiError(StatusCode::CONFLICT, "the proposal is not open".into()));
1607 
    }
1608 
    crate::web::proposals::request_reviewers(&app, &row, &p, &me, &body.reviewers)
1609 
        .await
1610 
        .map_err(|e| ApiError(StatusCode::UNPROCESSABLE_ENTITY, e))?;
1611 
    Ok(Json(db::proposals::review_requests(&app.db, p.id).await?))
1612 
}
1613
1614 
/// `DELETE .../proposals/{number}/reviewers/{username}`: withdraw a request.
1615 
async fn withdraw_reviewer(
1616 
    State(app): State<Shared>,
1617 
    headers: HeaderMap,
1618 
    Path((owner, name, number, username)): Path<(String, String, i64, String)>,
1619 
) -> Result<StatusCode, ApiError> {
1620 
    let c = caller(&app, &headers).await?;
1621 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
1622 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1623 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
1624 
    if Some(me.id) != p.author_id && role < Role::Write {
1625 
        return Err(forbidden("only the author or a writer withdraws review requests"));
1626 
    }
1627 
    let a = db::accounts::account_by_name(&app.db, &username).await?.ok_or_else(|| not_found("no such account"))?;
1628 
    if db::proposals::unrequest_review(&app.db, p.id, a.id).await? {
1629 
        db::proposals::add_event(&app.db, p.id, &me.username, "review request withdrawn", &a.username).await.ok();
1630 
    }
1631 
    Ok(StatusCode::NO_CONTENT)
1632 
}
1633
b64e2537 Andy McCall ↶ 1634 
async fn proposal_checks(
1635 
    State(app): State<Shared>,
1636 
    headers: HeaderMap,
1637 
    Path((owner, name, number)): Path<(String, String, i64)>,
1638 
) -> Result<Json<Vec<Check>>, ApiError> {
1639 
    let c = caller(&app, &headers).await?;
1640 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1641 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
3571c519 Andy McCall ↶ 1642 
    let loaded = crate::web::proposals::load_summary(&app, &repo, p).await?;
b64e2537 Andy McCall ↶ 1643 
    Ok(Json(db::hooks::checks_for_state(&app.db, row.id, &loaded.state).await?.iter().map(check_of).collect()))
1644 
}
1645
1646 
// ------------------------------------------------------------------ issues
1647
1648 
async fn issue_of(app: &Shared, row: &db::repos::RepoRow, i: &db::issues::IssueRow) -> Result<Issue, ApiError> {
1649 
    let labels = db::issues::issue_labels(&app.db, i.id)
1650 
        .await?
1651 
        .into_iter()
1652 
        .map(|l| Label { name: l.name, colour: l.colour, description: l.description })
1653 
        .collect();
1654 
    let assignees = db::issues::assignees(&app.db, i.id).await?;
1655 
    let milestone = match i.milestone_id {
1656 
        Some(id) => db::issues::milestone(&app.db, id).await?.map(|m| m.title),
1657 
        None => None,
1658 
    };
5d90e0e0 Andy McCall 1659 
    let comments: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM issue_comments WHERE issue_id = $1").bind(i.id).fetch_one(&app.db).await?;
b64e2537 Andy McCall ↶ 1660 
    Ok(Issue {
1661 
        number: i.number,
1662 
        title: i.title.clone(),
1663 
        body: i.body.clone(),
1664 
        author: i.author.clone(),
1665 
        state: i.state.clone(),
1666 
        reason: i.reason.clone(),
1667 
        labels,
1668 
        assignees,
1669 
        milestone,
1670 
        comments,
1671 
        locked: i.locked,
1672 
        pinned: i.pinned,
1673 
        created_ms: i.created_ms,
1674 
        updated_ms: i.updated_ms,
1675 
        closed_ms: i.closed_ms,
1676 
        url: format!("{}/{}/issue/{}", app.config.base_url(), row.slug(), i.number),
1677 
    })
1678 
}
1679
1680 
#[derive(Deserialize)]
1681 
struct IssuesQuery {
1682 
    state: Option<String>,
1683 
}
1684
1685 
async fn issues(
1686 
    State(app): State<Shared>,
1687 
    headers: HeaderMap,
1688 
    Path((owner, name)): Path<(String, String)>,
1689 
    Query(q): Query<IssuesQuery>,
1690 
) -> Result<Json<Vec<Issue>>, ApiError> {
1691 
    let c = caller(&app, &headers).await?;
1692 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1693 
    let state = q.state.unwrap_or_else(|| "open".into());
1694 
    let mut out = Vec::new();
1695 
    for i in db::issues::list(&app.db, row.id).await? {
1696 
        if state == "all" || i.state == state {
1697 
            out.push(issue_of(&app, &row, &i).await?);
d23464c0 Andy McCall ↶ 1698 
        }
1699 
    }
b64e2537 Andy McCall ↶ 1700 
    Ok(Json(out))
d23464c0 Andy McCall ↶ 1701 
}
1702
b64e2537 Andy McCall ↶ 1703 
async fn create_issue(
1704 
    State(app): State<Shared>,
1705 
    headers: HeaderMap,
1706 
    Path((owner, name)): Path<(String, String)>,
1707 
    Json(body): Json<NewIssue>,
1708 
) -> Result<(StatusCode, Json<Issue>), ApiError> {
1709 
    let c = caller(&app, &headers).await?;
1710 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
76f262e1 Andy McCall ↶ 1711 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
b64e2537 Andy McCall ↶ 1712 
    if body.title.trim().is_empty() {
1713 
        return Err(ApiError(StatusCode::BAD_REQUEST, "an issue needs a title".into()));
d23464c0 Andy McCall ↶ 1714 
    }
76f262e1 Andy McCall ↶ 1715 
    let triage = !body.labels.is_empty() || !body.assignees.is_empty() || body.milestone.is_some();
1716 
    if triage && role < Role::Triage {
1717 
        return Err(forbidden("setting labels, assignees or a milestone needs triage access"));
1718 
    }
1719 
    // Check the names before anything is created.
1720 
    resolve_triage(&app, row.id, Some(&body.labels), Some(&body.assignees), body.milestone.as_deref()).await?;
b64e2537 Andy McCall ↶ 1721 
    let i = db::issues::create(
1722 
        &app.db,
1723 
        db::issues::NewIssue {
1724 
            repo_id: row.id,
1725 
            title: body.title.trim(),
1726 
            body: body.body.trim(),
1727 
            author_id: Some(me.id),
1728 
            author: &me.username,
1729 
        },
1730 
    )
1731 
    .await?;
1732 
    db::issues::add_event(&app.db, i.id, &me.username, "opened", "").await.ok();
76f262e1 Andy McCall ↶ 1733 
    if triage {
1734 
        let t = resolve_triage(&app, row.id, Some(&body.labels), Some(&body.assignees), body.milestone.as_deref()).await?;
1735 
        apply_triage(&app, &i, &me, t).await?;
1736 
    }
1737 
    let i = db::issues::get(&app.db, row.id, i.number).await?.unwrap_or(i);
b64e2537 Andy McCall ↶ 1738 
    crate::web::issues::reindex(&app, row.id, &i).await;
1739 
    let api = issue_of(&app, &row, &i).await?;
1740 
    crate::notify::deliver(
1741 
        &app,
1742 
        crate::notify::Event {
1743 
            kind: "issue.opened",
1744 
            title: format!("{owner}/{name}#{}: {}", i.number, i.title),
1745 
            url: format!("/{owner}/{name}/issue/{}", i.number),
1746 
            actor: &me,
1747 
            repo_id: row.id,
1748 
            thread: Some(("issue", i.id)),
1749 
            mention_text: &body.body,
1750 
            direct: vec![],
1751 
        },
1752 
    )
1753 
    .await;
1754 
    crate::hooks::emit(&app, &row, "issue.opened", &me.username, serde_json::json!({ "issue": api })).await;
1755 
    Ok((StatusCode::CREATED, Json(api)))
1756 
}
1757
1758 
async fn issue(
1759 
    State(app): State<Shared>,
1760 
    headers: HeaderMap,
1761 
    Path((owner, name, number)): Path<(String, String, i64)>,
1762 
) -> Result<Json<Issue>, ApiError> {
1763 
    let c = caller(&app, &headers).await?;
1764 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1765 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1766 
    Ok(Json(issue_of(&app, &row, &i).await?))
1767 
}
1768
1769 
async fn issue_state(
1770 
    State(app): State<Shared>,
1771 
    headers: HeaderMap,
1772 
    Path((owner, name, number)): Path<(String, String, i64)>,
1773 
    Json(body): Json<IssueStateChange>,
1774 
) -> Result<Json<Issue>, ApiError> {
1775 
    let c = caller(&app, &headers).await?;
1776 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
1777 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1778 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1779 
    if role < Role::Triage && Some(me.id) != i.author_id {
1780 
        return Err(forbidden("only the author or triage may change the state"));
1781 
    }
1782 
    let (state, reason) = match body.state.as_str() {
1783 
        "closed" => ("closed", if body.reason == "not_planned" { "not_planned" } else { "completed" }),
1784 
        "open" => ("open", ""),
1785 
        _ => return Err(ApiError(StatusCode::BAD_REQUEST, "state is open or closed".into())),
1786 
    };
1787 
    db::issues::set_state(&app.db, i.id, state, reason).await?;
1788 
    db::issues::add_event(&app.db, i.id, &me.username, if state == "closed" { "closed" } else { "reopened" }, "").await.ok();
1789 
    let fresh = db::issues::get(&app.db, row.id, number).await?.unwrap_or(i);
1790 
    let api = issue_of(&app, &row, &fresh).await?;
1791 
    crate::hooks::emit(
1792 
        &app,
1793 
        &row,
1794 
        if state == "closed" { "issue.closed" } else { "issue.reopened" },
1795 
        &me.username,
1796 
        serde_json::json!({ "issue": api }),
1797 
    )
1798 
    .await;
1799 
    Ok(Json(api))
1800 
}
1801
1802 
async fn issue_comments(
1803 
    State(app): State<Shared>,
1804 
    headers: HeaderMap,
1805 
    Path((owner, name, number)): Path<(String, String, i64)>,
1806 
) -> Result<Json<Vec<Comment>>, ApiError> {
1807 
    let c = caller(&app, &headers).await?;
1808 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
1809 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1810 
    Ok(Json(
1811 
        db::issues::comments(&app.db, i.id)
1812 
            .await?
1813 
            .into_iter()
1814 
            .map(|c| Comment {
1815 
                id: c.id,
1816 
                author: c.author,
1817 
                body: c.body,
1818 
                created_ms: c.created_ms,
1819 
                path: None,
1820 
                anchor: None,
c0fac31d Andy McCall ↶ 1821 
                line: None,
b64e2537 Andy McCall ↶ 1822 
                resolved: false,
1823 
            })
1824 
            .collect(),
1825 
    ))
1826 
}
1827
1828 
async fn issue_comment(
1829 
    State(app): State<Shared>,
1830 
    headers: HeaderMap,
1831 
    Path((owner, name, number)): Path<(String, String, i64)>,
1832 
    Json(body): Json<NewComment>,
1833 
) -> Result<(StatusCode, Json<Comment>), ApiError> {
1834 
    let c = caller(&app, &headers).await?;
1835 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
1836 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1837 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1838 
    if i.locked && role < Role::Triage {
1839 
        return Err(forbidden("this issue is locked"));
1840 
    }
1841 
    if body.body.trim().is_empty() {
1842 
        return Err(ApiError(StatusCode::BAD_REQUEST, "an empty comment says nothing".into()));
1843 
    }
1844 
    let cm = db::issues::add_comment(&app.db, i.id, Some(me.id), &me.username, body.body.trim()).await?;
1845 
    crate::web::issues::reindex(&app, row.id, &i).await;
1846 
    crate::notify::deliver(
1847 
        &app,
1848 
        crate::notify::Event {
1849 
            kind: "issue.comment",
1850 
            title: format!("{owner}/{name}#{number}: {}", i.title),
1851 
            url: format!("/{owner}/{name}/issue/{number}"),
1852 
            actor: &me,
1853 
            repo_id: row.id,
1854 
            thread: Some(("issue", i.id)),
1855 
            mention_text: &body.body,
1856 
            direct: i.author_id.into_iter().collect(),
1857 
        },
1858 
    )
1859 
    .await;
c0fac31d Andy McCall ↶ 1860 
    let api = Comment {
1861 
        id: cm.id,
1862 
        author: cm.author,
1863 
        body: cm.body,
1864 
        created_ms: cm.created_ms,
1865 
        path: None,
1866 
        anchor: None,
1867 
        line: None,
1868 
        resolved: false,
1869 
    };
b64e2537 Andy McCall ↶ 1870 
    crate::hooks::emit(&app, &row, "comment.issue", &me.username, serde_json::json!({ "number": number, "comment": api })).await;
1871 
    Ok((StatusCode::CREATED, Json(api)))
76f262e1 Andy McCall ↶ 1872 
}
1873
1874 
/// Labels, assignees and milestone named in a request, looked up.
1875 
struct Triage {
1876 
    labels: Option<Vec<db::issues::Label>>,
1877 
    assignees: Option<Vec<Account>>,
1878 
    /// `Some(None)` clears the milestone.
1879 
    milestone: Option<Option<db::issues::Milestone>>,
1880 
}
1881
1882 
async fn resolve_triage(
1883 
    app: &Shared,
1884 
    repo_id: i64,
1885 
    labels: Option<&[String]>,
1886 
    assignees: Option<&[String]>,
1887 
    milestone: Option<&str>,
1888 
) -> Result<Triage, ApiError> {
1889 
    let bad = |m: String| ApiError(StatusCode::BAD_REQUEST, m);
1890 
    let labels = match labels {
1891 
        Some(names) => {
1892 
            let mut out = Vec::new();
1893 
            for n in names {
1894 
                out.push(
1895 
                    db::issues::label_by_name(&app.db, repo_id, n.trim())
1896 
                        .await?
1897 
                        .ok_or_else(|| bad(format!("no label {n:?}; create it first")))?,
1898 
                );
1899 
            }
1900 
            Some(out)
1901 
        }
1902 
        None => None,
1903 
    };
1904 
    let assignees = match assignees {
1905 
        Some(names) => {
1906 
            let mut out = Vec::new();
1907 
            for n in names {
1908 
                out.push(db::accounts::account_by_name(&app.db, n.trim()).await?.ok_or_else(|| bad(format!("no account {n:?}")))?);
1909 
            }
1910 
            Some(out)
1911 
        }
1912 
        None => None,
1913 
    };
1914 
    let milestone = match milestone.map(str::trim) {
1915 
        None => None,
1916 
        Some("") => Some(None),
1917 
        Some(title) => Some(Some(
1918 
            db::issues::milestones(&app.db, repo_id)
1919 
                .await?
1920 
                .into_iter()
1921 
                .find(|m| m.title == title)
1922 
                .ok_or_else(|| bad(format!("no milestone {title:?}")))?,
1923 
        )),
1924 
    };
1925 
    Ok(Triage { labels, assignees, milestone })
1926 
}
1927
1928 
/// Make an issue's labels, assignees and milestone what `t` says, with
1929 
/// timeline events for what changed.
1930 
async fn apply_triage(app: &Shared, i: &db::issues::IssueRow, me: &Account, t: Triage) -> Result<(), ApiError> {
1931 
    if let Some(want) = t.labels {
1932 
        let have = db::issues::issue_labels(&app.db, i.id).await?;
1933 
        for l in &have {
1934 
            if !want.iter().any(|w| w.id == l.id) {
1935 
                db::issues::set_issue_label(&app.db, i.id, l.id, false).await?;
1936 
            }
1937 
        }
1938 
        for w in &want {
1939 
            if !have.iter().any(|l| l.id == w.id) {
1940 
                db::issues::set_issue_label(&app.db, i.id, w.id, true).await?;
1941 
            }
1942 
        }
1943 
        let names: Vec<&str> = want.iter().map(|l| l.name.as_str()).collect();
1944 
        db::issues::add_event(&app.db, i.id, &me.username, "set labels", &names.join(", ")).await.ok();
1945 
    }
1946 
    if let Some(want) = t.assignees {
1947 
        let have = db::issues::assignees(&app.db, i.id).await?;
1948 
        for name in &have {
1949 
            if !want.iter().any(|a| &a.username == name) {
1950 
                if let Some(a) = db::accounts::account_by_name(&app.db, name).await? {
1951 
                    db::issues::set_assignee(&app.db, i.id, a.id, false).await?;
1952 
                    db::issues::add_event(&app.db, i.id, &me.username, "unassigned", name).await.ok();
1953 
                }
1954 
            }
1955 
        }
1956 
        for a in &want {
1957 
            if !have.contains(&a.username) {
1958 
                db::issues::set_assignee(&app.db, i.id, a.id, true).await?;
1959 
                db::issues::add_event(&app.db, i.id, &me.username, "assigned", &a.username).await.ok();
1960 
            }
1961 
        }
1962 
    }
1963 
    if let Some(m) = t.milestone {
1964 
        db::issues::set_milestone(&app.db, i.id, m.as_ref().map(|m| m.id)).await?;
1965 
        db::issues::add_event(&app.db, i.id, &me.username, "set milestone", m.as_ref().map(|m| m.title.as_str()).unwrap_or("")).await.ok();
1966 
    }
1967 
    Ok(())
1968 
}
1969
1970 
/// `PATCH /repos/{o}/{n}/issues/{number}`.
1971 
async fn issue_edit(
1972 
    State(app): State<Shared>,
1973 
    headers: HeaderMap,
1974 
    Path((owner, name, number)): Path<(String, String, i64)>,
1975 
    Json(body): Json<IssueEdit>,
1976 
) -> Result<Json<Issue>, ApiError> {
1977 
    let c = caller(&app, &headers).await?;
1978 
    let me = c.require("issues:write").or_else(|_| c.require("repo:write"))?.clone();
1979 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
1980 
    let i = db::issues::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such issue"))?;
1981 
    let text = body.title.is_some() || body.body.is_some();
1982 
    let triage = body.labels.is_some() || body.assignees.is_some() || body.milestone.is_some();
1983 
    if text && role < Role::Triage && Some(me.id) != i.author_id {
1984 
        return Err(forbidden("only the author or triage may edit the title and body"));
1985 
    }
1986 
    if triage && role < Role::Triage {
1987 
        return Err(forbidden("setting labels, assignees or a milestone needs triage access"));
1988 
    }
1989 
    if i.locked && role < Role::Triage {
1990 
        return Err(forbidden("this issue is locked"));
1991 
    }
1992 
    let t = resolve_triage(&app, row.id, body.labels.as_deref(), body.assignees.as_deref(), body.milestone.as_deref()).await?;
1993 
    if text {
1994 
        let title = body.title.as_deref().map(str::trim).unwrap_or(&i.title);
1995 
        if title.is_empty() {
1996 
            return Err(ApiError(StatusCode::BAD_REQUEST, "an issue needs a title".into()));
1997 
        }
1998 
        db::issues::edit(&app.db, i.id, title, body.body.as_deref().unwrap_or(&i.body)).await?;
1999 
        db::issues::add_event(&app.db, i.id, &me.username, "edited", "").await.ok();
2000 
    }
2001 
    apply_triage(&app, &i, &me, t).await?;
2002 
    db::issues::touch(&app.db, i.id).await.ok();
2003 
    let fresh = db::issues::get(&app.db, row.id, number).await?.unwrap_or(i);
2004 
    crate::web::issues::reindex(&app, row.id, &fresh).await;
2005 
    let api = issue_of(&app, &row, &fresh).await?;
2006 
    crate::hooks::emit(&app, &row, "issue.edited", &me.username, serde_json::json!({ "issue": api })).await;
2007 
    Ok(Json(api))
2008 
}
2009
2010 
/// `POST /repos/{o}/{n}/labels` (triage).
2011 
async fn create_label(
2012 
    State(app): State<Shared>,
2013 
    headers: HeaderMap,
2014 
    Path((owner, name)): Path<(String, String)>,
2015 
    Json(body): Json<NewLabel>,
2016 
) -> Result<(StatusCode, Json<Label>), ApiError> {
2017 
    let c = caller(&app, &headers).await?;
2018 
    c.require("issues:write").or_else(|_| c.require("repo:write"))?;
2019 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
2020 
    if role < Role::Triage {
2021 
        return Err(forbidden("labels need triage access"));
2022 
    }
2023 
    let label = body.name.trim();
2024 
    if label.is_empty() || label.len() > 50 {
2025 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a label has a name of 1 to 50 characters".into()));
2026 
    }
2027 
    let colour = match body.colour.as_deref() {
2028 
        Some(c) if c.len() == 7 && c.starts_with('#') && c[1..].chars().all(|x| x.is_ascii_hexdigit()) => c.to_string(),
2029 
        Some(c) => return Err(ApiError(StatusCode::BAD_REQUEST, format!("colour {c:?} is not #rrggbb"))),
2030 
        None => "#5aa8ff".to_string(),
2031 
    };
2032 
    let l = db::issues::upsert_label(&app.db, row.id, label, &colour, body.description.trim()).await?;
2033 
    Ok((StatusCode::CREATED, Json(Label { name: l.name, colour: l.colour, description: l.description })))
2034 
}
2035
2036 
/// `DELETE /repos/{o}/{n}/labels/{label}` (triage).
2037 
async fn delete_label(
2038 
    State(app): State<Shared>,
2039 
    headers: HeaderMap,
2040 
    Path((owner, name, label)): Path<(String, String, String)>,
2041 
) -> Result<StatusCode, ApiError> {
2042 
    let c = caller(&app, &headers).await?;
2043 
    c.require("issues:write").or_else(|_| c.require("repo:write"))?;
2044 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
2045 
    if role < Role::Triage {
2046 
        return Err(forbidden("labels need triage access"));
2047 
    }
2048 
    let l = db::issues::label_by_name(&app.db, row.id, &label).await?.ok_or_else(|| not_found("no such label"))?;
2049 
    db::issues::delete_label(&app.db, l.id).await?;
2050 
    Ok(StatusCode::NO_CONTENT)
d23464c0 Andy McCall ↶ 2051 
}
2052
b64e2537 Andy McCall ↶ 2053 
async fn labels(
2054 
    State(app): State<Shared>,
2055 
    headers: HeaderMap,
2056 
    Path((owner, name)): Path<(String, String)>,
2057 
) -> Result<Json<Vec<Label>>, ApiError> {
2058 
    let c = caller(&app, &headers).await?;
2059 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2060 
    Ok(Json(
2061 
        db::issues::labels(&app.db, row.id)
2062 
            .await?
2063 
            .into_iter()
2064 
            .map(|l| Label { name: l.name, colour: l.colour, description: l.description })
2065 
            .collect(),
2066 
    ))
2067 
}
2068
2069 
async fn milestones(
2070 
    State(app): State<Shared>,
2071 
    headers: HeaderMap,
2072 
    Path((owner, name)): Path<(String, String)>,
2073 
) -> Result<Json<Vec<Milestone>>, ApiError> {
2074 
    let c = caller(&app, &headers).await?;
2075 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2076 
    let mut out = Vec::new();
2077 
    for m in db::issues::milestones(&app.db, row.id).await? {
2078 
        let (open, closed) = db::issues::milestone_counts(&app.db, m.id).await?;
2079 
        out.push(Milestone { title: m.title, description: m.description, due_ms: m.due_ms, state: m.state, open, closed });
d23464c0 Andy McCall ↶ 2080 
    }
b64e2537 Andy McCall ↶ 2081 
    Ok(Json(out))
2082 
}
2083
5ea4872f Andy McCall ↶ 2084 
fn milestone_of(m: db::issues::Milestone, open: i64, closed: i64) -> Milestone {
2085 
    Milestone { title: m.title, description: m.description, due_ms: m.due_ms, state: m.state, open, closed }
2086 
}
2087
2088 
/// A due date as `YYYY-MM-DD` (UTC midnight), or the empty string for none.
2089 
fn due_ms_of(due: &str) -> Result<Option<i64>, ApiError> {
2090 
    let due = due.trim();
2091 
    if due.is_empty() {
2092 
        return Ok(None);
2093 
    }
2094 
    time::Date::parse(due, &time::macros::format_description!("[year]-[month]-[day]"))
2095 
        .map(|d| Some(d.midnight().assume_utc().unix_timestamp() * 1000))
2096 
        .map_err(|_| ApiError(StatusCode::BAD_REQUEST, format!("due {due:?} is not YYYY-MM-DD")))
2097 
}
2098
2099 
async fn triage_for_milestones(app: &Shared, headers: &HeaderMap, owner: &str, name: &str) -> Result<db::repos::RepoRow, ApiError> {
2100 
    let c = caller(app, headers).await?;
2101 
    c.require("issues:write").or_else(|_| c.require("repo:write"))?;
2102 
    let (_, row, role) = reach(app, &c, owner, name, Access::Read).await?;
2103 
    if role < Role::Triage {
2104 
        return Err(forbidden("milestones need triage access"));
2105 
    }
2106 
    Ok(row)
2107 
}
2108
2109 
/// `POST /repos/{o}/{n}/milestones` (triage, oxygenhub#91): create a
2110 
/// milestone, or change the description and due date of the one with
2111 
/// that title.
2112 
async fn create_milestone(
2113 
    State(app): State<Shared>,
2114 
    headers: HeaderMap,
2115 
    Path((owner, name)): Path<(String, String)>,
2116 
    Json(body): Json<NewMilestone>,
2117 
) -> Result<(StatusCode, Json<Milestone>), ApiError> {
2118 
    let row = triage_for_milestones(&app, &headers, &owner, &name).await?;
2119 
    let title = body.title.trim();
2120 
    if title.is_empty() || title.len() > 100 {
2121 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a milestone has a title of 1 to 100 characters".into()));
2122 
    }
2123 
    let due_ms = due_ms_of(body.due.as_deref().unwrap_or(""))?;
2124 
    let m = db::issues::upsert_milestone(&app.db, row.id, title, body.description.trim(), due_ms).await?;
2125 
    let (open, closed) = db::issues::milestone_counts(&app.db, m.id).await?;
2126 
    Ok((StatusCode::CREATED, Json(milestone_of(m, open, closed))))
2127 
}
2128
2129 
/// `PATCH /repos/{o}/{n}/milestones/{title}` (triage): title,
2130 
/// description, due date and state; what is not given stays.
2131 
async fn edit_milestone(
2132 
    State(app): State<Shared>,
2133 
    headers: HeaderMap,
2134 
    Path((owner, name, title)): Path<(String, String, String)>,
2135 
    Json(body): Json<MilestoneEdit>,
2136 
) -> Result<Json<Milestone>, ApiError> {
2137 
    let row = triage_for_milestones(&app, &headers, &owner, &name).await?;
2138 
    let m = db::issues::milestones(&app.db, row.id)
2139 
        .await?
2140 
        .into_iter()
2141 
        .find(|m| m.title == title)
2142 
        .ok_or_else(|| not_found("no such milestone"))?;
2143 
    let new_title = body.title.as_deref().map(str::trim).unwrap_or(&m.title);
2144 
    if new_title.is_empty() || new_title.len() > 100 {
2145 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a milestone has a title of 1 to 100 characters".into()));
2146 
    }
2147 
    let due_ms = match body.due.as_deref() {
2148 
        Some(d) => due_ms_of(d)?,
2149 
        None => m.due_ms,
2150 
    };
2151 
    let description = body.description.as_deref().map(str::trim).unwrap_or(&m.description);
2152 
    if body.title.is_some() || body.description.is_some() || body.due.is_some() {
2153 
        db::issues::update_milestone(&app.db, m.id, new_title, description, due_ms).await?;
2154 
    }
2155 
    if let Some(state) = body.state.as_deref() {
2156 
        match state {
2157 
            "open" | "closed" => db::issues::set_milestone_state(&app.db, m.id, state).await?,
2158 
            other => return Err(ApiError(StatusCode::BAD_REQUEST, format!("state {other:?} is open or closed"))),
2159 
        }
2160 
    }
2161 
    let fresh = db::issues::milestone(&app.db, m.id).await?.ok_or_else(|| not_found("no such milestone"))?;
2162 
    let (open, closed) = db::issues::milestone_counts(&app.db, fresh.id).await?;
2163 
    Ok(Json(milestone_of(fresh, open, closed)))
2164 
}
2165
b64e2537 Andy McCall ↶ 2166 
// --------------------------------------------------------- hooks, checks
2167
2168 
fn hook_of(h: &db::hooks::Hook) -> Hook {
2169 
    Hook { id: h.id, url: h.url.clone(), events: h.events.clone(), active: h.active, created_ms: h.created_ms }
2170 
}
2171
2172 
async fn hooks(
2173 
    State(app): State<Shared>,
2174 
    headers: HeaderMap,
2175 
    Path((owner, name)): Path<(String, String)>,
2176 
) -> Result<Json<Vec<Hook>>, ApiError> {
2177 
    let c = caller(&app, &headers).await?;
2178 
    c.require("hooks:admin").or_else(|_| c.require("repo:admin"))?;
2179 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
2180 
    Ok(Json(db::hooks::hooks_for_repo(&app.db, row.id).await?.iter().map(hook_of).collect()))
d23464c0 Andy McCall ↶ 2181 
}
2182
b64e2537 Andy McCall ↶ 2183 
async fn create_hook(
2184 
    State(app): State<Shared>,
2185 
    headers: HeaderMap,
2186 
    Path((owner, name)): Path<(String, String)>,
2187 
    Json(body): Json<NewHook>,
2188 
) -> Result<(StatusCode, Json<Hook>), ApiError> {
2189 
    let c = caller(&app, &headers).await?;
2190 
    let me = c.require("hooks:admin").or_else(|_| c.require("repo:admin"))?.clone();
2191 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
2192 
    if !(body.url.starts_with("http://") || body.url.starts_with("https://")) {
2193 
        return Err(ApiError(StatusCode::BAD_REQUEST, "the URL must be http or https".into()));
2194 
    }
2195 
    let h = db::hooks::create_hook(&app.db, Some(row.id), None, &body.url, &body.secret, &body.events).await?;
2196 
    db::accounts::audit(&app.db, Some(&me), "hook.created", &row.slug(), &body.url).await.ok();
2197 
    Ok((StatusCode::CREATED, Json(hook_of(&h))))
d23464c0 Andy McCall ↶ 2198 
}
2199
b64e2537 Andy McCall ↶ 2200 
async fn delete_hook(
2201 
    State(app): State<Shared>,
2202 
    headers: HeaderMap,
2203 
    Path((owner, name, id)): Path<(String, String, i64)>,
2204 
) -> Result<StatusCode, ApiError> {
2205 
    let c = caller(&app, &headers).await?;
2206 
    c.require("hooks:admin").or_else(|_| c.require("repo:admin"))?;
2207 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
2208 
    if db::hooks::hook(&app.db, id).await?.is_some_and(|h| h.repo_id == Some(row.id)) {
2209 
        db::hooks::delete_hook(&app.db, id).await?;
2210 
    }
2211 
    Ok(StatusCode::NO_CONTENT)
d23464c0 Andy McCall ↶ 2212 
}
2213
b64e2537 Andy McCall ↶ 2214 
pub fn check_of(c: &db::hooks::Check) -> Check {
2215 
    Check {
2216 
        state: c.state.clone(),
2217 
        name: c.name.clone(),
2218 
        status: CheckStatus::parse(&c.status).unwrap_or(CheckStatus::Queued),
2219 
        summary: c.summary.clone(),
2220 
        url: c.url.clone(),
2221 
        reporter: c.reporter.clone(),
2222 
        seal: if c.seal.is_empty() { None } else { Some(c.seal.clone()) },
2223 
        started_ms: c.started_ms,
2224 
        finished_ms: c.finished_ms,
2225 
    }
961c10be Andy McCall ↶ 2226 
}
2227
2228 
/// `GET /repos/{o}/{n}/checks/required`.
2229 
async fn required_checks(
2230 
    State(app): State<Shared>,
2231 
    headers: HeaderMap,
2232 
    Path((owner, name)): Path<(String, String)>,
2233 
) -> Result<Json<RequiredChecks>, ApiError> {
2234 
    let c = caller(&app, &headers).await?;
2235 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2236 
    Ok(Json(RequiredChecks { names: db::hooks::required_checks(&app.db, row.id).await? }))
2237 
}
2238
2239 
/// `PUT /repos/{o}/{n}/checks/required` (repository admin): the whole list.
2240 
async fn set_required_checks(
2241 
    State(app): State<Shared>,
2242 
    headers: HeaderMap,
2243 
    Path((owner, name)): Path<(String, String)>,
2244 
    Json(body): Json<RequiredChecks>,
2245 
) -> Result<Json<RequiredChecks>, ApiError> {
2246 
    let c = caller(&app, &headers).await?;
2247 
    c.require("repo:admin")?;
2248 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Admin).await?;
2249 
    let mut names: Vec<String> = body.names.iter().map(|n| n.trim().to_string()).filter(|n| !n.is_empty()).collect();
2250 
    names.sort();
2251 
    names.dedup();
2252 
    if names.len() > 32 || names.iter().any(|n| n.len() > 100 || n.contains(',')) {
2253 
        return Err(ApiError(StatusCode::BAD_REQUEST, "at most 32 check names, each under 100 characters and without commas".into()));
2254 
    }
2255 
    db::hooks::set_required_checks(&app.db, row.id, &names).await?;
2256 
    db::accounts::audit(&app.db, c.account.as_ref(), "repo.required_checks", &format!("{owner}/{name}"), &names.join(", ")).await.ok();
2257 
    Ok(Json(RequiredChecks { names }))
1edac4b6 Andy McCall ↶ 2258 
}
2259
bf3d0754 Andy McCall ↶ 2260 
fn flow_run_of(
2261 
    app: &Shared,
2262 
    row: &db::repos::RepoRow,
2263 
    r: &db::flow::Run,
2264 
    jobs: Vec<db::flow::Job>,
2265 
    queue: &[db::flow::QueueEntry],
2266 
) -> FlowRun {
90326c96 Andy McCall ↶ 2267 
    FlowRun {
bf3d0754 Andy McCall ↶ 2268 
        queue_position: crate::flow::queue_info(queue, row.id, r.id).position.map(|p| p as i64),
90326c96 Andy McCall ↶ 2269 
        number: r.number,
2270 
        bookmark: r.bookmark.clone(),
2271 
        state: r.state.clone(),
2272 
        heads: r.head_list().into_iter().map(String::from).collect(),
2273 
        status: r.status.clone(),
c889911b Andy McCall ↶ 2274 
        trigger: r.trigger_label(),
90326c96 Andy McCall ↶ 2275 
        actor: r.actor.clone(),
2276 
        pipeline_hash: r.pipeline_hash.clone(),
2277 
        error: r.error.clone(),
2278 
        created_ms: r.created_ms,
2279 
        finished_ms: r.finished_ms,
2280 
        url: format!("{}/{}/{}/flow/{}", app.config.base_url(), row.owner, row.name, r.number),
2281 
        jobs: jobs
2282 
            .into_iter()
2283 
            .map(|j| FlowJob {
2284 
                depends_on: j.depends_on(),
2285 
                name: j.name,
2286 
                status: j.status,
2287 
                runner: j.runner,
2288 
                exit_code: j.exit_code,
2289 
                error: j.error,
2290 
                started_ms: j.started_ms,
2291 
                finished_ms: j.finished_ms,
2292 
                log_lines: j.log_count,
4d2e44d7 Andy McCall ↶ 2293 
                waiting: j.waiting,
501d8b26 Andy McCall ↶ 2294 
                placed: j.placed,
90326c96 Andy McCall ↶ 2295 
            })
2296 
            .collect(),
2297 
    }
2298 
}
2299
1edac4b6 Andy McCall ↶ 2300 
#[derive(Deserialize)]
90326c96 Andy McCall ↶ 2301 
struct RunsPage {
2302 
    /// Runs numbered below this one (the next page).
2303 
    before: Option<i64>,
2304 
    limit: Option<i64>,
2305 
}
2306
2307 
/// `GET /repos/{o}/{n}/flow/runs`: newest first, `?before=N&limit=` (max 100).
2308 
async fn flow_runs(
2309 
    State(app): State<Shared>,
2310 
    headers: HeaderMap,
2311 
    Path((owner, name)): Path<(String, String)>,
2312 
    Query(q): Query<RunsPage>,
2313 
) -> Result<Json<Vec<FlowRun>>, ApiError> {
2314 
    let c = caller(&app, &headers).await?;
2315 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2316 
    let limit = q.limit.unwrap_or(30).clamp(1, 100);
2317 
    let runs = db::flow::runs_by_number(&app.db, row.id, limit, q.before).await?;
bf3d0754 Andy McCall ↶ 2318 
    let queue = if runs.iter().any(|r| r.live()) { db::flow::queue(&app.db).await? } else { vec![] };
2319 
    Ok(Json(runs.iter().map(|r| flow_run_of(&app, &row, r, vec![], &queue)).collect()))
90326c96 Andy McCall ↶ 2320 
}
2321
2322 
/// `GET /repos/{o}/{n}/flow/runs/{number}`: a run with its jobs.
2323 
async fn flow_run(
2324 
    State(app): State<Shared>,
2325 
    headers: HeaderMap,
2326 
    Path((owner, name, number)): Path<(String, String, i64)>,
2327 
) -> Result<Json<FlowRun>, ApiError> {
2328 
    let c = caller(&app, &headers).await?;
2329 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2330 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
2331 
    let jobs = db::flow::jobs(&app.db, run.id).await?;
bf3d0754 Andy McCall ↶ 2332 
    let queue = if run.live() { db::flow::queue(&app.db).await? } else { vec![] };
2333 
    Ok(Json(flow_run_of(&app, &row, &run, jobs, &queue)))
90326c96 Andy McCall ↶ 2334 
}
2335
2336 
#[derive(Deserialize)]
2337 
struct LogPage {
2338 
    /// Lines after this `seq`.
2339 
    #[serde(default)]
2340 
    after: i64,
2341 
    limit: Option<i64>,
2342 
}
2343
2344 
/// `GET /repos/{o}/{n}/flow/runs/{number}/jobs/{job}/log`: `?after=seq&limit=` (max 5000).
2345 
async fn flow_job_log(
2346 
    State(app): State<Shared>,
2347 
    headers: HeaderMap,
2348 
    Path((owner, name, number, job)): Path<(String, String, i64, String)>,
2349 
    Query(q): Query<LogPage>,
2350 
) -> Result<Json<Vec<FlowLogLine>>, ApiError> {
2351 
    let c = caller(&app, &headers).await?;
2352 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2353 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
2354 
    let j = db::flow::jobs(&app.db, run.id)
2355 
        .await?
2356 
        .into_iter()
2357 
        .find(|j| j.name == job)
2358 
        .ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such job".into()))?;
2359 
    let lines = db::flow::log(&app.db, j.id, q.after, q.limit.unwrap_or(1000).clamp(1, 5000)).await?;
2360 
    Ok(Json(lines.into_iter().map(|l| FlowLogLine { seq: l.seq, t: l.t, stream: l.stream, text: l.text }).collect()))
2361 
}
2362
2363 
#[derive(Deserialize)]
1edac4b6 Andy McCall ↶ 2364 
struct StartRun {
2365 
    /// Default: the repository's default bookmark.
2366 
    #[serde(default)]
2367 
    bookmark: Option<String>,
4f692533 Andy McCall ↶ 2368 
    /// A change's full hash: run the state whose only head it is, instead
2369 
    /// of a bookmark's.
2370 
    #[serde(default)]
2371 
    change: Option<String>,
0650d94e Andy McCall ↶ 2372 
    /// Only these jobs, with what they depend on (oxygenhub#130); default:
2373 
    /// every job a manual run starts.
2374 
    #[serde(default)]
2375 
    jobs: Vec<String>,
1edac4b6 Andy McCall ↶ 2376 
}
2377
2378 
fn started(app: &Shared, row: &db::repos::RepoRow, number: i64) -> (StatusCode, Json<serde_json::Value>) {
2379 
    let url = format!("{}/{}/{}/flow/{number}", app.config.base_url(), row.owner, row.name);
2380 
    (StatusCode::CREATED, Json(serde_json::json!({ "number": number, "url": url })))
2381 
}
2382
2383 
/// `POST /repos/{o}/{n}/flow/runs` (repo:write): run a bookmark's current
4f692533 Andy McCall ↶ 2384 
/// state, or one change's, without moving anything (hub spec §13.2).
1edac4b6 Andy McCall ↶ 2385 
async fn start_flow_run(
2386 
    State(app): State<Shared>,
2387 
    headers: HeaderMap,
2388 
    Path((owner, name)): Path<(String, String)>,
2389 
    Json(body): Json<StartRun>,
2390 
) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
2391 
    let c = caller(&app, &headers).await?;
2392 
    let me = c.require("repo:write")?.clone();
2393 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
0650d94e Andy McCall ↶ 2394 
    let (n, what) = match body.change.clone().filter(|c| !c.trim().is_empty()) {
4f692533 Andy McCall ↶ 2395 
        Some(change) => {
0650d94e Andy McCall ↶ 2396 
            let n = crate::flow::run_change(&app, &row, &change, &me.username, &body.jobs)
2397 
                .await
2398 
                .map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
4f692533 Andy McCall ↶ 2399 
            (n, format!("change {}", change.trim()))
2400 
        }
2401 
        None => {
2402 
            let bookmark = body.bookmark.unwrap_or_else(|| row.default_bookmark.clone());
0650d94e Andy McCall ↶ 2403 
            (
2404 
                crate::flow::run_bookmark(&app, &row, &bookmark, &me.username, &body.jobs)
2405 
                    .await
2406 
                    .map_err(|m| ApiError(StatusCode::CONFLICT, m))?,
2407 
                bookmark,
2408 
            )
4f692533 Andy McCall ↶ 2409 
        }
2410 
    };
2411 
    db::accounts::audit(&app.db, Some(&me), "flow.run", &format!("{owner}/{name}"), &format!("#{n} {what}")).await.ok();
1edac4b6 Andy McCall ↶ 2412 
    Ok(started(&app, &row, n))
2413 
}
2414
2415 
/// `POST /repos/{o}/{n}/flow/runs/{number}/rerun` (repo:write).
2416 
async fn rerun_flow_run(
2417 
    State(app): State<Shared>,
2418 
    headers: HeaderMap,
2419 
    Path((owner, name, number)): Path<(String, String, i64)>,
2420 
) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
2421 
    let c = caller(&app, &headers).await?;
2422 
    let me = c.require("repo:write")?.clone();
2423 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
2424 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
2425 
    let n = crate::flow::rerun(&app, &row, &run, &me.username).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
2426 
    db::accounts::audit(&app.db, Some(&me), "flow.rerun", &format!("{owner}/{name}"), &format!("#{n} of #{number}")).await.ok();
2427 
    Ok(started(&app, &row, n))
d23464c0 Andy McCall ↶ 2428 
}
2429
e8fa5369 Andy McCall ↶ 2430 
/// `POST /repos/{o}/{n}/flow/runs/{number}/jobs/{job}/rerun` (repo:write,
2431 
/// oxygenflow#31): that job again, with the jobs that depend on it, in the
2432 
/// same run. Answers with how many jobs were queued.
2433 
async fn rerun_flow_job(
2434 
    State(app): State<Shared>,
2435 
    headers: HeaderMap,
2436 
    Path((owner, name, number, job)): Path<(String, String, i64, String)>,
2437 
) -> Result<Json<serde_json::Value>, ApiError> {
2438 
    let c = caller(&app, &headers).await?;
2439 
    let me = c.require("repo:write")?.clone();
2440 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
2441 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
2442 
    let n = crate::flow::rerun_job(&app, &row, &run, &job, &me.username).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
2443 
    db::accounts::audit(&app.db, Some(&me), "flow.rerun", &format!("{owner}/{name}"), &format!("{job} of #{number}")).await.ok();
2444 
    Ok(Json(serde_json::json!({ "run": number, "job": job, "queued": n })))
2445 
}
2446
745d225d Andy McCall ↶ 2447 
/// `POST /repos/{o}/{n}/flow/runs/{number}/cancel` (repo:write): answers
2448 
/// with the run as it now stands.
2449 
async fn cancel_flow_run(
2450 
    State(app): State<Shared>,
2451 
    headers: HeaderMap,
2452 
    Path((owner, name, number)): Path<(String, String, i64)>,
2453 
) -> Result<Json<serde_json::Value>, ApiError> {
2454 
    let c = caller(&app, &headers).await?;
2455 
    let me = c.require("repo:write")?.clone();
2456 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;
2457 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
2458 
    crate::flow::cancel(&app, &row, &run, &me.username).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
2459 
    db::accounts::audit(&app.db, Some(&me), "flow.cancel", &format!("{owner}/{name}"), &format!("#{number}")).await.ok();
2460 
    Ok(Json(serde_json::json!({ "number": number, "status": "cancelled" })))
2461 
}
2462
b644e175 Andy McCall ↶ 2463 
/// `GET /repos/{o}/{n}/deployments`: deployments, newest first
2464 
/// (oxygenflow#59).
2465 
async fn list_deployments(
2466 
    State(app): State<Shared>,
2467 
    headers: HeaderMap,
2468 
    Path((owner, name)): Path<(String, String)>,
2469 
) -> Result<Json<Vec<serde_json::Value>>, ApiError> {
2470 
    let c = caller(&app, &headers).await?;
2471 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2472 
    let list = db::flow::deployments(&app.db, row.id, 100).await?;
2473 
    Ok(Json(
2474 
        list.into_iter()
2475 
            .map(|d| {
2476 
                serde_json::json!({ "environment": d.environment, "job": d.job, "run": d.run_number, "state": d.state,
2477 
                    "bookmark": d.bookmark, "actor": d.actor, "approved_by": d.approved_by, "finished_ms": d.finished_ms })
2478 
            })
2479 
            .collect(),
2480 
    ))
2481 
}
2482
417184c7 Andy McCall ↶ 2483 
/// `POST /repos/{o}/{n}/flow/runs/{number}/jobs/{job}/approve` and
2484 
/// `.../reject` (oxygenflow#57): the job's approval rules decide who may.
2485 
async fn approve_flow_job(
2486 
    State(app): State<Shared>,
2487 
    headers: HeaderMap,
2488 
    Path((owner, name, number, job)): Path<(String, String, i64, String)>,
2489 
) -> Result<Json<serde_json::Value>, ApiError> {
2490 
    decide_flow_job(&app, &headers, &owner, &name, number, &job, true).await
2491 
}
2492
2493 
async fn reject_flow_job(
2494 
    State(app): State<Shared>,
2495 
    headers: HeaderMap,
2496 
    Path((owner, name, number, job)): Path<(String, String, i64, String)>,
2497 
) -> Result<Json<serde_json::Value>, ApiError> {
2498 
    decide_flow_job(&app, &headers, &owner, &name, number, &job, false).await
2499 
}
2500
47e37402 Andy McCall ↶ 2501 
/// `GET .../flow/runs/{n}/jobs/{job}/approval`: what approving the job
2502 
/// means, for `oxy seal --flow` to sign (oxygenhub#235).
2503 
async fn flow_job_statement(
2504 
    State(app): State<Shared>,
2505 
    headers: HeaderMap,
2506 
    Path((owner, name, number, job)): Path<(String, String, i64, String)>,
2507 
) -> Result<Json<serde_json::Value>, ApiError> {
2508 
    let c = caller(&app, &headers).await?;
2509 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2510 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
2511 
    let (s, j) = crate::flow::approval_statement(&app, &row, &run, &job).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
2512 
    Ok(Json(serde_json::json!({
2513 
        "repo": hex::encode(s.repo),
2514 
        "run": s.run,
2515 
        "job": s.job,
2516 
        "job_hash": s.job_hash.to_hex(),
2517 
        "state": s.state.to_hex(),
2518 
        "inputs": s.inputs.iter().map(|i| i.to_hex()).collect::<Vec<_>>(),
2519 
        "environment": s.environment,
2520 
        "waiting": j.approval == "waiting" && j.status == "queued",
2521 
    })))
2522 
}
2523
2524 
#[derive(Deserialize)]
2525 
struct SealBody {
2526 
    signed: String,
2527 
}
2528
2529 
/// `POST .../flow/runs/{n}/jobs/{job}/seal` `{"signed": hex}`: approve or
2530 
/// reject with a signed approval (oxygenhub#235). The signature, not the
2531 
/// caller, says who decided; the caller must be signed in.
2532 
async fn seal_flow_job(
2533 
    State(app): State<Shared>,
2534 
    headers: HeaderMap,
2535 
    Path((owner, name, number, job)): Path<(String, String, i64, String)>,
2536 
    Json(body): Json<SealBody>,
2537 
) -> Result<Json<serde_json::Value>, ApiError> {
2538 
    let c = caller(&app, &headers).await?;
2539 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2540 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
2541 
    let said = crate::flow::decide_sealed(&app, &row, &run, &job, &body.signed).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
2542 
    Ok(Json(serde_json::json!({ "number": number, "job": job, "said": said })))
2543 
}
2544
417184c7 Andy McCall ↶ 2545 
async fn decide_flow_job(
2546 
    app: &Shared,
2547 
    headers: &HeaderMap,
2548 
    owner: &str,
2549 
    name: &str,
2550 
    number: i64,
2551 
    job: &str,
2552 
    approve: bool,
2553 
) -> Result<Json<serde_json::Value>, ApiError> {
2554 
    let c = caller(app, headers).await?;
2555 
    let me = c.require("repo:write")?.clone();
2556 
    let (_, row, _) = reach(app, &c, owner, name, Access::Read).await?;
2557 
    let run = db::flow::run(&app.db, row.id, number).await?.ok_or_else(|| ApiError(StatusCode::NOT_FOUND, "no such run".into()))?;
05f1a85a Andy McCall ↶ 2558 
    let via = c.agent.then_some(c.token.as_str());
2559 
    let said = crate::flow::decide(app, &row, &run, job, &me, approve, via).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;
417184c7 Andy McCall ↶ 2560 
    Ok(Json(serde_json::json!({ "number": number, "job": job, "decision": if approve { "approved" } else { "rejected" }, "said": said })))
2561 
}
2562
b64e2537 Andy McCall ↶ 2563 
/// `POST /repos/{o}/{n}/checks`: any `checks:write` (or write) token may
2564 
/// report; the state hash names what was checked.
2565 
async fn post_check(
2566 
    State(app): State<Shared>,
2567 
    headers: HeaderMap,
2568 
    Path((owner, name)): Path<(String, String)>,
2569 
    Json(body): Json<NewCheck>,
2570 
) -> Result<(StatusCode, Json<Check>), ApiError> {
2571 
    let c = caller(&app, &headers).await?;
2572 
    let me = c.require("checks:write").or_else(|_| c.require("repo:write"))?.clone();
2573 
    let (_, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2574 
    if body.state.len() != 64 || !body.state.chars().all(|ch| ch.is_ascii_hexdigit()) {
2575 
        return Err(ApiError(StatusCode::BAD_REQUEST, "state is a 64-character hex state hash".into()));
2576 
    }
2577 
    if body.name.trim().is_empty() || body.name.len() > 100 {
2578 
        return Err(ApiError(StatusCode::BAD_REQUEST, "a check has a short name".into()));
2579 
    }
2580 
    let ch = db::hooks::upsert_check(
2581 
        &app.db,
2582 
        row.id,
2583 
        &body.state,
2584 
        body.name.trim(),
2585 
        body.status.as_str(),
2586 
        &body.summary,
2587 
        &body.url,
2588 
        Some((me.id, &me.username)),
2589 
        body.seal.as_deref().unwrap_or(""),
2590 
    )
2591 
    .await?;
2592 
    let api = check_of(&ch);
33d98147 Andy McCall 2593 
    app.bus.proposal(row.id, ProposalEvent { number: 0, kind: "check".into(), check: Some(api.clone()) });
b64e2537 Andy McCall ↶ 2594 
    crate::hooks::emit(&app, &row, "check", &me.username, serde_json::json!({ "check": api })).await;
2595 
    Ok((StatusCode::CREATED, Json(api)))
d23464c0 Andy McCall ↶ 2596 
}
2597
b64e2537 Andy McCall ↶ 2598 
async fn checks_for_state(
2599 
    State(app): State<Shared>,
2600 
    headers: HeaderMap,
2601 
    Path((owner, name, state)): Path<(String, String, String)>,
2602 
) -> Result<Json<Vec<Check>>, ApiError> {
2603 
    let c = caller(&app, &headers).await?;
90326c96 Andy McCall ↶ 2604 
    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Read).await?;
2605 
    let state = state_key(&app, &repo, &state).await?;
b64e2537 Andy McCall ↶ 2606 
    Ok(Json(db::hooks::checks_for_state(&app.db, row.id, &state).await?.iter().map(check_of).collect()))
90326c96 Andy McCall ↶ 2607 
}
2608
2609 
/// The state hash checks are keyed by, from what a client has: a state
2610 
/// hash, its heads (full change hashes joined with `+`, or the one head of
2611 
/// a single-head state, which is what `oxy log` shows), or a bookmark.
2612 
async fn state_key(app: &Shared, repo: &RepoName, s: &str) -> Result<String, ApiError> {
2613 
    use oxy_core::hash::{hash_object, ChangeHash, ObjectType};
2614 
    let hexes: Vec<&str> = s.split('+').collect();
2615 
    let all_hashes = hexes.iter().all(|h| h.len() == 64 && h.bytes().all(|b| b.is_ascii_hexdigit()));
2616 
    if all_hashes {
2617 
        let row = db::repos::get(&app.db, &repo.owner, &repo.name).await?.ok_or_else(|| not_found("no such repository"))?;
2618 
        if hexes.len() == 1 && !db::hooks::checks_for_state(&app.db, row.id, s).await?.is_empty() {
2619 
            return Ok(s.to_string());
2620 
        }
2621 
        let heads: Vec<ChangeHash> = hexes.iter().filter_map(|h| ChangeHash::from_hex(h)).collect();
2622 
        return Ok(hash_object(ObjectType::State, &oxy_core::objects::StateObject::new(heads).encode()).to_hex());
2623 
    }
2624 
    let b = s.to_string();
2625 
    let found = app.repos.read(repo, move |r, _| Ok(r.view()?.bookmarks.get(&b).copied())).await?;
2626 
    found.map(|st| st.to_hex()).ok_or_else(|| ApiError(StatusCode::NOT_FOUND, format!("{s:?} is not a state hash, heads or a bookmark")))
d23464c0 Andy McCall ↶ 2627 
}
b66e70b7 Andy McCall ↶ 2628
2629 
// ----------------------------------------------------------------- runners
2630
2631 
/// Site administrators only, with any token of theirs (hub spec §13.2).
2632 
fn require_site_admin(c: &Caller) -> Result<&Account, ApiError> {
2633 
    match c.account.as_ref() {
2634 
        Some(a) if a.is_admin => Ok(a),
2635 
        _ => Err(not_found("no such API route")),
2636 
    }
2637 
}
2638
2639 
async fn runner_of(app: &Shared, r: db::runners::Runner, running: i64) -> hub_api::Runner {
2640 
    let serves = match r.scope_repo_id {
2641 
        Some(id) => db::repos::get_by_id(&app.db, id).await.ok().flatten().map(|p| p.slug()).unwrap_or_default(),
2642 
        None => r.scope_owner.clone(),
2643 
    };
2644 
    hub_api::Runner {
2645 
        id: r.id,
2646 
        status: r.status().to_string(),
2647 
        serves,
2648 
        labels: r.label_list().into_iter().map(String::from).collect(),
2649 
        name: r.name,
2650 
        arch: r.arch,
2651 
        os: r.os,
2652 
        version: r.version,
2653 
        max_jobs: r.max_jobs,
2654 
        memory_mib: r.memory_mib,
2655 
        cpus: r.cpus,
2656 
        key: r.key,
2657 
        source: r.source,
2658 
        last_seen_ms: r.last_seen_ms,
2659 
        running,
2fb70d01 Andy McCall ↶ 2660 
        free_disk_mib: r.free_disk_mib,
2661 
        load_x100: r.load_x100,
2662 
        speed: r.speed,
2663 
        speed_class: r.speed_class,
2664 
        kernel: r.kernel,
b66e70b7 Andy McCall ↶ 2665 
    }
2666 
}
2667
2668 
/// `GET /api/v1/runners`.
2669 
async fn runners(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<hub_api::Runner>>, ApiError> {
2670 
    let c = caller(&app, &headers).await?;
2671 
    require_site_admin(&c)?;
2672 
    let running: std::collections::HashMap<i64, i64> = db::runners::running(&app.db).await?.into_iter().collect();
2673 
    let mut out = Vec::new();
2674 
    for r in db::runners::list(&app.db).await? {
2675 
        let n = running.get(&r.id).copied().unwrap_or(0);
2676 
        out.push(runner_of(&app, r, n).await);
2677 
    }
2678 
    Ok(Json(out))
2679 
}
2680
2681 
#[derive(Deserialize)]
2682 
struct BeforeQuery {
2683 
    #[serde(default)]
2684 
    before: Option<i64>,
2685 
    #[serde(default)]
2686 
    limit: Option<i64>,
2687 
}
2688
2689 
/// `GET /api/v1/runners/{id}/jobs?before=MS&limit=N`: newest first.
2690 
async fn runner_jobs(
2691 
    State(app): State<Shared>,
2692 
    headers: HeaderMap,
2693 
    Path(id): Path<i64>,
2694 
    Query(q): Query<BeforeQuery>,
2695 
) -> Result<Json<Vec<hub_api::RunnerJob>>, ApiError> {
2696 
    let c = caller(&app, &headers).await?;
2697 
    require_site_admin(&c)?;
2698 
    db::runners::get(&app.db, id).await?.ok_or_else(|| not_found("no such runner"))?;
2699 
    let jobs = db::runners::history(&app.db, id, q.limit.unwrap_or(50).clamp(1, 200), q.before).await?;
2700 
    Ok(Json(
2701 
        jobs.into_iter()
2702 
            .map(|j| hub_api::RunnerJob {
2703 
                repo: format!("{}/{}", j.owner, j.repo),
2704 
                run: j.run_number,
2705 
                job: j.job,
2706 
                status: j.status,
2707 
                started_ms: j.started_ms,
2708 
                finished_ms: j.finished_ms,
2709 
            })
2710 
            .collect(),
2711 
    ))
2712 
}
2713
2714 
/// `GET /api/v1/runners/queue`: running jobs, then queued ones in claim order.
2715 
async fn runner_queue(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<hub_api::QueueItem>>, ApiError> {
2716 
    let c = caller(&app, &headers).await?;
2717 
    require_site_admin(&c)?;
2718 
    Ok(Json(
2719 
        db::flow::queue(&app.db)
2720 
            .await?
2721 
            .into_iter()
2722 
            .map(|e| hub_api::QueueItem {
2723 
                repo: format!("{}/{}", e.owner, e.name),
2724 
                run: e.run_number,
2725 
                job: e.job,
2726 
                status: e.status,
2727 
                runner: e.runner,
2728 
            })
2729 
            .collect(),
2730 
    ))
2731 
}
7d2eb590 Andy McCall ↶ 2732
2733 
/// `POST .../proposals/{number}/review-requests`: ask an AI assistant the
2734 
/// repository may use to review (hub spec §13.4). Accepted at once; the
2735 
/// answer arrives as a `comment` review via the assistant.
2736 
async fn request_assistant(
2737 
    State(app): State<Shared>,
2738 
    headers: HeaderMap,
2739 
    Path((owner, name, number)): Path<(String, String, i64)>,
2740 
    Json(body): Json<hub_api::AssistantRequest>,
2741 
) -> Result<(StatusCode, Json<hub_api::AssistantRequest>), ApiError> {
2742 
    let c = caller(&app, &headers).await?;
2743 
    let me = c.require("proposals:write").or_else(|_| c.require("repo:write"))?.clone();
2744 
    let (_, row, role) = reach(&app, &c, &owner, &name, Access::Read).await?;
2745 
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;
2746 
    if Some(me.id) != p.author_id && role < Role::Write {
2747 
        return Err(forbidden("only the author or a writer asks for reviews"));
2748 
    }
2749 
    if !p.is_open() {
2750 
        return Err(ApiError(StatusCode::CONFLICT, "the proposal is not open".into()));
2751 
    }
2752 
    let a = crate::assistants::enabled_for_repo(&app.db, &row)
2753 
        .await?
2754 
        .into_iter()
2755 
        .find(|a| a.name.eq_ignore_ascii_case(body.assistant.trim()))
2756 
        .ok_or_else(|| ApiError(StatusCode::UNPROCESSABLE_ENTITY, format!("no assistant called {} here", body.assistant.trim())))?;
2757 
    let asked = hub_api::AssistantRequest { assistant: a.name.clone() };
2758 
    crate::assistants::request_review(&app, &row, &p, &me, a).await.map_err(|e| ApiError(StatusCode::CONFLICT, e))?;
2759 
    Ok((StatusCode::ACCEPTED, Json(asked)))
2760 
}
62ceb2ee Andy McCall ↶ 2761
2762 
// -------------------------------------------------------- assistants (§13.4)
2763
2764 
use crate::levels::At;
2765 
use crate::web::assistants as aa;
2766
2767 
/// The level a repository's assistants live at, for its admins (repo:admin).
2768 
async fn repo_level(app: &Shared, c: &Caller, owner: &str, name: &str) -> Result<(Account, At), ApiError> {
2769 
    let me = c.require("repo:admin")?.clone();
2770 
    let (_, row, _) = reach(app, c, owner, name, Access::Admin).await?;
2771 
    Ok((me, At::repo(&row)))
2772 
}
2773
2774 
/// An organisation's level, for its owners (repo:admin).
2775 
async fn org_level(app: &Shared, c: &Caller, org: &str) -> Result<(Account, At), ApiError> {
2776 
    let me = c.require("repo:admin")?.clone();
2777 
    let o = db::accounts::org_by_name(&app.db, org).await?.ok_or_else(|| not_found("no such organisation"))?;
2778 
    if !auth::roles::is_org_owner(&app.db, &me, o.id).await? {
2779 
        return Err(not_found("no such organisation"));
2780 
    }
2781 
    Ok((me, At::org(&o)))
2782 
}
2783
2784 
/// The site's level, for its administrators.
2785 
fn site_level(c: &Caller) -> Result<(Account, At), ApiError> {
2786 
    Ok((require_site_admin(c)?.clone(), At::site()))
2787 
}
2788
2789 
fn put_outcome(r: Result<String, String>) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
2790 
    match r {
2791 
        Ok(msg) => Ok((StatusCode::OK, Json(serde_json::json!({ "ok": msg })))),
2792 
        Err(e) => Err(ApiError(StatusCode::UNPROCESSABLE_ENTITY, e)),
2793 
    }
2794 
}
2795
2796 
macro_rules! assistant_routes {
2797 
    ($list:ident, $put:ident, $del:ident, $prompt:ident, $prompt_put:ident, ($($p:ident: $t:ty),*), $level:expr) => {
2798 
        async fn $list(State(app): State<Shared>, headers: HeaderMap, Path(($($p),*)): Path<($($t),*)>) -> Result<Json<Vec<Assistant>>, ApiError> {
2799 
            let c = caller(&app, &headers).await?;
2800 
            let (_, at) = $level(&app, &c, $(&$p),*).await?;
2801 
            Ok(Json(aa::api_list(&app, &at).await?))
2802 
        }
2803 
        async fn $put(
2804 
            State(app): State<Shared>,
2805 
            headers: HeaderMap,
2806 
            Path(($($p),*)): Path<($($t),*)>,
2807 
            Json(body): Json<NewAssistant>,
2808 
        ) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
2809 
            let c = caller(&app, &headers).await?;
2810 
            let (me, at) = $level(&app, &c, $(&$p),*).await?;
2811 
            put_outcome(aa::api_put(&app, &me, &at, body).await?)
2812 
        }
2813 
        async fn $prompt(State(app): State<Shared>, headers: HeaderMap, Path(($($p),*)): Path<($($t),*)>) -> Result<Json<AssistantPrompt>, ApiError> {
2814 
            let c = caller(&app, &headers).await?;
2815 
            let (_, at) = $level(&app, &c, $(&$p),*).await?;
2816 
            Ok(Json(aa::api_prompt(&app, &at).await?))
2817 
        }
2818 
        async fn $prompt_put(
2819 
            State(app): State<Shared>,
2820 
            headers: HeaderMap,
2821 
            Path(($($p),*)): Path<($($t),*)>,
2822 
            Json(body): Json<AssistantPrompt>,
2823 
        ) -> Result<Json<AssistantPrompt>, ApiError> {
2824 
            let c = caller(&app, &headers).await?;
2825 
            let (me, at) = $level(&app, &c, $(&$p),*).await?;
2826 
            aa::api_set_prompt(&app, &me, &at, &body.prompt).await?.map_err(|e| ApiError(StatusCode::UNPROCESSABLE_ENTITY, e))?;
2827 
            Ok(Json(aa::api_prompt(&app, &at).await?))
2828 
        }
2829 
    };
2830 
}
2831
2832 
assistant_routes!(repo_assistants, repo_assistant_put, _rd, repo_prompt, repo_prompt_put, (owner: String, name: String), repo_level);
2833
2834 
async fn repo_assistant_delete(
2835 
    State(app): State<Shared>,
2836 
    headers: HeaderMap,
2837 
    Path((owner, name, assistant)): Path<(String, String, String)>,
2838 
) -> Result<StatusCode, ApiError> {
2839 
    let c = caller(&app, &headers).await?;
2840 
    let (me, at) = repo_level(&app, &c, &owner, &name).await?;
2841 
    if aa::api_delete(&app, &me, &at, &assistant).await? {
2842 
        Ok(StatusCode::NO_CONTENT)
2843 
    } else {
2844 
        Err(not_found("no such assistant at this level"))
2845 
    }
2846 
}
2847
2848 
async fn org_level_one(app: &Shared, c: &Caller, org: &str) -> Result<(Account, At), ApiError> {
2849 
    org_level(app, c, org).await
2850 
}
2851
2852 
async fn org_assistants(State(app): State<Shared>, headers: HeaderMap, Path(org): Path<String>) -> Result<Json<Vec<Assistant>>, ApiError> {
2853 
    let c = caller(&app, &headers).await?;
2854 
    let (_, at) = org_level_one(&app, &c, &org).await?;
2855 
    Ok(Json(aa::api_list(&app, &at).await?))
2856 
}
2857
2858 
async fn org_assistant_put(
2859 
    State(app): State<Shared>,
2860 
    headers: HeaderMap,
2861 
    Path(org): Path<String>,
2862 
    Json(body): Json<NewAssistant>,
2863 
) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
2864 
    let c = caller(&app, &headers).await?;
2865 
    let (me, at) = org_level_one(&app, &c, &org).await?;
2866 
    put_outcome(aa::api_put(&app, &me, &at, body).await?)
2867 
}
2868
2869 
async fn org_assistant_delete(
2870 
    State(app): State<Shared>,
2871 
    headers: HeaderMap,
2872 
    Path((org, assistant)): Path<(String, String)>,
2873 
) -> Result<StatusCode, ApiError> {
2874 
    let c = caller(&app, &headers).await?;
2875 
    let (me, at) = org_level_one(&app, &c, &org).await?;
2876 
    if aa::api_delete(&app, &me, &at, &assistant).await? {
2877 
        Ok(StatusCode::NO_CONTENT)
2878 
    } else {
2879 
        Err(not_found("no such assistant at this level"))
2880 
    }
2881 
}
2882
2883 
async fn org_prompt(State(app): State<Shared>, headers: HeaderMap, Path(org): Path<String>) -> Result<Json<AssistantPrompt>, ApiError> {
2884 
    let c = caller(&app, &headers).await?;
2885 
    let (_, at) = org_level_one(&app, &c, &org).await?;
2886 
    Ok(Json(aa::api_prompt(&app, &at).await?))
2887 
}
2888
2889 
async fn org_prompt_put(
2890 
    State(app): State<Shared>,
2891 
    headers: HeaderMap,
2892 
    Path(org): Path<String>,
2893 
    Json(body): Json<AssistantPrompt>,
2894 
) -> Result<Json<AssistantPrompt>, ApiError> {
2895 
    let c = caller(&app, &headers).await?;
2896 
    let (me, at) = org_level_one(&app, &c, &org).await?;
2897 
    aa::api_set_prompt(&app, &me, &at, &body.prompt).await?.map_err(|e| ApiError(StatusCode::UNPROCESSABLE_ENTITY, e))?;
2898 
    Ok(Json(aa::api_prompt(&app, &at).await?))
2899 
}
2900
2901 
async fn site_assistants(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<Assistant>>, ApiError> {
2902 
    let c = caller(&app, &headers).await?;
2903 
    let (_, at) = site_level(&c)?;
2904 
    Ok(Json(aa::api_list(&app, &at).await?))
2905 
}
2906
2907 
async fn site_assistant_put(
2908 
    State(app): State<Shared>,
2909 
    headers: HeaderMap,
2910 
    Json(body): Json<NewAssistant>,
2911 
) -> Result<(StatusCode, Json<serde_json::Value>), ApiError> {
2912 
    let c = caller(&app, &headers).await?;
2913 
    let (me, at) = site_level(&c)?;
2914 
    put_outcome(aa::api_put(&app, &me, &at, body).await?)
2915 
}
2916
2917 
async fn site_assistant_delete(
2918 
    State(app): State<Shared>,
2919 
    headers: HeaderMap,
2920 
    Path(assistant): Path<String>,
2921 
) -> Result<StatusCode, ApiError> {
2922 
    let c = caller(&app, &headers).await?;
2923 
    let (me, at) = site_level(&c)?;
2924 
    if aa::api_delete(&app, &me, &at, &assistant).await? {
2925 
        Ok(StatusCode::NO_CONTENT)
2926 
    } else {
2927 
        Err(not_found("no such assistant at this level"))
2928 
    }
2929 
}
2930
2931 
async fn site_prompt(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<AssistantPrompt>, ApiError> {
2932 
    let c = caller(&app, &headers).await?;
2933 
    let (_, at) = site_level(&c)?;
2934 
    Ok(Json(aa::api_prompt(&app, &at).await?))
2935 
}
2936
2937 
async fn site_prompt_put(
2938 
    State(app): State<Shared>,
2939 
    headers: HeaderMap,
2940 
    Json(body): Json<AssistantPrompt>,
2941 
) -> Result<Json<AssistantPrompt>, ApiError> {
2942 
    let c = caller(&app, &headers).await?;
2943 
    let (me, at) = site_level(&c)?;
2944 
    aa::api_set_prompt(&app, &me, &at, &body.prompt).await?.map_err(|e| ApiError(StatusCode::UNPROCESSABLE_ENTITY, e))?;
2945 
    Ok(Json(aa::api_prompt(&app, &at).await?))
2946 
}