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