OXYGENHUB

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

279 of 509 lines run, 36 of 202 functions · run #500 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
}
84
8531×
async fn org_page(
8631×
    app: &Shared,
8731×
    shell: Shell,
8831×
    org: accounts::Organisation,
8931×
    notice: Option<String>,
9031×
    error: Option<String>,
9131×
) -> Result<Page<OrgSettingsPage>, Error> {
9231×
    let members = accounts::org_members(&app.db, org.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
9331×
    let mut teams = Vec::new();
9431×
    for t in accounts::teams(&app.db, org.id).await.map_err(|e| Error::from_db(shell.clone(), e))? {
950×
        let members = accounts::team_members(&app.db, t.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
960×
        teams.push((t, members));
97
    }
9831×
    let hooks = crate::db::hooks::hooks_for_org(&app.db, org.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
9931×
    let hooks = super::webhooks::rows(app, hooks).await.map_err(|e| Error::from_db(shell.clone(), e))?;
10031×
    let updates = super::runner_updates::views(app, &super::runner_updates::Reach::Org(org.name.clone()))
10131×
        .await
10231×
        .map_err(|e| Error::from_db(shell.clone(), e))?;
10331×
    let mut runners = Vec::new();
10433×
    for r in crate::db::runners::serving_owner(&app.db, &org.name).await.map_err(|e| Error::from_db(shell.clone(), e))? {
10533×
        let own = r.scope_owner == org.name;
10633×
        let serves = match r.scope_repo_id {
1070×
            Some(id) => crate::db::repos::get_by_id(&app.db, id).await.ok().flatten().map(|p| p.slug()).unwrap_or_default(),
10820×
            None if own => "the organisation's repositories".into(),
10913×
            None => "the whole site".into(),
110
        };
11133×
        runners.push((r, serves, own));
112
    }
11331×
    let assistants = super::assistants::panel(app, &org_assistants(&org)).await.map_err(|e| Error::from_db(shell.clone(), e))?;
11431×
    let variables = super::variables::panel(app, &org_assistants(&org)).await.map_err(|e| Error::from_db(shell.clone(), e))?;
11531×
    let secrets = super::secrets::panel(app, &org_assistants(&org)).await.map_err(|e| Error::from_db(shell.clone(), e))?;
11631×
    let policy = crate::storage::policy(&app.db, org.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
11731×
    Ok(Page(OrgSettingsPage {
11831×
        policy,
11931×
        shell,
12031×
        org,
12131×
        members,
12231×
        teams,
12331×
        hooks,
12431×
        notice,
12531×
        error,
12631×
        runners,
12731×
        updates,
12831×
        runner_token: None,
12931×
        assistants,
13031×
        variables,
13131×
        secrets,
13231×
    }))
13331×
}
134
13538×
pub(crate) async fn owned_org(
13638×
    app: &Shared,
13738×
    shell: &Shell,
13838×
    viewer: &Viewer,
13938×
    name: &str,
14038×
) -> Result<(accounts::Account, accounts::Organisation), Error> {
14138×
    let me = require(viewer, shell)?;
14238×
    let org = accounts::org_by_name(&app.db, name)
14338×
        .await
14438×
        .map_err(|e| Error::from_db(shell.clone(), e))?
14538×
        .ok_or_else(|| Error::not_found(shell.clone()))?;
14638×
    if !roles::is_org_owner(&app.db, &me.account, org.id).await.map_err(|e| Error::from_db(shell.clone(), e))? {
1474×
        return Err(Error::not_found(shell.clone()));
14834×
    }
14934×
    Ok((me.account, org))
15038×
}
151
15210×
pub async fn settings(State(app): State<Shared>, viewer: Viewer, Path(name): Path<String>) -> Result<Page<OrgSettingsPage>, Error> {
15310×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
15410×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
1559×
    org_page(&app, shell, org, None, None).await
15610×
}
157
158
#[derive(Deserialize)]
159
pub struct OrgForm {
160
    #[serde(rename = "_csrf")]
161
    csrf_token: String,
162
    display_name: String,
163
    description: String,
164
    default_role: String,
165
}
166
1670×
pub async fn update(
1680×
    State(app): State<Shared>,
1690×
    viewer: Viewer,
1700×
    Path(name): Path<String>,
1710×
    Form(f): Form<OrgForm>,
1720×
) -> Result<Page<OrgSettingsPage>, Error> {
1730×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
1740×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
1750×
    csrf(&viewer, &f.csrf_token, &shell)?;
1760×
    let role = if f.default_role == "none" || roles::Role::parse(&f.default_role).is_some() { f.default_role.as_str() } else { "read" };
1770×
    accounts::set_org(&app.db, org.id, f.display_name.trim(), f.description.trim(), role)
1780×
        .await
1790×
        .map_err(|e| Error::from_db(shell.clone(), e))?;
1800×
    accounts::audit(&app.db, Some(&me), "org.updated", &org.name, "").await.ok();
1810×
    let org = accounts::org_by_name(&app.db, &name).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(org);
1820×
    org_page(&app, shell, org, Some("Saved.".into()), None).await
1830×
}
184
185
#[derive(Deserialize)]
186
pub struct PriorityForm {
187
    #[serde(rename = "_csrf")]
188
    csrf_token: String,
189
    priority: String,
190
}
191
192
/// `POST /orgs/{name}/settings/flow-priority` (oxygenhub#244): its
193
/// repositories' Flow level unless one sets its own. Owners choose low,
194
/// normal or the site's; only site administrators raise one to high.
1950×
pub async fn flow_priority(
1960×
    State(app): State<Shared>,
1970×
    viewer: Viewer,
1980×
    Path(name): Path<String>,
1990×
    Form(f): Form<PriorityForm>,
2000×
) -> Result<Page<OrgSettingsPage>, Error> {
2010×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
2020×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
2030×
    csrf(&viewer, &f.csrf_token, &shell)?;
2040×
    let level = match f.priority.as_str() {
2050×
        "low" | "normal" | "high" => f.priority.as_str(),
2060×
        "default" => "",
2070×
        _ => return org_page(&app, shell, org, None, Some("Pick low, normal, high or the site's.".into())).await,
208
    };
2090×
    if level == "high" && !viewer.is_admin() {
2100×
        return org_page(&app, shell, org, None, Some("Only site administrators raise an organisation to high.".into())).await;
2110×
    }
2120×
    accounts::set_org_flow_priority(&app.db, org.id, level).await.map_err(|e| Error::from_db(shell.clone(), e))?;
2130×
    accounts::audit(&app.db, Some(&me), "org.flow_priority", &org.name, if level.is_empty() { "default" } else { level }).await.ok();
2140×
    let org = accounts::org_by_name(&app.db, &name).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(org);
2150×
    org_page(&app, shell, org, Some("Saved.".into()), None).await
2160×
}
217
218
#[derive(Deserialize)]
219
pub struct MemberForm {
220
    #[serde(rename = "_csrf")]
221
    csrf_token: String,
222
    username: String,
223
    #[serde(default)]
224
    role: String,
225
    #[serde(default)]
226
    remove: Option<String>,
227
}
228
2291×
pub async fn member(
2301×
    State(app): State<Shared>,
2311×
    viewer: Viewer,
2321×
    Path(name): Path<String>,
2331×
    Form(f): Form<MemberForm>,
2341×
) -> Result<Page<OrgSettingsPage>, Error> {
2351×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
2361×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
2371×
    csrf(&viewer, &f.csrf_token, &shell)?;
2381×
    let Some(target) = accounts::account_by_name(&app.db, f.username.trim()).await.map_err(|e| Error::from_db(shell.clone(), e))? else {
2390×
        return org_page(&app, shell, org, None, Some("No such account.".into())).await;
240
    };
2411×
    if f.remove.is_some() {
2420×
        let owners = accounts::org_members(&app.db, org.id)
2430×
            .await
2440×
            .map_err(|e| Error::from_db(shell.clone(), e))?
2450×
            .iter()
2460×
            .filter(|(_, r)| r == "owner")
2470×
            .count();
2480×
        let is_owner =
2490×
            accounts::org_role(&app.db, org.id, target.id).await.map_err(|e| Error::from_db(shell.clone(), e))?.as_deref() == Some("owner");
2500×
        if is_owner && owners <= 1 {
2510×
            return org_page(&app, shell, org, None, Some("An organisation keeps at least one owner.".into())).await;
2520×
        }
2530×
        accounts::remove_org_member(&app.db, org.id, target.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
2540×
        accounts::audit(&app.db, Some(&me), "org.member.removed", &org.name, &target.username).await.ok();
2550×
        return org_page(&app, shell, org, Some(format!("Removed {}.", target.username)), None).await;
2561×
    }
2571×
    let role = if f.role == "owner" { "owner" } else { "member" };
2581×
    accounts::set_org_member(&app.db, org.id, target.id, role).await.map_err(|e| Error::from_db(shell.clone(), e))?;
2591×
    accounts::audit(&app.db, Some(&me), "org.member.set", &org.name, &format!("{} {role}", target.username)).await.ok();
2601×
    org_page(&app, shell, org, Some(format!("{} is now {role}.", target.username)), None).await
2611×
}
262
263
#[derive(Deserialize)]
264
pub struct TeamForm {
265
    #[serde(rename = "_csrf")]
266
    csrf_token: String,
267
    team: String,
268
    #[serde(default)]
269
    username: String,
270
    #[serde(default)]
271
    action: String,
272
}
273
2740×
pub async fn team(
2750×
    State(app): State<Shared>,
2760×
    viewer: Viewer,
2770×
    Path(name): Path<String>,
2780×
    Form(f): Form<TeamForm>,
2790×
) -> Result<Page<OrgSettingsPage>, Error> {
2800×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
2810×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
2820×
    csrf(&viewer, &f.csrf_token, &shell)?;
2830×
    let team_name = f.team.trim().to_string();
2840×
    if !crate::repos::names::valid_segment(&team_name) {
2850×
        return org_page(&app, shell, org, None, Some("A team name is letters, digits, dots, dashes and underscores.".into())).await;
2860×
    }
2870×
    let existing = accounts::team_by_name(&app.db, org.id, &team_name).await.map_err(|e| Error::from_db(shell.clone(), e))?;
2880×
    let notice = match f.action.as_str() {
2890×
        "create" => {
2900×
            if existing.is_some() {
2910×
                return org_page(&app, shell, org, None, Some("That team exists.".into())).await;
2920×
            }
2930×
            accounts::create_team(&app.db, org.id, &team_name).await.map_err(|e| Error::from_db(shell.clone(), e))?;
2940×
            format!("Team {team_name} created.")
295
        }
2960×
        "delete" => {
2970×
            if let Some(t) = existing {
2980×
                accounts::delete_team(&app.db, t.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
2990×
            }
3000×
            format!("Team {team_name} deleted.")
301
        }
3020×
        "add" | "remove" => {
3030×
            let Some(t) = existing else { return org_page(&app, shell, org, None, Some("No such team.".into())).await };
3040×
            let Some(target) = accounts::account_by_name(&app.db, f.username.trim()).await.map_err(|e| Error::from_db(shell.clone(), e))?
305
            else {
3060×
                return org_page(&app, shell, org, None, Some("No such account.".into())).await;
307
            };
3080×
            if f.action == "add" {
3090×
                accounts::set_org_member(&app.db, org.id, target.id, "member").await.ok();
3100×
                accounts::add_team_member(&app.db, t.id, target.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
3110×
                format!("{} added to {team_name}.", target.username)
312
            } else {
3130×
                accounts::remove_team_member(&app.db, t.id, target.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
3140×
                format!("{} removed from {team_name}.", target.username)
315
            }
316
        }
3170×
        _ => return Err(Error::bad(shell, "unknown team action")),
318
    };
3190×
    accounts::audit(&app.db, Some(&me), "org.team", &org.name, &format!("{} {team_name} {}", f.action, f.username.trim())).await.ok();
3200×
    org_page(&app, shell, org, Some(notice), None).await
3210×
}
322
323
/// `POST /orgs/{name}/settings/avatar`: upload or remove the organisation's logo.
3242×
pub async fn avatar(
3252×
    State(app): State<Shared>,
3262×
    viewer: Viewer,
3272×
    Path(name): Path<String>,
3282×
    multipart: axum::extract::Multipart,
3292×
) -> Result<Page<OrgSettingsPage>, Error> {
3302×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
3312×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
3321×
    let upload = super::avatar::read_upload(multipart).await;
3331×
    csrf(&viewer, &upload.csrf, &shell)?;
3341×
    let result = super::avatar::apply(&app, "org", org.id, upload).await;
3351×
    if result.is_ok() {
3361×
        accounts::audit(&app.db, Some(&me), "org.picture", &org.name, "").await.ok();
3370×
    }
3381×
    let org = accounts::org_by_name(&app.db, &name).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(org);
3391×
    match result {
3401×
        Ok(m) => org_page(&app, shell, org, Some(m), None).await,
3410×
        Err(e) => org_page(&app, shell, org, None, Some(e)).await,
342
    }
3432×
}
344
345
/// `POST /orgs/{name}/settings/hooks`: webhooks that hear every repository of the organisation.
3464×
pub async fn hooks(
3474×
    State(app): State<Shared>,
3484×
    viewer: Viewer,
3494×
    Path(name): Path<String>,
3504×
    Form(f): Form<super::webhooks::HookForm>,
3514×
) -> Result<Page<OrgSettingsPage>, Error> {
3524×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
3534×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
3544×
    csrf(&viewer, &f.csrf_token, &shell)?;
3554×
    let scope = super::webhooks::Scope::Org { id: org.id, name: org.name.clone() };
3564×
    match super::webhooks::apply(&app, &viewer, &scope, f).await.map_err(|e| Error::from_db(shell.clone(), e))? {
3573×
        Ok(notice) => org_page(&app, shell, org, Some(notice), None).await,
3581×
        Err(error) => org_page(&app, shell, org, None, Some(error)).await,
359
    }
3604×
}
361
3622×
pub async fn deliveries(
3632×
    State(app): State<Shared>,
3642×
    viewer: Viewer,
3652×
    Path((name, id)): Path<(String, i64)>,
3662×
) -> Result<Page<super::webhooks::DeliveriesPage>, Error> {
3672×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings/hooks/{id}/deliveries"), &viewer);
3682×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
3692×
    let scope = super::webhooks::Scope::Org { id: org.id, name: org.name };
3702×
    super::webhooks::deliveries_page(&app, shell, &scope, None, id).await
3712×
}
372
3730×
pub async fn redeliver(
3740×
    State(app): State<Shared>,
3750×
    viewer: Viewer,
3760×
    Path((name, id, delivery)): Path<(String, i64, i64)>,
3770×
    Form(f): Form<super::session::CsrfForm>,
3780×
) -> Result<Page<super::webhooks::DeliveriesPage>, Error> {
3790×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings/hooks/{id}/deliveries"), &viewer);
3800×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
3810×
    csrf(&viewer, &f.csrf, &shell)?;
3820×
    let scope = super::webhooks::Scope::Org { id: org.id, name: org.name };
3830×
    super::webhooks::redeliver(&app, &scope, id, delivery).await.map_err(|e| Error::from_db(shell.clone(), e))?;
3840×
    super::webhooks::deliveries_page(&app, shell, &scope, None, id).await
3850×
}
386
387
/// `POST /orgs/{name}/settings/runners/token`: a one-time registration
388
/// token for a runner that serves the organisation's repositories
389
/// (oxygenhub#41).
3903×
pub async fn runner_token(
3913×
    State(app): State<Shared>,
3923×
    viewer: Viewer,
3933×
    Path(name): Path<String>,
3943×
    Form(f): Form<super::session::CsrfForm>,
3953×
) -> Result<Page<OrgSettingsPage>, Error> {
3963×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
3973×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
3983×
    csrf(&viewer, &f.csrf, &shell)?;
3993×
    let token = format!("flowreg_{}", crate::auth::random_hex(24));
4003×
    let scope = crate::db::runners::Scope { owner: org.name.clone(), repo_id: None };
4013×
    crate::db::runners::add_registration(&app.db, &blake3::hash(token.as_bytes()).to_hex(), &me.username, &scope)
4023×
        .await
4033×
        .map_err(|e| Error::from_db(shell.clone(), e))?;
4043×
    accounts::audit(&app.db, Some(&me), "flow.runner.token", &org.name, "registration token for the organisation").await.ok();
4053×
    let mut page = org_page(&app, shell, org, Some("Copy the token now; it is not shown again.".into()), None).await?;
4063×
    page.0.runner_token = Some(token);
4073×
    Ok(page)
4083×
}
409
410
/// `POST /orgs/{name}/settings/runners/{id}/remove`: remove a runner scoped
411
/// to the organisation or one of its repositories, when it runs nothing.
4121×
pub async fn runner_remove(
4131×
    State(app): State<Shared>,
4141×
    viewer: Viewer,
4151×
    Path((name, id)): Path<(String, i64)>,
4161×
    Form(f): Form<super::session::CsrfForm>,
4171×
) -> Result<Page<OrgSettingsPage>, Error> {
4181×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
4191×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
4201×
    csrf(&viewer, &f.csrf, &shell)?;
4211×
    let e = |e| Error::from_db(shell.clone(), e);
4221×
    let Some(r) = crate::db::runners::get(&app.db, id).await.map_err(e)?.filter(|r| r.scope_owner == org.name) else {
4230×
        return Err(Error::not_found(shell));
424
    };
4251×
    if crate::db::runners::running(&app.db).await.map_err(e)?.iter().any(|(rid, n)| *rid == id && *n > 0) {
4260×
        return org_page(&app, shell, org, None, Some(format!("{} is running jobs: wait for them to finish.", r.name))).await;
4271×
    }
4281×
    crate::db::runners::remove(&app.db, id).await.map_err(e)?;
4291×
    accounts::audit(&app.db, Some(&me), "flow.runner.removed", &r.name, &org.name).await.ok();
4301×
    org_page(&app, shell, org, Some(format!("{} removed: its credential no longer works.", r.name)), None).await
4311×
}
432
43395×
fn org_assistants(org: &accounts::Organisation) -> crate::levels::At {
43495×
    crate::levels::At::org(org)
43595×
}
436
437
/// `POST /orgs/{name}/settings/assistants`: the organisation's assistants
438
/// and prompt (#97).
4393×
pub async fn assistants(
4403×
    State(app): State<Shared>,
4413×
    viewer: Viewer,
4423×
    Path(name): Path<String>,
4433×
    Form(f): Form<super::assistants::AssistantForm>,
4443×
) -> Result<Page<OrgSettingsPage>, Error> {
4453×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
4463×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
4472×
    csrf(&viewer, &f.csrf_token, &shell)?;
4482×
    match super::assistants::apply(&app, &viewer, &org_assistants(&org), f).await.map_err(|e| Error::from_db(shell.clone(), e))? {
4492×
        Ok(notice) => org_page(&app, shell, org, Some(notice), None).await,
4500×
        Err(error) => org_page(&app, shell, org, None, Some(error)).await,
451
    }
4523×
}
453
454
#[derive(Deserialize)]
455
pub struct PolicyForm {
456
    #[serde(rename = "_csrf")]
457
    csrf_token: String,
458
    #[serde(default)]
459
    require_bucket: Option<String>,
460
    #[serde(default)]
461
    allowed: String,
462
}
463
464
/// `POST /orgs/{name}/settings/storage`: where the organisation's new
465
/// repositories may live (#96).
4662×
pub async fn storage(
4672×
    State(app): State<Shared>,
4682×
    viewer: Viewer,
4692×
    Path(name): Path<String>,
4702×
    Form(f): Form<PolicyForm>,
4712×
) -> Result<Page<OrgSettingsPage>, Error> {
4722×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
4732×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
4742×
    csrf(&viewer, &f.csrf_token, &shell)?;
4752×
    match crate::storage::set_policy(&app.db, org.id, f.require_bucket.is_some(), &f.allowed).await {
4761×
        Ok(p) => {
4771×
            let what = match (p.require_bucket, p.allowed.is_empty()) {
4780×
                (true, true) => "every new repository in a bucket".to_string(),
4791×
                (true, false) => format!("every new repository in {}", p.allowed.join(", ")),
4800×
                (false, true) => "any storage".to_string(),
4810×
                (false, false) => format!("buckets only in {}", p.allowed.join(", ")),
482
            };
4831×
            accounts::audit(&app.db, Some(&me), "org.storage_policy", &org.name, &what).await.ok();
4841×
            org_page(&app, shell, org, Some(format!("Storage policy saved: {what}.")), None).await
485
        }
4861×
        Err(e) => org_page(&app, shell, org, None, Some(format!("Storage policy: {e}."))).await,
487
    }
4882×
}
489
490
/// `POST /orgs/{name}/settings/variables`: the organisation's Flow
491
/// variables (#102).
4920×
pub async fn variables(
4930×
    State(app): State<Shared>,
4940×
    viewer: Viewer,
4950×
    Path(name): Path<String>,
4960×
    Form(f): Form<super::variables::VariableForm>,
4970×
) -> Result<Page<OrgSettingsPage>, Error> {
4980×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
4990×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
5000×
    csrf(&viewer, &f.csrf_token, &shell)?;
5010×
    match super::variables::apply(&app, &viewer, &org_assistants(&org), f).await.map_err(|e| Error::from_db(shell.clone(), e))? {
5020×
        Ok(notice) => org_page(&app, shell, org, Some(notice), None).await,
5030×
        Err(error) => org_page(&app, shell, org, None, Some(error)).await,
504
    }
5050×
}
506
507
/// `POST /orgs/{name}/settings/secrets`: the organisation's Flow secrets (#107).
5080×
pub async fn secrets(
5090×
    State(app): State<Shared>,
5100×
    viewer: Viewer,
5110×
    Path(name): Path<String>,
5120×
    Form(f): Form<super::secrets::SecretForm>,
5130×
) -> Result<Page<OrgSettingsPage>, Error> {
5140×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
5150×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
5160×
    csrf(&viewer, &f.csrf_token, &shell)?;
5170×
    match super::secrets::apply(&app, &viewer, &org_assistants(&org), f).await.map_err(|e| Error::from_db(shell.clone(), e))? {
5180×
        Ok(notice) => org_page(&app, shell, org, Some(notice), None).await,
5190×
        Err(error) => org_page(&app, shell, org, None, Some(error)).await,
520
    }
5210×
}
522
523
/// `POST /orgs/{name}/settings/assistants/models`: what a provider offers (#109).
5240×
pub async fn assistant_models(
5250×
    State(app): State<Shared>,
5260×
    viewer: Viewer,
5270×
    Path(name): Path<String>,
5280×
    Form(f): Form<super::assistants::ModelsForm>,
5290×
) -> Result<axum::Json<serde_json::Value>, Error> {
5300×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
5310×
    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;
5320×
    csrf(&viewer, &f.csrf_token, &shell)?;
5330×
    Ok(axum::Json(super::assistants::models(&app, &org_assistants(&org), f).await.map_err(|e| Error::from_db(shell.clone(), e))?))
5340×
}
535
536
/// `POST /orgs/{name}/settings/runners/updates/policy`: the organisation's,
537
/// one of its test groups' or one of its runners' update settings.
5386×
pub async fn runner_updates_policy(
5396×
    State(app): State<Shared>,
5406×
    viewer: Viewer,
5416×
    Path(name): Path<String>,
5426×
    Form(f): Form<super::runner_updates::PolicyForm>,
5436×
) -> Result<Page<OrgSettingsPage>, Error> {
5446×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
5456×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
5466×
    csrf(&viewer, &f.csrf_token, &shell)?;
5476×
    let reach = super::runner_updates::Reach::Org(org.name.clone());
5486×
    let outcome = super::runner_updates::apply_policy(&app, &me, &reach, &f).await.map_err(|e| Error::from_db(shell.clone(), e))?;
5496×
    org_page_after(&app, shell, org, outcome).await
5506×
}
551
552
/// `POST /orgs/{name}/settings/runners/updates/groups`: a test group of the organisation's runners.
5531×
pub async fn runner_updates_group_new(
5541×
    State(app): State<Shared>,
5551×
    viewer: Viewer,
5561×
    Path(name): Path<String>,
5571×
    axum_extra::extract::Form(f): axum_extra::extract::Form<super::runner_updates::GroupForm>,
5581×
) -> Result<Page<OrgSettingsPage>, Error> {
5591×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
5601×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
5611×
    csrf(&viewer, &f.csrf_token, &shell)?;
5621×
    let reach = super::runner_updates::Reach::Org(org.name.clone());
5631×
    let outcome = super::runner_updates::apply_create_group(&app, &me, &reach, &f).await.map_err(|e| Error::from_db(shell.clone(), e))?;
5641×
    org_page_after(&app, shell, org, outcome).await
5651×
}
566
567
/// `POST /orgs/{name}/settings/runners/updates/groups/{id}`: who is in one of its test groups.
5680×
pub async fn runner_updates_group(
5690×
    State(app): State<Shared>,
5700×
    viewer: Viewer,
5710×
    Path((name, id)): Path<(String, i64)>,
5720×
    axum_extra::extract::Form(f): axum_extra::extract::Form<super::runner_updates::GroupForm>,
5730×
) -> Result<Page<OrgSettingsPage>, Error> {
5740×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
5750×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
5760×
    csrf(&viewer, &f.csrf_token, &shell)?;
5770×
    let reach = super::runner_updates::Reach::Org(org.name.clone());
5780×
    let outcome = super::runner_updates::apply_save_group(&app, &me, &reach, id, &f).await.map_err(|e| Error::from_db(shell.clone(), e))?;
5790×
    org_page_after(&app, shell, org, outcome).await
5800×
}
581
582
/// `POST /orgs/{name}/settings/runners/updates/groups/{id}/delete`.
5831×
pub async fn runner_updates_group_delete(
5841×
    State(app): State<Shared>,
5851×
    viewer: Viewer,
5861×
    Path((name, id)): Path<(String, i64)>,
5871×
    Form(f): Form<super::runner_updates::CsrfOnly>,
5881×
) -> Result<Page<OrgSettingsPage>, Error> {
5891×
    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);
5901×
    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;
5911×
    csrf(&viewer, &f.csrf_token, &shell)?;
5921×
    let reach = super::runner_updates::Reach::Org(org.name.clone());
5931×
    let outcome = super::runner_updates::apply_delete_group(&app, &me, &reach, id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
5941×
    org_page_after(&app, shell, org, outcome).await
5951×
}
596
597
/// The settings page saying what a change did.
5988×
async fn org_page_after(
5998×
    app: &Shared,
6008×
    shell: Shell,
6018×
    org: accounts::Organisation,
6028×
    outcome: super::runner_updates::Outcome,
6038×
) -> Result<Page<OrgSettingsPage>, Error> {
6048×
    match outcome {
6054×
        Ok(n) => org_page(app, shell, org, Some(n), None).await,
6064×
        Err(why) => org_page(app, shell, org, None, Some(why)).await,
607
    }
6088×
}