Selected column and task now persist. Reworked the borrowing for task edit

sql/migrations.sql

@@ -18,10 +18,11 @@ create table if not exists kb_column
 );
 
 
-create table if not exists setting
+create table if not exists app_state
 (
     key text not null primary key,
     value text not null
 );
 
 insert into kb_column(name) values ("Todo"),("InProgress"),("Done"),("Ideas");
+insert into app_state(key, value) values ("selected_column", "0");

src/app.rs

@@ -12,7 +12,7 @@ mod tests;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Column {
-    pub id: i64,
+    pub id: i32,
     pub name: String,
     pub selected_task_idx: usize,
     pub tasks: Vec<Task>,
@@ -89,17 +89,6 @@ impl State<'_> {
 }
 
 impl<'a> Column {
-    #[must_use]
-    pub fn new(name: &str) -> Self {
-        Column {
-            // TODO: Get the right ID here
-            id: 1,
-            name: name.to_owned(),
-            tasks: vec![],
-            selected_task_idx: 0,
-        }
-    }
-
     pub fn add_task(&mut self, task: Task) {
         self.tasks.push(task);
         self.select_last_task();
@@ -188,11 +177,12 @@ impl Project {
     /// This function will return an error if it has issues reading from the database
     pub fn load(conn: &Connection) -> Result<Self, Box<dyn Error>> {
         let columns = db::get_all_columns(conn)?;
+        let selected_column = db::get_selected_column(conn);
 
         Ok(Project {
             name: String::from("Kanban Board"),
             columns,
-            selected_column_idx: 0,
+            selected_column_idx: selected_column,
         })
     }
 

src/db.rs

@@ -35,23 +35,19 @@ pub fn get_tasks_by_column(conn: &Connection, column_name: &String) -> Result<Ve
 ///
 /// This function will return an error if there are issues with the SQL
 pub fn get_all_columns(conn: &Connection) -> Result<Vec<Column>> {
-    let mut stmt = conn.prepare("select id, name from kb_column")?;
+    let mut stmt = conn.prepare("select id, name, selected_task from kb_column")?;
-    let query_rows = stmt.query_map((), |row| {
+    let columns = stmt
-        Ok((row.get::<usize, i64>(0)?, row.get::<usize, String>(1)?))
+        .query_map((), |row| {
-    })?;
+            let name = row.get(1)?;
-    let mut columns: Vec<Column> = Vec::new();
+            Ok(Column {
-    for row in query_rows {
+                id: row.get(0)?,
-        let r = &row?;
+                tasks: get_tasks_by_column(conn, &name)?,
-        let name = &r.1;
+                name,
-        let tasks = get_tasks_by_column(conn, name)?;
+                selected_task_idx: row.get(2)?,
-        let col = Column {
+            })
-            id: r.0,
+        })?
-            name: name.clone(),
+        .filter_map(Result::ok)
-            tasks,
+        .collect();
-            selected_task_idx: 0,
-        };
-        columns.push(col);
-    }
     Ok(columns)
 }
 
@@ -121,6 +117,7 @@ pub fn move_task_to_column(conn: &Connection, task: &Task, target_column: &Colum
         )
         .unwrap();
     stmt.execute((&task.id, &target_column.id)).unwrap();
+    set_selected_task_for_column(conn, target_column.selected_task_idx, target_column.id);
 }
 
 /// .
@@ -153,3 +150,44 @@ pub fn swap_task_order(conn: &mut Connection, task1: &Task, task2: &Task) {
 
     tx.commit().unwrap();
 }
+
+///
+/// Panics if something goes wrong with the SQL
+pub fn set_selected_column(conn: &Connection, column_id: usize) {
+    let mut stmt = conn
+        .prepare("insert or replace into app_state(key, value) values (?1, ?2)")
+        .unwrap();
+    stmt.execute((&"selected_column", column_id.to_string()))
+        .unwrap();
+}
+
+///
+/// Panics if something goes wrong with the SQL
+pub fn get_selected_column(conn: &Connection) -> usize {
+    let mut stmt = conn
+        .prepare("select value from app_state where key = ?1")
+        .unwrap();
+    stmt.query_row(&["selected_column"], |row| {
+        let value: String = row.get::<usize, String>(0).unwrap();
+        Ok(value.parse::<usize>().unwrap())
+    })
+    .unwrap()
+}
+
+///
+/// Panics if something goes wrong with the SQL
+pub fn set_selected_task_for_column(conn: &Connection, task_idx: usize, column_id: i32) {
+    let mut stmt = conn
+        .prepare("update kb_column set selected_task = ?2 where id = ?1")
+        .unwrap();
+    stmt.execute((column_id, task_idx)).unwrap();
+}
+
+///
+/// Panics if something goes wrong with the SQL
+pub fn get_selected_task_for_column(conn: &Connection, column_id: i32) -> usize {
+    let mut stmt = conn
+        .prepare("select selected_task from kb_column where key = ?1")
+        .unwrap();
+    stmt.query_row([column_id], |row| row.get(0)).unwrap()
+}

src/input.rs

@@ -1,11 +1,17 @@
 use crate::app::{State, TaskEditFocus, TaskState};
-use crate::db;
+use crate::{db, Column};
 use crossterm::event;
 use crossterm::event::{Event, KeyCode};
+use rusqlite::Connection;
 
-pub fn handle_task_edit(state: &mut State<'_>, key: event::KeyEvent, mut task: TaskState<'_>) {
+// pub fn handle_task_edit(state: &mut State<'_>, key: event::KeyEvent, mut task: TaskState<'_>) {
-    let project = &mut state.project;
+pub fn handle_task_edit(
-    let column = project.get_selected_column_mut();
+    db_conn: &Connection,
+    column: &mut Column,
+    key: event::KeyEvent,
+    task_opt: &mut Option<TaskState<'_>>,
+) {
+    let mut task = task_opt.as_mut().unwrap();
     match task.focus {
         // TODO: Handle wrapping around the enum rather than doing it manually
         TaskEditFocus::Title => match key.code {
@@ -33,13 +39,13 @@ pub fn handle_task_edit(state: &mut State<'_>, key: event::KeyEvent, mut task: T
                     if let Some(selected_task) = column.get_selected_task_mut() {
                         selected_task.title = title;
                         selected_task.description = description;
-                        db::update_task_text(&state.db_conn, selected_task);
+                        db::update_task_text(db_conn, selected_task);
                     }
                 } else {
-                    let task = db::insert_new_task(&state.db_conn, title, description, column);
+                    let task = db::insert_new_task(db_conn, title, description, column);
                     column.add_task(task);
                 }
-                state.task_edit_state = None;
+                *task_opt = None;
             }
             _ => (),
         },
@@ -47,7 +53,7 @@ pub fn handle_task_edit(state: &mut State<'_>, key: event::KeyEvent, mut task: T
             KeyCode::Tab => task.focus = TaskEditFocus::Title,
             KeyCode::BackTab => task.focus = TaskEditFocus::ConfirmBtn,
             KeyCode::Enter => {
-                state.task_edit_state = None;
+                *task_opt = None;
             }
             _ => (),
         },
@@ -61,14 +67,44 @@ pub fn handle_main(state: &mut State<'_>, key: event::KeyEvent) {
         KeyCode::Char('q') => state.quit = true,
         KeyCode::Char('h') | KeyCode::Left => {
             project.select_previous_column();
+            db::set_selected_column(&state.db_conn, project.selected_column_idx);
+        }
+        KeyCode::Char('j') | KeyCode::Down => {
+            column.select_next_task();
+            db::set_selected_task_for_column(
+                &state.db_conn,
+                column.selected_task_idx,
+                project.get_selected_column().id,
+            );
+        }
+        KeyCode::Char('k') | KeyCode::Up => {
+            column.select_previous_task();
+            db::set_selected_task_for_column(
+                &state.db_conn,
+                column.selected_task_idx,
+                project.get_selected_column().id,
+            );
         }
-        KeyCode::Char('j') | KeyCode::Down => column.select_next_task(),
-        KeyCode::Char('k') | KeyCode::Up => column.select_previous_task(),
         KeyCode::Char('l') | KeyCode::Right => {
             project.select_next_column();
+            db::set_selected_column(&state.db_conn, project.selected_column_idx);
+        }
+        KeyCode::Char('g') => {
+            column.select_first_task();
+            db::set_selected_task_for_column(
+                &state.db_conn,
+                column.selected_task_idx,
+                project.get_selected_column().id,
+            );
+        }
+        KeyCode::Char('G') => {
+            column.select_last_task();
+            db::set_selected_task_for_column(
+                &state.db_conn,
+                column.selected_task_idx,
+                project.get_selected_column().id,
+            );
         }
-        KeyCode::Char('g') => column.select_first_task(),
-        KeyCode::Char('G') => column.select_last_task(),
         KeyCode::Char('H') => {
             if !column.tasks.is_empty() {
                 project.move_task_previous_column();
@@ -90,6 +126,11 @@ pub fn handle_main(state: &mut State<'_>, key: event::KeyEvent) {
                 let task1 = column.get_selected_task().unwrap();
                 let task2 = column.get_previous_task().unwrap();
                 db::swap_task_order(&mut state.db_conn, task1, task2);
+                db::set_selected_task_for_column(
+                    &state.db_conn,
+                    column.selected_task_idx,
+                    project.get_selected_column().id,
+                );
             }
         }
         KeyCode::Char('K') => {
@@ -97,6 +138,11 @@ pub fn handle_main(state: &mut State<'_>, key: event::KeyEvent) {
                 let task1 = column.get_selected_task().unwrap();
                 let task2 = column.get_next_task().unwrap();
                 db::swap_task_order(&mut state.db_conn, task1, task2);
+                db::set_selected_task_for_column(
+                    &state.db_conn,
+                    column.selected_task_idx,
+                    project.get_selected_column().id,
+                );
             }
         }
         KeyCode::Char('n') => state.task_edit_state = Some(TaskState::default()),
@@ -107,6 +153,11 @@ pub fn handle_main(state: &mut State<'_>, key: event::KeyEvent) {
             if !column.tasks.is_empty() {
                 db::delete_task(&state.db_conn, column.get_selected_task().unwrap());
                 column.remove_task();
+                db::set_selected_task_for_column(
+                    &state.db_conn,
+                    column.selected_task_idx,
+                    project.get_selected_column().id,
+                );
             }
         }
         _ => {}
@@ -122,8 +173,9 @@ pub fn handle_main(state: &mut State<'_>, key: event::KeyEvent) {
 /// Shouldn't really panic because there are checks to ensure we can unwrap safely
 pub fn handle(state: &mut State<'_>) -> Result<(), std::io::Error> {
     if let Event::Key(key) = event::read()? {
-        if let Some(task) = state.task_edit_state.take() {
+        if let Some(_) = state.task_edit_state {
-            handle_task_edit(state, key, task);
+            let mut column = state.project.get_selected_column_mut();
+            handle_task_edit(&state.db_conn, &mut column, key, &mut state.task_edit_state);
         } else {
             handle_main(state, key);
         }