todoctl 0.3.0

Simple command line utility application for managing your tasks
Documentation 
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

use prettytable::{row, Table};
use rusqlite::Connection;
use uuid::Uuid;

use crate::db::{
    add_todo, complete_todo, delete_todo, models::Todo, show_all, show_one, update_todo,
};
use crate::utils::user_input;

/// Add a new todo, either from `--title` or interactive prompt
pub async fn add_action(conn: &Connection, title_arg: Option<String>) {
    let title = title_arg.unwrap_or_else(|| {
        println!("Add:");
        user_input("todo".to_string()).trim().to_owned()
    });

    let todo = Todo {
        id: Uuid::new_v4().to_string(),
        title: title.clone(),
        completed: false,
    };

    match add_todo(conn, todo.clone()) {
        Ok(_) => {
            let mut table = Table::new();
            table.add_row(row![b->"ID", b->"Title", b->"Completed"]);
            table.add_row(row![
                todo.id,
                todo.title,
                if todo.completed { "✅" } else { "❌" }
            ]);
            table.printstd();
        }
        Err(e) => eprintln!("Error adding todo: {}", e),
    }
}

/// List all todos
pub async fn show_action(conn: &Connection) {
    match show_all(conn) {
        Ok(todos) if todos.is_empty() => {
            println!("No todos found!");
        }
        Ok(todos) => {
            let mut table = Table::new();
            table.add_row(row![b->"ID", b->"Title", b->"Completed"]);
            for t in todos {
                table.add_row(row![t.id, t.title, if t.completed { "✅" } else { "❌" }]);
            }
            table.printstd();
        }
        Err(e) => eprintln!("Error fetching todos: {}", e),
    }
}

/// Complete a todo by ID (flag or interactive)
pub async fn complete_action(conn: &Connection, id_arg: Option<String>) {
    let id = id_arg.unwrap_or_else(|| {
        println!("Complete:");
        user_input("ID".to_string()).trim().to_owned()
    });

    if let Err(e) = complete_todo(conn, &id) {
        eprintln!("Error completing todo: {}", e);
        return;
    }

    match show_one(conn, &id) {
        Ok(mut v) if !v.is_empty() => {
            let t = v.remove(0);
            let mut table = Table::new();
            table.add_row(row![b->"ID", b->"Title", b->"Completed"]);
            table.add_row(row![t.id, t.title, if t.completed { "✅" } else { "❌" }]);
            table.printstd();
        }
        Ok(_) => println!("No todo found with ID: {}", id),
        Err(e) => eprintln!("Error fetching todo: {}", e),
    }
}

/// Delete a todo by ID (flag or interactive)
pub async fn delete_action(conn: &Connection, id_arg: Option<String>) {
    let id = id_arg.unwrap_or_else(|| {
        println!("Delete:");
        user_input("ID".to_string()).trim().to_owned()
    });

    // Show it first
    if let Ok(mut v) = show_one(conn, &id) {
        if v.is_empty() {
            println!("No todo found with ID: {}", id);
            return;
        }
        let t = v.remove(0);
        let mut table = Table::new();
        table.add_row(row![b->"ID", b->"Title", b->"Completed"]);
        table.add_row(row![t.id, t.title, if t.completed { "✅" } else { "❌" }]);
        table.printstd();
    }

    if let Err(e) = delete_todo(conn, &id) {
        eprintln!("Error deleting todo: {}", e);
    }
}

/// Update a todo by ID (flag or interactive)
pub async fn update_action(
    conn: &Connection,
    id_arg: Option<String>,
    title_arg: Option<String>,
    comp_arg: Option<bool>,
) {
    // 1) Determine ID
    let id = id_arg.unwrap_or_else(|| {
        println!("Update:");
        user_input("ID of todo to update".into()).trim().to_owned()
    });

    // 2) Fetch and show existing
    match show_one(conn, &id) {
        Ok(mut v) if !v.is_empty() => {
            let todo = v.remove(0);
            let mut tbl = Table::new();
            tbl.add_row(row![b->"ID", b->"Title", b->"Completed"]);
            tbl.add_row(row![
                &todo.id,
                &todo.title,
                if todo.completed { "✅" } else { "❌" }
            ]);
            tbl.printstd();
        }
        _ => {
            eprintln!("❌ No todo found with ID: {}", id);
            return;
        }
    }

    // 3) Determine new title
    let new_title = title_arg.or_else(|| {
        let input = user_input("New title (leave blank to skip)".into());
        let trimmed = input.trim();
        if trimmed.is_empty() {
            None
        } else {
            Some(trimmed.to_owned())
        }
    });

    // 4) Determine new completed status
    let new_completed = comp_arg.or_else(|| {
        let input = user_input("Completed? (y/n, leave blank to skip)".into());
        match input.trim().to_lowercase().as_str() {
            "y" | "yes" => Some(true),
            "n" | "no" => Some(false),
            _ => None,
        }
    });

    // 5) Apply update
    match update_todo(conn, &id, new_title.as_deref(), new_completed) {
        Ok(0) => println!("No fields changed."),
        Ok(_) => println!("✅ Todo updated."),
        Err(e) => eprintln!("Error updating todo: {}", e),
    }
}