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