// *******************************************************************************
// AUTHOR: Jayson Velicaria
// DATE: 26/07/2006
// FUNCTION: generateFilterClause
// *******************************************************************************
function showPopupWindow(url)
{

	var screenwidth = screen.availWidth, screenheight = screen.availHeight;		
	var popW = 750, popH = 600;
	var leftPos = (screenwidth-popW)/2, topPos = (screenheight-popH)/2;	
	
	window.open(url,"name","height="+popH+",width="+popW+",top="+topPos+",left="+topPos+"resizable=no,scrollbars=yes,toolbar=no,status=no");	
	
	return true;
}

function generateFilterClause(form)
{
	var element;
	var elementName;
	var columnName;
	var columnDataType;
	var columnCompareType;
	var columnValue;
	var operator;
	
	var ret;		
	
	ret = "";
	
	for (var n=0; n<form.elements.length; n++) 
	{	
		element=form.elements[n];
		elementName=element.name;		
		
		columnName = element.getAttribute("filter_column_name");		
				
		if ((!columnName)||(columnName.length == 0))
		{
			continue;
		}			
		
		//alert("columnName=" + columnName);
		if (columnName.indexOf("document.") >= 0)
		{
			//alert("eval columnName=" + columnName + ";");
			eval("columnName=" + columnName + ";");			
		}
		
		//alert("new columnName=" + columnName);
		
		columnDataType = element.getAttribute("filter_column_data_type");

		if ((columnDataType != null) && (columnDataType == ""))
		{
			columnDataType = columnDataType.toLowerCase();
		}		
		
		columnCompareType = element.getAttribute("filter_column_compare_type");
		
		if ((columnCompareType != null) && (columnCompareType == ""))
		{
			columnCompareType = columnCompareType.toLowerCase();
		}
		
		columnValue	 = GetValue(element);
		
		//alert(columnValue);
		
		if ((!columnValue)||(columnValue.length == 0) || columnValue == 'All' || columnValue == 'Other')
		{
			continue;
		}
		
		if (ret != "")
		{		
			ret = ret + " AND";			
		}
		else
		{
			ret = "WHERE";
		}
		
		switch (columnCompareType)
		{			  
			case "equal":
				operator = "=";
				break;
			case "greater":				
				operator = ">";			
				break;
			case "less":		
				operator = "<";
				break;
			case "equalOrGreater":		
				operator = ">=";
				break;
			case "equalOrLess":		
				operator = "<=";
				break;
			case "greaterOrEqual":		
				operator = ">=";
				break;
			case "lessOrEqual":		
				operator = "<=";
				break;				
			case "notEqual":
				operator = "<>";
				break;																				
			case "contains":
				operator = "LIKE";
				break;
			case "in":
				operator = "IN";
				break;		
														
			default:				
				operator = "=";
		}		
		
		switch (columnDataType)
		{			    								
			case "text":				
			case "memo":						
			case "currency":	
				if (operator == "LIKE")
				{		
					ret = ret + " " + columnName + " " + operator + " '%" + columnValue + "%'";
					
				}
				else if (operator == "IN")
				{		
					ret = ret + " (" + columnName + " LIKE '%" + columnValue + ",%'";
					ret = ret + " OR " + columnName + " LIKE '" + columnValue + ",%'";
					ret = ret + " OR " + columnName + " LIKE '%, " + columnValue + ",%'";
					ret = ret + " OR " + columnName + " LIKE '%, " + columnValue + "'";
					ret = ret + " OR " + columnName + " = '" + columnValue + "')";
					
				}
				else
				{
					ret = ret + " " + columnName + operator + "'" + columnValue + "'";
				}
				break;
			case "date":					
			case "datetime":	
			case "time":		
				if (columnCompareType == "next_days")
				{
					ret = ret + " " + "DateDiff('d',Date()," + columnName + ") <= " + columnValue;					
				}
				else if (columnCompareType == "last_days")
				{
					if (columnValue == 0 || columnValue == 1)
					{
						ret = ret + " " + "DateDiff('d'," + columnName + ", " + "Date()) = " + columnValue;										
					}
					else
					{					
						ret = ret + " " + "DateDiff('d'," + columnName + ", " + "Date()) <= " + columnValue;										
					}						
				}
				else
				{
					ret = ret + " " + columnName + operator +  "#" + columnValue + "#";
				}
				break;
			case "autonumber":
			case "number":
			case "numeric":				
				ret = ret + " " + columnName + operator + columnValue;				
				break;
			default:
				ret = ret + " " + columnName + operator + "'" + columnValue + "'";
		}		
//alert(ret);	
	}
	return ret;
}

function clearForm(form)
{	
	var element;	
	ret = "";
	
	for (var n=0; n<form.elements.length; n++) 
	{	
		element=form.elements[n];
		ClearValue(element);
	}			
	
	return;
}

// *******************************************************************************
// AUTHOR: Jayson Velicaria
// DATE: 26/07/2006
// FUNCTION: validateForm
// *******************************************************************************
function validateForm(form)
{
	var element;
	var elementName;
	var validationType;
	var errorMessage;
	var validationType;
	var valueValid=true;
	var currentValidationType;
	var currentRequiredType;
	var currentMinValue;
	var currentMaxValue;
		
	for (var n=0; n<form.elements.length; n++) 
	{	
		element=form.elements[n];
		elementName=element.name;

		currentRequiredType = element.getAttribute("required");
		
		if ((!currentRequiredType)||(currentRequiredType.length == 0))
		{
			continue;
		}										
		
		currentValidationType = element.getAttribute("validation");

		if ((!currentValidationType)||(currentValidationType.length == 0))
		{
			continue;
		}										
		
		valueValid = true;		
								
		switch (currentRequiredType) 
		{			    					
			case "yes":
				valueValid = validateNotEmpty(GetValue(element));				
				break;
			case "no":
				break;			
			default:
				alert("Invalid Validation Type for " + element.name)
				valueValid = true;
		}
								
		if (notEmpty(GetValue(element)) && (valueValid == true))								
		{
			switch (currentValidationType) 
			{			    					
				case "not_empty":
					valueValid = validateNotEmpty(GetValue(element));
					break;
				case "integer":
					valueValid = validateInteger(GetValue(element));					
					
					if (valueValid)
					{
						currentMinValue = element.getAttribute("min");
						if (notEmpty(currentMinValue))
						{
							if (parseInt(GetValue(element)) < parseInt(currentMinValue))
							{
								valueValid = false;
							}
						}
					}
															
					break;
				case "numeric":
					valueValid = validateNumeric(GetValue(element));
					
					if (valueValid)
					{					
						currentMinValue = element.getAttribute("min");
						if (notEmpty(currentMinValue))
						{
							if (parseFloat(GetValue(element)) < parseFloat(currentMinValue))
							{
								valueValid = false;
							}
						}
					}												
					break;
				case "email":
					valueValid = validateEmail(GetValue(element));
					break;
				case "phone":
					valueValid = validateUSPhone(GetValue(element));
					break;
				case "date":
					valueValid = validateDate(GetValue(element));
					
					if (valueValid)
					{
						currentMinValue = element.getAttribute("min");
					
						if (notEmpty(currentMinValue))
						{
							if (new Date(GetValue(element)) < new Date(currentMinValue))
							{
								valueValid = false;
							}
						}
					}
					
					if (valueValid)
					{
						currentMaxValue = element.getAttribute("max");
					
						if (notEmpty(currentMaxValue))
						{
							if (new Date(GetValue(element)) > new Date(currentMaxValue))
							{
								valueValid = false;
							}
						}
					}
					
					
					break;										
				case "text":				
				case "any":
					break;				
				default:
					alert("Invalid Validation Type for " + element.name)
					valueValid = true;
			}
		}			

		if (valueValid == false) 
		{												
			errorMessage=element.getAttribute("error");
			
			if ((!errorMessage)||(errorMessage.length == 0))
			{						
				errorMessage="Please enter a valid " + currentValidationType + " for "+ element.name;
			}
			
			alert(errorMessage);
			
			element.focus();			
			
			return false;
		}
	}
	return true;
}

function GetValue(element) 
{
	var ret="";

//alert(element.name + ' ' + element.type);
	switch (element.type) 
	{
		case "text":
		case "hidden":
		case "textarea":
		case "password":
			ret = element.value;
			break;
		case "radio":
		case "checkbox":
			for (var i=0; i<element.form.elements.length; i++) 
			{
				if (element.form.elements[i].name == element.name) 
				{
					if (element.form.elements[i].checked)
						result += objElement.form.elements[i].value+",";

				}
			}
			break;
		case "select-one":			
		case "select":
			if (element.selectedIndex >= 0)
			{
				ret = element.options[element.selectedIndex].value;				
			}
			break;
	}
		
	return ret; 
}

function ClearValue(element) 
{
	switch (element.type) 
	{
		case "text":
		case "hidden":
		case "textarea":
		case "password":
			element.value = "";
			break;
		case "radio":
		case "checkbox":
			for (var i=0; i<element.form.elements.length; i++) 
			{
				if (element.form.elements[i].name == element.name) 
				{
					if (element.form.elements[i].checked)
						element.form.elements[i].checked = false;
				}
			}
			break;
		case "select-one":			
		case "select":
			element.selectedIndex = 0;
			break;
	}
		
	return;
}

/*******************************************************************************
FILE: RegExpValidate.js

available at: http://www.rgagnon.com/jsdetails/js-0063.html
 
* DHTML date validation script. Courtesy of SmartWebby.com (http://www.smartwebby.com/dhtml/)

DESCRIPTION: This file contains a library of validation functions
  using javascript regular expressions.  Library also contains functions that re-
  format fields for display or for storage.


  VALIDATION FUNCTIONS:

  validateEmail - checks format of email address
    validateUSPhone - checks format of US phone number
    validateNumeric - checks for valid numeric value
  validateInteger - checks for valid integer value
    validateNotEmpty - checks for blank form field
  validateUSZip - checks for valid US zip code
  validateDate - checks for valid date in US format
  validateValue - checks a string against supplied pattern

  FORMAT FUNCTIONS:

  rightTrim - removes trailing spaces from a string
  leftTrim - removes leading spaces from a string
  trimAll - removes leading and trailing spaces from a string
  removeCurrency - removes currency formatting characters (), $
  addCurrency - inserts currency formatting characters
  removeCommas - removes comma separators from a number
  addCommas - adds comma separators to a number
  removeCharacters - removes characters from a string that match passed pattern


AUTHOR: Karen Gayda

DATE: 03/24/2000
*******************************************************************************/

/*function validateEmail( strValue) {
************************************************
DESCRIPTION: Validates that a string contains a
  valid email pattern.

 PARAMETERS:
   strValue - String to be tested for validity

RETURNS:
   True if valid, otherwise false.

REMARKS: Accounts for email with country appended
  does not validate that email contains valid URL
  type (.com, .gov, etc.) or valid country suffix.
*************************************************
var objRegExp  = /(^[a-z]([a-z_\.]*)@([a-z_\.]*)([.][a-z]{3})$)|(^[a-z]([a-z_\.]*)@([a-z_\.]*)(\.[a-z]{3})(\.[a-z]{2})*$)/n;

  //check for valid email
  return objRegExp.test(strValue);
}
*/

//************************************************
function validateEmail(checkThisEmail)
{
var myEMailIsValid = true;
var myAtSymbolAt = checkThisEmail.indexOf('@');
var myLastDotAt = checkThisEmail.lastIndexOf('.');
var mySpaceAt = checkThisEmail.indexOf(' ');
var myLength = checkThisEmail.length;

// at least one @ must be present and not before position 2
// @yellow.com : NOT valid
// x@yellow.com : VALID

if (myAtSymbolAt < 1 ) 
 {myEMailIsValid = false}

// at least one . (dot) afer the @ is required
// x@yellow : NOT valid
// x.y@yellow : NOT valid
// x@yellow.org : VALID

if (myLastDotAt < myAtSymbolAt) 
 {myEMailIsValid = false}

// at least two characters [com, uk, fr, ...] must occur after the last . (dot)
// x.y@yellow. : NOT valid
// x.y@yellow.a : NOT valid
// x.y@yellow.ca : VALID

if (myLength - myLastDotAt <= 2) 
 {myEMailIsValid = false}


// no empty space " " is permitted (one may trim the email)
// x.y@yell ow.com : NOT valid

if (mySpaceAt != -1) 
 {myEMailIsValid = false}


//if (myEMailIsValid == true)
 //{alert("email is VALID")}
//else
 //{alert("email is NOT valid!")}


return myEMailIsValid
}
//************************************************

function validateUSPhone( strValue ) {
/************************************************
DESCRIPTION: Validates that a string contains valid
  US phone pattern.
  Ex. (999) 999-9999 or (999)999-9999

PARAMETERS:
   strValue - String to be tested for validity

RETURNS:
   True if valid, otherwise false.
*************************************************/
  var objRegExp  = /^\([1-9]\d{2}\)\s?\d{3}\-\d{4}$/;

  //check for valid us phone with or without space between
  //area code
  return objRegExp.test(strValue);
}

function  validateNumeric( strValue ) {
/******************************************************************************
DESCRIPTION: Validates that a string contains only valid numbers.

PARAMETERS:
   strValue - String to be tested for validity

RETURNS:
   True if valid, otherwise false.
******************************************************************************/
  var objRegExp  =  /(^-?\d\d*\.\d*$)|(^-?\d\d*$)|(^-?\.\d\d*$)/;

  //check for numeric characters
  return objRegExp.test(strValue);
}

function validateInteger( strValue ) {
/************************************************
DESCRIPTION: Validates that a string contains only
    valid integer number.

PARAMETERS:
   strValue - String to be tested for validity

RETURNS:
   True if valid, otherwise false.
******************************************************************************/
  var objRegExp  = /(^-?\d\d*$)/;

  //check for integer characters
  return objRegExp.test(strValue);
}

function validateNotEmpty( strValue ) {
/************************************************
DESCRIPTION: Validates that a string is not all
  blank (whitespace) characters.

PARAMETERS:
   strValue - String to be tested for validity

RETURNS:
   True if valid, otherwise false.
*************************************************/
   var strTemp = strValue;
   strTemp = trimAll(strTemp);
   if(strTemp.length > 0){
     return true;
   }
   return false;
}

function validateUSZip( strValue ) {
/************************************************
DESCRIPTION: Validates that a string a United
  States zip code in 5 digit format or zip+4
  format. 99999 or 99999-9999

PARAMETERS:
   strValue - String to be tested for validity

RETURNS:
   True if valid, otherwise false.

*************************************************/
var objRegExp  = /(^\d{5}$)|(^\d{5}-\d{4}$)/;

  //check for valid US Zipcode
  return objRegExp.test(strValue);
}


function validateDate(strValue) {
/*************************************************
DESCRIPTION: Validates that a string contains only
    valid dates with 2 digit month, 2 digit day,
    4 digit year. Date separator can be ., -, or /.
    Uses combination of regular expressions and
    string parsing to validate date.
    Ex. mm/dd/yyyy or mm-dd-yyyy or mm.dd.yyyy

PARAMETERS:
   strValue - String to be tested for validity

RETURNS:
   True if valid, otherwise false.

REMARKS:
   Avoids some of the limitations of the Date.parse()
   method such as the date separator character.
*************************************************/
  var objRegExp = /^\d{2}(\-|\/|\.)\d{2}\1\d{4}$/;
//alert(objRegExp.test(strValue));
  //check to see if in correct format
  if(!objRegExp.test(strValue))
    return false; //doesn't match pattern, bad date
  else{
    var strSeparator = strValue.substring(2,3) //find date separator
//alert(strSeparator);
    var arrayDate = strValue.split(strSeparator); //split date into month, day, year
//alert(arrayDate);
    //create a lookup for months not equal to Feb.
    var arrayLookup = { '01' : 31,'03' : 31, '04' : 30,'05' : 31,'06' : 30,'07' : 31,
                        '08' : 31,'09' : 30,'10' : 31,'11' : 30,'12' : 31}
    var intDay = parseInt(arrayDate[1]);
//alert(intDay);
    //check if month value and day value agree
    if(arrayLookup[arrayDate[0]] != null) {
      if(intDay <= arrayLookup[arrayDate[0]] && intDay != 0)
        return true; //found in lookup table, good date
    }

    //check for February
    var intYear = parseInt(arrayDate[2]);
//alert(intYear);
    var intMonth = parseInt(arrayDate[0]);
//alert(intMonth);
    //if( ((intYear % 4 == 0 && intDay <= 29) || (intYear % 4 != 0 && intDay <=28)) && intDay !=0)
      return true; //Feb. had valid number of days
  }
  return false; //any other values, bad date
}


//**************************
var dtCh= "/";
var minYear=1900;
var maxYear=2100;

function isInteger(s){
	var n;
    for (n = 0; n < s.length; n++){   
        // Check that current character is number.
        var c = s.charAt(n);
        if (((c < "0") || (c > "9"))) return false;
    }
    // All characters are numbers.
    return true;
}

function stripCharsInBag(s, bag){
	var n;
    var returnString = "";
    // Search through string's characters one by one.
    // If character is not in bag, append to returnString.
    for (n = 0; n < s.length; n++){   
        var c = s.charAt(n);
        if (bag.indexOf(c) == -1) returnString += c;
    }
    return returnString;
}

function daysInFebruary (year){
	// February has 29 days in any year evenly divisible by four,
    // EXCEPT for centurial years which are not also divisible by 400.
    return (((year % 4 == 0) && ( (!(year % 100 == 0)) || (year % 400 == 0))) ? 29 : 28 );
}
function DaysArray(n) {
	for (var n = 1; n <= n; n++) {
		this[n] = 31;
		if (n==4 || n==6 || n==9 || n==11) {this[n] = 30}
		if (n==2) {this[n] = 29;}
   } 
   return this;
}



function validateValue( strValue, strMatchPattern ) {
/************************************************
DESCRIPTION: Validates that a string a matches
  a valid regular expression value.

PARAMETERS:
   strValue - String to be tested for validity
   strMatchPattern - String containing a valid
      regular expression match pattern.

RETURNS:
   True if valid, otherwise false.
*************************************************/
var objRegExp = new RegExp( strMatchPattern);

 //check if string matches pattern
 return objRegExp.test(strValue);
}


function rightTrim( strValue ) {
/************************************************
DESCRIPTION: Trims trailing whitespace chars.

PARAMETERS:
   strValue - String to be trimmed.

RETURNS:
   Source string with right whitespaces removed.
*************************************************/
var objRegExp = /^([\w\W]*)(\b\s*)$/;

      if(objRegExp.test(strValue)) {
       //remove trailing a whitespace characters
       strValue = strValue.replace(objRegExp, '$1');
    }
  return strValue;
}

function leftTrim( strValue ) {
/************************************************
DESCRIPTION: Trims leading whitespace chars.

PARAMETERS:
   strValue - String to be trimmed

RETURNS:
   Source string with left whitespaces removed.
*************************************************/
var objRegExp = /^(\s*)(\b[\w\W]*)$/;

      if(objRegExp.test(strValue)) {
       //remove leading a whitespace characters
       strValue = strValue.replace(objRegExp, '$2');
    }
  return strValue;
}

function trimAll( strValue ) {
/************************************************
DESCRIPTION: Removes leading and trailing spaces.

PARAMETERS: Source string from which spaces will
  be removed;

RETURNS: Source string with whitespaces removed.
*************************************************/
 var objRegExp = /^(\s*)$/;

    //check for all spaces
    if(objRegExp.test(strValue)) {
       strValue = strValue.replace(objRegExp, '');
       if( strValue.length == 0)
          return strValue;
    }

   //check for leading & trailing spaces
   objRegExp = /^(\s*)([\W\w]*)(\b\s*$)/;
   if(objRegExp.test(strValue)) {
       //remove leading and trailing whitespace characters
       strValue = strValue.replace(objRegExp, '$2');
    }
  return strValue;
}

function removeCurrency( strValue ) {
/************************************************
DESCRIPTION: Removes currency formatting from
  source string.

PARAMETERS:
  strValue - Source string from which currency formatting
     will be removed;

RETURNS: Source string with commas removed.
*************************************************/
  var objRegExp = /\(/;
  var strMinus = '';

  //check if negative
  if(objRegExp.test(strValue)){
    strMinus = '-';
  }

  objRegExp = /\)|\(|[,]/g;
  strValue = strValue.replace(objRegExp,'');
  if(strValue.indexOf('$') >= 0){
    strValue = strValue.substring(1, strValue.length);
  }
  return strMinus + strValue;
}

function addCurrency( strValue ) {
/************************************************
DESCRIPTION: Formats a number as currency.

PARAMETERS:
  strValue - Source string to be formatted

REMARKS: Assumes number passed is a valid
  numeric value in the rounded to 2 decimal
  places.  If not, returns original value.
*************************************************/
  var objRegExp = /-?[0-9]+\.[0-9]{2}$/;

    if( objRegExp.test(strValue)) {
      objRegExp.compile('^-');
      strValue = addCommas(strValue);
      if (objRegExp.test(strValue)){
        strValue = '(' + strValue.replace(objRegExp,'') + ')';
      }
      return '$' + strValue;
    }
    else
      return strValue;
}

function removeCommas( strValue ) {
/************************************************
DESCRIPTION: Removes commas from source string.

PARAMETERS:
  strValue - Source string from which commas will
    be removed;

RETURNS: Source string with commas removed.
*************************************************/
  var objRegExp = /,/g; //search for commas globally

  //replace all matches with empty strings
  return strValue.replace(objRegExp,'');
}

function addCommas( strValue ) {
/************************************************
DESCRIPTION: Inserts commas into numeric string.

PARAMETERS:
  strValue - source string containing commas.

RETURNS: String modified with comma grouping if
  source was all numeric, otherwise source is
  returned.

REMARKS: Used with integers or numbers with
  2 or less decimal places.
*************************************************/
  var objRegExp  = new RegExp('(-?[0-9]+)([0-9]{3})');

    //check for match to search criteria
    while(objRegExp.test(strValue)) {
       //replace original string with first group match,
       //a comma, then second group match
       strValue = strValue.replace(objRegExp, '$1,$2');
    }
  return strValue;
}

function removeCharacters( strValue, strMatchPattern ) {
/************************************************
DESCRIPTION: Removes characters from a source string
  based upon matches of the supplied pattern.

PARAMETERS:
  strValue - source string containing number.

RETURNS: String modified with characters
  matching search pattern removed

USAGE:  strNoSpaces = removeCharacters( ' sfdf  dfd','\s*')
*************************************************/
 var objRegExp =  new RegExp( strMatchPattern, 'gi' );

 //replace passed pattern matches with blanks
  return strValue.replace(objRegExp,'');
}

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

//***********************************************************************
// Author			: Jayson A. Velicaria
// Created       	: 28/07/2006
// Description   	: Get list based on the filters and sort form parameters
//***********************************************************************
function AutoCorrectDate(srcElement,destElement)
{	
	if (!validateNotEmpty(srcElement.value) || !validateNotEmpty(destElement.value))
	{
		return;
	}
		
	if (Date.parse(srcElement.value) > Date.parse(destElement.value))
	{
		destElement.value = srcElement.value;
	}			
}

function notEmpty(value)
{
	ret = true;
	if ((!value)||(value.length == 0))	
	{
		ret = false;
	}		
	
	return ret;
}