Dataloader für BenutzerGruppen und BenutzerRollen hinzugefügt

src/dataloader/benutzer_gruppen.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::models::gruppe::Gruppe;
+use crate::scalar::Id;
+
+pub struct BenutzerGruppenLoader {
+    pub pool: sqlx::PgPool,
+}
+
+impl Loader<Id> for BenutzerGruppenLoader {
+    type Value = Vec<Gruppe>;
+    type Error = Arc<sqlx::Error>;
+
+    async fn load(&self, keys: &[Id]) -> Result<HashMap<Id, Self::Value>, Self::Error> {
+        let rows = sqlx::query!(
+            r#"
+                SELECT
+                    bg.benutzer_id, 
+                    g.id, 
+                    g.gruppenname, 
+                    g.erstellt_am, 
+                    g.geaendert_am 
+                FROM gruppen AS g
+                LEFT JOIN benutzer_gruppen AS bg ON g.id = bg.gruppe_id
+                WHERE bg.benutzer_id = ANY($1);
+            "#,
+            keys
+        )
+        .fetch_all(&self.pool)
+        .await?
+        .into_iter()
+        .map(|row| {
+            (
+                row.benutzer_id,
+                Gruppe {
+                    id: row.id,
+                    gruppenname: row.gruppenname,
+                    erstellt_am: row.erstellt_am,
+                    geaendert_am: row.geaendert_am,
+                },
+            )
+        })
+        .into_group_map();
+
+        Ok(rows)
+    }
+}

src/dataloader/benutzer_gruppen_kumulativ.rs

@@ -0,0 +1,72 @@
+use async_graphql::dataloader::*;
+use async_graphql::*;
+use itertools::Itertools;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use crate::models::gruppe_ansicht::{GruppeAnsicht, Herkunft};
+use crate::scalar::Id;
+
+pub struct BenutzerGruppenKumulativLoader {
+    pub pool: sqlx::PgPool,
+}
+
+impl Loader<Id> for BenutzerGruppenKumulativLoader {
+    type Value = Vec<GruppeAnsicht>;
+    type Error = Arc<sqlx::Error>;
+
+    async fn load(&self, keys: &[Id]) -> Result<HashMap<Id, Self::Value>, Self::Error> {
+        let rows = sqlx::query!(
+            r#"
+                SELECT DISTINCT
+                    COALESCE(bg.benutzer_id, br.benutzer_id) AS benutzer_id,
+                    g.id AS gruppe_id,
+                    g.gruppenname,
+                    g.erstellt_am,
+                    g.geaendert_am,
+                    CASE WHEN br.benutzer_id IS NOT null THEN r.rollenname END AS rollenname,
+                    CASE 
+                        WHEN bg.benutzer_id IS NOT NULL AND br.benutzer_id IS NOT NULL THEN 'beides'::gruppen_herkunft 
+                        WHEN bg.benutzer_id IS NOT NULL THEN 'direkt'::gruppen_herkunft
+                        WHEN br.benutzer_id IS NOT NULL THEN 'indirekt'::gruppen_herkunft 
+                    END AS "herkunft: Herkunft"
+                FROM gruppen AS g
+                LEFT JOIN
+                    benutzer_gruppen AS bg
+                    ON
+                        g.id = bg.gruppe_id
+                        AND bg.benutzer_id = ANY($1) 
+                LEFT JOIN rollen_gruppen AS rg ON g.id = rg.gruppe_id
+                LEFT JOIN
+                    benutzer_rollen AS br
+                    ON
+                        rg.rolle_id = br.rolle_id
+                        AND br.benutzer_id = ANY($1) 
+                LEFT JOIN rollen AS r ON rg.rolle_id = r.id
+                WHERE
+                    bg.benutzer_id = ANY($1) 
+                    OR br.benutzer_id = ANY($1); 
+            "#,
+            keys
+        )
+        .fetch_all(&self.pool)
+        .await?
+        .into_iter()
+        .map(|row| {
+            (
+                row.benutzer_id.unwrap(),
+                GruppeAnsicht {
+                    id: row.gruppe_id,
+                    gruppenname: row.gruppenname,
+                    rollenname: row.rollenname,
+                    herkunft: row.herkunft.unwrap(),
+                    erstellt_am: row.erstellt_am,
+                    geaendert_am: row.geaendert_am,
+                },
+            )
+        })
+        .into_group_map();
+
+        Ok(rows)
+    }
+}

src/dataloader/benutzer_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::models::rolle::Rolle;
+use crate::scalar::Id;
+
+pub struct BenutzerRollenLoader {
+    pub pool: sqlx::PgPool,
+}
+
+impl Loader<Id> for BenutzerRollenLoader {
+    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/dataloader/mod.rs

@@ -0,0 +1,41 @@
+mod benutzer_gruppen;
+mod benutzer_gruppen_kumulativ;
+mod benutzer_rollen;
+mod rollen_gruppen;
+
+pub use benutzer_gruppen::BenutzerGruppenLoader;
+pub use benutzer_gruppen_kumulativ::BenutzerGruppenKumulativLoader;
+pub use benutzer_rollen::BenutzerRollenLoader;
+pub use rollen_gruppen::RollenGruppenLoader;
+
+use async_graphql::dataloader::DataLoader;
+
+pub struct LoaderContext {
+    pub benutzer_gruppen: DataLoader<BenutzerGruppenLoader>,
+    pub benutzer_rollen: DataLoader<BenutzerRollenLoader>,
+    pub rollen_gruppen: DataLoader<RollenGruppenLoader>,
+    pub benutzer_gruppen_kumulativ: DataLoader<BenutzerGruppenKumulativLoader>,
+}
+
+impl LoaderContext {
+    pub fn new(pool: sqlx::PgPool) -> Self {
+        Self {
+            benutzer_gruppen: DataLoader::new(
+                BenutzerGruppenLoader { pool: pool.clone() },
+                tokio::spawn,
+            ),
+            benutzer_rollen: DataLoader::new(
+                BenutzerRollenLoader { pool: pool.clone() },
+                tokio::spawn,
+            ),
+            rollen_gruppen: DataLoader::new(
+                RollenGruppenLoader { pool: pool.clone() },
+                tokio::spawn,
+            ),
+            benutzer_gruppen_kumulativ: DataLoader::new(
+                BenutzerGruppenKumulativLoader { pool: pool.clone() },
+                tokio::spawn,
+            ),
+        }
+    }
+}

src/dataloader/rollen_gruppen.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::models::gruppe::Gruppe;
+use crate::scalar::Id;
+
+pub struct RollenGruppenLoader {
+    pub pool: sqlx::PgPool,
+}
+
+impl Loader<Id> for RollenGruppenLoader {
+    type Value = Vec<Gruppe>;
+    type Error = Arc<sqlx::Error>;
+
+    async fn load(&self, keys: &[Id]) -> Result<HashMap<Id, Self::Value>, Self::Error> {
+        let rows = sqlx::query!(
+            r#"
+                SELECT
+                    rg.rolle_id, 
+                    g.id, 
+                    g.gruppenname, 
+                    g.erstellt_am, 
+                    g.geaendert_am 
+                FROM gruppen AS g
+                LEFT JOIN rollen_gruppen AS rg ON g.id = rg.gruppe_id
+                WHERE rg.rolle_id = ANY($1);
+            "#,
+            keys
+        )
+        .fetch_all(&self.pool)
+        .await?
+        .into_iter()
+        .map(|row| {
+            (
+                row.rolle_id,
+                Gruppe {
+                    id: row.id,
+                    gruppenname: row.gruppenname,
+                    erstellt_am: row.erstellt_am,
+                    geaendert_am: row.geaendert_am,
+                },
+            )
+        })
+        .into_group_map();
+
+        Ok(rows)
+    }
+}