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