/*	Procedure File: Forms.js
	Date: From Jan 2001-Oct 2001	
	Author: Stephen  Moxon
			Vassilis Kalampokis

	Purpose: Contains all the necessary function for client-side field
			validation.
			Also contains the Validator() object that can be dropped on forms
			to perform the validation on form submission.
			
			change by kioan 18/05/07 add functionality to form validation
			add custome functions that retruns true or false.
			if return false stop the validation and display the message.


	Functions List

		isNumber(tcNumber)
		isInteger(tcNumber)
		isEmpty(tcstring)
		validDate (date, separator)
		validEmail(strValue)  

		ValidForm(FormName)

		ClearField(strFieldname)
		
		SubmitFormAutoSubmit(FormName)
		SubmitForm(FormName)
		ResetForm()
		
		y2k(number)
		charInString (tchar, tcstring)
		GetWeek(strDate)
		GetDateBit(strDate, strBit)
		
		dateToANSI(date, separator)		
		numBetween(num, lowlimit, highlimit)
		
		

*/

var ovalidator = new Validator();

ovalidator.Initialise();

function isNumber(tcNumber) {
	var checkOK = "0123456789,.";
	var checkStr = tcNumber;
	var allValid = true;
	var intDPCount=0;
	
	var chTestChar=''
	
	var intcheckOKLen= checkOK.length;	 
	var intTestLen	=  tcNumber.length;
	var blnFound=false;

	if 	(intTestLen <=0) return false;
	
	for (var i = 0;  i < intTestLen;  i++)
	{
		ch = tcNumber.charAt(i);

		// If the string contains multiple , and ' reject!!
		if (ch=="."  || ch=="," ) {
			intDPCount++;

			if (intDPCount > 1) {
				allValid = false;
				break;
			}	
			continue;
		}
	
		
		blnFound=false;
			
		for (j = 0;  j < intcheckOKLen;  j++)
		{
			chTestChar = checkOK.charAt(j);
			
			
			if (ch == chTestChar) {			
				blnFound=true;
				break;
			}
				
		}	
		
		if (blnFound==false)  {
			allValid = false;
			break;
		}	
	}
		
	return allValid;
}




				
function isInteger(tcNumber) {
	var checkOK = "0123456789";
	var checkStr = tcNumber;
	var blnIsInteger = true;
	
	for (var i = 0; i < tcNumber.length;  i++)
	{
		ch = tcNumber.charAt(i);
		
		for (j = 0;  j < checkOK.length;  j++)
			if (ch == checkOK.charAt(j))
				break;				
		if (j == checkOK.length)
		{
			blnIsInteger = false;
			break;
		}
	}
	return blnIsInteger;
}


function isEmpty(tcstring)  {   
	return ((tcstring == null) || (tcstring.length == 0))
}

function validEmail(strValue) 
{
	var objRegExp  = new RegExp('^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}\|[0-9]{1,3})(\\]?)\$');
	return objRegExp.test(strValue);
}

function charInString (tchar, tcstring)
{   for (var i = 0; i < tcstring.length; i++)
    {   if (tcstring.charAt(i) == tchar) return true;
    }
    return false
}

function y2k(number) { 
	return (number < 1000) ? number + 1900 : number; 
}



function GetDateBit(strDate, strBit) {

	var strRetval='';
		
	if (strDate =='today') {
		today=new Date();
		
		var day=today.getDate() ;
		var month=today.getMonth();
		var year=today.getYear() ; year=(year<1000?1900+year:year);
	}
	else {
		var tmp = strDate.split("/") 
		var day=parseInt(tmp[0], 10);
		var month=parseInt(tmp[1], 10)-1;
		var year=parseInt(tmp[2], 10);
	}

	switch (strBit) {
		case "day":
			strRetval= day;
			break;
			
		case "month":
			strRetval = month;
			break;
			
		case "year":
			strRetval =  year;
			break;	
	}		

    return strRetval;
}



function GetWeek(strDate) {

	var intRetval=0;
	
	if (strDate =='today') {
		today=new Date();
		
		var day=today.getDate() ;
		var month=today.getMonth();
		var year=today.getYear() ; year=(year<1000?1900+year:year);
	}
	else {
		var tmp = strDate.split("/") 
		var day=parseInt(tmp[0], 10);
		var month=parseInt(tmp[1], 10)-1;
		var year=parseInt(tmp[2], 10);
	}

    var when = new Date(year,month,day);
    var newYear = new Date(year,0,1);
    var modDay = newYear.getDay();
    
    if (modDay == 0) modDay=6; else modDay--;

    var daynum = ((Date.UTC(y2k(year),when.getMonth(),when.getDate(),0,0,0) -
                 Date.UTC(y2k(year),0,1,0,0,0)) /1000/60/60/24) + 1;

    if (modDay < 4 ) {
        var weeknum = Math.floor((daynum+modDay-1)/7)+1;
    }
    else {
        var weeknum = Math.floor((daynum+modDay-1)/7);
        if (weeknum == 0) {
            year--;
            var prevNewYear = new Date(year,0,1);
            var prevmodDay = prevNewYear.getDay();
            if (prevmodDay == 0) prevmodDay = 6; else prevmodDay--;
            if (prevmodDay < 4) weeknum = 53; else weeknum = 52;
        }
    }

	
	intRetval = + weeknum;

	if (intRetval==53)
		intRetval=52;
				
		
    return intRetval
}




/*******************************************************************************
	Author: Vassilis Kalampokis [EXODUS SA]
	Date: 08 Mar 2001
*******************************************************************************/
function dateToANSI(date, separator) {
	var luretval;		
	var tmp = date.split(separator);
	
	if (tmp.length != 3) { 
		return false ;
	}	
	
	// Ensure that single digits, have the 0 prefix		
	if (tmp[0].length == 1) {
		tmp[0] = '0' + tmp[0];
	}		
	if (tmp[1].length == 1) {
		tmp[1] = '0' + tmp[1];
	}
	
	luretval = 	tmp[2] + tmp[1] + tmp[0];
	
	return luretval;	
}


function numBetween(num, lowlimit, highlimit) {
	return ((num >= lowlimit) && (num <= highlimit))
}


function validDate (date, separator) {
		
	function leapYear(year) {	return (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0)) }

	function validDay (day, month, year) {
		var days = Array (31,28,31,30,31,30,31,31,30,31,30,31)
		if (leapYear (year)) days[1] = days[1] + 1
		return (day>=1) && (day <= days[month-1])	
	}

	var tmp = date.split(separator)
	
	if (tmp.length != 3) {		
		return false;
	}	
		
	var day = parseInt (tmp[0],10)
	var month = parseInt (tmp[1],10)
	var year = parseInt (tmp[2],10)
		
	return (validDay(day,month, year) && (month>=1) && (month<=12) && (year>=1800) && (year<=3000))
}

/*******************************************************************************
*******************************************************************************/


function ValidForm(tFormName)
{

	ovalidator.CheckFields(tFormName);
	
	return ovalidator.valid;
}

function ClearField(FieldName)
{

	var ElementList = document.getElementsByTagName("INPUT");

	for (var ElementIndex = 0; ElementIndex < ElementList.length; ElementIndex++) 
	{
		FieldID= ElementList[ElementIndex].id;
			
		if  ((FieldID!="" ) && (FieldID.indexOf(FieldName) >=0) )
		{
			ElementList[ElementIndex].value="";
			break;
		}
	}
}

function SubmitForm(tFormName)
{
	if ( ValidForm(tFormName) )
	{
		var oForm = document.forms[0];
		oForm.submit();	
	}
}

function SubmitFormAutoSubmit(tFormName)
{
	var blnOK = ValidForm(tFormName);
	
	return blnOK
}


function ResetForm()
{
	var oForm = document.forms[0];
	
	if (oForm) {
		oForm.reset();	
	}	
}



/*******************************************************************************
	Validation object - for generic form / or field level checking

	HOW TO USE ***
	
		In the form_onload()
			ovalidator = new Validator();
			ovalidator.Initialise();

		In the form_unload()
			ovalidator = null;
		
		Add a reference to all fields to be validated:
			ovalidator.AddField("txtPhoneNumber","string","true",10,"","","Telephone Number required, maximum of 15 characters");

			where parameters are:
				HTML object name, datatype,mandatory,max len,min value, max value, errorstring

		To validate all the listed fields when the user clicks submit:
			<form name="replace with the form name" onSubmit="ovalidator.CheckFields(Formname);return ovalidator.valid;">			

	NOTE: In the function Validator(), it sets an object property 
			This.MandatoryMsg, that is displayed when the user does not enter
			data in a mandatory field.  Ensure you assign this a value !!

*******************************************************************************/

function Initialise() {
	this.FieldList = new Array(1);
	this.CFunctionList = new Array(1);	
}

function customfunction(){
	this.cfunction='';
	this.errorstring='';
}

function fieldstructure() {	
	this.name='';
	this.datatype='';
	this.minvalue='';
	this.maxvalue='';	
	this.errorstring='';
	this.mandatory = 'false';	
	this.maxlen=0;
	
	this.formname='';
	
}


function AddCustomValidation(tfunction,terror){
	//create the object holding the custome fucntion
	var ofunction = new customfunction();
	with (ofunction){
		cfunction = tfunction;
		errorstring = terror; 
	
	}
	this.UsedRows++;
	
	this.CFunctionList.length= this.UsedRows;
								
	this.CFunctionList[this.UsedRows-1] = ofunction;
		
	ofunction = null;

}
function AddField(tcformname,tcname,tcdatatype,tlMandatory,tnmaxlen,tumin,tumax, tcerror) {

	// Create the object holding the validation info
	var ofield = new fieldstructure() ;
						
	with (ofield) {
	
		formname=tcformname;
		name=tcname;
		datatype=tcdatatype;
		mandatory = tlMandatory;
		
		maxlen=tnmaxlen;
					
		// Range for date/numeric, Length for string
		minvalue=tumin;
		maxvalue=tumax;
		errorstring=tcerror;
	}
		
	this.UsedRows++;
	
	this.FieldList.length= this.UsedRows;
								
	this.FieldList[this.UsedRows-1] = ofield;
		
	ofield = null;
}



function ValidateNumber(tuvalue,tuMinValue,tuMaxValue) {
	var llretval = true;
		
	if ( isNumber(tuvalue) ) {						

		tuvalue = parseFloat(tuvalue,10);
		
		if (!isEmpty(tuMinValue)) {
			tuMinValue = parseFloat(tuMinValue,10);
			
			if (tuvalue < tuMinValue) {
				llretval = false;
			}		
		}

		if (!isEmpty(tuMaxValue)) {
			tuMaxValue = parseFloat(tuMaxValue,10);
			
			if (tuvalue > tuMaxValue) {
				llretval = false;
			}		
		}		
	}
	else {
		llretval = false;
	}		
	

	return llretval;					
}



function ValidateInteger(tuvalue,tuMinValue,tuMaxValue) {

	var llretval = true;
		
	if ( (tuvalue !='') && isInteger(tuvalue) ) {						
		
		tuvalue = parseInt(tuvalue,10);
		
		if (!isEmpty(tuMinValue)) {
			tuMinValue = parseInt(tuMinValue,10);
			
			if (tuvalue < tuMinValue) {
				llretval = false;
			}		
		}

		if (!isEmpty(tuMaxValue)) {
			tuMaxValue = parseInt(tuMaxValue,10);
			
			if (tuvalue > tuMaxValue) {
				llretval = false;
			}		
		}
		
	}
	else {
		llretval = false;
	}		
	return llretval;					
}

function ValidateEmail(tuValue,tuMaxLen) 
{
	return  validEmail(tuValue); 
}

function ValidateAFM(tuValue,tuMaxLen)
{
	var llretval = true;
	var lnStrLen = 	tuValue.length
	
  
	var nn; 
	var S = 0; 
	var V = 512; 
	var Y = 0; 
	var tempchar; 
	var lastchar;
	
		
	if ( isNumber(tuValue) ) {	
		if (!isEmpty(tuMaxLen)) {
			tuMaxLen = parseInt(tuMaxLen,9);
			
			if (lnStrLen != tuMaxLen) {
				llretval = false;
			}
			else
			{
			
				for (var i= 0 ; i < tuValue.length-1; i++){ 
					tempchar = tuValue.charAt(i); 
					V = V / 2; 
					S += tempchar * V; 
				} 

				Y = S % 11; 
				lastchar = tuValue.charAt(tuValue.length-1); 
				
				if ((Y != 10 && lastchar != "0") && (Y != lastchar)) 
					llretval = false;
			}
				 	
		}				

		
	}
	else {
		llretval = false;
	}		
	return llretval;	

}

function ValidateString(tuValue,tuMaxLen,tuMinLen) {

	var llretval = true;
	var lnStrLen = 	tuValue.length	
	
	if (!isEmpty(tuMaxLen)) {
	
		if (typeof(tuMaxLen)=="string") {
			tuMaxLen = parseInt(tuMaxLen,10);	
		}	
		
		if (lnStrLen > tuMaxLen) {
			llretval = false;
		}		
	}
	if (!isEmpty(tuMinLen)) {
	
		if (typeof(tuMinLen)=="string") {
			tuMinLen = parseInt(tuMinLen,10);	
		}	
		
		if (lnStrLen <= tuMinLen) {
			llretval = false;
		}		
	}			
	return llretval;					
}

function ValidateDate(tuvalue,tuMinDate,tuMaxDate) {

	var llretval = true;
		
	if ( validDate(tuvalue, "/") ) {						
	
		tuvalue = dateToANSI (tuvalue, "/");			
		
		if ( (!isEmpty(tuMinDate))  && (validDate(tuMinDate,"/"))  ) {
			tuMinDate = dateToANSI (tuMinDate, "/");
						
			if (tuvalue < tuMinDate) {
				llretval = false;
			}		
		}

		if ( (!isEmpty(tuMaxDate))  && (validDate(tuMaxDate,"/"))  ) {
			tuMaxDate = dateToANSI (tuMaxDate, "/");
						
			if (tuvalue > tuMaxDate) {
				llretval = false;
			}		
		}
	}
	else {
		llretval = false;
	}		
	return llretval;					
}


function ValidatePassword(tuValue,tuMaxLen) {

	var llretval = true;
	var strBadChars = "<>!@#$%^&*[] :;./\|?{}()'" + '"';
	var intBadChars =  strBadChars.length;
	
	var intStringLen = tuValue.length
	var i=0;
	var j=0;
	var ch1='';
	var ch2='';
		
	tuValue
	for (i=0;i < intStringLen;i++) {
		ch1= tuValue.charAt(i);

		for (j=0;j < intBadChars;j++) {
		
			ch2=  strBadChars.charAt(j)
			if (ch1==ch2) {
				llretval=false;
			}
		}
			
	} 

	return llretval;					
}



function CheckFields( tFormName) 
{
	var lFieldsOk = true;
	var oFieldObject;
	var luValue;
	var lSingleField;

	var lcstartbit;
	var lcFieldName;
	var lcDataType;
	var luMinValue;
	var luMaxValue;	
	var luMaxLen;
	var lcErrorMsg;
	var lnstartbitlen = this.startbit.length;
	
	var loform = document.forms[0];
	var oField;
	var FieldID
	
	var oCFunction;

	lSingleField = false;
	
	ElementList = document.getElementsByTagName("INPUT");
	
	//add to the list the TEXTAREA
	ElementListText = document.getElementsByTagName("TEXTAREA");
	/*var CurrentIndex = 0;
	for (var ElementTextIndex = 0; ElementTextIndex < ElementListText.length; ElementTextIndex++) 
			{
				
				CurrentIndex = ElementList.length + ElementTextIndex + 1
				ElementList[CurrentIndex] = ElementListText[ElementTextIndex];
				//alert(ElementList[CurrentIndex].id);
				
			}
			alert(CurrentIndex + " " + ElementList.length);*/
	
	// Only check the fields that have been marked for validation
	for	(i in this.FieldList) {
				
		oFieldObject = this.FieldList[i];			
		FieldName = oFieldObject.name;
	
		
        //alert(CurrentIndex + " " + ElementList.length);
		if (tFormName == oFieldObject.formname)
		{
			

			// Find the field based on the supplied name - note because this could
			// be ASP.NET where the ClientID is dynamic then we will do a IndexOf
			// to check if the name is contained in the form field name
			oField = null;
			for (var ElementIndex = 0; ElementIndex < ElementList.length; ElementIndex++) 
			{
				
				FieldID= ElementList[ElementIndex].id;
				
				if  ((FieldID!="" ) && (FieldID.indexOf(FieldName) >=0) )
				{
					oField = ElementList[ElementIndex];
					
					
					break;
				}
			}
			//Check for TEXTAREA
			for (var ElementTextIndex = 0; ElementTextIndex < ElementListText.length; ElementTextIndex++) 
			{
				
				FieldID= ElementListText[ElementTextIndex].id;
				
				if  ((FieldID!="" ) && (FieldID.indexOf(FieldName) >=0) )
				{
					oField = ElementListText[ElementTextIndex];
					
					
					break;
				}
			}
			
  
			//FieldName = this.startbit + "." + loform.name + "." + FieldName ;			
			if (oField != null)
			{
				//alert(oField.id);
				//luValue = eval( FieldName  + '.value');
				luValue=oField.value;
				//alert(luValue);
				lcDataType = oFieldObject.datatype;				
				luMaxLen=oFieldObject.maxlen;
				luMinValue = oFieldObject.minvalue;	

				// If the range is a reference to other fields, evaluate those fields to get the value
				if ( typeof(luMinValue) == "string" )  {

					var lcstartbit = luMinValue.substr(0,lnstartbitlen) ;
				
					if (lcstartbit == this.startbit) {
						luMinValue = eval(luMinValue);
					}
				}		

				luMaxValue = oFieldObject.maxvalue;
			
				if ( typeof(luMaxValue) == "string" )  {
					lcstartbit = luMaxValue.substr(0,lnstartbitlen) ;
				
					if (lcstartbit == this.startbit) {
						luMaxValue = eval(luMaxValue);
					}
				}		
							
				lcMandatory= oFieldObject.mandatory ;	
				lcErrorMsg = oFieldObject.errorstring ;
				
				// If a mandatory field has been left empty	
				if (isEmpty(luValue))  {
				
					if (lcMandatory=="true")  {
						if (lcErrorMsg=="") {			
							// lcErrorMsg= "Selected field must be completed";
							lcErrorMsg= this.MandatoryMsg;
						}					
						
						lFieldsOk=false;			
					}
					else 	lFieldsOk=true;
				}
				else {

			
					// User entered a value, ensure that is the correct format, and within the required min/max values
					switch (lcDataType) {
				
						case "number": {
							lFieldsOk = this.ValidateNumber(luValue,luMinValue, luMaxValue);					
							break;
						}

						case "integer": {
							lFieldsOk = this.ValidateInteger(luValue,luMinValue, luMaxValue);
							break;
						}

						case "string": {			
							lFieldsOk = this.ValidateString(luValue,luMaxLen,luMinValue);
							break;
						}
		
						case "email": {			
							lFieldsOk = this.ValidateEmail(luValue,luMaxLen);
							break;
						}
				
						case "password": {		
							lFieldsOk = this.ValidatePassword(luValue,luMaxLen);
							break;
						}
							
						case "date": {
						
							lFieldsOk = this.ValidateDate(luValue,luMinValue, luMaxValue);
							break;
						}
					
						case "money": {
							lFieldsOk = this.ValidateNumber(luValue,luMinValue, luMaxValue);
							break;
						}
						case "afm": {
							lFieldsOk = this.ValidateAFM(luValue,luMaxLen);
							break;
						}
						default: {
							alert("Valid data-types are: email;number;integer;string;date;money");
							break;
						}
					}	
				}
                
				oFieldObject = null;
				
			
				if (!lFieldsOk) {

					alert(lcErrorMsg);			

					// Move cursor back to field that failed validation				
					oField.focus();
					break;
				} 
			} 
			
			
		} // formname=.formname	
		
	}// next
	
	// Check if exist custome function - validation
	if (lFieldsOk) {
		for	(k in this.CFunctionList) {
			oCFunction = this.CFunctionList[k];
			lFieldsOk = eval(oCFunction.cfunction);
			if (!lFieldsOk) {

				alert(oCFunction.errorstring);			

				// Move cursor back to field that failed validation				
				break;
			} 
			
		}
	}
	
	this.valid = lFieldsOk ; 
}


function Validator() {

	this.MaxRows = 0 ;	
	this.UsedRows=0 ;
	this.valid = true;

	this.MandatoryMsg = ""; //gstrMandatory;

	this.startbit = "document";
			
	this.Initialise = Initialise;
	this.AddField = AddField;
	this.AddCustomValidation = AddCustomValidation;	
	this.CheckFields = CheckFields ;
	
	this.ValidateNumber = ValidateNumber;
	this.ValidateString = ValidateString;
	this.ValidatePassword = ValidatePassword;
	this.ValidateDate = ValidateDate;
	this.ValidateInteger=ValidateInteger;
	this.ValidateEmail=ValidateEmail;
	this.ValidateAFM = ValidateAFM;

	
}
/*****************************************************************************/
/****************************************************************************
	NAME:			f_checkSourceControl
	AUTHOR:			kioan
	PARAM:			
	RETURNS:		

	DESCRIPTION:	trap the id ofthe active control and return to module variabel
		Calls:

	HISTORY:
		kioan, Created

*/
var vActiveCotrolID = "";
var vkeyCode = "";
function f_checkSourceControl(){
	vkeyCode = window.event.keyCode;
	if (window.event.keyCode == 13) 
		{
			vActiveCotrolID = window.document.activeElement.id;
			
		}

}