git-task 0.2.4

Local-first task manager/bug tracker within your git repository which can sync issues with remote sources.
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

use crate::status;
use crate::status::StatusManager;
use crate::util::{error_message, read_from_pipe, success_message};

pub(crate) fn task_config_status_add(name: String, shortcut: String, color: String, is_done: Option<bool>) -> bool {
    let mut status_manager = StatusManager::new();
    match status_manager.add_status(name, shortcut, color, is_done.unwrap_or(false)) {
        Ok(_) => success_message("Status has been added".to_string()),
        Err(e) => error_message(format!("ERROR: {e}"))
    }
}

pub(crate) fn task_config_status_delete(name: String, force: bool) -> bool {
    let mut status_manager = StatusManager::new();
    let name = status_manager.get_full_status_name(&name);

    if !force {
        if let Ok(tasks) = gittask::list_tasks() {
            let task_exists = tasks.iter().any(|task| task.get_property("status").unwrap() == name.as_str());
            if task_exists {
                return error_message("Can't delete a status, some tasks still have it. Use --force option to override.".to_string());
            }
        }
    }

    match status_manager.delete_status(name) {
        Ok(_) => success_message("Status has been deleted".to_string()),
        Err(e) => error_message(format!("ERROR: {e}"))
    }
}

pub(crate) fn task_config_status_get(name: String, param: String) -> bool {
    let status_manager = StatusManager::new();
    let name = status_manager.get_full_status_name(&name);
    match status_manager.get_property(&name, &param) {
        Some(value) => success_message(value),
        None => error_message(format!("Unknown status {name} or property: {param}"))
    }
}

pub(crate) fn task_config_status_set(name: String, param: String, value: String) -> bool {
    let mut status_manager = StatusManager::new();
    let name = status_manager.get_full_status_name(&name);
    match status_manager.set_property(&name, &param, &value) {
        Ok(prev_value) => {
            println!("{name} {param} has been updated");

            if param.as_str() == "name" && prev_value.is_some() {
                let prev_status = prev_value.unwrap();
                match gittask::list_tasks() {
                    Ok(tasks) => {
                        for mut task in tasks {
                            if task.get_property("status").unwrap() == prev_status.as_str() {
                                task.set_property("status", &value);
                                if let Err(e) = gittask::update_task(task) {
                                    eprintln!("ERROR: {e}");
                                }
                            }
                        }
                    },
                    Err(e) => eprintln!("ERROR: {e}")
                }
            }

            true
        },
        Err(e) => error_message(format!("ERROR: {e}"))
    }
}

pub(crate) fn task_config_status_list() -> bool {
    let status_manager = StatusManager::new();
    println!("Name\tShortcut\tColor\tStyle\tIs DONE");
    status_manager.get_statuses().iter().for_each(|status| {
        println!("{}\t{}\t{}\t{}\t{}", status.get_name(), status.get_shortcut(), status.get_color(), status.get_style().unwrap_or_else(|| ""), status.is_done());
    });
    true
}

pub(crate) fn task_config_status_import() -> bool {
    if let Some(input) = read_from_pipe() {
        match status::parse_statuses(input) {
            Ok(statuses) => {
                let mut status_manager = StatusManager::new();
                match status_manager.set_statuses(statuses) {
                    Ok(_) => success_message("Import successful".to_string()),
                    Err(e) => error_message(format!("ERROR: {e}"))
                }
            },
            Err(e) => error_message(e)
        }
    } else {
        error_message("Can't read from pipe".to_string())
    }
}

pub(crate) fn task_config_status_export(pretty: bool) -> bool {
    let status_manager = StatusManager::new();
    let func = if pretty { serde_json::to_string_pretty } else { serde_json::to_string };

    if let Ok(result) = func(&status_manager.get_statuses()) {
        success_message(result)
    } else {
        error_message("ERROR serializing status list".to_string())
    }
}

pub(crate) fn task_config_status_reset() -> bool {
    let mut status_manager = StatusManager::new();
    match status_manager.set_defaults() {
        Ok(_) => success_message("Statuses have been reset".to_string()),
        Err(e) => error_message(format!("ERROR: {e}"))
    }
}