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