Peter/axum-async-graphql
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

kleine änderungen

Browse Source
This commit is contained in:
Peter
2026-05-31 20:37:12 +02:00
parent a1e8d34210
commit 90a88c15dc
20 changed files with 310 additions and 449 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
src/dataloader/benutzer_gruppen_kumulativ.rs
View File

@@ -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<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)
}
}
// 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)
// }
// }

102
src/dataloader/benutzer_rollen.rs
View File

@@ -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<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)
}
}
// 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<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)
// }
// }

14
src/dataloader/mod.rs
View File

@@ -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<GruppenLoader>,
// pub benutzer_rollen: DataLoader<BenutzerRollenLoader>,
pub rollen: DataLoader<RollenLoader>,
pub benutzer_gruppen_kumulativ: DataLoader<BenutzerGruppenKumulativLoader>,
// pub benutzer_gruppen_kumulativ: DataLoader<BenutzerGruppenKumulativLoader>,
}
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,
// ),
}
}
}

51
src/dataloader/rollen_gruppen.rs
View File

@@ -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<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)
}
}

17
src/domain/benutzer/model/benutzer.rs
View File

@@ -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<Option<Vec<GruppeAnsicht>>> {
let loader = ctx.data::<LoaderContext>()?;
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<Option<Vec<GruppeAnsicht>>> {
// let loader = ctx.data::<LoaderContext>()?;
// Ok(loader.benutzer_gruppen_kumulativ.load_one(self.id).await?)
// }
}

8
src/domain/gruppe/repository/gruppe_dataloader.rs
View File

@@ -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,

2
src/domain/gruppe/repository/gruppe_update.rs
View File

@@ -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)

4
src/domain/gruppe/service/gruppe_dataloader.rs
View File

@@ -9,7 +9,7 @@ impl Service {
&self,
keys: &[Id],
) -> Result<HashMap<Id, Vec<Gruppe>>, Arc<sqlx::Error>> {
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)
}
}

3
src/domain/typ/repository.rs
View File

@@ -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;

2
src/domain/typ/repository/typ_alle.rs
View File

@@ -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<Vec<model::Typ>, 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?;

1
src/domain/typ/service.rs
View File

@@ -1,6 +1,7 @@
mod typ_alle;
// mod typ_dataloader;
mod typ_erstellen;
mod typ_erstellen_viele;
mod typ_loeschen;
mod typ_update;

6
src/models/gruppe_ansicht.rs
View File

@@ -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 {}

8
src/models/mod.rs
View File

@@ -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;

258
src/models/modell.rs
View File

@@ -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<String>,
pub typ_id: Option<Id>,
pub hersteller_id: Option<Id>,
}
impl Modell {
pub async fn read_one(pool: &PgPool, id: &Id) -> Result<Modell> {
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<Vec<Modell>> {
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<Modell> {
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::<Id>(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<Modell> {
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<bool> {
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<String>,
// pub typ_id: Option<Id>,
// pub hersteller_id: Option<Id>,
// }
//
// impl Modell {
// pub async fn read_one(pool: &PgPool, id: &Id) -> Result<Modell> {
// 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<Vec<Modell>> {
// 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<Modell> {
// 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::<Id>(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<Modell> {
// 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<bool> {
// let result = sqlx::query!("DELETE FROM modelle WHERE id = $1", id)
// .execute(pool)
// .await?;
//
// Ok(result.rows_affected() > 0)
// }
// }

95
src/models/typ.rs
View File

@@ -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<String>,
}
impl Typ {
pub async fn read_one(pool: &PgPool, id: &Id) -> Result<Typ> {
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<Vec<Typ>> {
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<Typ> {
const QUERY: &str = "INSERT INTO typen (id, typname) VALUES ($1, $2) RETURNING id, typname";
let result: Typ = sqlx::query_as::<_, Typ>(QUERY)
.bind::<Id>(Ulid::new().into())
.bind(&input.typname)
.fetch_one(pool)
.await?;
Ok(result)
}
pub async fn create_many(pool: &PgPool, input: &[TypCreateInput]) -> Result<Vec<Typ>> {
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<Typ> {
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<bool> {
let result = sqlx::query!("DELETE FROM typen WHERE id = $1", id)
.execute(pool)
.await?;
Ok(result.rows_affected() > 0)
}
}

2
src/mutations/gruppe.rs
View File

@@ -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,

22
src/mutations/hersteller.rs
View File

@@ -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<Hersteller> {
let pool = ctx.data::<PgPool>()?;
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<Hersteller> {
let pool = ctx.data::<PgPool>()?;
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<bool> {
async fn delete_hersteller(
&self,
ctx: &Context<'_>,
input: HerstellerLoeschenInputen,
) -> FieldResult<bool> {
let pool = ctx.data::<PgPool>()?;
Ok(Hersteller::delete(pool, &id).await?)
let row = Service::new(pool.clone())
.hersteller_loeschen(input)
.await?;
Ok(row)
}
}

8
src/mutations/mod.rs
View File

@@ -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,

4
src/queries/hersteller.rs
View File

@@ -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<Vec<Hersteller>> {
let pool = ctx.data::<PgPool>()?;
let rows = Hersteller::read_all(pool).await?;
let rows = Service::new(pool.clone()).gruppe_alle().await?;
Ok(rows)
}
}

8
src/queries/mod.rs
View File

@@ -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,