Lists: filters, sort orders, pages, and counts on the tabs 1ac84c62ba53

{% if pager.pages > 1 %}

<nav class="pager small" aria-label="Pages">

  {% if pager.page > 1 %}<a class="go" href="{{ pager.url(pager.page - 1) }}" rel="prev">← newer</a>{% endif %}

  <span class="mute">page {{ pager.page }} of {{ pager.pages }} · {{ pager.total }} in all</span>

  {% if pager.page < pager.pages %}<a class="go" href="{{ pager.url(pager.page + 1) }}" rel="next">older →</a>{% endif %}

</nav>

{% endif %}

/// Every proposal's labels in a repository, for filtering the list.

pub async fn labels_by_proposal(pool: &Pool, repo_id: i64) -> sqlx::Result<Vec<(i64, Label)>> {

    let rows: Vec<(i64, i64, i64, String, String, String)> = sqlx::query_as(

        "SELECT pl.proposal_id, l.id, l.repo_id, l.name, l.colour, l.description FROM proposal_labels pl JOIN labels l ON l.id = pl.label_id JOIN proposals p ON p.id = pl.proposal_id WHERE p.repo_id = ? ORDER BY l.name",

    )

    .bind(repo_id)

    .fetch_all(pool)

    .await?;

    Ok(rows

        .into_iter()

        .map(|(proposal_id, id, repo_id, name, colour, description)| (proposal_id, Label { id, repo_id, name, colour, description }))

        .collect())

}

    /// Counts for the tabs; filled by `get` only.

    #[sqlx(default)]

    pub open_issues: i64,

    #[sqlx(default)]

    pub open_proposals: i64,

/// One repository, with its open issue and proposal counts for the tabs.

    sqlx::query_as(

        "SELECT r.*, \

           (SELECT COUNT(*) FROM issues i WHERE i.repo_id = r.id AND i.state = 'open') AS open_issues, \

           (SELECT COUNT(*) FROM proposals p WHERE p.repo_id = r.id AND p.state IN ('open', 'draft')) AS open_proposals \

         FROM repositories r WHERE r.owner = ? AND r.name = ?",

    )

    .bind(owner)

    .bind(name)

    .fetch_optional(pool)

    .await

    sort: String,

    pager: super::Pager,

    sort: Option<String>,

    page: Option<usize>,

/// The list's sort orders: `newest` (pinned first, the default),

/// `oldest`, `updated`, `comments`.

pub const SORTS: &[(&str, &str)] =

    &[("newest", "newest"), ("oldest", "oldest"), ("updated", "recently updated"), ("comments", "most comments")];

    authors: Vec<String>,

    let mut f = Filter {

        state: state.unwrap_or_else(|| "open".into()),

        labels: vec![],

        assignees: vec![],

        authors: vec![],

        milestone: None,

        words: vec![],

    };

            Some(("author", v)) => f.authors.push(v.to_lowercase()),

            && (f.authors.is_empty() || f.authors.contains(&i.author.to_lowercase()))

    let sort = q.sort.filter(|s| SORTS.iter().any(|(k, _)| k == s)).unwrap_or_else(|| "newest".into());

    match sort.as_str() {

        "oldest" => rows.sort_by_key(|r| r.issue.number),

        "updated" => rows.sort_by_key(|r| std::cmp::Reverse(r.issue.updated_ms)),

        "comments" => rows.sort_by_key(|r| (std::cmp::Reverse(r.comments), std::cmp::Reverse(r.issue.number))),

        _ => {}

    }

    let pager = super::Pager::new(rows.len(), q.page, &[("state", &f.state), ("q", &qtext), ("sort", &sort)]);

    let rows = pager.slice(rows);

    Ok(Page(IssuesPage {

        shell,

        repo: RepoShell::new(&app, &row, "issues").with_role(role),

        rows,

        state: f.state,

        q: qtext,

        counts,

        sort,

        pager,

    }))

    /// Open issues and proposals, shown on their tabs.

    pub open_issues: i64,

    pub open_proposals: i64,

            open_issues: row.open_issues,

            open_proposals: row.open_proposals,

/// One page of a long list: which page, how many, and links that keep

/// the rest of the query.

#[derive(Clone, Debug)]

pub struct Pager {

    pub page: usize,

    pub pages: usize,

    pub total: usize,

    /// The query without `page`, each pair encoded, joined with `&`.

    query: String,

}

impl Pager {

    pub const PER_PAGE: usize = 25;

    /// `page` counts from 1; out-of-range pages clamp to the last.

    pub fn new(total: usize, page: Option<usize>, query: &[(&str, &str)]) -> Pager {

        let pages = total.div_ceil(Self::PER_PAGE).max(1);

        let page = page.unwrap_or(1).clamp(1, pages);

        let query = query

            .iter()

            .filter(|(_, v)| !v.is_empty())

            .map(|(k, v)| format!("{k}={}", settings::urlencode(v).replace('/', "%2F")))

            .collect::<Vec<_>>()

            .join("&");

        Pager { page, pages, total, query }

    }

    /// This page's items.

    pub fn slice<T>(&self, all: Vec<T>) -> Vec<T> {

        all.into_iter().skip((self.page - 1) * Self::PER_PAGE).take(Self::PER_PAGE).collect()

    }

    pub fn url(&self, page: usize) -> String {

        if self.query.is_empty() {

            format!("?page={page}")

        } else {

            format!("?{}&page={page}", self.query)

        }

    }

    /// The same query with another sort, back on page one.

    pub fn sorted(&self, sort: &str) -> String {

        let rest: Vec<&str> = self.query.split('&').filter(|p| !p.is_empty() && !p.starts_with("sort=")).collect();

        let mut q = rest.join("&");

        if !q.is_empty() {

            q.push('&');

        }

        format!("?{q}sort={sort}")

    }

}

    q: String,

    sort: String,

    pager: super::Pager,

    labels: std::collections::HashMap<i64, Vec<db::issues::Label>>,

impl ProposalsPage {

    fn labels_of(&self, id: &i64) -> &[db::issues::Label] {

        self.labels.get(id).map(Vec::as_slice).unwrap_or(&[])

    }

}

    q: Option<String>,

    sort: Option<String>,

    page: Option<usize>,

/// The list's sort orders.

pub const SORTS: &[(&str, &str)] = &[("updated", "recently updated"), ("newest", "newest"), ("oldest", "oldest")];

    let mut labels: std::collections::HashMap<i64, Vec<db::issues::Label>> = std::collections::HashMap::new();

    for (id, l) in db::issues::labels_by_proposal(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))? {

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

    }

    // `author:bob label:ui target:main words…`

    let qtext = q.q.clone().unwrap_or_default();

    let (mut authors, mut wanted, mut targets, mut words) = (vec![], vec![], vec![], vec![]);

    for tok in qtext.split_whitespace() {

        match tok.split_once(':') {

            Some(("author", v)) => authors.push(v.to_lowercase()),

            Some(("label", v)) => wanted.push(v.to_lowercase()),

            Some(("target", v)) => targets.push(v.to_string()),

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

        }

    }

    let mut rows: Vec<pdb::ProposalRow> = all

        .filter(|p| authors.is_empty() || authors.contains(&p.author.to_lowercase()))

        .filter(|p| targets.is_empty() || targets.contains(&p.target))

        .filter(|p| wanted.iter().all(|w| labels.get(&p.id).is_some_and(|ls| ls.iter().any(|l| l.name.to_lowercase() == *w))))

        .filter(|p| words.iter().all(|w| p.title.to_lowercase().contains(w) || p.body.to_lowercase().contains(w)))

    let sort = q.sort.filter(|s| SORTS.iter().any(|(k, _)| k == s)).unwrap_or_else(|| "updated".into());

    match sort.as_str() {

        "newest" => rows.sort_by_key(|p| std::cmp::Reverse(p.number)),

        "oldest" => rows.sort_by_key(|p| p.number),

        _ => rows.sort_by_key(|p| std::cmp::Reverse(p.updated_ms)),

    }

    let pager = super::Pager::new(rows.len(), q.page, &[("state", &filter), ("q", &qtext), ("sort", &sort)]);

    let rows = pager.slice(rows);

    Ok(Page(ProposalsPage {

        shell,

        repo: RepoShell::new(&app, &row, "proposals").with_role(role),

        rows,

        filter,

        counts,

        bookmarks,

        q: qtext,

        sort,

        pager,

        labels,

    }))

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

async fn lists_filter_sort_page_and_count() {

    let h = hub().await;

    let app = &h.app;

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

    let _bob = register(app, "bob").await;

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

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

    for n in 0..30 {

        let author = if n % 3 == 0 { "bob" } else { "andy" };

        db::issues::create(

            &app.db,

            db::issues::NewIssue { repo_id: repo.id, title: &format!("Issue number {n}"), body: "", author_id: None, author },

        )

        .await

        .unwrap();

    }

    let ui = db::issues::upsert_label(&app.db, repo.id, "ui", "#00f0ff", "").await.unwrap();

    for (title, author, target) in [("Faster menus", "bob", "main"), ("New theme", "andy", "main"), ("Release prep", "andy", "stable")] {

        let p = db::proposals::create(

            &app.db,

            db::proposals::NewProposal {

                repo_id: repo.id,

                title,

                body: "",

                author_id: None,

                author,

                draft: false,

                target,

                source_kind: "changes",

                source_repo_id: None,

                source_bookmark: "",

                source_changes: "",

            },

        )

        .await

        .unwrap();

        if title == "New theme" {

            db::issues::set_proposal_label(&app.db, p.id, ui.id, true).await.unwrap();

        }

    }

    // The tabs count what is open.

    let page = get(app, "/andy/demo/issues", Some(&andy)).await;

    assert!(page.body.contains(r#"Issues <span class="count-chip">30</span>"#), "{}", page.body);

    assert!(page.body.contains(r#"Proposals <span class="count-chip">3</span>"#));

    // Pages of 25, newest first; the second page holds the rest.

    let rows = |b: &str| b.matches("/andy/demo/issue/").count();

    assert_eq!(rows(&page.body), 25);

    assert!(page.body.contains("page 1 of 2") && page.body.contains("page=2"), "a pager");

    let second = get(app, "/andy/demo/issues?page=2", Some(&andy)).await;

    assert_eq!(rows(&second.body), 5);

    assert!(second.body.contains("Issue number 0<"), "the oldest are last");

    let oldest = get(app, "/andy/demo/issues?sort=oldest", Some(&andy)).await;

    assert!(oldest.body.find("Issue number 0<").unwrap() < oldest.body.find("Issue number 1<").unwrap());

    let bobs = get(app, "/andy/demo/issues?q=author:bob", Some(&andy)).await;

    assert_eq!(rows(&bobs.body), 10, "{}", bobs.body);

    // Proposals: by author, label and target.

    let by_bob = get(app, "/andy/demo/proposals?q=author:bob", Some(&andy)).await.body;

    assert!(by_bob.contains("Faster menus") && !by_bob.contains("New theme"));

    let ui_only = get(app, "/andy/demo/proposals?q=label:ui", Some(&andy)).await.body;

    assert!(ui_only.contains("New theme") && !ui_only.contains("Faster menus") && ui_only.contains(r#"class="label""#));

    let stable = get(app, "/andy/demo/proposals?q=target:stable", Some(&andy)).await.body;

    assert!(stable.contains("Release prep") && !stable.contains("New theme"));

}

| `/{owner}/{name}/proposals`, `/proposal/{n}` | §7. The list filters by state and by `q` (`author:`, `label:`, `target:` and words), sorts by recently updated (default), newest or oldest, and pages 25 at a time |

| `/{owner}/{name}/issues`, `/issue/{n}` | §8. The list filters by state and by `q` (`author:`, `label:`, `assignee:`, `milestone:` and words), sorts by newest (pinned first, default), oldest, recently updated or most comments, and pages 25 at a time. The Proposals and Issues tabs show how many are open |

  <form class="find" method="get" action="{{ repo.url }}/issues"><input type="search" name="q" value="{{ q }}" placeholder="Filter: text, author:bob, label:bug, assignee:andy, milestone:v1, state:closed"><input type="hidden" name="state" value="{{ state }}"><input type="hidden" name="sort" value="{{ sort }}"></form>

  <span class="modes small" aria-label="Sort">{% for (k, label) in crate::web::issues::SORTS %}<a href="{{ pager.sorted(k) }}"{% if sort == *k %} class="on"{% endif %}>{{ label }}</a>{% endfor %}</span>

{% include "pager.html" %}

    <a href="?state=open&amp;q={{ q }}"{% if filter == "open" %} class="on"{% endif %}>{{ counts.0 }} open</a>

    <a href="?state=landed&amp;q={{ q }}"{% if filter == "landed" %} class="on"{% endif %}>{{ counts.1 }} landed</a>

    <a href="?state=closed&amp;q={{ q }}"{% if filter == "closed" %} class="on"{% endif %}>{{ counts.2 }} closed</a>

<div class="bar">

  <form class="find" method="get" action="{{ repo.url }}/proposals"><input type="search" name="q" value="{{ q }}" placeholder="Filter: text, author:bob, label:ui, target:main"><input type="hidden" name="state" value="{{ filter }}"><input type="hidden" name="sort" value="{{ sort }}"></form>

  <span class="modes small" aria-label="Sort">{% for (k, label) in crate::web::proposals::SORTS %}<a href="{{ pager.sorted(k) }}"{% if sort == *k %} class="on"{% endif %}>{{ label }}</a>{% endfor %}</span>

</div>

      {% for l in labels_of(p.id) %}<span class="label" style="--c: {{ l.colour }}">{{ l.name }}</span>{% endfor %}

{% include "pager.html" %}

    <a href="{{ repo.url }}/proposals"{% if tab == "proposals" %} class="on"{% endif %}>Proposals{% if repo.open_proposals > 0 %} <span class="count-chip">{{ repo.open_proposals }}</span>{% endif %}</a>

    <a href="{{ repo.url }}/issues"{% if tab == "issues" %} class="on"{% endif %}>Issues{% if repo.open_issues > 0 %} <span class="count-chip">{{ repo.open_issues }}</span>{% endif %}</a>

.count-chip { display: inline-block; min-width: 1.6em; padding: 0 6px; margin-left: 4px; border-radius: 9px; background: var(--soft); color: var(--mute); font-size: 11px; text-align: center; }

.pager { display: flex; gap: 12px; align-items: center; justify-content: center; margin: 14px 0; }