/** 
* All the javascript form validation code
*
* @author Sachin Gadia
* @version $RCSfile: validate.js,v $ $Revision: 1.30 $ $Date: 2006/05/19 08:13:12 $ $Author: vsingh $
*/

/***************************************************************************************************
**			KEY CODES
***************************************************************************************************/
var TAB_DOWN_KEY 	= 35;
var TAB_UP_KEY 		= 36; 
var ENTER_KEY 		= 13;
var ESC_KEY 		= 27; 
var BACKSPACE_KEY 	= 8; 
var TAB_KEY 		= 9;
var F9_KEY 			= 120;
var F12_KEY			= 123;

var A_KEY 		= 65;
var B_KEY 		= 66;
var C_KEY 		= 67;
var D_KEY 		= 68;
var E_KEY 		= 69;
var F_KEY 		= 70;
var G_KEY 		= 71;
var H_KEY		= 72;
var I_KEY 		= 73;
var J_KEY 		= 74;
var K_KEY 		= 75;
var L_KEY 		= 76;
var M_KEY 		= 77;
var N_KEY		= 78;
var O_KEY 		= 79;
var P_KEY 		= 80;
var Q_KEY 		= 81;
var R_KEY 		= 82;
var S_KEY 		= 83;
var T_KEY 		= 84;
var U_KEY 		= 85;
var V_KEY 		= 86;
var W_KEY		= 87;
var X_KEY       = 88;
var Y_KEY		= 89;
var Z_KEY		= 90;

// HTML Control Names
var TEXTFIELD	= "TEXT" ;
var PASSWORD	= "PASSWORD" ;
var COMBOBOX	= "SELECT-ONE" ;
var TEXTAREA	= "TEXTAREA" ;
var V_TRUE = "1";

/***************************************************************************************************
**			END OF KEY CODES
***************************************************************************************************/
// constant declaration for use it through out the program
var cEMAIL					= 'email';
var cNULL					= 'null';
var cPHONE					= 'phone';
var cSSN					= 'ssn';
var cNUMERIC				= 'numeric';
var cDATE					= 'date'; 
var SSN_MASK				= "XXX-XX-XXXX";	//Format(Mask) String
var PHONE_NO_MASK			= "999-999-9999";	//Format(Mask) String
var ZIPCODE_MASK			= "99999-9999";	//Format(Mask) String
var ZIP_PART1_MASK          = "99999";
var NDC_MASK				= "XXXXX-XXXX-XX";	//Format(Mask) String

var EMPTY_STR = "IS EMPTY";
var NON_EMPTY_STR = "IS NOT EMPTY";
var BETWEEN_STR = "BETWEEN";
var NULL_STR = "IS NULL";
var NON_NULL_STR = "IS NOT NULL";
var ERROR_CODE_TAG = "KEY";
var ERROR_MESSAGE_TAG = "MESSAGE";
var HEADER_CODE_INDEX = 0;

//******************************************************************************************************
// REGILAR EXPRESSION
//******************************************************************************************************
/*var reWhitespace = /^\s+$/;
var reLetter = /^[a-zA-Z]$/;
var reAlphabetic = /^[a-zA-Z]+$/;
var reAlphanumeric = /^[a-zA-Z0-9]+$/;
var reDigit = /^\d/;
var reLetterOrDigit = /^([a-zA-Z]|\d)$/;
var reInteger = /^\d+$/;
var reSignedInteger = /^(+|-)?\d+$/;
var reFloat = /^((\d+(\.\d*)?)|((\d*\.)?\d+))$/;*/


//******************************************************************************************************
// VALIDATION FUNCTIONS
//******************************************************************************************************

/**
* Funtion used to check blank value of a given string.
*/ 
function fnIsEmpty(pStrField){
    var lblnSuccess = true;
	var lstrTemp="";				
	var lstrTemp=fnTrim(pStrField);
	var len = lstrTemp.length;
	if (!(lstrTemp == null || len==0)){
		lblnSuccess=false;			
	}			
	return lblnSuccess;
}

/**
* Funtion used to check blank value in numeric field.
*/ 
function fnIsNumericEmpty(pStrField){
    var lblnSuccess = true;
	if (!(pStrField == null || pStrField.length==0)){
		lblnSuccess=false;			
	}			
	return lblnSuccess;
}

/**
* Funtion used to check whitespaces
*/ 
function fnIsWhiteSpaces(pStrField){
	if (pStrField.indexOf(" ")!=-1){
		return true;
	}else{
		return false;
	}
}

/**
* Function checks for the length of Text Box.
*/ 
function fnCheckTextLength(pValue, pLength){		
	if (pValue.length > pLength){
		return false;
	}
	return true;	
}


/**
* Checks the size of the value entered in the text area is within the specified limitor not. 
*/
function fnCheckTextAreaLength(pValue, pLength, pLabel){
	var conValue = pValue;			
	if (fnTrim(conValue) != ""){
		var len = conValue.length;
		if (len > (pLength - 0)){			
			return (fnGetMessage(MAXLENGTH_MSG, pLabel , pLength));
		}else{
			return "";
		}
	}else{
		return (fnGetMessage(BLANK_MSG, pLabel));
	}
		
}
/**
* Check Text Area max size
*/
function fnCheckTextArea(pValue, pLength, pLabel){		
	var errMsg = "";
	errMsg = fnCheckTextAreaLength(pValue, pLength, pLabel);			
	fnPrintMsg(errMsg);
	return errMsg;
}

/**
* Check Text Area max size while user typing
*/
function fnCheckTextAreaLengthOnType(pValue, pLength, pLabel){
	/*if (pValue.length>pLength){
		var errMsg = fnCheckTextArea(pValue, pLength, pLabel);
		fnPrintMsg("\n" + errMsg);
		return;
	}
	
	Ref 99 Issue
	if (pValue.length<pLength){
		fnRemoveErrorPanel();
		return;
	}*/
}


/**
* Function used to print status message.
*/ 
function fnPrintStatusMsg(vStatusMessage){
	var obj = $('msgStatus');
	var statusMsg = $('StatusMessage');
	
	if (vStatusMessage != ""){		
		obj.style.display = "block";			
		statusMsg.innerHTML = vStatusMessage;
	}else{
		statusMsg.innerHTML = '';
		obj.style.display = "none";		
	}
}


/**
* Function used to print error in the text area.
*/ 
function fnPrintMsg(vErrorMessage){
	var obj = $('errorPanel');
	var errTxtArea = $('ErrorMessage');
	
	if (vErrorMessage != ""){		
		if (vErrorMessage == 'null'){
			obj.style.display = "block";			
			errTxtArea.value = CONTACT_SYSTEM_ADMIN;			
		}else{	
			obj.style.display = "block";			
			errTxtArea.value = fnTrimNewLine(fnTrim(vErrorMessage));
		}
	}else{			
		obj.style.display = "none";
		errTxtArea.value = '';
	}
}
/**
* Remove Error Panel
*/ 
function fnRemoveErrorPanel(){
	var obj = $('errorPanel');
	var errTxtArea = $('ErrorMessage');
		obj.style.display = "none";
		errTxtArea.value = '';
}
/**
* Function to trim line
*/
function fnTrimNewLine(pMsg){
	if (pMsg != null && pMsg != ""){
		if (pMsg.charAt(0) == "\n"){
			var len = pMsg.length;
			if (len > 1){
				pMsg = pMsg.substring(1,len)
			}
		}
	}
	return pMsg;
}

/**
* Function used to reset controls to its original value.
*/
function fnReset(){
	var obj = $('errorPanel');
	var errTxtArea = $('ErrorMessage');
	obj.style.display = "none";
	errTxtArea.value = '';
}

/**
* Function used to remove left blank spaces from a given string.
*/
function fnLTrim(pStr){
	var lstrTemp = pStr;
	var len = lstrTemp.length;
	while (len > 0 && lstrTemp.charAt(0) == " "){
		lstrTemp = lstrTemp.substring(1, len);
	}
	return lstrTemp;
}

/**
* Function used to remove right blank spaces from a given string.
*/
function fnRTrim(pStr){
	var lstrTemp = pStr;
	var len = lstrTemp.length;
	
	while (len > 0 && lstrTemp.charAt(len - 1) == " "){
		lstrTemp = lstrTemp.substring(0, len - 1);
		len = lstrTemp.length;
	}
	
	return lstrTemp;
}

/**
* Function used to remove right & left blank spaces  from a given string.
*/
function fnTrim(pStr){
	return fnRTrim(fnLTrim(pStr));
}

//Function checks the validitiy of the email field value. 	Valid Characters are [a-z, A-Z, 0-9,'.','-','_' ]
function fnValidateEmail(pstrFieldValue){
	var lblnSuccess=false;
	var lstrTemp='';
	var lintCount=0;
	var lintDot=0;		
	var lintPos=0;

	lstrTemp=pstrFieldValue;
	lstrTemp=fnTrim(lstrTemp);
	
	var len = lstrTemp.length;
	//Check for @ and '.' in the E-mail string, 
	for (lintIndex = 0; lintIndex < len; lintIndex++){
		var char1 = lstrTemp.charAt(lintIndex);
		
		if ((char1 >= '0' && char1 <= '9') || (char1 == "@" || char1 == "." || char1 == "_" || char1 == "-") || (char1 >= "a" && char1 <= "z") || (char1 >= "A" && char1 <= "Z")) {
			if (char1=='@'){	
				  lintPos=lintIndex;			  
				  ++lintCount;
			}
			if (char1=='.'){			      
				++lintDot;
			}
		}else{			
			return false;
		}		
	}	

	//Character @ should not be more than once		
	if (lintCount==1){		    
		if (lstrTemp.charAt(0)!='@' && lstrTemp.charAt(len-1)!='@'){
		    //After @, '.' should not come 
		    if (lstrTemp.charAt(lintPos+1)=='.')
			   return lblnSuccess;

		   	//Character '.' should be present in the E-mail	
			if (lintDot >= 1){
				if (lstrTemp.charAt(0)!='.' && lstrTemp.charAt(len-1)!='.')		
					lblnSuccess=true;						
			}				
		}
	}
	return lblnSuccess;
}

//Function checks whether a given string is numeric or not

function fnIsDigit(pStr){
	var counter=0;  			
	//removing the leading and trialing spaces
	pStr = fnTrim( pStr );
	
	var len = 	pStr.length;
	for (counter=0;counter < len; counter++){
		var char1 = pStr.charAt(counter) ;
		if (char1 < "0" || char1 > "9")
			return false;
	}
	return true;
}

function fnGenericValidation(sErrMsg,sNameArray,sValueArray,sTypeOfValidation){
	var sErrs='';
	if(sErrMsg != null){
		sErrs=sErrs+sErrMsg;
	}
	
	if(sTypeOfValidation == cNULL){ 
		sErrs=sErrs+fnBatchNullValidation(sErrMsg,sNameArray,sValueArray);
	}else if(sTypeOfValidation == cEMAIL){ 
		sErrs=sErrs+fnBatchEmailValidation(sErrMsg,sNameArray,sValueArray);	
	}else if(sTypeOfValidation == cNUMERIC){ 
		sErrs=sErrs+fnBatchNumericValidation(sErrMsg,sNameArray,sValueArray);	
	}else if(sTypeOfValidation == cDATE){ 
		sErrs=sErrs+fnBatchDateValidation(sErrMsg,sNameArray,sValueArray);	
	}else if(sTypeOfValidation == cSSN){ 
		sErrs=sErrs+fnBatchSSNValidation(sErrMsg,sNameArray,sValueArray);	
	}else if(sTypeOfValidation == cPHONE){ 
		sErrs=sErrs+fnBatchPhoneValidation(sErrMsg,sNameArray,sValueArray);	
	}
	return sErrs;
}

function fnBatchPhoneValidation(sErrMsg,sNameArray,sValueArray){ 
	var sErrs='';
	
	for(var i=0;i<sNameArray.length;i++){	
		if(!fnPhoneValidate(sValueArray[i])){
			sErrs = sErrs +VALUE_OF + " \'" +sNameArray[i] + "\' " + PHONE_MSG + "\n";
		}	
	}
	return sErrs;
}

function fnBatchSSNValidation(sErrMsg,sNameArray,sValueArray){

	var sErrs='';	
	for(var i=0;i<sNameArray.length;i++){		
		if(!fnSSNValidate(sValueArray[i])){
			sErrs = sErrs +VALUE_OF + " \'" +sNameArray[i] + "\' " + SSN_MSG + "\n";
		}	
	}
	return sErrs;
}


function fnBatchNullValidation(sErrMsg,sNameArray,sValueArray){
	var sErrs='';
	
	for(var i=0;i<sNameArray.length;i++){		
		if(fnIsEmpty(sValueArray[i])){
			sErrs = sErrs +VALUE_OF + " \'" +sNameArray[i] + "\' " + NULL_MSG + "\n";
		}	
	}
	return sErrs;
}

function fnBatchEmailValidation(sErrMsg,sNameArray,sValueArray){
	var sErrs='';
	
	for(var j=0;j<sNameArray.length;j++){		
		if(!fnValidateEmail(sValueArray[j])){
			sErrs = sErrs +VALUE_OF + " \'" +sNameArray[j] + "\' " + EMAIL_MSG + "\n";
		}	
	}
	return sErrs;
}

function fnBatchNumericValidation(sErrMsg,sNameArray,sValueArray){
	var sErrs='';
	
	for(var k=0;k<sNameArray.length;k++){		
		if(!fnIsDigit(sValueArray[k])){
			sErrs = sErrs +VALUE_OF + " \'" +sNameArray[k] + "\' " + NUMERIC_MSG + "\n";
		}	
	}
	return sErrs;
}

function fnBatchDateValidation(sErrMsg,sNameArray,sValueArray){
	var sErrs='';
	
	for(var k=0;k<sNameArray.length;k++){		
		if(!fnDateValidate(sValueArray[k])){
			sErrs = sErrs +VALUE_OF + " \'" +sNameArray[k] + "\' " + DATE_MSG + "\n";
		}	
	}
	return sErrs;
}

function fnBatchPercentageValidation(sErrMsg,sNameArray,sValueArray){ 
	var sErrs='';
	for(var i=0;i<sNameArray.length;i++){
		if(sValueArray[i].indexOf(" ")!=-1){
			sErrs = sErrs +VALUE_OF + " \'" +sNameArray[i] + "\' " + BLANK_SPACE + "\n";
		}else{
			if (!fnIsEmpty(sValueArray[i])){
				if(!fnIsSignedFloat(sValueArray[i], 10, 6)){
					sErrs = sErrs +VALUE_OF + " \'" +sNameArray[i] + "\' " + fnGetMessage(VALID_FLOAT_MSG, "4", "6") + "\n";
				}
			}
		}
	}
	return sErrs;
}

function fnSSNValidate(sInput){
	return fnMaskValidate(sInput,SSN_MASK);
}

function fnZipCodeValidate(sInput){
	if (sInput=="00000" || sInput=="00000-0000"){
		return false;
	}
	/*if(sInput.indexOf('-') != -1){
		return fnMaskValidate(sInput,ZIPCODE_MASK);
	}else{
		return fnMaskValidate(sInput,ZIP_PART1_MASK);
	}*/
	return true;
}

//this function validates the Zip Code
function fnZipCodeValidateNew(part1, part2){
	var zipCombined = "";
	
	if(!fnIsEmpty(part1) && !fnIsEmpty(part2)){
		zipCombined = part1+'-'+part2;
		return(fnZipCodeValidate(zipCombined));
	}else if(!fnIsEmpty(part1))
		return fnMaskValidate(part1, ZIP_PART1_MASK);
	else if(fnIsEmpty(part1) && !fnIsEmpty(part2))
		return false;	
		
	return true;
}

function fnNDCCodeValidate(sInput){
	return fnMaskValidate(sInput,NDC_MASK);
}

function fnPhoneValidate(sInput){
	if (sInput=="000-000-0000"){
		return false;
	}else{
		return fnMaskValidate(sInput,PHONE_NO_MASK);
	}
}


function fnBatchStringValidation(sErrMsg,sNameArray,sValueArray){
	var sErrs="";
	for(var i=0;i<sNameArray.length;i++){		
		if(!fnStringValidate(sValueArray[i])){
			sErrs = sErrs +VALUE_OF + " \'" +sNameArray[i] + "\' " + NOT_VALID + "\n";
		}	
	}
	return sErrs;
}

function fnStringValidate(sInput){
	isProperString=new RegExp("[0-9]");
	if (!isProperString.test(sInput)){
		return true;
	}else{
		return false;
	}
}
/**********************MY F/N's*************************/
// It's not working  now :)
function isProper(string) {

   if (!string) return false;
   var iChars = "*|,\":<>[]{}`\';()@&$#%";

   for (var i = 0; i < string.length; i++) {
      if (iChars.indexOf(string.charAt(i)) != -1)
         return false;
   }
   return true;
}
/***********************************************/
function fnMaskValidate(sInput,sMask){
   str = sInput.toString();
	var len = str.length;
	if(len != sMask.length){ 
		return false;
	}	
	
	for(i=0 ; i<len; i++){
		strChar = str.charAt(i);
		maskChar = sMask.charAt(i);	
		switch(maskChar){
			case '9':
			if( !(strChar >= '0' && strChar <= '9' ) ){	
				return false;
			}
			break;
	     
			case 'a':;
			case 'A':
			if( !( (strChar >= 'a' && strChar <= 'z' ) || (strChar >= 'A' && strChar <= 'Z' ) )  ){						
				return false;					
			}
			break;
	     
			case 'x':;
			case 'X':
			if( !( (strChar >= 'a' && strChar <= 'z' ) || (strChar >= 'A' && strChar <= 'Z' )
				|| (strChar >= '0' && strChar <= '9' ))   )	{						
			 return false;					
			}
			break;
			default: if(strChar != maskChar){ 
				return false;
			}
			break;
		}			
	}
	return true;
}

function fnCheckStringEqality(sStr1, sStr2){
	if (sStr1=="" || sStr1==null) return false;
	if (sStr2=="" || sStr2==null) return false;
	if (sStr1!="" && sStr2!=""){
		if ((sStr1.length==sStr2.length) && (sStr1==sStr2)){
			return true;
		}else{
			return false;
		}
	}
}

// Create a '-' seperated String from 	parts Array
function fnCreateStringFromParts(){
	var retStr='';
	if( (arguments != null) && (arguments.length > 0) ){
		var len = arguments.length;
		for(var i=0; i < len; i++){   
			var value= eval("document."+arguments[i]).value;
			if(value == null) 
			  	value = '';	
			retStr = retStr + value+'-';
		}
	}
	return retStr.substring(0,retStr.length-1);
}

// Break a '-',',' seperated String to String Parts Array
function fnCreatePartsFromString(str){
	var parts = str.split('-');
	return parts;
}

function fnStringFromList(pListObj, pIndex){
	var retStr = "";		
	if (pIndex != -1){			
		retStr = eval(pListObj + ".options[" + pIndex + "].text");
	}		
	return retStr;
}

function fnClearTextValue(pObjName,pFormName){
	var obj = "";
	if (pObjName != "" && pFormName != ""){
		var len = pObjName.length;
		for (var i=0; i<len; i++){			
			obj = "document." + pFormName + "." + pObjName[i];
			eval(obj).value = "";
		}
	}		
}

function fnClearCheckBoxValue(pObjName,pFormName){
	var obj = "";
	if (pObjName != "" && pFormName != ""){
		var len = pObjName.length;
		for (var i=0; i<len; i++){			
			obj = "document." + pFormName + "." + pObjName[i];
			eval(obj).checked = false;
		}
	}		
}

function fnClearComboValue(pObjName,pFormName){
	var obj = "";
	if (pObjName != "" && pFormName != ""){
		var len = pObjName.length;
		for (var i=0; i < len; i++){			
			obj = "document." + pFormName + "." + pObjName[i];
			eval(obj).selectedIndex = 0;
		}
	}		
}

function fnDisabledControl(pObjName, pFormName){
	var obj = "";	
	if (pObjName != "" && pFormName != ""){
		var len = pObjName.length;
		for (var i=0; i < len; i++){			
			obj = "document." + pFormName + "." + pObjName[i];					
			eval(obj).disabled = true;
		}
	}
}	

function fnEnabledControl(pObjName, pFormName){
	var obj = "";
	if (pObjName != "" && pFormName != ""){
		var len = pObjName.length;
		for (var i=0; i < len; i++){			
			obj = "document." + pFormName + "." + pObjName[i];					
			eval(obj).disabled = false;
		}
	}
}	

function fnDisableAllControls(){ 

   	var disabledControlsArrayPointer =0;
	disabledControlsArray = new Array();
   	var docForm = document.forms[0];
   	var formControls = docForm.elements;
	var conLen = formControls.length;
	
   	for(var j=0; j<conLen; j++){ 
    	if(formControls[j].disabled == false){   
   			disabledControlsArray[disabledControlsArrayPointer] =  formControls[j];
         	disabledControlsArrayPointer++;
         	var formType = (formControls[j].type).toUpperCase();
			
			if(formType == "BUTTON" || formType == "RESET" || formType == "SUBMIT"){
				formControls[j].className = 'cssButton';
				formControls[j].disabled=true;				
			}
			var selectIndex = (formType).indexOf("SELECT");
			if(formType == "TEXT" || (selectIndex != -1) || formType == "TEXTAREA" || formType == "RADIO" || formType == "CHECKBOX"){
				formControls[j].disabled=true;
			}       
		}else{				
    		formControls[j].name;
    	}
   	}    
}


function fnEnableAllControls(){
	var len = disabledControlsArray.length;
   	for(var j=0;j<len;j++){ 
    	disabledControlsArray[j].disabled=false;
   	} 
   	setFocusOnFirst();
}

function fnToBeImplemented(){
	fnAlert( ALERT_DIALOG_TITLE, "",'To be implemented');
}

//Set focus on first active field on active tab
function setFocusOnFirst(){
		
	if (document.forms.length > 0){
	    //First form would always be displayed on the screen
	    var docForm = document.forms[0];
	    var formControls = docForm.elements;
		var conLen = formControls.length;
					  
	    for(var j=0; j < conLen; j++){ 
			var formType = (formControls[j].type).toUpperCase();
			if(formType == "TEXT" || formType == "SELECT-ONE" || formType == "CHECKBOX" || formType == "RADIO" || formType == "TEXTAREA" ){ 
				if(formControls[j].disabled == false){ 					
					try{	
						document.focus(true);
						formControls[j].focus(true);
						break;
					}catch(error){}	
				}
			}	
	    } 
	}    
}

/**
* Function used to compare two dates.		
*/
function fnDateComparison_Old(pFromDate, pToDate){
	var retFlag = false;
	pFromDate = new Date(fnTrim(pFromDate));
	pToDate =   new Date(fnTrim(pToDate));
	if (pFromDate != "" && pToDate != "") {
		if (pToDate >= pFromDate) {			
			retFlag = true;
		}				
	}
	return retFlag;	
}
/**
* Function used to compare two dates.		
*/
//------------------------------------------
/**
* Function used to compare two dates(Modified by Dilip Namdeo on 31Jan08).		
*/
function fnDateComparison(pFromDate, pToDate){
	var retFlag = false;
	pFromDate = fnTrim(pFromDate);
	pToDate =   fnTrim(pToDate);	
	if (pFromDate != "" && pToDate != "") {
	    var oFromDate =parseInt(pFromDate.substring(6,10)+pFromDate.substring(3,5)+pFromDate.substring(0,2),10)
        var oToDate =parseInt(pToDate.substring(6,10)+pToDate.substring(3,5)+pToDate.substring(0,2),10)
		if (oToDate >= oFromDate) {			
			retFlag = true;
		}				
	}
	return retFlag;	
}
/**
* Function used to compare two dates.		
*/
function fnDateComparisonEquals(pFromDate, pToDate){
	var retFlag = true;
	pFromDate = new Date(fnTrim(pFromDate));
	pToDate =   new Date(fnTrim(pToDate));
	if (pFromDate != "" && pToDate != "") {
		if (pToDate > pFromDate) {
			retFlag = false;
		}else if (pToDate < pFromDate){
			retFlag = false;
		}		
	}
	return retFlag;	
}

//Function checks whether a given string is float(real) or not. 
//Can be used only for unsigned floats and unsigned inetgers.
function fnIsFloat(pStr){
	var ctr = 0;
    var seenDecimal = false;

	if(pStr.indexOf(" ")!=-1){
		return false;
	}
	
	pStr = fnTrim( pStr );//removing the leading and trailing spaces

	var len = pStr.length;
    for(ctr=0; ctr<len; ctr++){
    	var c = pStr.charAt(ctr);
        if(c == "." && !seenDecimal)
        	seenDecimal = true;
        else if(!fnIsDigit(c))
            return false;
    }
    return true;
}

/* Overloaded fnIsFloat()
/*<!--
**********************************************************************************************
**        Function Name    ::	fnIsFloat(pStr, totLength, decLength)
**        Purpose          ::   Function checks whether a given string is float(real) or not.
                               Can be used only for unsigned floats and unsigned inetgers.
pStr - Value to be validated  totLength - Maximum allowed length for a float	decLength - Maximum no of digites allowed after decimal
************************************************************************************************-->*/
function fnIsFloat(pStr, totLength, decLength){
  	var ctr = 0;
    var seenDecimal = false;

	if(pStr.indexOf(" ")!=-1){
		return false;
	}
	//removing the leading and trailing spaces
	pStr = fnTrim( pStr );

	var len = pStr.length;
    for(ctr=0; ctr<len; ctr++){
    	var c = pStr.charAt(ctr);
        if(c == "." && !seenDecimal)
    		seenDecimal = true;
       else if(!fnIsDigit(c))
            return false;
     }
	if (arguments.length <= 1){
		return true;
	}
	var isPartsValid = fnCheckFloatParts(pStr, totLength, decLength);
	return (isPartsValid);
}

/* Overloaded fnIsFloat()
/*<!--
**********************************************************************************************
**        Function Name    ::	fnIsSignedFloat(pStr, totLength, decLength)
**        Purpose          ::   Function checks whether a given string is float(real) or not.
                               Can be used only for signed floats and signed inetgers.
pStr - Value to be validated  totLength - Maximum allowed length for a float	decLength - Maximum no of digites allowed after decimal
************************************************************************************************-->*/
function fnIsSignedFloat (pStr, totLength, decLength) {
	pStr = fnTrim(pStr);
    var startPos = 0;
    if ( (pStr.charAt(0) == "-" || pStr.charAt(0) == "+") && !(pStr.length==1 && (pStr=='-' || pStr=='+'))){
      startPos = 1;  
	}
    return (fnIsFloat(pStr.substring(startPos, pStr.length), totLength, decLength));
}

/* function fnCheckFloatParts 
/*<!--
**********************************************************************************************
**        Function Name    ::	fnCheckFloatParts(pStr, totLength, decLength)
**        Purpose          ::   Function that checks whether the integer and the decimal parts 
							of a float value exceed the maximum lengths or not
pStr - Value to be validated	totLength - Maximum allowed length for a float		decLength - Maximum no of digites allowed after decimal
************************************************************************************************-->*/
function fnCheckFloatParts(pStr, totLength, decLength){
	var errMsg = "";
	var parts = pStr.split(".");
	var intLength = totLength - decLength;
	if(!fnIsDigit(pStr)){
		//implies that the input value is float
		if(parts[0].length > intLength){
			 return false;
		}		
		if (decLength != 0){
			if(parts[1].length > decLength){
				return false;
			}
		}
	}else{
		//implies that the input value is integer 
		if(pStr.length > intLength)
			return false;
	}
	return true;
}

//Function used to validate a date string. Date should be in MM/DD/YYYY
function fnDateValidate(pDDate){	
	if (fnIsEmpty(pDDate)){ 
      return true;
	}
	var day = ""; var date = ""; var flag = false;
			
	var date = pDDate + "//";  var symbol = "/";
	
	if ((pDDate.length >= 8) && (pDDate.length <=10)) {
		sub			= "";	cyear		= "";   month		= 0;             
		day			= 0;	year		= 0;	indexFirst  = 0;	indexSecond = 0;
		
		while ((date.charAt(indexFirst) != symbol)){			
			ch = date.charAt(indexFirst);
			if ((ch >= '0') && (ch <= '9')) {
				sub = sub + ch;
				indexFirst++;
			}else {
				ch = "0";
				indexFirst = date.length - 2;
				return(false);
			}			
		}					

		if (sub=="" || sub.length > 2) {	
			return false;
		}
		month = eval(sub);				
	   if ((month > 0) && (month <= 12)) {
			sub = "";
			indexFirst++;
			while (date.charAt(indexFirst) != symbol) {				
				ch = date.charAt(indexFirst);				
				if ((ch >= '0') && (ch <= '9')) {
					sub = sub + ch;
					indexFirst++;
				} else {
					ch		   = "0";
					indexFirst = date.length - 1;
					return false;
				}
			 }
			if (sub=="" || sub.length > 2) {
				return false;
			}
			day	= eval(sub);
			
			indexFirst++;
			yearField=date.substring(indexFirst);												
			while( yearField.charAt(indexSecond) != symbol)	{
				gyear = yearField.charAt(indexSecond);

				if ((gyear >= '0') && (gyear <= '9')) {
					cyear = cyear + gyear;
					indexSecond++;
				} else {
					gyear = "0";
					indexSecond = 0;
					return false;
				}
			}			
			if ((month == 1) || (month == 3) || (month == 5) || (month == 7) 
			|| (month == 8) || (month == 10) || (month == 12)) {
				if ((day > 0) && (day <= 31)) {
					year = fnGetYear(cyear);						
				} else {
					return false;
				}
			}
			if (month == 2) {
				if ((day > 0) && (day <= 29)) {
					year = fnGetYear(cyear);
					if ((year % 4 != 0) && (day == 29)){
						year = 0;
					}
				}
			}
			if ((month == 4) || (month == 6) || (month == 9) || (month == 11)) {
				if ((day > 0) && (day <= 30)) {
					year = fnGetYear(cyear);
				} else {
					return false;
				}
			}			
			if (year < 1800) {
				return false;
			} 
		} else { 
			return false;
		}
		return true;
	} else {
		return false;
	}
}
//Function used to get the year field from a string. 
function fnGetYear(pYearString) {
	if (pYearString.length < 4) {
		return false;
	} else {
		return(eval(pYearString.substring(0,4)));
	}
}

/***************************************************************************************************
/*           PHONE VALIDATIONS
****************************************************************************************************/
function fnValidatePhone(pValue){
	var errMsg='';
	var extension=false;
	var isValidPhone=true;
	
	var validFormatRegExp = /^(\+\d{1,3} ?)?(\(\d{1,5}\)|\d{1,5}) ?\d{3} ?\-?\d{4} ?\d{0,3}( ?(x|X|xtn.|xtn)?\.? ?\d{1,5})?$/i;
	var pValue = fnTrim(pValue);
	
	pValue = pValue.toUpperCase();
	
	if (pValue.charAt(0)==1){
		pValue = pValue.substring(1,pValue.length);	
	}
	if (pValue.indexOf('(')!= -1){
		pValue=fnReplaceCharacters(pValue, '(','');
	}
	if (pValue.indexOf(')')!= -1){
		pValue=fnReplaceCharacters(pValue, ')','');
	}
	if (pValue.indexOf('-')!= -1){
		pValue=fnReplaceCharacters(pValue, '-','');
	}
	if (pValue.indexOf('.')!= -1){
		pValue=fnReplaceCharacters(pValue, '.','');
	}
	
	pValue = fnRemoveRepeatedCharacters(pValue, ' ');
	var userEnteredValue = pValue;
	
	pValue = fnReplaceCharacters(pValue, ' ','');
		
	if (pValue.indexOf('XTN')!= -1){
		pValue=fnReplaceCharacters(pValue, 'XTN','X');
	}else if (pValue.indexOf('XTN.')!= -1){
		pValue=fnReplaceCharacters(pValue, 'XTN.','X');
	}
	
	if (pValue.charAt(10)=='X'){
		extension = true; 
	}
	
	if 	(extension == true){
		if (!validFormatRegExp.test(pValue)) { 
			isValidPhone = false;
		}else{
			isValidPhone = true;
		}
	}
	
	if 	(extension == false){
		if (!fnIsDigit(pValue)) { 
			isValidPhone = false;
		}else{
			isValidPhone = true;
		}
	}

	if (isValidPhone){
		if (pValue.length==10){
			pValue = fnFilter('', pValue, '(###) ###-####');
			return pValue;
		}
		if(extension==true){
			pValue = fnFilter('', pValue, '(###) ###-#### ####');
			return pValue;
		}
		if(extension==false && pValue.length>10){
			return userEnteredValue;
		}
		if(extension==false && pValue.length<10){
			return userEnteredValue;
		}
	}else{
		return false;
	}
}

var dFilterStep
function fnFilterStrip (dFilterTemp, dFilterMask){
    dFilterMask = replace(dFilterMask,'#','');
    for (dFilterStep = 0; dFilterStep < dFilterMask.length++; dFilterStep++){
		    dFilterTemp = replace(dFilterTemp,dFilterMask.substring(dFilterStep,dFilterStep+1),'');
		}
		return dFilterTemp;
}

function fnFilter (key, pValue, dFilterMask){
	dFilterNum = fnFilterStrip(pValue, dFilterMask);

	var dFilterFinal='';
	
    for (dFilterStep = 0; dFilterStep < dFilterMask.length; dFilterStep++){
        if (dFilterMask.charAt(dFilterStep)=='#'){
			if (dFilterNum.length!=0){
				dFilterFinal = dFilterFinal + dFilterNum.charAt(0);
				dFilterNum = dFilterNum.substring(1,dFilterNum.length);
			}else{
				dFilterFinal = dFilterFinal + "";
			}
		}else if (dFilterMask.charAt(dFilterStep)!='#'){
			dFilterFinal = dFilterFinal + dFilterMask.charAt(dFilterStep); 			
		}
			//dFilterTemp = replace(dFilterTemp,dFilterMask.substring(dFilterStep,dFilterStep+1),'');
	}
	return dFilterFinal;
}

function replace(fullString,text,by) {
// Replaces text with by in string
    var strLength = fullString.length, txtLength = text.length;
    if ((strLength == 0) || (txtLength == 0)) return fullString;

    var i = fullString.indexOf(text);
    if ((!i) && (text != fullString.substring(0,txtLength))) return fullString;
    if (i == -1) return fullString;

    var newstr = fullString.substring(0,i) + by;

    if (i+txtLength < strLength)
        newstr += replace(fullString.substring(i+txtLength,strLength),text,by);

    return newstr;
}
/*
* This function is replaces the given char with another char
*/
function fnReplaceCharacters(conversionString,inChar,outChar){
	var strConvertedString = conversionString.split(inChar);
	strConvertedString = strConvertedString.join(outChar);
	return strConvertedString;
}
/*
* This function is removes Repeated Characters from the given string
*/
function fnRemoveRepeatedCharacters(string, delimiter){
	var returnString = "";
	splitstring = string.split(delimiter);
	
	for(i = 0; i < splitstring.length; i++){
		if (splitstring[i]!="") returnString += splitstring[i] + delimiter;
	}
	return returnString;
}

/*
* This function is called on onkeydown event which disallow any non numeric char
* It only accept decimal once. Used to for FLOAT
*/
function fnOnlyFloatAllowed(pValue){
	var isDecimalExist=false;
	/*
	* Key Code Description
	* 8:Backspace, 9:Tab, 37:Left Arrow, 39:Right Arrow, 46:Delete, 190:Dot(.), 48-57:All Numeric Values(0-9), 
	* 187:Plus(+), 189:minus(-), 36:Home, 35:End, 16:Shift Key
	* Num Pad
	* 110:Dot, 96-105:All Numeric Values(0-9), 107:Plus(+), 109:minus(-)
	*/
	 
	if(event.shiftKey || event.ctrlKey || event.altKey) return false;

	if (pValue.indexOf(".")!=-1){
		isDecimalExist=true;
	}
	if ((event.keyCode >=48  && event.keyCode <=57) || (event.keyCode >=96  && event.keyCode <=105) || (event.keyCode >=35  && event.keyCode <=37) || event.keyCode ==8 || event.keyCode ==39 || event.keyCode ==46 || event.keyCode ==9  || event.keyCode ==190 || event.keyCode ==110){
		if(isDecimalExist && (event.keyCode ==190 || event.keyCode ==110)){
			return false;
		}else{
			return true;
		}
	}else{
		return false;
	}
}

/*
* This function is called on onkeydown event which disallow any non numeric char
* It only accept decimal once. Used to for SIGNED FLOAT
*/
function fnOnlySignedFloatAllowed(pValue){
	var isDecimalExist=false;
	/*
	* Key Code Description
	* 8:Backspace, 9:Tab, 37:Left Arrow, 39:Right Arrow, 46:Delete, 190:Dot(.), 48-57:All Numeric Values(0-9), 
	* 187:Plus(+), 189:minus(-), 36:Home, 35:End, 16:Shift Key
	* Num Pad
	* 110:Dot, 96-105:All Numeric Values(0-9), 107:Plus(+), 109:minus(-)
	*/
	 
	if(event.shiftKey || event.ctrlKey || event.altKey) return false;

	if (pValue.indexOf(".")!=-1){
		isDecimalExist=true;
	}
	if ((event.keyCode >=48  && event.keyCode <=57) || (event.keyCode >=96  && event.keyCode <=105) || (event.keyCode >=35  && event.keyCode <=37) || event.keyCode ==8 || event.keyCode ==39 || event.keyCode ==46 || event.keyCode ==9  || event.keyCode ==190 || event.keyCode ==110 || event.keyCode ==189  || event.keyCode ==109){
		if(isDecimalExist && (event.keyCode ==190 || event.keyCode ==110)){
			return false;
		}else{
			return true;
		}
	}else{
		return false;
	}
}

/*
* This function is called on onkeydown event which disallow any non numeric char
* It does not decimal. Used to for INTEGER
*/
function fnOnlyIntegerAllowed(pValue){
	/*
	* Key Code Description
	* 8:Backspace, 9:Tab, 37:Left Arrow, 39:Right Arrow, 46:Delete, 190:Dot(.), 48-57:All Numeric Values(0-9), 
	* 187:Plus(+), 189:minus(-), 36:Home, 35:End, 16:Shift Key
	* Num Pad
	* 110:Dot, 96-105:All Numeric Values(0-9), 107:Plus(+), 109:minus(-)
	*/
	if(event.shiftKey || event.ctrlKey || event.altKey) return false;
	
	if ((event.keyCode >=48  && event.keyCode <=57) || (event.keyCode >=96  && event.keyCode <=105) || (event.keyCode >=35  && event.keyCode <=37) || event.keyCode ==8 || event.keyCode ==39 || event.keyCode ==46 || event.keyCode ==9){
		return true
	}else{
		return false
	}
}
// Function used to validate file name 
function fnValidateFileName(fileName){
	var sCharaters = new Array("\\","/","*","?",":","\"","<",">","|");
	var bCharFound = false;
	for (var i=0;i<sCharaters.length;i++){
		if(fileName.indexOf(sCharaters[i])!= -1){
			return false;
		}		
	}
	return true;
}

function goBack(oPath){
window.location = oPath
}


/** 
* Function used to compare two dates(Modified by Dilip Namdeo on 31Jan08).		
*/
function fnDateComparisonNew(pFromDate, pToDate){ //For MMDDYYY Format
	var retFlag = false;
	pFromDate = fnTrim(pFromDate);
	pToDate =   fnTrim(pToDate);	
	if (pFromDate != "" && pToDate != "") { 
	    var oFromDate =parseInt(pFromDate.substring(6,10)+pFromDate.substring(0,2)+pFromDate.substring(3,5),10)
        var oToDate =parseInt(pToDate.substring(6,10)+pToDate.substring(0,2)+pToDate.substring(3,5),10)
        //alert("oToDate= "+oToDate + " :: oFromDate= "+oFromDate);
		if (oToDate >= oFromDate) {			
			retFlag = true;
		}				
	}
	return retFlag;	
}
//----------------------------------------------------------------------
/**
* Function used to add no of days in to a date (Code by Dilip Namdeo on 20May08).	
* Input date formate is DD/MM/YYYY	
*/
function addDays(oDate,days) {
    oDate = oDate.substring(3,5)+'/'+oDate.substring(0,2)+'/'+oDate.substring(6,10)    
    var myDate = new Date(oDate);    
    myDate.setDate(myDate.getDate()+7) 
    var DD = myDate.getDate();
    var MM = myDate.getMonth()+1;
    if(parseInt(DD)<10)
        DD = "0"+DD;
    if(parseInt(MM)<10)
        MM = "0"+MM;
    return (DD+'/'+MM+'/'+myDate.getFullYear()) // January = 0
}
//----------------------------------------------------------------------

/**
* Function used to Validate the date i.e. selected date should not be exceed today (Code by Dilip Namdeo on 24June08).	
* Input date formate is DD/MM/YYYY	
*/
function validateDate(id){ 
    var msg = "";         
    var currentTime = new Date()
    var month = currentTime.getMonth() + 1
    if(parseInt(month)<10)
        month = "0"+month;
    var day = currentTime.getDate()    
    if(parseInt(day)<10)
        day = "0"+day;
    var year = currentTime.getFullYear()        
    var toDayDate =  day + "/" + month + "/" + year;
    var selDate = document.getElementById('ctl00_ContentPlaceHolder1_'+id+'_textBox').value    
    if(!fnDateComparisonNew(selDate,toDayDate)){
        msg = msg+"date should not be exceed from today \n";            
    }
    if(msg==""){}
    else{
        window.alert(msg);
        return false;
    }       
    return true;
}

/**
* Function used to Validate the numeric data onBlur event this f/n is specialy for GridView (Code by Dilip Namdeo on 26Aug08).	
*/
function handleBlurEvent(elementRef){
    //alert(elementRef.value);
    var elementValue = elementRef.value; //parseFloat(elementRef.value);

    if (!fnIsDigit(elementValue)){
        alert('Only numeric values are allowed');
        elementRef.value = 0;
        elementRef.focus();
        elementRef.select();
        return false;
    }

    //     if ( (elementValue < 5) || (elementValue > 10) )
    //     {
    //      alert('Only values between 5 and 10 are allowed');
    //      elementRef.focus();
    //      elementRef.select();

    //      return false;
    //     }
    return true;
}  
//----------------------------------------------------------------------
//  check for valid numeric strings	
function IsNumericNew(strString,validString){
   var strValidChars = validString; //"0123456789";
   var strChar;
   var blnResult = true;

   if (strString.length == 0) return false;

   //  test strString consists of valid characters listed above
   for (i = 0; i < strString.length && blnResult == true; i++)
      {
      strChar = strString.charAt(i);
      if (strValidChars.indexOf(strChar) == -1)
         {
         blnResult = false;
         }
      }
   return blnResult;
}
//----------------------------------------------------------------------
//to Validate the date i.e. selected date should not be exceed today 
function fnSelDateShdNotExceedFromCurrentDate(elementRef){
    //alert(oThis.value);        
    var msg;
    msg = "";   
    var currentTime = new Date()
    var month = currentTime.getMonth() + 1
    if(parseInt(month)<10)
        month = "0"+month;
    var day = currentTime.getDate()    
    if(parseInt(day)<10)
        day = "0"+day;
    var year = currentTime.getFullYear()        
    var toDayDate =  month + "/" + day + "/" + year;
    var selDate = elementRef.value; //document.getElementById('ctl00_ContentPlaceHolder1_STdate_textBox').value 
    if(elementRef.value != ''){   //alert(selDate + " : " + toDayDate);
        if(!fnDateComparisonNew(selDate,toDayDate)){
            msg = msg+"Date should not be exceed from today \n";  
            elementRef.value = ''; 
            //elementRef.focus();
            //elementRef.select();         
        }
    }
    if(msg==""){}
    else{
        window.alert(msg);
        return false;
    }      
    return true;
}

function IsNumeric(sText){
   var ValidChars = "0123456789.";
   var IsNumber=true;
   var Char;
   for (i = 0; i < sText.length && IsNumber == true; i++) 
      { 
      Char = sText.charAt(i); 
      if (ValidChars.indexOf(Char) == -1) 
         {
         IsNumber = false;
         }
      }
   return IsNumber;   
}

function fnLastDateOfMonth(oFDate){    
    var myDate = new Date(oFDate);
    
    //-------Todday Date--------
    var currentTime = new Date()
    var month = currentTime.getMonth() + 1
    if(parseInt(month)<10)
        month = "0"+month;
    var day = currentTime.getDate()    
    if(parseInt(day)<10)
        day = "0"+day;
    var year = currentTime.getFullYear()        
    var toDayDate =  month + "/" + day + "/" + year;
    //----------------------------------------------
    
    if(parseInt(myDate.getDate()) == 1){
        var oToMonth = (myDate.getMonth()+1);
        if(parseInt(oToMonth)<10)
        oToMonth = "0"+oToMonth;
        var oToDay = LastDayOfMonth(myDate.getFullYear(), myDate.getMonth());
        if(parseInt(oToDay)<10)
        oToDay = "0"+oToDay;
        var oToYear = myDate.getFullYear();
        
        var oToDate = oToMonth +"/"+ oToDay +"/"+ oToYear;
        
        if(fnDateComparisonNew(oToDate,toDayDate)){
            return(oToDate);     
        }else{
            return toDayDate;
        }
    }
}
   
function LastDayOfMonth(Year, Month){   
    return(new Date((new Date(Year, Month+1,1))-1)).getDate();   
}