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