vendor/gopkg.in/go-playground/validator.v9/translations/en/en.go

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