trackWork 0.15.0

A terminal-based time tracking application for managing work sessions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use anyhow::Result;

use crate::app::{App, InputMode, TaskEditState};

impl App {
    pub fn open_tasks(&mut self) {
        let tasks = self.db.get_all_tasks().unwrap_or_default();
        self.input_mode = InputMode::Tasks {
            selected_index: 0,
            tasks,
            editing: None,
            confirm_delete: false,
        };
    }

    pub fn refresh_tasks(&mut self) {
        if let InputMode::Tasks { tasks, selected_index, .. } = &mut self.input_mode {
            *tasks = self.db.get_all_tasks().unwrap_or_default();
            if *selected_index >= tasks.len() && !tasks.is_empty() {
                *selected_index = tasks.len() - 1;
            }
        }
    }

    pub fn tasks_start_creating(&mut self) {
        if let InputMode::Tasks { editing, .. } = &mut self.input_mode {
            *editing = Some(TaskEditState {
                task_id: None,
                issue_key: String::new(),
                name: String::new(),
                project: String::new(),
                current_field: 0,
            });
        }
    }

    pub fn tasks_start_editing(&mut self) {
        if let InputMode::Tasks { tasks, selected_index, editing, .. } = &mut self.input_mode {
            if let Some(task) = tasks.get(*selected_index) {
                *editing = Some(TaskEditState {
                    task_id: Some(task.id),
                    issue_key: task.issue_key.clone(),
                    name: task.name.clone(),
                    project: task.project.clone(),
                    current_field: 0,
                });
            }
        }
    }

    pub fn tasks_save(&mut self) -> Result<()> {
        if let InputMode::Tasks { editing, tasks, .. } = &mut self.input_mode {
            if let Some(ref edit) = editing {
                if edit.issue_key.is_empty() {
                    self.status_message = Some("Issue key cannot be empty".to_string());
                    return Ok(());
                }
                // Check for issue_key conflict with a different task
                let conflict = tasks.iter().any(|t| {
                    t.issue_key == edit.issue_key && Some(t.id) != edit.task_id
                });
                if conflict {
                    self.status_message = Some(format!(
                        "Issue key '{}' already exists",
                        edit.issue_key
                    ));
                    return Ok(());
                }
                let edit = editing.take().unwrap();
                if let Some(id) = edit.task_id {
                    self.db.update_task(id, &edit.issue_key, &edit.name, &edit.project)?;
                } else {
                    self.db.create_task(&edit.issue_key, &edit.name, &edit.project)?;
                }
                self.refresh_tasks();
            }
        }
        Ok(())
    }

    pub fn tasks_delete(&mut self) -> Result<()> {
        if let InputMode::Tasks { tasks, selected_index, confirm_delete, .. } = &mut self.input_mode {
            if let Some(task) = tasks.get(*selected_index) {
                self.db.delete_task(task.id)?;
                *confirm_delete = false;
            }
        }
        self.refresh_tasks();
        Ok(())
    }

    pub fn tasks_cancel_edit(&mut self) {
        if let InputMode::Tasks { editing, .. } = &mut self.input_mode {
            *editing = None;
        }
    }

    pub fn tasks_confirm_delete(&mut self) {
        if let InputMode::Tasks { tasks, selected_index, confirm_delete, .. } = &mut self.input_mode {
            if *selected_index < tasks.len() {
                *confirm_delete = true;
            }
        }
    }

    pub fn tasks_cancel_delete(&mut self) {
        if let InputMode::Tasks { confirm_delete, .. } = &mut self.input_mode {
            *confirm_delete = false;
        }
    }
}