//<script language="javascript">
/*=============================================================================
 WebSolvers Framework Library
 Copyright 2003, WebSolvers, Inc., All Rights Reserved.                

 Library Validation (Basic Types)
 Cross-Browser/Platform common Validation library for basic variables
 
 Revision History:
 6-4-03 Created

 Supports
 Library_Validation

 Provides
 The following validation types are provided
	ltrim
	rtrim
	trim
	str([min len], [max len])
	int([min], [max])
	float([min], [max])
	date
	time
	email
	

  Notes:
=============================================================================

 The WebSolvers Framework Library may be used and/or modified by anyone owning
 the original work as it was incorporated into an original development project
 so long as this copyright notice and the comments above remain intact.  

 By using this code you agree to indemnify WebSolvers, Inc. from any liability
 that might arise from its use.

 This code may not be sold exclusively or as a part of other code without prior 
 written consent and is expressly forbidden.

 Obtain permission before redistributing this software over the Internet or 
 in any other medium. In all cases the copyright and header must remain intact. 
============================================================================= */

//======================================================================================
//                                 Internal Routines
//======================================================================================

if(!window.validate) {
	alert("Form Libraries not installed, or installed after FormTypes!");
}

function validator_String(value, params, elem) {
	var max = (params.length && !isNaN(parseInt(params[0],10)) ? parseInt(params[0],10) : Number.POSITIVE_INFINITY);
	var min = (params.length > 1 && !isNaN(parseInt(params[1],10)) ? parseInt(params[1],10) : 0);

	if(max < min) {
		var sw = max;
		max = min;
		min = sw;
	}

	if(value || value == 0)
		value = value.toString();
	else {
  	validator_String._value = value;
		return '';
	}

	validator_String._value = value;
	if(value.length > max)
		return ' cannot have more than ' + max +' characters';
	if(value.length < min)
		return ' must have at least ' + min + ' characters';

	return '';
}

function validator_Integer(value, params, elem) {
	var max = (params.length && !isNaN(parseInt(params[0],10)) ? parseInt(params[0],10) : Number.POSITIVE_INFINITY);
	var min = (params.length > 1 && !isNaN(parseInt(params[1],10)) ? parseInt(params[1],10) : Number.NEGATIVE_INFINITY);

	if(max < min) {
		var sw = max;
		max = min;
		min = sw;
	}

	if(value == null || !value.toString().trim().length) {
  	validator_Integer._value = value;
	  return '';
	} else if(value || value == 0)
		value = cint(value.toString().trim());
	else
		value = Number.NaN;

	validator_Integer._value = value;
	if(isNaN(value))
		return ' is not a valid integer';
	if(value > max)
		return ' cannot be greater than ' + max;
	if(value < min)
		return ' can be no less than ' + min;
		
	return '';
}

function validator_Float(value, param, elems) {
	var max = (params.length && !isNaN(parseFloat(params[0])) ? parseFloat(params[0]) : Number.POSITIVE_INFINITY);
	var min = (params.length > 1 && !isNaN(parseFloat(params[1])) ? parseFloat(params[1]) : Number.NEGATIVE_INFINITY);
	var type = "";

	if(max < min) {
		var sw = max;
		max = min;
		min = sw;
	}

	if(value == null || !value.toString().trim().length) {
  	validator_Float._value = value;
	  return '';
	} else if(value || value == 0)
		value = value.toString().trim();
	else {
  	validator_Float._value = value;
		return '';
	}
	
	if(value.substr(value.length-1) == "%") {
		type = "%";
		value = value.substr(0, value.length-1);
	} else {
		type = value.substr(0, 1);
		value = value.substr(1);
	}
	
	switch(type) {
	case "$":;
	case "%":;
		break;
	default:
		value = type + value;
	}
	value = parseFloat(value.trim());
	if(!isNaN(num) && type == "%")
		value /= 100;

	validator_Float._value = value;
	if(isNaN(value))
		return ' is not a valid decimal number';
	if(value > max)
		return ' cannot be greater than ' + max;
	if(value < min)
		return ' can be no less than ' + min;
		
	return '';
}

function parseDate(str, def) {
	var n = Date.parse(str);
	var s = "";
	var p = 0;
	var m = 1;
	
	str = str.trim();
	if(!str || !str.length)
		return def;
	
	if(!isNaN(n))
		return n;
	
	p = str.indexOf('+');
	m = str.indexOf('-');
	if(p > -1 || m > -1) {
		if(m > -1 && m < p)
			p = m;
		s = str.substr(0, p).trim();
		str = str.substr(p, str.length).trim();
	} else {
		s = str;
		str = "";
	}

	n = new Date();
	switch(s.toLowerCase()) {
	case "now":
		break;
	case "year":
	case "thisyear":
		n.setMonth(1);
	case "month":
	case "thismonth":
		n.setDate(1);
	case "today":
	case "thisday":
		n.setHours(0);
		n.setMinutes(0);
		n.setSeconds(0);
		n.setMilliseconds(0);
		break;
	default:
		return def;
	}

	while(str && str.length && (str.substr(0, 1) == "+" || str.substr(0, 1) == "-")) {
		if(str.substr(0,1) == "-")
			m = -1;
		else
			m = 1;
			
		str = str.substr(1, str.length);
		p = parseInt(str, 10);
		str = str.substr(p.toString().length, str.length);
		s = str.substr(0, 1);
		str = str.substr(1, str.length).trim();
		
		switch(s.toLowerCase()) {
		case "n":
			n.setMilliseconds(n.getMilliseconds()+(m*p));
			break;
		case "s":
			n.setSeconds(n.getSeconds()+(m*p));
			break;
		case "i":
			n.setMinutes(n.getMinutes()+(m*p));
			break;
		case "h":
			n.setHours(n.getHours()+(m*p));
			break;
		case "d":
			n.setDate(n.getDate()+(m*p));
			break;
		case "m":
			n.setMonth(n.getMonth()+(m*p));
			break;
		case "y":
			n.setYear(n.getYear()+(m*p));
			break;
		}
	}

	return n.getTime();
}

function validator_Date(value, params, elem) {
	var max = (params.length ? parseDate(params[0], Number.POSITIVE_INFINITY) : Number.POSITIVE_INFINITY);
	var min = (params.length > 1 ? parseDate(params[1], 0) : 0);

	if(max < min) {
		var sw = max;
		max = min;
		min = sw;
	}

	validator_Date._value = value;
	if(!value || !value.toString().length)
	  return '';
	
	var y = value.trim();
	var dc = (y.indexOf('/') > -1 ? '/' : (y.indexOf('-') > -1 ? '-' : (y.indexOf('.') > -1 ? '.'
			 : (y.indexOf(',') > -1 ? ',' : (y.indexOf('\\') > -1 ? '\\' : (y.indexOf(' ') > -1 ? ' '
			 : ''))))));
	var m = 0;
	var d = 0;
	var ly = 0;
	if(!dc.length)
		return ' is not a valid date';
			
	y = y.split(dc);
	if(y.length != 3)
		return ' is not a valid date';

	m = parseInt(y[0],10);
	if(isNaN(m) || m < 1)
		return ' is not a valid date';

	d = parseInt(y[1],10);
	if(isNaN(d) || d < 1)
		return ' is not a valid date';
								
	y = parseInt(y[2],10);
	if(isNaN(y) || y < 1)
		return ' is not a valid date';

	// going to be nice and try to handle mangled dates
	// I run two loops to be safe
	for(var i = 0; i < 2; i++) {
		if(m > 12 && y < 13) {
			var sw = y;
			y = m;
			m = sw;
		} else if(m > 12 && d < 13) {
			var sw = d;
			d = m;
			m = sw;
		} else if(m > 12)
			return ' is not a valid date.';
			
		if(d > 31 && y < 32) {
			var sw = y;
			y = d;
			d = sw;
		}
	}

	ly=(!(y % 100) && !(y % 400)) || !(y % 4);
		
	if(m == 2 && ly && d > 29)
		return ' is not a valid date';
	else if(m == 2 && d > 28)
		return ' is not a valid date';
	else if((m == 4 || m == 6 || m == 9 || m == 11) && d > 30)
		return ' is not a valid date';
	else if( d > 31)
		return ' is not a valid date';

	validator_Date._value = m+'/'+d+'/'+y;
	d = new Date(validator_Date._value);

	if(d.getTime() > max) {
		d = new Date(max);
		return ' cannot be greater than ' + (d.getMonth() + 1) + '/' + d.getDate() + '/' + d.getFullYear();
	} else if(d.getTime() < min) {
		d = new Date(min);
		return ' can be no less than ' + (d.getMonth() + 1) + '/' + d.getDate() + '/' + d.getFullYear();
	}
	
	return '';
}

function time2sec(str) {
	var h = str.toString().trim();
	var a = "";
	var s = 0;
	switch(h.substr(h.length-1)) {
	case "a":;
		a = "am";
		h = h.substr(0, h.length-1).trim();
		break;
	case "p":;
		a = "pm";
		h = h.substr(0, h.length-1).trim();
		break;
	case "m":;
		a = h.substr(h.length-2);
		h = h.substr(0, h.length-2).trim();
		break;
	}
	
	h = h.split(':');
	if(h.length > 3)
		return Number.NaN;
		
	if(h.length > 2)
		s = cint(h[2].trim());
	if(h.length > 1)
		s += cint(h[1].trim()) * 60;

	h = cint(h[0].trim());
	if((a == "am" && h < 12) || a == "")
		s += h * 3600;
	else if(ap == "pm" && h < 12)
		s += 43200 + (h * 3600);
	else if(ap == "pm")
		s += 43200;

	time2sec._ap = a.length;

	return s;
}

function sec2time(sec, ap) {
	var h = sec / 3600;
	var m = (sec % 3600) / 60;
	var s = sec % 60;
	var a = "";
	
	if(ap) {
		if(h > 11)
			ap = " pm";
		else
			ap = " am";

		if(h == 0)
			h = 12;
		else if (h > 12)
			h -= 12;
	}
		 
	return h + ':' + m + ':' + s + a;
}

function validator_Time(value, params, elem) {
	var max = (params.length && !isNaN(time2sec(params[0])) ? time2sec(params[0]) : 86399);
	var maxap = time2sec._ap;
	var min = (params.length > 1 && !isNaN(time2sec(params[1])) ? time2sec(params[1]) : 0);
	var minap = time2sec._ap;

	if(max < min) {
		var sw = max;
		max = min;
		min = sw;
	}

	validator_Time._value = value;
	if(!value || !value.toString().length)
	  return '';
	
	value = time2sec(value);
	var valap = time2sec._ap;

	if(isNaN(value))
		return ' is not a valid time';
	else if(value > max)
		return ' cannot be greater than ' + sec2time(max, maxap);
	else if(value < min)
		return ' can be no less than ' + sec2time(min, minap);

	validator_Time._value = sec2time(value, valap);
	return '';
}

function validator_Email(value, params, elem) {
	var reEmail = /^[\w]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/	

	value = value.trim();
	validator_Email._value = value;
	if(!value || !value.toString().length)
	  return'';
	  
	if(!reEmail.test(value))
		return ' is not a valid email address';
	
	return '';
}

if(window.validate) {
	validate.addValidator('ltrim', 
			function(value, params, elem) {
				arguments.callee._value = value.toString().ltrim();
				
				return '';
			}, -1);
	
	validate.addValidator('rtrim', 
			function(value, params, elem) {
				arguments.callee._value = value.toString().rtrim();
				
				return '';
			}, -1);
	
	validate.addValidator('trim', 
			function(value, params, elem) {
				arguments.callee._value = value.toString().trim();
				
				return '';
			}, -1);
	
	validate.addValidator('str', validator_String, null, 2);
	
	validate.addValidator('int', validator_Integer, null, 2);
	
	validate.addValidator('float', validator_Float, null, 2);
	
	validate.addValidator('date', validator_Date, null, 2);
	
	validate.addValidator('time', validator_Time, null, 2);
	
	validate.addValidator('email', validator_Email);
}