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    join_table: String,
12    /// 数据库
13    db: Db,
14    /// 记录总数量
15    total: f64,
16    /// 字段数据
17    fields: JsonValue,
18    /// 连表查询
19    join_params: Vec<Vec<String>>,
20    /// 字段值集合
21    fields_keys: 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            join_table: "".to_string(),
87            db,
88            total: 0.0,
89            fields: object! {},
90            join_params: vec![],
91            fields_keys: vec![],
92            data: array![],
93            page: 1,
94            pages: 0,
95            limit: 10,
96            search: "".to_string(),
97            search_fields: vec![],
98            search_name: "".to_string(),
99            edit_fields: vec![],
100            order: array![],
101            where_and: array![],
102            where_or: array![],
103            filter_fields: vec![],
104            table_fields: vec![],
105            tree_fields: vec![],
106            json_fields: vec![],
107            location_fields: vec![],
108            primary_key: "".to_string(),
109            value: vec![],
110            version: 0,
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 self.fields.entries() {
137            self.fields_keys.push(field.to_string());
138            match item["mode"].as_str().unwrap() {
139                "table" => self.table_fields.push(field.to_string()),
140                "tree" => self.tree_fields.push(field.to_string()),
141                "object" | "array" | "polygon" => self.json_fields.push(field.to_string()),
142                "location" => self.location_fields.push(field.to_string()),
143                _ => {}
144            }
145        }
146        self
147    }
148    pub fn join_table_fields(&mut self, table: &str, mut fields: JsonValue, main_field: &str, join_field: &str) -> &mut Self {
149        self.join_table = table.to_string();
150
151        let mut field = vec![];
152        for (key, item) in fields.entries_mut() {
153            item["field"] = format!("{table}_{key}").into();
154            field.push(format!("{key} as {table}_{key}"));
155            self.fields[format!("{table}_{key}").as_str()] = item.clone();
156        }
157        self.join_params.push(vec![table.to_string(), main_field.to_string(), join_field.to_string(), field.join(",")]);
158        self
159    }
160    pub fn main_select_fields(&mut self, table: &str, mut show_fields: Vec<&str>) -> &mut Self {
161        self.main_table = table.to_string();
162        show_fields.insert(0, "id");
163        self.fields_keys = show_fields.into_iter().map(|x| x.to_string()).collect();
164        self.search_fields = self.fields_keys.clone();
165        self
166    }
167
168    pub fn edit_fields(&mut self, fields: Vec<&str>) -> &mut Self {
169        self.edit_fields = fields.iter().map(|s| s.to_string()).collect();
170        self
171    }
172    pub fn search_fields(&mut self, fields: Vec<&str>) -> &mut Self {
173        let mut search_name = vec![];
174        for key in fields.clone() {
175            if self.fields.has_key(key) {
176                self.search_fields.push(key.to_string());
177                search_name.push(self.fields[key]["title"].to_string());
178            }
179        }
180        self.search_name = search_name.join("/");
181        self
182    }
183    /// 条件过滤
184    pub fn filter_fields(&mut self, fields: Vec<&str>) -> &mut Self {
185        for key in fields.clone() {
186            if self.fields.has_key(key) {
187                self.filter_fields.push(key.to_string());
188            }
189        }
190        self
191    }
192    /// 请求参数
193    pub fn params(&mut self, request: JsonValue) -> &mut Self {
194        if request.has_key("page") {
195            self.page = request["page"].as_usize().unwrap();
196        }
197        if request.has_key("limit") {
198            self.limit = request["limit"].as_usize().unwrap();
199        }
200        if request.has_key("where_and") {
201            self.where_and = request["where_and"].clone();
202        }
203        if request.has_key("where_or") {
204            self.where_or = request["where_or"].clone();
205        }
206        if request.has_key("search") {
207            self.search = request["search"].to_string();
208        }
209        if request.has_key("primary_key") {
210            self.primary_key = request["primary_key"].to_string();
211        }
212        if request.has_key("value") {
213            self.value = request["value"].members().map(|x| x.to_string()).collect();
214        }
215        self
216    }
217
218    fn db_search(&mut self) {
219        if !self.search.is_empty() {
220            self.db.where_and(&self.search_fields.join("|"), "like", format!("%{}%", self.search).into());
221        }
222    }
223    fn db_where(&mut self) {
224        for value in self.where_or.members() {
225            self.db.where_or(
226                value[0].as_str().unwrap(),
227                value[1].as_str().unwrap(),
228                value[2].clone(),
229            );
230        }
231        for value in self.where_and.members() {
232            self.db.where_and(
233                value[0].as_str().unwrap(),
234                value[1].as_str().unwrap(),
235                value[2].clone(),
236            );
237        }
238        for item in self.order.members() {
239            self.db.order(item[0].as_str().unwrap(), item[1].as_bool().unwrap());
240        }
241    }
242    fn db_fields(&mut self) {
243        self.db.field(self.fields_keys.join(",").as_str());
244        if !self.json_fields.is_empty() {
245            self.db.json(self.json_fields.join(",").as_str());
246        }
247        if !self.location_fields.is_empty() {
248            self.db.location(self.location_fields.join(",").as_str());
249        }
250    }
251    fn db_join(&mut self) {
252        for item in self.join_params.iter() {
253            self.db.join(&item[0], &item[1], &item[2]).field(&item[3]);
254        }
255    }
256    fn db_total(&mut self) {
257        self.total = self.db.clone().count().as_f64().unwrap();
258        self.pages = (self.total / (self.limit as f64)).ceil() as i64;
259    }
260    fn db_table(&mut self) {
261        let mut table_data = object! {};
262        for item in self.data.members_mut() {
263            for field in self.table_fields.iter() {
264                let key = item[field].as_str().unwrap_or("");
265                if key.is_empty() {
266                    continue;
267                }
268                let field_info = self.fields[field].clone();
269
270                if !table_data.has_key(field) {
271                    table_data[field] = object! {};
272                }
273                if !table_data[field].has_key(key) {
274                    let mut info = field_info.clone();
275                    let _ = info["fields"].push("id");
276                    let fields_k = info["fields"].members().map(|x| x.as_str().unwrap()).collect::<Vec<&str>>();
277                    let mut find = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", key.into()).field(&fields_k.join(",")).find();
278                    let id = find["id"].to_string();
279                    find.remove("id");
280                    let label = find.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
281                    table_data[field][key] = object! {
282                                value: id.clone(),
283                                label:label.join(" | ").clone(),
284                    };
285                }
286                item[field] = table_data[field][key].clone();
287            }
288            for field in self.tree_fields.iter() {
289                let key = item[field].as_str().unwrap_or("");
290                if key.is_empty() {
291                    continue;
292                }
293                let field_info = self.fields[field].clone();
294                if !table_data.has_key(field) {
295                    table_data[field] = object! {};
296                }
297                if !table_data[field].has_key(key) {
298                    let mut info = field_info.clone();
299                    let pid_field = info["pid_field"].clone().to_string();
300                    let _ = info["fields"].push("id");
301                    let _ = info["fields"].push(pid_field.clone());
302                    let fields_k = info["fields"].members().map(|x| x.as_str().unwrap()).collect::<Vec<&str>>();
303                    let mut find = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", key.into()).field(&fields_k.join(",")).find();
304                    let mut pid = find[pid_field.clone()].to_string();
305                    let mut name_list = vec![];
306                    let id = find["id"].to_string();
307                    find.remove("id");
308                    find.remove(&pid_field);
309                    let label = find.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
310                    name_list.push(label.join(" | ").clone());
311                    loop {
312                        if pid.is_empty() {
313                            break;
314                        }
315                        let mut t = self.db.table(info["table"].as_str().unwrap()).where_and("id", "=", pid.clone().into()).field(&fields_k.join(",")).find();
316                        pid = t[pid_field.clone()].to_string();
317                        t.remove("id");
318                        t.remove(&pid_field);
319                        let label = t.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
320                        name_list.push(label.join(" | ").clone());
321                    }
322                    name_list.reverse();
323                    table_data[field][key] = object! {
324                                value: id.clone(),
325                                label:name_list.join("/").clone(),
326                        };
327                }
328                item[field] = table_data[field][key].clone();
329            }
330        }
331    }
332    fn q_columns(&mut self) -> JsonValue {
333        let mut columns = object! {};
334        for (key, item) in self.fields.entries() {
335            columns[key] = item.clone();
336            columns[key]["name"] = item["field"].clone();
337            columns[key]["align"] = "center".into();
338            columns[key]["label"] = item["title"].clone();
339            columns[key]["field"] = item["field"].clone();
340            columns[key]["version"] = self.version.into();
341            if item["mode"].as_str().unwrap() == "string" {}
342        }
343        columns
344    }
345
346    fn a_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]["dataIndex"] = item["field"].clone();
351            columns[key]["align"] = "center".into();
352            columns[key]["slotName"] = item["field"].clone();
353            columns[key]["titleSlotName"] = item["field"].clone();
354            columns[key]["version"] = self.version.into();
355            if item["mode"].as_str().unwrap() == "string" {}
356            //columns[key]["width"] = 50.into();
357
358            //columns[key]["minWidth"] = 50.into();
359            //columns[key]["fixed"] = "left".into();
360        }
361        columns
362    }
363    pub fn get_table(&mut self) -> JsonValue {
364        self.db.table(&self.main_table);
365        self.db_search();
366        self.db_where();
367        self.db_total();
368        self.db_fields();
369        self.db.page(self.page as i32, self.limit as i32);
370        self.db_join();
371        self.data = self.db.select();
372        self.db_table();
373
374        object! {
375            "pages"=>self.pages,
376            "total"=>self.total,
377            "data"=>self.data.clone(),
378            "columns"=>self.q_columns(),
379            "filter_fields"=>self.filter_fields.clone(),
380            "search_name"=>self.search_name.clone(),
381            "btn_all"=>array![],
382            "btn_api"=>array![],
383            "btn_ids"=>array![]
384        }
385    }
386    pub fn get_table_edit(&mut self) -> JsonValue {
387        self.db.table(&self.main_table);
388        self.db_search();
389        self.db_where();
390        self.db_total();
391        self.db_fields();
392        self.db.page(self.page as i32, self.limit as i32);
393        self.db_join();
394        self.data = self.db.select();
395
396        object! {
397            "pages"=>self.pages,
398            "total"=>self.total,
399            "data"=>self.data.clone(),
400            "columns"=>self.a_columns(),
401            "edit_fields"=>self.edit_fields.clone(),
402        }
403    }
404    pub fn get_table_select(&mut self) -> JsonValue {
405        self.db.table(&self.main_table);
406        if !self.primary_key.eq("id") {
407            self.fields_keys.remove(0);
408        }
409        if !self.value.is_empty() {
410            let _ = self.where_or.push(array![self.primary_key.clone(),"in",self.value.clone()]);
411            let _ = self.where_or.push(array![self.primary_key.clone(),"isnot","NULL"]);
412            let _ = self.order.push(array![format!("{} in ('{}')",self.primary_key.clone(),self.value.join("','")),true]);
413        }
414
415        self.db_search();
416        self.db_where();
417        self.db_total();
418        self.db_fields();
419        self.db.page(self.page as i32, self.limit as i32);
420        self.db_join();
421
422        let mut list = self.db.select();
423
424        for item in list.members_mut() {
425            let value = item[self.primary_key.clone()].clone();
426            if self.primary_key.eq("id") {
427                item.remove(&self.primary_key.clone());
428            }
429            let label = item.entries().map(|(_, v)| v.to_string()).collect::<Vec<String>>();
430            self.data.push(object! {
431                value: value,
432                label: label.join(" | ").clone(),
433            }).unwrap();
434        }
435        object! {
436            "pages"=>self.pages,
437            "total"=>self.total,
438            "data"=>self.data.clone(),
439        }
440    }
441}
br_addon/tables.rs

br_addon/
tables.rs
