crates/hub/src/web/repo_settings.rs at v0.1.0 · andymccall/oxygenhub

◆ v0.1.0 oxygenhub / crates / hub / src / web / repo_settings.rs

18.5 KiB · Rust · last changed Turn OxygenFlow on or off per repository in settings 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<super::webhooks::HookRow>,
    required_checks: String,
    /// Whether hub.toml alone would run Flow here, and whether it runs.
    flow_default: bool,
    flow_enabled: bool,
    site_admin: bool,
    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 hooks = super::webhooks::rows(app, hooks).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(", ");
    let flow_default = app.config.flow.allows(&row.owner, &row.name);
    let flow_enabled = crate::flow::enabled(app, &row);
    let site_admin = shell.is_admin;
    Ok(Page(RepoSettingsPage {
        shell,
        repo,
        row,
        collaborators,
        teams,
        role,
        requirements,
        hooks,
        required_checks,
        flow_default,
        flow_enabled,
        site_admin,
        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
}

pub async fn hooks(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<super::webhooks::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 scope = super::webhooks::Scope::Repo { id: row.id, slug: format!("{owner}/{name}") };
    match super::webhooks::apply(&app, &viewer, &scope, f).await.map_err(|e| Error::from_db(shell.clone(), e))? {
        Ok(notice) => settings_page(&app, shell, row, role, Some(notice), None).await,
        Err(error) => settings_page(&app, shell, row, role, None, Some(error)).await,
    }
}

pub async fn deliveries(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name, id)): Path<(String, String, i64)>,
) -> Result<Page<super::webhooks::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 scope = super::webhooks::Scope::Repo { id: row.id, slug: format!("{owner}/{name}") };
    super::webhooks::deliveries_page(&app, shell, &scope, Some(RepoShell::new(&app, &row, "settings").with_role(role)), id).await
}

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<super::webhooks::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?;
    csrf(&viewer, &f.csrf, &shell)?;
    let scope = super::webhooks::Scope::Repo { id: row.id, slug: format!("{owner}/{name}") };
    super::webhooks::redeliver(&app, &scope, id, delivery).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    super::webhooks::deliveries_page(&app, shell, &scope, Some(RepoShell::new(&app, &row, "settings").with_role(role)), 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>,
}

#[derive(Deserialize)]
pub struct FlowForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    /// `on`, `off`, or `default`.
    flow: String,
}

/// Turn OxygenFlow on or off for one repository. Runs use the site's
/// runners, so only site administrators decide.
pub async fn flow(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<FlowForm>,
) -> 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)?;
    if !viewer.is_admin() {
        return settings_page(&app, shell, row, role, None, Some("Only site administrators turn OxygenFlow on or off.".into())).await;
    }
    let setting = match f.flow.as_str() {
        "on" => "on",
        "off" => "off",
        "default" => "",
        _ => return settings_page(&app, shell, row, role, None, Some("Pick on, off or the site default.".into())).await,
    };
    db::repos::set_flow(&app.db, row.id, setting).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    let label = if setting.is_empty() { "default" } else { setting };
    accounts::audit(&app.db, viewer.account(), "repo.flow", &format!("{owner}/{name}"), label).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 crate::flow::enabled(&app, &row) {
        "OxygenFlow is on: pushes with a .flow/pipeline.kdl start runs."
    } else {
        "OxygenFlow is off for this repository."
    };
    settings_page(&app, shell, row, role, Some(notice.into()), None).await
}

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

19bb31ff Andy McCall 1 month ago ↶	1	//! Creating repositories and their settings pages (hub spec §6.3).
	2
	3	use super::settings::{csrf, require};
b64e2537 Andy McCall 1 month ago ↶	4	use super::{filters, lookup_role, Error, Page, RepoShell, Shell};
19bb31ff Andy McCall 1 month ago ↶	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
07b1a5bb Andy McCall 1 month ago ↶	23	pub(crate) async fn owners_for(app: &Shared, me: &accounts::Account) -> Vec<String> {
19bb31ff Andy McCall 1 month ago ↶	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,
de505df5 Andy McCall 1 month ago ↶	89	requirements: db::proposals::Requirements,
9756c67d Andy McCall 1 month ago ↶	90	hooks: Vec<super::webhooks::HookRow>,
b64e2537 Andy McCall 1 month ago ↶	91	required_checks: String,
9008bf6c Andy McCall 1 month ago ↶	92	/// Whether hub.toml alone would run Flow here, and whether it runs.
	93	flow_default: bool,
	94	flow_enabled: bool,
	95	site_admin: bool,
19bb31ff Andy McCall 1 month ago ↶	96	notice: Option<String>,
	97	error: Option<String>,
	98	}
	99
	100	async fn settings_page(
	101	app: &Shared,
	102	shell: Shell,
	103	row: db::repos::RepoRow,
	104	role: Role,
	105	notice: Option<String>,
	106	error: Option<String>,
	107	) -> Result<Page<RepoSettingsPage>, Error> {
	108	let collaborators = accounts::collaborators(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
	109	let teams = match accounts::org_by_name(&app.db, &row.owner).await.map_err(\|e\| Error::from_db(shell.clone(), e))? {
	110	Some(org) => accounts::teams(&app.db, org.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?,
	111	None => vec![],
	112	};
de505df5 Andy McCall 1 month ago ↶	113	let repo = RepoShell::new(app, &row, "settings").with_role(role);
de505df5 Andy McCall 1 month ago ↶	114	let requirements = db::proposals::requirements(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
b64e2537 Andy McCall 1 month ago ↶	115	let hooks = db::hooks::hooks_for_repo(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
9756c67d Andy McCall 1 month ago ↶	116	let hooks = super::webhooks::rows(app, hooks).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
b64e2537 Andy McCall 1 month ago ↶	117	let required_checks = db::hooks::required_checks(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?.join(", ");
9008bf6c Andy McCall 1 month ago ↶	118	let flow_default = app.config.flow.allows(&row.owner, &row.name);
	119	let flow_enabled = crate::flow::enabled(app, &row);
	120	let site_admin = shell.is_admin;
	121	Ok(Page(RepoSettingsPage {
	122	shell,
	123	repo,
	124	row,
	125	collaborators,
	126	teams,
	127	role,
	128	requirements,
	129	hooks,
	130	required_checks,
	131	flow_default,
	132	flow_enabled,
	133	site_admin,
	134	notice,
	135	error,
	136	}))
19bb31ff Andy McCall 1 month ago ↶	137	}
	138
	139	pub async fn settings(
	140	State(app): State<Shared>,
	141	viewer: Viewer,
	142	Path((owner, name)): Path<(String, String)>,
	143	) -> Result<Page<RepoSettingsPage>, Error> {
	144	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
	145	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
	146	settings_page(&app, shell, row, role, None, None).await
	147	}
	148
	149	#[derive(Deserialize)]
	150	pub struct GeneralForm {
	151	#[serde(rename = "_csrf")]
	152	csrf_token: String,
	153	description: String,
	154	default_bookmark: String,
	155	visibility: String,
1553bfc9 Andy McCall 1 month ago ↶	156	#[serde(default)]
1553bfc9 Andy McCall 1 month ago ↶	157	topics: String,
19bb31ff Andy McCall 1 month ago ↶	158	}
	159
	160	pub async fn update(
	161	State(app): State<Shared>,
	162	viewer: Viewer,
	163	Path((owner, name)): Path<(String, String)>,
	164	Form(f): Form<GeneralForm>,
	165	) -> Result<Page<RepoSettingsPage>, Error> {
	166	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
	167	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
	168	csrf(&viewer, &f.csrf_token, &shell)?;
	169	let e = \|e\| Error::from_db(shell.clone(), e);
1553bfc9 Andy McCall 1 month ago ↶	170	let topics = match db::repos::parse_topics(&f.topics) {
	171	Ok(t) => t,
	172	Err(msg) => return settings_page(&app, shell, row, role, None, Some(msg)).await,
	173	};
19bb31ff Andy McCall 1 month ago ↶	174	db::repos::set_description(&app.db, row.id, f.description.trim()).await.map_err(e)?;
1553bfc9 Andy McCall 1 month ago ↶	175	db::repos::set_topics(&app.db, row.id, &topics).await.map_err(e)?;
19bb31ff Andy McCall 1 month ago ↶	176	if crate::repos::names::valid_segment(f.default_bookmark.trim()) {
	177	db::repos::set_default_bookmark(&app.db, row.id, f.default_bookmark.trim()).await.map_err(e)?;
	178	}
	179	if role >= Role::Admin {
	180	if let Some(v) = Visibility::parse(&f.visibility) {
	181	db::repos::set_visibility(&app.db, row.id, v).await.map_err(e)?;
	182	}
	183	}
	184	accounts::audit(&app.db, viewer.account(), "repo.updated", &format!("{owner}/{name}"), "").await.ok();
	185	let row = db::repos::get_by_id(&app.db, row.id).await.map_err(e)?.unwrap_or(row);
	186	settings_page(&app, shell, row, role, Some("Saved.".into()), None).await
	187	}
	188
	189	#[derive(Deserialize)]
	190	pub struct CollaboratorForm {
	191	#[serde(rename = "_csrf")]
	192	csrf_token: String,
	193	#[serde(default)]
	194	username: String,
	195	#[serde(default)]
	196	team: String,
	197	#[serde(default)]
	198	role: String,
	199	#[serde(default)]
	200	remove: Option<String>,
	201	}
	202
	203	pub async fn collaborator(
	204	State(app): State<Shared>,
	205	viewer: Viewer,
	206	Path((owner, name)): Path<(String, String)>,
	207	Form(f): Form<CollaboratorForm>,
	208	) -> Result<Page<RepoSettingsPage>, Error> {
	209	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
	210	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
	211	csrf(&viewer, &f.csrf_token, &shell)?;
	212	let e = \|e\| Error::from_db(shell.clone(), e);
	213	let (account_id, team_id, label) = if !f.username.trim().is_empty() {
	214	match accounts::account_by_name(&app.db, f.username.trim()).await.map_err(e)? {
	215	Some(a) => (Some(a.id), None, a.username),
	216	None => return settings_page(&app, shell, row, role, None, Some("No such account.".into())).await,
	217	}
	218	} else if !f.team.trim().is_empty() {
	219	let org = accounts::org_by_name(&app.db, &row.owner).await.map_err(e)?;
	220	let team = match org {
	221	Some(o) => accounts::team_by_name(&app.db, o.id, f.team.trim()).await.map_err(e)?,
	222	None => None,
	223	};
	224	match team {
	225	Some(t) => (None, Some(t.id), format!("team {}", t.name)),
	226	None => return settings_page(&app, shell, row, role, None, Some("No such team in this organisation.".into())).await,
	227	}
	228	} else {
	229	return settings_page(&app, shell, row, role, None, Some("Name an account or a team.".into())).await;
	230	};
	231	if f.remove.is_some() {
	232	accounts::remove_collaborator(&app.db, row.id, account_id, team_id).await.map_err(e)?;
	233	accounts::audit(&app.db, viewer.account(), "repo.collaborator.removed", &format!("{owner}/{name}"), &label).await.ok();
	234	return settings_page(&app, shell, row, role, Some(format!("Removed {label}.")), None).await;
	235	}
	236	let Some(new_role) = Role::parse(&f.role) else {
	237	return settings_page(&app, shell, row, role, None, Some("Pick a role.".into())).await;
	238	};
	239	accounts::set_collaborator(&app.db, row.id, account_id, team_id, new_role.as_str()).await.map_err(e)?;
240	accounts::audit(
241	&app.db,
242	viewer.account(),
243	"repo.collaborator.set",
244	&format!("{owner}/{name}"),
245	&format!("{label} {}", new_role.as_str()),
246	)
247	.await
248	.ok();
249	settings_page(&app, shell, row, role, Some(format!("{label} now has {} access.", new_role.as_str())), None).await
250	}
251
252	#[derive(Deserialize)]
253	pub struct DeleteForm {
254	#[serde(rename = "_csrf")]
255	csrf_token: String,
256	confirm: String,
257	}
258
259	pub async fn delete(
260	State(app): State<Shared>,
261	viewer: Viewer,
262	Path((owner, name)): Path<(String, String)>,
263	Form(f): Form<DeleteForm>,
264	) -> Result<Response, Error> {
265	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
266	let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
267	csrf(&viewer, &f.csrf_token, &shell)?;
268	if f.confirm.trim() != repo.to_string() {
269	return Ok(settings_page(&app, shell, row, role, None, Some("Type the repository's full name to delete it.".into()))
270	.await?
271	.into_response());
272	}
273	let _guard = app.repos.write_guard(&repo).await;
274	app.repos.trash(&repo).map_err(\|e\| Error::from_repo(shell.clone(), e))?;
275	db::repos::delete(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
276	accounts::audit(&app.db, viewer.account(), "repo.deleted", &repo.to_string(), "moved to trash").await.ok();
277	Ok(Redirect::to(&format!("/{owner}")).into_response())
278	}
de505df5 Andy McCall 1 month ago ↶	279
	280	#[derive(Deserialize)]
	281	pub struct RequirementsForm {
	282	#[serde(rename = "_csrf")]
	283	csrf_token: String,
	284	#[serde(default)]
	285	required_approvals: i64,
	286	#[serde(default)]
	287	require_owners: Option<String>,
	288	#[serde(default)]
	289	allow_conflicts: Option<String>,
	290	}
	291
	292	pub async fn requirements(
	293	State(app): State<Shared>,
	294	viewer: Viewer,
	295	Path((owner, name)): Path<(String, String)>,
	296	Form(f): Form<RequirementsForm>,
	297	) -> Result<Page<RepoSettingsPage>, Error> {
	298	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
	299	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
	300	csrf(&viewer, &f.csrf_token, &shell)?;
	301	let r = db::proposals::Requirements {
	302	required_approvals: f.required_approvals.max(0),
	303	require_owners: f.require_owners.is_some(),
	304	allow_conflicts: f.allow_conflicts.is_some(),
	305	};
	306	db::proposals::set_requirements(&app.db, row.id, r).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
	307	accounts::audit(
	308	&app.db,
	309	viewer.account(),
	310	"repo.requirements",
	311	&format!("{owner}/{name}"),
	312	&format!("{} approvals, owners {}, conflicts {}", r.required_approvals, r.require_owners, r.allow_conflicts),
	313	)
	314	.await
	315	.ok();
	316	settings_page(&app, shell, row, role, Some("Landing requirements saved.".into()), None).await
	317	}
b64e2537 Andy McCall 1 month ago ↶	318
	319	pub async fn hooks(
	320	State(app): State<Shared>,
	321	viewer: Viewer,
	322	Path((owner, name)): Path<(String, String)>,
8fb35df7 Andy McCall 1 month ago ↶	323	Form(f): Form<super::webhooks::HookForm>,
b64e2537 Andy McCall 1 month ago ↶	324	) -> Result<Page<RepoSettingsPage>, Error> {
	325	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
	326	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
	327	csrf(&viewer, &f.csrf_token, &shell)?;
8fb35df7 Andy McCall 1 month ago ↶	328	let scope = super::webhooks::Scope::Repo { id: row.id, slug: format!("{owner}/{name}") };
	329	match super::webhooks::apply(&app, &viewer, &scope, f).await.map_err(\|e\| Error::from_db(shell.clone(), e))? {
	330	Ok(notice) => settings_page(&app, shell, row, role, Some(notice), None).await,
	331	Err(error) => settings_page(&app, shell, row, role, None, Some(error)).await,
	332	}
b64e2537 Andy McCall 1 month ago ↶	333	}
	334
	335	pub async fn deliveries(
	336	State(app): State<Shared>,
	337	viewer: Viewer,
	338	Path((owner, name, id)): Path<(String, String, i64)>,
8fb35df7 Andy McCall 1 month ago ↶	339	) -> Result<Page<super::webhooks::DeliveriesPage>, Error> {
b64e2537 Andy McCall 1 month ago ↶	340	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings/hooks/{id}/deliveries"), &viewer);
b64e2537 Andy McCall 1 month ago ↶	341	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
8fb35df7 Andy McCall 1 month ago ↶	342	let scope = super::webhooks::Scope::Repo { id: row.id, slug: format!("{owner}/{name}") };
8fb35df7 Andy McCall 1 month ago ↶	343	super::webhooks::deliveries_page(&app, shell, &scope, Some(RepoShell::new(&app, &row, "settings").with_role(role)), id).await
b64e2537 Andy McCall 1 month ago ↶	344	}
	345
	346	pub async fn redeliver(
	347	State(app): State<Shared>,
	348	viewer: Viewer,
	349	Path((owner, name, id, delivery)): Path<(String, String, i64, i64)>,
	350	Form(f): Form<super::session::CsrfForm>,
8fb35df7 Andy McCall 1 month ago ↶	351	) -> Result<Page<super::webhooks::DeliveriesPage>, Error> {
b64e2537 Andy McCall 1 month ago ↶	352	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings/hooks/{id}/deliveries"), &viewer);
8fb35df7 Andy McCall 1 month ago ↶	353	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;
b64e2537 Andy McCall 1 month ago ↶	354	csrf(&viewer, &f.csrf, &shell)?;
8fb35df7 Andy McCall 1 month ago ↶	355	let scope = super::webhooks::Scope::Repo { id: row.id, slug: format!("{owner}/{name}") };
	356	super::webhooks::redeliver(&app, &scope, id, delivery).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
	357	super::webhooks::deliveries_page(&app, shell, &scope, Some(RepoShell::new(&app, &row, "settings").with_role(role)), id).await
b64e2537 Andy McCall 1 month ago ↶	358	}
	359
	360	#[derive(Deserialize)]
	361	pub struct ChecksForm {
	362	#[serde(rename = "_csrf")]
	363	csrf_token: String,
	364	#[serde(default)]
	365	required_checks: String,
	366	}
	367
	368	pub async fn required_checks(
	369	State(app): State<Shared>,
	370	viewer: Viewer,
	371	Path((owner, name)): Path<(String, String)>,
	372	Form(f): Form<ChecksForm>,
	373	) -> Result<Page<RepoSettingsPage>, Error> {
	374	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
	375	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
	376	csrf(&viewer, &f.csrf_token, &shell)?;
	377	let names: Vec<String> = f.required_checks.split(',').map(str::trim).filter(\|s\| !s.is_empty()).map(String::from).collect();
	378	db::hooks::set_required_checks(&app.db, row.id, &names).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
	379	settings_page(&app, shell, row, role, Some("Required checks saved.".into()), None).await
	380	}
3f4b0ea6 Andy McCall 1 month ago ↶	381
	382	#[derive(Deserialize)]
	383	pub struct MirrorForm {
	384	#[serde(rename = "_csrf")]
	385	csrf_token: String,
	386	#[serde(default)]
	387	enabled: Option<String>,
9008bf6c Andy McCall 1 month ago ↶	388	}
	389
	390	#[derive(Deserialize)]
	391	pub struct FlowForm {
	392	#[serde(rename = "_csrf")]
	393	csrf_token: String,
	394	/// `on`, `off`, or `default`.
	395	flow: String,
	396	}
	397
	398	/// Turn OxygenFlow on or off for one repository. Runs use the site's
	399	/// runners, so only site administrators decide.
	400	pub async fn flow(
	401	State(app): State<Shared>,
	402	viewer: Viewer,
	403	Path((owner, name)): Path<(String, String)>,
	404	Form(f): Form<FlowForm>,
	405	) -> Result<Page<RepoSettingsPage>, Error> {
	406	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
	407	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
	408	csrf(&viewer, &f.csrf_token, &shell)?;
	409	if !viewer.is_admin() {
	410	return settings_page(&app, shell, row, role, None, Some("Only site administrators turn OxygenFlow on or off.".into())).await;
	411	}
	412	let setting = match f.flow.as_str() {
	413	"on" => "on",
	414	"off" => "off",
	415	"default" => "",
	416	_ => return settings_page(&app, shell, row, role, None, Some("Pick on, off or the site default.".into())).await,
	417	};
	418	db::repos::set_flow(&app.db, row.id, setting).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
	419	let label = if setting.is_empty() { "default" } else { setting };
	420	accounts::audit(&app.db, viewer.account(), "repo.flow", &format!("{owner}/{name}"), label).await.ok();
	421	let row = db::repos::get_by_id(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?.unwrap_or(row);
	422	let notice = if crate::flow::enabled(&app, &row) {
	423	"OxygenFlow is on: pushes with a .flow/pipeline.kdl start runs."
	424	} else {
	425	"OxygenFlow is off for this repository."
	426	};
	427	settings_page(&app, shell, row, role, Some(notice.into()), None).await
3f4b0ea6 Andy McCall 1 month ago ↶	428	}
	429
	430	pub async fn mirror(
	431	State(app): State<Shared>,
	432	viewer: Viewer,
	433	Path((owner, name)): Path<(String, String)>,
	434	Form(f): Form<MirrorForm>,
	435	) -> Result<Page<RepoSettingsPage>, Error> {
	436	let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);
	437	let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
	438	csrf(&viewer, &f.csrf_token, &shell)?;
	439	db::repos::set_git_mirror(&app.db, row.id, f.enabled.is_some()).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
	440	let row = db::repos::get_by_id(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?.unwrap_or(row);
	441	if row.git_mirror {
	442	crate::mirror::refresh(&app, &row).await;
	443	}
	444	accounts::audit(&app.db, viewer.account(), "repo.mirror", &format!("{owner}/{name}"), if row.git_mirror { "on" } else { "off" })
	445	.await
	446	.ok();
	447	let row = db::repos::get_by_id(&app.db, row.id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?.unwrap_or(row);
	448	let notice = if row.git_mirror { "The Git mirror is on and up to date." } else { "The Git mirror is off." };
	449	settings_page(&app, shell, row, role, Some(notice.into()), None).await
	450	}

Keyboard