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(
8 feature = "sqlite",
9 feature = "mssql",
10 feature = "mysql",
11 feature = "pgsql"
12))]
13pub struct Tables {
14 main_table: String,
16 db: Db,
18 total: f64,
20 fields: Vec<JsonValue>,
22 join_params: Vec<Vec<String>>,
24 fields_keys: Vec<String>,
26 join_fields: Vec<String>,
28 hide_fields: Vec<String>,
30 show_fields: Vec<String>,
32 total_fields: Vec<String>,
34 data: JsonValue,
36 page: usize,
38 pages: i64,
40 limit: usize,
42 search: String,
44 search_fields: Vec<String>,
46 search_name: String,
48 edit_fields: Vec<String>,
50 order: JsonValue,
53 where_and: JsonValue,
56 where_or: JsonValue,
59 filter_fields: Vec<String>,
61 table_fields: Vec<String>,
63 tree_fields: Vec<String>,
65 json_fields: Vec<String>,
67 location_fields: Vec<String>,
69 primary_key: String,
71 value: Vec<String>,
73 version: usize,
74 pid_id: String,
76}
77impl Tables {
78 pub fn params_table(mut params: JsonValue) -> JsonValue {
79 params["page"] = br_fields::int::Int::new(false, "page", "页数", 10, 1)
80 .example(1.into())
81 .field();
82 params["limit"] = br_fields::int::Int::new(false, "limit", "行数", 10, 10)
83 .example(10.into())
84 .field();
85 params["order"] = br_fields::text::Array::new(false, "order", "排序", array![]).field();
86 params["search"] = br_fields::str::Str::new(false, "search", "搜索", 200, "")
87 .example("".into())
88 .field();
89 params["where_or"] = br_fields::text::Array::new(false, "where_or", "查询条件", array![])
90 .example(array![])
91 .field();
92 params["where_and"] = br_fields::text::Array::new(false, "where_and", "查询条件", array![])
93 .example(array![])
94 .field();
95 params["params"] =
96 br_fields::text::Object::new(false, "params", "关联数据参数", object! {})
97 .describe("如果是表单就是表单里的其他字段")
98 .example(object! {})
99 .field();
100 params
101 }
102 pub fn params_table_tree(mut params: JsonValue) -> JsonValue {
103 params["pid"] = br_fields::str::Str::new(false, "pid", "上级ID", 50, "")
104 .example("".into())
105 .field();
106 Tables::params_table_select(params)
107 }
108 pub fn params_table_select(mut params: JsonValue) -> JsonValue {
109 params["value"] = br_fields::text::Array::new(false, "value", "已选中值", array![]).field();
110 params["primary_key"] =
111 br_fields::str::Str::new(false, "primary_key", "显示内容的字段", 50, "id").field();
112 Tables::params_table(params)
113 }
114 pub fn params_table_select_tree(mut params: JsonValue) -> JsonValue {
115 params["pid"] = br_fields::str::Str::new(false, "pid", "上级ID", 20, "")
116 .example("".into())
117 .field();
118 params["value"] = br_fields::text::Array::new(false, "value", "已选中值", array![]).field();
119 Tables::params_table(params)
120 }
121 pub fn new(db: Db) -> Self {
122 Self {
123 main_table: "".to_string(),
124 db,
125 total: 0.0,
126 fields: vec![],
127 join_params: vec![],
128 fields_keys: vec![],
129 data: array![],
130 page: 1,
131 pages: 0,
132 limit: 10,
133 search: "".to_string(),
134 search_fields: vec![],
135 search_name: "".to_string(),
136 edit_fields: vec![],
137 order: array![],
138 where_and: array![],
139 where_or: array![],
140 filter_fields: vec![],
141 table_fields: vec![],
142 tree_fields: vec![],
143 json_fields: vec![],
144 location_fields: vec![],
145 primary_key: "".to_string(),
146 value: vec![],
147 version: 0,
148 join_fields: vec![],
149 hide_fields: vec![],
150 show_fields: vec![],
151 total_fields: vec![],
152 pid_id: "".to_string(),
153 }
154 }
155 pub fn set_version(&mut self, version: usize) -> &mut Self {
156 self.version = version;
157 self
158 }
159 pub fn main_table_fields(
160 &mut self,
161 table: &str,
162 fields: JsonValue,
163 hide_fields: Vec<&str>,
164 show_fields: Vec<&str>,
165 ) -> &mut Self {
166 self.main_table = table.to_string();
167 self.hide_fields = hide_fields.iter().map(|s| s.to_string()).collect();
168 self.show_fields = show_fields.iter().map(|s| s.to_string()).collect();
169 self.fields = fields
170 .entries()
171 .map(|(_, x)| x.clone())
172 .collect::<Vec<JsonValue>>();
173 self
174 }
175 pub fn join_fields(&mut self, table: &str, mut fields: JsonValue, index: isize) -> &mut Self {
176 for (field, item) in fields.entries_mut() {
177 if self.main_table != table {
178 item["field"] = format!("{table}_{field}").into();
179 item["field_table"] = table.into();
180 item["field_table_field"] = field.into();
181 }
182
183 match index {
184 x if x > -1 => {
185 self.fields.insert(x as usize, item.clone());
187 }
188 _ => {
189 self.fields.push(item.clone());
191 }
192 }
193 self.join_fields.push(format!("{table}.{field}"));
194 }
195 self
196 }
197 pub fn fields(&mut self, fields: JsonValue) -> &mut Self {
198 self.fields = fields
199 .entries()
200 .map(|(_, x)| x.clone())
201 .collect::<Vec<JsonValue>>();
202 self
203 }
204 pub fn hide_fields(&mut self, hide_fields: Vec<&str>) -> &mut Self {
205 self.hide_fields = hide_fields.iter().map(|s| s.to_string()).collect();
206 self
207 }
208 pub fn show_fields(&mut self, show_fields: Vec<&str>) -> &mut Self {
209 self.show_fields = show_fields.iter().map(|s| s.to_string()).collect();
210 self
211 }
212 pub fn total_fields(&mut self, fields: Vec<&str>) -> &mut Self {
213 self.total_fields = fields.iter().map(|s| s.to_string()).collect();
214 self
215 }
216 fn set_fields(&mut self, field: &str, mode: &str) {
217 match mode {
218 "table" => self.table_fields.push(field.to_string()),
219 "tree" => self.tree_fields.push(field.to_string()),
220 "object" | "array" | "polygon" => self.json_fields.push(field.to_string()),
221 "location" => self.location_fields.push(field.to_string()),
222 _ => {}
223 }
224 }
225 pub fn join_table(
226 &mut self,
227 main_table: &str,
228 main_field: &str,
229 join_table: &str,
230 join_field: &str,
231 ) -> &mut Self {
232 self.join_params.push(vec![
233 main_table.to_string(),
234 main_field.to_string(),
235 join_table.to_string(),
236 join_field.to_string(),
237 ]);
238 self
239 }
240 pub fn main_select_fields(&mut self, table: &str, mut show_fields: Vec<&str>) -> &mut Self {
241 self.main_table = table.to_string();
242 show_fields.insert(0, "id");
243 self.fields_keys = show_fields.into_iter().map(|x| x.to_string()).collect();
244 self.search_fields = self.fields_keys.clone();
245 self
246 }
247
248 pub fn edit_fields(&mut self, fields: Vec<&str>) -> &mut Self {
249 self.edit_fields = fields.iter().map(|s| s.to_string()).collect();
250 self
251 }
252 pub fn search_fields(&mut self, fields: Vec<&str>) -> &mut Self {
253 let mut search_name = vec![];
254 let all_fields = self
255 .fields
256 .iter()
257 .map(|x| (x["field"].to_string(), x.clone()))
258 .collect::<HashMap<String, JsonValue>>();
259 for key in fields.clone() {
260 if all_fields.contains_key(key) {
261 self.search_fields.push(key.to_string());
262 search_name.push(all_fields.get(key).unwrap()["title"].to_string());
263 }
264 }
265 self.search_name = search_name.join("/");
266 self
267 }
268 pub fn filter_fields(&mut self, fields: Vec<&str>) -> &mut Self {
270 let all_fields = self
271 .fields
272 .iter()
273 .map(|x| (x["field"].to_string(), x.clone()))
274 .collect::<HashMap<String, JsonValue>>();
275 for key in fields.clone() {
276 if all_fields.contains_key(key) {
277 self.filter_fields.push(key.to_string());
278 }
279 }
280 self
281 }
282 pub fn params(&mut self, request: JsonValue) -> &mut Self {
284 if request.has_key("page") {
285 self.page = request["page"].as_usize().unwrap();
286 }
287 if request.has_key("limit") {
288 self.limit = request["limit"].as_usize().unwrap();
289 }
290 if request.has_key("where_and") {
291 self.where_and = request["where_and"].clone();
292 }
293 if request.has_key("where_or") {
294 self.where_or = request["where_or"].clone();
295 }
296
297 if request.has_key("pid") {
298 self.pid_id = request["pid"].as_str().unwrap_or("").to_string();
299 }
300
301 if request.has_key("order") {
302 for item in request["order"].members() {
303 let _ = self.order.push(item.clone());
304 }
305 }
306 if request.has_key("search") {
307 self.search = request["search"].to_string();
308 }
309 if request.has_key("primary_key") {
310 self.primary_key = request["primary_key"].to_string();
311 }
312 if request.has_key("value") {
313 self.value = request["value"]
314 .members()
315 .map(|x| x.as_str().unwrap_or("").to_string())
316 .filter(|x| !x.is_empty())
317 .collect();
318 }
319 self
320 }
321
322 fn db_search(&mut self) {
323 if !self.search.is_empty() {
324 let mut all_fields = object! {};
325 let _ = self
326 .fields
327 .iter()
328 .map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()))
329 .collect::<Vec<_>>();
330
331 let mut t = vec![];
332 for value in self.search_fields.clone() {
333 let field = all_fields[value.as_str()].clone();
334 if field.has_key("field_table") {
335 t.push(format!(
336 "{}.{}",
337 field["field_table"].clone(),
338 field["field_table_field"].clone()
339 ));
340 } else {
341 t.push(value);
342 }
343 }
344 self.db
345 .where_and(&t.join("|"), "like", format!("%{}%", self.search).into());
346 }
347 }
348 fn db_where(&mut self) {
349 let mut all_fields = object! {};
350 let _ = self
351 .fields
352 .iter()
353 .map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()))
354 .collect::<Vec<_>>();
355
356 for value in self.where_or.members() {
357 let field = all_fields[value[0].to_string()].clone();
358 if field.has_key("field_table") {
359 self.db.where_or(
360 format!(
361 "{}.{}",
362 field["field_table"].clone(),
363 field["field_table_field"].clone()
364 )
365 .as_str(),
366 value[1].as_str().unwrap(),
367 value[2].clone(),
368 );
369 } else {
370 self.db.where_or(
371 value[0].as_str().unwrap(),
372 value[1].as_str().unwrap(),
373 value[2].clone(),
374 );
375 }
376 }
377 for value in self.where_and.members() {
378 let field = all_fields[value[0].to_string()].clone();
379 if field.has_key("field_table") {
380 self.db.where_and(
381 format!(
382 "{}.{}",
383 field["field_table"].clone(),
384 field["field_table_field"].clone()
385 )
386 .as_str(),
387 value[1].as_str().unwrap(),
388 value[2].clone(),
389 );
390 } else {
391 self.db.where_and(
392 value[0].as_str().unwrap(),
393 value[1].as_str().unwrap(),
394 value[2].clone(),
395 );
396 }
397 }
398 }
399 fn db_order(&mut self) {
400 let mut all_fields = object! {};
401 let _ = self
402 .fields
403 .iter()
404 .map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()))
405 .collect::<Vec<_>>();
406
407 for item in self.order.members() {
408 let field = all_fields[item[0].to_string()].clone();
409 if field.has_key("field_table") {
410 self.db.order(
411 format!(
412 "{}.{}",
413 field["field_table"].clone(),
414 field["field_table_field"].clone()
415 )
416 .as_str(),
417 item[1].as_bool().unwrap(),
418 );
419 } else {
420 self.db.order(
421 format!("{}.{}", self.main_table, item[0]).as_str(),
422 item[1].as_bool().unwrap(),
423 );
424 }
425 }
426 }
427 fn db_fields(&mut self) {
428 let mut all_fields = object! {};
429 let _ = self
430 .fields
431 .iter()
432 .map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()))
433 .collect::<Vec<_>>();
434
435 if !self.hide_fields.is_empty() {
436 for field in self.hide_fields.clone() {
437 if all_fields.has_key(&field) {
438 all_fields.remove(&field);
439 continue;
440 }
441 }
442 }
443
444 if !self.show_fields.is_empty() {
445 self.show_fields.insert(0, "id".to_string());
446 let mut f = object! {};
447 for field in self.show_fields.clone() {
448 if all_fields.has_key(&field) {
449 let _ = f.insert(&field.clone(), all_fields[field].clone());
450 }
451 }
452 all_fields = f;
453 }
454
455 for (field, item) in all_fields.entries() {
456 let mode = item["mode"].to_string();
457 self.set_fields(field, mode.as_str());
458 }
459
460 self.fields = all_fields
461 .entries()
462 .map(|(_, x)| x.clone())
463 .collect::<Vec<JsonValue>>();
464
465 if !self.fields_keys.is_empty() {
466 self.db.field(self.fields_keys.join(",").as_str());
467 }
468 if !self.json_fields.is_empty() {
469 self.db.json(self.json_fields.join(",").as_str());
470 }
471 if !self.location_fields.is_empty() {
472 self.db.location(self.location_fields.join(",").as_str());
473 }
474 }
475 fn db_join(&mut self) {
476 if !self.join_fields.is_empty() {
477 self.db
478 .join_fields(self.join_fields.iter().map(|x| x.as_str()).collect());
479 }
480 for item in self.join_params.iter() {
481 self.db.join(&item[0], &item[1], &item[2], &item[3]);
482 }
483 }
484 fn db_total(&mut self) {
485 self.total = self.db.clone().count().as_f64().unwrap();
486 self.pages = (self.total / (self.limit as f64)).ceil() as i64;
487 }
488 fn db_table(&mut self) {
489 let mut all_fields = object! {};
490 let _ = self
491 .fields
492 .iter()
493 .map(|x| {
494 all_fields
495 .insert(x["field"].as_str().unwrap(), x.clone())
496 .unwrap()
497 })
498 .collect::<Vec<_>>();
499
500 let mut table_data = object! {};
501 for item in self.data.members_mut() {
502 for field in self.table_fields.iter() {
503 let key = item[field].as_str().unwrap_or("");
504 if key.is_empty() {
505 continue;
506 }
507 let field_info = all_fields[field].clone();
508
509 if !table_data.has_key(field) {
510 table_data[field] = object! {};
511 }
512 if !table_data[field].has_key(key) {
513 let mut info = field_info.clone();
514 let _ = info["fields"].push("id");
515 let fields_k = info["fields"]
516 .members()
517 .map(|x| x.as_str().unwrap())
518 .collect::<Vec<&str>>();
519 let mut find = self
520 .db
521 .table(info["table"].as_str().unwrap())
522 .where_and("id", "=", key.into())
523 .field(&fields_k.join(","))
524 .find();
525 let id = find["id"].to_string();
526 find.remove("id");
527 let label = find
528 .entries()
529 .map(|(_, v)| v.to_string())
530 .collect::<Vec<String>>();
531 table_data[field][key] = object! {
532 value: id.clone(),
533 label:label.join(" | ").clone(),
534 };
535 }
536 item[field] = table_data[field][key].clone();
537 }
538 for field in self.tree_fields.iter() {
539 let key = item[field].as_str().unwrap_or("");
540 if key.is_empty() {
541 continue;
542 }
543 let field_info = all_fields[field].clone();
544 if !table_data.has_key(field) {
545 table_data[field] = object! {};
546 }
547 if !table_data[field].has_key(key) {
548 let mut info = field_info.clone();
549 let pid_field = info["pid_field"].clone().to_string();
550 let _ = info["fields"].push("id");
551 let _ = info["fields"].push(pid_field.clone());
552 let fields_k = info["fields"]
553 .members()
554 .map(|x| x.as_str().unwrap())
555 .collect::<Vec<&str>>();
556 let mut find = self
557 .db
558 .table(info["table"].as_str().unwrap())
559 .where_and("id", "=", key.into())
560 .field(&fields_k.join(","))
561 .find();
562 let mut pid = find[pid_field.clone()].to_string();
563 let mut name_list = vec![];
564 let id = find["id"].to_string();
565 find.remove("id");
566 find.remove(&pid_field);
567 let label = find
568 .entries()
569 .map(|(_, v)| v.to_string())
570 .collect::<Vec<String>>();
571 name_list.push(label.join(" | ").clone());
572 loop {
573 if pid.is_empty() {
574 break;
575 }
576 let mut t = self
577 .db
578 .table(info["table"].as_str().unwrap())
579 .where_and("id", "=", pid.clone().into())
580 .field(&fields_k.join(","))
581 .find();
582 pid = t[pid_field.clone()].to_string();
583 t.remove("id");
584 t.remove(&pid_field);
585 let label = t
586 .entries()
587 .map(|(_, v)| v.to_string())
588 .collect::<Vec<String>>();
589 name_list.push(label.join(" | ").clone());
590 }
591 name_list.reverse();
592 table_data[field][key] = object! {
593 value: id.clone(),
594 label:name_list.join("/").clone(),
595 };
596 }
597 item[field] = table_data[field][key].clone();
598 }
599 }
600 }
601 fn db_table_tree(&mut self, pid_field: &str) {
602 let mut all_fields = object! {};
603 let _ = self
604 .fields
605 .iter()
606 .map(|x| {
607 all_fields
608 .insert(x["field"].as_str().unwrap(), x.clone())
609 .unwrap()
610 })
611 .collect::<Vec<_>>();
612
613 let mut table_data = object! {};
614 for item in self.data.members_mut() {
615 let find = self
616 .db
617 .table(&self.main_table)
618 .where_and(pid_field, "=", item["id"].clone())
619 .count();
620 if find.is_empty() {
621 item["isLeaf"] = true.into();
622 }
623
624 for field in self.table_fields.iter() {
625 let key = item[field].as_str().unwrap_or("");
626 if key.is_empty() {
627 continue;
628 }
629 let field_info = all_fields[field].clone();
630
631 if !table_data.has_key(field) {
632 table_data[field] = object! {};
633 }
634 if !table_data[field].has_key(key) {
635 let mut info = field_info.clone();
636 let _ = info["fields"].push("id");
637 let fields_k = info["fields"]
638 .members()
639 .map(|x| x.as_str().unwrap())
640 .collect::<Vec<&str>>();
641 let mut find = self
642 .db
643 .table(info["table"].as_str().unwrap())
644 .where_and("id", "=", key.into())
645 .field(&fields_k.join(","))
646 .find();
647 let id = find["id"].to_string();
648 find.remove("id");
649 let label = find
650 .entries()
651 .map(|(_, v)| v.to_string())
652 .collect::<Vec<String>>();
653 table_data[field][key] = object! {
654 value: id.clone(),
655 label:label.join(" | ").clone(),
656 };
657 }
658 item[field] = table_data[field][key].clone();
659 }
660 for field in self.tree_fields.iter() {
661 let key = item[field].as_str().unwrap_or("");
662 if key.is_empty() {
663 continue;
664 }
665 let field_info = all_fields[field].clone();
666 if !table_data.has_key(field) {
667 table_data[field] = object! {};
668 }
669 if !table_data[field].has_key(key) {
670 let mut info = field_info.clone();
671 let pid_field = info["pid_field"].clone().to_string();
672 let _ = info["fields"].push("id");
673 let _ = info["fields"].push(pid_field.clone());
674 let fields_k = info["fields"]
675 .members()
676 .map(|x| x.as_str().unwrap())
677 .collect::<Vec<&str>>();
678 let mut find = self
679 .db
680 .table(info["table"].as_str().unwrap())
681 .where_and("id", "=", key.into())
682 .field(&fields_k.join(","))
683 .find();
684 let mut pid = find[pid_field.clone()].to_string();
685 let mut name_list = vec![];
686 let id = find["id"].to_string();
687 find.remove("id");
688 find.remove(&pid_field);
689 let label = find
690 .entries()
691 .map(|(_, v)| v.to_string())
692 .collect::<Vec<String>>();
693 name_list.push(label.join(" | ").clone());
694 loop {
695 if pid.is_empty() {
696 break;
697 }
698 let mut t = self
699 .db
700 .table(info["table"].as_str().unwrap())
701 .where_and("id", "=", pid.clone().into())
702 .field(&fields_k.join(","))
703 .find();
704 pid = t[pid_field.clone()].to_string();
705 t.remove("id");
706 t.remove(&pid_field);
707 let label = t
708 .entries()
709 .map(|(_, v)| v.to_string())
710 .collect::<Vec<String>>();
711 name_list.push(label.join(" | ").clone());
712 }
713 name_list.reverse();
714 table_data[field][key] = object! {
715 value: id.clone(),
716 label:name_list.join("/").clone(),
717 };
718 }
719 item[field] = table_data[field][key].clone();
720 }
721 }
722 }
723 fn columns(&mut self) -> JsonValue {
724 let mut all_fields = object! {};
725 let _ = self
726 .fields
727 .iter()
728 .map(|x| {
729 all_fields
730 .insert(x["field"].as_str().unwrap(), x.clone())
731 .unwrap()
732 })
733 .collect::<Vec<_>>();
734
735 let sort_field = self
736 .order
737 .members()
738 .map(|x| (x[0].to_string(), x[1].as_bool().unwrap()))
739 .collect::<HashMap<String, bool>>();
740 for (_, item) in all_fields.entries_mut() {
741 item["name"] = item["field"].clone();
742 item["align"] = "center".into();
743 item["label"] = item["title"].clone();
744 item["version"] = self.version.into();
745
746 if item["field"].as_str().unwrap_or("") != "id" {
747 if self.version == 0 {
748 item["sortable"] = true.into();
749 } else {
750 item["sortable"] = object! {
751 "sorter"=>false,
752 "sortDirections"=>array!["ascend","descend"],
753 "defaultSortOrder"=>"",
754 "sortOrder"=>""
755 };
756 if sort_field.contains_key(item["field"].to_string().as_str()) {
757 item["sortable"]["sortOrder"] =
758 if *sort_field.get(&item["field"].to_string()).unwrap() {
759 "descend"
760 } else {
761 "ascend"
762 }
763 .into();
764 }
765 }
766 }
767 item["dataIndex"] = item["field"].clone();
768 item["slotName"] = item["field"].clone();
769 item["titleSlotName"] = item["field"].clone();
770 match item["mode"].as_str().unwrap() {
771 "string" | "text" => {
772 item["ellipsis"] = true.into();
773 item["tooltip"] = true.into();
774 }
775 "key" => {
776 item["width"] = 280.into();
777 item["ellipsis"] = true.into();
778 }
779 _ => {}
780 }
781 }
782 all_fields
783 }
784 pub fn get_table(&mut self) -> JsonValue {
785 self.db.table(&self.main_table);
786 self.db_fields();
787 self.db_search();
788 self.db_where();
789 self.db_join();
790 self.db_total();
791 self.db_order();
792 self.db.page(self.page as i32, self.limit as i32);
793
794 self.data = self.db.select();
795 self.db_table();
796
797 object! {
798 "pages"=>self.pages,
799 "total"=>self.total,
800 "data"=>self.data.clone(),
801 "columns"=>self.columns(),
802 "filter_fields"=>self.filter_fields.clone(),
803 "search_name"=>self.search_name.clone(),
804 "total_fields"=>self.total_fields.clone(),
805 "btn_all"=>array![],
806 "btn_api"=>array![],
807 "btn_ids"=>array![]
808 }
809 }
810 pub fn get_table_menu(&mut self, label_field: &str) -> JsonValue {
811 self.db.table(&self.main_table);
812 self.db_fields();
813 self.db_search();
814 self.db_where();
815 self.db_join();
816 self.db_total();
817 self.db_order();
818 self.db.page(self.page as i32, self.limit as i32);
819
820 self.data = self.db.select();
821 self.db_table();
822
823 object! {
824 "pages"=>self.pages,
825 "total"=>self.total,
826 "data"=>self.data.clone(),
827 "columns"=>self.columns(),
828 "filter_fields"=>self.filter_fields.clone(),
829 "search_name"=>self.search_name.clone(),
830 "total_fields"=>self.total_fields.clone(),
831 "btn_all"=>array![],
832 "btn_api"=>array![],
833 "btn_ids"=>array![],
834 "label_field"=>label_field
835 }
836 }
837
838 pub fn get_tree(&mut self, pid_field: &str) -> JsonValue {
839 self.db.table(&self.main_table);
840 self.set_version(1);
841 self.db
842 .where_and(pid_field, "=", self.pid_id.clone().into());
843 self.db_fields();
844 self.db_search();
845 self.db_where();
846 self.db_join();
847 self.db_total();
848 self.db_order();
849 if self.pid_id.is_empty() {
850 self.db.page(self.page as i32, self.limit as i32);
851 } else {
852 self.db.page(1, 1000);
853 }
854
855 self.data = self.db.select();
856 self.db_table_tree(pid_field);
857
858 object! {
859 "pages"=>self.pages,
860 "total"=>self.total,
861 "data"=>self.data.clone(),
862 "columns"=>self.columns(),
863 "filter_fields"=>self.filter_fields.clone(),
864 "search_name"=>self.search_name.clone(),
865 "total_fields"=>self.total_fields.clone(),
866 "btn_all"=>array![],
867 "btn_api"=>array![],
868 "btn_ids"=>array![]
869 }
870 }
871 pub fn get_table_edit(&mut self) -> JsonValue {
872 self.db.table(&self.main_table);
873 self.db_fields();
874 self.db_search();
875 self.db_where();
876 self.db_total();
877 self.db_order();
878 self.db.page(self.page as i32, self.limit as i32);
879 self.db_join();
880 self.data = self.db.select();
881
882 object! {
883 "pages"=>self.pages,
884 "total"=>self.total,
885 "data"=>self.data.clone(),
886 "columns"=>self.columns(),
887 "edit_fields"=>self.edit_fields.clone(),
888 }
889 }
890 pub fn get_table_select(&mut self) -> JsonValue {
891 self.db.table(&self.main_table);
892 if !self.primary_key.eq("id") {
893 self.fields_keys.remove(0);
894 }
895 if !self.value.is_empty() {
896 let _ = self
897 .where_or
898 .push(array![self.primary_key.clone(), "in", self.value.clone()]);
899 let _ = self
900 .where_or
901 .push(array![self.primary_key.clone(), "isnot", "NULL"]);
902 let _ = self.order.push(array![
903 format!(
904 "{} in ('{}')",
905 self.primary_key.clone(),
906 self.value.join("','")
907 ),
908 true
909 ]);
910 }
911 self.db_fields();
912 self.db_search();
913 self.db_where();
914 self.db_join();
915 self.db_total();
916 self.db_order();
917 self.db.page(self.page as i32, self.limit as i32);
918
919 let mut list = self.db.select();
920
921 for item in list.members_mut() {
922 let value = item[self.primary_key.clone()].clone();
923 if self.primary_key.eq("id") {
924 item.remove(&self.primary_key.clone());
925 }
926 let label = item
927 .entries()
928 .map(|(_, v)| v.to_string())
929 .collect::<Vec<String>>();
930 self.data
931 .push(object! {
932 value: value,
933 label: label.join(" | ").clone(),
934 })
935 .unwrap();
936 }
937
938 object! {
939 "pages"=>self.pages,
940 "total"=>self.total,
941 "data"=>self.data.clone(),
942 }
943 }
944 pub fn get_table_select_tree(&mut self, pid_field: &str, label_field: &str) -> JsonValue {
945 self.fields_keys.push(pid_field.to_string());
946 self.db.table(&self.main_table);
947 self.db
948 .where_and(pid_field, "=", self.pid_id.clone().into());
949
950 self.db_fields();
951 self.db_search();
952 self.db_where();
953 self.db_join();
954 self.db_order();
955 self.db.page(1, 1000);
956
957 self.data = self.db.select();
958
959 for item in self.data.members_mut() {
960 let children = self
961 .db
962 .table(&self.main_table)
963 .where_and(pid_field, "=", item["id"].clone())
964 .count();
965 if children.is_empty() {
966 item["lazy"] = false.into();
967 item["isLeaf"] = true.into();
968 } else {
969 item["lazy"] = true.into();
970 }
971 }
972
973 if self.pid_id.is_empty() {
974 for id in self.value.clone() {
975 let mut list = vec![];
976 let mut find = self
977 .db
978 .table(&self.main_table)
979 .where_and("id", "=", id.into())
980 .field(self.fields_keys.join(",").as_str())
981 .find();
982 loop {
983 let pid = find[pid_field].to_string();
984 if pid.is_empty() {
985 break;
986 }
987 find = self
988 .db
989 .table(&self.main_table)
990 .where_and("id", "=", pid.into())
991 .field(self.fields_keys.join(",").as_str())
992 .find();
993 list.insert(0, find.clone());
994 }
995 let data = &mut self.data.clone();
996 self.tree_data(data, list.into(), 0, pid_field);
997 self.data = data.clone();
998 }
999 }
1000 object! {
1001 "data"=> self.data.clone(),
1002 "label_field"=>label_field.to_string(),
1003 "pid_field"=>pid_field.to_string(),
1004 }
1005 }
1006 fn tree_data(&mut self, data: &mut JsonValue, list: JsonValue, index: usize, pid_field: &str) {
1007 let id = list[index]["id"].clone();
1008 for item in data.members_mut() {
1009 let children = self
1010 .db
1011 .table(&self.main_table)
1012 .where_and(pid_field, "=", item["id"].clone())
1013 .field(self.fields_keys.join(",").as_str())
1014 .select();
1015 if children.is_empty() {
1016 item["isLeaf"] = true.into();
1017 }
1018 if id == item["id"] && !children.is_empty() {
1019 item["children"] = children;
1020 self.tree_data(&mut item["children"], list.clone(), index + 1, pid_field);
1021 }
1022 }
1023 }
1024}