fix produce flows

src/flow.rs

@@ -47,7 +47,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::json;
 
 use crate::item::Item;
-use crate::routes::item::{item_does_not_exist_error, variant_does_not_exist_error};
+use crate::routes::item::{item_does_not_exist_error, variant_does_not_exist_error, SupplyForm};
 use crate::routes::{api_error, ApiError};
 use crate::transaction::{Price, Transaction};
 
@@ -156,42 +156,35 @@ impl Flow {
 
     pub async fn end_with_produce(
         self,
-        produced: &[HashMap<String, u64>],
+        produced: &[SupplyForm],
     ) -> Result<HashMap<String, Vec<String>>, ApiError> {
         let mut ret = HashMap::new();
         let mut t_create = Vec::new();
         let mut produced_ref = Vec::with_capacity(ret.len());
 
         for prod in produced {
-            for (item_variant, amount) in prod {
+            let t = Item::get(&prod.item)
-                let (item, variant) = item_variant
+            .await
-                    .split_once("::")
+            .ok_or_else(item_does_not_exist_error)?
-                    .ok_or_else(|| api_error("Bad Request"))?;
+            .variant(&prod.variant)
-                let t = Item::get(item)
+            .ok_or_else(variant_does_not_exist_error)?;
-                    .await
-                    .ok_or_else(item_does_not_exist_error)?
-                    .variant(variant)
-                    .ok_or_else(variant_does_not_exist_error)?;
 
-                t_create.push((t, amount));
+                t_create.push((t, prod));
             }
-        }
 
-        for (item, amount) in t_create {
+        for (item, info) in t_create {
-            for _ in 0..*amount {
                 let t = item
                     .supply(
                         Price::zero(),
                         Some(&format!("flow::{}::{}", self.kind.id(), self._id)),
-                        None,
+                        info.location.as_ref().map(|x| x.as_str()),
-                        None,
+                        info.note.as_ref().map(|x| x.as_str()),
                     )
                     .await;
                 ret.entry(item.item_variant_id().clone())
                     .or_insert(Vec::new())
                     .push(t._id.clone());
                 produced_ref.push(t.reference());
-            }
         }
 
         self.change()

src/routes/flow.rs

@@ -15,7 +15,7 @@ use crate::{
     transaction::{Price, Transaction},
 };
 
-use super::ApiError;
+use super::{item::SupplyForm, ApiError};
 
 #[get("/flow/<id>/info")]
 pub async fn flow_info(
@@ -129,7 +129,7 @@ pub struct CreateFlow {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct EndFlow {
-    pub produced: Option<Vec<HashMap<String, u64>>>,
+    pub produced: Option<Vec<SupplyForm>>,
 }
 
 #[post("/flow/<id>", data = "<form>")]

src/routes/item/supply.rs

@@ -1,7 +1,7 @@
 use mongod::ToAPI;
 use rocket::serde::json::Json;
 use rocket::{get, post, State};
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use serde_json::json;
 
 use crate::check_auth;
@@ -14,14 +14,14 @@ use crate::{
 
 use super::{item_does_not_exist_error, variant_does_not_exist_error};
 
-#[derive(Deserialize, Debug)]
+#[derive(Deserialize, Debug, Clone, Serialize)]
 pub struct SupplyForm {
-    item: String,
+    pub item: String,
-    variant: String,
+    pub variant: String,
-    price: String,
+    pub price: String,
-    origin: Option<String>,
+    pub origin: Option<String>,
-    location: Option<String>,
+    pub location: Option<String>,
-    note: Option<String>,
+    pub note: Option<String>,
 }
 
 /// Route for supply action. Creates a new Transaction for the specified Item Variant.