use br_db::Db;
use br_fields::Field;
use json::{array, object, JsonValue};
use std::collections::HashMap;
#[allow(clippy::too_many_arguments)]
#[cfg(any(
feature = "sqlite",
feature = "mssql",
feature = "mysql",
feature = "pgsql"
))]
pub struct Tables {
main_table: String,
db: Db,
total: f64,
fields: Vec<JsonValue>,
join_params: Vec<Vec<String>>,
fields_keys: Vec<String>,
join_fields: Vec<String>,
hide_fields: Vec<String>,
show_fields: Vec<String>,
total_fields: Vec<String>,
data: JsonValue,
page: usize,
pages: i64,
limit: usize,
search: String,
search_fields: Vec<String>,
search_name: String,
edit_fields: Vec<String>,
order: JsonValue,
where_and: JsonValue,
where_or: JsonValue,
filter_fields: Vec<String>,
table_fields: Vec<String>,
tree_fields: Vec<String>,
json_fields: Vec<String>,
location_fields: Vec<String>,
primary_key: String,
value: Vec<String>,
version: usize,
pid_id: String,
}
impl Tables {
pub fn params_table(mut params: JsonValue) -> JsonValue {
params["page"] = br_fields::int::Int::new(false, "page", "页数", 10, 1)
.example(1.into())
.field();
params["limit"] = br_fields::int::Int::new(false, "limit", "行数", 10, 10)
.example(10.into())
.field();
params["order"] = br_fields::text::Array::new(false, "order", "排序", array![]).field();
params["search"] = br_fields::str::Str::new(false, "search", "搜索", 200, "")
.example("".into())
.field();
params["where_or"] = br_fields::text::Array::new(false, "where_or", "查询条件", array![])
.example(array![])
.field();
params["where_and"] = br_fields::text::Array::new(false, "where_and", "查询条件", array![])
.example(array![])
.field();
params["params"] =
br_fields::text::Object::new(false, "params", "关联数据参数", object! {})
.describe("如果是表单就是表单里的其他字段")
.example(object! {})
.field();
params
}
pub fn params_table_tree(mut params: JsonValue) -> JsonValue {
params["pid"] = br_fields::str::Str::new(false, "pid", "上级ID", 50, "")
.example("".into())
.field();
Tables::params_table_select(params)
}
pub fn params_table_select(mut params: JsonValue) -> JsonValue {
params["value"] = br_fields::text::Array::new(false, "value", "已选中值", array![]).field();
params["primary_key"] =
br_fields::str::Str::new(false, "primary_key", "显示内容的字段", 50, "id").field();
Tables::params_table(params)
}
pub fn params_table_select_tree(mut params: JsonValue) -> JsonValue {
params["pid"] = br_fields::str::Str::new(false, "pid", "上级ID", 20, "")
.example("".into())
.field();
params["value"] = br_fields::text::Array::new(false, "value", "已选中值", array![]).field();
Tables::params_table(params)
}
pub fn new(db: Db) -> Self {
Self {
main_table: "".to_string(),
db,
total: 0.0,
fields: vec![],
join_params: vec![],
fields_keys: vec![],
data: array![],
page: 1,
pages: 0,
limit: 10,
search: "".to_string(),
search_fields: vec![],
search_name: "".to_string(),
edit_fields: vec![],
order: array![],
where_and: array![],
where_or: array![],
filter_fields: vec![],
table_fields: vec![],
tree_fields: vec![],
json_fields: vec![],
location_fields: vec![],
primary_key: "".to_string(),
value: vec![],
version: 0,
join_fields: vec![],
hide_fields: vec![],
show_fields: vec![],
total_fields: vec![],
pid_id: "".to_string(),
}
}
pub fn set_version(&mut self, version: usize) -> &mut Self {
self.version = version;
self
}
pub fn main_table_fields(
&mut self,
table: &str,
fields: JsonValue,
hide_fields: Vec<&str>,
show_fields: Vec<&str>,
) -> &mut Self {
self.main_table = table.to_string();
self.hide_fields = hide_fields.iter().map(|s| s.to_string()).collect();
self.show_fields = show_fields.iter().map(|s| s.to_string()).collect();
self.fields = fields
.entries()
.map(|(_, x)| x.clone())
.collect::<Vec<JsonValue>>();
self
}
pub fn join_fields(&mut self, table: &str, mut fields: JsonValue, index: isize) -> &mut Self {
for (field, item) in fields.entries_mut() {
if self.main_table != table {
item["field"] = format!("{table}_{field}").into();
item["field_table"] = table.into();
item["field_table_field"] = field.into();
}
match index {
x if x > -1 => {
self.fields.insert(x as usize, item.clone());
}
_ => {
self.fields.push(item.clone());
}
}
self.join_fields.push(format!("{table}.{field}"));
}
self
}
pub fn fields(&mut self, fields: JsonValue) -> &mut Self {
self.fields = fields
.entries()
.map(|(_, x)| x.clone())
.collect::<Vec<JsonValue>>();
self
}
pub fn hide_fields(&mut self, hide_fields: Vec<&str>) -> &mut Self {
self.hide_fields = hide_fields.iter().map(|s| s.to_string()).collect();
self
}
pub fn show_fields(&mut self, show_fields: Vec<&str>) -> &mut Self {
self.show_fields = show_fields.iter().map(|s| s.to_string()).collect();
self
}
pub fn total_fields(&mut self, fields: Vec<&str>) -> &mut Self {
self.total_fields = fields.iter().map(|s| s.to_string()).collect();
self
}
fn set_fields(&mut self, field: &str, mode: &str) {
match mode {
"table" => self.table_fields.push(field.to_string()),
"tree" => self.tree_fields.push(field.to_string()),
"object" | "array" | "polygon" => self.json_fields.push(field.to_string()),
"location" => self.location_fields.push(field.to_string()),
_ => {}
}
}
pub fn join_table(
&mut self,
main_table: &str,
main_field: &str,
join_table: &str,
join_field: &str,
) -> &mut Self {
self.join_params.push(vec![
main_table.to_string(),
main_field.to_string(),
join_table.to_string(),
join_field.to_string(),
]);
self
}
pub fn main_select_fields(&mut self, table: &str, mut show_fields: Vec<&str>) -> &mut Self {
self.main_table = table.to_string();
show_fields.insert(0, "id");
self.fields_keys = show_fields.into_iter().map(|x| x.to_string()).collect();
self.search_fields = self.fields_keys.clone();
self
}
pub fn edit_fields(&mut self, fields: Vec<&str>) -> &mut Self {
self.edit_fields = fields.iter().map(|s| s.to_string()).collect();
self
}
pub fn search_fields(&mut self, fields: Vec<&str>) -> &mut Self {
let mut search_name = vec![];
let all_fields = self
.fields
.iter()
.map(|x| (x["field"].to_string(), x.clone()))
.collect::<HashMap<String, JsonValue>>();
for key in fields.clone() {
if all_fields.contains_key(key) {
self.search_fields.push(key.to_string());
search_name.push(all_fields.get(key).unwrap()["title"].to_string());
}
}
self.search_name = search_name.join("/");
self
}
pub fn filter_fields(&mut self, fields: Vec<&str>) -> &mut Self {
let all_fields = self
.fields
.iter()
.map(|x| (x["field"].to_string(), x.clone()))
.collect::<HashMap<String, JsonValue>>();
for key in fields.clone() {
if all_fields.contains_key(key) {
self.filter_fields.push(key.to_string());
}
}
self
}
pub fn params(&mut self, request: JsonValue) -> &mut Self {
if request.has_key("page") {
self.page = request["page"].as_usize().unwrap();
}
if request.has_key("limit") {
self.limit = request["limit"].as_usize().unwrap();
}
if request.has_key("where_and") {
self.where_and = request["where_and"].clone();
}
if request.has_key("where_or") {
self.where_or = request["where_or"].clone();
}
if request.has_key("pid") {
self.pid_id = request["pid"].as_str().unwrap_or("").to_string();
}
if request.has_key("order") {
for item in request["order"].members() {
let _ = self.order.push(item.clone());
}
}
if request.has_key("search") {
self.search = request["search"].to_string();
}
if request.has_key("primary_key") {
self.primary_key = request["primary_key"].to_string();
}
if request.has_key("value") {
self.value = request["value"].members().map(|x| x.to_string()).collect();
}
self
}
fn db_search(&mut self) {
if !self.search.is_empty() {
let mut all_fields = object! {};
let _ = self
.fields
.iter()
.map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()))
.collect::<Vec<_>>();
let mut t = vec![];
for value in self.search_fields.clone() {
let field = all_fields[value.as_str()].clone();
if field.has_key("field_table") {
t.push(format!(
"{}.{}",
field["field_table"].clone(),
field["field_table_field"].clone()
));
} else {
t.push(value);
}
}
self.db
.where_and(&t.join("|"), "like", format!("%{}%", self.search).into());
}
}
fn db_where(&mut self) {
let mut all_fields = object! {};
let _ = self
.fields
.iter()
.map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()))
.collect::<Vec<_>>();
for value in self.where_or.members() {
let field = all_fields[value[0].to_string()].clone();
if field.has_key("field_table") {
self.db.where_or(
format!(
"{}.{}",
field["field_table"].clone(),
field["field_table_field"].clone()
)
.as_str(),
value[1].as_str().unwrap(),
value[2].clone(),
);
} else {
self.db.where_or(
value[0].as_str().unwrap(),
value[1].as_str().unwrap(),
value[2].clone(),
);
}
}
for value in self.where_and.members() {
let field = all_fields[value[0].to_string()].clone();
if field.has_key("field_table") {
self.db.where_and(
format!(
"{}.{}",
field["field_table"].clone(),
field["field_table_field"].clone()
)
.as_str(),
value[1].as_str().unwrap(),
value[2].clone(),
);
} else {
self.db.where_and(
value[0].as_str().unwrap(),
value[1].as_str().unwrap(),
value[2].clone(),
);
}
}
}
fn db_order(&mut self) {
let mut all_fields = object! {};
let _ = self
.fields
.iter()
.map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()))
.collect::<Vec<_>>();
for item in self.order.members() {
let field = all_fields[item[0].to_string()].clone();
if field.has_key("field_table") {
self.db.order(
format!(
"{}.{}",
field["field_table"].clone(),
field["field_table_field"].clone()
)
.as_str(),
item[1].as_bool().unwrap(),
);
} else {
self.db.order(
format!("{}.{}", self.main_table, item[0]).as_str(),
item[1].as_bool().unwrap(),
);
}
}
}
fn db_fields(&mut self) {
let mut all_fields = object! {};
let _ = self
.fields
.iter()
.map(|x| all_fields.insert(x["field"].as_str().unwrap(), x.clone()))
.collect::<Vec<_>>();
if !self.hide_fields.is_empty() {
for field in self.hide_fields.clone() {
if all_fields.has_key(&field) {
all_fields.remove(&field);
continue;
}
}
}
if !self.show_fields.is_empty() {
self.show_fields.insert(0, "id".to_string());
let mut f = object! {};
for field in self.show_fields.clone() {
if all_fields.has_key(&field) {
let _ = f.insert(&field.clone(), all_fields[field].clone());
}
}
all_fields = f;
}
for (field, item) in all_fields.entries() {
let mode = item["mode"].to_string();
self.set_fields(field, mode.as_str());
}
self.fields = all_fields
.entries()
.map(|(_, x)| x.clone())
.collect::<Vec<JsonValue>>();
if !self.fields_keys.is_empty() {
self.db.field(self.fields_keys.join(",").as_str());
}
if !self.json_fields.is_empty() {
self.db.json(self.json_fields.join(",").as_str());
}
if !self.location_fields.is_empty() {
self.db.location(self.location_fields.join(",").as_str());
}
}
fn db_join(&mut self) {
if !self.join_fields.is_empty() {
self.db
.join_fields(self.join_fields.iter().map(|x| x.as_str()).collect());
}
for item in self.join_params.iter() {
self.db.join(&item[0], &item[1], &item[2], &item[3]);
}
}
fn db_total(&mut self) {
self.total = self.db.clone().count().as_f64().unwrap();
self.pages = (self.total / (self.limit as f64)).ceil() as i64;
}
fn db_table(&mut self) {
let mut all_fields = object! {};
let _ = self
.fields
.iter()
.map(|x| {
all_fields
.insert(x["field"].as_str().unwrap(), x.clone())
.unwrap()
})
.collect::<Vec<_>>();
let mut table_data = object! {};
for item in self.data.members_mut() {
for field in self.table_fields.iter() {
let key = item[field].as_str().unwrap_or("");
if key.is_empty() {
continue;
}
let field_info = all_fields[field].clone();
if !table_data.has_key(field) {
table_data[field] = object! {};
}
if !table_data[field].has_key(key) {
let mut info = field_info.clone();
let _ = info["fields"].push("id");
let fields_k = info["fields"]
.members()
.map(|x| x.as_str().unwrap())
.collect::<Vec<&str>>();
let mut find = self
.db
.table(info["table"].as_str().unwrap())
.where_and("id", "=", key.into())
.field(&fields_k.join(","))
.find();
let id = find["id"].to_string();
find.remove("id");
let label = find
.entries()
.map(|(_, v)| v.to_string())
.collect::<Vec<String>>();
table_data[field][key] = object! {
value: id.clone(),
label:label.join(" | ").clone(),
};
}
item[field] = table_data[field][key].clone();
}
for field in self.tree_fields.iter() {
let key = item[field].as_str().unwrap_or("");
if key.is_empty() {
continue;
}
let field_info = all_fields[field].clone();
if !table_data.has_key(field) {
table_data[field] = object! {};
}
if !table_data[field].has_key(key) {
let mut info = field_info.clone();
let pid_field = info["pid_field"].clone().to_string();
let _ = info["fields"].push("id");
let _ = info["fields"].push(pid_field.clone());
let fields_k = info["fields"]
.members()
.map(|x| x.as_str().unwrap())
.collect::<Vec<&str>>();
let mut find = self
.db
.table(info["table"].as_str().unwrap())
.where_and("id", "=", key.into())
.field(&fields_k.join(","))
.find();
let mut pid = find[pid_field.clone()].to_string();
let mut name_list = vec![];
let id = find["id"].to_string();
find.remove("id");
find.remove(&pid_field);
let label = find
.entries()
.map(|(_, v)| v.to_string())
.collect::<Vec<String>>();
name_list.push(label.join(" | ").clone());
loop {
if pid.is_empty() {
break;
}
let mut t = self
.db
.table(info["table"].as_str().unwrap())
.where_and("id", "=", pid.clone().into())
.field(&fields_k.join(","))
.find();
pid = t[pid_field.clone()].to_string();
t.remove("id");
t.remove(&pid_field);
let label = t
.entries()
.map(|(_, v)| v.to_string())
.collect::<Vec<String>>();
name_list.push(label.join(" | ").clone());
}
name_list.reverse();
table_data[field][key] = object! {
value: id.clone(),
label:name_list.join("/").clone(),
};
}
item[field] = table_data[field][key].clone();
}
}
}
fn db_table_tree(&mut self, pid_field: &str) {
let mut all_fields = object! {};
let _ = self
.fields
.iter()
.map(|x| {
all_fields
.insert(x["field"].as_str().unwrap(), x.clone())
.unwrap()
})
.collect::<Vec<_>>();
let mut table_data = object! {};
for item in self.data.members_mut() {
let find = self
.db
.table(&self.main_table)
.where_and(pid_field, "=", item["id"].clone())
.count();
if find.is_empty() {
item["isLeaf"] = true.into();
}
for field in self.table_fields.iter() {
let key = item[field].as_str().unwrap_or("");
if key.is_empty() {
continue;
}
let field_info = all_fields[field].clone();
if !table_data.has_key(field) {
table_data[field] = object! {};
}
if !table_data[field].has_key(key) {
let mut info = field_info.clone();
let _ = info["fields"].push("id");
let fields_k = info["fields"]
.members()
.map(|x| x.as_str().unwrap())
.collect::<Vec<&str>>();
let mut find = self
.db
.table(info["table"].as_str().unwrap())
.where_and("id", "=", key.into())
.field(&fields_k.join(","))
.find();
let id = find["id"].to_string();
find.remove("id");
let label = find
.entries()
.map(|(_, v)| v.to_string())
.collect::<Vec<String>>();
table_data[field][key] = object! {
value: id.clone(),
label:label.join(" | ").clone(),
};
}
item[field] = table_data[field][key].clone();
}
for field in self.tree_fields.iter() {
let key = item[field].as_str().unwrap_or("");
if key.is_empty() {
continue;
}
let field_info = all_fields[field].clone();
if !table_data.has_key(field) {
table_data[field] = object! {};
}
if !table_data[field].has_key(key) {
let mut info = field_info.clone();
let pid_field = info["pid_field"].clone().to_string();
let _ = info["fields"].push("id");
let _ = info["fields"].push(pid_field.clone());
let fields_k = info["fields"]
.members()
.map(|x| x.as_str().unwrap())
.collect::<Vec<&str>>();
let mut find = self
.db
.table(info["table"].as_str().unwrap())
.where_and("id", "=", key.into())
.field(&fields_k.join(","))
.find();
let mut pid = find[pid_field.clone()].to_string();
let mut name_list = vec![];
let id = find["id"].to_string();
find.remove("id");
find.remove(&pid_field);
let label = find
.entries()
.map(|(_, v)| v.to_string())
.collect::<Vec<String>>();
name_list.push(label.join(" | ").clone());
loop {
if pid.is_empty() {
break;
}
let mut t = self
.db
.table(info["table"].as_str().unwrap())
.where_and("id", "=", pid.clone().into())
.field(&fields_k.join(","))
.find();
pid = t[pid_field.clone()].to_string();
t.remove("id");
t.remove(&pid_field);
let label = t
.entries()
.map(|(_, v)| v.to_string())
.collect::<Vec<String>>();
name_list.push(label.join(" | ").clone());
}
name_list.reverse();
table_data[field][key] = object! {
value: id.clone(),
label:name_list.join("/").clone(),
};
}
item[field] = table_data[field][key].clone();
}
}
}
fn columns(&mut self) -> JsonValue {
let mut all_fields = object! {};
let _ = self
.fields
.iter()
.map(|x| {
all_fields
.insert(x["field"].as_str().unwrap(), x.clone())
.unwrap()
})
.collect::<Vec<_>>();
let sort_field = self
.order
.members()
.map(|x| (x[0].to_string(), x[1].as_bool().unwrap()))
.collect::<HashMap<String, bool>>();
for (_, item) in all_fields.entries_mut() {
item["name"] = item["field"].clone();
item["align"] = "center".into();
item["label"] = item["title"].clone();
item["version"] = self.version.into();
if item["field"].as_str().unwrap_or("") != "id" {
if self.version == 0 {
item["sortable"] = true.into();
} else {
item["sortable"] = object! {
"sorter"=>false,
"sortDirections"=>array!["ascend","descend"],
"defaultSortOrder"=>"",
"sortOrder"=>""
};
if sort_field.contains_key(item["field"].to_string().as_str()) {
item["sortable"]["sortOrder"] =
if *sort_field.get(&item["field"].to_string()).unwrap() {
"descend"
} else {
"ascend"
}
.into();
}
}
}
item["dataIndex"] = item["field"].clone();
item["slotName"] = item["field"].clone();
item["titleSlotName"] = item["field"].clone();
match item["mode"].as_str().unwrap() {
"string" | "text" => {
item["ellipsis"] = true.into();
item["tooltip"] = true.into();
}
"key" => {
item["width"] = 280.into();
item["ellipsis"] = true.into();
}
_ => {}
}
}
all_fields
}
pub fn get_table(&mut self) -> JsonValue {
self.db.table(&self.main_table);
self.db_fields();
self.db_search();
self.db_where();
self.db_join();
self.db_total();
self.db_order();
self.db.page(self.page as i32, self.limit as i32);
self.data = self.db.select();
self.db_table();
object! {
"pages"=>self.pages,
"total"=>self.total,
"data"=>self.data.clone(),
"columns"=>self.columns(),
"filter_fields"=>self.filter_fields.clone(),
"search_name"=>self.search_name.clone(),
"total_fields"=>self.total_fields.clone(),
"btn_all"=>array![],
"btn_api"=>array![],
"btn_ids"=>array![]
}
}
pub fn get_table_menu(&mut self, label_field: &str) -> JsonValue {
self.db.table(&self.main_table);
self.db_fields();
self.db_search();
self.db_where();
self.db_join();
self.db_total();
self.db_order();
self.db.page(self.page as i32, self.limit as i32);
self.data = self.db.select();
self.db_table();
object! {
"pages"=>self.pages,
"total"=>self.total,
"data"=>self.data.clone(),
"columns"=>self.columns(),
"filter_fields"=>self.filter_fields.clone(),
"search_name"=>self.search_name.clone(),
"total_fields"=>self.total_fields.clone(),
"btn_all"=>array![],
"btn_api"=>array![],
"btn_ids"=>array![],
"label_field"=>label_field
}
}
pub fn get_tree(&mut self, pid_field: &str) -> JsonValue {
self.db.table(&self.main_table);
self.set_version(1);
self.db
.where_and(pid_field, "=", self.pid_id.clone().into());
self.db_fields();
self.db_search();
self.db_where();
self.db_join();
self.db_total();
self.db_order();
if self.pid_id.is_empty() {
self.db.page(self.page as i32, self.limit as i32);
} else {
self.db.page(1, 1000);
}
self.data = self.db.select();
self.db_table_tree(pid_field);
object! {
"pages"=>self.pages,
"total"=>self.total,
"data"=>self.data.clone(),
"columns"=>self.columns(),
"filter_fields"=>self.filter_fields.clone(),
"search_name"=>self.search_name.clone(),
"total_fields"=>self.total_fields.clone(),
"btn_all"=>array![],
"btn_api"=>array![],
"btn_ids"=>array![]
}
}
pub fn get_table_edit(&mut self) -> JsonValue {
self.db.table(&self.main_table);
self.db_fields();
self.db_search();
self.db_where();
self.db_total();
self.db_order();
self.db.page(self.page as i32, self.limit as i32);
self.db_join();
self.data = self.db.select();
object! {
"pages"=>self.pages,
"total"=>self.total,
"data"=>self.data.clone(),
"columns"=>self.columns(),
"edit_fields"=>self.edit_fields.clone(),
}
}
pub fn get_table_select(&mut self) -> JsonValue {
self.db.table(&self.main_table);
if !self.primary_key.eq("id") {
self.fields_keys.remove(0);
}
if !self.value.is_empty() {
let _ = self
.where_or
.push(array![self.primary_key.clone(), "in", self.value.clone()]);
let _ = self
.where_or
.push(array![self.primary_key.clone(), "isnot", "NULL"]);
let _ = self.order.push(array![
format!(
"{} in ('{}')",
self.primary_key.clone(),
self.value.join("','")
),
true
]);
}
self.db_fields();
self.db_search();
self.db_where();
self.db_join();
self.db_total();
self.db_order();
self.db.page(self.page as i32, self.limit as i32);
let mut list = self.db.select();
for item in list.members_mut() {
let value = item[self.primary_key.clone()].clone();
if self.primary_key.eq("id") {
item.remove(&self.primary_key.clone());
}
let label = item
.entries()
.map(|(_, v)| v.to_string())
.collect::<Vec<String>>();
self.data
.push(object! {
value: value,
label: label.join(" | ").clone(),
})
.unwrap();
}
object! {
"pages"=>self.pages,
"total"=>self.total,
"data"=>self.data.clone(),
}
}
pub fn get_table_select_tree(&mut self, pid_field: &str, label_field: &str) -> JsonValue {
self.fields_keys.push(pid_field.to_string());
self.db.table(&self.main_table);
self.db
.where_and(pid_field, "=", self.pid_id.clone().into());
self.db_fields();
self.db_search();
self.db_where();
self.db_join();
self.db_order();
self.db.page(1, 1000);
self.data = self.db.select();
for item in self.data.members_mut() {
let children = self
.db
.table(&self.main_table)
.where_and(pid_field, "=", item["id"].clone())
.count();
if children.is_empty() {
item["lazy"] = false.into();
item["isLeaf"] = true.into();
} else {
item["lazy"] = true.into();
}
}
if self.pid_id.is_empty() {
for id in self.value.clone() {
let mut list = vec![];
let mut find = self
.db
.table(&self.main_table)
.where_and("id", "=", id.into())
.field(self.fields_keys.join(",").as_str())
.find();
loop {
let pid = find[pid_field].to_string();
if pid.is_empty() {
break;
}
find = self
.db
.table(&self.main_table)
.where_and("id", "=", pid.into())
.field(self.fields_keys.join(",").as_str())
.find();
list.insert(0, find.clone());
}
let data = &mut self.data.clone();
self.tree_data(data, list.into(), 0, pid_field);
self.data = data.clone();
}
}
object! {
"data"=> self.data.clone(),
"label_field"=>label_field.to_string(),
"pid_field"=>pid_field.to_string(),
}
}
fn tree_data(&mut self, data: &mut JsonValue, list: JsonValue, index: usize, pid_field: &str) {
let id = list[index]["id"].clone();
for item in data.members_mut() {
let children = self
.db
.table(&self.main_table)
.where_and(pid_field, "=", item["id"].clone())
.field(self.fields_keys.join(",").as_str())
.select();
if children.is_empty() {
item["isLeaf"] = true.into();
}
if id == item["id"] && !children.is_empty() {
item["children"] = children;
self.tree_data(&mut item["children"], list.clone(), index + 1, pid_field);
}
}
}
}