Skip to main content

br_addon/
tables.rs

1use br_db::Db;
2use br_fields::Field;
3use json::{array, object, JsonValue};
4use std::collections::HashMap;
5
6#[allow(clippy::too_many_arguments)]
7#[cfg(any(feature = "sqlite",
8    feature = "mssql",
9    feature = "mysql",
10    feature = "pgsql"))]
11pub struct Tables {
12    /// 主数据表名称
13    main_table: String,
14    /// 数据库
15    db: Db,
16    /// 记录总数量
17    total: f64,
18    /// 字段数据
19    fields: Vec<JsonValue>,
20    /// 连表查询
21    join_params: Vec<Vec<String>>,
22    /// 字段值集合
23    fields_keys: Vec<String>,
24    /// 联表字段
25    join_fields: Vec<String>,
26    /// 隐藏字段
27    hide_fields: Vec<String>,
28    /// 显示字段
29    show_fields: Vec<String>,
30    /// 合计字段
31    total_fields: Vec<String>,
32    /// 数据
33    data: JsonValue,
34    /// 页数
35    page: usize,
36    /// 总页数
37    pages: i64,
38    /// 每页数量
39    limit: usize,
40    /// 搜索内容
41    search: String,
42    /// 搜索字段
43    search_fields: Vec<String>,
44    /// 搜索框名称
45    search_name: String,
46    /// 可以编辑字段
47    edit_fields: Vec<String>,
48    /// 排序
49    /// array![array!["id",false]]
50    order: JsonValue,
51    /// 过滤条件
52    /// array![array!["id","=","*"]]
53    where_and: JsonValue,
54    /// 过滤条件
55    /// array![array!["id","=","*"]]
56    where_or: JsonValue,
57    /// 过滤字段
58    filter_fields: Vec<String>,
59    /// 表单关联字段
60    table_fields: Vec<String>,
61    /// 树形关联字段
62    tree_fields: Vec<String>,
63    /// JSON字段
64    json_fields: Vec<String>,
65    /// 地图字段
66    location_fields: Vec<String>,
67    /// 显示的主键
68    primary_key: String,
69    /// 选中值
70    value: Vec<String>,
71    version: usize,
72    /// 树形pid
73    pid_id: String,
74}
75impl Tables {
76    pub fn params_table(mut params: JsonValue) -> JsonValue {
77        params["page"] = br_fields::int::Int::new(false, "page", "页数", 10, 1).example(1.into()).field();
78        params["limit"] = br_fields::int::Int::new(false, "limit", "行数", 10, 10).example(10.into()).field();
79        params["order"] = br_fields::text::Array::new(false, "order", "排序", array![]).field();
80        params["search"] = br_fields::str::Str::new(false, "search", "搜索", 200, "").example("".into()).field();
81        params["where_or"] = br_fields::text::Array::new(false, "where_or", "查询条件", array![]).example(array![]).field();
82        params["where_and"] = br_fields::text::Array::new(false, "where_and", "查询条件", array![]).example(array![]).field();
83        params["params"] = br_fields::text::Object::new(false, "params", "关联数据参数", object! {}).describe("如果是表单就是表单里的其他字段").example(object! {}).field();
84        params
85    }
86    pub fn params_table_tree(mut params: JsonValue) -> JsonValue {
87        params["pid"] = br_fields::str::Str::new(false, "pid", "上级ID", 50, "").example("".into()).field();
88        Tables::params_table_select(params)
89    }
90    pub fn params_table_select(mut params: JsonValue) -> JsonValue {
91        params["value"] = br_fields::text::Array::new(false, "value", "已选中值", array![]).field();
92        params["primary_key"] = br_fields::str::Str::new(false, "primary_key", "显示内容的字段", 50, "id").field();
93        Tables::params_table(params)
94    }
95    pub fn params_table_select_tree(mut params: JsonValue) -> JsonValue {
96        params["pid"] = br_fields::str::Str::new(false, "pid", "上级ID", 20, "").example("".into()).field();
97        params["value"] = br_fields::text::Array::new(false, "value", "已选中值", array![]).field();
98        Tables::params_table(params)
99    }
100    pub fn new(db: Db) -> Self {
101        Self {
102            main_table: "".to_string(),
103            db,
104            total: 0.0,
105            fields: vec![],
106            join_params: vec![],
107            fields_keys: vec![],
108            data: array![],
109            page: 1,
110            pages: 0,
111            limit: 10,
112            search: "".to_string(),
113            search_fields: vec![],
114            search_name: "".to_string(),
115            edit_fields: vec![],
116            order: array![],
117            where_and: array![],
118            where_or: array![],
119            filter_fields: vec![],
120            table_fields: vec![],
121            tree_fields: vec![],
122            json_fields: vec![],
123            location_fields: vec![],
124            primary_key: "".to_string(),
125            value: vec![],
126            version: 0,
127            join_fields: vec![],
128            hide_fields: vec![],
129            show_fields: vec![],
130            total_fields: vec![],
131            pid_id: "".to_string(),
132        }
133    }
134    pub fn set_version(&mut self, version: usize) -> &mut Self {
135        self.version = version;
136        self
137    }
138    pub fn main_table_fields(
139        &mut self,
140        table: &str,
141        fields: JsonValue,
142        hide_fields: Vec<&str>,
143        show_fields: Vec<&str>,
144    ) -> &mut Self {
145        self.main_table = table.to_string();
146        self.hide_fields = hide_fields.iter().map(|s| s.to_string()).collect();
147        self.show_fields = show_fields.iter().map(|s| s.to_string()).collect();
148        self.fields = fields.entries().map(|(_, x)| x.clone()).collect::<Vec<JsonValue>>();
149        self
150    }
151    pub fn join_fields(&mut self, table: &str, mut fields: JsonValue, index: isize) -> &mut Self {
152        for (field, item) in fields.entries_mut() {
153            if self.main_table != table {
154                item["field"] = format!("{table}_{field}").into();
155                item["field_table"] = table.into();
156                item["field_table_field"] = field.into();
157            }
158
159            match index {
160                x if x > -1 => {
161                    // 插入
162                    self.fields.insert(x as usize, item.clone());
163                }
164                _ => {
165                    // 尾部添加
166                    self.fields.push(item.clone());
167                }
168            }
169            self.join_fields.push(format!("{table}.{field}"));
170        }
171        self
172    }
173    pub fn fields(&mut self, fields: JsonValue) -> &mut Self {
174        self.fields = fields.entries().map(|(_, x)| x.clone()).collect::<Vec<JsonValue>>();
175        self
176    }
177    pub fn hide_fields(&mut self, hide_fields: Vec<&str>) -> &mut Self {
178        self.hide_fields = hide_fields.iter().map(|s| s.to_string()).collect();
179        self
180    }
181    pub fn show_fields(&mut self, show_fields: Vec<&str>) -> &mut Self {
182        self.show_fields = show_fields.iter().map(|s| s.to_string()).collect();
183        self
184    }
185    pub fn total_fields(&mut self, fields: Vec<&str>) -> &mut Self {
186        self.total_fields = fields.iter().map(|s| s.to_string()).collect();
187        self
188    }
189    fn set_fields(&mut self, field: &str, mode: &str) {
190        match mode {
191            "table" => self.table_fields.push(field.to_string()),
192            "tree" => self.tree_fields.push(field.to_string()),
193            "object" | "array" | "polygon" => self.json_fields.push(field.to_string()),
194            "location" => self.location_fields.push(field.to_string()),
195            _ => {}
196        }
197    }
198    pub fn join_table(
199        &mut self,
200        main_table: &str,
201        main_field: &str,
202        join_table: &str,
203        join_field: &str,
204    ) -> &mut Self {
205        self.join_params.push(vec![
206            main_table.to_string(),
207            main_field.to_string(),
208            join_table.to_string(),
209            join_field.to_string(),
210        ]);
211        self
212    }
213    pub fn main_select_fields(&mut self, table: &str, mut show_fields: Vec<&str>) -> &mut Self {
214        self.main_table = table.to_string();
215        show_fields.insert(0, "id");
216        self.fields_keys = show_fields.into_iter().map(|x| x.to_string()).collect();
217        self.search_fields = self.fields_keys.clone();
218        self
219    }
220
221    pub fn edit_fields(&mut self, fields: Vec<&str>) -> &mut Self {
222        self.edit_fields = fields.iter().map(|s| s.to_string()).collect();
223        self
224    }
225    pub fn search_fields(&mut self, fields: Vec<&str>) -> &mut Self {
226        let mut search_name = vec![];
227        let all_fields = self.fields.iter().map(|x| (x["field"].to_string(), x.clone())).collect::<HashMap<String, JsonValue>>();
228        for key in fields.clone() {
229            if all_fields.contains_key(key) {
230                self.search_fields.push(key.to_string());
231                search_name.push(all_fields.get(key).unwrap()["title"].to_string());
232            }
233        }
234        self.search_name = search_name.join("/");
235        self
236    }
237    /// 条件过滤
238    pub fn filter_fields(&mut self, fields: Vec<&str>) -> &mut Self {
239        let all_fields = self.fields.iter().map(|x| (x["field"].to_string(), x.clone())).collect::<HashMap<String, JsonValue>>();
240        for key in fields.clone() {
241            if all_fields.contains_key(key) {
242                self.filter_fields.push(key.to_string());
243            }
244        }
245        self
246    }
247    /// 请求参数
248    pub fn params(&mut self, request: JsonValue) -> &mut Self {
249        if request.has_key("page") {
250            self.page = request["page"].as_usize().unwrap();
251        }
252        if request.has_key("limit") {
253            self.limit = request["limit"].as_usize().unwrap();
254        }
255        if request.has_key("where_and") {
256            self.where_and = request["where_and"].clone();
257        }
258        if request.has_key("where_or") {
259            self.where_or = request["where_or"].clone();
260        }
261
262        if request.has_key("pid") {
263            self.pid_id = request["pid"].as_str().unwrap_or("").to_string();
264        }
265
266        if request.has_key("order") {
267            for item in request["order"].members() {
268                let _ = self.order.push(item.clone());
269            }
270        }
271        if request.has_key("search") {
272            self.search = request["search"].to_string();
273        }
274        if request.has_key("primary_key") {
275            self.primary_key = request["primary_key"].to_string();
276        }
277        if request.has_key("value") {
278            self.value = request["value"].members().map(|x| x.as_str().unwrap_or("").to_string()).filter(|x| !x.is_empty()).collect();
279        }
280        self
281    }
282
283    fn db_search(&mut self) {
284        if !self.search.is_empty() {
285            let mut all_fields = object! {};
286            let _ = self.fields.iter().map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone())).collect::<Vec<_>>();
287
288            let mut t = vec![];
289            for value in self.search_fields.clone() {
290                let field = all_fields[value.as_str()].clone();
291                if field.has_key("field_table") {
292                    t.push(format!(
293                        "{}.{}",
294                        field["field_table"].clone(),
295                        field["field_table_field"].clone()
296                    ));
297                } else {
298                    t.push(value);
299                }
300            }
301            self.db.where_and(&t.join("|"), "like", format!("%{}%", self.search).into());
302        }
303    }
304    fn db_where(&mut self) {
305        let mut all_fields = object! {};
306        let _ = self.fields.iter().map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone())).collect::<Vec<_>>();
307
308        for value in self.where_or.members() {
309            let field = all_fields[value[0].to_string()].clone();
310            if field.has_key("field_table") {
311                self.db.where_or(
312                    format!(
313                        "{}.{}",
314                        field["field_table"].clone(),
315                        field["field_table_field"].clone()
316                    ).as_str(),
317                    value[1].as_str().unwrap(),
318                    value[2].clone(),
319                );
320            } else {
321                self.db.where_or(
322                    value[0].as_str().unwrap(),
323                    value[1].as_str().unwrap(),
324                    value[2].clone(),
325                );
326            }
327        }
328        for value in self.where_and.members() {
329            let field = all_fields[value[0].to_string()].clone();
330            if field.has_key("field_table") {
331                self.db.where_and(
332                    format!(
333                        "{}.{}",
334                        field["field_table"].clone(),
335                        field["field_table_field"].clone()
336                    ).as_str(),
337                    value[1].as_str().unwrap(),
338                    value[2].clone(),
339                );
340            } else {
341                self.db.where_and(
342                    value[0].as_str().unwrap(),
343                    value[1].as_str().unwrap(),
344                    value[2].clone(),
345                );
346            }
347        }
348    }
349    fn db_order(&mut self) {
350        let mut all_fields = object! {};
351        let _ = self.fields.iter().map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone())).collect::<Vec<_>>();
352
353        for item in self.order.members() {
354            let field = all_fields[item[0].to_string()].clone();
355            if field.has_key("field_table") {
356                self.db.order(
357                    format!(
358                        "{}.{}",
359                        field["field_table"].clone(),
360                        field["field_table_field"].clone()
361                    ).as_str(),
362                    item[1].as_bool().unwrap(),
363                );
364            } else {
365                self.db.order(
366                    format!("{}.{}", self.main_table, item[0]).as_str(),
367                    item[1].as_bool().unwrap(),
368                );
369            }
370        }
371    }
372    fn db_fields(&mut self) {
373        let mut all_fields = object! {};
374        let _ = self.fields.iter().map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone())).collect::<Vec<_>>();
375
376        if !self.hide_fields.is_empty() {
377            for field in self.hide_fields.clone() {
378                if all_fields.has_key(&field) {
379                    all_fields.remove(&field);
380                    continue;
381                }
382            }
383        }
384
385        if !self.show_fields.is_empty() {
386            self.show_fields.insert(0, "id".to_string());
387            let mut f = object! {};
388            for field in self.show_fields.clone() {
389                if all_fields.has_key(&field) {
390                    let _ = f.insert(&field.clone(), all_fields[field].clone());
391                }
392            }
393            all_fields = f;
394        }
395
396        for (field, item) in all_fields.entries() {
397            let mode = item["mode"].to_string();
398            self.set_fields(field, mode.as_str());
399        }
400
401        self.fields = all_fields.entries().map(|(_, x)| x.clone()).collect::<Vec<JsonValue>>();
402
403        if !self.fields_keys.is_empty() {
404            self.db.field(self.fields_keys.join(",").as_str());
405        }
406        if !self.json_fields.is_empty() {
407            self.db.json(self.json_fields.join(",").as_str());
408        }
409        if !self.location_fields.is_empty() {
410            self.db.location(self.location_fields.join(",").as_str());
411        }
412    }
413    fn db_join(&mut self) {
414        if !self.join_fields.is_empty() {
415            self.db.join_fields(self.join_fields.iter().map(|x| x.as_str()).collect());
416        }
417        for item in self.join_params.iter() {
418            self.db.join(&item[0], &item[1], &item[2], &item[3]);
419        }
420    }
421    fn db_total(&mut self) {
422        self.total = self.db.clone().count().as_f64().unwrap();
423        self.pages = (self.total / (self.limit as f64)).ceil() as i64;
424    }
425    fn db_table(&mut self) {
426        let mut all_fields = object! {};
427        let _ = self.fields.iter().map(|x| {
428            all_fields.insert(x["field"].as_str().unwrap(), x.clone()).unwrap()
429        }).collect::<Vec<_>>();
430
431        let mut table_data = object! {};
432        for item in self.data.members_mut() {
433            for field in self.table_fields.iter() {
434                let key = item[field].as_str().unwrap_or("");
435                if key.is_empty() {
436                    continue;
437                }
438                let field_info = all_fields[field].clone();
439
440                if !table_data.has_key(field) {
441                    table_data[field] = object! {};
442                }
443                if !table_data[field].has_key(key) {
444                    let mut info = field_info.clone();
445                    let _ = info["fields"].push("id");
446                    let fields_k = info["fields"].members().map(|x| x.as_str().unwrap()).collect::<Vec<&str>>();
447                    let mut find = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", key.into()).field(&fields_k.join(",")).find();
448                    let id = find["id"].to_string();
449                    find.remove("id");
450                    let label = find.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
451                    table_data[field][key] = object! {
452                                value: id.clone(),
453                                label:label.join(" | ").clone(),
454                    };
455                }
456                item[field] = table_data[field][key].clone();
457            }
458            for field in self.tree_fields.iter() {
459                let key = item[field].as_str().unwrap_or("");
460                if key.is_empty() {
461                    continue;
462                }
463                let field_info = all_fields[field].clone();
464                if !table_data.has_key(field) {
465                    table_data[field] = object! {};
466                }
467                if !table_data[field].has_key(key) {
468                    let mut info = field_info.clone();
469                    let pid_field = info["pid_field"].clone().to_string();
470                    let _ = info["fields"].push("id");
471                    let _ = info["fields"].push(pid_field.clone());
472                    let fields_k = info["fields"].members().map(|x| x.as_str().unwrap()).collect::<Vec<&str>>();
473                    let mut find = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", key.into()).field(&fields_k.join(",")).find();
474                    let mut pid = find[pid_field.clone()].to_string();
475                    let mut name_list = vec![];
476                    let id = find["id"].to_string();
477                    find.remove("id");
478                    find.remove(&pid_field);
479                    let label = find.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
480                    name_list.push(label.join(" | ").clone());
481                    loop {
482                        if pid.is_empty() {
483                            break;
484                        }
485                        let mut t = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", pid.clone().into()).field(&fields_k.join(",")).find();
486                        pid = t[pid_field.clone()].to_string();
487                        t.remove("id");
488                        t.remove(&pid_field);
489                        let label = t.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
490                        name_list.push(label.join(" | ").clone());
491                    }
492                    name_list.reverse();
493                    table_data[field][key] = object! {
494                            value: id.clone(),
495                            label:name_list.join("/").clone(),
496                    };
497                }
498                item[field] = table_data[field][key].clone();
499            }
500        }
501    }
502    fn db_table_tree(&mut self, pid_field: &str) {
503        let mut all_fields = object! {};
504        let _ = self.fields.iter().map(|x| {
505            all_fields.insert(x["field"].as_str().unwrap(), x.clone()).unwrap()
506        }).collect::<Vec<_>>();
507
508        let mut table_data = object! {};
509        for item in self.data.members_mut() {
510            let find = self.db.table(&self.main_table).where_and(pid_field, "=", item["id"].clone()).count();
511            if find.is_empty() {
512                item["isLeaf"] = true.into();
513            }
514
515            for field in self.table_fields.iter() {
516                let key = item[field].as_str().unwrap_or("");
517                if key.is_empty() {
518                    continue;
519                }
520                let field_info = all_fields[field].clone();
521
522                if !table_data.has_key(field) {
523                    table_data[field] = object! {};
524                }
525                if !table_data[field].has_key(key) {
526                    let mut info = field_info.clone();
527                    let _ = info["fields"].push("id");
528                    let fields_k = info["fields"].members().map(|x| x.as_str().unwrap()).collect::<Vec<&str>>();
529                    let mut find = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", key.into()).field(&fields_k.join(",")).find();
530                    let id = find["id"].to_string();
531                    find.remove("id");
532                    let label = find.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
533                    table_data[field][key] = object! {
534                                value: id.clone(),
535                                label:label.join(" | ").clone(),
536                    };
537                }
538                item[field] = table_data[field][key].clone();
539            }
540            for field in self.tree_fields.iter() {
541                let key = item[field].as_str().unwrap_or("");
542                if key.is_empty() {
543                    continue;
544                }
545                let field_info = all_fields[field].clone();
546                if !table_data.has_key(field) {
547                    table_data[field] = object! {};
548                }
549                if !table_data[field].has_key(key) {
550                    let mut info = field_info.clone();
551                    let pid_field = info["pid_field"].clone().to_string();
552                    let _ = info["fields"].push("id");
553                    let _ = info["fields"].push(pid_field.clone());
554                    let fields_k = info["fields"].members().map(|x| x.as_str().unwrap()).collect::<Vec<&str>>();
555                    let mut find = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", key.into()).field(&fields_k.join(",")).find();
556                    let mut pid = find[pid_field.clone()].to_string();
557                    let mut name_list = vec![];
558                    let id = find["id"].to_string();
559                    find.remove("id");
560                    find.remove(&pid_field);
561                    let label = find.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
562                    name_list.push(label.join(" | ").clone());
563                    loop {
564                        if pid.is_empty() {
565                            break;
566                        }
567                        let mut t = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", pid.clone().into()).field(&fields_k.join(",")).find();
568                        pid = t[pid_field.clone()].to_string();
569                        t.remove("id");
570                        t.remove(&pid_field);
571                        let label = t.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
572                        name_list.push(label.join(" | ").clone());
573                    }
574                    name_list.reverse();
575                    table_data[field][key] = object! {
576                            value: id.clone(),
577                            label:name_list.join("/").clone(),
578                    };
579                }
580                item[field] = table_data[field][key].clone();
581            }
582        }
583    }
584    fn columns(&mut self) -> JsonValue {
585        let mut all_fields = object! {};
586        let _ = self.fields.iter().map(|x| {
587            all_fields.insert(x["field"].as_str().unwrap(), x.clone()).unwrap()
588        }).collect::<Vec<_>>();
589
590        let sort_field = self.order.members().map(|x| (x[0].to_string(), x[1].as_bool().unwrap())).collect::<HashMap<String, bool>>();
591        for (_, item) in all_fields.entries_mut() {
592            item["name"] = item["field"].clone();
593            item["align"] = "center".into();
594            item["label"] = item["title"].clone();
595            item["version"] = self.version.into();
596
597            if item["field"].as_str().unwrap_or("") != "id" {
598                if self.version == 0 {
599                    item["sortable"] = true.into();
600                } else {
601                    item["sortable"] = object! {
602                        "sorter"=>false,
603                        "sortDirections"=>array!["ascend","descend"],
604                        "defaultSortOrder"=>"",
605                        "sortOrder"=>""
606                    };
607                    if sort_field.contains_key(item["field"].to_string().as_str()) {
608                        item["sortable"]["sortOrder"] = if *sort_field.get(&item["field"].to_string()).unwrap() {
609                            "descend"
610                        } else {
611                            "ascend"
612                        }.into();
613                    }
614                }
615            }
616            item["dataIndex"] = item["field"].clone();
617            item["slotName"] = item["field"].clone();
618            item["titleSlotName"] = item["field"].clone();
619            match item["mode"].as_str().unwrap() {
620                "string" | "text" => {
621                    item["ellipsis"] = true.into();
622                    item["tooltip"] = true.into();
623                }
624                "key" => {
625                    item["width"] = 280.into();
626                    item["ellipsis"] = true.into();
627                }
628                _ => {}
629            }
630        }
631        all_fields
632    }
633    pub fn get_table(&mut self) -> JsonValue {
634        self.db.table(&self.main_table);
635        self.db_fields();
636        self.db_search();
637        self.db_where();
638        self.db_join();
639        self.db_total();
640        self.db_order();
641        self.db.page(self.page as i32, self.limit as i32);
642
643        self.data = self.db.select();
644        self.db_table();
645
646        object! {
647            "pages"=>self.pages,
648            "total"=>self.total,
649            "data"=>self.data.clone(),
650            "columns"=>self.columns(),
651            "filter_fields"=>self.filter_fields.clone(),
652            "search_name"=>self.search_name.clone(),
653            "total_fields"=>self.total_fields.clone(),
654            "btn_all"=>array![],
655            "btn_api"=>array![],
656            "btn_ids"=>array![]
657        }
658    }
659    pub fn get_table_menu(&mut self, label_field: &str) -> JsonValue {
660        self.db.table(&self.main_table);
661        self.db_fields();
662        self.db_search();
663        self.db_where();
664        self.db_join();
665        self.db_total();
666        self.db_order();
667        self.db.page(self.page as i32, self.limit as i32);
668
669        self.data = self.db.select();
670        self.db_table();
671
672        object! {
673            "pages"=>self.pages,
674            "total"=>self.total,
675            "data"=>self.data.clone(),
676            "columns"=>self.columns(),
677            "filter_fields"=>self.filter_fields.clone(),
678            "search_name"=>self.search_name.clone(),
679            "total_fields"=>self.total_fields.clone(),
680            "btn_all"=>array![],
681            "btn_api"=>array![],
682            "btn_ids"=>array![],
683            "label_field"=>label_field
684        }
685    }
686
687    pub fn get_tree(&mut self, pid_field: &str) -> JsonValue {
688        self.db.table(&self.main_table);
689        self.set_version(1);
690        self.db.where_and(pid_field, "=", self.pid_id.clone().into());
691        self.db_fields();
692        self.db_search();
693        self.db_where();
694        self.db_join();
695        self.db_total();
696        self.db_order();
697        if self.pid_id.is_empty() {
698            self.db.page(self.page as i32, self.limit as i32);
699        } else {
700            self.db.page(1, 1000);
701        }
702
703        self.data = self.db.select();
704        self.db_table_tree(pid_field);
705
706        object! {
707            "pages"=>self.pages,
708            "total"=>self.total,
709            "data"=>self.data.clone(),
710            "columns"=>self.columns(),
711            "filter_fields"=>self.filter_fields.clone(),
712            "search_name"=>self.search_name.clone(),
713            "total_fields"=>self.total_fields.clone(),
714            "btn_all"=>array![],
715            "btn_api"=>array![],
716            "btn_ids"=>array![]
717        }
718    }
719    pub fn get_table_edit(&mut self) -> JsonValue {
720        self.db.table(&self.main_table);
721        self.db_fields();
722        self.db_search();
723        self.db_where();
724        self.db_total();
725        self.db_order();
726        self.db.page(self.page as i32, self.limit as i32);
727        self.db_join();
728        self.data = self.db.select();
729
730        object! {
731            "pages"=>self.pages,
732            "total"=>self.total,
733            "data"=>self.data.clone(),
734            "columns"=>self.columns(),
735            "edit_fields"=>self.edit_fields.clone(),
736        }
737    }
738    pub fn get_table_select(&mut self) -> JsonValue {
739        self.db.table(&self.main_table);
740        if !self.primary_key.eq("id") {
741            self.fields_keys.remove(0);
742        }
743        if !self.value.is_empty() && self.search.is_empty() {
744            let _ = self.where_or.push(array![self.primary_key.clone(), "in", self.value.clone()]);
745            let _ = self.where_or.push(array![self.primary_key.clone(), "isnot", "NULL"]);
746            let _ = self.order.push(array![
747                format!(
748                    "{} in ('{}')",
749                    self.primary_key.clone(),
750                    self.value.join("','")
751                ),
752                true
753            ]);
754        }
755        self.db_fields();
756        self.db_search();
757        self.db_where();
758        self.db_join();
759        self.db_total();
760        self.db_order();
761        self.db.page(self.page as i32, self.limit as i32);
762
763        let mut list = self.db.select();
764
765        for item in list.members_mut() {
766            let value = item[self.primary_key.clone()].clone();
767            if self.primary_key.eq("id") {
768                item.remove(&self.primary_key.clone());
769            }
770            let label = item.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
771            self.data.push(object! {
772                    value: value,
773                    label: label.join(" | ").clone(),
774                }).unwrap();
775        }
776
777        object! {
778            "pages"=>self.pages,
779            "total"=>self.total,
780            "data"=>self.data.clone(),
781        }
782    }
783    pub fn get_table_select_tree(&mut self, pid_field: &str, label_field: &str) -> JsonValue {
784        self.fields_keys.push(pid_field.to_string());
785        self.db.table(&self.main_table);
786        self.db.where_and(pid_field, "=", self.pid_id.clone().into());
787
788        self.db_fields();
789        self.db_search();
790        self.db_where();
791        self.db_join();
792        self.db_order();
793        self.db.page(1, 1000);
794
795        self.data = self.db.select();
796
797        for item in self.data.members_mut() {
798            let children = self.db.table(&self.main_table).where_and(pid_field, "=", item["id"].clone()).count();
799            if children.is_empty() {
800                item["lazy"] = false.into();
801                item["isLeaf"] = true.into();
802            } else {
803                item["lazy"] = true.into();
804            }
805        }
806
807        if self.pid_id.is_empty() {
808            for id in self.value.clone() {
809                let mut list = vec![];
810                let mut find = self.db.table(&self.main_table).where_and("id", "=", id.into()).field(self.fields_keys.join(",").as_str()).find();
811                loop {
812                    let pid = find[pid_field].to_string();
813                    if pid.is_empty() {
814                        break;
815                    }
816                    find = self.db.table(&self.main_table).where_and("id", "=", pid.into()).field(self.fields_keys.join(",").as_str()).find();
817                    list.insert(0, find.clone());
818                }
819                let data = &mut self.data.clone();
820                self.tree_data(data, list.into(), 0, pid_field);
821                self.data = data.clone();
822            }
823        }
824        object! {
825            "data"=> self.data.clone(),
826            "label_field"=>label_field.to_string(),
827            "pid_field"=>pid_field.to_string(),
828        }
829    }
830    fn tree_data(&mut self, data: &mut JsonValue, list: JsonValue, index: usize, pid_field: &str) {
831        let id = list[index]["id"].clone();
832        for item in data.members_mut() {
833            let children = self.db.table(&self.main_table).where_and(pid_field, "=", item["id"].clone()).field(self.fields_keys.join(",").as_str()).select();
834            if children.is_empty() {
835                item["isLeaf"] = true.into();
836            }
837            if id == item["id"] && !children.is_empty() {
838                item["children"] = children;
839                self.tree_data(&mut item["children"], list.clone(), index + 1, pid_field);
840            }
841        }
842    }
843}