数字和货币校验的dojo的js

dojo.provide("busSingle.validate");
dojo.require("bmc.common.ajx");
(function()
{
 var bmf=busSingle.validate;
 var message;
  
 /**
 *compare inputValue to targetValue
 *if inputValue is bigger than targetValue return false;
 *if inputValue is equal to or less than targetValue return true;
 */
 bmf.numCompare = function(inputValue, targetValue)
 {
  var tmpboolean = true;
  if (null != inputValue && null != targetValue && inputValue != "" && targetValue != "")
  {
   return tmpboolean = bmc.common.ajx.callQueryInterface("/bus_singletable_sync/validateMaxValueInt.action?inputValue=" + inputValue + "&maxValue=" + targetValue);
  }
  
  return tmpboolean;
 }
 
 //convert to currency unit
 bmf.getMeasureStr = function(inputValue)
 {
  var retString = inputValue;
  if (null != inputValue && inputValue != "")
  {
   return retString = bmc.common.ajx.callQueryInterface("/bus_singletable_sync/getMeasureDisRuleOutputSINGLE.action?measureType=1&value=" + inputValue);
  }
  return retString;
 }
 
 /**
 *validate the scope for input value
 *inputValue:
 *label:
 *minValue: lower limitation for input value
 *isEqualToMinVal: 0: input value must be equal to or bigger than the minValue.
       1: input value can't  be equal to minValue.
       2. input value must be bigger than minValue
 *maxValue: upper limitation for input value
 *isEqualToMaxVal: 0: input value must be equal to or less than the maxValue. 
       1: input value can not be  equal than maxValue  
       2:input value must be  less than maxValue
 */
 bmf.validateCurrencyNumber = function(dispNode, minValue, isEqualToMinVal, maxValue, isEqualToMaxVal)
 {       
  
  if(!dispNode || dispNode == -1 || (null == dispNode))
     {
         return;
     }
    
     maxValue = bmf.getMeasureStr(maxValue) + "";
     minValue = bmf.getMeasureStr(minValue) + "";
         
     var inputValue = dispNode.value;    
     var label = dispNode.parentNode.previousSibling.innerText;   

       //only input number
  var patrner=new RegExp(/^(-)?(\d)+((\.)?(\d)+)?$/);  
  
  if (!patrner.test(inputValue))
  {
   return  Message.getString("SINGLETABLE_NUMBER", label);
  } 
  
  if((inputValue.length > 1) && (inputValue.charAt(0) == "0") && (inputValue.charAt(1) != "."))
  {
   return Message.getString("SINGLETABLE_IS_VALID_NUMBER", label);
  }
  var mess=bmf.validateCurrencyUnit(inputValue,label);
  
  if(null!=mess)
  {
   return mess;
  }
               
     message=bmf.validateMinAndMaxValue(inputValue, label, minValue,
     isEqualToMinVal, maxValue, isEqualToMaxVal);
   
  return message;
 };
 
 
 /**
 *validate the scope for input value
 *inputValue:
 *label:
 *minValue: lower limitation for input value
 *isEqualToMinVal: 0: input value must be equal to or bigger than the minValue.
       1: input value can't  be equal to minValue.
       2. input value must be bigger than minValue
 *maxValue: upper limitation for input value
 *isEqualToMaxVal: 0: input value must be equal to or less than the maxValue. 
       1: input value can not be  equal than maxValue  
       2:input value must be  less than maxValue
 */
 bmf.validateGeneralNumber = function(dispNode, minValue, isEqualToMinVal, maxValue, isEqualToMaxVal)
 {
  if(!dispNode || dispNode == -1 || (null == dispNode))
  {
   return;
  }
  
  maxValue = maxValue + "";
  minValue = minValue + "";
    var inputValue = dispNode.value;    
    var label = dispNode.parentNode.previousSibling.innerText;
   
     //validate the field only constitute by numeral
     if(isNaN(inputValue))
  {
   return Message.getString("SINGLETABLE_NUMBER", label);
  }
  
  //validate the field can not contain "."
  if(inputValue.indexOf(".")!=-1)
  {
    return Message.getString("SINGLETABLE_INTEGER", label);
  }
  
  //validate the field can not begin with "0"
  if(inputValue.length > 1 && inputValue.charAt(0) == '0')
  {
   return Message.getString("SINGLETABLE_INTEGER", label);
  }
   
      message=bmf.validateMinAndMaxValue(inputValue, label, minValue,
     isEqualToMinVal, maxValue, isEqualToMaxVal);
   
  return message;
 };
 
 
 /**
 *validate the scope for input value
 *inputValue:
 *label:
 *minValue: lower limitation for input value
 *isEqualToMinVal: 0: input value must be equal to or bigger than the minValue.
       1: input value can't  be equal to minValue.
       2. input value must be bigger than minValue
 *maxValue: upper limitation for input value
 *isEqualToMaxVal: 0: input value must be equal to or less than the maxValue. 
       1: input value can not be  equal than maxValue  
       2:input value must be  less than maxValue
 */
 bmf.validateMinAndMaxValue = function(inputValue, label,
                              minValue, isEqualToMinVal, maxValue, isEqualToMaxVal)
 {
        
  //validate the input value must be equal to or bigger than the minValue. 
  if ((isEqualToMinVal == 0)&&(!bmf.numCompare(minValue, inputValue)))
  {
   return Message.getString("SINGLETABLE_GREATER_OR_EQUAL", label, minValue);
  }
  //validate the  input value can't be less than minValue
  if((isEqualToMinVal == 1) && (parseFloat(inputValue) == minValue))
  {
    return Message.getString("SINGLETABLE_GREATER", label, minValue);  
  } 
  //validate the  input value must be bigger than minValue
  if((isEqualToMinVal == 2) && (parseFloat(inputValue) <= minValue))
  {
    return Message.getString("SINGLETABLE_GREATER", label, minValue);  
  }

  
  //validate the input value must be equal to or less than the maxValue. 
  if ((isEqualToMaxVal == 0) &&(!bmf.numCompare(inputValue, maxValue)))
  {
   return Message.getString("SINGLETABLE_LESS_EQUAL", label, maxValue);
  }    
  //validate the input value can not be  equal than maxValue   
  if((isEqualToMaxVal == 1) && (parseFloat(inputValue) == maxValue))
  {    
   return Message.getString("SINGLETABLE_LessThan", label, maxValue);
  }
  //validate the input value must be  less than maxValue   
  if((isEqualToMaxVal == 2) && (parseFloat(inputValue) <= maxValue))
  {    
   return Message.getString("SINGLETABLE_LessThan", label, maxValue);
  }
 };
 /**
   * measureTypeName:name of  measureType
   */ 
 bmf.getMeasureObj = function(measureTypeName)
 {
     return bmc.common.ajx.callQueryInterface("/measureConvert/getMeasureDisRuleInputByMeasureTypeName.action?measureTypeName="+measureTypeName);
 };
 
 /**
   *  inputValue: inputValue of smap
   *  label:text label of inputValue
   */ 
 bmf.validateCurrencyUnit=function(inputValue,label)
 {
  //index of dot
        var dotIndex = inputValue.lastIndexOf (".");
       
        if(dotIndex > 0)
        {        
   var measureObj =bmf.getMeasureObj('CURRENCY');
      if(measureObj!=null && measureObj != -1)
      { 
          //get min measure unit
          var measureamount = measureObj.measureamount.toString();
             
          //only input integer        
     var matchInteger=new RegExp(/^(-)?(\d)+?$/); 
     
          //validate small unit integer  
          if((measureamount.length-1)==0&&!matchInteger.test(inputValue))
          {
            return Message.getString("SINGLETABLE_INTEGER", label);
          }
         
         
          // the length of the inputValue decimal
             var decimalLength=inputValue.length - 1 - dotIndex;
                   
          //validate big unit float  
          if(decimalLength > measureamount.length-1 )
          {
           return label+":"+Message.getString("SINGLETABLE_DECIMALPOINT_CHECK_ERROR", measureamount.length-1);
         } 
   }        
        }//if 
        return null;  
  };
 
  /**
  * compare to minBal and maxBal
  * @param minObj
  * @param minLable
  * @param maxObj
  * @param maxLable
  * @param isEqual(0:minValue<maxValue 1:minValue<=maxValue)
  */
 bmf.validateMinMaxBalanceForInt=function(minObj, minLable, maxObj, maxLable, isEqual)
 {
  var minValue = minObj.value;
  var maxValue = maxObj.value;
     var tmpboolean = true;
     if(null != minValue && null != maxValue && minValue!="" && maxValue!="")
     {
      // true: minValue<=maxValue, false:minValue>maxValue
       tmpboolean = bmc.common.ajx.callQueryInterface("/bus_singletable_sync/validateMinMaxBalance.action?minBalance="+minValue+"&maxBalance="+maxValue);
     }
     
     // minValue<maxValue
     if(isEqual == 0)
     {
      if(!tmpboolean || (minValue == maxValue))
      {
       return Message.getString('SINGLETABLE_GREATER',maxLable,minLable);
      }
     }
     
     // minValue<=maxValue
     if(isEqual == 1)
     {
      if(!tmpboolean)
      {
       return Message.getString('SINGLETABLE_GREATER_OR_EQUAL',maxLable,minLable);
      }
     }
  
  return null;
 };
   
})();