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 let Some(field_info) = all_fields.get(key) {
261 self.search_fields.push(key.to_string());
262 search_name.push(field_info["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_or(1);
286 }
287 if request.has_key("limit") {
288 self.limit = request["limit"].as_usize().unwrap_or(10);
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_or_default(), 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_or_default(), 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_or("="),
367 value[2].clone(),
368 );
369 } else {
370 self.db.where_or(
371 value[0].as_str().unwrap_or_default(),
372 value[1].as_str().unwrap_or("="),
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_or("="),
388 value[2].clone(),
389 );
390 } else {
391 self.db.where_and(
392 value[0].as_str().unwrap_or_default(),
393 value[1].as_str().unwrap_or("="),
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_or_default(), 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_or(false),
418 );
419 } else {
420 self.db.order(
421 format!("{}.{}", self.main_table, item[0]).as_str(),
422 item[1].as_bool().unwrap_or(false),
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_or_default(), 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_or(0.0);
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 let _ = all_fields.insert(x["field"].as_str().unwrap_or_default(), x.clone());
495 })
496 .collect::<Vec<_>>();
497
498 let mut table_data = object! {};
499 for item in self.data.members_mut() {
500 for field in self.table_fields.iter() {
501 let key = item[field].as_str().unwrap_or("");
502 if key.is_empty() {
503 continue;
504 }
505 let field_info = all_fields[field].clone();
506
507 if !table_data.has_key(field) {
508 table_data[field] = object! {};
509 }
510 if !table_data[field].has_key(key) {
511 let mut info = field_info.clone();
512 let _ = info["fields"].push("id");
513 let fields_k = info["fields"]
514 .members()
515 .map(|x| x.as_str().unwrap_or_default())
516 .collect::<Vec<&str>>();
517 let mut find = self
518 .db
519 .table(info["table"].as_str().unwrap_or_default())
520 .where_and("id", "=", key.into())
521 .field(&fields_k.join(","))
522 .find();
523 let id = find["id"].to_string();
524 find.remove("id");
525 let label = find
526 .entries()
527 .map(|(_, v)| v.to_string())
528 .collect::<Vec<String>>();
529 table_data[field][key] = object! {
530 value: id.clone(),
531 label:label.join(" | ").clone(),
532 };
533 }
534 item[field] = table_data[field][key].clone();
535 }
536 for field in self.tree_fields.iter() {
537 let key = item[field].as_str().unwrap_or("");
538 if key.is_empty() {
539 continue;
540 }
541 let field_info = all_fields[field].clone();
542 if !table_data.has_key(field) {
543 table_data[field] = object! {};
544 }
545 if !table_data[field].has_key(key) {
546 let mut info = field_info.clone();
547 let pid_field = info["pid_field"].clone().to_string();
548 let _ = info["fields"].push("id");
549 let _ = info["fields"].push(pid_field.clone());
550 let fields_k = info["fields"]
551 .members()
552 .map(|x| x.as_str().unwrap_or_default())
553 .collect::<Vec<&str>>();
554 let mut find = self
555 .db
556 .table(info["table"].as_str().unwrap_or_default())
557 .where_and("id", "=", key.into())
558 .field(&fields_k.join(","))
559 .find();
560 let mut pid = find[pid_field.clone()].to_string();
561 let mut name_list = vec![];
562 let id = find["id"].to_string();
563 find.remove("id");
564 find.remove(&pid_field);
565 let label = find
566 .entries()
567 .map(|(_, v)| v.to_string())
568 .collect::<Vec<String>>();
569 name_list.push(label.join(" | ").clone());
570 loop {
571 if pid.is_empty() {
572 break;
573 }
574 let mut t = self
575 .db
576 .table(info["table"].as_str().unwrap_or_default())
577 .where_and("id", "=", pid.clone().into())
578 .field(&fields_k.join(","))
579 .find();
580 pid = t[pid_field.clone()].to_string();
581 t.remove("id");
582 t.remove(&pid_field);
583 let label = t
584 .entries()
585 .map(|(_, v)| v.to_string())
586 .collect::<Vec<String>>();
587 name_list.push(label.join(" | ").clone());
588 }
589 name_list.reverse();
590 table_data[field][key] = object! {
591 value: id.clone(),
592 label:name_list.join("/").clone(),
593 };
594 }
595 item[field] = table_data[field][key].clone();
596 }
597 }
598 }
599 fn db_table_tree(&mut self, pid_field: &str) {
600 let mut all_fields = object! {};
601 let _ = self
602 .fields
603 .iter()
604 .map(|x| {
605 let _ = all_fields.insert(x["field"].as_str().unwrap_or_default(), x.clone());
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_or_default())
636 .collect::<Vec<&str>>();
637 let mut find = self
638 .db
639 .table(info["table"].as_str().unwrap_or_default())
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_or_default())
673 .collect::<Vec<&str>>();
674 let mut find = self
675 .db
676 .table(info["table"].as_str().unwrap_or_default())
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_or_default())
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 let _ = all_fields.insert(x["field"].as_str().unwrap_or_default(), x.clone());
726 })
727 .collect::<Vec<_>>();
728
729 let sort_field = self
730 .order
731 .members()
732 .map(|x| (x[0].to_string(), x[1].as_bool().unwrap_or(false)))
733 .collect::<HashMap<String, bool>>();
734 for (_, item) in all_fields.entries_mut() {
735 item["name"] = item["field"].clone();
736 item["align"] = "center".into();
737 item["label"] = item["title"].clone();
738 item["version"] = self.version.into();
739
740 if item["field"].as_str().unwrap_or("") != "id" {
741 if self.version == 0 {
742 item["sortable"] = true.into();
743 } else {
744 item["sortable"] = object! {
745 "sorter"=>false,
746 "sortDirections"=>array!["ascend","descend"],
747 "defaultSortOrder"=>"",
748 "sortOrder"=>""
749 };
750 if sort_field.contains_key(item["field"].to_string().as_str()) {
751 item["sortable"]["sortOrder"] =
752 if *sort_field.get(&item["field"].to_string()).unwrap_or(&false) {
753 "descend"
754 } else {
755 "ascend"
756 }
757 .into();
758 }
759 }
760 }
761 item["dataIndex"] = item["field"].clone();
762 item["slotName"] = item["field"].clone();
763 item["titleSlotName"] = item["field"].clone();
764 match item["mode"].as_str().unwrap_or_default() {
765 "string" | "text" => {
766 item["ellipsis"] = true.into();
767 item["tooltip"] = true.into();
768 }
769 "key" => {
770 item["width"] = 280.into();
771 item["ellipsis"] = true.into();
772 }
773 _ => {}
774 }
775 }
776 all_fields
777 }
778 pub fn get_table(&mut self) -> JsonValue {
779 self.db.table(&self.main_table);
780 self.db_fields();
781 self.db_search();
782 self.db_where();
783 self.db_join();
784 self.db_total();
785 self.db_order();
786 self.db.page(self.page as i32, self.limit as i32);
787
788 self.data = self.db.select();
789 self.db_table();
790
791 object! {
792 "pages"=>self.pages,
793 "total"=>self.total,
794 "data"=>self.data.clone(),
795 "columns"=>self.columns(),
796 "filter_fields"=>self.filter_fields.clone(),
797 "search_name"=>self.search_name.clone(),
798 "total_fields"=>self.total_fields.clone(),
799 "btn_all"=>array![],
800 "btn_api"=>array![],
801 "btn_ids"=>array![]
802 }
803 }
804 pub fn get_table_menu(&mut self, label_field: &str) -> JsonValue {
805 self.db.table(&self.main_table);
806 self.db_fields();
807 self.db_search();
808 self.db_where();
809 self.db_join();
810 self.db_total();
811 self.db_order();
812 self.db.page(self.page as i32, self.limit as i32);
813
814 self.data = self.db.select();
815 self.db_table();
816
817 object! {
818 "pages"=>self.pages,
819 "total"=>self.total,
820 "data"=>self.data.clone(),
821 "columns"=>self.columns(),
822 "filter_fields"=>self.filter_fields.clone(),
823 "search_name"=>self.search_name.clone(),
824 "total_fields"=>self.total_fields.clone(),
825 "btn_all"=>array![],
826 "btn_api"=>array![],
827 "btn_ids"=>array![],
828 "label_field"=>label_field
829 }
830 }
831
832 pub fn get_tree(&mut self, pid_field: &str) -> JsonValue {
833 self.db.table(&self.main_table);
834 self.set_version(1);
835 self.db
836 .where_and(pid_field, "=", self.pid_id.clone().into());
837 self.db_fields();
838 self.db_search();
839 self.db_where();
840 self.db_join();
841 self.db_total();
842 self.db_order();
843 if self.pid_id.is_empty() {
844 self.db.page(self.page as i32, self.limit as i32);
845 } else {
846 self.db.page(1, 1000);
847 }
848
849 self.data = self.db.select();
850 self.db_table_tree(pid_field);
851
852 object! {
853 "pages"=>self.pages,
854 "total"=>self.total,
855 "data"=>self.data.clone(),
856 "columns"=>self.columns(),
857 "filter_fields"=>self.filter_fields.clone(),
858 "search_name"=>self.search_name.clone(),
859 "total_fields"=>self.total_fields.clone(),
860 "btn_all"=>array![],
861 "btn_api"=>array![],
862 "btn_ids"=>array![]
863 }
864 }
865 pub fn get_table_edit(&mut self) -> JsonValue {
866 self.db.table(&self.main_table);
867 self.db_fields();
868 self.db_search();
869 self.db_where();
870 self.db_total();
871 self.db_order();
872 self.db.page(self.page as i32, self.limit as i32);
873 self.db_join();
874 self.data = self.db.select();
875
876 object! {
877 "pages"=>self.pages,
878 "total"=>self.total,
879 "data"=>self.data.clone(),
880 "columns"=>self.columns(),
881 "edit_fields"=>self.edit_fields.clone(),
882 }
883 }
884 pub fn get_table_select(&mut self) -> JsonValue {
885 self.db.table(&self.main_table);
886 if !self.primary_key.eq("id") {
887 self.fields_keys.remove(0);
888 }
889 if !self.value.is_empty() && self.search.is_empty() {
890 let _ = self
891 .where_or
892 .push(array![self.primary_key.clone(), "in", self.value.clone()]);
893 let _ = self
894 .where_or
895 .push(array![self.primary_key.clone(), "isnot", "NULL"]);
896 let _ = self.order.push(array![
897 format!(
898 "{} in ('{}')",
899 self.primary_key.clone(),
900 self.value.join("','")
901 ),
902 true
903 ]);
904 }
905 self.db_fields();
906 self.db_search();
907 self.db_where();
908 self.db_join();
909 self.db_total();
910 self.db_order();
911 self.db.page(self.page as i32, self.limit as i32);
912
913 let mut list = self.db.select();
914
915 for item in list.members_mut() {
916 let value = item[self.primary_key.clone()].clone();
917 if self.primary_key.eq("id") {
918 item.remove(&self.primary_key.clone());
919 }
920 let label = item
921 .entries()
922 .map(|(_, v)| v.to_string())
923 .collect::<Vec<String>>();
924 let _ = self.data.push(object! {
925 value: value,
926 label: label.join(" | ").clone(),
927 });
928 }
929
930 object! {
931 "pages"=>self.pages,
932 "total"=>self.total,
933 "data"=>self.data.clone(),
934 }
935 }
936 pub fn get_table_select_tree(&mut self, pid_field: &str, label_field: &str) -> JsonValue {
937 self.fields_keys.push(pid_field.to_string());
938 self.db.table(&self.main_table);
939 self.db
940 .where_and(pid_field, "=", self.pid_id.clone().into());
941
942 self.db_fields();
943 self.db_search();
944 self.db_where();
945 self.db_join();
946 self.db_order();
947 self.db.page(1, 1000);
948
949 self.data = self.db.select();
950
951 for item in self.data.members_mut() {
952 let children = self
953 .db
954 .table(&self.main_table)
955 .where_and(pid_field, "=", item["id"].clone())
956 .count();
957 if children.is_empty() {
958 item["lazy"] = false.into();
959 item["isLeaf"] = true.into();
960 } else {
961 item["lazy"] = true.into();
962 }
963 }
964
965 if self.pid_id.is_empty() {
966 for id in self.value.clone() {
967 let mut list = vec![];
968 let mut find = self
969 .db
970 .table(&self.main_table)
971 .where_and("id", "=", id.into())
972 .field(self.fields_keys.join(",").as_str())
973 .find();
974 loop {
975 let pid = find[pid_field].to_string();
976 if pid.is_empty() {
977 break;
978 }
979 find = self
980 .db
981 .table(&self.main_table)
982 .where_and("id", "=", pid.into())
983 .field(self.fields_keys.join(",").as_str())
984 .find();
985 list.insert(0, find.clone());
986 }
987 let data = &mut self.data.clone();
988 self.tree_data(data, list.into(), 0, pid_field);
989 self.data = data.clone();
990 }
991 }
992 object! {
993 "data"=> self.data.clone(),
994 "label_field"=>label_field.to_string(),
995 "pid_field"=>pid_field.to_string(),
996 }
997 }
998 fn tree_data(&mut self, data: &mut JsonValue, list: JsonValue, index: usize, pid_field: &str) {
999 let id = list[index]["id"].clone();
1000 for item in data.members_mut() {
1001 let children = self
1002 .db
1003 .table(&self.main_table)
1004 .where_and(pid_field, "=", item["id"].clone())
1005 .field(self.fields_keys.join(",").as_str())
1006 .select();
1007 if children.is_empty() {
1008 item["isLeaf"] = true.into();
1009 }
1010 if id == item["id"] && !children.is_empty() {
1011 item["children"] = children;
1012 self.tree_data(&mut item["children"], list.clone(), index + 1, pid_field);
1013 }
1014 }
1015 }
1016}