br_fields/
lib.rs

1use json::JsonValue;
2use log::info;
3
4/// 日期时间
5pub mod datetime;
6/// 字典
7pub mod dict;
8/// 附件
9pub mod files;
10pub mod float;
11pub mod int;
12/// 坐标
13pub mod location;
14pub mod select;
15pub mod str;
16/// 关联表字段
17pub mod table;
18pub mod text;
19
20pub trait Field {
21    fn require(&mut self, _require: bool) -> &mut Self {
22        self
23    }
24    fn sql(&mut self, model: &str) -> String;
25    /// 隐藏字段
26    fn hide(&mut self) -> &mut Self;
27    /// 字段描述
28    fn describe(&mut self, text: &str) -> &mut Self;
29    fn field(&mut self) -> JsonValue;
30    /// 验证方法
31    fn verify(&mut self, data: JsonValue) -> JsonValue {
32        data
33    }
34    /// api格式
35    fn swagger(&mut self) -> JsonValue;
36    /// 示例
37    fn example(&mut self, data: JsonValue) -> &mut Self;
38}
39
40#[derive(Debug, Clone)]
41pub enum FieldMode {
42    Key,
43    Pass,
44    Color,
45    String,
46    Tel,
47    Ident,
48    Code,
49    Email,
50    Table,
51    Text,
52    Editor,
53    Url,
54    Files,
55    Json,
56    Array,
57    Object,
58    Float,
59    Int,
60    Switch,
61    Datetime,
62    Year,
63    YearMonth,
64    Date,
65    Time,
66    Timestamp,
67    Select,
68    Radio,
69    Location,
70    Dict,
71    BarCode,
72    QrCode,
73    Tree,
74    Polygon,
75}
76
77impl FieldMode {
78    pub fn from(name: &str) -> FieldMode {
79        match name {
80            "key" => FieldMode::Key,
81            "pass" => FieldMode::Pass,
82            "string" => FieldMode::String,
83            "color" => FieldMode::Color,
84            "tel" => FieldMode::Tel,
85            "ident" => FieldMode::Ident,
86            "email" => FieldMode::Email,
87            "table" => FieldMode::Table,
88            "text" => FieldMode::Text,
89            "editor" => FieldMode::Editor,
90            "url" => FieldMode::Url,
91            "file" => FieldMode::Files,
92            "json" => FieldMode::Json,
93            "array" => FieldMode::Array,
94            "object" => FieldMode::Object,
95            "float" => FieldMode::Float,
96            "int" => FieldMode::Int,
97            "switch" => FieldMode::Switch,
98            "datetime" => FieldMode::Datetime,
99            "year" => FieldMode::Year,
100            "yearmonth" => FieldMode::YearMonth,
101            "date" => FieldMode::Date,
102            "time" => FieldMode::Time,
103            "timestamp" => FieldMode::Timestamp,
104            "select" => FieldMode::Select,
105            "radio" => FieldMode::Radio,
106            "location" => FieldMode::Location,
107            "polygon" => FieldMode::Polygon,
108            "dict" => FieldMode::Dict,
109            "code" => FieldMode::Code,
110            "barcode" => FieldMode::BarCode,
111            "qrcode" => FieldMode::QrCode,
112            "tree" => FieldMode::Tree,
113            _ => {
114                info!("未知字段类型 mode: {name}");
115                FieldMode::String
116            }
117        }
118    }
119}
120
121/// 解析数据
122pub fn field(model: &str, field: &str, data: JsonValue) -> String {
123    let mode = data["mode"].as_str().unwrap();
124    let require = data["require"].as_bool().unwrap_or(false);
125    let title = data["title"].as_str().unwrap_or("未知标题");
126
127    let field_mode = FieldMode::from(mode);
128
129    let row = match field_mode {
130        FieldMode::Table => {
131            let table = data["table"].as_str().unwrap();
132            let fields: Vec<&str> = data["fields"]
133                .members()
134                .map(|x| x.as_str().unwrap())
135                .collect();
136            let api = data["api"].as_str().unwrap();
137            let multiple_count = data["multiple_count"].as_i32().unwrap_or(1);
138            table::Table::new(require, field, title, table, fields, api)
139                .multiple(multiple_count)
140                .sql(model)
141        }
142        FieldMode::Tree => {
143            let table = data["table"].as_str().unwrap();
144            let pid_field = data["pid_field"].as_str().unwrap();
145            let fields: Vec<&str> = data["fields"]
146                .members()
147                .map(|x| x.as_str().unwrap())
148                .collect();
149            let api = data["api"].as_str().unwrap();
150            let multiple_count = data["multiple_count"].as_i32().unwrap_or(1);
151            table::Tree::new(require, field, title, table, pid_field, fields, api)
152                .multiple(multiple_count)
153                .sql(model)
154        }
155        FieldMode::Text => {
156            let default = data["def"].as_str().unwrap_or("");
157            let length = data["length"].as_i32().unwrap_or(0);
158            text::Text::new(require, field, title, default)
159                .length(length)
160                .sql(model)
161        }
162        FieldMode::Editor => {
163            let default = data["def"].as_str().unwrap_or("");
164            let length = data["length"].as_i32().unwrap_or(0);
165            text::Editor::new(require, field, title, default)
166                .length(length)
167                .sql(model)
168        }
169        FieldMode::Json => {
170            let default = data["def"].clone();
171            let length = data["length"].as_i32().unwrap_or(0);
172            text::Json::new(require, field, title, default)
173                .length(length)
174                .sql(model)
175        }
176        FieldMode::Array => {
177            let default = data["def"].clone();
178            let length = data["length"].as_i32().unwrap_or(0);
179            text::Array::new(require, field, title, default)
180                .length(length)
181                .sql(model)
182        }
183        FieldMode::Object => {
184            let default = data["def"].clone();
185            let length = data["length"].as_i32().unwrap_or(0);
186            text::Object::new(require, field, title, default)
187                .length(length)
188                .sql(model)
189        }
190        FieldMode::Url => {
191            let default = data["def"].as_str().unwrap_or("");
192            text::Url::new(require, field, title, default).sql(model)
193        }
194        FieldMode::Files => {
195            let length = data["length"].as_i32().unwrap_or(1);
196            let encrypt = data["encrypt"].as_bool().unwrap_or(false);
197            let size = data["size"].as_usize().unwrap_or(0);
198            let default = data["def"].as_str().unwrap_or("");
199            let option: Vec<&str> = data["option"]
200                .members()
201                .map(|x| x.as_str().unwrap())
202                .collect();
203            let mut files_mode = files::Files::new(require, field, title);
204
205            if length > 1 {
206                files_mode.multiple(length);
207            }
208            if encrypt {
209                files_mode.encrypt();
210            }
211            files_mode.def(default);
212            files_mode.size(size);
213            files_mode.option(option);
214            files_mode.sql(model)
215        }
216        FieldMode::Float => {
217            let length = data["length"].as_i32().unwrap();
218            let dec = data["dec"].as_usize().unwrap();
219            let default = data["def"].to_string().parse::<f64>().unwrap_or(0.0);
220            float::Float::new(require, field, title, length, dec, default).sql(model)
221        }
222        FieldMode::Int => {
223            let length = data["length"].as_i32().unwrap();
224            let default = data["def"].as_i64().unwrap();
225            int::Int::new(require, field, title, length, default).sql(model)
226        }
227        FieldMode::Switch => {
228            let default = data["def"].to_string().parse::<bool>().unwrap();
229            int::Switch::new(require, field, title, default).sql(model)
230        }
231        FieldMode::Datetime => {
232            let default = data["def"].as_str().unwrap_or("");
233            datetime::Datetime::new(require, field, title, default).sql(model)
234        }
235        FieldMode::Year => {
236            let default = data["def"].as_str().unwrap_or("");
237            datetime::Year::new(require, field, title, default).sql(model)
238        }
239        FieldMode::YearMonth => {
240            let default = data["def"].as_i64().unwrap_or(0);
241            datetime::YearMonth::new(require, field, title, default).sql(model)
242        }
243        FieldMode::Date => {
244            let default = data["def"].as_str().unwrap();
245            datetime::Date::new(require, field, title, default).sql(model)
246        }
247        FieldMode::Time => {
248            let default = data["def"].as_str().unwrap();
249            datetime::Time::new(require, field, title, default).sql(model)
250        }
251        FieldMode::Timestamp => {
252            let dec = data["dec"].as_i32().unwrap();
253            let default = data["def"].as_f64().unwrap_or(0.0);
254            datetime::Timestamp::new(require, field, title, dec, default).sql(model)
255        }
256        FieldMode::Select => {
257            let option: Vec<&str> = data["option"]
258                .members()
259                .map(|x| x.as_str().unwrap())
260                .collect();
261
262            let def: Vec<&str> = data["def"].members().map(|x| x.as_str().unwrap()).collect();
263
264            select::Select::new(require, field, title, option, def)
265                .table_name(data["table_name"].as_str().unwrap_or(""))
266                .sql(model)
267        }
268        FieldMode::Radio => {
269            let option: Vec<&str> = data["option"]
270                .members()
271                .map(|x| x.as_str().unwrap())
272                .collect();
273            select::Radio::new(require, field, title, option, data["def"].as_str().unwrap())
274                .table_name(data["table_name"].as_str().unwrap_or(""))
275                .sql(model)
276        }
277        FieldMode::Location => {
278            let default = data["def"].as_str().unwrap_or("");
279            location::Location::new(require, field, title)
280                .def(default)
281                .sql(model)
282        }
283        FieldMode::Dict => {
284            let table = data["table"].as_str().unwrap();
285            let fields = data["fields"].as_str().unwrap_or("");
286            let api = data["api"].as_str().unwrap();
287            let default = data["def"].as_str().unwrap_or("");
288
289            let multiple_count = data["multiple_count"].as_i32().unwrap_or(1);
290            dict::Dict::new(require, field, title, table, fields, api)
291                .multiple(multiple_count)
292                .default(default)
293                .sql(model)
294        }
295
296        FieldMode::Key
297        | FieldMode::Pass
298        | FieldMode::String
299        | FieldMode::Code
300        | FieldMode::BarCode
301        | FieldMode::Email
302        | FieldMode::Tel
303        | FieldMode::Ident
304        | FieldMode::Color
305        | FieldMode::QrCode => {
306            let default = data["def"].as_str().unwrap_or("");
307            let dec = data["dec"].as_str().unwrap_or("");
308            let length = data["length"].as_usize().unwrap_or(20);
309            match FieldMode::from(mode) {
310                FieldMode::Code => {
311                    str::Code::new(require, field, title, length, dec, default).sql(model)
312                }
313                FieldMode::BarCode => str::BarCode::new(require, field, title, default).sql(model),
314                FieldMode::Email => str::Email::new(require, field, title, default).sql(model),
315                FieldMode::Tel => str::Tel::new(require, field, title, default).sql(model),
316                FieldMode::Ident => str::Ident::new(require, field, title, default).sql(model),
317                FieldMode::Color => str::Color::new(require, field, title, default).sql(model),
318                FieldMode::String => {
319                    str::Str::new(require, field, title, length, default).sql(model)
320                }
321                FieldMode::Pass => {
322                    str::Pass::new(require, field, title, length, default).sql(model)
323                }
324                FieldMode::Key => str::Key::new(true, field, title, length)
325                    .auto(data["auto"].as_bool().unwrap())
326                    .sql(model),
327                FieldMode::QrCode => {
328                    str::QrCode::new(require, field, title, length, default).sql(model)
329                }
330                _ => str::Str::new(require, field, title, length, default).sql(model),
331            }
332        }
333        FieldMode::Polygon => {
334            let default = data["def"].clone();
335            let length = data["length"].as_i32().unwrap_or(0);
336            text::Array::new(require, field, title, default)
337                .length(length)
338                .sql(model)
339        }
340    };
341    row.to_string()
342}
343
344/// 验证
345pub fn verify(field: &str, data: JsonValue) -> JsonValue {
346    let mode = data["mode"].as_str().unwrap();
347    let require = data["require"].as_bool().unwrap_or(false);
348    let title = data["title"].as_str().unwrap_or("未知标题");
349    let field_mode = FieldMode::from(mode);
350
351    match field_mode {
352        FieldMode::BarCode
353        | FieldMode::Pass
354        | FieldMode::Key
355        | FieldMode::String
356        | FieldMode::Color
357        | FieldMode::Tel
358        | FieldMode::Ident
359        | FieldMode::Email
360        | FieldMode::Code
361        | FieldMode::QrCode => {
362            let default = data["def"].as_str().unwrap_or("");
363            let length = data["length"].as_usize().unwrap_or(20);
364            match field_mode {
365                FieldMode::Key => str::Key::new(true, field, title, length)
366                    .auto(data["auto"].as_bool().unwrap())
367                    .verify(data),
368                FieldMode::Pass => {
369                    str::Pass::new(require, field, title, length, default).verify(data)
370                }
371                FieldMode::String => {
372                    str::Str::new(require, field, title, length, default).verify(data)
373                }
374                FieldMode::Color => str::Color::new(require, field, title, default).verify(data),
375                FieldMode::Tel => str::Tel::new(require, field, title, default).verify(data),
376                FieldMode::Ident => str::Ident::new(require, field, title, default).verify(data),
377                FieldMode::Email => str::Email::new(require, field, title, default).verify(data),
378                FieldMode::BarCode => {
379                    str::BarCode::new(require, field, title, default).verify(data)
380                }
381                FieldMode::Code => {
382                    let dec = data["dec"].as_str().unwrap_or("");
383                    str::Code::new(require, field, title, length, dec, default).verify(data)
384                }
385                FieldMode::QrCode => {
386                    str::QrCode::new(require, field, title, length, default).verify(data)
387                }
388                _ => str::Str::new(require, field, title, length, default).verify(data),
389            }
390        }
391        FieldMode::Table => {
392            let table = data["table"].as_str().unwrap();
393            let fields: Vec<&str> = data["fields"]
394                .members()
395                .map(|x| x.as_str().unwrap())
396                .collect();
397            let api = data["api"].as_str().unwrap();
398            let multiple_count = data["multiple_count"].as_i32().unwrap_or(1);
399            table::Table::new(require, field, title, table, fields, api)
400                .multiple(multiple_count)
401                .verify(data)
402        }
403        FieldMode::Tree => {
404            let table = data["table"].as_str().unwrap();
405            let pid_field = data["pid_field"].as_str().unwrap_or("");
406            let fields: Vec<&str> = data["fields"]
407                .members()
408                .map(|x| x.as_str().unwrap())
409                .collect();
410            let api = data["api"].as_str().unwrap();
411            let multiple_count = data["multiple_count"].as_i32().unwrap_or(1);
412            table::Tree::new(require, field, title, table, pid_field, fields, api)
413                .multiple(multiple_count)
414                .verify(data)
415        }
416        FieldMode::Text => {
417            let default = data["def"].as_str().unwrap_or("");
418            let length = data["length"].as_i32().unwrap_or(0);
419            text::Text::new(require, field, title, default)
420                .length(length)
421                .verify(data)
422        }
423        FieldMode::Editor => {
424            let default = data["def"].as_str().unwrap_or("");
425            let length = data["length"].as_i32().unwrap_or(0);
426            text::Editor::new(require, field, title, default)
427                .length(length)
428                .verify(data)
429        }
430        FieldMode::Json => {
431            let default = data["def"].clone();
432            let length = data["length"].as_i32().unwrap_or(0);
433            text::Json::new(require, field, title, default)
434                .length(length)
435                .verify(data)
436        }
437        FieldMode::Array => {
438            let default = data["def"].clone();
439            let length = data["length"].as_i32().unwrap_or(0);
440            text::Array::new(require, field, title, default)
441                .length(length)
442                .verify(data)
443        }
444        FieldMode::Object => {
445            let default = data["def"].clone();
446            let length = data["length"].as_i32().unwrap_or(0);
447            text::Object::new(require, field, title, default)
448                .length(length)
449                .verify(data)
450        }
451        FieldMode::Url => {
452            let default = data["def"].as_str().unwrap_or("");
453            text::Url::new(require, field, title, default).verify(data)
454        }
455        FieldMode::Files => {
456            let length = data["length"].as_i32().unwrap_or(1);
457            let encrypt = data["encrypt"].as_bool().unwrap_or(false);
458            let size = data["size"].as_usize().unwrap_or(0);
459            let option: Vec<&str> = data["option"]
460                .members()
461                .map(|x| x.as_str().unwrap())
462                .collect();
463            let default = data["def"].as_str().unwrap_or("");
464
465            let mut files_mode = files::Files::new(require, field, title);
466
467            if length > 1 {
468                files_mode.multiple(length);
469            }
470            if encrypt {
471                files_mode.encrypt();
472            }
473            files_mode.def(default);
474            files_mode.size(size);
475            files_mode.option(option);
476            files_mode.verify(data)
477        }
478        FieldMode::Float => {
479            let length = data["length"].as_i32().unwrap();
480            let dec = data["dec"].as_usize().unwrap();
481            let default = data["def"].as_f64().unwrap();
482            float::Float::new(require, field, title, length, dec, default).verify(data)
483        }
484        FieldMode::Int => {
485            let length = data["length"].as_i32().unwrap();
486            let default = data["def"].as_i64().unwrap();
487            int::Int::new(require, field, title, length, default).verify(data)
488        }
489        FieldMode::Switch => {
490            let default = data["def"].to_string().parse::<u8>().unwrap();
491            let default = default == 1;
492            int::Switch::new(require, field, title, default).verify(data)
493        }
494        FieldMode::Year
495        | FieldMode::YearMonth
496        | FieldMode::Date
497        | FieldMode::Datetime
498        | FieldMode::Time
499        | FieldMode::Timestamp => {
500            let default = data["def"].as_str().unwrap_or("");
501            match field_mode {
502                FieldMode::Datetime => {
503                    datetime::Datetime::new(require, field, title, default).verify(data)
504                }
505                FieldMode::Year => datetime::Year::new(require, field, title, default).verify(data),
506                FieldMode::YearMonth => {
507                    let default = data["def"].as_i64().unwrap_or(0);
508                    datetime::YearMonth::new(require, field, title, default).verify(data)
509                }
510                FieldMode::Date => datetime::Date::new(require, field, title, default).verify(data),
511                FieldMode::Time => datetime::Time::new(require, field, title, default).verify(data),
512                FieldMode::Timestamp => {
513                    let dec = data["dec"].as_i32().unwrap();
514                    let default = data["def"].as_f64().unwrap_or(0.0);
515                    datetime::Timestamp::new(require, field, title, dec, default).verify(data)
516                }
517                _ => datetime::Datetime::new(require, field, title, default).verify(data),
518            }
519        }
520
521        FieldMode::Select => {
522            let option: Vec<&str> = data["option"]
523                .members()
524                .map(|c| c.as_str().unwrap())
525                .collect();
526            let def: Vec<&str> = data["def"].members().map(|c| c.as_str().unwrap()).collect();
527            select::Select::new(require, field, title, option, def).verify(data)
528        }
529        FieldMode::Radio => {
530            let option: Vec<&str> = data["option"]
531                .members()
532                .map(|x| x.as_str().unwrap())
533                .collect();
534            select::Radio::new(require, field, title, option, data["def"].as_str().unwrap())
535                .verify(data)
536        }
537
538        FieldMode::Location => {
539            let default = data["def"].as_str().unwrap_or("");
540            location::Location::new(require, field, title)
541                .def(default)
542                .verify(data)
543        }
544        FieldMode::Dict => {
545            let table = data["table"].as_str().unwrap();
546            let fields = data["fields"].as_str().unwrap_or("");
547            let api = data["api"].as_str().unwrap();
548            let multiple_count = data["multiple_count"].as_i32().unwrap_or(1);
549            dict::Dict::new(require, field, title, table, fields, api)
550                .multiple(multiple_count)
551                .verify(data)
552        }
553        FieldMode::Polygon => {
554            let default = data["def"].clone();
555            let length = data["length"].as_i32().unwrap_or(0);
556            text::Array::new(require, field, title, default)
557                .length(length)
558                .verify(data)
559        }
560    }
561}
br_fields/lib.rs

br_fields/
lib.rs
