committing to insanityHEADmaster

1 files changed, 990 insertions, 0 deletions

diff --git a/src/ui/zones.rs b/src/ui/zones.rs
new file mode 100644
index 0000000..d331642
--- /dev/null
+++ b/src/ui/zones.rs
@@ -0,0 +1,990 @@
+use eframe::egui;
+use std::collections::{HashMap, HashSet};
+
+use crate::core::components::form_builder::FormBuilder;
+use crate::core::components::interactions::ConfirmDialog;
+use crate::core::{EditorField, FieldType};
+
+use crate::api::ApiClient;
+use crate::core::tables::get_assets_in_zone;
+
+pub struct ZonesView {
+    zones: Vec<serde_json::Value>,
+    is_loading: bool,
+    last_error: Option<String>,
+    // UI state
+    show_items: bool,
+    search_query: String,
+    // Cache: assets per zone id
+    zone_assets: HashMap<i32, Vec<serde_json::Value>>,
+    // Request guards
+    initial_load_done: bool,
+    zone_assets_attempted: HashSet<i32>,
+    zone_assets_failed: HashSet<i32>,
+    // Editor dialogs for zones
+    edit_dialog: FormBuilder,
+    add_dialog: FormBuilder,
+    delete_dialog: ConfirmDialog,
+    // Pending operation
+    pending_delete_id: Option<i32>,
+    pending_parent_id: Option<i32>, // For "Add Child Zone"
+    // Navigation request
+    pub switch_to_inventory_with_zone: Option<String>, // zone_code to filter by
+    // Print dialog
+    print_dialog: Option<crate::core::print::PrintDialog>,
+    show_print_dialog: bool,
+    force_expand_state: Option<bool>,
+}
+
+impl ZonesView {
+    pub fn new() -> Self {
+        // Create basic editors first, they'll be updated with dropdowns when API client is available
+        let edit_dialog = Self::create_edit_dialog(Vec::new());
+        let add_dialog = Self::create_add_dialog(Vec::new());
+
+        Self {
+            zones: Vec::new(),
+            is_loading: false,
+            last_error: None,
+            show_items: true,
+            search_query: String::new(),
+            zone_assets: HashMap::new(),
+            initial_load_done: false,
+            zone_assets_attempted: HashSet::new(),
+            zone_assets_failed: HashSet::new(),
+            edit_dialog,
+            add_dialog,
+            delete_dialog: ConfirmDialog::new("Delete Zone", "Are you sure you want to delete this zone? All items in this zone will lose their zone assignment."),
+            pending_delete_id: None,
+            pending_parent_id: None,
+            switch_to_inventory_with_zone: None,
+            print_dialog: None,
+            show_print_dialog: false,
+            force_expand_state: None,
+        }
+    }
+
+    /// Check if a zone or any of its descendants have items
+    fn zone_or_descendants_have_items(
+        &self,
+        zone_id: i32,
+        all_zones: &[serde_json::Value],
+    ) -> bool {
+        // Check if this zone has items
+        if self
+            .zone_assets
+            .get(&zone_id)
+            .map(|assets| !assets.is_empty())
+            .unwrap_or(false)
+        {
+            return true;
+        }
+
+        // Check if any children have items (recursively)
+        for z in all_zones {
+            if let Some(parent_id) = z
+                .get("parent_id")
+                .and_then(|v| v.as_i64())
+                .map(|v| v as i32)
+            {
+                if parent_id == zone_id {
+                    if let Some(child_id) = z.get("id").and_then(|v| v.as_i64()).map(|v| v as i32) {
+                        if self.zone_or_descendants_have_items(child_id, all_zones) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+
+        false
+    }
+
+    /// Create edit dialog with zone options for parent selection
+    fn create_edit_dialog(parent_options: Vec<(String, String)>) -> FormBuilder {
+        let zone_type_options = vec![
+            ("Building".to_string(), "Building".to_string()),
+            ("Floor".to_string(), "Floor".to_string()),
+            ("Room".to_string(), "Room".to_string()),
+            ("Storage Area".to_string(), "Storage Area".to_string()),
+        ];
+
+        FormBuilder::new(
+            "Edit Zone",
+            vec![
+                EditorField {
+                    name: "id".into(),
+                    label: "ID".into(),
+                    field_type: FieldType::Text,
+                    required: false,
+                    read_only: true,
+                },
+                EditorField {
+                    name: "mini_code".into(),
+                    label: "Mini Code".into(),
+                    field_type: FieldType::Text,
+                    required: true,
+                    read_only: false,
+                },
+                EditorField {
+                    name: "zone_code".into(),
+                    label: "Full Zone Code".into(),
+                    field_type: FieldType::Text,
+                    required: false,
+                    read_only: false,
+                },
+                EditorField {
+                    name: "zone_name".into(),
+                    label: "Name".into(),
+                    field_type: FieldType::Text,
+                    required: true,
+                    read_only: false,
+                },
+                EditorField {
+                    name: "zone_type".into(),
+                    label: "Type".into(),
+                    field_type: FieldType::Dropdown(zone_type_options.clone()),
+                    required: false,
+                    read_only: false,
+                },
+                EditorField {
+                    name: "parent_id".into(),
+                    label: "Parent Zone".into(),
+                    field_type: FieldType::Dropdown(parent_options.clone()),
+                    required: false,
+                    read_only: false,
+                },
+                EditorField {
+                    name: "include_in_parent".into(),
+                    label: "Include in Parent".into(),
+                    field_type: FieldType::Checkbox,
+                    required: false,
+                    read_only: false,
+                },
+                EditorField {
+                    name: "audit_timeout_minutes".into(),
+                    label: "Audit Timeout (minutes)".into(),
+                    field_type: FieldType::Text,
+                    required: false,
+                    read_only: false,
+                },
+                EditorField {
+                    name: "zone_notes".into(),
+                    label: "Notes".into(),
+                    field_type: FieldType::MultilineText,
+                    required: false,
+                    read_only: false,
+                },
+            ],
+        )
+    }
+
+    /// Create add dialog with zone options for parent selection
+    fn create_add_dialog(parent_options: Vec<(String, String)>) -> FormBuilder {
+        let zone_type_options = vec![
+            ("Building".to_string(), "Building".to_string()),
+            ("Floor".to_string(), "Floor".to_string()),
+            ("Room".to_string(), "Room".to_string()),
+            ("Storage Area".to_string(), "Storage Area".to_string()),
+        ];
+
+        FormBuilder::new(
+            "Add Zone",
+            vec![
+                EditorField {
+                    name: "mini_code".into(),
+                    label: "Mini Code".into(),
+                    field_type: FieldType::Text,
+                    required: true,
+                    read_only: false,
+                },
+                EditorField {
+                    name: "zone_code".into(),
+                    label: "Full Zone Code".into(),
+                    field_type: FieldType::Text,
+                    required: false,
+                    read_only: false,
+                },
+                EditorField {
+                    name: "zone_name".into(),
+                    label: "Name".into(),
+                    field_type: FieldType::Text,
+                    required: true,
+                    read_only: false,
+                },
+                EditorField {
+                    name: "zone_type".into(),
+                    label: "Type".into(),
+                    field_type: FieldType::Dropdown(zone_type_options),
+                    required: false,
+                    read_only: false,
+                },
+                EditorField {
+                    name: "parent_id".into(),
+                    label: "Parent Zone".into(),
+                    field_type: FieldType::Dropdown(parent_options),
+                    required: false,
+                    read_only: false,
+                },
+                EditorField {
+                    name: "include_in_parent".into(),
+                    label: "Include in Parent".into(),
+                    field_type: FieldType::Checkbox,
+                    required: false,
+                    read_only: false,
+                },
+                EditorField {
+                    name: "audit_timeout_minutes".into(),
+                    label: "Audit Timeout (minutes)".into(),
+                    field_type: FieldType::Text,
+                    required: false,
+                    read_only: false,
+                },
+                EditorField {
+                    name: "zone_notes".into(),
+                    label: "Notes".into(),
+                    field_type: FieldType::MultilineText,
+                    required: false,
+                    read_only: false,
+                },
+            ],
+        )
+    }
+
+    /// Update editor dialogs with current zone list for parent dropdown
+    fn update_editor_dropdowns(&mut self) {
+        let parent_options: Vec<(String, String)> =
+            std::iter::once(("".to_string(), "(None)".to_string()))
+                .chain(self.zones.iter().filter_map(|z| {
+                    let id = z.get("id")?.as_i64()?.to_string();
+                    let code = z.get("zone_code")?.as_str()?;
+                    let name = z.get("name").or_else(|| z.get("zone_name"))?.as_str()?;
+                    Some((id, format!("{} - {}", code, name)))
+                }))
+                .collect();
+
+        self.edit_dialog = Self::create_edit_dialog(parent_options.clone());
+        self.add_dialog = Self::create_add_dialog(parent_options);
+    }
+
+    fn ensure_loaded(&mut self, api_client: Option<&ApiClient>) {
+        if self.is_loading || self.initial_load_done {
+            return;
+        }
+        if let Some(client) = api_client {
+            self.load_zones(client, None);
+        }
+    }
+
+    /// Load zones with optional filter
+    fn load_zones(&mut self, api_client: &ApiClient, filter: Option<serde_json::Value>) {
+        use crate::core::tables::get_all_zones_with_filter;
+
+        self.is_loading = true;
+        self.last_error = None;
+        match get_all_zones_with_filter(api_client, filter) {
+            Ok(list) => {
+                self.zones = list;
+                self.is_loading = false;
+                self.initial_load_done = true;
+                // Update editor dropdowns with new zone list
+                self.update_editor_dropdowns();
+            }
+            Err(e) => {
+                self.last_error = Some(e.to_string());
+                self.is_loading = false;
+                self.initial_load_done = true;
+            }
+        }
+    }
+
+    /// Refresh zones data from the API
+    pub fn refresh(&mut self, api_client: Option<&ApiClient>) {
+        self.zones.clear();
+        self.is_loading = false;
+        self.initial_load_done = false;
+        self.zone_assets.clear();
+        self.zone_assets_attempted.clear();
+        self.zone_assets_failed.clear();
+        self.last_error = None;
+        self.ensure_loaded(api_client);
+    }
+
+    pub fn show(
+        &mut self,
+        ui: &mut egui::Ui,
+        api_client: Option<&ApiClient>,
+        ribbon: &mut crate::ui::ribbon::RibbonUI,
+    ) {
+        self.ensure_loaded(api_client);
+
+        // Handle filter changes from FilterBuilder
+        if ribbon
+            .checkboxes
+            .get("zones_filter_changed")
+            .copied()
+            .unwrap_or(false)
+        {
+            ribbon
+                .checkboxes
+                .insert("zones_filter_changed".to_string(), false);
+            if let Some(client) = api_client {
+                self.last_error = None;
+
+                // Get user-defined filters from FilterBuilder
+                let user_filter = ribbon.filter_builder.get_filter_json("zones");
+
+                // Debug: Log the filter to see what we're getting
+                if let Some(ref cf) = user_filter {
+                    log::info!("Zones filter: {:?}", cf);
+                } else {
+                    log::info!("No filter conditions (showing all zones)");
+                }
+
+                self.load_zones(client, user_filter);
+            }
+        }
+
+        // Handle ribbon actions
+        if ribbon
+            .checkboxes
+            .get("zones_action_add")
+            .copied()
+            .unwrap_or(false)
+        {
+            self.update_editor_dropdowns();
+            self.add_dialog.open_new(None);
+        }
+        if ribbon
+            .checkboxes
+            .get("zones_action_edit")
+            .copied()
+            .unwrap_or(false)
+        {
+            // Edit needs a selected zone - will be handled via context menu
+            log::info!("Edit zone clicked - use right-click context menu on a zone");
+        }
+        if ribbon
+            .checkboxes
+            .get("zones_action_remove")
+            .copied()
+            .unwrap_or(false)
+        {
+            // Remove needs a selected zone - will be handled via context menu
+            log::info!("Remove zone clicked - use right-click context menu on a zone");
+        }
+
+        // Update show_items from ribbon
+        self.show_items = ribbon
+            .checkboxes
+            .get("zones_show_items")
+            .copied()
+            .unwrap_or(false);
+
+        // Get show_empty preference from ribbon
+        let show_empty = ribbon
+            .checkboxes
+            .get("zones_show_empty")
+            .copied()
+            .unwrap_or(true);
+
+        ui.horizontal(|ui| {
+            ui.heading("Zones");
+            if self.is_loading {
+                ui.spinner();
+                ui.label("Loading zones...");
+            }
+            if let Some(err) = &self.last_error {
+                ui.colored_label(egui::Color32::RED, err);
+                if ui.button("Refresh").clicked() {
+                    self.refresh(api_client);
+                }
+            }
+            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                if ui.button("Collapse All").clicked() {
+                    self.set_all_open(false, ui.ctx());
+                }
+                if ui.button("Expand All").clicked() {
+                    self.set_all_open(true, ui.ctx());
+                }
+                if ui.button("➕ Add Zone").clicked() {
+                    self.update_editor_dropdowns();
+                    self.add_dialog.open_new(None);
+                }
+            });
+        });
+
+        // Search bar
+        ui.horizontal(|ui| {
+            ui.label("Search:");
+            ui.text_edit_singleline(&mut self.search_query);
+            if ui.button("Clear").clicked() {
+                self.search_query.clear();
+            }
+        });
+
+        ui.separator();
+
+        // If there was an error loading zones, stop here until user refreshes
+        if self.last_error.is_some() {
+            return;
+        }
+        if self.zones.is_empty() {
+            return;
+        }
+
+        // Default: expand all once on first successful load
+        // Filter zones by search query (case-insensitive)
+        let search_lower = self.search_query.to_lowercase();
+        let filtered_zones: Vec<serde_json::Value> = self
+            .zones
+            .iter()
+            .filter(|z| {
+                // Apply search filter
+                if !search_lower.is_empty() {
+                    let code_match = z
+                        .get("zone_code")
+                        .and_then(|v| v.as_str())
+                        .map(|s| s.to_lowercase().contains(&search_lower))
+                        .unwrap_or(false);
+                    let mini_match = z
+                        .get("mini_code")
+                        .and_then(|v| v.as_str())
+                        .map(|s| s.to_lowercase().contains(&search_lower))
+                        .unwrap_or(false);
+                    let name_match = z
+                        .get("name")
+                        .or_else(|| z.get("zone_name"))
+                        .and_then(|v| v.as_str())
+                        .map(|s| s.to_lowercase().contains(&search_lower))
+                        .unwrap_or(false);
+                    if !code_match && !mini_match && !name_match {
+                        return false;
+                    }
+                }
+
+                // Apply empty filter
+                if !show_empty {
+                    let zone_id = z.get("id").and_then(|v| v.as_i64()).map(|v| v as i32);
+                    if let Some(id) = zone_id {
+                        // Only show zones that have items or have descendants with items
+                        if !self.zone_or_descendants_have_items(id, &self.zones) {
+                            return false;
+                        }
+                    }
+                }
+
+                true
+            })
+            .cloned()
+            .collect();
+
+        // Build parent -> children map
+        let mut children: HashMap<Option<i32>, Vec<serde_json::Value>> = HashMap::new();
+        for z in &filtered_zones {
+            let parent = z
+                .get("parent_id")
+                .and_then(|v| v.as_i64())
+                .map(|v| v as i32);
+            children.entry(parent).or_default().push(z.clone());
+        }
+        // Sort children lists by zone_code
+        for list in children.values_mut() {
+            list.sort_by(|a, b| {
+                a.get("zone_code")
+                    .and_then(|v| v.as_str())
+                    .cmp(&b.get("zone_code").and_then(|v| v.as_str()))
+            });
+        }
+
+        // Render roots (parent = None)
+        if let Some(roots) = children.get(&None) {
+            egui::ScrollArea::both()
+                .auto_shrink([false; 2])
+                .show(ui, |ui| {
+                    for root in roots {
+                        self.render_zone_node(ui, root, &children, api_client);
+                    }
+                });
+        }
+
+        // Clear the one-shot expand/collapse request after applying it
+        if self.force_expand_state.is_some() {
+            self.force_expand_state = None;
+        }
+
+        // Show zone editor dialogs
+        if let Some(result) = self.edit_dialog.show_editor(ui.ctx()) {
+            if let Some(updated) = result {
+                log::info!("Zone updated: {:?}", updated);
+                if let Some(client) = api_client {
+                    self.update_zone(client, &updated);
+                }
+            }
+        }
+
+        if let Some(result) = self.add_dialog.show_editor(ui.ctx()) {
+            if let Some(new_zone) = result {
+                log::info!("Zone added: {:?}", new_zone);
+                if let Some(client) = api_client {
+                    self.create_zone(client, &new_zone);
+                }
+            }
+        }
+
+        // Show delete confirmation dialog
+        if let Some(should_delete) = self.delete_dialog.show_dialog(ui.ctx()) {
+            if should_delete {
+                if let Some(zone_id) = self.pending_delete_id {
+                    log::info!("Deleting zone ID: {}", zone_id);
+                    if let Some(client) = api_client {
+                        self.delete_zone(client, zone_id);
+                    }
+                }
+            }
+            self.pending_delete_id = None;
+        }
+
+        // Show print dialog
+        if let Some(print_dialog) = &mut self.print_dialog {
+            let print_complete =
+                print_dialog.show(ui.ctx(), &mut self.show_print_dialog, api_client);
+            if print_complete || !self.show_print_dialog {
+                self.print_dialog = None;
+            }
+        }
+    }
+
+    fn render_zone_node(
+        &mut self,
+        ui: &mut egui::Ui,
+        zone: &serde_json::Value,
+        children: &HashMap<Option<i32>, Vec<serde_json::Value>>,
+        api_client: Option<&ApiClient>,
+    ) {
+        let id = zone.get("id").and_then(|v| v.as_i64()).unwrap_or_default() as i32;
+        let code = zone
+            .get("zone_code")
+            .and_then(|v| v.as_str())
+            .unwrap_or("?");
+        let mini = zone.get("mini_code").and_then(|v| v.as_str()).unwrap_or("");
+        let name = zone.get("name").and_then(|v| v.as_str()).unwrap_or("");
+        let label = if mini.is_empty() {
+            format!("{} — {}", code, name)
+        } else {
+            // Subtle mini code display in parentheses
+            format!("{} — {} ({})", code, name, mini)
+        };
+
+        let mut header = egui::CollapsingHeader::new(label.clone())
+            .id_salt(("zone", id))
+            .default_open(true);
+
+        if let Some(force) = self.force_expand_state {
+            let ctx = ui.ctx();
+            let id_key = egui::Id::new(label.clone()).with(("zone", id));
+            let mut state = egui::collapsing_header::CollapsingState::load_with_default_open(
+                ctx, id_key, force,
+            );
+            state.set_open(force);
+            state.store(ctx);
+
+            header = header.open(Some(force));
+        }
+
+        let resp = header.show(ui, |ui| {
+            // Children zones
+            if let Some(kids) = children.get(&Some(id)) {
+                ui.indent(egui::Id::new(("zone_indent", id)), |ui| {
+                    for child in kids {
+                        self.render_zone_node(ui, child, children, api_client);
+                    }
+                });
+            }
+
+            // Optional: items in this zone
+            if self.show_items {
+                ui.indent(egui::Id::new(("zone_items", id)), |ui| {
+                    ui.spacing_mut().item_spacing.y = 2.0;
+                    // Load from cache or fetch
+                    if !self.zone_assets.contains_key(&id)
+                        && !self.zone_assets_attempted.contains(&id)
+                        && !self.zone_assets_failed.contains(&id)
+                    {
+                        self.zone_assets_attempted.insert(id);
+                        if let Some(client) = api_client {
+                            match get_assets_in_zone(client, id, Some(200)) {
+                                Ok(list) => {
+                                    self.zone_assets.insert(id, list);
+                                }
+                                Err(e) => {
+                                    self.zone_assets_failed.insert(id);
+                                    ui.colored_label(
+                                        egui::Color32::RED,
+                                        format!("Failed to load items: {}", e),
+                                    );
+                                }
+                            }
+                        }
+                    }
+                    if self.zone_assets_failed.contains(&id) && !self.zone_assets.contains_key(&id)
+                    {
+                        ui.colored_label(
+                            egui::Color32::RED,
+                            "(items failed to load – use Refresh at top)",
+                        );
+                    }
+                    if let Some(items) = self.zone_assets.get(&id) {
+                        for a in items {
+                            let tag = a.get("asset_tag").and_then(|v| v.as_str()).unwrap_or("?");
+                            let nm = a.get("name").and_then(|v| v.as_str()).unwrap_or("");
+                            let status = a.get("status").and_then(|v| v.as_str()).unwrap_or("");
+                            ui.label(format!("• [{}] {} ({})", tag, nm, status));
+                        }
+                        if items.is_empty() {
+                            ui.label("(no items)");
+                        }
+                    }
+                });
+            }
+        });
+
+        // Add context menu to header for editing
+        resp.header_response.context_menu(|ui| {
+            if ui
+                .button(format!("{} Edit Zone", egui_phosphor::regular::PENCIL))
+                .clicked()
+            {
+                // Update dropdowns with current zone list
+                self.update_editor_dropdowns();
+
+                // Map the zone data to match the editor field names
+                if let Some(zone_obj) = zone.as_object() {
+                    let mut zone_for_editor = zone_obj.clone();
+
+                    // The data comes in with "name" (aliased from zone_name), but editor expects "zone_name"
+                    if let Some(name_value) = zone_for_editor.remove("name") {
+                        zone_for_editor.insert("zone_name".to_string(), name_value);
+                    }
+
+                    // Convert integer fields to strings if they're numbers
+                    if let Some(audit_timeout) = zone_for_editor.get("audit_timeout_minutes") {
+                        if let Some(num) = audit_timeout.as_i64() {
+                            zone_for_editor.insert(
+                                "audit_timeout_minutes".to_string(),
+                                serde_json::json!(num.to_string()),
+                            );
+                        }
+                    }
+
+                    self.edit_dialog
+                        .open(&serde_json::Value::Object(zone_for_editor));
+                    ui.close();
+                } else {
+                    log::error!("Zone data is not an object, cannot edit");
+                }
+            }
+            if ui
+                .button(format!("{} Delete Zone", egui_phosphor::regular::TRASH))
+                .clicked()
+            {
+                self.pending_delete_id = Some(id);
+                self.delete_dialog
+                    .open(format!("{} - {}", code, name), id.to_string());
+                ui.close();
+            }
+            ui.separator();
+            if ui
+                .button(format!("{} Add Child Zone", egui_phosphor::regular::PLUS))
+                .clicked()
+            {
+                // Open add dialog with parent_id pre-filled
+                self.pending_parent_id = Some(id);
+                self.update_editor_dropdowns();
+
+                // Create initial data with parent_id
+                let mut initial_data = serde_json::Map::new();
+                initial_data.insert("parent_id".to_string(), serde_json::json!(id.to_string()));
+
+                self.add_dialog.open_new(Some(&initial_data));
+                ui.close();
+            }
+            if ui
+                .button(format!(
+                    "{} Show Items in this Zone",
+                    egui_phosphor::regular::PACKAGE
+                ))
+                .clicked()
+            {
+                // Set the flag to switch to inventory with this zone filter
+                self.switch_to_inventory_with_zone = Some(code.to_string());
+                ui.close();
+            }
+            if ui
+                .button(format!(
+                    "{} Print Zone Label",
+                    egui_phosphor::regular::PRINTER
+                ))
+                .clicked()
+            {
+                // Prepare zone data for printing
+                let mut print_data = std::collections::HashMap::new();
+                print_data.insert("zone_code".to_string(), code.to_string());
+                print_data.insert("zone_name".to_string(), name.to_string());
+
+                // Extract additional fields from zone JSON
+                if let Some(zone_type) = zone.get("zone_type").and_then(|v| v.as_str()) {
+                    print_data.insert("zone_type".to_string(), zone_type.to_string());
+                }
+                if let Some(zone_barcode) = zone.get("zone_barcode").and_then(|v| v.as_str()) {
+                    print_data.insert("zone_barcode".to_string(), zone_barcode.to_string());
+                }
+
+                // Create new print dialog with zone data
+                self.print_dialog = Some(crate::core::print::PrintDialog::new(print_data));
+                self.show_print_dialog = true;
+                ui.close();
+            }
+            ui.separator();
+            if ui
+                .button(format!("{} Clone Zone", egui_phosphor::regular::COPY))
+                .clicked()
+            {
+                // Open add dialog prefilled with cloned values
+                self.update_editor_dropdowns();
+
+                // Start from original zone object
+                let mut clone_map = zone.as_object().cloned().unwrap_or_default();
+
+                // Editor expects zone_name instead of name
+                if let Some(name_val) = clone_map.remove("name") {
+                    clone_map.insert("zone_name".to_string(), name_val);
+                }
+
+                // Clear identifiers and codes that must be unique
+                clone_map.remove("id");
+                clone_map.insert(
+                    "zone_code".to_string(),
+                    serde_json::Value::String(String::new()),
+                );
+                // Mini code is required but typically unique — leave empty to force user choice
+                clone_map.insert(
+                    "mini_code".to_string(),
+                    serde_json::Value::String(String::new()),
+                );
+
+                // Convert parent_id to string for dropdown if present
+                if let Some(p) = clone_map.get("parent_id").cloned() {
+                    let as_str = match p {
+                        serde_json::Value::Number(n) => {
+                            n.as_i64().map(|i| i.to_string()).unwrap_or_default()
+                        }
+                        serde_json::Value::String(s) => s,
+                        _ => String::new(),
+                    };
+                    clone_map.insert("parent_id".to_string(), serde_json::Value::String(as_str));
+                }
+
+                // Ensure audit_timeout_minutes is string
+                if let Some(a) = clone_map.get("audit_timeout_minutes").cloned() {
+                    if let Some(num) = a.as_i64() {
+                        clone_map.insert(
+                            "audit_timeout_minutes".to_string(),
+                            serde_json::json!(num.to_string()),
+                        );
+                    }
+                }
+
+                // Suffix the name to indicate copy
+                if let Some(serde_json::Value::String(nm)) = clone_map.get_mut("zone_name") {
+                    nm.push_str("");
+                }
+
+                // Open prefilled Add dialog
+                self.add_dialog.open_new(Some(&clone_map));
+                ui.close();
+            }
+        });
+    }
+
+    /// Create a new zone via API
+    fn create_zone(
+        &mut self,
+        api_client: &ApiClient,
+        zone_data: &serde_json::Map<String, serde_json::Value>,
+    ) {
+        use crate::models::QueryRequest;
+
+        // Clean the data - remove empty parent_id and convert audit_timeout_minutes to integer
+        let mut clean_data = zone_data.clone();
+
+        if let Some(parent_id) = clean_data.get("parent_id") {
+            if parent_id.as_str() == Some("") || parent_id.is_null() {
+                clean_data.remove("parent_id");
+            }
+        }
+
+        // Do not auto-generate full zone_code here; use user-provided value as-is for now.
+
+        // Convert audit_timeout_minutes string to integer if present and not empty
+        if let Some(audit_timeout) = clean_data.get("audit_timeout_minutes") {
+            if let Some(s) = audit_timeout.as_str() {
+                if !s.is_empty() {
+                    if let Ok(num) = s.parse::<i64>() {
+                        clean_data
+                            .insert("audit_timeout_minutes".to_string(), serde_json::json!(num));
+                    }
+                } else {
+                    clean_data.remove("audit_timeout_minutes");
+                }
+            }
+        }
+
+        let request = QueryRequest {
+            action: "insert".to_string(),
+            table: "zones".to_string(),
+            columns: None,
+            data: Some(serde_json::Value::Object(clean_data)),
+            r#where: None,
+            filter: None,
+            order_by: None,
+            limit: None,
+            offset: None,
+            joins: None,
+        };
+
+        match api_client.query(&request) {
+            Ok(response) => {
+                if response.success {
+                    self.refresh(Some(api_client));
+                } else {
+                    log::error!("Failed to create zone: {:?}", response.error);
+                }
+            }
+            Err(e) => {
+                log::error!("Error creating zone: {}", e);
+            }
+        }
+    }
+
+    /// Update an existing zone via API
+    fn update_zone(
+        &mut self,
+        api_client: &ApiClient,
+        zone_data: &serde_json::Map<String, serde_json::Value>,
+    ) {
+        use crate::models::QueryRequest;
+
+        // Try to get ID from various possible locations
+        let zone_id = zone_data
+            .get("id")
+            .and_then(|v| {
+                v.as_i64()
+                    .or_else(|| v.as_str().and_then(|s| s.parse().ok()))
+            })
+            .or_else(|| {
+                // Check for __editor_item_id which is set by the editor for read-only ID fields
+                zone_data
+                    .get("__editor_item_id")
+                    .and_then(|v| v.as_str().and_then(|s| s.parse().ok()))
+            })
+            .unwrap_or_else(|| {
+                log::error!("Zone update attempted without ID");
+                0
+            });
+
+        // Create a clean data object without the editor metadata and without the id field
+        let mut clean_data = zone_data.clone();
+        clean_data.remove("__editor_item_id");
+        clean_data.remove("id"); // Don't include id in the update data, only in WHERE
+
+        // Remove empty parent_id
+        if let Some(parent_id) = clean_data.get("parent_id") {
+            if parent_id.as_str() == Some("") || parent_id.is_null() {
+                clean_data.remove("parent_id");
+            }
+        }
+
+        // Do not auto-generate full zone_code during updates either; keep user value intact.
+
+        // Convert audit_timeout_minutes string to integer if present and not empty
+        if let Some(audit_timeout) = clean_data.get("audit_timeout_minutes") {
+            if let Some(s) = audit_timeout.as_str() {
+                if !s.is_empty() {
+                    if let Ok(num) = s.parse::<i64>() {
+                        clean_data
+                            .insert("audit_timeout_minutes".to_string(), serde_json::json!(num));
+                    }
+                } else {
+                    clean_data.remove("audit_timeout_minutes");
+                }
+            }
+        }
+
+        let request = QueryRequest {
+            action: "update".to_string(),
+            table: "zones".to_string(),
+            columns: None,
+            data: Some(serde_json::Value::Object(clean_data)),
+            r#where: Some(serde_json::json!({
+                "id": zone_id
+            })),
+            filter: None,
+            order_by: None,
+            limit: None,
+            offset: None,
+            joins: None,
+        };
+
+        match api_client.query(&request) {
+            Ok(response) => {
+                if response.success {
+                    self.refresh(Some(api_client));
+                } else {
+                    log::error!("Failed to update zone: {:?}", response.error);
+                }
+            }
+            Err(e) => {
+                log::error!("Error updating zone: {}", e);
+            }
+        }
+    }
+
+    /// Delete a zone via API
+    fn delete_zone(&mut self, api_client: &ApiClient, zone_id: i32) {
+        use crate::models::QueryRequest;
+
+        let request = QueryRequest {
+            action: "delete".to_string(),
+            table: "zones".to_string(),
+            columns: None,
+            data: None,
+            r#where: Some(serde_json::json!({
+                "id": zone_id
+            })),
+            filter: None,
+            order_by: None,
+            limit: None,
+            offset: None,
+            joins: None,
+        };
+
+        match api_client.query(&request) {
+            Ok(response) => {
+                if response.success {
+                    self.refresh(Some(api_client));
+                } else {
+                    log::error!("Failed to delete zone: {:?}", response.error);
+                }
+            }
+            Err(e) => {
+                log::error!("Error deleting zone: {}", e);
+            }
+        }
+    }
+
+    fn set_all_open(&mut self, open: bool, ctx: &egui::Context) {
+        self.force_expand_state = Some(open);
+        ctx.request_repaint();
+    }
+}