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

br_fields/
lib.rs
