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 main_table: String,
14 db: Db,
16 total: f64,
18 fields: Vec<JsonValue>,
20 join_params: Vec<Vec<String>>,
22 fields_keys: Vec<String>,
24 join_fields: Vec<String>,
26 hide_fields: Vec<String>,
28 show_fields: Vec<String>,
30 total_fields: Vec<String>,
32 data: JsonValue,
34 page: usize,
36 pages: i64,
38 limit: usize,
40 search: String,
42 search_fields: Vec<String>,
44 search_name: String,
46 edit_fields: Vec<String>,
48 order: JsonValue,
51 where_and: JsonValue,
54 where_or: JsonValue,
57 filter_fields: Vec<String>,
59 table_fields: Vec<String>,
61 tree_fields: Vec<String>,
63 json_fields: Vec<String>,
65 location_fields: Vec<String>,
67 primary_key: String,
69 value: Vec<String>,
71 version: usize,
72 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 self.fields.insert(x as usize, item.clone());
163 }
164 _ => {
165 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 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 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}