committing to insanityHEADmaster

1 files changed, 613 insertions, 0 deletions

diff --git a/src/core/operations/asset_operations.rs b/src/core/operations/asset_operations.rs
new file mode 100644
index 0000000..459aeb5
--- /dev/null
+++ b/src/core/operations/asset_operations.rs
@@ -0,0 +1,613 @@
+use crate::api::ApiClient;
+use crate::models::api_error_detail;
+use serde_json::{Map, Value};
+/// Asset CRUD operations that can be reused across different entity types
+pub struct AssetOperations;
+
+impl AssetOperations {
+    /// Apply updates to one or more assets
+    pub fn apply_updates<T>(
+        api: &ApiClient,
+        updated: Map<String, Value>,
+        pending_edit_ids: &mut Vec<i64>,
+        easy_dialog_item_id: Option<&str>,
+        advanced_dialog_item_id: Option<&str>,
+        find_asset_fn: impl Fn(i64) -> Option<T>,
+        limit: Option<u32>,
+        reload_fn: impl FnOnce(&ApiClient, Option<u32>),
+    ) where
+        T: serde::Serialize,
+    {
+        let ids: Vec<i64> = std::mem::take(pending_edit_ids);
+        log::info!("Pending edit IDs from ribbon: {:?}", ids);
+
+        if ids.is_empty() {
+            // Try to get ID from either dialog or from the embedded ID in the diff
+            let item_id = updated
+                .get("__editor_item_id")
+                .and_then(|v| v.as_str())
+                .map(|s| s.to_string())
+                .or_else(|| easy_dialog_item_id.map(|s| s.to_string()))
+                .or_else(|| advanced_dialog_item_id.map(|s| s.to_string()));
+
+            if let Some(id_str) = item_id {
+                if let Ok(id) = id_str.parse::<i64>() {
+                    // Compute diff against the current asset so we only send changed fields
+                    let only_changed = if let Some(orig) = find_asset_fn(id) {
+                        log::info!("Found original asset data for comparison");
+                        let orig_value = serde_json::to_value(&orig).unwrap_or_default();
+                        let mut diff = Map::new();
+                        for (k, v) in updated.iter() {
+                            match orig_value.get(k) {
+                                Some(ov) if ov == v => {
+                                    log::debug!("Field '{}' unchanged: {:?}", k, v);
+                                }
+                                _ => {
+                                    log::info!(
+                                        "Field '{}' CHANGED: old={:?}, new={:?}",
+                                        k,
+                                        orig_value.get(k),
+                                        v
+                                    );
+                                    diff.insert(k.clone(), v.clone());
+                                }
+                            }
+                        }
+                        log::info!("Final diff map to send: {:?}", diff);
+                        diff
+                    } else {
+                        log::warn!(
+                            "Asset ID {} not found in local cache, sending full update",
+                            id
+                        );
+                        updated.clone()
+                    };
+
+                    if only_changed.is_empty() {
+                        log::warn!("No changes detected - update will be skipped!");
+                    } else {
+                        log::info!("Calling update_one with {} changes", only_changed.len());
+                    }
+                    Self::update_one(api, id, &only_changed);
+                } else {
+                    log::error!("FAILED to parse asset ID: '{}' - UPDATE SKIPPED!", id_str);
+                }
+            } else {
+                log::error!("NO ITEM ID FOUND - This is the bug! UPDATE COMPLETELY SKIPPED!");
+                log::error!("Easy dialog item_id: {:?}", easy_dialog_item_id);
+                log::error!("Advanced dialog item_id: {:?}", advanced_dialog_item_id);
+            }
+        } else {
+            log::info!("Bulk edit mode for {} assets", ids.len());
+            // Bulk edit: apply provided fields to each id without diffing per-record
+            for id in ids {
+                log::info!("Bulk updating asset ID: {}", id);
+                Self::update_one(api, id, &updated);
+            }
+        }
+
+        reload_fn(api, limit);
+    }
+
+    /// Handle quick-add fields for category, zone, and supplier when editing
+    pub fn preprocess_quick_adds(api: &ApiClient, data: &mut Map<String, Value>) {
+        // CATEGORY
+        let new_cat_name = data
+            .get("new_category_name")
+            .and_then(|v| v.as_str())
+            .unwrap_or("")
+            .trim()
+            .to_string();
+        let new_cat_code = data
+            .get("new_category_code")
+            .and_then(|v| v.as_str())
+            .unwrap_or("")
+            .trim()
+            .to_string();
+        let has_selected_cat = data.get("category_id").and_then(|v| v.as_i64()).is_some()
+            || data
+                .get("category_id")
+                .and_then(|v| v.as_str())
+                .map(|s| !s.trim().is_empty())
+                .unwrap_or(false);
+
+        if !has_selected_cat && !new_cat_name.is_empty() && !new_cat_code.is_empty() {
+            let values = serde_json::json!({
+                "category_name": new_cat_name,
+                "category_code": new_cat_code,
+            });
+            match api.insert("categories", values) {
+                Ok(resp) if resp.success => {
+                    if let Some(id) = resp.data {
+                        data.insert("category_id".into(), Value::Number((id as i64).into()));
+                    }
+                }
+                Ok(resp) => {
+                    log::error!(
+                        "Quick-add category failed: {}",
+                        api_error_detail(&resp.error)
+                    );
+                }
+                Err(e) => {
+                    log::error!("Quick-add category err: {}", e);
+                }
+            }
+        }
+
+        // ZONE
+        let new_zone_name = data
+            .get("new_zone_name")
+            .and_then(|v| v.as_str())
+            .unwrap_or("")
+            .trim()
+            .to_string();
+        // Prefer new_zone_mini_code (new), fallback to legacy new_zone_code
+        let new_zone_mini_code = data
+            .get("new_zone_mini_code")
+            .and_then(|v| v.as_str())
+            .unwrap_or("")
+            .trim()
+            .to_string();
+        let legacy_new_zone_code = data
+            .get("new_zone_code")
+            .and_then(|v| v.as_str())
+            .unwrap_or("")
+            .trim()
+            .to_string();
+        let parent_id_val = data.get("new_zone_parent_id").cloned();
+        let has_selected_zone = data.get("zone_id").and_then(|v| v.as_i64()).is_some()
+            || data
+                .get("zone_id")
+                .and_then(|v| v.as_str())
+                .map(|s| !s.trim().is_empty())
+                .unwrap_or(false);
+
+        if !has_selected_zone && !new_zone_name.is_empty() {
+            // parent optional, parse int if provided
+            let mut zone_obj = Map::new();
+            zone_obj.insert("zone_name".into(), Value::String(new_zone_name));
+            // Determine mini_code to use
+            let mini_code = if !new_zone_mini_code.is_empty() {
+                new_zone_mini_code.clone()
+            } else {
+                legacy_new_zone_code.clone()
+            };
+            if !mini_code.is_empty() {
+                // Compute full zone_code using parent if provided
+                let full_code = if let Some(v) = parent_id_val.clone() {
+                    if let Some(pid) = v
+                        .as_i64()
+                        .or_else(|| v.as_str().and_then(|s| s.parse::<i64>().ok()))
+                    {
+                        // Fetch parent's zone_code
+                        if let Ok(resp) = api.select(
+                            "zones",
+                            Some(vec!["zone_code".into()]),
+                            Some(serde_json::json!({"id": pid})),
+                            None,
+                            Some(1),
+                        ) {
+                            if resp.success {
+                                if let Some(rows) = resp.data {
+                                    if let Some(row) = rows.into_iter().next() {
+                                        let pcode = row
+                                            .get("zone_code")
+                                            .and_then(|v| v.as_str())
+                                            .unwrap_or("");
+                                        format!("{}-{}", pcode, mini_code)
+                                    } else {
+                                        mini_code.clone()
+                                    }
+                                } else {
+                                    mini_code.clone()
+                                }
+                            } else {
+                                mini_code.clone()
+                            }
+                        } else {
+                            mini_code.clone()
+                        }
+                    } else {
+                        mini_code.clone()
+                    }
+                } else {
+                    mini_code.clone()
+                };
+                // Send both mini_code and computed full zone_code
+                zone_obj.insert("mini_code".into(), Value::String(mini_code));
+                zone_obj.insert("zone_code".into(), Value::String(full_code));
+            }
+            if let Some(v) = parent_id_val {
+                if let Some(n) = v.as_i64() {
+                    zone_obj.insert("parent_id".into(), Value::Number(n.into()));
+                } else if let Some(s) = v.as_str() {
+                    if let Ok(n) = s.parse::<i64>() {
+                        zone_obj.insert("parent_id".into(), Value::Number(n.into()));
+                    }
+                }
+            }
+            match api.insert("zones", Value::Object(zone_obj)) {
+                Ok(resp) if resp.success => {
+                    if let Some(id) = resp.data {
+                        data.insert("zone_id".into(), Value::Number((id as i64).into()));
+                    }
+                }
+                Ok(resp) => {
+                    log::error!("Quick-add zone failed: {}", api_error_detail(&resp.error));
+                }
+                Err(e) => {
+                    log::error!("Quick-add zone err: {}", e);
+                }
+            }
+        }
+
+        // SUPPLIER
+        let new_supplier_name = data
+            .get("new_supplier_name")
+            .and_then(|v| v.as_str())
+            .unwrap_or("")
+            .trim()
+            .to_string();
+        let has_selected_supplier = data.get("supplier_id").and_then(|v| v.as_i64()).is_some()
+            || data
+                .get("supplier_id")
+                .and_then(|v| v.as_str())
+                .map(|s| !s.trim().is_empty())
+                .unwrap_or(false);
+
+        if !has_selected_supplier && !new_supplier_name.is_empty() {
+            let values = serde_json::json!({ "name": new_supplier_name });
+            match api.insert("suppliers", values) {
+                Ok(resp) if resp.success => {
+                    if let Some(id) = resp.data {
+                        data.insert("supplier_id".into(), Value::Number((id as i64).into()));
+                    }
+                }
+                Ok(resp) => {
+                    log::error!(
+                        "Quick-add supplier failed: {}",
+                        api_error_detail(&resp.error)
+                    );
+                }
+                Err(e) => {
+                    log::error!("Quick-add supplier err: {}", e);
+                }
+            }
+        }
+    }
+
+    /// Filter update data to only include allowed fields with proper type coercion
+    pub fn filtered_update_fields(data: &Map<String, Value>) -> Map<String, Value> {
+        // Allow only writable/meaningful asset fields (exclude IDs, timestamps, joined names)
+        let allowed = [
+            "asset_tag",
+            "asset_type",
+            "name",
+            "category_id",
+            "zone_id",
+            "zone_plus",
+            "zone_note",
+            "manufacturer",
+            "model",
+            "serial_number",
+            "status",
+            "label_template_id",
+            "price",
+            "purchase_date",
+            "warranty_until",
+            "expiry_date",
+            "supplier_id",
+            "lendable",
+            "lending_status",
+            "due_date",
+            "no_scan",
+            "quantity_available",
+            "quantity_total",
+            "quantity_used",
+            "minimum_role_for_lending",
+            "audit_task_id",
+            "asset_image",
+            "notes",
+            "additional_fields",
+        ];
+        let allowed_set: std::collections::HashSet<&str> = allowed.iter().copied().collect();
+        let mut out = Map::new();
+
+        for (k, v) in data.iter() {
+            // Skip internal editor fields
+            if k.starts_with("__editor_") {
+                continue;
+            }
+            // Map template-only "description" to asset "notes" to avoid DB column mismatch
+            if k == "description" {
+                let coerced = if let Some(s) = v.as_str() {
+                    Value::String(s.to_string())
+                } else if v.is_null() {
+                    Value::Null
+                } else {
+                    Value::String(v.to_string())
+                };
+                if !out.contains_key("notes") {
+                    out.insert("notes".to_string(), coerced);
+                }
+                continue;
+            }
+            if !allowed_set.contains(k.as_str()) {
+                continue;
+            }
+
+            // Coerce common types where Advanced Editor may send strings
+            let coerced = match k.as_str() {
+                // Integers (IDs and quantities)
+                "category_id"
+                | "zone_id"
+                | "label_template_id"
+                | "supplier_id"
+                | "audit_task_id"
+                | "quantity_available"
+                | "quantity_total"
+                | "quantity_used"
+                | "minimum_role_for_lending" => {
+                    if let Some(n) = v.as_i64() {
+                        Value::Number(n.into())
+                    } else if let Some(s) = v.as_str() {
+                        if s.trim().is_empty() {
+                            Value::Null
+                        } else if let Ok(n) = s.trim().parse::<i64>() {
+                            Value::Number(n.into())
+                        } else {
+                            Value::Null
+                        }
+                    } else {
+                        v.clone()
+                    }
+                }
+
+                // Booleans
+                "lendable" => {
+                    if let Some(b) = v.as_bool() {
+                        Value::Bool(b)
+                    } else if let Some(s) = v.as_str() {
+                        match s.trim().to_lowercase().as_str() {
+                            "true" | "1" | "yes" => Value::Bool(true),
+                            "false" | "0" | "no" => Value::Bool(false),
+                            _ => v.clone(),
+                        }
+                    } else {
+                        v.clone()
+                    }
+                }
+
+                // Price as decimal number
+                "price" => {
+                    if let Some(f) = v.as_f64() {
+                        Value::Number(
+                            serde_json::Number::from_f64(f)
+                                .unwrap_or_else(|| serde_json::Number::from(0)),
+                        )
+                    } else if let Some(s) = v.as_str() {
+                        if s.trim().is_empty() {
+                            Value::Null
+                        } else if let Ok(f) = s.trim().parse::<f64>() {
+                            Value::Number(
+                                serde_json::Number::from_f64(f)
+                                    .unwrap_or_else(|| serde_json::Number::from(0)),
+                            )
+                        } else {
+                            Value::Null
+                        }
+                    } else {
+                        v.clone()
+                    }
+                }
+
+                // Date fields: accept YYYY-MM-DD strings; treat empty strings as NULL
+                "purchase_date" | "warranty_until" | "expiry_date" | "due_date" => {
+                    if let Some(s) = v.as_str() {
+                        let t = s.trim();
+                        if t.is_empty() {
+                            Value::Null
+                        } else {
+                            Value::String(t.to_string())
+                        }
+                    } else if v.is_null() {
+                        Value::Null
+                    } else {
+                        // Fallback: stringify other types
+                        Value::String(v.to_string())
+                    }
+                }
+
+                // String fields - ensure they're strings (not null if empty)
+                "asset_tag" | "asset_type" | "name" | "manufacturer" | "model"
+                | "serial_number" | "status" | "zone_plus" | "zone_note" | "lending_status"
+                | "no_scan" | "notes" => {
+                    if let Some(s) = v.as_str() {
+                        Value::String(s.to_string())
+                    } else if v.is_null() {
+                        Value::Null
+                    } else {
+                        Value::String(v.to_string())
+                    }
+                }
+
+                _ => v.clone(),
+            };
+            out.insert(k.clone(), coerced);
+        }
+        out
+    }
+
+    /// Update a single entity record
+    pub fn update_one(api: &ApiClient, id: i64, data: &Map<String, Value>) {
+        Self::update_one_table(api, "assets", id, data);
+    }
+
+    /// Update a single record in any table
+    pub fn update_one_table(api: &ApiClient, table: &str, id: i64, data: &Map<String, Value>) {
+        log::info!("=== UPDATE_ONE START for {} ID {} ===", table, id);
+        log::info!("Raw input data: {:?}", data);
+
+        let values_map = Self::filtered_update_fields(data);
+        log::info!("Filtered values_map: {:?}", values_map);
+
+        if values_map.is_empty() {
+            log::warn!(
+                "No allowed fields found after filtering for {} ID {}, SKIPPING UPDATE",
+                table,
+                id
+            );
+            log::warn!("Original data keys: {:?}", data.keys().collect::<Vec<_>>());
+            return;
+        }
+
+        let values = Value::Object(values_map.clone());
+        let where_clause = serde_json::json!({"id": id});
+
+        log::info!("SENDING UPDATE to server:");
+        log::info!("  TABLE: {}", table);
+        log::info!("  WHERE: {:?}", where_clause);
+        log::info!("  VALUES: {:?}", values);
+
+        match api.update(table, values, where_clause) {
+            Ok(resp) if resp.success => {
+                log::info!("Successfully updated {} ID {}", table, id);
+            }
+            Ok(resp) => {
+                log::error!(
+                    "Server rejected update for {} ID {}: {}",
+                    table,
+                    id,
+                    api_error_detail(&resp.error)
+                );
+            }
+            Err(e) => {
+                log::error!("Network/API error updating {} ID {}: {}", table, id, e);
+            }
+        }
+        log::info!("=== UPDATE_ONE END ===");
+    }
+
+    /// Insert a new asset record with preprocessing and return its DB id (if available)
+    pub fn insert_new_asset(
+        api: &ApiClient,
+        mut data: Map<String, Value>,
+        limit: Option<u32>,
+        reload_fn: impl FnOnce(&ApiClient, Option<u32>),
+    ) -> Option<i64> {
+        log::info!("=== INSERT_NEW_ASSET START ===");
+        log::info!("Raw asset data: {:?}", data);
+
+        // Process quick-add fields first
+        Self::preprocess_quick_adds(api, &mut data);
+
+        // Ensure mandatory defaults if missing or blank
+        let needs_default = |v: Option<&Value>| -> bool {
+            match v {
+                None => true,
+                Some(Value::Null) => true,
+                Some(Value::String(s)) => s.trim().is_empty(),
+                _ => false,
+            }
+        };
+        if needs_default(data.get("asset_type")) {
+            data.insert("asset_type".into(), Value::String("N".to_string()));
+        }
+        if needs_default(data.get("status")) {
+            data.insert("status".into(), Value::String("Good".to_string()));
+        }
+
+        // Filter to allowed fields
+        let filtered_data = Self::filtered_update_fields(&data);
+        log::info!("Filtered asset data: {:?}", filtered_data);
+
+        if filtered_data.is_empty() {
+            log::error!("No valid data to insert");
+            return None;
+        }
+
+        let values = Value::Object(filtered_data);
+        log::info!("SENDING INSERT to server: {:?}", values);
+
+        let result = match api.insert("assets", values) {
+            Ok(resp) if resp.success => {
+                log::info!("Successfully created new asset");
+                let id = resp.data.map(|d| d as i64);
+                log::info!("New asset DB id from server: {:?}", id);
+                reload_fn(api, limit);
+                id
+            }
+            Ok(resp) => {
+                log::error!(
+                    "Server rejected asset creation: {}",
+                    api_error_detail(&resp.error)
+                );
+                None
+            }
+            Err(e) => {
+                log::error!("Network/API error creating asset: {}", e);
+                None
+            }
+        };
+        log::info!("=== INSERT_NEW_ASSET END ===");
+        result
+    }
+
+    /// Find an asset by ID in a collection
+    pub fn find_by_id<T>(
+        collection: &[T],
+        id: i64,
+        id_extractor: impl Fn(&T) -> Option<i64>,
+    ) -> Option<T>
+    where
+        T: Clone,
+    {
+        collection
+            .iter()
+            .find(|item| id_extractor(item) == Some(id))
+            .cloned()
+    }
+
+    /// Get selected IDs from a collection based on row indices
+    #[allow(dead_code)]
+    pub fn get_selected_ids<T>(
+        collection: &[T],
+        selected_rows: &std::collections::HashSet<usize>,
+        id_extractor: impl Fn(&T) -> Option<i64>,
+    ) -> Vec<i64> {
+        let mut ids = Vec::new();
+        for &row in selected_rows {
+            if let Some(item) = collection.get(row) {
+                if let Some(id) = id_extractor(item) {
+                    ids.push(id);
+                }
+            }
+        }
+        ids
+    }
+
+    /// Filter and search through JSON data
+    #[allow(dead_code)]
+    pub fn filter_and_search(
+        data: &[Value],
+        search_query: &str,
+        search_fields: &[&str],
+    ) -> Vec<Value> {
+        if search_query.is_empty() {
+            return data.to_vec();
+        }
+
+        let search_lower = search_query.to_lowercase();
+        data.iter()
+            .filter(|item| {
+                search_fields.iter().any(|field| {
+                    item.get(field)
+                        .and_then(|v| v.as_str())
+                        .map(|s| s.to_lowercase().contains(&search_lower))
+                        .unwrap_or(false)
+                })
+            })
+            .cloned()
+            .collect()
+    }
+}