Refactoring gruppe und rolle

src/domain/gruppe/model.rs

@@ -1,7 +1,9 @@
 pub mod gruppe;
-pub mod gruppe_erstelle_input;
+pub mod gruppe_erstellen_input;
+pub mod gruppe_loeschen_input;
 pub mod gruppe_update_input;
 
 pub use gruppe::Gruppe;
-pub use gruppe_erstelle_input::GruppeErstelleInput;
+pub use gruppe_erstellen_input::GruppeErstelleInput;
+pub use gruppe_loeschen_input::GruppeLoeschenInput;
 pub use gruppe_update_input::GruppeUpdateInput;

src/domain/gruppe/model/gruppe_loeschen_input.rs

@@ -0,0 +1,9 @@
+use async_graphql::InputObject;
+
+use crate::scalar::Id;
+
+#[derive(InputObject)]
+pub struct GruppeLoeschenInput {
+    /// Die ID einer Gruppe
+    pub id: Id,
+}

src/domain/gruppe/model/gruppe_update_input.rs

@@ -1,7 +1,11 @@
+use crate::scalar::Id;
 use async_graphql::InputObject;
 
 #[derive(InputObject)]
 pub struct GruppeUpdateInput {
+    /// Die ID einer Gruppe
+    pub id: Id,
+
     /// Der Name einer Gruppe
     pub gruppenname: String,
 }

src/domain/gruppe/repository.rs

@@ -1,6 +1,7 @@
 mod gruppe_alle;
 mod gruppe_dataloader;
 mod gruppe_erstellen;
+mod gruppe_loeschen;
 mod gruppe_update;
 
 #[derive(Debug, Clone)]

src/domain/gruppe/repository/gruppe_loeschen.rs

@@ -0,0 +1,24 @@
+use anyhow::Error;
+
+use super::Repository;
+use crate::database::Queryer;
+use crate::domain::gruppe::{entity, model};
+
+impl Repository {
+    pub async fn gruppe_loeschen<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+        gruppe: &entity::Gruppe,
+    ) -> Result<model::Gruppe, Error> {
+        const QUERY: &str = r#"
+            DELETE FROM gruppen WHERE id=$1 RETURNING id, gruppenname, erstellt_am, geaendert_am;
+        "#;
+
+        let gruppe = sqlx::query_as::<_, model::Gruppe>(QUERY)
+            .bind(gruppe.id)
+            .fetch_one(db)
+            .await?;
+
+        Ok(gruppe)
+    }
+}

src/domain/gruppe/service.rs

@@ -1,6 +1,7 @@
 mod gruppe_alle;
 mod gruppe_dataloader;
 mod gruppe_erstellen;
+mod gruppe_loeschen;
 mod gruppe_update;
 
 use super::repository::Repository;

src/domain/gruppe/service/gruppe_loeschen.rs

@@ -0,0 +1,25 @@
+use anyhow::Error;
+use chrono::Utc;
+
+use super::Service;
+use crate::domain::gruppe::{
+    entity,
+    model::{self, GruppeLoeschenInput},
+};
+
+impl Service {
+    pub async fn gruppe_loeschen(
+        &self,
+        input: GruppeLoeschenInput,
+    ) -> Result<model::Gruppe, Error> {
+        let gruppe_input = entity::Gruppe {
+            id: input.id,
+            gruppenname: String::new(),
+            erstellt_am: None,
+            geaendert_am: Some(Utc::now()),
+        };
+
+        let gruppe = self.repo.gruppe_loeschen(&self.db, &gruppe_input).await?;
+        Ok(gruppe)
+    }
+}

src/domain/gruppe/service/gruppe_update.rs

@@ -17,7 +17,7 @@ impl Service {
             geaendert_am: Some(Utc::now()),
         };
 
-        let gruppe = self.repo.gruppe_erstellen(&self.db, &gruppe_input).await?;
+        let gruppe = self.repo.gruppe_update(&self.db, &gruppe_input).await?;
         Ok(gruppe)
     }
 }

src/domain/rolle/model.rs

@@ -1,7 +1,9 @@
 pub mod rolle;
 pub mod rolle_erstelle_input;
+pub mod rolle_loeschen_input;
 pub mod rolle_update_input;
 
 pub use rolle::Rolle;
 pub use rolle_erstelle_input::RolleErstelleInput;
+pub use rolle_loeschen_input::RolleLoeschenInput;
 pub use rolle_update_input::RolleUpdateInput;

src/domain/rolle/model/rolle_loeschen_input.rs

@@ -0,0 +1,9 @@
+use async_graphql::InputObject;
+
+use crate::scalar::Id;
+
+#[derive(InputObject)]
+pub struct RolleLoeschenInput {
+    /// Die ID einer Rolle
+    pub id: Id,
+}

src/domain/rolle/model/rolle_update_input.rs

@@ -1,6 +1,5 @@
-use async_graphql::InputObject;
-
 use crate::scalar::Id;
+use async_graphql::InputObject;
 
 #[derive(InputObject)]
 pub struct RolleUpdateInput {

src/domain/rolle/repository.rs

@@ -1,7 +1,7 @@
-mod delete_rolle;
 mod find_all_rolle;
 mod find_rolle_by_id;
 mod rolle_erstellen;
+mod rolle_loeschen;
 mod rolle_update;
 mod rollen_dataloader;
 
@@ -13,7 +13,6 @@ impl Repository {
         Repository {}
     }
 }
-
 impl Default for Repository {
     fn default() -> Self {
         Self::new()

src/domain/rolle/repository/rolle_loeschen.rs

@@ -0,0 +1,26 @@
+use anyhow::Error;
+
+use super::Repository;
+use crate::{
+    database::Queryer,
+    domain::rolle::{entity, model},
+};
+
+impl Repository {
+    pub async fn rolle_loeschen<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+        rolle: &entity::Rolle,
+    ) -> Result<model::Rolle, Error> {
+        const QUERY: &str = r#"
+            DELETE FROM rollen WHERE id=$1 RETURNING id, rollenname, erstellt_am, geaendert_am;
+        "#;
+
+        let rolle = sqlx::query_as::<_, model::Rolle>(QUERY)
+            .bind(rolle.id)
+            .fetch_one(db)
+            .await?;
+
+        Ok(rolle)
+    }
+}

src/domain/rolle/service.rs

@@ -1,4 +1,5 @@
 mod rolle_erstellen;
+mod rolle_loeschen;
 mod rolle_update;
 
 use super::repository::Repository;

src/domain/rolle/service/rolle_loeschen.rs

@@ -0,0 +1,21 @@
+use super::Service;
+use anyhow::Error;
+
+use crate::domain::rolle::{
+    entity,
+    model::{self, RolleLoeschenInput},
+};
+
+impl Service {
+    pub async fn rolle_loeschen(&self, input: RolleLoeschenInput) -> Result<model::Rolle, Error> {
+        let rolle_input = entity::Rolle {
+            id: input.id,
+            rollenname: String::new(),
+            erstellt_am: None,
+            geaendert_am: None,
+        };
+
+        let deleted = self.repo.rolle_loeschen(&self.db, &rolle_input).await?;
+        Ok(deleted)
+    }
+}

src/mutations/gruppe.rs

@@ -1,5 +1,5 @@
 use crate::domain::gruppe::{
-    model::{Gruppe, GruppeErstelleInput},
+    model::{Gruppe, GruppeErstelleInput, GruppeLoeschenInput, GruppeUpdateInput},
     service::Service,
 };
 use async_graphql::{Context, FieldResult};
@@ -10,7 +10,7 @@ pub struct GruppeMutation;
 
 #[async_graphql::Object]
 impl GruppeMutation {
-    async fn gruppe_ersellen(
+    async fn erselle_gruppe(
         &self,
         ctx: &Context<'_>,
         input: GruppeErstelleInput,
@@ -20,4 +20,26 @@ impl GruppeMutation {
         let gruppe = Service::new(pool.clone()).gruppe_erstellen(input).await?;
         Ok(gruppe)
     }
+
+    async fn update_gruppe(
+        &self,
+        ctx: &Context<'_>,
+        input: GruppeUpdateInput,
+    ) -> FieldResult<Gruppe> {
+        let pool = ctx.data::<PgPool>()?;
+
+        let gruppe = Service::new(pool.clone()).gruppe_update(input).await?;
+        Ok(gruppe)
+    }
+
+    async fn loesche_gruppe(
+        &self,
+        ctx: &Context<'_>,
+        input: GruppeLoeschenInput,
+    ) -> FieldResult<Gruppe> {
+        let pool = ctx.data::<PgPool>()?;
+
+        let gruppe = Service::new(pool.clone()).gruppe_loeschen(input).await?;
+        Ok(gruppe)
+    }
 }

src/mutations/rolle.rs

@@ -1,5 +1,5 @@
 use crate::domain::rolle::{
-    model::{Rolle, RolleErstelleInput, RolleUpdateInput},
+    model::{Rolle, RolleErstelleInput, RolleLoeschenInput, RolleUpdateInput},
     service::Service,
 };
 use async_graphql::{Context, FieldResult};
@@ -10,7 +10,7 @@ pub struct RolleMutation;
 
 #[async_graphql::Object]
 impl RolleMutation {
-    async fn rolle_erstellen(
+    async fn erstelle_rolle(
         &self,
         ctx: &Context<'_>,
         input: RolleErstelleInput,
@@ -21,10 +21,21 @@ impl RolleMutation {
         Ok(gruppe)
     }
 
-    async fn rolle_update(&self, ctx: &Context<'_>, input: RolleUpdateInput) -> FieldResult<Rolle> {
+    async fn update_rolle(&self, ctx: &Context<'_>, input: RolleUpdateInput) -> FieldResult<Rolle> {
         let pool = ctx.data::<PgPool>()?;
 
-        let gruppe = Service::new(pool.clone()).rolle_update(input).await?;
+        let rolle = Service::new(pool.clone()).rolle_update(input).await?;
-        Ok(gruppe)
+        Ok(rolle)
+    }
+
+    async fn loesche_rolle(
+        &self,
+        ctx: &Context<'_>,
+        input: RolleLoeschenInput,
+    ) -> FieldResult<Rolle> {
+        let pool = ctx.data::<PgPool>()?;
+
+        let rolle = Service::new(pool.clone()).rolle_loeschen(input).await?;
+        Ok(rolle)
     }
 }

src/queries/gruppe.rs

@@ -8,12 +8,12 @@ pub struct GruppeQuery {}
 
 #[Object(extends)]
 impl GruppeQuery {
-    async fn gruppe(&self, ctx: &Context<'_>, id: uuid::Uuid) -> FieldResult<Gruppe> {
+    // async fn gruppe(&self, ctx: &Context<'_>, id: uuid::Uuid) -> FieldResult<Gruppe> {
-        todo!();
+    //     todo!();
-        // let pool = ctx.data::<PgPool>()?;
+    //     // let pool = ctx.data::<PgPool>()?;
-        //
+    //     //
-        // Ok(row)
+    //     // Ok(row)
-    }
+    // }
 
     async fn gruppen(&self, ctx: &Context<'_>) -> FieldResult<Vec<Gruppe>> {
         let pool = ctx.data::<PgPool>()?;