crates/hub/src/web/repo_settings.rs at 045f967db8f2 · andymccall/oxygenhub

# 045f967db8f2 oxygenhub / crates / hub / src / web / repo_settings.rs

18.9 KiB · Rust · last changed Stars, topics, and a sortable, filterable Explore 1 month ago source blame history raw

//! Creating repositories and their settings pages (hub spec §6.3).

use super::settings::{csrf, require};
use super::{filters, lookup_role, Error, Page, RepoShell, Shell};
use crate::auth::{roles, Access, Role, Viewer};
use crate::db::{self, accounts};
use crate::repos::RepoName;
use crate::Shared;
use askama::Template;
use axum::extract::{Form, Path, State};
use axum::response::{IntoResponse, Redirect, Response};
use hub_api::Visibility;
use serde::Deserialize;

#[derive(Template)]
#[template(path = "repo_new.html")]
pub struct NewRepoPage {
    shell: Shell,
    owners: Vec<String>,
    error: Option<String>,
}

pub(crate) async fn owners_for(app: &Shared, me: &accounts::Account) -> Vec<String> {
    let mut owners = vec![me.username.clone()];
    if let Ok(orgs) = accounts::orgs_of(&app.db, me.id).await {
        owners.extend(orgs.into_iter().map(|(o, _)| o.name));
    }
    owners
}

pub async fn new_form(State(app): State<Shared>, viewer: Viewer) -> Result<Page<NewRepoPage>, Error> {
    let shell = Shell::new(&app, "/new", &viewer);
    let me = require(&viewer, &shell)?;
    let owners = owners_for(&app, &me.account).await;
    Ok(Page(NewRepoPage { shell, owners, error: None }))
}

#[derive(Deserialize)]
pub struct NewRepoForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    owner: String,
    name: String,
    #[serde(default)]
    description: String,
    #[serde(default = "default_visibility")]
    visibility: String,
}

fn default_visibility() -> String {
    "public".into()
}

pub async fn create(State(app): State<Shared>, viewer: Viewer, Form(f): Form<NewRepoForm>) -> Result<Response, Error> {
    let shell = Shell::new(&app, "/new", &viewer);
    let me = require(&viewer, &shell)?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let owners = owners_for(&app, &me.account).await;
    let fail = |msg: &str| Page(NewRepoPage { shell: shell.clone(), owners: owners.clone(), error: Some(msg.into()) }).into_response();
    let Some(name) = RepoName::new(f.owner.trim(), f.name.trim()) else {
        return Ok(fail("A repository name is letters, digits, dots, dashes and underscores."));
    };
    if !roles::may_create_under(&app.db, &me.account, &name.owner).await.map_err(|e| Error::from_db(shell.clone(), e))? {
        return Ok(fail("You cannot create repositories under that owner."));
    }
    let Some(visibility) = Visibility::parse(&f.visibility) else { return Ok(fail("Visibility is public, internal or private.")) };
    if db::repos::get(&app.db, &name.owner, &name.name).await.map_err(|e| Error::from_db(shell.clone(), e))?.is_some()
        || app.repos.exists(&name)
    {
        return Ok(fail("That repository exists."));
    }
    app.repos.create(&name, None).map_err(|e| Error::from_repo(shell.clone(), e))?;
    db::repos::create(&app.db, &name.owner, &name.name, f.description.trim(), visibility)
        .await
        .map_err(|e| Error::from_db(shell.clone(), e))?;
    accounts::audit(&app.db, Some(&me.account), "repo.created", &name.to_string(), visibility.as_str()).await.ok();
    Ok(Redirect::to(&name.url()).into_response())
}

#[derive(Template)]
#[template(path = "repo_settings.html")]
pub struct RepoSettingsPage {
    shell: Shell,
    repo: RepoShell,
    row: db::repos::RepoRow,
    collaborators: Vec<accounts::Collaborator>,
    teams: Vec<accounts::Team>,
    role: Role,
    requirements: db::proposals::Requirements,
    hooks: Vec<db::hooks::Hook>,
    required_checks: String,
    notice: Option<String>,
    error: Option<String>,
}

async fn settings_page(
    app: &Shared,
    shell: Shell,
    row: db::repos::RepoRow,
    role: Role,
    notice: Option<String>,
    error: Option<String>,
) -> Result<Page<RepoSettingsPage>, Error> {
    let collaborators = accounts::collaborators(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    let teams = match accounts::org_by_name(&app.db, &row.owner).await.map_err(|e| Error::from_db(shell.clone(), e))? {
        Some(org) => accounts::teams(&app.db, org.id).await.map_err(|e| Error::from_db(shell.clone(), e))?,
        None => vec![],
    };
    let repo = RepoShell::new(app, &row, "settings").with_role(role);
    let requirements = db::proposals::requirements(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    let hooks = db::hooks::hooks_for_repo(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    let required_checks = db::hooks::required_checks(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?.join(", ");
    Ok(Page(RepoSettingsPage { shell, repo, row, collaborators, teams, role, requirements, hooks, required_checks, notice, error }))
}

pub async fn settings(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
) -> Result<Page<RepoSettingsPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
    settings_page(&app, shell, row, role, None, None).await
}

#[derive(Deserialize)]
pub struct GeneralForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    description: String,
    default_bookmark: String,
    visibility: String,
    #[serde(default)]
    topics: String,
}

pub async fn update(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<GeneralForm>,
) -> Result<Page<RepoSettingsPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let e = |e| Error::from_db(shell.clone(), e);
    let topics = match db::repos::parse_topics(&f.topics) {
        Ok(t) => t,
        Err(msg) => return settings_page(&app, shell, row, role, None, Some(msg)).await,
    };
    db::repos::set_description(&app.db, row.id, f.description.trim()).await.map_err(e)?;
    db::repos::set_topics(&app.db, row.id, &topics).await.map_err(e)?;
    if crate::repos::names::valid_segment(f.default_bookmark.trim()) {
        db::repos::set_default_bookmark(&app.db, row.id, f.default_bookmark.trim()).await.map_err(e)?;
    }
    if role >= Role::Admin {
        if let Some(v) = Visibility::parse(&f.visibility) {
            db::repos::set_visibility(&app.db, row.id, v).await.map_err(e)?;
        }
    }
    accounts::audit(&app.db, viewer.account(), "repo.updated", &format!("{owner}/{name}"), "").await.ok();
    let row = db::repos::get_by_id(&app.db, row.id).await.map_err(e)?.unwrap_or(row);
    settings_page(&app, shell, row, role, Some("Saved.".into()), None).await
}

#[derive(Deserialize)]
pub struct CollaboratorForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    #[serde(default)]
    username: String,
    #[serde(default)]
    team: String,
    #[serde(default)]
    role: String,
    #[serde(default)]
    remove: Option<String>,
}

pub async fn collaborator(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<CollaboratorForm>,
) -> Result<Page<RepoSettingsPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let e = |e| Error::from_db(shell.clone(), e);
    let (account_id, team_id, label) = if !f.username.trim().is_empty() {
        match accounts::account_by_name(&app.db, f.username.trim()).await.map_err(e)? {
            Some(a) => (Some(a.id), None, a.username),
            None => return settings_page(&app, shell, row, role, None, Some("No such account.".into())).await,
        }
    } else if !f.team.trim().is_empty() {
        let org = accounts::org_by_name(&app.db, &row.owner).await.map_err(e)?;
        let team = match org {
            Some(o) => accounts::team_by_name(&app.db, o.id, f.team.trim()).await.map_err(e)?,
            None => None,
        };
        match team {
            Some(t) => (None, Some(t.id), format!("team {}", t.name)),
            None => return settings_page(&app, shell, row, role, None, Some("No such team in this organisation.".into())).await,
        }
    } else {
        return settings_page(&app, shell, row, role, None, Some("Name an account or a team.".into())).await;
    };
    if f.remove.is_some() {
        accounts::remove_collaborator(&app.db, row.id, account_id, team_id).await.map_err(e)?;
        accounts::audit(&app.db, viewer.account(), "repo.collaborator.removed", &format!("{owner}/{name}"), &label).await.ok();
        return settings_page(&app, shell, row, role, Some(format!("Removed {label}.")), None).await;
    }
    let Some(new_role) = Role::parse(&f.role) else {
        return settings_page(&app, shell, row, role, None, Some("Pick a role.".into())).await;
    };
    accounts::set_collaborator(&app.db, row.id, account_id, team_id, new_role.as_str()).await.map_err(e)?;
    accounts::audit(
        &app.db,
        viewer.account(),
        "repo.collaborator.set",
        &format!("{owner}/{name}"),
        &format!("{label} {}", new_role.as_str()),
    )
    .await
    .ok();
    settings_page(&app, shell, row, role, Some(format!("{label} now has {} access.", new_role.as_str())), None).await
}

#[derive(Deserialize)]
pub struct DeleteForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    confirm: String,
}

pub async fn delete(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<DeleteForm>,
) -> Result<Response, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    if f.confirm.trim() != repo.to_string() {
        return Ok(settings_page(&app, shell, row, role, None, Some("Type the repository's full name to delete it.".into()))
            .await?
            .into_response());
    }
    let _guard = app.repos.write_guard(&repo).await;
    app.repos.trash(&repo).map_err(|e| Error::from_repo(shell.clone(), e))?;
    db::repos::delete(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    accounts::audit(&app.db, viewer.account(), "repo.deleted", &repo.to_string(), "moved to trash").await.ok();
    Ok(Redirect::to(&format!("/{owner}")).into_response())
}

#[derive(Deserialize)]
pub struct RequirementsForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    #[serde(default)]
    required_approvals: i64,
    #[serde(default)]
    require_owners: Option<String>,
    #[serde(default)]
    allow_conflicts: Option<String>,
}

pub async fn requirements(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<RequirementsForm>,
) -> Result<Page<RepoSettingsPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let r = db::proposals::Requirements {
        required_approvals: f.required_approvals.max(0),
        require_owners: f.require_owners.is_some(),
        allow_conflicts: f.allow_conflicts.is_some(),
    };
    db::proposals::set_requirements(&app.db, row.id, r).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    accounts::audit(
        &app.db,
        viewer.account(),
        "repo.requirements",
        &format!("{owner}/{name}"),
        &format!("{} approvals, owners {}, conflicts {}", r.required_approvals, r.require_owners, r.allow_conflicts),
    )
    .await
    .ok();
    settings_page(&app, shell, row, role, Some("Landing requirements saved.".into()), None).await
}

#[derive(Deserialize)]
pub struct HookForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    #[serde(default)]
    url: String,
    #[serde(default)]
    secret: String,
    #[serde(default = "star")]
    events: String,
    #[serde(default)]
    id: Option<i64>,
    #[serde(default)]
    action: String,
}

fn star() -> String {
    "*".into()
}

pub async fn hooks(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<HookForm>,
) -> Result<Page<RepoSettingsPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let e = |e| Error::from_db(shell.clone(), e);
    let notice = match (f.action.as_str(), f.id) {
        ("delete", Some(id)) => {
            if db::hooks::hook(&app.db, id).await.map_err(e)?.is_some_and(|h| h.repo_id == Some(row.id)) {
                db::hooks::delete_hook(&app.db, id).await.map_err(e)?;
            }
            "Webhook deleted.".to_string()
        }
        ("toggle", Some(id)) => {
            if let Some(h) = db::hooks::hook(&app.db, id).await.map_err(e)?.filter(|h| h.repo_id == Some(row.id)) {
                db::hooks::set_hook_active(&app.db, id, !h.active).await.map_err(e)?;
            }
            "Webhook updated.".to_string()
        }
        ("ping", Some(id)) => {
            if let Some(h) = db::hooks::hook(&app.db, id).await.map_err(e)?.filter(|h| h.repo_id == Some(row.id)) {
                let delivery = crate::auth::random_hex(16);
                let env = hub_api::WebhookEnvelope {
                    event: "ping".into(),
                    delivery: delivery.clone(),
                    repository: None,
                    actor: viewer.account().map(|a| a.username.clone()).unwrap_or_default(),
                    at_ms: db::now_ms(),
                    data: serde_json::json!({ "zen": "changes commute" }),
                };
                db::hooks::queue_delivery(&app.db, h.id, &delivery, "ping", &serde_json::to_string(&env).unwrap_or_default())
                    .await
                    .map_err(e)?;
                app.events.notify_deliveries();
            }
            "Ping queued.".to_string()
        }
        _ => {
            if !(f.url.starts_with("http://") || f.url.starts_with("https://")) {
                return settings_page(&app, shell, row, role, None, Some("A webhook URL starts with http:// or https://.".into())).await;
            }
            db::hooks::create_hook(&app.db, Some(row.id), None, f.url.trim(), f.secret.trim(), f.events.trim()).await.map_err(e)?;
            accounts::audit(&app.db, viewer.account(), "hook.created", &format!("{owner}/{name}"), f.url.trim()).await.ok();
            "Webhook added.".to_string()
        }
    };
    settings_page(&app, shell, row, role, Some(notice), None).await
}

#[derive(Template)]
#[template(path = "deliveries.html")]
pub struct DeliveriesPage {
    shell: Shell,
    repo: RepoShell,
    hook: db::hooks::Hook,
    rows: Vec<db::hooks::Delivery>,
}

pub async fn deliveries(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name, id)): Path<(String, String, i64)>,
) -> Result<Page<DeliveriesPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings/hooks/{id}/deliveries"), &viewer);
    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
    let hook = db::hooks::hook(&app.db, id)
        .await
        .map_err(|e| Error::from_db(shell.clone(), e))?
        .filter(|h| h.repo_id == Some(row.id))
        .ok_or_else(|| Error::not_found(shell.clone()))?;
    let rows = db::hooks::deliveries_for_hook(&app.db, id, 100).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    Ok(Page(DeliveriesPage { shell, repo: RepoShell::new(&app, &row, "settings").with_role(role), hook, rows }))
}

pub async fn redeliver(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name, id, delivery)): Path<(String, String, i64, i64)>,
    Form(f): Form<super::session::CsrfForm>,
) -> Result<Page<DeliveriesPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings/hooks/{id}/deliveries"), &viewer);
    let (_, row, _) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
    csrf(&viewer, &f.csrf, &shell)?;
    let mine = db::hooks::hook(&app.db, id).await.ok().flatten().is_some_and(|h| h.repo_id == Some(row.id));
    if mine && db::hooks::delivery(&app.db, delivery).await.map_err(|e| Error::from_db(shell.clone(), e))?.is_some_and(|d| d.hook_id == id)
    {
        db::hooks::redeliver(&app.db, delivery).await.map_err(|e| Error::from_db(shell.clone(), e))?;
        app.events.notify_deliveries();
    }
    deliveries(State(app), viewer, Path((owner, name, id))).await
}

#[derive(Deserialize)]
pub struct ChecksForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    #[serde(default)]
    required_checks: String,
}

pub async fn required_checks(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<ChecksForm>,
) -> Result<Page<RepoSettingsPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let names: Vec<String> = f.required_checks.split(',').map(str::trim).filter(|s| !s.is_empty()).map(String::from).collect();
    db::hooks::set_required_checks(&app.db, row.id, &names).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    settings_page(&app, shell, row, role, Some("Required checks saved.".into()), None).await
}

#[derive(Deserialize)]
pub struct MirrorForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    #[serde(default)]
    enabled: Option<String>,
}

pub async fn mirror(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<MirrorForm>,
) -> Result<Page<RepoSettingsPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    db::repos::set_git_mirror(&app.db, row.id, f.enabled.is_some()).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    let row = db::repos::get_by_id(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(row);
    if row.git_mirror {
        crate::mirror::refresh(&app, &row).await;
    }
    accounts::audit(&app.db, viewer.account(), "repo.mirror", &format!("{owner}/{name}"), if row.git_mirror { "on" } else { "off" })
        .await
        .ok();
    let row = db::repos::get_by_id(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(row);
    let notice = if row.git_mirror { "The Git mirror is on and up to date." } else { "The Git mirror is off." };
    settings_page(&app, shell, row, role, Some(notice.into()), None).await
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1	//! Creating repositories and their settings pages (hub spec §6.3).
2
3	use super::settings::{csrf, require};
4	use super::{filters, lookup_role, Error, Page, RepoShell, Shell};
5	use crate::auth::{roles, Access, Role, Viewer};
6	use crate::db::{self, accounts};
7	use crate::repos::RepoName;
8	use crate::Shared;
9	use askama::Template;
10	use axum::extract::{Form, Path, State};
11	use axum::response::{IntoResponse, Redirect, Response};
12	use hub_api::Visibility;
13	use serde::Deserialize;
14
15	#[derive(Template)]
16	#[template(path = "repo_new.html")]
17	pub struct NewRepoPage {
18	shell: Shell,
19	owners: Vec<String>,
20	error: Option<String>,
21	}
22
23	pub(crate) async fn owners_for(app: &Shared, me: &accounts::Account) -> Vec<String> {
24	let mut owners = vec![me.username.clone()];
25	if let Ok(orgs) = accounts::orgs_of(&app.db, me.id).await {
26	owners.extend(orgs.into_iter().map(\|(o, _)\| o.name));
27	}
28	owners
29	}
30
31	pub async fn new_form(State(app): State<Shared>, viewer: Viewer) -> Result<Page<NewRepoPage>, Error> {
32	let shell = Shell::new(&app, "/new", &viewer);
33	let me = require(&viewer, &shell)?;
34	let owners = owners_for(&app, &me.account).await;
35	Ok(Page(NewRepoPage { shell, owners, error: None }))
36	}
37
38	#[derive(Deserialize)]
39	pub struct NewRepoForm {
40	#[serde(rename = "_csrf")]
41	csrf_token: String,
42	owner: String,
43	name: String,
44	#[serde(default)]
45	description: String,
46	#[serde(default = "default_visibility")]
47	visibility: String,
48	}
49
50	fn default_visibility() -> String {
51	"public".into()
52	}
53
54	pub async fn create(State(app): State<Shared>, viewer: Viewer, Form(f): Form<NewRepoForm>) -> Result<Response, Error> {
55	let shell = Shell::new(&app, "/new", &viewer);
56	let me = require(&viewer, &shell)?;
57	csrf(&viewer, &f.csrf_token, &shell)?;
58	let owners = owners_for(&app, &me.account).await;
59	let fail = \|msg: &str\| Page(NewRepoPage { shell: shell.clone(), owners: owners.clone(), error: Some(msg.into()) }).into_response();
60	let Some(name) = RepoName::new(f.owner.trim(), f.name.trim()) else {
61	return Ok(fail("A repository name is letters, digits, dots, dashes and underscores."));
62	};
63	if !roles::may_create_under(&app.db, &me.account, &name.owner).await.map_err(\|e\| Error::from_db(shell.clone(), e))? {
64	return Ok(fail("You cannot create repositories under that owner."));
65	}
66	let Some(visibility) = Visibility::parse(&f.visibility) else { return Ok(fail("Visibility is public, internal or private.")) };
67	if db::repos::get(&app.db, &name.owner, &name.name).await.map_err(\|e\| Error::from_db(shell.clone(), e))?.is_some()
68	\|\| app.repos.exists(&name)
69	{
70	return Ok(fail("That repository exists."));
71	}
72	app.repos.create(&name, None).map_err(\|e\| Error::from_repo(shell.clone(), e))?;
73	db::repos::create(&app.db, &name.owner, &name.name, f.description.trim(), visibility)
74	.await
75	.map_err(\|e\| Error::from_db(shell.clone(), e))?;
76	accounts::audit(&app.db, Some(&me.account), "repo.created", &name.to_string(), visibility.as_str()).await.ok();
77	Ok(Redirect::to(&name.url()).into_response())
78	}
79
80	#[derive(Template)]
81	#[template(path = "repo_settings.html")]
82	pub struct RepoSettingsPage {
83	shell: Shell,
84	repo: RepoShell,
85	row: db::repos::RepoRow,
86	collaborators: Vec<accounts::Collaborator>,
87	teams: Vec<accounts::Team>,
88	role: Role,
89	requirements: db::proposals::Requirements,
90	hooks: Vec<db::hooks::Hook>,
91	required_checks: String,
92	notice: Option<String>,
93	error: Option<String>,
94	}
95
96	async fn settings_page(
97	app: &Shared,
98	shell: Shell,
99	row: db::repos::RepoRow,
100	role: Role,
101	notice: Option<String>,
102	error: Option<String>,
103	) -> Result<Page<RepoSettingsPage>, Error> {
104	let collaborators = accounts::collaborators(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
105	let teams = match accounts::org_by_name(&app.db, &row.owner).await.map_err(\|e\| Error::from_db(shell.clone(), e))? {
106	Some(org) => accounts::teams(&app.db, org.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?,
107	None => vec![],
108	};
109	let repo = RepoShell::new(app, &row, "settings").with_role(role);
110	let requirements = db::proposals::requirements(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
111	let hooks = db::hooks::hooks_for_repo(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
112	let required_checks = db::hooks::required_checks(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?.join(", ");
113	Ok(Page(RepoSettingsPage { shell, repo, row, collaborators, teams, role, requirements, hooks, required_checks, notice, error }))
114	}
115
116	pub async fn settings(
117	State(app): State<Shared>,
118	viewer: Viewer,
119	Path((owner, name)): Path<(String, String)>,
120	) -> Result<Page<RepoSettingsPage>, Error> {
121	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
122	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
123	settings_page(&app, shell, row, role, None, None).await
124	}
125
126	#[derive(Deserialize)]
127	pub struct GeneralForm {
128	#[serde(rename = "_csrf")]
129	csrf_token: String,
130	description: String,
131	default_bookmark: String,
132	visibility: String,
133	#[serde(default)]
134	topics: String,
135	}
136
137	pub async fn update(
138	State(app): State<Shared>,
139	viewer: Viewer,
140	Path((owner, name)): Path<(String, String)>,
141	Form(f): Form<GeneralForm>,
142	) -> Result<Page<RepoSettingsPage>, Error> {
143	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
144	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
145	csrf(&viewer, &f.csrf_token, &shell)?;
146	let e = \|e\| Error::from_db(shell.clone(), e);
147	let topics = match db::repos::parse_topics(&f.topics) {
148	Ok(t) => t,
149	Err(msg) => return settings_page(&app, shell, row, role, None, Some(msg)).await,
150	};
151	db::repos::set_description(&app.db, row.id, f.description.trim()).await.map_err(e)?;
152	db::repos::set_topics(&app.db, row.id, &topics).await.map_err(e)?;
153	if crate::repos::names::valid_segment(f.default_bookmark.trim()) {
154	db::repos::set_default_bookmark(&app.db, row.id, f.default_bookmark.trim()).await.map_err(e)?;
155	}
156	if role >= Role::Admin {
157	if let Some(v) = Visibility::parse(&f.visibility) {
158	db::repos::set_visibility(&app.db, row.id, v).await.map_err(e)?;
159	}
160	}
161	accounts::audit(&app.db, viewer.account(), "repo.updated", &format!("{owner}/{name}"), "").await.ok();
162	let row = db::repos::get_by_id(&app.db, row.id).await.map_err(e)?.unwrap_or(row);
163	settings_page(&app, shell, row, role, Some("Saved.".into()), None).await
164	}
165
166	#[derive(Deserialize)]
167	pub struct CollaboratorForm {
168	#[serde(rename = "_csrf")]
169	csrf_token: String,
170	#[serde(default)]
171	username: String,
172	#[serde(default)]
173	team: String,
174	#[serde(default)]
175	role: String,
176	#[serde(default)]
177	remove: Option<String>,
178	}
179
180	pub async fn collaborator(
181	State(app): State<Shared>,
182	viewer: Viewer,
183	Path((owner, name)): Path<(String, String)>,
184	Form(f): Form<CollaboratorForm>,
185	) -> Result<Page<RepoSettingsPage>, Error> {
186	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
187	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
188	csrf(&viewer, &f.csrf_token, &shell)?;
189	let e = \|e\| Error::from_db(shell.clone(), e);
190	let (account_id, team_id, label) = if !f.username.trim().is_empty() {
191	match accounts::account_by_name(&app.db, f.username.trim()).await.map_err(e)? {
192	Some(a) => (Some(a.id), None, a.username),
193	None => return settings_page(&app, shell, row, role, None, Some("No such account.".into())).await,
194	}
195	} else if !f.team.trim().is_empty() {
196	let org = accounts::org_by_name(&app.db, &row.owner).await.map_err(e)?;
197	let team = match org {
198	Some(o) => accounts::team_by_name(&app.db, o.id, f.team.trim()).await.map_err(e)?,
199	None => None,
200	};
201	match team {
202	Some(t) => (None, Some(t.id), format!("team {}", t.name)),
203	None => return settings_page(&app, shell, row, role, None, Some("No such team in this organisation.".into())).await,
204	}
205	} else {
206	return settings_page(&app, shell, row, role, None, Some("Name an account or a team.".into())).await;
207	};
208	if f.remove.is_some() {
209	accounts::remove_collaborator(&app.db, row.id, account_id, team_id).await.map_err(e)?;
210	accounts::audit(&app.db, viewer.account(), "repo.collaborator.removed", &format!("{owner}/{name}"), &label).await.ok();
211	return settings_page(&app, shell, row, role, Some(format!("Removed {label}.")), None).await;
212	}
213	let Some(new_role) = Role::parse(&f.role) else {
214	return settings_page(&app, shell, row, role, None, Some("Pick a role.".into())).await;
215	};
216	accounts::set_collaborator(&app.db, row.id, account_id, team_id, new_role.as_str()).await.map_err(e)?;
217	accounts::audit(
218	&app.db,
219	viewer.account(),
220	"repo.collaborator.set",
221	&format!("{owner}/{name}"),
222	&format!("{label} {}", new_role.as_str()),
223	)
224	.await
225	.ok();
226	settings_page(&app, shell, row, role, Some(format!("{label} now has {} access.", new_role.as_str())), None).await
227	}
228
229	#[derive(Deserialize)]
230	pub struct DeleteForm {
231	#[serde(rename = "_csrf")]
232	csrf_token: String,
233	confirm: String,
234	}
235
236	pub async fn delete(
237	State(app): State<Shared>,
238	viewer: Viewer,
239	Path((owner, name)): Path<(String, String)>,
240	Form(f): Form<DeleteForm>,
241	) -> Result<Response, Error> {
242	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
243	let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
244	csrf(&viewer, &f.csrf_token, &shell)?;
245	if f.confirm.trim() != repo.to_string() {
246	return Ok(settings_page(&app, shell, row, role, None, Some("Type the repository's full name to delete it.".into()))
247	.await?
248	.into_response());
249	}
250	let _guard = app.repos.write_guard(&repo).await;
251	app.repos.trash(&repo).map_err(\|e\| Error::from_repo(shell.clone(), e))?;
252	db::repos::delete(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
253	accounts::audit(&app.db, viewer.account(), "repo.deleted", &repo.to_string(), "moved to trash").await.ok();
254	Ok(Redirect::to(&format!("/{owner}")).into_response())
255	}
256
257	#[derive(Deserialize)]
258	pub struct RequirementsForm {
259	#[serde(rename = "_csrf")]
260	csrf_token: String,
261	#[serde(default)]
262	required_approvals: i64,
263	#[serde(default)]
264	require_owners: Option<String>,
265	#[serde(default)]
266	allow_conflicts: Option<String>,
267	}
268
269	pub async fn requirements(
270	State(app): State<Shared>,
271	viewer: Viewer,
272	Path((owner, name)): Path<(String, String)>,
273	Form(f): Form<RequirementsForm>,
274	) -> Result<Page<RepoSettingsPage>, Error> {
275	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
276	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
277	csrf(&viewer, &f.csrf_token, &shell)?;
278	let r = db::proposals::Requirements {
279	required_approvals: f.required_approvals.max(0),
280	require_owners: f.require_owners.is_some(),
281	allow_conflicts: f.allow_conflicts.is_some(),
282	};
283	db::proposals::set_requirements(&app.db, row.id, r).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
284	accounts::audit(
285	&app.db,
286	viewer.account(),
287	"repo.requirements",
288	&format!("{owner}/{name}"),
289	&format!("{} approvals, owners {}, conflicts {}", r.required_approvals, r.require_owners, r.allow_conflicts),
290	)
291	.await
292	.ok();
293	settings_page(&app, shell, row, role, Some("Landing requirements saved.".into()), None).await
294	}
295
296	#[derive(Deserialize)]
297	pub struct HookForm {
298	#[serde(rename = "_csrf")]
299	csrf_token: String,
300	#[serde(default)]
301	url: String,
302	#[serde(default)]
303	secret: String,
304	#[serde(default = "star")]
305	events: String,
306	#[serde(default)]
307	id: Option<i64>,
308	#[serde(default)]
309	action: String,
310	}
311
312	fn star() -> String {
313	"*".into()
314	}
315
316	pub async fn hooks(
317	State(app): State<Shared>,
318	viewer: Viewer,
319	Path((owner, name)): Path<(String, String)>,
320	Form(f): Form<HookForm>,
321	) -> Result<Page<RepoSettingsPage>, Error> {
322	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
323	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
324	csrf(&viewer, &f.csrf_token, &shell)?;
325	let e = \|e\| Error::from_db(shell.clone(), e);
326	let notice = match (f.action.as_str(), f.id) {
327	("delete", Some(id)) => {
328	if db::hooks::hook(&app.db, id).await.map_err(e)?.is_some_and(\|h\| h.repo_id == Some(row.id)) {
329	db::hooks::delete_hook(&app.db, id).await.map_err(e)?;
330	}
331	"Webhook deleted.".to_string()
332	}
333	("toggle", Some(id)) => {
334	if let Some(h) = db::hooks::hook(&app.db, id).await.map_err(e)?.filter(\|h\| h.repo_id == Some(row.id)) {
335	db::hooks::set_hook_active(&app.db, id, !h.active).await.map_err(e)?;
336	}
337	"Webhook updated.".to_string()
338	}
339	("ping", Some(id)) => {
340	if let Some(h) = db::hooks::hook(&app.db, id).await.map_err(e)?.filter(\|h\| h.repo_id == Some(row.id)) {
341	let delivery = crate::auth::random_hex(16);
342	let env = hub_api::WebhookEnvelope {
343	event: "ping".into(),
344	delivery: delivery.clone(),
345	repository: None,
346	actor: viewer.account().map(\|a\| a.username.clone()).unwrap_or_default(),
347	at_ms: db::now_ms(),
348	data: serde_json::json!({ "zen": "changes commute" }),
349	};
350	db::hooks::queue_delivery(&app.db, h.id, &delivery, "ping", &serde_json::to_string(&env).unwrap_or_default())
351	.await
352	.map_err(e)?;
353	app.events.notify_deliveries();
354	}
355	"Ping queued.".to_string()
356	}
357	_ => {
358	if !(f.url.starts_with("http://") \|\| f.url.starts_with("https://")) {
359	return settings_page(&app, shell, row, role, None, Some("A webhook URL starts with http:// or https://.".into())).await;
360	}
361	db::hooks::create_hook(&app.db, Some(row.id), None, f.url.trim(), f.secret.trim(), f.events.trim()).await.map_err(e)?;
362	accounts::audit(&app.db, viewer.account(), "hook.created", &format!("{owner}/{name}"), f.url.trim()).await.ok();
363	"Webhook added.".to_string()
364	}
365	};
366	settings_page(&app, shell, row, role, Some(notice), None).await
367	}
368
369	#[derive(Template)]
370	#[template(path = "deliveries.html")]
371	pub struct DeliveriesPage {
372	shell: Shell,
373	repo: RepoShell,
374	hook: db::hooks::Hook,
375	rows: Vec<db::hooks::Delivery>,
376	}
377
378	pub async fn deliveries(
379	State(app): State<Shared>,
380	viewer: Viewer,
381	Path((owner, name, id)): Path<(String, String, i64)>,
382	) -> Result<Page<DeliveriesPage>, Error> {
383	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings/hooks/{id}/deliveries"), &viewer);
384	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
385	let hook = db::hooks::hook(&app.db, id)
386	.await
387	.map_err(\|e\| Error::from_db(shell.clone(), e))?
388	.filter(\|h\| h.repo_id == Some(row.id))
389	.ok_or_else(\|\| Error::not_found(shell.clone()))?;
390	let rows = db::hooks::deliveries_for_hook(&app.db, id, 100).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
391	Ok(Page(DeliveriesPage { shell, repo: RepoShell::new(&app, &row, "settings").with_role(role), hook, rows }))
392	}
393
394	pub async fn redeliver(
395	State(app): State<Shared>,
396	viewer: Viewer,
397	Path((owner, name, id, delivery)): Path<(String, String, i64, i64)>,
398	Form(f): Form<super::session::CsrfForm>,
399	) -> Result<Page<DeliveriesPage>, Error> {
400	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings/hooks/{id}/deliveries"), &viewer);
401	let (_, row, _) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
402	csrf(&viewer, &f.csrf, &shell)?;
403	let mine = db::hooks::hook(&app.db, id).await.ok().flatten().is_some_and(\|h\| h.repo_id == Some(row.id));
404	if mine && db::hooks::delivery(&app.db, delivery).await.map_err(\|e\| Error::from_db(shell.clone(), e))?.is_some_and(\|d\| d.hook_id == id)
405	{
406	db::hooks::redeliver(&app.db, delivery).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
407	app.events.notify_deliveries();
408	}
409	deliveries(State(app), viewer, Path((owner, name, id))).await
410	}
411
412	#[derive(Deserialize)]
413	pub struct ChecksForm {
414	#[serde(rename = "_csrf")]
415	csrf_token: String,
416	#[serde(default)]
417	required_checks: String,
418	}
419
420	pub async fn required_checks(
421	State(app): State<Shared>,
422	viewer: Viewer,
423	Path((owner, name)): Path<(String, String)>,
424	Form(f): Form<ChecksForm>,
425	) -> Result<Page<RepoSettingsPage>, Error> {
426	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
427	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
428	csrf(&viewer, &f.csrf_token, &shell)?;
429	let names: Vec<String> = f.required_checks.split(',').map(str::trim).filter(\|s\| !s.is_empty()).map(String::from).collect();
430	db::hooks::set_required_checks(&app.db, row.id, &names).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
431	settings_page(&app, shell, row, role, Some("Required checks saved.".into()), None).await
432	}
433
434	#[derive(Deserialize)]
435	pub struct MirrorForm {
436	#[serde(rename = "_csrf")]
437	csrf_token: String,
438	#[serde(default)]
439	enabled: Option<String>,
440	}
441
442	pub async fn mirror(
443	State(app): State<Shared>,
444	viewer: Viewer,
445	Path((owner, name)): Path<(String, String)>,
446	Form(f): Form<MirrorForm>,
447	) -> Result<Page<RepoSettingsPage>, Error> {
448	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
449	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
450	csrf(&viewer, &f.csrf_token, &shell)?;
451	db::repos::set_git_mirror(&app.db, row.id, f.enabled.is_some()).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
452	let row = db::repos::get_by_id(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?.unwrap_or(row);
453	if row.git_mirror {
454	crate::mirror::refresh(&app, &row).await;
455	}
456	accounts::audit(&app.db, viewer.account(), "repo.mirror", &format!("{owner}/{name}"), if row.git_mirror { "on" } else { "off" })
457	.await
458	.ok();
459	let row = db::repos::get_by_id(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?.unwrap_or(row);
460	let notice = if row.git_mirror { "The Git mirror is on and up to date." } else { "The Git mirror is off." };
461	settings_page(&app, shell, row, role, Some(notice.into()), None).await
462	}

Keyboard