utilities.js

/**
 * 本文件用来保存一些常用的工具函数，供各个页面调用。
 */

document.onkeydown = function() {
    if (event.keyCode == 8) {
        event.keyCode = 27;
    }
};
// 检查版本号，如果相等返回0，version1 > version2 返回1，否则返回-1
function compareVersion(version1, version2) {
    if (!version1 || !version2) {
        throw error("参数非法！");
    }
    var parts1 = version1.split(".");
    var parts2 = version2.split(".");
    // 进行修整
    var maxLength =
        parts1.length > parts2.length ? parts1.length : parts2.length;
    fixArrayLength(parts1, maxLength);
    fixArrayLength(parts2, maxLength);
    // 比较两个数组
    var num1, num2;
    for (var index = 0; index < maxLength; index++) {
        num1 = parseInt(parts1[index]);
        num2 = parseInt(parts2[index]);
        if (num1 > num2) {
            return 1;
        } else if (num1 < num2) {
            return -1;
        } else {
            continue;
        }
    }
    return 0;

    function fixArrayLength(arr, length) {
        if (arr.length < length) {
            for (var i = 0; i < length - arr.length; i++) {
                arr.push(0);
            }
        }
    }
}
/**
 * 测试ip地址及端口是否可打开，后台使用telnet命令进行测试。
 * @param {string} ip   要测试的Ip地址
 * @param {Number} port 要测试的端口，整形
 */
function testNetwork(ip, port) {
    var url = "/do/trafficController/testConnection";
    $.get(
        url,
        {
            IP: ip,
            Port: port,
            t: new Date().getTime()
        },
        function(data) {
            if (data.error) {
                $.messager.show({
                    title: "结果",
                    msg: "连接成功 消息将在3秒后关闭。",
                    timeout: 3000,
                    showType: "slide"
                });
                return true;
            } else {
                $.messager.show({
                    title: "结果",
                    msg: "连接失败!",
                    timeout: 3000,
                    showType: "slide"
                });
                return false;
            }
        },
        "json"
    );
}
/**
 * 相机运行模式
 */
var CameraRunMode = {
    intersection: {
        mode: 0,
        desc: "路口电警"
    },
    videoBayonet: {
        mode: 2,
        desc: "视频卡口"
    },
    busSetting: {
        mode: 3,
        desc: "移动公交"
    },
    noMotorVehicleViolation: {
        mode: 4,
        desc: "非机动车违法"
    }
};

/**
 * 获取相机业务模式,获取成功后执行回调函数
 * @param {(cameraMode: Number) => {}} callback  获取相机模式成功后要执行的回调函数,传入参数为相机的运行模式
 */
function getCameraBusinessMode(callback) {
    var url = "/do/trafficController/getTrafficData";
    $.get(
        url,
        {
            RefererInfo: "cameraSettings",
            t: new Date().getTime()
        },
        function(data) {
            // 判断返回值
            if (data && data.feedback) {
                var cameraRunMode = data.feedback["220"];
                logInfo("获取到相机运行模式: " + cameraRunMode);
                if (callback && typeof callback == "function") {
                    callback(cameraRunMode);
                }
            } else {
                logInfo("获取相机运行模式失败,接口返回值格式不正确! " + data);
            }
        },
        "json"
    );
}

/**
 * Nvr控件控制器，用来声明nvr相关的ocx方法，包装一些业务逻辑。
 * @param {HTMLElement} ocxObj    nvr ocx 对象，可使用document.getElementById()来获取。
 */
function NvrOcxController(ocxObj) {
    var ocxObject = ocxObj;
    var isInit = false;

    /*初始化视频插件*/
    this.init = function(isDebug) {
        if (isInit) {
            ocxObject.UnInit();
        }
        var videoType = isDebug ? 100 : 0;
        initOcxObj(videoType, "", 1);
        isInit = true;
    };
    /*播放视频*/
    this.playVideo = function(url, channel, channelName, cameraIp, streamType) {
        playRealVideo(url, channel, channelName, cameraIp, streamType);
    };
    /*
    反初始化
    */
    this.uninit = function() {
        ocxObject.UnInit();
    };

    this.getVersion = function() {
        return ocxObject.GetOcxVersion();
    };

    this.setKakouMode = function(isKakouMode) {
        return ocxObject.setKakouMode(isKakouMode ? 1 : 0);
    };

    //在Ocx控件上显示时间
    this.setShowTime = function(year, month, day, hour, minute, second) {
        ocxObject.setShowTime(year, month, day, hour, minute, second);
    };
    //显示红灯状态
    this.setRedLightState = function(l, s, r) {
        ocxObject.setRedLightState(l, s, r);
    };

    /*
    初始化Ocx控件
        param: videoType 视频类型 0-实时视频，1-历史视频
                nvrIp nvr的IP地址
                splitScreenNumber 视频窗口分隔数目
        */
    function initOcxObj(videoType, nvrIp, splitScreenNumber) {
        ocxObject.Init(videoType, nvrIp, splitScreenNumber);
    }
    /*
    播放实时视频
        param:
            url         视频URL地址
            channel     通道号
            channelName 通道号名称，显示在Ocx上方会显示
            cameraIp    相机的IP地址
            streamType  (0-子码流,1-主码流,2-不区分)
    */
    function playRealVideo(url, channel, channelName, cameraIp, streamType) {
        ocxObject.PlayRealVideo(
            url,
            channel,
            channelName,
            cameraIp,
            streamType
        );
    }
}

/**
 * 参数适配器，主要封装一些跟后台交互的逻辑。
 */
function ParameterAdaptor() {
    //Url集合
    var urls = {
        get: "/do/trafficController/getTrafficData",
        save: "/do/trafficController/setTrafficData"
    };
    var attibuteUrl = "/do/trafficController/getAttributeData";

    //已经生效的参数字典对象
    var originalData = {};

    /**
     * 从后台获取参数，并调用指定的回调函数进行处理
     * @param {string} referInfo
     * @param {*} callback
     * @param {string} fackDataUrl  假的数据地址，主要用来测试目的。
     */
    this.getParameters = function(referInfo, callback, fackDataUrl) {
        var url = fackDataUrl ? fackDataUrl : urls.get;
        $.get(
            url,
            {
                RefererInfo: referInfo,
                t: new Date().getTime()
            },
            function(data) {
                // 首先对数据进行预处理,后台返回的值为0:false,1:true,需要进行转换
                // 0 => "off", 1 => "on" 才能被jquery easyui form组件正确加载
                var values = data.feedback;
                // 保存获取到的原始参数
                for (var k in values) {
                    originalData[k] = values[k];
                }
                // 对获取到的数据进行处理
                for (var key in values) {
                    var obj = $("#" + key);
                    // checkbox元素的值不为空时才进行转换
                    if (obj.attr("type") == "checkbox" && values[key]) {
                        values[key] = values[key] == "1" ? "on" : "off";
                    }
                }

                //如果有回调，则调用回调函数
                if (callback && typeof callback === "function") callback(data);
            },
            "json"
        );
    };

    /**
     * 从后台获取数据并调用回调函数
     * @param {string} referInfo   一个字符串,用来表示要获取的数据是哪一类的(包含多个值，每个参数的key为数值型)
     * @param {function} callback   获取数据成功后的回调函数
     */
    this.getAttribute = function(referInfo, callback) {
        $.get(
            attibuteUrl,
            {
                RefererInfo: referInfo
            },
            function(data) {
                if (callback) callback(data.feedback);
            },
            "json"
        );
    };

    /**
     * 变更相机的SD卡模式
     * @param {"single"|"double"} cardmodel    sd卡模式，可取值: single（单卡模式），double（双卡模式）
     */
    this.setSDCardMode = function(cardmodel) {
        var url = "/do/trafficController/setSDCardMode?mode=" + cardmodel;
        $.get(
            url,
            null,
            function(data) {
                if (data.error) {
                    $.messager.alert("结果", "设置卡模式成功", "info");
                } else {
                    $.messager.alert("结果", "设置卡模式失败", "error");
                }
            },
            "json"
        );
    };

    /**
     * 保存参数到后台，在调用后台接口前会进行数据的转换等操作。
     * @param {*} formObj Jquery Form 对象
     * @param {(data:any)=>{}} callBack 回调函数
     * @param {"GET"|"POST"} methodType 请求方法类型 "GET|POST"
     */
    this.saveParameters = function(formObj, callBack, methodType) {
        // 保存完参数后是否需要重启
        var isNeedReboot = false;
        // 从传入的form对象中获取到所有要保存的参数对象
        var allData = sy.serializeObject(formObj);
        // 获取所有未勾选的 checkbox，如果未被勾选无法从form中获取对应元素的值，需要手动处理
        var $chks = formObj.find(":checkbox:not(:checked)");
        $chks.each(function(i, item) {
            allData[item.id] = 0;
        });
        // 没有要保存的数据，进行提示
        if (!allData) {
            $.messager.show({
                title: "提示",
                msg: "没有要保存的修改",
                timeout: 3000,
                showType: "slide"
            });
            return;
        }

        // 把获取到的checkbox值从on ,off 分别转换为0，或1
        for (var k in allData) {
            var target = $("#" + k);
            if (target.attr("type") == "checkbox") {
                allData[k] = target.prop("checked") ? "1" : "0";
            } else if (target.attr("type") == "radio") {
                allData[k] = allData[k].indexOf("1") > 0 ? "1" : "0";
            }
        }

        // 与获取到的原始值进行对比，过滤出已经改变的元素的值
        var changedData = {};
        var objSize = 0;
        for (var i in allData) {
            if (allData[i] != originalData[i]) {
                changedData[i] = allData[i];
                //name为"-xsrf-"的参数不需要统计
                if (i != "-xsrf-") {
                    objSize++;
                }
            }
        }

        if (objSize == 0) {
            $.messager.show({
                title: "提示",
                msg: "没有要保存的修改",
                timeout: 3000,
                showType: "slide"
            });
            return;
        }

        //添加securityToken(appweb Post请求需要此参数，否则会报错)
        var securityToken = allData["-xsrf-"];
        if (securityToken) {
            //必须设置该项，以保证每一次都包含key为 "-xsrf-"的值
            changedData["-xsrf-"] = securityToken;
        } else {
            $.messager.show({
                title: "提示",
                msg: "securityToken为空！不能提交!",
                timeout: 3000,
                showType: "slide"
            });
            return;
        }

        //检查是否有参数需要重启
        for (var key in changedData) {
            var obj = $("#" + key);
            if (obj.hasClass("needReboot")) {
                isNeedReboot = true;
                break;
            }
        }
        // 隐藏页面上的Ocx控件，因为Ocx控件会遮盖其他dom对象。
        hideOcxSafe();

        //显示进度提示
        $.messager.progress({
            title: "保存",
            text: "保存参数中，请稍侯...",
            interval: 1000
        });

        //保存修改过的参数
        $.ajax(urls.save, {
            data: changedData,
            dataType: "json",
            type: methodType || "POST",
            success: function(data) {
                //关闭进度提示
                $.messager.progress("close");
                var haveCustomCallBack = false;
                //判断是否有自定义回调函数。自定义回调将在最后被调用
                if (callBack && typeof callBack == "function") {
                    haveCustomCallBack = true;
                }

                //默认的结果处理逻辑
                if (data.error) {
                    var msg = "保存成功! 消息将在3秒后关闭。";
                    if (isNeedReboot) {
                        msg += "一些参数需要重启生效！";
                    }

                    if (!haveCustomCallBack) {
                        $.messager.show({
                            title: "结果",
                            msg: msg,
                            timeout: 3000,
                            showType: "slide"
                        });
                    }

                    //清除保存失败的参数的样式
                    $(".settingParameter").removeClass("save-failed");

                    //保存成功，更新现有的参数值(Form表单值)
                    delete changedData["-xsrf-"];
                    //更新已保存成功的参数到生效参数字典,保持字典状态最新
                    for (var id in changedData) {
                        originalData[id] = changedData[id];
                    }
                } else {
                    var tempData = new Array();
                    //保存失败，对保存失败的参数进行处理。
                    if (data.feedback) {
                        var tempKey;
                        for (var j = 0; j < data.Msg.length; j++) {
                            tempKey = data.Msg[j].Key;
                            tempData.push(data.Msg[j].Err); //保存错误信息
                            //标注没有保存成功的
                            $("#" + tempKey).addClass("save-failed");
                            //从已修改的值中去除掉
                            delete changedData[tempKey];
                        }
                        delete changedData["-xsrf-"];
                        //changedData 中保存的值为修改成功的,需要更新表单状态
                        for (var k1 in changedData) {
                            originalData[k1] = changedData[k1];
                        }
                    }

                    if (!haveCustomCallBack) {
                        $.messager.show({
                            title: "结果",
                            msg: "保存失败!" + data.feedback.Msg,
                            timeout: 3000,
                            showType: "slide"
                        });
                    }
                }
                //显示Ocx
                showOcxSafe();
                //调用自定义的回调
                if (haveCustomCallBack) {
                    callBack(data);
                }
            },
            error: function(jqXHR, textStatus, error) {
                $.messager.progress("close");
                if (window.console) {
                    console.error(
                        "请求出错,状态:" + textStatus + ",错误信息:" + error
                    );
                }
                $.messager.alert(
                    "错误",
                    "请求出错！请刷新页面并重试！",
                    "error",
                    function() {
                        showOcxSafe();
                    }
                );
            }
        });
    };
    /**
     * 显示ocx插件
     */
    function showOcxSafe() {
        //如果存在"showOcxObj"的函数，则执行
        if (typeof showOcxObj == "function") {
            showOcxObj();
        }
    }

    function hideOcxSafe() {
        if (typeof hideOcxObj == "function") {
            hideOcxObj();
        }
    }
}

/**
 * 获取设备时间,并调用回调
 * @param {(serverDate:Date) => {}} callback 获取到相机的时间后，需要调用的回调函数
 */
function getServerTime(callback) {
    var url = "/do/trafficController/getTime?t=" + new Date().getTime();
    $.get(
        url,
        null,
        function(responseData) {
            var dateTime = null;
            if (!responseData.error || !responseData.feedback) return;
            var data = responseData.feedback;
            try {
                dateTime = new Date(
                    data.Year,
                    data.Month - 1,
                    data.Day,
                    data.Hour,
                    data.Minute,
                    data.Second
                );
            } catch (e) {}
            //当日期合法，并且存在回调时才去调回调
            if (
                dateTime != "Invalid Date" &&
                dateTime != NaN &&
                dateTime != null &&
                callback &&
                typeof callback == "function"
            ) {
                callback(dateTime);
            }
        },
        "json"
    );
}

var sy = $.extend({}, sy); /*定义全局对象*/
/*
将form表单元素的值序列化对象
*/
sy.serializeObject = function(form) {
    var o = {};
    $.each(form.serializeArray(), function(index) {
        var value = this["value"];

        if (o[this["name"]]) {
            o[this["name"]] = o[this["name"]] + "," + value;
        } else {
            o[this["name"]] = value;
        }
    });
    return o;
};

/*-----------------自定义 jquery easyui Tabs方法-------------------*/
$().ready(function() {
    //点选标签页时，显示对应的标签页内容
    $(".tab_title").click(function(event) {
        var currentTab = $(event.currentTarget);
        currentTab
            .addClass("selected")
            .siblings()
            .removeClass("selected");
        //显示对应的Tab页
        var index = currentTab.attr("data-index");
        $(".tab_content:eq(" + index + ")")
            .show()
            .siblings(".tab_content")
            .hide();
    });

    $(document).keydown(function(event) {
        //logInfo(event.keyCode);
        if ($(event.target).is("input")) {
            return true;
        }
        var keyCode = event.keyCode;
        if (keyCode == 8 || (keyCode >= 112 && keyCode < 123)) {
            event.preventDefault();
            event.returnValue = null;
            return false;
        }
    });
});

//使用iframe来下载文件
function downloadByIframe(url) {
    var iframeObj = $("#downloadIframe");
    if (iframeObj.length == 0) {
        iframeObj = $(
            "<iframe id='downloadIframe' src='' style='width:0;height:0'></iframe>"
        );
        $("body").append(iframeObj);
    }
    iframeObj.attr("src", url);
}

//写日志到浏览器控制台
function logInfo(info) {
    if (window.console && window.console.log) {
        console.log(info);
    }
}

// 重启相机的公用方法
function RebootManager() {
    var self = this;
    var rebootTimer = null;
    //发送重启命令
    self.sendRebootCmd = function(msg) {
        if (msg) {
            $.messager.confirm("提示", msg, function(r) {
                if (r) {
                    sendRebootInner();
                }
            });
        } else {
            sendRebootInner();
        }
    };

    function sendRebootInner() {
        var url = "/do/trafficController/restart";
        $.get(
            url,
            null,
            function(data) {
                if (data.error) {
                    //$.messager.alert("结果", "重启成功，请稍侯刷新页面！", "info");
                } else {
                    $.messager.alert(
                        "结果",
                        "重启设备失败！" + data.feedback.Msg,
                        "error"
                    );
                }
            },
            "json"
        );
        showRebootCutdown();
    }

    //显示重启后倒计时的窗口
    function showRebootCutdown() {
        //检测 ".rebootCutdown" 是否存在
        var cutdownPanel = $(".rebootCutdown");
        if (cutdownPanel.length == 0) {
            cutdownPanel = $(
                '<div class="rebootCutdown"><div class="rebootProgressBar"><div class="progressbar-inner-text"></div>' +
                    '<div class="progressbar-inner"><div class="progressbar-inner-value"></div></div></div></div>'
            ).appendTo($("body"));
        }

        var width = 0;
        var count = 60;
        //开始倒计时
        rebootTimer = setInterval(function() {
            width = 10 / 6 * (60 - count);
            if (width >= 100) {
                clearInterval(rebootTimer);
                //刷新主框架
                window.parent.location.reload();
                return;
            }
            $(".progressbar-inner-value").css("width", width + "%");
            $(".progressbar-inner-text").text(
                "重启中，请稍侯...  倒计时: " + count + " 秒"
            );
            count--;
        }, 1000);
    }
}

//设定Ajax出错信息
$.ajaxSetup({
    error: function(XMLHttpRequest, textStatus, errorThrown) {
        if ($.messager && $.messager.progress) {
            $.messager.progress("close");
        }

        if (window.console) {
            var errorMsg =
                "code:" +
                textStatus +
                ",responseText:" +
                XMLHttpRequest.responseText +
                ",error:" +
                errorThrown;
            console.error(errorMsg);
        }
    }
});