jobber 0.10.5

Command line tool for tracking work time
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

//! Operations that can be processed at a jobber database.

use super::prelude::*;
use rand::Rng;

const MOTD: &[&str] = &["And don't work too much!", "Work smarter, not harder."];

/// Catches what to change the jobs within the database.
#[derive(Clone, Debug)]
pub enum Operation {
    /// No operation
    None,
    /// No change
    Intro,
    /// Push a new `Job` into database.
    Push(usize, Job),
    /// Change an existing `Job` at index `usize` into database but return error if message is missing.
    Modify(usize, Job),
    /// Remove jobs from
    Delete(Positions),
    /// Import file
    Import(String, usize, TagSet),
    /// Change configuration
    Configure(Option<TagSet>, Properties),
    /// List jobs
    List(Positions, Range, Option<TagSet>),
    /// Report jobs
    Report(Positions, Range, Option<TagSet>),
    /// Export jobs
    ExportCSV(Positions, Range, Option<TagSet>, Columns),
    /// List all available tags.
    ListTags(TagSet),
    /// Show the database configuration.
    ShowConfiguration(Configuration),
}

impl Operation {
    pub fn reports_open_job(&self) -> bool {
        matches!(self, Operation::Intro | Operation::Push(_, _))
    }
}

impl std::fmt::Display for Operation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Operation::None => Ok(()),
            Operation::Intro => {
                let mut rng = rand::thread_rng();
                let motd = MOTD[rng.gen_range(0..MOTD.len())];
                write!(f, "\n{}", motd)
            }
            Operation::Push(position, job) => {
                if job.is_open() {
                    write!(f, "Started new job:\n\n    Pos: {}\n{job}", position + 1)
                } else {
                    write!(f, "Added new job:\n\n    Pos: {}\n{job}", position + 1)
                }
            }
            Operation::Modify(position, job) => {
                if job.is_open() {
                    write!(f, "Modified open job:\n\n    Pos: {}\n{job}", position + 1)
                } else {
                    write!(f, "Modified job:\n\n    Pos: {}\n{job}", position + 1)
                }
            }
            Operation::Delete(positions) => {
                write!(
                    f,
                    "Deleting job(s) at position(s): {}",
                    positions.into_ranges()
                )
            }
            Operation::Import(filename, count, new_tags) => {
                if new_tags.is_empty() {
                    write!(f, "Imported {count} jobs from {filename}.")
                } else {
                    write!(
                        f,
                        "Imported {count} jobs from {filename} (added new tags {new_tags})."
                    )
                }
            }
            Operation::Configure(tags, config) => {
                if let Some(tags) = tags {
                    write!(
                        f,
                        "Changed the following configuration values for tag(s) {}:\n\n{}",
                        tags, config
                    )
                } else {
                    write!(
                        f,
                        "Changed the following default configuration values:\n\n{}",
                        config
                    )
                }
            }
            Operation::List(_, range, tags) => {
                if let Some(tags) = tags {
                    write!(f, "Listed {range} with tags {tags}.")?;
                } else {
                    write!(f, "Listed {range}:")?;
                }
                Ok(())
            }
            Operation::Report(_, range, tags) => {
                if let Some(tags) = tags {
                    write!(f, "Reported {range} with tags {tags}.")?;
                } else {
                    write!(f, "Reported {range}:")?;
                }
                Ok(())
            }
            Operation::ExportCSV(_, range, tags, columns) => {
                if let Some(tags) = tags {
                    write!(f, "Exported {columns} from {range} with tags {tags}.")?;
                } else {
                    write!(f, "Exported {columns} from {range}:")?;
                }
                Ok(())
            }
            Operation::ListTags(tags) => {
                if tags.is_empty() {
                    write!(f, "Currently no tags are used.")
                } else {
                    write!(f, "Known tags: {}", tags)
                }
            }
            Operation::ShowConfiguration(configuration) => {
                // print base configurations
                writeln!(f, "Base Configuration:\n\n{}", configuration.base)?;
                // print tag wise configurations
                for (tag, properties) in &configuration.tags {
                    write!(
                        f,
                        "Configuration for tag {}:\n\n{}",
                        TagSet::from(tag.as_str()),
                        properties
                    )?;
                }
                Ok(())
            }
        }
    }
}