JosephFerano/kanban-tui
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

WIP Refactoring methods: Merge Project into State, add DBConn struct with impl

Browse Source
This commit is contained in:
Joseph Ferano 2023-06-14 19:13:24 +07:00
parent 4accf41c45
commit 71f12ec7f9
5 changed files with 279 additions and 309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
src/app.rs
View File

@ -2,7 +2,7 @@
// use int_enum::IntEnum;
use rusqlite::Connection;
use serde::{Deserialize, Serialize};
use std::{cmp::min, error::Error};
use std::cmp::min;
use tui_textarea::TextArea;
use crate::db;
@ -25,22 +25,6 @@ pub struct Task {
pub description: String,
}
/// Type used mainly for serialization at this time
#[derive(Deserialize, Serialize, Debug)]
pub struct Project {
pub name: String,
pub selected_column_idx: usize,
pub columns: Vec<Column>,
}
#[derive(Debug, thiserror::Error)]
pub enum KanbanError {
#[error("There is something wrong with the json schema, it doesn't match Project struct")]
BadJson,
#[error("IO - {0}")]
Io(#[from] std::io::Error),
}
#[derive(Debug)]
pub enum TaskEditFocus {
Title,
@ -68,24 +52,77 @@ impl Default for TaskState<'_> {
}
pub struct State<'a> {
pub project: Project,
pub db_conn: Connection,
pub quit: bool,
pub selected_column_idx: usize,
pub columns: Vec<Column>,
pub db_conn: db::DBConn,
pub quit: bool,
pub task_edit_state: Option<TaskState<'a>>,
}
impl State<'_> {
#[must_use]
pub fn new(db_pool: Connection, project: Project) -> Self {
pub fn new(conn: Connection) -> Self {
let db_conn = db::DBConn::new(conn);
let columns = db_conn.get_all_columns().unwrap();
let selected_column = db_conn.get_selected_column();
State {
columns,
selected_column_idx: selected_column,
quit: false,
task_edit_state: None,
db_conn: db_pool,
project,
columns: vec![],
db_conn,
}
}
#[must_use]
pub fn get_selected_column(&self) -> &Column {
&self.columns[self.selected_column_idx]
}
pub fn get_selected_column_mut(&mut self) -> &mut Column {
&mut self.columns[self.selected_column_idx]
}
pub fn select_previous_column(&mut self) -> &Column {
self.selected_column_idx = self.selected_column_idx.saturating_sub(1);
&self.columns[self.selected_column_idx]
}
pub fn select_next_column(&mut self) -> &Column {
self.selected_column_idx = min(self.selected_column_idx + 1, self.columns.len() - 1);
&self.columns[self.selected_column_idx]
}
fn move_task_to_column(&mut self, move_next: bool) {
let col_idx = self.selected_column_idx;
let cols_len = self.columns.len();
let column = self.get_selected_column_mut();
let cond = if move_next {
col_idx < cols_len - 1
} else {
col_idx > 0
};
if cond && !column.tasks.is_empty() {
let t = column.tasks.remove(column.selected_task_idx);
column.select_previous_task();
if move_next {
self.select_next_column();
} else {
self.select_previous_column();
}
let col = self.get_selected_column_mut();
col.tasks.push(t);
col.select_last_task();
}
}
pub fn move_task_previous_column(&mut self) {
self.move_task_to_column(false);
}
pub fn move_task_next_column(&mut self) {
self.move_task_to_column(true);
}
}
impl<'a> Column {
@ -168,71 +205,3 @@ impl<'a> Column {
})
}
}
impl Project {
/// .
///
/// # Errors
///
/// 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: selected_column,
})
}
#[must_use]
pub fn get_selected_column(&self) -> &Column {
&self.columns[self.selected_column_idx]
}
pub fn get_selected_column_mut(&mut self) -> &mut Column {
&mut self.columns[self.selected_column_idx]
}
pub fn select_previous_column(&mut self) -> &Column {
self.selected_column_idx = self.selected_column_idx.saturating_sub(1);
&self.columns[self.selected_column_idx]
}
pub fn select_next_column(&mut self) -> &Column {
self.selected_column_idx = min(self.selected_column_idx + 1, self.columns.len() - 1);
&self.columns[self.selected_column_idx]
}
fn move_task_to_column(&mut self, move_next: bool) {
let col_idx = self.selected_column_idx;
let cols_len = self.columns.len();
let column = self.get_selected_column_mut();
let cond = if move_next {
col_idx < cols_len - 1
} else {
col_idx > 0
};
if cond && !column.tasks.is_empty() {
let t = column.tasks.remove(column.selected_task_idx);
column.select_previous_task();
if move_next {
self.select_next_column();
} else {
self.select_previous_column();
}
let col = self.get_selected_column_mut();
col.tasks.push(t);
col.select_last_task();
}
}
pub fn move_task_previous_column(&mut self) {
self.move_task_to_column(false);
}
pub fn move_task_next_column(&mut self) {
self.move_task_to_column(true);
}
}

336
src/db.rs
View File

@ -1,112 +1,115 @@
use crate::{Column, Task};
use rusqlite::{params, Connection, Result};
/// .
///
/// # Errors
///
/// This function will return an error if something is wrong with the SQL
pub fn get_tasks_by_column(conn: &Connection, column_name: &String) -> Result<Vec<Task>> {
let mut stmt = conn.prepare(
r#"
pub struct DBConn(Connection);
impl DBConn {
pub fn new(conn: Connection) -> Self {
DBConn(conn)
}
/// .
///
/// # Errors
///
/// This function will return an error if something is wrong with the SQL
pub fn get_tasks_by_column(&self, column_name: &String) -> Result<Vec<Task>> {
let mut stmt = self.0.prepare(
r#"
select task.id, title, description from task
join kb_column on column_id = kb_column.id
where kb_column.name = ?1
order by sort_order
"#,
)?;
let mut tasks = Vec::new();
let rows = stmt.query_map([column_name], |row| {
Ok(Task {
id: row.get(0)?,
title: row.get(1)?,
description: row.get(2)?,
})
})?;
for row in rows {
tasks.push(row?);
}
Ok(tasks)
}
/// .
///
/// # Errors
///
/// 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, selected_task from kb_column")?;
let columns = stmt
.query_map((), |row| {
let name = row.get(1)?;
Ok(Column {
)?;
let mut tasks = Vec::new();
let rows = stmt.query_map([column_name], |row| {
Ok(Task {
id: row.get(0)?,
tasks: get_tasks_by_column(conn, &name)?,
name,
selected_task_idx: row.get(2)?,
title: row.get(1)?,
description: row.get(2)?,
})
})?
.filter_map(Result::ok)
.collect();
Ok(columns)
}
/// .
///
/// # Panics
///
/// Panics if something goes wrong with the SQL
pub fn insert_new_task(
conn: &Connection,
title: String,
description: String,
column: &Column,
) -> Task {
let mut stmt = conn
.prepare("insert into task(title, description, column_id) values (?1, ?2, ?3)")
.unwrap();
stmt.execute(params![title, description, column.id])
.unwrap();
let id = conn.last_insert_rowid();
Task {
id,
title,
description,
})?;
for row in rows {
tasks.push(row?);
}
Ok(tasks)
}
}
/// .
///
/// # Panics
///
/// Panics if something goes wrong with the SQL
pub fn delete_task(conn: &Connection, task: &Task) {
let mut stmt = conn.prepare("delete from task where id = ?1").unwrap();
stmt.execute([task.id]).unwrap();
}
/// .
///
/// # Errors
///
/// This function will return an error if there are issues with the SQL
pub fn get_all_columns(&self) -> Result<Vec<Column>> {
let mut stmt = self.0.prepare("select id, name, selected_task from kb_column")?;
let columns = stmt
.query_map((), |row| {
let name = row.get(1)?;
Ok(Column {
id: row.get(0)?,
tasks: self.get_tasks_by_column(&name)?,
name,
selected_task_idx: row.get(2)?,
})
})?
.filter_map(Result::ok)
.collect();
Ok(columns)
}
/// .
///
/// # Panics
///
/// Panics if something goes wrong with the SQL
pub fn update_task_text(conn: &Connection, task: &Task) {
let mut stmt = conn
.prepare("update task set title = ?2, description = ?3 where id = ?1")
.unwrap();
stmt.execute((&task.id, &task.title, &task.description))
.unwrap();
}
/// .
///
/// # Panics
///
/// Panics if something goes wrong with the SQL
pub fn insert_new_task(&self, title: String, description: String, column: &Column) -> Task {
let mut stmt = self
.0
.prepare("insert into task(title, description, column_id) values (?1, ?2, ?3)")
.unwrap();
stmt.execute(params![title, description, column.id])
.unwrap();
let id = self.0.last_insert_rowid();
Task {
id,
title,
description,
}
}
/// .
///
/// # Panics
///
/// Panics if something goes wrong with the SQL
pub fn move_task_to_column(conn: &Connection, task: &Task, target_column: &Column) {
let mut stmt = conn
.prepare(
"update task
/// .
///
/// # Panics
///
/// Panics if something goes wrong with the SQL
pub fn delete_task(&self, task: &Task) {
let mut stmt = self.0.prepare("delete from task where id = ?1").unwrap();
stmt.execute([task.id]).unwrap();
}
/// .
///
/// # Panics
///
/// Panics if something goes wrong with the SQL
pub fn update_task_text(&self, task: &Task) {
let mut stmt = self.0
.prepare("update task set title = ?2, description = ?3 where id = ?1")
.unwrap();
stmt.execute((&task.id, &task.title, &task.description))
.unwrap();
}
/// .
///
/// # Panics
///
/// Panics if something goes wrong with the SQL
pub fn move_task_to_column(&self, task: &Task, target_column: &Column) {
let mut stmt = self.0
.prepare(
"update task
set
column_id = ?2,
sort_order = coalesce(1 +
@ -114,84 +117,85 @@ pub fn move_task_to_column(conn: &Connection, task: &Task, target_column: &Colum
where column_id = ?2 order by sort_order desc limit 1),
0)
where task.id = ?1",
)
.unwrap();
stmt.execute((&task.id, &target_column.id)).unwrap();
self.set_selected_task_for_column(target_column.selected_task_idx, target_column.id);
}
/// .
///
/// # Panics
///
/// Panics if something goes wrong with the SQL
pub fn swap_task_order(&mut self, task1: &Task, task2: &Task) {
let tx = self.0.transaction().unwrap();
tx.execute(
"create temp table temp_order as select sort_order from task where id = ?1",
[&task1.id],
)
.unwrap();
stmt.execute((&task.id, &target_column.id)).unwrap();
set_selected_task_for_column(conn, target_column.selected_task_idx, target_column.id);
}
/// .
///
/// # Panics
///
/// Panics if something goes wrong with the SQL
pub fn swap_task_order(conn: &mut Connection, task1: &Task, task2: &Task) {
let tx = conn.transaction().unwrap();
tx.execute(
"create temp table temp_order as select sort_order from task where id = ?1",
[&task1.id],
)
.unwrap();
tx.execute(
"update task set sort_order = (select sort_order from task where id = ?2)
tx.execute(
"update task set sort_order = (select sort_order from task where id = ?2)
where id = ?1",
(task1.id, task2.id),
)
.unwrap();
tx.execute(
"update task set sort_order = (select sort_order from temp_order) where id = ?1",
[&task2.id],
)
.unwrap();
tx.execute("drop table temp_order", ()).unwrap();
tx.commit().unwrap();
}
/// # Panics
///
/// 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)")
(task1.id, task2.id),
)
.unwrap();
stmt.execute((&"selected_column", column_id.to_string()))
.unwrap();
}
/// # Panics
///
/// 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")
tx.execute(
"update task set sort_order = (select sort_order from temp_order) where id = ?1",
[&task2.id],
)
.unwrap();
stmt.query_row(["selected_column"], |row| {
let value: String = row.get::<usize, String>(0).unwrap();
Ok(value.parse::<usize>().unwrap())
})
.unwrap()
}
tx.execute("drop table temp_order", ()).unwrap();
/// # Panics
///
/// 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();
}
tx.commit().unwrap();
}
/// # Panics
///
/// 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()
/// # Panics
///
/// Panics if something goes wrong with the SQL
pub fn set_selected_column(&self, column_id: usize) {
let mut stmt = self.0
.prepare("insert or replace into app_state(key, value) values (?1, ?2)")
.unwrap();
stmt.execute((&"selected_column", column_id.to_string()))
.unwrap();
}
/// # Panics
///
/// Panics if something goes wrong with the SQL
pub fn get_selected_column(&self) -> usize {
let mut stmt = self.0
.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
///
/// Panics if something goes wrong with the SQL
pub fn set_selected_task_for_column(&self, task_idx: usize, column_id: i32) {
let mut stmt = self.0
.prepare("update kb_column set selected_task = ?2 where id = ?1")
.unwrap();
stmt.execute((column_id, task_idx)).unwrap();
}
/// # Panics
///
/// Panics if something goes wrong with the SQL
pub fn get_selected_task_for_column(&self, column_id: i32) -> usize {
let mut stmt = self.0
.prepare("select selected_task from kb_column where key = ?1")
.unwrap();
stmt.query_row([column_id], |row| row.get(0)).unwrap()
}
}

80
src/input.rs
View File

@ -2,11 +2,10 @@ use crate::app::{State, TaskEditFocus, TaskState};
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(
db_conn: &Connection,
db_conn: &db::DBConn,
column: &mut Column,
key: event::KeyEvent,
task_opt: &mut Option<TaskState<'_>>,
@ -39,12 +38,12 @@ pub fn handle_task_edit(
if let Some(selected_task) = column.get_selected_task_mut() {
selected_task.title = title;
selected_task.description = description;
db::update_task_text(db_conn, selected_task);
db_conn.update_task_text(selected_task);
}
} else {
let task = db::insert_new_task(db_conn, title, description, column);
let task = db_conn.insert_new_task(title, description, column);
column.add_task(task);
db::set_selected_task_for_column(db_conn, column.selected_task_idx, column.id);
db_conn.set_selected_task_for_column(column.selected_task_idx, column.id);
}
*task_opt = None;
}
@ -62,95 +61,94 @@ pub fn handle_task_edit(
}
pub fn handle_main(state: &mut State<'_>, key: event::KeyEvent) {
let project = &mut state.project;
let column = project.get_selected_column_mut();
let column = state.get_selected_column_mut();
match key.code {
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);
state.select_previous_column();
state.db_conn.set_selected_column(state.selected_column_idx);
}
KeyCode::Char('j') | KeyCode::Down => {
column.select_next_task();
let task_idx = column.selected_task_idx;
let col_id = project.get_selected_column().id;
db::set_selected_task_for_column(&state.db_conn, task_idx, col_id);
let col_id = state.get_selected_column().id;
state.db_conn.set_selected_task_for_column(task_idx, col_id);
}
KeyCode::Char('k') | KeyCode::Up => {
column.select_previous_task();
let task_idx = column.selected_task_idx;
let col_id = project.get_selected_column().id;
db::set_selected_task_for_column(&state.db_conn, task_idx, col_id);
let col_id = state.get_selected_column().id;
state.db_conn.set_selected_task_for_column(task_idx, col_id);
}
KeyCode::Char('l') | KeyCode::Right => {
project.select_next_column();
db::set_selected_column(&state.db_conn, project.selected_column_idx);
state.select_next_column();
state.db_conn.set_selected_column(state.selected_column_idx);
}
KeyCode::Char('g') => {
column.select_first_task();
let task_idx = column.selected_task_idx;
let col_id = project.get_selected_column().id;
db::set_selected_task_for_column(&state.db_conn, task_idx, col_id);
let col_id = state.get_selected_column().id;
state.db_conn.set_selected_task_for_column(task_idx, col_id);
}
KeyCode::Char('G') => {
column.select_last_task();
let task_idx = column.selected_task_idx;
let col_id = project.get_selected_column().id;
db::set_selected_task_for_column(&state.db_conn, task_idx, col_id);
let col_id = state.get_selected_column().id;
state.db_conn.set_selected_task_for_column(task_idx, col_id);
}
KeyCode::Char('H') => {
if !column.tasks.is_empty() {
let first_col = project.get_selected_column_mut();
let first_col = state.get_selected_column_mut();
let task_idx = first_col.selected_task_idx.saturating_sub(1);
db::set_selected_task_for_column(&state.db_conn, task_idx, first_col.id);
project.move_task_previous_column();
let col = project.get_selected_column();
state.db_conn.set_selected_task_for_column(task_idx, first_col.id);
state.move_task_previous_column();
let col = state.get_selected_column();
let t = col.get_selected_task().unwrap();
db::move_task_to_column(&state.db_conn, t, col);
db::set_selected_column(&state.db_conn, project.selected_column_idx);
state.db_conn.move_task_to_column(t, col);
state.db_conn.set_selected_column(state.selected_column_idx);
}
}
KeyCode::Char('L') => {
if !column.tasks.is_empty() {
let first_col = project.get_selected_column_mut();
let first_col = state.get_selected_column_mut();
let task_idx = first_col.selected_task_idx.saturating_sub(1);
db::set_selected_task_for_column(&state.db_conn, task_idx, first_col.id);
project.move_task_next_column();
let col = project.get_selected_column();
state.db_conn.set_selected_task_for_column(task_idx, first_col.id);
state.move_task_next_column();
let col = state.get_selected_column();
let t = col.get_selected_task().unwrap();
db::move_task_to_column(&state.db_conn, t, col);
db::set_selected_column(&state.db_conn, project.selected_column_idx);
state.db_conn.move_task_to_column(t, col);
state.db_conn.set_selected_column(state.selected_column_idx);
}
}
KeyCode::Char('J') => {
if column.move_task_down() {
let task1 = column.get_selected_task().unwrap();
let task2 = column.get_previous_task().unwrap();
db::swap_task_order(&mut state.db_conn, task1, task2);
state.db_conn.swap_task_order(task1, task2);
let task_idx = column.selected_task_idx;
let col_id = project.get_selected_column().id;
db::set_selected_task_for_column(&state.db_conn, task_idx, col_id);
let col_id = state.get_selected_column().id;
state.db_conn.set_selected_task_for_column(task_idx, col_id);
}
}
KeyCode::Char('K') => {
if column.move_task_up() {
let task1 = column.get_selected_task().unwrap();
let task2 = column.get_next_task().unwrap();
db::swap_task_order(&mut state.db_conn, task1, task2);
state.db_conn.swap_task_order(task1, task2);
let task_idx = column.selected_task_idx;
let col_id = project.get_selected_column().id;
db::set_selected_task_for_column(&state.db_conn, task_idx, col_id);
let col_id = state.get_selected_column().id;
state.db_conn.set_selected_task_for_column(task_idx, col_id);
}
}
KeyCode::Char('n') => state.task_edit_state = Some(TaskState::default()),
KeyCode::Char('e') => state.task_edit_state = column.get_task_state_from_current(),
KeyCode::Char('D') => {
if !column.tasks.is_empty() {
db::delete_task(&state.db_conn, column.get_selected_task().unwrap());
state.db_conn.delete_task(column.get_selected_task().unwrap());
column.remove_task();
let task_idx = column.selected_task_idx;
let col_id = project.get_selected_column().id;
db::set_selected_task_for_column(&state.db_conn, task_idx, col_id);
let col_id = state.get_selected_column().id;
state.db_conn.set_selected_task_for_column(task_idx, col_id);
}
}
_ => {}
@ -167,7 +165,7 @@ pub fn handle_main(state: &mut State<'_>, key: event::KeyEvent) {
pub fn handle(state: &mut State<'_>) -> Result<(), std::io::Error> {
if let Event::Key(key) = event::read()? {
if state.task_edit_state.is_some() {
let column = state.project.get_selected_column_mut();
let column = state.get_selected_column_mut();
handle_task_edit(&state.db_conn, column, key, &mut state.task_edit_state);
} else {
handle_main(state, key);

5
src/main.rs
View File

@ -4,7 +4,7 @@ use crossterm::{
event::{DisableMouseCapture, EnableMouseCapture},
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};
use kanban_tui::{Project, State};
use kanban_tui::State;
use rusqlite::Connection;
use std::{error::Error, io, path::PathBuf};
use tui::backend::CrosstermBackend;
@ -40,8 +40,7 @@ fn main() -> anyhow::Result<(), Box<dyn Error>> {
tx.commit()?;
}
let project = Project::load(&conn)?;
let mut state = State::new(conn, project);
let mut state = State::new(conn);
enable_raw_mode()?;
let mut stdout = io::stdout();

14
src/ui.rs
View File

@ -11,22 +11,22 @@ fn draw_tasks<B: Backend>(f: &mut Frame<'_, B>, area: Rect, state: &State<'_>) {
.direction(Direction::Horizontal)
.constraints(
vec![
Constraint::Percentage(100 / u16::try_from(state.project.columns.len()).unwrap());
state.project.columns.len()
Constraint::Percentage(100 / u16::try_from(state.columns.len()).unwrap());
state.columns.len()
]
.as_ref(),
)
.split(area);
for (i, column) in state.project.columns.iter().enumerate() {
for (i, column) in state.columns.iter().enumerate() {
let items: Vec<ListItem<'_>> = column
.tasks
.iter()
.enumerate()
.map(|(j, task)| {
let mut style = Style::default();
let col_idx = state.project.selected_column_idx;
let task_idx = state.project.get_selected_column().selected_task_idx;
let col_idx = state.selected_column_idx;
let task_idx = state.get_selected_column().selected_task_idx;
let item_txt;
if i == col_idx && j == task_idx {
style = style.add_modifier(Modifier::BOLD | Modifier::UNDERLINED);
@ -40,7 +40,7 @@ fn draw_tasks<B: Backend>(f: &mut Frame<'_, B>, area: Rect, state: &State<'_>) {
})
.collect();
let mut style = Style::default();
if i == state.project.selected_column_idx {
if i == state.selected_column_idx {
style = style.add_modifier(Modifier::REVERSED);
};
let mut s = Span::raw(column.name.as_str());
@ -60,7 +60,7 @@ fn draw_tasks<B: Backend>(f: &mut Frame<'_, B>, area: Rect, state: &State<'_>) {
fn draw_task_info<B: Backend>(f: &mut Frame<'_, B>, area: Rect, state: &State<'_>) {
let block = Block::default().title("TASK INFO").borders(Borders::ALL);
if let Some(task) = state.project.get_selected_column().get_selected_task() {
if let Some(task) = state.get_selected_column().get_selected_task() {
let p = Paragraph::new(task.description.as_str())
.block(block)
.wrap(Wrap { trim: true });