ZLPMS/PMS.WebUI/Content/Scripts/Common.js

/// <reference path="SysFrame/Zlsoft.UI-1.0.js" />
/*
说明：公共Js文件，保存公共方法和扩展方法
创建时间：2016.02.02
创建人：LMS
依赖文件：
1<reference path="/Scripts/jquery-1.12.0.min.js" />
2 <reference path="/Scripts/plugins/WebPlugins/layer-2.1/layer.js" />
3 <reference path="/Scripts/plugins/WebPlugins/ArtTemplate/template.js" />
修改记录：
*/
//#region 全局方法
Date.prototype.format = function (format) {
    var o =
    {
        "M+": this.getMonth() + 1, //month
        "d+": this.getDate(),    //day
        "h+": this.getHours(),   //hour
        "m+": this.getMinutes(), //minute
        "s+": this.getSeconds(), //second
        "q+": Math.floor((this.getMonth() + 3) / 3),  //quarter
        "S": this.getMilliseconds() //millisecond
    }
    if (/(y+)/.test(format))
        format = format.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
    for (var k in o)
        if (new RegExp("(" + k + ")").test(format))
            format = format.replace(RegExp.$1, RegExp.$1.length == 1 ? o[k] : ("00" + o[k]).substr(("" + o[k]).length));
    return format;
}
String.prototype.endWith = function (s) {
    if (s == null || s == "" || this.length == 0 || s.length > this.length)
        return false;
    if (this.substring(this.length - s.length) == s)
        return true;
    else
        return false;
    return true;
}


String.prototype.startWith = function (s) {
    if (s == null || s == "" || this.length == 0 || s.length > this.length)
        return false;
    if (this.substr(0, s.length) == s)
        return true;
    else
        return false;
    return true;
}
//字符串格式化
//Example: String.format("名称是{0},年龄是{1}", "john", 12)
String.format = function () {
    if (arguments.length === 0)
        return null;
    var str = arguments[0];
    for (var i = 1; i < arguments.length; i++) {
        var re = new RegExp('\\{' + (i - 1) + '\\}', 'gm');
        str = str.replace(re, arguments[i]);
    }
    return str;
}

/**字符串截取
 * showStartNo=前面显示字数(默认为3)
 * showEndNo=后面显示字数(默认为3)
 * symbol =分割符号(默认为“***”) 
 * 不足时返回原字符
 */
String.cutString = function (str, showStartNo, showEndNo, symbol) {
    var strlength = str.length;
    if (strlength <= showStartNo + showEndNo) {
        return str;
    }
    showStartNo = showStartNo || 3;
    showEndNo = showEndNo || 3;
    symbol = symbol || "***";
    return str.substring(0, showStartNo) + symbol + str.substring(strlength - showEndNo, strlength);
}

//diaojian。项目全局公共js方法入口
function MsgError(resultFun) {
    // document.write("<script language=javascript src='/Scripts/SysFrame/Zlsoft.UI-1.0.js'></script>");

    //var oCss = document.create_rElement("link");
    //oCss.setAttribute("rel", "stylesheet");
    //oCss.setAttribute("type", "text/css");
    //oCss.setAttribute("href", "/Scripts/layer-2.1/skin/layer.css");
    //document.getElementsByTagName_r("head")[0].appendChild(oCss);
    var TopWin = getTopmostWinodow();

    TopWin.jQuery.getScript("/Scripts/layer-2.1/layer.js", function (data, status, jqxhr) {
        TopWin.jQuery.getScript("/Scripts/SysFrame/Zlsoft.UI-1.0.js", function (data, status, jqxhr) {
            resultFun();
        });
    });

}

function getTopmostWinodow() {
    var win = window;
    while (win.frameElement) {
        win = win.parent;
    }
    return win;
}
; (function ($) {
    //#region jq常用方法设置 diaojian
    //#region --设置控件高度
    $.fn.SetHeightForWin = function (topH) {
        var winHeight = $(window).height();
        $This = $(this);
        $This.height(winHeight - topH);
    }
    //#endregion
    $.fn.getDgPageSize = function () {
        $This = $(this);
        var h = $This.find("table tr").eq(0).height();
        var result = $This.height() / h;
        return Math.floor(result) - 1;
    }
    //将表单序列化为对象
    $.fn.serializeJson = function () {
        var serializeObj = {};
        $(this.serializeArray()).each(function () {
            try {
                var obj = jQuery.parseJSON(this.value);
                if (typeof obj === "number")
                    obj = this.value;

                serializeObj[this.name] = obj;
            } catch (e) {
                serializeObj[this.name] = this.value;
            }
        });

        return serializeObj;
    };
    $.fn.createIfr = function () {
        var win = window.parent;
       
        console.log(win.DuiFn);
        win.DuiFn.createIframe($(this));
    };
})(jQuery);
var PublicFun = function () {
    jQuery.support.cors = true;

    return {
        //获取服务器时间
        //type:时间格式。true:时间对象，false:时间格式字符串
        getServerTime: function (type) {
            var win = getTopmostWinodow();
            if (win.global_serverTime) {

            } else {
                //没有服务器时间时。使用客户端时间
                //PublicFun.MsgAlert("未获取到服务器时间！", null, "错误", 2);
                win.global_serverTime = new Date().FormatDF();
            }
            if (type) {
                return convertToDate(win.global_serverTime);
            } else {
                return win.global_serverTime;
            }
        },

        //绑定全局变量存取
        //存数据:PublicFun.GlobalData("两癌信息",1)
        //取数据:PublicFun.GlobalData("两癌信息"); //注意取出数据后,不能再取.
        GlobalData: function (key, value, isSave) {
            var win = getTopmostWinodow();
            var data = win.GLOBALDATAS;
            if (!data) {
                win.GLOBALDATAS = data = {};
            }

            if (value || value == 0) { //0也算做参数值进行保存
                //放
                data[key] = value;
            } else {    //取
                var res = data[key];
                if (!isSave) {
                    data[key] = null;
                }
                return res;
            }
        },
        //获取顶级窗体
        GetTopmostWinodow: getTopmostWinodow,
        //方法：Ajax提交表单数据
        //参数： 
        FromAjax: function (url, formId, callBack) {
            if (HasUrlParameter(url)) {
                url += "&random=" + Math.random();
            } else {
                url += "?random=" + Math.random();
            }
            $.ajax({
                type: 'post',
                url: url,
                data: $(formId).serialize(),
                dataType: "text",
                success: function (data, textStatus) {
                    callBack(data);
                },
                error: function (XMLHttpRequest, textStatus, errorThrown) {
                    //$(page).hideLoading();
                    var errMsg = XMLHttpRequest.responseText;
                    if (!errMsg) errMsg = '请求地址不存在!';
                    PublicFun.MsgAlert("错误：" + errMsg, null, "错误", 2);
                },
                complete: function (XHR, TS) {
                    //Loading(0);
                }
            });
        },

        /*
            弹层打开新窗口。
            option:参数对象。参数内容：
                title:窗口标题；
                url:弹窗页面路径；
                area:弹窗区域尺寸，默认 ['80%', '90%']，也可以写 ['200px', '300px'];
                maxWidth:数字类型，弹窗最大宽度；
                maxHeight:数字类型，弹窗最大高度；
                success:弹层创建好以后的回调;
                end:弹层被关闭（销毁）以后的回调,
                closeBtn:是否显示关闭按钮，0为关闭。默认1,
                closed:关闭时回调传入参数执行的方法,回调参数(data),
                maxmin:true/false.弹窗显示最大最小按钮，默认false,
                scrollbar :true/false.弹窗是否出现滚动条，默认true,
                shade:0.3/0.是否遮罩，0为遮罩，默认0.3
            */
        OpenWindow: function (option) {
            try {
                var win = getTopmostWinodow();

                //*************扩展OpenWindow方法

                if (option && option.closed) {
                    //兼容success方法,如果存在则做一个存储
                    var opSuccessCB = option.success;
                    var opEndCB = option.end;
                    //重写success方法
                    option.success = function (layero, index) {
                        var key = 'iframeeventtransfer-openwindow-' + index;
                        if (!win.iframeeventtransfercurrentkey) {
                            win.iframeeventtransfercurrentkey = [];
                        }
                        //设置当前弹出窗体的key
                        win.iframeeventtransfercurrentkey.push(key);
                        $.iframeEventTransfer.on(key, option.closed);
                        if (opSuccessCB) {
                            opSuccessCB(layero, index);
                        }
                    }


                    option.end = function () {

                        if (win.iframeeventtransfercurrentkey && win.iframeeventtransfercurrentkey.length > 0) {
                            var key = win.iframeeventtransfercurrentkey.pop();
                            //去掉事件
                            $.iframeEventTransfer.unbind(key);
                            if (opEndCB) {
                                opEndCB();
                            }
                        } else {
                            console.log("window.iframeeventtransfercurrentkey is null,can not unbind iframeEventTransfer");
                        }
                    }
                }

                //*************END扩展OpenWindow方法
                return win.DuiFn.OpenWindow(option);
            }
            catch (e) { 
                MsgError(function () {
                    var win = getTopmostWinodow();
                    win.DuiFn.OpenWindow(option);
                    //DuiFn.OpenWindow(option);
                });
            }
        },
        //关闭窗体同时执行openwindow中的closewindow回调
        DoCloseWindow: function (data) {
            //判断运行环境。
            if (typeof (CEFAPI) != "undefined") { //BH内打开的页面
                //执行BH中关闭窗口的方法
                CEFAPI.trigger("关闭窗体", "");
                try {
                    var win = getTopmostWinodow();
                    var wIndex = win.layer.getFrameIndex(window.name);
                    //调用回调
                    var key = 'iframeeventtransfer-openwindow-' + wIndex;
                    $.iframeEventTransfer.trigger(key, data);
                    win.layer.close(wIndex);
                } catch (e) { }
            } else { //公卫项目内
                var win = getTopmostWinodow();
                var wIndex = win.layer.getFrameIndex(window.name);
                //调用回调
                var key = 'iframeeventtransfer-openwindow-' + wIndex;
                $.iframeEventTransfer.trigger(key, data);
                win.layer.close(wIndex);
            }
        },
        //关闭弹窗。在弹窗中调用，关闭自身,option:{on:true,data:{}}
        CloseWindow: function () {
            //判断运行环境。
            if (typeof (CEFAPI) != "undefined") { //BH内打开的页面
                //执行BH中关闭窗口的方法
                CEFAPI.trigger("关闭窗体", "");
                try {
                    var win = getTopmostWinodow();
                    var wIndex = win.layer.getFrameIndex(window.name);
                    win.layer.close(wIndex);
                } catch (e) { }

            } else { //公卫项目内
                var win = getTopmostWinodow();
                //win.DuiFn.OpenWindow(option);
                var wIndex = win.layer.getFrameIndex(window.name);
                win.layer.close(wIndex);
            }

        },
        /*获取url参数*/
        getQueryValue: function (url, name) {

            name = name.replace(/[\[]/, "\\\[").replace(/[\]]/, "\\\]");
            var regexS = "[\\?&]" + name + "=([^&#]*)";
            var regex = new RegExp(regexS);
            var results = regex.exec(url);
            if (results == null)
                return "";
            else
                return results[1];
        },
        /*
        生成时间戳+随机数的字符串
        */
        CreateRandomNumber: function () {
            return new Date().getTime() + '' + Math.floor(Math.random() * 10000);
        },
        /**
        获取URL参数，
        */
        GetUrlQueryValue: function (name) {
            var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)", "i");
            var r = window.location.search.substr(1).match(reg);
            if (r != null) return r[2]; return null;
        },
        /* 弹出框
        1个必要参数：
         msg：弹出的消息，必要参数；       
         callback:点击确定按钮的回调；
         title：弹出框标题，默认为 "提示消息";
         icon:图标，默认为0. 0：叹号；1：勾；2：叉；3：问号；4：锁；5：哭脸；6：笑脸
         optionObject:其他配置参数对象，如：{closeBtn:0}隐藏右上角关闭按钮
     */
        MsgAlert: function (msg, callback, title, icon, optionObject) {
            try {
                var win = getTopmostWinodow();
                win.DuiFn.MsgAlert(msg, callback, title, icon, optionObject);
            }
            catch (e) {
                MsgError(function () {
                    var win = getTopmostWinodow();
                    win.DuiFn.MsgAlert(msg, callback, title, icon, optionObject);
                });
            }
        },
        /*
        询问层。
        1个必要参数：
         msg：弹出的消息，必要参数；；
        callbackYes:点击确定按钮的回调；
        callbackNo:点击确定按钮的回调；
        title：弹出框标题，默认为 "操作提示";
        icon:图标，默认为3。0：叹号；1：勾；2：叉；3：问号；4：锁；5：哭脸；6：笑脸
        layerOption:layer文档内的其他配置参数对象
        */
        MsgConfirm: function (msg, callbackYes, callbackNo, title, icon, layerOption) {
            try {
                var win = getTopmostWinodow();
                win.DuiFn.MsgConfirm(msg, icon, title, callbackYes, callbackNo, layerOption);
            }
            catch (e) {
                MsgError(function () {
                    var win = getTopmostWinodow();
                    win.DuiFn.MsgConfirm(msg, icon, title, callbackYes, callbackNo, layerOption);
                });
            }
        },
        /*
      询问层输入。
      1个必要参数：
       msg：弹出的消息，必要参数；；
      _formType:1,密码框，2多行文本，3单行文本
      callbackYes:点击确定按钮的回调；
      layerOption:layer文档内的其他配置参数对象
      */
        MsgPrompt: function (msg, _formType, callbackYes, layerOption) {
            try {

                var win = getTopmostWinodow();
                win.DuiFn.MsgPrompt(msg, _formType, callbackYes, layerOption);
            }
            catch (e) {
                MsgError(function () {
                    var win = getTopmostWinodow();
                    win.DuiFn.MsgPrompt(msg, _formType, callbackYes, layerOption);
                });
            }
        },
        /*提示消息，默认3秒后自动关闭
        *1个必要参数：msg,消息。必要参数；
        time:持续时间，单位ms,默认3000
        callback:提示消失以后的回调
        */
        MsgShow: function (msg, callback, time) {
            try {
                var win = getTopmostWinodow();
                win.DuiFn.MsgShow(msg, callback, time);
            }
            catch (e) {
                MsgError(function () {
                    var win = getTopmostWinodow();
                    win.DuiFn.MsgShow(msg, callback, time);
                });
            }
        },
        /*使用最外层页面的layer对象。
        参数callback：回调函数。传入的参数为最外层页面的layer对象
        */
        OriginalLayer: function (callback) {
            try {
                var win = getTopmostWinodow();
                win.DuiFn.OriginalLayer(callback);
            }
            catch (e) {
                MsgError(function () {
                    var win = getTopmostWinodow();
                    win.DuiFn.OriginalLayer(callback);
                });
            }
        },
        /*
        layer的tips方法。参数与原方法完全相同。
        参数1-3:原参数；
        参数4：layer的js和css文件加载完成后的回调。获取
        */
        Tips: function (content, follow, options, callback) {
            var rs;
            try {
                //tips带有位置信息，需要在本页面调用layer对象
                if (window.layer == undefined) {
                    //加载样式表
                    $("head").prepend("<link href=\"/Scripts/layer-2.1/skin/layer.css\" rel=\"stylesheet\" />");
                    //引入js文件
                    $.getScript("/Scripts/layer-2.1/layer.js", function (data, status, jqxhr) {
                        if (callback) {
                            rs = layer.tips(content, follow, options);
                            callback(rs);
                        }
                    });
                    //这种方式会导致第一次加载时样式出现错误，tips错位
                    ////加载样式表
                    //$("head").prepend("<link href=\"/Scripts/layer-2.1/skin/layer.css\" rel=\"stylesheet\" />");
                    ////引入js文件
                    //$("head").append("<script src=\"/Scripts/layer-2.1/layer.js\"></script>");
                    //while (true) {
                    //    if (window.layer) {
                    //        rs = layer.tips(content, follow, options);
                    //        break;
                    //    }
                    //}
                } else {
                    rs = layer.tips(content, follow, options);
                    if (callback) {
                        callback(rs);
                    } else {
                        return rs;
                    }
                }
            }
            catch (e) {
            }
            return rs;
        },
        /*
        layer的close方法，关闭层。优先使用当前页面的layer对象关闭
        参数：层索引
        */
        CloseLayer: function (index) {
            try {
                if (window.layer == undefined) {
                    //当前页面没有引入js，调用顶级窗口的方法
                    var TopWin = getTopmostWinodow();
                    TopWin.DuiFn.MsgShowCloseLayer(index);
                } else {
                    //当前页面有layer，从当前页面关闭
                    layer.close(index);
                }
            }
            catch (e) {
            }
        },
        //处理2016-03-13T00:00:00格式的字符串，返回正常格式的字符串
        HandleDateTimeString: function (dateTimeStr) {
            if (dateTimeStr) {
                return dateTimeStr.replaceAll("T", " ", 1);
            }
        },
        /*
        * 搜索框条件判断
        *0：没有任何值
        *1：姓名
        *2：简码
        *3：身份证
        *4：电话号码
        */
        QueryChoose: function (Str) {
            if (Str == "" || Str == null) {
                return 0;
            }
            //判断是否包含汉字
            var reg = new RegExp("[\\u4E00-\\u9FFF]+", "g");
            if (reg.test(Str)) {
                return 1;
            }
            reg = /^[A-Za-z]+$/;
            //判断是否全文英文
            if (reg.test(Str)) {
                return 2;
            }
            //判断字符串长度确定是否是身份证
            if (Str.length >= 12) {
                return 3;
            }
            return 4;

        },
       

        /*处理后台Ajax返回结果的公共方法。参数:
        returnString:返回的json字符串;
        callback:处理结果回调，回调参数是json字符串转化的对象
        */
        HandleAjaxResult: function (returnString, callback) {
            if (!returnString || returnString.length == 0) {
                PublicFun.MsgAlert("请求返回空数据");
            }
            var returnValue;    //函数返回值，用于返回回调的返回值
            try {
                var resultObject;
                if (typeof (returnString) == "string") {
                    resultObject = eval("(" + returnString + ")");
                } else {
                    resultObject = returnString;
                }
                switch (resultObject.code) {
                    case 100:   //成功
                        break;
                    case 201:       //登录超时
                        PublicFun.MsgAlert(resultObject.errormessage, function () {
                            PublicFun.OpenWindow({
                                id: 'login20160830',
                                title: "重新登录",
                                url: "/Account/OpenLogin?tag=" + resultObject.data,
                                area: ["500px;", "325px;"],
                                maxWidth: 1000,
                                maxHeight: 350,
                                closeBtn: 0
                            });
                        });
                        break;
                    default:
                        break;
                }
                if (resultObject.code == 201)
                    return;
                if (callback) {
                    returnValue = callback(resultObject);
                }
            } catch (e) {
                //PublicFun.MsgAlert("公共请求-解析请求结果数据异常：" + e.message);
                console.log("公共请求错误：%o", e);
            }
            return returnValue;
        },
        //配合HandleAjaxResult使用，在HandleAjaxResult回调中用alert方式显示结果
        //参数：result:HandleAjaxResult回调的参数；
        //optName：用于提示的操作名称
        //callback：提示窗口关闭后的回调.参数为第一个参数（rs）
        AlertAjaxResult: function (result, _optName, callback) {
            var optName = _optName || "操作";
            if (result.code == 100) {
                PublicFun.MsgAlert(optName + "成功！", callback, "操作提示", 1);
            } else {
                PublicFun.MsgAlert(optName + "失败：" + result.errormessage, callback, "操作提示", 2);
            }
        },
        /*发起Ajax请求公共方法。参数对象：
        url:必须参数；
        //非必须参数：
        type:请求方式，默认get;
        data:post参数；
        timeout:请求超时时间。不使用超时则不需要传这个参数；
        loading:是否使用loading效果锁住当前窗口，默认false
        success:请求成功回调（默认使用MsgAlert提示成功信息）,参数是后台传回的json字符串转化的对象；
        error：请求失败回调（默认使用MsgAlert提示错误信息）,参数是$.ajax的error回调的参数；
        complete：请求完成回调；
        async:异/同步 默认异步 true:异步、false:同步;
        */
        DoAjax: function (option) {
            if (!option.url) {
                PublicFun.MsgAlert("缺少url参数");
                return;
            }
            var defaultOption = { type: "get", timeout: null, loading: false, dataType: "text", async: true };  //关闭超时
            $.extend(defaultOption, option);//合并参数
            var url = defaultOption.url;
            if (HasUrlParameter(url)) {
                url += "&random=" + Math.random();
            } else {
                url += "?random=" + Math.random();
            }
            if (defaultOption.loading) {    //打开loading效果
                Loading(1);
            }

            $.ajax({
                type: defaultOption.type,
                url: url,
                data: defaultOption.data,
                async: defaultOption.async,
                dataType: defaultOption.dataType,
                success: function (data, textStatus) {
                    PublicFun.HandleAjaxResult(data, defaultOption.success); //执行回调
                },
                error: function (XMLHttpRequest, textStatus, errorThrown) {
                    if (typeof (defaultOption.error) != "undefined") {
                        defaultOption.error(XMLHttpRequest, textStatus, errorThrown); //执行回调
                    } else {
                        PublicFun.HandleAjaxError(XMLHttpRequest, textStatus, errorThrown); //调用公共错误处理方法
                    }
                },
                complete: function (XHR, TS) {
                    if (defaultOption.loading) { //关闭loading效果
                        Loading(0);
                    }
                    if (typeof (defaultOption.complete) != "undefined") { //执行回调
                        defaultOption.complete();
                    }
                }
                //timeout: defaultOption.timeout    //取消超时
            });
        },
        //公共方法，处理ajax请求错误时的信息显示，参数与$.ajax的error回调参数相同
        HandleAjaxError: function (XMLHttpRequest, textStatus, errorThrown) {
            var errMsg = XMLHttpRequest.responseText;
            var isShowErrorMessage = true;
            switch (textStatus) {
                case "timeout": //超时
                    errMsg = "请求超时";
                    break;
                case "error":
                    if (XMLHttpRequest.status == 404) {
                        errMsg = "请求地址不存在!";
                    }
                    else if (XMLHttpRequest.status == 0 && errorThrown.length == 0) {
                        //errMsg = "服务器请求异常!";
                        //ajax请求完成前关闭窗口，不弹出异常
                        isShowErrorMessage = false;
                    }
                    else {
                        errMsg = XMLHttpRequest.statusText;
                    }
                    break;
                case "parsererror":  //数据格式错误
                    errMsg = "数据格式转化错误:" + errorThrown.message;
                    break;
                default:
                    errMsg = XMLHttpRequest.statusText + "。" + errorThrown;
                    break;
            }
            //alert(errorThrown);
            if (isShowErrorMessage) {
                PublicFun.MsgAlert("请求数据错误：" + errMsg, null, "错误", 2);
            }
        },
        //处理日期控件范围
        //必须参数controlID
        //非必需参数minTime，maxTime
        //参数说明
        //controlID ：日期控件的ID
        //minTime：最小时间 默认1001-01-01
        //maxTime：最大时间 不传最大时间则默认不做控制
        TimeRange: function (controlID, minTime, maxTime) {
            var a = minTime || '1001-01-01';
            var b = maxTime || "";
            controlID = "#" + controlID;
            $(controlID).datebox('calendar').calendar({
                validator: function (date) {
                    //最小时间范围
                    var minYear = a.substring(0, 4);//范围小 年
                    var minMonth = a.substring(5, 7);//范围小 月
                    var minDay = a.substring(8, 10);//范围小 日
                    //不做最大范围时间控制
                    if (b == "") {
                        var MinValiTime = new Date(minYear, minMonth - 1, minDay);
                        return date >= MinValiTime;
                    }
                    else {
                        //最大时间范围
                        var maxYear = b.substring(0, 4);//范围大 年
                        var maxMonth = b.substring(5, 7);//范围大 月
                        var maxDay = b.substring(8, 10);//范围大 日
                        //easyui的日期的月份是0-11月，所以月份统一减去1。
                        var MinValiTime = new Date(minYear, minMonth - 1, minDay);
                        var MaxValiTime = new Date(maxYear, maxMonth - 1, maxDay);

                        return MaxValiTime >= date && date >= MinValiTime;
                    }
                }
            });
            //判断时间范围是否有误 如果有误则清掉
            var getvalue = $(controlID).datebox('getValue');
            if (getvalue != null && getvalue < minTime) {
                $(controlID).datebox('setValue');
            }
        },
        //传入身份证号码返回生日日期和性别的数组，参数身份证号码
        IdCardIsSexAndBirthday: function (idCard) {
            var birthdayValue;
            var sex;
            var arr = new Array();
            try {
                //15位身份证号码
                if (idCard.length == 15) {
                    //出生日期代码，第7—8位数代表年份(年份前面二位数省略)，第9—10位数代表月份(月份为l位数的前面加零)。第11一12位数代表日期(日期为1位数的前面加零)。 
                    birthdayValue = idCard.charAt(6) + idCard.charAt(7);
                    if (parseInt(birthdayValue) < 16) {
                        birthdayValue = '20' + birthdayValue;

                    }
                    else {
                        birthdayValue = '19' + birthdayValue;
                    }
                    //生日
                    birthdayValue = birthdayValue + '-' + idCard.charAt(8) + idCard.charAt(9) + '-' + idCard.charAt(10) + idCard.charAt(11);
                    arr[0] = birthdayValue;
                    //性别：男
                    if (parseInt(idCard.charAt(14) / 2) * 2 != idCard.charAt(14)) {
                        sex = "1";
                    }
                        //性别：女
                    else {
                        sex = "2";
                    }
                    arr[1] = sex;
                    return arr;
                }
                    //18位身份证号码
                else if (idCard.length == 18) {
                    //生日
                    birthdayValue = idCard.charAt(6) + idCard.charAt(7) + idCard.charAt(8) + idCard.charAt(9) + '-' + idCard.charAt(10) + idCard.charAt(11) + '-' + idCard.charAt(12) + idCard.charAt(13);
                    arr[0] = birthdayValue;
                    //性别：男
                    if (parseInt(idCard.charAt(16) / 2) * 2 != idCard.charAt(16)) {
                        sex = "1";
                    }
                        //性别：女
                    else {
                        sex = "2";
                    }
                    arr[1] = sex;
                    return arr;
                }
                else {
                    PublicFun.MsgShow("身份证有误");
                }
            }
            catch (e) {
                PublicFun.MsgShow("身份证解析异常");
            }
        },
        
        //表单数据转化为对象。参数:表单id
        FormToObject: function (formId) {
            var array = $("#" + formId).serializeArray();
            var rs = new Object();
            for (var i = 0; i < array.length; i++) {
                //重复就在后面加上
                if (rs[array[i].name]) {
                    rs[array[i].name] = rs[array[i].name] + "," + array[i].value;
                }
                else {
                    rs[array[i].name] = array[i].value;
                }
            }
            return rs;
        },
        //获取正则表达式
        GetRegex: function (type) {
            var regex;
            switch (type) {
                case "数字字母":
                    regex = /^[\da-zA-Z]+$/;
                    break;
                case "座机电话":
                    regex = /^((0\d{2,3}-?\d{7,8})|(\d{7,8})|(1\d{10}))$/;
                    break;
            }
            return regex;
        },
        /*模拟表单提交post请求。用于下载功能等服务器端返回文件流的场景
        *参数1:对象option：
        *url:请求url
        *formId:表单id；
        *参数2：表单提交url，使用此参数则第一个参数option为参数对象
        */
        SendPostRequest: function (option, url) {
            var temp = document.createElement("form");
            if (url) {
                temp.action = url;
                temp.method = "post";
                temp.style.display = "none";
                for (var x in option) {
                    var opt = document.createElement("textarea");
                    opt.name = x;
                    opt.value = option[x];
                    temp.appendChild(opt);
                }
            } else {
                var defaultOption = { url: "", formId: "" };
                $.extend(defaultOption, option);//合并参数
                if (defaultOption.url) {
                    //模拟表单post提交数据
                    var params = $("#" + defaultOption.formId).serializeArray();
                    //type参数标识业务类型
                    temp.action = defaultOption.url;
                    temp.method = "post";
                    temp.style.display = "none";
                    for (var x in params) {
                        var opt = document.createElement("textarea");
                        opt.name = params[x].name;
                        opt.value = params[x].value;
                        temp.appendChild(opt);
                    }
                }
            }
            document.body.appendChild(temp);
            temp.submit();
        },
        /*返回字符是否超过指定长度，strByte字符，sum长度
        */
        Bytecount: function (strByte, sum) {
            var oreg = /[\u4e00-\u9fa5]/;
            var count = 0;
            for (var i = 0; i < strByte.length; i++) {
                if (oreg.test(strByte.charAt(i))) {
                    count += 2;
                }
                else {
                    count += 1;
                }
            }
            return sum >= count;
        },
        //阻止事件冒泡
        StopPropagation: function (e) {
            if (e && e.stopPropagation)
                //因此它支持W3C的stopPropagation()方法 
                e.stopPropagation();
            else
                //否则，使用IE的方式来取消事件冒泡 
                window.event.cancelBubble = true;
        },
        OpenIfm: function (id) {
            var win = getTopmostWinodow();
            win.DuiFn.OpenIfm(id);

        },
        foldupClick: function () {
            var TopWin = getTopmostWinodow();
            TopWin.DuiFn.colsefold()
        },
       
        //批量绑定表单数据
        //JYC
        //传入json对象
        //格式要求 
        //1.input 添加自定义属性‘data-input='AutoInput' data-name='需要绑定的表字段'’
        BandFormVal: function (data) {
            //申明一个数组keys
            var keys = [];
            //循环传入json节点
            for (var p1 in data) {
                //保存节点 ‘字段名称’
                if (data.hasOwnProperty(p1)) {
                    var arr = { "key": p1, "value": data[p1] };
                    keys.push(arr);
                }
            }
            //循环前台表单
            $("input[data-input='AutoInput']").each(function () {
                for (var i = 0; i < keys.length; i++) {
                    if ($(this).attr("data-name") == keys[i].key) {
                        //绑定值
                        $(this).val(keys[i].value);
                    }
                }
            });
        },

        //LMS.2018.07.16
        //验证时间字符串是否为有效的时间格式。输入参数为时间字符串
        validateDate: function (dateString) {
            var rs = false;
            //将允许的时间分隔符统一替换为"/"分隔，否则会在ie下解析异常
            dateString = dateString.replace(/-/g, "/").replace(/\./g, "/");
            //alert(dateString);
            var d = new Date(dateString);
            if (d != "Invalid Date") {
                //被解析为正常的时间对象
                //输入纯数字时会被当成时间戳处理，能正常转为时间对象。阻止这种情况
                if (/^\d+$/.test(dateString)) {
                    //由纯数字组成。属于异常情况
                } else {
                    rs = true;  //正确的时间格式
                }
            }
            return rs;
        }

    }
}();