toggl 0.5.0

Unofficial command-line interface for Toggl Track using the v9 API.
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

use crate::api;
use crate::arguments::Entity;
use crate::models;
use api::client::ApiClient;
use colored::Colorize;
use models::ResultWithDefaultError;
use std::io::{self, BufWriter, Write};

pub struct ListCommand;

impl ListCommand {
    pub async fn execute(
        api_client: impl ApiClient,
        count: Option<usize>,
        json_flag: bool,
        since: Option<String>,
        until: Option<String>,
        entity: Option<Entity>,
    ) -> ResultWithDefaultError<()> {
        if let Some(Entity::Tag { json: entity_json }) = entity {
            let json = json_flag || entity_json;
            let user = api_client.get_user().await?;
            match api_client.get_tags(user.default_workspace_id).await {
                Err(error) => println!("{}\n{}", "Couldn't fetch tags from API".red(), error),
                Ok(tags) => {
                    let stdout = io::stdout();
                    let mut handle = BufWriter::new(stdout);
                    let tags = tags
                        .iter()
                        .take(count.unwrap_or(usize::MAX))
                        .collect::<Vec<_>>();
                    if json {
                        let json_string = serde_json::to_string_pretty(&tags)
                            .expect("failed to serialize tags to JSON");
                        writeln!(handle, "{json_string}").expect("failed to print");
                    } else {
                        tags.iter()
                            .for_each(|tag| writeln!(handle, "{tag}").expect("failed to print"));
                    }
                }
            }
            return Ok(());
        }

        let is_time_entry = matches!(entity, None | Some(Entity::TimeEntry { .. }));
        let has_date_filter = since.is_some() || until.is_some();

        if is_time_entry && has_date_filter {
            let stdout = io::stdout();
            let mut handle = BufWriter::new(stdout);
            let json = match &entity {
                Some(Entity::TimeEntry { json }) => json_flag || *json,
                _ => json_flag,
            };
            match api_client.get_time_entries_filtered(since, until).await {
                Err(error) => println!(
                    "{}\n{}",
                    "Couldn't fetch time entries from API".red(),
                    error
                ),
                Ok(entries) => {
                    let entries = entries
                        .iter()
                        .take(count.unwrap_or(usize::MAX))
                        .collect::<Vec<_>>();
                    if json {
                        let json_string = serde_json::to_string_pretty(&entries)
                            .expect("failed to serialize time entries to JSON");
                        writeln!(handle, "{json_string}").expect("failed to print");
                    } else {
                        entries
                            .iter()
                            .for_each(|te| writeln!(handle, "{te}").expect("failed to print"));
                    }
                }
            }
            return Ok(());
        }

        match api_client.get_entities().await {
            Err(error) => println!(
                "{}\n{}",
                "Couldn't fetch time entries the from API".red(),
                error
            ),
            Ok(entities) => {
                // use this to avoid calling println! in a loop:
                // <https://rust-cli.github.io/book/tutorial/output.html#a-note-on-printing-performance>
                let stdout = io::stdout();
                let mut handle = BufWriter::new(stdout);

                // TODO: better error handling for writeln!
                match entity.unwrap_or(Entity::TimeEntry { json: false }) {
                    Entity::TimeEntry { json: entity_json } => {
                        let json = json_flag || entity_json;
                        let entries = entities
                            .time_entries
                            .iter()
                            .take(count.unwrap_or(usize::MAX))
                            .collect::<Vec<_>>();

                        if json {
                            let json_string = serde_json::to_string_pretty(&entries)
                                .expect("failed to serialize time entries to JSON");
                            writeln!(handle, "{json_string}").expect("failed to print");
                        } else {
                            entries.iter().for_each(|time_entry| {
                                writeln!(handle, "{time_entry}").expect("failed to print")
                            });
                        }
                    }

                    Entity::Project { json: entity_json } => {
                        let json = json_flag || entity_json;
                        let projects = entities
                            .projects
                            .values()
                            .take(count.unwrap_or(usize::MAX))
                            .collect::<Vec<_>>();

                        if json {
                            let json_string = serde_json::to_string_pretty(&projects)
                                .expect("failed to serialize projects to JSON");
                            writeln!(handle, "{json_string}").expect("failed to print");
                        } else {
                            projects.iter().for_each(|project| {
                                writeln!(handle, "{project}").expect("failed to print")
                            });
                        }
                    }

                    // Already handled above, but needed for exhaustive match
                    Entity::Tag { .. } => unreachable!(),
                };
            }
        }
        Ok(())
    }
}