/*
-------------- 函数检索 --------------
trim函数: trim() lTrim() rTrim()
校验字符串是否为空: checkIsNotEmpty(str)
校验字符串是否为整型: checkIsInteger(str)
校验整型最小值: checkIntegerMinValue(str,val)
校验整型最大值: checkIntegerMaxValue(str,val)
校验整型是否为非负数: isNotNegativeInteger(str)
校验字符串是否为浮点型: checkIsDouble(str)
校验浮点型最小值: checkDoubleMinValue(str,val)
校验浮点型最大值: checkDoubleMaxValue(str,val)
校验浮点型是否为非负数: isNotNegativeDouble(str)
校验字符串是否为日期型: checkIsValidDate(str)
校验两个日期的先后: checkDateEarlier(strStart,strEnd)
校验字符串是否为email型: checkEmail(str)
校验字符串是否为中文: checkIsChinese(str)
计算字符串的长度，一个汉字两个字符: realLength()
校验字符串是否符合自定义正则表达式: checkMask(str,pat)
得到文件的后缀名: getFilePostfix(oFile)
校验手机号码: isMobile(str)
校验固定电话: isTelephone(str)
校验电话号码(固定电话或移动电话): function isPhone(str)
校验邮政编码: isPostalcode(str)
-------------- 函数检索 --------------
*/

/**
* added by LxcJie 2004.6.25
* 去除多余空格函数
* trim:去除两边空格 lTrim:去除左空格 rTrim: 去除右空格
* 用法：
* var str = " hello ";
* str = str.trim();
*/

//去左空格;
function ltrim(s) {
    return s.replace(/^\s*/, "");
}
//去右空格;
function rtrim(s) {
    return s.replace(/\s*$/, "");
}
//去左右空格;
function trim(s) {
    return rtrim(ltrim(s));
}

/********************************** Empty **************************************/
/**
*校验字符串是否为空
*返回值：
*如果不为空，定义校验通过，返回true
*如果为空，校验不通过，返回false 参考提示信息：输入域不能为空！
*/
function checkIsNotEmpty(str)
{
	if(trim(str) == "")
		return false;
	else
		return true;
}//~~~
/*--------------------------------- Empty --------------------------------------*/
/********************************** Integer *************************************/
/**
*校验字符串是否为整型
*返回值：
*如果为空，定义校验通过， 返回true
*如果字串全部为数字，校验通过，返回true
*如果校验不通过， 返回false 参考提示信息：输入域必须为数字！
*/
function checkIsInteger(str)
{
	//如果为空，则通过校验
	if(str == "")
		return true;
	if(/^(\-?)(\d+)$/.test(str))
		return true;
	else
		return false;
}//~~~
/**
*校验整型最小值
*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;
	//如果是整数，则校验整数的有效性
	if(str.indexOf(".") == -1) {
		if(checkIsInteger(str) == true)
			return true;
		else
			return false;
	}
	else {
		if(/^(\-?)(\d+)(.{1})(\d+)$/g.test(str))
			return true;
		else
			return false;
	}
}//~~~
/**
*校验浮点型最小值
*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;
	if(checkIsDouble(str) == true) {
		if(parseFloat(str) < 0)
			return false;
		else
			return true;
	}
	else
		return false;
}//~~~
/*--------------------------------- Double ---------------------------------------*/
/********************************** date ******************************************/
/**
*校验字符串是否为日期型
*返回值：
*如果为空，定义校验通过， 返回true
*如果字串为日期型，校验通过， 返回true
*如果日期不合法， 返回false 参考提示信息：输入域的时间不合法！（yyyy-MM-dd）
*/
function checkIsValidDate(str){
	var reg = /^(\d{1,4})-(\d{1,2})-(\d{1,2})$/; 
	var r = str.match(reg); 
	if(r==null)return false; 
	var d= new Date(r[1], --r[2],r[3]); 
	if(d.getFullYear()!=r[1])return false;
	if(d.getMonth()!=r[2])return false;
	if(d.getDate()!=r[3])return false;
	return true;
}//~~~
/**
*校验两个日期的先后
*返回值：
*如果其中有一个日期为空，校验通过, 返回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;
    var pattern = /^(.+)@(.+)$/;
    if (pattern.test(str))
        return true;
    else
        return false;
}
//~~~
/*--------------------------------- 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;
}
//~~~
/**
* 计算字符串的长度，一个汉字三个字符
*/
String.prototype.realThreeLength = function()
{
	return this.replace(/[^\\x00-\\xff]/g,"***").length;
}

//****************************************************************
//* 名　　称：DataLength
//* 功    能：计算数据的长度
//* 入口参数：fData：需要计算的数据
//* 出口参数：返回fData的长度(Unicode长度为3，非Unicode长度为1,当然可以改变有的Unicode长度为2) ;
//*****************************************************************
function DataLength(fData)
{
    var intLength=0;
    for (var i=0;i<fData.length;i++) {
        if ((fData.charCodeAt(i) < 0) || (fData.charCodeAt(i) > 255))
            intLength=intLength+3
        else
            intLength=intLength+1
    }
    return intLength
}

/*--------------------------------- 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;
}//~~~
/*--------------------------------- file --------------------------------------*/
/********************************** phone ***************************************/
/**
* 校验字符串是否为移动电话
* 返回值：
* 如果为空，定义校验通过， 返回true
* 如果字串为移动电话，校验通过， 返回true
* 如果字串为非移动电话， 返回false 参考提示信息：必须为移动电话号码
*/
function isMobile(str)
{
	//如果值为空，通过校验
	if (str == "")
		return true;
	var pattern = /^1\d{10}$/g;
	if (pattern.test(str))
		return true;
	else
		return false;
}//~~~
/**
* 校验字符串是否为固定电话
* 返回值：
* 如果为空，定义校验通过， 返回true
* 如果字串为固定电话，校验通过， 返回true
* 如果字串为非固定电话， 返回false 参考提示信息：必须为固定电话号码
*/
function isTelephone(str)
{
	//如果值为空，通过校验
	if (str == "")
		return true;
	var pattern = /^(\(0\d{2,3}\)|0\d{2,3}-)?[1-9]\d{6,7}$/g;
	if (pattern.test(str))
		return true;
	else
		return false;
}//~~~
/**
* 校验字符串是否为电话号码
* 返回值：
* 如果为空，定义校验通过， 返回true
* 如果字串为电话号码，校验通过，返回true
* 如果字串为非电话号码， 返回false 参考提示信息：必须为电话号码
*/
function isPhone(str)
{
	//如果值为空，通过校验
	if (str == "")
		return true;
	var pattern = /^(\(0\d{2,3}\)|0\d{2,3}-)?[1-9]\d{6,7}$/g;
	if (isMobile(str) || isTelephone(str))
		return true;
	else
		return false;
}//~~~
/*--------------------------------- phone --------------------------------------*/
/********************************** postalcode ***************************************/
/**
* 校验字符串是否为邮政编码
* 返回值：
* 如果为空，定义校验通过， 返回true
* 如果字串为邮政编码，校验通过， 返回true
* 如果字串为非邮政编码， 返回false 参考提示信息：必须为6位邮政编码
*/
function isPostalcode(str)
{
	//如果值为空，通过校验
	if (str == "")
		return true;
	var pattern = /^\d{6}$/g;
	if (pattern.test(str))
		return true;
	else
		return false;
}//~~~
/*--------------------------------- postalcode --------------------------------------*/

/**
 表单验证类型:
 1.notNull
 2.lengthMax
 3.lengthMin
 4.isInt
 5.isNotNegInt
 6.isDouble
 7.intMin
 8.intMax
 9.doubleMin
 10.doubleMax
 11.email
 12.sameValue
 13.mobile
 14.telephone
 15.phone
 16.postalcode
*/


    function validate_form(obj){
        var objs = obj.elements;
        var count = objs.length;
        var messages ="Can't Submit Because of:\n\n";
        var isShowMsg=false;
        var v_focus_obj=null;
        var msg_index=0;
        var sameValue;
        var k=0;
        var baseTitle;
        for (var i = 0; i < count; i++) {
            var filed_obj=objs[i];
            var filed_obj_name=objs[i].name;
            var span=document.getElementById(filed_obj_name+"_span");
            var isPass=false;
            if(span){
            	var k_types=getCheckTypes(span.type);
            	for(var j=0;j<k_types.length;j++){
            			if(k_types[j]=='sameValue'){
            			   if(k==0){
            			  		sameValue=filed_obj.value;
            			  		baseTitle=filed_obj.title;
            			  		k=1;
            			   }else{
            			     if(sameValue!=filed_obj.value){
            			      	isShowMsg=true;
            			       	isPass=true;
            			       	msg_index++;
            			       	messages=messages+msg_index+". "+filed_obj.title+" must be equal to "+baseTitle+"\n";
            			     }

            			}
            	}
            }
        }
      }
        for (var i = 0; i < count; i++) {
            var filed_obj=objs[i];
            var filed_obj_name=objs[i].name;
            var span=document.getElementById(filed_obj_name+"_span");
            var isPass=false;
            if(span){
                var k_types=getCheckTypes(span.type);
                for(var j=0;j<k_types.length;j++){
                    //输入是否为空
                    if(k_types[j]=='notNull'){
                        if(!(checkIsNotEmpty(filed_obj.value))){
                            msg_index++;
                            messages=messages+msg_index+". "+filed_obj.title+" can't be empty"+"\n";
                            if(v_focus_obj==null){
                                v_focus_obj=filed_obj;
                            }
                            isShowMsg=true;
                            isPass=true;
                            break;
                        }
                    }
                    //输入长度最大值
                    else if(k_types[j].indexOf("lengthMax")!=-1){
                        param_s=k_types[j].split("-");
                        if(param_s.length>1){
                            var in_str=filed_obj.value;
                            if (in_str.length > 0) {
                                if (DataLength(in_str) > parseInt(param_s[1])) {
                                    msg_index++;
                                    messages = messages + msg_index + ". " + filed_obj.title + "'s length can't more than" + param_s[1] + "\n";
                                    if (v_focus_obj == null) {
                                        v_focus_obj = filed_obj;
                                    }
                                    isShowMsg = true;
                                    isPass = true;
                                    break;
                                }
                            }
                        }
                    }
                    //输入长度最小值
                    else if(k_types[j].indexOf("lengthMin")!=-1){
                        param_s=k_types[j].split("-");
                        if(param_s.length>1){
                            var in_str=filed_obj.value;
                            if (in_str.length > 0) {
                                if (DataLength(in_str) < parseInt(param_s[1])) {
                                    msg_index++;
                                    messages = messages + msg_index + ". " + filed_obj.title + "'s length can't less than" + param_s[1] + "\n";
                                    if (v_focus_obj == null) {
                                        v_focus_obj = filed_obj;
                                    }
                                    isShowMsg = true;
                                    isPass = true;
                                    break;
                                }
                            }
                        }
                    }
                    //输入是否为整数
                    else if(k_types[j].indexOf("isInt")!=-1){
                        if(!(checkIsInteger(filed_obj.value))){
                            msg_index++;
                            messages=messages+msg_index+". "+filed_obj.title+" must be number"+"\n";
                            if(v_focus_obj==null){
                                v_focus_obj=filed_obj;
                            }
                            isShowMsg=true;
                            isPass=true;
                            break;
                        }
                    }
                    //输入是否为非负数
                    else if(k_types[j].indexOf("isNotNegInt")!=-1){
                        if(!(isNotNegativeInteger(filed_obj.value))){
                            msg_index++;
                            messages=messages+msg_index+". "+filed_obj.title+" must be negative"+"\n";
                            if(v_focus_obj==null){
                                v_focus_obj=filed_obj;
                            }
                            isShowMsg=true;
                            isPass=true;
                            break;
                        }
                    }
                    //输入是否为Double
                    else if(k_types[j].indexOf("isDouble")!=-1){
                        if(!(checkIsDouble(filed_obj.value))){
                            msg_index++;
                            messages=messages+msg_index+". "+filed_obj.title+" must be floating-point"+"\n";
                            if(v_focus_obj==null){
                                v_focus_obj=filed_obj;
                            }
                            isShowMsg=true;
                            isPass=true;
                            break;
                        }
                    }
                    // 整数值不小于
                    else if(k_types[j].indexOf("intMin")!=-1){
                        param_s=k_types[j].split("-");
                        if(!(checkIntegerMinValue(filed_obj.value,param_s[1]))){
                            msg_index++;
                            messages=messages+msg_index+". "+filed_obj.title+" can't less than"+param_s[1]+"\n";
                            if(v_focus_obj==null){
                                v_focus_obj=filed_obj;
                            }
                            isShowMsg=true;
                            isPass=true;
                            break;
                        }
                    }
                    // 整数值不大于
                    else if(k_types[j].indexOf("intMax")!=-1){
                        param_s=k_types[j].split("-");
                        if(!(checkIntegerMaxValue(filed_obj.value,param_s[1]))){
                            msg_index++;
                            messages=messages+msg_index+". "+filed_obj.title+" can't more than"+param_s[1]+"\n";
                            if(v_focus_obj==null){
                                v_focus_obj=filed_obj;
                            }
                            isShowMsg=true;
                            isPass=true;
                            break;
                        }
                    }
                    // 浮点数值不小于
                    else if(k_types[j].indexOf("doubleMin")!=-1){
                        param_s=k_types[j].split("-");
                        if(!(checkDoubleMinValue(filed_obj.value,param_s[1]))){
                            msg_index++;
                            messages=messages+msg_index+". "+filed_obj.title+" can't less than"+param_s[1]+"!\n";
                            if(v_focus_obj==null){
                                v_focus_obj=filed_obj;
                            }
                            isShowMsg=true;
                            isPass=true;
                            break;
                        }
                    }
                    // 浮点数值不大于
                    else if(k_types[j].indexOf("doubleMax")!=-1){
                        param_s=k_types[j].split("-");
                        if(!(checkDoubleMaxValue(filed_obj.value,param_s[1]))){
                            msg_index++;
                            messages=messages+msg_index+". "+filed_obj.title+" can't more than"+param_s[1]+"!\n";
                            if(v_focus_obj==null){
                                v_focus_obj=filed_obj;
                            }
                            isShowMsg=true;
                            isPass=true;
                            break;
                        }
                    }
                    // 检查时否为email格式
                    else if(k_types[j].indexOf("email")!=-1){
                        if(!(checkEmail(filed_obj.value))){
                            msg_index++;
                            messages=messages+msg_index+". "+filed_obj.title+" must be format of email(ex:adf@yyy.net)\n";
                            if(v_focus_obj==null){
                                v_focus_obj=filed_obj;
                            }
                            isShowMsg=true;
                            isPass=true;
                            break;
                        }
                    }
                     // 检查时否为日期
                    else if(k_types[j].indexOf("date")!=-1){
                        if(filed_obj.value==null||filed_obj.value=="")
                          break;
                    
                        if(!(checkIsValidDate(filed_obj.value))){
                            msg_index++;
                            messages=messages+msg_index+". "+filed_obj.title+" must be format of date(ex:2007-08-23)\n";
                            if(v_focus_obj==null){
                                v_focus_obj=filed_obj;
                            }
                            isShowMsg=true;
                            isPass=true;
                            break;
                        }
                    }
					// 检验是否为移动电话
					else if(k_types[j].indexOf("mobile")!=-1){
                        if(!(isMobile(filed_obj.value))){
                            msg_index++;
                            messages=messages+msg_index+". "+filed_obj.title+" must be mobile"+"\n";
                            if(v_focus_obj==null){
                                v_focus_obj=filed_obj;
                            }
                            isShowMsg=true;
                            isPass=true;
                            break;
                        }
					}
					// 检验是否为固定电话
					else if(k_types[j].indexOf("telephone")!=-1){
						if(!(isTelephone(filed_obj.value))){
                            msg_index++;
                            messages=messages+msg_index+". "+filed_obj.title+" must be telephone"+"\n";
                            if(v_focus_obj==null){
                                v_focus_obj=filed_obj;
                            }
                            isShowMsg=true;
                            isPass=true;
                            break;
                        }
					}
					// 检验是否为电话
					else if(k_types[j].indexOf("phone")!=-1){
						if(!(isPhone(filed_obj.value))){
                            msg_index++;
                            messages=messages+msg_index+". "+filed_obj.title+" must be phone"+"\n";
                            if(v_focus_obj==null){
                                v_focus_obj=filed_obj;
                            }
                            isShowMsg=true;
                            isPass=true;
                            break;
                        }
					}
					// 检验是否为邮政编码
					else if(k_types[j].indexOf("isPostalcode")!=-1){
						if(!(isPhone(filed_obj.value))){
                            msg_index++;
                            messages=messages+msg_index+". "+filed_obj.title+" must be postalcode"+"\n";
                            if(v_focus_obj==null){
                                v_focus_obj=filed_obj;
                            }
                            isShowMsg=true;
                            isPass=true;
                            break;
                        }
					}
                }
                if (isPass) {
                    span.className = "error_color";
                } else {
                    span.className = "default_color";
                }
            }
            
        }
        if(isShowMsg){
            alert(messages);
            if(v_focus_obj){
                v_focus_obj.focus();
            }
            return false;
        }else{
            return true;
        }
    }
    function getCheckTypes(_dataTypestr){
        if(_dataTypestr){
            _dataTypes=_dataTypestr.split(",");
            return _dataTypes;
        }
        return _dataTypestr;
    }