tod 0.15.0

An unofficial Todoist command-line client
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

use std::fmt::Display;

use serde::{Deserialize, Serialize};

use crate::{
    config::Config,
    errors::Error,
    format,
    tasks::{DateInfo, Task},
    todoist,
};

#[allow(clippy::struct_excessive_bools)]
#[derive(PartialEq, Eq, Serialize, Deserialize, Clone, Debug)]
pub struct Reminder {
    pub id: String,
    pub item_id: String,
    pub notify_uid: String,
    pub r#type: String,
    pub is_deleted: bool,
    pub minute_offset: Option<u32>,
    pub is_urgent: bool,
    pub due: Option<DateInfo>,
}

impl Reminder {
    pub fn from_json(json: &str) -> Result<Reminder, Error> {
        let reminder: Reminder = serde_json::from_str(json)?;
        Ok(reminder)
    }
}

impl Display for Reminder {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if let Some(dateinfo) = &self.due {
            write!(f, "{}", dateinfo)
        } else if let Some(minute_offset) = self.minute_offset {
            write!(f, "{}", minute_offset)
        } else {
            write!(f, "{:?}", self)
        }
    }
}

#[derive(PartialEq, Eq, Serialize, Deserialize, Clone, Debug)]
pub struct ReminderResponse {
    pub results: Vec<Reminder>,
    pub next_cursor: Option<String>,
}

impl ReminderResponse {
    pub fn from_json(json: &str) -> Result<ReminderResponse, Error> {
        let response: ReminderResponse = serde_json::from_str(json)?;
        Ok(response)
    }
}

/// List all the reminders with their tasks
pub async fn list(config: &mut Config) -> Result<String, Error> {
    let reminders = todoist::all_reminders(config, None).await?;

    let task_ids = reminders
        .clone()
        .into_iter()
        .map(|reminder| reminder.item_id)
        .collect::<Vec<_>>();

    let tasks = todoist::all_tasks_by_ids(config, task_ids, None).await?;

    let reminders_with_tasks = reminders
        .into_iter()
        .map(|reminder| (find_task(&tasks, &reminder), reminder))
        .collect::<Vec<(Option<Task>, Reminder)>>();

    let mut buffer = String::new();
    buffer.push_str(&format::green_string("Reminders"));

    for (maybe_task, reminder) in reminders_with_tasks {
        buffer.push_str("\n - ");
        buffer.push_str(&reminder.to_string());
        if let Some(task) = maybe_task {
            buffer.push_str("\n   ");
            buffer.push_str(&task.to_string());
        }
    }
    Ok(buffer)
}

fn find_task(tasks: &[Task], reminder: &Reminder) -> Option<Task> {
    tasks.iter().find(|t| t.id == reminder.item_id).cloned()
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::test;
    use crate::test::responses::ResponseFromFile;
    #[tokio::test]
    async fn test_list() {
        let mut server = mockito::Server::new_async().await;
        let mock = server
            .mock("GET", "/api/v1/reminders?limit=200")
            .with_status(200)
            .with_header("content-type", "application/json")
            .with_body(ResponseFromFile::Reminders.read().await)
            .create_async()
            .await;

        let mock2 = server
            .mock("GET", "/api/v1/tasks/?ids=6Xqhv4cwxgjwG9w8&limit=200")
            .with_status(200)
            .with_header("content-type", "application/json")
            .with_body(ResponseFromFile::TodayTasks.read().await)
            .create_async()
            .await;

        let mut config = test::fixtures::config()
            .await
            .create()
            .await
            .expect("expected value or result, got None or Err")
            .with_mock_url(server.url())
            .with_projects(vec![test::fixtures::project()]);

        config
            .save()
            .await
            .expect("expected value or result, got None or Err");

        let str = "Reminders\n - 2026-01-18 17:00\n   TEST";

        assert_eq!(list(&mut config).await, Ok(String::from(str)));
        mock.expect(1);
        mock2.expect(1);
    }
    use pretty_assertions::assert_eq;
}