OXYGENHUB

Coverage / crates/hub/src/api/projects.rs 90.9%

401 of 441 lines run, 78 of 182 functions · run #541 on main · run missed

1
//! Projects over the API (hub spec §8.2, §12.1): the same rules as the
2
//! pages, through the functions they use.
3
4
use super::{caller, forbidden, not_found, ApiError, Caller};
5
use crate::db::projects as pdb;
6
use crate::web::projects as wp;
7
use crate::Shared;
8
use axum::extract::{Path, Query, State};
9
use axum::http::{HeaderMap, StatusCode};
10
use axum::Json;
11
use hub_api::{
12
    Board, CardMove, CardsArchive, CardsArchived, CardsMove, CardsMoved, NewCard, NewProject, Project, ProjectCard, ProjectColumn,
13
    ProjectEdit,
14
};
15
1621×
fn project_of(app: &Shared, p: &pdb::Project) -> Project {
1721×
    Project {
1821×
        owner: p.owner.clone(),
1921×
        number: p.number,
2021×
        title: p.title.clone(),
2121×
        description: p.description.clone(),
2221×
        public: p.public,
2321×
        closed: p.closed,
2421×
        updated_ms: p.updated_ms,
2521×
        url: format!("{}/projects/{}/{}", app.config.base_url().trim_end_matches('/'), p.owner, p.number),
2621×
    }
2721×
}
28
2954×
fn card_of(v: &wp::CardView) -> ProjectCard {
30
    ProjectCard {
3154×
        id: v.card.id,
3254×
        kind: v.card.kind.clone(),
3354×
        reference: v.reference.clone(),
3454×
        title: v.title.clone(),
3554×
        state: v.state.clone(),
3654×
        labels: v.labels.iter().map(|l| l.name.clone()).collect(),
3754×
        assignees: v.assignees.clone(),
3854×
        archived_ms: v.card.archived_ms,
39
    }
4054×
}
41
4274×
async fn rights(app: &Shared, c: &Caller, owner: &str) -> Result<wp::Rights, ApiError> {
4374×
    wp::rights_of(app, c.account.as_ref(), owner).await?.ok_or_else(|| not_found("no such owner"))
4474×
}
45
46
/// A project the caller may see.
4767×
async fn visible(app: &Shared, c: &Caller, owner: &str, number: i64) -> Result<(wp::Rights, pdb::Project), ApiError> {
4867×
    let r = rights(app, c, owner).await?;
4967×
    let p = pdb::get(&app.db, owner, number).await?.filter(|p| p.public || r.member).ok_or_else(|| not_found("no such project"))?;
5066×
    Ok((r, p))
5167×
}
52
53
/// A project the caller may change: a write token, edit rights, and open unless `closed_ok`.
5443×
async fn changeable(
5543×
    app: &Shared,
5643×
    headers: &HeaderMap,
5743×
    owner: &str,
5843×
    number: i64,
5943×
    closed_ok: bool,
6043×
) -> Result<(Caller, pdb::Project), ApiError> {
6143×
    let c = caller(app, headers).await?;
6243×
    c.require("repo:write")?;
6343×
    let (r, p) = visible(app, &c, owner, number).await?;
6443×
    if !r.edit {
654×
        return Err(forbidden("only the owner (or the organisation's members) may change this project"));
6639×
    }
6739×
    if p.closed && !closed_ok {
681×
        return Err(ApiError(StatusCode::CONFLICT, "this project is closed; reopen it to change it".into()));
6938×
    }
7038×
    Ok((c, p))
7143×
}
72
73
/// A column by id or by name (case-insensitive); the first when absent.
7424×
async fn column(app: &Shared, project_id: i64, spec: Option<&str>) -> Result<pdb::Column, ApiError> {
7524×
    let cols = pdb::columns(&app.db, project_id).await?;
7624×
    let found = match spec.map(str::trim).filter(|s| !s.is_empty()) {
776×
        None => cols.into_iter().next(),
7847×
        Some(s) => cols.into_iter().find(|c| c.id.to_string() == s || c.name.eq_ignore_ascii_case(s)),
79
    };
8024×
    found.ok_or_else(|| ApiError(StatusCode::BAD_REQUEST, "no such column".into()))
8124×
}
82
83
/// `GET /projects/{owner}`.
842×
pub async fn list(State(app): State<Shared>, headers: HeaderMap, Path(owner): Path<String>) -> Result<Json<Vec<Project>>, ApiError> {
852×
    let c = caller(&app, &headers).await?;
862×
    let r = rights(&app, &c, &owner).await?;
872×
    let list = pdb::of_owner(&app.db, &owner).await?;
882×
    Ok(Json(list.iter().filter(|p| p.public || r.member).map(|p| project_of(&app, p)).collect()))
892×
}
90
91
/// `POST /projects/{owner}`.
925×
pub async fn create(
935×
    State(app): State<Shared>,
945×
    headers: HeaderMap,
955×
    Path(owner): Path<String>,
965×
    Json(body): Json<NewProject>,
975×
) -> Result<(StatusCode, Json<Project>), ApiError> {
985×
    let c = caller(&app, &headers).await?;
995×
    c.require("repo:write")?;
1005×
    if !rights(&app, &c, &owner).await?.edit {
1011×
        return Err(forbidden("only the owner (or the organisation's members) may create projects"));
1023×
    }
1033×
    let title = body.title.trim();
1043×
    if title.is_empty() || title.chars().count() > 100 {
1050×
        return Err(ApiError(StatusCode::BAD_REQUEST, "a project needs a title of up to 100 characters".into()));
1063×
    }
1073×
    let p = pdb::create(&app.db, &owner, title, body.description.trim(), !body.private).await?;
1083×
    crate::db::accounts::audit(&app.db, c.account.as_ref(), "project.created", &format!("{owner}/{}", p.number), title).await.ok();
1093×
    Ok((StatusCode::CREATED, Json(project_of(&app, &p))))
1105×
}
111
112
/// `GET /projects/{owner}/{n}`'s filter (#361): `q` as the board's filter
113
/// bar takes it, or the `view` saved under that name.
114
#[derive(serde::Deserialize, Default)]
115
pub struct BoardFilter {
116
    #[serde(default)]
117
    q: Option<String>,
118
    #[serde(default)]
119
    view: Option<String>,
120
}
121
122
/// `GET /projects/{owner}/{n}`.
12310×
pub async fn board(
12410×
    State(app): State<Shared>,
12510×
    headers: HeaderMap,
12610×
    Path((owner, number)): Path<(String, i64)>,
12710×
    Query(f): Query<BoardFilter>,
12810×
) -> Result<Json<Board>, ApiError> {
12910×
    let c = caller(&app, &headers).await?;
13010×
    let (_, p) = visible(&app, &c, &owner, number).await?;
1319×
    let q = match (f.q, f.view) {
1320×
        (Some(q), _) => q,
1330×
        (None, Some(name)) => pdb::views(&app.db, p.id)
1340×
            .await?
1350×
            .into_iter()
1360×
            .find(|v| v.name == name)
1370×
            .map(|v| v.q)
1380×
            .ok_or_else(|| ApiError(StatusCode::NOT_FOUND, format!("no view {name}")))?,
1399×
        (None, None) => String::new(),
140
    };
1419×
    let Json(mut b) = board_of(&app, &c, &owner, number).await?;
1429×
    if !q.trim().is_empty() {
1430×
        let filter = wp::CardFilter::parse(&q);
1440×
        let now = crate::db::now_ms();
1450×
        let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, false).await?;
1460×
        for (out, col) in b.columns.iter_mut().zip(columns.iter()) {
1470×
            out.cards = col.cards.iter().filter(|card| filter.keeps(card, now)).map(card_of).collect();
148
        }
1490×
        b.filter = q.trim().to_string();
1509×
    }
1519×
    Ok(Json(b))
15210×
}
153
154
/// `PATCH /projects/{owner}/{n}`.
1554×
pub async fn edit(
1564×
    State(app): State<Shared>,
1574×
    headers: HeaderMap,
1584×
    Path((owner, number)): Path<(String, i64)>,
1594×
    Json(body): Json<ProjectEdit>,
1604×
) -> Result<Json<Project>, ApiError> {
1614×
    let (c, p) = changeable(&app, &headers, &owner, number, true).await?;
162
    // A transfer (#125) first: the other fields then apply where it went.
1634×
    let (owner, number) = match body.owner.as_deref().map(str::trim).filter(|to| !to.is_empty() && *to != owner) {
1640×
        Some(to) => match wp::rights_of(&app, c.account.as_ref(), to).await? {
1650×
            Some(r) if r.edit => {
1660×
                let moved = pdb::transfer(&app.db, p.id, to).await?;
1670×
                let detail = format!("{owner}/{number} to {to}/{}", moved.number);
1680×
                crate::db::accounts::audit(&app.db, c.account.as_ref(), "project.transferred", &detail, &p.title).await.ok();
1690×
                (moved.owner, moved.number)
170
            }
1710×
            _ => return Err(ApiError(StatusCode::FORBIDDEN, format!("you cannot make projects under {to}"))),
172
        },
1734×
        None => (owner, number),
174
    };
1754×
    let p = pdb::get(&app.db, &owner, number).await?.unwrap_or(p);
1764×
    let title = body.title.as_deref().map(str::trim).filter(|t| !t.is_empty()).unwrap_or(&p.title).chars().take(100).collect::<String>();
1774×
    pdb::set(
1784×
        &app.db,
1794×
        p.id,
1804×
        &title,
1814×
        body.description.as_deref().map(str::trim).unwrap_or(&p.description),
1824×
        body.private.map(|x| !x).unwrap_or(p.public),
1834×
        body.closed.unwrap_or(p.closed),
184
    )
1854×
    .await?;
1864×
    let fresh = pdb::get(&app.db, &owner, number).await?.unwrap_or(p);
1874×
    Ok(Json(project_of(&app, &fresh)))
1884×
}
189
190
/// A board's columns as `GET /projects/{owner}/{n}` gives them, for the
191
/// column calls to answer with (#366).
19213×
async fn board_of(app: &Shared, c: &Caller, owner: &str, number: i64) -> Result<Json<Board>, ApiError> {
19313×
    let (_, p) = visible(app, c, owner, number).await?;
19413×
    let (columns, _) = wp::board_columns(app, c.account.as_ref(), owner, &p, false).await?;
195
    Ok(Json(Board {
19613×
        project: project_of(app, &p),
19713×
        columns: columns
19813×
            .iter()
19913×
            .map(|col| ProjectColumn {
20042×
                id: col.column.id,
20142×
                name: col.column.name.clone(),
20242×
                cards: col.cards.iter().map(card_of).collect(),
20342×
                wip_limit: col.column.wip_limit,
20442×
            })
20513×
            .collect(),
20613×
        views: pdb::views(&app.db, p.id)
20713×
            .await?
20813×
            .into_iter()
20913×
            .map(|v| hub_api::ProjectView { name: v.name, layout: v.layout, q: v.q, lane: v.lane, sort: v.sort })
21013×
            .collect(),
21113×
        filter: String::new(),
212
    }))
21313×
}
214
215
/// A column's name: trimmed, 1 to 40 characters, as the board page has it.
2165×
fn column_name(name: &str) -> Result<&str, ApiError> {
2175×
    let name = name.trim();
2185×
    if name.is_empty() || name.chars().count() > 40 {
2191×
        return Err(ApiError(StatusCode::BAD_REQUEST, "a column has a name of 1 to 40 characters".into()));
2204×
    }
2214×
    Ok(name)
2225×
}
223
224
/// `POST /projects/{owner}/{n}/columns` (#366): add a column at the right;
225
/// answers the board.
2264×
pub async fn add_column(
2274×
    State(app): State<Shared>,
2284×
    headers: HeaderMap,
2294×
    Path((owner, number)): Path<(String, i64)>,
2304×
    Json(body): Json<hub_api::NewColumn>,
2314×
) -> Result<Json<Board>, ApiError> {
2324×
    let (c, p) = changeable(&app, &headers, &owner, number, false).await?;
2333×
    let name = column_name(&body.name)?;
2347×
    if pdb::columns(&app.db, p.id).await?.iter().any(|col| col.name.eq_ignore_ascii_case(name)) {
2351×
        return Err(ApiError(StatusCode::CONFLICT, format!("the board has a column {name} already")));
2361×
    }
2371×
    pdb::add_column(&app.db, p.id, name).await?;
2381×
    board_of(&app, &c, &owner, number).await
2394×
}
240
241
/// `PATCH /projects/{owner}/{n}/columns/{column}` (#366): rename or move a
242
/// column named by id or name; answers the board.
2435×
pub async fn edit_column(
2445×
    State(app): State<Shared>,
2455×
    headers: HeaderMap,
2465×
    Path((owner, number, spec)): Path<(String, i64, String)>,
2475×
    Json(body): Json<hub_api::ColumnEdit>,
2485×
) -> Result<Json<Board>, ApiError> {
2495×
    let (c, p) = changeable(&app, &headers, &owner, number, false).await?;
2505×
    let col = named_column(&app, p.id, &spec).await?;
2514×
    if body.name.is_none() && body.position.is_none() {
2521×
        return Err(ApiError(StatusCode::BAD_REQUEST, "say what to change: name or position".into()));
2533×
    }
2543×
    if let Some(name) = body.name.as_deref() {
2552×
        let name = column_name(name)?;
2562×
        let others = pdb::columns(&app.db, p.id).await?;
2577×
        if others.iter().any(|o| o.id != col.id && o.name.eq_ignore_ascii_case(name)) {
2581×
            return Err(ApiError(StatusCode::CONFLICT, format!("the board has a column {name} already")));
2591×
        }
2601×
        pdb::rename_column(&app.db, p.id, col.id, name).await?;
2611×
    }
2622×
    if let Some(pos) = body.position {
2632×
        pdb::place_column(&app.db, p.id, col.id, pos).await?;
2640×
    }
2652×
    board_of(&app, &c, &owner, number).await
2665×
}
267
268
/// `DELETE /projects/{owner}/{n}/columns/{column}` (#366): its cards go to
269
/// the first remaining column; a board keeps at least one. Answers the board.
2701×
pub async fn remove_column(
2711×
    State(app): State<Shared>,
2721×
    headers: HeaderMap,
2731×
    Path((owner, number, spec)): Path<(String, i64, String)>,
2741×
) -> Result<Json<Board>, ApiError> {
2751×
    let (c, p) = changeable(&app, &headers, &owner, number, false).await?;
2761×
    let col = named_column(&app, p.id, &spec).await?;
2771×
    if !pdb::remove_column(&app.db, p.id, col.id).await? {
2780×
        return Err(ApiError(StatusCode::CONFLICT, "a board keeps at least one column".into()));
2791×
    }
2801×
    board_of(&app, &c, &owner, number).await
2811×
}
282
283
/// A column named by id or name, or 404.
2846×
async fn named_column(app: &Shared, project_id: i64, spec: &str) -> Result<pdb::Column, ApiError> {
2856×
    let cols = pdb::columns(&app.db, project_id).await?;
2866×
    cols.into_iter()
28721×
        .find(|c| c.id.to_string() == spec.trim() || c.name.eq_ignore_ascii_case(spec.trim()))
2886×
        .ok_or_else(|| ApiError(StatusCode::NOT_FOUND, format!("no column {spec}")))
2896×
}
290
291
/// `GET /projects/{owner}/{n}/cards`: the cards by column, as the board
292
/// has them.
293
#[derive(serde::Deserialize, Default)]
294
pub struct CardsQuery {
295
    /// The archived cards instead (#293).
296
    #[serde(default)]
297
    archived: bool,
298
}
299
300
/// `GET /projects/{owner}/{n}/cards`, `?archived=true` for the archived ones.
3012×
pub async fn cards(
3022×
    State(app): State<Shared>,
3032×
    headers: HeaderMap,
3042×
    Path((owner, number)): Path<(String, i64)>,
3052×
    Query(q): Query<CardsQuery>,
3062×
) -> Result<Json<Vec<ProjectColumn>>, ApiError> {
3072×
    if !q.archived {
3081×
        return Ok(Json(board(State(app), headers, Path((owner, number)), Query(BoardFilter::default())).await?.0.columns));
3091×
    }
3101×
    let c = caller(&app, &headers).await?;
3111×
    let (_, p) = visible(&app, &c, &owner, number).await?;
3121×
    let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, true).await?;
313
    Ok(Json(
3141×
        columns
3151×
            .iter()
3161×
            .map(|col| ProjectColumn {
3173×
                id: col.column.id,
3183×
                name: col.column.name.clone(),
3193×
                cards: col.cards.iter().map(card_of).collect(),
3203×
                wip_limit: col.column.wip_limit,
3213×
            })
3221×
            .collect(),
323
    ))
3242×
}
325
326
/// `POST /projects/{owner}/{n}/cards`.
32713×
pub async fn add_card(
32813×
    State(app): State<Shared>,
32913×
    headers: HeaderMap,
33013×
    Path((owner, number)): Path<(String, i64)>,
33113×
    Json(body): Json<NewCard>,
33213×
) -> Result<(StatusCode, Json<ProjectCard>), ApiError> {
33313×
    let (c, p) = changeable(&app, &headers, &owner, number, false).await?;
33411×
    let col = column(&app, p.id, body.column.as_deref()).await?;
33510×
    let actor = c.account.as_ref().map(|a| a.username.clone()).unwrap_or_default();
33610×
    let card = match wp::add_card(&app, c.account.as_ref(), &owner, p.id, col.id, &body.reference, "", &body.note, &actor).await? {
3376×
        Ok(card) => card,
3384×
        Err(why) => return Err(ApiError(StatusCode::BAD_REQUEST, why)),
339
    };
340
    // Answer with the card as the board shows it.
3416×
    let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, false).await?;
3426×
    let view = columns
3436×
        .iter()
34410×
        .flat_map(|col| col.cards.iter())
3459×
        .find(|v| v.card.id == card.id)
3466×
        .map(card_of)
3476×
        .ok_or_else(|| not_found("no such card"))?;
3486×
    Ok((StatusCode::CREATED, Json(view)))
34913×
}
350
351
/// `PATCH /projects/{owner}/{n}/cards/{id}`: move to another column.
3522×
pub async fn move_card(
3532×
    State(app): State<Shared>,
3542×
    headers: HeaderMap,
3552×
    Path((owner, number, id)): Path<(String, i64, i64)>,
3562×
    Json(body): Json<CardMove>,
3572×
) -> Result<StatusCode, ApiError> {
3582×
    let (_, p) = changeable(&app, &headers, &owner, number, false).await?;
3592×
    let col = column(&app, p.id, Some(&body.column)).await?;
3602×
    if !pdb::cards(&app.db, p.id).await?.iter().any(|c| c.id == id) {
3610×
        return Err(not_found("no such card"));
3622×
    }
3632×
    pdb::move_card(&app.db, p.id, id, col.id).await?;
3642×
    Ok(StatusCode::NO_CONTENT)
3652×
}
366
367
/// Whether `card` is the one `name` names: its id, or its issue or
368
/// proposal as `12`, `#12`, `name#12` or `owner/name#12`.
3694×
fn names_card(name: &str, card: &ProjectCard) -> bool {
3704×
    let name = name.trim();
3714×
    if name.is_empty() {
3720×
        return false;
3734×
    }
3744×
    if name.parse::<i64>().is_ok_and(|id| id == card.id) {
3750×
        return true;
3764×
    }
3774×
    let Some((_, number)) = card.reference.rsplit_once('#') else { return false };
3784×
    match name.rsplit_once('#') {
3790×
        None => name == number,
3804×
        Some(("", n)) => n == number,
3812×
        Some((repo, n)) => n == number && (card.reference == format!("{repo}#{n}") || card.reference.ends_with(&format!("/{repo}#{n}"))),
382
    }
3834×
}
384
385
/// `POST /projects/{owner}/{n}/cards/move` (#289): a column's cards to
386
/// another at once, with exceptions and a state filter; one audit entry.
3875×
pub async fn move_cards(
3885×
    State(app): State<Shared>,
3895×
    headers: HeaderMap,
3905×
    Path((owner, number)): Path<(String, i64)>,
3915×
    Json(body): Json<CardsMove>,
3925×
) -> Result<Json<CardsMoved>, ApiError> {
3935×
    let (c, p) = changeable(&app, &headers, &owner, number, false).await?;
3944×
    let from = column(&app, p.id, Some(&body.from)).await?;
3954×
    let to = column(&app, p.id, Some(&body.column)).await?;
3964×
    if from.id == to.id {
3971×
        return Err(ApiError(StatusCode::BAD_REQUEST, "the cards are in that column already".into()));
3983×
    }
3993×
    let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, false).await?;
4003×
    let cards: Vec<ProjectCard> =
4019×
        columns.iter().filter(|col| col.column.id == from.id).flat_map(|col| col.cards.iter().map(card_of)).collect();
4023×
    let states: Vec<String> = body.state.iter().map(|s| s.trim().to_ascii_lowercase()).filter(|s| !s.is_empty()).collect();
4036×
    let (moved, kept): (Vec<ProjectCard>, Vec<ProjectCard>) = cards.into_iter().partition(|card| {
4046×
        !body.except.iter().any(|e| names_card(e, card)) && (states.is_empty() || states.iter().any(|s| card.state.eq_ignore_ascii_case(s)))
4056×
    });
4063×
    if !body.dry_run && !moved.is_empty() {
4071×
        let ids: Vec<i64> = moved.iter().map(|c| c.id).collect();
4081×
        pdb::move_cards(&app.db, p.id, &ids, to.id).await?;
4091×
        let detail = format!("{} card(s) from {} to {}", moved.len(), from.name, to.name);
4101×
        crate::db::accounts::audit(&app.db, c.account.as_ref(), "project.cards_moved", &format!("{owner}/{number}"), &detail).await.ok();
4112×
    }
4123×
    Ok(Json(CardsMoved { moved, kept, dry_run: body.dry_run }))
4135×
}
414
415
/// `POST /projects/{owner}/{n}/cards/archive` (#293): a column's cards off
416
/// the board at once, kept, with #289's exceptions and state filter and an
417
/// age; one audit entry.
4183×
pub async fn archive_cards(
4193×
    State(app): State<Shared>,
4203×
    headers: HeaderMap,
4213×
    Path((owner, number)): Path<(String, i64)>,
4223×
    Json(body): Json<CardsArchive>,
4233×
) -> Result<Json<CardsArchived>, ApiError> {
4243×
    let (c, p) = changeable(&app, &headers, &owner, number, false).await?;
4253×
    let from = column(&app, p.id, Some(&body.from)).await?;
4263×
    if body.older_days.is_some_and(|d| !(0..=3650).contains(&d)) {
4271×
        return Err(ApiError(StatusCode::BAD_REQUEST, "older_days is 0 to 3650".into()));
4282×
    }
4292×
    let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, false).await?;
4302×
    let now = crate::db::now_ms();
4312×
    let states: Vec<String> = body.state.iter().map(|s| s.trim().to_ascii_lowercase()).filter(|s| !s.is_empty()).collect();
4322×
    let (archived, kept): (Vec<&wp::CardView>, Vec<&wp::CardView>) =
4336×
        columns.iter().filter(|col| col.column.id == from.id).flat_map(|col| col.cards.iter()).partition(|v| {
4344×
            let card = card_of(v);
4354×
            !body.except.iter().any(|e| names_card(e, &card))
4364×
                && (states.is_empty() || states.iter().any(|s| card.state.eq_ignore_ascii_case(s)))
4374×
                && body.older_days.is_none_or(|d| pdb::older_than(&v.card, d, now))
4384×
        });
4392×
    if !body.dry_run && !archived.is_empty() {
4401×
        let ids: Vec<i64> = archived.iter().map(|v| v.card.id).collect();
4411×
        pdb::archive_cards(&app.db, p.id, &ids).await?;
4421×
        let detail = format!("{} card(s) of {}", ids.len(), from.name);
4431×
        crate::db::accounts::audit(&app.db, c.account.as_ref(), "project.cards_archived", &format!("{owner}/{number}"), &detail).await.ok();
4441×
    }
4452×
    let stamp = |v: &wp::CardView| ProjectCard { archived_ms: (!body.dry_run).then_some(now), ..card_of(v) };
4462×
    Ok(Json(CardsArchived {
4472×
        archived: archived.into_iter().map(stamp).collect(),
4482×
        kept: kept.into_iter().map(card_of).collect(),
4492×
        dry_run: body.dry_run,
4502×
    }))
4513×
}
452
453
/// `POST /projects/{owner}/{n}/cards/{id}/restore` (#293): an archived
454
/// card back on the board, at the end of its column.
4553×
pub async fn restore_card(
4563×
    State(app): State<Shared>,
4573×
    headers: HeaderMap,
4583×
    Path((owner, number, id)): Path<(String, i64, i64)>,
4593×
) -> Result<StatusCode, ApiError> {
4603×
    let (_, p) = changeable(&app, &headers, &owner, number, false).await?;
4618×
    if !pdb::cards(&app.db, p.id).await?.iter().any(|c| c.id == id && c.archived_ms.is_some()) {
4621×
        return Err(not_found("no such archived card"));
4631×
    }
4641×
    pdb::restore_card(&app.db, p.id, id).await?;
4651×
    Ok(StatusCode::NO_CONTENT)
4663×
}
467
468
/// `DELETE /projects/{owner}/{n}/cards/{id}`.
4693×
pub async fn remove_card(
4703×
    State(app): State<Shared>,
4713×
    headers: HeaderMap,
4723×
    Path((owner, number, id)): Path<(String, i64, i64)>,
4733×
) -> Result<StatusCode, ApiError> {
4743×
    let (_, p) = changeable(&app, &headers, &owner, number, false).await?;
4755×
    if !pdb::cards(&app.db, p.id).await?.iter().any(|c| c.id == id) {
4761×
        return Err(not_found("no such card"));
4772×
    }
4782×
    pdb::remove_card(&app.db, p.id, id).await?;
4792×
    Ok(StatusCode::NO_CONTENT)
4803×
}