benutzer hinzugefügt und grupe repostory überarbeitet

src/domain.rs

@@ -1,4 +1,4 @@
-// pub mod benutzer;
+pub mod benutzer;
 pub mod gruppe;
 pub mod liegenschaft;
 pub mod rolle;

src/domain/benutzer.rs

@@ -1,6 +1,7 @@
 pub mod dataloader;
 pub mod entity;
 pub mod model;
-pub mod queries;
+pub mod mutation;
+pub mod query;
 pub mod repository;
 pub mod service;

src/domain/benutzer/dataloader.rs

@@ -1,2 +1,2 @@
-pub mod benutzer_gruppen_kumulativ;
-pub mod benutzer_rollen;
+// pub mod benutzer_gruppen_kumulativ;
+// pub mod benutzer_rollen;

src/domain/benutzer/entity.rs

@@ -1,3 +1,5 @@
 pub mod benutzer;
 
-pub use benutzer::Benutzer;
+pub use benutzer::BenutzerErstellen;
+pub use benutzer::BenutzerLoeschen;
+pub use benutzer::BenutzerUpdate;

src/domain/benutzer/entity/benutzer.rs

@@ -1,8 +1,30 @@
-use crate::scalar::Id;
+use crate::scalar::{Id, Time, Ulid};
 
-pub struct Benutzer {
-    pub id: Id,
+// pub struct Benutzer {
+//     pub id: Id,
+//     pub kennung: String,
+//     pub nachname: String,
+//     pub vorname: String,
+// }
+
+pub struct BenutzerErstellen {
+    pub benutzer_id: Id,
+    pub id: Ulid,
     pub kennung: String,
     pub nachname: String,
     pub vorname: String,
+    pub erstellt_am: Time,
+    pub geaendert_am: Time,
+}
+
+pub struct BenutzerLoeschen {
+    pub id: Ulid,
+}
+
+pub struct BenutzerUpdate {
+    pub id: Ulid,
+    pub kennung: Option<String>,
+    pub nachname: Option<String>,
+    pub vorname: Option<String>,
+    pub geaendert_am: Time,
 }

src/domain/benutzer/model.rs

@@ -1,8 +1,8 @@
 pub mod benutzer;
-pub mod benutzer_create_input;
+pub mod benutzer_erstellen_input;
 pub mod benutzer_gruppen_ansicht;
 
 pub use benutzer::Benutzer;
-pub use benutzer_create_input::BenutzerCreateInput;
-pub use benutzer_gruppen_ansicht::GruppeAnsicht;
-pub use benutzer_gruppen_ansicht::Herkunft;
+pub use benutzer_erstellen_input::BenutzerErstellenInput;
+// pub use benutzer_gruppen_ansicht::GruppeAnsicht;
+// pub use benutzer_gruppen_ansicht::Herkunft;

src/domain/benutzer/model/benutzer.rs

@@ -3,7 +3,7 @@ use async_graphql::{ComplexObject, Context, FieldResult, SimpleObject};
 use crate::{
     dataloader::LoaderContext,
     domain::{gruppe::model::Gruppe, rolle::model::Rolle},
-    scalar::Ulid,
+    scalar::{Time, Ulid},
 };
 
 #[derive(sqlx::FromRow, SimpleObject)]
@@ -20,6 +20,12 @@ pub struct Benutzer {
 
     /// Der Nachname des Benutzers
     pub nachname: String,
+
+    /// Wann der Benutzer erstellt wurde
+    pub erstellt_am: Time,
+
+    /// Wann der Benutzer geaendert wurde
+    pub geaendert_am: Time,
 }
 
 #[ComplexObject]

src/domain/benutzer/model/benutzer_erstellen_input.rs

@@ -3,7 +3,7 @@ use async_graphql::InputObject;
 use crate::scalar::Ulid;
 
 #[derive(InputObject)]
-pub struct BenutzerCreateInput {
+pub struct BenutzerErstellenInput {
     // #[graphql(validator(min_length = 6, max_length = 8))]
     pub kennung: String,
     pub vorname: String,

src/domain/benutzer/mutation.rs

@@ -0,0 +1,3 @@
+pub mod benutzer;
+
+pub use benutzer::BenutzerMutation;

src/domain/benutzer/mutation/benutzer.rs

@@ -0,0 +1,49 @@
+use crate::domain::benutzer::{
+    model::{Benutzer, BenutzerErstellenInput},
+    service::Service,
+};
+
+use async_graphql::{Context, FieldResult};
+use sqlx::postgres::PgPool;
+
+#[derive(Default)]
+pub struct BenutzerMutation;
+
+#[async_graphql::Object]
+impl BenutzerMutation {
+    async fn erstelle_benutzer(
+        &self,
+        ctx: &Context<'_>,
+        input: BenutzerErstellenInput,
+    ) -> FieldResult<Benutzer> {
+        let pool = ctx.data::<PgPool>()?.clone();
+
+        let benutzer = Service::new(pool).benutzer_erstellen(input).await?;
+        Ok(benutzer)
+    }
+
+    // async fn erstelle_viele_benutzer(
+    //     &self,
+    //     ctx: &Context<'_>,
+    //     input: Vec<BenutzerErstelleInput>,
+    // ) -> FieldResult<Vec<Benutzer>> {
+    //     let pool = ctx.data::<PgPool>()?.clone();
+    //
+    //     let benutzer = Service::new(pool).benutzer_erstellen_viele(&input).await?;
+    //     Ok(benutzer)
+    // }
+    //
+    // async fn update_benutzer(&self, ctx: &Context<'_>, input: BenutzerUpdateInput) -> FieldResult<Benutzer> {
+    //     let pool = ctx.data::<PgPool>()?;
+    //
+    //     let benutzer = Service::new(pool.clone()).benutzer_update(input).await?;
+    //     Ok(benutzer)
+    // }
+    //
+    // async fn loesche_benutzer(&self, ctx: &Context<'_>, input: BenutzerLoeschenInput) -> FieldResult<Benutzer> {
+    //     let pool = ctx.data::<PgPool>()?.clone();
+    //
+    //     let benutzer = Service::new(pool).benutzer_loeschen(input).await?;
+    //     Ok(benutzer)
+    // }
+}

src/domain/benutzer/repository.rs

@@ -1,5 +1,7 @@
-mod alle_benutzer;
-pub mod create_benutzer;
+pub mod benutzer_alle;
+pub mod benutzer_erstellen;
+pub mod benutzer_loeschen;
+pub mod benutzer_update;
 pub mod find_gruppen;
 
 #[derive(Debug, Clone)]

src/domain/benutzer/repository/benutzer_alle.rs

@@ -10,8 +10,7 @@ impl Repository {
         db: C,
     ) -> Result<Vec<model::Benutzer>, Error> {
         const QUERY: &str = r#"
-            SELECT *
-            FROM benutzer
+            SELECT * FROM benutzer
         "#;
 
         let benutzer = sqlx::query_as::<_, model::Benutzer>(QUERY)

src/domain/benutzer/repository/benutzer_erstellen.rs

@@ -0,0 +1,34 @@
+use anyhow::Error;
+
+use super::Repository;
+use crate::{
+    database::Queryer,
+    domain::benutzer::{entity, model},
+};
+
+impl Repository {
+    pub async fn benutzer_erstellen<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+        benutzer: &entity::BenutzerErstellen,
+    ) -> Result<model::Benutzer, Error> {
+        const QUERY: &str = r#"
+            INSERT INTO benutzer (benutzer_id, id, kennung, nachname, vorname, erstellt_am, geaendert_am)
+            VALUES ($1, $2, $3, $4, $5, $6, $7)
+            RETURNING id, kennung, nachname, vorname, erstellt_am, geaendert_am;
+        "#;
+
+        let benutzer = sqlx::query_as::<_, model::Benutzer>(QUERY)
+            .bind(benutzer.benutzer_id)
+            .bind(benutzer.id)
+            .bind(&benutzer.kennung)
+            .bind(&benutzer.nachname)
+            .bind(&benutzer.vorname)
+            .bind(benutzer.erstellt_am)
+            .bind(benutzer.geaendert_am)
+            .fetch_one(db)
+            .await?;
+
+        Ok(benutzer)
+    }
+}

src/domain/benutzer/repository/benutzer_loeschen.rs

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

src/domain/benutzer/repository/benutzer_update.rs

@@ -0,0 +1,30 @@
+use anyhow::Error;
+
+use super::Repository;
+use crate::{
+    database::Queryer,
+    domain::benutzer::{entity, model},
+};
+
+impl Repository {
+    pub async fn benutzer_update<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+        benutzer: &entity::BenutzerUpdate,
+    ) -> Result<model::Benutzer, Error> {
+        const QUERY: &str = r#"
+            UPDATE benutzer
+            SET kennung = $2, geaendert_am = $3 WHERE id = $1
+            RETURNING id, typname, erstellt_am, geaendert_am;
+        "#;
+
+        let benutzer = sqlx::query_as::<_, model::Benutzer>(QUERY)
+            .bind(benutzer.id)
+            .bind(&benutzer.kennung)
+            .bind(benutzer.geaendert_am)
+            .fetch_one(db)
+            .await?;
+
+        Ok(benutzer)
+    }
+}

src/domain/benutzer/repository/create_benutzer.rs

@@ -1,31 +0,0 @@
-use anyhow::Error;
-
-use super::Repository;
-use crate::database::Queryer;
-use crate::domain::benutzer::entity;
-use crate::domain::benutzer::model;
-use crate::scalar::Id;
-
-impl Repository {
-    pub async fn create_benutzer<'c, C: Queryer<'c>>(
-        &self,
-        db: C,
-        benutzer: &entity::Benutzer,
-    ) -> Result<model::Benutzer, Error> {
-        const QUERY: &str = r#"
-            INSERT INTO benutzer (id, kennung, nachname, vorname)
-            VALUES ($1, $2, $3, $4)
-            RETURNING id, kennung, nachname, vorname;
-        "#;
-
-        let benutzer = sqlx::query_as::<_, model::Benutzer>(QUERY)
-            .bind::<Id>(benutzer.id)
-            .bind(&benutzer.kennung)
-            .bind(&benutzer.nachname)
-            .bind(&benutzer.vorname)
-            .fetch_one(db)
-            .await?;
-
-        Ok(benutzer)
-    }
-}

src/domain/benutzer/service.rs

@@ -1,5 +1,5 @@
-mod alle_benutzer;
-pub mod create_benutzer;
+mod benutzer_alle;
+mod benutzer_erstellen;
 
 use super::repository::Repository;
 use crate::database::DB;

src/domain/benutzer/service/alle_benutzer.rs

@@ -1,11 +0,0 @@
-use async_graphql::FieldResult;
-
-use crate::domain::benutzer::model::Benutzer;
-
-use super::Service;
-
-impl Service {
-    pub async fn alle_benutzer(&self) -> FieldResult<Vec<Benutzer>> {
-        Ok(self.repo.alle_benutzer(&self.db).await?)
-    }
-}

src/domain/benutzer/service/benutzer_alle.rs

@@ -0,0 +1,12 @@
+use anyhow::Error;
+
+use crate::domain::benutzer::model::Benutzer;
+
+use super::Service;
+
+impl Service {
+    pub async fn alle_benutzer(&self) -> Result<Vec<Benutzer>, Error> {
+        let benutzer = self.repo.alle_benutzer(&self.db).await?;
+        Ok(benutzer)
+    }
+}

src/domain/benutzer/service/benutzer_erstellen.rs

@@ -0,0 +1,36 @@
+use anyhow::Error;
+use chrono::Utc;
+
+use crate::{
+    domain::benutzer::{
+        entity,
+        model::{self, BenutzerErstellenInput},
+    },
+    scalar::Ulid,
+};
+
+use super::Service;
+
+impl Service {
+    pub async fn benutzer_erstellen(
+        &self,
+        input: BenutzerErstellenInput,
+    ) -> Result<model::Benutzer, Error> {
+        let benutzer_entity = entity::BenutzerErstellen {
+            benutzer_id: ulid::Ulid::new().into(),
+            id: Ulid(ulid::Ulid::new()),
+            kennung: input.kennung,
+            nachname: input.nachname,
+            vorname: input.vorname,
+            erstellt_am: Utc::now(),
+            geaendert_am: Utc::now(),
+        };
+
+        let benutzer = self
+            .repo
+            .benutzer_erstellen(&self.db, &benutzer_entity)
+            .await?;
+
+        Ok(benutzer)
+    }
+}

src/domain/benutzer/service/create_benutzer.rs

@@ -1,25 +0,0 @@
-use async_graphql::FieldResult;
-use ulid::Ulid;
-
-use crate::domain::benutzer::{
-    entity,
-    model::{Benutzer, BenutzerCreateInput},
-};
-
-use super::Service;
-
-impl Service {
-    pub async fn create_benutzer(&self, input: BenutzerCreateInput) -> FieldResult<Benutzer> {
-        let benutzer_entity = entity::Benutzer {
-            id: Ulid::new().into(),
-            kennung: input.kennung,
-            nachname: input.nachname,
-            vorname: input.vorname,
-        };
-
-        Ok(self
-            .repo
-            .create_benutzer(&self.db, &benutzer_entity)
-            .await?)
-    }
-}

src/domain/gruppe/repository.rs

@@ -4,6 +4,7 @@ mod gruppe_erstellen;
 mod gruppe_loeschen;
 mod gruppe_update;
 
+/// Die Dokumentation für das Gruppen Repository
 #[derive(Debug, Clone)]
 pub struct Repository {}
 

src/domain/gruppe/repository/gruppe_alle.rs

@@ -4,6 +4,9 @@ use super::Repository;
 use crate::{database::Queryer, domain::gruppe::model};
 
 impl Repository {
+    /// Das ist ein Test
+    /// Blub
+    /// Hui
     pub async fn gruppe_alle<'c, C: Queryer<'c>>(
         &self,
         db: C,

src/domain/gruppe/service.rs

@@ -9,6 +9,7 @@ use crate::database::DB;
 
 #[derive(Debug)]
 pub struct Service {
+    /// das ist die Dokumentation für das Gruppen Repository
     repo: Repository,
     pub db: DB,
 }

src/mutations/benutzer.rs

@@ -1,36 +1,38 @@
-use crate::domain::benutzer::{model::Benutzer, model::BenutzerCreateInput, service::Service};
-use async_graphql::{Context, FieldResult};
-use sqlx::postgres::PgPool;
-
-#[derive(Default)]
-pub struct BenutzerMutation;
-
-#[async_graphql::Object]
-impl BenutzerMutation {
-    async fn create_benutzer(
-        &self,
-        ctx: &Context<'_>,
-        input: BenutzerCreateInput,
-    ) -> FieldResult<Benutzer> {
-        let pool = ctx.data::<PgPool>()?;
-
-        let row = Service::new(pool.clone()).create_benutzer(input).await?;
-
-        Ok(row)
-    }
-
-    // async fn update_hersteller(
-    //     &self,
-    //     ctx: &Context<'_>,
-    //     input: HerstellerUpdateInput,
-    // ) -> FieldResult<Hersteller> {
-    //     let pool = ctx.data::<PgPool>()?;
-    //     let row = Hersteller::update(pool, &input).await?;
-    //     Ok(row)
-    // }
-
-    // async fn delete_hersteller(&self, ctx: &Context<'_>, id: Id) -> FieldResult<bool> {
-    //     let pool = ctx.data::<PgPool>()?;
-    //     Ok(Hersteller::delete(pool, &id).await?)
-    // }
-}
+// use crate::domain::benutzer::{model::Benutzer, model::BenutzerCreateInput, service::Service};
+// use async_graphql::{Context, FieldResult};
+// use sqlx::postgres::PgPool;
+//
+// #[derive(Default)]
+// pub struct BenutzerMutation;
+//
+// #[async_graphql::Object]
+// impl BenutzerMutation {
+//     async fn create_benutzer(
+//         &self,
+//         ctx: &Context<'_>,
+//         input: BenutzerCreateInput,
+//     ) -> FieldResult<Benutzer> {
+//         let pool = ctx.data::<PgPool>()?;
+//
+//         let r1 = cts.date::<PgPool>();
+//
+//         let row = Service::new(pool.clone()).create_benutzer(input).await?;
+//
+//         Ok(row)
+//     }
+//
+//     // async fn update_hersteller(
+//     //     &self,
+//     //     ctx: &Context<'_>,
+//     //     input: HerstellerUpdateInput,
+//     // ) -> FieldResult<Hersteller> {
+//     //     let pool = ctx.data::<PgPool>()?;
+//     //     let row = Hersteller::update(pool, &input).await?;
+//     //     Ok(row)
+//     // }
+//
+//     // async fn delete_hersteller(&self, ctx: &Context<'_>, id: Id) -> FieldResult<bool> {
+//     //     let pool = ctx.data::<PgPool>()?;
+//     //     Ok(Hersteller::delete(pool, &id).await?)
+//     // }
+// }

src/mutations/mod.rs

@@ -1,4 +1,3 @@
-// pub mod benutzer;
 // pub mod hersteller;
 // pub mod modell;
 pub mod liegenschaft;
@@ -6,16 +5,17 @@ pub mod liegenschaft;
 use async_graphql::MergedObject;
 
 use crate::domain::{
-    gruppe::mutation::GruppeMutation, rolle::mutation::RolleMutation, typ::mutation::TypMutation,
+    benutzer::mutation::BenutzerMutation, gruppe::mutation::GruppeMutation,
+    rolle::mutation::RolleMutation, typ::mutation::TypMutation,
 };
 
 #[derive(MergedObject, Default)]
 pub struct Mutation(
+    BenutzerMutation,
+    GruppeMutation,
+    RolleMutation,
     TypMutation,
     // hersteller::HerstellerMutation,
     // modell::ModellMutation,
-    // benutzer::BenutzerMutation,
-    GruppeMutation,
-    RolleMutation,
     liegenschaft::LiegenschaftMutation,
 );

src/queries/mod.rs

@@ -1,12 +1,15 @@
 use crate::domain::{
-    // benutzer::queries::benutzer,
-    gruppe::query::GruppeQuery,
-    liegenschaft::query::LiegenschaftQuery,
-    rolle::query::RolleQuery,
-    typ::query::TypQuery,
+    benutzer::query::BenutzerQuery, gruppe::query::GruppeQuery,
+    liegenschaft::query::LiegenschaftQuery, rolle::query::RolleQuery, typ::query::TypQuery,
 };
 
 use async_graphql::MergedObject;
 
 #[derive(MergedObject, Default)]
-pub struct Query(TypQuery, RolleQuery, GruppeQuery, LiegenschaftQuery);
+pub struct Query(
+    BenutzerQuery,
+    GruppeQuery,
+    LiegenschaftQuery,
+    RolleQuery,
+    TypQuery,
+);