rm_shared/
status_task.rs

1use crate::utils::truncated_str;
2
3pub struct StatusTask {
4    task_type: TaskType,
5    what: String,
6}
7
8#[derive(Clone, Copy)]
9enum TaskType {
10    Add,
11    Delete,
12    Rename,
13    Move,
14    Open,
15    ChangeCategory,
16}
17
18impl StatusTask {
19    pub fn new_add(what: impl Into<String>) -> Self {
20        StatusTask {
21            task_type: TaskType::Add,
22            what: what.into(),
23        }
24    }
25
26    pub fn new_rename(what: impl Into<String>) -> Self {
27        StatusTask {
28            task_type: TaskType::Rename,
29            what: what.into(),
30        }
31    }
32
33    pub fn new_del(what: impl Into<String>) -> Self {
34        StatusTask {
35            task_type: TaskType::Delete,
36            what: what.into(),
37        }
38    }
39
40    pub fn new_move(what: impl Into<String>) -> Self {
41        StatusTask {
42            task_type: TaskType::Move,
43            what: what.into(),
44        }
45    }
46
47    pub fn new_category(what: impl Into<String>) -> Self {
48        StatusTask {
49            task_type: TaskType::ChangeCategory,
50            what: what.into(),
51        }
52    }
53
54    pub fn new_open(what: impl Into<String>) -> Self {
55        StatusTask {
56            task_type: TaskType::Open,
57            what: what.into(),
58        }
59    }
60
61    pub fn success_str(&self) -> String {
62        let truncated = truncated_str(&self.what, 60);
63
64        match self.task_type {
65            TaskType::Add => format!(" Added {truncated}"),
66            TaskType::Delete => format!(" Deleted {truncated}"),
67            TaskType::Move => format!(" Moved {truncated}"),
68            TaskType::Open => format!(" Opened {truncated}"),
69            TaskType::ChangeCategory => {
70                if truncated.is_empty() {
71                    " Categories cleared!".to_string()
72                } else {
73                    format!(" Category set to {truncated}!")
74                }
75            }
76            TaskType::Rename => format!("Renamed {truncated}"),
77        }
78    }
79
80    pub fn failure_str(&self) -> String {
81        let truncated = truncated_str(&self.what, 60);
82
83        match self.task_type {
84            TaskType::Add => format!(" Error adding {truncated}"),
85            TaskType::Delete => format!(" Error deleting {truncated}"),
86            TaskType::Move => format!(" Error moving to {truncated}"),
87            TaskType::Open => format!(" Error opening {truncated}"),
88            TaskType::ChangeCategory => format!(" Error changing category to {truncated}"),
89            TaskType::Rename => format!(" Error renaming {truncated}"),
90        }
91    }
92
93    pub fn loading_str(&self) -> String {
94        let truncated = truncated_str(&self.what, 60);
95
96        match self.task_type {
97            TaskType::Add => format!(" Adding {truncated}"),
98            TaskType::Delete => format!(" Deleting {truncated}"),
99            TaskType::Move => format!(" Moving {truncated}"),
100            TaskType::Open => format!(" Opening {truncated}"),
101            TaskType::ChangeCategory => format!(" Changing category to {truncated}"),
102            TaskType::Rename => format!(" Renaming {truncated}"),
103        }
104    }
105}