/*  FileName:ValidationUtility.js
    Description:Common validation functions for the page.
*/

//Adds the error class for the page fields
function addError(obj)
{    
    obj.addClass("error");
}

function removeError(obj)
{  
    obj.addClass("idleField");
}

//Common function for validating the fields with the regex
function validateFields(Field,Regex,InvalidText)
{
    var Fieldvalue = Field.val().replace(/^\s*|\s*$/g, "");   
     if (Fieldvalue != "") { 
         if (Regex.test(Fieldvalue)) {
            removeError(Field);                                
            return "";
        }
        //if it's NOT valid
        else {
            addError(Field); 
            return "Invalid " + InvalidText + "." ;
        }
    }
    else
    {
     return "";
    }

}

//Common validation for required fields 
function validateRequiredfield(obj, fieldName) {
   
    //required field
    if (obj.val() == "") {
        addError(obj); 
        return fieldName + " is required." ;       
    }
    else {
        removeError(obj);       
        return "";
    }
}

//Validates the Name
function validateCompanyName(name, fieldName,IsRequired) {

     var nameRegex = /^[A-Za-z0-9\-\,\.\$\%\&\!\(\)\<\>\?\+\:\@\/\#\'\s]{1,60}$/;
    
    if (IsRequired == true) {
        if (validateRequiredfield(name, fieldName)=="") {                 
         return validateFields(name,nameRegex,fieldName ); 
        }
        else {
            //required field
            return validateRequiredfield(name,fieldName);
        }
    }
    else {       
           return validateFields(name,nameRegex,fieldName );        
    }
}


//Validates the Name
function validateName(name, fieldName,IsRequired) {

     var nameRegex = /^[A-Za-z0-9\-\,\.\$\%\&\!\(\)\<\>\?\+\:\@\/\#\'\s]{1,30}$/;
    
    if (IsRequired == true) {
        if (validateRequiredfield(name, fieldName)=="") { 
                
         return validateFields(name,nameRegex,fieldName );  
           
        }
        else {
            //required field
            return validateRequiredfield(name,fieldName);
        }
    }
    else {       
           return validateFields(name,nameRegex,fieldName );        
    }
}

//Validates the address
function validateAddress(Address, fieldName,IsRequired) {

  
    var AddressRegex =  /^[A-Za-z0-9_ \'\-\,\.\$\%\&\!\(\)\<\>\?\+\:\@\/\#]{1,100}$/;
    
    if (IsRequired == true) {
        if (validateRequiredfield(Address, fieldName)=="") {
           
              return validateFields(Address,AddressRegex,fieldName );  
           
        }
        else {
            //required field
            return validateRequiredfield(Address,fieldName);
        }
    }
    else {       
             return validateFields(Address,AddressRegex,fieldName );  
       
    }
}

//Validates the City
function validateCity(City, fieldName,IsRequired) {

  
    var CityRegex =/^[A-Za-z \-]{1,30}$/;
    
    if (IsRequired == true) {
        if (validateRequiredfield(City, fieldName)=="") {
            
                return validateFields(City,CityRegex,fieldName );  
           
        }
        else {
            //required field
            return validateRequiredfield(City,fieldName);
        }
    }
    else {
       
             return validateFields(City,CityRegex,fieldName );  
       
    }
}

//Validates the State
function validateState(State, fieldName,IsRequired) {
 
    var StateRegex = /^[A-Za-z ]{2,15}$/;
    
    if (IsRequired == true) {
        if (validateRequiredfield(State, fieldName)=="") {
           
                 return validateFields(State,StateRegex,fieldName );  
          
        }
        else {
            //required field
            return validateRequiredfield(State,fieldName);
        }
    }
    else {
       
             return validateFields(State,StateRegex,fieldName );  
      
    }
}

//Validates the Zip
function validateZip(Zip, fieldName,IsRequired) {

    var ZipVal;
    ZipVal = Zip.val().replace(/^\s*|\s*$/g, "");     
    
    var ZipLength;    
    ZipLength = ZipVal.length

    var ZipRegex = /^[\d]{5,15}$/;
    var ZipUSRegex = /^(\d{5})(-\d{4})?$/;
    var ZipCanadaRegex = /^[A-Za-z][0-9][A-Za-z] [0-9][A-Za-z][0-9]$/;
    
    if (IsRequired == true) {
        if (validateRequiredfield(Zip, fieldName)=="") {
                    
                if ((ZipLength == '5') || ( ZipLength == '10' ))
	            {	            
	                 return validateFields(Zip,ZipUSRegex,fieldName + ". Enter in valid either of these formats : 12345 or 12345-1234." );  
	            
		        } 
		         else 
	            {
	                if ((ZipLength == '7') || (ZipLength == '6'))
	                {
	                   
	                  return validateFields(Zip,ZipCanadaRegex,fieldName + ". Enter in a format as :ANA NAN, where A and N refer to alphabet and Number respectively." );  	
		                  
		            }
		            else
		            {
		                 return validateFields(Zip,ZipRegex,fieldName );   
		            }
		         }  
                              
            
        }
        else {
            //required field
            return validateRequiredfield(Zip,fieldName);
        }
    }
    else {
               
             if ((ZipLength == '5') || ( ZipLength == '10' ))
            {	            
                 return validateFields(Zip,ZipUSRegex,fieldName + ". Enter in valid either of these formats : 12345 or 12345-1234." );  
            
	        } 
	         else 
            {
                if ((ZipLength == '7') || (ZipLength == '6'))
                {
                   
                  return validateFields(Zip,ZipCanadaRegex,fieldName + ". Enter in a format as :ANA NAN, where A and N refer to alphabet and Number respectively." );  	
	                  
	            }
	            else
	            {
	                 return validateFields(Zip,ZipRegex,fieldName );   
	            }
	         }
       
    }
}

//Validates the Country
function validateCountry(Country, fieldName,IsRequired) {

    var CountryRegex = /^[A-Za-z ]{2,30}$/;
    
    if (IsRequired == true) {
        if (validateRequiredfield(Country, fieldName)=="") {        
         return validateFields(Country,CountryRegex,fieldName );
        }
        else {
            //required field
            return validateRequiredfield(Country,fieldName);
        }
    }
    else {
      
             return validateFields(Country,CountryRegex,fieldName );
    }
}

//Validates the Currency
function validateCurrency(Currency, fieldName,IsRequired) {

    if (IsRequired == true) {
        if (validateRequiredfield(Currency, fieldName)=="") {           
                return validatecurrencyValue(Currency,fieldName);            
        }
        else {
            //required field
            return validateRequiredfield(Currency,fieldName);
        }
    }
    else {       
            return validatecurrencyValue(Currency,fieldName);         
    }
}

//Validates the currency value
function validatecurrencyValue(Currency,fieldName)
{
    var CurrencyVal;
    CurrencyVal = Currency.val().replace(/^\s*|\s*$/g, ""); 

    var CurrencyRegex = /^(\$)?(\d+)(\.\d{0,2})?$/;
    
    if (CurrencyVal !="")
    {    
        if (CurrencyRegex.test(CurrencyVal)) {
            if (parseFloat(ReplaceCurrencySign(CurrencyVal)) >= 10000000)
            {
                addError(Currency); 
                return  fieldName + "must be less than 10,000,000." ;
        		
            }
            else{	                
            removeError(Currency);              
            return "";
            }
        }
        //if it's NOT valid
        else {
            addError(Currency);
            return "Invalid " + fieldName ;
        }
    }
    else{
    return "";
    }
}

//Validates Notes
function validateNotes(Notes, fieldName,IsRequired) {
  
    if (IsRequired == true) {
        if (validateRequiredfield(Notes, fieldName)=="") {           
                return  validateNotesValue(Notes,fieldName);
          
        }
        else {
            //required field
            return validateRequiredfield(Notes,fieldName);
        }
    }
    else {
       
         return  validateNotesValue(Notes,fieldName);  
       
    }
}

//Validates notes value
function  validateNotesValue(Notes,fieldName)
{
  var NotesVal;
  var InvalidCharacters;
    
    NotesVal = Notes.val().replace(/^\s*|\s*$/g, ""); 

    var NotesRegex = /^[A-Za-z0-9 \'\-\,\.\$\&\!\<\>\?\%\+\:\@\#\/\s]{0,250}$/;
    
    if(NotesVal != "")
    {    
        if (NotesRegex.test(NotesVal)) {
                if (NotesVal.length >= 250)
                {
                    addError(Notes); 
                    return "No of Chracters should be less than 250 in the " + fieldName ;
                }
                else{
                    removeError(Notes);                 
                    return "";
                }
            }
            //if it's NOT valid
            else {
                InvalidCharacters = GetInValidCharacters(NotesVal,"Notes");
                 if (InvalidCharacters != "")
                    {		        
                        addError(Notes);
                        return "Invalid characters " + "(  " + InvalidCharacters + "  )" + " in the input text in " + fieldName +".";
    	              
                    }	
                    else
                    {
                         addError(Notes);
                        return "Invalid " + fieldName +".";
                    }               
              
             }
         }
        else
        {
         return "";
        }

}

//Validates the Email
function validateEmail(Email, fieldName,IsRequired) {

   
    var EmailRegex = /^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$/;
    
    if (IsRequired == true) {
        if (validateRequiredfield(Email, fieldName)=="") {
           
                return validateFields(Email,EmailRegex,fieldName );
          
        }
        else {
            //required field
            return validateRequiredfield(Email,fieldName);
        }
    }
    else {
       
             return validateFields(Email,EmailRegex,fieldName );
      
    }
}

//Validates the Fax

function validateFax(Fax, fieldName,IsRequired) {

    var FaxRegex = /^((\(\d{3}\) ?)|(\d{3}[- \.]))?\d{3}[- \.]\d{4}$/ 
    
    if (IsRequired == true) {
        if (validateRequiredfield(Fax, fieldName)=="") {
           
             return validateFields(Fax,FaxRegex,fieldName );
          
        }
        else {
            //required field
            return validateRequiredfield(Fax,fieldName);
        }
    }
    else {
       
            return validateFields(Fax,FaxRegex,fieldName );
      
    }
}

//Validates the Phone

function validatePhone(Phone, fieldName,IsRequired) {

    var PhoneRegex = /^((\(\d{3}\) ?)|(\d{3}[- \.]))?\d{3}[- \.]\d{4}$/ 
    
    if (IsRequired == true) {
        if (validateRequiredfield(Phone, fieldName)=="") {
           
             return validateFields(Phone,PhoneRegex,fieldName );
          
        }
        else {
            //required field
            return validateRequiredfield(Phone,fieldName);
        }
    }
    else {
       
             return validateFields(Phone,PhoneRegex,fieldName );
      
    }
}

//Validates the Date
function validateDate(Date, fieldName,IsRequired) {

    var DateVal;
    DateVal = Date.val().replace(/^\s*|\s*$/g, ""); 
  
    if (IsRequired == true) {
        if (validateRequiredfield(Date, fieldName)=="") {
        
         if(DateVal != "")
         {        
                var match = chkDate(DateVal); 
			    if (match == false)
			    {
			        addError(Date);
                    return "Invalid " + fieldName +"." ;				
    			
			    }
			    else{
			        removeError(Date);                
                    return "";
			    }
			}
		    else{
		     return "";
		    }
           
        }
        else {
            //required field
            return validateRequiredfield(Date,fieldName);
        }
    }
    else {
        if(DateVal != "")
        {
           var match = chkDate(DateVal); 
			if (match == false)
			{
			    addError(Date);
                return "Invalid " + fieldName +".";				
			
			}
			else{
			    removeError(Date);                  
                return "";
			}
			
		}
	    else{
	     return "";
	    }
      
    }
}

//Validates the Reference Number
function validateRefNum(Ref, fieldName,IsRequired) {

       var RefRegex = /^[A-Za-z0-9-/]{0,25}$/;	
    
    if (IsRequired == true) {
        if (validateRequiredfield(Ref, fieldName)=="") {
        
         return validateFields(Ref,RefRegex,fieldName );
          
        }
        else {
            //required field
            return validateRequiredfield(Ref,fieldName);
        }
    }
    else {
       
            return validateFields(Ref,RefRegex,fieldName );
      
    }
}

//Validates the Number
function validateNumber(Number, fieldName,IsRequired) {
 
 var NumberVal = Number.val().replace(/^\s*|\s*$/g, ""); 

    var NumberRegex =  /^[-+]?[0-9]+$/;
    
    if (IsRequired == true) {
        if (validateRequiredfield(Number, fieldName)=="") {
           
             if( validateFields(Number,NumberRegex,fieldName )=="")
             {
                 if ((parseInt(NumberVal) >= 99999 || parseInt(NumberVal) <= 0 ))
                    {
                         addError(Number);
                         return fieldName + " should be in between : 0 and 99999. ";
                    }
                    else{
                           removeError(Number); 
                           return "";
                        }
             }
             else {       
                    return validateFields(Number,NumberRegex,fieldName );      
                  }
          
        }
        else {
            //required field
            return validateRequiredfield(Number,fieldName);
        }
    }
    else {
       
         if( validateFields(Number,NumberRegex,fieldName )=="")
             {
                 if ((parseInt(NumberVal) >= 99999 || parseInt(NumberVal) <= 0 ))
                    {
                         addError(Number);
                         return fieldName + " should be in between : 0 and 99999. ";
                    }
                    else{
                           removeError(Number); 
                           return "";
                        }
             }
             else {       
                    return validateFields(Number,NumberRegex,fieldName );      
                  }
      
     }
}

//Validates the float fields 
function validateFloat(Float, fieldName,IsRequired) {
 
 var FloatVal = Float.val().replace(/^\s*|\s*$/g, ""); 

    var FloatRegex = /^[-+]?\d+(\.\d+)?$/;
    
    if (IsRequired == true) {
        if (validateRequiredfield(Float, fieldName)=="") {
           
             if( validateFields(Float,FloatRegex,fieldName)=="")
             {
                 if ((parseFloat(FloatVal) >=  99999.00 || parseFloat(FloatVal) <= 0.0 ))
                    {
                         addError(Float);
                         return fieldName + " should be in between : 0 and 99999." ;
                    }
                    else{
                           removeError(Float); 
                           return "";
                        }
             }
             else {       
                    return validateFields(Float,FloatRegex,fieldName);      
                  }
          
        }
        else {
            //required field
            return validateRequiredfield(Float,fieldName);
        }
    }
    else {
       
         if( validateFields(Float,FloatRegex,fieldName)=="")
             {
                  if ((parseFloat(FloatVal) >=  99999.00 || parseFloat(FloatVal) <= 0.0 ))
                    {
                         addError(Float);
                         return fieldName + " should be in between : 0 and 99999. " ;
                    }
                    else{
                           removeError(Float); 
                           return "";
                        }
             }
             else {       
                    return validateFields(Float,FloatRegex,fieldName);      
                  }
      
     }
}

//Validates the Insurance amount
function validateInsurance(InsAmount, fieldName,IsRequired) {
 
 var InsAmountVal = InsAmount.val().replace(/^\s*|\s*$/g, ""); 

    var InsAmountRegex = /^[-+]?\d+(\,|.\d+)(\.\d+)?$/;
  
    if (IsRequired == true) {
        if (validateRequiredfield(InsAmount, fieldName)=="") {
           
             if( validateFields(InsAmount,InsAmountRegex,fieldName)=="")
             {
                 if ((parseFloat(InsAmountVal) >  99999.00 || parseFloat(InsAmountVal) <= 0.0 ))
                    {
                         addError(InsAmount);
                         return fieldName + " should be in between : 0 and 99999." ;
                    }
                    else{
                           removeError(InsAmount); 
                           return "";
                        }
             }
             else {       
                    return validateFields(InsAmount,InsAmountRegex,fieldName);      
                  }
          
        }
        else {
            //required field
            return validateRequiredfield(InsAmount,fieldName);
        }
    }
    else {
       
         if( validateFields(InsAmount,InsAmountRegex,fieldName)=="")
             {
                  if ((parseFloat(InsAmountVal) >  99999.00 || parseFloat(InsAmountVal) <= 0.0 ))
                    {
                         addError(InsAmount);
                         return fieldName + " should be in between : 0 and 99999. " ;
                    }
                    else{
                           removeError(InsAmount); 
                           return "";
                        }
             }
             else {       
                    return validateFields(InsAmount,InsAmountRegex,fieldName);      
                  }
      
     }
}

//Validates the Track A Number
function validateTrackNumField(TrackNum,TrackNumVal, fieldName) {

    var InvalidCharacters;
    
   TrackNumVal = TrackNumVal.replace(/^\s*|\s*$/g, ""); 

    var TrackNumRegex = /^[A-Za-z0-9 \-\,\.\#/]{1,25}$/;
             
    //if it's valid name
    if (TrackNumRegex.test(TrackNumVal)) {
        if (TrackNumVal.length >= 25)
        {
            addError(TrackNum);
            return "No of Chracters should be less than 25 in the " + fieldName ;
        }
        else{
             removeError(TrackNum); 
            return "";
        }
    }
    //if it's NOT valid
    else {
        InvalidCharacters = GetInValidCharacters(TrackNumVal,"TrackNum");
         if (InvalidCharacters != "")
            {		        
                 addError(TrackNum);
                return "Invalid characters " + "(  " + InvalidCharacters + "  )" + " in the input text in " + fieldName ;
              
            }	
            else
            {
                 addError(TrackNum);
                return "Invalid " + fieldName ;
            }               
      
    }
          
}

//Validate the combo
function validateCombo(Combo, fieldName)
{
    var ComboVal;
    ComboVal = Combo.val().replace(/^\s*|\s*$/g, ""); 
    
     if (ComboVal == "0" )
		{
		  	
		    Combo.addClass("error"); 		    	
			return "Please select the " + fieldName + "." ;
		}
		else
		{
		    Combo.removeClass("error");   
		             
            return ""; 
		}
    
}


//This function checks for the currency value in the input string and replaces it  
function ReplaceCurrencySign(Value)
{
    var CurrencyValue = (Value).replace(/^\s*|\s*$/g,"");
    CurrencySign = new Array("$","€");
    for (var cnt= 0 ; cnt < CurrencySign.length; cnt++ )
    {
         if (CurrencyValue.indexOf(CurrencySign[cnt]) >= 0)
         {
            CurrencyValue.replace(CurrencySign[cnt]);
            return CurrencyValue;
         }
    } 
}


//Function for getting the invalid chracters
function GetInValidCharacters(InputStr,InputType)
{ 
    var InvalidCharStr="";
    var ArrLength;
    var InvalidCharArr;
    
    //Check the input type for validation check
    switch(InputType)
    {
        case "Ref":
            InvalidCharArr = new Array("^","[","]","{","}","=","`","|","<",">","(",")");      
            break;    
        case "Name":
            InvalidCharArr = new Array("*","~","^","[","]","{","}","=","`","|");      
            break;
        case "Address":
            InvalidCharArr = new Array("*","~","^","[","]","{","}","=","`","|");      
            break;
        case "Notes":
            InvalidCharArr = new Array("^","[","]","{","}","=","`");      
            break;
        case "City":
            InvalidCharArr = new  Array("*","~","^","[","]","{","}","=","`","|");     
            break;
       case "Entity":
            InvalidCharArr = new  Array("*","~","^","[","]","{","}","=","`","|");  
            break;      
        case "Desc":
            InvalidCharArr = new Array("*","~","^","[","]","{","}","=","`","|");     
            break;
        case "TrackNum":  
             InvalidCharArr = new Array("!","@","(",")","$","&","*","~","%","^","+",";","<",">","[","]","{","}","=",",","'","`",'"',"|","?",":","_","\\")           
        default : 
            InvalidCharArr = new  Array("*","~","^","[","]","{","}","=","`","|");  
            break;
   }
   
   //Get the length of the special character array
    ArrLength = InvalidCharArr.length;
    
    //Check the invalid characters present in the in put string
    for (var cnt = 0 ; cnt < ArrLength; cnt++)
    {
        if (InputStr.indexOf(InvalidCharArr[cnt]) >= 0)
        {                  	      
            InvalidCharStr = InvalidCharStr + " " + InvalidCharArr[cnt];    		
        }                
    }    
    
    //return the invalid characters present in the input string
    if (InvalidCharStr != "")
    {
        return InvalidCharStr;
    }   
    else
    {
          return ""
    }      
}

//This function validates the date value
function chkDate(mDate)
{
    var checkstr = "0123456789";
    var DateTemp = "";
    var day;
    var month;
    var year;
    var leap = 0;
    var err = 0;
    var DateValue = new String(mDate);

    var Pat = /^\d*$/;
       
    month = DateValue.substring(0,DateValue.indexOf("/"));
    DateValue = DateValue.substr(DateValue.indexOf("/")+1)
    day = DateValue.substring(0,DateValue.indexOf("/"));
    DateValue = DateValue.substr(DateValue.indexOf("/")+1)
       
    if ((month.length != 2) || (day.length != 2) || (DateValue.length!= 4))
    {        		    		
	    return false;
    }
          
    if (DateValue < "1900")
    {
	    err = 1; 
    }
    else 
    {
	    year = DateValue;
    }
    var matchMonth =month.match(Pat);
    var matchDay=day.match(Pat)
    var matchYear=DateValue.match(Pat)

    if ((matchMonth == null) || (matchDay == null) || (matchYear == null) )
    {
        return false;
    }    
    if (year == 0) 
    {
         err = 2;
    }
    /* Validation of month*/
    if ((month < 1) || (month > 12)) 
    {
         err = 3;
    }
    /* Validation of day*/
    //day = DateValue.substr(0,2);
    if ((day < 1) || (day > 31)) 
    {
        err = 4;
    }
    /* Validation leap-year / february / day */
    if (year % 4 == 0) 
    {
        leap = 1;
    }
    if ((month == 2) && (leap == 1) && (day > 29)) 
    {
        err = 6;
    }
    if ((month == 2) && (leap != 1) && (day > 28)) 
    {
        err = 7;
    }

    /* Validation of other months */
    if ((day > 31) && ((month == "01") || (month == "03") || (month == "05") || (month == "07") || (month == "08") || (month == "10") || (month == "12"))) 
    {
        err = 8;
    }
    if ((day > 30) && ((month == "04") || (month == "06") || (month == "09") || (month == "11"))) 
    {
        err = 9;
    }

    if (err == 0)
    {
	    return true;
    }
    else 
    {      		
	    return false;
    }  	
}	

//Validates the Time
function validateTime(Time, fieldName,IsRequired) {

           
    if (IsRequired == true) {
        if (validateRequiredfield(Time, fieldName)=="") {
        
         return ValidateTimeValue(Time,fieldName );
          
        }
        else {
            //required field
            return validateRequiredfield(Time,fieldName);
        }
    }
    else {
       
            return ValidateTimeValue(Time,fieldName);
      
    }

}


//this function validates the Time value
function ValidateTimeValue(Time,fieldName) 
{
  var TimeVal;
     
   TimeVal = Time.val().replace(/^\s*|\s*$/g, ""); 
// Checks if time is in HH:MM:SS AM/PM format.

    var timePat = /^(\d{2}):(\d{2})$/;
    var matchArray = TimeVal.match(timePat);
    
    if(TimeVal !="")
    {
        if (matchArray == null)
        {
	          addError(Time);
              return  fieldName +" is not in a valid format.";
        }
        else
        {
	        hour = matchArray[1];
	        minute = matchArray[2];

	        if (hour < 0  || hour > 23)
	        {	  
	           addError(Time);
               return  fieldName +"  Hour must be between 0 and 23.";
	        }    

	        if (minute < 0 || minute > 59)
	        {	    
	            addError(Time);
                return  fieldName +"  Minute must be between 0 and 59.";
	        }
         else{
               removeError(Time); 
               return "";
            }
        }
    } 
    else{
        return "";
    }   	
    
}


// Validation for the details section

//Added the error class for details
function addErrorDetails(obj)
{
 obj.className = "error";
}

function removeErrorDetails(obj)
{
  obj.className = "bodytext";
}

//Validation for the required fields for details
function validateRequiredfieldDetails(obj, fieldName) {
  
    //required field
    if (obj.value == "") {
        addErrorDetails(obj); 
        return fieldName + " is required. " ;       
    }
    else {
        removeErrorDetails(obj);       
        return "";
    }
}

//Validates the fields for the regex for details
function validateFieldsDetails(Field,Regex,InvalidText)
{

    var Fieldvalue = Field.value.replace(/^\s*|\s*$/g, "");   
     if (Fieldvalue != "") { 
         if (Regex.test(Fieldvalue)) {
            removeErrorDetails(Field);                                
            return "";
        }
        //if it's NOT valid
        else {
            addErrorDetails(Field); 
            return "Invalid " + InvalidText + " as " + Fieldvalue ;
        }
    }
    else
    {
     return "";
    }

}

//Validates the number fields for the details
function validateNumberForDetails(Number, fieldName,IsRequired) {
 
 var NumberVal = Number.value.replace(/^\s*|\s*$/g, ""); 

    var NumberRegex =  /^[-+]?[0-9]+$/;
    
    if (IsRequired == true) {
        if (validateRequiredfieldDetails(Number, fieldName)=="") {
           
             if( validateFieldsDetails(Number,NumberRegex,fieldName)=="")
             {
                 if ((parseInt(NumberVal) >= 99999 || parseInt(NumberVal) < 0 ))
                    {
                         addErrorDetails(Number);
                         return fieldName + " should be in between : 0 and 99999." ;
                    }
                    else{
                           removeErrorDetails(Number); 
                           return "";
                        }
             }
             else {       
                    return validateFieldsDetails(Number,NumberRegex,fieldName);      
                  }
          
        }
        else {
            //required field
            return validateRequiredfieldDetails(Number,fieldName);
        }
    }
    else {
       
         if( validateFieldsDetails(Number,NumberRegex,fieldName)=="")
             {
                 if ((parseInt(NumberVal) >= 99999 || parseInt(NumberVal) < 0 ))
                    {
                         addErrorDetails(Number);
                         return fieldName + " should be in between : 0 and 99999. " ;
                    }
                    else{
                           removeErrorDetails(Number); 
                           return "";
                        }
             }
             else {       
                    return validateFieldsDetails(Number,NumberRegex,fieldName);      
                  }
      
     }
}


//Validates the number fields for the details
function validateFloatForDetails(Float, fieldName,IsRequired) {
 
 var FloatVal = Float.value.replace(/^\s*|\s*$/g, ""); 

    var FloatRegex = /^[-+]?\d+(\.\d+)?$/;
    
    if (IsRequired == true) {
        if (validateRequiredfieldDetails(Float, fieldName)=="") {
           
             if( validateFieldsDetails(Float,FloatRegex,fieldName)=="")
             {
                 if ((parseFloat(FloatVal) >=  99999.00 || parseFloat(FloatVal) < 0.0 ))
                    {
                         addErrorDetails(Float);
                         return fieldName + " should be in between : 0 and 99999." ;
                    }
                    else{
                           removeErrorDetails(Float); 
                           return "";
                        }
             }
             else {       
                    return validateFieldsDetails(Float,FloatRegex,fieldName);      
                  }
          
        }
        else {
            //required field
            return validateRequiredfieldDetails(Float,fieldName);
        }
    }
    else {
       
         if( validateFieldsDetails(Float,FloatRegex,fieldName)=="")
             {
                  if ((parseFloat(FloatVal) >=  99999.00 || parseFloat(FloatVal) < 0.0 ))
                    {
                         addErrorDetails(Float);
                         return fieldName + " should be in between : 0 and 99999. " ;
                    }
                    else{
                           removeErrorDetails(Float); 
                           return "";
                        }
             }
             else {       
                    return validateFieldsDetails(Float,FloatRegex,fieldName);      
                  }
      
     }
}

//Validates the description for details
function validateDesDetails(Notes, fieldName,IsRequired) {
  
    if (IsRequired == true) {
        if (validateRequiredfieldDetails(Notes, fieldName)=="") {           
                return  validateDesValueDetails(Notes,fieldName);
          
        }
        else {
            //required field
            return validateRequiredfieldDetails(Notes,fieldName);
        }
    }
    else {
       
         return  validateDesValueDetails(Notes,fieldName);  
       
    }
}

//validates the description value
function  validateDesValueDetails(Notes,fieldName)
{
  var NotesVal;
  var InvalidCharacters;
    
    NotesVal = Notes.value.replace(/^\s*|\s*$/g, ""); 

    var NotesRegex = /^[A-Za-z0-9 \'\-\,\.\$\&\!\<\>\?\%\+\:\@\#\/\s]{0,100}$/;
    
    if(NotesVal != "")
    {    
        if (NotesRegex.test(NotesVal)) {
            if (NotesVal.length >= 250)
            {
                addErrorDetails(Notes); 
                return "No of Chracters should be less than 250 in the " + fieldName ;
            }
            else{
                removeErrorDetails(Notes);                 
                return "";
            }
        }
        //if it's NOT valid
        else {
            InvalidCharacters = GetInValidCharacters(NotesVal,"Notes");
            if (InvalidCharacters != "") {		        
                addErrorDetails(Notes);
                return "Invalid characters " + "(  " + InvalidCharacters + "  )" + " in the input text in " + fieldName +" as " + NotesVal ;
              
            }	
            else {
                 addErrorDetails(Notes);
                return "Invalid " + fieldName + "as" + NotesVal;
            }             
         }
     }
    else
    {
     return "";
    }
}


//Validates the Currency
function validateCurrencyDetails(Currency, fieldName,IsRequired) {

    if (IsRequired == true) {
        if (validateRequiredfieldDetails(Currency, fieldName)=="") {           
                return validatecurrencyValueDetails(Currency,fieldName);            
        }
        else {
            //required field
            return validateRequiredfieldDetails(Currency,fieldName);
        }
    }
    else {       
            return validatecurrencyValueDetails(Currency,fieldName);         
    }
}

//Validates the currency value
function validatecurrencyValueDetails(Currency,fieldName)
{

    var CurrencyVal;
    CurrencyVal = Currency.value.replace(/^\s*|\s*$/g, ""); 

    var CurrencyRegex = /^(\$)?(\d+)(\.\d{0,2})?$/;
    
    if (CurrencyVal !="")
    {    
        if (CurrencyRegex.test(CurrencyVal)) {
            if (parseFloat(ReplaceCurrencySign(CurrencyVal)) >= 10000000)
            {
                addErrorDetails(Currency); 
                return  fieldName + "must be less than 10,000,000" ;
        		
            }
            else{	                
            removeErrorDetails(Currency);              
            return "";
            }
        }
        //if it's NOT valid
        else {
            addErrorDetails(Currency);
            return "Invalid " + fieldName + " as " + CurrencyVal ;
        }
    }
    else{
    return "";
    }
}


//Validates the Reference Number
function validateRefNumDetails(Ref, fieldName,IsRequired)
{
    var RefRegex = /^[A-Za-z0-9-/]{0,25}$/;	
    
    if (IsRequired == true) {
        if (validateRequiredfieldDetails(Ref, fieldName)=="") {
        
         return validateFieldsDetails(Ref,RefRegex,fieldName);
          
        }
        else {
            //required field
            return validateRequiredfieldDetails(Ref,fieldName);
        }
    }
    else {      
            return validateFieldsDetails(Ref,RefRegex,fieldName);
      
    }
}

//Validates the Reference Number
function validateTrackingNumDetails(Number, fieldName,IsRequired)
{
    var NumRegex = /^\d+$/;
    
    if (IsRequired == true) {
        if (validateRequiredfieldDetails(Number, fieldName)=="") {
        
         return validateFieldsDetails(Number,NumRegex,fieldName);
          
        }
        else {
            //required field
            return validateRequiredfieldDetails(Number,fieldName);
        }
    }
    else {      
            return validateFieldsDetails(Number,NumRegex,fieldName);
      
    }
}

//Validates the User name password
function validateUserNamePassword(name, fieldName,IsRequired) {

     var nameRegex = /^[A-Za-z0-9_]{1,20}$/
    
    if (IsRequired == true) {
        if (validateRequiredfield(name, fieldName)=="") { 
                
         return validateFields(name,nameRegex,fieldName );  
           
        }
        else {
            //required field
            return validateRequiredfield(name,fieldName);
        }
    }
    else {       
           return validateFields(name,nameRegex,fieldName );        
    }
}

//Validates the login for email and login name
function validateLogin(LoginText, fieldName,IsRequired) {

    var UserEmailNameMsg = validateEmail(LoginText, fieldName,IsRequired);

    if (UserEmailNameMsg != "") {         
         var UserNameMsg = validateUserNamePassword(LoginText, fieldName,IsRequired);   
         if (UserNameMsg != "") {         
                return UserNameMsg;
         }
         else return "" 
    }
    else return ""   
    
}

//Validates the Quote Number
function validateQuoteNumber(Number, fieldName,IsRequired) {

    var NumberRegex =  /^[-+]?[0-9]+$/;
    
    if (IsRequired == true) {
        if (validateRequiredfield(Number, fieldName)=="") { 
                
         return validateFields(Number,NumberRegex,fieldName );  
           
        }
        else {
            //required field
            return validateRequiredfield(Number,fieldName);
        }
    }
    else {       
           return validateFields(Number,NumberRegex,fieldName);        
    }
}

var ErroMsgCol;
var ErrorMsg;
var ErrorCount;
    
function GenericFormValidator()
{

    var Index;
    var FieldTitleText = "";
    var ValidationType = "";
    var IsRequiredField = "";
    var ControlObjVal = "";
    var ControlObj = "";
    var ValTypeArr = ['Email','Fax','Name','Time', 'Entity','Phone', 'Date','Address','City', 'State', 'Country', 'Zip','Notes','Desc','URL','Ref']
    var ErrorMsgArr = new Array();   
    var BrowserAgentVal = navigator.userAgent.toLowerCase();
    
    ErrorMsgArr[0]= "";
    ErroMsgCol = "";
    ErrorMsg= "";
    ErrorCount= 1;
    
    //Run loop of all form controls
    for(Index=0;Index<=document.forms[0].length-1;Index++)
    {
        if(BrowserAgentVal.indexOf("msie") > -1)
        {
            FieldTitleText = document.forms[0].item(Index).TitleText;
            ValidationType = document.forms[0].item(Index).ValidationType;
            IsRequiredField = document.forms[0].item(Index).IsRequired;
            ControlObj = document.forms[0].item(Index);    
        }
        else
        {
            FieldTitleText = document.forms[0].elements[Index].getAttribute("TitleText");
            ValidationType = document.forms[0].elements[Index].getAttribute("ValidationType");
            IsRequiredField = document.forms[0].elements[Index].getAttribute("IsRequired");
            ControlObj = document.forms[0].elements[Index];    
        }
    
        //Check mandetory controls
        if((FieldTitleText !="") && (typeof(FieldTitleText)!="undefined"))
        {
            //Check type of controls
            if(ControlObj.type == "text")
            {    
                //Reset the border style
                ControlObj.style.border = 'none'
                                  
                //Validate empty text controls
                if(ControlObj.value == "")
                {
                    if(IsRequiredField == "True")
                    {
                        ErrorMsgStr = ErrorCount + " . " + FieldTitleText + " is a required field.";
                        ValidationMessage(ErrorMsgStr,"");
                        ControlObj.style.border = '1px solid #FF0000'
                    }                    
                }
                else
                {                
                    for(var Count = 0 ; Count <= ValTypeArr.length; Count++ )
                    {
                        if( ValidationType == ValTypeArr[Count])
                        {
                            if(IsValid(ValidationType,ControlObj.value) == false)
                            {
                               ValidationMessage(ErrorMsgStr,FieldTitleText);
                                ControlObj.style.border = '1px solid #FF0000';                           
                            }                        
                        }                    
                    }                                                        
                 }                 
            }
            else if(ControlObj.type == "checkbox")
            {  
                 if(IsRequiredField == "True")
                 {         
                   if(! ControlObj.checked)
                    {
                        ErrorMsgStr = ErrorCount + " . " + FieldTitleText + " is a required field.";
                        ValidationMessage(ErrorMsgStr,"");
                        ControlObj.style.border = '1px solid #FF0000'
                    }  
                }             
            }           
        }
    }
    
    //call the method for details validation
    //ValidateMandetoryLineItem();
    
    //Check the error messages and then return the message as an array.
    if(ErroMsgCol!="")
    {   
        ErrorCount = ErrorCount-1;
        ErrorMsgArr[0] = ErrorCount + " Error occured in the form.";
        ErrorMsgArr[1] = ErroMsgCol;
    }
    
    return ErrorMsgArr;
 } 
  //Apply Rule and Validate
 function IsValid(ValidationType,ControlVal)
 {
    var RegExp;
    var RegMatch;
    var InvalidErrorMsg = "Please enter a valid ";
    ErrorMsgStr = "";
    
    switch(ValidationType)
    {    
        case "Email":
            RegExp = /^(\".*\"|[A-Za-z]\w*)@(\[\d{1,3}(\.\d{1,3}){3}]|[A-Za-z]\w*(\.[A-Za-z]\w*)+)$/;
            ErrorMsgStr = InvalidErrorMsg;
            break;
        case "URL":
            //RegExp = /^[A-Za-z]+://[A-Za-z0-9-_]+\\.[A-Za-z0-9-_%&\?\/.=]+$/;
             ErrorMsgStr = InvalidErrorMsg ;
            break;
        case "Date":
            RegExp = /^(?=\d)(?:(?:(?:(?:(?:0?[13578]|1[02])(\/|-|\.)31)\1|(?:(?:0?[1,3-9]|1[0-2])(\/|-|\.)(?:29|30)\2))(?:(?:1[6-9]|[2-9]\d)?\d{2})|(?:0?2(\/|-|\.)29\3(?:(?:(?:1[6-9]|[2-9]\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))|(?:(?:0?[1-9])|(?:1[0-2]))(\/|-|\.)(?:0?[1-9]|1\d|2[0-8])\4(?:(?:1[6-9]|[2-9]\d)?\d{2}))($|\ (?=\d)))?(((0?[1-9]|1[012])(:[0-5]\d){0,2}(\ [AP]M))|([01]\d|2[0-3])(:[0-5]\d){1,2})?$/;
            ErrorMsgStr = InvalidErrorMsg;
            break;
        case "Name":
            RegExp = /^[A-Za-z0-9\-\,\.\$\%\&\!\(\)\<\>\?\+\:\@\/\#\'\s]{1,30}$/;
             ErrorMsgStr = InvalidErrorMsg;
            break;
        case "Address":
            RegExp = /^[A-Za-z0-9_ \''\-\,\.\$\%\&\!\(\)\<\>\?\+\:\@\/\#]{1,100}$/;
             ErrorMsgStr = InvalidErrorMsg;
            break;
        case "City":
            RegExp = /^[A-Za-z \-]{1,30}$/;
             ErrorMsgStr = InvalidErrorMsg;
            break;
        case "State":
            RegExp = /^[A-Za-z ]{2,15}$/;
             ErrorMsgStr = InvalidErrorMsg;
            break;
        case "Desc":
            RegExp = /^[A-Za-z0-9 \''\-\,\.\$\&\!\<\>\?\%\+\:\@\#\/\s]{0,100}$/;
             ErrorMsgStr = InvalidErrorMsg;
            break;
        case "Notes":
            RegExp = /^[A-Za-z0-9 \''\-\,\.\$\&\!\<\>\?\%\+\:\@\#\/\s]{0,250}$/;
             ErrorMsgStr = InvalidErrorMsg ;
            break;
        case "Country":
            RegExp = /^[A-Za-z ]{2,30}$/; 
             ErrorMsgStr = InvalidErrorMsg ;
            break;
        case "Fax":
            RegExp = /^((\(\d{3}\) ?)|(\d{3}[- \.]))?\d{3}[- \.]\d{4}$/; 
             ErrorMsgStr = InvalidErrorMsg ;
            break;
        case "Phone":
            RegExp = /^((\(\d{3}\) ?)|(\d{3}[- \.]))?\d{3}[- \.]\d{4}$/; 
             ErrorMsgStr = InvalidErrorMsg ;
            break;
        case "Ref":
            RegExp = /^[A-Za-z0-9 \-\,\.\#\/]{1,25}$/;
             ErrorMsgStr = InvalidErrorMsg ;
            break;
         case "Time":
            RegExp = /^([0-1][0-9]|[2][0-3]):([0-5][0-9])$/;
             ErrorMsgStr = InvalidErrorMsg ;
            break;
         case "Money":
            RegExp = /^(\$|)([1-9]\d{0,2}(\,\d{3})*|([1-9]\d*))(\.\d{2})?$/;
             ErrorMsgStr = InvalidErrorMsg ;
            break;
    }
    
    //Check the regular expresion match
    RegMatch = ControlVal.match(RegExp);
    
    if (RegMatch == null)
    {
        return false;
    }
    return true;
 }

//Sets the validation mesage
function ValidationMessage(ErrorMsgStr,Obj)
{
    if(ErrorMsgStr != "")
    {
        if(Obj != ""){
            ErroMsgCol =  ErroMsgCol + "\n" + ErrorCount + " . " + ErrorMsgStr + " at " + "" + Obj + "";
            ErrorCount++;
        } 
        else{
            ErroMsgCol = ErroMsgCol + "\n" + ErrorMsgStr;
            ErrorCount++;
        }        
    }    
}

//This function validate the details item and make sure that one line item is placed
function ValidateMandetoryLineItem()
{ 
     var GridViewId = "ctl00_MasterCph_InvoiceDetailsGv";
     var SectionId = "_ctl02_";
     var BaseId = GridViewId + SectionId;
     
     var Qty = document.getElementById(BaseId + "QtyTxt").value;
     var PkgType = document.getElementById(BaseId + "PackageTypeCmb").value;
     var Weight =  document.getElementById(BaseId + "EstimatedWgtTxt").value;
     var Description  = document.getElementById(BaseId + "DescriptionTxt").value;
     var Length = document.getElementById(BaseId + "LengthTxt").value
     var Width = document.getElementById(BaseId + "WidthTxt").value;
     var Height =  document.getElementById(BaseId + "HeightTxt").value;
     var DimenWeight = document.getElementById(BaseId + "DimWgtTxt").value;
     
     if((Qty == "") && (PkgType == "0") && (Weight == "") && (Description == "") && (Length == "") && (Height == "") && (DimenWeight == "") )
     {
        ValidationMessage(ErrorCount + " . One line items is mandetory for the shipment.","");
     }
}