//------------utils function define-----------------
/*

-------------- 函数检索 --------------
trim函数:                         trim() lTrim() rTrim()
校验字符串是否为空:                 checkIsNotEmpty(str)
校验字符串是否为整型:               checkIsInteger(str)
校验整型最小值:                    checkIntegerMinValue(str,val)
校验整型最大值:                    checkIntegerMaxValue(str,val) 
校验整型是否为非负数:               isNotNegativeInteger(str)  //有问题,不要使用改用checkNotNegativeInteger
校验字符串是否为浮点型:             checkIsDouble(str)         
校验浮点型最小值:                  checkDoubleMinValue(str,val)
校验浮点型最大值:                  checkDoubleMaxValue(str,val)
校验浮点型是否为非负数:             isNotNegativeDouble(str)
校验字符串是否为日期型:             checkIsValidDate(str)
校验两个日期的先后:                checkDateEarlier(strStart,strEnd)
校验字符串是否为合法email地址:           checkEmail(str)
校验字符串是否为中文和字母和空格			checkChineseChar(str)

校验字符串是否为中文:               checkIsChinese(str)
计算字符串的长度，一个汉字两个字符:   realLength()
校验字符串是否符合自定义正则表达式:   checkMask(str,pat)
得到文件的后缀名:                   getFilePostfix(oFile)
是否超过最大长度                     isOverLength(str,maxLength)
交换两个select里的值                selectChange(src,des)
是否是正实数                         isUnsignedReal(num)
得到所选择的复选框的值:             reChecked(store,checkboxId,tabId)
检查上传文件的类型是否被允许          checkFileType(allowFileTypes,fileId)
检查一个字符串是否为非负整数        checkNotNegativeInteger
检查身份证是否合法(简易的)					isIdCardNo(num)
限制textArea的行数					checkTextAreaRows(obj,len)
省略号替代多余字符                         replaceStr(str,num)
删除富文本编辑器中的显示标签             mailFiltrateTag(str)
去掉文本格式,并且用省略号替代多余字符		filtrateTag(str)
检查管理员修改用户密码的长度              checkAdminSetPasswordLen(password)
校验字符串是否为价格类型(价格数字格式为:小数点后面的数字最多2位,小数点前面最多7位)   checkIsDoubleBeArr(str)
编号的输入只允许字母和数字                     checkIsCode(str)
获得当前日期  YYYY-MM-DD  getNonceDate()

-------------- 函数检索 --------------
*/

/**
*校验字符串是否为价格类型(价格数字格式为:小数点后面的数字最多3位,小数点前面最多7位)
*返回值：
*如果为空，定义校验通过，      返回true
*如果字串为浮点型，校验通过，  返回true
*如果校验不通过，              返回false     参考提示信息：输入域不是合法的价格类型！
*/
function checkIsfeifushu(str){
	 //如果为空，则通过校验
    if(str == "")
        return true;
    return /^\d{1,7}(\.\d{1,3})?$/g.test(str);
}




/**
* added by LxcJie 2004.6.25
* 去除多余空格函数
* trim:去除两边空格 lTrim:去除左空格 rTrim: 去除右空格
* 用法：
*     var str = "  hello ";
*     str = str.trim();
*/
String.prototype.trim = function()
{
    return this.replace(/(^\s*)|(\s*$)/g, "");
}
String.prototype.lTrim = function()
{
    return this.replace(/(^[\s]*)/g, "");
}
String.prototype.rTrim = function()
{
    return this.replace(/([\s]* $)/g, "");
}
/********************************** Empty **************************************/
/**
*校验字符串是否为空
*返回值：
*如果不为空，定义校验通过，返回true
*如果为空，校验不通过，返回false               参考提示信息：输入域不能为空！
*/
function checkIsNotEmpty(str)
{
    if(str.trim() == "")
        return false;
    else
        return true;
}

function isEmpty(str){
	if(str.trim() == "")
        return true;
    else
        return false;
}
/*--------------------------------- Empty --------------------------------------*/
/********************************** Integer *************************************/
/**
*校验字符串是否为整型
*返回值：
*如果为空，定义校验通过，      返回true
*如果字串全部为数字，校验通过，返回true
*如果校验不通过，              返回false     参考提示信息：输入域必须为数字！
*/
function checkIsInteger(str)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
	return /^(\-?)(\d+)$/g.test(str);
}//~~~
/**
*校验整型最小值
*str：要校验的串。  val：比较的值
*
*返回值：
*如果为空，定义校验通过，                返回true
*如果满足条件，大于等于给定值，校验通过，返回true
*如果小于给定值，                        返回false              参考提示信息：输入域不能小于给定值！
*/
function checkIntegerMinValue(str,val)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if(typeof(val) != "string")
        val = val + "";
    if(checkIsInteger(str) == true)
    {
        if(parseInt(str,10)>=parseInt(val,10))
            return true;
        else
            return false;
    }
    else
        return false;
}//~~~
/**
*校验整型最大值
*str：要校验的串。  val：比较的值
*
*返回值：
*如果为空，定义校验通过，                返回true
*如果满足条件，小于等于给定值，校验通过，返回true
*如果大于给定值，                        返回false       参考提示信息：输入值不能大于给定值！
*/
function checkIntegerMaxValue(str,val)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if(typeof(val) != "string")
        val = val + "";
    if(checkIsInteger(str) == true)
    {
        if(parseInt(str,10)<=parseInt(val,10))
            return true;
        else
            return false;
    }
    else
        return false;
}//~~~
/**
*校验整型是否为非负数
*str：要校验的串。
*
*返回值：
*如果为空，定义校验通过，返回true
*如果非负数，            返回true
*如果是负数，            返回false               参考提示信息：输入值不能是负数！
*/
function isNotNegativeInteger(str)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if(checkIsInteger(str) == true)
    {
        if(parseInt(str,10) < 0)
            return false;
        else
            return true;
    }
    else
        return false;
}//~~~
/*--------------------------------- Integer --------------------------------------*/
/********************************** Double ****************************************/
/**
*校验字符串是否为浮点型
*返回值：
*如果为空，定义校验通过，      返回true
*如果字串为浮点型，校验通过，  返回true
*如果校验不通过，              返回false     参考提示信息：输入域不是合法的浮点数！
*/
function checkIsDouble(str)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    return /^[\+\-]?\d*\.?\d*$/g.test(str);
}//~~~
/**
*校验字符串是否为价格类型(价格数字格式为:小数点后面的数字最多2位,小数点前面最多7位)
*返回值：
*如果为空，定义校验通过，      返回true
*如果字串为浮点型，校验通过，  返回true
*如果校验不通过，              返回false     参考提示信息：输入域不是合法的价格类型！
*/
function checkIsDoubleBeArr(str){
	 //如果为空，则通过校验
    if(str == "")
        return true;
    return /^\d{1,7}(\.\d{1,2})?$/g.test(str);
}
//~~~
/**
*校验浮点型最小值
*str：要校验的串。  val：比较的值
*
*返回值：
*如果为空，定义校验通过，                返回true
*如果满足条件，大于等于给定值，校验通过，返回true
*如果小于给定值，                        返回false              参考提示信息：输入域不能小于给定值！
*/
function checkDoubleMinValue(str,val)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if(typeof(val) != "string")
        val = val + "";
    if(checkIsDouble(str) == true)
    {
        if(parseFloat(str)>=parseFloat(val))
            return true;
        else
            return false;
    }
    else
        return false;
}//~~~
/**
*校验浮点型最大值
*str：要校验的串。  val：比较的值
*
*返回值：
*如果为空，定义校验通过，                返回true
*如果满足条件，小于等于给定值，校验通过，返回true
*如果大于给定值，                        返回false       参考提示信息：输入值不能大于给定值！
*/
function checkDoubleMaxValue(str,val)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if(typeof(val) != "string")
        val = val + "";
    if(checkIsDouble(str) == true)
    {
        if(parseFloat(str)<=parseFloat(val))
            return true;
        else
            return false;
    }
    else
        return false;
}//~~~
/**
*校验浮点型是否为非负数
*str：要校验的串。
*
*返回值：
*如果为空，定义校验通过，返回true
*如果非负数，            返回true
*如果是负数，            返回false               参考提示信息：输入值不能是负数！
*/
function isNotNegativeDouble(str)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    return /^\d*\.?\d*$/g.test(str);
}//~~~
/*--------------------------------- Double ---------------------------------------*/
/********************************** date ******************************************/
/**
*校验字符串是否为日期型
*返回值：
*如果为空，定义校验通过，           返回true
*如果字串为日期型，校验通过，       返回true
*如果日期不合法，                   返回false    参考提示信息：输入域的时间不合法！（yyyy-MM-dd）
*/
function checkIsValidDate(str)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    var pattern = /^((\d{4})|(\d{2}))-(\d{1,2})-(\d{1,2}) $/g;
    if(!pattern.test(str))
        return false;
    var arrDate = str.split("-");
    if(parseInt(arrDate[0],10) < 100)
        arrDate[0] = 2000 + parseInt(arrDate[0],10) + "";
    var date =  new Date(arrDate[0],(parseInt(arrDate[1],10) -1)+"",arrDate[2]);
    if(date.getYear() == arrDate[0]
       && date.getMonth() == (parseInt(arrDate[1],10) -1)+""
       && date.getDate() == arrDate[2])
        return true;
    else
        return false;
}//~~~
/**
*校验两个日期的先后
*返回值：
*如果其中有一个日期为空，校验通过,          返回true
*如果起始日期早于等于终止日期，校验通过，   返回true
*如果起始日期晚于终止日期，                 返回false    参考提示信息： 起始日期不能晚于结束日期。
*/
function checkDateEarlier(strStart,strEnd)
{
    if(checkIsValidDate(strStart) == false || checkIsValidDate(strEnd) == false)
        return false;
    //如果有一个输入为空，则通过检验
    if (( strStart == "" ) || ( strEnd == "" ))
        return true;
    var arr1 = strStart.split("-");
    var arr2 = strEnd.split("-");
    var date1 = new Date(arr1[0],parseInt(arr1[1].replace(/^0/,""),10) - 1,arr1[2]);
    var date2 = new Date(arr2[0],parseInt(arr2[1].replace(/^0/,""),10) - 1,arr2[2]);
    if(arr1[1].length == 1)
        arr1[1] = "0" + arr1[1];
    if(arr1[2].length == 1)
        arr1[2] = "0" + arr1[2];
    if(arr2[1].length == 1)
        arr2[1] = "0" + arr2[1];
    if(arr2[2].length == 1)
        arr2[2]="0" + arr2[2];
    var d1 = arr1[0] + arr1[1] + arr1[2];
    var d2 = arr2[0] + arr2[1] + arr2[2];
    if(parseInt(d1,10) > parseInt(d2,10))
       return false;
    else
       return true;
}//~~~
/*--------------------------------- date -----------------------------------------*/
/********************************** email *****************************************/
/**
*校验字符串是否为email型
*返回值：
*如果为空，定义校验通过，           返回true
*如果字串为email型，校验通过，      返回true
*如果email不合法，                  返回false    参考提示信息：Email的格式不正確！
*/
function checkEmail(str)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if (str.charAt(0) == "." || str.charAt(0) == "@" || str.indexOf('@', 0) == -1
        || str.indexOf('.', 0) == -1 || str.lastIndexOf("@") == str.length-1 || str.lastIndexOf(".") == str.length-1)
        return false;
    else
        return true;
}//~~~
/*--------------------------------- email ----------------------------------------*/
/********************************** chinese ***************************************/
/**
*校验字符串是否为中文
*返回值：
*如果为空，定义校验通过，           返回true
*如果字串为中文，校验通过，         返回true
*如果字串为非中文，             返回false    参考提示信息：必须为中文！
*/
function checkIsChinese(str)
{
    //如果值为空，通过校验
    if (str == "")
        return true;
    var pattern = /^([\u4E00-\u9FA5]|[\uFE30-\uFFA0])* $/gi;
    if (pattern.test(str))
        return true;
    else
        return false;
}//~~~
/**
* 计算字符串的长度，一个汉字两个字符
*/
String.prototype.realLength = function()
{
  return this.replace(/[^\x00-\xff]/g,"**").length;
}
/*--------------------------------- chinese --------------------------------------*/
/********************************** mask ***************************************/
/**
*校验字符串是否符合自定义正则表达式
*str 要校验的字串  pat 自定义的正则表达式
*返回值：
*如果为空，定义校验通过，           返回true
*如果字串符合，校验通过，           返回true
*如果字串不符合，                   返回false    参考提示信息：必须满足***模式
*/
function checkMask(str,pat)
{
    //如果值为空，通过校验
    if (str == "")
        return true;
    var pattern = new RegExp(pat,"gi")
    if (pattern.test(str))
        return true;
    else
        return false;
}//~~~
/*--------------------------------- mask --------------------------------------*/
/********************************** file ***************************************/
/**
* added by LxcJie 2004.6.25
* 得到文件的后缀名
* oFile为file控件对象
*/
function getFilePostfix(oFile)
{
    if(oFile == null)
        return null;
    var pattern = /(.*)\.(.*) $/gi;
    if(typeof(oFile) == "object")
    {
        if(oFile.value == null || oFile.value == "")
            return null;
        var arr = pattern.exec(oFile.value);
        return RegExp. $2;
    }
    else if(typeof(oFile) == "string")
    {
        var arr = pattern.exec(oFile);
        return RegExp. $2;
    }
    else
        return null;
}
/*-------------------
说明:是否全选，或全不选
srcChkId:全选checkbox的name属性
descChkId:目标checkbox的name属性
--------------------*/
function checkAll(srcChkId,descChkId){
	var srcObj=document.getElementsByName(srcChkId);
	var descObj=document.getElementsByName(descChkId);
	
	if(srcObj[0].checked==true){
		for(var i=0;i<descObj.length;i++){
			descObj[i].checked=true;
		}
	}
	
	if(srcObj[0].checked==false){
		for(var i=0;i<descObj.length;i++){
			descObj[i].checked=false;
		}
	}
}

/*-------------------
说明:是否全选，或全不选
srcChkId:全选checkbox的name属性
descChkId:目标checkbox的name属性
textChId:目标text的name属性
--------------------*/
function checkAllText(srcChkId,descChkId,textChId){
	var srcObj=document.getElementsByName(srcChkId);
	var descObj=document.getElementsByName(descChkId);
	var textObj=document.getElementsByName(textChId);
	
	if(srcObj[0].checked==true){
		for(var i=0;i<descObj.length;i++){
			descObj[i].checked=true;
			textObj[i].disabled=false;
		}
	}
	
	if(srcObj[0].checked==false){
		for(var i=0;i<descObj.length;i++){
			descObj[i].checked=false;
			textObj[i].disabled=true;
		}
	}
}

/*-------------------
说明:改变状态
descChkId:目标checkbox的name属性
textChId:目标text的name属性
--------------------*/
function checkText(descChkId,textChId){
	var descObj=document.getElementsByName(descChkId);
	var textObj=document.getElementsByName(textChId);
	
	for(var i=0;i<descObj.length;i++){
	    if(descObj[i].checked){
	    	textObj[i].disabled=false;
		}else{
			textObj[i].disabled=true;
		}
	}
}

/*******************
*form:要提交的form表单
*url：要链接的地址
*target:目标窗口
********************/
function doSubmit(form,url,target){
	if(target==null)
		document.getElementById(form).target="_self";
	else
		document.getElementById(form).target=target;
	document.getElementById(form).action=url;
	document.getElementById(form).submit();
}

/*-------------------
说明:是否展开菜单
sid:菜单的序列
menu:菜单的名称
--------------------*/
function showsubmenu(sid,menu){
	whichEl = eval("submenu" + sid);
	var menu = menu;
	if (whichEl.style.display == "none"){
		eval("submenu" + sid + ".style.display=\"\";");
		menu.className = "menu_title2";
	}else{
		eval("submenu" + sid + ".style.display=\"none\";");
		menu.className = "menu_title";
	}
}

/*-------------------
是否超过最大长度
---------------------*/
function isOverLength(str,maxLength){
	if(str.replace(/[^\x00-\xff]/g, "~~~").length>maxLength){
		return true;
	}else
		return false;
}

/*-------------------
说明：清空error Span
--------------------*/
function clearErrors(){
	var spanObj=document.getElementById(spanId);
	var msgsObj=document.getElementById(msgsId);
	var errorsObj=document.getElementById(errorsId);
	
	if(msgsObj!=null){
		msgsObj.removeNode(true);
	}
	if(errorsObj!=null)
		errorsObj.removeNode(true);
		
	errorMsgs="";
	spanObj.className="";
	spanObj.innerHTML="";
}

/*-------------------
说明：写出错误记录！
--------------------*/
function writeErrors(){
	var spanObj=document.getElementById(spanId);
	
	spanObj.className=spanCss;
	spanObj.innerHTML=errorMsgs;
}

/*-------------------
说明:修改的动作
form:表单的id
url：表单的action
target:表单的target
checkboxId:列表前checkbox的name值
--------------------*/
function oneInListVal(form,url,target,checkboxId){
	clearErrors();
	if(isSelected(checkboxId)&&isSelectOnlyOne(checkboxId)){
		doSubmit(form,url,target);
	}else{
		writeErrors();
	}
}

/*-------------------
说明：删除记录
checkboxId:记录前checkbox的name属性
--------------------*/
function removeListVal(form,url,target,checkboxId){
	clearErrors();	
	if(isSelected(checkboxId)){
		if(confirm(hint_deleteOnServer)==true)
			doSubmit(form,url,target);
	}else{
		writeErrors();
	}
}

function updateFlagListVal(form,url,target,checkboxId){
	clearErrors();	
	if(isSelected(checkboxId)){
		if(confirm("确定修改吗？")==true)
			doSubmit(form,url,target);
	}else{
		writeErrors();
	}
}


/*-------------------
说明：设置已读记录
checkboxId:记录前checkbox的name属性
--------------------*/
function readListVal(form,url,target,checkboxId){
	clearErrors();	
	if(isSelected(checkboxId)){
		if(confirm("是否设置已读？")==true)
			doSubmit(form,url,target);
	}else{
		writeErrors();
	}
}
/*-------------------
说明：设置已回复记录
checkboxId:记录前checkbox的name属性
--------------------*/
function replyListVal(form,url,target,checkboxId){
	//clearErrors();	
	if(isSelected(checkboxId)){
		if(confirm("是否设置已回复？")==true)
			doSubmit(form,url,target);
	}else{
		writeErrors();
	}
}
/*-------------------
说明：设置屏蔽记录
checkboxId:记录前checkbox的name属性
--------------------*/
function shiledListVal(form,url,target,checkboxId){
	clearErrors();	
	if(isSelected(checkboxId)){
		if(confirm("是否屏蔽？")==true)
			doSubmit(form,url,target);
	}else{
		writeErrors();
	}
}
/*-------------------
说明：批量审核
checkboxId:记录前checkbox的name属性
--------------------*/
function auditingListVal(form,url,target,checkboxId){
	clearErrors();	
	if(isSelected(checkboxId)){
		if(confirm(hint_auditingOnServer)==true)
			doSubmit(form,url,target);
	}else{
		writeErrors();
	}
}

/*-------------------
说明：注销记录
checkboxId:记录前checkbox的name属性
--------------------*/
function logoutListVal(form,url,target,checkboxId){
	clearErrors();	
	if(isSelected(checkboxId)){
		if(confirm(hint_logoutOnServer)==true)
			doSubmit(form,url,target);
	}else{
		writeErrors();
	}
}

/*-------------------
说明：和删除类似
checkboxId:记录前checkbox的name属性
--------------------*/
function someInListVal(form,url,target,checkboxId){
	clearErrors();	
	if(isSelected(checkboxId)){
		if(confirm(hint_isDelete)==true)
			doSubmit(form,url,target);
	}else{
		writeErrors();
	}
}

/*-------------------
说明：是否只选择了一条记录
checkboxId:checkbox的name属性
--------------------*/
function isSelectOnlyOne(checkboxId){
if(notNullOrEmpty(checkboxId)){
		if(getCheckedCount(checkboxId)!=1){
			errorMsgs+=tooMore;
			return false;
		}
		
		return true;
	}
	return false;
}

/*-------------------
说明：是否只选择了记录
checkboxId:checkbox的name属性
--------------------*/
function isSelected(selectId){
	//if(notNullOrEmpty(selectId)){
		if(getCheckedCount(selectId)==0){
			errorMsgs+=noChoose;
			return false;
		}
		return true;
	//}
	//return false;
}

/*-------------------
说明：check了多少条记录
checkboxId:checkbox的name属性
--------------------*/
function getCheckedCount(checkboxId){
	var checkbox=document.getElementsByName(checkboxId);
	var count=0;
	
	if("undefined"==typeof(checkbox)){
		errorMsgs+=unsupport;
		return null;
	}
	
	for(var i=0;i<checkbox.length;i++){
		if(checkbox[i].checked==true)
			count++;
	}
	
	return count;
}

/*-------------------
交换两个select里的值
---------------------*/
function selectChange(src,des){
	//alert(src+"dddd"+des);
	  var srcLength = src.length;
	  var oindex = 0;
	  for(j=0;j<srcLength;j++){
	  	if(src.options[j].selected){
	  		var olength=des.length;
	  		oindex = j;
	  		if(oindex >= 0){
	    		var otext=src.options[oindex].text;
				var ovalue=src.options[oindex].value;
	
				var tag=0;
	
				for(i=0; i<olength; i++){
		  			if(otext==des.options[i].text){
		    			tag=1;
						break;
		  			}
				}
				if(tag==0){
		  			des.options[olength]=new Option(otext,olength);
		  			des.options[olength].value=ovalue;
				}
	  		}
	 	}
	  }
	  
	  for(j=srcLength-1;j>=0;j--){
	    if(src.options[j].selected) src.options[j]=null;
	  }
	  src.selectedIndex=-1;
}
/**********************
*说明：选择多选列表里所有的值
*selectName:多选列表的名字
***********************/
function selectAll(selectName){
	var length=selectName.length;
	for(i=0;i<length;i++){
		selectName.options[i].selected=true;
	}
}
/**
 * 权限树*/
function expandSubmit(nodeId,form,url,target){
        expandField = "<input type=\"hidden\" name=\"expand\" value=\"" + nodeId + "\"/>";
        document.getElementById("hiddenField").innerHTML = expandField;
        doSubmit(form,url,target);
}

function collapseSubmit(nodeId,form,url,target){
        collapseField = "<input type=\"hidden\" name=\"collapse\" value=\"" + nodeId + "\"/>";
        document.getElementById("hiddenField").innerHTML = collapseField;
        doSubmit(form,url,target);
}
    
function selectSubmit(nodeId,form,url,target){
        selectField = "<input type=\"hidden\" name=\"actionNode\" value=\"" + nodeId + "\"/>";
        document.getElementById("hiddenField").innerHTML = selectField;
        doSubmit(form,url,target);
}


/***/   
//是否是正实数
function isUnsignedReal(num){
    return   /^\d*\.?\d*$/.test(num);
}

/*****格式化日期*****/
	Date.prototype.format = function(formatter)
{
    if(!formatter || formatter == "")
    {
        formatter = "yyyy-MM-dd";
    }
    var year = this.getYear().toString();
    var month = (this.getMonth() + 1).toString();
    var day = this.getDate().toString();
    var yearMarker = formatter.replace(/[^y|Y]/g,'');
    if(yearMarker.length == 2)
    {
        year = year.substring(2,4);
    }    
    var monthMarker = formatter.replace(/[^m|M]/g,'');
    if(monthMarker.length > 1)
    {
        if(month.length == 1) 
        {
            month = "0" + month;
        }
    }    
    var dayMarker = formatter.replace(/[^d]/g,'');
    if(dayMarker.length > 1)
    {
        if(day.length == 1) 
        {
            day = "0" + day;
        }
    }    
    return formatter.replace(yearMarker,year).replace(monthMarker,month).replace(dayMarker,day);    
}

Date.parseString = function(dateString,formatter)
{
    var today = new Date();
    if(!dateString || dateString == "")
    {
        return today;
    }
    if(!formatter || formatter == "")
    {
        formatter = "yyyy-MM-dd";
    }  
    var yearMarker = formatter.replace(/[^y|Y]/g,'');   
    var monthMarker = formatter.replace(/[^m|M]/g,'');   
    var dayMarker = formatter.replace(/[^d]/g,'');
    var yearPosition = formatter.indexOf(yearMarker);
    var yearLength = yearMarker.length;
    var year =  dateString.substring(yearPosition ,yearPosition + yearLength) * 1;
    if( yearLength == 2)
    {
        if(year < 50 )
        {
            year += 2000;
        }
        else
        {
            year += 1900;
        }
    }
    var monthPosition = formatter.indexOf(monthMarker);
    var month = dateString.substring(monthPosition,monthPosition + monthMarker.length) * 1 - 1;
    var dayPosition = formatter.indexOf(dayMarker);
    var day = dateString.substring( dayPosition,dayPosition + dayMarker.length )* 1;
    return new Date(year,month,day);
}
/****end 格式化日期 ****/

/**
 * 获得日期的标准形式YYYY-MM-dd
 */
function getDateNow(id,formatter){
	var dateNow=new Date();
	document.getElementById(id).value=dateNow.format(formatter);
}
/**时间戳函数,加在window.showModalDialog的url后*/
function getTimeNow(){
	var time=new Date();
	var yearMark=time.getYear().toString();
	var monthMark=time.getMonth()+1;
	var dayMark=time.getDate().toString();
	var hourMark=time.getHours().toString();
	var minMark=time.getMinutes().toString();
	var secMark=time.getSeconds().toString();
	var timesAll=yearMark+monthMark+dayMark+hourMark+minMark+secMark;
	return "&time="+timesAll;
}
/*打开模态对话框
 * */
function showModal(url){
	var timeNow=getTimeNow();
	var modalResult=window.showModalDialog(url+timeNow,'null','width=560,height=360');
	return modalResult;
}
/**
 * 模态对话框返回时,返回指定面并刷新,无指定则返回父页面,url中要附带所用到的参数
 * @url 模态对话框打开的页面
 * @actionType "add","modify"
 */
function showModalAndRefresh(url,actionType,checkBoxName,reloadHref){
	var postVal="";
	if(actionType!=null){
		if(actionType=="add"){
			clearErrors();
			var idObj=document.getElementsByName(checkBoxName);
			if(idObj!=null){
				for(var index=0; index<idObj.length; index++) {
					idObj[index].checked=false;
				}		
			}
		}if(actionType=="modify"){
			clearErrors();
			if(isSelected(checkBoxName)&&isSelectOnlyOne(checkBoxName)){
				var idObj=document.getElementsByName(checkBoxName);
				for(var i=0;i<idObj.length;i++){
					if(idObj[i].checked==true)
						postVal=idObj[i].value;
				}
			}else{
				writeErrors();
				return;
			}
		}
	}
	var fatherHref=window.location.href;
	var timeNow=getTimeNow();
	var modalResult=window.showModalDialog(url+timeNow+"&"+checkBoxName+"="+postVal,'null','width=560,height=360');
	actionType="";
	if(modalResult=="Y"){
		if(reloadHref!="")
			window.location.href=reloadHref;
		else
			window.location.href=fatherHref;
	}else{
		writeErrors();
		return;
	}
}
   /* iframe 页面自适应大小
     * @targObj    iframe
     * @id iframe's id
     * @extraHight 
     * updated by hwq  del if(aimObj.id.length<1) return;
     */
function f_frameStyleResize(targObj,id,extraHight){
   var aimObj = targObj.parent.document.getElementById(id);
   
   //alert(aimObj.id);
   //if(aimObj.id.length<1) return;
	 if(aimObj != null) {
	 	var HeightValue = targObj.document.body.scrollHeight;
	   	if(extraHight!=null){
	   		aimObj.style.height=HeightValue+extraHight
	   	}else{    		 		
	    		aimObj.style.height = HeightValue;	
//	 			if(HeightValue < 350){HeightValue = 350}　		 		
// 			    aimObj.style.height = HeightValue;
		}
 	}else{
 		 return;
 		
 	}
}	

function checkIsCode(str){
	 //编号的输入只允许字母和数字
    if(str == "")
        return true;
    return /^[a-zA-Z0-9]+$/g.test(str);
}

function checkChineseChar(str){
	if (str == "")
        return true;
    var pattern = /^([a-zA-Z\ ]|[\u4E00-\u9FA5]|[\uFE30-\uFFA0])*?$/gi;
    if (pattern.test(str))
        return true;
    else
        return false;
}

function frameResize(frameName){
	var targWin =parent.document.all[frameName];
    if(targWin != null) {
 		var HeightValue = document.body.scrollHeight;
		targWin.style.pixelHeight = HeightValue;
     }
}

function selfAdaptHeight(targObj,extraHight){

	var HeightValue = targObj.document.body.scrollHeight; 
	if(HeightValue < 500){HeightValue = 500} 　		 		
 	targObj.height = HeightValue;
}
 //在下拉框中添加请选择条目
function addPleaseSel(elementId){
	var sel=document.getElementById(elementId);
	sel.options.add(new Option(pleaseSelect,""));
}

function writeMessage(message){
	var spanObj=document.getElementById(spanId);
	spanObj.className=spanCss;
	spanObj.innerHTML=message;
}

function  returnNothing(){
	
}
//数据列表 添加时 添加按钮的通用调用，除去钩选的复选框的值
function addVal(form,url,target,checkboxName){
	var idObj=document.getElementsByName(checkboxName);
	if(idObj!=null){
		for(var index=0; index<idObj.length; index++) {
			idObj[index].value="";	
		}		
	}
	doSubmit(form,url,target);
}

function closeWindow(refreshVal){
	window.returnValue=document.getElementById(refreshVal).value; 
}

function notNullOrEmpty(id){
	var el=document.getElementsByName(id);
	if("undefined"==typeof(el)||el==null||el[0].value.trim()=="")
		return false;
	else 
		return true;
}

function isNotNull(id){
	var el=document.getElementById(id);
	if("undefined"==typeof(el)||el==null)
		return false;
	else 
		return true;
}

function singCheckedBoxValue(checkboxName){
	var checkbox=document.getElementsByName(checkboxName);
	if("undefined"==typeof(checkbox)){
		errorMsgs+=unsupport;
		return null;
	}
	for(var i=0;i<checkbox.length;i++){
		if(checkbox[i].checked==true)
			return checkbox[i].value;
	}	
}
/*
function updateShelf(form,url,target,checkboxId){
	clearErrors();
	if(isSelected(checkboxId)&&isSelectOnlyOne(checkboxId)){
		doSubmit(form,url,target);
	}else{
		writeErrors();
	}
}
*/
/*
*  得到所选择的复选框的值
*  @checkboxId    所选择的复选框
*  @tabId         table的id属性
*/
function reChecked(checkboxId,tabId){
	if(isNotNull(tabId)){
		var count=document.all(tabId).rows.length;
		var str="";
		if(isSelected(checkboxId)&&isSelectOnlyOne(checkboxId)){
			for(var i=0;i<count-1;i++){
				if(document.getElementsByName(checkboxId)[i].checked){
					str=document.getElementsByName(checkboxId)[i].value;
				}
			}
			return str;
		}
		return "false";
	}
	return "false";
}

/*
*  得到所选择的复选框的值
*  @checkboxId    所选择的复选框
*  @tabId         table的id属性
*/
function reCheckedIsLogout(checkboxId,tabId){
	var x = 0;
	if(isNotNull(tabId)){
		var count=document.all(tabId).rows.length;
		var str="";
		if(isSelected(checkboxId)){
			for(var i=0;i<count-1;i++){
				if(document.getElementsByName(checkboxId)[i].checked){
					str=document.getElementsByName(checkboxId)[i].value;
					str=document.getElementById(str).value;
					if(str=="1"){
						++x;
					}
				}
			}
			if(x > 0){
				return "1";
			}else{
				return "0";
			}
		}
		return "false";
	}
	return "false";
}

/*
*  判断所勾选的输入框是否为空(单条或多条记录)
*  @checkboxId    所选择的复选框
*  @tabId         table的id属性
*  @rankId         select的id属性
*  @rankMonthsId         select的id属性
*/
function reCheckedInputes(checkboxId,tabId,rankId,rankMonthsId,remark){
	var count=document.all(tabId).rows.length;
	var rankCount=0;
	var monthCount=0;
	var remarkCount=0;
	
	if(notNullOrEmpty(checkboxId)){
		for(var i=0;i<count-1;i++){
			if(isSelected(checkboxId)){
				if(document.getElementsByName(checkboxId)[i].checked){
					if(isEmpty(document.getElementsByName(rankId)[i].value)){
						rankCount++;
					}
					if(rankMonthsId != null){
						if(isEmpty(document.getElementsByName(rankMonthsId)[i].value)){
							monthCount++;
						}
					}
					if(!isEmpty(document.getElementsByName(remark)[i].value)&&(isOverLength(document.getElementsByName(remark)[i].value,255))){
						remarkCount++;
					}
				}
			}else{
				return false;
			}
		}
		if(rankCount>0){
			errorMsgs+=rankBlank;
			return false;
		}
		if(monthCount>0){
			errorMsgs+=rankMonthBlank;
			return false;
		}
		if(remarkCount>0){
			errorMsgs+=wareRemark;
			errorMsgs+=wareRemarkLengthBlank;
			return false;
		}
		return true;
	}
	return false;
}

/*
*  判断所勾选的输入框的值是否为非负数(单条或多条记录)
*  @checkboxId    所选择的复选框
*  @tabId         table的id属性
*  @rankId         select的id属性
*/
function reCheckedInputesInt(checkboxId,tabId,rankId){
	var count=document.all(tabId).rows.length;
	var rankCount=0;
	var inputCount=0;
	if(notNullOrEmpty(checkboxId)){
		for(var i=0;i<count-1;i++){
			if(isSelected(checkboxId)){
				if(document.getElementsByName(checkboxId)[i].checked){
					if(isEmpty(document.getElementsByName(rankId)[i].value)){
						inputCount++;
					}
					if(!checkNotNegativeInteger(document.getElementsByName(rankId)[i].value)){
						rankCount++;
					}
				}
			}else{
				return false;
			}
		}
		if(inputCount>0){
			errorMsgs+=serialNumberBlank;
			return false;
		}
		if(rankCount>0){
			errorMsgs+=unInvalidateError;
			return false;
		}
		return true;
	}
	return false;
}

/**
 * 检查上传文件的类型是否被允许
 * @param allowFileTypes 允许的类型 格式为 'txt,exe,word,jpeg'
 * @param fileId  input type 的id
 */
function checkFileType(allowFileTypes,fileId){
	if(fileId)
	{
		var fileName=document.getElementById(fileId).value;
		if(fileName.trim()=="")return true;
		var getFileType=fileName.substr(fileName.lastIndexOf(".")+1).trim(); 
		typeRegExp =new RegExp(getFileType,"i");
		if (typeRegExp.test(allowFileTypes)) {
			return true;
		} else {
			return false;
		}
	}
	else{
		alert("找不到id，請聯繫網站管理員");/*by hwq*/
		return false;
	}
	
}
/**
 *  简单的获得元素的对象
 */
function getEl(id){
	return document.getElementById(id);
}
/**
 * 简单的获得元素的值
 */
function getVal(id){
	return document.getElementById(id).value.trim();
}
/**
 * 验证用户名是否合法,可选方案
 */
function checkUserId(userId){
	var checkWay="NumAndChar";
	switch (checkWay){
	   case "NumAndChar": //只能是数字和字母组成
	  	if(/^[a-zA-Z0-9]*$/g.test(userId))
			return true;
		else 
			return false;
	   default: //默认只能是数字和字母组成
	   		if(/^[a-zA-Z0-9]*$/g.test(userId))
			return true;
		else 
			return false;
	}
}	

function checkPasswordLen(password){
	if(password.length>=4&&password.length<=12)
		return true;
	else
		return false;
}

function checkAdminSetPasswordLen(password){
	if(password.length<=12)
		return true;
	else
		return false;
}

/**
 * 验证用户名的长度
 */
function checkUserIdLen(userId){
	if(userId.length<=15&&userId.length>=4)
		return true;
	else
		return false;
}

function checkNotNegativeInteger(str){
	if(str == "")
        return true;
	if(/^\d*$/.test(str))
		return true;
	else
		return false;
}

function isIdCardNo(num){
	if(num=="")return false;
//    if (isNaN(num)) {return false;}
	var len = num.length, re; 
	if (len == 15)
	  re = new RegExp(/^(\d{6})()?(\d{2})(\d{2})(\d{2})(\d{3})$/);
	else if (len == 18)
	  re = new RegExp(/^(\d{6})()?(\d{4})(\d{2})(\d{2})(\d{3})(\d)$/);
	else {return false;}
	var a = num.match(re);
	if (a != null){
	  if (len==15){
	    var D = new Date("19"+a[3]+"/"+a[4]+"/"+a[5]);
	    var B = D.getYear()==a[3]&&(D.getMonth()+1)==a[4]&&D.getDate()==a[5];
	  }
	  else{
	    var D = new Date(a[3]+"/"+a[4]+"/"+a[5]);
	    var B = D.getFullYear()==a[3]&&(D.getMonth()+1)==a[4]&&D.getDate()==a[5];
	  }
	  if (!B){return false;}
	}
	return true;
}
/**
 * 限制textarea的行数
 */
function checkTextAreaRows(obj,len){   
  var   o=obj.createTextRange().getClientRects();   
  if(o.length==len&&event.keyCode==13)   
      event.returnValue=false;   
  if(o.length>len)   
  event.returnValue=false;   
}

function loadPic(picType,fileInputId,imageId){
	if(!checkFileType(picType,fileInputId)){
		clearErrors();
		errorMsgs+="请上传 "+picType+" 格式的图片！";
		writeErrors();
		return false;
	}
	getEl(imageId).src=getEl(fileInputId).value;
}

//商户广告图片上传验证
function loadStoreInfoPic(picType,fileInputId,imageId){
	if(!checkFileType(picType,fileInputId)){
		alert("请上传 "+picType+" 格式的图片！");
		return false;
	}
	getEl(imageId).src=getEl(fileInputId).value;
}

function userOSloadPic(picType,fileInputId,imageId){
	clearErrors();
	if(!checkFileType(picType,fileInputId)){
		errorMsgs+="请上传 "+picType+" 格式的图片！";
		writeErrors();
		return false;
	}
	if(navigator.userAgent.indexOf("MSIE 8.0")<=0){
		getEl(imageId).filters.item("DXImageTransform.Microsoft.AlphaImageLoader").src = getEl(fileInputId).value;
	}
}

function replaceStr(str,num){
	var cha = str;
	var size = str.length;
	if(cha != ""){
		if(num < size){
			cha = cha.substring(0,num) + "&nbsp;<b>...</b>";
		}
	}
	document.write(cha);
}

function replaceTitleStr(str,num){
	var cha = str;
	var size = str.length;
	if(cha != ""){
		if(num < size){
			cha = cha.substring(0,num-2) + "&nbsp;<b>…</b>";
		}
	}
	document.write(cha);
}


function filtrateTag(str){
	var cha = str;
	if(cha != ""){
		while(cha.indexOf("<") != -1 && cha.indexOf(">") != -1){
				if(cha.indexOf("<") == 0){
					cha=cha.substring(cha.indexOf(">")+1);
				}else if(cha.indexOf("<") != 0 && cha.indexOf(">")+1 != cha.length){
					if(cha.indexOf("<") < cha.indexOf(">")){
						cha=cha.substring(0,cha.indexOf("<"))+cha.substring(cha.indexOf(">")+1);
					}else if(cha.indexOf("<") > cha.indexOf(">")){
						cha=cha.substring(cha.indexOf(">")+1);
					}
				}else if(cha.indexOf(">")+1 == cha.length){
					cha=cha.substring(0,cha.indexOf("<"));
				}
		}
	}
	replaceStr(cha,82);
}

function mailFiltrateTag(str){
	var cha = str;
	if(cha != ""){
		while(cha.indexOf("<") != -1 && cha.indexOf(">") != -1){
				if(cha.indexOf("<") == 0){
					cha=cha.substring(cha.indexOf(">")+1);
				}else if(cha.indexOf("<") != 0 && cha.indexOf(">")+1 != cha.length){
					if(cha.indexOf("<") < cha.indexOf(">")){
						cha=cha.substring(0,cha.indexOf("<"))+cha.substring(cha.indexOf(">")+1);
					}else if(cha.indexOf("<") > cha.indexOf(">")){
						cha=cha.substring(cha.indexOf(">")+1);
					}
				}else if(cha.indexOf(">")+1 == cha.length){
					cha=cha.substring(0,cha.indexOf("<"));
				}
		}
	}
	document.write(cha);
}
/**
 * 在两个复选select框中移动option元素
 */
function moveOption(resource,destination){
    try
    {
        var eRes = getEl(resource);
        var eDes = getEl(destination);
        while(eRes.selectedIndex>=0)
        {
        	
            var e = eRes.options[eRes.selectedIndex];
            eDes.options.add(new Option(e.text, e.value));
            eRes.options.remove(eRes.selectedIndex); 
        }
    }   
    catch(e)
    {}
}

function submitMutiSel(mutiSelId){
	try {
		var mutiSel=getEl(mutiSelId);
		for(var index=0; index<mutiSel.length; index++) {
			mutiSel.options[index].selected=true;
		}
	} catch (e) {
		// TODO: handle exception
	}
}

//判断输入字符是否为浮点型
function checkfloat(s){
  return /^\d+(\.\d+)?$/.test(s);
}

function setEscapeURL(url){
	//var endStr=escape(str);
	//var ur=url+"&keys="+endStr;
	//alert(ur);
	//window.location.href=ur;
	//document.getElementById("wareCategoryId").value=vid;
	//document.getElementById("keys").value=str;
	document.getElementById("proList").action=url;
	//alert("wareCategoryId = "+document.getElementById("wareCategoryId").value+" keys = "+document.getElementById("keys").value);
	document.getElementById("proList").submit();
}
//获得当前日期  YYYY-MM-DD
function getNonceDate(){
	var date = new Date();
	var nonceDate = date.getYear()+"-";
	if ((date.getMonth()+1)<10){
		nonceDate = nonceDate+"0"+(date.getMonth()+1);
	}else{
		nonceDate = nonceDate+(date.getMonth()+1);
	}
	if (date.getDate()<10){
		nonceDate = nonceDate+"-0"+date.getDate();
	}else{
		nonceDate = nonceDate+"-"+date.getDate();
	}
  return nonceDate;
}

//弹出窗口显示店铺荣誉说明
function viewGloryLevelInfo(){
	var url = "help/help_glory_level.html";
	window.open(url,"viewGloryLevelInfo","height=360px,width=600px,top=150px,left=100px,toolbar=no,menubar=no,scrollbars=no,resizable=no,location=no,status=no");
}

/**
 * 设置下拉框的选中项目
 * @param chkName 该组checkBox的名字的前缀
 * @return 若至少被选中一个则返回true，否则返回false
 */
function setSelectItem(objName,selValue){
	var i;
	if(document.all[objName]){
		for(i=0;i<document.all[objName].length;i++){
			if(document.all[objName].options[i].value==selValue){
				document.all[objName].options[i].selected=true;
			}
			else{
				document.all[objName].options[i].selected=false;
			}
		}
	}
	else{
		window.alert("setSelectItem():没有找到下拉框："+objName);
		return "";
	}
}

function UrlEncode(str)
{
    var ret="";
    var strSpecial="!\"#$%&()*+,/:;<=>?[]^`{|}~%"; var tt="";
    for(var i=0;i<str.length;i++)
    {
        var chr = str.charAt(i);
        var c=str2asc(chr);
        tt += chr+":"+c+"n";
        if(parseInt("0x"+c) > 0x7f)
        {
            ret+="%"+c.slice(0,2)+"%"+c.slice(-2);
        }
        else
        {
            if(chr==" ")
                ret+="+";
            else if(strSpecial.indexOf(chr)!=-1)
                ret+="%"+c.toString(16);
            else
                ret+=chr;
        }
    }
    return ret;
}

function showtime()
{
var today,hour,second,minute,year,month,date;
var strDate ;
   today=new Date();
 var n_day = today.getDay();
 switch (n_day)
 {
 case 0:{
 strDate = "星期日"
 }break;
 case 1:{
 strDate = "星期一"
 }break;
 case 2:{
 strDate ="星期二"
 }break;
 case 3:{
 strDate =  "星期三"
 }break;
 case 4:{
 strDate =  "星期四"
 }break;
 case 5:{
 strDate =  "星期五"
 }break;
 case 6:{
 strDate =  "星期六"
 }break;
 case 7:{
 strDate =  "星期日"
 }break;
 }
year = today.getYear();
month = today.getMonth()+1;
date = today.getDate();
hour = today.getHours();
minute =today.getMinutes();
second = today.getSeconds();
document.getElementById('time').innerHTML = year + " 年 " + month + " 月 " + date + " 日 " +  strDate +" " + hour + ":" + minute + ":" + second; //显示时间
setTimeout("showtime();", 1000); //设定函数自动执行时间为 1000 ms(1 s)
}