Board cards show labels and assignees, and the board filters by them (refs #293) 6a306cd03fc1

- **Board cards show their labels and assignees, and the board filters by them (#293, filters):** an issue's or proposal's card shows its labels (each a link to the board filtered by it) and an issue's assignees; the filter takes `label:NAME`, `assignee:NAME` and `state:STATE` with words, as the issue list does, every term holding. The board reads what its cards show once per repository rather than once per card (a board of 300 cards made 300 queries). The API's cards and `oh project view` carry the labels and assignees too.

    /// The issue's or proposal's label names (oxygenhub#293).

    #[serde(default)]

    pub labels: Vec<String>,

    /// An issue's assignees' usernames.

    #[serde(default)]

    pub assignees: Vec<String>,

    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(),

    }

use crate::db::{self, issues as idb, projects as pdb};

    /// The issue's or proposal's labels, and an issue's assignees (#293).

    pub labels: Vec<idb::Label>,

    pub assignees: Vec<String>,

    /// Only cards whose title or reference holds these words, and with

    /// `label:NAME`, `assignee:NAME` or `state:STATE` as the issue list takes.

/// The board filter's `label:`, `assignee:` and `state:` terms, and its words.

#[derive(Default)]

struct CardFilter {

    labels: Vec<String>,

    assignees: Vec<String>,

    state: String,

    words: Vec<String>,

}

impl CardFilter {

    fn of(view: &BoardQuery) -> CardFilter {

        let mut f = CardFilter { state: view.state(), ..Default::default() };

        for tok in view.text().split_whitespace() {

            match tok.split_once(':') {

                Some(("label", v)) if !v.is_empty() => f.labels.push(v.to_lowercase()),

                Some(("assignee", v)) if !v.is_empty() => f.assignees.push(v.trim_start_matches('@').to_lowercase()),

                Some(("state", v)) if !v.is_empty() => f.state = v.to_lowercase(),

                _ => f.words.push(tok.to_lowercase()),

            }

        }

        f

    }

    fn is_empty(&self) -> bool {

        self.labels.is_empty() && self.assignees.is_empty() && self.state.is_empty() && self.words.is_empty()

    }

    /// Every term holds: each word in the title or reference, each label

    /// and assignee among the card's, and its state.

    fn keeps(&self, c: &CardView) -> bool {

        let (title, reference) = (c.title.to_lowercase(), c.reference.to_lowercase());

        self.words.iter().all(|w| title.contains(w) || reference.contains(w))

            && self.labels.iter().all(|l| c.labels.iter().any(|x| x.name.eq_ignore_ascii_case(l)))

            && self.assignees.iter().all(|a| c.assignees.iter().any(|x| x.eq_ignore_ascii_case(a)))

            && (self.state.is_empty() || c.state.eq_ignore_ascii_case(&self.state))

    }

}

    let filter = CardFilter::of(view);

        if !filter.is_empty() {

            col.cards.retain(|c| filter.keeps(c));

    // What the cards show, read once per repository, not per card: a

    // board of 300 cards made 300 queries.

    let mut shown: std::collections::HashMap<(i64, bool, i64), Shown> = Default::default();

    let mut repo_ids: Vec<(i64, bool)> =

        cards.iter().filter_map(|c| Some((c.repo_id?, c.kind == "issue"))).filter(|(rid, _)| readable.contains_key(rid)).collect();

    repo_ids.sort();

    repo_ids.dedup();

    for (rid, issues) in repo_ids {

        shown.extend(shown_in(app, rid, issues).await?.into_iter().map(|(n, s)| ((rid, issues, n), s)));

    }

                    labels: Vec::new(),

                    assignees: Vec::new(),

                    let Some(s) = shown.get(&(rid, kind == "issue", n)) else { continue };

                        title: s.title.clone(),

                        state: s.state.clone(),

                        labels: s.labels.clone(),

                        assignees: s.assignees.clone(),

}

/// What a card shows of an issue or a proposal.

struct Shown {

    title: String,

    state: String,

    labels: Vec<idb::Label>,

    assignees: Vec<String>,

}

/// A repository's issues (or proposals) as cards show them, by number.

async fn shown_in(app: &Shared, repo_id: i64, issues: bool) -> sqlx::Result<Vec<(i64, Shown)>> {

    use std::collections::HashMap;

    let mut out = Vec::new();

    if issues {

        let mut labels: HashMap<i64, Vec<idb::Label>> = HashMap::new();

        for (id, l) in idb::labels_by_issue(&app.db, repo_id).await? {

            labels.entry(id).or_default().push(l);

        }

        let mut assignees: HashMap<i64, Vec<String>> = HashMap::new();

        for (id, u) in idb::assignees_by_issue(&app.db, repo_id).await? {

            assignees.entry(id).or_default().push(u);

        }

        for i in idb::list(&app.db, repo_id).await? {

            let mut a = assignees.remove(&i.id).unwrap_or_default();

            a.sort();

            let s = Shown { labels: labels.remove(&i.id).unwrap_or_default(), assignees: a, title: i.title, state: i.state };

            out.push((i.number, s));

        }

    } else {

        let mut labels: HashMap<i64, Vec<idb::Label>> = HashMap::new();

        for (id, l) in idb::labels_by_proposal(&app.db, repo_id).await? {

            labels.entry(id).or_default().push(l);

        }

        for p in db::proposals::list(&app.db, repo_id, &[]).await? {

            let s = Shown { labels: labels.remove(&p.id).unwrap_or_default(), assignees: Vec::new(), title: p.title, state: p.state };

            out.push((p.number, s));

        }

    }

    Ok(out)

    assert_eq!((card["labels"].as_array().map(Vec::len), card["assignees"].as_array().map(Vec::len)), (Some(0), Some(0)), "{card}");

/// #293: a card shows its issue's labels and assignees, each a link to

/// the board filtered by it, and the filter takes `label:`, `assignee:`

/// and `state:` with words, every term holding.

async fn a_board_filters_by_label_and_assignee() {

    let h = hub().await;

    let app = &h.app;

    let andy = register(app, "andy").await;

    let csrf = csrf_of(&get(app, "/projects/andy", Some(&andy)).await.body);

    post(app, "/projects/andy", Some(&andy), &format!("_csrf={csrf}&title=Roadmap")).await;

    app.repos.create(&RepoName::parse("andy/game").unwrap(), None).unwrap();

    let row = db::repos::create(&app.db, "andy", "game", "", hub_api::Visibility::Public).await.unwrap();

    let mut ids = Vec::new();

    for title in ["Sound crackles", "Jump is floaty", "Title screen"] {

        let i = db::issues::create(&app.db, db::issues::NewIssue { repo_id: row.id, title, body: "", author_id: None, author: "andy" })

            .await

            .unwrap();

        ids.push(i.id);

    }

    let bug = db::issues::upsert_label(&app.db, row.id, "bug", "#d73a4a", "Something is wrong").await.unwrap();

    let feel = db::issues::upsert_label(&app.db, row.id, "feel", "#0e8a16", "").await.unwrap();

    db::issues::set_issue_label(&app.db, ids[0], bug.id, true).await.unwrap();

    db::issues::set_issue_label(&app.db, ids[1], bug.id, true).await.unwrap();

    db::issues::set_issue_label(&app.db, ids[1], feel.id, true).await.unwrap();

    let (andy_id,): (i64,) = sqlx::query_as("SELECT id FROM accounts WHERE username = 'andy'").fetch_one(&app.db).await.unwrap();

    db::issues::set_assignee(&app.db, ids[1], andy_id, true).await.unwrap();

    let (project, todo): (i64, i64) =

        sqlx::query_as("SELECT p.id, c.id FROM projects p JOIN project_columns c ON c.project_id = p.id ORDER BY c.position LIMIT 1")

            .fetch_one(&app.db)

            .await

            .unwrap();

    for n in 1..=3i64 {

        sqlx::query(

            "INSERT INTO project_cards (project_id, column_id, position, kind, repo_id, number, note, created_ms) VALUES ($1, $2, $3, 'issue', $4, $5, '', 0)",

        )

        .bind(project)

        .bind(todo)

        .bind(n)

        .bind(row.id)

        .bind(n)

        .execute(&app.db)

        .await

        .unwrap();

    }

    let board = get(app, "/projects/andy/1", Some(&andy)).await.body;

    assert!(board.contains("href=\"/projects/andy/1?q=label:bug\""), "{board}");

    assert!(board.contains("title=\"Something is wrong\">bug</a>"), "a label's description is its title");

    assert!(board.contains(">@andy</a>"), "{board}");

    let bugs = get(app, "/projects/andy/1?q=label:bug", Some(&andy)).await.body;

    assert!(bugs.contains("Sound crackles") && bugs.contains("Jump is floaty") && !bugs.contains("Title screen"), "{bugs}");

    assert!(bugs.contains("2 of 3"));

    let both = get(app, "/projects/andy/1?q=label:BUG+label:feel", Some(&andy)).await.body;

    assert!(!both.contains("Sound crackles") && both.contains("Jump is floaty"), "every label must hold");

    let mine = get(app, "/projects/andy/1?q=assignee:%40andy", Some(&andy)).await.body;

    assert!(mine.contains("Jump is floaty") && !mine.contains("Sound crackles"), "{mine}");

    let words = get(app, "/projects/andy/1?q=label:bug+sound", Some(&andy)).await.body;

    assert!(words.contains("Sound crackles") && !words.contains("Jump is floaty"));

    let closed = get(app, "/projects/andy/1?q=state:closed", Some(&andy)).await.body;

    assert!(closed.contains("0 of 3"), "{closed}");

}

#[tokio::test(flavor = "multi_thread")]

                    let mut tags: Vec<String> = card.labels.iter().map(|l| format!("[{l}]")).collect();

                    tags.extend(card.assignees.iter().map(|a| format!("@{a}")));

                    let tags = if tags.is_empty() { String::new() } else { format!("  {}", ui::dim(&tags.join(" "))) };

                    println!("  {} {what}{st}  {}{tags}", ui::dim(&format!("{:>4}", card.id)), card.title);

  <label class="visually-hidden" for="board-q">Filter cards</label><input type="search" id="board-q" name="q" value="{{ q }}" placeholder="filter: words, label:bug, assignee:andy" title="Words in the title or reference; label:NAME, assignee:NAME and state:STATE as on the issue list">

      <p class="small mute"><span class="glyph" aria-hidden="true">{% if c.card.kind == "issue" %}◇{% else %}⇄{% endif %}</span> {{ c.reference }} · <span class="state-{{ c.state }}">{{ c.state }}</span>{% for a in c.assignees %} · <a class="card-who" href="/projects/{{ project.owner }}/{{ project.number }}?q=assignee:{{ a|urlencode }}" title="Cards assigned to {{ a }}">@{{ a }}</a>{% endfor %}</p>

      {% if !c.labels.is_empty() %}<p class="card-labels">{% for l in c.labels %}<a class="label" style="--c: {{ l.colour }}" href="/projects/{{ project.owner }}/{{ project.number }}?q=label:{{ l.name|urlencode }}" title="{% if l.description.is_empty() %}Cards labelled {{ l.name }}{% else %}{{ l.description }}{% endif %}">{{ l.name }}</a>{% endfor %}</p>{% endif %}{% endif %}

.card-item .card-labels { display: flex; flex-wrap: wrap; gap: 4px; }

.card-item .card-labels .label { margin-right: 0; text-decoration: none; }

.card-item .card-labels .label:hover, .card-item .card-labels .label:focus-visible { background: color-mix(in srgb, var(--c, var(--acc)) 14%, transparent); }

.card-item .card-who { color: inherit; }