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

br_fields/
lib.rs
