From 90a88c15dc1ceadb5c534a7d2b4e75a4423256b3 Mon Sep 17 00:00:00 2001 From: Peter Date: Sun, 31 May 2026 20:37:12 +0200 Subject: [PATCH] =?UTF-8?q?kleine=20=C3=A4nderungen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/dataloader/benutzer_gruppen_kumulativ.rs | 144 +++++----- src/dataloader/benutzer_rollen.rs | 102 +++---- src/dataloader/mod.rs | 14 +- src/dataloader/rollen_gruppen.rs | 51 ---- src/domain/benutzer/model/benutzer.rs | 17 +- .../gruppe/repository/gruppe_dataloader.rs | 8 +- src/domain/gruppe/repository/gruppe_update.rs | 2 +- .../gruppe/service/gruppe_dataloader.rs | 4 +- src/domain/typ/repository.rs | 3 + src/domain/typ/repository/typ_alle.rs | 2 +- src/domain/typ/service.rs | 1 + src/models/gruppe_ansicht.rs | 6 +- src/models/mod.rs | 8 +- src/models/modell.rs | 258 +++++++++--------- src/models/typ.rs | 95 ------- src/mutations/gruppe.rs | 2 +- src/mutations/hersteller.rs | 22 +- src/mutations/mod.rs | 8 +- src/queries/hersteller.rs | 4 +- src/queries/mod.rs | 8 +- 20 files changed, 310 insertions(+), 449 deletions(-) delete mode 100644 src/dataloader/rollen_gruppen.rs delete mode 100644 src/models/typ.rs diff --git a/src/dataloader/benutzer_gruppen_kumulativ.rs b/src/dataloader/benutzer_gruppen_kumulativ.rs index b23be02..bf4d051 100644 --- a/src/dataloader/benutzer_gruppen_kumulativ.rs +++ b/src/dataloader/benutzer_gruppen_kumulativ.rs @@ -1,72 +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 for BenutzerGruppenKumulativLoader { - type Value = Vec; - type Error = Arc; - - async fn load(&self, keys: &[Id]) -> Result, 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) - } -} +// 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 for BenutzerGruppenKumulativLoader { +// type Value = Vec; +// type Error = Arc; +// +// async fn load(&self, keys: &[Id]) -> Result, 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) +// } +// } diff --git a/src/dataloader/benutzer_rollen.rs b/src/dataloader/benutzer_rollen.rs index ade87ab..75a6d80 100644 --- a/src/dataloader/benutzer_rollen.rs +++ b/src/dataloader/benutzer_rollen.rs @@ -1,51 +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 BenutzerRollenLoader { - pub pool: sqlx::PgPool, -} - -impl Loader for BenutzerRollenLoader { - type Value = Vec; - type Error = Arc; - - async fn load(&self, keys: &[Id]) -> Result, 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) - } -} +// 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 BenutzerRollenLoader { +// pub pool: sqlx::PgPool, +// } +// +// impl Loader for BenutzerRollenLoader { +// type Value = Vec; +// type Error = Arc; +// +// async fn load(&self, keys: &[Id]) -> Result, 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) +// } +// } diff --git a/src/dataloader/mod.rs b/src/dataloader/mod.rs index eade08d..68f892b 100644 --- a/src/dataloader/mod.rs +++ b/src/dataloader/mod.rs @@ -1,11 +1,10 @@ mod benutzer_gruppen_kumulativ; mod benutzer_rollen; -mod rollen_gruppen; use crate::domain::{ gruppe::dataloader::gruppen::GruppenLoader, rolle::dataloader::rollen::RollenLoader, }; -pub use benutzer_gruppen_kumulativ::BenutzerGruppenKumulativLoader; +// pub use benutzer_gruppen_kumulativ::BenutzerGruppenKumulativLoader; use async_graphql::dataloader::DataLoader; @@ -13,7 +12,7 @@ pub struct LoaderContext { pub gruppen: DataLoader, // pub benutzer_rollen: DataLoader, pub rollen: DataLoader, - pub benutzer_gruppen_kumulativ: DataLoader, + // pub benutzer_gruppen_kumulativ: DataLoader, } impl LoaderContext { @@ -21,11 +20,10 @@ impl LoaderContext { Self { gruppen: DataLoader::new(GruppenLoader { pool: pool.clone() }, tokio::spawn), rollen: DataLoader::new(RollenLoader { pool: pool.clone() }, tokio::spawn), - - benutzer_gruppen_kumulativ: DataLoader::new( - BenutzerGruppenKumulativLoader { pool: pool.clone() }, - tokio::spawn, - ), + // benutzer_gruppen_kumulativ: DataLoader::new( + // BenutzerGruppenKumulativLoader { pool: pool.clone() }, + // tokio::spawn, + // ), } } } diff --git a/src/dataloader/rollen_gruppen.rs b/src/dataloader/rollen_gruppen.rs deleted file mode 100644 index 9eba755..0000000 --- a/src/dataloader/rollen_gruppen.rs +++ /dev/null @@ -1,51 +0,0 @@ -use async_graphql::dataloader::*; -use async_graphql::*; -use itertools::Itertools; -use std::collections::HashMap; -use std::sync::Arc; - -use crate::domain::gruppe::model::Gruppe; -use crate::scalar::Id; - -pub struct RollenGruppenLoader { - pub pool: sqlx::PgPool, -} - -impl Loader for RollenGruppenLoader { - type Value = Vec; - type Error = Arc; - - async fn load(&self, keys: &[Id]) -> Result, 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) - } -} diff --git a/src/domain/benutzer/model/benutzer.rs b/src/domain/benutzer/model/benutzer.rs index fdd2292..16fa8dc 100644 --- a/src/domain/benutzer/model/benutzer.rs +++ b/src/domain/benutzer/model/benutzer.rs @@ -3,7 +3,6 @@ use async_graphql::{ComplexObject, Context, FieldResult, SimpleObject}; use crate::{ dataloader::LoaderContext, domain::{gruppe::model::Gruppe, rolle::model::Rolle}, - models::gruppe_ansicht::GruppeAnsicht, scalar::Id, }; @@ -37,12 +36,12 @@ impl Benutzer { Ok(loader.gruppen.load_one(self.id).await?) } - /// Die Gruppen eines Benutzer kumulativ mit den Gruppen aus den Rollen - pub async fn gruppen_kumulativ( - &self, - ctx: &Context<'_>, - ) -> FieldResult>> { - let loader = ctx.data::()?; - Ok(loader.benutzer_gruppen_kumulativ.load_one(self.id).await?) - } + // /// Die Gruppen eines Benutzer kumulativ mit den Gruppen aus den Rollen + // pub async fn gruppen_kumulativ( + // &self, + // ctx: &Context<'_>, + // ) -> FieldResult>> { + // let loader = ctx.data::()?; + // Ok(loader.benutzer_gruppen_kumulativ.load_one(self.id).await?) + // } } diff --git a/src/domain/gruppe/repository/gruppe_dataloader.rs b/src/domain/gruppe/repository/gruppe_dataloader.rs index 7484159..55ce765 100644 --- a/src/domain/gruppe/repository/gruppe_dataloader.rs +++ b/src/domain/gruppe/repository/gruppe_dataloader.rs @@ -17,14 +17,14 @@ impl Repository { let rows = sqlx::query!( r#" SELECT - bg.benutzer_id, + rg.rolle_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); + LEFT JOIN rollen_gruppen AS rg ON g.id = rg.gruppe_id + WHERE rg.rolle_id = ANY($1); "#, keys ) @@ -33,7 +33,7 @@ impl Repository { .into_iter() .map(|row| { ( - row.benutzer_id, + row.rolle_id, Gruppe { id: row.id, gruppenname: row.gruppenname, diff --git a/src/domain/gruppe/repository/gruppe_update.rs b/src/domain/gruppe/repository/gruppe_update.rs index bd6f001..617091d 100644 --- a/src/domain/gruppe/repository/gruppe_update.rs +++ b/src/domain/gruppe/repository/gruppe_update.rs @@ -13,7 +13,7 @@ impl Repository { const QUERY: &str = r#" UPDATE gruppen SET geaendert_am = $2, ruppenname = $3 WHERE gruppeid = $1 - RETURNING id, geaendert_am, gruppenname, gruppenname; + RETURNING id, geaendert_am, erstellt_am, gruppenname; "#; let gruppe = sqlx::query_as::<_, model::Gruppe>(QUERY) diff --git a/src/domain/gruppe/service/gruppe_dataloader.rs b/src/domain/gruppe/service/gruppe_dataloader.rs index 4b18ac5..2773868 100644 --- a/src/domain/gruppe/service/gruppe_dataloader.rs +++ b/src/domain/gruppe/service/gruppe_dataloader.rs @@ -9,7 +9,7 @@ impl Service { &self, keys: &[Id], ) -> Result>, Arc> { - let grupen_dataloader = self.repo.gruppe_dataloader(&self.db, keys).await?; - Ok(grupen_dataloader) + let gruppen_dataloader = self.repo.gruppe_dataloader(&self.db, keys).await?; + Ok(gruppen_dataloader) } } diff --git a/src/domain/typ/repository.rs b/src/domain/typ/repository.rs index f5a110c..7f9f601 100644 --- a/src/domain/typ/repository.rs +++ b/src/domain/typ/repository.rs @@ -1,4 +1,7 @@ mod typ_alle; +mod typ_dataloader; +mod typ_einen_zeigen; +mod typ_erstelle_viele; mod typ_erstellen; mod typ_loeschen; mod typ_update; diff --git a/src/domain/typ/repository/typ_alle.rs b/src/domain/typ/repository/typ_alle.rs index 3fb2780..6bd68fb 100644 --- a/src/domain/typ/repository/typ_alle.rs +++ b/src/domain/typ/repository/typ_alle.rs @@ -6,7 +6,7 @@ use crate::{database::Queryer, domain::typ::model}; impl Repository { pub async fn typ_alle<'c, C: Queryer<'c>>(&self, db: C) -> Result, Error> { const QUERY: &str = r#" - SELECT * FROM typen + SELECT id, erstellt_am, geaendert_am, typname FROM typen "#; let typen = sqlx::query_as::<_, model::Typ>(QUERY).fetch_all(db).await?; diff --git a/src/domain/typ/service.rs b/src/domain/typ/service.rs index be650e1..ef93518 100644 --- a/src/domain/typ/service.rs +++ b/src/domain/typ/service.rs @@ -1,6 +1,7 @@ mod typ_alle; // mod typ_dataloader; mod typ_erstellen; +mod typ_erstellen_viele; mod typ_loeschen; mod typ_update; diff --git a/src/models/gruppe_ansicht.rs b/src/models/gruppe_ansicht.rs index 1e2006f..72f3d29 100644 --- a/src/models/gruppe_ansicht.rs +++ b/src/models/gruppe_ansicht.rs @@ -3,7 +3,7 @@ use sqlx::Type; use crate::scalar::{Id, Time}; -/// Aus welcher Quille die Gruppe stammt. +/// Aus welcher Quelle die Gruppe stammt. #[derive(Enum, Clone, Debug, Eq, Copy, PartialEq, Type)] #[sqlx(type_name = "gruppen_herkunft", rename_all = "lowercase")] pub enum Herkunft { @@ -39,5 +39,5 @@ pub struct GruppeAnsicht { pub geaendert_am: Time, } -#[ComplexObject] -impl GruppeAnsicht {} +// #[ComplexObject] +// impl GruppeAnsicht {} diff --git a/src/models/mod.rs b/src/models/mod.rs index 6736873..58ac041 100644 --- a/src/models/mod.rs +++ b/src/models/mod.rs @@ -1,4 +1,4 @@ -pub mod gruppe_ansicht; -pub mod hersteller; -pub mod modell; -pub mod typ; +// pub mod gruppe_ansicht; +// pub mod hersteller; +// pub mod modell; +// pub mod typ; diff --git a/src/models/modell.rs b/src/models/modell.rs index 319b7a2..bb31f76 100644 --- a/src/models/modell.rs +++ b/src/models/modell.rs @@ -1,129 +1,129 @@ -use anyhow::Result; -use async_graphql::{InputObject, SimpleObject}; -use serde::{Deserialize, Serialize}; -use sqlx::{FromRow, PgPool}; -use ulid::Ulid; -use uuid::Uuid; - -use crate::scalar::Id; - -use super::{hersteller::Hersteller, typ::Typ}; - -#[derive(SimpleObject, FromRow, Deserialize, Serialize, Debug)] -pub struct Modell { - /// Die Datenbank-ID - pub id: Id, - - /// Der Geräte-Typ z.B. Monitor - typ: Typ, - - /// Der Geräte-Hersteller z.B. Dell - hersteller: Hersteller, - - /// Der Name eines Modells - modellname: String, -} - -#[derive(InputObject, Debug)] -pub struct ModellCreateInput { - /// Der Name eines Modells - pub modellname: String, - - /// Die Id eines Geräte-Typs z.B. Monitor - pub typ_id: Id, - - /// Die Id eines Geräte-Herstellers z.B. Dell - pub hersteller_id: Id, -} - -#[derive(InputObject, Debug)] -pub struct ModellUpdateInput { - pub id: Id, - pub modellname: Option, - pub typ_id: Option, - pub hersteller_id: Option, -} - -impl Modell { - pub async fn read_one(pool: &PgPool, id: &Id) -> Result { - let row = sqlx::query_as!( - Modell, - r#" - SELECT - m.id, - m.modellname, - (t.id, t.typname) AS "typ!: Typ", - (h.id, h.herstellername) AS "hersteller!: Hersteller" - FROM modelle AS m - JOIN typen AS t ON t.id = m.typ_id - JOIN hersteller AS h ON h.id = m.hersteller_id - WHERE m.id = $1; - "#, - id - ) - .fetch_one(pool) - .await?; - - Ok(row) - } - - pub async fn read_all(pool: &PgPool) -> Result> { - let row = sqlx::query_as!( - Modell, - r#" - SELECT - m.id, - m.modellname, - (t.id, t.typname) AS "typ!: Typ", - (h.id, h.herstellername) AS "hersteller!: Hersteller" - FROM modelle AS m - LEFT JOIN typen AS t ON t.id = m.typ_id - LEFT JOIN hersteller AS h ON h.id = m.hersteller_id - "# - ) - .fetch_all(pool) - .await?; - - Ok(row) - } - - pub async fn create(pool: &PgPool, input: &ModellCreateInput) -> Result { - const QUERY: &str = "INSERT INTO modelle (id, typ_id, hersteller_id, modellname) VALUES ($1, $2, $3, $4) RETURNING id"; - - let row: (Uuid,) = sqlx::query_as(QUERY) - .bind::(Ulid::new().into()) - .bind(input.typ_id) - .bind(input.hersteller_id) - .bind(&input.modellname) - .fetch_one(pool) - .await?; - - let modell = Modell::read_one(pool, &row.0).await?; - - Ok(modell) - } - - pub async fn update(pool: &PgPool, input: &ModellUpdateInput) -> Result { - sqlx::query!( - "UPDATE modelle SET modellname=COALESCE($1, modellname), typ_id=COALESCE($2, typ_id), hersteller_id=COALESCE($3, hersteller_id) WHERE id = $4", - input.modellname, - input.typ_id, - input.hersteller_id, - input.id - ) - .execute(pool) - .await?; - - let t = Modell::read_one(pool, &input.id).await?; - - Ok(t) - } - - pub async fn delete(pool: &PgPool, id: &Id) -> Result { - let result = sqlx::query!("DELETE FROM modelle WHERE id = $1", id) - .execute(pool) - .await?; - - Ok(result.rows_affected() > 0) - } -} +// use anyhow::Result; +// use async_graphql::{InputObject, SimpleObject}; +// use serde::{Deserialize, Serialize}; +// use sqlx::{FromRow, PgPool}; +// use ulid::Ulid; +// use uuid::Uuid; +// +// use crate::scalar::Id; +// +// use super::{hersteller::Hersteller, typ::Typ}; +// +// #[derive(SimpleObject, FromRow, Deserialize, Serialize, Debug)] +// pub struct Modell { +// /// Die Datenbank-ID +// pub id: Id, +// +// /// Der Geräte-Typ z.B. Monitor +// typ: Typ, +// +// /// Der Geräte-Hersteller z.B. Dell +// hersteller: Hersteller, +// +// /// Der Name eines Modells +// modellname: String, +// } +// +// #[derive(InputObject, Debug)] +// pub struct ModellCreateInput { +// /// Der Name eines Modells +// pub modellname: String, +// +// /// Die Id eines Geräte-Typs z.B. Monitor +// pub typ_id: Id, +// +// /// Die Id eines Geräte-Herstellers z.B. Dell +// pub hersteller_id: Id, +// } +// +// #[derive(InputObject, Debug)] +// pub struct ModellUpdateInput { +// pub id: Id, +// pub modellname: Option, +// pub typ_id: Option, +// pub hersteller_id: Option, +// } +// +// impl Modell { +// pub async fn read_one(pool: &PgPool, id: &Id) -> Result { +// let row = sqlx::query_as!( +// Modell, +// r#" +// SELECT +// m.id, +// m.modellname, +// (t.id, t.typname) AS "typ!: Typ", +// (h.id, h.herstellername) AS "hersteller!: Hersteller" +// FROM modelle AS m +// JOIN typen AS t ON t.id = m.typ_id +// JOIN hersteller AS h ON h.id = m.hersteller_id +// WHERE m.id = $1; +// "#, +// id +// ) +// .fetch_one(pool) +// .await?; +// +// Ok(row) +// } +// +// pub async fn read_all(pool: &PgPool) -> Result> { +// let row = sqlx::query_as!( +// Modell, +// r#" +// SELECT +// m.id, +// m.modellname, +// (t.id, t.typname) AS "typ!: Typ", +// (h.id, h.herstellername) AS "hersteller!: Hersteller" +// FROM modelle AS m +// LEFT JOIN typen AS t ON t.id = m.typ_id +// LEFT JOIN hersteller AS h ON h.id = m.hersteller_id +// "# +// ) +// .fetch_all(pool) +// .await?; +// +// Ok(row) +// } +// +// pub async fn create(pool: &PgPool, input: &ModellCreateInput) -> Result { +// const QUERY: &str = "INSERT INTO modelle (id, typ_id, hersteller_id, modellname) VALUES ($1, $2, $3, $4) RETURNING id"; +// +// let row: (Uuid,) = sqlx::query_as(QUERY) +// .bind::(Ulid::new().into()) +// .bind(input.typ_id) +// .bind(input.hersteller_id) +// .bind(&input.modellname) +// .fetch_one(pool) +// .await?; +// +// let modell = Modell::read_one(pool, &row.0).await?; +// +// Ok(modell) +// } +// +// pub async fn update(pool: &PgPool, input: &ModellUpdateInput) -> Result { +// sqlx::query!( +// "UPDATE modelle SET modellname=COALESCE($1, modellname), typ_id=COALESCE($2, typ_id), hersteller_id=COALESCE($3, hersteller_id) WHERE id = $4", +// input.modellname, +// input.typ_id, +// input.hersteller_id, +// input.id +// ) +// .execute(pool) +// .await?; +// +// let t = Modell::read_one(pool, &input.id).await?; +// +// Ok(t) +// } +// +// pub async fn delete(pool: &PgPool, id: &Id) -> Result { +// let result = sqlx::query!("DELETE FROM modelle WHERE id = $1", id) +// .execute(pool) +// .await?; +// +// Ok(result.rows_affected() > 0) +// } +// } diff --git a/src/models/typ.rs b/src/models/typ.rs deleted file mode 100644 index 97bb863..0000000 --- a/src/models/typ.rs +++ /dev/null @@ -1,95 +0,0 @@ -use anyhow::Result; -use async_graphql::{InputObject, SimpleObject}; -use serde::{Deserialize, Serialize}; -use sqlx::{FromRow, PgPool, Type}; -use ulid::Ulid; - -use crate::scalar::Id; - -#[derive(SimpleObject, Debug, FromRow, Deserialize, Serialize, Type)] -pub struct Typ { - /// Die ID eines Geräte-Typs - pub id: Id, - - /// Der Name eines Geräte-Typs - pub typname: String, -} - -#[derive(InputObject, Debug)] -pub struct TypCreateInput { - pub typname: String, -} - -#[derive(InputObject, Debug)] -pub struct TypUpdateInput { - pub id: Id, - pub typname: Option, -} - -impl Typ { - pub async fn read_one(pool: &PgPool, id: &Id) -> Result { - const QUERY: &str = "SELECT * FROM typen WHERE id = $1"; - let row: Typ = sqlx::query_as(QUERY).bind(id).fetch_one(pool).await?; - - Ok(row) - } - - pub async fn read_all(pool: &PgPool) -> Result> { - let rows = sqlx::query_as!(Typ, "SELECT id, typname FROM typen") - .fetch_all(pool) - .await?; - - Ok(rows) - } - - pub async fn create(pool: &PgPool, input: &TypCreateInput) -> Result { - const QUERY: &str = "INSERT INTO typen (id, typname) VALUES ($1, $2) RETURNING id, typname"; - - let result: Typ = sqlx::query_as::<_, Typ>(QUERY) - .bind::(Ulid::new().into()) - .bind(&input.typname) - .fetch_one(pool) - .await?; - - Ok(result) - } - - pub async fn create_many(pool: &PgPool, input: &[TypCreateInput]) -> Result> { - let mut v1: Vec<&str> = Vec::new(); - input.iter().for_each(|typ| v1.push(&typ.typname)); - - let row = sqlx::query_as!( - Typ, - r#" - INSERT INTO typen(typname) - SELECT * FROM UNNEST($1::text[]) - RETURNING id, typname"#, - &v1 as _ - ) - .fetch_all(pool) - .await?; - - Ok(row) - } - - pub async fn update(pool: &PgPool, input: &TypUpdateInput) -> Result { - sqlx::query!( - "UPDATE typen SET typname=$1 WHERE id = $2", - input.typname, - input.id - ) - .execute(pool) - .await?; - - let t = Typ::read_one(pool, &input.id).await?; - Ok(t) - } - - pub async fn delete(pool: &PgPool, id: &Id) -> Result { - let result = sqlx::query!("DELETE FROM typen WHERE id = $1", id) - .execute(pool) - .await?; - - Ok(result.rows_affected() > 0) - } -} diff --git a/src/mutations/gruppe.rs b/src/mutations/gruppe.rs index fb43a53..ec0ebc8 100644 --- a/src/mutations/gruppe.rs +++ b/src/mutations/gruppe.rs @@ -10,7 +10,7 @@ pub struct GruppeMutation; #[async_graphql::Object] impl GruppeMutation { - async fn erselle_gruppe( + async fn erstelle_gruppe( &self, ctx: &Context<'_>, input: GruppeErstelleInput, diff --git a/src/mutations/hersteller.rs b/src/mutations/hersteller.rs index 82d18e8..0075d2d 100644 --- a/src/mutations/hersteller.rs +++ b/src/mutations/hersteller.rs @@ -1,7 +1,4 @@ -use crate::{ - models::hersteller::{Hersteller, HerstellerCreateInput, HerstellerUpdateInput}, - scalar::Id, -}; +use crate::models::hersteller::{Hersteller, HerstellerCreateInput, HerstellerUpdateInput}; use async_graphql::{Context, FieldResult}; use sqlx::postgres::PgPool; @@ -16,6 +13,9 @@ impl HerstellerMutation { input: HerstellerCreateInput, ) -> FieldResult { let pool = ctx.data::()?; + let row = Service::new(pool.clone()) + .hersteller_erstellen(input) + .await?; let row = Hersteller::create(pool, &input).await?; Ok(row) } @@ -26,12 +26,20 @@ impl HerstellerMutation { input: HerstellerUpdateInput, ) -> FieldResult { let pool = ctx.data::()?; - let row = Hersteller::update(pool, &input).await?; + let row = Service::new(pool.clone()).hersteller_update(input).await?; Ok(row) } - async fn delete_hersteller(&self, ctx: &Context<'_>, id: Id) -> FieldResult { + async fn delete_hersteller( + &self, + ctx: &Context<'_>, + input: HerstellerLoeschenInputen, + ) -> FieldResult { let pool = ctx.data::()?; - Ok(Hersteller::delete(pool, &id).await?) + + let row = Service::new(pool.clone()) + .hersteller_loeschen(input) + .await?; + Ok(row) } } diff --git a/src/mutations/mod.rs b/src/mutations/mod.rs index 2216a08..5d4dc5f 100644 --- a/src/mutations/mod.rs +++ b/src/mutations/mod.rs @@ -1,7 +1,7 @@ pub mod benutzer; pub mod gruppe; -pub mod hersteller; -pub mod modell; +// pub mod hersteller; +// pub mod modell; pub mod rolle; pub mod typ; @@ -10,8 +10,8 @@ use async_graphql::MergedObject; #[derive(MergedObject, Default)] pub struct Mutation( typ::TypMutation, - hersteller::HerstellerMutation, - modell::ModellMutation, + // hersteller::HerstellerMutation, + // modell::ModellMutation, benutzer::BenutzerMutation, gruppe::GruppeMutation, rolle::RolleMutation, diff --git a/src/queries/hersteller.rs b/src/queries/hersteller.rs index 0c00c00..b761d46 100644 --- a/src/queries/hersteller.rs +++ b/src/queries/hersteller.rs @@ -1,8 +1,6 @@ use async_graphql::{Context, FieldResult, Object}; use sqlx::postgres::PgPool; -use crate::models::hersteller::Hersteller; - #[derive(Default)] pub struct HerstellerQuery {} @@ -16,7 +14,7 @@ impl HerstellerQuery { async fn alle_hersteller(&self, ctx: &Context<'_>) -> FieldResult> { let pool = ctx.data::()?; - let rows = Hersteller::read_all(pool).await?; + let rows = Service::new(pool.clone()).gruppe_alle().await?; Ok(rows) } } diff --git a/src/queries/mod.rs b/src/queries/mod.rs index 5e57679..b384ab7 100644 --- a/src/queries/mod.rs +++ b/src/queries/mod.rs @@ -1,7 +1,7 @@ pub mod benutzer; pub mod gruppe; -pub mod hersteller; -pub mod modell; +// pub mod hersteller; +// pub mod modell; pub mod rolle; pub mod typ; @@ -10,8 +10,8 @@ use async_graphql::MergedObject; #[derive(MergedObject, Default)] pub struct Query( typ::TypQuery, - modell::ModellQuery, - hersteller::HerstellerQuery, + // modell::ModellQuery, + // hersteller::HerstellerQuery, benutzer::BenutzerQuery, rolle::RolleQuery, gruppe::GruppeQuery,