5

src/main/webapp/js/xadmin.js

@@ -1,195 +1,181 @@
-;!function (win) {
+// 定义一个立即执行的函数表达式 (IIFE)，传入全局对象 window
-	"use strict";
+!function(win) {
-	var doc = document
+    "use strict"; // 使用严格模式
+    var doc = document; // 获取文档对象
 
-	,Xadmin = function(){
+    // 定义 Xadmin 构造函数
+    var Xadmin = function() {
         this.v = '2.2'; // 版本号
     }
 
+    // 初始化方法
     Xadmin.prototype.init = function() {
-		var tab_list = this.get_data();
+        var tab_list = this.get_data(); // 获取所有标签页数据
         for (var i in tab_list) {
-			this.add_lay_tab(tab_list[i].title,tab_list[i].url,i);
+            this.add_lay_tab(tab_list[i].title, tab_list[i].url, i); // 添加标签页
         }
-		element.tabChange('xbs_tab', i);
+        element.tabChange('xbs_tab', i); // 切换到最后一个标签页
     };
-  /**
-   * [end 执行结束要做的]
-   * @return {[type]} [description]
-   */
-  Xadmin.prototype.end = function() {
-
-    var cate_list = this.get_cate_data();
 
+    // 结束方法，用于执行一些收尾工作
+    Xadmin.prototype.end = function() {
+        var cate_list = this.get_cate_data(); // 获取分类数据
         for (var i in cate_list) {
             if (cate_list[i] != null) {
-        $('.left-nav #nav li').eq(cate_list[i]).click();
+                $('.left-nav #nav li').eq(cate_list[i]).click(); // 点击左侧导航栏的对应项
             }
         }
     };
 
+    // 添加标签页方法
     Xadmin.prototype.add_tab = function(title, url, is_refresh) {
-		var id = md5(url);//md5每个url
+        var id = md5(url); // 对 URL 进行 MD5 加密生成唯一 ID
 
-		//重复点击
+        // 检查是否已经存在相同的标签页
         for (var i = 0; i < $('.x-iframe').length; i++) {
             if ($('.x-iframe').eq(i).attr('tab-id') == id) {
-                element.tabChange('xbs_tab', id);
+                element.tabChange('xbs_tab', id); // 切换到已存在的标签页
                 if (is_refresh)
-                    $('.x-iframe').eq(i).attr("src",$('.x-iframe').eq(i).attr('src'));
+                    $('.x-iframe').eq(i).attr("src", $('.x-iframe').eq(i).attr('src')); // 刷新页面
                 return;
             }
-        };
+        }
-
-		this.add_lay_tab(title,url,id);
-	    this.set_data(title,url,id);
-	    element.tabChange('xbs_tab', id);
 
+        this.add_lay_tab(title, url, id); // 添加新的标签页
+        this.set_data(title, url, id); // 保存标签页数据
+        element.tabChange('xbs_tab', id); // 切换到新添加的标签页
     }
 
+    // 删除标签页方法
     Xadmin.prototype.del_tab = function(id) {
-
         if (id) {
-      console.log(88);
+            console.log(88); // 打印日志（调试用）
         } else {
-      var id = $(window.frameElement).attr('tab-id');
+            var id = $(window.frameElement).attr('tab-id'); // 获取当前窗口的 tab-id
-      parent.element.tabDelete('xbs_tab', id);
+            parent.element.tabDelete('xbs_tab', id); // 删除父窗口中的标签页
         }
     }
 
+    // 添加 Layui 标签页方法
     Xadmin.prototype.add_lay_tab = function(title, url, id) {
         element.tabAdd('xbs_tab', {
-	       title: title 
+            title: title, // 标签标题
-	        ,content: '<iframe tab-id="'+id+'" frameborder="0" src="'+url+'" scrolling="yes" class="x-iframe"></iframe>'
+            content: '<iframe tab-id="' + id + '" frameborder="0" scrolling="yes" class="x-iframe"></iframe>', // 标签内容为 iframe
-	        ,id: id
+            id: id // 标签 ID
         })
     }
-	/**
+
-     * [open 打开弹出层]
+    // 打开弹出层方法
-     * @param  {[type]}  title [弹出层标题]
-     * @param  {[type]}  url   [弹出层地址]
-     * @return {[type]}        [description]
-     */
     Xadmin.prototype.open = function(title, url) {
         if (title == null || title == '') {
-	        var title=false;
+            var title = false; // 如果标题为空，则不显示标题
         };
         if (url == null || url == '') {
-	        var url="404.html";
+            var url = "404.html"; // 如果 URL 为空，则默认指向 404 页面
         };
         if (w == null || w == '') {
-	        var w=($(window).width()*0.9);
+            var w = ($(window).width() * 0.9); // 设置宽度为窗口宽度的 90%
         };
         if (h == null || h == '') {
-	        var h=($(window).height() - 50);
+            var h = ($(window).height() - 50); // 设置高度为窗口高度减去 50px
         };
         var index = layer.open({
-	        type: 2,
+            type: 2, // 类型为 iframe
-	        area: [w+'px', h +'px'],
+            area: [w + 'px', h + 'px'], // 设置弹出层大小
-	        fix: false, //不固定
+            fix: false, // 不固定位置
-	        maxmin: true,
+            maxmin: true, // 允许最大化和最小化
-	        shadeClose: true,
+            shadeClose: true, // 点击遮罩关闭弹出层
-	        shade:0.4,
+            shade: 0.4, // 设置遮罩透明度
-	        title: title,
+            title: title, // 弹出层标题
-	        content: url
+            content: url // 弹出层内容 URL
         });
         if (full) {
-	       layer.full(index); 
+            layer.full(index); // 如果 full 为真，则全屏显示弹出层
         }
     }
-	/**
+
-	 * [close 关闭弹出层]
+    // 关闭弹出层方法
-	 * @return {[type]} [description]
-	 */
     Xadmin.prototype.close = function() {
-		var index = parent.layer.getFrameIndex(window.name);
+        var index = parent.layer.getFrameIndex(window.name); // 获取当前窗口索引
-    	parent.layer.close(index);
+        parent.layer.close(index); // 关闭弹出层
     };
-  /**
+
-   * [close 关闭弹出层父窗口关闭]
+    // 关闭弹出层并刷新父窗口方法
-   * @return {[type]} [description]
-   */
     Xadmin.prototype.father_reload = function() {
-      parent.location.reload();
+        parent.location.reload(); // 刷新父窗口
     };
-	/**
+
-	 * [get_data 获取所有项]
+    // 获取所有标签页数据方法
-	 * @return {[type]} [description]
-	 */
     Xadmin.prototype.get_data = function() {
         if (typeof is_remember != "undefined")
-          return false;
+            return false; // 如果 is_remember 被定义，则返回 false
-		return layui.data('tab_list')
+        return layui.data('tab_list') // 从本地存储中获取标签页数据
     }
-	/**
-	 * [set_data 增加某一项]
-	 * @param {[type]} id [description]
-	 */
-	Xadmin.prototype.set_data = function(title,url,id) {
 
+    // 增加标签页数据方法
+    Xadmin.prototype.set_data = function(title, url, id) {
         if (typeof is_remember != "undefined")
-        	return false;
+            return false; // 如果 is_remember 被定义，则不执行任何操作
-
         layui.data('tab_list', {
-		  key: id
+            key: id, // 数据的键为标签页 ID
-		  ,value: {title:title,url:url}
+            value: { title: title, url: url } // 数据的值为包含标题和 URL 的对象
         });
     };
 
-  /**
+    // 获取分类数据方法
-   * [get_data 获取所有项]
-   * @return {[type]} [description]
-   */
     Xadmin.prototype.get_cate_data = function() {
         if (typeof is_remember != "undefined")
-          return false;
+            return false; // 如果 is_remember 被定义，则返回 false
-    return layui.data('cate')
+        return layui.data('cate') // 从本地存储中获取分类数据
   }
     /**
-   * [set_data 增加某一项]
+     * 设置分类数据
-   * @param {[type]} id [description]
+     * @param {Object} data - 要存储的数据对象
      */
     Xadmin.prototype.set_cate_data = function(data) {
-
+        if (typeof is_remember !== "undefined")
-    if(typeof is_remember!="undefined")
             return false;
 
         layui.data('cate', data);
     };
+
     /**
-	 * [del_data 删除某一项]
+     * 删除指定ID的数据
-	 * @param  {[type]} id [description]
+     * @param {String} id - 要删除的数据的键值
-	 * @return {[type]}    [description]
      */
     Xadmin.prototype.del_data = function(id) {
-		if(typeof is_remember!="undefined")
+        if (typeof is_remember !== "undefined")
             return false;
-		if(typeof id!="undefined"){
+
+        if (typeof id !== "undefined") {
             layui.data('tab_list', {
-			  key: id
+                key: id,
-			  ,remove: true
+                remove: true
             });
         } else {
             layui.data('tab_list', null);
         }
     };
+
     /**
-	 * [del_other_data 删除其它]
+     * 删除其他数据，只保留指定ID的数据
-	 * @param  {[type]} id [description]
+     * @param {String} id - 要保留的数据的键值
-	 * @return {[type]}    [description]
      */
     Xadmin.prototype.del_other_data = function(id) {
-		if(typeof is_remember!="undefined")
+        if (typeof is_remember !== "undefined")
             return false;
+
         var tab_list = this.get_data();
 
         layui.data('tab_list', null);
 
         layui.data('tab_list', {
-		  key: id
+            key: id,
-		  ,value: tab_list[id]
+            value: tab_list[id]
         });
     };
+
+// 初始化xadmin实例
     win.xadmin = new Xadmin();
 
 }(window);
@@ -199,7 +185,6 @@ layui.use(['layer','element','jquery'],function() {
     element = layui.element;
     $ = layui.jquery;
 
-
     // 打开页面初始
     xadmin.init();
 
@@ -208,26 +193,24 @@ layui.use(['layer','element','jquery'],function() {
         var id = $(this).parent().attr('lay-id');
         xadmin.del_data(id);
     });
-    //左侧菜单
-    $('.left-nav #nav').on('click', 'li', function(event) {
 
+    // 左侧菜单点击事件处理
+    $('.left-nav #nav').on('click', 'li', function(event) {
         if ($(this).parent().attr('id') == 'nav') {
-          xadmin.set_cate_data({key:'f1',value:$('.left-nav #nav li').index($(this))})
+            xadmin.set_cate_data({ key: 'f1', value: $('.left-nav #nav li').index($(this)) });
-          xadmin.set_cate_data({key:'f2',value:null})
+            xadmin.set_cate_data({ key: 'f2', value: null });
-          xadmin.set_cate_data({key:'f3',value:null})
+            xadmin.set_cate_data({ key: 'f3', value: null });
         }
 
         if ($(this).parent().parent().parent().attr('id') == 'nav') {
-          xadmin.set_cate_data({key:'f2',value:$('.left-nav #nav li').index($(this))})
+            xadmin.set_cate_data({ key: 'f2', value: $('.left-nav #nav li').index($(this)) });
-          xadmin.set_cate_data({key:'f3',value:null})
+            xadmin.set_cate_data({ key: 'f3', value: null });
         }
 
         if ($(this).parent().parent().parent().parent().parent().attr('id') == 'nav') {
-          xadmin.set_cate_data({key:'f3',value:$('.left-nav #nav li').index($(this))})
+            xadmin.set_cate_data({ key: 'f3', value: $('.left-nav #nav li').index($(this)) });
         }
 
-
-
         if ($('.left-nav').css('width') == '60px') {
             $('.left-nav').animate({ width: '220px' }, 100);
             $('.page-content').animate({ left: '220px' }, 100);
@@ -257,19 +240,21 @@ layui.use(['layer','element','jquery'],function() {
             }
         }
         event.stopPropagation();
-    })
+    });
+
     var left_tips_index = null;
     $('.left-nav #nav').on('mouseenter', '.left-nav-li', function(event) {
         if ($('.left-nav').css('width') != '220px') {
             var tips = $(this).attr('lay-tips');
             left_tips_index = layer.tips(tips, $(this));
         }
-    })
+    });
 
     $('.left-nav #nav').on('mouseout', '.left-nav-li', function(event) {
         layer.close(left_tips_index);
-    })
+    });
-    // 隐藏左侧
+
+    // 隐藏左侧导航栏
     $('.container .left_open i').click(function(event) {
         if ($('.left-nav').css('width') == '220px') {
             $('.left-nav .open').click();
@@ -339,8 +324,11 @@ layui.use(['layer','element','jquery'],function() {
 * to work around bugs in some JS interpreters.
 */
 function safeAdd (x, y) {
+    // 将 x 和 y 分别限制在 16 位，然后相加
     var lsw = (x & 0xffff) + (y & 0xffff)
+    // 计算高位部分的和，并考虑低位部分可能产生的进位
     var msw = (x >> 16) + (y >> 16) + (lsw >> 16)
+    // 返回合并后的 32 位结果
     return (msw << 16) | (lsw & 0xffff)
 }
 
@@ -348,6 +336,7 @@ return (msw << 16) | (lsw & 0xffff)
  * Bitwise rotate a 32-bit number to the left.
  */
 function bitRotateLeft (num, cnt) {
+    // 使用位移操作实现循环左移
     return (num << cnt) | (num >>> (32 - cnt))
 }
 
@@ -355,18 +344,23 @@ return (num << cnt) | (num >>> (32 - cnt))
  * These functions implement the four basic operations the algorithm uses.
  */
 function md5cmn (q, a, b, x, s, t) {
+    // 执行 MD5 算法中的一个基本操作
     return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b)
 }
 function md5ff (a, b, c, d, x, s, t) {
+    // 执行 MD5 算法中的 F 函数操作
     return md5cmn((b & c) | (~b & d), a, b, x, s, t)
 }
 function md5gg (a, b, c, d, x, s, t) {
+    // 执行 MD5 算法中的 G 函数操作
     return md5cmn((b & d) | (c & ~d), a, b, x, s, t)
 }
 function md5hh (a, b, c, d, x, s, t) {
+    // 执行 MD5 算法中的 H 函数操作
     return md5cmn(b ^ c ^ d, a, b, x, s, t)
 }
 function md5ii (a, b, c, d, x, s, t) {
+    // 执行 MD5 算法中的 I 函数操作
     return md5cmn(c ^ (b | ~d), a, b, x, s, t)
 }
 
@@ -375,8 +369,10 @@ return md5cmn(c ^ (b | ~d), a, b, x, s, t)
  */
 function binlMD5 (x, len) {
     /* append padding */
+    // 添加填充数据，使数据长度满足要求
     x[len >> 5] |= 0x80 << (len % 32)
-x[((len + 64) >>> 9 << 4) + 14] = len
+    // 添加原始数据长度信息（以位为单位）
+    x[(((len + 64) >>> 9) << 4) + 14] = len
 
     var i
     var olda
@@ -389,11 +385,13 @@ var c = -1732584194
     var d = 271733878
 
     for (i = 0; i < x.length; i += 16) {
+        // 保存当前状态
         olda = a
         oldb = b
         oldc = c
         oldd = d
 
+        // 执行 MD5 算法的主循环，处理每个块的数据
         a = md5ff(a, b, c, d, x[i], 7, -680876936)
         d = md5ff(d, a, b, c, x[i + 1], 12, -389564586)
         c = md5ff(c, d, a, b, x[i + 2], 17, 606105819)
@@ -425,7 +423,7 @@ for (i = 0; i < x.length; i += 16) {
         b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501)
         a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467)
         d = md5gg(d, a, b, c, x[i + 2], 9, -51403784)
-  c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473)
+        c = md5gg(c, d, a, b, x[i + 7], 14, 173537119)
         b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734)
 
         a = md5hh(a, b, c, d, x[i + 5], 4, -378558)
@@ -437,7 +435,7 @@ for (i = 0; i < x.length; i += 16) {
         c = md5hh(c, d, a, b, x[i + 7], 16, -155497632)
         b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640)
         a = md5hh(a, b, c, d, x[i + 13], 4, 681279174)
-  d = md5hh(d, a, b, c, x[i], 11, -358537222)
+        d = md5hh(d, a, b, c, x[i + 0], 11, -358537222)
         c = md5hh(c, d, a, b, x[i + 3], 16, -722521979)
         b = md5hh(b, c, d, a, x[i + 6], 23, 76029189)
         a = md5hh(a, b, c, d, x[i + 9], 4, -640364487)
@@ -467,115 +465,124 @@ for (i = 0; i < x.length; i += 16) {
         c = safeAdd(c, oldc)
         d = safeAdd(d, oldd)
     }
+
     return [a, b, c, d]
 }
 
 /*
 * Convert an array of little-endian words to a string
 */
+/*
+ * 将小端序的字数组转换为字符串
+ */
 function binl2rstr (input) {
-var i
+    var i;
-var output = ''
+    var output = '';
-var length32 = input.length * 32
+    var length32 = input.length * 32; // 计算输入数组的总位数
     for (i = 0; i < length32; i += 8) {
-  output += String.fromCharCode((input[i >> 5] >>> (i % 32)) & 0xff)
+        // 从输入数组中提取每个字节并转换为字符
+        output += String.fromCharCode((input[i >> 5] >>> (i % 32)) & 0xff);
     }
-return output
+    return output;
 }
 
 /*
-* Convert a raw string to an array of little-endian words
+ * 将原始字符串转换为小端序的字数组
-* Characters >255 have their high-byte silently ignored.
+ * 字符值大于255的高字节将被忽略。
  */
 function rstr2binl (input) {
-var i
+    var i;
-var output = []
+    var output = [];
-output[(input.length >> 2) - 1] = undefined
+    output[(input.length >> 2) - 1] = undefined; // 确保输出数组有足够的空间
     for (i = 0; i < output.length; i += 1) {
-  output[i] = 0
+        output[i] = 0; // 用零初始化输出数组
     }
-var length8 = input.length * 8
+    var length8 = input.length * 8; // 计算输入字符串的总位数
     for (i = 0; i < length8; i += 8) {
-  output[i >> 5] |= (input.charCodeAt(i / 8) & 0xff) << (i % 32)
+        // 将每个字符打包到输出数组中作为小端序字
+        output[i >> 5] |= (input.charCodeAt(i / 8) & 0xff) << (i % 32);
     }
-return output
+    return output;
 }
 
 /*
-* Calculate the MD5 of a raw string
+ * 计算原始字符串的MD5哈希值
  */
 function rstrMD5 (s) {
-return binl2rstr(binlMD5(rstr2binl(s), s.length * 8))
+    return binl2rstr(binlMD5(rstr2binl(s), s.length * 8)); // 将原始字符串转换为二进制，进行哈希运算，然后转换回原始字符串
 }
 
 /*
-* Calculate the HMAC-MD5, of a key and some data (raw strings)
+ * 计算HMAC-MD5（密钥和数据）
  */
 function rstrHMACMD5 (key, data) {
-var i
+    var i;
-var bkey = rstr2binl(key)
+    var bkey = rstr2binl(key); // 将密钥转换为二进制数组
-var ipad = []
+    var ipad = [];
-var opad = []
+    var opad = [];
-var hash
+    var hash;
-ipad[15] = opad[15] = undefined
+    ipad[15] = opad[15] = undefined; // 确保ipad和opad数组有足够的空间
     if (bkey.length > 16) {
-  bkey = binlMD5(bkey, key.length * 8)
+        bkey = binlMD5(bkey, key.length * 8); // 如果密钥长度超过16个字，先对其进行哈希运算
     }
     for (i = 0; i < 16; i += 1) {
-  ipad[i] = bkey[i] ^ 0x36363636
+        ipad[i] = bkey[i] ^ 0x36363636; // 使用ipad常量对密钥进行异或操作
-  opad[i] = bkey[i] ^ 0x5c5c5c5c
+        opad[i] = bkey[i] ^ 0x5c5c5c5c; // 使用opad常量对密钥进行异或操作
     }
-hash = binlMD5(ipad.concat(rstr2binl(data)), 512 + data.length * 8)
+    hash = binlMD5(ipad.concat(rstr2binl(data)), 512 + data.length * 8); // 对内填充的密钥和数据进行哈希运算
-return binl2rstr(binlMD5(opad.concat(hash), 512 + 128))
+    return binl2rstr(binlMD5(opad.concat(hash), 512 + 128)); // 对外填充的密钥和之前的哈希结果进行哈希运算，然后转换为原始字符串
 }
 
 /*
-* Convert a raw string to a hex string
+ * 将原始字符串转换为十六进制字符串
  */
 function rstr2hex (input) {
-var hexTab = '0123456789abcdef'
+    var hexTab = '0123456789abcdef'; // 十六进制字符表
-var output = ''
+    var output = '';
-var x
+    var x;
-var i
+    var i;
     for (i = 0; i < input.length; i += 1) {
-  x = input.charCodeAt(i)
+        x = input.charCodeAt(i); // 获取每个字符的ASCII码
-  output += hexTab.charAt((x >>> 4) & 0x0f) + hexTab.charAt(x & 0x0f)
+        output += hexTab.charAt((x >>> 4) & 0x0f) + hexTab.charAt(x & 0x0f); // 将每个字符转换为其十六进制表示
     }
-return output
+    return output;
 }
 
 /*
-* Encode a string as utf-8
+ * 将字符串编码为UTF-8格式
  */
 function str2rstrUTF8 (input) {
-return unescape(encodeURIComponent(input))
+    return unescape(encodeURIComponent(input)); // 将输入字符串编码为UTF-8格式
 }
 
 /*
-* Take string arguments and return either raw or hex encoded strings
+ * 接受字符串参数并返回原始或十六进制编码的字符串
  */
 function rawMD5 (s) {
-return rstrMD5(str2rstrUTF8(s))
+    return rstrMD5(str2rstrUTF8(s)); // 将输入字符串转换为原始格式并计算其MD5哈希值
 }
 function hexMD5 (s) {
-return rstr2hex(rawMD5(s))
+    return rstr2hex(rawMD5(s)); // 将输入字符串转换为原始格式，计算其MD5哈希值，然后转换为十六进制格式
 }
 function rawHMACMD5 (k, d) {
-return rstrHMACMD5(str2rstrUTF8(k), str2rstrUTF8(d))
+    return rstrHMACMD5(str2rstrUTF8(k), str2rstrUTF8(d)); // 将密钥和数据转换为原始格式，计算它们的HMAC-MD5哈希值，并返回原始结果
 }
 function hexHMACMD5 (k, d) {
-return rstr2hex(rawHMACMD5(k, d))
+    return rstr2hex(rawHMACMD5(k, d)); // 将密钥和数据转换为原始格式，计算它们的HMAC-MD5哈希值，转换为十六进制格式，并返回十六进制结果
 }
 
+/*
+ * 根据提供的参数计算MD5或HMAC-MD5的主函数
+ */
 function md5 (string, key, raw) {
-if (!key) {
+    if (!key) { // 如果没有提供密钥，计算输入字符串的MD5哈希值
         if (!raw) {
-    return hexMD5(string)
+            return hexMD5(string); // 返回十六进制编码的MD5哈希值
         }
-  return rawMD5(string)
+        return rawMD5(string); // 返回原始MD5哈希值
     }
-if (!raw) {
+    if (!raw) { // 如果提供了密钥，使用密钥计算输入字符串的HMAC-MD5哈希值
-  return hexHMACMD5(key, string)
+        return hexHMACMD5(key, string); // 返回十六进制编码的HMAC-MD5哈希值
     }
-return rawHMACMD5(key, string)
+    return rawHMACMD5(key, string);
 }