br_addon/

tables.rs

use br_db::Db;
use br_fields::Field;
use json::{array, object, JsonValue};
use std::collections::HashMap;

#[allow(clippy::too_many_arguments)]
#[cfg(any(
    feature = "sqlite",
    feature = "mssql",
    feature = "mysql",
    feature = "pgsql"
))]
pub struct Tables {
    /// 主数据表名称
    main_table: String,
    /// 数据库
    db: Db,
    /// 记录总数量
    total: i64,
    /// 字段数据
    fields: Vec<JsonValue>,
    /// 连表查询
    join_params: Vec<Vec<String>>,
    /// 字段值集合
    fields_keys: Vec<String>,
    /// 联表字段
    join_fields: Vec<String>,
    /// 隐藏字段
    hide_fields: Vec<String>,
    /// 显示字段
    show_fields: Vec<String>,
    /// 合计字段
    total_fields: Vec<String>,
    /// 数据
    data: JsonValue,
    /// 页数
    page: usize,
    /// 总页数
    pages: i64,
    /// 每页数量
    limit: usize,
    /// 搜索内容
    search: String,
    /// 搜索字段
    search_fields: Vec<String>,
    /// 搜索框名称
    search_name: String,
    /// 可以编辑字段
    edit_fields: Vec<String>,
    /// 排序
    /// array![array!["id",false]]
    order: JsonValue,
    /// 过滤条件
    /// array![array!["id","=","*"]]
    where_and: JsonValue,
    /// 过滤条件
    /// array![array!["id","=","*"]]
    where_or: JsonValue,
    /// 过滤字段
    filter_fields: Vec<String>,
    /// 表单关联字段
    table_fields: Vec<String>,
    /// 表单关联多选字段
    table_multiple_fields: Vec<String>,
    /// 树形关联字段
    tree_fields: Vec<String>,
    /// JSON字段
    json_fields: Vec<String>,
    /// 地图字段
    location_fields: Vec<String>,
    /// 显示的主键
    primary_key: String,
    /// 选中值
    value: Vec<String>,
    /// 树形pid
    pid_id: String,
    /// 字段索引缓存（field name → field metadata）
    all_fields_map: JsonValue,
}
impl Tables {
    pub fn params_table(mut params: JsonValue) -> JsonValue {
        params["page"] = br_fields::int::Int::new(false, "page", "页数", 10, 1)
            .example(1.into())
            .field();
        params["limit"] = br_fields::int::Int::new(false, "limit", "行数", 10, 10)
            .example(10.into())
            .field();
        params["order"] = br_fields::text::Array::new(false, "order", "排序", array![]).field();
        params["search"] = br_fields::str::Str::new(false, "search", "搜索", 200, "")
            .example("".into())
            .field();
        params["where_or"] = br_fields::text::Array::new(false, "where_or", "查询条件", array![])
            .example(array![])
            .field();
        params["where_and"] = br_fields::text::Array::new(false, "where_and", "查询条件", array![])
            .example(array![])
            .field();
        params["params"] =
            br_fields::text::Object::new(false, "params", "关联数据参数", object! {})
                .describe("如果是表单就是表单里的其他字段")
                .example(object! {})
                .field();
        params
    }
    pub fn params_table_tree(mut params: JsonValue) -> JsonValue {
        params["pid"] = br_fields::str::Str::new(false, "pid", "上级ID", 50, "")
            .example("".into())
            .field();
        Tables::params_table_select(params)
    }
    pub fn params_table_select(mut params: JsonValue) -> JsonValue {
        params["value"] = br_fields::text::Array::new(false, "value", "已选中值", array![]).field();
        params["primary_key"] =
            br_fields::str::Str::new(false, "primary_key", "显示内容的字段", 50, "id").field();
        Tables::params_table(params)
    }
    pub fn params_table_select_tree(mut params: JsonValue) -> JsonValue {
        params["pid"] = br_fields::str::Str::new(false, "pid", "上级ID", 20, "")
            .example("".into())
            .field();
        params["value"] = br_fields::text::Array::new(false, "value", "已选中值", array![]).field();
        Tables::params_table(params)
    }
    pub fn new(db: Db) -> Self {
        Self {
            main_table: "".to_string(),
            db,
            total: 0,
            fields: vec![],
            join_params: vec![],
            fields_keys: vec![],
            data: array![],
            page: 1,
            pages: 0,
            limit: 10,
            search: "".to_string(),
            search_fields: vec![],
            search_name: "".to_string(),
            edit_fields: vec![],
            order: array![],
            where_and: array![],
            where_or: array![],
            filter_fields: vec![],
            table_fields: vec![],
            table_multiple_fields: vec![],
            tree_fields: vec![],
            json_fields: vec![],
            location_fields: vec![],
            primary_key: "".to_string(),
            value: vec![],
            join_fields: vec![],
            hide_fields: vec![],
            show_fields: vec![],
            total_fields: vec![],
            pid_id: "".to_string(),
            all_fields_map: object! {},
        }
    }
    pub fn main_table_fields(
        &mut self,
        table: &str,
        fields: JsonValue,
        hide_fields: Vec<&str>,
        show_fields: Vec<&str>,
    ) -> &mut Self {
        self.main_table = table.to_string();
        self.hide_fields = hide_fields.iter().map(|s| s.to_string()).collect();
        self.show_fields = show_fields.iter().map(|s| s.to_string()).collect();
        self.fields = fields
            .entries()
            .map(|(_, x)| x.clone())
            .collect::<Vec<JsonValue>>();
        self
    }
    pub fn join_fields(&mut self, table: &str, mut fields: JsonValue, index: isize) -> &mut Self {
        for (field, item) in fields.entries_mut() {
            if self.main_table != table {
                item["field"] = format!("{table}_{field}").into();
                item["field_table"] = table.into();
                item["field_table_field"] = field.into();
            }

            match index {
                x if x > -1 => {
                    // 插入
                    self.fields.insert(x as usize, item.clone());
                }
                _ => {
                    // 尾部添加
                    self.fields.push(item.clone());
                }
            }
            self.join_fields.push(format!("{table}.{field}"));
        }
        self
    }
    pub fn fields(&mut self, fields: JsonValue) -> &mut Self {
        self.fields = fields
            .entries()
            .map(|(_, x)| x.clone())
            .collect::<Vec<JsonValue>>();
        self
    }
    pub fn hide_fields(&mut self, hide_fields: Vec<&str>) -> &mut Self {
        self.hide_fields = hide_fields.iter().map(|s| s.to_string()).collect();
        self
    }
    pub fn show_fields(&mut self, show_fields: Vec<&str>) -> &mut Self {
        self.show_fields = show_fields.iter().map(|s| s.to_string()).collect();
        self
    }
    pub fn total_fields(&mut self, fields: Vec<&str>) -> &mut Self {
        self.total_fields = fields.iter().map(|s| s.to_string()).collect();
        self
    }
    fn set_fields(&mut self, field: &str, mode: &str) {
        match mode {
            "table" => self.table_fields.push(field.to_string()),
            "table_multiple" => {
                self.table_multiple_fields.push(field.to_string());
                self.json_fields.push(field.to_string());
            }
            "tree" => self.tree_fields.push(field.to_string()),
            "object" | "array" | "polygon" | "select" | "location_address" => {
                self.json_fields.push(field.to_string())
            }
            "location" => self.location_fields.push(field.to_string()),
            _ => {}
        }
    }
    pub fn join_table(
        &mut self,
        main_table: &str,
        main_field: &str,
        join_table: &str,
        join_field: &str,
    ) -> &mut Self {
        self.join_params.push(vec![
            main_table.to_string(),
            main_field.to_string(),
            join_table.to_string(),
            join_field.to_string(),
        ]);
        self
    }
    pub fn main_select_fields(&mut self, table: &str, mut show_fields: Vec<&str>) -> &mut Self {
        self.main_table = table.to_string();
        show_fields.insert(0, "id");
        self.fields_keys = show_fields.into_iter().map(|x| x.to_string()).collect();
        self.search_fields = self.fields_keys.clone();
        self
    }

    pub fn edit_fields(&mut self, fields: Vec<&str>) -> &mut Self {
        self.edit_fields = fields.iter().map(|s| s.to_string()).collect();
        self
    }
    pub fn search_fields(&mut self, fields: Vec<&str>) -> &mut Self {
        let mut search_name = vec![];
        let all_fields = self
            .fields
            .iter()
            .map(|x| (x["field"].to_string(), x.clone()))
            .collect::<HashMap<String, JsonValue>>();
        for key in fields.clone() {
            if let Some(field_info) = all_fields.get(key) {
                self.search_fields.push(key.to_string());
                search_name.push(field_info["title"].to_string());
            }
        }
        self.search_name = search_name.join("/");
        self
    }
    /// 条件过滤
    pub fn filter_fields(&mut self, fields: Vec<&str>) -> &mut Self {
        let all_fields = self
            .fields
            .iter()
            .map(|x| (x["field"].to_string(), x.clone()))
            .collect::<HashMap<String, JsonValue>>();
        for key in fields.clone() {
            if all_fields.contains_key(key) {
                self.filter_fields.push(key.to_string());
            } else {
                log::warn!(
                    "filter_fields: unknown field '{}' in table '{}'",
                    key,
                    self.main_table
                );
            }
        }
        self
    }
    /// 请求参数
    pub fn params(&mut self, request: JsonValue) -> &mut Self {
        if request.has_key("page") {
            self.page = request["page"].as_usize().unwrap_or(1);
        }
        if request.has_key("limit") {
            self.limit = request["limit"].as_usize().unwrap_or(10);
        }
        if request.has_key("where_and") {
            self.where_and = request["where_and"].clone();
        }
        if request.has_key("where_or") {
            self.where_or = request["where_or"].clone();
        }

        if request.has_key("pid") {
            self.pid_id = if let Some(s) = request["pid"].as_str() {
                s.to_string()
            } else if request["pid"].is_number() {
                request["pid"].to_string()
            } else {
                String::new()
            };
        }

        if request.has_key("order") {
            for item in request["order"].members() {
                let _ = self.order.push(item.clone());
            }
        }
        if request.has_key("search") {
            self.search = request["search"].as_str().unwrap_or("").to_string();
        }
        if request.has_key("primary_key") {
            self.primary_key = request["primary_key"].as_str().unwrap_or("").to_string();
        }
        if request.has_key("value") {
            self.value = request["value"]
                .members()
                .map(|x| x.as_str().unwrap_or("").to_string())
                .filter(|x| !x.is_empty())
                .collect();
        }
        self
    }

    fn db_search(&mut self) {
        if !self.search.is_empty() {
            let mut t = vec![];
            for value in self.search_fields.clone() {
                let field = self.all_fields_map[value.as_str()].clone();
                if field.has_key("field_table") {
                    t.push(format!(
                        "{}.{}",
                        field["field_table"].clone(),
                        field["field_table_field"].clone()
                    ));
                } else {
                    t.push(value);
                }
            }
            self.db
                .where_and(&t.join("|"), "like", format!("%{}%", self.search).into());
        }
    }
    fn db_where(&mut self) {
        for value in self.where_or.members() {
            let field = self.all_fields_map[value[0].to_string()].clone();
            if field.has_key("field_table") {
                self.db.where_or(
                    format!(
                        "{}.{}",
                        field["field_table"].clone(),
                        field["field_table_field"].clone()
                    )
                    .as_str(),
                    value[1].as_str().unwrap_or("="),
                    value[2].clone(),
                );
            } else {
                self.db.where_or(
                    value[0].as_str().unwrap_or_default(),
                    value[1].as_str().unwrap_or("="),
                    value[2].clone(),
                );
            }
        }
        for value in self.where_and.members() {
            let field_name = value[0].as_str().unwrap_or_default();
            let field = self.all_fields_map[field_name].clone();

            // table_multiple 字段是 JSON 数组 TEXT 列，用 LIKE + where_or 匹配
            if self.table_multiple_fields.contains(&field_name.to_string()) {
                let filter_ids: Vec<String> = if value[2].is_array() {
                    value[2]
                        .members()
                        .filter_map(|v| {
                            let s = v.as_str().unwrap_or("");
                            if s.is_empty() {
                                None
                            } else {
                                Some(s.to_string())
                            }
                        })
                        .collect()
                } else {
                    let s = value[2].as_str().unwrap_or("");
                    s.split(',')
                        .map(|x| x.trim().to_string())
                        .filter(|x| !x.is_empty())
                        .collect()
                };
                if filter_ids.is_empty() {
                    continue;
                }
                for id in &filter_ids {
                    self.db
                        .where_or(field_name, "like", format!("%{}%", id).into());
                }
                continue;
            }

            if field.has_key("field_table") {
                self.db.where_and(
                    format!(
                        "{}.{}",
                        field["field_table"].clone(),
                        field["field_table_field"].clone()
                    )
                    .as_str(),
                    value[1].as_str().unwrap_or("="),
                    value[2].clone(),
                );
            } else {
                self.db.where_and(
                    value[0].as_str().unwrap_or_default(),
                    value[1].as_str().unwrap_or("="),
                    value[2].clone(),
                );
            }
        }
    }
    fn db_order(&mut self) {
        for item in self.order.members() {
            let field = self.all_fields_map[item[0].to_string()].clone();
            if field.has_key("field_table") {
                self.db.order(
                    format!(
                        "{}.{}",
                        field["field_table"].clone(),
                        field["field_table_field"].clone()
                    )
                    .as_str(),
                    item[1].as_bool().unwrap_or(false),
                );
            } else {
                self.db.order(
                    format!("{}.{}", self.main_table, item[0]).as_str(),
                    item[1].as_bool().unwrap_or(false),
                );
            }
        }
    }
    fn db_fields(&mut self) {
        let mut all_fields = object! {};
        let _ = self
            .fields
            .iter()
            .map(|x| all_fields.insert(x["field"].as_str().unwrap_or_default(), x.clone()))
            .collect::<Vec<_>>();

        if !self.hide_fields.is_empty() {
            for field in self.hide_fields.clone() {
                if all_fields.has_key(&field) {
                    all_fields.remove(&field);
                    continue;
                }
            }
        }

        if !self.show_fields.is_empty() {
            self.show_fields.insert(0, "id".to_string());
            let mut f = object! {};
            for field in self.show_fields.clone() {
                if all_fields.has_key(&field) {
                    let _ = f.insert(&field.clone(), all_fields[field].clone());
                }
            }
            all_fields = f;
        }

        for (field, item) in all_fields.entries() {
            let mode = item["mode"].to_string();
            self.set_fields(field, mode.as_str());
        }

        self.fields = all_fields
            .entries()
            .map(|(_, x)| x.clone())
            .collect::<Vec<JsonValue>>();

        self.all_fields_map = all_fields;

        if !self.fields_keys.is_empty() {
            self.db.field(self.fields_keys.join(",").as_str());
        }
        if !self.json_fields.is_empty() {
            self.db.json(self.json_fields.join(",").as_str());
        }
        if !self.location_fields.is_empty() {
            self.db.location(self.location_fields.join(",").as_str());
        }
    }
    fn db_join(&mut self) {
        if !self.join_fields.is_empty() {
            self.db
                .join_fields(self.join_fields.iter().map(|x| x.as_str()).collect());
        }
        for item in self.join_params.iter() {
            self.db.join(&item[0], &item[1], &item[2], &item[3]);
        }
    }
    fn db_total(&mut self) {
        self.total = self.db.clone().count().as_i64().unwrap_or(0);
        self.pages = if self.limit > 0 {
            (self.total + self.limit as i64 - 1) / self.limit as i64
        } else {
            0
        };
    }
    fn resolve_table_field_batch(&mut self, field: &str) -> JsonValue {
        let field_info = self.all_fields_map[field].clone();
        let mut info = field_info.clone();
        let _ = info["fields"].push("id");
        let fields_k = info["fields"]
            .members()
            .map(|x| x.as_str().unwrap_or_default())
            .collect::<Vec<&str>>();
        let table_name = info["table"].as_str().unwrap_or_default().to_string();
        let field_str = fields_k.join(",");

        let mut ids: Vec<String> = vec![];
        for item in self.data.members() {
            let key = item[field].as_str().unwrap_or("");
            if !key.is_empty() && !ids.contains(&key.to_string()) {
                ids.push(key.to_string());
            }
        }

        let mut lookup = object! {};
        if ids.is_empty() {
            return lookup;
        }

        let rows = self
            .db
            .table(&table_name)
            .where_and("id", "in", ids.into())
            .field(&field_str)
            .select();
        for mut row in rows.members().cloned() {
            let id = row["id"]
                .as_str()
                .map(|s| s.to_string())
                .unwrap_or_else(|| row["id"].to_string());
            row.remove("id");
            let label = row
                .entries()
                .map(|(_, v)| {
                    v.as_str()
                        .map(|s| s.to_string())
                        .unwrap_or_else(|| v.to_string())
                })
                .collect::<Vec<String>>();
            lookup[id.as_str()] = object! {
                value: id.clone(),
                label: label.join(" | ").clone(),
            };
        }
        lookup
    }

    fn resolve_table_multiple_field_batch(&mut self, field: &str) -> JsonValue {
        let field_info = self.all_fields_map[field].clone();
        let mut info = field_info.clone();
        let _ = info["fields"].push("id");
        let fields_k = info["fields"]
            .members()
            .map(|x| x.as_str().unwrap_or_default())
            .collect::<Vec<&str>>();
        let table_name = info["table"].as_str().unwrap_or_default().to_string();
        let field_str = fields_k.join(",");

        let mut ids: Vec<String> = vec![];
        for item in self.data.members() {
            let arr = &item[field];
            if arr.is_array() {
                for id_val in arr.members() {
                    let key = id_val.as_str().unwrap_or("");
                    if !key.is_empty() && !ids.contains(&key.to_string()) {
                        ids.push(key.to_string());
                    }
                }
            }
        }

        let mut lookup = object! {};
        if ids.is_empty() {
            return lookup;
        }

        let rows = self
            .db
            .table(&table_name)
            .where_and("id", "in", ids.into())
            .field(&field_str)
            .select();
        for mut row in rows.members().cloned() {
            let id = row["id"]
                .as_str()
                .map(|s| s.to_string())
                .unwrap_or_else(|| row["id"].to_string());
            row.remove("id");
            let label = row
                .entries()
                .map(|(_, v)| {
                    v.as_str()
                        .map(|s| s.to_string())
                        .unwrap_or_else(|| v.to_string())
                })
                .collect::<Vec<String>>();
            lookup[id.as_str()] = object! {
                value: id.clone(),
                label: label.join(" | ").clone(),
            };
        }
        lookup
    }

    fn resolve_tree_field(&mut self, field: &str, table_data: &mut JsonValue, key: &str) {
        if table_data[field].has_key(key) {
            return;
        }
        let field_info = self.all_fields_map[field].clone();
        let mut info = field_info.clone();
        let pid_field = info["pid_field"].clone().to_string();
        let _ = info["fields"].push("id");
        let _ = info["fields"].push(pid_field.clone());
        let fields_k = info["fields"]
            .members()
            .map(|x| x.as_str().unwrap_or_default())
            .collect::<Vec<&str>>();
        let table_name = info["table"].as_str().unwrap_or_default().to_string();
        let field_str = fields_k.join(",");

        let mut find = self
            .db
            .table(&table_name)
            .where_and("id", "=", key.into())
            .field(&field_str)
            .find();
        let mut pid = find[pid_field.clone()]
            .as_str()
            .map(|s| s.to_string())
            .unwrap_or_else(|| find[pid_field.clone()].to_string());
        let mut name_list = vec![];
        let id = find["id"]
            .as_str()
            .map(|s| s.to_string())
            .unwrap_or_else(|| find["id"].to_string());
        find.remove("id");
        find.remove(&pid_field);
        let label = find
            .entries()
            .map(|(_, v)| {
                v.as_str()
                    .map(|s| s.to_string())
                    .unwrap_or_else(|| v.to_string())
            })
            .collect::<Vec<String>>();
        name_list.push(label.join(" | ").clone());
        loop {
            if pid.is_empty() {
                break;
            }
            let mut t = self
                .db
                .table(&table_name)
                .where_and("id", "=", pid.clone().into())
                .field(&field_str)
                .find();
            pid = t[pid_field.clone()]
                .as_str()
                .map(|s| s.to_string())
                .unwrap_or_else(|| t[pid_field.clone()].to_string());
            t.remove("id");
            t.remove(&pid_field);
            let label = t
                .entries()
                .map(|(_, v)| {
                    v.as_str()
                        .map(|s| s.to_string())
                        .unwrap_or_else(|| v.to_string())
                })
                .collect::<Vec<String>>();
            name_list.push(label.join(" | ").clone());
        }
        name_list.reverse();
        if !table_data.has_key(field) {
            table_data[field] = object! {};
        }
        table_data[field][key] = object! {
            value: id.clone(),
            label: name_list.join("/").clone(),
        };
    }

    fn db_table(&mut self) {
        let mut table_lookups: HashMap<String, JsonValue> = HashMap::new();
        for field in self.table_fields.clone() {
            table_lookups.insert(field.clone(), self.resolve_table_field_batch(&field));
        }

        let mut multiple_lookups: HashMap<String, JsonValue> = HashMap::new();
        for field in self.table_multiple_fields.clone() {
            multiple_lookups.insert(
                field.clone(),
                self.resolve_table_multiple_field_batch(&field),
            );
        }

        let mut tree_data = object! {};
        let tree_fields = self.tree_fields.clone();
        let mut tree_keys: Vec<(String, String)> = vec![];
        for item in self.data.members() {
            for field in tree_fields.iter() {
                let key = item[field].as_str().unwrap_or("");
                if !key.is_empty() {
                    tree_keys.push((field.clone(), key.to_string()));
                }
            }
        }
        for (field, key) in tree_keys {
            self.resolve_tree_field(&field, &mut tree_data, &key);
        }

        for item in self.data.members_mut() {
            for field in self.table_fields.iter() {
                let key = item[field].as_str().unwrap_or("");
                if key.is_empty() {
                    continue;
                }
                if let Some(lookup) = table_lookups.get(field.as_str()) {
                    if lookup.has_key(key) {
                        item[field] = lookup[key].clone();
                    }
                }
            }
            for field in tree_fields.iter() {
                let key = item[field].as_str().unwrap_or("");
                if key.is_empty() {
                    continue;
                }
                if tree_data.has_key(field) && tree_data[field].has_key(key) {
                    item[field] = tree_data[field][key].clone();
                }
            }
            for field in self.table_multiple_fields.iter() {
                let ids = item[field].clone();
                if !ids.is_array() || ids.is_empty() {
                    item[field] = array![];
                    continue;
                }
                let mut result = array![];
                if let Some(lookup) = multiple_lookups.get(field.as_str()) {
                    for id_val in ids.members() {
                        let key = id_val.as_str().unwrap_or("");
                        if !key.is_empty() && lookup.has_key(key) {
                            let _ = result.push(lookup[key].clone());
                        }
                    }
                }
                item[field] = result;
            }
        }
    }
    fn db_table_tree(&mut self, pid_field: &str) {
        let mut table_lookups: HashMap<String, JsonValue> = HashMap::new();
        for field in self.table_fields.clone() {
            table_lookups.insert(field.clone(), self.resolve_table_field_batch(&field));
        }

        let mut multiple_lookups: HashMap<String, JsonValue> = HashMap::new();
        for field in self.table_multiple_fields.clone() {
            multiple_lookups.insert(
                field.clone(),
                self.resolve_table_multiple_field_batch(&field),
            );
        }

        let mut tree_data = object! {};
        let tree_fields = self.tree_fields.clone();
        let mut tree_keys: Vec<(String, String)> = vec![];
        for item in self.data.members() {
            for field in tree_fields.iter() {
                let key = item[field].as_str().unwrap_or("");
                if !key.is_empty() {
                    tree_keys.push((field.clone(), key.to_string()));
                }
            }
        }
        for (field, key) in tree_keys {
            self.resolve_tree_field(&field, &mut tree_data, &key);
        }

        for item in self.data.members_mut() {
            let children = self
                .db
                .table(&self.main_table)
                .where_and(pid_field, "=", item["id"].clone())
                .count();
            if children.is_empty() {
                item["isLeaf"] = true.into();
            }

            for field in self.table_fields.iter() {
                let key = item[field].as_str().unwrap_or("");
                if key.is_empty() {
                    continue;
                }
                if let Some(lookup) = table_lookups.get(field.as_str()) {
                    if lookup.has_key(key) {
                        item[field] = lookup[key].clone();
                    }
                }
            }
            for field in tree_fields.iter() {
                let key = item[field].as_str().unwrap_or("");
                if key.is_empty() {
                    continue;
                }
                if tree_data.has_key(field) && tree_data[field].has_key(key) {
                    item[field] = tree_data[field][key].clone();
                }
            }
            for field in self.table_multiple_fields.iter() {
                let ids = item[field].clone();
                if !ids.is_array() || ids.is_empty() {
                    item[field] = array![];
                    continue;
                }
                let mut result = array![];
                if let Some(lookup) = multiple_lookups.get(field.as_str()) {
                    for id_val in ids.members() {
                        let key = id_val.as_str().unwrap_or("");
                        if !key.is_empty() && lookup.has_key(key) {
                            let _ = result.push(lookup[key].clone());
                        }
                    }
                }
                item[field] = result;
            }
        }
    }
    fn columns(&mut self) -> JsonValue {
        let mut all_fields = self.all_fields_map.clone();

        for (_, item) in all_fields.entries_mut() {
            item["name"] = item["field"].clone();
            item["align"] = "center".into();
            item["label"] = item["title"].clone();

            if item["field"].as_str().unwrap_or("") != "id" {
                item["sortable"] = true.into();
            }
            item["dataIndex"] = item["field"].clone();
            item["slotName"] = item["field"].clone();
            item["titleSlotName"] = item["field"].clone();
            match item["mode"].as_str().unwrap_or_default() {
                "string" | "text" => {
                    item["ellipsis"] = true.into();
                    item["tooltip"] = true.into();
                }
                "key" => {
                    item["width"] = 280.into();
                    item["ellipsis"] = true.into();
                }
                _ => {}
            }
        }
        all_fields
    }
    pub fn get_table(&mut self) -> JsonValue {
        self.db.table(&self.main_table);
        self.db_fields();
        self.db_search();
        self.db_where();
        self.db_join();
        self.db_total();
        self.db_order();
        self.db.page(self.page as i32, self.limit as i32);

        self.data = self.db.select();
        self.db_table();

        object! {
            "pages"=>self.pages,
            "total"=>self.total,
            "data"=>self.data.clone(),
            "columns"=>self.columns(),
            "filter_fields"=>self.filter_fields.clone(),
            "search_name"=>self.search_name.clone(),
            "total_fields"=>self.total_fields.clone(),
            "btn_all"=>array![],
            "btn_api"=>array![],
            "btn_ids"=>array![]
        }
    }
    pub fn get_table_menu(&mut self, label_field: &str) -> JsonValue {
        self.db.table(&self.main_table);
        self.db_fields();
        self.db_search();
        self.db_where();
        self.db_join();
        self.db_total();
        self.db_order();
        self.db.page(self.page as i32, self.limit as i32);

        self.data = self.db.select();
        self.db_table();

        object! {
            "pages"=>self.pages,
            "total"=>self.total,
            "data"=>self.data.clone(),
            "columns"=>self.columns(),
            "filter_fields"=>self.filter_fields.clone(),
            "search_name"=>self.search_name.clone(),
            "total_fields"=>self.total_fields.clone(),
            "btn_all"=>array![],
            "btn_api"=>array![],
            "btn_ids"=>array![],
            "label_field"=>label_field
        }
    }

    pub fn get_tree(&mut self, pid_field: &str) -> JsonValue {
        self.db.table(&self.main_table);
        if self.search.is_empty() || !self.pid_id.is_empty() {
            self.db
                .where_and(pid_field, "=", self.pid_id.clone().into());
        }
        self.db_fields();
        self.db_search();
        self.db_where();
        self.db_join();
        self.db_total();
        self.db_order();
        if self.pid_id.is_empty() {
            self.db.page(self.page as i32, self.limit as i32);
        } else {
            self.db.page(1, 1000);
        }

        self.data = self.db.select();
        self.db_table_tree(pid_field);

        object! {
            "pages"=>self.pages,
            "total"=>self.total,
            "data"=>self.data.clone(),
            "columns"=>self.columns(),
            "filter_fields"=>self.filter_fields.clone(),
            "search_name"=>self.search_name.clone(),
            "total_fields"=>self.total_fields.clone(),
            "btn_all"=>array![],
            "btn_api"=>array![],
            "btn_ids"=>array![]
        }
    }
    pub fn get_table_edit(&mut self) -> JsonValue {
        self.db.table(&self.main_table);
        self.db_fields();
        self.db_search();
        self.db_where();
        self.db_total();
        self.db_order();
        self.db.page(self.page as i32, self.limit as i32);
        self.db_join();
        self.data = self.db.select();

        object! {
            "pages"=>self.pages,
            "total"=>self.total,
            "data"=>self.data.clone(),
            "columns"=>self.columns(),
            "edit_fields"=>self.edit_fields.clone(),
        }
    }
    pub fn get_table_select(&mut self) -> JsonValue {
        self.db.table(&self.main_table);
        if !self.primary_key.eq("id") {
            self.fields_keys.remove(0);
        }
        if !self.value.is_empty() && self.search.is_empty() {
            let _ = self
                .where_or
                .push(array![self.primary_key.clone(), "in", self.value.clone()]);
            let _ = self
                .where_or
                .push(array![self.primary_key.clone(), "isnot", "NULL"]);
            let _ = self.order.push(array![
                format!(
                    "{} in ('{}')",
                    self.primary_key.clone(),
                    self.value.join("','")
                ),
                true
            ]);
        }
        self.db_fields();
        self.db_search();
        self.db_where();
        self.db_join();
        self.db_total();
        self.db_order();
        self.db.page(self.page as i32, self.limit as i32);

        let mut list = self.db.select();

        for item in list.members_mut() {
            let value = item[self.primary_key.clone()].clone();
            if self.primary_key.eq("id") {
                item.remove(&self.primary_key.clone());
            }
            let label = item
                .entries()
                .map(|(_, v)| v.to_string())
                .collect::<Vec<String>>();
            let _ = self.data.push(object! {
                value: value,
                label: label.join(" | ").clone(),
            });
        }

        object! {
            "pages"=>self.pages,
            "total"=>self.total,
            "data"=>self.data.clone(),
        }
    }
    pub fn get_table_select_tree(&mut self, pid_field: &str, label_field: &str) -> JsonValue {
        self.fields_keys.push(pid_field.to_string());
        self.db.table(&self.main_table);
        self.db
            .where_and(pid_field, "=", self.pid_id.clone().into());

        self.db_fields();
        self.db_search();
        self.db_where();
        self.db_join();
        self.db_order();
        self.db.page(1, 1000);

        self.data = self.db.select();

        for item in self.data.members_mut() {
            let children = self
                .db
                .table(&self.main_table)
                .where_and(pid_field, "=", item["id"].clone())
                .count();
            if children.is_empty() {
                item["lazy"] = false.into();
                item["isLeaf"] = true.into();
            } else {
                item["lazy"] = true.into();
            }
        }

        if self.pid_id.is_empty() {
            for id in self.value.clone() {
                let mut list = vec![];
                let mut find = self
                    .db
                    .table(&self.main_table)
                    .where_and("id", "=", id.into())
                    .field(self.fields_keys.join(",").as_str())
                    .find();
                loop {
                    let pid = find[pid_field].to_string();
                    if pid.is_empty() {
                        break;
                    }
                    find = self
                        .db
                        .table(&self.main_table)
                        .where_and("id", "=", pid.into())
                        .field(self.fields_keys.join(",").as_str())
                        .find();
                    list.insert(0, find.clone());
                }
                let data = &mut self.data.clone();
                self.tree_data(data, list.into(), 0, pid_field);
                self.data = data.clone();
            }
        }
        object! {
            "data"=> self.data.clone(),
            "label_field"=>label_field.to_string(),
            "pid_field"=>pid_field.to_string(),
        }
    }
    fn tree_data(&mut self, data: &mut JsonValue, list: JsonValue, index: usize, pid_field: &str) {
        let id = list[index]["id"].clone();
        for item in data.members_mut() {
            let children = self
                .db
                .table(&self.main_table)
                .where_and(pid_field, "=", item["id"].clone())
                .field(self.fields_keys.join(",").as_str())
                .select();
            if children.is_empty() {
                item["isLeaf"] = true.into();
            }
            if id == item["id"] && !children.is_empty() {
                item["children"] = children;
                self.tree_data(&mut item["children"], list.clone(), index + 1, pid_field);
            }
        }
    }
}