Coverage / crates/hub/src/api/drops.rs 94.4%

    fn from(e: DropError) -> ApiError {

        match e {

            DropError::Bad(m) => ApiError(StatusCode::UNPROCESSABLE_ENTITY, m),

    }

fn shape(app: &Shared, row: &db::repos::RepoRow, files: &[DropFile], content: bool) -> Drop {

    let base = app.config.base_url();

    let url = drops::url_of(row);

        id: drops::id_of(row).to_string(),

        owner: row.owner.clone(),

        title: row.title.clone(),

        description: row.description.clone(),

        visibility: drops::visibility_label(row).to_string(),

        url: format!("{base}{url}"),

        clone_url: format!("{base}{url}"),

        created_ms: row.created_ms,

        updated_ms: row.updated_ms,

        files: files

            .iter()

            .map(|f| hub_api::DropFile {

                name: f.path.clone(),

                size: f.size,

                content: if content { f.text.clone() } else { None },

                raw_url: format!("{base}{url}/raw/{}/{}", row.default_bookmark, f.path),

            })

            .collect(),

}

async fn listed(app: &Shared, rows: Vec<db::repos::RepoRow>) -> Result<Vec<Drop>, ApiError> {

    let mut out = Vec::with_capacity(rows.len());

    for row in rows {

        let files = drops::files(app, &row, "").await.map(|(_, f)| f).unwrap_or_default();

        out.push(shape(app, &row, &files, false));

    Ok(out)

}

pub(super) async fn mine(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<Vec<Drop>>, ApiError> {

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

    let me = c.require("repo:read")?.clone();

    let rows = db::repos::drops_of(&app.db, &me.username).await?;

    Ok(Json(listed(&app, rows).await?))

}

pub(super) async fn of_user(State(app): State<Shared>, headers: HeaderMap, Path(name): Path<String>) -> Result<Json<Vec<Drop>>, ApiError> {

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

    let account = db::accounts::account_by_name(&app.db, &name).await?.ok_or_else(|| not_found("no such user"))?;

    let rows: Vec<_> =

        db::repos::drops_of(&app.db, &account.username).await?.into_iter().filter(|r| drops::listed_to(c.account.as_ref(), r)).collect();

    Ok(Json(listed(&app, rows).await?))

}

pub(super) async fn create(

    State(app): State<Shared>,

    headers: HeaderMap,

    Json(body): Json<NewDrop>,

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

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

    let me = c.require("repo:write")?.clone();

    let files: Vec<NewFile> = body.files.into_iter().map(|f| NewFile { name: f.name, content: f.content }).collect();

    let row = drops::create(&app, &me, &body.title, &body.description, body.secret, &files).await?;

    let (_, files) = drops::files(&app, &row, "").await?;

    Ok((StatusCode::CREATED, Json(shape(&app, &row, &files, true))))

}

async fn row_of(app: &Shared, id: &str) -> Result<db::repos::RepoRow, ApiError> {

    if !crate::repos::names::valid_drop_id(id) {

    }

    db::repos::drop_by_id(&app.db, id).await?.ok_or_else(|| not_found("no such drop"))

}

pub(super) async fn view(State(app): State<Shared>, headers: HeaderMap, Path(id): Path<String>) -> Result<Json<Drop>, ApiError> {

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

    let row = row_of(&app, &id).await?;

    if c.account.as_ref().is_some_and(|a| a.blocked()) {

    }

    let (_, files) = drops::files(&app, &row, "").await?;

    Ok(Json(shape(&app, &row, &files, true)))

}

async fn writable(

    app: &Shared,

    headers: &HeaderMap,

    id: &str,

    deleting: bool,

) -> Result<(db::accounts::Account, db::repos::RepoRow), ApiError> {

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

    let me = c.require("repo:write")?.clone();

    let row = row_of(app, id).await?;

    let may = if deleting { drops::may_delete(Some(&me), &row) } else { drops::may_edit(Some(&me), &row) };

    if !may {

        return Err(super::forbidden(if deleting {

            "only the drop's owner or a site administrator may delete it"

            "only the drop's owner may change it"

    }

    Ok((me, row))

}

pub(super) async fn edit(

    State(app): State<Shared>,

    headers: HeaderMap,

    Path(id): Path<String>,

    Json(body): Json<DropEdit>,

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

    let (me, row) = writable(&app, &headers, &id, false).await?;

    let mut seen = Vec::new();

    let mut files = Vec::with_capacity(body.files.len());

    for f in body.files {

        let name = drops::check_name(&f.name).map_err(|m| ApiError(StatusCode::UNPROCESSABLE_ENTITY, m))?;

        if seen.contains(&name) {

        }

        seen.push(name.clone());

        files.push(oxy_core::repo::FileEdit { path: name, content: f.content.map(|c| c.replace("\r\n", "\n").into_bytes()) });

    let update = drops::Update {

        title: body.title.unwrap_or_else(|| row.title.clone()),

        description: body.description.unwrap_or_else(|| row.description.clone()),

        secret: body.secret.unwrap_or(row.visibility() != hub_api::Visibility::Public),

        files,

        message: body.message.unwrap_or_default(),

    drops::update(&app, &me, &row, update).await?;

    let row = db::repos::get_by_id(&app.db, row.id).await?.ok_or_else(|| not_found("no such drop"))?;

    let (_, files) = drops::files(&app, &row, "").await?;

    Ok(Json(shape(&app, &row, &files, true)))

}

pub(super) async fn delete(State(app): State<Shared>, headers: HeaderMap, Path(id): Path<String>) -> Result<StatusCode, ApiError> {

    let (me, row) = writable(&app, &headers, &id, true).await?;

    drops::delete(&app, &me, &row).await?;

    Ok(StatusCode::NO_CONTENT)

}