1 package it
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 translations := []struct {
20 tag string
21 translation string
22 override bool
23 customRegisFunc validator.RegisterTranslationsFunc
24 customTransFunc validator.TranslationFunc
25 }{
26 {
27 tag: "required",
28 translation: "{0} è un campo obbligatorio",
29 override: false,
30 },
31 {
32 tag: "required_without",
33 translation: "{0} è un campo obbligatorio",
34 override: false,
35 },
36 {
37 tag: "len",
38 customRegisFunc: func(ut ut.Translator) (err error) {
39 if err = ut.Add("len-string", "{0} deve essere lungo {1}", false); err != nil {
40 return
41 }
42
43 if err = ut.AddCardinal("len-string-character", "{0} carattere", locales.PluralRuleOne, false); err != nil {
44 return
45 }
46
47 if err = ut.AddCardinal("len-string-character", "{0} caratteri", locales.PluralRuleOther, false); err != nil {
48 return
49 }
50
51 if err = ut.Add("len-number", "{0} deve essere uguale a {1}", false); err != nil {
52 return
53 }
54
55 if err = ut.Add("len-items", "{0} deve contenere {1}", false); err != nil {
56 return
57 }
58 if err = ut.AddCardinal("len-items-item", "{0} elemento", locales.PluralRuleOne, false); err != nil {
59 return
60 }
61
62 if err = ut.AddCardinal("len-items-item", "{0} elementi", locales.PluralRuleOther, false); err != nil {
63 return
64 }
65
66 return
67 },
68 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
69 var err error
70 var t string
71
72 var digits uint64
73 var kind reflect.Kind
74
75 if idx := strings.Index(fe.Param(), "."); idx != -1 {
76 digits = uint64(len(fe.Param()[idx+1:]))
77 }
78
79 f64, err := strconv.ParseFloat(fe.Param(), 64)
80 if err != nil {
81 goto END
82 }
83
84 kind = fe.Kind()
85 if kind == reflect.Ptr {
86 kind = fe.Type().Elem().Kind()
87 }
88
89 switch kind {
90 case reflect.String:
91
92 var c string
93
94 c, err = ut.C("len-string-character", f64, digits, ut.FmtNumber(f64, digits))
95 if err != nil {
96 goto END
97 }
98
99 t, err = ut.T("len-string", fe.Field(), c)
100
101 case reflect.Slice, reflect.Map, reflect.Array:
102 var c string
103
104 c, err = ut.C("len-items-item", f64, digits, ut.FmtNumber(f64, digits))
105 if err != nil {
106 goto END
107 }
108
109 t, err = ut.T("len-items", fe.Field(), c)
110
111 default:
112 t, err = ut.T("len-number", fe.Field(), ut.FmtNumber(f64, digits))
113 }
114
115 END:
116 if err != nil {
117 fmt.Printf("warning: error translating FieldError: %s", err)
118 return fe.(error).Error()
119 }
120
121 return t
122 },
123 },
124 {
125 tag: "min",
126 customRegisFunc: func(ut ut.Translator) (err error) {
127
128 if err = ut.Add("min-string", "{0} deve essere lungo almeno {1}", false); err != nil {
129 return
130 }
131
132 if err = ut.AddCardinal("min-string-character", "{0} carattere", locales.PluralRuleOne, false); err != nil {
133 return
134 }
135
136 if err = ut.AddCardinal("min-string-character", "{0} caratteri", locales.PluralRuleOther, false); err != nil {
137 return
138 }
139
140 if err = ut.Add("min-number", "{0} deve essere maggiore o uguale a {1}", false); err != nil {
141 return
142 }
143
144 if err = ut.Add("min-items", "{0} deve contenere almeno {1}", false); err != nil {
145 return
146 }
147 if err = ut.AddCardinal("min-items-item", "{0} elemento", locales.PluralRuleOne, false); err != nil {
148 return
149 }
150
151 if err = ut.AddCardinal("min-items-item", "{0} elementi", locales.PluralRuleOther, false); err != nil {
152 return
153 }
154
155 return
156 },
157 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
158 var err error
159
160 var t string
161
162 var digits uint64
163 var kind reflect.Kind
164
165 if idx := strings.Index(fe.Param(), "."); idx != -1 {
166 digits = uint64(len(fe.Param()[idx+1:]))
167 }
168
169 f64, err := strconv.ParseFloat(fe.Param(), 64)
170 if err != nil {
171 goto END
172 }
173
174 kind = fe.Kind()
175 if kind == reflect.Ptr {
176 kind = fe.Type().Elem().Kind()
177 }
178
179 switch kind {
180 case reflect.String:
181
182 var c string
183
184 c, err = ut.C("min-string-character", f64, digits, ut.FmtNumber(f64, digits))
185 if err != nil {
186 goto END
187 }
188
189 t, err = ut.T("min-string", fe.Field(), c)
190
191 case reflect.Slice, reflect.Map, reflect.Array:
192 var c string
193
194 c, err = ut.C("min-items-item", f64, digits, ut.FmtNumber(f64, digits))
195 if err != nil {
196 goto END
197 }
198
199 t, err = ut.T("min-items", fe.Field(), c)
200
201 default:
202 t, err = ut.T("min-number", fe.Field(), ut.FmtNumber(f64, digits))
203 }
204
205 END:
206 if err != nil {
207 fmt.Printf("warning: error translating FieldError: %s", err)
208 return fe.(error).Error()
209 }
210
211 return t
212 },
213 },
214 {
215 tag: "max",
216 customRegisFunc: func(ut ut.Translator) (err error) {
217 if err = ut.Add("max-string", "{0} deve essere lungo al massimo {1}", false); err != nil {
218 return
219 }
220
221 if err = ut.AddCardinal("max-string-character", "{0} carattere", locales.PluralRuleOne, false); err != nil {
222 return
223 }
224
225 if err = ut.AddCardinal("max-string-character", "{0} caratteri", locales.PluralRuleOther, false); err != nil {
226 return
227 }
228
229 if err = ut.Add("max-number", "{0} deve essere minore o uguale a {1}", false); err != nil {
230 return
231 }
232
233 if err = ut.Add("max-items", "{0} deve contenere al massimo {1}", false); err != nil {
234 return
235 }
236 if err = ut.AddCardinal("max-items-item", "{0} elemento", locales.PluralRuleOne, false); err != nil {
237 return
238 }
239
240 if err = ut.AddCardinal("max-items-item", "{0} elementi", locales.PluralRuleOther, false); err != nil {
241 return
242 }
243
244 return
245 },
246 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
247 var err error
248 var t string
249
250 var digits uint64
251 var kind reflect.Kind
252
253 if idx := strings.Index(fe.Param(), "."); idx != -1 {
254 digits = uint64(len(fe.Param()[idx+1:]))
255 }
256
257 f64, err := strconv.ParseFloat(fe.Param(), 64)
258 if err != nil {
259 goto END
260 }
261
262 kind = fe.Kind()
263 if kind == reflect.Ptr {
264 kind = fe.Type().Elem().Kind()
265 }
266
267 switch kind {
268 case reflect.String:
269
270 var c string
271
272 c, err = ut.C("max-string-character", f64, digits, ut.FmtNumber(f64, digits))
273 if err != nil {
274 goto END
275 }
276
277 t, err = ut.T("max-string", fe.Field(), c)
278
279 case reflect.Slice, reflect.Map, reflect.Array:
280 var c string
281
282 c, err = ut.C("max-items-item", f64, digits, ut.FmtNumber(f64, digits))
283 if err != nil {
284 goto END
285 }
286
287 t, err = ut.T("max-items", fe.Field(), c)
288
289 default:
290 t, err = ut.T("max-number", fe.Field(), ut.FmtNumber(f64, digits))
291 }
292
293 END:
294 if err != nil {
295 fmt.Printf("warning: error translating FieldError: %s", err)
296 return fe.(error).Error()
297 }
298
299 return t
300 },
301 },
302 {
303 tag: "eq",
304 translation: "{0} non è uguale a {1}",
305 override: false,
306 customTransFunc: customTransFuncV1,
307 },
308 {
309 tag: "ne",
310 translation: "{0} deve essere diverso da {1}",
311 override: false,
312 customTransFunc: customTransFuncV1,
313 },
314 {
315 tag: "lt",
316 customRegisFunc: func(ut ut.Translator) (err error) {
317 if err = ut.Add("lt-string", "{0} deve essere lungo meno di {1}", false); err != nil {
318 return
319 }
320
321 if err = ut.AddCardinal("lt-string-character", "{0} carattere", locales.PluralRuleOne, false); err != nil {
322 return
323 }
324
325 if err = ut.AddCardinal("lt-string-character", "{0} caratteri", locales.PluralRuleOther, false); err != nil {
326 return
327 }
328
329 if err = ut.Add("lt-number", "{0} deve essere minore di {1}", false); err != nil {
330
331 return
332 }
333
334 if err = ut.Add("lt-items", "{0} deve contenere meno di {1}", false); err != nil {
335 return
336 }
337
338 if err = ut.AddCardinal("lt-items-item", "{0} elemento", locales.PluralRuleOne, false); err != nil {
339 return
340 }
341
342 if err = ut.AddCardinal("lt-items-item", "{0} elementi", locales.PluralRuleOther, false); err != nil {
343 return
344 }
345
346 if err = ut.Add("lt-datetime", "{0} deve essere precedente alla Data/Ora corrente", false); err != nil {
347 return
348 }
349
350 return
351 },
352 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
353 var err error
354 var t string
355 var f64 float64
356 var digits uint64
357 var kind reflect.Kind
358
359 fn := func() (err error) {
360 if idx := strings.Index(fe.Param(), "."); idx != -1 {
361 digits = uint64(len(fe.Param()[idx+1:]))
362 }
363
364 f64, err = strconv.ParseFloat(fe.Param(), 64)
365
366 return
367 }
368
369 kind = fe.Kind()
370 if kind == reflect.Ptr {
371 kind = fe.Type().Elem().Kind()
372 }
373
374 switch kind {
375 case reflect.String:
376
377 var c string
378
379 err = fn()
380 if err != nil {
381 goto END
382 }
383
384 c, err = ut.C("lt-string-character", f64, digits, ut.FmtNumber(f64, digits))
385 if err != nil {
386 goto END
387 }
388
389 t, err = ut.T("lt-string", fe.Field(), c)
390
391 case reflect.Slice, reflect.Map, reflect.Array:
392 var c string
393
394 err = fn()
395 if err != nil {
396 goto END
397 }
398
399 c, err = ut.C("lt-items-item", f64, digits, ut.FmtNumber(f64, digits))
400 if err != nil {
401 goto END
402 }
403
404 t, err = ut.T("lt-items", fe.Field(), c)
405
406 case reflect.Struct:
407 if fe.Type() != reflect.TypeOf(time.Time{}) {
408 err = fmt.Errorf("tag '%s' cannot be used on a struct type", fe.Tag())
409 goto END
410 }
411
412 t, err = ut.T("lt-datetime", fe.Field())
413
414 default:
415 err = fn()
416 if err != nil {
417 goto END
418 }
419
420 t, err = ut.T("lt-number", fe.Field(), ut.FmtNumber(f64, digits))
421 }
422
423 END:
424 if err != nil {
425 fmt.Printf("warning: error translating FieldError: %s", err)
426 return fe.(error).Error()
427 }
428
429 return t
430 },
431 },
432 {
433 tag: "lte",
434 customRegisFunc: func(ut ut.Translator) (err error) {
435
436 if err = ut.Add("lte-string", "{0} deve essere lungo al massimo {1}", false); err != nil {
437 return
438 }
439
440 if err = ut.AddCardinal("lte-string-character", "{0} carattere", locales.PluralRuleOne, false); err != nil {
441 return
442 }
443
444 if err = ut.AddCardinal("lte-string-character", "{0} caratteri", locales.PluralRuleOther, false); err != nil {
445 return
446 }
447
448 if err = ut.Add("lte-number", "{0} deve essere minore o uguale a {1}", false); err != nil {
449 return
450 }
451
452 if err = ut.Add("lte-items", "{0} deve contenere al massimo {1}", false); err != nil {
453 return
454 }
455
456 if err = ut.AddCardinal("lte-items-item", "{0} elemento", locales.PluralRuleOne, false); err != nil {
457 return
458 }
459
460 if err = ut.AddCardinal("lte-items-item", "{0} elementi", locales.PluralRuleOther, false); err != nil {
461 return
462 }
463
464 if err = ut.Add("lte-datetime", "{0} deve essere uguale o precedente alla Data/Ora corrente", false); err != nil {
465 return
466 }
467
468 return
469 },
470 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
471
472 var err error
473 var t string
474 var f64 float64
475 var digits uint64
476 var kind reflect.Kind
477
478 fn := func() (err error) {
479 if idx := strings.Index(fe.Param(), "."); idx != -1 {
480 digits = uint64(len(fe.Param()[idx+1:]))
481 }
482
483 f64, err = strconv.ParseFloat(fe.Param(), 64)
484
485 return
486 }
487
488 kind = fe.Kind()
489 if kind == reflect.Ptr {
490 kind = fe.Type().Elem().Kind()
491 }
492
493 switch kind {
494 case reflect.String:
495
496 var c string
497
498 err = fn()
499 if err != nil {
500 goto END
501 }
502
503 c, err = ut.C("lte-string-character", f64, digits, ut.FmtNumber(f64, digits))
504 if err != nil {
505 goto END
506 }
507
508 t, err = ut.T("lte-string", fe.Field(), c)
509
510 case reflect.Slice, reflect.Map, reflect.Array:
511 var c string
512
513 err = fn()
514 if err != nil {
515 goto END
516 }
517
518 c, err = ut.C("lte-items-item", f64, digits, ut.FmtNumber(f64, digits))
519 if err != nil {
520 goto END
521 }
522
523 t, err = ut.T("lte-items", fe.Field(), c)
524
525 case reflect.Struct:
526 if fe.Type() != reflect.TypeOf(time.Time{}) {
527 err = fmt.Errorf("tag '%s' cannot be used on a struct type", fe.Tag())
528 goto END
529 }
530
531 t, err = ut.T("lte-datetime", fe.Field())
532
533 default:
534 err = fn()
535 if err != nil {
536 goto END
537 }
538
539 t, err = ut.T("lte-number", fe.Field(), ut.FmtNumber(f64, digits))
540 }
541
542 END:
543 if err != nil {
544 fmt.Printf("warning: error translating FieldError: %s", err)
545 return fe.(error).Error()
546 }
547
548 return t
549 },
550 },
551 {
552 tag: "gt",
553 customRegisFunc: func(ut ut.Translator) (err error) {
554
555 if err = ut.Add("gt-string", "{0} deve essere lungo più di {1}", false); err != nil {
556 return
557 }
558
559 if err = ut.AddCardinal("gt-string-character", "{0} carattere", locales.PluralRuleOne, false); err != nil {
560 return
561 }
562
563 if err = ut.AddCardinal("gt-string-character", "{0} caratteri", locales.PluralRuleOther, false); err != nil {
564 return
565 }
566
567 if err = ut.Add("gt-number", "{0} deve essere maggiore di {1}", false); err != nil {
568 return
569 }
570
571 if err = ut.Add("gt-items", "{0} deve contenere più di {1}", false); err != nil {
572 return
573 }
574
575 if err = ut.AddCardinal("gt-items-item", "{0} elemento", locales.PluralRuleOne, false); err != nil {
576 return
577 }
578
579 if err = ut.AddCardinal("gt-items-item", "{0} elementi", locales.PluralRuleOther, false); err != nil {
580 return
581 }
582
583 if err = ut.Add("gt-datetime", "{0} deve essere successivo alla Data/Ora corrente", false); err != nil {
584 return
585 }
586
587 return
588 },
589 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
590
591 var err error
592 var t string
593 var f64 float64
594 var digits uint64
595 var kind reflect.Kind
596
597 fn := func() (err error) {
598 if idx := strings.Index(fe.Param(), "."); idx != -1 {
599 digits = uint64(len(fe.Param()[idx+1:]))
600 }
601
602 f64, err = strconv.ParseFloat(fe.Param(), 64)
603
604 return
605 }
606
607 kind = fe.Kind()
608 if kind == reflect.Ptr {
609 kind = fe.Type().Elem().Kind()
610 }
611
612 switch kind {
613 case reflect.String:
614
615 var c string
616
617 err = fn()
618 if err != nil {
619 goto END
620 }
621
622 c, err = ut.C("gt-string-character", f64, digits, ut.FmtNumber(f64, digits))
623 if err != nil {
624 goto END
625 }
626
627 t, err = ut.T("gt-string", fe.Field(), c)
628
629 case reflect.Slice, reflect.Map, reflect.Array:
630 var c string
631
632 err = fn()
633 if err != nil {
634 goto END
635 }
636
637 c, err = ut.C("gt-items-item", f64, digits, ut.FmtNumber(f64, digits))
638 if err != nil {
639 goto END
640 }
641
642 t, err = ut.T("gt-items", fe.Field(), c)
643
644 case reflect.Struct:
645 if fe.Type() != reflect.TypeOf(time.Time{}) {
646 err = fmt.Errorf("tag '%s' cannot be used on a struct type", fe.Tag())
647 goto END
648 }
649
650 t, err = ut.T("gt-datetime", fe.Field())
651
652 default:
653 err = fn()
654 if err != nil {
655 goto END
656 }
657
658 t, err = ut.T("gt-number", fe.Field(), ut.FmtNumber(f64, digits))
659 }
660
661 END:
662 if err != nil {
663 fmt.Printf("warning: error translating FieldError: %s", err)
664 return fe.(error).Error()
665 }
666
667 return t
668 },
669 },
670 {
671 tag: "gte",
672 customRegisFunc: func(ut ut.Translator) (err error) {
673 if err = ut.Add("gte-string", "{0} deve essere lungo almeno {1}", false); err != nil {
674 return
675 }
676
677 if err = ut.AddCardinal("gte-string-character", "{0} carattere", locales.PluralRuleOne, false); err != nil {
678 return
679 }
680
681 if err = ut.AddCardinal("gte-string-character", "{0} caratteri", locales.PluralRuleOther, false); err != nil {
682 return
683 }
684
685 if err = ut.Add("gte-number", "{0} deve essere maggiore o uguale a {1}", false); err != nil {
686 return
687 }
688
689 if err = ut.Add("gte-items", "{0} deve contenere almeno {1}", false); err != nil {
690 return
691 }
692
693 if err = ut.AddCardinal("gte-items-item", "{0} elemento", locales.PluralRuleOne, false); err != nil {
694 return
695 }
696
697 if err = ut.AddCardinal("gte-items-item", "{0} elementi", locales.PluralRuleOther, false); err != nil {
698 return
699 }
700
701 if err = ut.Add("gte-datetime", "{0} deve essere uguale o successivo alla Data/Ora corrente", false); err != nil {
702 return
703 }
704
705 return
706 },
707 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
708
709 var err error
710 var t string
711 var f64 float64
712 var digits uint64
713 var kind reflect.Kind
714
715 fn := func() (err error) {
716 if idx := strings.Index(fe.Param(), "."); idx != -1 {
717 digits = uint64(len(fe.Param()[idx+1:]))
718 }
719
720 f64, err = strconv.ParseFloat(fe.Param(), 64)
721
722 return
723 }
724
725 kind = fe.Kind()
726 if kind == reflect.Ptr {
727 kind = fe.Type().Elem().Kind()
728 }
729
730 switch kind {
731 case reflect.String:
732
733 var c string
734
735 err = fn()
736 if err != nil {
737 goto END
738 }
739
740 c, err = ut.C("gte-string-character", f64, digits, ut.FmtNumber(f64, digits))
741 if err != nil {
742 goto END
743 }
744
745 t, err = ut.T("gte-string", fe.Field(), c)
746
747 case reflect.Slice, reflect.Map, reflect.Array:
748 var c string
749
750 err = fn()
751 if err != nil {
752 goto END
753 }
754
755 c, err = ut.C("gte-items-item", f64, digits, ut.FmtNumber(f64, digits))
756 if err != nil {
757 goto END
758 }
759
760 t, err = ut.T("gte-items", fe.Field(), c)
761
762 case reflect.Struct:
763 if fe.Type() != reflect.TypeOf(time.Time{}) {
764 err = fmt.Errorf("tag '%s' cannot be used on a struct type", fe.Tag())
765 goto END
766 }
767
768 t, err = ut.T("gte-datetime", fe.Field())
769
770 default:
771 err = fn()
772 if err != nil {
773 goto END
774 }
775
776 t, err = ut.T("gte-number", fe.Field(), ut.FmtNumber(f64, digits))
777 }
778
779 END:
780 if err != nil {
781 fmt.Printf("warning: error translating FieldError: %s", err)
782 return fe.(error).Error()
783 }
784
785 return t
786 },
787 },
788 {
789 tag: "eqfield",
790 translation: "{0} deve essere uguale a {1}",
791 override: false,
792 customTransFunc: customTransFuncV1,
793 },
794 {
795 tag: "eqcsfield",
796 translation: "{0} deve essere uguale a {1}",
797 override: false,
798 customTransFunc: customTransFuncV1,
799 },
800 {
801 tag: "necsfield",
802 translation: "{0} deve essere diverso da {1}",
803 override: false,
804 customTransFunc: customTransFuncV1,
805 },
806 {
807 tag: "gtcsfield",
808 translation: "{0} deve essere maggiore di {1}",
809 override: false,
810 customTransFunc: customTransFuncV1,
811 },
812 {
813 tag: "gtecsfield",
814 translation: "{0} deve essere maggiore o uguale a {1}",
815 override: false,
816 customTransFunc: customTransFuncV1,
817 },
818 {
819 tag: "ltcsfield",
820 translation: "{0} deve essere minore di {1}",
821 override: false,
822 customTransFunc: customTransFuncV1,
823 },
824 {
825 tag: "ltecsfield",
826 translation: "{0} deve essere minore o uguale a {1}",
827 override: false,
828 customTransFunc: customTransFuncV1,
829 },
830 {
831 tag: "nefield",
832 translation: "{0} deve essere diverso da {1}",
833 override: false,
834 customTransFunc: customTransFuncV1,
835 },
836 {
837 tag: "gtfield",
838 translation: "{0} deve essere maggiore di {1}",
839 override: false,
840 customTransFunc: customTransFuncV1,
841 },
842 {
843 tag: "gtefield",
844 translation: "{0} deve essere maggiore o uguale a {1}",
845 override: false,
846 customTransFunc: customTransFuncV1,
847 },
848 {
849 tag: "ltfield",
850 translation: "{0} deve essere minore di {1}",
851 override: false,
852 customTransFunc: customTransFuncV1,
853 },
854 {
855 tag: "ltefield",
856 translation: "{0} deve essere minore o uguale a {1}",
857 override: false,
858 customTransFunc: customTransFuncV1,
859 },
860 {
861 tag: "alpha",
862 translation: "{0} può contenere solo caratteri alfabetici",
863 override: false,
864 },
865 {
866 tag: "alphanum",
867 translation: "{0} può contenere solo caratteri alfanumerici",
868 override: false,
869 },
870 {
871 tag: "numeric",
872 translation: "{0} deve essere un valore numerico valido",
873 override: false,
874 },
875 {
876 tag: "number",
877 translation: "{0} deve essere un numero valido",
878 override: false,
879 },
880 {
881 tag: "hexadecimal",
882 translation: "{0} deve essere un esadecimale valido",
883 override: false,
884 },
885 {
886 tag: "hexcolor",
887 translation: "{0} deve essere un colore HEX valido",
888 override: false,
889 },
890 {
891 tag: "rgb",
892 translation: "{0} deve essere un colore RGB valido",
893 override: false,
894 },
895 {
896 tag: "rgba",
897 translation: "{0} deve essere un colore RGBA valido",
898 override: false,
899 },
900 {
901 tag: "hsl",
902 translation: "{0} deve essere un colore HSL valido",
903 override: false,
904 },
905 {
906 tag: "hsla",
907 translation: "{0} deve essere un colore HSLA valido",
908 override: false,
909 },
910 {
911 tag: "e164",
912 translation: "{0} deve essere un numero telefonico in formato E.164 valido",
913 override: false,
914 },
915 {
916 tag: "email",
917 translation: "{0} deve essere un indirizzo email valido",
918 override: false,
919 },
920 {
921 tag: "url",
922 translation: "{0} deve essere un URL valido",
923 override: false,
924 },
925 {
926 tag: "uri",
927 translation: "{0} deve essere un URI valido",
928 override: false,
929 },
930 {
931 tag: "base64",
932 translation: "{0} deve essere una stringa Base64 valida",
933 override: false,
934 },
935 {
936 tag: "contains",
937 translation: "{0} deve contenere il testo '{1}'",
938 override: false,
939 customTransFunc: customTransFuncV1,
940 },
941 {
942 tag: "containsany",
943 translation: "{0} deve contenere almeno uno dei seguenti caratteri '{1}'",
944 override: false,
945 customTransFunc: customTransFuncV1,
946 },
947 {
948 tag: "excludes",
949 translation: "{0} non deve contenere il testo '{1}'",
950 override: false,
951 customTransFunc: customTransFuncV1,
952 },
953 {
954 tag: "excludesall",
955 translation: "{0} non deve contenere alcuno dei seguenti caratteri '{1}'",
956 override: false,
957 customTransFunc: customTransFuncV1,
958 },
959 {
960 tag: "excludesrune",
961 translation: "{0} non deve contenere '{1}'",
962 override: false,
963 customTransFunc: customTransFuncV1,
964 },
965 {
966 tag: "isbn",
967 translation: "{0} deve essere un numero ISBN valido",
968 override: false,
969 },
970 {
971 tag: "isbn10",
972 translation: "{0} deve essere un numero ISBN-10 valido",
973 override: false,
974 },
975 {
976 tag: "isbn13",
977 translation: "{0} deve essere un numero ISBN-13 valido",
978 override: false,
979 },
980 {
981 tag: "issn",
982 translation: "{0} deve essere un numero ISSN valido",
983 override: false,
984 },
985 {
986 tag: "uuid",
987 translation: "{0} deve essere un UUID valido",
988 override: false,
989 },
990 {
991 tag: "uuid3",
992 translation: "{0} deve essere un UUID versione 3 valido",
993 override: false,
994 },
995 {
996 tag: "uuid4",
997 translation: "{0} deve essere un UUID versione 4 valido",
998 override: false,
999 },
1000 {
1001 tag: "uuid5",
1002 translation: "{0} deve essere un UUID versione 5 valido",
1003 override: false,
1004 },
1005 {
1006 tag: "ulid",
1007 translation: "{0} deve essere un ULID valido",
1008 override: false,
1009 },
1010 {
1011 tag: "ascii",
1012 translation: "{0} deve contenere solo caratteri ascii",
1013 override: false,
1014 },
1015 {
1016 tag: "printascii",
1017 translation: "{0} deve contenere solo caratteri ascii stampabili",
1018 override: false,
1019 },
1020 {
1021 tag: "multibyte",
1022 translation: "{0} deve contenere caratteri multibyte",
1023 override: false,
1024 },
1025 {
1026 tag: "datauri",
1027 translation: "{0} deve contenere un Data URI valido",
1028 override: false,
1029 },
1030 {
1031 tag: "latitude",
1032 translation: "{0} deve contenere una latitudine valida",
1033 override: false,
1034 },
1035 {
1036 tag: "longitude",
1037 translation: "{0} deve contenere una longitudine valida",
1038 override: false,
1039 },
1040 {
1041 tag: "ssn",
1042 translation: "{0} deve essere un numero SSN valido",
1043 override: false,
1044 },
1045 {
1046 tag: "ipv4",
1047 translation: "{0} deve essere un indirizzo IPv4 valido",
1048 override: false,
1049 },
1050 {
1051 tag: "ipv6",
1052 translation: "{0} deve essere un indirizzo IPv6 valido",
1053 override: false,
1054 },
1055 {
1056 tag: "ip",
1057 translation: "{0} deve essere un indirizzo IP valido",
1058 override: false,
1059 },
1060 {
1061 tag: "cidr",
1062 translation: "{0} deve contenere una notazione CIDR valida",
1063 override: false,
1064 },
1065 {
1066 tag: "cidrv4",
1067 translation: "{0} deve contenere una notazione CIDR per un indirizzo IPv4 valida",
1068 override: false,
1069 },
1070 {
1071 tag: "cidrv6",
1072 translation: "{0} deve contenere una notazione CIDR per un indirizzo IPv6 valida",
1073 override: false,
1074 },
1075 {
1076 tag: "tcp_addr",
1077 translation: "{0} deve essere un indirizzo TCP valido",
1078 override: false,
1079 },
1080 {
1081 tag: "tcp4_addr",
1082 translation: "{0} deve essere un indirizzo IPv4 TCP valido",
1083 override: false,
1084 },
1085 {
1086 tag: "tcp6_addr",
1087 translation: "{0} deve essere un indirizzo IPv6 TCP valido",
1088 override: false,
1089 },
1090 {
1091 tag: "udp_addr",
1092 translation: "{0} deve essere un indirizzo UDP valido",
1093 override: false,
1094 },
1095 {
1096 tag: "udp4_addr",
1097 translation: "{0} deve essere un indirizzo IPv4 UDP valido",
1098 override: false,
1099 },
1100 {
1101 tag: "udp6_addr",
1102 translation: "{0} deve essere un indirizzo IPv6 UDP valido",
1103 override: false,
1104 },
1105 {
1106 tag: "ip_addr",
1107 translation: "{0} deve essere un indirizzo IP risolvibile",
1108 override: false,
1109 },
1110 {
1111 tag: "ip4_addr",
1112 translation: "{0} deve essere un indirizzo IPv4 risolvibile",
1113 override: false,
1114 },
1115 {
1116 tag: "ip6_addr",
1117 translation: "{0} deve essere un indirizzo IPv6 risolvibile",
1118 override: false,
1119 },
1120 {
1121 tag: "unix_addr",
1122 translation: "{0} deve essere un indirizzo UNIX risolvibile",
1123 override: false,
1124 },
1125 {
1126 tag: "mac",
1127 translation: "{0} deve contenere un indirizzo MAC valido",
1128 override: false,
1129 },
1130 {
1131 tag: "unique",
1132 translation: "{0} deve contenere valori unici",
1133 override: false,
1134 },
1135 {
1136 tag: "iscolor",
1137 translation: "{0} deve essere un colore valido",
1138 override: false,
1139 },
1140 {
1141 tag: "cron",
1142 translation: "{0} deve essere una stringa cron valida",
1143 override: false,
1144 },
1145 {
1146 tag: "oneof",
1147 translation: "{0} deve essere uno di [{1}]",
1148 override: false,
1149 customTransFunc: customTransFuncV1,
1150 },
1151 {
1152 tag: "json",
1153 translation: "{0} deve essere una stringa json valida",
1154 override: false,
1155 },
1156 {
1157 tag: "jwt",
1158 translation: "{0} deve essere una stringa jwt valida",
1159 override: false,
1160 },
1161 {
1162 tag: "lowercase",
1163 translation: "{0} deve essere una stringa minuscola",
1164 override: false,
1165 },
1166 {
1167 tag: "boolean",
1168 translation: "{0} deve rappresentare un valore booleano",
1169 override: false,
1170 },
1171 {
1172 tag: "uppercase",
1173 translation: "{0} deve essere una stringa maiuscola",
1174 override: false,
1175 },
1176 {
1177 tag: "startswith",
1178 translation: "{0} deve iniziare con {1}",
1179 override: false,
1180 customTransFunc: customTransFuncV1,
1181 },
1182 {
1183 tag: "startsnotwith",
1184 translation: "{0} non deve iniziare con {1}",
1185 override: false,
1186 customTransFunc: customTransFuncV1,
1187 },
1188 {
1189 tag: "endswith",
1190 translation: "{0} deve terminare con {1}",
1191 override: false,
1192 customTransFunc: customTransFuncV1,
1193 },
1194 {
1195 tag: "endsnotwith",
1196 translation: "{0} non deve terminare con {1}",
1197 override: false,
1198 customTransFunc: customTransFuncV1,
1199 },
1200 {
1201 tag: "datetime",
1202 translation: "{0} non corrisponde al formato {1}",
1203 override: false,
1204 customTransFunc: customTransFuncV1,
1205 },
1206 {
1207 tag: "postcode_iso3166_alpha2",
1208 translation: "{0} non corrisponde al formato del codice postale dello stato {1}",
1209 override: false,
1210 customTransFunc: customTransFuncV1,
1211 },
1212 {
1213 tag: "postcode_iso3166_alpha2_field",
1214 translation: "{0} non corrisponde al formato del codice postale dello stato nel campo {1}",
1215 override: false,
1216 customTransFunc: customTransFuncV1,
1217 },
1218 {
1219 tag: "image",
1220 translation: "{0} deve essere un'immagine valida",
1221 override: false,
1222 },
1223 }
1224
1225 for _, t := range translations {
1226 if t.customTransFunc != nil && t.customRegisFunc != nil {
1227 err = v.RegisterTranslation(t.tag, trans, t.customRegisFunc, t.customTransFunc)
1228 } else if t.customTransFunc != nil && t.customRegisFunc == nil {
1229 err = v.RegisterTranslation(t.tag, trans, registrationFunc(t.tag, t.translation, t.override), t.customTransFunc)
1230 } else if t.customTransFunc == nil && t.customRegisFunc != nil {
1231 err = v.RegisterTranslation(t.tag, trans, t.customRegisFunc, translateFunc)
1232 } else {
1233 err = v.RegisterTranslation(t.tag, trans, registrationFunc(t.tag, t.translation, t.override), translateFunc)
1234 }
1235
1236 if err != nil {
1237 return
1238 }
1239 }
1240
1241 return
1242 }
1243
1244 func registrationFunc(tag string, translation string, override bool) validator.RegisterTranslationsFunc {
1245 return func(ut ut.Translator) (err error) {
1246 if err = ut.Add(tag, translation, override); err != nil {
1247 return
1248 }
1249
1250 return
1251 }
1252 }
1253
1254 func translateFunc(ut ut.Translator, fe validator.FieldError) string {
1255 t, err := ut.T(fe.Tag(), fe.Field())
1256 if err != nil {
1257 log.Printf("warning: error translating FieldError: %#v", fe)
1258 return fe.(error).Error()
1259 }
1260
1261 return t
1262 }
1263
1264 func customTransFuncV1(ut ut.Translator, fe validator.FieldError) string {
1265 s, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1266 if err != nil {
1267 log.Printf("warning: error translating FieldError: %#v", fe)
1268 return fe.(error).Error()
1269 }
1270 return s
1271 }
1272
View as plain text