refs.rs 93.7%

298 of 318 lines run, 33 of 86 functions · run #507 on main · run missed

//! Bookmarks, tags, conflicts, trust and pushes pages.

use super::settings::{csrf, require};
use super::{filters, lookup, lookup_role, Error, Page, RepoShell, Shell};
use crate::auth::{Access, Role, Viewer};
use crate::repos::view;
use crate::{db, Shared};
use askama::Template;
use axum::extract::{Form, Path, State};
use serde::Deserialize;

#[derive(Template)]
#[template(path = "bookmarks.html")]
pub struct BookmarksPage {
    shell: Shell,
    repo: RepoShell,
    bookmarks: Vec<view::BookmarkView>,
    /// Whether the viewer may create and delete bookmarks (write access).
    can_delete: bool,
    /// Whether the viewer may run the pipeline of a bookmark.
    can_run: bool,
    notice: Option<String>,
    error: Option<String>,
}

async fn bookmarks_page(
    app: &Shared,
    shell: Shell,
    repo: crate::repos::RepoName,
    row: db::repos::RepoRow,
    role: Role,
    notice: Option<String>,
    error: Option<String>,
) -> Result<Page<BookmarksPage>, Error> {
    let default = row.default_bookmark.clone();
    let bookmarks =
        app.repos.read(&repo, move |r, cache| view::bookmarks(r, cache, &default)).await.map_err(|e| Error::from_repo(shell.clone(), e))?;
    let can_delete = shell.user.is_some() && role >= Role::Write;
    let can_run = super::flow::why_not_run(crate::flow::enabled(app, &row), shell.user.is_some(), role).is_none();
    Ok(Page(BookmarksPage {
        shell,
        repo: RepoShell::new(app, &row, "bookmarks").with_role(role),
        bookmarks,
        can_delete,
        can_run,
        notice,
        error,
    }))
}

pub async fn bookmarks(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
) -> Result<Page<BookmarksPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/bookmarks"), &viewer);
    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
    bookmarks_page(&app, shell, repo, row, role, None, None).await
}

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

/// Delete a bookmark from the web (hub spec §6.4): what `oxy push --delete`
/// does, through the same checks. Never the default bookmark; refused under
/// a trust policy, which needs a signed attestation only a client can make.
pub async fn delete_bookmark(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<DeleteBookmarkForm>,
) -> Result<Page<BookmarksPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/bookmarks"), &viewer);
    let me = require(&viewer, &shell)?;
    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let bookmark = f.bookmark.trim().to_string();
    if bookmark == row.default_bookmark {
        let msg = format!("{bookmark} is the default bookmark; choose another default in Settings first.");
        return bookmarks_page(&app, shell, repo, row, role, None, Some(msg)).await;
    }
    let target = bookmark.clone();
    let outcome = app
        .repos
        .write(&repo, move |r, _| {
            let Some(state) = r.view()?.bookmarks.get(&target).copied() else {
                return Ok(Err(format!("There is no bookmark {target}.")));
            };
            let update = oxy_core::protocol::RefUpdate {
                name: target.clone(),
                old_state: state,
                new_state: oxy_core::hash::ObjectRef::ZERO,
                force: true,
                attestation: None,
            };
            let report = r.receive_push_report(Default::default(), vec![update], None, vec![])?;
            Ok(match report.results.first() {
                Some(res) if res.ok => Ok(state.to_hex()),
                Some(res) => Err(res.reason.clone()),
                None => Err("nothing happened".into()),
            })
        })
        .await
        .map_err(|e| Error::from_repo(shell.clone(), e))?;
    let old_state = match outcome {
        Ok(s) => s,
        Err(msg) => return bookmarks_page(&app, shell, repo, row, role, None, Some(format!("Could not delete {bookmark}: {msg}"))).await,
    };
    let result = db::repos::PushOutcome {
        reference: bookmark.clone(),
        ok: true,
        reason: "deleted on the web".into(),
        old_state: old_state.clone(),
        new_state: oxy_core::hash::ObjectRef::ZERO.to_hex(),
        heads: 0,
        changes: 0,
    };
    db::repos::record_push(&app.db, row.id, Some((me.account.id, &me.account.username)), &[result]).await.ok();
    crate::hooks::emit(
        &app,
        &row,
        "push",
        &me.account.username,
        serde_json::json!({ "updates": [{ "reference": bookmark, "old_state": old_state, "new_state": oxy_core::hash::ObjectRef::ZERO.to_hex(), "heads": 0, "changes": 0, "deleted": true }], "via": "web" }),
    )
    .await;
    db::accounts::audit(&app.db, Some(&me.account), "bookmark.deleted", &format!("{owner}/{name}"), &bookmark).await.ok();
    bookmarks_page(
        &app,
        shell,
        repo,
        row,
        role,
        Some(format!("Deleted {bookmark}. Its changes stay while anything else reaches them.")),
        None,
    )
    .await
}

#[derive(Deserialize)]
pub struct CreateBookmarkForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    name: String,
    /// A bookmark, tag or change; the default bookmark when empty.
    #[serde(default)]
    from: String,
}

/// Create a bookmark from the web at the heads of a bookmark, tag or change:
/// what pushing a new bookmark does, signed by the hub key as the user's
/// delegate, as the web's other changes to bookmarks are.
pub async fn create_bookmark(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<CreateBookmarkForm>,
) -> Result<Page<BookmarksPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/bookmarks"), &viewer);
    let me = require(&viewer, &shell)?;
    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let bookmark = f.name.trim().to_string();
    let from = match f.from.trim() {
        "" => row.default_bookmark.clone(),
        s => s.to_string(),
    };
    if bookmark.is_empty() || bookmark.chars().any(char::is_whitespace) {
        return bookmarks_page(&app, shell, repo, row, role, None, Some("A bookmark's name has no spaces.".into())).await;
    }
    let (wanted, spec) = (bookmark.clone(), from.clone());
    let found = app
        .repos
        .read(&repo, move |r, cache| {
            if r.view()?.bookmarks.contains_key(&wanted) {
                return Ok(Err(format!("{wanted} is a bookmark already.")));
            }
            Ok(view::resolve(r, cache, &spec).map(|t| t.heads).map_err(|e| e.to_string()))
        })
        .await
        .map_err(|e| Error::from_repo(shell.clone(), e))?;
    let heads = match found {
        Ok(heads) if !heads.is_empty() => heads,
        Ok(_) => return bookmarks_page(&app, shell, repo, row, role, None, Some(format!("{from} holds no changes to start from."))).await,
        Err(msg) => return bookmarks_page(&app, shell, repo, row, role, None, Some(msg)).await,
    };
    // As the user's delegate when they have one; otherwise unsigned, which
    // a repository without a trust policy takes, as a push without one.
    let made = match super::edit::signer_for(&app, me.account.id).await {
        Ok(signer) => crate::repos::edits::move_bookmark(&app.repos, &repo, bookmark.clone(), heads.clone(), signer)
            .await
            .map(|_| ())
            .map_err(|e| e.to_string()),
        Err(why) => {
            let (target, at) = (bookmark.clone(), heads.clone());
            let unsigned = app
                .repos
                .write(&repo, move |r, _| {
                    let update = r.host_ref_update(&target, &at, None)?;
                    let report = r.receive_push_report(Default::default(), vec![update], None, vec![])?;
                    Ok(match report.results.first() {
                        Some(res) if res.ok => Ok(()),
                        Some(res) => Err(res.reason.clone()),
                        None => Err("nothing happened".to_string()),
                    })
                })
                .await
                .map_err(|e| e.to_string())
                .and_then(|r| r);
            unsigned.map_err(|refused| format!("{refused}. {why}"))
        }
    };
    if let Err(e) = made {
        return bookmarks_page(&app, shell, repo, row, role, None, Some(format!("Could not create {bookmark}: {e}"))).await;
    }
    let made = bookmark.clone();
    let new_state = app
        .repos
        .read(&repo, move |r, _| Ok(r.view()?.bookmarks.get(&made).map(|s| s.to_hex()).unwrap_or_default()))
        .await
        .unwrap_or_default();
    let result = db::repos::PushOutcome {
        reference: bookmark.clone(),
        ok: true,
        reason: format!("created on the web from {from}"),
        old_state: oxy_core::hash::ObjectRef::ZERO.to_hex(),
        new_state: new_state.clone(),
        heads: heads.len() as i64,
        changes: 0,
    };
    db::repos::record_push(&app.db, row.id, Some((me.account.id, &me.account.username)), &[result]).await.ok();
    crate::hooks::emit(
        &app,
        &row,
        "push",
        &me.account.username,
        serde_json::json!({ "updates": [{ "reference": bookmark, "old_state": oxy_core::hash::ObjectRef::ZERO.to_hex(), "new_state": new_state, "heads": heads.len(), "changes": 0, "created": true }], "via": "web" }),
    )
    .await;
    db::accounts::audit(&app.db, Some(&me.account), "bookmark.created", &format!("{owner}/{name}"), &format!("{bookmark} from {from}"))
        .await
        .ok();
    let notice = format!("Created {bookmark} from {from}. Propose changes into it, or make it the default in Settings.");
    bookmarks_page(&app, shell, repo, row, role, Some(notice), None).await
}

#[derive(Template)]
#[template(path = "tags.html")]
pub struct TagsPage {
    shell: Shell,
    repo: RepoShell,
    tags: Vec<view::TagView>,
    withdrawn: Vec<view::WithdrawnView>,
    /// Tags a release uses (not withdrawn while it does).
    released: Vec<String>,
    can_create: bool,
    can_withdraw: bool,
    notice: Option<String>,
    error: Option<String>,
}

impl TagsPage {
    fn released(&self, tag: &str) -> bool {
        self.released.iter().any(|t| t == tag)
    }
}

async fn tags_page(
    app: &Shared,
    shell: Shell,
    repo: crate::repos::RepoName,
    row: db::repos::RepoRow,
    role: Role,
    notice: Option<String>,
    error: Option<String>,
) -> Result<Page<TagsPage>, Error> {
    let (tags, withdrawn) = app
        .repos
        .read(&repo, |r, _| Ok((view::tags(r)?, view::withdrawn_tags(r)?)))
        .await
        .map_err(|e| Error::from_repo(shell.clone(), e))?;
    let released = db::releases::list(&app.db, row.id).await.unwrap_or_default().into_iter().map(|r| r.tag).collect();
    let signed_in = shell.user.is_some();
    Ok(Page(TagsPage {
        shell,
        repo: RepoShell::new(app, &row, "tags").with_role(role),
        tags,
        withdrawn,
        released,
        can_create: signed_in && role >= Role::Write,
        can_withdraw: signed_in && role >= Role::Maintain,
        notice,
        error,
    }))
}

pub async fn tags(State(app): State<Shared>, viewer: Viewer, Path((owner, name)): Path<(String, String)>) -> Result<Page<TagsPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/tags"), &viewer);
    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
    tags_page(&app, shell, repo, row, role, None, None).await
}

#[derive(Deserialize)]
pub struct CreateTagForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    name: String,
    #[serde(default)]
    target: String,
    #[serde(default)]
    message: String,
}

/// Create a tag from the web (#295): signed by the hub key as the user's
/// delegate, under the policy, as `oxy tag create` and a push would be.
pub async fn create_tag(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<CreateTagForm>,
) -> Result<Page<TagsPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/tags"), &viewer);
    let me = require(&viewer, &shell)?;
    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    match crate::tags::create(&app, &row, &repo, &me.account, &f.name, &f.target, &f.message).await {
        Ok(t) => {
            let notice = format!(
                "Tagged {} ({} head{}). Start a release from it under Releases.",
                t.name,
                t.heads.len(),
                if t.heads.len() == 1 { "" } else { "s" }
            );
            tags_page(&app, shell, repo, row, role, Some(notice), None).await
        }
        Err(e) => tags_page(&app, shell, repo, row, role, None, Some(format!("Could not create the tag: {e}"))).await,
    }
}

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

/// Withdraw a tag from the web (#301), as `oxy push --delete tags/NAME`
/// does: a signed withdrawal, kept and logged. Maintainers only; never
/// while a release uses the tag.
pub async fn withdraw_tag(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<WithdrawTagForm>,
) -> Result<Page<TagsPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/tags"), &viewer);
    let me = require(&viewer, &shell)?;
    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    match crate::tags::withdraw(&app, &row, &repo, &me.account, &f.tag, &f.reason).await {
        Ok(t) => {
            let notice = format!("Withdrew {}. Clones drop it on their next fetch; the name is not used again.", t.name);
            tags_page(&app, shell, repo, row, role, Some(notice), None).await
        }
        Err(e) => tags_page(&app, shell, repo, row, role, None, Some(format!("Could not withdraw {}: {e}", f.tag.trim()))).await,
    }
}

#[derive(Template)]
#[template(path = "conflicts.html")]
pub struct ConflictsPage {
    shell: Shell,
    repo: RepoShell,
    conflicts: Vec<view::ConflictView>,
}

pub async fn conflicts(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
) -> Result<Page<ConflictsPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/conflicts"), &viewer);
    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
    let conflicts = app.repos.read(&repo, view::conflicts).await.map_err(|e| Error::from_repo(shell.clone(), e))?;
    Ok(Page(ConflictsPage { shell, repo: RepoShell::new(&app, &row, "conflicts").with_role(role).with_sky(&app, &row).await, conflicts }))
}

#[derive(Template)]
#[template(path = "trust.html")]
pub struct TrustPage {
    shell: Shell,
    repo: RepoShell,
    t: view::Trust,
}

pub async fn trust(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
) -> Result<Page<TrustPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/trust"), &viewer);
    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
    let key = app.hub_key.key;
    let t = app.repos.read(&repo, move |r, cache| view::trust(r, cache, &key)).await.map_err(|e| Error::from_repo(shell.clone(), e))?;
    Ok(Page(TrustPage { shell, repo: RepoShell::new(&app, &row, "trust").with_role(role), t }))
}

#[derive(Template)]
#[template(path = "pushes.html")]
pub struct PushesPage {
    shell: Shell,
    repo: RepoShell,
    pushes: Vec<db::repos::PushRow>,
}

pub async fn pushes(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
) -> Result<Page<PushesPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/pushes"), &viewer);
    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
    let pushes = db::repos::pushes(&app.db, row.id, 200).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    Ok(Page(PushesPage { shell, repo: RepoShell::new(&app, &row, "pushes").with_role(role), pushes }))
}

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

1		//! Bookmarks, tags, conflicts, trust and pushes pages.
2
3		use super::settings::{csrf, require};
4		use super::{filters, lookup, lookup_role, Error, Page, RepoShell, Shell};
5		use crate::auth::{Access, Role, Viewer};
6		use crate::repos::view;
7		use crate::{db, Shared};
8		use askama::Template;
9		use axum::extract::{Form, Path, State};
10		use serde::Deserialize;
11
12		#[derive(Template)]
13		#[template(path = "bookmarks.html")]
14		pub struct BookmarksPage {
15		shell: Shell,
16		repo: RepoShell,
17		bookmarks: Vec<view::BookmarkView>,
18		/// Whether the viewer may create and delete bookmarks (write access).
19		can_delete: bool,
20		/// Whether the viewer may run the pipeline of a bookmark.
21		can_run: bool,
22		notice: Option<String>,
23		error: Option<String>,
24		}
25
26	16×	async fn bookmarks_page(
27	16×	app: &Shared,
28	16×	shell: Shell,
29	16×	repo: crate::repos::RepoName,
30	16×	row: db::repos::RepoRow,
31	16×	role: Role,
32	16×	notice: Option<String>,
33	16×	error: Option<String>,
34	16×	) -> Result<Page<BookmarksPage>, Error> {
35	16×	let default = row.default_bookmark.clone();
36	16×	let bookmarks =
37	16×	app.repos.read(&repo, move \|r, cache\| view::bookmarks(r, cache, &default)).await.map_err(\|e\| Error::from_repo(shell.clone(), e))?;
38	16×	let can_delete = shell.user.is_some() && role >= Role::Write;
39	16×	let can_run = super::flow::why_not_run(crate::flow::enabled(app, &row), shell.user.is_some(), role).is_none();
40	16×	Ok(Page(BookmarksPage {
41	16×	shell,
42	16×	repo: RepoShell::new(app, &row, "bookmarks").with_role(role),
43	16×	bookmarks,
44	16×	can_delete,
45	16×	can_run,
46	16×	notice,
47	16×	error,
48	16×	}))
49	16×	}
50
51	8×	pub async fn bookmarks(
52	8×	State(app): State<Shared>,
53	8×	viewer: Viewer,
54	8×	Path((owner, name)): Path<(String, String)>,
55	8×	) -> Result<Page<BookmarksPage>, Error> {
56	8×	let shell = Shell::new(&app, &format!("/{owner}/{name}/bookmarks"), &viewer);
57	8×	let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
58	8×	bookmarks_page(&app, shell, repo, row, role, None, None).await
59	8×	}
60
61		#[derive(Deserialize)]
62		pub struct DeleteBookmarkForm {
63		#[serde(rename = "_csrf")]
64		csrf_token: String,
65		bookmark: String,
66		}
67
68		/// Delete a bookmark from the web (hub spec §6.4): what `oxy push --delete`
69		/// does, through the same checks. Never the default bookmark; refused under
70		/// a trust policy, which needs a signed attestation only a client can make.
71	5×	pub async fn delete_bookmark(
72	5×	State(app): State<Shared>,
73	5×	viewer: Viewer,
74	5×	Path((owner, name)): Path<(String, String)>,
75	5×	Form(f): Form<DeleteBookmarkForm>,
76	5×	) -> Result<Page<BookmarksPage>, Error> {
77	5×	let shell = Shell::new(&app, &format!("/{owner}/{name}/bookmarks"), &viewer);
78	5×	let me = require(&viewer, &shell)?;
79	4×	let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;
80	4×	csrf(&viewer, &f.csrf_token, &shell)?;
81	4×	let bookmark = f.bookmark.trim().to_string();
82	4×	if bookmark == row.default_bookmark {
83	1×	let msg = format!("{bookmark} is the default bookmark; choose another default in Settings first.");
84	1×	return bookmarks_page(&app, shell, repo, row, role, None, Some(msg)).await;
85	3×	}
86	3×	let target = bookmark.clone();
87	3×	let outcome = app
88	3×	.repos
89	3×	.write(&repo, move \|r, _\| {
90	3×	let Some(state) = r.view()?.bookmarks.get(&target).copied() else {
91	1×	return Ok(Err(format!("There is no bookmark {target}.")));
92		};
93	2×	let update = oxy_core::protocol::RefUpdate {
94	2×	name: target.clone(),
95	2×	old_state: state,
96	2×	new_state: oxy_core::hash::ObjectRef::ZERO,
97	2×	force: true,
98	2×	attestation: None,
99	2×	};
100	2×	let report = r.receive_push_report(Default::default(), vec![update], None, vec![])?;
101	2×	Ok(match report.results.first() {
102	2×	Some(res) if res.ok => Ok(state.to_hex()),
103	0×	Some(res) => Err(res.reason.clone()),
104	0×	None => Err("nothing happened".into()),
105		})
106	3×	})
107	3×	.await
108	3×	.map_err(\|e\| Error::from_repo(shell.clone(), e))?;
109	3×	let old_state = match outcome {
110	2×	Ok(s) => s,
111	1×	Err(msg) => return bookmarks_page(&app, shell, repo, row, role, None, Some(format!("Could not delete {bookmark}: {msg}"))).await,
112		};
113	2×	let result = db::repos::PushOutcome {
114	2×	reference: bookmark.clone(),
115	2×	ok: true,
116	2×	reason: "deleted on the web".into(),
117	2×	old_state: old_state.clone(),
118	2×	new_state: oxy_core::hash::ObjectRef::ZERO.to_hex(),
119	2×	heads: 0,
120	2×	changes: 0,
121	2×	};
122	2×	db::repos::record_push(&app.db, row.id, Some((me.account.id, &me.account.username)), &[result]).await.ok();
123	2×	crate::hooks::emit(
124	2×	&app,
125	2×	&row,
126	2×	"push",
127	2×	&me.account.username,
128	2×	serde_json::json!({ "updates": [{ "reference": bookmark, "old_state": old_state, "new_state": oxy_core::hash::ObjectRef::ZERO.to_hex(), "heads": 0, "changes": 0, "deleted": true }], "via": "web" }),
129	2×	)
130	2×	.await;
131	2×	db::accounts::audit(&app.db, Some(&me.account), "bookmark.deleted", &format!("{owner}/{name}"), &bookmark).await.ok();
132	2×	bookmarks_page(
133	2×	&app,
134	2×	shell,
135	2×	repo,
136	2×	row,
137	2×	role,
138	2×	Some(format!("Deleted {bookmark}. Its changes stay while anything else reaches them.")),
139	2×	None,
140	2×	)
141	2×	.await
142	5×	}
143
144		#[derive(Deserialize)]
145		pub struct CreateBookmarkForm {
146		#[serde(rename = "_csrf")]
147		csrf_token: String,
148		name: String,
149		/// A bookmark, tag or change; the default bookmark when empty.
150		#[serde(default)]
151		from: String,
152		}
153
154		/// Create a bookmark from the web at the heads of a bookmark, tag or change:
155		/// what pushing a new bookmark does, signed by the hub key as the user's
156		/// delegate, as the web's other changes to bookmarks are.
157	4×	pub async fn create_bookmark(
158	4×	State(app): State<Shared>,
159	4×	viewer: Viewer,
160	4×	Path((owner, name)): Path<(String, String)>,
161	4×	Form(f): Form<CreateBookmarkForm>,
162	4×	) -> Result<Page<BookmarksPage>, Error> {
163	4×	let shell = Shell::new(&app, &format!("/{owner}/{name}/bookmarks"), &viewer);
164	4×	let me = require(&viewer, &shell)?;
165	4×	let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;
166	4×	csrf(&viewer, &f.csrf_token, &shell)?;
167	4×	let bookmark = f.name.trim().to_string();
168	4×	let from = match f.from.trim() {
169	4×	"" => row.default_bookmark.clone(),
170	3×	s => s.to_string(),
171		};
172	4×	if bookmark.is_empty() \|\| bookmark.chars().any(char::is_whitespace) {
173	1×	return bookmarks_page(&app, shell, repo, row, role, None, Some("A bookmark's name has no spaces.".into())).await;
174	3×	}
175	3×	let (wanted, spec) = (bookmark.clone(), from.clone());
176	3×	let found = app
177	3×	.repos
178	3×	.read(&repo, move \|r, cache\| {
179	3×	if r.view()?.bookmarks.contains_key(&wanted) {
180	1×	return Ok(Err(format!("{wanted} is a bookmark already.")));
181	2×	}
182	2×	Ok(view::resolve(r, cache, &spec).map(\|t\| t.heads).map_err(\|e\| e.to_string()))
183	3×	})
184	3×	.await
185	3×	.map_err(\|e\| Error::from_repo(shell.clone(), e))?;
186	1×	let heads = match found {
187	1×	Ok(heads) if !heads.is_empty() => heads,
188	0×	Ok(_) => return bookmarks_page(&app, shell, repo, row, role, None, Some(format!("{from} holds no changes to start from."))).await,
189	2×	Err(msg) => return bookmarks_page(&app, shell, repo, row, role, None, Some(msg)).await,
190		};
191		// As the user's delegate when they have one; otherwise unsigned, which
192		// a repository without a trust policy takes, as a push without one.
193	1×	let made = match super::edit::signer_for(&app, me.account.id).await {
194	0×	Ok(signer) => crate::repos::edits::move_bookmark(&app.repos, &repo, bookmark.clone(), heads.clone(), signer)
195	0×	.await
196	0×	.map(\|_\| ())
197	0×	.map_err(\|e\| e.to_string()),
198	1×	Err(why) => {
199	1×	let (target, at) = (bookmark.clone(), heads.clone());
200	1×	let unsigned = app
201	1×	.repos
202	1×	.write(&repo, move \|r, _\| {
203	1×	let update = r.host_ref_update(&target, &at, None)?;
204	1×	let report = r.receive_push_report(Default::default(), vec![update], None, vec![])?;
205	1×	Ok(match report.results.first() {
206	1×	Some(res) if res.ok => Ok(()),
207	0×	Some(res) => Err(res.reason.clone()),
208	0×	None => Err("nothing happened".to_string()),
209		})
210	1×	})
211	1×	.await
212	1×	.map_err(\|e\| e.to_string())
213	1×	.and_then(\|r\| r);
214	1×	unsigned.map_err(\|refused\| format!("{refused}. {why}"))
215		}
216		};
217	1×	if let Err(e) = made {
218	0×	return bookmarks_page(&app, shell, repo, row, role, None, Some(format!("Could not create {bookmark}: {e}"))).await;
219	1×	}
220	1×	let made = bookmark.clone();
221	1×	let new_state = app
222	1×	.repos
223	1×	.read(&repo, move \|r, _\| Ok(r.view()?.bookmarks.get(&made).map(\|s\| s.to_hex()).unwrap_or_default()))
224	1×	.await
225	1×	.unwrap_or_default();
226	1×	let result = db::repos::PushOutcome {
227	1×	reference: bookmark.clone(),
228	1×	ok: true,
229	1×	reason: format!("created on the web from {from}"),
230	1×	old_state: oxy_core::hash::ObjectRef::ZERO.to_hex(),
231	1×	new_state: new_state.clone(),
232	1×	heads: heads.len() as i64,
233	1×	changes: 0,
234	1×	};
235	1×	db::repos::record_push(&app.db, row.id, Some((me.account.id, &me.account.username)), &[result]).await.ok();
236	1×	crate::hooks::emit(
237	1×	&app,
238	1×	&row,
239	1×	"push",
240	1×	&me.account.username,
241	1×	serde_json::json!({ "updates": [{ "reference": bookmark, "old_state": oxy_core::hash::ObjectRef::ZERO.to_hex(), "new_state": new_state, "heads": heads.len(), "changes": 0, "created": true }], "via": "web" }),
242	1×	)
243	1×	.await;
244	1×	db::accounts::audit(&app.db, Some(&me.account), "bookmark.created", &format!("{owner}/{name}"), &format!("{bookmark} from {from}"))
245	1×	.await
246	1×	.ok();
247	1×	let notice = format!("Created {bookmark} from {from}. Propose changes into it, or make it the default in Settings.");
248	1×	bookmarks_page(&app, shell, repo, row, role, Some(notice), None).await
249	4×	}
250
251		#[derive(Template)]
252		#[template(path = "tags.html")]
253		pub struct TagsPage {
254		shell: Shell,
255		repo: RepoShell,
256		tags: Vec<view::TagView>,
257		withdrawn: Vec<view::WithdrawnView>,
258		/// Tags a release uses (not withdrawn while it does).
259		released: Vec<String>,
260		can_create: bool,
261		can_withdraw: bool,
262		notice: Option<String>,
263		error: Option<String>,
264		}
265
266		impl TagsPage {
267	25×	fn released(&self, tag: &str) -> bool {
268	25×	self.released.iter().any(\|t\| t == tag)
269	25×	}
270		}
271
272	9×	async fn tags_page(
273	9×	app: &Shared,
274	9×	shell: Shell,
275	9×	repo: crate::repos::RepoName,
276	9×	row: db::repos::RepoRow,
277	9×	role: Role,
278	9×	notice: Option<String>,
279	9×	error: Option<String>,
280	9×	) -> Result<Page<TagsPage>, Error> {
281	9×	let (tags, withdrawn) = app
282	9×	.repos
283	9×	.read(&repo, \|r, _\| Ok((view::tags(r)?, view::withdrawn_tags(r)?)))
284	9×	.await
285	9×	.map_err(\|e\| Error::from_repo(shell.clone(), e))?;
286	9×	let released = db::releases::list(&app.db, row.id).await.unwrap_or_default().into_iter().map(\|r\| r.tag).collect();
287	9×	let signed_in = shell.user.is_some();
288		Ok(Page(TagsPage {
289	9×	shell,
290	9×	repo: RepoShell::new(app, &row, "tags").with_role(role),
291	9×	tags,
292	9×	withdrawn,
293	9×	released,
294	9×	can_create: signed_in && role >= Role::Write,
295	9×	can_withdraw: signed_in && role >= Role::Maintain,
296	9×	notice,
297	9×	error,
298		}))
299	9×	}
300
301	3×	pub async fn tags(State(app): State<Shared>, viewer: Viewer, Path((owner, name)): Path<(String, String)>) -> Result<Page<TagsPage>, Error> {
302	3×	let shell = Shell::new(&app, &format!("/{owner}/{name}/tags"), &viewer);
303	3×	let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
304	3×	tags_page(&app, shell, repo, row, role, None, None).await
305	3×	}
306
307		#[derive(Deserialize)]
308		pub struct CreateTagForm {
309		#[serde(rename = "_csrf")]
310		csrf_token: String,
311		name: String,
312		#[serde(default)]
313		target: String,
314		#[serde(default)]
315		message: String,
316		}
317
318		/// Create a tag from the web (#295): signed by the hub key as the user's
319		/// delegate, under the policy, as `oxy tag create` and a push would be.
320	4×	pub async fn create_tag(
321	4×	State(app): State<Shared>,
322	4×	viewer: Viewer,
323	4×	Path((owner, name)): Path<(String, String)>,
324	4×	Form(f): Form<CreateTagForm>,
325	4×	) -> Result<Page<TagsPage>, Error> {
326	4×	let shell = Shell::new(&app, &format!("/{owner}/{name}/tags"), &viewer);
327	4×	let me = require(&viewer, &shell)?;
328	4×	let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;
329	4×	csrf(&viewer, &f.csrf_token, &shell)?;
330	4×	match crate::tags::create(&app, &row, &repo, &me.account, &f.name, &f.target, &f.message).await {
331	2×	Ok(t) => {
332	2×	let notice = format!(
333		"Tagged {} ({} head{}). Start a release from it under Releases.",
334		t.name,
335	2×	t.heads.len(),
336	2×	if t.heads.len() == 1 { "" } else { "s" }
337		);
338	2×	tags_page(&app, shell, repo, row, role, Some(notice), None).await
339		}
340	2×	Err(e) => tags_page(&app, shell, repo, row, role, None, Some(format!("Could not create the tag: {e}"))).await,
341		}
342	4×	}
343
344		#[derive(Deserialize)]
345		pub struct WithdrawTagForm {
346		#[serde(rename = "_csrf")]
347		csrf_token: String,
348		tag: String,
349		#[serde(default)]
350		reason: String,
351		}
352
353		/// Withdraw a tag from the web (#301), as `oxy push --delete tags/NAME`
354		/// does: a signed withdrawal, kept and logged. Maintainers only; never
355		/// while a release uses the tag.
356	2×	pub async fn withdraw_tag(
357	2×	State(app): State<Shared>,
358	2×	viewer: Viewer,
359	2×	Path((owner, name)): Path<(String, String)>,
360	2×	Form(f): Form<WithdrawTagForm>,
361	2×	) -> Result<Page<TagsPage>, Error> {
362	2×	let shell = Shell::new(&app, &format!("/{owner}/{name}/tags"), &viewer);
363	2×	let me = require(&viewer, &shell)?;
364	2×	let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;
365	2×	csrf(&viewer, &f.csrf_token, &shell)?;
366	2×	match crate::tags::withdraw(&app, &row, &repo, &me.account, &f.tag, &f.reason).await {
367	1×	Ok(t) => {
368	1×	let notice = format!("Withdrew {}. Clones drop it on their next fetch; the name is not used again.", t.name);
369	1×	tags_page(&app, shell, repo, row, role, Some(notice), None).await
370		}
371	1×	Err(e) => tags_page(&app, shell, repo, row, role, None, Some(format!("Could not withdraw {}: {e}", f.tag.trim()))).await,
372		}
373	2×	}
374
375		#[derive(Template)]
376		#[template(path = "conflicts.html")]
377		pub struct ConflictsPage {
378		shell: Shell,
379		repo: RepoShell,
380		conflicts: Vec<view::ConflictView>,
381		}
382
383	8×	pub async fn conflicts(
384	8×	State(app): State<Shared>,
385	8×	viewer: Viewer,
386	8×	Path((owner, name)): Path<(String, String)>,
387	8×	) -> Result<Page<ConflictsPage>, Error> {
388	8×	let shell = Shell::new(&app, &format!("/{owner}/{name}/conflicts"), &viewer);
389	8×	let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
390	8×	let conflicts = app.repos.read(&repo, view::conflicts).await.map_err(\|e\| Error::from_repo(shell.clone(), e))?;
391	8×	Ok(Page(ConflictsPage { shell, repo: RepoShell::new(&app, &row, "conflicts").with_role(role).with_sky(&app, &row).await, conflicts }))
392	8×	}
393
394		#[derive(Template)]
395		#[template(path = "trust.html")]
396		pub struct TrustPage {
397		shell: Shell,
398		repo: RepoShell,
399		t: view::Trust,
400		}
401
402	2×	pub async fn trust(
403	2×	State(app): State<Shared>,
404	2×	viewer: Viewer,
405	2×	Path((owner, name)): Path<(String, String)>,
406	2×	) -> Result<Page<TrustPage>, Error> {
407	2×	let shell = Shell::new(&app, &format!("/{owner}/{name}/trust"), &viewer);
408	2×	let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
409	2×	let key = app.hub_key.key;
410	2×	let t = app.repos.read(&repo, move \|r, cache\| view::trust(r, cache, &key)).await.map_err(\|e\| Error::from_repo(shell.clone(), e))?;
411	2×	Ok(Page(TrustPage { shell, repo: RepoShell::new(&app, &row, "trust").with_role(role), t }))
412	2×	}
413
414		#[derive(Template)]
415		#[template(path = "pushes.html")]
416		pub struct PushesPage {
417		shell: Shell,
418		repo: RepoShell,
419		pushes: Vec<db::repos::PushRow>,
420		}
421
422	6×	pub async fn pushes(
423	6×	State(app): State<Shared>,
424	6×	viewer: Viewer,
425	6×	Path((owner, name)): Path<(String, String)>,
426	6×	) -> Result<Page<PushesPage>, Error> {
427	6×	let shell = Shell::new(&app, &format!("/{owner}/{name}/pushes"), &viewer);
428	6×	let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
429	6×	let pushes = db::repos::pushes(&app.db, row.id, 200).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
430	6×	Ok(Page(PushesPage { shell, repo: RepoShell::new(&app, &row, "pushes").with_role(role), pushes }))
431	6×	}

Coverage / crates/hub/src/web/refs.rs 93.7%

Keyboard