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

fn project_of(app: &Shared, p: &pdb::Project) -> Project {

    Project {

        owner: p.owner.clone(),

        number: p.number,

        title: p.title.clone(),

        description: p.description.clone(),

        public: p.public,

        closed: p.closed,

        updated_ms: p.updated_ms,

        url: format!("{}/projects/{}/{}", app.config.base_url().trim_end_matches('/'), p.owner, p.number),

    }

}

fn card_of(v: &wp::CardView) -> ProjectCard {

        id: v.card.id,

        kind: v.card.kind.clone(),

        reference: v.reference.clone(),

        title: v.title.clone(),

        state: v.state.clone(),

        labels: v.labels.iter().map(|l| l.name.clone()).collect(),

        assignees: v.assignees.clone(),

        archived_ms: v.card.archived_ms,

}

async fn rights(app: &Shared, c: &Caller, owner: &str) -> Result<wp::Rights, ApiError> {

    wp::rights_of(app, c.account.as_ref(), owner).await?.ok_or_else(|| not_found("no such owner"))

}

async fn visible(app: &Shared, c: &Caller, owner: &str, number: i64) -> Result<(wp::Rights, pdb::Project), ApiError> {

    let r = rights(app, c, owner).await?;

    let p = pdb::get(&app.db, owner, number).await?.filter(|p| p.public || r.member).ok_or_else(|| not_found("no such project"))?;

    Ok((r, p))

}

async fn changeable(

    app: &Shared,

    headers: &HeaderMap,

    owner: &str,

    number: i64,

    closed_ok: bool,

) -> Result<(Caller, pdb::Project), ApiError> {

    let c = caller(app, headers).await?;

    c.require("repo:write")?;

    let (r, p) = visible(app, &c, owner, number).await?;

    if !r.edit {

        return Err(forbidden("only the owner (or the organisation's members) may change this project"));

    }

    if p.closed && !closed_ok {

        return Err(ApiError(StatusCode::CONFLICT, "this project is closed; reopen it to change it".into()));

    }

    Ok((c, p))

}

async fn column(app: &Shared, project_id: i64, spec: Option<&str>) -> Result<pdb::Column, ApiError> {

    let cols = pdb::columns(&app.db, project_id).await?;

    let found = match spec.map(str::trim).filter(|s| !s.is_empty()) {

        None => cols.into_iter().next(),

        Some(s) => cols.into_iter().find(|c| c.id.to_string() == s || c.name.eq_ignore_ascii_case(s)),

    found.ok_or_else(|| ApiError(StatusCode::BAD_REQUEST, "no such column".into()))

}

pub async fn list(State(app): State<Shared>, headers: HeaderMap, Path(owner): Path<String>) -> Result<Json<Vec<Project>>, ApiError> {

    let c = caller(&app, &headers).await?;

    let r = rights(&app, &c, &owner).await?;

    let list = pdb::of_owner(&app.db, &owner).await?;

    Ok(Json(list.iter().filter(|p| p.public || r.member).map(|p| project_of(&app, p)).collect()))

}

pub async fn create(

    State(app): State<Shared>,

    headers: HeaderMap,

    Path(owner): Path<String>,

    Json(body): Json<NewProject>,

) -> Result<(StatusCode, Json<Project>), ApiError> {

    let c = caller(&app, &headers).await?;

    c.require("repo:write")?;

    if !rights(&app, &c, &owner).await?.edit {

        return Err(forbidden("only the owner (or the organisation's members) may create projects"));

    }

    let title = body.title.trim();

    if title.is_empty() || title.chars().count() > 100 {

    }

    let p = pdb::create(&app.db, &owner, title, body.description.trim(), !body.private).await?;

    crate::db::accounts::audit(&app.db, c.account.as_ref(), "project.created", &format!("{owner}/{}", p.number), title).await.ok();

    Ok((StatusCode::CREATED, Json(project_of(&app, &p))))

}

pub async fn board(

    State(app): State<Shared>,

    headers: HeaderMap,

    Path((owner, number)): Path<(String, i64)>,

) -> Result<Json<Board>, ApiError> {

    let c = caller(&app, &headers).await?;

    let (_, p) = visible(&app, &c, &owner, number).await?;

    let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, false).await?;

        project: project_of(&app, &p),

        columns: columns

            .iter()

            .map(|col| ProjectColumn { id: col.column.id, name: col.column.name.clone(), cards: col.cards.iter().map(card_of).collect() })

            .collect(),

}

pub async fn edit(

    State(app): State<Shared>,

    headers: HeaderMap,

    Path((owner, number)): Path<(String, i64)>,

    Json(body): Json<ProjectEdit>,

) -> Result<Json<Project>, ApiError> {

    let (c, p) = changeable(&app, &headers, &owner, number, true).await?;

    let (owner, number) = match body.owner.as_deref().map(str::trim).filter(|to| !to.is_empty() && *to != owner) {

        None => (owner, number),

    let p = pdb::get(&app.db, &owner, number).await?.unwrap_or(p);

    let title = body.title.as_deref().map(str::trim).filter(|t| !t.is_empty()).unwrap_or(&p.title).chars().take(100).collect::<String>();

    pdb::set(

        &app.db,

        p.id,

        &title,

        body.description.as_deref().map(str::trim).unwrap_or(&p.description),

        body.private.map(|x| !x).unwrap_or(p.public),

        body.closed.unwrap_or(p.closed),

    .await?;

    let fresh = pdb::get(&app.db, &owner, number).await?.unwrap_or(p);

    Ok(Json(project_of(&app, &fresh)))

}

pub async fn cards(

    State(app): State<Shared>,

    headers: HeaderMap,

    Path((owner, number)): Path<(String, i64)>,

    Query(q): Query<CardsQuery>,

) -> Result<Json<Vec<ProjectColumn>>, ApiError> {

    if !q.archived {

        return Ok(Json(board(State(app), headers, Path((owner, number))).await?.0.columns));

    }

    let c = caller(&app, &headers).await?;

    let (_, p) = visible(&app, &c, &owner, number).await?;

    let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, true).await?;

        columns

            .iter()

            .map(|col| ProjectColumn { id: col.column.id, name: col.column.name.clone(), cards: col.cards.iter().map(card_of).collect() })

            .collect(),

}

pub async fn add_card(

    State(app): State<Shared>,

    headers: HeaderMap,

    Path((owner, number)): Path<(String, i64)>,

    Json(body): Json<NewCard>,

) -> Result<(StatusCode, Json<ProjectCard>), ApiError> {

    let (c, p) = changeable(&app, &headers, &owner, number, false).await?;

    let col = column(&app, p.id, body.column.as_deref()).await?;

    let actor = c.account.as_ref().map(|a| a.username.clone()).unwrap_or_default();

    let card = match wp::add_card(&app, c.account.as_ref(), &owner, p.id, col.id, &body.reference, "", &body.note, &actor).await? {

        Ok(card) => card,

        Err(why) => return Err(ApiError(StatusCode::BAD_REQUEST, why)),

    let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, false).await?;

    let view = columns

        .iter()

        .flat_map(|col| col.cards.iter())

        .find(|v| v.card.id == card.id)

        .map(card_of)

        .ok_or_else(|| not_found("no such card"))?;

    Ok((StatusCode::CREATED, Json(view)))

}

pub async fn move_card(

    State(app): State<Shared>,

    headers: HeaderMap,

    Path((owner, number, id)): Path<(String, i64, i64)>,

    Json(body): Json<CardMove>,

) -> Result<StatusCode, ApiError> {

    let (_, p) = changeable(&app, &headers, &owner, number, false).await?;

    let col = column(&app, p.id, Some(&body.column)).await?;

    if !pdb::cards(&app.db, p.id).await?.iter().any(|c| c.id == id) {

    }

    pdb::move_card(&app.db, p.id, id, col.id).await?;

    Ok(StatusCode::NO_CONTENT)

}

fn names_card(name: &str, card: &ProjectCard) -> bool {

    let name = name.trim();

    if name.is_empty() {

    }

    if name.parse::<i64>().is_ok_and(|id| id == card.id) {

    }

    let Some((_, number)) = card.reference.rsplit_once('#') else { return false };

    match name.rsplit_once('#') {

        Some(("", n)) => n == number,

        Some((repo, n)) => n == number && (card.reference == format!("{repo}#{n}") || card.reference.ends_with(&format!("/{repo}#{n}"))),

}

pub async fn move_cards(

    State(app): State<Shared>,

    headers: HeaderMap,

    Path((owner, number)): Path<(String, i64)>,

    Json(body): Json<CardsMove>,

) -> Result<Json<CardsMoved>, ApiError> {

    let (c, p) = changeable(&app, &headers, &owner, number, false).await?;

    let from = column(&app, p.id, Some(&body.from)).await?;

    let to = column(&app, p.id, Some(&body.column)).await?;

    if from.id == to.id {

        return Err(ApiError(StatusCode::BAD_REQUEST, "the cards are in that column already".into()));

    }

    let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, false).await?;

    let cards: Vec<ProjectCard> =

        columns.iter().filter(|col| col.column.id == from.id).flat_map(|col| col.cards.iter().map(card_of)).collect();

    let states: Vec<String> = body.state.iter().map(|s| s.trim().to_ascii_lowercase()).filter(|s| !s.is_empty()).collect();

    let (moved, kept): (Vec<ProjectCard>, Vec<ProjectCard>) = cards.into_iter().partition(|card| {

        !body.except.iter().any(|e| names_card(e, card)) && (states.is_empty() || states.iter().any(|s| card.state.eq_ignore_ascii_case(s)))

    });

    if !body.dry_run && !moved.is_empty() {

        let ids: Vec<i64> = moved.iter().map(|c| c.id).collect();

        pdb::move_cards(&app.db, p.id, &ids, to.id).await?;

        let detail = format!("{} card(s) from {} to {}", moved.len(), from.name, to.name);

        crate::db::accounts::audit(&app.db, c.account.as_ref(), "project.cards_moved", &format!("{owner}/{number}"), &detail).await.ok();

    }

    Ok(Json(CardsMoved { moved, kept, dry_run: body.dry_run }))

}

pub async fn archive_cards(

    State(app): State<Shared>,

    headers: HeaderMap,

    Path((owner, number)): Path<(String, i64)>,

    Json(body): Json<CardsArchive>,

) -> Result<Json<CardsArchived>, ApiError> {

    let (c, p) = changeable(&app, &headers, &owner, number, false).await?;

    let from = column(&app, p.id, Some(&body.from)).await?;

    if body.older_days.is_some_and(|d| !(0..=3650).contains(&d)) {

        return Err(ApiError(StatusCode::BAD_REQUEST, "older_days is 0 to 3650".into()));

    }

    let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, false).await?;

    let now = crate::db::now_ms();

    let states: Vec<String> = body.state.iter().map(|s| s.trim().to_ascii_lowercase()).filter(|s| !s.is_empty()).collect();

    let (archived, kept): (Vec<&wp::CardView>, Vec<&wp::CardView>) =

        columns.iter().filter(|col| col.column.id == from.id).flat_map(|col| col.cards.iter()).partition(|v| {

            let card = card_of(v);

            !body.except.iter().any(|e| names_card(e, &card))

                && (states.is_empty() || states.iter().any(|s| card.state.eq_ignore_ascii_case(s)))

                && body.older_days.is_none_or(|d| pdb::older_than(&v.card, d, now))

        });

    if !body.dry_run && !archived.is_empty() {

        let ids: Vec<i64> = archived.iter().map(|v| v.card.id).collect();

        pdb::archive_cards(&app.db, p.id, &ids).await?;

        let detail = format!("{} card(s) of {}", ids.len(), from.name);

        crate::db::accounts::audit(&app.db, c.account.as_ref(), "project.cards_archived", &format!("{owner}/{number}"), &detail).await.ok();

    }

    let stamp = |v: &wp::CardView| ProjectCard { archived_ms: (!body.dry_run).then_some(now), ..card_of(v) };

    Ok(Json(CardsArchived {

        archived: archived.into_iter().map(stamp).collect(),

        kept: kept.into_iter().map(card_of).collect(),

        dry_run: body.dry_run,

    }))

}

pub async fn restore_card(

    State(app): State<Shared>,

    headers: HeaderMap,

    Path((owner, number, id)): Path<(String, i64, i64)>,

) -> Result<StatusCode, ApiError> {

    let (_, p) = changeable(&app, &headers, &owner, number, false).await?;

    if !pdb::cards(&app.db, p.id).await?.iter().any(|c| c.id == id && c.archived_ms.is_some()) {

        return Err(not_found("no such archived card"));

    }

    pdb::restore_card(&app.db, p.id, id).await?;

    Ok(StatusCode::NO_CONTENT)

}

pub async fn remove_card(

    State(app): State<Shared>,

    headers: HeaderMap,

    Path((owner, number, id)): Path<(String, i64, i64)>,

) -> Result<StatusCode, ApiError> {

    let (_, p) = changeable(&app, &headers, &owner, number, false).await?;

    if !pdb::cards(&app.db, p.id).await?.iter().any(|c| c.id == id) {

        return Err(not_found("no such card"));

    }

    pdb::remove_card(&app.db, p.id, id).await?;

    Ok(StatusCode::NO_CONTENT)

}