First Commit

src/models/hersteller.rs

@@ -0,0 +1,63 @@
+use anyhow::Result;
+use async_graphql::SimpleObject;
+use serde::{Deserialize, Serialize};
+use sqlx::{FromRow, PgPool};
+
+#[derive(SimpleObject, FromRow, Deserialize, Serialize)]
+pub struct Hersteller {
+    /// Die Datenbank-ID
+    pub id: i32,
+
+    /// Der Name eines Herstellers
+    name: String,
+}
+
+impl Hersteller {
+    pub async fn create(pool: &PgPool, name: &str) -> Result<Hersteller> {
+        let row = sqlx::query!(
+            "INSERT INTO hersteller(name) VALUES ($1) RETURNING id",
+            name
+        )
+        .fetch_one(pool)
+        .await?;
+
+        Ok(Hersteller {
+            id: row.id,
+            name: name.to_string(),
+        })
+    }
+
+    pub async fn read_one(pool: &PgPool, id: &i32) -> Result<Hersteller> {
+        let row = sqlx::query_as!(Hersteller, "SELECT * FROM hersteller WHERE id = $1", id)
+            .fetch_one(pool)
+            .await?;
+
+        Ok(row)
+    }
+
+    pub async fn read_all(pool: &PgPool) -> Result<Vec<Hersteller>> {
+        let rows = sqlx::query_as!(Hersteller, "SELECT id, name FROM hersteller")
+            .fetch_all(pool)
+            .await?;
+
+        Ok(rows)
+    }
+
+    pub async fn update(pool: &PgPool, id: &i32, name: &str) -> Result<Hersteller> {
+        sqlx::query!("UPDATE hersteller SET name=$1 WHERE id = $2", name, id)
+            .execute(pool)
+            .await?;
+
+        let t = Hersteller::read_one(pool, id).await?;
+
+        Ok(t)
+    }
+
+    pub async fn delete(pool: &PgPool, id: &i32) -> Result<()> {
+        sqlx::query!("DELETE FROM hersteller WHERE id = $1", id)
+            .execute(pool)
+            .await?;
+
+        Ok(())
+    }
+}

src/models/mod.rs

@@ -0,0 +1,3 @@
+pub mod hersteller;
+pub mod modell;
+pub mod typ;

src/models/modell.rs

@@ -0,0 +1,104 @@
+use anyhow::Result;
+use async_graphql::SimpleObject;
+use serde::{Deserialize, Serialize};
+use sqlx::{FromRow, PgPool};
+
+#[derive(SimpleObject, FromRow, Deserialize, Serialize)]
+pub struct Modell {
+    /// Die Datenbank-ID
+    pub id: i32,
+
+    /// Der Typ
+    typ_id: i32,
+
+    /// Der Hersteller
+    hersteller_id: i32,
+
+    /**
+     * Der Name eines Modells
+     * Das ist ein Zusatz
+     */
+    name: String,
+}
+
+impl Modell {
+    pub async fn create(
+        pool: &PgPool,
+        typ_id: i32,
+        hersteller_id: i32,
+        name: &str,
+    ) -> Result<Modell> {
+        let row = sqlx::query!(
+            "INSERT INTO modelle(typ_id, hersteller_id, name) VALUES ($1, $2, $3) RETURNING id",
+            typ_id,
+            hersteller_id,
+            name
+        )
+        .fetch_one(pool)
+        .await?;
+
+        Ok(Modell {
+            id: row.id,
+            typ_id,
+            hersteller_id,
+            name: name.to_string(),
+        })
+    }
+
+    pub async fn read_one(pool: &PgPool, id: &i32) -> Result<Modell> {
+        let row = sqlx::query_as!(Modell, "SELECT * FROM modelle WHERE id = $1", id)
+            .fetch_one(pool)
+            .await?;
+
+        Ok(row)
+    }
+
+    pub async fn read_all(pool: &PgPool) -> Result<Vec<Modell>> {
+        let rows = sqlx::query_as!(
+            Modell,
+            "SELECT id, name, hersteller_id, typ_id FROM modelle"
+        )
+        .fetch_all(pool)
+        .await?;
+
+        Ok(rows)
+    }
+
+    pub async fn read_by_typ(pool: &PgPool, typ_id: &i32) -> Result<Vec<Modell>> {
+        let row = sqlx::query_as!(Modell, "SELECT * FROM modelle WHERE typ_id = $1", typ_id)
+            .fetch_all(pool)
+            .await?;
+
+        Ok(row)
+    }
+
+    pub async fn read_by_hersteller(pool: &PgPool, hersteller_id: &i32) -> Result<Vec<Modell>> {
+        let row = sqlx::query_as!(
+            Modell,
+            "SELECT * FROM modelle WHERE hersteller_id = $1",
+            hersteller_id
+        )
+        .fetch_all(pool)
+        .await?;
+
+        Ok(row)
+    }
+
+    pub async fn update(pool: &PgPool, id: &i32, name: &str) -> Result<Modell> {
+        sqlx::query!("UPDATE modelle SET name=$1 WHERE id = $2", name, id)
+            .execute(pool)
+            .await?;
+
+        let t = Modell::read_one(pool, id).await?;
+
+        Ok(t)
+    }
+
+    pub async fn delete(pool: &PgPool, id: &i32) -> Result<()> {
+        sqlx::query!("DELETE FROM modelle WHERE id = $1", id)
+            .execute(pool)
+            .await?;
+
+        Ok(())
+    }
+}

src/models/typ.rs

@@ -0,0 +1,60 @@
+use anyhow::Result;
+use async_graphql::SimpleObject;
+use serde::{Deserialize, Serialize};
+use sqlx::{FromRow, PgPool};
+
+#[derive(SimpleObject, FromRow, Deserialize, Serialize)]
+pub struct Typ {
+    /// Die Datenbank-ID
+    pub id: i32,
+
+    /// Der Name eines Typs
+    name: String,
+}
+
+impl Typ {
+    pub async fn create(pool: &PgPool, name: &str) -> Result<Typ> {
+        let row = sqlx::query!("INSERT INTO typen(name) VALUES ($1) RETURNING id", name)
+            .fetch_one(pool)
+            .await?;
+
+        Ok(Typ {
+            id: row.id,
+            name: name.to_string(),
+        })
+    }
+
+    pub async fn read_one(pool: &PgPool, id: &i32) -> Result<Typ> {
+        let row = sqlx::query_as!(Typ, "SELECT * FROM typen WHERE id = $1", 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, name FROM typen")
+            .fetch_all(pool)
+            .await?;
+
+        Ok(rows)
+    }
+
+    pub async fn update(pool: &PgPool, id: &i32, name: &str) -> Result<Typ> {
+        sqlx::query!("UPDATE typen SET name=$1 WHERE id = $2", name, id)
+            .execute(pool)
+            .await?;
+
+        let t = Typ::read_one(pool, id).await?;
+
+        Ok(t)
+    }
+
+    pub async fn delete(pool: &PgPool, id: &i32) -> Result<()> {
+        sqlx::query!("DELETE FROM typen WHERE id = $1", id)
+            .execute(pool)
+            .await?;
+
+        Ok(())
+    }
+}