create gruppen, rollen, etc...

src/domain/rolle/dataloader.rs

@@ -0,0 +1 @@
+pub mod rollen;

src/domain/rolle/dataloader/rollen.rs

@@ -0,0 +1,51 @@
+use async_graphql::dataloader::*;
+use async_graphql::*;
+use itertools::Itertools;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use crate::domain::rolle::model::Rolle;
+use crate::scalar::Id;
+
+pub struct RollenLoader {
+    pub pool: sqlx::PgPool,
+}
+
+impl Loader<Id> for RollenLoader {
+    type Value = Vec<Rolle>;
+    type Error = Arc<sqlx::Error>;
+
+    async fn load(&self, keys: &[Id]) -> Result<HashMap<Id, Self::Value>, Self::Error> {
+        let rows = sqlx::query!(
+            r#"
+                SELECT
+                    br.benutzer_id,
+                    r.id,
+                    r.rollenname,
+                    r.erstellt_am,
+                    r.geaendert_am
+                FROM rollen AS r
+                LEFT JOIN benutzer_rollen AS br ON r.id = br.rolle_id
+                WHERE br.benutzer_id = ANY($1);
+            "#,
+            keys
+        )
+        .fetch_all(&self.pool)
+        .await?
+        .into_iter()
+        .map(|row| {
+            (
+                row.benutzer_id,
+                Rolle {
+                    id: row.id,
+                    rollenname: row.rollenname,
+                    erstellt_am: row.erstellt_am,
+                    geaendert_am: row.geaendert_am,
+                },
+            )
+        })
+        .into_group_map();
+
+        Ok(rows)
+    }
+}

src/domain/rolle/entity/rolle.rs

@@ -1,9 +1,8 @@
 use crate::scalar::{Id, Time};
 
-#[derive(sqlx::FromRow)]
 pub struct Rolle {
     pub id: Id,
-    pub created_at: Time,
-    pub updated_at: Time,
     pub rollenname: String,
+    pub erstellt_am: Time,
+    pub geaendert_am: Time,
 }

src/domain/rolle/model.rs

@@ -2,6 +2,5 @@ mod rolle;
 mod rolle_create_input;
 mod rolle_update_input;
 
-pub use rolle::Gruppe;
 pub use rolle::Rolle;
 pub use rolle_create_input::RolleCreateInput;

src/domain/rolle/model/rolle.rs

@@ -1,36 +1,33 @@
-use async_graphql::SimpleObject;
+use async_graphql::{ComplexObject, Context, FieldResult, SimpleObject};
 
-use crate::scalar::{Id, Time};
+use crate::{
+    dataloader::LoaderContext,
+    domain::gruppe::model::Gruppe,
+    scalar::{Id, Time},
+};
 
-#[derive(Debug, SimpleObject, sqlx::FromRow)]
+/// Um die Administration zu erleichtern werden Gruppen in die Rollen hinzugefuegt
+#[derive(sqlx::FromRow, SimpleObject, Debug, Clone)]
+#[graphql(complex)]
 pub struct Rolle {
-    /// Die ID einer Rolle
+    /// Die  uuid einer Rolle
     pub id: Id,
 
-    /// Zeit wann die Rolle erstellt wurde
-    pub created_at: Time,
-
-    /// Zeit wann die Rolle geändert wurde
-    pub updated_at: Time,
-
-    /// Der Name einer Rolle
+    /// Der Rollenname
     pub rollenname: String,
 
-    pub gruppen: Vec<Gruppe>,
+    /// Wann die Rolle erstellt wurde
+    pub erstellt_am: Time,
+
+    /// Wann die Rolle geaendert wurde
+    pub geaendert_am: Time,
 }
 
-/// TODO: Migration in ein separates Modul
-#[derive(Debug, SimpleObject, sqlx::Type)]
-pub struct Gruppe {
-    /// Die ID einer Gruppe
-    pub id: Id,
-
-    /// Zeit wann die Gruppe erstellt wurde
-    pub created_at: Time,
-
-    ///Zeit wann die Gruppe geändert wurde
-    pub updated_at: Time,
-
-    /// Der Name einer Gruppe
-    pub gruppenname: String,
+#[ComplexObject]
+impl Rolle {
+    /// Die Gruppen in einer Rolle
+    pub async fn gruppen<'ctx>(&self, ctx: &Context<'ctx>) -> FieldResult<Option<Vec<Gruppe>>> {
+        let loader = ctx.data::<LoaderContext>()?;
+        Ok(loader.gruppen.load_one(self.id).await?)
+    }
 }

src/domain/rolle/repository.rs

@@ -2,6 +2,7 @@ mod create_rolle;
 mod delete_rolle;
 mod find_all_rolle;
 mod find_rolle_by_id;
+mod rollen_dataloader;
 mod update_rolle;
 
 #[derive(Debug, Clone)]

src/domain/rolle/repository/create_rolle.rs

@@ -16,8 +16,8 @@ impl Repository {
 
         match sqlx::query_scalar::<_, Id>(QUERY)
             .bind(rolle.id)
-            .bind(rolle.created_at)
-            .bind(rolle.updated_at)
+            .bind(rolle.erstellt_am)
+            .bind(rolle.geaendert_am)
             .bind(&rolle.rollenname)
             .fetch_one(db)
             .await

src/domain/rolle/repository/rollen_dataloader.rs

@@ -0,0 +1,49 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use itertools::Itertools;
+
+use super::Repository;
+use crate::database::Queryer;
+use crate::domain::rolle::model::Rolle;
+use crate::scalar::Id;
+
+impl Repository {
+    pub async fn rollen_dataloader<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+        keys: &[Id],
+    ) -> Result<HashMap<Id, Vec<Rolle>>, Arc<sqlx::Error>> {
+        let rows = sqlx::query!(
+            r#"
+                SELECT
+                    br.benutzer_id,
+                    r.id,
+                    r.rollenname,
+                    r.erstellt_am,
+                    r.geaendert_am
+                FROM rollen AS r
+                LEFT JOIN benutzer_rollen AS br ON r.id = br.rolle_id
+                WHERE br.benutzer_id = ANY($1);
+            "#,
+            keys
+        )
+        .fetch_all(db)
+        .await?
+        .into_iter()
+        .map(|row| {
+            (
+                row.benutzer_id,
+                Rolle {
+                    id: row.id,
+                    rollenname: row.rollenname,
+                    erstellt_am: row.erstellt_am,
+                    geaendert_am: row.geaendert_am,
+                },
+            )
+        })
+        .into_group_map();
+
+        Ok(rows)
+    }
+}

src/domain/rolle/service/create_user.rs

@@ -16,8 +16,8 @@ impl Service {
         let rolle_input = entity::Rolle {
             id: Ulid::new().into(),
             rollenname: input.rollenname,
-            created_at: Utc::now(),
-            updated_at: Utc::now(),
+            erstellt_am: Utc::now(),
+            geaendert_am: Utc::now(),
         };
 
         let created_id = self.repo.create_rolle(&self.db, &rolle_input).await?;