chimes_utils/utils/
common_search.rs

1use rbatis::wrapper::Wrapper;
2use serde_derive::{Deserialize, Serialize};
3
4#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5pub struct SearchField {
6    pub field: Option<String>,
7    pub operator: Option<String>,
8    pub render: Option<String>,
9    pub field_type: Option<String>,
10    pub val: Option<String>,
11}
12
13#[derive(Debug, Clone, Default, Deserialize, Serialize)]
14pub struct CommonSearch {
15    pub limit: Option<u64>,
16    pub page: Option<u64>,
17    pub order: Option<String>,
18    pub search: Vec<SearchField>,
19}
20
21impl CommonSearch {
22    fn to_value(&self, field: &SearchField) -> Option<rbatis::Value> {
23        let field_value = field.val.clone().unwrap_or_default();
24        self.to_value_inner(field, field_value)
25    }
26
27    fn to_value_inner(&self, field: &SearchField, field_value: String) -> Option<rbatis::Value> {
28        let value = match field.field_type.clone() {
29            Some(t) => {
30                match t.to_lowercase().as_str() {
31                    "integer" => match field_value.parse::<i64>() {
32                        Ok(v) => Some(rbatis::Value::Int64(v)),
33                        Err(_) => None,
34                    },
35                    "float" => match field_value.parse::<f64>() {
36                        Ok(v) => Some(rbatis::Value::Double(v)),
37                        Err(_) => None,
38                    },
39                    "decimal" => Some(rbatis::Value::String(field_value)),
40                    "boolean" => Some(rbatis::Value::from(
41                        field_value.to_lowercase().as_str() == "true",
42                    )),
43                    "datetime" => match rbatis::DateTimeNative::from_str(&field_value) {
44                        Ok(_) => Some(rbatis::Value::from(&field_value)),
45                        Err(_) => None,
46                    },
47                    "date" => match rbatis::DateNative::from_str(&field_value) {
48                        Ok(_) => Some(rbatis::Value::from(&field_value)),
49                        Err(_) => None,
50                    },
51                    _ => Some(rbatis::Value::String(field_value)), // default to string
52                }
53            }
54            None => Some(rbatis::Value::String(field_value)),
55        };
56        value
57    }
58
59    fn split_value(&self, field: &SearchField) -> Vec<Option<rbatis::Value>> {
60        let field_value = field.val.clone().unwrap_or_default();
61        let list: Vec<Option<rbatis::Value>> = field_value
62            .split(',')
63            .map(|f| self.to_value_inner(field, f.to_string()))
64            .collect();
65        list
66    }
67
68    pub fn into_wrapper(&self, mut wp: Wrapper) -> Wrapper {
69        for f in self.search.clone() {
70            if let Some(t) = f.operator.clone() {
71                match t.to_lowercase().as_str() {
72                    "eq" => {
73                        wp = wp.and().eq(
74                            f.field.clone().unwrap_or_default().as_str(),
75                            self.to_value(&f),
76                        );
77                    }
78                    "ne" => {
79                        wp = wp.and().ne(
80                            f.field.clone().unwrap_or_default().as_str(),
81                            self.to_value(&f),
82                        );
83                    }
84                    "gt" => {
85                        wp = wp.and().gt(
86                            f.field.clone().unwrap_or_default().as_str(),
87                            self.to_value(&f),
88                        );
89                    }
90                    "egt" => {
91                        wp = wp.and().gt(
92                            f.field.clone().unwrap_or_default().as_str(),
93                            self.to_value(&f),
94                        );
95                    }
96                    "lt" => {
97                        wp = wp.and().lt(
98                            f.field.clone().unwrap_or_default().as_str(),
99                            self.to_value(&f),
100                        );
101                    }
102                    "elt" => {
103                        wp = wp.and().le(
104                            f.field.clone().unwrap_or_default().as_str(),
105                            self.to_value(&f),
106                        );
107                    }
108                    "like" => {
109                        wp = wp.and().like(
110                            f.field.clone().unwrap_or_default().as_str(),
111                            self.to_value(&f),
112                        );
113                    }
114                    "not like" => {
115                        wp = wp.and().not_like(
116                            f.field.clone().unwrap_or_default().as_str(),
117                            self.to_value(&f),
118                        );
119                    }
120                    "in" => {
121                        let list = self.split_value(&f);
122                        wp = wp
123                            .and()
124                            .r#in(f.field.clone().unwrap_or_default().as_str(), &list);
125                    }
126                    "not in" => {
127                        let list = self.split_value(&f);
128                        wp = wp
129                            .and()
130                            .r#not_in(f.field.clone().unwrap_or_default().as_str(), &list);
131                    }
132                    "range" => {
133                        let list = self.split_value(&f);
134                        wp = wp.and().between(
135                            f.field.clone().unwrap_or_default().as_str(),
136                            list[0].clone(),
137                            list[1].clone(),
138                        );
139                    }
140                    "not range" => {
141                        let list = self.split_value(&f);
142                        wp = wp.and().not_between(
143                            f.field.clone().unwrap_or_default().as_str(),
144                            list[0].clone(),
145                            list[1].clone(),
146                        );
147                    }
148                    "null" => {
149                        wp = wp
150                            .and()
151                            .is_null(f.field.clone().unwrap_or_default().as_str());
152                    }
153                    "not null" => {
154                        wp = wp
155                            .and()
156                            .is_not_null(f.field.clone().unwrap_or_default().as_str());
157                    }
158                    _ => {}
159                }
160            }
161        }
162        wp
163    }
164}
chimes_utils/utils/common_search.rs

chimes_utils/utils/
common_search.rs
