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: f64,
    /// 字段数据
    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>,
    version: usize,
    /// 树形pid
    pid_id: String,
}
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.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![],
            version: 0,
            join_fields: vec![],
            hide_fields: vec![],
            show_fields: vec![],
            total_fields: vec![],
            pid_id: "".to_string(),
        }
    }
    pub fn set_version(&mut self, version: usize) -> &mut Self {
        self.version = version;
        self
    }
    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" => 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());
            }
        }
        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 = request["pid"].as_str().unwrap_or("").to_string();
        }

        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"].to_string();
        }
        if request.has_key("primary_key") {
            self.primary_key = request["primary_key"].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 all_fields = object! {};
            let _ = self
                .fields
                .iter()
                .map(|x| all_fields.insert(x["field"].as_str().unwrap_or_default(), x.clone()))
                .collect::<Vec<_>>();

            let mut t = vec![];
            for value in self.search_fields.clone() {
                let field = all_fields[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) {
        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<_>>();

        for value in self.where_or.members() {
            let field = all_fields[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 = all_fields[value[0].to_string()].clone();
            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) {
        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<_>>();

        for item in self.order.members() {
            let field = all_fields[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>>();

        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_f64().unwrap_or(0.0);
        self.pages = (self.total / (self.limit as f64)).ceil() as i64;
    }
    fn db_table(&mut self) {
        let mut all_fields = object! {};
        let _ = self
            .fields
            .iter()
            .map(|x| {
                let _ = all_fields.insert(x["field"].as_str().unwrap_or_default(), x.clone());
            })
            .collect::<Vec<_>>();

        let mut table_data = object! {};
        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;
                }
                let field_info = all_fields[field].clone();

                if !table_data.has_key(field) {
                    table_data[field] = object! {};
                }
                if !table_data[field].has_key(key) {
                    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 mut find = self
                        .db
                        .table(info["table"].as_str().unwrap_or_default())
                        .where_and("id", "=", key.into())
                        .field(&fields_k.join(","))
                        .find();
                    let id = find["id"].to_string();
                    find.remove("id");
                    let label = find
                        .entries()
                        .map(|(_, v)| v.to_string())
                        .collect::<Vec<String>>();
                    table_data[field][key] = object! {
                                value: id.clone(),
                                label:label.join(" | ").clone(),
                    };
                }
                item[field] = table_data[field][key].clone();
            }
            for field in self.tree_fields.iter() {
                let key = item[field].as_str().unwrap_or("");
                if key.is_empty() {
                    continue;
                }
                let field_info = all_fields[field].clone();
                if !table_data.has_key(field) {
                    table_data[field] = object! {};
                }
                if !table_data[field].has_key(key) {
                    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 mut find = self
                        .db
                        .table(info["table"].as_str().unwrap_or_default())
                        .where_and("id", "=", key.into())
                        .field(&fields_k.join(","))
                        .find();
                    let mut pid = find[pid_field.clone()].to_string();
                    let mut name_list = vec![];
                    let id = find["id"].to_string();
                    find.remove("id");
                    find.remove(&pid_field);
                    let label = find
                        .entries()
                        .map(|(_, v)| v.to_string())
                        .collect::<Vec<String>>();
                    name_list.push(label.join(" | ").clone());
                    loop {
                        if pid.is_empty() {
                            break;
                        }
                        let mut t = self
                            .db
                            .table(info["table"].as_str().unwrap_or_default())
                            .where_and("id", "=", pid.clone().into())
                            .field(&fields_k.join(","))
                            .find();
                        pid = t[pid_field.clone()].to_string();
                        t.remove("id");
                        t.remove(&pid_field);
                        let label = t
                            .entries()
                            .map(|(_, v)| v.to_string())
                            .collect::<Vec<String>>();
                        name_list.push(label.join(" | ").clone());
                    }
                    name_list.reverse();
                    table_data[field][key] = object! {
                            value: id.clone(),
                            label:name_list.join("/").clone(),
                    };
                }
                item[field] = table_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 field_info = all_fields[field].clone();
                if !table_data.has_key(field) {
                    table_data[field] = object! {};
                }
                let mut result = array![];
                for id_val in ids.members() {
                    let key = id_val.as_str().unwrap_or("");
                    if key.is_empty() {
                        continue;
                    }
                    if !table_data[field].has_key(key) {
                        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 mut find = self
                            .db
                            .table(info["table"].as_str().unwrap_or_default())
                            .where_and("id", "=", key.into())
                            .field(&fields_k.join(","))
                            .find();
                        let id = find["id"].to_string();
                        find.remove("id");
                        let label = find
                            .entries()
                            .map(|(_, v)| v.to_string())
                            .collect::<Vec<String>>();
                        table_data[field][key] = object! {
                            value: id.clone(),
                            label: label.join(" | ").clone(),
                        };
                    }
                    let _ = result.push(table_data[field][key].clone());
                }
                item[field] = result;
            }
        }
    }
    fn db_table_tree(&mut self, pid_field: &str) {
        let mut all_fields = object! {};
        let _ = self
            .fields
            .iter()
            .map(|x| {
                let _ = all_fields.insert(x["field"].as_str().unwrap_or_default(), x.clone());
            })
            .collect::<Vec<_>>();

        let mut table_data = object! {};
        for item in self.data.members_mut() {
            let find = self
                .db
                .table(&self.main_table)
                .where_and(pid_field, "=", item["id"].clone())
                .count();
            if find.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;
                }
                let field_info = all_fields[field].clone();

                if !table_data.has_key(field) {
                    table_data[field] = object! {};
                }
                if !table_data[field].has_key(key) {
                    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 mut find = self
                        .db
                        .table(info["table"].as_str().unwrap_or_default())
                        .where_and("id", "=", key.into())
                        .field(&fields_k.join(","))
                        .find();
                    let id = find["id"].to_string();
                    find.remove("id");
                    let label = find
                        .entries()
                        .map(|(_, v)| v.to_string())
                        .collect::<Vec<String>>();
                    table_data[field][key] = object! {
                                value: id.clone(),
                                label:label.join(" | ").clone(),
                    };
                }
                item[field] = table_data[field][key].clone();
            }
            for field in self.tree_fields.iter() {
                let key = item[field].as_str().unwrap_or("");
                if key.is_empty() {
                    continue;
                }
                let field_info = all_fields[field].clone();
                if !table_data.has_key(field) {
                    table_data[field] = object! {};
                }
                if !table_data[field].has_key(key) {
                    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 mut find = self
                        .db
                        .table(info["table"].as_str().unwrap_or_default())
                        .where_and("id", "=", key.into())
                        .field(&fields_k.join(","))
                        .find();
                    let mut pid = find[pid_field.clone()].to_string();
                    let mut name_list = vec![];
                    let id = find["id"].to_string();
                    find.remove("id");
                    find.remove(&pid_field);
                    let label = find
                        .entries()
                        .map(|(_, v)| v.to_string())
                        .collect::<Vec<String>>();
                    name_list.push(label.join(" | ").clone());
                    loop {
                        if pid.is_empty() {
                            break;
                        }
                        let mut t = self
                            .db
                            .table(info["table"].as_str().unwrap_or_default())
                            .where_and("id", "=", pid.clone().into())
                            .field(&fields_k.join(","))
                            .find();
                        pid = t[pid_field.clone()].to_string();
                        t.remove("id");
                        t.remove(&pid_field);
                        let label = t
                            .entries()
                            .map(|(_, v)| v.to_string())
                            .collect::<Vec<String>>();
                        name_list.push(label.join(" | ").clone());
                    }
                    name_list.reverse();
                    table_data[field][key] = object! {
                            value: id.clone(),
                            label:name_list.join("/").clone(),
                    };
                }
                item[field] = table_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 field_info = all_fields[field].clone();
                if !table_data.has_key(field) {
                    table_data[field] = object! {};
                }
                let mut result = array![];
                for id_val in ids.members() {
                    let key = id_val.as_str().unwrap_or("");
                    if key.is_empty() {
                        continue;
                    }
                    if !table_data[field].has_key(key) {
                        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 mut find = self
                            .db
                            .table(info["table"].as_str().unwrap_or_default())
                            .where_and("id", "=", key.into())
                            .field(&fields_k.join(","))
                            .find();
                        let id = find["id"].to_string();
                        find.remove("id");
                        let label = find
                            .entries()
                            .map(|(_, v)| v.to_string())
                            .collect::<Vec<String>>();
                        table_data[field][key] = object! {
                            value: id.clone(),
                            label: label.join(" | ").clone(),
                        };
                    }
                    let _ = result.push(table_data[field][key].clone());
                }
                item[field] = result;
            }
        }
    }
    fn columns(&mut self) -> JsonValue {
        let mut all_fields = object! {};
        let _ = self
            .fields
            .iter()
            .map(|x| {
                let _ = all_fields.insert(x["field"].as_str().unwrap_or_default(), x.clone());
            })
            .collect::<Vec<_>>();

        let sort_field = self
            .order
            .members()
            .map(|x| (x[0].to_string(), x[1].as_bool().unwrap_or(false)))
            .collect::<HashMap<String, bool>>();
        for (_, item) in all_fields.entries_mut() {
            item["name"] = item["field"].clone();
            item["align"] = "center".into();
            item["label"] = item["title"].clone();
            item["version"] = self.version.into();

            if item["field"].as_str().unwrap_or("") != "id" {
                if self.version == 0 {
                    item["sortable"] = true.into();
                } else {
                    item["sortable"] = object! {
                        "sorter"=>false,
                        "sortDirections"=>array!["ascend","descend"],
                        "defaultSortOrder"=>"",
                        "sortOrder"=>""
                    };
                    if sort_field.contains_key(item["field"].to_string().as_str()) {
                        item["sortable"]["sortOrder"] =
                            if *sort_field.get(&item["field"].to_string()).unwrap_or(&false) {
                                "descend"
                            } else {
                                "ascend"
                            }
                            .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);
        self.set_version(1);
        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);
            }
        }
    }
}