br_addon/
tables.rs

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

br_addon/
tables.rs
