OXYGENHUB
# d4792b4a4629 oxygenhub / crates / hub / src / web / proposals.rs
58.6 KiB · Rust · last changed Proposal page: edit in place from a pencil and a ··· menu; one action row; landed card 1 month ago source blame history raw
1 
//! Proposal pages (hub spec §7): list, new, detail with conversation,
2 
//! changes and files, comments anchored to atoms, reviews, landing.
3
4 
use super::history::{render_files, FileRows};
5 
use super::settings::{csrf, require};
6 
use super::{filters, lookup, lookup_role, Error, Page, RepoShell, Shell};
7 
use crate::auth::{Access, Role, Viewer};
8 
use crate::db::{self, accounts, proposals as pdb};
9 
use crate::render::{self, diff};
10 
use crate::repos::proposals::{self as pl, Projection, Source};
11 
use crate::repos::view::{self, ChangeView, ConflictView};
12 
use crate::repos::RepoName;
13 
use crate::Shared;
14 
use askama::Template;
15 
use axum::extract::{Form, Path, Query, State};
16 
use axum::response::{IntoResponse, Redirect, Response};
17 
use hub_api::{Approval, ProposalSource, ProposalState};
18 
use oxy_core::hash::ChangeHash;
19 
use serde::Deserialize;
20 
use std::collections::{BTreeMap, HashMap};
21
22 
// ------------------------------------------------------------------ list
23
24 
#[derive(Template)]
25 
#[template(path = "proposals.html")]
26 
pub struct ProposalsPage {
27 
    shell: Shell,
28 
    repo: RepoShell,
29 
    rows: Vec<pdb::ProposalRow>,
30 
    filter: String,
31 
    counts: (usize, usize, usize),
32 
    bookmarks: Vec<String>,
33 
    q: String,
34 
    sort: String,
35 
    pager: super::Pager,
36 
    labels: std::collections::HashMap<i64, Vec<db::issues::Label>>,
37 
}
38
39 
impl ProposalsPage {
40 
    fn labels_of(&self, id: &i64) -> &[db::issues::Label] {
41 
        self.labels.get(id).map(Vec::as_slice).unwrap_or(&[])
42 
    }
43 
}
44
45 
#[derive(Deserialize)]
46 
pub struct ListQuery {
47 
    state: Option<String>,
48 
    q: Option<String>,
49 
    sort: Option<String>,
50 
    page: Option<usize>,
51 
}
52
53 
/// The list's sort orders.
54 
pub const SORTS: &[(&str, &str)] = &[("updated", "recently updated"), ("newest", "newest"), ("oldest", "oldest")];
55
56 
pub async fn list(
57 
    State(app): State<Shared>,
58 
    viewer: Viewer,
59 
    Path((owner, name)): Path<(String, String)>,
60 
    Query(q): Query<ListQuery>,
61 
) -> Result<Page<ProposalsPage>, Error> {
62 
    let shell = Shell::new(&app, &format!("/{owner}/{name}/proposals"), &viewer);
63 
    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
64 
    let all = pdb::list(&app.db, row.id, &[]).await.map_err(|e| Error::from_db(shell.clone(), e))?;
65 
    let counts = (
66 
        all.iter().filter(|p| p.is_open()).count(),
67 
        all.iter().filter(|p| p.state == "landed").count(),
68 
        all.iter().filter(|p| p.state == "closed").count(),
69 
    );
70 
    let filter = q.state.unwrap_or_else(|| "open".into());
71 
    let mut labels: std::collections::HashMap<i64, Vec<db::issues::Label>> = std::collections::HashMap::new();
72 
    for (id, l) in db::issues::labels_by_proposal(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))? {
73 
        labels.entry(id).or_default().push(l);
74 
    }
75 
    // `author:bob label:ui target:main words…`
76 
    let qtext = q.q.clone().unwrap_or_default();
77 
    let (mut authors, mut wanted, mut targets, mut words) = (vec![], vec![], vec![], vec![]);
78 
    for tok in qtext.split_whitespace() {
79 
        match tok.split_once(':') {
80 
            Some(("author", v)) => authors.push(v.to_lowercase()),
81 
            Some(("label", v)) => wanted.push(v.to_lowercase()),
82 
            Some(("target", v)) => targets.push(v.to_string()),
83 
            _ => words.push(tok.to_lowercase()),
84 
        }
85 
    }
86 
    let mut rows: Vec<pdb::ProposalRow> = all
87 
        .into_iter()
88 
        .filter(|p| match filter.as_str() {
89 
            "open" => p.is_open(),
90 
            "landed" => p.state == "landed",
91 
            "closed" => p.state == "closed",
92 
            _ => true,
93 
        })
94 
        .filter(|p| authors.is_empty() || authors.contains(&p.author.to_lowercase()))
95 
        .filter(|p| targets.is_empty() || targets.contains(&p.target))
96 
        .filter(|p| wanted.iter().all(|w| labels.get(&p.id).is_some_and(|ls| ls.iter().any(|l| l.name.to_lowercase() == *w))))
97 
        .filter(|p| words.iter().all(|w| p.title.to_lowercase().contains(w) || p.body.to_lowercase().contains(w)))
98 
        .collect();
99 
    let sort = q.sort.filter(|s| SORTS.iter().any(|(k, _)| k == s)).unwrap_or_else(|| "updated".into());
100 
    match sort.as_str() {
101 
        "newest" => rows.sort_by_key(|p| std::cmp::Reverse(p.number)),
102 
        "oldest" => rows.sort_by_key(|p| p.number),
103 
        _ => rows.sort_by_key(|p| std::cmp::Reverse(p.updated_ms)),
104 
    }
105 
    let pager = super::Pager::new(rows.len(), q.page, &[("state", &filter), ("q", &qtext), ("sort", &sort)]);
106 
    let rows = pager.slice(rows);
107 
    let bookmarks = app
108 
        .repos
109 
        .read(&repo, |r, _| Ok(r.bookmarks()?.into_iter().map(|b| b.name).collect::<Vec<_>>()))
110 
        .await
111 
        .map_err(|e| Error::from_repo(shell.clone(), e))?;
112 
    Ok(Page(ProposalsPage {
113 
        shell,
114 
        repo: RepoShell::new(&app, &row, "proposals").with_role(role),
115 
        rows,
116 
        filter,
117 
        counts,
118 
        bookmarks,
119 
        q: qtext,
120 
        sort,
121 
        pager,
122 
        labels,
123 
    }))
124 
}
125
126 
// ------------------------------------------------------------------- new
127
128 
#[derive(Template)]
129 
#[template(path = "proposal_new.html")]
130 
pub struct NewProposalPage {
131 
    shell: Shell,
132 
    repo: RepoShell,
133 
    bookmarks: Vec<String>,
134 
    source: String,
135 
    target: String,
136 
    error: Option<String>,
137 
    /// Preview: the changes the proposal would add.
138 
    preview: Vec<ChangeView>,
139 
    conflicted: bool,
140 
}
141
142 
#[derive(Deserialize)]
143 
pub struct NewQuery {
144 
    source: Option<String>,
145 
    target: Option<String>,
146 
}
147
148 
/// `owner/name:bookmark` for a fork, else a bookmark of this repository.
149 
/// A proposal's source: a bookmark of this repository by name (which may
150 
/// hold `/`, as `feature/16-hud` does), or `owner/name:bookmark` of a fork;
151 
/// `owner/name:bookmark` naming this repository is its own bookmark.
152 
fn parse_source(app: &Shared, repo: &RepoName, source: &str) -> Option<(Option<RepoName>, String)> {
153 
    let plain = |b: &str| !b.is_empty() && !b.chars().any(|c| c.is_control() || c == ':');
154 
    if let Some((slug, bookmark)) = source.split_once(':') {
155 
        let fork = RepoName::parse(slug)?;
156 
        if !plain(bookmark) {
157 
            return None;
158 
        }
159 
        if fork == *repo {
160 
            return Some((None, bookmark.to_string()));
161 
        }
162 
        if !app.repos.exists(&fork) {
163 
            return None;
164 
        }
165 
        return Some((Some(fork), bookmark.to_string()));
166 
    }
167 
    plain(source).then(|| (None, source.to_string()))
168 
}
169
170 
async fn preview_for(
171 
    app: &Shared,
172 
    repo: &RepoName,
173 
    target: &str,
174 
    source: &str,
175 
) -> Result<(Vec<ChangeView>, bool), crate::repos::RepoError> {
176 
    let Some((fork, bookmark)) = parse_source(app, repo, source) else { return Ok((vec![], false)) };
177 
    let target = target.to_string();
178 
    let fork_dir = fork.as_ref().map(|f| app.repos.dir(f));
179 
    app.repos
180 
        .read(repo, move |r, cache| {
181 
            let projection = match &fork_dir {
182 
                Some(dir) => {
183 
                    let fork_repo = oxy_core::repo::Repo::open(dir)?;
184 
                    let heads = fork_repo.bookmarks()?.into_iter().find(|b| b.name == bookmark).map(|b| b.heads).unwrap_or_default();
185 
                    pl::project(r, cache, &target, Source::Fork { fork: &fork_repo, heads })?
186 
                }
187 
                None => {
188 
                    let heads = r.bookmarks()?.into_iter().find(|b| b.name == bookmark).map(|b| b.heads).unwrap_or_default();
189 
                    pl::project(r, cache, &target, Source::Bookmark(heads))?
190 
                }
191 
            };
192 
            Ok((projection.changes, projection.conflicted))
193 
        })
194 
        .await
195 
}
196
197 
pub async fn new_form(
198 
    State(app): State<Shared>,
199 
    viewer: Viewer,
200 
    Path((owner, name)): Path<(String, String)>,
201 
    Query(q): Query<NewQuery>,
202 
) -> Result<Page<NewProposalPage>, Error> {
203 
    let shell = Shell::new(&app, &format!("/{owner}/{name}/proposals/new"), &viewer);
204 
    require(&viewer, &shell)?;
205 
    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
206 
    let bookmarks = app
207 
        .repos
208 
        .read(&repo, |r, _| Ok(r.bookmarks()?.into_iter().map(|b| b.name).collect::<Vec<_>>()))
209 
        .await
210 
        .map_err(|e| Error::from_repo(shell.clone(), e))?;
211 
    let target = q.target.unwrap_or_else(|| row.default_bookmark.clone());
212 
    let source = q.source.unwrap_or_default();
213 
    let (preview, conflicted) =
214 
        if source.is_empty() { (vec![], false) } else { preview_for(&app, &repo, &target, &source).await.unwrap_or((vec![], false)) };
215 
    Ok(Page(NewProposalPage {
216 
        shell,
217 
        repo: RepoShell::new(&app, &row, "proposals").with_role(role),
218 
        bookmarks,
219 
        source,
220 
        target,
221 
        error: None,
222 
        preview,
223 
        conflicted,
224 
    }))
225 
}
226
227 
#[derive(Deserialize)]
228 
pub struct NewForm {
229 
    #[serde(rename = "_csrf")]
230 
    csrf_token: String,
231 
    title: String,
232 
    #[serde(default)]
233 
    body: String,
234 
    target: String,
235 
    source: String,
236 
    #[serde(default)]
237 
    draft: Option<String>,
238 
}
239
240 
/// Open a proposal from a form or the API: validate, create, index, notify.
241 
#[allow(clippy::too_many_arguments)]
242 
pub async fn open_proposal(
243 
    app: &Shared,
244 
    repo: &RepoName,
245 
    row: &db::repos::RepoRow,
246 
    me: &accounts::Account,
247 
    title: &str,
248 
    body: &str,
249 
    target: &str,
250 
    source: &str,
251 
    draft: bool,
252 
) -> Result<pdb::ProposalRow, String> {
253 
    if title.trim().is_empty() {
254 
        return Err("Give the proposal a title.".into());
255 
    }
256 
    let bookmarks =
257 
        app.repos.read(repo, |r, _| Ok(r.bookmarks()?.into_iter().map(|b| b.name).collect::<Vec<_>>())).await.map_err(|e| e.to_string())?;
258 
    if !bookmarks.iter().any(|b| b == target) {
259 
        return Err("Pick a target bookmark of this repository.".into());
260 
    }
261 
    let Some((fork, bookmark)) = parse_source(app, repo, source.trim()) else {
262 
        return Err("The source is a bookmark of this repository, or owner/name:bookmark of a fork.".into());
263 
    };
264 
    if fork.is_none() && !bookmarks.contains(&bookmark) {
265 
        return Err(format!("There is no bookmark {bookmark} in this repository."));
266 
    }
267 
    if fork.is_none() && bookmark == target {
268 
        return Err("The source and the target are the same bookmark.".into());
269 
    }
270 
    let (preview, _) = preview_for(app, repo, target, source.trim()).await.map_err(|e| e.to_string())?;
271 
    if preview.is_empty() {
272 
        return Err("The source adds nothing to the target.".into());
273 
    }
274 
    let source_repo_id = match &fork {
275 
        Some(fk) => db::repos::get(&app.db, &fk.owner, &fk.name).await.map_err(|e| e.to_string())?.map(|r| r.id),
276 
        None => None,
277 
    };
278 
    let created = pdb::create(
279 
        &app.db,
280 
        pdb::NewProposal {
281 
            repo_id: row.id,
282 
            title: title.trim(),
283 
            body: body.trim(),
284 
            author_id: Some(me.id),
285 
            author: &me.username,
286 
            draft,
287 
            target,
288 
            source_kind: if fork.is_some() { "fork" } else { "bookmark" },
289 
            source_repo_id,
290 
            source_bookmark: &bookmark,
291 
            source_changes: "",
292 
        },
293 
    )
294 
    .await
295 
    .map_err(|e| e.to_string())?;
296 
    pdb::add_event(&app.db, created.id, &me.username, "opened", "").await.ok();
297 
    accounts::audit(&app.db, Some(me), "proposal.opened", &format!("{}#{}", row.slug(), created.number), title).await.ok();
298 
    db::notify::index(&app.db, "proposal", row.id, created.id, created.number, &created.title, &created.body).await.ok();
299 
    let url = format!("/{}/proposal/{}", row.slug(), created.number);
300 
    crate::notify::deliver(
301 
        app,
302 
        crate::notify::Event {
303 
            kind: "proposal.opened",
304 
            title: format!("{}#{}: {}", row.slug(), created.number, created.title),
305 
            url,
306 
            actor: me,
307 
            repo_id: row.id,
308 
            thread: Some(("proposal", created.id)),
309 
            mention_text: body,
310 
            direct: vec![],
311 
        },
312 
    )
313 
    .await;
314 
    crate::hooks::emit(
315 
        app,
316 
        row,
317 
        "proposal.opened",
318 
        &me.username,
319 
        serde_json::json!({ "number": created.number, "title": created.title, "target": target, "source": source }),
320 
    )
321 
    .await;
322 
    Ok(created)
323 
}
324
325 
pub async fn create(
326 
    State(app): State<Shared>,
327 
    viewer: Viewer,
328 
    Path((owner, name)): Path<(String, String)>,
329 
    Form(f): Form<NewForm>,
330 
) -> Result<Response, Error> {
331 
    let shell = Shell::new(&app, &format!("/{owner}/{name}/proposals/new"), &viewer);
332 
    let me = require(&viewer, &shell)?;
333 
    csrf(&viewer, &f.csrf_token, &shell)?;
334 
    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
335 
    match open_proposal(&app, &repo, &row, &me.account, &f.title, &f.body, &f.target, &f.source, f.draft.is_some()).await {
336 
        Ok(created) => Ok(Redirect::to(&format!("/{owner}/{name}/proposal/{}", created.number)).into_response()),
337 
        Err(msg) => {
338 
            let bookmarks =
339 
                app.repos.read(&repo, |r, _| Ok(r.bookmarks()?.into_iter().map(|b| b.name).collect::<Vec<_>>())).await.unwrap_or_default();
340 
            Ok(Page(NewProposalPage {
341 
                shell,
342 
                repo: RepoShell::new(&app, &row, "proposals").with_role(role),
343 
                bookmarks,
344 
                source: f.source.clone(),
345 
                target: f.target.clone(),
346 
                error: Some(msg),
347 
                preview: vec![],
348 
                conflicted: false,
349 
            })
350 
            .into_response())
351 
        }
352 
    }
353 
}
354
355 
// ---------------------------------------------------------------- detail
356
357 
/// A comment placed on a diff row, or general.
358 
pub struct CommentView {
359 
    pub row: pdb::CommentRow,
360 
    pub body_html: String,
361 
    pub line: Option<usize>,
362 
}
363
364 
/// One entry of a proposal's conversation, in time order: what kind it
365 
/// is and its index in `comments`, `reviews` or `events`.
366 
pub struct Entry {
367 
    pub kind: &'static str,
368 
    pub index: usize,
369 
}
370
371 
pub struct ReviewView {
372 
    pub row: pdb::ReviewRow,
373 
    pub body_html: String,
374 
    pub sealed: bool,
375 
}
376
377 
/// Everything the detail page and the API need, computed once under the lock.
378 
pub struct Loaded {
379 
    pub row: pdb::ProposalRow,
380 
    pub changes: Vec<ChangeView>,
381 
    pub hashes: Vec<ChangeHash>,
382 
    pub heads: Vec<ChangeHash>,
383 
    pub target_heads: Vec<ChangeHash>,
384 
    pub state: String,
385 
    pub target_state: String,
386 
    pub conflicted: bool,
387 
    pub conflicts: Vec<ConflictView>,
388 
    pub files: Vec<FileRows>,
389 
    /// The per-file hunks and bases behind `files`, to render again with other options.
390 
    pub diffs: Vec<oxy_core::repo::FileDiff>,
391 
    pub bases: std::collections::BTreeMap<String, Vec<u8>>,
392 
    /// Atom per (path, new line number) of the projected state.
393 
    pub atoms: HashMap<(String, usize), (String, u32)>,
394 
    pub sealing_keys: Vec<String>,
395 
    pub touched: Vec<String>,
396 
    pub owners: Vec<String>,
397 
    pub landed_already: bool,
398 
}
399
400 
/// Compute the projection and everything derived from it.
401 
pub async fn load(app: &Shared, repo: &RepoName, row: pdb::ProposalRow) -> Result<Loaded, crate::repos::RepoError> {
402 
    let fork_dir = match (row.source_kind.as_str(), row.source_repo_id) {
403 
        ("fork", Some(id)) => {
404 
            db::repos::get_by_id(&app.db, id).await.ok().flatten().and_then(|r| RepoName::new(&r.owner, &r.name)).map(|n| app.repos.dir(&n))
405 
        }
406 
        _ => None,
407 
    };
408 
    let r2 = row.clone();
409 
    let loaded = app
410 
        .repos
411 
        .read(repo, move |r, cache| {
412 
            let source = match (r2.source_kind.as_str(), &fork_dir) {
413 
                ("changes", _) => Source::Changes(r2.source_changes().iter().filter_map(|h| ChangeHash::from_hex(h)).collect()),
414 
                ("fork", Some(dir)) => {
415 
                    let fork_repo = oxy_core::repo::Repo::open(dir)?;
416 
                    let heads =
417 
                        fork_repo.bookmarks()?.into_iter().find(|b| b.name == r2.source_bookmark).map(|b| b.heads).unwrap_or_default();
418 
                    // Bring the fork's changes over now, so the projection below can read them.
419 
                    let fork_state = fork_repo.load_state(&heads)?;
420 
                    let missing: Vec<ChangeHash> = fork_state.changes().map(|(h, _)| *h).filter(|h| !r.store().has(h)).collect();
421 
                    if !missing.is_empty() {
422 
                        r.import_bundle(&fork_repo.bundle_for(&missing)?, r.current_policy()?.is_some())?;
423 
                    }
424 
                    Source::Changes(heads)
425 
                }
426 
                _ => {
427 
                    let heads = r.bookmarks()?.into_iter().find(|b| b.name == r2.source_bookmark).map(|b| b.heads).unwrap_or_default();
428 
                    Source::Bookmark(heads)
429 
                }
430 
            };
431 
            let p: Projection = pl::project(r, cache, &r2.target, source)?;
432 
            let target_loaded = cache.load(r, &p.target_heads)?;
433 
            let files = render_files(&p.files, &p.bases);
434 
            let mut atoms = HashMap::new();
435 
            for f in &files {
436 
                for l in &f.lines {
437 
                    if let Some(n) = l.new_no {
438 
                        if let Some((h, i)) = pl::atom_at(&p.loaded, &f.path, n as usize) {
439 
                            atoms.insert((f.path.clone(), n as usize), (h.to_hex(), i));
440 
                        }
441 
                    }
442 
                }
443 
            }
444 
            let touched: Vec<String> = p.files.iter().map(|f| f.path.clone()).collect();
445 
            let owners = pl::owners_for(&target_loaded, &touched);
446 
            let sealing = pl::sealing_keys(r, &p.hashes)?.into_iter().map(|k| k.to_hex()).collect();
447 
            let landed_already = !p.hashes.is_empty() && p.hashes.iter().all(|h| target_loaded.state.contains(h));
448 
            // A landed proposal's changes are in its target now: it shows
449 
            // the ones it landed, as recorded when it landed.
450 
            let (changes, hashes) = if r2.state == "landed" && p.hashes.is_empty() {
451 
                let hashes: Vec<ChangeHash> = r2.projected_changes().iter().filter_map(|h| ChangeHash::from_hex(h)).collect();
452 
                let labels = HashMap::new();
453 
                let changes = hashes
454 
                    .iter()
455 
                    .filter_map(|h| Some(view::change_view_pub(r, h, &r.store().get_change_meta(h).ok()?, false, &labels)))
456 
                    .collect();
457 
                (changes, hashes)
458 
            } else {
459 
                (p.changes, p.hashes)
460 
            };
461 
            Ok(Loaded {
462 
                row: r2,
463 
                changes,
464 
                hashes,
465 
                heads: p.heads,
466 
                target_heads: p.target_heads.clone(),
467 
                state: p.state.to_hex(),
468 
                target_state: p.target_state.to_hex(),
469 
                conflicted: p.conflicted,
470 
                conflicts: p.conflicts,
471 
                files,
472 
                diffs: p.files.clone(),
473 
                bases: p.bases.clone(),
474 
                atoms,
475 
                sealing_keys: sealing,
476 
                touched,
477 
                owners,
478 
                landed_already,
479 
            })
480 
        })
481 
        .await?;
482 
    // Remember the projection for the list, the API and other proposals'
483 
    // stacking checks, while the proposal is open: a landed one keeps what
484 
    // it landed.
485 
    if !loaded.row.is_open() {
486 
        return Ok(loaded);
487 
    }
488 
    let heads_csv = loaded.heads.iter().map(|h| h.to_hex()).collect::<Vec<_>>().join(",");
489 
    let changes_csv = loaded.hashes.iter().map(|h| h.to_hex()).collect::<Vec<_>>().join(",");
490 
    pdb::set_projection(&app.db, loaded.row.id, &loaded.state, &heads_csv, &loaded.target_state, &changes_csv, loaded.conflicted)
491 
        .await
492 
        .ok();
493 
    Ok(loaded)
494 
}
495
496 
/// Reviews, approvals and blockers.
497 
pub struct Verdict {
498 
    pub reviews: Vec<ReviewView>,
499 
    pub approvals: Vec<Approval>,
500 
    pub blockers: Vec<String>,
501 
    pub depends_on: Vec<i64>,
502 
    pub requirements: pdb::Requirements,
503 
}
504
505 
pub async fn verdict(app: &Shared, loaded: &Loaded, repo_id: i64) -> Result<Verdict, sqlx::Error> {
506 
    let rows = pdb::reviews(&app.db, loaded.row.id).await?;
507 
    let links = accounts::identity_accounts(&app.db).await?;
508 
    let sealed_accounts: Vec<String> = links.iter().filter(|(k, _)| loaded.sealing_keys.contains(k)).map(|(_, u)| u.clone()).collect();
509 
    // Latest verdict per reviewer.
510 
    let mut latest: BTreeMap<String, &pdb::ReviewRow> = BTreeMap::new();
511 
    for r in &rows {
512 
        latest.insert(r.author.clone(), r);
513 
    }
514 
    let mut approvals = Vec::new();
515 
    for (who, r) in &latest {
516 
        if r.verdict == "approve" {
517 
            let sealed = sealed_accounts.contains(who);
518 
            let key = links.iter().find(|(k, u)| u == who && loaded.sealing_keys.contains(k)).map(|(k, _)| k.clone());
519 
            approvals.push(Approval { account: who.clone(), sealed, key });
520 
        }
521 
    }
522 
    let reviews = rows
523 
        .iter()
524 
        .map(|r| ReviewView {
525 
            row: r.clone(),
526 
            body_html: render::markdown::render(&r.body, "/", "/"),
527 
            sealed: r.verdict == "approve" && sealed_accounts.contains(&r.author),
528 
        })
529 
        .collect();
530 
    let requirements = pdb::requirements(&app.db, repo_id).await?;
531 
    let mut blockers = Vec::new();
532 
    // Only an open proposal can be held back.
533 
    if !loaded.row.is_open() {
534 
        return Ok(Verdict { reviews, approvals, blockers, depends_on: vec![], requirements });
535 
    }
536 
    if loaded.row.state == "draft" {
537 
        blockers.push("the proposal is a draft".into());
538 
    }
539 
    if loaded.hashes.is_empty() {
540 
        blockers.push("the proposal adds no changes".into());
541 
    }
542 
    let sealed_count = approvals.iter().filter(|a| a.sealed).count() as i64;
543 
    if sealed_count < requirements.required_approvals {
544 
        blockers.push(format!("{sealed_count} of {} required sealed approvals", requirements.required_approvals));
545 
    }
546 
    if requirements.require_owners {
547 
        let missing: Vec<&String> = loaded.owners.iter().filter(|o| !approvals.iter().any(|a| a.sealed && &a.account == *o)).collect();
548 
        if !missing.is_empty() {
549 
            blockers.push(format!("code owners still to approve: {}", missing.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(", ")));
550 
        }
551 
    }
552 
    if loaded.conflicted && !requirements.allow_conflicts {
553 
        blockers.push("landing would carry conflicts, which this repository refuses".into());
554 
    }
555 
    let required = db::hooks::required_checks(&app.db, repo_id).await?;
556 
    if !required.is_empty() {
557 
        let checks = db::hooks::checks_for_state(&app.db, repo_id, &loaded.state).await?;
558 
        let missing: Vec<String> =
559 
            required.iter().filter(|n| !checks.iter().any(|c| &c.name == *n && c.status == "passed")).cloned().collect();
560 
        if !missing.is_empty() {
561 
            blockers.push(format!("required checks not passed on the projected state: {}", missing.join(", ")));
562 
        }
563 
    }
564 
    let requesting: Vec<&String> = latest.iter().filter(|(_, r)| r.verdict == "changes").map(|(who, _)| who).collect();
565 
    if !requesting.is_empty() {
566 
        blockers.push(format!("changes requested by {}", requesting.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(", ")));
567 
    }
568 
    // Stacking: another open, earlier proposal whose changes this one includes.
569 
    let mut depends_on = Vec::new();
570 
    for other in pdb::list(&app.db, repo_id, &["open", "draft"]).await? {
571 
        if other.id == loaded.row.id || other.number > loaded.row.number {
572 
            continue;
573 
        }
574 
        let theirs = other.projected_changes();
575 
        if !theirs.is_empty() && theirs.iter().all(|h| loaded.hashes.iter().any(|m| m.to_hex() == *h)) {
576 
            depends_on.push(other.number);
577 
        }
578 
    }
579 
    if !depends_on.is_empty() {
580 
        blockers.push(format!("depends on {}", depends_on.iter().map(|n| format!("#{n}")).collect::<Vec<_>>().join(", ")));
581 
    }
582 
    Ok(Verdict { reviews, approvals, blockers, depends_on, requirements })
583 
}
584
585 
#[derive(Template)]
586 
#[template(path = "proposal.html")]
587 
pub struct ProposalPage {
588 
    shell: Shell,
589 
    repo: RepoShell,
590 
    p: pdb::ProposalRow,
591 
    /// Issues it closes, from its description and its changes.
592 
    closes: Vec<super::chain::Link>,
593 
    /// Projects the viewer may add it to.
594 
    project_choices: Option<Vec<db::projects::Project>>,
595 
    /// Comments (not anchored to a line), reviews and events, oldest first.
596 
    timeline: Vec<Entry>,
597 
    /// The viewer may set labels (triage or above).
598 
    can_triage: bool,
599 
    body_html: String,
600 
    tab: String,
601 
    changes: Vec<ChangeView>,
602 
    files: Vec<FileRows>,
603 
    diffs: Vec<oxy_core::repo::FileDiff>,
604 
    bases: std::collections::BTreeMap<String, Vec<u8>>,
605 
    /// Whitespace-only changes are hidden (`?w=1`).
606 
    ignore_ws: bool,
607 
    conflicts: Vec<ConflictView>,
608 
    conflicted: bool,
609 
    comments: Vec<CommentView>,
610 
    /// Anchored comments by (path, current line).
611 
    placed: HashMap<(String, usize), Vec<usize>>,
612 
    outdated: Vec<usize>,
613 
    reviews: Vec<ReviewView>,
614 
    approvals: Vec<Approval>,
615 
    blockers: Vec<String>,
616 
    depends_on: Vec<i64>,
617 
    events: Vec<pdb::EventRow>,
618 
    owners: Vec<String>,
619 
    requirements: pdb::Requirements,
620 
    landed_already: bool,
621 
    can_edit: bool,
622 
    /// The landed proposal's source bookmark, when it is this repository's,
623 
    /// still there, and the viewer may delete it (oxygenhub#86).
624 
    deletable_source: Option<String>,
625 
    can_land: bool,
626 
    hub_can_land: bool,
627 
    notice: Option<String>,
628 
    error: Option<String>,
629 
    heads: Vec<String>,
630 
    state_hash: String,
631 
    source_label: String,
632 
    api_url: String,
633 
    labels: Vec<db::issues::Label>,
634 
    all_labels: Vec<db::issues::Label>,
635 
    checks: Vec<db::hooks::Check>,
636 
    required_checks: Vec<String>,
637 
    /// Projects this proposal is on that the viewer may see, with the column.
638 
    projects: Vec<(db::projects::Project, String)>,
639 
    /// Asked to review and not yet reviewing.
640 
    requested: Vec<String>,
641 
    /// Who can be asked to review, for the sidebar's menu (oxygenhub#84).
642 
    reviewable: Vec<String>,
643 
    /// The viewer may ask for reviews (the author, or a writer).
644 
    can_request: bool,
645 
}
646
647 
#[derive(Deserialize)]
648 
pub struct DetailQuery {
649 
    tab: Option<String>,
650 
    /// What an action said, after it redirected here.
651 
    #[serde(default)]
652 
    notice: Option<String>,
653 
    #[serde(default)]
654 
    error: Option<String>,
655 
    #[serde(default)]
656 
    w: Option<String>,
657 
}
658
659 
/// The page assembler every action ends in; its arguments are the route
660 
/// plus what to say, and a struct would only rename them.
661 
#[allow(clippy::too_many_arguments)]
662 
async fn detail(
663 
    app: &Shared,
664 
    shell: Shell,
665 
    viewer: &Viewer,
666 
    owner: &str,
667 
    name: &str,
668 
    number: i64,
669 
    tab: String,
670 
    notice: Option<String>,
671 
    error: Option<String>,
672 
) -> Result<Page<ProposalPage>, Error> {
673 
    let (repo, row, role) = lookup(app, &shell, viewer, owner, name).await?;
674 
    let p = pdb::get(&app.db, row.id, number)
675 
        .await
676 
        .map_err(|e| Error::from_db(shell.clone(), e))?
677 
        .ok_or_else(|| Error::not_found(shell.clone()))?;
678 
    let loaded = load(app, &repo, p).await.map_err(|e| Error::from_repo(shell.clone(), e))?;
679 
    // A proposal whose changes all reached the target landed by another route.
680 
    if loaded.landed_already && loaded.row.is_open() {
681 
        pdb::set_state(&app.db, loaded.row.id, "landed", &loaded.target_state).await.ok();
682 
        pdb::add_event(&app.db, loaded.row.id, "", "landed", "every change reached the target").await.ok();
683 
    }
684 
    let p = pdb::get(&app.db, row.id, number).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(loaded.row.clone());
685 
    let v = verdict(app, &loaded, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
686 
    let comment_rows = pdb::comments(&app.db, loaded.row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
687 
    let events = pdb::events(&app.db, loaded.row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
688 
    // Place anchored comments at their atom's current line.
689 
    let mut by_atom: HashMap<(String, String, u32), usize> = HashMap::new();
690 
    for ((path, line), (h, i)) in &loaded.atoms {
691 
        by_atom.insert((path.clone(), h.clone(), *i), *line);
692 
    }
693 
    let mut comments = Vec::new();
694 
    let mut placed: HashMap<(String, usize), Vec<usize>> = HashMap::new();
695 
    let mut outdated = Vec::new();
696 
    for (idx, c) in comment_rows.into_iter().enumerate() {
697 
        let line = if c.anchor_change.is_empty() {
698 
            None
699 
        } else {
700 
            by_atom.get(&(c.path.clone(), c.anchor_change.clone(), c.anchor_index as u32)).copied()
701 
        };
702 
        if !c.anchor_change.is_empty() {
703 
            match line {
704 
                Some(l) => placed.entry((c.path.clone(), l)).or_default().push(idx),
705 
                None => outdated.push(idx),
706 
            }
707 
        }
708 
        comments.push(CommentView { body_html: render::markdown::render(&c.body, "/", "/"), row: c, line });
709 
    }
710 
    let mut changes = loaded.changes.clone();
711 
    super::attribute(app, &mut changes.iter_mut().collect::<Vec<_>>()).await;
712 
    let me = viewer.account();
713 
    let can_edit = me.is_some_and(|a| Some(a.id) == p.author_id || role >= Role::Maintain);
714 
    let deletable_source =
715 
        if p.state == "landed" && p.source_kind == "bookmark" && role >= Role::Write && p.source_bookmark != row.default_bookmark {
716 
            let b = p.source_bookmark.clone();
717 
            app.repos
718 
                .read(&repo, move |r, _| Ok(r.view()?.bookmarks.contains_key(&b)))
719 
                .await
720 
                .unwrap_or(false)
721 
                .then(|| p.source_bookmark.clone())
722 
        } else {
723 
            None
724 
        };
725 
    let can_land = role >= Role::Write && p.is_open() && v.blockers.is_empty();
726 
    let can_request = p.is_open() && me.is_some_and(|a| Some(a.id) == p.author_id || role >= Role::Write);
727 
    let requested = pdb::review_requests(&app.db, p.id).await.unwrap_or_default();
728 
    let mut reviewable: Vec<String> = if can_request {
729 
        accounts::assignable(&app.db, row.id, &row.owner).await.unwrap_or_default().into_iter().filter(|u| *u != p.author).collect()
730 
    } else {
731 
        Vec::new()
732 
    };
733 
    for r in &requested {
734 
        if !reviewable.iter().any(|x| x.eq_ignore_ascii_case(r)) {
735 
            reviewable.push(r.clone());
736 
        }
737 
    }
738 
    let delegated = match viewer.account() {
739 
        Some(a) => super::edit::delegated_identity(app, a.id).await.is_some(),
740 
        None => false,
741 
    };
742 
    let hub_can_land = delegated || app.repos.read(&repo, |r, _| Ok(r.current_policy()?.is_none())).await.unwrap_or(false);
743 
    let source_label = match p.source_kind.as_str() {
744 
        "fork" => format!(
745 
            "fork {}",
746 
            db::repos::get_by_id(&app.db, p.source_repo_id.unwrap_or(0))
747 
                .await
748 
                .ok()
749 
                .flatten()
750 
                .map(|r| format!("{}:{}", r.slug(), p.source_bookmark))
751 
                .unwrap_or_default()
752 
        ),
753 
        "changes" => format!("{} changes", p.source_changes().len()),
754 
        _ => p.source_bookmark.clone(),
755 
    };
756 
    let projects = super::projects::placements_for(app, viewer, &row, p.number).await;
757 
    let texts: Vec<String> = std::iter::once(p.body.clone()).chain(changes.iter().map(|c| format!("{}\n{}", c.title, c.body))).collect();
758 
    let closes = super::chain::issues_closed_by(app, &row, &texts.iter().map(String::as_str).collect::<Vec<_>>()).await;
759 
    let project_choices = super::projects::project_choices(app, viewer, &row, &projects).await;
760 
    let mut dated: Vec<(i64, Entry)> = Vec::new();
761 
    for (index, c) in comments.iter().enumerate() {
762 
        if c.row.anchor_change.is_empty() {
763 
            dated.push((c.row.created_ms, Entry { kind: "comment", index }));
764 
        }
765 
    }
766 
    for (index, r) in v.reviews.iter().enumerate() {
767 
        dated.push((r.row.created_ms, Entry { kind: "review", index }));
768 
    }
769 
    for (index, e) in events.iter().enumerate() {
770 
        dated.push((e.at_ms, Entry { kind: "event", index }));
771 
    }
772 
    dated.sort_by_key(|(at, _)| *at);
773 
    let timeline: Vec<Entry> = dated.into_iter().map(|(_, e)| e).collect();
774 
    Ok(Page(ProposalPage {
775 
        can_triage: role >= Role::Triage,
776 
        timeline,
777 
        closes,
778 
        project_choices,
779 
        projects,
780 
        shell,
781 
        repo: RepoShell::new(app, &row, "proposals").with_role(role),
782 
        body_html: super::issues::markdown(app, &row, &row.default_bookmark, &p.body).await,
783 
        p,
784 
        tab,
785 
        changes,
786 
        files: loaded.files,
787 
        diffs: loaded.diffs,
788 
        bases: loaded.bases,
789 
        ignore_ws: false,
790 
        conflicts: loaded.conflicts,
791 
        conflicted: loaded.conflicted,
792 
        comments,
793 
        placed,
794 
        outdated,
795 
        reviews: v.reviews,
796 
        approvals: v.approvals,
797 
        blockers: v.blockers,
798 
        depends_on: v.depends_on,
799 
        events,
800 
        owners: loaded.owners,
801 
        requirements: v.requirements,
802 
        landed_already: loaded.landed_already,
803 
        can_edit,
804 
        deletable_source,
805 
        can_land,
806 
        hub_can_land,
807 
        notice,
808 
        error,
809 
        heads: loaded.heads.iter().map(|h| h.to_hex()).collect(),
810 
        state_hash: loaded.state.clone(),
811 
        source_label,
812 
        api_url: format!("{}/api/v1/repos/{owner}/{name}/proposals/{number}", app.config.base_url()),
813 
        labels: db::issues::proposal_labels(&app.db, loaded.row.id).await.unwrap_or_default(),
814 
        all_labels: db::issues::labels(&app.db, row.id).await.unwrap_or_default(),
815 
        checks: db::hooks::checks_for_state(&app.db, row.id, &loaded.state).await.unwrap_or_default(),
816 
        required_checks: db::hooks::required_checks(&app.db, row.id).await.unwrap_or_default(),
817 
        requested,
818 
        reviewable,
819 
        can_request,
820 
    }))
821 
}
822
823 
/// Back to the proposal after an action, with what to say: a redirect, so
824 
/// reloading the page (the checks script does) never repeats the action.
825 
fn back(owner: &str, name: &str, number: i64, tab: &str, notice: Option<String>, error: Option<String>) -> Response {
826 
    let mut url = format!("/{owner}/{name}/proposal/{number}?tab={tab}");
827 
    if let Some(n) = notice {
828 
        url.push_str(&format!("&notice={}", super::settings::urlencode(&n)));
829 
    }
830 
    if let Some(e) = error {
831 
        url.push_str(&format!("&error={}", super::settings::urlencode(&e)));
832 
    }
833 
    Redirect::to(&url).into_response()
834 
}
835
836 
pub async fn show(
837 
    State(app): State<Shared>,
838 
    viewer: Viewer,
839 
    Path((owner, name, number)): Path<(String, String, i64)>,
840 
    Query(q): Query<DetailQuery>,
841 
) -> Result<Page<ProposalPage>, Error> {
842 
    let shell = Shell::new(&app, &format!("/{owner}/{name}/proposal/{number}"), &viewer);
843 
    let mut page =
844 
        detail(&app, shell, &viewer, &owner, &name, number, q.tab.unwrap_or_else(|| "conversation".into()), q.notice, q.error).await?;
845 
    if q.w.as_deref() == Some("1") {
846 
        // Hide whitespace-only changes: the same hunks, rendered again.
847 
        page.0.files =
848 
            super::history::render_files_with(&page.0.diffs, &page.0.bases, crate::render::diff::Options { ignore_whitespace: true });
849 
        page.0.ignore_ws = true;
850 
    }
851 
    Ok(page)
852 
}
853
854 
// ---------------------------------------------------------------- actions
855
856 
#[derive(Deserialize)]
857 
pub struct CommentForm {
858 
    #[serde(rename = "_csrf")]
859 
    csrf_token: String,
860 
    body: String,
861 
    #[serde(default)]
862 
    path: String,
863 
    #[serde(default)]
864 
    line: Option<usize>,
865 
}
866
867 
pub async fn comment(
868 
    State(app): State<Shared>,
869 
    viewer: Viewer,
870 
    Path((owner, name, number)): Path<(String, String, i64)>,
871 
    Form(f): Form<CommentForm>,
872 
) -> Result<Response, Error> {
873 
    let shell = Shell::new(&app, &format!("/{owner}/{name}/proposal/{number}"), &viewer);
874 
    let me = require(&viewer, &shell)?;
875 
    csrf(&viewer, &f.csrf_token, &shell)?;
876 
    let (repo, row, _) = lookup(&app, &shell, &viewer, &owner, &name).await?;
877 
    let p = pdb::get(&app.db, row.id, number)
878 
        .await
879 
        .map_err(|e| Error::from_db(shell.clone(), e))?
880 
        .ok_or_else(|| Error::not_found(shell.clone()))?;
881 
    if f.body.trim().is_empty() {
882 
        return Ok(back(&owner, &name, number, "conversation", None, Some("An empty comment says nothing.".into())));
883 
    }
884 
    let anchor = match (f.path.trim(), f.line) {
885 
        ("", _) | (_, None) => None,
886 
        (path, Some(line)) => {
887 
            let loaded = load(&app, &repo, p.clone()).await.map_err(|e| Error::from_repo(shell.clone(), e))?;
888 
            loaded.atoms.get(&(path.to_string(), line)).cloned()
889 
        }
890 
    };
891 
    let tab = if anchor.is_some() { "files" } else { "conversation" };
892 
    pdb::add_comment(
893 
        &app.db,
894 
        p.id,
895 
        Some(me.account.id),
896 
        &me.account.username,
897 
        f.body.trim(),
898 
        f.path.trim(),
899 
        anchor.as_ref().map(|(h, i)| (h.as_str(), *i as i64)),
900 
    )
901 
    .await
902 
    .map_err(|e| Error::from_db(shell.clone(), e))?;
903 
    Ok(back(&owner, &name, number, tab, None, None))
904 
}
905
906 
#[derive(Deserialize)]
907 
pub struct ReviewForm {
908 
    #[serde(rename = "_csrf")]
909 
    csrf_token: String,
910 
    verdict: String,
911 
    #[serde(default)]
912 
    body: String,
913 
}
914
915 
pub async fn review(
916 
    State(app): State<Shared>,
917 
    viewer: Viewer,
918 
    Path((owner, name, number)): Path<(String, String, i64)>,
919 
    Form(f): Form<ReviewForm>,
920 
) -> Result<Response, Error> {
921 
    let shell = Shell::new(&app, &format!("/{owner}/{name}/proposal/{number}"), &viewer);
922 
    let me = require(&viewer, &shell)?;
923 
    csrf(&viewer, &f.csrf_token, &shell)?;
924 
    let (_, row, _) = lookup(&app, &shell, &viewer, &owner, &name).await?;
925 
    let p = pdb::get(&app.db, row.id, number)
926 
        .await
927 
        .map_err(|e| Error::from_db(shell.clone(), e))?
928 
        .ok_or_else(|| Error::not_found(shell.clone()))?;
929 
    if !matches!(f.verdict.as_str(), "comment" | "changes" | "approve") {
930 
        return Err(Error::bad(shell, "a review is comment, changes or approve"));
931 
    }
932 
    if f.verdict == "approve" && Some(me.account.id) == p.author_id {
933 
        return Ok(back(&owner, &name, number, "conversation", None, Some("You cannot approve your own proposal.".into())));
934 
    }
935 
    pdb::add_review(&app.db, p.id, me.account.id, &me.account.username, &f.verdict, f.body.trim())
936 
        .await
937 
        .map_err(|e| Error::from_db(shell.clone(), e))?;
938 
    pdb::add_event(&app.db, p.id, &me.account.username, &format!("review.{}", f.verdict), "").await.ok();
939 
    reviewed(&app, &row, &p, &me.account, &f.verdict).await;
940 
    crate::hooks::emit(&app, &row, "review", &me.account.username, serde_json::json!({ "number": number, "verdict": f.verdict })).await;
941 
    let notice = if f.verdict == "approve" {
942 
        Some(format!(
943 
            "Approval recorded. It counts once you seal the changes: oxy seal --proposal {}/{owner}/{name}/proposal/{number}",
944 
            app.config.base_url()
945 
        ))
946 
    } else {
947 
        None
948 
    };
949 
    Ok(back(&owner, &name, number, "conversation", notice, None))
950 
}
951
952 
#[derive(Deserialize)]
953 
pub struct EditForm {
954 
    #[serde(rename = "_csrf")]
955 
    csrf_token: String,
956 
    title: String,
957 
    #[serde(default)]
958 
    body: String,
959 
    target: String,
960 
}
961
962 
pub async fn edit(
963 
    State(app): State<Shared>,
964 
    viewer: Viewer,
965 
    Path((owner, name, number)): Path<(String, String, i64)>,
966 
    Form(f): Form<EditForm>,
967 
) -> Result<Response, Error> {
968 
    let shell = Shell::new(&app, &format!("/{owner}/{name}/proposal/{number}"), &viewer);
969 
    let me = require(&viewer, &shell)?;
970 
    csrf(&viewer, &f.csrf_token, &shell)?;
971 
    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
972 
    let p = pdb::get(&app.db, row.id, number)
973 
        .await
974 
        .map_err(|e| Error::from_db(shell.clone(), e))?
975 
        .ok_or_else(|| Error::not_found(shell.clone()))?;
976 
    if Some(me.account.id) != p.author_id && role < Role::Maintain {
977 
        return Err(Error::not_found(shell));
978 
    }
979 
    let target = if crate::repos::names::valid_segment(f.target.trim()) { f.target.trim() } else { &p.target };
980 
    pdb::edit(&app.db, p.id, f.title.trim(), f.body.trim(), target).await.map_err(|e| Error::from_db(shell.clone(), e))?;
981 
    pdb::add_event(&app.db, p.id, &me.account.username, "edited", "").await.ok();
982 
    Ok(back(&owner, &name, number, "conversation", Some("Saved.".into()), None))
983 
}
984
985 
#[derive(Deserialize)]
986 
pub struct StateForm {
987 
    #[serde(rename = "_csrf")]
988 
    csrf_token: String,
989 
    action: String,
990 
}
991
992 
pub async fn state(
993 
    State(app): State<Shared>,
994 
    viewer: Viewer,
995 
    Path((owner, name, number)): Path<(String, String, i64)>,
996 
    Form(f): Form<StateForm>,
997 
) -> Result<Response, Error> {
998 
    let shell = Shell::new(&app, &format!("/{owner}/{name}/proposal/{number}"), &viewer);
999 
    let me = require(&viewer, &shell)?;
1000 
    csrf(&viewer, &f.csrf_token, &shell)?;
1001 
    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
1002 
    let p = pdb::get(&app.db, row.id, number)
1003 
        .await
1004 
        .map_err(|e| Error::from_db(shell.clone(), e))?
1005 
        .ok_or_else(|| Error::not_found(shell.clone()))?;
1006 
    if Some(me.account.id) != p.author_id && role < Role::Triage {
1007 
        return Err(Error::not_found(shell));
1008 
    }
1009 
    let new_state = match (f.action.as_str(), p.state.as_str()) {
1010 
        ("close", "open" | "draft") => "closed",
1011 
        ("reopen", "closed") => "open",
1012 
        ("ready", "draft") => "open",
1013 
        ("draft", "open") => "draft",
1014 
        _ => return Err(Error::bad(shell, "that transition is not possible")),
1015 
    };
1016 
    pdb::set_state(&app.db, p.id, new_state, "").await.map_err(|e| Error::from_db(shell.clone(), e))?;
1017 
    pdb::add_event(&app.db, p.id, &me.account.username, new_state, "").await.ok();
1018 
    crate::hooks::emit(&app, &row, &format!("proposal.{new_state}"), &me.account.username, serde_json::json!({ "number": number })).await;
1019 
    Ok(back(&owner, &name, number, "conversation", None, None))
1020 
}
1021
1022 
pub async fn resolve_comment(
1023 
    State(app): State<Shared>,
1024 
    viewer: Viewer,
1025 
    Path((owner, name, number, id)): Path<(String, String, i64, i64)>,
1026 
    Form(f): Form<super::session::CsrfForm>,
1027 
) -> Result<Response, Error> {
1028 
    let shell = Shell::new(&app, &format!("/{owner}/{name}/proposal/{number}"), &viewer);
1029 
    require(&viewer, &shell)?;
1030 
    csrf(&viewer, &f.csrf, &shell)?;
1031 
    let (_, row, _) = lookup(&app, &shell, &viewer, &owner, &name).await?;
1032 
    let p = pdb::get(&app.db, row.id, number)
1033 
        .await
1034 
        .map_err(|e| Error::from_db(shell.clone(), e))?
1035 
        .ok_or_else(|| Error::not_found(shell.clone()))?;
1036 
    let current: Option<bool> = sqlx::query_scalar("SELECT resolved FROM proposal_comments WHERE id = ? AND proposal_id = ?")
1037 
        .bind(id)
1038 
        .bind(p.id)
1039 
        .fetch_optional(&app.db)
1040 
        .await
1041 
        .map_err(|e| Error::from_db(shell.clone(), e))?;
1042 
    if let Some(r) = current {
1043 
        pdb::set_comment_resolved(&app.db, id, !r).await.map_err(|e| Error::from_db(shell.clone(), e))?;
1044 
    }
1045 
    Ok(back(&owner, &name, number, "files", None, None))
1046 
}
1047
1048 
/// Land from the hub: only when the repository has no trust policy (the
1049 
/// hub never signs a reference update the policy would have to admit).
1050 
pub async fn land(
1051 
    State(app): State<Shared>,
1052 
    viewer: Viewer,
1053 
    Path((owner, name, number)): Path<(String, String, i64)>,
1054 
    Form(f): Form<super::session::CsrfForm>,
1055 
) -> Result<Response, Error> {
1056 
    let shell = Shell::new(&app, &format!("/{owner}/{name}/proposal/{number}"), &viewer);
1057 
    let me = require(&viewer, &shell)?;
1058 
    csrf(&viewer, &f.csrf, &shell)?;
1059 
    let (repo, row, _) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;
1060 
    match land_as(&app, &repo, &row, &me.account, number, "web").await {
1061 
        Ok(_) => Ok(back(&owner, &name, number, "conversation", Some("Landed.".into()), None)),
1062 
        Err(Landing::NotFound) => Err(Error::not_found(shell)),
1063 
        Err(Landing::Refused(m)) => Ok(back(&owner, &name, number, "conversation", None, Some(m))),
1064 
    }
1065 
}
1066
1067 
/// Why a proposal did not land.
1068 
pub enum Landing {
1069 
    NotFound,
1070 
    Refused(String),
1071 
}
1072
1073 
/// Land proposal `number` as `me` (hub spec §8.4), who has write access:
1074 
/// refused while it is not open or has blockers. Moves the target bookmark
1075 
/// (attested by the hub key on `me`'s behalf when they delegated to it),
1076 
/// then records, announces and audits the landing, saying how it was done
1077 
/// (`via`: `web`, or `api (token NAME)`). Returns the new state.
1078 
pub async fn land_as(
1079 
    app: &Shared,
1080 
    repo: &RepoName,
1081 
    row: &db::repos::RepoRow,
1082 
    me: &accounts::Account,
1083 
    number: i64,
1084 
    via: &str,
1085 
) -> Result<String, Landing> {
1086 
    let (owner, name) = (row.owner.clone(), row.name.clone());
1087 
    let refused = |e: String| Landing::Refused(e);
1088 
    let p = pdb::get(&app.db, row.id, number).await.map_err(|e| refused(e.to_string()))?.ok_or(Landing::NotFound)?;
1089 
    let loaded = load(app, repo, p.clone()).await.map_err(|e| refused(e.to_string()))?;
1090 
    let v = verdict(app, &loaded, row.id).await.map_err(|e| refused(e.to_string()))?;
1091 
    if !p.is_open() {
1092 
        return Err(refused(format!("Cannot land: the proposal is {}", p.state)));
1093 
    }
1094 
    if !v.blockers.is_empty() {
1095 
        return Err(refused(format!("Cannot land: {}", v.blockers.join("; "))));
1096 
    }
1097 
    let target = p.target.clone();
1098 
    let heads = loaded.heads.clone();
1099 
    // With a delegation the landing is attested by the hub key on the
1100 
    // user's behalf, which a policy accepts when it lets the user update
1101 
    // the target (spec §14.5); without one, only a policy-free repository
1102 
    // can be landed here.
1103 
    let result = match super::edit::signer_for(app, me.id).await {
1104 
        Ok(signer) => crate::repos::edits::move_bookmark(&app.repos, repo, target.clone(), heads.clone(), signer).await.map(|_| pl::state_ref(&heads).to_hex()),
1105 
        Err(why) => {
1106 
            app.repos
1107 
                .write(repo, move |r, _| {
1108 
                    if r.current_policy()?.is_some() {
1109 
                        return Err(crate::repos::RepoError::Oxy(oxy_core::repo::RepoError::Msg(format!(
1110 
                            "this repository has a trust policy, so the landing must be signed by a key it authorises. Land from a client with oxy proposal land, or delegate to the hub. {why}"
1111 
                        ))));
1112 
                    }
1113 
                    r.bookmark_set(&target, &heads)?;
1114 
                    Ok(pl::state_ref(&heads).to_hex())
1115 
                })
1116 
                .await
1117 
        }
1118 
    };
1119 
    let state = result.map_err(|e| refused(e.to_string()))?;
1120 
    pdb::set_landed(&app.db, p.id, &state, &me.username, via).await.map_err(|e| refused(e.to_string()))?;
1121 
    let how = if v.approvals.is_empty() { format!("{via}, with no approval") } else { via.to_string() };
1122 
    pdb::add_event(&app.db, p.id, &me.username, "landed", &how).await.ok();
1123 
    crate::hooks::emit(
1124 
        app,
1125 
        row,
1126 
        "proposal.landed",
1127 
        &me.username,
1128 
        serde_json::json!({ "number": number, "target": p.target, "state": state }),
1129 
    )
1130 
    .await;
1131 
    crate::notify::deliver(
1132 
        app,
1133 
        crate::notify::Event {
1134 
            kind: "proposal.landed",
1135 
            title: format!("{owner}/{name}#{number}: {} landed", p.title),
1136 
            url: format!("/{owner}/{name}/proposal/{number}"),
1137 
            actor: me,
1138 
            repo_id: row.id,
1139 
            thread: Some(("proposal", p.id)),
1140 
            mention_text: "",
1141 
            direct: p.author_id.into_iter().collect(),
1142 
        },
1143 
    )
1144 
    .await;
1145 
    if p.target == row.default_bookmark {
1146 
        let messages: Vec<(String, String)> = loaded.changes.iter().map(|c| (c.hash.clone(), format!("{}\n{}", c.title, c.body))).collect();
1147 
        super::issues::close_from_messages(app, row, &messages).await;
1148 
    }
1149 
    accounts::audit(&app.db, Some(me), "proposal.landed", &format!("{owner}/{name}#{number}"), &how).await.ok();
1150 
    db::repos::record_push(
1151 
        &app.db,
1152 
        row.id,
1153 
        Some((me.id, me.username.as_str())),
1154 
        &[db::repos::PushOutcome {
1155 
            reference: p.target.clone(),
1156 
            ok: true,
1157 
            reason: format!("landed #{number} ({how})"),
1158 
            old_state: loaded.target_state.clone(),
1159 
            new_state: state.clone(),
1160 
            heads: loaded.heads.len() as i64,
1161 
            changes: loaded.hashes.len() as i64,
1162 
        }],
1163 
    )
1164 
    .await
1165 
    .ok();
1166 
    Ok(state)
1167 
}
1168
1169 
#[derive(Deserialize)]
1170 
pub struct LabelsForm {
1171 
    #[serde(rename = "_csrf")]
1172 
    csrf_token: String,
1173 
    #[serde(default)]
1174 
    label: Vec<i64>,
1175 
}
1176
1177 
pub async fn set_labels(
1178 
    State(app): State<Shared>,
1179 
    viewer: Viewer,
1180 
    Path((owner, name, number)): Path<(String, String, i64)>,
1181 
    axum_extra::extract::Form(f): axum_extra::extract::Form<LabelsForm>,
1182 
) -> Result<Response, Error> {
1183 
    let shell = Shell::new(&app, &format!("/{owner}/{name}/proposal/{number}"), &viewer);
1184 
    require(&viewer, &shell)?;
1185 
    csrf(&viewer, &f.csrf_token, &shell)?;
1186 
    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
1187 
    if role < Role::Triage {
1188 
        return Err(Error::not_found(shell));
1189 
    }
1190 
    let p = pdb::get(&app.db, row.id, number)
1191 
        .await
1192 
        .map_err(|e| Error::from_db(shell.clone(), e))?
1193 
        .ok_or_else(|| Error::not_found(shell.clone()))?;
1194 
    for l in db::issues::labels(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))? {
1195 
        db::issues::set_proposal_label(&app.db, p.id, l.id, f.label.contains(&l.id)).await.map_err(|e| Error::from_db(shell.clone(), e))?;
1196 
    }
1197 
    Ok(back(&owner, &name, number, "conversation", None, None))
1198 
}
1199
1200 
/// `GET /{owner}/{name}/proposal/{number}/events`: server-sent events for
1201 
/// checks on the projected state (hub spec §13.1).
1202 
pub async fn events(
1203 
    State(app): State<Shared>,
1204 
    viewer: Viewer,
1205 
    Path((owner, name, number)): Path<(String, String, i64)>,
1206 
) -> Result<axum::response::Sse<impl futures::Stream<Item = Result<axum::response::sse::Event, std::convert::Infallible>>>, Error> {
1207 
    use futures::StreamExt;
1208 
    let shell = Shell::new(&app, &format!("/{owner}/{name}/proposal/{number}"), &viewer);
1209 
    let (_, row, _) = lookup(&app, &shell, &viewer, &owner, &name).await?;
1210 
    let rx = app.events.proposals.subscribe();
1211 
    let repo_id = row.id;
1212 
    let stream = tokio_stream::wrappers::BroadcastStream::new(rx).filter_map(move |item| async move {
1213 
        match item {
1214 
            Ok((id, ev)) if id == repo_id => {
1215 
                Some(Ok(axum::response::sse::Event::default().event(ev.kind.clone()).data(serde_json::to_string(&ev).unwrap_or_default())))
1216 
            }
1217 
            _ => None,
1218 
        }
1219 
    });
1220 
    Ok(axum::response::Sse::new(stream).keep_alive(axum::response::sse::KeepAlive::default()))
1221 
}
1222
1223 
// -------------------------------------------------------------------- API
1224
1225 
pub async fn to_api(app: &Shared, owner: &str, name: &str, loaded: &Loaded, v: &Verdict, source_url: Option<String>) -> hub_api::Proposal {
1226 
    let p = &loaded.row;
1227 
    hub_api::Proposal {
1228 
        number: p.number,
1229 
        title: p.title.clone(),
1230 
        body: p.body.clone(),
1231 
        author: p.author.clone(),
1232 
        state: ProposalState::parse(&p.state).unwrap_or(ProposalState::Open),
1233 
        target: p.target.clone(),
1234 
        source: match p.source_kind.as_str() {
1235 
            "fork" => {
1236 
                let (o, n) = source_url
1237 
                    .as_deref()
1238 
                    .and_then(|u| u.rsplit_once('/'))
1239 
                    .and_then(|(b, n)| b.rsplit_once('/').map(|(_, o)| (o.to_string(), n.to_string())))
1240 
                    .unwrap_or_default();
1241 
                ProposalSource::Fork { owner: o, name: n, bookmark: p.source_bookmark.clone() }
1242 
            }
1243 
            "changes" => ProposalSource::Changes { hashes: p.source_changes() },
1244 
            _ => ProposalSource::Bookmark { bookmark: p.source_bookmark.clone() },
1245 
        },
1246 
        changes: loaded
1247 
            .changes
1248 
            .iter()
1249 
            .map(|c| hub_api::ChangeSummary {
1250 
                hash: c.hash.clone(),
1251 
                message: if c.body.is_empty() { c.title.clone() } else { format!("{}\n\n{}", c.title, c.body) },
1252 
                author: hub_api::Author {
1253 
                    name: c.author.name.clone(),
1254 
                    email: c.author.email.clone(),
1255 
                    key: c.author.key.clone(),
1256 
                    account: c.author.account.clone(),
1257 
                    note: hub_api::Author::note_for(&c.author.key, &c.author.account),
1258 
                },
1259 
                when_ms: c.when_ms,
1260 
                deps: c.deps.clone(),
1261 
                head: c.head,
1262 
                signature: match &c.signature {
1263 
                    view::SigView::Unsigned => hub_api::Signature::Unsigned,
1264 
                    view::SigView::Valid { key, sealed, revoked, .. } => {
1265 
                        hub_api::Signature::Valid { key: key.clone(), sealed: *sealed, revoked: *revoked }
1266 
                    }
1267 
                    view::SigView::Invalid(why) => hub_api::Signature::Invalid { reason: why.clone() },
1268 
                },
1269 
            })
1270 
            .collect(),
1271 
        projected_heads: loaded.heads.iter().map(|h| h.to_hex()).collect(),
1272 
        projected_state: Some(loaded.state.clone()),
1273 
        conflicted: loaded.conflicted,
1274 
        approvals: v.approvals.clone(),
1275 
        landable: p.is_open() && v.blockers.is_empty(),
1276 
        blockers: v.blockers.clone(),
1277 
        created_ms: p.created_ms,
1278 
        updated_ms: p.updated_ms,
1279 
        url: format!("{}/{owner}/{name}/proposal/{}", app.config.base_url(), p.number),
1280 
        repository_url: format!("{}/{owner}/{name}", app.config.base_url()),
1281 
        source_url,
1282 
        landed: (p.state == "landed" && p.landed_ms > 0).then(|| hub_api::Landed {
1283 
            by: p.landed_by.clone(),
1284 
            via: p.landed_via.clone(),
1285 
            when_ms: p.landed_ms,
1286 
        }),
1287 
        requested_reviewers: pdb::review_requests(&app.db, p.id).await.unwrap_or_default(),
1288 
        labels: db::issues::proposal_labels(&app.db, p.id)
1289 
            .await
1290 
            .unwrap_or_default()
1291 
            .into_iter()
1292 
            .map(|l| hub_api::Label { name: l.name, colour: l.colour, description: l.description })
1293 
            .collect(),
1294 
    }
1295 
}
1296
1297 
/// The line comment form's placement key, for templates.
1298 
pub fn key(path: &str, line: impl filters::Num) -> (String, usize) {
1299 
    (path.to_string(), line.as_u64() as usize)
1300 
}
1301
1302 
#[allow(dead_code)]
1303 
fn _unused(_: &diff::Line, _: &ConflictView, _: &Role) {}
1304
1305 
// ------------------------------------------------------- review requests
1306
1307 
/// Ask accounts to review a proposal (hub plan 0.4): each must exist, be
1308 
/// someone other than the author, and be able to read the repository. Each
1309 
/// newly asked is told, and the proposal records it. The usernames newly
1310 
/// asked, or why none could be.
1311 
pub async fn request_reviewers(
1312 
    app: &Shared,
1313 
    row: &db::repos::RepoRow,
1314 
    p: &pdb::ProposalRow,
1315 
    by: &accounts::Account,
1316 
    names: &[String],
1317 
) -> Result<Vec<String>, String> {
1318 
    let mut found = Vec::new();
1319 
    for name in names.iter().map(|n| n.trim().trim_start_matches('@')).filter(|n| !n.is_empty()) {
1320 
        let Some(a) = accounts::account_by_name(&app.db, name).await.ok().flatten() else {
1321 
            return Err(format!("There is no account {name}."));
1322 
        };
1323 
        if Some(a.id) == p.author_id {
1324 
            return Err(format!("{name} wrote this proposal, and cannot review it."));
1325 
        }
1326 
        let role = crate::auth::roles::role_for(&app.db, Some(&a), row).await.ok().flatten();
1327 
        if !crate::auth::roles::allows(role, crate::auth::Access::Read) {
1328 
            return Err(format!("{name} cannot read this repository."));
1329 
        }
1330 
        found.push(a);
1331 
    }
1332 
    let mut asked = Vec::new();
1333 
    for a in found {
1334 
        if !pdb::request_review(&app.db, p.id, a.id, &by.username).await.map_err(|e| e.to_string())? {
1335 
            continue;
1336 
        }
1337 
        pdb::add_event(&app.db, p.id, &by.username, "review requested", &a.username).await.ok();
1338 
        crate::notify::deliver(
1339 
            app,
1340 
            crate::notify::Event {
1341 
                kind: "proposal.review_requested",
1342 
                title: format!("{}/{}#{}: {} (review requested from {})", row.owner, row.name, p.number, p.title, a.username),
1343 
                url: format!("/{}/{}/proposal/{}", row.owner, row.name, p.number),
1344 
                actor: by,
1345 
                repo_id: row.id,
1346 
                thread: None,
1347 
                mention_text: "",
1348 
                direct: vec![a.id],
1349 
            },
1350 
        )
1351 
        .await;
1352 
        asked.push(a.username);
1353 
    }
1354 
    Ok(asked)
1355 
}
1356
1357 
/// After a review: it answers the reviewer's request, if there was one, and
1358 
/// the proposal's author is told.
1359 
pub async fn reviewed(app: &Shared, row: &db::repos::RepoRow, p: &pdb::ProposalRow, by: &accounts::Account, verdict: &str) {
1360 
    pdb::unrequest_review(&app.db, p.id, by.id).await.ok();
1361 
    let what = match verdict {
1362 
        "approve" => "approved",
1363 
        "changes" => "changes requested",
1364 
        _ => "reviewed",
1365 
    };
1366 
    crate::notify::deliver(
1367 
        app,
1368 
        crate::notify::Event {
1369 
            kind: "proposal.review",
1370 
            title: format!("{}/{}#{}: {} ({what} by {})", row.owner, row.name, p.number, p.title, by.username),
1371 
            url: format!("/{}/{}/proposal/{}", row.owner, row.name, p.number),
1372 
            actor: by,
1373 
            repo_id: row.id,
1374 
            thread: Some(("proposal", p.id)),
1375 
            mention_text: "",
1376 
            direct: p.author_id.into_iter().collect(),
1377 
        },
1378 
    )
1379 
    .await;
1380 
}
1381
1382 
#[derive(Deserialize)]
1383 
pub struct ReviewersForm {
1384 
    #[serde(rename = "_csrf")]
1385 
    csrf_token: String,
1386 
    /// `add`, `remove`, or `set` (the menu: exactly these are asked).
1387 
    action: String,
1388 
    #[serde(default)]
1389 
    username: Vec<String>,
1390 
}
1391
1392 
/// `POST /{owner}/{name}/proposal/{number}/reviewers`: the author or a
1393 
/// writer asks someone to review, or withdraws the request.
1394 
pub async fn reviewers(
1395 
    State(app): State<Shared>,
1396 
    viewer: Viewer,
1397 
    Path((owner, name, number)): Path<(String, String, i64)>,
1398 
    axum_extra::extract::Form(f): axum_extra::extract::Form<ReviewersForm>,
1399 
) -> Result<Response, Error> {
1400 
    let shell = Shell::new(&app, &format!("/{owner}/{name}/proposal/{number}"), &viewer);
1401 
    let me = require(&viewer, &shell)?;
1402 
    csrf(&viewer, &f.csrf_token, &shell)?;
1403 
    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
1404 
    let p = pdb::get(&app.db, row.id, number)
1405 
        .await
1406 
        .map_err(|e| Error::from_db(shell.clone(), e))?
1407 
        .ok_or_else(|| Error::not_found(shell.clone()))?;
1408 
    if Some(me.account.id) != p.author_id && role < Role::Write {
1409 
        return Err(Error::not_found(shell));
1410 
    }
1411 
    let names: Vec<String> = f.username.iter().map(|n| n.trim().trim_start_matches('@').to_string()).filter(|n| !n.is_empty()).collect();
1412 
    let current = pdb::review_requests(&app.db, p.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
1413 
    // Withdrawn: those named (remove), or those the menu left out (set).
1414 
    let withdraw: Vec<String> = match f.action.as_str() {
1415 
        "remove" => names.clone(),
1416 
        "set" => current.iter().filter(|c| !names.iter().any(|n| n.eq_ignore_ascii_case(c))).cloned().collect(),
1417 
        _ => Vec::new(),
1418 
    };
1419 
    for who in &withdraw {
1420 
        if let Some(a) = accounts::account_by_name(&app.db, who).await.ok().flatten() {
1421 
            if pdb::unrequest_review(&app.db, p.id, a.id).await.map_err(|e| Error::from_db(shell.clone(), e))? {
1422 
                pdb::add_event(&app.db, p.id, &me.account.username, "review request withdrawn", &a.username).await.ok();
1423 
            }
1424 
        }
1425 
    }
1426 
    let ask: Vec<String> = match f.action.as_str() {
1427 
        "add" => names,
1428 
        "set" => names.into_iter().filter(|n| !current.iter().any(|c| c.eq_ignore_ascii_case(n))).collect(),
1429 
        _ => return Ok(back(&owner, &name, number, "conversation", None, None)),
1430 
    };
1431 
    if ask.is_empty() {
1432 
        return Ok(back(&owner, &name, number, "conversation", None, None));
1433 
    }
1434 
    match request_reviewers(&app, &row, &p, &me.account, &ask).await {
1435 
        Ok(asked) if asked.is_empty() => Ok(back(&owner, &name, number, "conversation", Some("Already asked.".into()), None)),
1436 
        Ok(asked) => Ok(back(&owner, &name, number, "conversation", Some(format!("Asked {} to review.", asked.join(", "))), None)),
1437 
        Err(e) => Ok(back(&owner, &name, number, "conversation", None, Some(e))),
1438 
    }
1439 
}