OXYGENHUB

Coverage / crates/hub/src/web/orgs.rs 55.5%

292 of 526 lines run, 37 of 204 functions · run #545 on main · run missed

1
//! Organisations and teams (hub spec §5.2).
2
3
use super::settings::{csrf, require};
4
use super::{filters, Error, Page, Shell};
5
use crate::auth::{roles, Viewer};
6
use crate::db::accounts;
7
use crate::Shared;
8
use askama::Template;
9
use axum::extract::{Form, Path, State};
10
use axum::response::{IntoResponse, Redirect, Response};
11
use serde::Deserialize;
12
13
#[derive(Template)]
14
#[template(path = "org_new.html")]
15
pub struct OrgNewPage {
16
    shell: Shell,
17
    error: Option<String>,
18
}
19
204×
pub async fn new_form(State(app): State<Shared>, viewer: Viewer) -> Result<Page<OrgNewPage>, Error> {
214×
    let shell = Shell::new(&app, "/orgs/new", &viewer);
224×
    require(&viewer, &shell)?;
234×
    Ok(Page(OrgNewPage { shell, error: None }))
244×
}
25
26
#[derive(Deserialize)]
27
pub struct OrgNewForm {
28
    #[serde(rename = "_csrf")]
29
    csrf_token: String,
30
    name: String,
31
    display_name: String,
32
}
33
345×
pub async fn create(State(app): State<Shared>, viewer: Viewer, Form(f): Form<OrgNewForm>) -> Result<Response, Error> {
355×
    let shell = Shell::new(&app, "/orgs/new", &viewer);
365×
    let me = require(&viewer, &shell)?;
375×
    csrf(&viewer, &f.csrf_token, &shell)?;
385×
    let name = f.name.trim().to_string();
395×
    if !crate::repos::names::valid_owner(&name) {
400×
        return Ok(Page(OrgNewPage {
410×
            shell,
420×
            error: Some("An organisation name is letters, digits, dots, dashes and underscores.".into()),
430×
        })
440×
        .into_response());
455×
    }
465×
    let taken = accounts::account_by_name(&app.db, &name).await.map_err(|e| Error::from_db(shell.clone(), e))?.is_some()
475×
        || accounts::org_by_name(&app.db, &name).await.map_err(|e| Error::from_db(shell.clone(), e))?.is_some()
485×
        || accounts::username_retired(&app.db, &name).await.map_err(|e| Error::from_db(shell.clone(), e))?;
495×
    if taken {
500×
        return Ok(Page(OrgNewPage { shell, error: Some("That name is taken.".into()) }).into_response());
515×
    }
525×
    let org =
535×
        accounts::create_org(&app.db, &name, f.display_name.trim(), me.account.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
545×
    accounts::audit(&app.db, Some(&me.account), "org.created", &org.name, "").await.ok();
555×
    Ok(Redirect::to(&format!("/orgs/{}/settings", org.name)).into_response())
565×
}
57
58
#[derive(Template)]
59
#[template(path = "org_settings.html")]
60
pub struct OrgSettingsPage {
61
    shell: Shell,
62
    org: accounts::Organisation,
63
    members: Vec<(accounts::Account, String)>,
64
    teams: Vec<(accounts::Team, Vec<accounts::Account>)>,
65
    hooks: Vec<super::webhooks::HookRow>,
66
    notice: Option<String>,
67
    error: Option<String>,
68
    /// Runners serving the organisation: (runner, what it serves, whether
69
    /// it is the organisation's own).
70
    runners: Vec<(crate::db::runners::Runner, String, bool)>,
71
    /// Its runners' updates (oxygenhub#322): its setting, test groups and runners.
72
    updates: super::runner_updates::UpdateViews,
73
    /// A registration token just made, shown once.
74
    runner_token: Option<String>,
75
    /// The organisation's AI assistants and prompt (#97).
76
    assistants: super::assistants::Panel,
77
    /// The organisation's Flow variables (#102).
78
    variables: super::variables::Panel,
79
    /// The organisation's Flow secrets (#107).
80
    secrets: super::secrets::Panel,
81
    /// Where its new repositories may live (#96).
82
    policy: crate::storage::Policy,
83
    /// Its new repositories' default bookmark (#371), and the site's.
84
    default_bookmark: String,
85
    site_bookmark: String,
86
}
87
8831×
async fn org_page(
8931×
    app: &Shared,
9031×
    shell: Shell,
9131×
    org: accounts::Organisation,
9231×
    notice: Option<String>,
9331×
    error: Option<String>,
9431×
) -> Result<Page<OrgSettingsPage>, Error> {
9531×
    let members = accounts::org_members(&app.db, org.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
9631×
    let mut teams = Vec::new();
9731×
    for t in accounts::teams(&app.db, org.id).await.map_err(|e| Error::from_db(shell.clone(), e))? {
980×
        let members = accounts::team_members(&app.db, t.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
990×
        teams.push((t, members));
100
    }
10131×
    let hooks = crate::db::hooks::hooks_for_org(&app.db, org.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
10231×
    let hooks = super::webhooks::rows(app, hooks).await.map_err(|e| Error::from_db(shell.clone(), e))?;
10331×
    let updates = super::runner_updates::views(app, &super::runner_updates::Reach::Org(org.name.clone()))
10431×
        .await
10531×
        .map_err(|e| Error::from_db(shell.clone(), e))?;
10631×
    let mut runners = Vec::new();
10733×
    for r in crate::db::runners::serving_owner(&app.db, &org.name).await.map_err(|e| Error::from_db(shell.clone(), e))? {
10833×
        let own = r.scope_owner == org.name;
10933×
        let serves = match r.scope_repo_id {
1100×
            Some(id) => crate::db::repos::get_by_id(&app.db, id).await.ok().flatten().map(|p| p.slug()).unwrap_or_default(),
11120×
            None if own => "the organisation's repositories".into(),
11213×
            None => "the whole site".into(),
113
        };
11433×
        runners.push((r, serves, own));
115
    }
11631×
    let assistants = super::assistants::panel(app, &org_assistants(&org)).await.map_err(|e| Error::from_db(shell.clone(), e))?;
11731×
    let variables = super::variables::panel(app, &org_assistants(&org)).await.map_err(|e| Error::from_db(shell.clone(), e))?;
11831×
    let secrets = super::secrets::panel(app, &org_assistants(&org)).await.map_err(|e| Error::from_db(shell.clone(), e))?;
11931×
    let policy = crate::storage::policy(&app.db, org.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
12031×
    let default_bookmark = crate::repo_setup::bookmark_setting(&app.db, crate::repo_setup::BookmarkScope::Org(org.id))
12131×
        .await
12231×
        .ok()
12331×
        .flatten()
12431×
        .unwrap_or_default();
12531×
    let site_bookmark = crate::repo_setup::bookmark_setting(&app.db, crate::repo_setup::BookmarkScope::Site)
12631×
        .await
12731×
        .ok()
12831×
        .flatten()
12931×
        .unwrap_or_else(|| crate::repo_setup::MAIN.into());
13031×
    Ok(Page(OrgSettingsPage {
13131×
        default_bookmark,
13231×
        site_bookmark,
13331×
        policy,
13431×
        shell,
13531×
        org,
13631×
        members,
13731×
        teams,
13831×
        hooks,
13931×
        notice,
14031×
        error,
14131×
        runners,
14231×
        updates,
14331×
        runner_token: None,
14431×
        assistants,
14531×
        variables,
14631×
        secrets,
14731×
    }))
14831×
}
149
15038×
pub(crate) async fn owned_org(
15138×
    app: &Shared,
15238×
    shell: &Shell,
15338×
    viewer: &Viewer,
15438×
    name: &str,
15538×
) -> Result<(accounts::Account, accounts::Organisation), Error> {
15638×
    let me = require(viewer, shell)?;
15738×
    let org = accounts::org_by_name(&app.db, name)
15838×
        .await
15938×
        .map_err(|e| Error::from_db(shell.clone(), e))?
16038×
        .ok_or_else(|| Error::not_found(shell.clone()))?;
16138×
    if !roles::is_org_owner(&app.db, &me.account, org.id).await.map_err(|e| Error::from_db(shell.clone(), e))? {
1624×
        return Err(Error::not_found(shell.clone()));
16334×
    }
16434×
    Ok((me.account, org))
16538×
}
166
16710×
pub async fn settings(State(app): State<Shared>, viewer: Viewer, Path(name): Path<String>) -> Result<Page<OrgSettingsPage>, Error> {
16810×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
16910×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
1709×
    org_page(&app, shell, org, None, None).await
17110×
}
172
173
#[derive(Deserialize)]
174
pub struct OrgForm {
175
    #[serde(rename = "_csrf")]
176
    csrf_token: String,
177
    display_name: String,
178
    description: String,
179
    default_role: String,
180
    /// Its new repositories' default bookmark (#371); empty, the site's.
181
    #[serde(default)]
182
    default_bookmark: String,
183
}
184
1850×
pub async fn update(
1860×
    State(app): State<Shared>,
1870×
    viewer: Viewer,
1880×
    Path(name): Path<String>,
1890×
    Form(f): Form<OrgForm>,
1900×
) -> Result<Page<OrgSettingsPage>, Error> {
1910×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
1920×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
1930×
    csrf(&viewer, &f.csrf_token, &shell)?;
1940×
    let role = if f.default_role == "none" || roles::Role::parse(&f.default_role).is_some() { f.default_role.as_str() } else { "read" };
1950×
    if let Err(m) =
1960×
        crate::repo_setup::set_bookmark_setting(&app.db, crate::repo_setup::BookmarkScope::Org(org.id), &f.default_bookmark).await
197
    {
1980×
        return org_page(&app, shell, org, None, Some(m)).await;
1990×
    }
2000×
    accounts::set_org(&app.db, org.id, f.display_name.trim(), f.description.trim(), role)
2010×
        .await
2020×
        .map_err(|e| Error::from_db(shell.clone(), e))?;
2030×
    accounts::audit(&app.db, Some(&me), "org.updated", &org.name, "").await.ok();
2040×
    let org = accounts::org_by_name(&app.db, &name).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(org);
2050×
    org_page(&app, shell, org, Some("Saved.".into()), None).await
2060×
}
207
208
#[derive(Deserialize)]
209
pub struct PriorityForm {
210
    #[serde(rename = "_csrf")]
211
    csrf_token: String,
212
    priority: String,
213
}
214
215
/// `POST /orgs/{name}/settings/flow-priority` (oxygenhub#244): its
216
/// repositories' Flow level unless one sets its own. Owners choose low,
217
/// normal or the site's; only site administrators raise one to high.
2180×
pub async fn flow_priority(
2190×
    State(app): State<Shared>,
2200×
    viewer: Viewer,
2210×
    Path(name): Path<String>,
2220×
    Form(f): Form<PriorityForm>,
2230×
) -> Result<Page<OrgSettingsPage>, Error> {
2240×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
2250×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
2260×
    csrf(&viewer, &f.csrf_token, &shell)?;
2270×
    let level = match f.priority.as_str() {
2280×
        "low" | "normal" | "high" => f.priority.as_str(),
2290×
        "default" => "",
2300×
        _ => return org_page(&app, shell, org, None, Some("Pick low, normal, high or the site's.".into())).await,
231
    };
2320×
    if level == "high" && !viewer.is_admin() {
2330×
        return org_page(&app, shell, org, None, Some("Only site administrators raise an organisation to high.".into())).await;
2340×
    }
2350×
    accounts::set_org_flow_priority(&app.db, org.id, level).await.map_err(|e| Error::from_db(shell.clone(), e))?;
2360×
    accounts::audit(&app.db, Some(&me), "org.flow_priority", &org.name, if level.is_empty() { "default" } else { level }).await.ok();
2370×
    let org = accounts::org_by_name(&app.db, &name).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(org);
2380×
    org_page(&app, shell, org, Some("Saved.".into()), None).await
2390×
}
240
241
#[derive(Deserialize)]
242
pub struct MemberForm {
243
    #[serde(rename = "_csrf")]
244
    csrf_token: String,
245
    username: String,
246
    #[serde(default)]
247
    role: String,
248
    #[serde(default)]
249
    remove: Option<String>,
250
}
251
2521×
pub async fn member(
2531×
    State(app): State<Shared>,
2541×
    viewer: Viewer,
2551×
    Path(name): Path<String>,
2561×
    Form(f): Form<MemberForm>,
2571×
) -> Result<Page<OrgSettingsPage>, Error> {
2581×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
2591×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
2601×
    csrf(&viewer, &f.csrf_token, &shell)?;
2611×
    let Some(target) = accounts::account_by_name(&app.db, f.username.trim()).await.map_err(|e| Error::from_db(shell.clone(), e))? else {
2620×
        return org_page(&app, shell, org, None, Some("No such account.".into())).await;
263
    };
2641×
    if f.remove.is_some() {
2650×
        let owners = accounts::org_members(&app.db, org.id)
2660×
            .await
2670×
            .map_err(|e| Error::from_db(shell.clone(), e))?
2680×
            .iter()
2690×
            .filter(|(_, r)| r == "owner")
2700×
            .count();
2710×
        let is_owner =
2720×
            accounts::org_role(&app.db, org.id, target.id).await.map_err(|e| Error::from_db(shell.clone(), e))?.as_deref() == Some("owner");
2730×
        if is_owner && owners <= 1 {
2740×
            return org_page(&app, shell, org, None, Some("An organisation keeps at least one owner.".into())).await;
2750×
        }
2760×
        accounts::remove_org_member(&app.db, org.id, target.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
2770×
        accounts::audit(&app.db, Some(&me), "org.member.removed", &org.name, &target.username).await.ok();
2780×
        return org_page(&app, shell, org, Some(format!("Removed {}.", target.username)), None).await;
2791×
    }
2801×
    let role = if f.role == "owner" { "owner" } else { "member" };
2811×
    accounts::set_org_member(&app.db, org.id, target.id, role).await.map_err(|e| Error::from_db(shell.clone(), e))?;
2821×
    accounts::audit(&app.db, Some(&me), "org.member.set", &org.name, &format!("{} {role}", target.username)).await.ok();
2831×
    org_page(&app, shell, org, Some(format!("{} is now {role}.", target.username)), None).await
2841×
}
285
286
#[derive(Deserialize)]
287
pub struct TeamForm {
288
    #[serde(rename = "_csrf")]
289
    csrf_token: String,
290
    team: String,
291
    #[serde(default)]
292
    username: String,
293
    #[serde(default)]
294
    action: String,
295
}
296
2970×
pub async fn team(
2980×
    State(app): State<Shared>,
2990×
    viewer: Viewer,
3000×
    Path(name): Path<String>,
3010×
    Form(f): Form<TeamForm>,
3020×
) -> Result<Page<OrgSettingsPage>, Error> {
3030×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
3040×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
3050×
    csrf(&viewer, &f.csrf_token, &shell)?;
3060×
    let team_name = f.team.trim().to_string();
3070×
    if !crate::repos::names::valid_segment(&team_name) {
3080×
        return org_page(&app, shell, org, None, Some("A team name is letters, digits, dots, dashes and underscores.".into())).await;
3090×
    }
3100×
    let existing = accounts::team_by_name(&app.db, org.id, &team_name).await.map_err(|e| Error::from_db(shell.clone(), e))?;
3110×
    let notice = match f.action.as_str() {
3120×
        "create" => {
3130×
            if existing.is_some() {
3140×
                return org_page(&app, shell, org, None, Some("That team exists.".into())).await;
3150×
            }
3160×
            accounts::create_team(&app.db, org.id, &team_name).await.map_err(|e| Error::from_db(shell.clone(), e))?;
3170×
            format!("Team {team_name} created.")
318
        }
3190×
        "delete" => {
3200×
            if let Some(t) = existing {
3210×
                accounts::delete_team(&app.db, t.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
3220×
            }
3230×
            format!("Team {team_name} deleted.")
324
        }
3250×
        "add" | "remove" => {
3260×
            let Some(t) = existing else { return org_page(&app, shell, org, None, Some("No such team.".into())).await };
3270×
            let Some(target) = accounts::account_by_name(&app.db, f.username.trim()).await.map_err(|e| Error::from_db(shell.clone(), e))?
328
            else {
3290×
                return org_page(&app, shell, org, None, Some("No such account.".into())).await;
330
            };
3310×
            if f.action == "add" {
3320×
                accounts::set_org_member(&app.db, org.id, target.id, "member").await.ok();
3330×
                accounts::add_team_member(&app.db, t.id, target.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
3340×
                format!("{} added to {team_name}.", target.username)
335
            } else {
3360×
                accounts::remove_team_member(&app.db, t.id, target.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
3370×
                format!("{} removed from {team_name}.", target.username)
338
            }
339
        }
3400×
        _ => return Err(Error::bad(shell, "unknown team action")),
341
    };
3420×
    accounts::audit(&app.db, Some(&me), "org.team", &org.name, &format!("{} {team_name} {}", f.action, f.username.trim())).await.ok();
3430×
    org_page(&app, shell, org, Some(notice), None).await
3440×
}
345
346
/// `POST /orgs/{name}/settings/avatar`: upload or remove the organisation's logo.
3472×
pub async fn avatar(
3482×
    State(app): State<Shared>,
3492×
    viewer: Viewer,
3502×
    Path(name): Path<String>,
3512×
    multipart: axum::extract::Multipart,
3522×
) -> Result<Page<OrgSettingsPage>, Error> {
3532×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
3542×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
3551×
    let upload = super::avatar::read_upload(multipart).await;
3561×
    csrf(&viewer, &upload.csrf, &shell)?;
3571×
    let result = super::avatar::apply(&app, "org", org.id, upload).await;
3581×
    if result.is_ok() {
3591×
        accounts::audit(&app.db, Some(&me), "org.picture", &org.name, "").await.ok();
3600×
    }
3611×
    let org = accounts::org_by_name(&app.db, &name).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(org);
3621×
    match result {
3631×
        Ok(m) => org_page(&app, shell, org, Some(m), None).await,
3640×
        Err(e) => org_page(&app, shell, org, None, Some(e)).await,
365
    }
3662×
}
367
368
/// `POST /orgs/{name}/settings/hooks`: webhooks that hear every repository of the organisation.
3694×
pub async fn hooks(
3704×
    State(app): State<Shared>,
3714×
    viewer: Viewer,
3724×
    Path(name): Path<String>,
3734×
    Form(f): Form<super::webhooks::HookForm>,
3744×
) -> Result<Page<OrgSettingsPage>, Error> {
3754×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
3764×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
3774×
    csrf(&viewer, &f.csrf_token, &shell)?;
3784×
    let scope = super::webhooks::Scope::Org { id: org.id, name: org.name.clone() };
3794×
    match super::webhooks::apply(&app, &viewer, &scope, f).await.map_err(|e| Error::from_db(shell.clone(), e))? {
3803×
        Ok(notice) => org_page(&app, shell, org, Some(notice), None).await,
3811×
        Err(error) => org_page(&app, shell, org, None, Some(error)).await,
382
    }
3834×
}
384
3852×
pub async fn deliveries(
3862×
    State(app): State<Shared>,
3872×
    viewer: Viewer,
3882×
    Path((name, id)): Path<(String, i64)>,
3892×
) -> Result<Page<super::webhooks::DeliveriesPage>, Error> {
3902×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings/hooks/{id}/deliveries"), &viewer);
3912×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
3922×
    let scope = super::webhooks::Scope::Org { id: org.id, name: org.name };
3932×
    super::webhooks::deliveries_page(&app, shell, &scope, None, id).await
3942×
}
395
3960×
pub async fn redeliver(
3970×
    State(app): State<Shared>,
3980×
    viewer: Viewer,
3990×
    Path((name, id, delivery)): Path<(String, i64, i64)>,
4000×
    Form(f): Form<super::session::CsrfForm>,
4010×
) -> Result<Page<super::webhooks::DeliveriesPage>, Error> {
4020×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings/hooks/{id}/deliveries"), &viewer);
4030×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
4040×
    csrf(&viewer, &f.csrf, &shell)?;
4050×
    let scope = super::webhooks::Scope::Org { id: org.id, name: org.name };
4060×
    super::webhooks::redeliver(&app, &scope, id, delivery).await.map_err(|e| Error::from_db(shell.clone(), e))?;
4070×
    super::webhooks::deliveries_page(&app, shell, &scope, None, id).await
4080×
}
409
410
/// `POST /orgs/{name}/settings/runners/token`: a one-time registration
411
/// token for a runner that serves the organisation's repositories
412
/// (oxygenhub#41).
4133×
pub async fn runner_token(
4143×
    State(app): State<Shared>,
4153×
    viewer: Viewer,
4163×
    Path(name): Path<String>,
4173×
    Form(f): Form<super::session::CsrfForm>,
4183×
) -> Result<Page<OrgSettingsPage>, Error> {
4193×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
4203×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
4213×
    csrf(&viewer, &f.csrf, &shell)?;
4223×
    let token = format!("flowreg_{}", crate::auth::random_hex(24));
4233×
    let scope = crate::db::runners::Scope { owner: org.name.clone(), repo_id: None };
4243×
    crate::db::runners::add_registration(&app.db, &blake3::hash(token.as_bytes()).to_hex(), &me.username, &scope)
4253×
        .await
4263×
        .map_err(|e| Error::from_db(shell.clone(), e))?;
4273×
    accounts::audit(&app.db, Some(&me), "flow.runner.token", &org.name, "registration token for the organisation").await.ok();
4283×
    let mut page = org_page(&app, shell, org, Some("Copy the token now; it is not shown again.".into()), None).await?;
4293×
    page.0.runner_token = Some(token);
4303×
    Ok(page)
4313×
}
432
433
/// `POST /orgs/{name}/settings/runners/{id}/remove`: remove a runner scoped
434
/// to the organisation or one of its repositories, when it runs nothing.
4351×
pub async fn runner_remove(
4361×
    State(app): State<Shared>,
4371×
    viewer: Viewer,
4381×
    Path((name, id)): Path<(String, i64)>,
4391×
    Form(f): Form<super::session::CsrfForm>,
4401×
) -> Result<Page<OrgSettingsPage>, Error> {
4411×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
4421×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
4431×
    csrf(&viewer, &f.csrf, &shell)?;
4441×
    let e = |e| Error::from_db(shell.clone(), e);
4451×
    let Some(r) = crate::db::runners::get(&app.db, id).await.map_err(e)?.filter(|r| r.scope_owner == org.name) else {
4460×
        return Err(Error::not_found(shell));
447
    };
4481×
    if crate::db::runners::running(&app.db).await.map_err(e)?.iter().any(|(rid, n)| *rid == id && *n > 0) {
4490×
        return org_page(&app, shell, org, None, Some(format!("{} is running jobs: wait for them to finish.", r.name))).await;
4501×
    }
4511×
    crate::db::runners::remove(&app.db, id).await.map_err(e)?;
4521×
    accounts::audit(&app.db, Some(&me), "flow.runner.removed", &r.name, &org.name).await.ok();
4531×
    org_page(&app, shell, org, Some(format!("{} removed: its credential no longer works.", r.name)), None).await
4541×
}
455
45695×
fn org_assistants(org: &accounts::Organisation) -> crate::levels::At {
45795×
    crate::levels::At::org(org)
45895×
}
459
460
/// `POST /orgs/{name}/settings/assistants`: the organisation's assistants
461
/// and prompt (#97).
4623×
pub async fn assistants(
4633×
    State(app): State<Shared>,
4643×
    viewer: Viewer,
4653×
    Path(name): Path<String>,
4663×
    Form(f): Form<super::assistants::AssistantForm>,
4673×
) -> Result<Page<OrgSettingsPage>, Error> {
4683×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
4693×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
4702×
    csrf(&viewer, &f.csrf_token, &shell)?;
4712×
    match super::assistants::apply(&app, &viewer, &org_assistants(&org), f).await.map_err(|e| Error::from_db(shell.clone(), e))? {
4722×
        Ok(notice) => org_page(&app, shell, org, Some(notice), None).await,
4730×
        Err(error) => org_page(&app, shell, org, None, Some(error)).await,
474
    }
4753×
}
476
477
#[derive(Deserialize)]
478
pub struct PolicyForm {
479
    #[serde(rename = "_csrf")]
480
    csrf_token: String,
481
    #[serde(default)]
482
    require_bucket: Option<String>,
483
    #[serde(default)]
484
    allowed: String,
485
}
486
487
/// `POST /orgs/{name}/settings/storage`: where the organisation's new
488
/// repositories may live (#96).
4892×
pub async fn storage(
4902×
    State(app): State<Shared>,
4912×
    viewer: Viewer,
4922×
    Path(name): Path<String>,
4932×
    Form(f): Form<PolicyForm>,
4942×
) -> Result<Page<OrgSettingsPage>, Error> {
4952×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
4962×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
4972×
    csrf(&viewer, &f.csrf_token, &shell)?;
4982×
    match crate::storage::set_policy(&app.db, org.id, f.require_bucket.is_some(), &f.allowed).await {
4991×
        Ok(p) => {
5001×
            let what = match (p.require_bucket, p.allowed.is_empty()) {
5010×
                (true, true) => "every new repository in a bucket".to_string(),
5021×
                (true, false) => format!("every new repository in {}", p.allowed.join(", ")),
5030×
                (false, true) => "any storage".to_string(),
5040×
                (false, false) => format!("buckets only in {}", p.allowed.join(", ")),
505
            };
5061×
            accounts::audit(&app.db, Some(&me), "org.storage_policy", &org.name, &what).await.ok();
5071×
            org_page(&app, shell, org, Some(format!("Storage policy saved: {what}.")), None).await
508
        }
5091×
        Err(e) => org_page(&app, shell, org, None, Some(format!("Storage policy: {e}."))).await,
510
    }
5112×
}
512
513
/// `POST /orgs/{name}/settings/variables`: the organisation's Flow
514
/// variables (#102).
5150×
pub async fn variables(
5160×
    State(app): State<Shared>,
5170×
    viewer: Viewer,
5180×
    Path(name): Path<String>,
5190×
    Form(f): Form<super::variables::VariableForm>,
5200×
) -> Result<Page<OrgSettingsPage>, Error> {
5210×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
5220×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
5230×
    csrf(&viewer, &f.csrf_token, &shell)?;
5240×
    match super::variables::apply(&app, &viewer, &org_assistants(&org), f).await.map_err(|e| Error::from_db(shell.clone(), e))? {
5250×
        Ok(notice) => org_page(&app, shell, org, Some(notice), None).await,
5260×
        Err(error) => org_page(&app, shell, org, None, Some(error)).await,
527
    }
5280×
}
529
530
/// `POST /orgs/{name}/settings/secrets`: the organisation's Flow secrets (#107).
5310×
pub async fn secrets(
5320×
    State(app): State<Shared>,
5330×
    viewer: Viewer,
5340×
    Path(name): Path<String>,
5350×
    Form(f): Form<super::secrets::SecretForm>,
5360×
) -> Result<Page<OrgSettingsPage>, Error> {
5370×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
5380×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
5390×
    csrf(&viewer, &f.csrf_token, &shell)?;
5400×
    match super::secrets::apply(&app, &viewer, &org_assistants(&org), f).await.map_err(|e| Error::from_db(shell.clone(), e))? {
5410×
        Ok(notice) => org_page(&app, shell, org, Some(notice), None).await,
5420×
        Err(error) => org_page(&app, shell, org, None, Some(error)).await,
543
    }
5440×
}
545
546
/// `POST /orgs/{name}/settings/assistants/models`: what a provider offers (#109).
5470×
pub async fn assistant_models(
5480×
    State(app): State<Shared>,
5490×
    viewer: Viewer,
5500×
    Path(name): Path<String>,
5510×
    Form(f): Form<super::assistants::ModelsForm>,
5520×
) -> Result<axum::Json<serde_json::Value>, Error> {
5530×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
5540×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
5550×
    csrf(&viewer, &f.csrf_token, &shell)?;
5560×
    Ok(axum::Json(super::assistants::models(&app, &org_assistants(&org), f).await.map_err(|e| Error::from_db(shell.clone(), e))?))
5570×
}
558
559
/// `POST /orgs/{name}/settings/runners/updates/policy`: the organisation's,
560
/// one of its test groups' or one of its runners' update settings.
5616×
pub async fn runner_updates_policy(
5626×
    State(app): State<Shared>,
5636×
    viewer: Viewer,
5646×
    Path(name): Path<String>,
5656×
    Form(f): Form<super::runner_updates::PolicyForm>,
5666×
) -> Result<Page<OrgSettingsPage>, Error> {
5676×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
5686×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
5696×
    csrf(&viewer, &f.csrf_token, &shell)?;
5706×
    let reach = super::runner_updates::Reach::Org(org.name.clone());
5716×
    let outcome = super::runner_updates::apply_policy(&app, &me, &reach, &f).await.map_err(|e| Error::from_db(shell.clone(), e))?;
5726×
    org_page_after(&app, shell, org, outcome).await
5736×
}
574
575
/// `POST /orgs/{name}/settings/runners/updates/groups`: a test group of the organisation's runners.
5761×
pub async fn runner_updates_group_new(
5771×
    State(app): State<Shared>,
5781×
    viewer: Viewer,
5791×
    Path(name): Path<String>,
5801×
    axum_extra::extract::Form(f): axum_extra::extract::Form<super::runner_updates::GroupForm>,
5811×
) -> Result<Page<OrgSettingsPage>, Error> {
5821×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
5831×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
5841×
    csrf(&viewer, &f.csrf_token, &shell)?;
5851×
    let reach = super::runner_updates::Reach::Org(org.name.clone());
5861×
    let outcome = super::runner_updates::apply_create_group(&app, &me, &reach, &f).await.map_err(|e| Error::from_db(shell.clone(), e))?;
5871×
    org_page_after(&app, shell, org, outcome).await
5881×
}
589
590
/// `POST /orgs/{name}/settings/runners/updates/groups/{id}`: who is in one of its test groups.
5910×
pub async fn runner_updates_group(
5920×
    State(app): State<Shared>,
5930×
    viewer: Viewer,
5940×
    Path((name, id)): Path<(String, i64)>,
5950×
    axum_extra::extract::Form(f): axum_extra::extract::Form<super::runner_updates::GroupForm>,
5960×
) -> Result<Page<OrgSettingsPage>, Error> {
5970×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
5980×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
5990×
    csrf(&viewer, &f.csrf_token, &shell)?;
6000×
    let reach = super::runner_updates::Reach::Org(org.name.clone());
6010×
    let outcome = super::runner_updates::apply_save_group(&app, &me, &reach, id, &f).await.map_err(|e| Error::from_db(shell.clone(), e))?;
6020×
    org_page_after(&app, shell, org, outcome).await
6030×
}
604
605
/// `POST /orgs/{name}/settings/runners/updates/groups/{id}/delete`.
6061×
pub async fn runner_updates_group_delete(
6071×
    State(app): State<Shared>,
6081×
    viewer: Viewer,
6091×
    Path((name, id)): Path<(String, i64)>,
6101×
    Form(f): Form<super::runner_updates::CsrfOnly>,
6111×
) -> Result<Page<OrgSettingsPage>, Error> {
6121×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
6131×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
6141×
    csrf(&viewer, &f.csrf_token, &shell)?;
6151×
    let reach = super::runner_updates::Reach::Org(org.name.clone());
6161×
    let outcome = super::runner_updates::apply_delete_group(&app, &me, &reach, id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
6171×
    org_page_after(&app, shell, org, outcome).await
6181×
}
619
620
/// The settings page saying what a change did.
6218×
async fn org_page_after(
6228×
    app: &Shared,
6238×
    shell: Shell,
6248×
    org: accounts::Organisation,
6258×
    outcome: super::runner_updates::Outcome,
6268×
) -> Result<Page<OrgSettingsPage>, Error> {
6278×
    match outcome {
6284×
        Ok(n) => org_page(app, shell, org, Some(n), None).await,
6294×
        Err(why) => org_page(app, shell, org, None, Some(why)).await,
630
    }
6318×
}