Added data label for backend.

common/src/models/article.rs

@@ -33,7 +33,7 @@ fn from_postgres_row_small(row: PgRow) -> Article {
 }
 
 async fn from_postgres_row(row: PgRow, pool: PgPool) -> Article {
-    let variants_option = load_article_variants(row.get(0), pool).await;
+    let variants_option = load_article_variants(row.get(0), &pool).await;
 
     let variants = match variants_option {
         Some(variants_inner) => {

common/src/models/label.rs

@@ -0,0 +1,148 @@
+use log::{error, info};
+use serde::{Deserialize, Serialize};
+use sqlx::{Arguments, Decode, Encode, FromRow, PgPool, Row};
+use sqlx::postgres::{PgArguments, PgRow};
+
+#[derive(Debug, Deserialize, Serialize, Clone, FromRow, Decode, Encode)]
+pub struct Label {
+    pub id: i64,
+    pub name: String,
+}
+
+fn from_postgres_row_small(row: PgRow) -> Label {
+    Label {
+        id: row.get(0),
+        name: row.get(1),
+    }
+}
+
+pub async fn load_labels(pool: PgPool) -> Option<Vec<Label>> {
+    let statement = format!(
+        "SELECT * FROM {}",
+        "label",
+    );
+
+    let res = sqlx::query(
+        statement.as_str())
+        .fetch_all(&pool).await;
+
+    let mut labels: Vec<Label> = Vec::new();
+
+    match res {
+        Ok(records) => {
+            for record in records {
+                labels.push(
+                    from_postgres_row_small(record)
+                );
+            }
+
+            Some(labels)
+        }
+        Err(err) => {
+            error!("Error while loading all labels");
+            None
+        }
+    }
+}
+
+pub async fn load_label(id: i64, pool: &PgPool) -> Option<Label> {
+    let statement = format!(
+        "SELECT * FROM {} WHERE $1 = id",
+        "label",
+    );
+
+    let mut args = PgArguments::default();
+    args.add(id);
+
+    let res = sqlx::query_with(
+        statement.as_str(), args)
+        .fetch_one(pool).await;
+    
+    match res {
+        Ok(record) => {
+            Some(from_postgres_row_small(record))
+        }
+        Err(err) => {
+            error!("Error while loading label: {}", id);
+            None
+        }
+    }
+}
+
+pub async fn insert_label(label: &Label, pool: PgPool) -> Option<Label> {
+    let mut args = PgArguments::default();
+    args.add(&label.name);
+
+    let statement = format!(
+        "INSERT INTO {} (name) VALUES ($1) RETURNING *",
+        "label",
+    );
+
+    let res = sqlx::query_with(
+        statement.as_str(),
+        args)
+        .fetch_one(&pool).await;
+
+    info!("{:#?}", res);
+
+    match res {
+        Ok(record) => {
+            let label = from_postgres_row_small(record);
+
+            Some(label)
+        }
+        Err(err) => {
+            error!("Error while loading newly created label: {}", label.name);
+            None
+        }
+    }
+}
+
+pub async fn update_label(label_id: i64, label: &Label, pool: PgPool) -> Option<Label> {
+    let mut args = PgArguments::default();
+    args.add(&label.id);
+    args.add(&label.name);
+
+    let statement = format!(
+        "UPDATE {} SET name = $2 WHERE id = $1 RETURNING *",
+        "label",
+    );
+
+    let res = sqlx::query_with(
+        statement.as_str(),
+        args)
+        .fetch_one(&pool).await;
+
+    info!("{:#?}", res);
+
+    match res {
+        Ok(record) => {
+            let label = from_postgres_row_small(record);
+            Some(label)
+        }
+        Err(err) => {
+            error!("Error while updating label: {}", label_id);
+            None
+        }
+    }
+}
+
+pub async fn delete_label(label_id: i64, pool: PgPool) -> Option<()> {
+    let result = sqlx::query(
+        format!("DELETE FROM {} WHERE id = {}",
+                "label",
+                label_id
+        ).as_str()
+    ).execute(&pool).await;
+
+    match result {
+        Ok(_) => {
+            Some(())
+        }
+        Err(err) => {
+            println!("Error deleting label: {:#?}", err);
+
+            None
+        }
+    }
+}

common/src/models/mod.rs

@@ -2,3 +2,4 @@ pub mod origin;
 pub mod article;
 pub mod variant;
 pub mod unit;
+pub mod label;

common/src/models/variant.rs

@@ -2,6 +2,7 @@ use log::{error, info};
 use serde::{Deserialize, Serialize};
 use sqlx::{Arguments, FromRow, PgPool, Row};
 use sqlx::postgres::{PgArguments, PgRow};
+use crate::models::label::{load_label, Label};
 use crate::models::unit::Unit;
 
 #[derive(Debug, Deserialize, Serialize, Clone, FromRow)]
@@ -13,9 +14,13 @@ pub struct Variant {
     pub description: Option<String>,
     pub ingredients: Option<String>,
     pub unit: Unit,
+    pub label: Option<Label>,
+    pub variant_description: Option<String>,
 }
 
-fn from_postgres_row_small(row: PgRow) -> Variant {
+async fn from_postgres_row(row: PgRow, pool: &PgPool) -> Variant {
+    let label = load_label(row.get(0), pool).await;
+
     Variant {
         id: row.get(0),
         weight: row.get(2),
@@ -24,10 +29,12 @@ fn from_postgres_row_small(row: PgRow) -> Variant {
         description: row.get(5),
         ingredients: row.get(6),
         unit: row.get(7),
+        label: label,
+        variant_description: row.get(9),
     }
 }
 
-pub async fn load_article_variants(article_id: i64, pool: PgPool) -> Option<Vec<Variant>> {
+pub async fn load_article_variants(article_id: i64, pool: &PgPool) -> Option<Vec<Variant>> {
     let statement = format!(
         "SELECT * FROM {} WHERE article_id = $1",
         "variant",
@@ -38,7 +45,7 @@ pub async fn load_article_variants(article_id: i64, pool: PgPool) -> Option<Vec<
 
     let res = sqlx::query_with(
         statement.as_str(), args)
-        .fetch_all(&pool).await;
+        .fetch_all(pool).await;
 
     let mut variants: Vec<Variant> = Vec::new();
 
@@ -46,7 +53,7 @@ pub async fn load_article_variants(article_id: i64, pool: PgPool) -> Option<Vec<
         Ok(records) => {
             for record in records {
                 variants.push(
-                    from_postgres_row_small(record)
+                    from_postgres_row(record, &pool).await
                 );
             }
 
@@ -60,6 +67,15 @@ pub async fn load_article_variants(article_id: i64, pool: PgPool) -> Option<Vec<
 }
 
 pub async fn insert_variant(article_id: i64, variant: &Variant, pool: PgPool) -> Option<Variant> {
+    let label_id = match &variant.label {
+        Some(label) => {
+            Some(label.id)
+        }
+        None => {
+            None
+        }
+    };
+
     let mut args = PgArguments::default();
     args.add(&article_id);
     args.add(&variant.weight);
@@ -68,9 +84,11 @@ pub async fn insert_variant(article_id: i64, variant: &Variant, pool: PgPool) ->
     args.add(&variant.description);
     args.add(&variant.ingredients);
     args.add(&variant.unit);
+    args.add(label_id);
+    args.add(&variant.variant_description);
 
     let statement = format!(
-        "INSERT INTO {} (article_id, weight, ean, name, description, ingredients, unit_id) VALUES ($1, $2, $3, $4, $5, $6, $7) RETURNING *",
+        "INSERT INTO {} (article_id, weight, ean, name, description, ingredients, unit_id, label_id, variant_description) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) RETURNING *",
         "variant",
     );
 
@@ -83,7 +101,7 @@ pub async fn insert_variant(article_id: i64, variant: &Variant, pool: PgPool) ->
 
     match res {
         Ok(record) => {
-            let variant = from_postgres_row_small(record);
+            let variant = from_postgres_row(record, &pool).await;
             Some(variant)
         }
         Err(err) => {
@@ -94,6 +112,15 @@ pub async fn insert_variant(article_id: i64, variant: &Variant, pool: PgPool) ->
 }
 
 pub async fn update_variant(variant_id: i64, variant: &Variant, pool: PgPool) -> Option<Variant> {
+    let label_id = match &variant.label {
+        Some(label) => {
+            Some(label.id)
+        }
+        None => {
+            None
+        }
+    };
+
     let mut args = PgArguments::default();
     args.add(&variant.id);
     args.add(&variant.weight);
@@ -102,11 +129,13 @@ pub async fn update_variant(variant_id: i64, variant: &Variant, pool: PgPool) ->
     args.add(&variant.description);
     args.add(&variant.ingredients);
     args.add(&variant.unit);
+    args.add(label_id);
+    args.add(&variant.variant_description);
 
     info!("Variant: {:#?}", variant);
 
     let statement = format!(
-        "UPDATE {} SET weight = $2, ean = $3, name = $4, description = $5, ingredients = $6, unit_id = $7 WHERE id = $1 RETURNING *",
+        "UPDATE {} SET weight = $2, ean = $3, name = $4, description = $5, ingredients = $6, unit_id = $7, label_id = $8, variant_description = $9 WHERE id = $1 RETURNING *",
         "variant",
     );
 
@@ -119,7 +148,7 @@ pub async fn update_variant(variant_id: i64, variant: &Variant, pool: PgPool) ->
 
     match res {
         Ok(record) => {
-            let variant = from_postgres_row_small(record);
+            let variant = from_postgres_row(record, &pool).await;
             Some(variant)
         }
         Err(err) => {