br_addon/
tables.rs

1use std::collections::{HashMap};
2use br_db::Db;
3use br_fields::Field;
4use json::{array, object, JsonValue};
5
6#[allow(clippy::too_many_arguments)]
7#[cfg(any(feature = "sqlite", feature = "mssql", feature = "mysql", feature = "pgsql"))]
8pub struct Tables {
9    /// 主数据表名称
10    main_table: String,
11    /// 数据库
12    db: Db,
13    /// 记录总数量
14    total: f64,
15    /// 字段数据
16    fields: Vec<JsonValue>,
17    /// 连表查询
18    join_params: Vec<Vec<String>>,
19    /// 字段值集合
20    fields_keys: Vec<String>,
21    /// 联表字段
22    join_fields: Vec<String>,
23    /// 隐藏字段
24    hide_fields: Vec<String>,
25    /// 显示字段
26    show_fields: Vec<String>,
27    /// 合计字段
28    total_fields: Vec<String>,
29    /// 数据
30    data: JsonValue,
31    /// 页数
32    page: usize,
33    /// 总页数
34    pages: i64,
35    /// 每页数量
36    limit: usize,
37    /// 搜索内容
38    search: String,
39    /// 搜索字段
40    search_fields: Vec<String>,
41    /// 搜索框名称
42    search_name: String,
43    /// 可以编辑字段
44    edit_fields: Vec<String>,
45    /// 排序
46    /// array![array!["id",false]]
47    order: JsonValue,
48    /// 过滤条件
49    /// array![array!["id","=","*"]]
50    where_and: JsonValue,
51    /// 过滤条件
52    /// array![array!["id","=","*"]]
53    where_or: JsonValue,
54    /// 过滤字段
55    filter_fields: Vec<String>,
56    /// 表单关联字段
57    table_fields: Vec<String>,
58    /// 树形关联字段
59    tree_fields: Vec<String>,
60    /// JSON字段
61    json_fields: Vec<String>,
62    /// 地图字段
63    location_fields: Vec<String>,
64    /// 显示的主键
65    primary_key: String,
66    /// 选中值
67    value: Vec<String>,
68    version: usize,
69}
70impl Tables {
71    pub fn params_table(mut params: JsonValue) -> JsonValue {
72        params["page"] = br_fields::int::Int::new(false, "page", "页数", 10, 1).example(1.into()).field();
73        params["limit"] = br_fields::int::Int::new(false, "limit", "行数", 10, 10).example(10.into()).field();
74        params["order"] = br_fields::text::Array::new(false, "order", "排序", array![]).field();
75        params["search"] = br_fields::str::Str::new(false, "search", "搜索", 200, "").example("".into()).field();
76        params["where_or"] = br_fields::text::Array::new(false, "where_or", "查询条件", array![]).example(array![]).field();
77        params["where_and"] = br_fields::text::Array::new(false, "where_and", "查询条件", array![]).example(array![]).field();
78        params["params"] = br_fields::text::Object::new(false, "params", "关联数据参数", object! {}).describe("如果是表单就是表单里的其他字段").example(object! {}).field();
79        params
80    }
81    pub fn params_table_tree(mut params: JsonValue) -> JsonValue {
82        params["pid"] = br_fields::str::Str::new(false, "pid", "上级ID", 50, "").example("".into()).field();
83        Tables::params_table_select(params)
84    }
85    pub fn params_table_select(mut params: JsonValue) -> JsonValue {
86        params["value"] = br_fields::text::Array::new(false, "value", "已选中值", array![]).field();
87        params["primary_key"] = br_fields::str::Str::new(false, "primary_key", "显示内容的字段", 50, "id").field();
88        Tables::params_table(params)
89    }
90    pub fn new(db: Db) -> Self {
91        Self {
92            main_table: "".to_string(),
93            db,
94            total: 0.0,
95            fields: vec![],
96            join_params: vec![],
97            fields_keys: vec![],
98            data: array![],
99            page: 1,
100            pages: 0,
101            limit: 10,
102            search: "".to_string(),
103            search_fields: vec![],
104            search_name: "".to_string(),
105            edit_fields: vec![],
106            order: array![],
107            where_and: array![],
108            where_or: array![],
109            filter_fields: vec![],
110            table_fields: vec![],
111            tree_fields: vec![],
112            json_fields: vec![],
113            location_fields: vec![],
114            primary_key: "".to_string(),
115            value: vec![],
116            version: 0,
117            join_fields: vec![],
118            hide_fields: vec![],
119            show_fields: vec![],
120            total_fields: vec![],
121        }
122    }
123    pub fn set_version(&mut self, version: usize) -> &mut Self {
124        self.version = version;
125        self
126    }
127    pub fn main_table_fields(&mut self, table: &str, fields: JsonValue, hide_fields: Vec<&str>, show_fields: Vec<&str>) -> &mut Self {
128        self.main_table = table.to_string();
129        self.hide_fields = hide_fields.iter().map(|s| s.to_string()).collect();
130        self.show_fields = show_fields.iter().map(|s| s.to_string()).collect();
131        self.fields = fields.entries().map(|(_, x)| x.clone()).collect::<Vec<JsonValue>>();
132        self
133    }
134    pub fn join_fields(&mut self, table: &str, mut fields: JsonValue, index: isize) -> &mut Self {
135        for (field, item) in fields.entries_mut() {
136            if self.main_table != table {
137                item["field"] = format!("{table}_{field}").into();
138                item["field_table"] = table.into();
139                item["field_table_field"] = field.into();
140            }
141
142            match index {
143                | x if x > -1 => {
144                    // 插入
145                    self.fields.insert(x as usize, item.clone());
146                }
147                _ => {
148                    // 尾部添加
149                    self.fields.push(item.clone());
150                }
151            }
152            self.join_fields.push(format!("{table}.{field}"));
153        }
154        self
155    }
156    pub fn fields(&mut self, fields: JsonValue) -> &mut Self {
157        self.fields = fields.entries().map(|(_, x)| x.clone()).collect::<Vec<JsonValue>>();
158        self
159    }
160    pub fn hide_fields(&mut self, hide_fields: Vec<&str>) -> &mut Self {
161        self.hide_fields = hide_fields.iter().map(|s| s.to_string()).collect();
162        self
163    }
164    pub fn show_fields(&mut self, show_fields: Vec<&str>) -> &mut Self {
165        self.show_fields = show_fields.iter().map(|s| s.to_string()).collect();
166        self
167    }
168    pub fn total_fields(&mut self, fields: Vec<&str>) -> &mut Self {
169        self.total_fields = fields.iter().map(|s| s.to_string()).collect();
170        self
171    }
172    fn set_fields(&mut self, field: &str, mode: &str) {
173        match mode {
174            "table" => self.table_fields.push(field.to_string()),
175            "tree" => self.tree_fields.push(field.to_string()),
176            "object" | "array" | "polygon" => self.json_fields.push(field.to_string()),
177            "location" => self.location_fields.push(field.to_string()),
178            _ => {}
179        }
180    }
181    pub fn join_table(&mut self, main_table: &str, main_field: &str, join_table: &str, join_field: &str) -> &mut Self {
182        self.join_params.push(vec![main_table.to_string(), main_field.to_string(), join_table.to_string(), join_field.to_string()]);
183        self
184    }
185    pub fn main_select_fields(&mut self, table: &str, mut show_fields: Vec<&str>) -> &mut Self {
186        self.main_table = table.to_string();
187        show_fields.insert(0, "id");
188        self.fields_keys = show_fields.into_iter().map(|x| x.to_string()).collect();
189        self.search_fields = self.fields_keys.clone();
190        self
191    }
192
193    pub fn edit_fields(&mut self, fields: Vec<&str>) -> &mut Self {
194        self.edit_fields = fields.iter().map(|s| s.to_string()).collect();
195        self
196    }
197    pub fn search_fields(&mut self, fields: Vec<&str>) -> &mut Self {
198        let mut search_name = vec![];
199        let all_fields = self.fields.iter().map(|x| (x["field"].to_string(), x.clone())).collect::<HashMap<String, JsonValue>>();
200        for key in fields.clone() {
201            if all_fields.contains_key(key) {
202                self.search_fields.push(key.to_string());
203                search_name.push(all_fields.get(key).unwrap()["title"].to_string());
204            }
205        }
206        self.search_name = search_name.join("/");
207        self
208    }
209    /// 条件过滤
210    pub fn filter_fields(&mut self, fields: Vec<&str>) -> &mut Self {
211        let all_fields = self.fields.iter().map(|x| (x["field"].to_string(), x.clone())).collect::<HashMap<String, JsonValue>>();
212        for key in fields.clone() {
213            if all_fields.contains_key(key) {
214                self.filter_fields.push(key.to_string());
215            }
216        }
217        self
218    }
219    /// 请求参数
220    pub fn params(&mut self, request: JsonValue) -> &mut Self {
221        if request.has_key("page") {
222            self.page = request["page"].as_usize().unwrap();
223        }
224        if request.has_key("limit") {
225            self.limit = request["limit"].as_usize().unwrap();
226        }
227        if request.has_key("where_and") {
228            self.where_and = request["where_and"].clone();
229        }
230        if request.has_key("where_or") {
231            self.where_or = request["where_or"].clone();
232        }
233        if request.has_key("order") {
234            for item in request["order"].members() {
235                let _ = self.order.push(item.clone());
236            }
237        }
238        if request.has_key("search") {
239            self.search = request["search"].to_string();
240        }
241        if request.has_key("primary_key") {
242            self.primary_key = request["primary_key"].to_string();
243        }
244        if request.has_key("value") {
245            self.value = request["value"].members().map(|x| x.to_string()).collect();
246        }
247        self
248    }
249
250    fn db_search(&mut self) {
251        if !self.search.is_empty() {
252            let mut all_fields = object! {};
253            let _ = self.fields.iter().map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone())).collect::<Vec<_>>();
254
255            let mut t=vec![];
256            for value in self.search_fields.clone() {
257                let field = all_fields[value.as_str()].clone();
258                if field.has_key("field_table") {
259                    t.push(format!("{}.{}", field["field_table"].clone(), field["field_table_field"].clone()));
260                }else {
261                    t.push(value);
262                }
263            }
264            self.db.where_and(&t.join("|"), "like", format!("%{}%", self.search).into());
265        }
266    }
267    fn db_where(&mut self) {
268        let mut all_fields = object! {};
269        let _ = self.fields.iter().map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone())).collect::<Vec<_>>();
270
271
272        for value in self.where_or.members() {
273            let field = all_fields[value[0].to_string()].clone();
274            if field.has_key("field_table") {
275                self.db.where_or(
276                    format!("{}.{}", field["field_table"].clone(), field["field_table_field"].clone()).as_str(),
277                    value[1].as_str().unwrap(),
278                    value[2].clone(),
279                );
280            } else {
281                self.db.where_or(
282                    value[0].as_str().unwrap(),
283                    value[1].as_str().unwrap(),
284                    value[2].clone(),
285                );
286            }
287        }
288        for value in self.where_and.members() {
289            let field = all_fields[value[0].to_string()].clone();
290            if field.has_key("field_table") {
291                self.db.where_and(
292                    format!("{}.{}", field["field_table"].clone(), field["field_table_field"].clone()).as_str(),
293                    value[1].as_str().unwrap(),
294                    value[2].clone(),
295                );
296            } else {
297                self.db.where_and(
298                    value[0].as_str().unwrap(),
299                    value[1].as_str().unwrap(),
300                    value[2].clone(),
301                );
302            }
303        }
304    }
305    fn db_order(&mut self) {
306        let mut all_fields = object! {};
307        let _ = self.fields.iter().map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone())).collect::<Vec<_>>();
308
309        for item in self.order.members() {
310            let field = all_fields[item[0].to_string()].clone();
311            if field.has_key("field_table") {
312                self.db.order(format!("{}.{}", field["field_table"].clone(), field["field_table_field"].clone()).as_str(), item[1].as_bool().unwrap());
313            } else {
314                self.db.order(format!("{}.{}", self.main_table, item[0]).as_str(), item[1].as_bool().unwrap());
315            }
316        }
317    }
318    fn db_fields(&mut self) {
319        let mut all_fields = object! {};
320        let _ = self.fields.iter().map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone())).collect::<Vec<_>>();
321
322        if !self.hide_fields.is_empty() {
323            for field in self.hide_fields.clone() {
324                if all_fields.has_key(&field) {
325                    all_fields.remove(&field);
326                    continue;
327                }
328            }
329        }
330
331        if !self.show_fields.is_empty() {
332            self.show_fields.insert(0, "id".to_string());
333            let mut f = object! {};
334            for field in self.show_fields.clone() {
335                if all_fields.has_key(&field) {
336                    let _ = f.insert(&field.clone(), all_fields[field].clone());
337                }
338            }
339            all_fields = f;
340        }
341
342        for (field, item) in all_fields.entries() {
343            let mode = item["mode"].to_string();
344            self.set_fields(field, mode.as_str());
345        }
346
347        self.fields = all_fields.entries().map(|(_, x)| x.clone()).collect::<Vec<JsonValue>>();
348
349
350        if !self.fields_keys.is_empty() {
351            self.db.field(self.fields_keys.join(",").as_str());
352        }
353        if !self.json_fields.is_empty() {
354            self.db.json(self.json_fields.join(",").as_str());
355        }
356        if !self.location_fields.is_empty() {
357            self.db.location(self.location_fields.join(",").as_str());
358        }
359    }
360    fn db_join(&mut self) {
361        self.db.join_fields(self.join_fields.iter().map(|x| x.as_str()).collect());
362        for item in self.join_params.iter() {
363            self.db.join(&item[0], &item[1], &item[2], &item[3]);
364        }
365    }
366    fn db_total(&mut self) {
367        self.total = self.db.clone().count().as_f64().unwrap();
368        self.pages = (self.total / (self.limit as f64)).ceil() as i64;
369    }
370    fn db_table(&mut self) {
371        let mut all_fields = object! {};
372        let _ = self.fields.iter().map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()).unwrap()).collect::<Vec<_>>();
373
374        let mut table_data = object! {};
375        for item in self.data.members_mut() {
376            for field in self.table_fields.iter() {
377                let key = item[field].as_str().unwrap_or("");
378                if key.is_empty() {
379                    continue;
380                }
381                let field_info = all_fields[field].clone();
382
383                if !table_data.has_key(field) {
384                    table_data[field] = object! {};
385                }
386                if !table_data[field].has_key(key) {
387                    let mut info = field_info.clone();
388                    let _ = info["fields"].push("id");
389                    let fields_k = info["fields"].members().map(|x| x.as_str().unwrap()).collect::<Vec<&str>>();
390                    let mut find = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", key.into()).field(&fields_k.join(",")).find();
391                    let id = find["id"].to_string();
392                    find.remove("id");
393                    let label = find.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
394                    table_data[field][key] = object! {
395                                value: id.clone(),
396                                label:label.join(" | ").clone(),
397                    };
398                }
399                item[field] = table_data[field][key].clone();
400            }
401            for field in self.tree_fields.iter() {
402                let key = item[field].as_str().unwrap_or("");
403                if key.is_empty() {
404                    continue;
405                }
406                let field_info = all_fields[field].clone();
407                if !table_data.has_key(field) {
408                    table_data[field] = object! {};
409                }
410                if !table_data[field].has_key(key) {
411                    let mut info = field_info.clone();
412                    let pid_field = info["pid_field"].clone().to_string();
413                    let _ = info["fields"].push("id");
414                    let _ = info["fields"].push(pid_field.clone());
415                    let fields_k = info["fields"].members().map(|x| x.as_str().unwrap()).collect::<Vec<&str>>();
416                    let mut find = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", key.into()).field(&fields_k.join(",")).find();
417                    let mut pid = find[pid_field.clone()].to_string();
418                    let mut name_list = vec![];
419                    let id = find["id"].to_string();
420                    find.remove("id");
421                    find.remove(&pid_field);
422                    let label = find.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
423                    name_list.push(label.join(" | ").clone());
424                    loop {
425                        if pid.is_empty() {
426                            break;
427                        }
428                        let mut t = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", pid.clone().into()).field(&fields_k.join(",")).find();
429                        pid = t[pid_field.clone()].to_string();
430                        t.remove("id");
431                        t.remove(&pid_field);
432                        let label = t.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
433                        name_list.push(label.join(" | ").clone());
434                    }
435                    name_list.reverse();
436                    table_data[field][key] = object! {
437                                value: id.clone(),
438                                label:name_list.join("/").clone(),
439                        };
440                }
441                item[field] = table_data[field][key].clone();
442            }
443        }
444    }
445    fn columns(&mut self) -> JsonValue {
446        let mut all_fields = object! {};
447        let _ = self.fields.iter().map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()).unwrap()).collect::<Vec<_>>();
448
449        let sort_field = self.order.members().map(|x| (x[0].to_string(), x[1].as_bool().unwrap())).collect::<HashMap<String, bool>>();
450        for (_, item) in all_fields.entries_mut() {
451            item["name"] = item["field"].clone();
452            item["align"] = "center".into();
453            item["label"] = item["title"].clone();
454            item["version"] = self.version.into();
455
456            if item["field"].as_str().unwrap_or("") != "id" {
457                if self.version == 0 {
458                    item["sortable"] = true.into();
459                } else {
460                    item["sortable"] = object! {
461                    "sorter"=>false,
462                    "sortDirections"=>array!["ascend","descend"],
463                    "defaultSortOrder"=>"",
464                    "sortOrder"=>""
465                };
466                    if sort_field.contains_key(item["field"].to_string().as_str()) {
467                        item["sortable"]["sortOrder"] = if *sort_field.get(&item["field"].to_string()).unwrap() {
468                            "descend"
469                        } else {
470                            "ascend"
471                        }.into();
472                    }
473                }
474            }
475            item["dataIndex"] = item["field"].clone();
476            item["slotName"] = item["field"].clone();
477            item["titleSlotName"] = item["field"].clone();
478            match item["mode"].as_str().unwrap() {
479                "string" | "text" => {
480                    item["ellipsis"] = true.into();
481                    item["tooltip"] = true.into();
482                }
483                "key" => {
484                    item["width"] = 280.into();
485                    item["ellipsis"] = true.into();
486                }
487                _ => {}
488            }
489        }
490        all_fields
491    }
492    pub fn get_table(&mut self) -> JsonValue {
493        self.db.table(&self.main_table);
494        self.db_fields();
495        self.db_search();
496        self.db_where();
497        self.db_join();
498        self.db_total();
499        self.db_order();
500        self.db.page(self.page as i32, self.limit as i32);
501
502        self.data = self.db.select();
503        self.db_table();
504
505        object! {
506            "pages"=>self.pages,
507            "total"=>self.total,
508            "data"=>self.data.clone(),
509            "columns"=>self.columns(),
510            "filter_fields"=>self.filter_fields.clone(),
511            "search_name"=>self.search_name.clone(),
512            "total_fields"=>self.total_fields.clone(),
513            "btn_all"=>array![],
514            "btn_api"=>array![],
515            "btn_ids"=>array![]
516        }
517    }
518    pub fn get_table_edit(&mut self) -> JsonValue {
519        self.db.table(&self.main_table);
520        self.db_fields();
521        self.db_search();
522        self.db_where();
523        self.db_total();
524        self.db_order();
525        self.db.page(self.page as i32, self.limit as i32);
526        self.db_join();
527        self.data = self.db.select();
528
529        object! {
530            "pages"=>self.pages,
531            "total"=>self.total,
532            "data"=>self.data.clone(),
533            "columns"=>self.columns(),
534            "edit_fields"=>self.edit_fields.clone(),
535        }
536    }
537    pub fn get_table_select(&mut self) -> JsonValue {
538        self.db.table(&self.main_table);
539        if !self.primary_key.eq("id") {
540            self.fields_keys.remove(0);
541        }
542        if !self.value.is_empty() {
543            let _ = self.where_or.push(array![self.primary_key.clone(),"in",self.value.clone()]);
544            let _ = self.where_or.push(array![self.primary_key.clone(),"isnot","NULL"]);
545            let _ = self.order.push(array![format!("{} in ('{}')",self.primary_key.clone(),self.value.join("','")),true]);
546        }
547        self.db_fields();
548        self.db_search();
549        self.db_where();
550        self.db_total();
551        self.db_order();
552        self.db.page(self.page as i32, self.limit as i32);
553        self.db_join();
554
555        let mut list = self.db.select();
556
557        for item in list.members_mut() {
558            let value = item[self.primary_key.clone()].clone();
559            if self.primary_key.eq("id") {
560                item.remove(&self.primary_key.clone());
561            }
562            let label = item.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
563            self.data.push(object! {
564                value: value,
565                label: label.join(" | ").clone(),
566            }).unwrap();
567        }
568        object! {
569            "pages"=>self.pages,
570            "total"=>self.total,
571            "data"=>self.data.clone(),
572        }
573    }
574}
br_addon/tables.rs

br_addon/
tables.rs
