From 84adbdc0494df4214243f3abdd61082d9a4de5dc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dominykas=20Dja=C4=8Denko?= <chaosteil@gmail.com>
Date: Mon, 16 Jan 2023 11:47:45 -0800
Subject: [PATCH] Enable support for APIv2 (#83)

* Make the project work with v2 of the REST API

* Get rid of all warnings

* Make color strings

* Make project work again with real data

* Go through the whole migration plan in source

* Make all the tests pass

* Enforce sorting of list
---
 src/api/color.rs                           |  43 --
 src/api/deserialize.rs                     |  25 --
 src/api/mod.rs                             |   4 -
 src/api/rest/comment.rs                    |   8 +-
 src/api/rest/display.rs                    |   2 +-
 src/api/rest/gateway.rs                    | 268 +++++++------
 src/api/rest/label.rs                      |  25 +-
 src/api/rest/mod.rs                        |   2 +-
 src/api/rest/project.rs                    |  71 ++--
 src/api/rest/section.rs                    |  10 +-
 src/api/rest/task.rs                       |  57 +--
 src/api/sync/data.rs                       |   7 +-
 src/api/sync/state.rs                      |   4 +-
 src/api/tree.rs                            |  95 ++---
 src/config.rs                              |   2 +-
 src/interactive.rs                         |  18 +-
 src/labels/delete.rs                       |   2 +-
 src/labels/label.rs                        |   2 +-
 src/projects/comment.rs                    |   2 +-
 src/projects/delete.rs                     |   2 +-
 src/projects/list.rs                       |  24 +-
 src/projects/state.rs                      |   8 +-
 src/projects/view.rs                       |   6 +-
 src/sections/add.rs                        |   2 +-
 src/sections/delete.rs                     |   2 +-
 src/tasks/add.rs                           |   8 +-
 src/tasks/close.rs                         |  12 +-
 src/tasks/edit.rs                          |   2 +-
 src/tasks/filter.rs                        |   6 +-
 src/tasks/list.rs                          |  18 +-
 src/tasks/state.rs                         |  21 +-
 src/tasks/view.rs                          |   4 +-
 tests/commands/fixtures/labels.json        |  12 +-
 tests/commands/fixtures/projects.json      |  92 +++--
 tests/commands/fixtures/sections.json      |  32 +-
 tests/commands/fixtures/tasks.json         | 433 ++++++++++-----------
 tests/commands/fixtures/tasks_partial.json |  41 +-
 tests/commands/mocks.rs                    |  10 +-
 38 files changed, 685 insertions(+), 697 deletions(-)
 delete mode 100644 src/api/color.rs
 delete mode 100644 src/api/deserialize.rs

diff --git a/src/api/color.rs b/src/api/color.rs
deleted file mode 100644
index ed71d61..0000000
--- a/src/api/color.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-/// Maps the color number used by the Todoist API to a specific color name.
-#[allow(missing_docs)]
-#[derive(
-    Clone,
-    Copy,
-    Debug,
-    serde_repr::Serialize_repr,
-    serde_repr::Deserialize_repr,
-    PartialEq,
-    Eq,
-    Ord,
-    PartialOrd,
-)]
-#[repr(u16)]
-pub enum Color {
-    Unknown,
-    BerryRed = 30,
-    Red,
-    Orange,
-    Yellow,
-    OliveGreen,
-    LimeGreen,
-    Green,
-    MintGreen,
-    Teal,
-    SkyBlue,
-    LightBlue,
-    Blue,
-    Grape,
-    Violet,
-    Lavender,
-    Magenta,
-    Salmon,
-    Charcoal,
-    Grey,
-    Taupe,
-}
-
-impl Default for Color {
-    fn default() -> Self {
-        Color::Unknown
-    }
-}
diff --git a/src/api/deserialize.rs b/src/api/deserialize.rs
deleted file mode 100644
index 1e74894..0000000
--- a/src/api/deserialize.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use serde::{Deserialize, Deserializer};
-
-/// When deserializing and the content is a zero, it returns [`Option::None`] otherwise
-/// [`Option::Some`] with the value that was deserialized.
-pub(crate) fn deserialize_zero_to_none<'de, D, T: Deserialize<'de> + num_traits::Zero>(
-    deserializer: D,
-) -> Result<Option<T>, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    #[derive(Deserialize)]
-    struct Value<U>(Option<U>);
-    let v: Value<T> = Deserialize::deserialize(deserializer)?;
-    let result = match v.0 {
-        Some(v) => {
-            if v.is_zero() {
-                None
-            } else {
-                Some(v)
-            }
-        }
-        None => None,
-    };
-    Ok(result)
-}
diff --git a/src/api/mod.rs b/src/api/mod.rs
index b57bd95..62e70a4 100644
--- a/src/api/mod.rs
+++ b/src/api/mod.rs
@@ -2,9 +2,5 @@
 pub mod rest;
 pub mod tree;
 
-mod color;
-mod deserialize;
 mod serialize;
 mod sync;
-
-pub use color::*;
diff --git a/src/api/rest/comment.rs b/src/api/rest/comment.rs
index e2925ec..e149b12 100644
--- a/src/api/rest/comment.rs
+++ b/src/api/rest/comment.rs
@@ -5,10 +5,10 @@ use crate::api::serialize::todoist_rfc3339;
 use super::{ProjectID, TaskID};
 
 /// CommentID describes the unique ID of a [`Comment`].
-pub type CommentID = u64;
+pub type CommentID = String;
 
 /// ThreadID is the ID of the location where the comment is posted.
-#[derive(Debug, Serialize, Deserialize, Copy, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 #[serde(untagged)]
 pub enum ThreadID {
     /// The ID of the project this comment is attached to.
@@ -25,7 +25,7 @@ pub enum ThreadID {
 
 /// Comment describes a Comment from the Todoist API.
 ///
-/// Taken from the [Developer Documentation](https://developer.todoist.com/rest/v1/#comments)
+/// Taken from the [Developer Documentation](https://developer.todoist.com/rest/v2/#comments)
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Comment {
     /// The unique ID of a comment.
@@ -35,7 +35,7 @@ pub struct Comment {
     pub thread: ThreadID,
     /// The date when the comment was posted.
     #[serde(serialize_with = "todoist_rfc3339")]
-    pub posted: chrono::DateTime<chrono::Utc>,
+    pub posted_at: chrono::DateTime<chrono::Utc>,
     /// Contains the comment text with markdown.
     pub content: String,
     /// Optional attachment file description.
diff --git a/src/api/rest/display.rs b/src/api/rest/display.rs
index be55ee3..9a0732c 100644
--- a/src/api/rest/display.rs
+++ b/src/api/rest/display.rs
@@ -17,7 +17,7 @@ impl std::fmt::Display for FullComment<'_> {
                 .id
                 .if_supports_color(Stream::Stdout, |text| text.bright_yellow())
         )?;
-        writeln!(f, "Posted: {}", comment.posted)?;
+        writeln!(f, "Posted: {}", comment.posted_at)?;
         writeln!(
             f,
             "Attachment: {}",
diff --git a/src/api/rest/gateway.rs b/src/api/rest/gateway.rs
index 3346343..adc7d2a 100644
--- a/src/api/rest/gateway.rs
+++ b/src/api/rest/gateway.rs
@@ -51,8 +51,8 @@ impl Gateway {
     /// Retuns a [`Task`].
     ///
     /// * `id` - the ID as used by the Todoist API.
-    pub async fn task(&self, id: TaskID) -> Result<Task> {
-        self.get::<(), _>(&format!("rest/v1/tasks/{}", id), None)
+    pub async fn task(&self, id: &TaskID) -> Result<Task> {
+        self.get::<(), _>(&format!("rest/v2/tasks/{}", id), None)
             .await
             .wrap_err("unable to get task")
     }
@@ -62,7 +62,7 @@ impl Gateway {
     /// * `filter` - a filter query as described in the [documentation](https://todoist.com/help/articles/205248842).
     pub async fn tasks(&self, filter: Option<&str>) -> Result<Vec<Task>> {
         self.get(
-            "rest/v1/tasks",
+            "rest/v2/tasks",
             filter.map(|filter| vec![("filter", filter)]),
         )
         .await
@@ -72,9 +72,9 @@ impl Gateway {
     /// Closes a task.
     ///
     /// Equivalent to pushing the circle in the UI.
-    pub async fn close(&self, id: TaskID) -> Result<()> {
+    pub async fn close(&self, id: &TaskID) -> Result<()> {
         self.post_empty(
-            &format!("rest/v1/tasks/{}/close", id),
+            &format!("rest/v2/tasks/{}/close", id),
             &serde_json::Map::new(),
         )
         .await
@@ -86,7 +86,7 @@ impl Gateway {
     /// recurring, it will stop doing that.
     /// This is a bit hacky, but the REST API does not support completely closing tasks without
     /// deleting them.
-    pub async fn complete(&self, id: TaskID) -> Result<()> {
+    pub async fn complete(&self, id: &TaskID) -> Result<()> {
         self.update(
             id,
             &UpdateTask {
@@ -102,15 +102,15 @@ impl Gateway {
 
     /// Creates a task by calling the Todoist API.
     pub async fn create(&self, task: &CreateTask) -> Result<Task> {
-        self.post("rest/v1/tasks", task)
+        self.post("rest/v2/tasks", task)
             .await
             .wrap_err("unable to create task")?
             .ok_or_else(|| eyre!("unable to create task"))
     }
 
     /// Updates a task with the data as specified in UpdateTask.
-    pub async fn update(&self, id: TaskID, task: &UpdateTask) -> Result<()> {
-        self.post_empty(&format!("rest/v1/tasks/{}", id), &task)
+    pub async fn update(&self, id: &TaskID, task: &UpdateTask) -> Result<()> {
+        self.post_empty(&format!("rest/v2/tasks/{}", id), &task)
             .await
             .wrap_err("unable to update task")?;
         Ok(())
@@ -118,42 +118,42 @@ impl Gateway {
 
     /// Returns the list of Projects.
     pub async fn projects(&self) -> Result<Vec<Project>> {
-        self.get::<(), _>("rest/v1/projects", None)
+        self.get::<(), _>("rest/v2/projects", None)
             .await
             .wrap_err("unable to get projects")
     }
 
     /// Returns the list of all Sections.
     pub async fn sections(&self) -> Result<Vec<Section>> {
-        self.get::<(), _>("rest/v1/sections", None)
+        self.get::<(), _>("rest/v2/sections", None)
             .await
             .wrap_err("unable to get sections")
     }
 
     /// Returns the list of all Labels.
     pub async fn labels(&self) -> Result<Vec<Label>> {
-        self.get::<(), _>("rest/v1/labels", None)
+        self.get::<(), _>("rest/v2/labels", None)
             .await
             .wrap_err("unable to get labels")
     }
 
     /// Returns the list of all comments attached to the given Project.
-    pub async fn project_comments(&self, id: ProjectID) -> Result<Vec<Comment>> {
-        self.get("rest/v1/comments", Some(&[("project_id", id)]))
+    pub async fn project_comments(&self, id: &ProjectID) -> Result<Vec<Comment>> {
+        self.get("rest/v2/comments", Some(&[("project_id", id)]))
             .await
             .wrap_err("unable to get comments")
     }
 
     /// Returns the list of all comments attached to the given Task.
-    pub async fn task_comments(&self, id: TaskID) -> Result<Vec<Comment>> {
-        self.get("rest/v1/comments", Some(&[("task_id", id)]))
+    pub async fn task_comments(&self, id: &TaskID) -> Result<Vec<Comment>> {
+        self.get("rest/v2/comments", Some(&[("task_id", id)]))
             .await
             .wrap_err("unable to get comments")
     }
 
     /// Creates a comment by calling the API.
     pub async fn create_comment(&self, comment: &CreateComment) -> Result<Comment> {
-        self.post("rest/v1/comments", comment)
+        self.post("rest/v2/comments", comment)
             .await
             .wrap_err("unable to create comment")?
             .ok_or_else(|| eyre!("unable to create comment"))
@@ -162,23 +162,23 @@ impl Gateway {
     /// Returns details about a single project.
     ///
     /// * `id` - the ID as used by the Todoist API.
-    pub async fn project(&self, id: ProjectID) -> Result<Project> {
-        self.get::<(), _>(&format!("rest/v1/projects/{}", id), None)
+    pub async fn project(&self, id: &ProjectID) -> Result<Project> {
+        self.get::<(), _>(&format!("rest/v2/projects/{}", id), None)
             .await
             .wrap_err("unable to get project")
     }
 
     /// Creates a project by calling the Todoist API.
     pub async fn create_project(&self, project: &CreateProject) -> Result<Project> {
-        self.post("rest/v1/projects", project)
+        self.post("rest/v2/projects", project)
             .await
             .wrap_err("unable to create project")?
             .ok_or_else(|| eyre!("unable to create project"))
     }
 
     /// Deletes a project by calling the Todoist API.
-    pub async fn delete_project(&self, project: ProjectID) -> Result<()> {
-        self.delete(&format!("rest/v1/projects/{}", project))
+    pub async fn delete_project(&self, project: &ProjectID) -> Result<()> {
+        self.delete(&format!("rest/v2/projects/{}", project))
             .await
             .wrap_err("unable to delete project")
     }
@@ -186,23 +186,23 @@ impl Gateway {
     /// Returns details about a single section.
     ///
     /// * `id` - the ID as used by the Todoist API.
-    pub async fn section(&self, id: SectionID) -> Result<Section> {
-        self.get::<(), _>(&format!("rest/v1/sections/{}", id), None)
+    pub async fn section(&self, id: &SectionID) -> Result<Section> {
+        self.get::<(), _>(&format!("rest/v2/sections/{}", id), None)
             .await
             .wrap_err("unable to get section")
     }
 
     /// Creates a section by calling the Todoist API.
     pub async fn create_section(&self, section: &CreateSection) -> Result<Section> {
-        self.post("rest/v1/sections", section)
+        self.post("rest/v2/sections", section)
             .await
             .wrap_err("unable to create section")?
             .ok_or_else(|| eyre!("unable to create section"))
     }
 
     /// Deletes a section by calling the Todoist API.
-    pub async fn delete_section(&self, section: SectionID) -> Result<()> {
-        self.delete(&format!("rest/v1/sections/{}", section))
+    pub async fn delete_section(&self, section: &SectionID) -> Result<()> {
+        self.delete(&format!("rest/v2/sections/{}", section))
             .await
             .wrap_err("unable to delete section")
     }
@@ -210,23 +210,23 @@ impl Gateway {
     /// Returns details about a single label.
     ///
     /// * `id` - the ID as used by the Todoist API.
-    pub async fn label(&self, id: LabelID) -> Result<Label> {
-        self.get::<(), _>(&format!("rest/v1/labels/{}", id), None)
+    pub async fn label(&self, id: &LabelID) -> Result<Label> {
+        self.get::<(), _>(&format!("rest/v2/labels/{}", id), None)
             .await
             .wrap_err("unable to get label")
     }
 
     /// Creates a label by calling the Todoist API.
     pub async fn create_label(&self, label: &CreateLabel) -> Result<Label> {
-        self.post("rest/v1/labels", label)
+        self.post("rest/v2/labels", label)
             .await
             .wrap_err("unable to create label")?
             .ok_or_else(|| eyre!("unable to create label"))
     }
 
     /// Deletes a label by calling the Todoist API.
-    pub async fn delete_label(&self, label: LabelID) -> Result<()> {
-        self.delete(&format!("rest/v1/labels/{}", label))
+    pub async fn delete_label(&self, label: &LabelID) -> Result<()> {
+        self.delete(&format!("rest/v2/labels/{}", label))
             .await
             .wrap_err("unable to delete label")
     }
@@ -315,7 +315,7 @@ mod test {
     };
 
     use super::*;
-    use crate::api::rest::{CommentID, ProjectID, Task, TaskID, ThreadID};
+    use crate::api::rest::{Task, ThreadID};
     use color_eyre::Result;
 
     #[tokio::test]
@@ -323,12 +323,14 @@ mod test {
         let mock_server = MockServer::start().await;
         Mock::given(method("GET"))
             .and(bearer_token("hellothere"))
-            .and(path("/rest/v1/tasks/123"))
-            .respond_with(ResponseTemplate::new(200).set_body_json(create_task(123, 456, "hello")))
+            .and(path("/rest/v2/tasks/123"))
+            .respond_with(
+                ResponseTemplate::new(200).set_body_json(create_task("123", "456", "hello")),
+            )
             .mount(&mock_server)
             .await;
         let gw = gateway("hellothere", &mock_server);
-        let task = gw.task(123).await;
+        let task = gw.task(&"123".to_string()).await;
         assert!(task.is_ok());
     }
 
@@ -336,25 +338,27 @@ mod test {
     async fn task() {
         let mock_server = MockServer::start().await;
         Mock::given(method("GET"))
-            .and(path("/rest/v1/tasks/123"))
-            .respond_with(ResponseTemplate::new(200).set_body_json(create_task(123, 456, "hello")))
+            .and(path("/rest/v2/tasks/123"))
+            .respond_with(
+                ResponseTemplate::new(200).set_body_json(create_task("123", "456", "hello")),
+            )
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
-        let task = gw.task(123).await.unwrap();
+        let task = gw.task(&"123".to_string()).await.unwrap();
         mock_server.verify().await;
-        assert_eq!(task.id, 123);
-        assert!(gw.task(1234).await.is_err());
+        assert_eq!(task.id, "123");
+        assert!(gw.task(&"1234".to_string()).await.is_err());
     }
 
     #[tokio::test]
     async fn tasks() -> Result<()> {
         let mock_server = MockServer::start().await;
         Mock::given(method("GET"))
-            .and(path("/rest/v1/tasks"))
+            .and(path("/rest/v2/tasks"))
             .respond_with(ResponseTemplate::new(200).set_body_json(&[
-                create_task(123, 456, "hello there"),
-                create_task(234, 567, "general kenobi"),
+                create_task("123", "456", "hello there"),
+                create_task("234", "567", "general kenobi"),
             ]))
             .mount(&mock_server)
             .await;
@@ -369,12 +373,12 @@ mod test {
     async fn close_task() {
         let mock_server = MockServer::start().await;
         Mock::given(method("POST"))
-            .and(path("/rest/v1/tasks/123/close"))
+            .and(path("/rest/v2/tasks/123/close"))
             .respond_with(ResponseTemplate::new(204))
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
-        let closed = gw.close(123).await;
+        let closed = gw.close(&"123".to_string()).await;
         assert!(closed.is_ok());
     }
 
@@ -382,17 +386,17 @@ mod test {
     async fn complete_task() {
         let mock_server = MockServer::start().await;
         Mock::given(method("POST"))
-            .and(path("/rest/v1/tasks/123"))
+            .and(path("/rest/v2/tasks/123"))
             .respond_with(ResponseTemplate::new(204))
             .mount(&mock_server)
             .await;
         Mock::given(method("POST"))
-            .and(path("/rest/v1/tasks/123/close"))
+            .and(path("/rest/v2/tasks/123/close"))
             .respond_with(ResponseTemplate::new(204))
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
-        let completed = gw.complete(123).await;
+        let completed = gw.complete(&"123".to_string()).await;
         mock_server.verify().await;
         assert!(completed.is_ok());
     }
@@ -401,14 +405,14 @@ mod test {
     async fn update_task() {
         let mock_server = MockServer::start().await;
         Mock::given(method("POST"))
-            .and(path("/rest/v1/tasks/123"))
+            .and(path("/rest/v2/tasks/123"))
             .respond_with(ResponseTemplate::new(204))
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
         let completed = gw
             .update(
-                123,
+                &"123".to_string(),
                 &UpdateTask {
                     content: Some("hello".to_string()),
                     ..Default::default()
@@ -423,31 +427,33 @@ mod test {
     async fn creates_task() {
         let mock_server = MockServer::start().await;
         Mock::given(method("POST"))
-            .and(path("/rest/v1/tasks"))
-            .respond_with(ResponseTemplate::new(200).set_body_json(create_task(123, 456, "hello")))
+            .and(path("/rest/v2/tasks"))
+            .respond_with(
+                ResponseTemplate::new(200).set_body_json(create_task("123", "456", "hello")),
+            )
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
         let task = gw
             .create(&CreateTask {
                 content: "hello".to_string(),
-                project_id: Some(456),
+                project_id: Some("456".to_string()),
                 ..Default::default()
             })
             .await
             .unwrap();
         mock_server.verify().await;
-        assert_eq!(task.id, 123);
+        assert_eq!(task.id, "123");
     }
 
     #[tokio::test]
     async fn lists_projects() {
         let mock_server = MockServer::start().await;
         Mock::given(method("GET"))
-            .and(path("/rest/v1/projects"))
+            .and(path("/rest/v2/projects"))
             .respond_with(
                 ResponseTemplate::new(200)
-                    .set_body_json(vec![Project::new(123, "one"), Project::new(456, "two")]),
+                    .set_body_json(vec![Project::new("123", "one"), Project::new("456", "two")]),
             )
             .mount(&mock_server)
             .await;
@@ -461,14 +467,14 @@ mod test {
     async fn show_project() {
         let mock_server = MockServer::start().await;
         Mock::given(method("GET"))
-            .and(path("/rest/v1/projects/123"))
-            .respond_with(ResponseTemplate::new(200).set_body_json(Project::new(123, "one")))
+            .and(path("/rest/v2/projects/123"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(Project::new("123", "one")))
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
-        let project = gw.project(123).await.unwrap();
+        let project = gw.project(&"123".to_string()).await.unwrap();
         mock_server.verify().await;
-        assert_eq!(project.id, 123);
+        assert_eq!(project.id, "123");
         assert_eq!(project.name, "one");
     }
 
@@ -476,10 +482,10 @@ mod test {
     async fn lists_labels() {
         let mock_server = MockServer::start().await;
         Mock::given(method("GET"))
-            .and(path("/rest/v1/labels"))
+            .and(path("/rest/v2/labels"))
             .respond_with(
                 ResponseTemplate::new(200)
-                    .set_body_json(vec![Label::new(123, "one"), Label::new(456, "two")]),
+                    .set_body_json(vec![Label::new("123", "one"), Label::new("456", "two")]),
             )
             .mount(&mock_server)
             .await;
@@ -493,14 +499,14 @@ mod test {
     async fn show_label() {
         let mock_server = MockServer::start().await;
         Mock::given(method("GET"))
-            .and(path("/rest/v1/labels/123"))
-            .respond_with(ResponseTemplate::new(200).set_body_json(Label::new(123, "one")))
+            .and(path("/rest/v2/labels/123"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(Label::new("123", "one")))
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
-        let label = gw.label(123).await.unwrap();
+        let label = gw.label(&"123".to_string()).await.unwrap();
         mock_server.verify().await;
-        assert_eq!(label.id, 123);
+        assert_eq!(label.id, "123");
         assert_eq!(label.name, "one");
     }
 
@@ -508,10 +514,10 @@ mod test {
     async fn lists_sections() {
         let mock_server = MockServer::start().await;
         Mock::given(method("GET"))
-            .and(path("/rest/v1/sections"))
+            .and(path("/rest/v2/sections"))
             .respond_with(ResponseTemplate::new(200).set_body_json(vec![
-                Section::new(123, 1, "one"),
-                Section::new(456, 2, "two"),
+                Section::new("123", "1", "one"),
+                Section::new("456", "2", "two"),
             ]))
             .mount(&mock_server)
             .await;
@@ -525,14 +531,14 @@ mod test {
     async fn show_section() {
         let mock_server = MockServer::start().await;
         Mock::given(method("GET"))
-            .and(path("/rest/v1/sections/123"))
-            .respond_with(ResponseTemplate::new(200).set_body_json(Section::new(123, 1, "one")))
+            .and(path("/rest/v2/sections/123"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(Section::new("123", "1", "one")))
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
-        let section = gw.section(123).await.unwrap();
+        let section = gw.section(&"123".to_string()).await.unwrap();
         mock_server.verify().await;
-        assert_eq!(section.id, 123);
+        assert_eq!(section.id, "123");
         assert_eq!(section.name, "one");
     }
 
@@ -540,10 +546,12 @@ mod test {
     async fn create_project_comment() {
         let mock_server = MockServer::start().await;
         Mock::given(method("POST"))
-            .and(path("/rest/v1/comments"))
+            .and(path("/rest/v2/comments"))
             .respond_with(ResponseTemplate::new(200).set_body_json(create_comment(
-                1,
-                ThreadID::Project { project_id: 123 },
+                "1",
+                ThreadID::Project {
+                    project_id: "123".to_string(),
+                },
                 "hello",
             )))
             .mount(&mock_server)
@@ -551,13 +559,15 @@ mod test {
         let gw = gateway("", &mock_server);
         let comment = gw
             .create_comment(&CreateComment {
-                thread: ThreadID::Project { project_id: 123 },
+                thread: ThreadID::Project {
+                    project_id: "123".to_string(),
+                },
                 content: "hello".to_string(),
             })
             .await
             .unwrap();
         mock_server.verify().await;
-        assert_eq!(comment.id, 1);
+        assert_eq!(comment.id, "1");
         assert_eq!(comment.content, "hello");
     }
 
@@ -565,10 +575,12 @@ mod test {
     async fn create_task_comment() {
         let mock_server = MockServer::start().await;
         Mock::given(method("POST"))
-            .and(path("/rest/v1/comments"))
+            .and(path("/rest/v2/comments"))
             .respond_with(ResponseTemplate::new(200).set_body_json(create_comment(
-                1,
-                ThreadID::Task { task_id: 123 },
+                "1",
+                ThreadID::Task {
+                    task_id: "123".to_string(),
+                },
                 "hello",
             )))
             .mount(&mock_server)
@@ -576,13 +588,15 @@ mod test {
         let gw = gateway("", &mock_server);
         let comment = gw
             .create_comment(&CreateComment {
-                thread: ThreadID::Task { task_id: 123 },
+                thread: ThreadID::Task {
+                    task_id: "123".to_string(),
+                },
                 content: "hello".to_string(),
             })
             .await
             .unwrap();
         mock_server.verify().await;
-        assert_eq!(comment.id, 1);
+        assert_eq!(comment.id, "1");
         assert_eq!(comment.content, "hello");
     }
 
@@ -590,26 +604,50 @@ mod test {
     async fn show_comments() {
         let mock_server = MockServer::start().await;
         Mock::given(method("GET"))
-            .and(path("/rest/v1/comments"))
+            .and(path("/rest/v2/comments"))
             .and(query_param("project_id", "123"))
             .respond_with(ResponseTemplate::new(200).set_body_json(vec![
-                create_comment(1, ThreadID::Project { project_id: 123 }, "hello"),
-                create_comment(1, ThreadID::Project { project_id: 123 }, "there"),
+                create_comment(
+                    "1",
+                    ThreadID::Project {
+                        project_id: "123".to_string(),
+                    },
+                    "hello",
+                ),
+                create_comment(
+                    "1",
+                    ThreadID::Project {
+                        project_id: "123".to_string(),
+                    },
+                    "there",
+                ),
             ]))
             .mount(&mock_server)
             .await;
         Mock::given(method("GET"))
-            .and(path("/rest/v1/comments"))
+            .and(path("/rest/v2/comments"))
             .and(query_param("task_id", "456"))
             .respond_with(ResponseTemplate::new(200).set_body_json(vec![
-                create_comment(1, ThreadID::Task { task_id: 456 }, "no"),
-                create_comment(1, ThreadID::Task { task_id: 456 }, "way"),
+                create_comment(
+                    "1",
+                    ThreadID::Task {
+                        task_id: "456".to_string(),
+                    },
+                    "no",
+                ),
+                create_comment(
+                    "1",
+                    ThreadID::Task {
+                        task_id: "456".to_string(),
+                    },
+                    "way",
+                ),
             ]))
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
-        let project_comments = gw.project_comments(123).await.unwrap();
-        let task_comments = gw.task_comments(456).await.unwrap();
+        let project_comments = gw.project_comments(&"123".to_string()).await.unwrap();
+        let task_comments = gw.task_comments(&"456".to_string()).await.unwrap();
         mock_server.verify().await;
         assert_eq!(project_comments.len(), 2);
         assert_eq!(project_comments[0].content, "hello");
@@ -621,8 +659,8 @@ mod test {
     async fn creates_label() {
         let mock_server = MockServer::start().await;
         Mock::given(method("POST"))
-            .and(path("/rest/v1/labels"))
-            .respond_with(ResponseTemplate::new(200).set_body_json(Label::new(123, "hello")))
+            .and(path("/rest/v2/labels"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(Label::new("123", "hello")))
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
@@ -634,19 +672,19 @@ mod test {
             .await
             .unwrap();
         mock_server.verify().await;
-        assert_eq!(label.id, 123);
+        assert_eq!(label.id, "123");
     }
 
     #[tokio::test]
     async fn delete_label() {
         let mock_server = MockServer::start().await;
         Mock::given(method("DELETE"))
-            .and(path("/rest/v1/labels/123"))
+            .and(path("/rest/v2/labels/123"))
             .respond_with(ResponseTemplate::new(204))
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
-        let closed = gw.delete_label(123).await;
+        let closed = gw.delete_label(&"123".to_string()).await;
         assert!(closed.is_ok());
     }
 
@@ -654,8 +692,8 @@ mod test {
     async fn creates_project() {
         let mock_server = MockServer::start().await;
         Mock::given(method("POST"))
-            .and(path("/rest/v1/projects"))
-            .respond_with(ResponseTemplate::new(200).set_body_json(Project::new(123, "hello")))
+            .and(path("/rest/v2/projects"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(Project::new("123", "hello")))
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
@@ -667,19 +705,19 @@ mod test {
             .await
             .unwrap();
         mock_server.verify().await;
-        assert_eq!(project.id, 123);
+        assert_eq!(project.id, "123");
     }
 
     #[tokio::test]
     async fn delete_project() {
         let mock_server = MockServer::start().await;
         Mock::given(method("DELETE"))
-            .and(path("/rest/v1/projects/123"))
+            .and(path("/rest/v2/projects/123"))
             .respond_with(ResponseTemplate::new(204))
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
-        let closed = gw.delete_project(123).await;
+        let closed = gw.delete_project(&"123".to_string()).await;
         assert!(closed.is_ok());
     }
 
@@ -691,49 +729,51 @@ mod test {
     async fn creates_section() {
         let mock_server = MockServer::start().await;
         Mock::given(method("POST"))
-            .and(path("/rest/v1/sections"))
-            .respond_with(ResponseTemplate::new(200).set_body_json(Section::new(123, 456, "heya")))
+            .and(path("/rest/v2/sections"))
+            .respond_with(
+                ResponseTemplate::new(200).set_body_json(Section::new("123", "456", "heya")),
+            )
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
         let section = gw
             .create_section(&CreateSection {
                 name: "hello".to_string(),
-                project_id: 456,
+                project_id: "456".to_string(),
                 ..Default::default()
             })
             .await
             .unwrap();
         mock_server.verify().await;
-        assert_eq!(section.id, 123);
-        assert_eq!(section.project_id, 456);
+        assert_eq!(section.id, "123");
+        assert_eq!(section.project_id, "456");
     }
 
     #[tokio::test]
     async fn delete_section() {
         let mock_server = MockServer::start().await;
         Mock::given(method("DELETE"))
-            .and(path("/rest/v1/sections/123"))
+            .and(path("/rest/v2/sections/123"))
             .respond_with(ResponseTemplate::new(204))
             .mount(&mock_server)
             .await;
         let gw = gateway("", &mock_server);
-        let closed = gw.delete_section(123).await;
+        let closed = gw.delete_section(&"123".to_string()).await;
         assert!(closed.is_ok());
     }
 
-    fn create_task(id: TaskID, project_id: ProjectID, content: &str) -> Task {
+    fn create_task(id: &str, project_id: &str, content: &str) -> Task {
         crate::api::rest::Task {
-            project_id,
+            project_id: project_id.to_string(),
             ..crate::api::rest::Task::new(id, content)
         }
     }
 
-    fn create_comment(id: CommentID, tid: ThreadID, content: &str) -> Comment {
+    fn create_comment(id: &str, tid: ThreadID, content: &str) -> Comment {
         Comment {
-            id,
+            id: id.to_string(),
             thread: tid,
-            posted: Utc::now(),
+            posted_at: Utc::now(),
             content: content.to_string(),
             attachment: None,
         }
diff --git a/src/api/rest/label.rs b/src/api/rest/label.rs
index 750fe08..a1fbdeb 100644
--- a/src/api/rest/label.rs
+++ b/src/api/rest/label.rs
@@ -1,15 +1,13 @@
 use owo_colors::{OwoColorize, Stream};
 use serde::{Deserialize, Serialize};
-use serde_with::{serde_as, DefaultOnError};
-
-use crate::api::Color;
+use serde_with::serde_as;
 
 /// LabelID specifies the unique ID of a [`Label`].
-pub type LabelID = usize;
+pub type LabelID = String;
 
 /// Label is a tag associated with a Task. Marked with `@name` in the UI.
 ///
-/// Taken from the [Developer Documentation](https://developer.todoist.com/rest/v1/#labels).
+/// Taken from the [Developer Documentation](https://developer.todoist.com/rest/v2/#labels).
 #[serde_as]
 #[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone)]
 pub struct Label {
@@ -18,12 +16,11 @@ pub struct Label {
     /// Name of the label. Written as `@name` in the UI.
     pub name: String,
     /// The display color of the label as given from the API.
-    #[serde_as(deserialize_as = "DefaultOnError")]
-    pub color: Color,
+    pub color: String,
     /// The order among labels if we were to sort them.
     pub order: isize,
     /// Toggle for marking a label as a favorite.
-    pub favorite: bool,
+    pub is_favorite: bool,
 }
 
 impl Ord for Label {
@@ -60,7 +57,7 @@ pub struct CreateLabel {
     pub order: Option<isize>,
     /// Color of the label icon.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub color: Option<Color>,
+    pub color: Option<String>,
     /// Mark as favorite or not.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub favorite: Option<bool>,
@@ -70,13 +67,13 @@ pub struct CreateLabel {
 impl Label {
     /// This is initializer is used for tests, as in general the tool relies on the API and not
     /// local state.
-    pub fn new(id: LabelID, name: &str) -> Label {
+    pub fn new(id: &str, name: &str) -> Label {
         Label {
-            id,
+            id: id.to_string(),
             name: name.to_string(),
-            color: crate::api::Color::Unknown,
+            color: "".to_string(),
             order: 0,
-            favorite: false,
+            is_favorite: false,
         }
     }
 }
@@ -85,7 +82,7 @@ impl Label {
 mod test {
     #[test]
     fn succeeds_with_bad_color() {
-        let label = r#"{"id":123,"name":"hello","color":7,"order":0,"favorite":false}"#;
+        let label = r#"{"id":"123","name":"hello","color":"wow","order":0,"is_favorite":false}"#;
         assert!(serde_json::from_str::<'_, super::Label>(label).is_ok());
     }
 }
diff --git a/src/api/rest/mod.rs b/src/api/rest/mod.rs
index 0d56e4e..7543889 100644
--- a/src/api/rest/mod.rs
+++ b/src/api/rest/mod.rs
@@ -1,7 +1,7 @@
 //! Contains low-level structs as used by the Todoist REST API and provides some tools to work
 //! with them.
 //!
-//! This maps parts of the [API Documentation](https://developer.todoist.com/rest/v1/#overview) to
+//! This maps parts of the [API Documentation](https://developer.todoist.com/rest/v2/#overview) to
 //! code that can be consumed by clients, including the actual network calls and
 //! serialization/deserialization..
 //!
diff --git a/src/api/rest/project.rs b/src/api/rest/project.rs
index c1f9b1c..ccfcf14 100644
--- a/src/api/rest/project.rs
+++ b/src/api/rest/project.rs
@@ -1,18 +1,17 @@
-use crate::api::deserialize::deserialize_zero_to_none;
-use crate::api::{tree::Treeable, Color};
+use crate::api::tree::Treeable;
 use owo_colors::{OwoColorize, Stream};
 use reqwest::Url;
 use serde::{Deserialize, Serialize};
-use serde_with::{serde_as, DefaultOnError};
+use serde_with::serde_as;
 
 /// ProjectID is the unique ID of a [`Project`]
-pub type ProjectID = u64;
+pub type ProjectID = String;
 /// ProjectSyncID is an identifier to mark between copies of shared projects.
-pub type ProjectSyncID = u64;
+pub type ProjectSyncID = String;
 
 /// Project as described by the Todoist API.
 ///
-/// Taken from the [Developer Documentation](https://developer.todoist.com/rest/v1/#projects).
+/// Taken from the [Developer Documentation](https://developer.todoist.com/rest/v2/#projects).
 #[serde_as]
 #[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Clone)]
 pub struct Project {
@@ -25,34 +24,50 @@ pub struct Project {
     /// How many project comments.
     pub comment_count: usize,
     /// Color as used by the Todoist UI.
-    #[serde_as(deserialize_as = "DefaultOnError")]
-    pub color: Color,
+    pub color: String,
     /// Whether the project is shared with someone else.
-    pub shared: bool,
+    pub is_shared: bool,
     /// Project order under the same parent.
-    pub order: Option<usize>,
+    pub order: usize,
     /// This marks the project as the initial Inbox project if it exists.
-    pub inbox_project: Option<bool>,
+    pub is_inbox_project: bool,
     /// This markes the project as a TeamInbox project if it exists.
-    pub team_inbox: Option<bool>,
-    /// Identifier to match between different copies of shared projects.
-    #[serde(deserialize_with = "deserialize_zero_to_none")]
-    pub sync_id: Option<ProjectSyncID>,
+    pub is_team_inbox: bool,
     /// Toggle to mark this project as a favorite.
-    pub favorite: bool,
+    pub is_favorite: bool,
     /// URL to the Todoist UI.
     pub url: Url,
+    /// View style to show in todoist clients.
+    pub view_style: ViewStyle,
+}
+
+/// ViewStyle for viewing of the project in different clients.
+///
+/// Taken from the [Developer Documentation](https://developer.todoist.com/rest/v2/#projects).
+#[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum ViewStyle {
+    /// Project as list view (default).
+    List,
+    /// Project as board view.
+    Board,
+}
+
+impl Default for ViewStyle {
+    fn default() -> Self {
+        Self::List
+    }
 }
 
 impl Treeable for Project {
     type ID = ProjectID;
 
     fn id(&self) -> ProjectID {
-        self.id
+        self.id.clone()
     }
 
     fn parent_id(&self) -> Option<ProjectID> {
-        self.parent_id
+        self.parent_id.clone()
     }
 
     fn reset_parent(&mut self) {
@@ -82,7 +97,7 @@ pub struct CreateProject {
     pub parent_id: Option<ProjectID>,
     /// Color of the project icon.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub color: Option<Color>,
+    pub color: Option<String>,
     /// Mark as favorite or not.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub favorite: Option<bool>,
@@ -92,20 +107,20 @@ pub struct CreateProject {
 impl Project {
     /// This is initializer is used for tests, as in general the tool relies on the API and not
     /// local state.
-    pub fn new(id: ProjectID, name: &str) -> Project {
+    pub fn new(id: &str, name: &str) -> Project {
         Project {
-            id,
+            id: id.to_string(),
             name: name.to_string(),
             parent_id: None,
             comment_count: 0,
-            color: crate::api::Color::Unknown,
-            shared: false,
-            order: None,
-            inbox_project: None,
-            team_inbox: None,
-            sync_id: None,
-            favorite: false,
+            color: "".to_string(),
+            is_shared: false,
+            order: 0,
+            is_inbox_project: false,
+            is_team_inbox: false,
+            is_favorite: false,
             url: "http://localhost".to_string().parse().unwrap(),
+            view_style: Default::default(),
         }
     }
 }
diff --git a/src/api/rest/section.rs b/src/api/rest/section.rs
index df57d55..96c0cff 100644
--- a/src/api/rest/section.rs
+++ b/src/api/rest/section.rs
@@ -4,11 +4,11 @@ use serde::{Deserialize, Serialize};
 use super::ProjectID;
 
 /// SectionID is the unique ID of a [`Section`].
-pub type SectionID = usize;
+pub type SectionID = String;
 
 /// Section describes a subsection of a [`super::Project`].
 ///
-/// Taken from the [Developer Documentation](https://developer.todoist.com/rest/v1/#sections).
+/// Taken from the [Developer Documentation](https://developer.todoist.com/rest/v2/#sections).
 #[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone)]
 pub struct Section {
     /// The unique ID of this section.
@@ -65,10 +65,10 @@ pub struct CreateSection {
 impl Section {
     /// This is initializer is used for tests, as in general the tool relies on the API and not
     /// local state.
-    pub fn new(id: SectionID, project_id: ProjectID, name: &str) -> Section {
+    pub fn new(id: &str, project_id: &str, name: &str) -> Section {
         Section {
-            id,
-            project_id,
+            id: id.to_string(),
+            project_id: project_id.to_string(),
             name: name.to_string(),
             order: 0,
         }
diff --git a/src/api/rest/task.rs b/src/api/rest/task.rs
index 38af328..607c184 100644
--- a/src/api/rest/task.rs
+++ b/src/api/rest/task.rs
@@ -1,8 +1,8 @@
 use core::fmt;
 use std::fmt::Display;
 
+use crate::api::serialize::todoist_rfc3339;
 use crate::api::tree::Treeable;
-use crate::api::{deserialize::deserialize_zero_to_none, serialize::todoist_rfc3339};
 use chrono::{DateTime, FixedOffset, Utc};
 use owo_colors::{OwoColorize, Stream};
 use reqwest::Url;
@@ -12,13 +12,13 @@ use serde_repr::{Deserialize_repr, Serialize_repr};
 use super::{LabelID, ProjectID, SectionID};
 
 /// TaskID describes the unique ID of a [`Task`].
-pub type TaskID = u64;
+pub type TaskID = String;
 /// UserID is the unique ID of a User.
-pub type UserID = u64;
+pub type UserID = String;
 
 /// Task describes a Task from the Todoist API.
 ///
-/// Taken from the [Developer Documentation](https://developer.todoist.com/rest/v1/#tasks).
+/// Taken from the [Developer Documentation](https://developer.todoist.com/rest/v2/#tasks).
 #[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone)]
 pub struct Task {
     /// Unique ID of a Task.
@@ -26,16 +26,15 @@ pub struct Task {
     /// Shows which [`super::Project`] the Task belongs to.
     pub project_id: ProjectID,
     /// Set if the Task is also in a subsection of a Project.
-    #[serde(deserialize_with = "deserialize_zero_to_none")]
     pub section_id: Option<SectionID>,
     /// The main content of the Task, also known as Task name.
     pub content: String,
     /// Description is the description found under the content.
     pub description: String,
     /// Completed is set if this task was completed.
-    pub completed: bool,
-    /// All associated [`super::Label`]s to this Task.
-    pub label_ids: Vec<LabelID>,
+    pub is_completed: bool,
+    /// All associated [`super::Label`]s to this Task. Just label names are used here.
+    pub labels: Vec<String>,
     /// If set, this Task is a subtask of another.
     pub parent_id: Option<TaskID>,
     /// Order the order within the subtasks of a Task.
@@ -49,24 +48,25 @@ pub struct Task {
     /// How many comments are written for this Task.
     pub comment_count: usize,
     /// Who this task is assigned to.
-    pub assignee: Option<UserID>,
+    pub creator_id: UserID,
+    /// Who this task is assigned to.
+    pub assignee_id: Option<UserID>,
     /// Who assigned this task to the [`Task::assignee`]
-    #[serde(deserialize_with = "deserialize_zero_to_none")]
-    pub assigner: Option<UserID>,
+    pub assigner_id: Option<UserID>,
     /// Exact date when the task was created.
     #[serde(serialize_with = "todoist_rfc3339")]
-    pub created: DateTime<Utc>,
+    pub created_at: DateTime<Utc>,
 }
 
 impl Treeable for Task {
     type ID = TaskID;
 
     fn id(&self) -> TaskID {
-        self.id
+        self.id.clone()
     }
 
     fn parent_id(&self) -> Option<TaskID> {
-        self.parent_id
+        self.parent_id.clone()
     }
 
     fn reset_parent(&mut self) {
@@ -189,11 +189,11 @@ impl Display for ExactTime {
 pub struct DueDate {
     /// Human-redable form of the due date.
     #[serde(rename = "string")]
-    pub human_readable: String,
+    pub string: String,
     /// The date on which the Task is due.
     pub date: chrono::NaiveDate,
     /// Lets us know if it is recurring (reopens after close).
-    pub recurring: bool,
+    pub is_recurring: bool,
     /// If set, this shows the exact time the task is due.
     #[serde(flatten)]
     pub exact: Option<ExactTime>,
@@ -205,7 +205,7 @@ pub struct DueDateFormatter<'a>(pub &'a DueDate, pub &'a DateTime<Utc>);
 
 impl<'a> Display for DueDateFormatter<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if self.0.recurring {
+        if self.0.is_recurring {
             write!(
                 f,
                 "{}",
@@ -226,12 +226,12 @@ impl<'a> Display for DueDateFormatter<'a> {
                     exact.if_supports_color(Stream::Stdout, |text| text.bright_red())
                 )
             }
-        } else if self.0.date >= self.1.date().naive_utc() {
+        } else if self.0.date >= self.1.date_naive() {
             write!(
                 f,
                 "{}",
                 self.0
-                    .human_readable
+                    .string
                     .if_supports_color(Stream::Stdout, |text| text.bright_green())
             )
         } else {
@@ -239,7 +239,7 @@ impl<'a> Display for DueDateFormatter<'a> {
                 f,
                 "{}",
                 self.0
-                    .human_readable
+                    .string
                     .if_supports_color(Stream::Stdout, |text| text.bright_red())
             )
         }
@@ -319,24 +319,25 @@ pub struct UpdateTask {
 impl Task {
     /// This is initializer is used for tests, as in general the tool relies on the API and not
     /// local state.
-    pub fn new(id: TaskID, content: &str) -> Task {
+    pub fn new(id: &str, content: &str) -> Task {
         Task {
-            id,
-            project_id: 0,
+            id: id.to_string(),
+            project_id: "".to_string(),
             section_id: None,
             content: content.to_string(),
             description: String::new(),
-            completed: false,
-            label_ids: Vec::new(),
+            is_completed: false,
+            labels: Vec::new(),
             parent_id: None,
             order: 0,
             priority: Priority::default(),
             due: None,
             url: "http://localhost".to_string().parse().unwrap(),
             comment_count: 0,
-            assignee: None,
-            assigner: None,
-            created: Utc::now(),
+            creator_id: "0".to_string(),
+            assignee_id: None,
+            assigner_id: None,
+            created_at: Utc::now(),
         }
     }
 }
diff --git a/src/api/sync/data.rs b/src/api/sync/data.rs
index 3c86248..88e6208 100644
--- a/src/api/sync/data.rs
+++ b/src/api/sync/data.rs
@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 
-use crate::api::Color;
 use chrono::{DateTime, NaiveDate, NaiveDateTime, Utc};
 use serde::{Deserialize, Serialize};
 use serde_aux::prelude::*;
@@ -175,7 +174,7 @@ pub struct Project {
     pub id: ProjectID,
     pub legacy_id: Option<ProjectID>,
     pub name: String,
-    pub color: Color,
+    pub color: String,
     pub parent_id: Option<ProjectID>,
     pub legacy_parent_id: Option<ProjectID>,
     pub child_order: Order,
@@ -318,7 +317,7 @@ pub type LabelID = u64;
 pub struct Label {
     pub id: LabelID,
     pub name: String,
-    pub color: Color,
+    pub color: String,
     pub item_order: Order,
     #[serde(deserialize_with = "deserialize_bool_from_anything")]
     pub is_deleted: bool,
@@ -333,7 +332,7 @@ pub struct Filter {
     pub id: FilterID,
     pub name: String,
     pub query: String,
-    pub color: Color,
+    pub color: String,
     pub item_order: Order,
     #[serde(deserialize_with = "deserialize_bool_from_anything")]
     pub is_deleted: bool,
diff --git a/src/api/sync/state.rs b/src/api/sync/state.rs
index ec2a7dd..e36ff98 100644
--- a/src/api/sync/state.rs
+++ b/src/api/sync/state.rs
@@ -66,7 +66,7 @@ impl State {
     pub fn save(&self) -> color_eyre::Result<()> {
         let state = xdg::BaseDirectories::with_prefix("doist")?.place_state_file("state.json")?;
         let data = serde_json::to_string(self)?;
-        fs::write(&state, &data)?;
+        fs::write(state, data)?;
         Ok(())
     }
 
@@ -81,7 +81,7 @@ impl State {
         ];
         let res = client
             .post("https://api.todoist.com/sync/v8/sync")
-            .bearer_auth(&auth_token)
+            .bearer_auth(auth_token)
             .form(&params)
             .send()
             .await?
diff --git a/src/api/tree.rs b/src/api/tree.rs
index f25be81..4be29d5 100644
--- a/src/api/tree.rs
+++ b/src/api/tree.rs
@@ -26,7 +26,7 @@ pub trait Treeable: std::fmt::Debug + std::cmp::Ord {
 }
 
 /// Tree is a representation of Items as a tree.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Tree<T: Treeable> {
     /// The item of this Tree leaf.
     pub item: T,
@@ -212,9 +212,9 @@ pub trait TreeFlattenExt<T: Treeable> {
     /// its own indexable item. Useful for user selection lists.
     fn flat_tree(&self) -> Vec<&Tree<T>>;
     /// Finds a particular Tree item within the whole vector of Trees.
-    fn find(&self, id: T::ID) -> Option<&Tree<T>>;
+    fn find(&self, id: &T::ID) -> Option<&Tree<T>>;
     /// Finds a particular Tree item within the whole vector of Trees, mutably.
-    fn find_mut(&mut self, id: T::ID) -> Option<&mut Tree<T>>;
+    fn find_mut(&mut self, id: &T::ID) -> Option<&mut Tree<T>>;
     /// Uses the filter to keep only a subset of tasks of the current tree, but respects to keep
     /// parents.
     fn keep_trees(self, filter_items: &[T::ID]) -> Self
@@ -227,18 +227,18 @@ impl<T: Treeable> TreeFlattenExt<T> for Vec<Tree<T>> {
         self.iter().flat_map(Tree::flatten).collect()
     }
 
-    fn find(&self, id: T::ID) -> Option<&Tree<T>> {
+    fn find(&self, id: &T::ID) -> Option<&Tree<T>> {
         for item in self {
-            if let Some(item) = item.find(&id) {
+            if let Some(item) = item.find(id) {
                 return Some(item);
             }
         }
         None
     }
 
-    fn find_mut(&mut self, id: T::ID) -> Option<&mut Tree<T>> {
+    fn find_mut(&mut self, id: &T::ID) -> Option<&mut Tree<T>> {
         for item in self {
-            if let Some(item) = item.find_mut(&id) {
+            if let Some(item) = item.find_mut(id) {
                 return Some(item);
             }
         }
@@ -286,9 +286,9 @@ mod tests {
     #[test]
     fn test_tree_no_subitems() {
         let tasks = vec![
-            Task::new(1, "one"),
-            Task::new(2, "two"),
-            Task::new(3, "three"),
+            Task::new("1", "one"),
+            Task::new("2", "two"),
+            Task::new("3", "three"),
         ];
         let trees = Tree::from_items(tasks).unwrap();
         assert_eq!(trees.len(), 3);
@@ -297,22 +297,25 @@ mod tests {
     #[test]
     fn test_tree_some_subtasks() {
         let tasks = vec![
-            Task::new(1, "one"),
-            Task::new(2, "two"),
-            Task::new(3, "three"),
+            Task::new("1", "one"),
+            Task::new("2", "two"),
+            Task::new("3", "three"),
             Task {
-                parent_id: Some(1),
-                ..Task::new(4, "four")
+                parent_id: Some("1".to_string()),
+                ..Task::new("4", "four")
             },
         ];
         let trees = Tree::from_items(tasks).unwrap();
         assert_eq!(trees.len(), 3);
-        let task = trees.iter().filter(|t| t.item.id == 1).collect::<Vec<_>>();
+        let task = trees
+            .iter()
+            .filter(|t| t.item.id == "1")
+            .collect::<Vec<_>>();
         assert_eq!(task.len(), 1);
         let task = task[0];
         assert_eq!(task.subitems.len(), 1);
-        assert_eq!(task.subitems[0].item.id, 4);
-        for task in trees.into_iter().filter(|t| t.item.id != 1) {
+        assert_eq!(task.subitems[0].item.id, "4");
+        for task in trees.into_iter().filter(|t| t.item.id != "1") {
             assert_eq!(task.subitems.len(), 0);
         }
     }
@@ -320,29 +323,29 @@ mod tests {
     #[test]
     fn task_tree_complex_subtasks() {
         let tasks = vec![
-            Task::new(1, "one"),
+            Task::new("1", "one"),
             Task {
-                parent_id: Some(1),
-                ..Task::new(2, "two")
+                parent_id: Some("1".to_string()),
+                ..Task::new("2", "two")
             },
             Task {
-                parent_id: Some(2),
-                ..Task::new(3, "three")
+                parent_id: Some("2".to_string()),
+                ..Task::new("3", "three")
             },
             Task {
-                parent_id: Some(3),
-                ..Task::new(4, "four")
+                parent_id: Some("3".to_string()),
+                ..Task::new("4", "four")
             },
         ];
         let trees = Tree::from_items(tasks).unwrap();
         assert_eq!(trees.len(), 1);
-        assert_eq!(trees[0].item.id, 1);
+        assert_eq!(trees[0].item.id, "1");
         assert_eq!(trees[0].depth, 0);
-        assert_eq!(trees[0].subitems[0].item.id, 2);
+        assert_eq!(trees[0].subitems[0].item.id, "2");
         assert_eq!(trees[0].subitems[0].depth, 1);
-        assert_eq!(trees[0].subitems[0].subitems[0].item.id, 3);
+        assert_eq!(trees[0].subitems[0].subitems[0].item.id, "3");
         assert_eq!(trees[0].subitems[0].subitems[0].depth, 2);
-        assert_eq!(trees[0].subitems[0].subitems[0].subitems[0].item.id, 4);
+        assert_eq!(trees[0].subitems[0].subitems[0].subitems[0].item.id, "4");
         assert_eq!(trees[0].subitems[0].subitems[0].subitems[0].depth, 3);
     }
 
@@ -350,18 +353,18 @@ mod tests {
     fn task_tree_no_parent() {
         let tasks = vec![
             Task {
-                parent_id: Some(1),
-                ..Task::new(2, "two")
+                parent_id: Some("1".to_string()),
+                ..Task::new("2", "two")
             },
             Task {
-                parent_id: Some(2),
-                ..Task::new(3, "three")
+                parent_id: Some("2".to_string()),
+                ..Task::new("3", "three")
             },
         ];
         let trees = Tree::from_items(tasks).unwrap();
         assert_eq!(trees.len(), 1);
         assert_eq!(trees[0].item.parent_id, None);
-        assert_eq!(trees[0].subitems[0].item.id, 3);
+        assert_eq!(trees[0].subitems[0].item.id, "3");
     }
 
     #[test]
@@ -369,32 +372,32 @@ mod tests {
         let tasks = vec![
             Task {
                 parent_id: None,
-                ..Task::new(1, "one")
+                ..Task::new("1", "one")
             },
             Task {
-                parent_id: Some(1),
-                ..Task::new(2, "two")
+                parent_id: Some("1".to_string()),
+                ..Task::new("2", "two")
             },
             Task {
-                parent_id: Some(2),
-                ..Task::new(3, "three")
+                parent_id: Some("2".to_string()),
+                ..Task::new("3", "three")
             },
             Task {
                 parent_id: None,
-                ..Task::new(4, "four")
+                ..Task::new("4", "four")
             },
             Task {
                 parent_id: None,
-                ..Task::new(5, "five")
+                ..Task::new("5", "five")
             },
         ];
         let trees = Tree::from_items(tasks).unwrap();
-        let trees = trees.keep_trees(&[3, 4]);
+        let trees = trees.keep_trees(&["3".to_string(), "4".to_string()]);
         assert_eq!(trees.len(), 2);
-        assert_eq!(trees[0].item.id, 1);
+        assert_eq!(trees[0].item.id, "1");
         assert_eq!(trees[0].item.parent_id, None);
-        assert_eq!(trees[0].subitems[0].item.id, 2);
-        assert_eq!(trees[0].subitems[0].subitems[0].item.id, 3);
-        assert_eq!(trees[1].item.id, 4);
+        assert_eq!(trees[0].subitems[0].item.id, "2");
+        assert_eq!(trees[0].subitems[0].subitems[0].item.id, "3");
+        assert_eq!(trees[1].item.id, "4");
     }
 }
diff --git a/src/config.rs b/src/config.rs
index 0faf684..1a9d167 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -112,7 +112,7 @@ impl Config {
                 io,
             })?;
         let data = toml::to_string(self)?;
-        fs::write(&file, &data).map_err(|io| ConfigError::File { file, io })?;
+        fs::write(&file, data).map_err(|io| ConfigError::File { file, io })?;
         Ok(())
     }
 
diff --git a/src/interactive.rs b/src/interactive.rs
index 3faa613..90a562f 100644
--- a/src/interactive.rs
+++ b/src/interactive.rs
@@ -168,7 +168,7 @@ impl FuzzSelect for Project {
     type ID = ProjectID;
 
     fn id(&self) -> ProjectID {
-        self.id
+        self.id.clone()
     }
     fn name(&self) -> &str {
         &self.name
@@ -179,7 +179,7 @@ impl FuzzSelect for Section {
     type ID = SectionID;
 
     fn id(&self) -> SectionID {
-        self.id
+        self.id.clone()
     }
     fn name(&self) -> &str {
         &self.name
@@ -190,7 +190,7 @@ impl FuzzSelect for Label {
     type ID = LabelID;
 
     fn id(&self) -> LabelID {
-        self.id
+        self.id.clone()
     }
     fn name(&self) -> &str {
         &self.name
@@ -201,7 +201,7 @@ impl FuzzSelect for Task {
     type ID = TaskID;
 
     fn id(&self) -> TaskID {
-        self.id
+        self.id.clone()
     }
     fn name(&self) -> &str {
         &self.content
@@ -270,17 +270,17 @@ pub fn input_project(
 ) -> Result<Option<(ProjectID, Option<SectionID>)>> {
     match select("Select Project", projects)? {
         Some(p) => Ok(Some((
-            projects[p].id,
-            input_section(projects[p].id, sections)?,
+            projects[p].id.clone(),
+            input_section(&projects[p].id, sections)?,
         ))),
         None => Ok(None),
     }
 }
 
-pub fn input_section(project: ProjectID, sections: &[Section]) -> Result<Option<SectionID>> {
+pub fn input_section(project: &ProjectID, sections: &[Section]) -> Result<Option<SectionID>> {
     let sections: Vec<_> = sections
         .iter()
-        .filter(|s| s.project_id == project)
+        .filter(|s| s.project_id == *project)
         .collect();
     if sections.is_empty() {
         return Ok(None);
@@ -290,7 +290,7 @@ pub fn input_section(project: ProjectID, sections: &[Section]) -> Result<Option<
         .collect::<Vec<_>>();
     match select("Select Section", &section_names)? {
         Some(0) => Ok(None),
-        Some(s) => Ok(Some(sections[s - 1].id)),
+        Some(s) => Ok(Some(sections[s - 1].id.clone())),
         None => Ok(None),
     }
 }
diff --git a/src/labels/delete.rs b/src/labels/delete.rs
index 1cfe6f1..605b806 100644
--- a/src/labels/delete.rs
+++ b/src/labels/delete.rs
@@ -17,7 +17,7 @@ pub async fn delete(params: Params, gw: &Gateway) -> Result<()> {
         return Err(eyre!("no labels selected"));
     }
     for label in labels {
-        gw.delete_label(label.id).await?;
+        gw.delete_label(&label.id).await?;
         println!("deleted label: {}", &label);
     }
     Ok(())
diff --git a/src/labels/label.rs b/src/labels/label.rs
index a9c486c..f8a7637 100644
--- a/src/labels/label.rs
+++ b/src/labels/label.rs
@@ -33,7 +33,7 @@ impl LabelSelect {
         let label_ids = self.label_ids.clone().unwrap_or_default();
         let mut all_labels = labels
             .iter()
-            .map(|l| (l.id, l.to_owned()))
+            .map(|l| (l.id.clone(), l.to_owned()))
             .collect::<HashMap<_, _>>();
         let label_list = all_labels
             .values()
diff --git a/src/projects/comment.rs b/src/projects/comment.rs
index a021712..e01ff88 100644
--- a/src/projects/comment.rs
+++ b/src/projects/comment.rs
@@ -20,7 +20,7 @@ pub async fn comment(params: Params, gw: &Gateway) -> Result<()> {
     let comment = gw
         .create_comment(&CreateComment {
             thread: ThreadID::Project {
-                project_id: project.id,
+                project_id: project.id.clone(),
             },
             content: params.content,
         })
diff --git a/src/projects/delete.rs b/src/projects/delete.rs
index 366a129..71c4e6d 100644
--- a/src/projects/delete.rs
+++ b/src/projects/delete.rs
@@ -13,7 +13,7 @@ pub struct Params {
 pub async fn delete(params: Params, gw: &Gateway) -> Result<()> {
     let projects = gw.projects().await?;
     let project = params.project.mandatory(&projects)?;
-    gw.delete_project(project.id).await?;
+    gw.delete_project(&project.id).await?;
     println!("deleted project: {}", &project);
     Ok(())
 }
diff --git a/src/projects/list.rs b/src/projects/list.rs
index 1df3285..cf0be28 100644
--- a/src/projects/list.rs
+++ b/src/projects/list.rs
@@ -35,7 +35,7 @@ fn filtered_projects<'a>(
     tasks: &'_ [Task],
 ) -> Result<Vec<(&'a Project, usize)>> {
     let hm = tasks.iter().fold(HashMap::<_, usize>::new(), |mut hm, t| {
-        *hm.entry(t.project_id).or_default() += 1;
+        *hm.entry(&t.project_id).or_default() += 1;
         hm
     });
     let projects = projects
@@ -48,31 +48,31 @@ fn filtered_projects<'a>(
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::api::rest::{Project, ProjectID, Task, TaskID};
+    use crate::api::rest::{Project, Task};
 
     #[tokio::test]
     async fn filter_projects() {
         let ps = vec![
-            Project::new(1, "one"),
-            Project::new(2, "two"),
-            Project::new(3, "three"),
+            Project::new("1", "one"),
+            Project::new("2", "two"),
+            Project::new("3", "three"),
         ];
         let ts = vec![
-            create_task(1, 1, "one"),
-            create_task(2, 1, "two"),
-            create_task(3, 2, "three"),
+            create_task("1", "1", "one"),
+            create_task("2", "1", "two"),
+            create_task("3", "2", "three"),
         ];
         let projects = filtered_projects(&ps, &ts).unwrap();
         assert_eq!(projects.len(), 2);
-        assert_eq!(projects[0].0.id, 1);
+        assert_eq!(projects[0].0.id, "1");
         assert_eq!(projects[0].1, 2);
-        assert_eq!(projects[1].0.id, 2);
+        assert_eq!(projects[1].0.id, "2");
         assert_eq!(projects[1].1, 1);
     }
 
-    fn create_task(id: TaskID, project_id: ProjectID, content: &str) -> Task {
+    fn create_task(id: &str, project_id: &str, content: &str) -> Task {
         let mut task = crate::api::rest::Task::new(id, content);
-        task.project_id = project_id;
+        task.project_id = project_id.to_string();
         task
     }
 }
diff --git a/src/projects/state.rs b/src/projects/state.rs
index 9f809df..cf69ec0 100644
--- a/src/projects/state.rs
+++ b/src/projects/state.rs
@@ -21,7 +21,7 @@ impl State {
     pub async fn fetch_tree(gw: &Gateway) -> Result<State> {
         let (projects, sections) = tokio::try_join!(gw.projects(), gw.sections())?;
         let projects = Tree::from_items(projects).wrap_err("projects do not form a clean tree")?;
-        let sections = sections.into_iter().map(|s| (s.id, s)).collect();
+        let sections = sections.into_iter().map(|s| (s.id.clone(), s)).collect();
         Ok(State { projects, sections })
     }
 
@@ -37,15 +37,15 @@ impl State {
         Ok(result.map(|index| items[index]))
     }
 
-    pub fn project(&self, id: ProjectID) -> Option<&Tree<Project>> {
+    pub fn project(&self, id: &ProjectID) -> Option<&Tree<Project>> {
         self.projects.find(id)
     }
 
-    pub fn sections(&self, id: ProjectID) -> Vec<&Section> {
+    pub fn sections(&self, id: &ProjectID) -> Vec<&Section> {
         self.sections
             .iter()
             .filter_map(|s| {
-                if s.1.project_id == id {
+                if s.1.project_id == *id {
                     Some(s.1)
                 } else {
                     None
diff --git a/src/projects/view.rs b/src/projects/view.rs
index 770aca1..53882bb 100644
--- a/src/projects/view.rs
+++ b/src/projects/view.rs
@@ -17,7 +17,7 @@ pub async fn view(params: Params, gw: &Gateway) -> Result<()> {
     // TODO: no refetch here
     let state = State::fetch_tree(gw).await?;
     let tree = state
-        .project(project.id)
+        .project(&project.id)
         .ok_or_else(|| eyre!("full project list contained invalid data"))?;
     println!("Project: {}", &tree.item);
     if !tree.subitems.is_empty() {
@@ -26,7 +26,7 @@ pub async fn view(params: Params, gw: &Gateway) -> Result<()> {
             println!("{}", project.item)
         }
     }
-    let sections = state.sections(project.id);
+    let sections = state.sections(&project.id);
     if !sections.is_empty() {
         println!("Sections:");
         for section in sections {
@@ -34,7 +34,7 @@ pub async fn view(params: Params, gw: &Gateway) -> Result<()> {
         }
     }
     if project.comment_count > 0 {
-        let comments = gw.project_comments(project.id).await?;
+        let comments = gw.project_comments(&project.id).await?;
         comments::list(&comments)
     }
     Ok(())
diff --git a/src/sections/add.rs b/src/sections/add.rs
index 3460edd..875c51f 100644
--- a/src/sections/add.rs
+++ b/src/sections/add.rs
@@ -18,7 +18,7 @@ pub async fn add(params: Params, gw: &Gateway) -> Result<()> {
     let section = gw
         .create_section(&CreateSection {
             name: params.name,
-            project_id: project.id,
+            project_id: project.id.clone(),
             ..Default::default()
         })
         .await?;
diff --git a/src/sections/delete.rs b/src/sections/delete.rs
index 46036a3..f2fd09b 100644
--- a/src/sections/delete.rs
+++ b/src/sections/delete.rs
@@ -14,7 +14,7 @@ pub struct Params {
 pub async fn delete(params: Params, gw: &Gateway) -> Result<()> {
     let sections = gw.sections().await?;
     let section = params.section.mandatory(&sections)?;
-    gw.delete_section(section.id).await?;
+    gw.delete_section(&section.id).await?;
     println!("deleted section: {}", &section);
     Ok(())
 }
diff --git a/src/tasks/add.rs b/src/tasks/add.rs
index c3f2a5c..73ac981 100644
--- a/src/tasks/add.rs
+++ b/src/tasks/add.rs
@@ -47,9 +47,9 @@ pub async fn add(params: Params, gw: &Gateway, cfg: &Config) -> Result<()> {
         content: params.name,
         description: params.desc,
         priority: params.priority.map(|p| p.into()),
-        project_id: project.map(|p| p.id),
-        section_id: section.map(|s| s.id),
-        label_ids: labels.iter().map(|l| l.id).collect(),
+        project_id: project.map(|p| p.id.clone()),
+        section_id: section.map(|s| s.id.clone()),
+        label_ids: labels.iter().map(|l| l.id.clone()).collect(),
         ..Default::default()
     };
     if let Some(due) = params.due {
@@ -60,7 +60,7 @@ pub async fn add(params: Params, gw: &Gateway, cfg: &Config) -> Result<()> {
             .labels()
             .await?
             .into_iter()
-            .map(|label| (label.id, label))
+            .map(|label| (label.id.clone(), label))
             .collect();
         create
             .label_ids
diff --git a/src/tasks/close.rs b/src/tasks/close.rs
index 7fcb17a..3901baa 100644
--- a/src/tasks/close.rs
+++ b/src/tasks/close.rs
@@ -26,12 +26,12 @@ pub async fn close(params: Params, gw: &Gateway, cfg: &Config) -> Result<()> {
         .await
         .wrap_err("no task selected for closing")?;
     if params.complete {
-        return complete(id, gw).await;
+        return complete(&id, gw).await;
     }
-    gw.close(id).await?;
-    println!("closed task {}", id.bright_red());
-    let task = gw.task(id).await?;
-    if !task.completed {
+    gw.close(&id).await?;
+    println!("closed task {}", id.clone().bright_red());
+    let task = gw.task(&id).await?;
+    if !task.is_completed {
         if let Some(due) = task.due {
             if let Some(exact) = due.exact {
                 println!("next due date: {}", exact.datetime);
@@ -43,7 +43,7 @@ pub async fn close(params: Params, gw: &Gateway, cfg: &Config) -> Result<()> {
     Ok(())
 }
 
-pub async fn complete(id: api::rest::TaskID, gw: &Gateway) -> Result<()> {
+pub async fn complete(id: &api::rest::TaskID, gw: &Gateway) -> Result<()> {
     gw.complete(id).await?;
     println!(
         "completed task {}",
diff --git a/src/tasks/edit.rs b/src/tasks/edit.rs
index f75ded9..3144cf0 100644
--- a/src/tasks/edit.rs
+++ b/src/tasks/edit.rs
@@ -63,6 +63,6 @@ pub async fn edit(params: Params, gw: &Gateway, cfg: &Config) -> Result<()> {
     if let Some(due) = params.due {
         update.due = Some(TaskDue::String(due))
     }
-    gw.update(params.task.task_id(gw, cfg).await?, &update)
+    gw.update(&params.task.task_id(gw, cfg).await?, &update)
         .await
 }
diff --git a/src/tasks/filter.rs b/src/tasks/filter.rs
index cc56706..4f74e7d 100644
--- a/src/tasks/filter.rs
+++ b/src/tasks/filter.rs
@@ -47,11 +47,11 @@ impl TaskOrInteractive {
         cfg: &'a Config,
     ) -> Result<(TaskID, State<'a>)> {
         let state = State::fetch_tree(Some(&self.filter.filter), gw, cfg).await?;
-        let id = match self.id {
-            Some(id) => id,
+        let id = match &self.id {
+            Some(id) => id.clone(),
             None => state
                 .select_task()?
-                .map(|t| t.id)
+                .map(|t| t.id.clone())
                 .ok_or_else(|| eyre!("no task selected"))?,
         };
         Ok((id, state))
diff --git a/src/tasks/list.rs b/src/tasks/list.rs
index de92453..f94b4dc 100644
--- a/src/tasks/list.rs
+++ b/src/tasks/list.rs
@@ -171,23 +171,25 @@ async fn filter_list<'a>(state: State<'a>, params: &'_ Params) -> Result<State<'
         .labels(&labels, labels::Selection::AllowEmpty)?;
     let mut state = state;
     if let Some(p) = project {
-        state = state.filter(|tree| tree.project_id == p.id);
+        state = state.filter(|tree| tree.project_id == *p.id);
     }
     if let Some(s) = section {
-        state = state.filter(|tree| tree.section_id == Some(s.id));
+        state = state.filter(|tree| tree.section_id.as_ref() == Some(&s.id));
     }
     if !labels.is_empty() {
         state = state.filter(|tree| {
             labels
                 .iter()
-                .map(|l| l.id)
-                .any(|l| tree.label_ids.contains(&l))
+                .map(|l| l.id.clone())
+                .any(|l| tree.labels.contains(&l))
         });
     }
     Ok(state)
 }
 
 fn list_tasks<'a>(tasks: &'a [Tree<Task>], state: &'a State) {
+    let mut tasks = tasks.to_vec();
+    tasks.sort();
     for task in tasks.iter() {
         println!("{}", state.table_task(task));
         list_tasks(&task.subitems, state);
@@ -219,7 +221,7 @@ async fn select_task_option<'a, 'b>(
         TaskOptions::Close => {
             close::close(
                 close::Params {
-                    task: task.id.into(),
+                    task: task.id.clone().into(),
                     complete: false,
                 },
                 gw,
@@ -230,7 +232,7 @@ async fn select_task_option<'a, 'b>(
         TaskOptions::Complete => {
             close::close(
                 close::Params {
-                    task: task.id.into(),
+                    task: task.id.clone().into(),
                     complete: true,
                 },
                 gw,
@@ -274,7 +276,7 @@ async fn edit_task(task: &Tree<Task>, gw: &Gateway, cfg: &Config) -> Result<()>
                 .interact()
                 .wrap_err("Bad user input")?
                 + 1;
-            let mut params = edit::Params::new(task.id);
+            let mut params = edit::Params::new(task.id.clone());
             params.priority = Some(selection.try_into()?);
             edit::edit(params, gw, cfg).await?;
         }
@@ -283,7 +285,7 @@ async fn edit_task(task: &Tree<Task>, gw: &Gateway, cfg: &Config) -> Result<()>
                 .with_prompt("New value")
                 .interact_text()
                 .wrap_err("Bad user input")?;
-            let mut params = edit::Params::new(task.id);
+            let mut params = edit::Params::new(task.id.clone());
             match result {
                 EditOptions::Name => {
                     params.name = Some(text);
diff --git a/src/tasks/state.rs b/src/tasks/state.rs
index 7674a22..1797e39 100644
--- a/src/tasks/state.rs
+++ b/src/tasks/state.rs
@@ -6,8 +6,8 @@ use owo_colors::OwoColorize;
 use crate::{
     api::{
         rest::{
-            FullTask, Gateway, Label, LabelID, Project, ProjectID, Section, SectionID, TableTask,
-            Task, TaskID,
+            FullTask, Gateway, Label, Project, ProjectID, Section, SectionID, TableTask, Task,
+            TaskID,
         },
         tree::{Tree, TreeFlattenExt},
     },
@@ -20,7 +20,7 @@ pub struct State<'a> {
     pub tasks: Vec<Tree<Task>>,
     pub projects: HashMap<ProjectID, Project>,
     pub sections: HashMap<SectionID, Section>,
-    pub labels: HashMap<LabelID, Label>,
+    pub labels: HashMap<String, Label>,
     pub config: &'a Config,
 }
 
@@ -39,9 +39,10 @@ impl<'a> State<'a> {
     ) -> Result<State<'a>> {
         let (filtered_tasks, projects, sections, labels) =
             tokio::try_join!(gw.tasks(filter), gw.projects(), gw.sections(), gw.labels())?;
-        let projects = projects.into_iter().map(|p| (p.id, p)).collect();
-        let sections = sections.into_iter().map(|p| (p.id, p)).collect();
-        let labels = labels.into_iter().map(|p| (p.id, p)).collect();
+        let projects = projects.into_iter().map(|p| (p.id.clone(), p)).collect();
+        let sections = sections.into_iter().map(|s| (s.id.clone(), s)).collect();
+        // We save by name so it works with the shared labels concept of todoist
+        let labels = labels.into_iter().map(|l| (l.name.clone(), l)).collect();
         let tasks = Tree::from_items(filtered_tasks).wrap_err("tasks do not form clean tree")?;
         Ok(State {
             tasks,
@@ -60,11 +61,11 @@ impl<'a> State<'a> {
             tokio::try_join!(Self::fetch_tree(Some("all"), gw, cfg), gw.tasks(filter))?;
         full_state.tasks = full_state
             .tasks
-            .keep_trees(&tasks.iter().map(|t| t.id).collect::<Vec<_>>());
+            .keep_trees(&tasks.iter().map(|t| t.id.clone()).collect::<Vec<_>>());
         Ok(full_state)
     }
 
-    pub fn task(&self, id: TaskID) -> Option<&Tree<Task>> {
+    pub fn task(&self, id: &TaskID) -> Option<&Tree<Task>> {
         self.tasks.find(id)
     }
 
@@ -121,9 +122,9 @@ impl<'a> State<'a> {
     }
 
     fn labels<'s>(&'s self, task: &'s Tree<Task>) -> Vec<&'s Label> {
-        task.label_ids
+        task.labels
             .iter()
-            .map(|l| self.labels.get(l).unwrap())
+            .filter_map(|l| self.labels.get(l))
             .collect()
     }
 
diff --git a/src/tasks/view.rs b/src/tasks/view.rs
index 74b6315..aff5e5d 100644
--- a/src/tasks/view.rs
+++ b/src/tasks/view.rs
@@ -13,10 +13,10 @@ pub struct Params {
 /// Displays full information about a task.
 pub async fn view(params: Params, gw: &Gateway, cfg: &Config) -> Result<()> {
     let (id, state) = params.task.task(gw, cfg).await?;
-    let task = state.full_task(state.task(id).ok_or_else(|| eyre!("no valid task"))?);
+    let task = state.full_task(state.task(&id).ok_or_else(|| eyre!("no valid task"))?);
     println!("{}", task);
     if task.0.comment_count > 0 {
-        let comments = gw.task_comments(id).await?;
+        let comments = gw.task_comments(&id).await?;
         comments::list(&comments)
     }
     Ok(())
diff --git a/tests/commands/fixtures/labels.json b/tests/commands/fixtures/labels.json
index e0dee59..cbc3342 100644
--- a/tests/commands/fixtures/labels.json
+++ b/tests/commands/fixtures/labels.json
@@ -1,16 +1,16 @@
 [
 	{
-		"id": 1999991,
+		"id": "1999991",
 		"name": "one",
 		"order": 1,
-		"color": 41,
-		"favorite": false
+		"color": "blue",
+		"is_favorite": false
 	},
 	{
-		"id": 1999992,
+		"id": "1999992",
 		"name": "two",
 		"order": 2,
-		"color": 47,
-		"favorite": false
+		"color": "blue",
+		"is_favorite": false
 	}
 ]
diff --git a/tests/commands/fixtures/projects.json b/tests/commands/fixtures/projects.json
index 7719da4..d8b164d 100644
--- a/tests/commands/fixtures/projects.json
+++ b/tests/commands/fixtures/projects.json
@@ -1,72 +1,82 @@
 [
 	{
-		"id": 1000001,
-		"color": 48,
+		"id": "1000001",
+		"color": "berry_red",
 		"name": "Inbox",
+		"order": 0,
 		"comment_count": 0,
-		"shared": false,
-		"favorite": false,
-		"sync_id": 0,
-		"inbox_project": true,
-		"url": "https://todoist.com/showProject?id=1000001"
+		"is_shared": false,
+		"is_favorite": false,
+		"is_inbox_project": true,
+		"is_team_inbox": false,
+		"url": "https://todoist.com/showProject?id=1000001",
+		"view_style": "list"
 	},
 	{
-		"id": 1000002,
+		"id": "1000002",
 		"order": 2,
-		"color": 41,
+		"color": "berry_red",
 		"name": "Project One",
 		"comment_count": 0,
-		"shared": false,
-		"favorite": true,
-		"sync_id": 0,
-		"url": "https://todoist.com/showProject?id=1000002"
+		"is_shared": false,
+		"is_favorite": true,
+		"is_inbox_project": false,
+		"is_team_inbox": false,
+		"url": "https://todoist.com/showProject?id=1000002",
+		"view_style": "list"
 	},
 	{
-		"id": 1000003,
-		"parent": 1000002,
-		"parent_id": 1000002,
+		"id": "1000003",
+		"parent_id": "1000002",
 		"order": 0,
-		"color": 36,
+		"color": "berry_red",
 		"name": "Project Two",
 		"comment_count": 0,
-		"shared": false,
-		"favorite": false,
-		"sync_id": 0,
-		"url": "https://todoist.com/showProject?id=1000003"
+		"is_shared": false,
+		"is_favorite": false,
+		"is_inbox_project": false,
+		"is_team_inbox": false,
+		"url": "https://todoist.com/showProject?id=1000003",
+		"view_style": "list"
 	},
 	{
-		"id": 1000004,
-		"parent": 1000002,
-		"parent_id": 1000002,
+		"id": "1000004",
+		"parent_id": "1000002",
 		"order": 1,
-		"color": 31,
+		"color": "berry_red",
 		"name": "Project Three",
 		"comment_count": 2,
-		"shared": false,
-		"favorite": false,
-		"sync_id": 0,
-		"url": "https://todoist.com/showProject?id=1000004"
+		"is_shared": false,
+		"is_favorite": false,
+		"is_inbox_project": false,
+		"is_team_inbox": false,
+		"url": "https://todoist.com/showProject?id=1000004",
+		"view_style": "list"
 	},
 	{
-		"id": 1000005,
+		"id": "1000005",
 		"order": 3,
-		"color": 48,
+		"color": "berry_red",
 		"name": "Project Four",
 		"comment_count": 0,
-		"shared": false,
-		"favorite": false,
-		"sync_id": 0,
-		"url": "https://todoist.com/showProject?id=1000005"
+		"is_shared": false,
+		"is_favorite": false,
+		"is_inbox_project": false,
+		"is_team_inbox": false,
+		"url": "https://todoist.com/showProject?id=1000005",
+		"view_style": "list"
 	},
 	{
-		"id": 1000006,
+		"id": "1000006",
 		"order": 4,
-		"color": 30,
+		"color": "berry_red",
 		"name": "Project Five",
 		"comment_count": 0,
-		"shared": false,
-		"favorite": false,
-		"sync_id": 0,
-		"url": "https://todoist.com/showProject?id=1000006"
+		"is_shared": false,
+		"is_favorite": false,
+		"is_inbox_project": false,
+		"is_team_inbox": false,
+		"url": "https://todoist.com/showProject?id=1000006",
+		"view_style": "list"
 	}
 ]
diff --git a/tests/commands/fixtures/sections.json b/tests/commands/fixtures/sections.json
index 5221325..c61ceda 100644
--- a/tests/commands/fixtures/sections.json
+++ b/tests/commands/fixtures/sections.json
@@ -1,49 +1,49 @@
 [
 	{
-		"id": 1100001,
-		"project_id": 1000005,
+		"id": "1100001",
+		"project_id": "1000005",
 		"order": 1,
 		"name": "Section One"
 	},
 	{
-		"id": 1100002,
-		"project_id": 1000005,
+		"id": "1100002",
+		"project_id": "1000005",
 		"order": 2,
 		"name": "Section Two"
 	},
 	{
-		"id": 1100003,
-		"project_id": 1000002,
+		"id": "1100003",
+		"project_id": "1000002",
 		"order": 1,
 		"name": "Section Three"
 	},
 	{
-		"id": 1100004,
-		"project_id": 1000004,
+		"id": "1100004",
+		"project_id": "1000004",
 		"order": 1,
 		"name": "Section Four"
 	},
 	{
-		"id": 1100005,
-		"project_id": 1000004,
+		"id": "1100005",
+		"project_id": "1000004",
 		"order": 2,
 		"name": "Section Five"
 	},
 	{
-		"id": 1100006,
-		"project_id": 1000003,
+		"id": "1100006",
+		"project_id": "1000003",
 		"order": 1,
 		"name": "Section Six"
 	},
 	{
-		"id": 1100007,
-		"project_id": 1000003,
+		"id": "1100007",
+		"project_id": "1000003",
 		"order": 2,
 		"name": "Section Seven"
 	},
 	{
-		"id": 1100008,
-		"project_id": 1000003,
+		"id": "1100008",
+		"project_id": "1000003",
 		"order": 3,
 		"name": "Section Eight"
 	}
diff --git a/tests/commands/fixtures/tasks.json b/tests/commands/fixtures/tasks.json
index 1bc20c6..2dde492 100644
--- a/tests/commands/fixtures/tasks.json
+++ b/tests/commands/fixtures/tasks.json
@@ -1,66 +1,62 @@
 [
 	{
-		"id": 7000001,
+		"id": "7000001",
 		"assigner": 0,
-		"project_id": 1000002,
-		"section_id": 1100003,
+		"project_id": "1000002",
+		"section_id": "1100003",
 		"order": 2,
 		"content": "Bla bla",
 		"description": "",
-		"completed": false,
-		"label_ids": [
-			1999992
-		],
+		"is_completed": false,
+		"labels": ["two"],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-04-28T03:09:47Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-04-28T03:09:47Z",
 		"due": {
-			"recurring": true,
+			"is_recurring": true,
 			"string": "every day",
 			"date": "2022-08-24"
 		},
 		"url": "https://todoist.com/showTask?id=7000001"
 	},
 	{
-		"id": 7000002,
+		"id": "7000002",
 		"assigner": 0,
-		"project_id": 1000002,
-		"section_id": 1100003,
+		"project_id": "1000002",
+		"section_id": "1100003",
 		"order": 1,
 		"content": "Test",
 		"description": "Testing",
-		"completed": false,
-		"label_ids": [
-			1999992
-		],
+		"is_completed": false,
+		"labels": ["two"],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-04-28T03:10:28Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-04-28T03:10:28Z",
 		"due": {
-			"recurring": true,
+			"is_recurring": true,
 			"string": "every day",
 			"date": "2022-08-26"
 		},
 		"url": "https://todoist.com/showTask?id=7000002"
 	},
 	{
-		"id": 7000003,
+		"id": "7000003",
 		"assigner": 0,
-		"project_id": 1000002,
-		"section_id": 0,
+		"project_id": "1000002",
+		"section_id": null,
 		"order": 3,
 		"content": "Woah",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-04-28T03:11:20Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-04-28T03:11:20Z",
 		"due": {
-			"recurring": true,
+			"is_recurring": true,
 			"string": "every thursday 8am",
 			"date": "2022-09-15",
 			"datetime": "2022-09-15T05:00:00Z",
@@ -69,21 +65,21 @@
 		"url": "https://todoist.com/showTask?id=7000003"
 	},
 	{
-		"id": 7000004,
+		"id": "7000004",
 		"assigner": 0,
-		"project_id": 1000002,
-		"section_id": 0,
+		"project_id": "1000002",
+		"section_id": null,
 		"order": 4,
 		"content": "Unheard of",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 2,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-04-28T03:11:43Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-04-28T03:11:43Z",
 		"due": {
-			"recurring": true,
+			"is_recurring": true,
 			"string": "every day 8am",
 			"date": "2022-08-27",
 			"datetime": "2022-08-27T05:00:00Z",
@@ -92,87 +88,86 @@
 		"url": "https://todoist.com/showTask?id=7000004"
 	},
 	{
-		"id": 7000005,
+		"id": "7000005",
 		"assigner": 0,
-		"project_id": 1000004,
-		"section_id": 1100005,
+		"project_id": "1000004",
+		"section_id": "1100005",
 		"order": -2,
 		"content": "Impossible",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-04-28T03:20:53Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-04-28T03:20:53Z",
 		"url": "https://todoist.com/showTask?id=7000005"
 	},
 	{
-		"id": 7000006,
+		"id": "7000006",
 		"assigner": 0,
-		"project_id": 1000004,
-		"section_id": 1100005,
+		"project_id": "1000004",
+		"section_id": "1100005",
 		"order": 0,
 		"content": "Darn",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-04-28T03:21:11Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-04-28T03:21:11Z",
 		"url": "https://todoist.com/showTask?id=7000006"
 	},
 	{
-		"id": 7000007,
+		"id": "7000007",
 		"assigner": 0,
-		"project_id": 1000004,
-		"section_id": 1100005,
+		"project_id": "1000004",
+		"section_id": "1100005",
 		"order": 1,
 		"content": "Sweet",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-04-28T03:21:44Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-04-28T03:21:44Z",
 		"url": "https://todoist.com/showTask?id=7000007"
 	},
 	{
-		"id": 7000008,
+		"id": "7000008",
 		"assigner": 0,
-		"project_id": 1000004,
-		"section_id": 1100005,
-		"parent": 7000005,
-		"parent_id": 7000005,
+		"project_id": "1000004",
+		"section_id": "1100005",
+		"parent_id": "7000005",
 		"order": 1,
 		"content": "Nope",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-04-28T04:57:17Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-04-28T04:57:17Z",
 		"url": "https://todoist.com/showTask?id=7000008"
 	},
 	{
-		"id": 7000009,
+		"id": "7000009",
 		"assigner": 0,
-		"project_id": 1000005,
-		"section_id": 0,
+		"project_id": "1000005",
+		"section_id": null,
 		"order": 8,
 		"content": "Yay",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-04-28T22:32:39Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-04-28T22:32:39Z",
 		"due": {
-			"recurring": true,
+			"is_recurring": true,
 			"string": "every thursday 7pm",
 			"date": "2022-09-15",
 			"datetime": "2022-09-15T16:00:00Z",
@@ -181,123 +176,121 @@
 		"url": "https://todoist.com/showTask?id=7000009"
 	},
 	{
-		"id": 7000010,
+		"id": "7000010",
 		"assigner": 0,
-		"project_id": 1000002,
-		"section_id": 0,
+		"project_id": "1000002",
+		"section_id": null,
 		"order": 10,
 		"content": "Big crash",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-05-02T03:13:07Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-05-02T03:13:07Z",
 		"due": {
-			"recurring": true,
+			"is_recurring": true,
 			"string": "every other day",
 			"date": "2022-08-26"
 		},
 		"url": "https://todoist.com/showTask?id=7000010"
 	},
 	{
-		"id": 7000011,
+		"id": "7000011",
 		"assigner": 0,
-		"project_id": 1000006,
-		"section_id": 0,
+		"project_id": "1000006",
+		"section_id": null,
 		"order": 5,
 		"content": "Wooden board",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-05-05T03:41:12Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-05-05T03:41:12Z",
 		"due": {
-			"recurring": true,
+			"is_recurring": true,
 			"string": "every month",
 			"date": "2022-09-04"
 		},
 		"url": "https://todoist.com/showTask?id=7000011"
 	},
 	{
-		"id": 7000012,
+		"id": "7000012",
 		"assigner": 0,
-		"project_id": 1000002,
-		"section_id": 0,
+		"project_id": "1000002",
+		"section_id": null,
 		"order": 11,
 		"content": "Do the thing",
 		"description": "when the thing",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-05-06T20:54:06Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-05-06T20:54:06Z",
 		"url": "https://todoist.com/showTask?id=7000012"
 	},
 	{
-		"id": 7000013,
+		"id": "7000013",
 		"assigner": 0,
-		"project_id": 1000002,
-		"section_id": 0,
+		"project_id": "1000002",
+		"section_id": null,
 		"order": 12,
 		"content": "Check it yo",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-05-07T03:26:07Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-05-07T03:26:07Z",
 		"due": {
-			"recurring": true,
+			"is_recurring": true,
 			"string": "every day",
 			"date": "2022-09-13"
 		},
 		"url": "https://todoist.com/showTask?id=7000013"
 	},
 	{
-		"id": 7000014,
+		"id": "7000014",
 		"assigner": 0,
-		"project_id": 1000002,
-		"section_id": 0,
+		"project_id": "1000002",
+		"section_id": null,
 		"order": 13,
 		"content": "Switch it up",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-05-10T07:31:12Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-05-10T07:31:12Z",
 		"due": {
-			"recurring": true,
+			"is_recurring": true,
 			"string": "every 2 weeks",
 			"date": "2022-08-29"
 		},
 		"url": "https://todoist.com/showTask?id=7000014"
 	},
 	{
-		"id": 7000015,
+		"id": "7000015",
 		"assigner": 0,
-		"project_id": 1000002,
-		"section_id": 0,
+		"project_id": "1000002",
+		"section_id": null,
 		"order": 14,
 		"content": "Shake it",
 		"description": "",
-		"completed": false,
-		"label_ids": [
-			1999992
-		],
+		"is_completed": false,
+		"labels": ["two"],
 		"priority": 2,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-05-11T02:20:44Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-05-11T02:20:44Z",
 		"due": {
-			"recurring": true,
+			"is_recurring": true,
 			"string": "every day 22:00",
 			"date": "2022-08-27",
 			"datetime": "2022-08-27T19:00:00Z",
@@ -306,254 +299,252 @@
 		"url": "https://todoist.com/showTask?id=7000015"
 	},
 	{
-		"id": 7000016,
+		"id": "7000016",
 		"assigner": 0,
-		"project_id": 1000005,
-		"section_id": 1100001,
+		"project_id": "1000005",
+		"section_id": "1100001",
 		"order": 1,
 		"content": "Get some data",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-05-16T22:42:27Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-05-16T22:42:27Z",
 		"due": {
-			"recurring": false,
+			"is_recurring": false,
 			"string": "20 Sep",
 			"date": "2022-09-20"
 		},
 		"url": "https://todoist.com/showTask?id=7000016"
 	},
 	{
-		"id": 7000017,
+		"id": "7000017",
 		"assigner": 0,
-		"project_id": 1000002,
-		"section_id": 0,
+		"project_id": "1000002",
+		"section_id": null,
 		"order": 15,
 		"content": "Write it down",
 		"description": "",
-		"completed": false,
-		"label_ids": [
-			1999992
-		],
+		"is_completed": false,
+		"labels": ["two"],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-05-27T04:27:47Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-05-27T04:27:47Z",
 		"due": {
-			"recurring": true,
+			"is_recurring": true,
 			"string": "every day",
 			"date": "2022-08-27"
 		},
 		"url": "https://todoist.com/showTask?id=7000017"
 	},
 	{
-		"id": 7000018,
+		"id": "7000018",
 		"assigner": 0,
-		"project_id": 1000002,
-		"section_id": 0,
+		"project_id": "1000002",
+		"section_id": null,
 		"order": 17,
 		"content": "Garfield",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-06-28T20:09:49Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-06-28T20:09:49Z",
 		"due": {
-			"recurring": false,
+			"is_recurring": false,
 			"string": "Oct 3",
 			"date": "2022-10-03"
 		},
 		"url": "https://todoist.com/showTask?id=7000018"
 	},
 	{
-		"id": 7000019,
+		"id": "7000019",
 		"assigner": 0,
-		"project_id": 1000002,
-		"section_id": 0,
+		"project_id": "1000002",
+		"section_id": null,
 		"order": 18,
 		"content": "get video game",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-06-29T19:18:04Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-06-29T19:18:04Z",
 		"due": {
-			"recurring": false,
+			"is_recurring": false,
 			"string": "Sep 27",
 			"date": "2022-09-27"
 		},
 		"url": "https://todoist.com/showTask?id=7000019"
 	},
 	{
-		"id": 7000020,
+		"id": "7000020",
 		"assigner": 0,
-		"project_id": 1000002,
-		"section_id": 0,
+		"project_id": "1000002",
+		"section_id": null,
 		"order": 21,
 		"content": "Pause sub",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-07-01T03:00:44Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-07-01T03:00:44Z",
 		"due": {
-			"recurring": false,
+			"is_recurring": false,
 			"string": "Oct 1",
 			"date": "2022-10-01"
 		},
 		"url": "https://todoist.com/showTask?id=7000020"
 	},
 	{
-		"id": 7000021,
+		"id": "7000021",
 		"assigner": 0,
-		"project_id": 1000001,
-		"section_id": 0,
+		"project_id": "1000001",
+		"section_id": null,
 		"order": 3,
 		"content": "Bits n bytes",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-07-12T22:45:03Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-07-12T22:45:03Z",
 		"due": {
-			"recurring": false,
+			"is_recurring": false,
 			"string": "1 Sep",
 			"date": "2022-09-01"
 		},
 		"url": "https://todoist.com/showTask?id=7000021"
 	},
 	{
-		"id": 7000022,
+		"id": "7000022",
 		"assigner": 0,
-		"project_id": 1000001,
-		"section_id": 0,
+		"project_id": "1000001",
+		"section_id": null,
 		"order": 16,
 		"content": "Check it out okay",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-07-19T18:22:20Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-07-19T18:22:20Z",
 		"due": {
-			"recurring": false,
+			"is_recurring": false,
 			"string": "20 Sep",
 			"date": "2022-09-20"
 		},
 		"url": "https://todoist.com/showTask?id=7000022"
 	},
 	{
-		"id": 7000023,
+		"id": "7000023",
 		"assigner": 0,
-		"project_id": 1000001,
-		"section_id": 0,
+		"project_id": "1000001",
+		"section_id": null,
 		"order": 47,
 		"content": "Coffee",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-08-07T05:51:56Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-08-07T05:51:56Z",
 		"due": {
-			"recurring": false,
+			"is_recurring": false,
 			"string": "15 Sep",
 			"date": "2022-09-15"
 		},
 		"url": "https://todoist.com/showTask?id=7000023"
 	},
 	{
-		"id": 7000024,
+		"id": "7000024",
 		"assigner": 0,
-		"project_id": 1000001,
-		"section_id": 0,
+		"project_id": "1000001",
+		"section_id": null,
 		"order": 55,
 		"content": "Second shot",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-08-17T23:18:16Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-08-17T23:18:16Z",
 		"due": {
-			"recurring": false,
+			"is_recurring": false,
 			"string": "Sep 17",
 			"date": "2022-09-17"
 		},
 		"url": "https://todoist.com/showTask?id=7000024"
 	},
 	{
-		"id": 7000025,
+		"id": "7000025",
 		"assigner": 0,
-		"project_id": 1000001,
-		"section_id": 0,
+		"project_id": "1000001",
+		"section_id": null,
 		"order": 62,
 		"content": "Sign it",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-08-22T23:24:29Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-08-22T23:24:29Z",
 		"due": {
-			"recurring": false,
+			"is_recurring": false,
 			"string": "14 Sep",
 			"date": "2022-09-14"
 		},
 		"url": "https://todoist.com/showTask?id=7000025"
 	},
 	{
-		"id": 7000026,
+		"id": "7000026",
 		"assigner": 0,
-		"project_id": 1000001,
-		"section_id": 0,
+		"project_id": "1000001",
+		"section_id": null,
 		"order": 64,
 		"content": "Check comments",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-08-23T04:54:02Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-08-23T04:54:02Z",
 		"due": {
-			"recurring": false,
+			"is_recurring": false,
 			"string": "13 Sep",
 			"date": "2022-09-13"
 		},
 		"url": "https://todoist.com/showTask?id=7000026"
 	},
 	{
-		"id": 7000027,
+		"id": "7000027",
 		"assigner": 0,
-		"project_id": 1000001,
-		"section_id": 0,
+		"project_id": "1000001",
+		"section_id": null,
 		"order": 65,
 		"content": "Open data",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-08-23T04:57:00Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-08-23T04:57:00Z",
 		"due": {
-			"recurring": false,
+			"is_recurring": false,
 			"string": "13 Sep",
 			"date": "2022-09-13"
 		},
diff --git a/tests/commands/fixtures/tasks_partial.json b/tests/commands/fixtures/tasks_partial.json
index 6bcdf5c..7ca358b 100644
--- a/tests/commands/fixtures/tasks_partial.json
+++ b/tests/commands/fixtures/tasks_partial.json
@@ -1,36 +1,37 @@
 [
 	{
-		"id": 7000008,
-		"assigner": 0,
-		"project_id": 1000004,
-		"section_id": 1100005,
-		"parent": 7000005,
-		"parent_id": 7000005,
-		"order": 1,
+		"id": "7000008",
+		"project_id": "1000004",
+		"section_id": "1100005",
 		"content": "Nope",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
+		"parent_id": "7000005",
+		"order": 1,
 		"priority": 1,
+		"due": null,
+		"url": "https://todoist.com/showTask?id=7000008",
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-04-28T04:57:17Z",
-		"url": "https://todoist.com/showTask?id=7000008"
+		"creator_id": "1111111111",
+		"assignee_id": "1111111111",
+		"assigner_id": "1111111111",
+		"created_at": "2022-04-28T04:57:17Z"
 	},
 	{
-		"id": 7000006,
-		"assigner": 0,
-		"project_id": 1000004,
-		"section_id": 1100005,
+		"id": "7000006",
+		"assigner_id": "1111111111",
+		"project_id": "1000004",
+		"section_id": "1100005",
 		"order": 0,
 		"content": "Darn",
 		"description": "",
-		"completed": false,
-		"label_ids": [],
+		"is_completed": false,
+		"labels": [],
 		"priority": 1,
 		"comment_count": 0,
-		"creator": 1111111111,
-		"created": "2022-04-28T03:21:11Z",
+		"creator_id": "1111111111",
+		"created_at": "2022-04-28T03:21:11Z",
 		"url": "https://todoist.com/showTask?id=7000006"
 	}
 ]
diff --git a/tests/commands/mocks.rs b/tests/commands/mocks.rs
index cb0e149..12512db 100644
--- a/tests/commands/mocks.rs
+++ b/tests/commands/mocks.rs
@@ -6,7 +6,7 @@ pub async fn mock_tasks(tool: &Tool, times: u64) {
     mock_http(
         tool,
         "GET",
-        "/rest/v1/tasks",
+        "/rest/v2/tasks",
         200,
         super::fixtures::TASKS,
         times,
@@ -18,7 +18,7 @@ pub async fn mock_tasks_partial(tool: &Tool, times: u64) {
     mock_http(
         tool,
         "GET",
-        "/rest/v1/tasks",
+        "/rest/v2/tasks",
         200,
         super::fixtures::TASKS_PARTIAL,
         times,
@@ -30,7 +30,7 @@ pub async fn mock_labels(tool: &Tool, times: u64) {
     mock_http(
         tool,
         "GET",
-        "/rest/v1/labels",
+        "/rest/v2/labels",
         200,
         super::fixtures::LABELS,
         times,
@@ -42,7 +42,7 @@ pub async fn mock_projects(tool: &Tool, times: u64) {
     mock_http(
         tool,
         "GET",
-        "/rest/v1/projects",
+        "/rest/v2/projects",
         200,
         super::fixtures::PROJECTS,
         times,
@@ -54,7 +54,7 @@ pub async fn mock_sections(tool: &Tool, times: u64) {
     mock_http(
         tool,
         "GET",
-        "/rest/v1/sections",
+        "/rest/v2/sections",
         200,
         super::fixtures::SECTIONS,
         times,