X-Git-Url: http://git.euphorik.ch/?a=blobdiff_plain;f=backend%2Fsrc%2Fdata%2Fasynchronous.rs;h=7ef77b8c2bc853b199f2fa199f68e22bd532f84e;hb=adcf4a5a5d982489a7e91d4988401eb4512839a3;hp=4dda8037edf1b6d42fe7c6c68a5a1a46f35cfa79;hpb=d28e765e39e70ad2ab9a42885c786d5d8ba9ba40;p=recipes.git

diff --git a/backend/src/data/asynchronous.rs b/backend/src/data/asynchronous.rs
index 4dda803..7ef77b8 100644
--- a/backend/src/data/asynchronous.rs
+++ b/backend/src/data/asynchronous.rs
@@ -2,8 +2,8 @@
 
 use std::fmt;
 
+use actix_web::{error::BlockingError, web};
 use chrono::{prelude::*, Duration};
-use actix_web::{web, error::BlockingError};
 
 use super::db::*;
 use crate::model;
@@ -22,15 +22,15 @@ impl fmt::Display for DBAsyncError {
     }
 }
 
-impl std::error::Error for DBAsyncError { }
+impl std::error::Error for DBAsyncError {}
 
-impl From<DBError> for DBAsyncError  {
+impl From<DBError> for DBAsyncError {
     fn from(error: DBError) -> Self {
         DBAsyncError::DBError(error)
     }
 }
 
-impl From<BlockingError> for DBAsyncError  {
+impl From<BlockingError> for DBAsyncError {
     fn from(error: BlockingError) -> Self {
         DBAsyncError::ActixError(error)
     }
@@ -42,63 +42,155 @@ impl DBAsyncError {
     }
 }
 
-fn combine_errors<T>(error: std::result::Result<std::result::Result<T, DBAsyncError>, BlockingError>) -> Result<T> {
+fn combine_errors<T>(
+    error: std::result::Result<std::result::Result<T, DBAsyncError>, BlockingError>,
+) -> Result<T> {
     error?
 }
 
 type Result<T> = std::result::Result<T, DBAsyncError>;
 
 impl Connection {
-    pub async fn get_all_recipe_titles_async(&self) -> Result<Vec<(i32, String)>> {
+    pub async fn get_all_recipe_titles_async(&self) -> Result<Vec<(i64, String)>> {
         let self_copy = self.clone();
-        web::block(move || { self_copy.get_all_recipe_titles().unwrap_or_default() }).await.map_err(DBAsyncError::from)
+        web::block(move || self_copy.get_all_recipe_titles().unwrap_or_default())
+            .await
+            .map_err(DBAsyncError::from)
     }
 
-    pub async fn get_recipe_async(&self, id: i32) -> Result<model::Recipe> {
+    pub async fn get_recipe_async(&self, id: i64) -> Result<model::Recipe> {
         let self_copy = self.clone();
-        combine_errors(web::block(move || { self_copy.get_recipe(id).map_err(DBAsyncError::from) }).await)
+        combine_errors(
+            web::block(move || self_copy.get_recipe(id).map_err(DBAsyncError::from)).await,
+        )
     }
 
-    pub async fn load_user_async(&self, user_id: i32) -> Result<User> {
+    pub async fn load_user_async(&self, user_id: i64) -> Result<User> {
         let self_copy = self.clone();
-        combine_errors(web::block(move || { self_copy.load_user(user_id).map_err(DBAsyncError::from) }).await)
+        combine_errors(
+            web::block(move || self_copy.load_user(user_id).map_err(DBAsyncError::from)).await,
+        )
     }
 
     pub async fn sign_up_async(&self, email: &str, password: &str) -> Result<SignUpResult> {
         let self_copy = self.clone();
         let email_copy = email.to_string();
         let password_copy = password.to_string();
-        combine_errors(web::block(move || { self_copy.sign_up(&email_copy, &password_copy).map_err(DBAsyncError::from) }).await)
+        combine_errors(
+            web::block(move || {
+                self_copy
+                    .sign_up(&email_copy, &password_copy)
+                    .map_err(DBAsyncError::from)
+            })
+            .await,
+        )
     }
 
-    pub async fn validation_async(&self, token: &str, validation_time: Duration, ip: &str, user_agent: &str) -> Result<ValidationResult> {
+    pub async fn validation_async(
+        &self,
+        token: &str,
+        validation_time: Duration,
+        ip: &str,
+        user_agent: &str,
+    ) -> Result<ValidationResult> {
         let self_copy = self.clone();
         let token_copy = token.to_string();
         let ip_copy = ip.to_string();
         let user_agent_copy = user_agent.to_string();
-        combine_errors(web::block(move || { self_copy.validation(&token_copy, validation_time, &ip_copy, &user_agent_copy).map_err(DBAsyncError::from) }).await)
+        combine_errors(
+            web::block(move || {
+                self_copy
+                    .validation(&token_copy, validation_time, &ip_copy, &user_agent_copy)
+                    .map_err(DBAsyncError::from)
+            })
+            .await,
+        )
     }
 
-    pub async fn sign_in_async(&self, email: &str, password: &str, ip: &str, user_agent: &str) -> Result<SignInResult> {
+    pub async fn sign_in_async(
+        &self,
+        email: &str,
+        password: &str,
+        ip: &str,
+        user_agent: &str,
+    ) -> Result<SignInResult> {
         let self_copy = self.clone();
         let email_copy = email.to_string();
         let password_copy = password.to_string();
         let ip_copy = ip.to_string();
         let user_agent_copy = user_agent.to_string();
-        combine_errors(web::block(move || { self_copy.sign_in(&email_copy, &password_copy, &ip_copy, &user_agent_copy).map_err(DBAsyncError::from) }).await)
+        combine_errors(
+            web::block(move || {
+                self_copy
+                    .sign_in(&email_copy, &password_copy, &ip_copy, &user_agent_copy)
+                    .map_err(DBAsyncError::from)
+            })
+            .await,
+        )
     }
 
-    pub async fn authentication_async(&self, token: &str, ip: &str, user_agent: &str) -> Result<AuthenticationResult> {
+    pub async fn authentication_async(
+        &self,
+        token: &str,
+        ip: &str,
+        user_agent: &str,
+    ) -> Result<AuthenticationResult> {
         let self_copy = self.clone();
         let token_copy = token.to_string();
         let ip_copy = ip.to_string();
         let user_agent_copy = user_agent.to_string();
-        combine_errors(web::block(move || { self_copy.authentication(&token_copy, &ip_copy, &user_agent_copy).map_err(DBAsyncError::from) }).await)
+        combine_errors(
+            web::block(move || {
+                self_copy
+                    .authentication(&token_copy, &ip_copy, &user_agent_copy)
+                    .map_err(DBAsyncError::from)
+            })
+            .await,
+        )
     }
 
     pub async fn sign_out_async(&self, token: &str) -> Result<()> {
         let self_copy = self.clone();
         let token_copy = token.to_string();
-        combine_errors(web::block(move || { self_copy.sign_out(&token_copy).map_err(DBAsyncError::from) }).await)
+        combine_errors(
+            web::block(move || self_copy.sign_out(&token_copy).map_err(DBAsyncError::from)).await,
+        )
     }
-}
\ No newline at end of file
+
+    pub async fn create_recipe_async(&self, user_id: i64) -> Result<i64> {
+        let self_copy = self.clone();
+        combine_errors(
+            web::block(move || self_copy.create_recipe(user_id).map_err(DBAsyncError::from)).await,
+        )
+    }
+
+    pub async fn set_recipe_title_async(&self, recipe_id: i64, title: &str) -> Result<()> {
+        let self_copy = self.clone();
+        let title_copy = title.to_string();
+        combine_errors(
+            web::block(move || {
+                self_copy
+                    .set_recipe_title(recipe_id, &title_copy)
+                    .map_err(DBAsyncError::from)
+            })
+            .await,
+        )
+    }
+
+    pub async fn set_recipe_description_async(
+        &self,
+        recipe_id: i64,
+        description: &str,
+    ) -> Result<()> {
+        let self_copy = self.clone();
+        let description_copy = description.to_string();
+        combine_errors(
+            web::block(move || {
+                self_copy
+                    .set_recipe_description(recipe_id, &description_copy)
+                    .map_err(DBAsyncError::from)
+            })
+            .await,
+        )
+    }
+}