GET /user/proposals?landable=true: the proposals the caller can land now (closes #311) 5d818ec7d5fc

- **`GET /api/v1/user/proposals?landable=true` (#311):** also lists the open proposals the caller could land now (in repositories they can write to, with no blockers, as each proposal's `landable` says), for the Android app to say when there is something to land. Only when asked for, since it works out each one's projected state.

    /// With `?landable=true` (#311): the open proposals the caller could

    /// land now, in repositories they can write to, with no blockers.

    #[serde(default, skip_serializing_if = "Vec::is_empty")]

    pub landable: Vec<ProposalBrief>,

}

/// `GET /user/proposals` query.

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

pub struct UserProposalsQuery {

    /// Also list what the caller can land now (slower: each proposal's

    /// projected state is worked out).

    #[serde(default)]

    pub landable: bool,

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

/// with `?landable=true`, also what the caller can land now (#311).

async fn user_proposals(

    State(app): State<Shared>,

    headers: HeaderMap,

    Query(q): Query<UserProposalsQuery>,

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

    let landable = if q.landable { landable_for(&app, &c, &member, &base).await? } else { Vec::new() };

        landable,

}

/// The open proposals the caller could land now (#311): in repositories

/// it belongs to and can write to, whose verdict has no blockers. Each

/// projected state is worked out four at a time, as `proposals` does

/// (#171); one that cannot be is left out rather than failing the list.

async fn landable_for(app: &Shared, c: &Caller, member: &[i64], base: &str) -> Result<Vec<ProposalBrief>, ApiError> {

    use futures::StreamExt;

    let mut todo = Vec::new();

    for row in db::repos::list(&app.db).await?.into_iter().filter(|r| member.contains(&r.id) && !r.is_drop()) {

        let role = auth::roles::role_for(&app.db, c.account.as_ref(), &row).await?;

        if !auth::roles::allows(role, Access::Write) {

            continue;

        }

        let Some(repo) = RepoName::new(&row.owner, &row.name) else { continue };

        for p in db::proposals::list(&app.db, row.id, &["open"]).await? {

            todo.push((repo.clone(), row.clone(), p));

        }

    }

    let found: Vec<Option<ProposalBrief>> = futures::stream::iter(todo)

        .map(|(repo, row, p)| {

            let (app, base) = (app.clone(), base.to_string());

            async move {

                let (number, title, author, updated_ms) = (p.number, p.title.clone(), p.author.clone(), p.updated_ms);

                let loaded = crate::web::proposals::load_summary(&app, &repo, p).await.ok()?;

                let v = crate::web::proposals::verdict(&app, &loaded, row.id).await.ok()?;

                v.blockers.is_empty().then(|| ProposalBrief {

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

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

                    number,

                    title,

                    author,

                    state: ProposalState::Open,

                    conflicted: loaded.conflicted,

                    updated_ms,

                })

            }

        })

        .buffered(4)

        .collect()

        .await;

    Ok(found.into_iter().flatten().collect())

    // Nothing to land yet for its owner (#311), and the list is only there when asked for.

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

    assert!(v.get("landable").is_none(), "{v}");

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

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

    assert!(api(app, "GET", "/api/v1/user/proposals", Some(&andy_ro), None).await.1.get("landable").is_none(), "only when asked");