var systemFormulaOperate = (function(){
    //判断值是否属于数字
    function judgeIsNumber(val) {
        if(val === null || typeof val === "undefined")
            return false;
        var reg = /^(-?\d+)(\.\d+)?$/;
        return reg.test(val.toString());
    }

    /**
     * 比较两个数的大小
     * @param arg1
     * @param arg2
     * @returns {*}
     */
    function compare(arg1, arg2) {
        if (arg1.length == 2 && arg2 == undefined) {
            arg2 = arg1[1];
            arg1 = arg1[0];
        }
        if (judgeIsNumber(arg1) && judgeIsNumber(arg2)) {
            var arg1PointIndex = arg1.toString().indexOf(".");
            var arg1IntPar = arg1PointIndex > -1 ? arg1.substring(0, arg1PointIndex) : arg1;
            var arg1PointPar = arg1PointIndex>-1 ? arg1.substring(arg1PointIndex + 1) : "0";

            var arg2PointIndex = arg2.toString().indexOf(".");
            var arg2IntPar = arg2PointIndex > -1 ? arg2.substring(0, arg2PointIndex) : arg2;
            var arg2PointPar = arg2PointIndex>-1 ? arg2.substring(arg2PointIndex + 1) : "0";

            var isIntBigger = (parseInt(arg1IntPar) > parseInt(arg2IntPar));
            if (isIntBigger) {
                return 1;
            } else {
                var isIntEqual = (parseInt(arg1IntPar) == parseInt(arg2IntPar));
                if (isIntEqual) {
                    var isPointBigger = (parseInt(arg1PointPar) > parseInt(arg2PointPar));
                    if (isPointBigger) {
                        return 1;
                    } else {
                        var isPointLittle = (parseInt(arg1PointPar) < parseInt(arg2PointPar));
                        if (isPointLittle) {
                            return -1;
                        } else {
                            return 0;
                        }
                    }
                } else {
                    return -1;
                }
            }
        } else {
            if (arg1 > arg2) {
                return 1;
            } else if (arg1 <arg2 ) {
                return -1;
            } else {
                return 0;
            }
        }
    }
    function rewrite_add(arg1,arg2){
        if (arg1.length == 2 && arg2 == undefined) {
            arg2 = arg1[1];
            arg1 = arg1[0];
        }
        var r1=0,r2=0;
        try{
            r1=arg1.toString().split(".")[1].length;
        }catch(e){}
        try{
            r2=arg2.toString().split(".")[1].length;
        }catch(e){}
        var m=Math.pow(10,Math.max(r1,r2));
        return (arg1*m+arg2*m)/m;
    }
	//求和
	function SUM(param){
		var result = 0;
		if (param) {
			for(var i=0;i<param.length;i++){
				var par = param[i];
				if (par && par.constructor==Array) {
					par.forEach(function(item,index){
						if(!isNaN(convertFloatValue(item))){
							result = rewrite_add(result,item);
						}
					});
				} else if(!isNaN(convertFloatValue(par))){
					result = rewrite_add(result,par);
				}
			}
		}
		return result;
	}

	//求平均数
	function AVERAGE(param){
		var count = 0;
		var sumVal = 0;
		for(var i=0;i<param.length;i++){
			var par = param[i];
            if (par.length == 0) {
                return "";
            }
            if (par && par.constructor==Array) {
                par.forEach(function(item,index){
                    if(!isNaN(convertFloatValue(item))){
                        sumVal = rewrite_add(sumVal,item);
                        count++;
                    }
                });
            } else if(!isNaN(convertFloatValue(par))){
				sumVal = rewrite_add(sumVal,par);
				count++;
			}
		}
		if(count>0){
			return convertFloatValue(sumVal/count);
		}else{
			throw new Error("AVERAGE divisor is zero");
		}
	}
	//求绝对值
	function ABS(param){
		if(param.length==1){
			var par = param[0];
			if(!isNaN(convertFloatValue(par))){
				var result = convertFloatValue(par,undefined, undefined,true);
				return result;
			}else{
				throw new Error("ABS arguments value is not a number");
			}
		}else{
			throw new Error("ABS arguments number must equal one");
		}
	}
	//精度计算
	function ROUND(param){
		if(param.length==2){
			var result = 0;
			var par1 = param[0];
			var par2 = param[1];
			if(!isNaN(convertFloatValue(par1))){
				par1 = convertFloatValue(par1);
			}else{
				throw new Error("ROUND first argument value is not a number");
			}
			if(!isNaN(parseInt(par2))){
				par2 = parseInt(par2);
			}else{
				throw new Error("ROUND second argument value is not a int");
			}
	        result = Math.round(par1 * Math.pow(10, par2)) / Math.pow(10, par2);
	//		result = par1.toFixed(par2);
			return result;
		}else{
			throw new Error("ROUND arguments number must equal two");
		}
	}
	//条件判断
	function IF(param){
		if(param.length==4){
		    var triInfo = param[3];
			var triggerFieldid = triInfo.triggerFieldid;
			var triggerGroupid = triInfo.triggerGroupid;
	        var arg;
			if(eval(param[0])){
				arg = param[1];
			}else{
				arg = param[2];
			}
	        if (arg && arg.constructor==String && 
                (arg.indexOf("(") > -1 || arg.indexOf("=") > -1 || 
                    arg.toLowerCase().indexOf("return") > -1 || (arg.indexOf("'") < 0 && arg.indexOf("\"") < 0))) {
                var rightReg = /\[sys\.(-)?(\d)+](.id)?|\[main\.(\d)+](.id)?|\[detail_(\d)+\.(\d)+](.id)?/ig;
	            var leftReg = /\[sys\.(-)?(\d)+]|\[main\.(\d)+]|\[detail_(\d)+\.(\d)+]/g;
	        
	            var formulaStr = arg;
                triInfo.srcformulatxt = formulaStr;
	            if (formulaStr) {
                    triInfo.formulatxt = formulaStr;
	            }
	            if (triInfo.formulatxt) {
	                var tempFormula = triInfo.formulatxt;
	                var singleFormula = tempFormula.split("#rn#");
	                var formulatxt = new Array();
	                var cellrange = new Array();
	                var destcell = new Array();
	                var destfield = new Array();
	                for (var i = 0; i < singleFormula.length; i++) {
	                    var temp = singleFormula[i];

	                    temp = temp.replace(/===/g, "#sandenghao#");
	                    temp = temp.replace(/==/g, "#shuangdenghao#");
	                    temp = temp.replace(/>=/g, "#dayudengyu#");
	                    temp = temp.replace(/<=/g, "#xiaoyudengyu#");
	                    temp = temp.replace(/!=/g, "#budengyu#");
	                    //等号右侧：公式部分
	                    var rightFormula;

	                    var denghaoIndex = temp.indexOf('=');
	                    var ifIndex = temp.toUpperCase().indexOf('IF');
	                    var dotIndex = temp.toUpperCase().indexOf(',');
	                    if (ifIndex > -1 && denghaoIndex > -1) {
	                        if (ifIndex > denghaoIndex) {//等号在前，if在后，此时公式为A=IF(true, B, C)
	                            rightFormula = temp.substring(temp.indexOf('=') + 1);
	                        } else {// if在前，等号在后的公式模型。此时公式为IF(true, A=B, C=D)
	                            rightFormula = temp;
	                        }
	                    } else if (ifIndex > -1) {//有if，无等号，此时公式为IF(true, alert(1), alert(2))
	                        rightFormula = temp;
	                    } else if (denghaoIndex > -1) {//有等号，无if，此时公式为A=B
	                        rightFormula = temp.substring(temp.indexOf('=') + 1);
	                    } else {//无等号，无if，此时公式为alert(1)
	                        rightFormula = temp;
	                    }

	                    rightFormula = rightFormula.replace(/#sandenghao#/g, "===");
	                    rightFormula = rightFormula.replace(/#shuangdenghao#/g, "==");
	                    rightFormula = rightFormula.replace(/#dayudengyu#/g, ">=");
	                    rightFormula = rightFormula.replace(/#xiaoyudengyu#/g, "<=");
	                    rightFormula = rightFormula.replace(/#budengyu#/g, "!=");

	                    formulatxt.push(rightFormula);
	                    var rightValue = rightFormula.match(rightReg);
	                    if (rightValue && rightValue.length > 0) {
	                        for(j = 0; j < rightValue.length; j++) {
	                            rightValue[j] = rightValue[j].replace(/\[/g, "");
	                            rightValue[j] = rightValue[j].replace(/]/g, "");
                                rightValue[j] = rightValue[j].replace(/\.id/ig, ".id");
	                        }
	                    }
	                    cellrange.push(rightValue);
	                    //等号左侧：赋值单元格
	                    if (denghaoIndex > dotIndex && dotIndex > -1) {//此时公式为IF(true, A=B, C=D)
	                        denghaoIndex = -1;
	                    }
	                    var leftFormula;
	                    if (denghaoIndex > 0) {
	                        leftFormula = temp.substring(0, temp.indexOf('='));
	                    } else {
	                        leftFormula = "";
	                    }

	                    leftFormula = leftFormula.replace(/#sandenghao#/g, "===");
	                    leftFormula = leftFormula.replace(/#shuangdenghao#/g, "==");
	                    leftFormula = leftFormula.replace(/#dayudengyu#/g, ">=");
	                    leftFormula = leftFormula.replace(/#xiaoyudengyu#/g, "<=");
	                    leftFormula = leftFormula.replace(/#budengyu#/g, "!=");

	                    var leftValue = leftFormula.match(leftReg);
	                    if (leftValue && leftValue.length > 0) {
	                        for(j = 0; j < leftValue.length; j++) {
	                            leftValue[j] = leftValue[j].replace(/\[/g, "");
	                            leftValue[j] = leftValue[j].replace(/]/g, "");
	                        }
	                    }
	                    if (leftValue && leftValue.length > 0) {
	                        destcell.push(leftValue[0]);
	                        destfield.push(leftValue[0]);
	                    }
	                }
                    triInfo.formulatxt = formulatxt;
                    triInfo.cellrange = cellrange;
                    triInfo.destcell = destcell;
                    triInfo.destfield = destfield;
	            } else {
                    triInfo.cellrange = '';
	            }
	            var ret = formulaTrigger(triInfo);
                if (ret || ret == 0) {
                    return ret;
                }
	        } else if (arg && arg.constructor==String && (arg.indexOf("'") > -1 || arg.indexOf("\"") > -1)) {
                return arg.substring(1, arg.length - 1);
            } else {
                return arg;
            }
		}else{
			throw new Error("IF arguments number must equal four");
		}
	}
	//求最大值
	function MAX(param){
		var result;
		for(var i=0;i<param.length;i++){
			var par = param[i];
			if (par.constructor == Array) {
			    if (par.length == 0) {
			        return "";
                }
                for (var j = 0; j < par.length; j++) {
                    var parValue = par[j];
                    if(!isNaN(parseFloat(parValue))){
                        if(result==null){
                            result = parseFloat(parValue);
                        }else{
                            if(parseFloat(parValue) > result)
                                result = parseFloat(parValue);
                        }
                    } else if (par[j] === "") {
                        if (result == null) {
                            result = "";
                        }
                    }
                }
            } else {
                if(!isNaN(parseFloat(par))){
    				if(result==null){
    					result = parseFloat(par);
    				}else{
    					if(parseFloat(par) > result)
    						result = parseFloat(par);
    				}
                } else if (par === "") {
                    if (result == null) {
                        result = "";
                    }
                }
			}
		}
		if(result!=null){
			return result;
		}else{
			throw new Error("MAX arguments value must contain a number");
		}
	}
	//求最小值
	function MIN(param){
		var result;
		for(var i=0;i<param.length;i++){
			var par = param[i];
            if (par.constructor == Array) {
                if (par.length == 0) {
                    return "";
                }
                for (var j = 0; j < par.length; j++) {
                    var parValue = par[j];
                    if(!isNaN(parseFloat(parValue))){
                        if(result==null || result === ""){
                            result = parseFloat(parValue);
                        }else{
                            if(parseFloat(parValue) <  result)
                                result = parseFloat(parValue);
                        }
                    } else if (par[j] === "") {
                        if (result == null) {
                            result = "";
                        }
                    }
                }
            } else {
                if (!isNaN(parseFloat(par))) {
    				if(result==null  || result === ""){
    					result = parseFloat(par);
    				}else{
    					if(parseFloat(par) <  result)
    						result = parseFloat(par);
    				}
			     } else if (par === "") {
                    if (result == null) {
                        result = "";
                    }
                }
            }
		}
		if(result!=null){
			return result;
		}else{
			throw new Error("MIN arguments value must contain a number");
		}
	}
	//日期比较
	function CompareDate(param){
		if(param.length>=3){
			var result = 0;
			var par1 = param[0];
			var par2 = param[1];
			var par3 = param[2];

			par1=par1.replace(new RegExp(/-/gm) ,"/");
	        par1=par1.replace(new RegExp(/"/gm) ,"");
			par2=par2.replace(new RegExp(/-/gm) ,"/");
	        par2=par2.replace(new RegExp(/"/gm) ,"");
            
			var start;
	        var currDate1 = getCurrentDateTime();
			if (par1) {
                if (IsTime(par1)) {
                    var times = par1.split(":");
                    if (times[0]) {
                        currDate1.setHours(times[0]);
                    }
                    if (times[1]) {
                        currDate1.setMinutes(times[1]);
                    }
                    if (times[2]) {
                        currDate1.setSeconds(times[2]);
                    }
                    start = currDate1;
                } else {
				    start = new Date(Date.parse(par1));
                }
			} else {
				start = currDate1;
			}
            
			var end;
            var currDate2 = new Date();
			if (par2) {
                if (IsTime(par2)) {
                    var times = par2.split(":");
                    if (times[0]) {
                        currDate2.setHours(times[0]);
                    }
                    if (times[1]) {
                        currDate2.setMinutes(times[1]);
                    }
                    if (times[2]) {
                        currDate2.setSeconds(times[2]);
                    }
                    end = currDate2;
                } else {
				    end = new Date(Date.parse(par2));
                }
			} else {
				end = currDate1;
			}
			
			var diffDate = end - start;
			if (par3 === "Y" || par3 === "y") {
				result = end.getFullYear() - start.getFullYear();
			} else if (par3 === "M") {
                var startMonth = start.getMonth();
                var endMonth = end.getMonth();
				result = (end.getFullYear()*12+endMonth) - (start.getFullYear()*12+startMonth);
			} else if (par3 === "D" || par3 === "d") {
				result = diffDate / (1000 * 60 * 60 * 24);
			} else if (par3 === "H" || par3 === "h") {
				result = diffDate / (1000 * 60 * 60);
			} else if (par3 === "m") {	
				result = diffDate / (1000 * 60);
			} else if (par3 === "S" || par3 === "s") {
				result = diffDate / (1000);
			} else {
                result = diffDate;
            }
			return Math.floor(result);
		} else {
			return "";
		}
	}
    
    //不包含休息日的日期比较
    //param1:开始日期；param2:结束日期；param3:人员id
    function CompareWorkDate(param){
        if(param.length>=3){
            var result = 0;
            var par1 = param[0];
            var par2 = param[1];
            var par3 = param[2];
            
            var newParam = new Array();
            newParam.push(par1);
            newParam.push(par2);
            newParam.push("D");

            par1=par1.replace(new RegExp(/-/gm) ,"/");
            par1=par1.replace(new RegExp(/"/gm) ,"");
            par2=par2.replace(new RegExp(/-/gm) ,"/");
            par2=par2.replace(new RegExp(/"/gm) ,"");

            if (!par1 && !par2) {
                return "";
            }
            var start;
            var currDate1 = getCurrentDateTime();
            if (par1) {
                if (IsTime(par1)) {
                    var times = par1.split(":");
                    if (times[0]) {
                        currDate1.setHours(times[0]);
                    }
                    if (times[1]) {
                        currDate1.setMinutes(times[1]);
                    }
                    if (times[2]) {
                        currDate1.setSeconds(times[2]);
                    }
                    start = currDate1;
                } else {
                    start = new Date(Date.parse(par1));
                }
            } else {
                start = currDate1;
            }
            
            var end;
            var currDate2 = getCurrentDateTime();
            if (par2) {
                if (IsTime(par2)) {
                    var times = par2.split(":");
                    if (times[0]) {
                        currDate2.setHours(times[0]);
                    }
                    if (times[1]) {
                        currDate2.setMinutes(times[1]);
                    }
                    if (times[2]) {
                        currDate2.setSeconds(times[2]);
                    }
                    end = currDate2;
                } else {
                    end = new Date(Date.parse(par2));
                }
            } else {
                end = currDate1;
            }
            
            var workdayReturn;
            if (par3) {
                //workdayReturn = dbFormulaOperate.DoCustomSQL("select count(userid) CNT from workflow_workday_formula where userid="+ par3 + " and currdate>='" + start.toString() + "' and currdate <='" + end.toString() + "' and isworkday = 1" );
                var param = {};
                param.beginDate = start.toString();
                param.endDate = end.toString();
                param.userid = par3;
                jQuery.ajax({
                    type: "POST",
                    url: "/workflow/exceldesign/excelUploadFormula_CompareWorkDate_ajax.jsp",
                    data: param,
                    async: false,
                    success: function (msg) {
                        workdayReturn = msg;
                    }
                });
            } else {
                return "";
            }
            
            if (typeof workdayReturn != "undefined") {
                return workdayReturn;
            } else {
                return "";
            }
        } else {
            return "";
        }
        
    }

    Date.prototype.toString=function() {
        var year = this.getFullYear();
        var month = (this.getMonth()+1);
        var date = this.getDate();
        if (month < 10) {
            month = "0" + month;
        }
        if (date < 10) {
            date = "0" + date;
        }
        return year + "-" + month + "-" + date;
    }
    
    //是否是短时间格式 10:48:51
    function IsTime(str)
    {
        var d = /^(\d{1,2})(:)(\d{1,2})?(:)?(\d{1,2})?$/.test(str);
        if (d == null) {
            return false;
        }
        var a = str.match(/^(\d{1,2})(:)(\d{1,2})?(:)?(\d{1,2})?$/);
        if (!d || a[1]>24 || a[3]>60 || a[4]>60)
        {
            return false
        }
        return true;
    }
	//字符串长度
	function Length(param) {
		if (param && param.length == 1) {
			if (IsString(param)) {
				return param[0].length;
			} else {
				throw new Error("length arguments must be string");
			}
		} else {
			throw new Error("length arguments number must equal one");
		}
	}

	//判断对象是否是字符串
    function IsString(param) {
        if (param) {
            if (Object.prototype.toString.call(param) === "[object Arguments]" && param.length == 1) {
                if (param.length == 1) {
                    return Object.prototype.toString.call(param[0]) === "[object String]";
                } else {
                    throw new Error("IsString arguments number must equal one");
                }
            } else if (Object.prototype.toString.call(param) === "[object String]") {
                return true;
            }
        } else {
            throw new Error("IsString arguments is null");
        }
    }

	//大写转小写
	function Lower(param) {
		if (param && param.length == 1) {
			if (IsString(param)) {
				return param[0].toLowerCase();
			} else {
				throw new Error("Lower arguments must be string");
			}
		} else {
			throw new Error("Lower arguments number must equal one");
		}
	}

	//小写转大写
	function Upper(param) {
		if (param && param.length == 1) {
			if (IsString(param)) {
				return param[0].toUpperCase();
			} else {
				throw new Error("Upper arguments must be string");
			}
		} else {
			throw new Error("Upper arguments number must equal one");
		}
	}

	//将对象转换为字符串
	function ToString(param) {
		if (param && param.length == 1) {
			if (param[0]) {
				return param[0].toString();
			} else {
				return "";
			}
		} else {
			throw new Error("ToString String arguments number must equal one");
		}
	}

	//清除字符串两边的空白
	function Trim(param) {
		if (param && param.length == 1) {
			if (IsString(param)) {
				return param[0].replace(/(^\s*)|(\s*$)/g, "");
			} else {
				throw new Error("Trim arguments must be string");
			}
		} else {
			throw new Error("Trim arguments number must equal one");
		}
	}

	//清除字符串左边的空白
	function LTrim(param) {
		if (param && param.length == 1) {
			if (IsString(param)) {
				return param[0].replace(/(^\s*)/g,"");
			} else {
				throw new Error("LTrim arguments must be string");
			}
		} else {
			throw new Error("LTrim arguments number must equal one");
		}
	}

	//清除字符串右边的空白
	function RTrim(param) {
		if (param && param.length == 1) {
			if (IsString(param)) {
				return param[0].replace(/(\s*$)/g,"");
			} else {
				throw new Error("RTrim arguments must be string");
			}
		} else {
			throw new Error("RTrim arguments number must equal one");
		}
	}

	//判断对象是否是数字
	function IsNumber(param){
		if (param && param.length == 1) {
			// isNaN()函数 把空串 空格 以及NUll 按照0来处理 所以先去除
            if(param[0] === "" || param[0] ==null || typeof param[0] === "undefined"){
                return false;
            }
            var reg = /^(-?0\d+)(\.\d+)?$/;
            if(reg.test(param[0]))	//0开头不识别为数字
                return false;

		    if(!isNaN(param[0])){
		        return true;
		    }else{
		        return false;
		    }
		} else if (typeof param === "number") {
		    return true;
        } else if (typeof param === "text") {
            // isNaN()函数 把空串 空格 以及NUll 按照0来处理 所以先去除
            if(param === "" || param ==null || typeof param === "undefined"){
                return false;
            }
            var reg = /^(-?0\d+)(\.\d+)?$/;
            if(reg.test(param))	//0开头不识别为数字
                return false;

            if(!isNaN(param)){
                return true;
            }else{
                return false;
            }
        } else {
			return false;
		}
	}

	//判断对象是不是整数
	function IsInt(param) {
		if (param && param.length == 1) {
			try {
				var i = IsNumber(param);
				if (i) {
                    param = param[0].toString();
                    var pindex = param.indexOf(".");
                    if (pindex < 0) {
                        return true;
                    } else {
                        var pointPart = param.substr(pindex + 1);
                        ///小数部分大于0，不是整数
                        if (pointPart > 0) {
                            return false;
                        } else {
                            return true;
                        }
                    }
				} else {
					return false;
				}
			} catch (err) {
				return false;
			}
		} else {
			throw new Error("isInt arguments number must equal one");
		}
	}

    //判断对象是不是浮点数
    function IsFloat(param) {
        if (param && param.length == 1) {
            if (IsNumber(param)) {
                param = param[0].toString();
                var pindex = param.indexOf(".");
                if (pindex < 0) {
                    return false;
                } else {
                    var pointPart = param.substr(pindex + 1);
                    ///小数部分大于0，不是整数
                    if (pointPart > 0) {
                        return true;
                    } else {
                        return false;
                    }
                }
            } else {
                return false;
            }
        } else {
            throw new Error("IsFloat arguments number must equal one");
        }
    }

	//返回给定数值的整数
	function ToInt(param) {
		if (IsNumber(param)) {
			var i = parseInt(param[0]);
			if (isNaN(i)) {
				throw new Error("toInt arguments must be number");
			} else {
				return i;
			}
		}
	}

	//返回数值的浮点数
	function ToFloat(param) {
		if (param && param.length == 2) {
			if (IsNumber(param[0]) && IsInt(param[1])) {
				return parseFloat(param[0]).toFixed(param[1]);
			} else {
				throw new Error("ToFloat arguments must be two number");
			}
		} else if (param && param.length == 1) {
            if (IsNumber(param)) {
                return parseFloat(param[0]);
            } else {
                throw new Error("ToFloat arguments must be number");
            }
		} else {
            throw new Error("ToFloat arguments number must be two");
        }
	}

	//字符转数字
	function ToNumber(param) {
		if (param) {
			if (param.length == 1) {
			    if (IsNumber(param)) {
			        return param[0];
                }
			    if (param[0].toString().indexOf(".") > -1) {
                    try {
                        return ToFloat(param);
                    } catch (err) {
                        throw new Error("ToNumber arguments must be two number");
                    }
                } else {
                    try {
                        return ToInt(param);
                    } catch (err) {
                        throw new Error("ToNumber arguments must be number");
                    }
                }
			} else if (param.length == 2) {
				try {
					return ToFloat(param[0], param[1]);
				} catch (err) {
					throw new Error("ToNumber arguments must be two number");
				}
			}
		} else {
			throw new Error("ToNumber arguments number must be one or two");
		}
	}

	//返回当前日期
	function CurrDate(type) {
	    var currdate = getCurrentDateTime();
	    var result;
	    if (type === "Y" || type === "y") {
	        result = currdate.getFullYear();
	    } else if (type === "M") {
	        result = currdate.getMonth() + 1;
	    } else if (type === "D" || type === "d") {
	        result = currdate.getDate();
	    } else if (type === "W" || type === "w") {
	        var result = currdate.getDay();
	        if (result == 0) {
	            result = 7;
	        }
	    } else if (type === "H" || type === "h") {
	        result = currdate.getHours();
	    } else if (type === "m") {  
	        result = currdate.getMinutes();
	    } else if (type === "S" || type === "s") {
	        result = currdate.getSeconds();
	    } else {
	        result = currdate;
	    }
	    return result;
	}
	//返回当前年
	function CurrYear() {
	    return getCurrentDateTime().getFullYear();
	}
	//返回当前月
	function CurrMonth() {
	    return getCurrentDateTime().getMonth() + 1;
	}
	//返回当前日
	function CurrDay() {
	    return getCurrentDateTime().getDate();
	}
	//返回当前周
	function CurrWeek() {
	    var currweek = getCurrentDateTime().getDay();
	    if (currweek == 0) {
	        return 7;
	    } else {
	        return currweek;
	    }
	}
	//返回当前小时数
	function CurrHour() {
	    return getCurrentDateTime().getHours();
	}
	//返回当前分钟数
	function CurrMinute() {
	    return getCurrentDateTime().getMinutes();
	}
	//返回当前秒数
	function CurrSecond() {
	    return getCurrentDateTime().getSeconds();
	}
	//返回指定日期数据
	function GetDateValue(date, type) {
	    var paraDate;
	    if (date) {
            var tempDate;
	        if (date.length == 2) {
                var temp = date[0];
                temp=temp.replace(new RegExp(/-/gm) ,"/");
                temp=temp.replace(new RegExp(/"/gm) ,"");
                tempDate = Date.parse(temp);
                type = date[1];
            } else {
                var temp = date;
                temp=temp.replace(new RegExp(/-/gm) ,"/");
                temp=temp.replace(new RegExp(/"/gm) ,"");
                tempDate = Date.parse(temp);
            }
	        if (tempDate) {
	           paraDate = new Date(tempDate);
	        }
	    }
	    if (paraDate) {
	        var result;
	        if (type === "Y" || type === "y") {
	            result = paraDate.getFullYear();
	        } else if (type === "M") {
	            result = paraDate.getMonth() + 1;
	        } else if (type === "D" || type === "d") {
	            result = paraDate.getDate();
	        } else if (type === "W" || type === "w") {
	            var result = paraDate.getDay();
	            if (result == 0) {
	                result = 7;
	            }
	        } else if (type === "H" || type === "h") {
	            result = paraDate.getHours();
	        } else if (type === "m") {  
	            result = paraDate.getMinutes();
	        } else if (type === "S" || type === "s") {
	            result = paraDate.getSeconds();
	        } else {
	            result = paraDate;
	        }
	        return result;
	    } else {
	        return "";
	    }
	}

	//fmt:YYYY-MM-DD HH:mm:SS
    Date.prototype.format4FormulaNew = function(fmt)
    {
        var o = {
            "M+" : this.getMonth()+1,                 //月份
            "D+" : this.getDate(),                    //日
            "d+" : this.getDate(),                    //日
            "H+" : this.getHours(),                   //小时
            "h+" : this.getHours(),                   //小时
            "m+" : this.getMinutes(),                 //分
            "S+" : this.getSeconds(),                 //秒
            "s+" : this.getSeconds(),                 //秒
        };
        if(/(Y+)/.test(fmt))
            fmt=fmt.replace(RegExp.$1, (this.getFullYear()+"").substr(4 - RegExp.$1.length));
        if(/(y+)/.test(fmt))
            fmt=fmt.replace(RegExp.$1, (this.getFullYear()+"").substr(4 - RegExp.$1.length));
        for(var k in o)
            if(new RegExp("("+ k +")").test(fmt))
                fmt = fmt.replace(RegExp.$1, (RegExp.$1.length==1) ? (o[k]) : (("00"+ o[k]).substr((""+ o[k]).length)));
        return fmt;
    }

    //按指定格式返回当前日期时间   yyyy-MM-dd HH:mm:ss
    function CurrDateTime(param) {
        if (param && param.length == 1) {
            return getCurrentDateTime().format4FormulaNew(param[0]);
        } else {
            throw new Error("CurrDateTime arguments number must equal one");
        }
    }

    //返回当前数据库服务器的时间
    function getCurrentDateTime() {
        var ajaxParam = {};
        ajaxParam.type = "CurrDateTime";
        var currTime = "";
        jQuery.ajax({
            type: "POST",
            url: "/workflow/exceldesign/excelUploadFormula_exe_ajax.jsp",
            data: ajaxParam,
            async: false,
            success: function (msg) {
                currTime = new Date(parseInt(msg));
            }
        });
        return currTime;
    }

    //获取JSON字符串的值，
    // 两个参数，参数一为JSON字符串，参数二为key值，函数返回key对应的value，
    // 如果json为数组，则返回多个value，以逗号分隔
    function GetJSONValue(param) {
        if (param && param.length == 2) {
            if (IsJSON(param[0])) {
                var value = "";
                var obj = JSON.parse(param[0]);
                if (obj != undefined) {
                    var key = param[1];
                    if (Array.isArray(obj)) {//jsonarray
                        for (var i = 0; i < obj.length; i++) {
                            if (value.length > 0) {
                                value = value + ",";
                            }
                            value = value + eval("obj[i]." + key);
                        }
                    } else {//jsonobject
                        if (key != undefined) {
                            value = eval("obj." + key);
                        }
                    }
                }
                return value;
            } else {
                return "";
            }
        } else {
            throw new Error("GetJSONValue arguments number must equal two");
        }
    }

    //判断参数是否为json字符串，
    function IsJSON(param) {
        if (param != undefined) {
            if (Object.prototype.toString.call(param) === "[object Arguments]" && param.length == 1) {
                try {
                    JSON.parse(param[0]);
                } catch (e) {
                    return false;
                }
                return true;
            } else {
                try {
                    JSON.parse(param);
                } catch (e) {
                    return false;
                }
                return true;
            }
        } else {
            throw new Error("IsJSON arguments number must equal one");
        }
    }

    //对参数值进行计数，统计所有非空和非零的参数个数
    function COUNT(param) {
        if (param != undefined) {
            var count = 0;
            for (var i = 0; i < param.length; i++) {
                var par = param[i];
                if (par && par.constructor == Array) {
                    par.forEach(function (item, index) {
                        if (item) {
                            count++;
                        }
                    });
                } else if (par) {
                    count++;
                }
            }
            return count;
        } else {
            throw new Error("COUNT arguments can not be null");
        }
    }

    // 按指定条件对参数值进行计数,，统计所有符合条件的参数个数
    // 第一个参数为条件内容，其中[]为要统计参数的通配符
    function COUNTIF(param) {
        if (param != undefined && param.length >= 3) {
            var count = 0;
            var condition = param[0];
            var vars = param[param.length - 1];
            for (var i = 1; i < param.length - 1; i++) {
                var par = param[i];
                if (par && par.constructor == Array) {
                    par.forEach(function (item, index) {
                        if (item !== undefined && item !== '') {
                            temp = condition.replace(/\[]/g, item);
                            if (eval(temp)) {
                                count++;
                            }
                        }
                    });
                } else {
                    if (par !== undefined && par !== '') {
                        var temp = condition.replace(/\[]/g, par);
                        if (eval(temp)) {
                            count++;
                        }
                    }
                }
            }
            return count;
        } else {
            throw new Error("COUNTIF arguments number must bigger than one");
        }
    }

    // 按指定条件对参数值进行求和,，统计所有符合条件的数值和
    // 第一个参数为条件内容，其中[]为要统计参数的通配符
    function SUMIF(param) {
        if (param != undefined && param.length >= 3) {
            var result = 0;
            var condition = param[0];
            var vars = param[param.length - 1];
            for (var i = 1; i < param.length - 1; i++) {
                var par = param[i];
                if (par && par.constructor == Array) {
                    par.forEach(function (item, index) {
                        var temp = condition.replace(/\[]/g, item);
                        if (eval(temp)) {
                            if(!isNaN(convertFloatValue(item))){
                                result = rewrite_add(result,item);
                            }
                        }
                    });
                } else {
                    var temp = condition.replace(/\[]/g, par);
                    if (eval(temp)) {
                        if(!isNaN(convertFloatValue(par))){
                            result = rewrite_add(result,par);
                        }
                    }
                }
            }
            return result;
        } else {
            throw new Error("SUMIF arguments number must bigger than one");
        }
    }

    /**
     * @param {String} realval   真实值
     */
    function getFormulaFloatValue(realval) {
        if (realval === "" || typeof realval == "undefined") {
            return 0;
        }
        if(!systemFormulaOperate.IsNumber(realval))     //非数值直接返回原始值
            return realval;
        return parseFloat(realval);
    }

    // 随机函数，可以从参数中随机返回一个值
    function RAND(param) {
        if (param != undefined && param.length > 0) {
            var temp = [];
            for (var i = 0; i < param.length; i++) {
                var par = param[i];
                if (par && par.constructor == Array) {
                    par.forEach(function (item, index) {
                        if (item !== "") {
                            temp.push(item);
                        }
                    });
                } else {
                    if (par !== "") {
                        temp.push(par);
                    }
                }
            }
            if (temp && temp.length > 0) {
                var n = Math.floor(Math.random() * temp.length + 1) - 1;
                return temp[n];
            }
        } else {
            throw new Error("RAND arguments can not be null");
        }
    }

    // 取余函数，计算两数相除后的余数
    function MOD(param) {
        if (param != undefined && param.length == 2) {
            if(!isNaN(convertFloatValue(param[0])) && !isNaN(convertFloatValue(param[1]))){
                return param[0]%param[1];
            }
        } else {
            throw new Error("MOD arguments number must equal two");
        }
    }

    // 截取字符串函数，将指定字符串按指定位数进行截取
    // 参数1：需要截取的字符串,
    // 参数2：截取字符串的开始位置,
    // 参数3：要截取的字符串的长度
    function SUBSTR(param) {
        if (param != undefined && param.length >= 2) {
            var value = param[0] + "";
            if (param.length == 2) {
                return value.substring(param[1]);
            } else {
                var tempParam = [];
                tempParam.push(param[2]);
                if (param[2] == '' || param[2] == 0 || !IsNumber(tempParam)) {
                    return value.substring(param[1]);
                } else {
                    return value.substring(param[1], param[1] + param[2]);
                }
            }
        } else {
            throw new Error("SUBSTR arguments number must bigger than two");
        }
    }

    // 取多个日期的最大值
    function MAXDATE(param) {
        if (param != undefined && param.length > 0) {
            var tempDate;
            for (var i = 0; i < param.length; i++) {
                var par = param[i];
                if (par && par.constructor == Array) {
                    par.forEach(function (item, index) {
                        if (isDate(item)) {
                            if (!tempDate) {
                                tempDate = item;
                            } else {
                                var tempParam = [];
                                tempParam.push(item);
                                tempParam.push(tempDate);
                                tempParam.push("s");
                                var result = CompareDate(tempParam);
                                if (result < 0) {
                                    tempDate = item;
                                }
                            }
                        }
                    });
                } else {
                    if (isDate(par)) {
                        if (!tempDate) {
                            tempDate = par;
                        } else {
                            var tempParam = [];
                            tempParam.push(par);
                            tempParam.push(tempDate);
                            tempParam.push("s");
                            var result = CompareDate(tempParam);
                            if (result < 0) {
                                tempDate = par;
                            }
                        }
                    }
                }
            }
            return tempDate;
        } else {
            throw new Error("MAXDATE arguments can not be null");
        }
    }

    // 取多个日期的最小值
    function MINDATE(param) {
        if (param != undefined && param.length > 0) {
            var tempDate;
            for (var i = 0; i < param.length; i++) {
                var par = param[i];
                if (par && par.constructor == Array) {
                    par.forEach(function (item, index) {
                        if (isDate(item)) {
                            if (!tempDate) {
                                tempDate = item;
                            } else {
                                var tempParam = [];
                                tempParam.push(item);
                                tempParam.push(tempDate);
                                tempParam.push("s");
                                var result = CompareDate(tempParam);
                                if (result > 0) {
                                    tempDate = item;
                                }
                            }
                        }
                    });
                } else {
                    if (isDate(par)) {
                        if (!tempDate) {
                            tempDate = par;
                        } else {
                            var tempParam = [];
                            tempParam.push(par);
                            tempParam.push(tempDate);
                            tempParam.push("s");
                            var result = CompareDate(tempParam);
                            if (result > 0) {
                                tempDate = par;
                            }
                        }
                    }
                }
            }
            return tempDate;
        } else {
            throw new Error("MINDATE arguments can not be null");
        }
    }

    function isDate(param) {
        if (param) {
            if (IsTime(param)) {
                return true;
            } else {
                try {
                    var date1 = new Date(Date.parse(param));
                } catch (err) {
                    return false;
                }
                return true;
            }
        }
        return false;
    }
    
    return {
        SUM: function(){
            return SUM(arguments);
        },
        AVERAGE: function(){
            return AVERAGE(arguments);
        },
        ABS: function(){
            return ABS(arguments);
        },
        ROUND: function(){
            return ROUND(arguments);
        },
        IF: function(){
            return IF(arguments);
        },
        MAX: function(){
            return MAX(arguments);
        },
        MIN: function(){
            return MIN(arguments);
        },
        CompareDate: function(){
            return CompareDate(arguments);
        },
        Length: function(){
            return Length(arguments);
        },
        IsString: function(){
            return IsString(arguments);
        },
        Lower: function(){
            return Lower(arguments);
        },
        Upper: function(){
            return Upper(arguments);
        },
        ToString: function(){
            return ToString(arguments);
        },
        Trim: function(){
            return Trim(arguments);
        },
        Ltrim: function(){
            return LTrim(arguments);
        },
        Rtrim: function(){
            return RTrim(arguments);
        },
        IsNumber: function(){
            return IsNumber(arguments);
        },
        IsInt: function(){
            return IsInt(arguments);
        },
        IsFloat: function(){
            return IsFloat(arguments);
        },
        ToInt: function(){
            return ToInt(arguments);
        },
        ToFloat: function(){
            return ToFloat(arguments);
        },
        ToNumber: function(){
            return ToNumber(arguments);
        },
        CurrDate: function(){
            return CurrDate(arguments);
        },
        CurrYear: function(){
            return CurrYear(arguments);
        },
        CurrMonth: function(){
            return CurrMonth(arguments);
        },
        CurrDay: function(){
            return CurrDay(arguments);
        },
        CurrWeek: function(){
            return CurrWeek(arguments);
        },
        CurrHour: function(){
            return CurrHour(arguments);
        },
        CurrMinute: function(){
            return CurrMinute(arguments);
        },
        CurrSecond: function(){
            return CurrSecond(arguments);
        },
        CurrDateTime: function () {
            return CurrDateTime(arguments);
        },
        GetDateValue: function(){
            return GetDateValue(arguments);
        },
        CompareWorkDate: function(){
            return CompareWorkDate(arguments);
        },
        GetJSONValue: function () {
            return GetJSONValue(arguments);
        },
        IsJSON: function () {
            return IsJSON(arguments);
        },
        rewrite_add: function () {
            return rewrite_add(arguments);
        },
        compare: function () {
            return compare(arguments);
        },
        COUNT: function () {
            return COUNT(arguments);
        },
        COUNTIF_: function () {
            return COUNTIF(arguments);
        },
        RAND: function () {
            return RAND(arguments);
        },
        MOD: function () {
            return MOD(arguments);
        },
        SUMIF_: function () {
            return SUMIF(arguments);
        },
        SUBSTR: function () {
            return SUBSTR(arguments);
        },
        MAXDATE: function () {
            return MAXDATE(arguments);
        },
        MINDATE: function () {
            return MINDATE(arguments);
        }
    }
})();