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"].members().map(|x| x.to_string()).collect();
314 }
315 self
316 }
317
318 fn db_search(&mut self) {
319 if !self.search.is_empty() {
320 let mut all_fields = object! {};
321 let _ = self
322 .fields
323 .iter()
324 .map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()))
325 .collect::<Vec<_>>();
326
327 let mut t = vec![];
328 for value in self.search_fields.clone() {
329 let field = all_fields[value.as_str()].clone();
330 if field.has_key("field_table") {
331 t.push(format!(
332 "{}.{}",
333 field["field_table"].clone(),
334 field["field_table_field"].clone()
335 ));
336 } else {
337 t.push(value);
338 }
339 }
340 self.db
341 .where_and(&t.join("|"), "like", format!("%{}%", self.search).into());
342 }
343 }
344 fn db_where(&mut self) {
345 let mut all_fields = object! {};
346 let _ = self
347 .fields
348 .iter()
349 .map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()))
350 .collect::<Vec<_>>();
351
352 for value in self.where_or.members() {
353 let field = all_fields[value[0].to_string()].clone();
354 if field.has_key("field_table") {
355 self.db.where_or(
356 format!(
357 "{}.{}",
358 field["field_table"].clone(),
359 field["field_table_field"].clone()
360 )
361 .as_str(),
362 value[1].as_str().unwrap(),
363 value[2].clone(),
364 );
365 } else {
366 self.db.where_or(
367 value[0].as_str().unwrap(),
368 value[1].as_str().unwrap(),
369 value[2].clone(),
370 );
371 }
372 }
373 for value in self.where_and.members() {
374 let field = all_fields[value[0].to_string()].clone();
375 if field.has_key("field_table") {
376 self.db.where_and(
377 format!(
378 "{}.{}",
379 field["field_table"].clone(),
380 field["field_table_field"].clone()
381 )
382 .as_str(),
383 value[1].as_str().unwrap(),
384 value[2].clone(),
385 );
386 } else {
387 self.db.where_and(
388 value[0].as_str().unwrap(),
389 value[1].as_str().unwrap(),
390 value[2].clone(),
391 );
392 }
393 }
394 }
395 fn db_order(&mut self) {
396 let mut all_fields = object! {};
397 let _ = self
398 .fields
399 .iter()
400 .map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()))
401 .collect::<Vec<_>>();
402
403 for item in self.order.members() {
404 let field = all_fields[item[0].to_string()].clone();
405 if field.has_key("field_table") {
406 self.db.order(
407 format!(
408 "{}.{}",
409 field["field_table"].clone(),
410 field["field_table_field"].clone()
411 )
412 .as_str(),
413 item[1].as_bool().unwrap(),
414 );
415 } else {
416 self.db.order(
417 format!("{}.{}", self.main_table, item[0]).as_str(),
418 item[1].as_bool().unwrap(),
419 );
420 }
421 }
422 }
423 fn db_fields(&mut self) {
424 let mut all_fields = object! {};
425 let _ = self
426 .fields
427 .iter()
428 .map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()))
429 .collect::<Vec<_>>();
430
431 if !self.hide_fields.is_empty() {
432 for field in self.hide_fields.clone() {
433 if all_fields.has_key(&field) {
434 all_fields.remove(&field);
435 continue;
436 }
437 }
438 }
439
440 if !self.show_fields.is_empty() {
441 self.show_fields.insert(0, "id".to_string());
442 let mut f = object! {};
443 for field in self.show_fields.clone() {
444 if all_fields.has_key(&field) {
445 let _ = f.insert(&field.clone(), all_fields[field].clone());
446 }
447 }
448 all_fields = f;
449 }
450
451 for (field, item) in all_fields.entries() {
452 let mode = item["mode"].to_string();
453 self.set_fields(field, mode.as_str());
454 }
455
456 self.fields = all_fields
457 .entries()
458 .map(|(_, x)| x.clone())
459 .collect::<Vec<JsonValue>>();
460
461 if !self.fields_keys.is_empty() {
462 self.db.field(self.fields_keys.join(",").as_str());
463 }
464 if !self.json_fields.is_empty() {
465 self.db.json(self.json_fields.join(",").as_str());
466 }
467 if !self.location_fields.is_empty() {
468 self.db.location(self.location_fields.join(",").as_str());
469 }
470 }
471 fn db_join(&mut self) {
472 if !self.join_fields.is_empty() {
473 self.db
474 .join_fields(self.join_fields.iter().map(|x| x.as_str()).collect());
475 }
476 for item in self.join_params.iter() {
477 self.db.join(&item[0], &item[1], &item[2], &item[3]);
478 }
479 }
480 fn db_total(&mut self) {
481 self.total = self.db.clone().count().as_f64().unwrap();
482 self.pages = (self.total / (self.limit as f64)).ceil() as i64;
483 }
484 fn db_table(&mut self) {
485 let mut all_fields = object! {};
486 let _ = self
487 .fields
488 .iter()
489 .map(|x| {
490 all_fields
491 .insert(x["field"].as_str().unwrap(), x.clone())
492 .unwrap()
493 })
494 .collect::<Vec<_>>();
495
496 let mut table_data = object! {};
497 for item in self.data.members_mut() {
498 for field in self.table_fields.iter() {
499 let key = item[field].as_str().unwrap_or("");
500 if key.is_empty() {
501 continue;
502 }
503 let field_info = all_fields[field].clone();
504
505 if !table_data.has_key(field) {
506 table_data[field] = object! {};
507 }
508 if !table_data[field].has_key(key) {
509 let mut info = field_info.clone();
510 let _ = info["fields"].push("id");
511 let fields_k = info["fields"]
512 .members()
513 .map(|x| x.as_str().unwrap())
514 .collect::<Vec<&str>>();
515 let mut find = self
516 .db
517 .table(info["table"].as_str().unwrap())
518 .where_and("id", "=", key.into())
519 .field(&fields_k.join(","))
520 .find();
521 let id = find["id"].to_string();
522 find.remove("id");
523 let label = find
524 .entries()
525 .map(|(_, v)| v.to_string())
526 .collect::<Vec<String>>();
527 table_data[field][key] = object! {
528 value: id.clone(),
529 label:label.join(" | ").clone(),
530 };
531 }
532 item[field] = table_data[field][key].clone();
533 }
534 for field in self.tree_fields.iter() {
535 let key = item[field].as_str().unwrap_or("");
536 if key.is_empty() {
537 continue;
538 }
539 let field_info = all_fields[field].clone();
540 if !table_data.has_key(field) {
541 table_data[field] = object! {};
542 }
543 if !table_data[field].has_key(key) {
544 let mut info = field_info.clone();
545 let pid_field = info["pid_field"].clone().to_string();
546 let _ = info["fields"].push("id");
547 let _ = info["fields"].push(pid_field.clone());
548 let fields_k = info["fields"]
549 .members()
550 .map(|x| x.as_str().unwrap())
551 .collect::<Vec<&str>>();
552 let mut find = self
553 .db
554 .table(info["table"].as_str().unwrap())
555 .where_and("id", "=", key.into())
556 .field(&fields_k.join(","))
557 .find();
558 let mut pid = find[pid_field.clone()].to_string();
559 let mut name_list = vec![];
560 let id = find["id"].to_string();
561 find.remove("id");
562 find.remove(&pid_field);
563 let label = find
564 .entries()
565 .map(|(_, v)| v.to_string())
566 .collect::<Vec<String>>();
567 name_list.push(label.join(" | ").clone());
568 loop {
569 if pid.is_empty() {
570 break;
571 }
572 let mut t = self
573 .db
574 .table(info["table"].as_str().unwrap())
575 .where_and("id", "=", pid.clone().into())
576 .field(&fields_k.join(","))
577 .find();
578 pid = t[pid_field.clone()].to_string();
579 t.remove("id");
580 t.remove(&pid_field);
581 let label = t
582 .entries()
583 .map(|(_, v)| v.to_string())
584 .collect::<Vec<String>>();
585 name_list.push(label.join(" | ").clone());
586 }
587 name_list.reverse();
588 table_data[field][key] = object! {
589 value: id.clone(),
590 label:name_list.join("/").clone(),
591 };
592 }
593 item[field] = table_data[field][key].clone();
594 }
595 }
596 }
597 fn db_table_tree(&mut self, pid_field: &str) {
598 let mut all_fields = object! {};
599 let _ = self
600 .fields
601 .iter()
602 .map(|x| {
603 all_fields
604 .insert(x["field"].as_str().unwrap(), x.clone())
605 .unwrap()
606 })
607 .collect::<Vec<_>>();
608
609 let mut table_data = object! {};
610 for item in self.data.members_mut() {
611 let find = self
612 .db
613 .table(&self.main_table)
614 .where_and(pid_field, "=", item["id"].clone())
615 .count();
616 if find.is_empty() {
617 item["isLeaf"] = true.into();
618 }
619
620 for field in self.table_fields.iter() {
621 let key = item[field].as_str().unwrap_or("");
622 if key.is_empty() {
623 continue;
624 }
625 let field_info = all_fields[field].clone();
626
627 if !table_data.has_key(field) {
628 table_data[field] = object! {};
629 }
630 if !table_data[field].has_key(key) {
631 let mut info = field_info.clone();
632 let _ = info["fields"].push("id");
633 let fields_k = info["fields"]
634 .members()
635 .map(|x| x.as_str().unwrap())
636 .collect::<Vec<&str>>();
637 let mut find = self
638 .db
639 .table(info["table"].as_str().unwrap())
640 .where_and("id", "=", key.into())
641 .field(&fields_k.join(","))
642 .find();
643 let id = find["id"].to_string();
644 find.remove("id");
645 let label = find
646 .entries()
647 .map(|(_, v)| v.to_string())
648 .collect::<Vec<String>>();
649 table_data[field][key] = object! {
650 value: id.clone(),
651 label:label.join(" | ").clone(),
652 };
653 }
654 item[field] = table_data[field][key].clone();
655 }
656 for field in self.tree_fields.iter() {
657 let key = item[field].as_str().unwrap_or("");
658 if key.is_empty() {
659 continue;
660 }
661 let field_info = all_fields[field].clone();
662 if !table_data.has_key(field) {
663 table_data[field] = object! {};
664 }
665 if !table_data[field].has_key(key) {
666 let mut info = field_info.clone();
667 let pid_field = info["pid_field"].clone().to_string();
668 let _ = info["fields"].push("id");
669 let _ = info["fields"].push(pid_field.clone());
670 let fields_k = info["fields"]
671 .members()
672 .map(|x| x.as_str().unwrap())
673 .collect::<Vec<&str>>();
674 let mut find = self
675 .db
676 .table(info["table"].as_str().unwrap())
677 .where_and("id", "=", key.into())
678 .field(&fields_k.join(","))
679 .find();
680 let mut pid = find[pid_field.clone()].to_string();
681 let mut name_list = vec![];
682 let id = find["id"].to_string();
683 find.remove("id");
684 find.remove(&pid_field);
685 let label = find
686 .entries()
687 .map(|(_, v)| v.to_string())
688 .collect::<Vec<String>>();
689 name_list.push(label.join(" | ").clone());
690 loop {
691 if pid.is_empty() {
692 break;
693 }
694 let mut t = self
695 .db
696 .table(info["table"].as_str().unwrap())
697 .where_and("id", "=", pid.clone().into())
698 .field(&fields_k.join(","))
699 .find();
700 pid = t[pid_field.clone()].to_string();
701 t.remove("id");
702 t.remove(&pid_field);
703 let label = t
704 .entries()
705 .map(|(_, v)| v.to_string())
706 .collect::<Vec<String>>();
707 name_list.push(label.join(" | ").clone());
708 }
709 name_list.reverse();
710 table_data[field][key] = object! {
711 value: id.clone(),
712 label:name_list.join("/").clone(),
713 };
714 }
715 item[field] = table_data[field][key].clone();
716 }
717 }
718 }
719 fn columns(&mut self) -> JsonValue {
720 let mut all_fields = object! {};
721 let _ = self
722 .fields
723 .iter()
724 .map(|x| {
725 all_fields
726 .insert(x["field"].as_str().unwrap(), x.clone())
727 .unwrap()
728 })
729 .collect::<Vec<_>>();
730
731 let sort_field = self
732 .order
733 .members()
734 .map(|x| (x[0].to_string(), x[1].as_bool().unwrap()))
735 .collect::<HashMap<String, bool>>();
736 for (_, item) in all_fields.entries_mut() {
737 item["name"] = item["field"].clone();
738 item["align"] = "center".into();
739 item["label"] = item["title"].clone();
740 item["version"] = self.version.into();
741
742 if item["field"].as_str().unwrap_or("") != "id" {
743 if self.version == 0 {
744 item["sortable"] = true.into();
745 } else {
746 item["sortable"] = object! {
747 "sorter"=>false,
748 "sortDirections"=>array!["ascend","descend"],
749 "defaultSortOrder"=>"",
750 "sortOrder"=>""
751 };
752 if sort_field.contains_key(item["field"].to_string().as_str()) {
753 item["sortable"]["sortOrder"] =
754 if *sort_field.get(&item["field"].to_string()).unwrap() {
755 "descend"
756 } else {
757 "ascend"
758 }
759 .into();
760 }
761 }
762 }
763 item["dataIndex"] = item["field"].clone();
764 item["slotName"] = item["field"].clone();
765 item["titleSlotName"] = item["field"].clone();
766 match item["mode"].as_str().unwrap() {
767 "string" | "text" => {
768 item["ellipsis"] = true.into();
769 item["tooltip"] = true.into();
770 }
771 "key" => {
772 item["width"] = 280.into();
773 item["ellipsis"] = true.into();
774 }
775 _ => {}
776 }
777 }
778 all_fields
779 }
780 pub fn get_table(&mut self) -> JsonValue {
781 self.db.table(&self.main_table);
782 self.db_fields();
783 self.db_search();
784 self.db_where();
785 self.db_join();
786 self.db_total();
787 self.db_order();
788 self.db.page(self.page as i32, self.limit as i32);
789
790 self.data = self.db.select();
791 self.db_table();
792
793 object! {
794 "pages"=>self.pages,
795 "total"=>self.total,
796 "data"=>self.data.clone(),
797 "columns"=>self.columns(),
798 "filter_fields"=>self.filter_fields.clone(),
799 "search_name"=>self.search_name.clone(),
800 "total_fields"=>self.total_fields.clone(),
801 "btn_all"=>array![],
802 "btn_api"=>array![],
803 "btn_ids"=>array![]
804 }
805 }
806 pub fn get_table_menu(&mut self, label_field: &str) -> JsonValue {
807 self.db.table(&self.main_table);
808 self.db_fields();
809 self.db_search();
810 self.db_where();
811 self.db_join();
812 self.db_total();
813 self.db_order();
814 self.db.page(self.page as i32, self.limit as i32);
815
816 self.data = self.db.select();
817 self.db_table();
818
819 object! {
820 "pages"=>self.pages,
821 "total"=>self.total,
822 "data"=>self.data.clone(),
823 "columns"=>self.columns(),
824 "filter_fields"=>self.filter_fields.clone(),
825 "search_name"=>self.search_name.clone(),
826 "total_fields"=>self.total_fields.clone(),
827 "btn_all"=>array![],
828 "btn_api"=>array![],
829 "btn_ids"=>array![],
830 "label_field"=>label_field
831 }
832 }
833
834 pub fn get_tree(&mut self, pid_field: &str) -> JsonValue {
835 self.db.table(&self.main_table);
836 self.set_version(1);
837 self.db
838 .where_and(pid_field, "=", self.pid_id.clone().into());
839 self.db_fields();
840 self.db_search();
841 self.db_where();
842 self.db_join();
843 self.db_total();
844 self.db_order();
845 if self.pid_id.is_empty() {
846 self.db.page(self.page as i32, self.limit as i32);
847 } else {
848 self.db.page(1, 1000);
849 }
850
851 self.data = self.db.select();
852 self.db_table_tree(pid_field);
853
854 object! {
855 "pages"=>self.pages,
856 "total"=>self.total,
857 "data"=>self.data.clone(),
858 "columns"=>self.columns(),
859 "filter_fields"=>self.filter_fields.clone(),
860 "search_name"=>self.search_name.clone(),
861 "total_fields"=>self.total_fields.clone(),
862 "btn_all"=>array![],
863 "btn_api"=>array![],
864 "btn_ids"=>array![]
865 }
866 }
867 pub fn get_table_edit(&mut self) -> JsonValue {
868 self.db.table(&self.main_table);
869 self.db_fields();
870 self.db_search();
871 self.db_where();
872 self.db_total();
873 self.db_order();
874 self.db.page(self.page as i32, self.limit as i32);
875 self.db_join();
876 self.data = self.db.select();
877
878 object! {
879 "pages"=>self.pages,
880 "total"=>self.total,
881 "data"=>self.data.clone(),
882 "columns"=>self.columns(),
883 "edit_fields"=>self.edit_fields.clone(),
884 }
885 }
886 pub fn get_table_select(&mut self) -> JsonValue {
887 self.db.table(&self.main_table);
888 if !self.primary_key.eq("id") {
889 self.fields_keys.remove(0);
890 }
891 if !self.value.is_empty() {
892 let _ = self
893 .where_or
894 .push(array![self.primary_key.clone(), "in", self.value.clone()]);
895 let _ = self
896 .where_or
897 .push(array![self.primary_key.clone(), "isnot", "NULL"]);
898 let _ = self.order.push(array![
899 format!(
900 "{} in ('{}')",
901 self.primary_key.clone(),
902 self.value.join("','")
903 ),
904 true
905 ]);
906 }
907 self.db_fields();
908 self.db_search();
909 self.db_where();
910 self.db_join();
911 self.db_total();
912 self.db_order();
913 self.db.page(self.page as i32, self.limit as i32);
914
915 let mut list = self.db.select();
916
917 for item in list.members_mut() {
918 let value = item[self.primary_key.clone()].clone();
919 if self.primary_key.eq("id") {
920 item.remove(&self.primary_key.clone());
921 }
922 let label = item
923 .entries()
924 .map(|(_, v)| v.to_string())
925 .collect::<Vec<String>>();
926 self.data
927 .push(object! {
928 value: value,
929 label: label.join(" | ").clone(),
930 })
931 .unwrap();
932 }
933 object! {
934 "pages"=>self.pages,
935 "total"=>self.total,
936 "data"=>self.data.clone(),
937 }
938 }
939 pub fn get_table_select_tree(&mut self, pid_field: &str, label_field: &str) -> JsonValue {
940 self.fields_keys.push(pid_field.to_string());
941 self.db.table(&self.main_table);
942 self.db
943 .where_and(pid_field, "=", self.pid_id.clone().into());
944
945 self.db_fields();
946 self.db_search();
947 self.db_where();
948 self.db_join();
949 self.db_order();
950 self.db.page(1, 1000);
951
952 self.data = self.db.select();
953
954 for item in self.data.members_mut() {
955 let children = self
956 .db
957 .table(&self.main_table)
958 .where_and(pid_field, "=", item["id"].clone())
959 .count();
960 if children.is_empty() {
961 item["lazy"] = false.into();
962 item["isLeaf"] = true.into();
963 } else {
964 item["lazy"] = true.into();
965 }
966 }
967
968 if self.pid_id.is_empty() {
969 for id in self.value.clone() {
970 let mut list = vec![];
971 let mut find = self
972 .db
973 .table(&self.main_table)
974 .where_and("id", "=", id.into())
975 .field(self.fields_keys.join(",").as_str())
976 .find();
977 loop {
978 let pid = find[pid_field].to_string();
979 if pid.is_empty() {
980 break;
981 }
982 find = self
983 .db
984 .table(&self.main_table)
985 .where_and("id", "=", pid.into())
986 .field(self.fields_keys.join(",").as_str())
987 .find();
988 list.insert(0, find.clone());
989 }
990 let data = &mut self.data.clone();
991 self.tree_data(data, list.into(), 0, pid_field);
992 self.data = data.clone();
993 }
994 }
995 object! {
996 "data"=> self.data.clone(),
997 "label_field"=>label_field.to_string(),
998 "pid_field"=>pid_field.to_string(),
999 }
1000 }
1001 fn tree_data(&mut self, data: &mut JsonValue, list: JsonValue, index: usize, pid_field: &str) {
1002 let id = list[index]["id"].clone();
1003 for item in data.members_mut() {
1004 let children = self
1005 .db
1006 .table(&self.main_table)
1007 .where_and(pid_field, "=", item["id"].clone())
1008 .field(self.fields_keys.join(",").as_str())
1009 .select();
1010 if children.is_empty() {
1011 item["isLeaf"] = true.into();
1012 }
1013 if id == item["id"] && !children.is_empty() {
1014 item["children"] = children;
1015 self.tree_data(&mut item["children"], list.clone(), index + 1, pid_field);
1016 }
1017 }
1018 }
1019}