rollen muations und rolle_viele_erstellen

src/domain/rolle.rs

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

src/domain/rolle/mutation.rs

@@ -0,0 +1,3 @@
+pub mod rolle;
+
+pub use rolle::RolleMutation;

src/domain/rolle/mutation/rolle.rs

@@ -2,6 +2,7 @@ use crate::domain::rolle::{
     model::{Rolle, RolleErstelleInput, RolleLoeschenInput, RolleUpdateInput},
     service::Service,
 };
+
 use async_graphql::{Context, FieldResult};
 use sqlx::postgres::PgPool;
 
@@ -21,6 +22,17 @@ impl RolleMutation {
         Ok(gruppe)
     }
 
+    async fn erstelle_viele_rollen(
+        &self,
+        ctx: &Context<'_>,
+        input: Vec<RolleErstelleInput>,
+    ) -> FieldResult<Vec<Rolle>> {
+        let pool = ctx.data::<PgPool>()?.clone();
+
+        let typen = Service::new(pool).rolle_erstellen_viele(&input).await?;
+        Ok(typen)
+    }
+
     async fn update_rolle(&self, ctx: &Context<'_>, input: RolleUpdateInput) -> FieldResult<Rolle> {
         let pool = ctx.data::<PgPool>()?;
 

src/domain/rolle/repository.rs

@@ -2,6 +2,7 @@ mod find_all_rolle;
 mod find_rolle_by_id;
 mod rolle_alle;
 mod rolle_dataloader;
+mod rolle_erstelle_viele;
 mod rolle_erstellen;
 mod rolle_loeschen;
 mod rolle_update;

src/domain/rolle/repository/rolle_erstelle_viele.rs

@@ -0,0 +1,43 @@
+use anyhow::Error;
+
+use super::Repository;
+use crate::database::Queryer;
+use crate::domain::rolle::entity;
+use crate::domain::rolle::model::{self};
+use crate::scalar::{Id, Time, Ulid};
+
+impl Repository {
+    pub async fn rolle_viele_erstellen<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+        rollen: &[entity::RolleErstellen],
+    ) -> Result<Vec<model::Rolle>, Error> {
+        let rolle_id: Vec<Id> = rollen.iter().map(|t| t.rolle_id).collect();
+        let id: Vec<Ulid> = rollen.iter().map(|t| t.id).collect();
+        let rollenname: Vec<String> = rollen.iter().map(|t| t.rollenname.clone()).collect();
+        let erstellt_am: Vec<Time> = rollen.iter().map(|t| t.erstellt_am).collect();
+        let geaendert_am: Vec<Time> = rollen.iter().map(|t| t.geaendert_am).collect();
+
+        const QUERY: &str = r#"
+            INSERT INTO rollen (rolle_id, id, rollenname, erstellt_am, geaendert_am)
+            SELECT * FROM UNNEST(
+                $1::uuid[],
+                $2::text[],
+                $3::text[],
+                $4::TIMESTAMP[],
+                $5::TIMESTAMP[]
+            ) RETURNING id, rollenname, erstellt_am, geaendert_am;
+        "#;
+
+        let typen = sqlx::query_as::<_, model::Rolle>(QUERY)
+            .bind(rolle_id)
+            .bind(id)
+            .bind(rollenname)
+            .bind(erstellt_am)
+            .bind(geaendert_am)
+            .fetch_all(db)
+            .await?;
+
+        Ok(typen)
+    }
+}

src/domain/rolle/service.rs

@@ -1,6 +1,7 @@
 mod rolle_alle;
 mod rolle_dataloader;
 mod rolle_erstellen;
+mod rolle_erstellen_viele;
 mod rolle_loeschen;
 mod rolle_update;
 

src/domain/rolle/service/rolle_erstellen_viele.rs

@@ -0,0 +1,36 @@
+use anyhow::Error;
+use chrono::Utc;
+
+use super::Service;
+use crate::{
+    domain::rolle::{
+        entity,
+        model::{self, RolleErstelleInput},
+    },
+    scalar::Ulid,
+};
+
+impl Service {
+    pub async fn rolle_erstellen_viele(
+        &self,
+        input: &[RolleErstelleInput],
+    ) -> Result<Vec<model::Rolle>, Error> {
+        let rollen_erstellen: Vec<entity::RolleErstellen> = input
+            .iter()
+            .map(|t| entity::RolleErstellen {
+                rolle_id: ulid::Ulid::new().into(),
+                id: Ulid(ulid::Ulid::new()),
+                rollenname: t.rollenname.clone(),
+                erstellt_am: Utc::now(),
+                geaendert_am: Utc::now(),
+            })
+            .collect();
+
+        let typen = self
+            .repo
+            .rolle_viele_erstellen(&self.db, &rollen_erstellen)
+            .await?;
+
+        Ok(typen)
+    }
+}

src/mutations/mod.rs

@@ -3,11 +3,10 @@ pub mod gruppe;
 // pub mod hersteller;
 // pub mod modell;
 pub mod liegenschaft;
-pub mod rolle;
 
 use async_graphql::MergedObject;
 
-use crate::domain::typ::mutation::TypMutation;
+use crate::domain::{rolle::mutation::rolle, typ::mutation::TypMutation};
 
 #[derive(MergedObject, Default)]
 pub struct Mutation(

src/queries/mod.rs

@@ -17,5 +17,4 @@ pub struct Query(
     rolle::RolleQuery,
     gruppe::GruppeQuery,
     liegenschaft::LiegenschaftQuery, // modell::ModellQuery,
-                                     // hersteller::HerstellerQuery,
 );

src/scalar.rs

@@ -63,4 +63,8 @@ impl PgHasArrayType for Ulid {
     fn array_type_info() -> PgTypeInfo {
         <String as PgHasArrayType>::array_type_info()
     }
+
+    fn array_compatible(ty: &PgTypeInfo) -> bool {
+        <String as PgHasArrayType>::array_compatible(ty)
+    }
 }