Implement more mutations

Implement mutations:
- create language
- delete language
- user follows a language
- user unfollows a language
- new word

Context's user_auth now contains either the user's ID or nothing if
not authentificated.

src/db/models/languages.rs

@@ -27,6 +27,12 @@ pub enum Release {
     Private,
 }
 
+impl Default for Release {
+    fn default() -> Self {
+        Self::Public
+    }
+}
+
 #[derive(
     diesel_derive_enum::DbEnum, Debug, Clone, PartialEq, Eq, GraphQLEnum,
 )]
@@ -50,6 +56,91 @@ pub enum AgentLanguageRelation {
     Author,
 }
 
+#[derive(Default, Debug, Clone, juniper::GraphQLInputObject)]
+pub struct NewLanguage {
+    name: String,
+    native: Option<String>,
+    release: Option<Release>,
+    genre: Vec<DictGenre>,
+    abstract_: Option<String>,
+    description: Option<String>,
+    rights: Option<String>,
+    license: Option<String>,
+}
+
+#[derive(Insertable, Debug, Clone)]
+#[diesel(table_name = languages)]
+struct NewLanguageInternal {
+    name: String,
+    native: Option<String>,
+    release: Release,
+    genre: Vec<DictGenre>,
+    abstract_: Option<String>,
+    description: Option<String>,
+    rights: Option<String>,
+    license: Option<String>,
+    owner: String,
+}
+
+impl From<NewLanguage> for NewLanguageInternal {
+    fn from(val: NewLanguage) -> Self {
+        NewLanguageInternal {
+            name: val.name,
+            native: val.native,
+            release: if let Some(release) = val.release {
+                release
+            } else {
+                Release::default()
+            },
+            genre: val.genre,
+            abstract_: val.abstract_,
+            description: val.description,
+            rights: val.rights,
+            license: val.license,
+            owner: String::new(),
+        }
+    }
+}
+
+impl NewLanguage {
+    pub fn insert_db(
+        &self,
+        db: &Database,
+        owner: &str,
+    ) -> Result<Language, DatabaseError> {
+        use languages::dsl;
+        let conn = &mut db.conn()?;
+        match diesel::insert_into(dsl::languages)
+            .values(NewLanguageInternal {
+                owner: owner.to_string(),
+                ..self.clone().into()
+            })
+            .execute(conn)
+        {
+            Ok(_) => dsl::languages
+                .filter(dsl::name.eq(self.name.clone()))
+                .filter(dsl::owner.eq(owner))
+                .first::<Language>(conn)
+                .map_err(|e| {
+                    DatabaseError::new(
+                        format!(
+                            "Failed to find language {} by user {owner}: {e:?}",
+                            self.name
+                        ),
+                        "Database Error",
+                    )
+                }),
+            Err(e) => Err(DatabaseError::new(
+                format!(
+                    "Failed to insert language {} by user {owner}: {e:?}",
+                    self.name
+                ),
+                "Database Error",
+            )),
+        }
+    }
+}
+
 #[derive(Queryable, Insertable, Debug, Clone)]
 pub struct Language {
     id: Uuid,
@@ -66,6 +157,59 @@ pub struct Language {
 }
 
 impl Language {
+    pub fn find(
+        db: &Database,
+        language: Uuid,
+    ) -> Result<Language, DatabaseError> {
+        use languages::dsl;
+        dsl::languages.find(language).first::<Language>(&mut db.conn()?).map_err(|e| match e {
+            diesel::NotFound => DatabaseError::new(
+                format!("Language {language} not found"),
+                "Not Found"
+            ),
+            e => DatabaseError::new(
+                format!("Error fetching language {language} from database: {e:?}"),
+                "Database Error"
+            )
+        })
+    }
+
+    pub fn delete(
+        context: &Context,
+        language_id: Uuid,
+    ) -> Result<(), DatabaseError> {
+        use languages::dsl;
+        let conn = &mut context.db.conn()?;
+        match dsl::languages.find(language_id)
+                            .first::<Language>(conn)
+        {
+            Ok(language) if context.user_auth == Some(language.owner.clone()) => {
+        match diesel::delete(dsl::languages.find(language_id))
+            .execute(conn) {
+                Ok(_) => Ok(()),
+                Err(e) => Err(DatabaseError::new(
+                    format!("Failed to delete language {language_id}: {e:?}"),
+                    "Database Error"
+                ))
+            }
+            },
+            Ok(language) => {
+                Err(DatabaseError::new(
+                    format!(
+                        "User {} not allowed to delete other user's language {language_id}",
+                        language.owner),
+                    "Unauthorized"
+                ))
+            },
+            Err(e) => {
+                Err(DatabaseError::new(
+                    format!("Failed to delete language {language_id}: {e:?}"),
+                    "Database Error"
+                ))
+            }
+        }
+    }
+
     fn relationship(
         &self,
         db: &Database,
@@ -290,6 +434,13 @@ pub struct LangTranslatesTo {
     langto: Uuid,
 }
 
+#[derive(Insertable)]
+#[diesel(table_name = userfollowlanguage)]
+pub struct UserFollowLanguageInsert {
+    pub lang: Uuid,
+    pub userid: String,
+}
+
 #[derive(Queryable, Insertable, Debug, Clone, PartialEq, Eq)]
 #[diesel(table_name = userfollowlanguage)]
 pub struct UserFollowLanguage {
@@ -297,3 +448,71 @@ pub struct UserFollowLanguage {
     pub lang: Uuid,
     pub userid: String,
 }
+
+impl UserFollowLanguage {
+    pub fn user_follow_language(
+        context: &Context,
+        userid: &str,
+        lang: Uuid,
+    ) -> Result<Language, DatabaseError> {
+        let conn = &mut context.db.conn()?;
+        match languages::dsl::languages.find(lang).first::<Language>(conn) {
+            Err(diesel::NotFound) => Err(DatabaseError::new(
+                format!("Cannot follow non-existing language {lang}"),
+                "Invalid Language",
+            )),
+            Err(e) => Err(DatabaseError::new(
+                format!(
+                    "Could not retrieve language {lang} from database: {e:?}"
+                ),
+                "Database error",
+            )),
+            Ok(language) => {
+                use userfollowlanguage::dsl;
+                match diesel::insert_into(dsl::userfollowlanguage)
+                    .values(UserFollowLanguageInsert { lang, userid: userid.to_string() })
+                    .execute(conn) {
+                        Ok(_) => Ok(language),
+                        Err(e) => Err(DatabaseError::new(
+                            format!("Failed to follow language {lang} as user {userid}: {e:?}"),
+                            "Database Error"
+                        ))
+                    }
+            }
+        }
+    }
+
+    pub fn user_unfollow_language(
+        context: &Context,
+        userid: &str,
+        lang: Uuid,
+    ) -> Result<Language, DatabaseError> {
+        use userfollowlanguage::dsl;
+        let conn = &mut context.db.conn()?;
+        match dsl::userfollowlanguage
+            .filter(dsl::userid.eq(userid.to_string()))
+            .filter(dsl::lang.eq(lang))
+            .first::<UserFollowLanguage>(conn) {
+                Ok(relationship) => {
+                    match diesel::delete(dsl::userfollowlanguage.find(relationship.id))
+                        .execute(conn) {
+                            Ok(_) => Language::find(&context.db, lang),
+                            Err(e) => Err(DatabaseError::new(
+                                format!("Failed to make user {userid} unfollow language {lang}: {e:?}"),
+                                "Database Error"
+                            ))
+                        }
+                },
+                Err(diesel::NotFound) => {
+                    Err(DatabaseError::new(
+                        format!("User {userid} does not follow language {lang}"),
+                        "Invalid",
+                    ))
+                }
+                Err(e) => Err(DatabaseError::new(
+                    format!("Failed to retrieve relationship between user {userid} and language {lang} from database: {e:?}"),
+                    "Database Error",
+                ))
+            }
+    }
+}

src/db/models/words.rs

@@ -5,11 +5,11 @@ use crate::{
 };
 use diesel::prelude::*;
 use juniper::{FieldResult, GraphQLEnum};
-use schema::{wordrelation, words, wordlearning};
+use schema::{wordlearning, wordrelation, words};
 use tracing::info;
 use uuid::Uuid;
 
-use std::convert::Into;
+use std::{convert::Into, str::FromStr};
 
 use super::languages::Language;
 
@@ -20,11 +20,18 @@ pub enum WordRelationship {
     Related,
 }
 
-#[derive(diesel_derive_enum::DbEnum, Debug, Clone, PartialEq, Eq, juniper::GraphQLEnum)]
+#[derive(
+    diesel_derive_enum::DbEnum,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    juniper::GraphQLEnum,
+)]
 #[DieselTypePath = "crate::db::schema::sql_types::Wordlearningstatus"]
 pub enum WordLearningStatus {
     Learning,
-    Learned
+    Learned,
 }
 
 #[derive(
@@ -54,6 +61,72 @@ pub enum PartOfSpeech {
     Other,
 }
 
+impl Default for PartOfSpeech {
+    fn default() -> Self {
+        Self::Noun
+    }
+}
+
+#[derive(Debug, Clone, juniper::GraphQLInputObject)]
+pub struct NewWord {
+    norm: String,
+    native: Option<String>,
+    lemma: Option<String>,
+    language: String,
+    partofspeech: PartOfSpeech,
+    audio: Option<String>,
+    video: Option<String>,
+    image: Option<String>,
+    description: Option<String>,
+    etymology: Option<String>,
+    lusage: Option<String>,
+    morphology: Option<String>,
+}
+
+#[derive(Debug, Clone, Insertable)]
+#[diesel(table_name = words)]
+struct NewWordInternal {
+    norm: String,
+    native: Option<String>,
+    lemma: Option<Uuid>,
+    language: Uuid,
+    partofspeech: PartOfSpeech,
+    audio: Option<String>,
+    video: Option<String>,
+    image: Option<String>,
+    description: Option<String>,
+    etymology: Option<String>,
+    lusage: Option<String>,
+    morphology: Option<String>,
+}
+
+impl TryFrom<NewWord> for NewWordInternal {
+    type Error = uuid::Error;
+
+    fn try_from(value: NewWord) -> Result<Self, Self::Error> {
+        let language = Uuid::from_str(&value.language)?;
+        let lemma = if let Some(original_lemma) = value.lemma {
+            Some(Uuid::from_str(&original_lemma)?)
+        } else {
+            None
+        };
+        Ok(Self {
+            norm: value.norm,
+            native: value.native,
+            lemma,
+            language,
+            partofspeech: value.partofspeech,
+            audio: value.audio,
+            video: value.video,
+            image: value.image,
+            description: value.description,
+            etymology: value.etymology,
+            lusage: value.lusage,
+            morphology: value.morphology,
+        })
+    }
+}
+
 #[derive(Queryable, Insertable, Debug, Clone, PartialEq, Eq)]
 pub struct Word {
     id: Uuid,
@@ -229,5 +302,5 @@ pub struct WordLearning {
     pub id: i32,
     pub word: Uuid,
     pub userid: String,
-    pub status: WordLearningStatus
+    pub status: WordLearningStatus,
 }

src/graphql/context.rs

@@ -27,35 +27,42 @@ impl Default for OtherEnvVar {
 pub struct Context {
     pub db: Database,
     pub appwrite: APVariables,
-    pub user_auth: bool,
+    pub user_auth: Option<String>,
     pub other_vars: OtherEnvVar,
 }
 
 impl Context {
-    /// HTTP header for a user's session
+    /// Check if a request is performed by an autentificated user.
     ///
-    /// This header `Authorization` must be a single string in the
+    /// The HTTP header `Authorization` must be a single string in the
     /// form `userId;userSessionId` with `userId` and `userSessionId`
     /// being variables given by Appwrite to users that are logged in.
-    pub async fn user_auth<'r>(&self, auth_token: Option<&'r str>) -> bool {
+    ///
+    /// The function returns either the user's ID if the user is
+    /// authentified or `None`.
+    pub async fn user_auth<'r>(
+        &self,
+        auth_token: Option<&'r str>,
+    ) -> Option<String> {
         if let Some(token) = auth_token {
             let key = token.split(';').collect::<Vec<_>>();
             if key.len() == 2 {
                 let user_id = key[0];
                 let session_id = key[1];
                 match self.appwrite.check_session(session_id, user_id).await {
-                    Ok(val) => val,
+                    Ok(true) => Some(key[0].to_string()),
+                    Ok(false) => None,
                     Err(e) => {
                         info!("Error checking user session: {:?}", e);
-                        false
+                        None
                     }
                 }
             } else {
                 info!("Invalid session key: {}", token);
-                false
+                None
             }
         } else {
-            false
+            None
         }
     }
 

src/graphql/mutation.rs

@@ -1,6 +1,15 @@
-use juniper::FieldResult;
+use std::str::FromStr;
 
-use crate::db::{models::users::User, DatabaseError};
+use juniper::FieldResult;
+use uuid::Uuid;
+
+use crate::db::{
+    models::{
+        languages::{Language, NewLanguage, UserFollowLanguage},
+        users::User,
+    },
+    DatabaseError,
+};
 
 use super::Context;
 
@@ -9,7 +18,7 @@ pub struct Mutation;
 #[juniper::graphql_object(Context = Context)]
 impl Mutation {
     fn api_version(context: &Context) -> String {
-        if context.user_auth {
+        if context.user_auth.is_some() {
             "0.1 (authentified)"
         } else {
             "0.1 (not authentified)"
@@ -49,4 +58,103 @@ impl Mutation {
                 .into())
         }
     }
+
+    pub fn user_follow_language(
+        context: &Context,
+        language: String,
+    ) -> FieldResult<Language> {
+        if let Some(userid) = &context.user_auth {
+            match Uuid::from_str(&language) {
+                Err(e) => Err(DatabaseError::new(
+                    format!(
+                        "Could not parse {language} as a valid UUID: {e:?}"
+                    ),
+                    "Bad Request",
+                )
+                .into()),
+                Ok(lang) => UserFollowLanguage::user_follow_language(
+                    context,
+                    &userid.to_string(),
+                    lang,
+                )
+                .map_err(Into::into),
+            }
+        } else {
+            Err(DatabaseError::new(
+                "User not authentificated, cannot proceed",
+                "Unauthorized",
+            )
+            .into())
+        }
+    }
+
+    pub fn user_unfollow_language(
+        context: &Context,
+        language: String,
+    ) -> FieldResult<Language> {
+        if let Some(userid) = &context.user_auth {
+            match Uuid::from_str(&language) {
+                Err(e) => Err(DatabaseError::new(
+                    format!(
+                        "Could not parse {language} as a valid UUID: {e:?}"
+                    ),
+                    "Bad Request",
+                )
+                .into()),
+                Ok(lang) => UserFollowLanguage::user_unfollow_language(
+                    context,
+                    &userid.to_string(),
+                    lang,
+                )
+                .map_err(Into::into),
+            }
+        } else {
+            Err(DatabaseError::new(
+                "User not authentificated, cannot proceed",
+                "Unauthorized",
+            )
+            .into())
+        }
+    }
+
+    pub fn new_language(
+        context: &Context,
+        language: NewLanguage,
+    ) -> FieldResult<Language> {
+        if let Some(owner) = &context.user_auth {
+            language.insert_db(&context.db, owner).map_err(Into::into)
+        } else {
+            Err(DatabaseError::new(
+                "User not authentificated, cannot create new language",
+                "Unauthorized",
+            )
+            .into())
+        }
+    }
+
+    pub fn delete_language(
+        context: &Context,
+        language: String,
+    ) -> FieldResult<Option<Language>> {
+        if context.user_auth.is_some() {
+            match Uuid::from_str(&language) {
+                Ok(uuid) => Language::delete(context, uuid)
+                    .map(|_| None)
+                    .map_err(Into::into),
+                Err(e) => Err(DatabaseError::new(
+                    format!(
+                        "Could not parse {language} as a valid UUID: {e:?}"
+                    ),
+                    "Bad Request",
+                )
+                .into()),
+            }
+        } else {
+            Err(DatabaseError::new(
+                "User not authentificated, cannot create new language",
+                "Unauthorized",
+            )
+            .into())
+        }
+    }
 }