/* FUNCTION---------------------------------------------trim
功能：
	去除字符串两端的空格
参数：
	String	str 字符串
返回：
	String	去除两端空格的字符串
*/
function trim(str)
{
	var left = 0;
	var right = -1;
	for(i=0;i<str.length;i++)
		if(str.charAt(i)!=" ")
		{
			left = i;
			break;
		}
	for(i=str.length-1;i>=0;i--)
		if(str.charAt(i)!=" ")
		{
			right = i+1;
			break;
		}
	return str.substring(left,right);
}

/* FUNCTION---------------------------------------------isNotBlank
功能：
	判断输入值是否不为空
参数：
	Object	obj 标签对象
	boolean	是否先去除字符串两端的空格
返回：
	boolean	输入值是否不为空
*/
function isNotBlank(obj,isSpaceFilter)
{
	if(isSpaceFilter)
		obj.value = trim(obj.value);
	return obj.value!=""
}

/* FUNCTION---------------------------------------------isNotBlankEx
功能：
	判断输入值是否不为空（去除字符串两端的空格）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否不为空
*/
function isNotBlankEx(obj)
{
	return isNotBlank(obj,true);
}

/* FUNCTION---------------------------------------------isNumber
功能：
	判断输入值是否为数值
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为数值
*/
function isNumber(obj)
{
	obj.value = trim(obj.value);
	return !isNaN(obj.value)
}

/* FUNCTION---------------------------------------------isInteger
功能：
	判断输入值是否为整数
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为整数
*/
function isInteger(obj)
{
	if(!isNumber(obj))
		return false;
	if(parseInt(obj.value,10)==parseFloat(obj.value))
		return true;
	else
		return false;
}

/* FUNCTION---------------------------------------------isBetween
功能：
	判断输入值是否在一区间内
参数：
	Object	obj 标签对象
	float	nMin 左边界取值
	boolean	isContainMin 是否左边界为闭区间
	float	nMax 右边界取值
	boolean isContainMax 是否右边界为闭区间
返回：
	boolean	输入值是否在一区间内
*/
function isBetween(obj,nMin,isContainMin,nMax,isContainMax)
{
	if(!isNumber(obj))
		return false;
	var result = parseFloat(obj.value);
	var condition1 = (result>nMin && !isContainMin) || (result>=nMin && isContainMin);
	var condition2 = (result<nMax && !isContainMax) || (result<=nMax && isContainMax);
	if(condition1 && condition2)
		return true;
	else
		return false;
}

/* FUNCTION---------------------------------------------isBetweenEx
功能：
	判断输入值是否在一区间内（左边界为闭区间，右边界为闭区间）
参数：
	Object	obj 标签对象
	float	nMin 左边界取值
	float	nMax 右边界取值
返回：
	boolean	输入值是否在一区间内
*/
function isBetweenEx(obj,nMin,nMax)
{
	return isBetween(obj,nMin,true,nMax,true);
}

/* FUNCTION---------------------------------------------isBelow
功能：
	判断输入值是否小于某一数值
参数：
	Object	obj 标签对象
	float	nMax 右边界取值
	boolean isContainMax 是否右边界为闭区间
返回：
	boolean	输入值是否小于某一数值
*/
function isBelow(obj,nMax,isContainMax)
{
	if(!isNumber(obj))
		return false;
	var result = parseFloat(obj.value);
	if(result<nMax && !isContainMax || result<=nMax && isContainMax)
		return true;
	else
		return false;
}

/* FUNCTION---------------------------------------------isBelowEx
功能：
	判断输入值是否小于某一数值（右边界为闭区间）
参数：
	Object	obj 标签对象
	float	nMax 右边界取值
	boolean isContainMax 是否右边界为闭区间
返回：
	boolean	输入值是否小于某一数值
*/
function isBelowEx(obj,nMax)
{
	return isBelow(obj,nMax,true);
}

/* FUNCTION---------------------------------------------isAbove
功能：
	判断输入值是否大于某一数值
参数：
	Object	obj 标签对象
	float	nMin 左边界取值
	boolean isContainMin 是否左边界为闭区间
返回：
	boolean	输入值是否小于某一数值
*/
function isAbove(obj,nMin,isContainMin)
{
	if(!isNumber(obj))
		return false;
	var result = parseFloat(obj.value);
	if(result>nMin && !isContainMin || result>=nMin && isContainMin)
		return true;
	else
		return false;
}

/* FUNCTION---------------------------------------------isAboveEx
功能：
	判断输入值是否大于某一数值（左边界为闭区间）
参数：
	Object	obj 标签对象
	float	nMin 左边界取值
	boolean isContainMin 是否左边界为闭区间
返回：
	boolean	输入值是否小于某一数值
*/
function isAboveEx(obj,nMin)
{
	return isAbove(obj,nMin,true);
}

/* FUNCTION---------------------------------------------isPositiveNumber
功能：
	判断输入值是否为正数
参数：
	Object	obj 标签对象
	boolean isContainZero 是否允许零为合法
返回：
	boolean	输入值是否为正数
*/
function isPositiveNumber(obj,isContainZero)
{
	return isAbove(obj,0,isContainZero);
}

/* FUNCTION---------------------------------------------isPositiveNumberEx
功能：
	判断输入值是否为正数（允许零为合法）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为正数
*/
function isPositiveNumberEx(obj)
{
	return isPositiveNumber(obj,true);
}

/* FUNCTION---------------------------------------------isValidString
功能：
	判断输入值是否为指定的合法字符串
参数：
	Object	obj 标签对象
	String	species 合法字符集
	boolean isSpaceFilter 是否先去除字符串两端的空格
返回：
	boolean	输入值是否为指定的合法字符串
*/
var VS_LETTER = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
var VS_NUMBER = "0123456789";
var VS_BASIC = VS_LETTER + VS_NUMBER;
var VS_COMMON = "@$()/.- _" + VS_BASIC;
function isValidString(obj,species,isSpaceFilter)
{
	if(isSpaceFilter)
		obj.value = trim(obj.value);
	for(i=0;i<obj.value.length;i++)
		if(species.indexOf(obj.value.charAt(i))<0)
			return false;
	return true;
}

/* FUNCTION---------------------------------------------isValidStringEx
功能：
	判断输入值是否为指定的合法字符串（以VS_COMMON为合法字符集，先去除字符串两端的空格）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为指定的合法字符串
*/
function isValidStringEx(obj)
{
	return isValidString(obj,VS_BASIC,true);
}

/* FUNCTION---------------------------------------------isValidChineseString
功能：
	判断输入值是否为指定的合法的中文字符串
参数：
	Object	obj 标签对象
	String	species 其它合法字符集
	boolean isSpaceFilter 是否先去除字符串两端的空格
返回：
	boolean	输入值是否为指定的合法中文字符串
*/
function isValidChineseString(obj,species,isSpaceFilter)
{
	if(isSpaceFilter)
		obj.value = trim(obj.value);
	for(i=0;i<obj.value.length;i++)
		if(species.indexOf(obj.value.charAt(i))<0 && obj.value.charCodeAt(i)<19968)
			return false;
	return true;
}

/* FUNCTION---------------------------------------------isValidChineseStringEx
功能：
	判断输入值是否为指定的合法的中文字符串（以VS_COMMON为其它合法字符集，先去除字符串两端的空格）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为指定的合法中文字符串
*/
function isValidChineseStringEx(obj)
{
	return isValidChineseString(obj,VS_BASIC,true);
}

/* FUNCTION---------------------------------------------isValidExtendedString
功能：
	判断输入值是否为指定的合法的扩展（含中文）字符串
参数：
	Object	obj 标签对象
	String	species 其它合法字符集
	boolean isSpaceFilter 是否先去除字符串两端的空格
返回：
	boolean	输入值是否为指定的合法扩展（含中文）字符串
*/
function isValidExtendedString(obj,species,isSpaceFilter)
{
	if(isSpaceFilter)
		obj.value = trim(obj.value);
	for(i=0;i<obj.value.length;i++)
		if(species.indexOf(obj.value.charAt(i))<0 && obj.value.charCodeAt(i)<128)
			return false;
	return true;
}

/* FUNCTION---------------------------------------------isValidExtendedStringEx
功能：
	判断输入值是否为指定的合法的扩展（含中文）字符串（以VS_COMMON为其它合法字符集，先去除字符串两端的空格）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为指定的合法扩展（含中文）字符串
*/
function isValidExtendedStringEx(obj)
{
	return isValidExtendedString(obj,VS_COMMON,true);
}

/* FUNCTION---------------------------------------------isStandardDate
功能：
	判断输入值是否为合法的日期类型（格式为yyyy?mm?dd其中年份必须为[1000,9999]）
参数：
	Object	obj 标签对象
	String	conjunction 为年月日的连接符（长度为1）
返回：
	boolean	输入值是否为合法的日期类型
*/
function isStandardDate(obj,conjunction)
{
	obj.value = trim(obj.value);
	if(obj.value=="")
	    return true;
	if(obj.value.charAt(4)!=conjunction || obj.value.charAt(7)!=conjunction)
		return false;
	var year = obj.value.substring(0,4);
	var month = obj.value.substring(5,7);
	var day = obj.value.substring(8,10);
	var condition1 = isNaN(year) || isNaN(month) || isNaN(day);
	var condition2 = parseInt(year,10)!=parseFloat(year) || parseInt(month,10)!=parseFloat(month) || parseInt(day,10)!=parseFloat(day)
	if(condition1 || condition2)
		return false;
	var d = new Date();
	d.setFullYear(parseInt(year,10));
	d.setMonth(parseInt(month,10)-1);
	d.setDate(parseInt(day,10));
	year = d.getFullYear();
	month = d.getMonth()+1;
	day = d.getDate();
	var temp = year+conjunction;
	if(month<10)
		temp+="0";
	temp+=month+conjunction;
	if(day<10)
		temp+="0";
	temp+=day;
	if(obj.value==temp)
		return true;
	else
		return false;
}

/* FUNCTION---------------------------------------------isStandardDateEx
功能：
	判断输入值是否为合法的日期类型（格式为yyyy?mm?dd其中年份必须为[1000,9999]，年月日连接符为“/”）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否为合法的日期类型
*/
function isStandardDateEx(obj)
{
	return isStandardDate(obj,"/");
}

/* FUNCTION---------------------------------------------isLengthBetween
功能：
	判断输入值长度是否在一闭区间内
参数：
	Object	obj 标签对象
	int		nMin 长度左边界
	int		nMax 长度右边界
返回：
	boolean	输入值长度是否在一闭区间内
*/
function isLengthBetween(obj,nMin,nMax)
{
	obj.value = trim(obj.value);
	if(obj.value.length>=nMin && obj.value.length<=nMax)
		return true;
	else
		return false;
}

/* FUNCTION---------------------------------------------isLengthBelow
功能：
	判断输入值长度是否小于某一值
参数：
	Object	obj 标签对象
	int		nMax 长度右边界
返回：
	boolean	输入值长度是否小于某一值
*/
function isLengthBelow(obj,nMax)
{
	return isLengthBetween(obj,0,nMax);
}

/* FUNCTION---------------------------------------------isLengthEqual
功能：
	判断输入值长度是否为某一值
参数：
	Object	obj 标签对象
	int		n 字符串必须长度
返回：
	boolean	输入值长度是否为某一值
*/
function isLengthEqual(obj,n)
{
	return isLengthBetween(obj,n,n);
}

/* FUNCTION---------------------------------------------isNotContain
功能：
	判断输入值是否不含有某些字符
参数：
	Object	obj 标签对象
	String	species 不合法字符集
	boolean isSpaceFilter 是否先去除字符串两端的空格
返回：
	boolean	输入值是否不含有某些字符
*/
var NC_BASIC = "<>";
var NC_COMMON = NC_BASIC+"\"\'";
function isNotContain(obj,species,isSpaceFilter)
{
	if(isSpaceFilter)
		obj.value = trim(obj.value);
	for(i=0;i<species.length;i++)
		if(obj.value.indexOf(species.charAt(i))>=0)
			return false;
	return true;
}

/* FUNCTION---------------------------------------------isNotContain
功能：
	判断输入值是否不含有某些字符（以NC_COMMON为不合法字符集，先去除字符串两端的空格）
参数：
	Object	obj 标签对象
返回：
	boolean	输入值是否不含有某些字符
*/
function isNotcontainEx(obj)
{
	return isNotContain(obj,NC_COMMON,true);
}

/* FUNCTION---------------------------------------------isContain
功能：
	判断输入值是否含有某些字符（不去除字符串两端的空格）
参数：
	Object	obj 标签对象
	String	species 必须含有的字符集
返回：
	boolean	输入值是否含有某些字符
*/
function isContain(obj,species)
{
	for(i=0;i<species.length;i++)
		if(obj.value.indexOf(species.charAt(i))<0)
			return false;
	return true;
}

/* FUNCTION---------------------------------------------hideSelectLayer
功能：
	如果有需要隐藏而未隐藏的层时，将该层隐藏。
	（目前用于按页面任意处关闭日历窗口。）
参数：
	无
返回：
	无
*/
function hideSelectLayer(){
try{
	//Layer_item2.style.visibility='hidden';
	//Layer_base.style.visibility='hidden';
	BaseLayer1.style.visibility='hidden';
	daysOfMonth.style.visibility='hidden';
	daysOfMonth2.style.visibility='hidden';
}catch(e){
 //do nothing;
}
}

/* FUNCTION---------------------------------------------deleteConfirm
功能：
	在删除操作前弹出提示信息，以确认是否确定要执行删除操作。
参数：
	String msg 提示信息
返回：
	boolean 是否删除
*/
function deleteConfirm(msg){
	var agree;
	agree = confirm(msg);
	if(agree == 0){ //选择“取消”，不删除；
		return false;
	}
	return true;
}

/* FUNCTION---------------------------------------------openChildWindow
功能：
	弹出子窗口。
参数：
	String windowLocation  子窗口地址
	String windowName 子窗口名称，如为空时则使用默认窗口名
	String windowStyle 子窗口样式，如为空时则使用默认样式

返回：
	无
*/
function openChildWindow(windowLocation,windowName,windowStyle){
    var childwin
    if(!windowName){
    	windowName = 'smallWindow1';
    }
    if(!windowStyle){
    	windowStyle = 'width=660 height=500 top=50 left=100 scrollbars resizable=yes';
    }
    childwin = open(windowLocation,windowName,windowStyle)
    try{
    	childwin.focus();
    }catch(e){
    }
}


/* FUNCTION---------------------------------------------changeNumber
功能：
	修改数量（用于修改份数。）
参数：
	String inputName  输入框名称
	String step 改变数量

返回：
	无
*/
function changeNumber(inputName,step){
	if(inputName.value!=""){
		if(parseInt(inputName.value)+parseInt(step)>=0){
			inputName.value=parseInt(inputName.value)+parseInt(step);
		}else{
			inputName.value="0";
		}
	}else{
		inputName.value="0";
	}


}


/* FUNCTION---------------------------------------------deleteConfirm
功能：
	在删除操作前弹出提示信息，以确认是否确定要执行删除操作。
参数：
	String msg 提示信息
返回：
	boolean 是否删除
*/
function deleteConfirm(msg){
	var agree;
	agree = confirm(msg);
	if(agree == 0){ //选择“取消”，不删除；
		return false;
	}
	return true;
}

/* FUNCTION---------------------------------------------filterIdentityCard
功能：
	判断输入值是否是正确的身份证号码
参数：
	idStr为输入值
返回：
	boolean	判断输入值是否校验通过
*/
function filterIdentityCard(idStr){
  if(idStr.length!=15 && idStr.length!=18){
    alert("请输入15或18位身份证数字");
    return false;
  }
  else if(idStr.length==18){
    return filter18(idStr);
  }else if(idStr.length==15){
    if(isNaN(idStr)){
    	alert("请输入有效的身份证号码");
    	return false;
    }else{
    	var str18 = id15to18(idStr);
    	return filter18(str18);
    }
  }
}

function filter18(idStr){
 	var str1to17 = idStr.substring(0,17);
 	var str18 = idStr.substr(17,1);
	if(idStr.length!=18){ //校验失败
        	alert("请输入18位身份证号码");
		return false;
	}else if(!isNaN(idStr)){ //校验初步通过
		//valid=true;18位全是数字;
	}else if(str18.toUpperCase() == "X" && !isNaN(str1to17)){ //校验初步通过
          	//valid=true;第18位数字是X，前17位是数字
	}else { //校验失败
          	alert("请输入有效的身份证号码");
		return false;
	}

	if(getVerifyCode(idStr) != str18){ //校验最终失败
		alert("您输入的最后一位是校验码错误");
		return false;
	}else {
		return true; //校验最终通过
	}
}

function id15to18(idStr){
  	var str =  idStr.substr(0,6)+"19"+idStr.substr(6,9);
  	var vCode = getVerifyCode(str);
  	str=str+""+vCode;
 	return str;
}

function getVerifyCode(str){
  	var ai=new Array();
	//用户的身份证号码数组;
	var wi=[7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2];
	//17位数对应的加权因子，自左至右;
	var vi=["1","0","X","9","8","7","6","5","4","3","2"];
	//余数对应的校验码;
	var num =0;
	var sum =0;
	var y =0;
	var idStr = str.toUpperCase();
  	if(idStr.length==18)
      		num=idStr.length-1;
  	else
      		num=idStr.length;
  	if(num!=17){
   		alert("请求号码不正确");
                return;
   	}
	for(var i=0;i<num;i++){
        	ai[i]=idStr.charAt(i);
        	sum+=ai[i]*wi[i];//身份证号码分别乘以加权因子再求和;
     	}
	y=sum%11;
	return vi[y];
}

/* FUNCTION---------------------------------------------filterOrgFrameWorkNo
功能：
	判断组织机构代码是否合法
参数：
	codeStr为输入值（共10位，第10个字符为校验码，如："D2143569-X"）
返回：
	boolean	判断输入值是否校验通过
*/
function filterOrgFrameWorkNo(codeStr){
	var sum = 0;
  	//加权因子数组
	var Wi = new Array(3,7,9,10,5,8,4,2);

	//判断长度是否合法
	if(codeStr.length!=10){
          alert("组织机构代码长度错误");
          return false;
	}

	for(var n=0;n<8;n++){
		var temp = getNum(codeStr.substring(n,n+1));
		//判断是否为9位数字（或大写拉丁字母）
		if(temp == -1){
                  alert("含非法字符");
                  return false;
		}
		sum = sum + temp*Wi[n];
	}

	var result = 11 - sum%11; //取余%
	var C9 = '';

	if(result == 11){
          C9 = '0';
	}else if(result == 10){
          C9 = 'X';
	}else{
          C9 = result;
	}

	if(C9 != codeStr.substring(9,10)){
          alert("校验码错误");
          return false;
	}

	return true;
}

function getNum(str){
  	//若字符串为数字则返回false，若字符串不为数字则返回true
	if(!isNaN(str)){
          return str;
	}else{
          switch(str){
          	case 'A':return 10;
		case 'B':return 11;
		case 'C':return 12;
          	case 'D':return 13;
		case 'E':return 14;
		case 'F':return 15;
          	case 'G':return 16;
		case 'H':return 17;
		case 'I':return 18;
          	case 'J':return 19;
		case 'K':return 20;
		case 'L':return 21;
          	case 'M':return 22;
		case 'N':return 23;
		case 'O':return 24;
		case 'P':return 25;
		case 'Q':return 26;
		case 'R':return 27;
		case 'S':return 28;
		case 'T':return 29;
		case 'U':return 30;
		case 'V':return 31;
		case 'W':return 32;
		case 'X':return 33;
		case 'Y':return 34;
		case 'Z':return 35;
		default :return -1;
          }
	}
}