GET /api/v1/user/proposals: the dashboard's proposals, for apps f4e138301198

- **`GET /api/v1/user/proposals` (repo:read):** the proposals the web dashboard lists, for apps: `review` (open ones by others in repositories the caller belongs to, not yet reviewed by them) and `authored` (their own open and drafts, in repositories they can still see), each with its repository, state, conflicts and web address. The Android app's dashboard shows them (oxygenhub-android#18).

/// `GET /user/proposals`: the caller's proposals to act on, as the web

/// dashboard lists them: open ones by others in repositories they belong

/// to that they have not reviewed yet, and their own open and draft ones.

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]

pub struct UserProposals {

    pub review: Vec<ProposalBrief>,

    pub authored: Vec<ProposalBrief>,

}

/// A proposal in a list across repositories.

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]

pub struct ProposalBrief {

    /// `owner/name`.

    pub repository: String,

    pub number: i64,

    pub title: String,

    pub author: String,

    pub state: ProposalState,

    pub conflicted: bool,

    pub updated_ms: i64,

    /// `https://hub/{owner}/{name}/proposal/{number}`.

    pub url: String,

}

        .route("/user/proposals", get(user_proposals))

/// `GET /user/proposals` (repo:read): what the dashboard lists, for apps.

async fn user_proposals(State(app): State<Shared>, headers: HeaderMap) -> Result<Json<UserProposals>, ApiError> {

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

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

    // As the dashboard: reviews in repositories the caller belongs to, its

    // own proposals in any it can still see.

    let member = db::accounts::visible_repo_ids(&app.db, me.id).await?;

    let seen: Vec<i64> = db::repos::list(&app.db)

        .await?

        .into_iter()

        .filter(|r| me.is_admin || r.visibility() != Visibility::Private || member.contains(&r.id))

        .map(|r| r.id)

        .collect();

    let base = app.config.base_url().trim_end_matches('/').to_string();

    let brief = |p: db::activity::ProposalLine| ProposalBrief {

        url: format!("{base}/{}/{}/proposal/{}", p.owner, p.name, p.number),

        repository: format!("{}/{}", p.owner, p.name),

        number: p.number,

        title: p.title,

        author: p.author,

        state: match p.state.as_str() {

            "draft" => ProposalState::Draft,

            "landed" => ProposalState::Landed,

            "closed" => ProposalState::Closed,

            _ => ProposalState::Open,

        },

        conflicted: p.conflicted,

        updated_ms: p.updated_ms,

    };

    Ok(Json(UserProposals {

        review: db::activity::awaiting_review(&app.db, me.id, &member).await?.into_iter().map(brief).collect(),

        authored: db::activity::authored(&app.db, me.id, &seen).await?.into_iter().map(brief).collect(),

    }))

}

    // The proposals to act on, as the dashboard lists them: bob's in andy's

    // repository is andy's to review and bob's own.

    let demo = oxygenhub::db::repos::get(&app.db, "andy", "demo").await.unwrap().unwrap();

    let bob_id = oxygenhub::db::accounts::account_by_name(&app.db, "bob").await.unwrap().unwrap().id;

    oxygenhub::db::proposals::create(

        &app.db,

        oxygenhub::db::proposals::NewProposal {

            repo_id: demo.id,

            title: "Faster startup",

            body: "",

            author_id: Some(bob_id),

            author: "bob",

            draft: false,

            target: "main",

            source_kind: "bookmark",

            source_repo_id: Some(demo.id),

            source_bookmark: "fast",

            source_changes: "",

        },

    )

    .await

    .unwrap();

    let (st, v) = api(app, "GET", "/api/v1/user/proposals", Some(&a), None).await;

    assert_eq!(st, StatusCode::OK, "{v}");

    assert_eq!((v["review"][0]["repository"].as_str(), v["review"][0]["number"].as_i64()), (Some("andy/demo"), Some(2)), "{v}");

    assert_eq!(v["review"][0]["state"], "open");

    assert!(v["review"][0]["url"].as_str().unwrap().ends_with("/andy/demo/proposal/2"));

    assert_eq!(v["authored"].as_array().map(Vec::len), Some(0));

    let (_, v) = api(app, "GET", "/api/v1/user/proposals", Some(&b), None).await;

    assert_eq!((v["review"].as_array().map(Vec::len), v["authored"][0]["title"].as_str()), (Some(0), Some("Faster startup")), "{v}");

    assert_eq!(api(app, "GET", "/api/v1/user/proposals", None, None).await.0, StatusCode::UNAUTHORIZED);