local_provider: Implement update_task

Currently, the tests fail due to a concurrency issue. This is not an
concern, because the concurrency system being used right now will be
switched to a better system to prevent these issues

2 files changed, 49 insertions, 5 deletions

diff --git a/src/engine/providers/local.rs b/src/engine/providers/local.rs
index ef86b587..22bbab07 100644
--- a/src/engine/providers/local.rs
+++ b/src/engine/providers/local.rs
@@ -51,7 +51,7 @@ mod imp {
     use gtk::gio::ThemedIcon;
 
     use super::*;
-    use crate::{schema, task::Task};
+    use crate::{schema, task::Task, utils::Iso8601};
 
     pub struct LocalProvider {
         pool: Lazy<Pool>,
@@ -85,11 +85,11 @@ mod imp {
 
     #[async_trait]
     impl ProviderImpl for LocalProvider {
-        async fn create_task(&self, title: &str) -> Task {
+        async fn create_task(&self, title: &str) -> anyhow::Result<Task> {
             let task = Task::default();
             task.set_title(title);
 
-            let mut connection = self.pool().get().expect("Could not access database");
+            let mut connection = self.pool().get().expect("Expected a Connection");
             let fields = vec![(
                 schema::tasks::dsl::id.eq(task.id()),
                 schema::tasks::dsl::title.eq(task.title()),
@@ -107,7 +107,34 @@ mod imp {
                 .execute(&mut connection)
                 .unwrap();
 
-            task
+            drop(connection);
+
+            Ok(task)
+        }
+
+        async fn update_task(&self, task: &Task) -> anyhow::Result<bool> {
+            let current_time = chrono::Utc::now().naive_utc().to_iso8601();
+            let mut connection = self.pool().get().expect("Expected a Connection");
+
+            task.set_last_modified(current_time);
+            task.set_modification_count(task.modification_count() + 1);
+
+            // TODO: Search for the properties that actually need to be updated
+            diesel::update(schema::tasks::dsl::tasks)
+                .filter(schema::tasks::dsl::id.eq(task.id()))
+                .set((
+                    schema::tasks::dsl::title.eq(task.title()),
+                    schema::tasks::dsl::description.eq(task.description()),
+                    schema::tasks::dsl::due_date.eq(task.due_date()),
+                    schema::tasks::dsl::completed.eq(task.completed()),
+                    schema::tasks::dsl::priority.eq(task.priority()),
+                    schema::tasks::dsl::last_modified.eq(task.last_modified()),
+                    schema::tasks::dsl::modification_count.eq(task.modification_count()),
+                ))
+                .execute(&mut connection)
+                .unwrap();
+
+            Ok(true)
         }
     }
 
@@ -131,6 +158,8 @@ impl Default for LocalProvider {
 
 #[cfg(test)]
 mod tests {
+    use std::{thread, time};
+
     use futures::executor::block_on;
 
     use super::*;
@@ -138,6 +167,18 @@ mod tests {
     #[test]
     fn test_save_task() {
         let provider = LocalProvider::default();
-        block_on(provider.imp().create_task("Test Task"));
+        block_on(provider.imp().create_task("Test Task")).unwrap();
+    }
+
+    #[test]
+    fn test_update_task() {
+        let provider = LocalProvider::default();
+        let task = block_on(provider.imp().create_task("Test Task")).unwrap();
+        task.set_description("Test Description");
+
+        thread::sleep(time::Duration::from_secs(5));
+
+        block_on(provider.imp().update_task(&task)).unwrap();
+        assert_eq!(task.modification_count(), 1);
     }
 }
diff --git a/src/engine/task.rs b/src/engine/task.rs
index e15a01c4..aa6adf1f 100644
--- a/src/engine/task.rs
+++ b/src/engine/task.rs
@@ -226,6 +226,9 @@ impl Queryable<schema::tasks::SqlType, Sqlite> for Task {
     }
 }
 
+unsafe impl Sync for Task {}
+unsafe impl Send for Task {}
+
 #[cfg(test)]
 mod tests {
     use super::Task;