1 package ru
2
3 import (
4 "fmt"
5 "log"
6 "reflect"
7 "strconv"
8 "strings"
9 "time"
10
11 "github.com/go-playground/locales"
12 ut "github.com/go-playground/universal-translator"
13 "github.com/go-playground/validator/v10"
14 )
15
16
17
18 func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (err error) {
19
20 translations := []struct {
21 tag string
22 translation string
23 override bool
24 customRegisFunc validator.RegisterTranslationsFunc
25 customTransFunc validator.TranslationFunc
26 }{
27 {
28 tag: "required",
29 translation: "{0} обязательное поле",
30 override: false,
31 },
32 {
33 tag: "len",
34 customRegisFunc: func(ut ut.Translator) (err error) {
35
36 if err = ut.Add("len-string", "{0} должен быть длиной в {1}", false); err != nil {
37 return
38 }
39
40 if err = ut.AddCardinal("len-string-character", "{0} символ", locales.PluralRuleOne, false); err != nil {
41 return
42 }
43
44 if err = ut.AddCardinal("len-string-character", "{0} символа", locales.PluralRuleFew, false); err != nil {
45 return
46 }
47
48 if err = ut.AddCardinal("len-string-character", "{0} символов", locales.PluralRuleMany, false); err != nil {
49 return
50 }
51
52 if err = ut.AddCardinal("len-string-character", "{0} символы", locales.PluralRuleOther, false); err != nil {
53 return
54 }
55
56 if err = ut.Add("len-number", "{0} должен быть равен {1}", false); err != nil {
57 return
58 }
59
60 if err = ut.Add("len-items", "{0} должен содержать {1}", false); err != nil {
61 return
62 }
63
64 if err = ut.AddCardinal("len-items-item", "{0} элемент", locales.PluralRuleOne, false); err != nil {
65 return
66 }
67
68 if err = ut.AddCardinal("len-items-item", "{0} элемента", locales.PluralRuleFew, false); err != nil {
69 return
70 }
71
72 if err = ut.AddCardinal("len-items-item", "{0} элементов", locales.PluralRuleMany, false); err != nil {
73 return
74 }
75
76 if err = ut.AddCardinal("len-items-item", "{0} элементы", locales.PluralRuleOther, false); err != nil {
77 return
78 }
79
80 return
81
82 },
83 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
84
85 var err error
86 var t string
87
88 var digits uint64
89 var kind reflect.Kind
90
91 if idx := strings.Index(fe.Param(), "."); idx != -1 {
92 digits = uint64(len(fe.Param()[idx+1:]))
93 }
94
95 f64, err := strconv.ParseFloat(fe.Param(), 64)
96 if err != nil {
97 goto END
98 }
99
100 kind = fe.Kind()
101 if kind == reflect.Ptr {
102 kind = fe.Type().Elem().Kind()
103 }
104
105 switch kind {
106 case reflect.String:
107
108 var c string
109
110 c, err = ut.C("len-string-character", f64, digits, ut.FmtNumber(f64, digits))
111 if err != nil {
112 goto END
113 }
114
115 t, err = ut.T("len-string", fe.Field(), c)
116
117 case reflect.Slice, reflect.Map, reflect.Array:
118 var c string
119
120 c, err = ut.C("len-items-item", f64, digits, ut.FmtNumber(f64, digits))
121 if err != nil {
122 goto END
123 }
124
125 t, err = ut.T("len-items", fe.Field(), c)
126
127 default:
128 t, err = ut.T("len-number", fe.Field(), ut.FmtNumber(f64, digits))
129 }
130
131 END:
132 if err != nil {
133 fmt.Printf("warning: error translating FieldError: %s", err)
134 return fe.(error).Error()
135 }
136
137 return t
138 },
139 },
140 {
141 tag: "min",
142 customRegisFunc: func(ut ut.Translator) (err error) {
143
144 if err = ut.Add("min-string", "{0} должен содержать минимум {1}", false); err != nil {
145 return
146 }
147
148 if err = ut.AddCardinal("min-string-character", "{0} символ", locales.PluralRuleOne, false); err != nil {
149 return
150 }
151
152 if err = ut.AddCardinal("min-string-character", "{0} символа", locales.PluralRuleFew, false); err != nil {
153 return
154 }
155
156 if err = ut.AddCardinal("min-string-character", "{0} символов", locales.PluralRuleMany, false); err != nil {
157 return
158 }
159
160 if err = ut.AddCardinal("min-string-character", "{0} символы", locales.PluralRuleOther, false); err != nil {
161 return
162 }
163
164 if err = ut.Add("min-number", "{0} должен быть больше или равно {1}", false); err != nil {
165 return
166 }
167
168 if err = ut.Add("min-items", "{0} должен содержать минимум {1}", false); err != nil {
169 return
170 }
171 if err = ut.AddCardinal("min-items-item", "{0} элемент", locales.PluralRuleOne, false); err != nil {
172 return
173 }
174
175 if err = ut.AddCardinal("min-items-item", "{0} элемента", locales.PluralRuleFew, false); err != nil {
176 return
177 }
178
179 if err = ut.AddCardinal("min-items-item", "{0} элементов", locales.PluralRuleMany, false); err != nil {
180 return
181 }
182
183 if err = ut.AddCardinal("min-items-item", "{0} элементы", locales.PluralRuleOther, false); err != nil {
184 return
185 }
186
187 return
188
189 },
190 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
191
192 var err error
193 var t string
194
195 var digits uint64
196 var kind reflect.Kind
197
198 if idx := strings.Index(fe.Param(), "."); idx != -1 {
199 digits = uint64(len(fe.Param()[idx+1:]))
200 }
201
202 f64, err := strconv.ParseFloat(fe.Param(), 64)
203 if err != nil {
204 goto END
205 }
206
207 kind = fe.Kind()
208 if kind == reflect.Ptr {
209 kind = fe.Type().Elem().Kind()
210 }
211
212 switch kind {
213 case reflect.String:
214
215 var c string
216
217 c, err = ut.C("min-string-character", f64, digits, ut.FmtNumber(f64, digits))
218 if err != nil {
219 goto END
220 }
221
222 t, err = ut.T("min-string", fe.Field(), c)
223
224 case reflect.Slice, reflect.Map, reflect.Array:
225 var c string
226
227 c, err = ut.C("min-items-item", f64, digits, ut.FmtNumber(f64, digits))
228 if err != nil {
229 goto END
230 }
231
232 t, err = ut.T("min-items", fe.Field(), c)
233
234 default:
235 t, err = ut.T("min-number", fe.Field(), ut.FmtNumber(f64, digits))
236 }
237
238 END:
239 if err != nil {
240 fmt.Printf("warning: error translating FieldError: %s", err)
241 return fe.(error).Error()
242 }
243
244 return t
245 },
246 },
247 {
248 tag: "max",
249 customRegisFunc: func(ut ut.Translator) (err error) {
250
251 if err = ut.Add("max-string", "{0} должен содержать максимум {1}", false); err != nil {
252 return
253 }
254
255 if err = ut.AddCardinal("max-string-character", "{0} символ", locales.PluralRuleOne, false); err != nil {
256 return
257 }
258
259 if err = ut.AddCardinal("max-string-character", "{0} символа", locales.PluralRuleFew, false); err != nil {
260 return
261 }
262
263 if err = ut.AddCardinal("max-string-character", "{0} символов", locales.PluralRuleMany, false); err != nil {
264 return
265 }
266
267 if err = ut.AddCardinal("max-string-character", "{0} символы", locales.PluralRuleOther, false); err != nil {
268 return
269 }
270
271 if err = ut.Add("max-number", "{0} должен быть меньше или равно {1}", false); err != nil {
272 return
273 }
274
275 if err = ut.Add("max-items", "{0} должен содержать максимум {1}", false); err != nil {
276 return
277 }
278 if err = ut.AddCardinal("max-items-item", "{0} элемент", locales.PluralRuleOne, false); err != nil {
279 return
280 }
281
282 if err = ut.AddCardinal("max-items-item", "{0} элемента", locales.PluralRuleFew, false); err != nil {
283 return
284 }
285
286 if err = ut.AddCardinal("max-items-item", "{0} элементов", locales.PluralRuleMany, false); err != nil {
287 return
288 }
289
290 if err = ut.AddCardinal("max-items-item", "{0} элементы", locales.PluralRuleOther, false); err != nil {
291 return
292 }
293
294 return
295
296 },
297 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
298
299 var err error
300 var t string
301
302 var digits uint64
303 var kind reflect.Kind
304
305 if idx := strings.Index(fe.Param(), "."); idx != -1 {
306 digits = uint64(len(fe.Param()[idx+1:]))
307 }
308
309 f64, err := strconv.ParseFloat(fe.Param(), 64)
310 if err != nil {
311 goto END
312 }
313
314 kind = fe.Kind()
315 if kind == reflect.Ptr {
316 kind = fe.Type().Elem().Kind()
317 }
318
319 switch kind {
320 case reflect.String:
321
322 var c string
323
324 c, err = ut.C("max-string-character", f64, digits, ut.FmtNumber(f64, digits))
325 if err != nil {
326 goto END
327 }
328
329 t, err = ut.T("max-string", fe.Field(), c)
330
331 case reflect.Slice, reflect.Map, reflect.Array:
332 var c string
333
334 c, err = ut.C("max-items-item", f64, digits, ut.FmtNumber(f64, digits))
335 if err != nil {
336 goto END
337 }
338
339 t, err = ut.T("max-items", fe.Field(), c)
340
341 default:
342 t, err = ut.T("max-number", fe.Field(), ut.FmtNumber(f64, digits))
343 }
344
345 END:
346 if err != nil {
347 fmt.Printf("warning: error translating FieldError: %s", err)
348 return fe.(error).Error()
349 }
350
351 return t
352 },
353 },
354 {
355 tag: "eq",
356 translation: "{0} не равен {1}",
357 override: false,
358 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
359
360 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
361 if err != nil {
362 fmt.Printf("warning: error translating FieldError: %#v", fe)
363 return fe.(error).Error()
364 }
365
366 return t
367 },
368 },
369 {
370 tag: "ne",
371 translation: "{0} должен быть не равен {1}",
372 override: false,
373 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
374
375 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
376 if err != nil {
377 fmt.Printf("warning: error translating FieldError: %#v", fe)
378 return fe.(error).Error()
379 }
380
381 return t
382 },
383 },
384 {
385 tag: "lt",
386 customRegisFunc: func(ut ut.Translator) (err error) {
387
388 if err = ut.Add("lt-string", "{0} должен иметь менее {1}", false); err != nil {
389 return
390 }
391
392 if err = ut.AddCardinal("lt-string-character", "{0} символ", locales.PluralRuleOne, false); err != nil {
393 return
394 }
395
396 if err = ut.AddCardinal("lt-string-character", "{0} символов", locales.PluralRuleFew, false); err != nil {
397 return
398 }
399
400 if err = ut.AddCardinal("lt-string-character", "{0} символов", locales.PluralRuleMany, false); err != nil {
401 return
402 }
403
404 if err = ut.AddCardinal("lt-string-character", "{0} символы", locales.PluralRuleOther, false); err != nil {
405 return
406 }
407
408 if err = ut.Add("lt-number", "{0} должен быть менее {1}", false); err != nil {
409 return
410 }
411
412 if err = ut.Add("lt-items", "{0} должен содержать менее {1}", false); err != nil {
413 return
414 }
415
416 if err = ut.AddCardinal("lt-items-item", "{0} элемент", locales.PluralRuleOne, false); err != nil {
417 return
418 }
419
420 if err = ut.AddCardinal("lt-items-item", "{0} элементов", locales.PluralRuleFew, false); err != nil {
421 return
422 }
423
424 if err = ut.AddCardinal("lt-items-item", "{0} элементов", locales.PluralRuleMany, false); err != nil {
425 return
426 }
427
428 if err = ut.AddCardinal("lt-items-item", "{0} элементы", locales.PluralRuleOther, false); err != nil {
429 return
430 }
431
432 if err = ut.Add("lt-datetime", "{0} must be less than the current Date & Time", false); err != nil {
433 return
434 }
435
436 return
437
438 },
439 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
440
441 var err error
442 var t string
443 var f64 float64
444 var digits uint64
445 var kind reflect.Kind
446
447 fn := func() (err error) {
448
449 if idx := strings.Index(fe.Param(), "."); idx != -1 {
450 digits = uint64(len(fe.Param()[idx+1:]))
451 }
452
453 f64, err = strconv.ParseFloat(fe.Param(), 64)
454
455 return
456 }
457
458 kind = fe.Kind()
459 if kind == reflect.Ptr {
460 kind = fe.Type().Elem().Kind()
461 }
462
463 switch kind {
464 case reflect.String:
465
466 var c string
467
468 err = fn()
469 if err != nil {
470 goto END
471 }
472
473 c, err = ut.C("lt-string-character", f64, digits, ut.FmtNumber(f64, digits))
474 if err != nil {
475 goto END
476 }
477
478 t, err = ut.T("lt-string", fe.Field(), c)
479
480 case reflect.Slice, reflect.Map, reflect.Array:
481 var c string
482
483 err = fn()
484 if err != nil {
485 goto END
486 }
487
488 c, err = ut.C("lt-items-item", f64, digits, ut.FmtNumber(f64, digits))
489 if err != nil {
490 goto END
491 }
492
493 t, err = ut.T("lt-items", fe.Field(), c)
494
495 case reflect.Struct:
496 if fe.Type() != reflect.TypeOf(time.Time{}) {
497 err = fmt.Errorf("tag '%s' cannot be used on a struct type", fe.Tag())
498 goto END
499 }
500
501 t, err = ut.T("lt-datetime", fe.Field())
502
503 default:
504 err = fn()
505 if err != nil {
506 goto END
507 }
508
509 t, err = ut.T("lt-number", fe.Field(), ut.FmtNumber(f64, digits))
510 }
511
512 END:
513 if err != nil {
514 fmt.Printf("warning: error translating FieldError: %s", err)
515 return fe.(error).Error()
516 }
517
518 return t
519 },
520 },
521 {
522 tag: "lte",
523 customRegisFunc: func(ut ut.Translator) (err error) {
524
525 if err = ut.Add("lte-string", "{0} должен содержать максимум {1}", false); err != nil {
526 return
527 }
528
529 if err = ut.AddCardinal("lte-string-character", "{0} символ", locales.PluralRuleOne, false); err != nil {
530 return
531 }
532
533 if err = ut.AddCardinal("lte-string-character", "{0} символа", locales.PluralRuleFew, false); err != nil {
534 return
535 }
536
537 if err = ut.AddCardinal("lte-string-character", "{0} символов", locales.PluralRuleMany, false); err != nil {
538 return
539 }
540
541 if err = ut.AddCardinal("lte-string-character", "{0} символы", locales.PluralRuleOther, false); err != nil {
542 return
543 }
544
545 if err = ut.Add("lte-number", "{0} должен быть менее или равен {1}", false); err != nil {
546 return
547 }
548
549 if err = ut.Add("lte-items", "{0} должен содержать максимум {1}", false); err != nil {
550 return
551 }
552
553 if err = ut.AddCardinal("lte-items-item", "{0} элемент", locales.PluralRuleOne, false); err != nil {
554 return
555 }
556
557 if err = ut.AddCardinal("lte-items-item", "{0} элемента", locales.PluralRuleFew, false); err != nil {
558 return
559 }
560
561 if err = ut.AddCardinal("lte-items-item", "{0} элементов", locales.PluralRuleMany, false); err != nil {
562 return
563 }
564
565 if err = ut.AddCardinal("lte-items-item", "{0} элементы", locales.PluralRuleOther, false); err != nil {
566 return
567 }
568
569 if err = ut.Add("lte-datetime", "{0} must be less than or equal to the current Date & Time", false); err != nil {
570 return
571 }
572
573 return
574 },
575 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
576
577 var err error
578 var t string
579 var f64 float64
580 var digits uint64
581 var kind reflect.Kind
582
583 fn := func() (err error) {
584
585 if idx := strings.Index(fe.Param(), "."); idx != -1 {
586 digits = uint64(len(fe.Param()[idx+1:]))
587 }
588
589 f64, err = strconv.ParseFloat(fe.Param(), 64)
590
591 return
592 }
593
594 kind = fe.Kind()
595 if kind == reflect.Ptr {
596 kind = fe.Type().Elem().Kind()
597 }
598
599 switch kind {
600 case reflect.String:
601
602 var c string
603
604 err = fn()
605 if err != nil {
606 goto END
607 }
608
609 c, err = ut.C("lte-string-character", f64, digits, ut.FmtNumber(f64, digits))
610 if err != nil {
611 goto END
612 }
613
614 t, err = ut.T("lte-string", fe.Field(), c)
615
616 case reflect.Slice, reflect.Map, reflect.Array:
617 var c string
618
619 err = fn()
620 if err != nil {
621 goto END
622 }
623
624 c, err = ut.C("lte-items-item", f64, digits, ut.FmtNumber(f64, digits))
625 if err != nil {
626 goto END
627 }
628
629 t, err = ut.T("lte-items", fe.Field(), c)
630
631 case reflect.Struct:
632 if fe.Type() != reflect.TypeOf(time.Time{}) {
633 err = fmt.Errorf("tag '%s' cannot be used on a struct type", fe.Tag())
634 goto END
635 }
636
637 t, err = ut.T("lte-datetime", fe.Field())
638
639 default:
640 err = fn()
641 if err != nil {
642 goto END
643 }
644
645 t, err = ut.T("lte-number", fe.Field(), ut.FmtNumber(f64, digits))
646 }
647
648 END:
649 if err != nil {
650 fmt.Printf("warning: error translating FieldError: %s", err)
651 return fe.(error).Error()
652 }
653
654 return t
655 },
656 },
657 {
658 tag: "gt",
659 customRegisFunc: func(ut ut.Translator) (err error) {
660
661 if err = ut.Add("gt-string", "{0} должен быть длиннее {1}", false); err != nil {
662 return
663 }
664
665 if err = ut.AddCardinal("gt-string-character", "{0} символ", locales.PluralRuleOne, false); err != nil {
666 return
667 }
668
669 if err = ut.AddCardinal("gt-string-character", "{0} символов", locales.PluralRuleFew, false); err != nil {
670 return
671 }
672
673 if err = ut.AddCardinal("gt-string-character", "{0} символов", locales.PluralRuleMany, false); err != nil {
674 return
675 }
676
677 if err = ut.AddCardinal("gt-string-character", "{0} символы", locales.PluralRuleOther, false); err != nil {
678 return
679 }
680
681 if err = ut.Add("gt-number", "{0} должен быть больше {1}", false); err != nil {
682 return
683 }
684
685 if err = ut.Add("gt-items", "{0} должен содержать более {1}", false); err != nil {
686 return
687 }
688
689 if err = ut.AddCardinal("gt-items-item", "{0} элемент", locales.PluralRuleOne, false); err != nil {
690 return
691 }
692
693 if err = ut.AddCardinal("gt-items-item", "{0} элементов", locales.PluralRuleFew, false); err != nil {
694 return
695 }
696
697 if err = ut.AddCardinal("gt-items-item", "{0} элементов", locales.PluralRuleMany, false); err != nil {
698 return
699 }
700
701 if err = ut.AddCardinal("gt-items-item", "{0} элементы", locales.PluralRuleOther, false); err != nil {
702 return
703 }
704
705 if err = ut.Add("gt-datetime", "{0} должна быть позже текущего момента", false); err != nil {
706 return
707 }
708
709 return
710 },
711 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
712
713 var err error
714 var t string
715 var f64 float64
716 var digits uint64
717 var kind reflect.Kind
718
719 fn := func() (err error) {
720
721 if idx := strings.Index(fe.Param(), "."); idx != -1 {
722 digits = uint64(len(fe.Param()[idx+1:]))
723 }
724
725 f64, err = strconv.ParseFloat(fe.Param(), 64)
726
727 return
728 }
729
730 kind = fe.Kind()
731 if kind == reflect.Ptr {
732 kind = fe.Type().Elem().Kind()
733 }
734
735 switch kind {
736 case reflect.String:
737
738 var c string
739
740 err = fn()
741 if err != nil {
742 goto END
743 }
744
745 c, err = ut.C("gt-string-character", f64, digits, ut.FmtNumber(f64, digits))
746 if err != nil {
747 goto END
748 }
749
750 t, err = ut.T("gt-string", fe.Field(), c)
751
752 case reflect.Slice, reflect.Map, reflect.Array:
753 var c string
754
755 err = fn()
756 if err != nil {
757 goto END
758 }
759
760 c, err = ut.C("gt-items-item", f64, digits, ut.FmtNumber(f64, digits))
761 if err != nil {
762 goto END
763 }
764
765 t, err = ut.T("gt-items", fe.Field(), c)
766
767 case reflect.Struct:
768 if fe.Type() != reflect.TypeOf(time.Time{}) {
769 err = fmt.Errorf("tag '%s' cannot be used on a struct type", fe.Tag())
770 goto END
771 }
772
773 t, err = ut.T("gt-datetime", fe.Field())
774
775 default:
776 err = fn()
777 if err != nil {
778 goto END
779 }
780
781 t, err = ut.T("gt-number", fe.Field(), ut.FmtNumber(f64, digits))
782 }
783
784 END:
785 if err != nil {
786 fmt.Printf("warning: error translating FieldError: %s", err)
787 return fe.(error).Error()
788 }
789
790 return t
791 },
792 },
793 {
794 tag: "gte",
795 customRegisFunc: func(ut ut.Translator) (err error) {
796
797 if err = ut.Add("gte-string", "{0} должен содержать минимум {1}", false); err != nil {
798 return
799 }
800
801 if err = ut.AddCardinal("gte-string-character", "{0} символ", locales.PluralRuleOne, false); err != nil {
802 return
803 }
804
805 if err = ut.AddCardinal("gte-string-character", "{0} символа", locales.PluralRuleFew, false); err != nil {
806 return
807 }
808
809 if err = ut.AddCardinal("gte-string-character", "{0} символов", locales.PluralRuleMany, false); err != nil {
810 return
811 }
812
813 if err = ut.AddCardinal("gte-string-character", "{0} символы", locales.PluralRuleOther, false); err != nil {
814 return
815 }
816
817 if err = ut.Add("gte-number", "{0} должен быть больше или равно {1}", false); err != nil {
818 return
819 }
820
821 if err = ut.Add("gte-items", "{0} должен содержать минимум {1}", false); err != nil {
822 return
823 }
824
825 if err = ut.AddCardinal("gte-items-item", "{0} элемент", locales.PluralRuleOne, false); err != nil {
826 return
827 }
828
829 if err = ut.AddCardinal("gte-items-item", "{0} элемента", locales.PluralRuleFew, false); err != nil {
830 return
831 }
832
833 if err = ut.AddCardinal("gte-items-item", "{0} элементов", locales.PluralRuleMany, false); err != nil {
834 return
835 }
836
837 if err = ut.AddCardinal("gte-items-item", "{0} элементы", locales.PluralRuleOther, false); err != nil {
838 return
839 }
840
841 if err = ut.Add("gte-datetime", "{0} должна быть позже или равна текущему моменту", false); err != nil {
842 return
843 }
844
845 return
846 },
847 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
848
849 var err error
850 var t string
851 var f64 float64
852 var digits uint64
853 var kind reflect.Kind
854
855 fn := func() (err error) {
856
857 if idx := strings.Index(fe.Param(), "."); idx != -1 {
858 digits = uint64(len(fe.Param()[idx+1:]))
859 }
860
861 f64, err = strconv.ParseFloat(fe.Param(), 64)
862
863 return
864 }
865
866 kind = fe.Kind()
867 if kind == reflect.Ptr {
868 kind = fe.Type().Elem().Kind()
869 }
870
871 switch kind {
872 case reflect.String:
873
874 var c string
875
876 err = fn()
877 if err != nil {
878 goto END
879 }
880
881 c, err = ut.C("gte-string-character", f64, digits, ut.FmtNumber(f64, digits))
882 if err != nil {
883 goto END
884 }
885
886 t, err = ut.T("gte-string", fe.Field(), c)
887
888 case reflect.Slice, reflect.Map, reflect.Array:
889 var c string
890
891 err = fn()
892 if err != nil {
893 goto END
894 }
895
896 c, err = ut.C("gte-items-item", f64, digits, ut.FmtNumber(f64, digits))
897 if err != nil {
898 goto END
899 }
900
901 t, err = ut.T("gte-items", fe.Field(), c)
902
903 case reflect.Struct:
904 if fe.Type() != reflect.TypeOf(time.Time{}) {
905 err = fmt.Errorf("tag '%s' cannot be used on a struct type", fe.Tag())
906 goto END
907 }
908
909 t, err = ut.T("gte-datetime", fe.Field())
910
911 default:
912 err = fn()
913 if err != nil {
914 goto END
915 }
916
917 t, err = ut.T("gte-number", fe.Field(), ut.FmtNumber(f64, digits))
918 }
919
920 END:
921 if err != nil {
922 fmt.Printf("warning: error translating FieldError: %s", err)
923 return fe.(error).Error()
924 }
925
926 return t
927 },
928 },
929 {
930 tag: "eqfield",
931 translation: "{0} должен быть равен {1}",
932 override: false,
933 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
934
935 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
936 if err != nil {
937 log.Printf("warning: error translating FieldError: %#v", fe)
938 return fe.(error).Error()
939 }
940
941 return t
942 },
943 },
944 {
945 tag: "eqcsfield",
946 translation: "{0} должен быть равен {1}",
947 override: false,
948 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
949
950 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
951 if err != nil {
952 log.Printf("warning: error translating FieldError: %#v", fe)
953 return fe.(error).Error()
954 }
955
956 return t
957 },
958 },
959 {
960 tag: "necsfield",
961 translation: "{0} не должен быть равен {1}",
962 override: false,
963 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
964
965 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
966 if err != nil {
967 log.Printf("warning: error translating FieldError: %#v", fe)
968 return fe.(error).Error()
969 }
970
971 return t
972 },
973 },
974 {
975 tag: "gtcsfield",
976 translation: "{0} должен быть больше {1}",
977 override: false,
978 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
979
980 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
981 if err != nil {
982 log.Printf("warning: error translating FieldError: %#v", fe)
983 return fe.(error).Error()
984 }
985
986 return t
987 },
988 },
989 {
990 tag: "gtecsfield",
991 translation: "{0} должен быть больше или равен {1}",
992 override: false,
993 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
994
995 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
996 if err != nil {
997 log.Printf("warning: error translating FieldError: %#v", fe)
998 return fe.(error).Error()
999 }
1000
1001 return t
1002 },
1003 },
1004 {
1005 tag: "ltcsfield",
1006 translation: "{0} должен быть менее {1}",
1007 override: false,
1008 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1009
1010 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1011 if err != nil {
1012 log.Printf("warning: error translating FieldError: %#v", fe)
1013 return fe.(error).Error()
1014 }
1015
1016 return t
1017 },
1018 },
1019 {
1020 tag: "ltecsfield",
1021 translation: "{0} должен быть менее или равен {1}",
1022 override: false,
1023 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1024
1025 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1026 if err != nil {
1027 log.Printf("warning: error translating FieldError: %#v", fe)
1028 return fe.(error).Error()
1029 }
1030
1031 return t
1032 },
1033 },
1034 {
1035 tag: "nefield",
1036 translation: "{0} не должен быть равен {1}",
1037 override: false,
1038 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1039
1040 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1041 if err != nil {
1042 log.Printf("warning: error translating FieldError: %#v", fe)
1043 return fe.(error).Error()
1044 }
1045
1046 return t
1047 },
1048 },
1049 {
1050 tag: "gtfield",
1051 translation: "{0} должен быть больше {1}",
1052 override: false,
1053 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1054
1055 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1056 if err != nil {
1057 log.Printf("warning: error translating FieldError: %#v", fe)
1058 return fe.(error).Error()
1059 }
1060
1061 return t
1062 },
1063 },
1064 {
1065 tag: "gtefield",
1066 translation: "{0} должен быть больше или равен {1}",
1067 override: false,
1068 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1069
1070 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1071 if err != nil {
1072 log.Printf("warning: error translating FieldError: %#v", fe)
1073 return fe.(error).Error()
1074 }
1075
1076 return t
1077 },
1078 },
1079 {
1080 tag: "ltfield",
1081 translation: "{0} должен быть менее {1}",
1082 override: false,
1083 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1084
1085 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1086 if err != nil {
1087 log.Printf("warning: error translating FieldError: %#v", fe)
1088 return fe.(error).Error()
1089 }
1090
1091 return t
1092 },
1093 },
1094 {
1095 tag: "ltefield",
1096 translation: "{0} должен быть менее или равен {1}",
1097 override: false,
1098 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1099
1100 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1101 if err != nil {
1102 log.Printf("warning: error translating FieldError: %#v", fe)
1103 return fe.(error).Error()
1104 }
1105
1106 return t
1107 },
1108 },
1109 {
1110 tag: "alpha",
1111 translation: "{0} должен содержать только буквы",
1112 override: false,
1113 },
1114 {
1115 tag: "alphanum",
1116 translation: "{0} должен содержать только буквы и цифры",
1117 override: false,
1118 },
1119 {
1120 tag: "numeric",
1121 translation: "{0} должен быть цифровым значением",
1122 override: false,
1123 },
1124 {
1125 tag: "number",
1126 translation: "{0} должен быть цифрой",
1127 override: false,
1128 },
1129 {
1130 tag: "hexadecimal",
1131 translation: "{0} должен быть шестнадцатеричной строкой",
1132 override: false,
1133 },
1134 {
1135 tag: "hexcolor",
1136 translation: "{0} должен быть HEX цветом",
1137 override: false,
1138 },
1139 {
1140 tag: "rgb",
1141 translation: "{0} должен быть RGB цветом",
1142 override: false,
1143 },
1144 {
1145 tag: "rgba",
1146 translation: "{0} должен быть RGBA цветом",
1147 override: false,
1148 },
1149 {
1150 tag: "hsl",
1151 translation: "{0} должен быть HSL цветом",
1152 override: false,
1153 },
1154 {
1155 tag: "hsla",
1156 translation: "{0} должен быть HSLA цветом",
1157 override: false,
1158 },
1159 {
1160 tag: "e164",
1161 translation: "{0} должен быть E.164 formatted phone number",
1162 override: false,
1163 },
1164 {
1165 tag: "email",
1166 translation: "{0} должен быть email адресом",
1167 override: false,
1168 },
1169 {
1170 tag: "url",
1171 translation: "{0} должен быть URL",
1172 override: false,
1173 },
1174 {
1175 tag: "uri",
1176 translation: "{0} должен быть URI",
1177 override: false,
1178 },
1179 {
1180 tag: "base64",
1181 translation: "{0} должен быть Base64 строкой",
1182 override: false,
1183 },
1184 {
1185 tag: "contains",
1186 translation: "{0} должен содержать текст '{1}'",
1187 override: false,
1188 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1189
1190 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1191 if err != nil {
1192 log.Printf("warning: error translating FieldError: %#v", fe)
1193 return fe.(error).Error()
1194 }
1195
1196 return t
1197 },
1198 },
1199 {
1200 tag: "containsany",
1201 translation: "{0} должен содержать минимум один из символов '{1}'",
1202 override: false,
1203 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1204
1205 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1206 if err != nil {
1207 log.Printf("warning: error translating FieldError: %#v", fe)
1208 return fe.(error).Error()
1209 }
1210
1211 return t
1212 },
1213 },
1214 {
1215 tag: "excludes",
1216 translation: "{0} не должен содержать текст '{1}'",
1217 override: false,
1218 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1219
1220 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1221 if err != nil {
1222 log.Printf("warning: error translating FieldError: %#v", fe)
1223 return fe.(error).Error()
1224 }
1225
1226 return t
1227 },
1228 },
1229 {
1230 tag: "excludesall",
1231 translation: "{0} не должен содержать символы '{1}'",
1232 override: false,
1233 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1234
1235 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1236 if err != nil {
1237 log.Printf("warning: error translating FieldError: %#v", fe)
1238 return fe.(error).Error()
1239 }
1240
1241 return t
1242 },
1243 },
1244 {
1245 tag: "excludesrune",
1246 translation: "{0} не должен содержать '{1}'",
1247 override: false,
1248 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1249
1250 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1251 if err != nil {
1252 log.Printf("warning: error translating FieldError: %#v", fe)
1253 return fe.(error).Error()
1254 }
1255
1256 return t
1257 },
1258 },
1259 {
1260 tag: "isbn",
1261 translation: "{0} должен быть ISBN номером",
1262 override: false,
1263 },
1264 {
1265 tag: "isbn10",
1266 translation: "{0} должен быть ISBN-10 номером",
1267 override: false,
1268 },
1269 {
1270 tag: "isbn13",
1271 translation: "{0} должен быть ISBN-13 номером",
1272 override: false,
1273 },
1274 {
1275 tag: "issn",
1276 translation: "{0} должен быть ISSN номером",
1277 override: false,
1278 },
1279 {
1280 tag: "uuid",
1281 translation: "{0} должен быть UUID",
1282 override: false,
1283 },
1284 {
1285 tag: "uuid3",
1286 translation: "{0} должен быть UUID 3 версии",
1287 override: false,
1288 },
1289 {
1290 tag: "uuid4",
1291 translation: "{0} должен быть UUID 4 версии",
1292 override: false,
1293 },
1294 {
1295 tag: "uuid5",
1296 translation: "{0} должен быть UUID 5 версии",
1297 override: false,
1298 },
1299 {
1300 tag: "ulid",
1301 translation: "{0} должен быть ULID",
1302 override: false,
1303 },
1304 {
1305 tag: "ascii",
1306 translation: "{0} должен содержать только ascii символы",
1307 override: false,
1308 },
1309 {
1310 tag: "printascii",
1311 translation: "{0} должен содержать только доступные для печати ascii символы",
1312 override: false,
1313 },
1314 {
1315 tag: "multibyte",
1316 translation: "{0} должен содержать мультибайтные символы",
1317 override: false,
1318 },
1319 {
1320 tag: "datauri",
1321 translation: "{0} должен содержать Data URI",
1322 override: false,
1323 },
1324 {
1325 tag: "latitude",
1326 translation: "{0} должен содержать координаты широты",
1327 override: false,
1328 },
1329 {
1330 tag: "longitude",
1331 translation: "{0} должен содержать координаты долготы",
1332 override: false,
1333 },
1334 {
1335 tag: "ssn",
1336 translation: "{0} должен быть SSN номером",
1337 override: false,
1338 },
1339 {
1340 tag: "ipv4",
1341 translation: "{0} должен быть IPv4 адресом",
1342 override: false,
1343 },
1344 {
1345 tag: "ipv6",
1346 translation: "{0} должен быть IPv6 адресом",
1347 override: false,
1348 },
1349 {
1350 tag: "ip",
1351 translation: "{0} должен быть IP адресом",
1352 override: false,
1353 },
1354 {
1355 tag: "cidr",
1356 translation: "{0} должен содержать CIDR обозначения",
1357 override: false,
1358 },
1359 {
1360 tag: "cidrv4",
1361 translation: "{0} должен содержать CIDR обозначения для IPv4 адреса",
1362 override: false,
1363 },
1364 {
1365 tag: "cidrv6",
1366 translation: "{0} должен содержать CIDR обозначения для IPv6 адреса",
1367 override: false,
1368 },
1369 {
1370 tag: "tcp_addr",
1371 translation: "{0} должен быть TCP адресом",
1372 override: false,
1373 },
1374 {
1375 tag: "tcp4_addr",
1376 translation: "{0} должен быть IPv4 TCP адресом",
1377 override: false,
1378 },
1379 {
1380 tag: "tcp6_addr",
1381 translation: "{0} должен быть IPv6 TCP адресом",
1382 override: false,
1383 },
1384 {
1385 tag: "udp_addr",
1386 translation: "{0} должен быть UDP адресом",
1387 override: false,
1388 },
1389 {
1390 tag: "udp4_addr",
1391 translation: "{0} должен быть IPv4 UDP адресом",
1392 override: false,
1393 },
1394 {
1395 tag: "udp6_addr",
1396 translation: "{0} должен быть IPv6 UDP адресом",
1397 override: false,
1398 },
1399 {
1400 tag: "ip_addr",
1401 translation: "{0} должен быть распознаваемым IP адресом",
1402 override: false,
1403 },
1404 {
1405 tag: "ip4_addr",
1406 translation: "{0} должен быть распознаваемым IPv4 адресом",
1407 override: false,
1408 },
1409 {
1410 tag: "ip6_addr",
1411 translation: "{0} должен быть распознаваемым IPv6 адресом",
1412 override: false,
1413 },
1414 {
1415 tag: "unix_addr",
1416 translation: "{0} должен быть распознаваемым UNIX адресом",
1417 override: false,
1418 },
1419 {
1420 tag: "mac",
1421 translation: "{0} должен содержать MAC адрес",
1422 override: false,
1423 },
1424 {
1425 tag: "unique",
1426 translation: "{0} должен содержать уникальные значения",
1427 override: false,
1428 },
1429 {
1430 tag: "iscolor",
1431 translation: "{0} должен быть цветом",
1432 override: false,
1433 },
1434 {
1435 tag: "oneof",
1436 translation: "{0} должен быть одним из [{1}]",
1437 override: false,
1438 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1439 s, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1440 if err != nil {
1441 log.Printf("warning: error translating FieldError: %#v", fe)
1442 return fe.(error).Error()
1443 }
1444 return s
1445 },
1446 },
1447 {
1448 tag: "image",
1449 translation: "{0} должно быть допустимым изображением",
1450 override: false,
1451 },
1452 }
1453
1454 for _, t := range translations {
1455
1456 if t.customTransFunc != nil && t.customRegisFunc != nil {
1457
1458 err = v.RegisterTranslation(t.tag, trans, t.customRegisFunc, t.customTransFunc)
1459
1460 } else if t.customTransFunc != nil && t.customRegisFunc == nil {
1461
1462 err = v.RegisterTranslation(t.tag, trans, registrationFunc(t.tag, t.translation, t.override), t.customTransFunc)
1463
1464 } else if t.customTransFunc == nil && t.customRegisFunc != nil {
1465
1466 err = v.RegisterTranslation(t.tag, trans, t.customRegisFunc, translateFunc)
1467
1468 } else {
1469 err = v.RegisterTranslation(t.tag, trans, registrationFunc(t.tag, t.translation, t.override), translateFunc)
1470 }
1471
1472 if err != nil {
1473 return
1474 }
1475 }
1476
1477 return
1478 }
1479
1480 func registrationFunc(tag string, translation string, override bool) validator.RegisterTranslationsFunc {
1481
1482 return func(ut ut.Translator) (err error) {
1483
1484 if err = ut.Add(tag, translation, override); err != nil {
1485 return
1486 }
1487
1488 return
1489
1490 }
1491
1492 }
1493
1494 func translateFunc(ut ut.Translator, fe validator.FieldError) string {
1495
1496 t, err := ut.T(fe.Tag(), fe.Field())
1497 if err != nil {
1498 log.Printf("warning: error translating FieldError: %#v", fe)
1499 return fe.(error).Error()
1500 }
1501
1502 return t
1503 }
1504
View as plain text