Board views: saved views, filter bar, lanes, WIP limits, table, keys, card history (refs #361) 0bc95135954d

-- Board views and history (oxygenhub#361, #357): a column's work-in-progress

-- limit; a board's saved views, each a layout with its filter, lanes and

-- sort; and every card's moves (added, moved, archived, restored, removed),

-- from which cumulative flow, cycle time and forecasts are drawn. A move to

-- no column (NULL) takes the card off the board. Cards already on boards

-- start their history where they are now.

ALTER TABLE project_columns ADD COLUMN wip_limit BIGINT;

CREATE TABLE project_views (

    id         BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,

    project_id BIGINT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,

    name       TEXT NOT NULL,

    layout     TEXT NOT NULL DEFAULT 'board',

    q          TEXT NOT NULL DEFAULT '',

    lane       TEXT NOT NULL DEFAULT '',

    sort       TEXT NOT NULL DEFAULT '',

    position   BIGINT NOT NULL,

    created_ms BIGINT NOT NULL,

    UNIQUE (project_id, name)

);

CREATE TABLE project_card_moves (

    id         BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,

    project_id BIGINT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,

    card_id    BIGINT NOT NULL,

    column_id  BIGINT,

    at_ms      BIGINT NOT NULL

);

CREATE INDEX project_card_moves_by_project ON project_card_moves (project_id, at_ms);

INSERT INTO project_card_moves (project_id, card_id, column_id, at_ms)

    SELECT project_id, id, column_id, moved_ms FROM project_cards;

INSERT INTO project_card_moves (project_id, card_id, column_id, at_ms)

    SELECT project_id, id, NULL, archived_ms FROM project_cards WHERE archived_ms IS NOT NULL;

-- Board views and history (oxygenhub#361, #357): a column's work-in-progress

-- limit; a board's saved views, each a layout with its filter, lanes and

-- sort; and every card's moves (added, moved, archived, restored, removed),

-- from which cumulative flow, cycle time and forecasts are drawn. A move to

-- no column (NULL) takes the card off the board. Cards already on boards

-- start their history where they are now.

ALTER TABLE project_columns ADD COLUMN wip_limit INTEGER;

CREATE TABLE project_views (

    id         INTEGER PRIMARY KEY,

    project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,

    name       TEXT NOT NULL,

    layout     TEXT NOT NULL DEFAULT 'board',

    q          TEXT NOT NULL DEFAULT '',

    lane       TEXT NOT NULL DEFAULT '',

    sort       TEXT NOT NULL DEFAULT '',

    position   INTEGER NOT NULL,

    created_ms INTEGER NOT NULL,

    UNIQUE (project_id, name)

);

CREATE TABLE project_card_moves (

    id         INTEGER PRIMARY KEY,

    project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,

    card_id    INTEGER NOT NULL,

    column_id  INTEGER,

    at_ms      INTEGER NOT NULL

);

CREATE INDEX project_card_moves_by_project ON project_card_moves (project_id, at_ms);

INSERT INTO project_card_moves (project_id, card_id, column_id, at_ms)

    SELECT project_id, id, column_id, moved_ms FROM project_cards;

INSERT INTO project_card_moves (project_id, card_id, column_id, at_ms)

    SELECT project_id, id, NULL, archived_ms FROM project_cards WHERE archived_ms IS NOT NULL;

## Unreleased

- **Board views (#361):** a board shows what matters now and other views of the same cards.

  - **Saved views** as tabs across the top: a layout with its filter, lanes and order, saved under a name and shared by its address (`?view=NAME`).

  - **One filter bar** for every view: words, `repo:`, `assignee:`, `label:`, `milestone:` (quote a title with spaces), `state:`, `is:open|closed`, `age:>14d` and `age:<7d`.

  - **Board**: swimlanes by repository, assignee, label or milestone; a **work-in-progress limit** per column, whose header turns to the warning colour past it; **Done shows this iteration's work** while one is open, saying how many cards finished before it; and **compact cards** (labels as dots).

  - **Table**: every card as a row (title, reference, state, column, assignees, labels, milestone, opened), sortable, grouped, a column changed in place, 50 rows a page.

  - **Keys**: `j`/`k` between cards, `Enter` opens one, `m` moves it, `/` filters.

  - **History**: every card's moves (added, moved, archived, restored, removed) are kept from now on, for the charts and forecasts of #357.

  - The API answers `GET /projects/{owner}/{n}?q=` or `?view=NAME` with the filter applied, and lists the board's views and each column's limit; `oh project view N --filter TEXT` or `--view NAME`.

// Board keys (oxygenhub#361): j/k move between cards, Enter opens one, m

// moves it (focuses its column choice), / goes to the filter. Not while

// typing in a field.

(function () {

  var filter = document.querySelector("[data-board-filter]");

  if (!filter) return;

  function cards() {

    return Array.prototype.slice.call(document.querySelectorAll(".card-item[data-card]"));

  }

  function typing(el) {

    return el && (el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT" || el.isContentEditable);

  }

  document.addEventListener("keydown", function (e) {

    if (e.ctrlKey || e.metaKey || e.altKey || typing(document.activeElement)) return;

    var list = cards();

    var at = list.indexOf(document.activeElement && document.activeElement.closest ? document.activeElement.closest(".card-item[data-card]") : null);

    if (e.key === "/") {

      e.preventDefault();

      filter.focus();

      filter.select();

    } else if (e.key === "j" || e.key === "k") {

      if (!list.length) return;

      e.preventDefault();

      var next = at < 0 ? 0 : Math.max(0, Math.min(list.length - 1, at + (e.key === "j" ? 1 : -1)));

      list[next].focus();

      list[next].scrollIntoView({ block: "nearest", inline: "nearest" });

    } else if (e.key === "Enter" && at >= 0) {

      var href = list[at].getAttribute("data-href");

      if (href) {

        e.preventDefault();

        window.location.href = href;

      }

    } else if (e.key === "m" && at >= 0) {

      var sel = list[at].querySelector("select[name=column]");

      if (sel) {

        e.preventDefault();

        if (list[at].closest(".compact")) list[at].querySelector(".card-actions").style.display = "flex";

        sel.focus();

      }

    }

  });

  // A table row's column choice moves the card when changed.

  document.querySelectorAll("select[data-autosubmit]").forEach(function (sel) {

    sel.addEventListener("change", function () {

      var form = sel.form;

      var btn = form && form.querySelector("button[name=action][value=move]");

      if (btn) btn.click();

    });

  });

})();

    /// Its work-in-progress limit, when it has one (#361).

    #[serde(default, skip_serializing_if = "Option::is_none")]

    pub wip_limit: Option<i64>,

/// A board's saved view (#361): `GET /projects/{owner}/{n}?view=NAME`

/// gives the board with its filter applied.

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

pub struct ProjectView {

    pub name: String,

    /// `board` or `table`.

    pub layout: String,

    pub q: String,

    #[serde(default)]

    pub lane: String,

    #[serde(default)]

    pub sort: String,

}

    /// Its saved views (#361).

    #[serde(default)]

    pub views: Vec<ProjectView>,

    /// The filter applied (`?q=`, or the `?view=`'s), when one was.

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

    pub filter: String,

        ("ProjectView", schemars::schema_for!(ProjectView)),

/// `GET /projects/{owner}/{n}`'s filter (#361): `q` as the board's filter

/// bar takes it, or the `view` saved under that name.

#[derive(serde::Deserialize, Default)]

pub struct BoardFilter {

    #[serde(default)]

    q: Option<String>,

    #[serde(default)]

    view: Option<String>,

}

    Query(f): Query<BoardFilter>,

    let (_, p) = visible(&app, &c, &owner, number).await?;

    let q = match (f.q, f.view) {

        (Some(q), _) => q,

        (None, Some(name)) => pdb::views(&app.db, p.id)

            .await?

            .into_iter()

            .find(|v| v.name == name)

            .map(|v| v.q)

            .ok_or_else(|| ApiError(StatusCode::NOT_FOUND, format!("no view {name}")))?,

        (None, None) => String::new(),

    };

    let Json(mut b) = board_of(&app, &c, &owner, number).await?;

    if !q.trim().is_empty() {

        let filter = wp::CardFilter::parse(&q);

        let now = crate::db::now_ms();

        let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, false).await?;

        for (out, col) in b.columns.iter_mut().zip(columns.iter()) {

            out.cards = col.cards.iter().filter(|card| filter.keeps(card, now)).map(card_of).collect();

        }

        b.filter = q.trim().to_string();

    }

    Ok(Json(b))

            .map(|col| ProjectColumn {

                id: col.column.id,

                name: col.column.name.clone(),

                cards: col.cards.iter().map(card_of).collect(),

                wip_limit: col.column.wip_limit,

            })

            .collect(),

        views: pdb::views(&app.db, p.id)

            .await?

            .into_iter()

            .map(|v| hub_api::ProjectView { name: v.name, layout: v.layout, q: v.q, lane: v.lane, sort: v.sort })

        filter: String::new(),

        return Ok(Json(board(State(app), headers, Path((owner, number)), Query(BoardFilter::default())).await?.0.columns));

            .map(|col| ProjectColumn {

                id: col.column.id,

                name: col.column.name.clone(),

                cards: col.cards.iter().map(card_of).collect(),

                wip_limit: col.column.wip_limit,

            })

    /// Work in progress past this many cards turns its header amber (#361).

    #[sqlx(default)]

    pub wip_limit: Option<i64>,

    log_moves(&mut *tx, Some(to.id), now_ms(), "column_id = $1 AND archived_ms IS NULL", &[column_id]).await?;

/// Record, for every card `select` picks (`SELECT project_id, id FROM

/// project_cards WHERE …`, bound from `$1` on), that it moved to `column`

/// (`None`: off the board) at `at` (#357). Called before the update that

/// moves them, with the same conditions.

async fn log_moves<'e, E: sqlx::Executor<'e, Database = super::Db>>(

    ex: E,

    column: Option<i64>,

    at: i64,

    select: &str,

    binds: &[i64],

) -> sqlx::Result<()> {

    let sql = format!(

        "INSERT INTO project_card_moves (project_id, card_id, column_id, at_ms) SELECT project_id, id, {}, {at} FROM project_cards WHERE {select}",

        match column {

            Some(c) => c.to_string(),

            None => "NULL".to_string(),

        }

    );

    let mut q = sqlx::query(&sql);

    for b in binds {

        q = q.bind(*b);

    }

    q.execute(ex).await?;

    Ok(())

}

/// A board's card moves since `since`, oldest first: (card, column or

/// `None` off the board, when).

pub async fn moves(pool: &Pool, project_id: i64, since: i64) -> sqlx::Result<Vec<(i64, Option<i64>, i64)>> {

    sqlx::query_as("SELECT card_id, column_id, at_ms FROM project_card_moves WHERE project_id = $1 AND at_ms >= $2 ORDER BY at_ms, id")

        .bind(project_id)

        .bind(since)

        .fetch_all(pool)

        .await

}

    let now = now_ms();

    let id: Option<i64> = sqlx::query_scalar(

        "INSERT INTO project_cards (project_id, column_id, position, kind, repo_id, number, note, added_by, created_ms, moved_ms) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $9) ON CONFLICT DO NOTHING RETURNING id",

    .bind(now)

    .fetch_optional(pool)

    if let Some(id) = id {

        log_moves(pool, Some(c.column_id), now, "id = $1", &[id]).await?;

    }

    Ok(id.is_some())

    let now = now_ms();

    log_moves(

        pool,

        Some(column_id),

        now,

        "id = $1 AND project_id = $2 AND column_id <> $3 AND archived_ms IS NULL",

        &[card_id, project_id, column_id],

    )

    .await?;

        .bind(now)

        log_moves(

            &mut *tx,

            Some(column_id),

            now,

            "id = $1 AND project_id = $2 AND column_id <> $3 AND archived_ms IS NULL",

            &[*id, project_id, column_id],

        )

        .await?;

        log_moves(&mut *tx, None, now, "id = $1 AND project_id = $2 AND archived_ms IS NULL", &[*id, project_id]).await?;

    sqlx::query(&format!(

        "INSERT INTO project_card_moves (project_id, card_id, column_id, at_ms) SELECT project_id, id, column_id, {now} FROM project_cards \

         WHERE id = $1 AND project_id = $2 AND archived_ms IS NOT NULL"

    ))

    .bind(card_id)

    .bind(project_id)

    .execute(&mut *tx)

    .await?;

        log_moves(&mut *tx, None, now, "project_id = $1 AND column_id = $2 AND archived_ms IS NULL", &[project_id, done]).await?;

/// The finished cards due for archiving: in a column with no setting of

/// its own, joined before `$1`, and their issue closed or proposal closed

/// or landed.

const FINISHED_DUE: &str = "archived_ms IS NULL AND moved_ms < $1 \

     AND EXISTS (SELECT 1 FROM project_columns c WHERE c.id = project_cards.column_id AND c.archive_after_days IS NULL) \

     AND ((kind = 'issue' AND EXISTS (SELECT 1 FROM issues i WHERE i.repo_id = project_cards.repo_id \

           AND i.number = project_cards.number AND i.state = 'closed')) \

       OR (kind = 'proposal' AND EXISTS (SELECT 1 FROM proposals p WHERE p.repo_id = project_cards.repo_id \

           AND p.number = project_cards.number AND p.state IN ('closed', 'landed'))))";

    log_moves(

        pool,

        None,

        now,

        "archived_ms IS NULL AND EXISTS (SELECT 1 FROM project_columns c WHERE c.id = project_cards.column_id \

         AND c.archive_after_days >= 0 AND project_cards.moved_ms < $1 - c.archive_after_days * $2)",

        &[now, DAY_MS],

    )

    .await?;

    log_moves(pool, None, now, FINISHED_DUE, &[now - FINISHED_KEPT_DAYS * DAY_MS]).await?;

    let finished = sqlx::query(&format!("UPDATE project_cards SET archived_ms = $2 WHERE {FINISHED_DUE}"))

        .bind(now - FINISHED_KEPT_DAYS * DAY_MS)

        .bind(now)

        .execute(pool)

        .await?;

    log_moves(pool, None, now_ms(), "id = $1 AND project_id = $2 AND archived_ms IS NULL", &[card_id, project_id]).await?;

}

/// A board's saved view (#361): a layout with its filter, lanes and sort.

#[derive(Clone, Debug, FromRow)]

pub struct View {

    pub id: i64,

    pub project_id: i64,

    pub name: String,

    /// `board` or `table`.

    pub layout: String,

    pub q: String,

    /// Swimlanes (board) or groups (table): `repo`, `assignee`, `label`,

    /// `milestone`, or empty.

    pub lane: String,

    /// The table's order: `title`, `reference`, `state`, `column`, `age`,

    /// a `-` before it for the reverse; empty is the board's order.

    pub sort: String,

    pub position: i64,

    pub created_ms: i64,

}

pub async fn views(pool: &Pool, project_id: i64) -> sqlx::Result<Vec<View>> {

    sqlx::query_as("SELECT * FROM project_views WHERE project_id = $1 ORDER BY position, id").bind(project_id).fetch_all(pool).await

}

/// Save a view under `name`, replacing the one of that name.

pub async fn save_view(pool: &Pool, project_id: i64, name: &str, layout: &str, q: &str, lane: &str, sort: &str) -> sqlx::Result<View> {

    let mut tx = super::begin_write(pool).await?;

    let existing: Option<i64> = sqlx::query_scalar("SELECT id FROM project_views WHERE project_id = $1 AND name = $2")

        .bind(project_id)

        .bind(name)

        .fetch_optional(&mut *tx)

        .await?;

    let v: View = match existing {

        Some(id) => {

            sqlx::query_as("UPDATE project_views SET layout = $1, q = $2, lane = $3, sort = $4 WHERE id = $5 RETURNING *")

                .bind(layout)

                .bind(q)

                .bind(lane)

                .bind(sort)

                .bind(id)

                .fetch_one(&mut *tx)

                .await?

        }

        None => {

            let pos: i64 = sqlx::query_scalar("SELECT COALESCE(MAX(position), -1) + 1 FROM project_views WHERE project_id = $1")

                .bind(project_id)

                .fetch_one(&mut *tx)

                .await?;

            sqlx::query_as(

                "INSERT INTO project_views (project_id, name, layout, q, lane, sort, position, created_ms) \

                 VALUES ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING *",

            )

            .bind(project_id)

            .bind(name)

            .bind(layout)

            .bind(q)

            .bind(lane)

            .bind(sort)

            .bind(pos)

            .bind(now_ms())

            .fetch_one(&mut *tx)

            .await?

        }

    };

    tx.commit().await?;

    touch(pool, project_id).await?;

    Ok(v)

}

pub async fn delete_view(pool: &Pool, project_id: i64, view_id: i64) -> sqlx::Result<bool> {

    let r = sqlx::query("DELETE FROM project_views WHERE id = $1 AND project_id = $2").bind(view_id).bind(project_id).execute(pool).await?;

    touch(pool, project_id).await?;

    Ok(r.rows_affected() == 1)

}

/// A column's work-in-progress limit (#361); `None` for none.

pub async fn set_wip_limit(pool: &Pool, project_id: i64, column_id: i64, limit: Option<i64>) -> sqlx::Result<()> {

    sqlx::query("UPDATE project_columns SET wip_limit = $1 WHERE id = $2 AND project_id = $3")

        .bind(limit)

        .bind(column_id)

        .bind(project_id)

        .execute(pool)

        .await?;

    touch(pool, project_id).await

#[derive(Clone)]

    /// Its repository's name, its milestone's title, and when the issue or

    /// proposal was opened (a note: when it was added), for the filter's

    /// `repo:`, `milestone:` and `age:` and for lanes (#361).

    pub repo: String,

    pub milestone: String,

    pub opened_ms: i64,

#[derive(Clone)]

    /// More cards than its work-in-progress limit (#361).

    pub over_wip: bool,

    /// Done cards that reached it before the open iteration began, left

    /// out: the board shows this iteration's done work (#361).

    pub before_iteration: usize,

#[derive(Deserialize, Default, Clone)]

    /// A saved view, by name (#361): its layout, filter, lanes and sort;

    /// what the address says besides wins.

    #[serde(default)]

    pub view: Option<String>,

    /// `board` (the default) or `table`.

    #[serde(default)]

    pub layout: Option<String>,

    /// Swimlanes or groups: `repo`, `assignee`, `label`, `milestone`.

    #[serde(default)]

    pub lane: Option<String>,

    /// The table's order (`title`, `reference`, `state`, `column`, `age`;

    /// `-` first to reverse).

    #[serde(default)]

    pub sort: Option<String>,

    /// Compact cards: title, reference, avatars, labels as dots.

    #[serde(default)]

    pub compact: Option<String>,

    /// The table's page, from 1.

    #[serde(default)]

    pub page: Option<usize>,

    /// This query over the saved view it names (#361): what the address

    /// gives wins, the view fills the rest.

    pub fn over(&self, saved: Option<&pdb::View>) -> BoardQuery {

        let mut q = self.clone();

        if let Some(v) = saved {

            let fill = |x: &mut Option<String>, from: &str| {

                if x.is_none() && !from.is_empty() {

                    *x = Some(from.to_string());

                }

            };

            fill(&mut q.q, &v.q);

            fill(&mut q.layout, &v.layout);

            fill(&mut q.lane, &v.lane);

            fill(&mut q.sort, &v.sort);

        }

        q

    }

    pub fn layout(&self) -> &str {

        match self.layout.as_deref() {

            Some("table") => "table",

            _ => "board",

        }

    }

    pub fn lane(&self) -> &str {

        self.lane.as_deref().filter(|l| matches!(*l, "repo" | "assignee" | "label" | "milestone")).unwrap_or("")

    }

    fn compact(&self) -> bool {

        self.compact.as_deref().is_some_and(|c| !c.is_empty() && c != "0")

    }

pub struct CardFilter {

    /// `repo:NAME`, `milestone:TITLE` (#361).

    repos: Vec<String>,

    milestones: Vec<String>,

    /// `is:open` (open or draft) or `is:closed` (closed or landed).

    is: String,

    /// `age:>14d` and `age:<7d`: opened more than, or less than, so many

    /// days ago.

    older_than_days: Option<i64>,

    newer_than_days: Option<i64>,

        let mut f = CardFilter::parse(&view.text());

        if f.state.is_empty() {

            f.state = view.state();

        }

        f

    }

    /// The filter bar's text (#361): words, and `label:`, `assignee:`,

    /// `state:`, `repo:`, `milestone:`, `is:open|closed` and `age:>Nd` or

    /// `age:<Nd`. A value with spaces takes quotes: `milestone:"Release 1"`.

    pub fn parse(text: &str) -> CardFilter {

        let mut f = CardFilter::default();

        for tok in tokens(text) {

                Some(("repo", v)) if !v.is_empty() => f.repos.push(v.rsplit('/').next().unwrap_or(v).to_lowercase()),

                Some(("milestone", v)) if !v.is_empty() => f.milestones.push(v.to_lowercase()),

                Some(("is", v)) if matches!(v, "open" | "closed") => f.is = v.to_string(),

                Some(("age", v)) if age_days(v).is_some() => match age_days(v) {

                    Some((true, d)) => f.older_than_days = Some(d),

                    Some((false, d)) => f.newer_than_days = Some(d),

                    None => {}

                },

    pub fn is_empty(&self) -> bool {

        self.labels.is_empty()

            && self.assignees.is_empty()

            && self.state.is_empty()

            && self.words.is_empty()

            && self.repos.is_empty()

            && self.milestones.is_empty()

            && self.is.is_empty()

            && self.older_than_days.is_none()

            && self.newer_than_days.is_none()

    /// and assignee among the card's, its state, repository, milestone and

    /// age.

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

        let age_days = (now - c.opened_ms) / DAY_MS;

            && self.repos.iter().all(|r| c.repo.eq_ignore_ascii_case(r))

            && self.milestones.iter().all(|m| c.milestone.eq_ignore_ascii_case(m))

            && match self.is.as_str() {

                "open" => matches!(c.state.as_str(), "open" | "draft"),

                "closed" => matches!(c.state.as_str(), "closed" | "landed"),

                _ => true,

            }

            && self.older_than_days.is_none_or(|d| age_days > d)

            && self.newer_than_days.is_none_or(|d| age_days < d)

    }

}

/// The filter bar's words, a quoted value kept whole (`milestone:"Release 1"`).

fn tokens(text: &str) -> Vec<String> {

    let mut out = Vec::new();

    let mut cur = String::new();

    let mut quoted = false;

    for ch in text.chars() {

        match ch {

            '"' => quoted = !quoted,

            c if c.is_whitespace() && !quoted => {

                if !cur.is_empty() {

                    out.push(std::mem::take(&mut cur));

                }

            }

            c => cur.push(c),

        }

    if !cur.is_empty() {

        out.push(cur);

    }

    out

/// `>14d` (older than 14 days: `(true, 14)`), `<7d` (newer: `(false, 7)`);

/// the `d` may be left off.

fn age_days(v: &str) -> Option<(bool, i64)> {

    let (older, rest) = match v.as_bytes().first()? {

        b'>' => (true, &v[1..]),

        b'<' => (false, &v[1..]),

        _ => return None,

    };

    let n: i64 = rest.trim_end_matches('d').parse().ok()?;

    (n >= 0).then_some((older, n))

}

/// Filter and cut the columns as `view` says. With an iteration open,

/// the Done column `done` shows the cards that reached it since the

/// iteration began (#361); the rest are counted.

fn shape(columns: &mut [ColumnView], view: &BoardQuery, now: i64, done: Option<i64>, since: Option<i64>) {

        if let (Some(d), Some(since), false) = (done, since, view.archived() || view.iteration.is_some()) {

            if col.column.id == d {

                let before = col.cards.len();

                col.cards.retain(|c| c.card.moved_ms >= since);

                col.before_iteration = before - col.cards.len();

                col.total = col.cards.len();

            }

        }

        col.over_wip = col.column.wip_limit.is_some_and(|w| w >= 0 && col.total as i64 > w);

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

}

/// A swimlane (#361): the board's columns with the cards of one

/// repository, assignee, label or milestone.

pub struct LaneView {

    pub name: String,

    pub columns: Vec<ColumnView>,

    pub count: usize,

/// The lanes a card belongs to under `lane`: one, or one per assignee or

/// label; those without one share a lane named for it.

fn lanes_of(c: &CardView, lane: &str) -> Vec<String> {

    let many = |v: Vec<String>, none: &str| if v.is_empty() { vec![none.to_string()] } else { v };

    match lane {

        "repo" => vec![if c.repo.is_empty() { "(notes)".into() } else { c.repo.clone() }],

        "assignee" => many(c.assignees.iter().map(|a| format!("@{a}")).collect(), "(nobody)"),

        "label" => many(c.labels.iter().map(|l| l.name.clone()).collect(), "(no label)"),

        "milestone" => vec![if c.milestone.is_empty() { "(no milestone)".into() } else { c.milestone.clone() }],

        _ => vec![String::new()],

    }

}

/// Split shaped columns into swimlanes by `lane`, named in order with

/// the lane of those without one last.

pub fn lanes(columns: &[ColumnView], lane: &str) -> Vec<LaneView> {

    let mut names: Vec<String> = columns.iter().flat_map(|col| col.cards.iter().flat_map(|c| lanes_of(c, lane))).collect();

    names.sort_by_key(|n| (n.starts_with('('), n.to_lowercase()));

    names.dedup();

    names

        .into_iter()

        .map(|name| {

            let columns: Vec<ColumnView> = columns

                .iter()

                .map(|col| {

                    let mut col = col.clone();

                    col.cards.retain(|c| lanes_of(c, lane).contains(&name));

                    col.total = col.cards.len();

                    col.hidden = 0;

                    col.before_iteration = 0;

                    col

                })

                .collect();

            let count = columns.iter().map(|c| c.cards.len()).sum();

            LaneView { name, columns, count }

        })

        .collect()

}

/// A card as a table row (#361), with its column and group.

pub struct RowView {

    pub c: CardView,

    pub column: String,

    pub column_id: i64,

    pub group: String,

    /// The first row of its group, which carries the group's heading.

    pub starts_group: bool,

}

/// Rows a table page shows.

pub const TABLE_PAGE: usize = 50;

/// Every shaped card as a row, grouped by `lane` and ordered by `sort`

/// (`title`, `reference`, `state`, `column`, `age`; a leading `-`

/// reverses), then the page `page` (from 1) of them and how many pages.

pub fn rows(columns: &[ColumnView], lane: &str, sort: &str, page: usize) -> (Vec<RowView>, usize) {

    let mut all: Vec<RowView> = Vec::new();

    for (ci, col) in columns.iter().enumerate() {

        for c in &col.cards {

            for group in lanes_of(c, lane) {

                all.push(RowView { c: c.clone(), column: col.column.name.clone(), column_id: ci as i64, group, starts_group: false });

            }

        }

    }

    let (desc, key) = match sort.strip_prefix('-') {

        Some(k) => (true, k),

        None => (false, sort),

    };

    all.sort_by(|a, b| {

        let by = match key {

            "title" => a.c.title.to_lowercase().cmp(&b.c.title.to_lowercase()),

            "reference" => a.c.reference.cmp(&b.c.reference),

            "state" => a.c.state.cmp(&b.c.state),

            "column" => a.column_id.cmp(&b.column_id),

            "age" => b.c.opened_ms.cmp(&a.c.opened_ms),

            _ => a.column_id.cmp(&b.column_id).then(a.c.card.position.cmp(&b.c.card.position)),

        };

        let by = if desc { by.reverse() } else { by };

        (a.group.starts_with('('), a.group.to_lowercase()).cmp(&(b.group.starts_with('('), b.group.to_lowercase())).then(by)

    });

    let pages = all.len().div_ceil(TABLE_PAGE).max(1);

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

    let mut shown: Vec<RowView> = all.into_iter().skip((page - 1) * TABLE_PAGE).take(TABLE_PAGE).collect();

    let mut last: Option<String> = None;

    for r in shown.iter_mut() {

        r.starts_group = !lane.is_empty() && last.as_ref() != Some(&r.group);

        last = Some(r.group.clone());

    }

    (shown, pages)

}

    /// The saved views as tabs, and the one shown (#361).

    views: Vec<pdb::View>,

    view_name: String,

    /// `board` or `table`; lanes or groups; the table's order; compact cards.

    layout: String,

    lane: String,

    sort: String,

    compact: bool,

    /// The board in swimlanes, when `lane` is set.

    lanes: Vec<LaneView>,

    /// The table's rows, page and pages.

    rows: Vec<RowView>,

    page: usize,

    pages: usize,

    /// The address's query for this look, without the page, for links.

    look: String,

    let views = pdb::views(&app.db, project.id).await.map_err(e)?;

    let saved = view.view.as_deref().and_then(|n| views.iter().find(|v| v.name == n));

    let look = view.over(saved);

    let view = &look;

    let open_since = iterations.iter().find(|i| i.closed_ms.is_none()).map(|i| i.start_ms);

    shape(&mut columns, view, now, done, open_since);

    let archived_total = columns.iter().map(|c| c.archived).sum();

    let (layout, lane, sort) = (view.layout().to_string(), view.lane().to_string(), view.sort.clone().unwrap_or_default());

    let lanes = if layout == "board" && !lane.is_empty() { lanes(&columns, &lane) } else { Vec::new() };

    let (rows, pages) = if layout == "table" { rows(&columns, &lane, &sort, view.page.unwrap_or(1)) } else { (Vec::new(), 1) };

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

    let mut parts: Vec<String> = Vec::new();

    for (k, v) in [

        ("view", view.view.clone().unwrap_or_default()),

        ("layout", if layout == "table" { layout.clone() } else { String::new() }),

        ("q", view.text()),

        ("lane", lane.clone()),

        ("sort", sort.clone()),

        ("compact", if view.compact() { "1".into() } else { String::new() }),

    ] {

        if !v.is_empty() {

            parts.push(format!("{k}={}", super::settings::urlencode(&v)));

        }

    }

    let look_query = parts.join("&");

        view_name: view.view.clone().filter(|n| views.iter().any(|v| &v.name == n)).unwrap_or_default(),

        views,

        layout,

        lane,

        sort,

        compact: view.compact(),

        lanes,

        rows,

        page,

        pages,

        look: look_query,

                    repo: String::new(),

                    milestone: String::new(),

                    opened_ms: card.created_ms,

                        repo: row.name.clone(),

                        milestone: s.milestone.clone(),

                        opened_ms: s.opened_ms,

        columns.push(ColumnView { column, cards: views, hidden: 0, total, archived, finished, over_wip: false, before_iteration: 0 });

    milestone: String,

    opened_ms: i64,

        let milestones: HashMap<i64, String> = idb::milestones(&app.db, repo_id).await?.into_iter().map(|m| (m.id, m.title)).collect();

            let milestone = i.milestone_id.and_then(|m| milestones.get(&m).cloned()).unwrap_or_default();

            let s = Shown {

                labels: labels.remove(&i.id).unwrap_or_default(),

                assignees: a,

                title: i.title,

                state: i.state,

                milestone,

                opened_ms: i.created_ms,

            };

            let s = Shown {

                labels: labels.remove(&p.id).unwrap_or_default(),

                assignees: Vec::new(),

                title: p.title,

                state: p.state,

                milestone: String::new(),

                opened_ms: p.created_ms,

            };

    /// A column's work-in-progress limit; empty for none (#361).

    #[serde(default)]

    limit: String,

    /// A view to save (with `name`): its layout, filter, lanes and order;

    /// or the id of one to delete (#361).

    #[serde(default)]

    layout: String,

    #[serde(default)]

    q: String,

    #[serde(default)]

    lane: String,

    #[serde(default)]

    sort: String,

    #[serde(default)]

    view: Option<i64>,

            }

        }

        "wip" => {

            let limit = f.limit.trim();

            match (column, limit.parse::<i64>()) {

                (Some(col), _) if limit.is_empty() => pdb::set_wip_limit(&app.db, project.id, col, None).await.map_err(e)?,

                (Some(col), Ok(n)) if (0..=999).contains(&n) => pdb::set_wip_limit(&app.db, project.id, col, Some(n)).await.map_err(e)?,

                _ => error = Some("A work-in-progress limit is a number of cards, 0 to 999, or empty for none.".into()),

            }

        }

        "save_view" => {

            let name: String = f.name.trim().chars().take(40).collect();

            let layout = if f.layout == "table" { "table" } else { "board" };

            let lane = if matches!(f.lane.as_str(), "repo" | "assignee" | "label" | "milestone") { f.lane.as_str() } else { "" };

            let sort: String = f.sort.trim().chars().take(20).collect();

            let q: String = f.q.trim().chars().take(300).collect();

            if name.is_empty() {

                error = Some("Name the view.".into());

            } else {

                pdb::save_view(&app.db, project.id, &name, layout, &q, lane, &sort).await.map_err(e)?;

                return Ok(Redirect::to(&format!("/projects/{owner}/{number}?view={}", super::settings::urlencode(&name))).into_response());

            }

        }

        "delete_view" => {

            if let Some(id) = f.view {

                pdb::delete_view(&app.db, project.id, id).await.map_err(e)?;

}

#[cfg(test)]

mod view_tests {

    use super::*;

    const NOW: i64 = 100 * DAY_MS;

    #[allow(clippy::too_many_arguments)]

    fn card(

        id: i64,

        title: &str,

        repo: &str,

        state: &str,

        assignees: &[&str],

        labels: &[&str],

        milestone: &str,

        age_days: i64,

    ) -> CardView {

        CardView {

            card: pdb::Card {

                id,

                project_id: 1,

                column_id: 1,

                position: id,

                kind: "issue".into(),

                repo_id: Some(1),

                number: Some(id),

                note: String::new(),

                added_by: String::new(),

                created_ms: 0,

                archived_ms: None,

                moved_ms: NOW - age_days * DAY_MS,

                iteration_id: None,

            },

            reference: format!("andy/{repo}#{id}"),

            url: format!("/andy/{repo}/issue/{id}"),

            title: title.into(),

            state: state.into(),

            labels: labels

                .iter()

                .map(|l| idb::Label { id: 0, repo_id: 1, name: (*l).into(), colour: "#123456".into(), description: String::new() })

                .collect(),

            assignees: assignees.iter().map(|a| (*a).to_string()).collect(),

            repo: repo.into(),

            milestone: milestone.into(),

            opened_ms: NOW - age_days * DAY_MS,

        }

    }

    fn column(id: i64, name: &str, wip: Option<i64>, cards: Vec<CardView>) -> ColumnView {

        ColumnView {

            column: pdb::Column {

                id,

                project_id: 1,

                name: name.into(),

                position: id,

                archive_after_days: None,

                takes_finished: name == "Done",

                wip_limit: wip,

            },

            total: cards.len(),

            cards,

            hidden: 0,

            archived: 0,

            finished: false,

            over_wip: false,

            before_iteration: 0,

        }

    }

    fn board() -> Vec<ColumnView> {

        vec![

            column(

                1,

                "Doing",

                Some(1),

                vec![

                    card(1, "Crash on start", "oxy", "open", &["andy"], &["bug"], "Release 1", 20),

                    card(2, "Faster pull", "hub", "open", &[], &["perf", "bug"], "", 3),

                ],

            ),

            column(2, "Done", None, vec![card(3, "Docs", "oxy", "closed", &["kim"], &[], "Release 1", 40)]),

        ]

    }

    fn keeps(q: &str) -> Vec<i64> {

        let f = CardFilter::parse(q);

        board().iter().flat_map(|c| c.cards.iter()).filter(|c| f.keeps(c, NOW)).map(|c| c.card.id).collect()

    }

    #[test]

    fn the_filter_bar_reads_every_term() {

        assert_eq!(keeps(""), [1, 2, 3]);

        assert_eq!(keeps("repo:oxy"), [1, 3]);

        assert_eq!(keeps("repo:andy/hub"), [2]);

        assert_eq!(keeps("assignee:@andy"), [1]);

        assert_eq!(keeps("label:bug label:perf"), [2]);

        assert_eq!(keeps(r#"milestone:"release 1""#), [1, 3]);

        assert_eq!(keeps("is:open"), [1, 2]);

        assert_eq!(keeps("is:closed"), [3]);

        assert_eq!(keeps("age:>14d"), [1, 3]);

        assert_eq!(keeps("age:<7"), [2]);

        assert_eq!(keeps("crash age:>14d"), [1]);

        assert_eq!(keeps("age:soon"), Vec::<i64>::new(), "an unreadable term is a word, which matches nothing");

        assert!(CardFilter::parse("  ").is_empty());

    }

    #[test]

    fn wip_limits_and_this_iterations_done() {

        let mut cols = board();

        cols[1].cards.push(card(4, "Old", "oxy", "closed", &[], &[], "", 1));

        cols[1].cards[1].card.moved_ms = NOW - 30 * DAY_MS;

        let q = BoardQuery::default();

        shape(&mut cols, &q, NOW, Some(2), Some(NOW - 50 * DAY_MS + 1));

        assert!(cols[0].over_wip, "two cards over a limit of one");

        assert!(!cols[1].over_wip);

        // An iteration that began 50 days ago: card 3 (in Done for 40 days)

        // and card 4 (30) both reached Done during it.

        assert_eq!((cols[1].cards.len(), cols[1].before_iteration), (2, 0));

        let mut cols = board();

        shape(&mut cols, &q, NOW, Some(2), Some(NOW - 10 * DAY_MS));

        assert_eq!((cols[1].cards.len(), cols[1].before_iteration, cols[1].total), (0, 1, 0), "done before it began");