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
112
113
114
115
116
117
118
119

use anyhow::Result;
use crossterm::event::{KeyCode, KeyEvent};

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

pub fn handle_tasks_input(app: &mut App, key: KeyEvent) -> Result<bool> {
    if let InputMode::Tasks { confirm_delete, editing, .. } = &app.input_mode {
        if *confirm_delete {
            return handle_confirm_delete(app, key);
        }
        if editing.is_some() {
            return handle_edit_mode(app, key);
        }
    }
    handle_browse_mode(app, key)
}

fn handle_browse_mode(app: &mut App, key: KeyEvent) -> Result<bool> {
    match key.code {
        KeyCode::Esc | KeyCode::Char('q') => {
            app.input_mode = InputMode::Normal;
            Ok(false)
        }
        KeyCode::Up => {
            if let InputMode::Tasks { selected_index, tasks, .. } = &mut app.input_mode {
                if !tasks.is_empty() {
                    *selected_index = if *selected_index == 0 {
                        tasks.len() - 1
                    } else {
                        *selected_index - 1
                    };
                }
            }
            Ok(false)
        }
        KeyCode::Down => {
            if let InputMode::Tasks { selected_index, tasks, .. } = &mut app.input_mode {
                if !tasks.is_empty() {
                    *selected_index = (*selected_index + 1) % tasks.len();
                }
            }
            Ok(false)
        }
        KeyCode::Char('n') => {
            app.tasks_start_creating();
            Ok(false)
        }
        KeyCode::Char('e') => {
            app.tasks_start_editing();
            Ok(false)
        }
        KeyCode::Char('d') => {
            app.tasks_confirm_delete();
            Ok(false)
        }
        _ => Ok(false),
    }
}

fn handle_edit_mode(app: &mut App, key: KeyEvent) -> Result<bool> {
    match key.code {
        KeyCode::Esc => {
            app.tasks_cancel_edit();
            Ok(false)
        }
        KeyCode::Enter => {
            app.tasks_save()?;
            Ok(false)
        }
        KeyCode::Tab => {
            if let InputMode::Tasks { editing, .. } = &mut app.input_mode {
                if let Some(edit) = editing {
                    edit.current_field = (edit.current_field + 1) % 3;
                }
            }
            Ok(false)
        }
        KeyCode::Char(c) => {
            if let InputMode::Tasks { editing, .. } = &mut app.input_mode {
                if let Some(edit) = editing {
                    match edit.current_field {
                        0 => edit.issue_key.push(c),
                        1 => edit.name.push(c),
                        2 => edit.project.push(c),
                        _ => {}
                    }
                }
            }
            Ok(false)
        }
        KeyCode::Backspace => {
            if let InputMode::Tasks { editing, .. } = &mut app.input_mode {
                if let Some(edit) = editing {
                    match edit.current_field {
                        0 => { edit.issue_key.pop(); }
                        1 => { edit.name.pop(); }
                        2 => { edit.project.pop(); }
                        _ => {}
                    }
                }
            }
            Ok(false)
        }
        _ => Ok(false),
    }
}

fn handle_confirm_delete(app: &mut App, key: KeyEvent) -> Result<bool> {
    match key.code {
        KeyCode::Char('y') | KeyCode::Char('Y') => {
            app.tasks_delete()?;
            Ok(false)
        }
        _ => {
            app.tasks_cancel_delete();
            Ok(false)
        }
    }
}