shifty 0.1.7

A simple cli tool to keep track of your shifts at work
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

use crate::{
    args::Args,
    parse::{parse_date, parse_month, parse_premium, parse_time},
    shifts::{Shift, Shifts},
    Config,
};
use colored::Colorize;
use csv::Writer;

pub fn add_shift(args: Args, mut db: Shifts, db_path: String, config: Config) {
    let date = parse_date(args.date).expect("Invalid date");
    let time = parse_time(args.time, config.default_shift_length).expect("Invalid time");
    let premium = parse_premium(args.preimium).expect("Invalid premium");
    let shift = Shift {
        date,
        time,
        premium,
    };
    db.shifts.push(shift);
    let mut writer = Writer::from_path(db_path).expect("Couldn't open database file");
    for shift in db.shifts {
        writer.serialize(shift).expect("Couldn't parse data");
    }
    println!("{}", "Shift add successfully".green());
}

pub fn remove_shift(args: Args, mut db: Shifts, db_path: String) {
    let date = parse_date(args.date).expect("Invalid date");
    let old_len = db.shifts.len();
    db.shifts.retain(|v| v.date != date);
    if old_len == db.shifts.len() {
        println!("{}", "No shift found on this date".red());
        return;
    }
    let mut writer = Writer::from_path(db_path).expect("Couldn't open database file");
    for shift in db.shifts {
        writer.serialize(shift).expect("Couldn't parse data");
    }
    println!("{}", "Shift removed successfully".green());
}

pub fn list_all_shifts(args: Args, db: Shifts, config: Config) -> String {
    let shifts = Shifts {
        shifts: match args.date {
            None => db.shifts,
            Some(_) => {
                let date = parse_date(args.date).expect("Invalid date");
                db.shifts
                    .iter()
                    .filter(|v| v.date == date)
                    .cloned()
                    .collect::<Vec<Shift>>()
            }
        },
    };
    format!("{}", shifts.format(config))
}

pub fn list_shifts(args: Args, db: Shifts, config: Config) -> String {
    let mut slash_count = 1;
    let mut current_date = parse_month(None).unwrap();
    if args.date.is_some() {
        slash_count = args
            .date
            .as_ref()
            .unwrap()
            .chars()
            .filter(|v| *v == '/')
            .count();
        if slash_count == 1 {
            current_date = parse_month(args.date).unwrap();
        } else if slash_count == 2 {
            current_date = parse_date(args.date).unwrap();
        }
    }
    let shifts = Shifts {
        shifts: db
            .shifts
            .iter()
            .filter(|v| {
                if slash_count == 2 {
                    return v.date == current_date;
                }
                let date_split = v.date.split('/').collect::<Vec<&str>>();
                format!("{}/{}", date_split[1], date_split[2]) == current_date
            })
            .cloned()
            .collect::<Vec<Shift>>(),
    };
    if shifts.shifts.len() == 1 {
        return format!("{}", shifts.shifts[0].format_and_calc(config));
    }
    return format!("{}", shifts.format(config));
}