if(typeof HAR=="undefined") var HAR={};
if(typeof HAR.Data=="undefined") HAR.Data={};
HAR.Data.version = '2008-01-06 21:00'

//============================================================================
//---  STRING FUNCTIONS ------------------
HAR.Data.repeat = function(_s, _i) {
	return new Array(_i+1).join(_s) }

/*generate GUID*/
HAR.Data.guid=function () {
  var _guid, i, j;
  _guid = '';
  for(j=0; j<32; j++) {
    if( j == 8 || j == 12|| j == 16|| j == 20)
    _guid+='-';
    i = Math.floor(Math.random()*16).toString(16).toUpperCase();
    _guid+=i;
    }
    return _guid
  }

/* allows for conversion to string and safe escaping, even for null/undefined*/
HAR.Data.SafeToString = function(sVal) {
 if ( typeof(sVal) == 'undefined' )
		{ sVal = '' }
		var sRet = '' + sVal
		return sRet
}

//Internal Javascript Strings
//Passed a string, finds special chars '"\ and escapes them with \

HAR.Data.escQuotes = function(theStr){
  var i, theChar, escStr = "";
  for(var i=0; i<theStr.length; i++) {
    theChar = theStr.charAt(i);
    escStr += (theChar=='"' || theChar=="'" || theChar=="\\")?("\\"+theChar):theChar;
  }
  return escStr;
}

//Passed a string, finds any escape chars \ and removes them

HAR.Data.unescQuotes = function(theStr){
  var strLen, i, theChar, unescStr = "";
  strLen = theStr.length;
  for(i=0; i<strLen; i++) {
    theChar = theStr.charAt(i);
    if (theChar == "\\" && i < strLen - 1) //if escape char and not end
      theChar = theStr.charAt(++i); //append next char and skip over
    unescStr += theChar;
  }
  return unescStr;
}



//============================================================================
//Data functions
/*
  Author: Michael Harwitz
	Purpose: To assist in passing of multiple name/value pairs to functions
  send: array of name/value pair arrays, name=value
  only parses on the first "=", all chars are valid.
	returns: param object, where oParam["paramName"] will be value.
	Sample of using it to parse function arguments:
				 function testme() {
				 var oParams = ParseNameValuePairArray(arguments);
				 var msg = '';
				 for ( var e in oParams) {
				 		 msg = msg + e + ':' + oParams[e] + '\n' }
				 alert(msg);
*/
HAR.Data.ParseNameValuePairArray = function(aPairs, sDelim) {
  //default delim = '='
  if (typeof(sDelim) == 'undefined') { sDelim='=' }
	
 	var retPairArray = new Array();
	var sName, sValue, sThisPair;
	var pos
	var oPairs = new Object();

  for(var i = 0; i < aPairs.length; i++) {
	  sThisPair = aPairs[i];
		// Look for "name=value" (sDelim can be specified)
		var pos = sThisPair.indexOf(sDelim);
		// if not found, skip to next
		if (pos == -1) {
			 pos = sThisPair.length
				 }
		// Extract the name
		sName = sThisPair.substring(0,pos);
		// Extract the value
		sValue = sThisPair.substring(pos+1);
		//if param already exists, make it comma delimited mult-valued
		(oPairs[sName]==null)?oPairs[sName]=sValue:oPairs[sName]+=','+sValue;
  }

  return oPairs;
}

//------------------------------------------------------------------
//-----------------------------------------------------------------------
/* SQL-related functions
  Functions for setting parameter/values for appending to sql server
   stored procedure calls.  */

//prepares value for MsSqlServer format
HAR.Data.SqlSafeQuote = function (sValue) {
	var retStr = sValue;
	if(retStr.length>0) {
		retStr = retStr.replace("'","''") ;
		retStr = "'" + retStr + "'"
	}else{
		retStr= "null"
	}
	return retStr
}

//@paramname = 'value'
HAR.Data.spParamSet = function(sParamName, sValue){
	var retStr ;
	retStr = sParamName + "=" + HAR.Data.SqlSafeQuote(sValue);
	return retStr
}

	
/* end sql related functions */

//returns array of param name, value.  multiple values will be stored as comma delimited text
//example: queryString: ?abc=4&cc=hahaha: alert(a['abc']) would return '4'
HAR.Data.getQuerystring = function() {
	var sQuer = location.search.substring( 1, location.search.length );
	return(HAR.Data.ParseNameValuePairArray(sQuer.split('&')))
}

HAR.Data.parseUrl = function(data) {
//    var e=/^((http|ftp):\/)?\/?([^:\/\s]+)((\/\w+)*\/)([\w\-\.]+\.[^#?\s]+)(#[\w\-]+)?$/;
    var e=/((http|https|ftp):\/)?\/?([^:\/\s]+)((\/\w+)*\/)([\w\-\.]+\.[^#?\s]+)(#[\w\-]+)?/;
    try {
				if (data.match(e)) {
        return  {url: RegExp['$&'],
                protocol: RegExp.$2,
                host:RegExp.$3,
				port:"", /* not calculated yet */
                path:RegExp.$4,
                file:RegExp.$6,
                hash:RegExp.$7,
				RelativeUrl:RegExp.$4+RegExp.$6};
    }
    else {
        return  {url:"", protocol:"",host:"",path:"",file:"",hash:""};
    }
		} catch(err) {
        return  {url:"", protocol:"",host:"",path:"",file:"",hash:""};
		
		}
}
HAR.Data.locationPath = function() {
	var l=window.location.href.toString();
	return(HAR.Data.parseUrl(l));
	}

/* expects an array. returns true if no dupes, false if dupes */
HAR.Data.arrayRemoveDupes = function(_aryList) {
  var _unduped = new Object,
	    _aryUnduped = new Array();
  for (var i = 0; i < _aryList.length; i++) {
    _unduped[_aryList[i]] = _aryList[i];
    }
  for (var k in _unduped) {
    _aryUnduped.push(_unduped[k]);}
  return(_aryUnduped);
}

HAR.Data.TitleCase = function(str) {
	function InitCapWord() {
		return arguments[0].toUpperCase();
		}
	return str.toLowerCase().replace(/\b[a-z]/g, InitCapWord);
	}

/*===========================================================*/
//-------------------------------------------------------------------
// Trim functions
//   Returns string with whitespace trimmed
//-------------------------------------------------------------------
HAR.Data.LTrim = function(str){
	for(var i=0;str.charAt(i)==" ";i++);
	return str.substring(i,str.length);
	}
HAR.Data.RTrim = function(str){
	for(var i=str.length-1;str.charAt(i)==" ";i--);
	return str.substring(0,i+1);
	}
HAR.Data.Trim = function(str){return HAR.Data.LTrim(HAR.Data.RTrim(str));}
//-------------------------------------------------------------------
// isNull(value)
//   Returns true if value is null
//-------------------------------------------------------------------
HAR.Data.isNull = function(val){return(val==null);}

//-------------------------------------------------------------------
// isBlank(value)
//   Returns true if value only contains spaces
//-------------------------------------------------------------------
HAR.Data.isBlank = function(val){
	if(val==null){return true;}
	for(var i=0;i<val.length;i++) {
		if ((val.charAt(i)!=' ')&&(val.charAt(i)!="\t")&&(val.charAt(i)!="\n")&&(val.charAt(i)!="\r")){return false;}
		}
	return true;
	}

//-------------------------------------------------------------------
// isInteger(value)
//   Returns true if value contains all digits
//-------------------------------------------------------------------
HAR.Data.isInteger = function(val){
	for(var i=0;i<val.length;i++){
		if(!HAR.Data.isDigit(val.charAt(i))){return false;}
		}
	return true;
	}

//-------------------------------------------------------------------
// isNumeric(value)
//   Returns true if value contains a positive float value
//-------------------------------------------------------------------
HAR.Data.isNumeric = function(val){return(parseFloat(val,10)==val);}

//-------------------------------------------------------------------
// isArray(obj)
// Returns true if the object is an array, else false
//-------------------------------------------------------------------
HAR.Data.isArray = function(obj){
	if(typeof(obj)=='string') return false;
	return(typeof(obj.length)=="undefined")?false:true;}

//-------------------------------------------------------------------
// isDigit(value)
//   Returns true if value is a 1-character digit
//-------------------------------------------------------------------
HAR.Data.isDigit = function(num) {
	if (num.length>1){return false;}
	var string="1234567890";
	if (string.indexOf(num)!=-1){return true;}
	return false;
	}

// Removes all characters which appear in string bag from string s.

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



// Removes all characters which do NOT appear in string bag
// from string s.

HAR.Data.stripCharsNotInBag = function (s, bag) {
	var i;
    var returnString = "";

    // Search through string's characters one by one.
    // If character is in bag, append to returnString.

    for (i = 0; i < s.length; i++)
    {
        // Check that current character isn't whitespace.
        var c = s.charAt(i);
        if (bag.indexOf(c) != -1) returnString += c;
    }

    return returnString;
}


HAR.Data.stripNonNumeric = function(s) {
	s=HAR.Data.stripCharsNotInBag(s,'0123456789.')
	return(s)
	 }

HAR.Data.today = function() {
	var oDate = new Date()
	var sDate =  (oDate.getMonth() + 1) + '/' +  oDate.getDate() + '/' + oDate.getFullYear()
	return(sDate)
	}

HAR.Data.inList = function(_search, _list) {
	if(typeof(_list)=='string') _list=_list.split(',');
	for(var i=0;i<_list.length;i++){
		if(_list[i]==_search) return true;
		}
	return false
	}

// allow only letters, numbers, and underscores
HAR.Data.validateUsername=function(strng) {
	var illegalChars = /\W/;
	if ((strng == "")
	  || (strng.length < 6)
	  || (illegalChars.test(strng))) {
			return false;
			}
	return true;
	}

HAR.Data.validatePassword=function (strng) {
	strng+='';
    var illegalChars = /[\W_]/; // allow only letters and numbers
	if ((strng.length < 6)||(illegalChars.test(strng))) {
		return false;
		}
	return true;
	}
	
HAR.Data.validateEmail =function(_email) {
	var emailFilter=/^.+@.+\..{2,3}$/;
	var illegalChars= /[\(\)\<\>\,\;\:\\\/\"\[\]]/
	if (!(emailFilter.test(_email))||(_email.match(illegalChars))) {
		   return false;
		}
	return true;
	}

HAR.Data.validateLuhn = function(luhnIn){
        luhnIn=''+HAR.Data.stripNonNumeric(luhnIn);
        if(luhnIn==''||parseInt(luhnIn,10)==0) return false;
	var luhn = '', digits = '';;
	var anum = 0, sum = 0, j=0, k=0;
	
	//reverse string and strip out all non numeric characters
	for (j=luhnIn.length; j>=0; j--)
		if (!isNaN(parseInt(luhnIn.charAt(j))))
			luhn += luhnIn.charAt(j);

	for (j=0; j<luhn.length; j++){
		anum = luhn.charCodeAt(j) - 48;
		if (j%2!=0)
			anum*=2;
		digits = ''+anum;
		for(k=0; k<digits.length; k++)
			sum+=digits.charCodeAt(k) - 48;
	}
	return (sum%10==0);
}


/* takes an array of json data and populates it in a repeating template.
{%item name%} replaced with data when present, otherwise blanked out
author: Michael Harwitz */
HAR.Data.jsonTemplate = function (jsnArguments) {
	var aData=jsnArguments["data"],
		sTemplate=jsnArguments["mergeTemplate"],
		sHeader=jsnArguments["header"],
		sFooter=jsnArguments["footer"];
	if(!sHeader) sHeader='';
	if(!sFooter) sFooter='';
	for(var i=0, aProcessed=[], oThisData, tmpTemplate;i<aData.length;i++) {
		oThisData=aData[i];
		tmpTemplate=sTemplate;
		for(o in oThisData) {
			var rg=eval('/{%'+o+'%}/gm');
			tmpTemplate=tmpTemplate.replace(rg,oThisData[o]);
			}
		/*clean up any unmerged tags*/
		tmpTemplate=tmpTemplate.replace(/{%[a-zA-Z0-9_]+%}/gm,"")
		/*add to processed array*/
		aProcessed.push(tmpTemplate);
		}
	/*return joined array as string*/
	return sHeader+aProcessed.join("")+sFooter;
	}

HAR.Data.inArray=function(arr, val, from) {
	if (Array.prototype.indexOf)
		return arr.indexOf(val, from);
	var len = arr.length;
	var from = Number(arguments[2]) || 0;
	from=(from < 0)? Math.ceil(from):Math.floor(from);
	if (from < 0)
		from += len;
	for (; from < len; from++) {
		if (from in arr && arr[from]===val)
		return from;
		}
}