[Summary view] [Print] [Text view]

   1  /*+***********************************************************************************
   2   * The contents of this file are subject to the vtiger CRM Public License Version 1.0
   3   * ("License"); You may not use this file except in compliance with the License
   4   * The Original Code is:  vtiger CRM Open Source
   5   * The Initial Developer of the Original Code is vtiger.
   6   * Portions created by vtiger are Copyright (C) vtiger.
   7   * All Rights Reserved.
   8   *************************************************************************************/
   9  Vtiger_Base_Validator_Js("Vtiger_Email_Validator_Js",{
  10  
  11      /**
  12       *Function which invokes field validation
  13       *@param accepts field element as parameter
  14       * @return error if validation fails true on success
  15       */
  16      invokeValidation: function(field, rules, i, options){
  17          var emailInstance = new Vtiger_Email_Validator_Js();
  18          emailInstance.setElement(field);
  19          var response = emailInstance.validate();
  20          if(response != true){
  21              return emailInstance.getError();
  22          }
  23      }
  24  },{
  25  
  26      /**
  27       * Function to validate the email field data
  28       */
  29      validate: function(){
  30          var fieldValue = this.getFieldValue();
  31          return this.validateValue(fieldValue);
  32      },
  33      /**
  34       * Function to validate the email field data
  35       * @return true if validation is successfull
  36       * @return false if validation error occurs
  37       */
  38      validateValue : function(fieldValue){
  39          var emailFilter = /^[_/a-zA-Z0-9*]+([!"#$%&'()*+,./:;<=>?\^_`{|}~-]?[a-zA-Z0-9/_/-])*@[a-zA-Z0-9]+([\_\-\.]?[a-zA-Z0-9]+)*\.([\-\_]?[a-zA-Z0-9])+(\.?[a-zA-Z0-9]+)?$/;
  40          var illegalChars= /[\(\)\<\>\,\;\:\\\"\[\]]/ ;
  41  
  42          if (!emailFilter.test(fieldValue)) {
  43              var errorInfo = app.vtranslate('JS_PLEASE_ENTER_VALID_EMAIL_ADDRESS');
  44              this.setError(errorInfo);
  45              return false;
  46  
  47          } else if (fieldValue.match(illegalChars)) {
  48              var errorInfo = app.vtranslate('JS_CONTAINS_ILLEGAL_CHARACTERS');
  49              this.setError(errorInfo);
  50              return false;
  51          }
  52          return true;
  53      }
  54  });
  55  
  56  Vtiger_Base_Validator_Js("Vtiger_PositiveNumber_Validator_Js",{
  57  
  58      /**
  59       *Function which invokes field validation
  60       *@param accepts field element as parameter
  61       * @return error if validation fails true on success
  62       */
  63      invokeValidation: function(field, rules, i, options){
  64          var positiveNumberInstance = new Vtiger_PositiveNumber_Validator_Js();
  65          positiveNumberInstance.setElement(field);
  66          var response = positiveNumberInstance.validate();
  67          if(response != true){
  68              return positiveNumberInstance.getError();
  69          }
  70      }
  71  
  72  },{
  73  
  74      /**
  75       * Function to validate the Positive Numbers
  76       * @return true if validation is successfull
  77       * @return false if validation error occurs
  78       */
  79      validate: function(){
  80          var fieldValue = this.getFieldValue();
  81          var negativeRegex= /(^[-]+\d+)$/ ;
  82          if(isNaN(fieldValue) || fieldValue < 0 || fieldValue.match(negativeRegex)){
  83              var errorInfo = app.vtranslate('JS_ACCEPT_POSITIVE_NUMBER');
  84              this.setError(errorInfo);
  85              return false;
  86          }
  87          return true;
  88      }
  89  })
  90  
  91  Vtiger_Base_Validator_Js("Vtiger_Integer_Validator_Js",{
  92  
  93      /**
  94       *Function which invokes field validation
  95       *@param accepts field element as parameter
  96       * @return error if validation fails true on success
  97       */
  98      invokeValidation: function(field, rules, i, options){
  99          var integerInstance = new Vtiger_Integer_Validator_Js();
 100          integerInstance.setElement(field);
 101          var response = integerInstance.validate();
 102          if(response != true){
 103              return integerInstance.getError();
 104          }
 105      }
 106  },{
 107  
 108      /**
 109       * Function to validate the Integre field data
 110       * @return true if validation is successfull
 111       * @return false if validation error occurs
 112       */
 113      validate: function(){
 114          var fieldValue = this.getFieldValue();
 115          var integerRegex= /(^[-+]?\d+)$/ ;
 116          var decimalIntegerRegex = /(^[-+]?\d?).\d+$/ ;
 117          if ((!fieldValue.match(integerRegex))) {
 118              if(!fieldValue.match(decimalIntegerRegex)){
 119                  var errorInfo = app.vtranslate("JS_PLEASE_ENTER_INTEGER_VALUE");
 120                  this.setError(errorInfo);
 121                  return false;
 122              } else {
 123                  return true;
 124              }
 125          } else{
 126              return true;
 127          }
 128      }
 129  })
 130  
 131  Vtiger_PositiveNumber_Validator_Js("Vtiger_Percentage_Validator_Js",{
 132  
 133      /**
 134       *Function which invokes field validation
 135       *@param accepts field element as parameter
 136       * @return error if validation fails true on success
 137       */
 138      invokeValidation: function(field, rules, i, options){
 139          var percentageInstance = new Vtiger_Percentage_Validator_Js();
 140          percentageInstance.setElement(field);
 141          var response = percentageInstance.validate();
 142          if(response != true){
 143              return percentageInstance.getError();
 144          }
 145      }
 146  
 147  },{
 148  
 149      /**
 150       * Function to validate the percentage field data
 151       * @return true if validation is successfull
 152       * @return false if validation error occurs
 153       */
 154      validate: function(){
 155          var response = this._super();
 156          if(response != true){
 157              return response;
 158          }else{
 159              var fieldValue = this.getFieldValue();
 160              if (fieldValue > 100) {
 161                  var errorInfo = app.vtranslate('JS_PERCENTAGE_VALUE_SHOULD_BE_LESS_THAN_100');
 162                  this.setError(errorInfo);
 163                  return false;
 164              }
 165              return true;
 166          }
 167      }
 168  });
 169  
 170  Vtiger_Base_Validator_Js('Vtiger_Url_Validator_Js',{},{
 171  
 172      /**
 173       * Function to validate the Url
 174       * @return true if validation is successfull
 175       * @return false if validation error occurs
 176       */
 177      validate: function(){
 178          var fieldValue = this.getFieldValue();
 179          var regexp = /(^|\s)((https?:\/\/)?[\w-]+(\.[\w-]+)+\.?(:\d+)?(\/\S*)?)/gi;
 180          var result = regexp.test(fieldValue);
 181          if (!result ) {
 182              var errorInfo = app.vtranslate('JS_CONTAINS_ILLEGAL_CHARACTERS');//"Please enter valid url";
 183              this.setError(errorInfo);
 184              return false;
 185          }
 186          return true;
 187      }
 188  })
 189  
 190  Vtiger_Base_Validator_Js("Vtiger_MultiSelect_Validator_Js",{
 191  
 192      invokeValidation : function(field, rules, i, options) {
 193          var validatorInstance = new Vtiger_MultiSelect_Validator_Js ();
 194          validatorInstance.setElement(field);
 195          var result = validatorInstance.validate();
 196          if(result == true){
 197              return result;
 198          } else {
 199              return validatorInstance.getError();
 200          }
 201      }
 202  },{
 203      /**
 204       * Function to validate the Multi select
 205       * @return true if validation is successfull
 206       * @return false if validation error occurs
 207       */
 208      validate: function(){
 209          var fieldInstance = this.getElement();
 210          var selectElementValue = fieldInstance.val();
 211          if(selectElementValue == null){
 212              var errorInfo = app.vtranslate('JS_PLEASE_SELECT_ATLEAST_ONE_OPTION');
 213              this.setError(errorInfo);
 214              return false;
 215          }
 216          return true;
 217      }
 218  
 219  })
 220  
 221  
 222  Vtiger_Email_Validator_Js ("Vtiger_MultiEmails_Validator_Js",{
 223      invokeValidation : function(field) {
 224          var validatorInstance = new Vtiger_MultiEmails_Validator_Js ();
 225          validatorInstance.setElement(field);
 226          var result = validatorInstance.validate();
 227          if(!result){
 228              return validatorInstance.getError();
 229          }
 230      }
 231  },{
 232      /**
 233       * Function to validate the Multi select
 234       * @return true if validation is successfull
 235       * @return false if validation error occurs
 236       */
 237      validate: function(){
 238          var fieldInstance = this.getElement();
 239          var fieldInstanceValue = fieldInstance.val();
 240          if(fieldInstanceValue != ''){
 241              var emailsArr = fieldInstanceValue.split(',');
 242              var i;
 243              for (i = 0; i < emailsArr.length; ++i) {
 244                  var result =  this.validateValue(emailsArr[i]);
 245                  if(result == false){
 246                      return result;
 247                  }
 248              }
 249              return true;
 250          }
 251      }
 252  
 253  });
 254  
 255  Vtiger_PositiveNumber_Validator_Js("Vtiger_GreaterThanZero_Validator_Js",{
 256  
 257      /**
 258       *Function which invokes field validation
 259       *@param accepts field element as parameter
 260       * @return error if validation fails true on success
 261       */
 262      invokeValidation: function(field, rules, i, options){
 263  
 264          var GreaterThanZeroInstance = new Vtiger_GreaterThanZero_Validator_Js();
 265          GreaterThanZeroInstance.setElement(field);
 266          var response = GreaterThanZeroInstance.validate();
 267          if(response != true){
 268              return GreaterThanZeroInstance.getError();
 269          }
 270      }
 271  
 272  },{
 273  
 274      /**
 275       * Function to validate the Positive Numbers and greater than zero value
 276       * @return true if validation is successfull
 277       * @return false if validation error occurs
 278       */
 279      validate: function(){
 280  
 281          var response = this._super();
 282          if(response != true){
 283              return response;
 284          }else{
 285              var fieldValue = this.getFieldValue();
 286              if(fieldValue == 0){
 287                  var errorInfo = app.vtranslate('JS_VALUE_SHOULD_BE_GREATER_THAN_ZERO');
 288                  this.setError(errorInfo);
 289                  return false;
 290              }
 291          }
 292          return true;
 293      }
 294  })
 295  
 296  Vtiger_PositiveNumber_Validator_Js("Vtiger_WholeNumber_Validator_Js",{
 297  
 298      /**
 299       *Function which invokes field validation
 300       *@param accepts field element as parameter
 301       * @return error if validation fails true on success
 302       */
 303      invokeValidation: function(field, rules, i, options){
 304          var instance = new Vtiger_WholeNumber_Validator_Js();
 305          instance.setElement(field);
 306          var response = instance.validate();
 307          if(response != true){
 308              return instance.getError();
 309          }
 310      }
 311  },{
 312  
 313      /**
 314       * Function to validate the Positive Numbers and whole Number
 315       * @return true if validation is successfull
 316       * @return false if validation error occurs
 317       */
 318      validate: function(){
 319          var response = this._super();
 320          if(response != true){
 321              return response;
 322          }
 323          var field = this.getElement();
 324          var fieldValue = this.getFieldValue();
 325          var fieldData = field.data();
 326          var fieldInfo = fieldData.fieldinfo;
 327          if((fieldValue % 1) != 0){
 328              if(! jQuery.isEmptyObject(fieldInfo)){
 329                  var errorInfo = app.vtranslate('INVALID_NUMBER_OF')+" "+fieldInfo.label;
 330              } else {
 331                  var errorInfo = app.vtranslate('INVALID_NUMBER');
 332              }
 333              this.setError(errorInfo);
 334              return false;
 335          }
 336          return true;
 337      }
 338  })
 339  
 340  Vtiger_Base_Validator_Js("Vtiger_lessThanToday_Validator_Js",{},{
 341  
 342      /**
 343       * Function to validate the birthday field
 344       * @return true if validation is successfull
 345       * @return false if validation error occurs
 346       */
 347      validate: function(){
 348          var field = this.getElement();
 349          var fieldData = field.data();
 350          var fieldDateFormat = fieldData.dateFormat;
 351          var fieldInfo = fieldData.fieldinfo;
 352          var fieldValue = this.getFieldValue();
 353          try{
 354              var fieldDateInstance = Vtiger_Helper_Js.getDateInstance(fieldValue,fieldDateFormat);
 355          }
 356          catch(err){
 357              this.setError(err);
 358              return false;
 359          }
 360          fieldDateInstance.setHours(0,0,0,0);
 361          var todayDateInstance = new Date();
 362          todayDateInstance.setHours(0,0,0,0);
 363          var comparedDateVal =  todayDateInstance - fieldDateInstance;
 364          if(comparedDateVal <= 0){
 365              var errorInfo = fieldInfo.label+" "+app.vtranslate('JS_SHOULD_BE_LESS_THAN_CURRENT_DATE');
 366              this.setError(errorInfo);
 367              return false;
 368          }
 369                  return true;
 370      }
 371  })
 372  
 373  Vtiger_Base_Validator_Js("Vtiger_lessThanOrEqualToToday_Validator_Js",{},{
 374  
 375      /**
 376       * Function to validate the datesold field
 377       * @return true if validation is successfull
 378       * @return false if validation error occurs
 379       */
 380      validate: function(){
 381          var field = this.getElement();
 382          var fieldData = field.data();
 383          var fieldDateFormat = fieldData.dateFormat;
 384          var fieldInfo = fieldData.fieldinfo;
 385          var fieldValue = this.getFieldValue();
 386          try{
 387              var fieldDateInstance = Vtiger_Helper_Js.getDateInstance(fieldValue,fieldDateFormat);
 388          }
 389          catch(err){
 390              this.setError(err);
 391              return false;
 392          }
 393          fieldDateInstance.setHours(0,0,0,0);
 394          var todayDateInstance = new Date();
 395          todayDateInstance.setHours(0,0,0,0);
 396          var comparedDateVal =  todayDateInstance - fieldDateInstance;
 397          if(comparedDateVal < 0){
 398              var errorInfo = fieldInfo.label+" "+app.vtranslate('JS_SHOULD_BE_LESS_THAN_OR_EQUAL_TO')+" "+app.vtranslate('JS_CURRENT_DATE');
 399              this.setError(errorInfo);
 400              return false;
 401          }
 402                  return true;
 403      }
 404  })
 405  
 406  Vtiger_Base_Validator_Js('Vtiger_greaterThanOrEqualToToday_Validator_Js',{},{
 407  
 408      /**
 409       * Function to validate the dateinservice field
 410       * @return true if validation is successfull
 411       * @return false if validation error occurs
 412       */
 413      validate: function(){
 414          var field = this.getElement();
 415          var fieldData = field.data();
 416          var fieldDateFormat = fieldData.dateFormat;
 417          var fieldInfo = fieldData.fieldinfo;
 418          var fieldValue = this.getFieldValue();
 419          try{
 420              var fieldDateInstance = Vtiger_Helper_Js.getDateInstance(fieldValue,fieldDateFormat);
 421          }
 422          catch(err){
 423              this.setError(err);
 424              return false;
 425          }
 426          fieldDateInstance.setHours(0,0,0,0);
 427          var todayDateInstance = new Date();
 428          todayDateInstance.setHours(0,0,0,0);
 429          var comparedDateVal =  todayDateInstance - fieldDateInstance;
 430          if(comparedDateVal > 0){
 431              var errorInfo = fieldInfo.label+" "+app.vtranslate('JS_SHOULD_BE_GREATER_THAN_OR_EQUAL_TO')+" "+app.vtranslate('JS_CURRENT_DATE');;
 432              this.setError(errorInfo);
 433              return false;
 434          }
 435          return true;
 436      }
 437  })
 438  
 439  Vtiger_Base_Validator_Js("Vtiger_greaterThanDependentField_Validator_Js",{
 440      
 441      /**
 442       *Function which invokes field validation
 443       *@param accepts field element as parameter
 444       * @return error if validation fails true on success
 445       */
 446      invokeValidation: function(field, rules, i, options){
 447          var fieldForValidation = field[0];
 448          if(jQuery(fieldForValidation).attr('name') == 'followup_date_start'){
 449              var dependentFieldList = new Array('date_start');
 450          }
 451          var instance = new Vtiger_greaterThanDependentField_Validator_Js();
 452          instance.setElement(field);
 453          var response = instance.validate(dependentFieldList);
 454          if(response != true){
 455              return instance.getError();
 456          }
 457      }
 458  },{
 459  
 460      /**
 461       * Function to validate the birthday field
 462       * @return true if validation is successfull
 463       * @return false if validation error occurs
 464       */
 465      validate: function(dependentFieldList){
 466          var field = this.getElement();
 467          var fieldInfo = field.data('fieldinfo');
 468          var fieldLabel;
 469          if(typeof fieldInfo == "undefined"){
 470              fieldLabel = jQuery(field).attr('name');
 471          }else{
 472              fieldLabel = fieldInfo.label;
 473          }
 474          var contextFormElem = field.closest('form');
 475          for(var i=0; i<dependentFieldList.length; i++){
 476              var dependentField = dependentFieldList[i];
 477              var dependentFieldInContext = jQuery('input[name='+dependentField+']',contextFormElem);
 478              if(dependentFieldInContext.length > 0){
 479                  var dependentFieldLabel = dependentFieldInContext.data('fieldinfo').label;
 480                  var fieldDateInstance = this.getDateTimeInstance(field);
 481                  var dependentFieldDateInstance = this.getDateTimeInstance(dependentFieldInContext);
 482                  var comparedDateVal =  fieldDateInstance - dependentFieldDateInstance;
 483                  if(comparedDateVal < 0){
 484                      var errorInfo = fieldLabel+' '+app.vtranslate('JS_SHOULD_BE_GREATER_THAN_OR_EQUAL_TO')+' '+dependentFieldLabel+'';
 485                      this.setError(errorInfo);
 486                      return false;
 487                  }
 488              }
 489          }
 490          return true;
 491      },
 492  
 493      getDateTimeInstance : function(field) {
 494          var dateFormat = field.data('dateFormat');
 495          var fieldValue = field.val();
 496          try{
 497              var dateTimeInstance = Vtiger_Helper_Js.getDateInstance(fieldValue,dateFormat);
 498          }
 499          catch(err){
 500              this.setError(err);
 501              return false;
 502          }
 503          return dateTimeInstance;
 504      }
 505  })
 506  
 507  Vtiger_Base_Validator_Js("Vtiger_futureEventCannotBeHeld_Validator_Js",{},{
 508  
 509      /**
 510       * Function to validate event status , which cannot be held for future events
 511       * @return true if validation is successfull
 512       * @return false if validation error occurs
 513       */
 514      validate: function(dependentFieldList){
 515          var field = this.getElement();
 516          var fieldLabel = field.data('fieldinfo').label;
 517                  var status = field.val();
 518          var contextFormElem = field.closest('form');
 519          for(var i=0; i<dependentFieldList.length; i++){
 520              var dependentField = dependentFieldList[i];
 521              var dependentFieldInContext = jQuery('input[name='+dependentField+']',contextFormElem);
 522              if(dependentFieldInContext.length > 0){
 523                  var dependentFieldLabel = dependentFieldInContext.data('fieldinfo').label;
 524                  var todayDateInstance = new Date();
 525                                  var dateFormat = dependentFieldInContext.data('dateFormat');
 526                                  var time = jQuery('input[name=time_start]',contextFormElem);
 527                                  var fieldValue = dependentFieldInContext.val()+" "+time.val();
 528                  var dependentFieldDateInstance = Vtiger_Helper_Js.getDateInstance(fieldValue,dateFormat);
 529                  var comparedDateVal =  todayDateInstance - dependentFieldDateInstance;
 530                  if(comparedDateVal < 0 && status == "Held"){
 531                      var errorInfo = fieldLabel+' '+app.vtranslate('JS_FUTURE_EVENT_CANNOT_BE_HELD')+' '+dependentFieldLabel+'';
 532                      this.setError(errorInfo);
 533                      return false;
 534                  }
 535              }
 536          }
 537          return true;
 538      }
 539  })
 540  
 541  Vtiger_Base_Validator_Js("Vtiger_lessThanDependentField_Validator_Js",{},{
 542  
 543      /**
 544       * Function to validate the birthday field
 545       * @return true if validation is successfull
 546       * @return false if validation error occurs
 547       */
 548      validate: function(dependentFieldList){
 549          var field = this.getElement();
 550          var fieldLabel = field.data('fieldinfo').label;
 551          var contextFormElem = field.closest('form');
 552          //No need to validate if value is empty
 553          if(field.val().length == 0) {
 554              return;
 555          }
 556          for(var i=0; i<dependentFieldList.length; i++){
 557              var dependentField = dependentFieldList[i];
 558              var dependentFieldInContext = jQuery('input[name='+dependentField+']',contextFormElem);
 559              if(dependentFieldInContext.length > 0){
 560                  var dependentFieldLabel = dependentFieldInContext.data('fieldinfo').label;
 561                  var fieldDateInstance = this.getDateTimeInstance(field);
 562                  //No need to validate if value is empty
 563                  if(dependentFieldInContext.val().length == 0) {
 564                      continue;
 565                  }
 566                  var dependentFieldDateInstance = this.getDateTimeInstance(dependentFieldInContext);
 567                  var comparedDateVal =  fieldDateInstance - dependentFieldDateInstance;
 568                  if(comparedDateVal > 0){
 569                      var errorInfo = fieldLabel+' '+app.vtranslate('JS_SHOULD_BE_LESS_THAN_OR_EQUAL_TO')+' '+dependentFieldLabel+'';
 570                      this.setError(errorInfo);
 571                      return false;
 572                  }
 573              }
 574          }
 575          return true;
 576      },
 577  
 578      getDateTimeInstance : function(field) {
 579          var dateFormat = field.data('dateFormat');
 580          var fieldValue = field.val();
 581          try{
 582              var dateTimeInstance = Vtiger_Helper_Js.getDateInstance(fieldValue,dateFormat);
 583          }
 584          catch(err){
 585              this.setError(err);
 586              return false;
 587          }
 588          return dateTimeInstance;
 589      }
 590  })
 591  
 592  Vtiger_Base_Validator_Js('Vtiger_Currency_Validator_Js',{
 593  
 594      /**
 595       *Function which invokes field validation
 596       *@param accepts field element as parameter
 597       * @return error if validation fails true on success
 598       */
 599      invokeValidation: function(field, rules, i, options){
 600          var currencyValidatorInstance = new Vtiger_Currency_Validator_Js();
 601          currencyValidatorInstance.setElement(field);
 602          var response = currencyValidatorInstance.validate();
 603          if(response != true){
 604              return currencyValidatorInstance.getError();
 605          }
 606      }
 607  },{
 608  
 609      /**
 610       * Function to validate the Currency Field
 611       * @return true if validation is successfull
 612       * @return false if validation error occurs
 613       */
 614      validate: function(){
 615          var response = this._super();
 616          if(response != true){
 617              return response;
 618          }
 619          var field = this.getElement();
 620          var fieldValue = this.getFieldValue();
 621          var fieldData = field.data();
 622  
 623          if(fieldData.decimalSeperator == "'") fieldData.decimalSeperator = "''";
 624          var strippedValue = fieldValue.replace(fieldData.decimalSeperator, '');
 625          var errorInfo;
 626  
 627          var regex = new RegExp(fieldData.groupSeperator,'g');
 628          strippedValue = strippedValue.replace(regex, '');
 629          //Note: Need to review if we should allow only positive values in currencies
 630          /*if(strippedValue < 0){
 631              var errorInfo = app.vtranslate('JS_CONTAINS_ILLEGAL_CHARACTERS');//"currency value should be greater than or equal to zero";
 632              this.setError(errorInfo);
 633              return false;
 634          }*/
 635          if(isNaN(strippedValue)){
 636              errorInfo = app.vtranslate('JS_CONTAINS_ILLEGAL_CHARACTERS');
 637              this.setError(errorInfo);
 638              return false;
 639          }
 640          if(strippedValue < 0){
 641              errorInfo = app.vtranslate('JS_ACCEPT_POSITIVE_NUMBER');
 642              this.setError(errorInfo);
 643              return false;
 644          }
 645          return true;
 646      }
 647  })
 648  
 649  Vtiger_Base_Validator_Js("Vtiger_ReferenceField_Validator_Js",{},{
 650  
 651      /**
 652       * Function to validate the Positive Numbers and whole Number
 653       * @return true if validation is successfull
 654       * @return false if validation error occurs
 655       */
 656      validate: function(){
 657          var field = this.getElement();
 658          var parentElement = field.closest('.fieldValue');
 659          var referenceField = parentElement.find('.sourceField');
 660          var referenceFieldValue = referenceField.val();
 661          var fieldInfo = referenceField.data().fieldinfo;
 662          if(referenceFieldValue == ""){
 663              var errorInfo = app.vtranslate('JS_REQUIRED_FIELD');
 664              this.setError(errorInfo);
 665              return false;
 666          }
 667          return true;
 668      }
 669  })
 670  
 671  Vtiger_Integer_Validator_Js("Vtiger_Double_Validator_Js",{},{
 672  
 673      /**
 674       * Function to validate the Decimal field data
 675       * @return true if validation is successfull
 676       * @return false if validation error occurs
 677       */
 678      validate: function(){
 679          var response = this._super();
 680          if(response == false){
 681              var fieldValue = this.getFieldValue();
 682              var doubleRegex= /(^[-+]?\d+)\.\d+$/ ;
 683              if (!fieldValue.match(doubleRegex)) {
 684                  var errorInfo = app.vtranslate("JS_PLEASE_ENTER_DECIMAL_VALUE");
 685                  this.setError(errorInfo);
 686                  return false;
 687              }
 688              return true;
 689          }
 690          return response;
 691      }
 692  })
 693  
 694  Vtiger_Base_Validator_Js("Vtiger_Date_Validator_Js",{
 695  
 696      /**
 697       *Function which invokes field validation
 698       *@param accepts field element as parameter
 699       * @return error if validation fails true on success
 700       */
 701      invokeValidation: function(field, rules, i, options){
 702          var dateValidatorInstance = new Vtiger_Date_Validator_Js();
 703          dateValidatorInstance.setElement(field);
 704          var response = dateValidatorInstance.validate();
 705          if(response != true){
 706              return dateValidatorInstance.getError();
 707          }
 708          return response;
 709      }
 710  
 711  },{
 712  
 713      /**
 714       * Function to validate the Positive Numbers and whole Number
 715       * @return true if validation is successfull
 716       * @return false if validation error occurs
 717       */
 718      validate: function(){
 719          var field = this.getElement();
 720          var fieldData = field.data();
 721          var fieldDateFormat = fieldData.dateFormat;
 722          var fieldValue = this.getFieldValue();
 723          try{
 724              Vtiger_Helper_Js.getDateInstance(fieldValue,fieldDateFormat);
 725          }
 726          catch(err){
 727              var errorInfo = app.vtranslate("JS_PLEASE_ENTER_VALID_DATE");
 728              this.setError(errorInfo);
 729              return false;
 730          }
 731          return true;
 732      }
 733  
 734  
 735  })
 736  
 737  Vtiger_Base_Validator_Js("Vtiger_Time_Validator_Js",{
 738  
 739      /**
 740       * Function which invokes field validation
 741       * @param accepts field element as parameter
 742       * @return error if validation fails true on success
 743       */
 744      invokeValidation : function(field, rules, i, options) {
 745          var validatorInstance = new Vtiger_Time_Validator_Js();
 746          validatorInstance.setElement(field);
 747          var result = validatorInstance.validate();
 748          if(result == true){
 749              return result;
 750          } else {
 751              return validatorInstance.getError();
 752          }
 753      }
 754  
 755  },{
 756  
 757      /**
 758       * Function to validate the Time Fields
 759       * @return true if validation is successfull
 760       * @return false if validation error occurs
 761       */
 762      validate: function(){
 763          var fieldValue = this.getFieldValue();
 764          var time = fieldValue.replace(fieldValue.match(/[AP]M/i),'');
 765          var timeValue = time.split(":");
 766          if(isNaN(timeValue[0]) && isNaN(timeValue[1])) {
 767              var errorInfo = app.vtranslate("JS_PLEASE_ENTER_VALID_TIME");
 768              this.setError(errorInfo);
 769              return false;
 770          }
 771          return true;
 772      }
 773  
 774  })
 775  
 776  //Calendar Specific validators
 777  // We have placed it here since quick create will not load module specific validators
 778  
 779  Vtiger_greaterThanDependentField_Validator_Js("Calendar_greaterThanDependentField_Validator_Js",{},{
 780  
 781      getDateTimeInstance : function(field) {
 782          var form = field.closest('form');
 783          if(field.attr('name') == 'date_start') {
 784              var timeField = form.find('[name="time_start"]');
 785              var timeFieldValue = timeField.val();
 786          }else if(field.attr('name') == 'due_date') {
 787              var timeField = form.find('[name="time_end"]');
 788              if(timeField.length > 0) {
 789                  var timeFieldValue = timeField.val();
 790              }else{
 791                  //Max value for the day
 792                  timeFieldValue = '11:59 PM';
 793              }
 794          }
 795  
 796          var dateFieldValue = field.val()+" "+ timeFieldValue;
 797          var dateFormat = field.data('dateFormat');
 798          return Vtiger_Helper_Js.getDateInstance(dateFieldValue,dateFormat);
 799      }
 800  
 801  });
 802  
 803  Vtiger_Base_Validator_Js('Calendar_greaterThanToday_Validator_Js',{},{
 804  
 805      /**
 806       * Function to validate the birthday field
 807       * @return true if validation is successfull
 808       * @return false if validation error occurs
 809       */
 810      validate: function(){
 811          var field = this.getElement();
 812          var fieldData = field.data();
 813          var fieldDateFormat = fieldData.dateFormat;
 814          var fieldInfo = fieldData.fieldinfo;
 815          var fieldValue = this.getFieldValue();
 816          try{
 817              var fieldDateInstance = Vtiger_Helper_Js.getDateInstance(fieldValue,fieldDateFormat);
 818          }
 819          catch(err){
 820              this.setError(err);
 821              return false;
 822          }
 823          fieldDateInstance.setHours(0,0,0,0);
 824          var todayDateInstance = new Date();
 825          todayDateInstance.setHours(0,0,0,0);
 826          var comparedDateVal =  todayDateInstance - fieldDateInstance;
 827          if(comparedDateVal >= 0){
 828              var errorInfo = fieldInfo.label+" "+app.vtranslate('JS_SHOULD_BE_GREATER_THAN_CURRENT_DATE');
 829              this.setError(errorInfo);
 830              return false;
 831          }
 832          return true;
 833      }
 834  })
 835  
 836  Vtiger_Base_Validator_Js("Calendar_RepeatMonthDate_Validator_Js",{
 837  
 838      /**
 839       *Function which invokes field validation
 840       *@param accepts field element as parameter
 841       * @return error if validation fails true on success
 842       */
 843      invokeValidation: function(field, rules, i, options){
 844          var repeatMonthDateValidatorInstance = new Calendar_RepeatMonthDate_Validator_Js();
 845          repeatMonthDateValidatorInstance.setElement(field);
 846          var response = repeatMonthDateValidatorInstance.validate();
 847          if(response != true){
 848              return repeatMonthDateValidatorInstance.getError();
 849          }
 850      }
 851  
 852  },{
 853  
 854      /**
 855       * Function to validate the Positive Numbers and whole Number
 856       * @return true if validation is successfull
 857       * @return false if validation error occurs
 858       */
 859      validate: function(){
 860          var fieldValue = this.getFieldValue();
 861  
 862          if((parseInt(parseFloat(fieldValue))) != fieldValue || fieldValue == '' || parseInt(fieldValue) > '31' || parseInt(fieldValue) <= 0) {
 863              var result = app.vtranslate('JS_NUMBER_SHOULD_BE_LESS_THAN_32');
 864              this.setError(result);
 865              return false;
 866          }
 867          return true;
 868      }
 869  })
 870  
 871  Vtiger_WholeNumber_Validator_Js("Vtiger_WholeNumberGreaterThanZero_Validator_Js",{
 872  
 873      /**
 874       *Function which invokes field validation
 875       *@param accepts field element as parameter
 876       * @return error if validation fails true on success
 877       */
 878      invokeValidation: function(field, rules, i, options){
 879  
 880          var WholeNumberGreaterThanZero = new Vtiger_WholeNumberGreaterThanZero_Validator_Js();
 881          WholeNumberGreaterThanZero.setElement(field);
 882          var response = WholeNumberGreaterThanZero.validate();
 883          if(response != true){
 884              return WholeNumberGreaterThanZero.getError();
 885          }
 886      }
 887  
 888  },{
 889  
 890      /**
 891       * Function to validate the Positive Numbers and greater than zero value
 892       * @return true if validation is successfull
 893       * @return false if validation error occurs
 894       */
 895      validate: function(){
 896  
 897          var response = this._super();
 898          if(response != true){
 899              return response;
 900          }else{
 901              var fieldValue = this.getFieldValue();
 902              if(fieldValue == 0){
 903                  var errorInfo = app.vtranslate('JS_VALUE_SHOULD_BE_GREATER_THAN_ZERO');
 904                  this.setError(errorInfo);
 905                  return false;
 906              }
 907          }
 908          return true;
 909      }
 910  })
 911  Vtiger_Base_Validator_Js("Vtiger_AlphaNumeric_Validator_Js",{
 912  
 913      /**
 914       *Function which invokes field validation
 915       *@param accepts field element as parameter
 916       * @return error if validation fails true on success
 917       */
 918      invokeValidation: function(field, rules, i, options){
 919          var alphaNumericInstance = new Vtiger_AlphaNumeric_Validator_Js();
 920          alphaNumericInstance.setElement(field);
 921          var response = alphaNumericInstance.validate();
 922          if(response != true){
 923              return alphaNumericInstance.getError();
 924          }
 925      }
 926  
 927  },{
 928  
 929      /**
 930       * Function to validate the Positive Numbers
 931       * @return true if validation is successfull
 932       * @return false if validation error occurs
 933       */
 934      validate: function(){
 935          var field = this.getElement();
 936          var fieldValue = field.val();
 937          var alphaNumericRegex = /^[a-z0-9 _-]*$/i;
 938          if (!fieldValue.match(alphaNumericRegex)) {
 939              var errorInfo = app.vtranslate("JS_CONTAINS_ILLEGAL_CHARACTERS");
 940              this.setError(errorInfo);
 941              return false;
 942          }
 943          return true;
 944      }
 945  })