478 lines
16 KiB
Rust
478 lines
16 KiB
Rust
use crate::db;
|
|
use iced::keyboard::key;
|
|
use iced::widget::text::danger;
|
|
use iced::widget::{
|
|
button, center, checkbox, column, combo_box, row, scrollable, text_input, Text,
|
|
};
|
|
use iced::{event, keyboard, widget, Center, Element, Event, Length, Subscription, Task, Theme};
|
|
use rusqlite::Connection;
|
|
|
|
#[derive(Debug)]
|
|
pub struct TaskColumn {
|
|
pub(crate) id: usize,
|
|
pub(crate) checked: bool,
|
|
pub(crate) value: String,
|
|
}
|
|
|
|
pub struct TaskData {
|
|
db_id: usize,
|
|
checked: bool,
|
|
value: String,
|
|
edit: bool,
|
|
can_update: bool,
|
|
can_delete: bool,
|
|
already_exists: bool,
|
|
}
|
|
|
|
pub(crate) struct Todo {
|
|
new_task: String,
|
|
updated_task: String,
|
|
tasks: Vec<TaskData>,
|
|
completed_tasks: usize,
|
|
local_storage: bool,
|
|
conn: Connection,
|
|
select_all: bool,
|
|
task_list_input: String,
|
|
task_list_state: combo_box::State<String>,
|
|
task_list: Vec<String>,
|
|
current_task_group: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Message {
|
|
AddTask,
|
|
CheckTask(bool, usize),
|
|
EditTask(usize),
|
|
DeleteTask(usize),
|
|
DeleteAll,
|
|
ContentUpdated(ContentType, String),
|
|
Event(Event),
|
|
TaskPush(Option<usize>),
|
|
StorageToggle(bool),
|
|
ToggleUnselect(bool),
|
|
SelectedTaskList(String),
|
|
AddTaskList,
|
|
}
|
|
|
|
pub enum ChangeType {
|
|
Checked,
|
|
Value,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
enum ContentType {
|
|
NewTask,
|
|
ExistingTask,
|
|
NewList,
|
|
}
|
|
|
|
impl Default for Todo {
|
|
fn default() -> Self {
|
|
Todo::new()
|
|
}
|
|
}
|
|
|
|
impl Todo {
|
|
fn new() -> Self {
|
|
let mut init = Self {
|
|
new_task: String::new(),
|
|
updated_task: String::new(),
|
|
tasks: Vec::new(),
|
|
completed_tasks: 0,
|
|
local_storage: true, // todo eventually get this info from db - if no db set it to true
|
|
conn: db::startup("./todolist-db.db3".as_ref())
|
|
.expect("[ERROR] Failed to access the local storage"),
|
|
select_all: false,
|
|
task_list_input: String::from(""),
|
|
task_list_state: Default::default(),
|
|
task_list: vec![String::from("general")],
|
|
current_task_group: Some(String::from("")),
|
|
};
|
|
|
|
Self::load_data_from_db(&mut init);
|
|
init.task_list_state = combo_box::State::new(init.task_list.clone());
|
|
init.current_task_group = Some(init.task_list[0].clone());
|
|
|
|
init
|
|
}
|
|
pub(crate) fn update(&mut self, message: Message) -> Task<Message> {
|
|
match message {
|
|
Message::ContentUpdated(new, value) => {
|
|
/*if new {
|
|
self.new_task = String::from(&value);
|
|
} else {
|
|
self.updated_task = String::from(&value)
|
|
}*/
|
|
|
|
match new {
|
|
ContentType::NewTask => self.new_task = String::from(&value),
|
|
ContentType::ExistingTask => self.updated_task = String::from(&value),
|
|
ContentType::NewList => {
|
|
self.task_list_input = String::from(&value);
|
|
return Task::none();
|
|
}
|
|
}
|
|
|
|
for task in &mut self.tasks {
|
|
task.already_exists = task.value == value.to_string();
|
|
}
|
|
|
|
Task::none()
|
|
}
|
|
Message::AddTask => {
|
|
if self.new_task.is_empty() {
|
|
return Task::none();
|
|
}
|
|
if self.duplicate_exists(None) {
|
|
return Task::none();
|
|
}
|
|
|
|
let result = db::insert_task(
|
|
&self.conn,
|
|
TaskColumn {
|
|
id: 0,
|
|
checked: false,
|
|
value: self.new_task.to_string(),
|
|
},
|
|
);
|
|
|
|
match result {
|
|
Ok(t) => {
|
|
let data = TaskData {
|
|
db_id: t as usize,
|
|
checked: false,
|
|
value: self.new_task.to_string(),
|
|
edit: false,
|
|
can_update: true,
|
|
can_delete: true,
|
|
already_exists: false,
|
|
};
|
|
self.tasks.push(data);
|
|
}
|
|
Err(e) => eprintln!("[ERROR] Failed to insert new task into DB:\n{e}"),
|
|
}
|
|
|
|
self.new_task = String::new();
|
|
|
|
Task::none()
|
|
}
|
|
Message::DeleteTask(index) => {
|
|
if self.tasks[index].checked {
|
|
self.completed_tasks -= 1;
|
|
}
|
|
|
|
if let Err(e) = db::delete_tasks(&self.conn, Some(self.tasks[index].db_id)) {
|
|
eprintln!(
|
|
"[ERROR] Failed to delete task '{}':\n{e}",
|
|
self.tasks[index].value
|
|
);
|
|
}
|
|
|
|
self.tasks.remove(index);
|
|
|
|
Task::none()
|
|
}
|
|
Message::CheckTask(choice, id) => {
|
|
self.completed_tasks = if choice {
|
|
self.completed_tasks + 1
|
|
} else {
|
|
self.completed_tasks - 1
|
|
};
|
|
self.tasks[id].checked = choice;
|
|
|
|
let result = db::update_task(
|
|
&self.conn,
|
|
TaskColumn {
|
|
id: self.tasks[id].db_id,
|
|
checked: self.tasks[id].checked,
|
|
value: self.tasks[id].value.to_string(),
|
|
},
|
|
ChangeType::Checked,
|
|
);
|
|
|
|
if let Err(e) = result {
|
|
eprintln!("[ERROR] Failed to update checkbox in local storage:\n{e}");
|
|
}
|
|
|
|
Task::none()
|
|
}
|
|
Message::EditTask(index) => {
|
|
let set_update;
|
|
|
|
if self.tasks[index].edit {
|
|
if self.updated_task.is_empty() {
|
|
return Task::none();
|
|
}
|
|
if self.duplicate_exists(Some(&self.tasks[index].value)) {
|
|
return Task::none();
|
|
}
|
|
|
|
self.tasks[index].value = self.updated_task.clone();
|
|
let result = db::update_task(
|
|
&self.conn,
|
|
TaskColumn {
|
|
id: self.tasks[index].db_id,
|
|
checked: self.tasks[index].checked,
|
|
value: self.tasks[index].value.to_string(),
|
|
},
|
|
ChangeType::Value,
|
|
);
|
|
|
|
if let Err(e) = result {
|
|
eprintln!(
|
|
"[ERROR] Failed to update task '{}' in local storage:\n{e}",
|
|
self.tasks[index].value
|
|
);
|
|
}
|
|
|
|
set_update = true;
|
|
self.updated_task = String::new();
|
|
|
|
for item in &mut self.tasks {
|
|
if item.already_exists {
|
|
item.already_exists = false;
|
|
}
|
|
}
|
|
} else {
|
|
set_update = false;
|
|
}
|
|
|
|
self.tasks[index].edit = !self.tasks[index].edit;
|
|
self.set_other_update(index, set_update);
|
|
|
|
widget::focus_previous()
|
|
}
|
|
Message::DeleteAll => {
|
|
if let Err(e) = db::delete_tasks(&self.conn, None) {
|
|
eprintln!("[ERROR] Failed to delete all tasks:\n{e}")
|
|
}
|
|
|
|
self.new_task = String::from("");
|
|
self.updated_task = String::from("");
|
|
self.tasks.clear();
|
|
self.completed_tasks = 0;
|
|
|
|
Task::none()
|
|
}
|
|
Message::Event(event) => match event {
|
|
Event::Keyboard(keyboard::Event::KeyPressed {
|
|
key: keyboard::Key::Named(key::Named::Tab),
|
|
modifiers,
|
|
..
|
|
}) => {
|
|
if modifiers.shift() {
|
|
widget::focus_previous()
|
|
} else {
|
|
widget::focus_next()
|
|
}
|
|
}
|
|
Event::Keyboard(keyboard::Event::KeyPressed {
|
|
key: keyboard::Key::Named(key::Named::Delete),
|
|
modifiers,
|
|
..
|
|
}) => {
|
|
if modifiers.control() {
|
|
Task::perform(async move { Message::DeleteAll }, |result| result)
|
|
} else {
|
|
Task::none()
|
|
}
|
|
}
|
|
_ => Task::none(),
|
|
},
|
|
Message::TaskPush(option_id) => match option_id {
|
|
Some(i) => Task::perform(async move { Message::EditTask(i) }, |result| result),
|
|
None => Task::perform(async { Message::AddTask }, |result| result),
|
|
},
|
|
Message::StorageToggle(_toggle) => {
|
|
// todo must be enabled eventually
|
|
//self.local_storage = toggle;
|
|
|
|
/*
|
|
todo
|
|
here we only call for storage change not implement the whole system
|
|
as the system should be running since the program startup
|
|
*/
|
|
|
|
// also how do we even implement that
|
|
|
|
Task::none()
|
|
}
|
|
Message::ToggleUnselect(toggle) => {
|
|
self.select_all = toggle;
|
|
for task in &mut self.tasks {
|
|
task.checked = toggle;
|
|
}
|
|
|
|
if toggle {
|
|
self.completed_tasks = self.tasks.len();
|
|
} else {
|
|
self.completed_tasks = 0;
|
|
}
|
|
|
|
if let Err(e) = db::update_unselect_tasks(&self.conn, toggle) {
|
|
eprintln!("[ERROR] Failed to update un/select all operation in database:\n{e}");
|
|
}
|
|
|
|
Task::none()
|
|
}
|
|
Message::SelectedTaskList(task) => {
|
|
self.current_task_group = Some(task);
|
|
Task::none()
|
|
}
|
|
Message::AddTaskList => {
|
|
if self.task_list_input.is_empty() { return Task::none(); }
|
|
self.task_list.push(self.task_list_input.clone());
|
|
self.task_list_state = combo_box::State::new(self.task_list.clone());
|
|
self.task_list_input = String::from("");
|
|
Task::none()
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn view(&self) -> Element<Message> {
|
|
let input = text_input("Enter new task", &self.new_task)
|
|
.width(300)
|
|
.size(25)
|
|
.on_input(|str| Message::ContentUpdated(ContentType::NewTask, str))
|
|
.on_submit(Message::TaskPush(None));
|
|
|
|
let add_btn = button(Text::new("Add").size(19).center())
|
|
.width(Length::Shrink)
|
|
.padding(10)
|
|
.on_press(Message::AddTask);
|
|
|
|
let clear_btn = button(Text::new("Clear").size(19).center())
|
|
.width(Length::Shrink)
|
|
.padding(10)
|
|
.style(button::danger)
|
|
.on_press(Message::DeleteAll);
|
|
|
|
let new_task = row![input, add_btn, clear_btn].spacing(10);
|
|
let mut saved_tasks = column![];
|
|
|
|
for (i, task) in self.tasks.iter().enumerate() {
|
|
let chk = checkbox("", task.checked)
|
|
.size(25)
|
|
.on_toggle(move |b| Message::CheckTask(b, i));
|
|
let mut label = Text::new(&task.value).width(200);
|
|
if task.already_exists {
|
|
label = label.style(danger);
|
|
}
|
|
let input = text_input("Enter new name", &self.updated_task)
|
|
.width(200)
|
|
.on_input(|str| Message::ContentUpdated(ContentType::ExistingTask, str))
|
|
.on_submit(Message::TaskPush(Some(i)));
|
|
let mut edit = button(if task.edit { "save" } else { "edit" }).width(Length::Shrink);
|
|
if task.can_update {
|
|
edit = edit.on_press(Message::EditTask(i));
|
|
}
|
|
let mut delete = button("delete").width(Length::Shrink);
|
|
if task.can_delete {
|
|
delete = delete.on_press(Message::DeleteTask(i));
|
|
}
|
|
let mut task_line = row![chk];
|
|
task_line = if task.edit {
|
|
task_line.push(input)
|
|
} else {
|
|
task_line.push(label)
|
|
};
|
|
task_line = task_line
|
|
.push(edit)
|
|
.push(delete)
|
|
.spacing(10)
|
|
.padding([5, 10]);
|
|
|
|
saved_tasks = saved_tasks.push(task_line);
|
|
}
|
|
|
|
let status = Text::new(format!("{} / {}", self.completed_tasks, self.tasks.len()));
|
|
let tasklist = combo_box(
|
|
&self.task_list_state,
|
|
"Test...",
|
|
self.current_task_group.as_ref(),
|
|
Message::SelectedTaskList,
|
|
)
|
|
.on_input(|str| Message::ContentUpdated(ContentType::NewList, str));
|
|
let add_tasklist = button("+").on_press(Message::AddTaskList);
|
|
let tasklist_group = row![tasklist.width(Length::Fill), add_tasklist].spacing(5);
|
|
let unselect =
|
|
checkbox("Select all", self.select_all).on_toggle(Message::ToggleUnselect);
|
|
let storage =
|
|
checkbox("Local storage", self.local_storage).on_toggle(Message::StorageToggle);
|
|
let footer = row![
|
|
status,
|
|
tasklist_group,
|
|
unselect,
|
|
storage
|
|
]
|
|
.padding(10)
|
|
.spacing(10);
|
|
|
|
let mut output = column![new_task.padding(10)];
|
|
output = if self.tasks.is_empty() {
|
|
output.push(saved_tasks.height(Length::Fill))
|
|
} else {
|
|
output.push(scrollable(saved_tasks).height(Length::Fill).spacing(10))
|
|
};
|
|
output = output.align_x(Center).push(footer);
|
|
|
|
center(output).into()
|
|
}
|
|
|
|
pub(crate) fn theme(&self) -> Theme {
|
|
Theme::Dark
|
|
}
|
|
|
|
pub(crate) fn subscription(&self) -> Subscription<Message> {
|
|
event::listen().map(Message::Event)
|
|
}
|
|
|
|
fn set_other_update(&mut self, id: usize, enable: bool) {
|
|
for (i, task) in self.tasks.iter_mut().enumerate() {
|
|
if id != i {
|
|
task.can_update = enable;
|
|
}
|
|
task.can_delete = enable;
|
|
}
|
|
}
|
|
|
|
fn load_data_from_db(&mut self) {
|
|
if let Ok(t) = db::get_tasks(&self.conn) {
|
|
for item in t {
|
|
let data = TaskData {
|
|
db_id: item.id,
|
|
checked: item.checked,
|
|
value: item.value,
|
|
edit: false,
|
|
can_update: true,
|
|
can_delete: true,
|
|
already_exists: false,
|
|
};
|
|
|
|
if item.checked {
|
|
self.completed_tasks += 1;
|
|
}
|
|
|
|
self.tasks.push(data);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn duplicate_exists(&self, task_name: Option<&String>) -> bool {
|
|
for task in &self.tasks {
|
|
if task.already_exists {
|
|
match task_name {
|
|
Some(t) => {
|
|
if task.value != *t {
|
|
return true;
|
|
}
|
|
}
|
|
None => return true,
|
|
}
|
|
}
|
|
}
|
|
|
|
false
|
|
}
|
|
}
|