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
368        let t=self.db.clone().fetch_sql().count();
369        println!(">>>>{}<<<<",t);
370        let t=self.db.clone().count();
371        println!(">>>>{}<<<<",t);
372        self.total = t.as_f64().unwrap();
373        self.pages = (self.total / (self.limit as f64)).ceil() as i64;
374    }
375    fn db_table(&mut self) {
376        let mut all_fields = object! {};
377        let _ = self.fields.iter().map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()).unwrap()).collect::<Vec<_>>();
378
379        let mut table_data = object! {};
380        for item in self.data.members_mut() {
381            for field in self.table_fields.iter() {
382                let key = item[field].as_str().unwrap_or("");
383                if key.is_empty() {
384                    continue;
385                }
386                let field_info = all_fields[field].clone();
387
388                if !table_data.has_key(field) {
389                    table_data[field] = object! {};
390                }
391                if !table_data[field].has_key(key) {
392                    let mut info = field_info.clone();
393                    let _ = info["fields"].push("id");
394                    let fields_k = info["fields"].members().map(|x| x.as_str().unwrap()).collect::<Vec<&str>>();
395                    let mut find = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", key.into()).field(&fields_k.join(",")).find();
396                    let id = find["id"].to_string();
397                    find.remove("id");
398                    let label = find.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
399                    table_data[field][key] = object! {
400                                value: id.clone(),
401                                label:label.join(" | ").clone(),
402                    };
403                }
404                item[field] = table_data[field][key].clone();
405            }
406            for field in self.tree_fields.iter() {
407                let key = item[field].as_str().unwrap_or("");
408                if key.is_empty() {
409                    continue;
410                }
411                let field_info = all_fields[field].clone();
412                if !table_data.has_key(field) {
413                    table_data[field] = object! {};
414                }
415                if !table_data[field].has_key(key) {
416                    let mut info = field_info.clone();
417                    let pid_field = info["pid_field"].clone().to_string();
418                    let _ = info["fields"].push("id");
419                    let _ = info["fields"].push(pid_field.clone());
420                    let fields_k = info["fields"].members().map(|x| x.as_str().unwrap()).collect::<Vec<&str>>();
421                    let mut find = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", key.into()).field(&fields_k.join(",")).find();
422                    let mut pid = find[pid_field.clone()].to_string();
423                    let mut name_list = vec![];
424                    let id = find["id"].to_string();
425                    find.remove("id");
426                    find.remove(&pid_field);
427                    let label = find.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
428                    name_list.push(label.join(" | ").clone());
429                    loop {
430                        if pid.is_empty() {
431                            break;
432                        }
433                        let mut t = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", pid.clone().into()).field(&fields_k.join(",")).find();
434                        pid = t[pid_field.clone()].to_string();
435                        t.remove("id");
436                        t.remove(&pid_field);
437                        let label = t.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
438                        name_list.push(label.join(" | ").clone());
439                    }
440                    name_list.reverse();
441                    table_data[field][key] = object! {
442                                value: id.clone(),
443                                label:name_list.join("/").clone(),
444                        };
445                }
446                item[field] = table_data[field][key].clone();
447            }
448        }
449    }
450    fn columns(&mut self) -> JsonValue {
451        let mut all_fields = object! {};
452        let _ = self.fields.iter().map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()).unwrap()).collect::<Vec<_>>();
453
454        let sort_field = self.order.members().map(|x| (x[0].to_string(), x[1].as_bool().unwrap())).collect::<HashMap<String, bool>>();
455        for (_, item) in all_fields.entries_mut() {
456            item["name"] = item["field"].clone();
457            item["align"] = "center".into();
458            item["label"] = item["title"].clone();
459            item["version"] = self.version.into();
460
461            if item["field"].as_str().unwrap_or("") != "id" {
462                if self.version == 0 {
463                    item["sortable"] = true.into();
464                } else {
465                    item["sortable"] = object! {
466                    "sorter"=>false,
467                    "sortDirections"=>array!["ascend","descend"],
468                    "defaultSortOrder"=>"",
469                    "sortOrder"=>""
470                };
471                    if sort_field.contains_key(item["field"].to_string().as_str()) {
472                        item["sortable"]["sortOrder"] = if *sort_field.get(&item["field"].to_string()).unwrap() {
473                            "descend"
474                        } else {
475                            "ascend"
476                        }.into();
477                    }
478                }
479            }
480            item["dataIndex"] = item["field"].clone();
481            item["slotName"] = item["field"].clone();
482            item["titleSlotName"] = item["field"].clone();
483            match item["mode"].as_str().unwrap() {
484                "string" | "text" => {
485                    item["ellipsis"] = true.into();
486                    item["tooltip"] = true.into();
487                }
488                "key" => {
489                    item["width"] = 280.into();
490                    item["ellipsis"] = true.into();
491                }
492                _ => {}
493            }
494        }
495        all_fields
496    }
497    pub fn get_table(&mut self) -> JsonValue {
498        self.db.table(&self.main_table);
499        self.db_fields();
500        self.db_search();
501        self.db_where();
502        self.db_join();
503        self.db_total();
504        self.db_order();
505        self.db.page(self.page as i32, self.limit as i32);
506
507        self.data = self.db.select();
508        self.db_table();
509
510        object! {
511            "pages"=>self.pages,
512            "total"=>self.total,
513            "data"=>self.data.clone(),
514            "columns"=>self.columns(),
515            "filter_fields"=>self.filter_fields.clone(),
516            "search_name"=>self.search_name.clone(),
517            "total_fields"=>self.total_fields.clone(),
518            "btn_all"=>array![],
519            "btn_api"=>array![],
520            "btn_ids"=>array![]
521        }
522    }
523    pub fn get_table_edit(&mut self) -> JsonValue {
524        self.db.table(&self.main_table);
525        self.db_fields();
526        self.db_search();
527        self.db_where();
528        self.db_total();
529        self.db_order();
530        self.db.page(self.page as i32, self.limit as i32);
531        self.db_join();
532        self.data = self.db.select();
533
534        object! {
535            "pages"=>self.pages,
536            "total"=>self.total,
537            "data"=>self.data.clone(),
538            "columns"=>self.columns(),
539            "edit_fields"=>self.edit_fields.clone(),
540        }
541    }
542    pub fn get_table_select(&mut self) -> JsonValue {
543        self.db.table(&self.main_table);
544        if !self.primary_key.eq("id") {
545            self.fields_keys.remove(0);
546        }
547        if !self.value.is_empty() {
548            let _ = self.where_or.push(array![self.primary_key.clone(),"in",self.value.clone()]);
549            let _ = self.where_or.push(array![self.primary_key.clone(),"isnot","NULL"]);
550            let _ = self.order.push(array![format!("{} in ('{}')",self.primary_key.clone(),self.value.join("','")),true]);
551        }
552        self.db_fields();
553        self.db_search();
554        self.db_where();
555        self.db_join();
556        self.db_total();
557        self.db_order();
558        self.db.page(self.page as i32, self.limit as i32);
559
560        let mut list = self.db.select();
561
562        for item in list.members_mut() {
563            let value = item[self.primary_key.clone()].clone();
564            if self.primary_key.eq("id") {
565                item.remove(&self.primary_key.clone());
566            }
567            let label = item.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
568            self.data.push(object! {
569                value: value,
570                label: label.join(" | ").clone(),
571            }).unwrap();
572        }
573        object! {
574            "pages"=>self.pages,
575            "total"=>self.total,
576            "data"=>self.data.clone(),
577        }
578    }
579}
br_addon/tables.rs

br_addon/
tables.rs
