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

br_fields/
lib.rs
