1 package ar
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} عددًا سداسيًا عشريًا صالحاً",
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} سلسلة Base64 صالحة",
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} رقم ISBN صالح",
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} على أحرف ascii فقط",
1152 override: false,
1153 },
1154 {
1155 tag: "printascii",
1156 translation: "يجب أن يحتوي {0} على أحرف ascii قابلة للطباعة فقط",
1157 override: false,
1158 },
1159 {
1160 tag: "multibyte",
1161 translation: "يجب أن يحتوي {0} على أحرف متعددة البايت",
1162 override: false,
1163 },
1164 {
1165 tag: "datauri",
1166 translation: "يجب أن يحتوي {0} على 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} عنوان IP صالح",
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} عنوان IPv4 TCP صالح",
1222 override: false,
1223 },
1224 {
1225 tag: "tcp6_addr",
1226 translation: "يجب أن يكون {0} عنوان IPv6 TCP صالح",
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} عنوان IPv4 UDP صالح",
1237 override: false,
1238 },
1239 {
1240 tag: "udp6_addr",
1241 translation: "يجب أن يكون {0} عنوان IPv6 UDP صالح",
1242 override: false,
1243 },
1244 {
1245 tag: "ip_addr",
1246 translation: "يجب أن يكون {0} عنوان IP قابل للحل",
1247 override: false,
1248 },
1249 {
1250 tag: "ip4_addr",
1251 translation: "يجب أن يكون {0} عنوان IP قابل للحل",
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} على عنوان MAC صالح",
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: "jwt",
1299 translation: "يجب أن يكون {0} نص jwt صالح",
1300 override: false,
1301 },
1302 {
1303 tag: "lowercase",
1304 translation: "يجب أن يكون {0} نص حروف صغيرة",
1305 override: false,
1306 },
1307 {
1308 tag: "uppercase",
1309 translation: "يجب أن يكون {0} نص حروف كبيرة",
1310 override: false,
1311 },
1312 {
1313 tag: "datetime",
1314 translation: "لا يتطابق {0} مع تنسيق {1}",
1315 override: false,
1316 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1317 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1318 if err != nil {
1319 log.Printf("warning: error translating FieldError: %#v", fe)
1320 return fe.(error).Error()
1321 }
1322
1323 return t
1324 },
1325 },
1326 {
1327 tag: "postcode_iso3166_alpha2",
1328 translation: "لا يتطابق {0} مع تنسيق الرمز البريدي للبلد {1}",
1329 override: false,
1330 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1331 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1332 if err != nil {
1333 log.Printf("warning: error translating FieldError: %#v", fe)
1334 return fe.(error).Error()
1335 }
1336
1337 return t
1338 },
1339 },
1340 {
1341 tag: "postcode_iso3166_alpha2_field",
1342 translation: "لا يتطابق {0} مع تنسيق الرمز البريدي للبلد في حقل {1}",
1343 override: false,
1344 customTransFunc: func(ut ut.Translator, fe validator.FieldError) string {
1345 t, err := ut.T(fe.Tag(), fe.Field(), fe.Param())
1346 if err != nil {
1347 log.Printf("warning: error translating FieldError: %#v", fe)
1348 return fe.(error).Error()
1349 }
1350
1351 return t
1352 },
1353 },
1354 {
1355 tag: "image",
1356 translation: "يجب أن تكون {0} صورة صالحة",
1357 override: false,
1358 },
1359 }
1360
1361 for _, t := range translations {
1362
1363 if t.customTransFunc != nil && t.customRegisFunc != nil {
1364 err = v.RegisterTranslation(t.tag, trans, t.customRegisFunc, t.customTransFunc)
1365 } else if t.customTransFunc != nil && t.customRegisFunc == nil {
1366 err = v.RegisterTranslation(t.tag, trans, registrationFunc(t.tag, t.translation, t.override), t.customTransFunc)
1367 } else if t.customTransFunc == nil && t.customRegisFunc != nil {
1368 err = v.RegisterTranslation(t.tag, trans, t.customRegisFunc, translateFunc)
1369 } else {
1370 err = v.RegisterTranslation(t.tag, trans, registrationFunc(t.tag, t.translation, t.override), translateFunc)
1371 }
1372
1373 if err != nil {
1374 return
1375 }
1376 }
1377
1378 return
1379 }
1380
1381 func registrationFunc(tag string, translation string, override bool) validator.RegisterTranslationsFunc {
1382 return func(ut ut.Translator) (err error) {
1383 if err = ut.Add(tag, translation, override); err != nil {
1384 return
1385 }
1386
1387 return
1388 }
1389 }
1390
1391 func translateFunc(ut ut.Translator, fe validator.FieldError) string {
1392 t, err := ut.T(fe.Tag(), fe.Field())
1393 if err != nil {
1394 log.Printf("warning: error translating FieldError: %#v", fe)
1395 return fe.(error).Error()
1396 }
1397
1398 return t
1399 }
1400
View as plain text