Finished work moves to Done 1000b40a2629

-- A board's column for finished work (#325): a card whose issue closes, or

-- whose proposal lands or closes, moves there. One per board at most; a

-- board's column named Done takes it to begin with.

ALTER TABLE project_columns ADD COLUMN takes_finished BOOLEAN NOT NULL DEFAULT FALSE;

UPDATE project_columns SET takes_finished = TRUE WHERE lower(name) = 'done';

-- A board's column for finished work (#325): a card whose issue closes, or

-- whose proposal lands or closes, moves there. One per board at most; a

-- board's column named Done takes it to begin with.

ALTER TABLE project_columns ADD COLUMN takes_finished INTEGER NOT NULL DEFAULT 0;

UPDATE project_columns SET takes_finished = 1 WHERE lower(name) = 'done';

- **Finished work moves to Done (#325):** a card whose issue closes (on its page, through the API, or by a change's `closes #N`), or whose proposal lands or closes, moves to its board's column for finished work. A new board's Done is that column, and so is each existing board's column named Done; a column's menu turns it on or off (one column of a board). Archived cards stay archived.

    if state == "closed" {

        finished(pool, "issues", id).await?;

    }

}

/// Move the cards of finished issue or proposal `id` of `table` (#325).

pub(super) async fn finished(pool: &Pool, table: &str, id: i64) -> sqlx::Result<()> {

    let at: Option<(i64, i64)> =

        sqlx::query_as(&format!("SELECT repo_id, number FROM {table} WHERE id = $1")).bind(id).fetch_optional(pool).await?;

    match at {

        Some((repo, number)) => super::projects::finished(pool, repo, number).await,

        None => Ok(()),

    }

    /// Cards whose issue closes or whose proposal lands or closes move here

    /// (#325); one column of a board at most.

    pub takes_finished: bool,

        sqlx::query("INSERT INTO project_columns (project_id, name, position, takes_finished) VALUES ($1, $2, $3, $4)")

            .bind(*name == "Done")

/// Make `column_id` the board's column for finished work, or none (#325).

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

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

    sqlx::query("UPDATE project_columns SET takes_finished = FALSE WHERE project_id = $1").bind(project_id).execute(&mut *tx).await?;

    if let Some(c) = column_id {

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

            .bind(c)

            .bind(project_id)

            .execute(&mut *tx)

            .await?;

    }

    tx.commit().await?;

    touch(pool, project_id).await

}

/// Issue or proposal `number` of `repo_id` is finished (closed, landed):

/// its cards move to their boards' column for finished work, where a board

/// has one (#325). Archived cards stay archived.

pub async fn finished(pool: &Pool, repo_id: i64, number: i64) -> sqlx::Result<()> {

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

        "SELECT c.id, c.project_id, c.column_id FROM project_cards c

         WHERE c.repo_id = $1 AND c.number = $2 AND c.kind <> 'note' AND c.archived_ms IS NULL",

    )

    .bind(repo_id)

    .bind(number)

    .fetch_all(pool)

    .await?;

    for (card, project, column) in cards {

        let to: Option<i64> =

            sqlx::query_scalar("SELECT id FROM project_columns WHERE project_id = $1 AND takes_finished ORDER BY position LIMIT 1")

                .bind(project)

                .fetch_optional(pool)

                .await?;

        if let Some(to) = to.filter(|to| *to != column) {

            move_card(pool, project, card, to).await?;

        }

    }

    Ok(())

}

    if state == "closed" || state == "landed" {

        super::issues::finished(pool, "proposals", id).await?;

    }

    super::issues::finished(pool, "proposals", id).await

        "takes_finished" => {

            let Some(col) = f.column else { return Err(Error::bad(shell, "no column")) };

            let name = columns.iter().find(|c| c.id == col).map(|c| c.name.clone()).unwrap_or_default();

            let on = f.mode == "on";

            pdb::set_takes_finished(&app.db, project.id, on.then_some(col)).await.map_err(e)?;

            notice = Some(if on {

                format!("Cards move to {name} when their issue closes or their proposal lands or closes.")

            } else {

                "Cards stay where they are when their issue closes or their proposal lands.".into()

            });

        }

/// #325: a card whose issue closes, or whose proposal lands or closes,

/// moves to its board's column for finished work, Done to begin with.

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

async fn finished_work_moves_to_its_column() {

    let h = hub().await;

    let app = &h.app;

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

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

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

    let mut issues = vec![];

    for t in ["closed here", "closed by a change", "stays open", "the column is off"] {

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

            .await

            .unwrap();

        issues.push(i);

    }

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

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

    let cols: Vec<(i64, String, bool)> =

        sqlx::query_as("SELECT id, name, takes_finished FROM project_columns ORDER BY position").fetch_all(&app.db).await.unwrap();

    assert_eq!(cols.iter().map(|c| c.2).collect::<Vec<_>>(), [false, false, true], "a new board's Done takes finished work");

    let (backlog, doing, done) = (cols[0].0, cols[1].0, cols[2].0);

    let act = |form: String| {

        let andy = andy.clone();

        async move { post(app, "/projects/andy/1", Some(&andy), &form).await }

    };

    for (i, col) in issues.iter().zip([backlog, doing, backlog, backlog]) {

        act(format!("_csrf={csrf}&action=add&column={col}&reference=demo%23{}", i.number)).await;

    }

    let column_of = |n: i64| async move {

        sqlx::query_scalar::<_, i64>("SELECT column_id FROM project_cards WHERE number = $1").bind(n).fetch_one(&app.db).await.unwrap()

    };

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

    assert!(page.contains("Finished work comes here") && page.contains("MOVE IT HERE"), "{page}");

    // Closed on its page, and by a change's `closes #N` (the same call).

    let issue = format!("/andy/demo/issue/{}", issues[0].number);

    let icsrf = csrf_of(&get(app, &issue, Some(&andy)).await.body);

    post(app, &format!("{issue}/state"), Some(&andy), &format!("_csrf={icsrf}&action=close")).await;

    assert_eq!(column_of(issues[0].number).await, done, "closed on its page");

    db::issues::set_state(&app.db, issues[1].id, "closed", "completed").await.unwrap();

    assert_eq!(column_of(issues[1].number).await, done, "from Doing too");

    assert_eq!(column_of(issues[2].number).await, backlog, "an open issue stays");

    // Off: nothing moves; Backlog can take it instead.

    let r = act(format!("_csrf={csrf}&action=takes_finished&column={done}&mode=off")).await;

    assert!(r.body.contains("Cards stay where they are"), "{}", r.body);

    db::issues::set_state(&app.db, issues[3].id, "closed", "not_planned").await.unwrap();

    assert_eq!(column_of(issues[3].number).await, backlog);

    let r = act(format!("_csrf={csrf}&action=takes_finished&column={doing}&mode=on")).await;

    assert!(r.body.contains("Cards move to Doing when their issue closes"), "{}", r.body);

    let flags: Vec<bool> =

        sqlx::query_scalar("SELECT takes_finished FROM project_columns ORDER BY position").fetch_all(&app.db).await.unwrap();

    assert_eq!(flags, [false, true, false], "one column of a board");

}

    <form class="col-archive" method="post" action="/projects/{{ project.owner }}/{{ project.number }}"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><input type="hidden" name="column" value="{{ col.column.id }}"><input type="hidden" name="action" value="takes_finished">

      {% if col.column.takes_finished %}<p class="small">Finished work comes here: a card moves here when its issue closes or its proposal lands or closes.</p><button name="mode" value="off" class="small">STOP</button>{% else %}<label>Finished work</label><button name="mode" value="on" class="small" title="A card moves here when its issue closes or its proposal lands or closes (one column of the board)">MOVE IT HERE</button>{% endif %}

    </form>