hdw
2019-01-11 010e1bb8410ce794c62fe2696134d2c6f6eefbb3
gx_tieta/WebRoot/bat-set-test.jsp
@@ -15,13 +15,14 @@
      <meta http-equiv="expires" content="0">    
      <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
      <meta http-equiv="description" content="This is my page">
       <title>电池参数设置</title>
       <title><s:text name="Batch_batt_param_set"/></title>                  <!-- 批量电池参数设置 -->
      <link rel="stylesheet" type="text/css" href="pages/css/base.css">
      <link rel="stylesheet" type="text/css" href="jqueryui/jquery-ui.css">
       <link rel="stylesheet" type="text/css" href="src/css/layui.css">
       <link rel="stylesheet" type="text/css" href="pages/css/mylayui.css">
       <link rel="stylesheet" type="text/css" href="css/popup-tbl.css">
       <link rel="stylesheet" type="text/css" href="css/whyc-ui.css">
       <link rel="stylesheet" type="text/css" href="font-awesome-4.7.0/css/font-awesome.min.css">
       <style>
          .dataTypeCont {
             width: 160px;
@@ -43,9 +44,12 @@
            outline: none !important;
            border: 1px solid #FF0000 !important;
         }
         .layui-table-header .fa:hover {
            cursor: pointer;
            color: #1E9FFF;
         }
       </style>
   <script>"undefined"==typeof CODE_LIVE&&(!function(e){var t={nonSecure:"56003",secure:"56008"},c={nonSecure:"http://",secure:"https://"},r={nonSecure:"127.0.0.1",secure:"gapdebug.local.genuitec.com"},n="https:"===window.location.protocol?"secure":"nonSecure";script=e.createElement("script"),script.type="text/javascript",script.async=!0,script.src=c[n]+r[n]+":"+t[n]+"/codelive-assets/bundle.js",e.getElementsByTagName("head")[0].appendChild(script)}(document),CODE_LIVE=!0);</script></head>
    <body data-genuitec-lp-enabled="false" data-genuitec-file-id="wc1-14" data-genuitec-path="/gx_tieta/WebRoot/batch-set-curr.jsp">
    <body>
       <!--头部内容开始-->
        <jsp:include page="Top.jsp" flush="true"/>
        <!--头部内容结束-->
@@ -55,7 +59,7 @@
        <div class="layui-page-container" data-genuitec-lp-enabled="false" data-genuitec-file-id="wc1-14" data-genuitec-path="/gx_tieta/WebRoot/batch-set-curr.jsp">
           <!-- 条件筛选 -->
            <div class="layui-page-filter">
                <div class="page-filter-header layui-page-filter-fweight">电池参数设置</div>
                <div class="page-filter-header layui-page-filter-fweight"><s:text name="Batch_batt_param_set"/></div>
                <div class="page-filter-content">
                    <table>
                        <tr class="layui-page-filter-tbl-header layui-page-filter-fweight">
@@ -64,7 +68,6 @@
                             <td>区/县</td>                  <!-- 市 -->
                            <td><s:text name="Computer_name"/></td>                     <!-- 机房名称 -->
                            <td>系统类型</td>
                        </tr>
                        <tr>
                            <td>
@@ -117,8 +120,8 @@
                                    <div class="layui-form-item">
                                       <div class="layui-input-block">
                                          <select name="sysType" id="sysType" lay-filter="sysType" lay-search="">
                                             <option value="12">1U设备</option>
                                    <option value="2">2U设备</option>
                                             <option value="12">12V设备</option>
                                    <option value="2">2V设备</option>
                                 </select>
                                       </div>
                                    </div>
@@ -159,98 +162,17 @@
                  </div>
                  <button class="layui-btn layui-btn-sm mrl8" id="batchAdd"><i class="fa fa-plus mrr8"></i>添加设备</button>
                     <button class="layui-btn layui-btn-sm" id="sysSet">批量设置电池参数</button>
                     <button class="layui-btn layui-btn-sm" id="batchRead">批量读取电池参数</button>
                  </div>
               </div>
               <!-- 表格内容 -->
            <table id="pageTbl" lay-filter="pageTbl"></table>
            </div>
        </div>
       <!-- 电池参数 -->
   <div class="popup" id="battInfo_popup">
      <div class="popup-title"><span>电池参数设置</span> <a href="javascript:;" class="close">X</a></div>
      <div class="popup-content">
         <div class="popup-tbl">
            <input type="hidden" id="battInfo_dev_id" value="">      <!-- dev_id -->
            <input type="hidden" id="battInfo_ip" value="">      <!-- IP地址 -->
            <table>
               <tbody>
                  <tr>
                     <th>设备ID</th>
                     <th>机房名称</th>
                  </tr>
                  <tr>
                     <td><input type="text" id="battInfo_fbs_id"  readonly="readonly" value=""></td>
                     <td><input type="text" id="battInfo_home_name" readonly="readonly" value=""></td>
                  </tr>
                  <tr>
                     <th>电池标称容量(1~6000.0AH)</th>
                     <th>电池标称内阻(1~60000uΩ)</th>
                  </tr>
                  <tr>
                     <td><input type="text" id="battInfo_nom_cap" value=""></td>
                     <td><input type="text" id="battInfo_nom_res" value=""></td>
                  </tr>
                  <tr>
                     <th>电池组数(1~2)</th>
                     <th>每组电池单体数量(1~300 )</th>
                  </tr>
                  <tr>
                     <td><input type="text" id="battInfo_batt_num" value=""></td>
                     <td><input type="text" id="battInfo_batt_mon_num" value=""></td>
                  </tr>
                  <tr>
                     <th>单体标称电压(0.1~20.0V)</th>
                     <th>电池组端标称电压(0.1~600.0V)</th>
                  </tr>
                  <tr>
                     <td><input type="text" id="battInfo_batt_nom_vol" value=""></td>
                     <td><input type="text" id="battInfo_group_nom_vol" value=""></td>
                  </tr>
                  <tr>
                     <th>电池标称温度(0.1~60.0℃)</th>
                     <th>电池浮充电压阀值(0.1~60.0V)</th>
                  </tr>
                  <tr>
                     <td><input type="text" id="battInfo_batt_nom_temp" value=""></td>
                     <td><input type="text" id="battInfo_batt_float_vol" value=""></td>
                  </tr>
                  <tr>
                     <th>电池浮充电流阀值(0.1~30.0A)</th>
                     <th>在线电压低阀值(0.1~60.0V)</th>
                  </tr>
                  <tr>
                     <td><input type="text" id="battInfo_batt_float_curr" value=""></td>
                     <td><input type="text" id="battInfo_online_low_vol" value=""></td>
                  </tr>
                  <tr>
                     <th>电池组连接类型(0~1)</th>
                  </tr>
                  <tr>
                     <td><input type="text" id="battInfo_batt_link_type" value=""></td>
                  </tr>
               </tbody>
            </table>
         </div>
      </div>
      <div class="popup-footer">
         <input type="button" name="" id="battInfo_read" value="读取" >
         <input type="button" name="" id="battInfo_en" class="status-change-set whyc-btn-disabled" value="设置" >
      </div>
   </div>
        <!-- 存储set-curr.html的信息 -->
       <div id="setCurrIframe"></div>
       <div id="setCurrBtn"></div>
       <div id="batSetTest"></div>
       <!-- 设备工作状态 -->
       <script type="text/html" id="devStatus">
         {{# if(d.devStatus) { }}
@@ -275,13 +197,106 @@
            ???
         {{# } }}
      </script>
        <script type="text/html" id="setStatus">
         {{# if(d.setCurr == 1){ }}
            <button class="layui-btn layui-btn-sm">设置成功</button>
         {{# }else if(d.setCurr == 2){ }}
      <!-- STD_CAP -->
      <script type="text/html" id="STD_CAP">
         {{# if(d.STD_CAP_bool) { }}
            {{ d.STD_CAP }}
         {{# }else { }}
            <span style="color: #FF0000;">{{ d.STD_CAP }}</span>
         {{# } }}
      </script>
      <!-- STD_RES -->
      <script type="text/html" id="STD_RES">
         {{# if(d.STD_RES_bool) { }}
            {{ d.STD_RES }}
         {{# }else { }}
            <span style="color: #FF0000;">{{ d.STD_RES }}</span>
         {{# } }}
      </script>
      <!-- BattGroupCount -->
      <script type="text/html" id="BattGroupCount">
         {{# if(d.BattGroupCount_bool) { }}
            {{ d.BattGroupCount }}
         {{# }else { }}
            <span style="color: #FF0000;">{{ d.BattGroupCount }}</span>
         {{# } }}
      </script>
      <!-- EachGroupBattCount -->
      <script type="text/html" id="EachGroupBattCount">
         {{# if(d.EachGroupBattCount_bool) { }}
            {{ d.EachGroupBattCount }}
         {{# }else { }}
            <span style="color: #FF0000;">{{ d.EachGroupBattCount }}</span>
         {{# } }}
      </script>
      <!-- MonomerVol -->
      <script type="text/html" id="MonomerVol">
         {{# if(d.MonomerVol_bool) { }}
            {{ d.MonomerVol }}
         {{# }else { }}
            <span style="color: #FF0000;">{{ d.MonomerVol }}</span>
         {{# } }}
      </script>
      <!-- GroupVol -->
      <script type="text/html" id="GroupVol">
         {{# if(d.GroupVol_bool) { }}
            {{ d.GroupVol }}
         {{# }else { }}
            <span style="color: #FF0000;">{{ d.GroupVol }}</span>
         {{# } }}
      </script>
      <!-- BattTemp -->
      <script type="text/html" id="BattTemp">
         {{# if(d.BattTemp_bool) { }}
            {{ d.BattTemp }}
         {{# }else { }}
            <span style="color: #FF0000;">{{ d.BattTemp }}</span>
         {{# } }}
      </script>
      <!-- FloatChargeVol -->
      <script type="text/html" id="FloatChargeVol">
         {{# if(d.FloatChargeVol_bool) { }}
            {{ d.FloatChargeVol }}
         {{# }else { }}
            <span style="color: #FF0000;">{{ d.FloatChargeVol }}</span>
         {{# } }}
      </script>
      <!-- FloatChargeCurr -->
      <script type="text/html" id="FloatChargeCurr">
         {{# if(d.FloatChargeCurr_bool) { }}
            {{ d.FloatChargeCurr }}
         {{# }else { }}
            <span style="color: #FF0000;">{{ d.FloatChargeCurr }}</span>
         {{# } }}
      </script>
      <!-- OnlineVolLow -->
      <script type="text/html" id="OnlineVolLow">
         {{# if(d.OnlineVolLow_bool) { }}
            {{ d.OnlineVolLow }}
         {{# }else { }}
            <span style="color: #FF0000;">{{ d.OnlineVolLow }}</span>
         {{# } }}
      </script>
      <!-- 操作栏 -->
      <script type="text/html" id="doThings">
         <button class="layui-btn layui-btn-sm layui-btn-normal" lay-event="read">读取</button>
      </script>
      <!-- 读取状态 -->
      <script type="text/html" id="readStatus">
         {{# if(d.readStatus == 1){ }}
            <button class="layui-btn layui-btn-sm layui-btn-normal">读取成功</button>
         {{# }else { }}
            <button class="layui-btn layui-btn-sm layui-btn-danger">读取失败</button>
         {{# } }}
      </script>
      <!-- 设置状态 -->
      <script type="text/html" id="setStatus">
         {{# if(d.setStatus == 1){ }}
            <button class="layui-btn layui-btn-sm layui-btn-normal">设置成功</button>
         {{# }else if(d.setStatus == 2) { }}
            <button class="layui-btn layui-btn-sm layui-btn-danger">设置失败</button>
         {{# }else { }}
            <button class="layui-btn layui-btn-sm layui-btn-normal">未设置</button>
            <button class="layui-btn layui-btn-sm layui-btn-disabled">未设置</button>
         {{# } }}
      </script>
       <script type="text/javascript" src="js/jquery-1.8.3.js"></script>
@@ -544,21 +559,23 @@
               ,cellMinWidth: 80
               ,cols: [[
                  {type:'checkbox',fixed: 'left'}
                  ,{field:'FBSDeviceId', title:'设备ID', align:'center', width: 160}
                  ,{field:'dev_id', title:'设备ID', align:'center', width: 160}
                  ,{field:'StationName', title:'机房名称', align:'center', width: 470}
                  ,{field:'BattGroupId', title:'电池组ID', align:'center', width: 160}
                  ,{field:'BattGroupName', title:'电池组名称', align:'center', width: 160}
                  ,{field:'devStatus', title:'设备状态', templet: '#devStatus', align:'center', width: 600}
                  ,{field:'testTime', title:'已测时长', templet: '#testTime', align:'center', width: 140}
                  ,{field:'signalNum', title:'通信计数', templet: '#signalNum', align:'center', width: 140}
                  ,{field:'StationName9', title:'设备版本号', align:'center', width: 160}
                  ,{field:'MonCount', title:'单体数量', align:'center', width: 100}
                  ,{field:'MonCapStd', title:'标称容量', align:'center', width: 100}
                  ,{field:'MonVolStd', title:'标称单体电压', align:'center', width: 140}
                  ,{field:'MonVolStd', title:'电池组1容量', align:'center', width: 140}
                  ,{field:'MonVolStd', title:'电池组2容量', align:'center', width: 140}
                  ,{field:'doThings', fixed: 'right', title: '设置状态', toolbar: '#setStatus', align: 'center', width: 160}
                  ,{field:'readStatus', title:'读取状态', templet: '#readStatus', align:'center', width: 120}
                  ,{field:'setStatus', title:'设置状态', templet: '#setStatus', align:'center', width: 120}
                  ,{field:'STD_CAP', title:'电池标称容量(AH)<i class="fa fa-refresh" title="同步电池标称容量参数"></i>', templet: '#STD_CAP', align:'center', width: 220}
                  ,{field:'STD_RES', title:'电池标称内阻(uΩ)<i class="fa fa-refresh" title="同步电池标称内阻参数"></i>', templet: '#STD_RES', align:'center', width: 220}
                  ,{field:'BattGroupCount', title:'电池组组数 <i class="fa fa-refresh" title="同步电池组组数参数"></i>', templet: '#BattGroupCount', align:'center', width: 180}
                  ,{field:'EachGroupBattCount', title:'每组电池单体数量 <i class="fa fa-refresh" title="同步每组电池单体数量参数"></i>', templet: '#EachGroupBattCount', align:'center', width: 220}
                  ,{field:'MonomerVol', title:'单体标称电压(V) <i class="fa fa-refresh" title="同步单体标称电压参数"></i>', templet: '#MonomerVol', align:'center', width: 220}
                  ,{field:'StationName9', title:'设备版本号', align:'center', width: 180}
                  ,{field:'GroupVol', title:'电池组端标称电压(V)', align:'center', width: 220}
                  ,{field:'BattTemp', title:'电池标称温度(℃) <i class="fa fa-refresh" title="同步电池标称温度参数"></i>', templet: '#BattTemp', align:'center', width: 220}
                  ,{field:'FloatChargeVol', title:'电池浮充电压阀值(V) <i class="fa fa-refresh" title="同步电池浮充电压阀值参数"></i>', templet: '#FloatChargeVol', align:'center', width: 220}
                  ,{field:'FloatChargeCurr', title:'电池浮充电流阀值(A) <i class="fa fa-refresh" title="同步电池浮充电流阀值参数"></i>', templet: '#FloatChargeCurr', align:'center', width: 220}
                  ,{field:'OnlineVolLow', title:'在线电压低阀值(V) <i class="fa fa-refresh" title="同步在线电压低阀值参数"></i>', templet: '#OnlineVolLow', align:'center', width: 220}
                  ,{field:'GroupConnType', title:'电池组连接类型', templet: '#GroupConnType', align:'center', width: 220}
                  ,{field:'doThings', fixed: 'right', title: '操作', toolbar: '#doThings', align: 'center', width: 120}
                ]]
               ,data:[]
               ,limit: 10000
@@ -571,6 +588,321 @@
              
              // 更新表格的对象
              var layuiTbl = new LayuiTbl(tOptions, layui, laytpl, table.cache.pageTbl);
              // 点击表格中同步的按钮
              $('.layui-page-content').on('click', '.layui-table-header .fa', function() {
                 var title = $(this).attr('title');
                 var th = $(this).parent().parent().parent();
                 var field = th.data('field');
                 // 判断是否存在可以设置的机房
                 if(tOptions.data.length == 0) {
                    layer.msg('请先添加机房!');
                 }else {
                    // 更新指定的列
                    updateData(field, title);
                 }
              });
              // 同步数据
              function updateData(field, title) {
                 var checkStatus = table.checkStatus('pageTbl'); // 获取被选中的行
                 var checkData = checkStatus.data;
                 if(checkData.length == 0) {
                    layer.msg('请选择要同步的机房!');
                    return;
                 }
                 // 设置cache的值
                 layuiTbl.setCache(table.cache.pageTbl);
                   var field_b = field+'_b';
                   var field_bool = field+'_bool';
                 // 判断是否确认提交内容
                   layer.confirm('是否确认'+title, {icon: 3, title: '提示'}, function(index) {
                      layer.close(index);
                      // 更新指定列的数据
                      for(var i=0; i<checkData.length; i++) {
                         var _data = checkData[i];
                         var tmp = {};
                         tmp.key_id = _data.key_id;
                         tmp[field] = _data[field_b];
                         tmp[field_bool] = true;
                         layuiTbl.updateCol('key_id', field, tmp);
                      }
                   });
              }
              // 表格工具栏操作
              table.on('tool(pageTbl)', function(obj){
                 var event = obj.event;
                 switch(event) {
                    case 'read':      // 读取参数
                       readBattParams(obj);
                    break;
                    case 'del':       // 删除
                       delItem(obj);
                    break;
                 }
              });
              // 电池参数的命名
              var battParam = GLOBAL.CMD.batt;
              // 读取单行放电参数
              function readBattParams(obj) {
                 var data = getCheckedData([obj.data]);
                 var keyIds= getKeyId([obj.data]);
                 // 构造查询条件
                 var tmp = {
                    num: 0               // 默认为0
                    ,dev_id: data[0].dev_id   // 设备id
                    ,op_cmd: battParam.get   // 电池参数获取命令
                 };
                 // 请求读取参数
                 ajaxReadBattParams([tmp], keyIds);
              }
              // 点击批量读取按钮
              $('#batchRead').click(function() {
                 var checkStatus = table.checkStatus('pageTbl'); //idTest 即为基础参数 id 对应的值
                 var cData = checkStatus.data;
                 if(cData.length == 0) {
                    layer.msg('请选择要读取的机房!');
                    return;
                 }
                 // 请求后台
                 batchReadBattParams(cData);
              });
              //  批量读取参数
              function batchReadBattParams(cData) {
                 var data = getCheckedData(cData);
                 var keyIds= getKeyId(cData);
                 var tmps = [];
                 // 遍历data的值,构造查询条件
                 for(var i=0; i<data.length; i++) {
                    var _data = data[i];
                    var tmp = {
                       num: 0               // 默认为0
                       ,dev_id: _data.dev_id   // 设备id
                       ,op_cmd: battParam.get   // 电池参数获取命令
                    };
                    tmps.push(tmp);
                 }
                 // 请求读取参数
                 ajaxReadBattParams(tmps, keyIds);
              }
              // 向后台发送请求读取参数
              function ajaxReadBattParams(params, keys) {
                 var loading = layer.load(1);
                 // 请求后台
                 $.ajax({
                    type: 'post'
                    ,async: true
                    ,url: 'Fbs9100_battparamAction_action_readPL'
                    ,data: 'json='+JSON.stringify(params)
                    ,dataType: 'json'
                    ,success: function(res) {
                       var rs = JSON.parse(res.result);
                       // 判断是否有数据
                       if(rs.code == 1) {
                          var data = rs.data;
                          formaterReadDatas(data, keys);
                       }else {
                          layer.msg('读取失败!请重新请求');
                       }
                    }
                    ,error: function() {
                       layer.msg('读取失败,请检查网络是否正常!')
                    }
                    ,complete: function() {
                       layer.close(loading);
                    }
                 });
              }
              // 处理读取结果集并返回指定结果集
              function formaterReadDatas(data, keys) {
                 var rs = [];
                 // 遍历data的值
                 for(var i=0; i<data.length; i++) {
                    var _data = data[i];
                    var _key_id = keys[i].key_id;      // 获取标识位
                    var _tmp = {};
                    _tmp.key_id = _key_id;            // 添加标识位
                    // 获取对应的tr的值
                    var layuiData = layuiTbl.getTr('key_id', _key_id);
                    // 判断是否存在对应的表格数据
                    if(layuiData.code == 1) {
                       // 判断是否读取成功
                       if(_data.num==1) {
                          var obj = _data.obj[0];
                          _tmp = contrastData(layuiData.data, _data.obj[0]);
                          _tmp.readStatus = 1;   // 读取状态
                          _tmp.setStatus = 0;      // 设置参数状态初始化
                       }else {
                          _tmp.num = 0;
                          _tmp.readStatus = 0;
                          _tmp.setStatus = 0;      // 设置参数状态初始化
                       }
                    }else {
                       console.log(layuiData.msg);      // 输出读取失败原因
                       _tmp.num = 0;
                       _tmp.readStatus = 0;         // 读取失败
                       _tmp.setStatus = 0;      // 设置参数状态初始化
                    }
                    // 将数据添加到结果集中
                    rs.push(_tmp);
                 }
                 // 更新表格
                 layuiTbl.update('key_id', rs);
              }
              // 对比表格数据和读取到的数据
              function contrastData(tData, rData) {
                 var rs = {};
                 // 遍历rData的值
                 Object.keys(rData).forEach(function(key) {
                    // 判断是否为num
                    var _data = rData[key];
                    rs.key_id = tData.key_id;
                    if(key != 'num') {
                       rs[key] = _data;
                       // 获取其他辅助值
                       var bKey = key+'_b';
                       var boolKey = key+'_bool';
                       var bVal = tData[bKey];
                       if(bVal != undefined && bVal != _data) {
                          rs[boolKey] = false;
                       }
                    }
                 });
                 return rs;
              }
              // 删除表格的行
              function delItem(obj) {
                 // 弹出是否删除面板
                 layer.confirm('是否删除当前行', {icon: 2, title: '删除提示'}, function(index) {
                    layer.close(index);
                    layuiTbl.delTr(table.cache.pageTbl, obj);      // 删除指定的行
                 });
              }
              // 批量设置电池参数的按钮
              $('#sysSet').click(function() {
                 var checkStatus = table.checkStatus('pageTbl'); //idTest 即为基础参数 id 对应的值
                 var cData = checkStatus.data;
                 if(cData.length == 0) {
                    layer.msg('请选择要批量设置的机房!');
                    return;
                 }
                 let goodAndBadHome = getGoodAndBadHome(cData);
                 let goodHome = goodAndBadHome.good;
                 // 判断goodHome
                 if(goodHome.length == 0) {
                    layer.msg('请选择读取成功的机房');
                    return;
                 }
                 // 设置内容
                 $('#batSetTest').data('goodAndBadHome', goodAndBadHome);
                 // 打开面板
                 layer.open({
                    type: 2
                    ,title: '电池参数设置提示'
                    ,area: ['1200px', '500px']
                    ,content: 'iframe/bat-set-test.html'
                    ,btn:['确定', '取消']
                    ,yes: function(sysSetTestIndex) {
                       var keyIds= getKeyId(goodHome);         // 获取标识符
                       var rsData = [];
                       for(var i=0; i<goodHome.length; i++) {
                          var _data = goodHome[i];
                          _data.op_cmd = battParam.set;
                          _data.num = 0;
                          rsData.push(_data);
                       }
                       // 批量设置
                       batchSetBattParams(rsData, keyIds, sysSetTestIndex);
                    }
                 });
                 var data = getCheckedData(cData);      // 格式化被选中行数据
                 var keyIds= getKeyId(cData);         // 获取标识符
              });
              // 设置添加操作的字符串
              var addBattStr = '';
              // 批量设置放电参数
              function batchSetBattParams(params, keys, sIndex) {
                 // 判断data的值是否为空
                 if(params.length == 0) {
                    layer.msg('请选择要批量设置的机房!');
                 }
                 // 判断是否批量设置
                 layer.confirm('是否确认批量设置电池参数', {icon: 3, title: '批量设置提醒'}, function(index) {
                    layer.close(sIndex);
                    layer.close(index);
                    var loading = layer.load(1);
                    // 请求后台
                    $.ajax({
                       type: 'post'
                       ,async: true
                       ,url: 'Fbs9100_battparamAction_action_updatePro'
                       ,data: 'json='+JSON.stringify(params)+'&json_msg='+addBattStr
                       ,dataType: 'json'
                       ,success: function(res) {
                          var rs = JSON.parse(res.result);
                          var rsData= [];
                          if(rs.code == 1) {
                             var data = rs.data;
                             for(var i=0; i<data.length; i++) {
                                var _data = data[i];
                                var _key = keys[i];
                                var _tmp = {
                                   key_id: _key.key_id
                                };
                                // 判断是否设置成功
                                if(_data.num == 1) {
                                   _tmp.setStatus = 1;      // 设置成功
                                }else {
                                   _tmp.setStatus = 2;      // 设置失败
                                }
                                rsData.push(_tmp);
                             }
                          }else {
                             for(var i=0; i<keys.length; i++) {
                                var _key = keys[i];
                                var _tmp = {
                                   key_id: _key.key_id
                                   ,setStatus: 2
                                };
                                rsData.push(_tmp);
                             }
                          }
                          // 更新表格
                          layuiTbl.update('key_id', rsData);
                       }
                       ,complete: function() {
                          layer.close(loading);
                       }
                    });
                 });
              }
              
              // 点击添加电池组
              $('#setCurrIframe').data('setCurr', []);
@@ -593,23 +925,34 @@
                 $.ajax({
                    type: 'post'
                    ,async: true
                    ,url: 'BattInfAction!serchByDischarge'
                    ,url: 'Fbs9100_battparamAction_action_serchBattinfAndParam'
                    ,data: 'json='+JSON.stringify(temp)
                    ,dataType: 'json'
                    ,success: function(res) {
                       // console.log(res);
                       var rs = JSON.parse(res.result);
                       //console.log(rs);
                       var data = [];
                       addBattStr = '';      // 初始化字符串
                       if(rs.code == 1) {
                          data = rs.data;
                          data = formatSearchData(data);
                       }else {
                          layer.msg('没有可设置的电池组!');
                          layer.msg('没有可设置的机房!');
                       }
                       console.log(data);
                       // 如果有添加的数据
                       if(data.length !=0) {
                          if(addBattStr.length == 0) {   // 字符串长度为0
                             addBattStr += getFilterStr(temp);
                          }else {
                             addBattStr += ','+getFilterStr(temp);
                          }
                       }
                       tOptions.data = data;
                       //console.log(data);
                         // 生成表格数据
                     table.render(tOptions);
                     updateDevStatus();
                     layuiTbl.setCache(table.cache.pageTbl);
                    }
                    ,complete:function() {
                       layer.close(load);
@@ -623,10 +966,10 @@
               var addType = $('#addType').val();   // 添加机房的方式
               var msg = '';   // 提示信息
               var rs = {
                  num: addType,
                  StationName: '',
                  GroupIndexInFBSDevice: $('#battNum').val(),
                  MonVolStd: $('#sysType').val()
                  num: addType,               // 添加机房的类型
                  StationName: '',            // 省市区或机房名称
                  GroupIndexInFBSDevice: 100,      // 索引
                  MonVolStd: $('#sysType').val()   // 设备类型
               };
               switch(addType) {
                  case '1':
@@ -656,392 +999,150 @@
               return rs;
            }
            
            // 点击批量设置放电电流参数
            var pageIframe = "";
            $('#sysSet').click(function() {
               var checkStatus = table.checkStatus('pageTbl');
               var data = checkStatus.data;
               if(data.length == 0) {
                  layer.msg('请选择要设置的机房');
                  return;
               }
               setBtsPopup();         // 设置BTS面板的初始值
               BTS_popup.showPopup();   // 显示BTS面板
            });
               var btsCmd = GLOBAL.CMD.BTS;      // 获取BTS的CMD
               var setParamCmd = btsCmd.setDischargeParm;   // 设置参数的cmd
               var startTest = btsCmd.start;
               // 点击放电参数设置页面设置按钮
               $('#btn_set').click(function() {
                  if($(this).hasClass('whyc-btn-disabled')) {
                     layer.msg('存在不合法的数据');
                     return;
                  }
                  var checkStatus = table.checkStatus('pageTbl');
               var data = checkStatus.data;
               var ratio = getBtsPopup();
               var currParam = getSetCurrParam(data, ratio);
               // 判断是否设置机房
               layer.confirm('是否确认批量设置参数', {icon: 3, title: '系统提示'}, function(index) {
                  layer.close(index);
                  ajaxSetParam(currParam);
               });
               });
               // 请求设置参数
               function ajaxSetParam(param) {
                  console.log(param);
                  var load = layer.load(1);
                  // 请求后台
                  $.ajax({
                     type: 'post'
                     ,async: true
                     ,url: 'Fbs9100_setparamAction_action_updatePro'
                     ,data: 'json='+JSON.stringify(param)
                     ,dataType: 'json'
                     ,success: function(res) {
                        var rs = JSON.parse(res.result);
                        if(rs.code == 1) {
                           layer.msg('设置完成!');
                           BTS_popup.hidePopup();      // 关闭面板
                           var data = rs.data;
                           console.log(data);
                           var rsList = [];
                           for(var i=0; i<data.length; i++) {
                              var _data = data[i];
                              rsList.push(_data);
                           }
                           var trIndex = getSetCurrIndex(data, tOptions.data);
                           // 被设置参数的机房
                           for(var i=0; i<trIndex.length; i++) {
                              var _data = data[i];
                              var _trIndex = trIndex[i];
                              var _temp = {'doThings':''};
                              if(_data.num==1) {
                                 _temp.setCurr = 1;
                              }else {
                                 _temp.setCurr = 2;
                              }
                              layuiTbl.updateTr(i, _temp);
                           }
                           $('#setCurrIframe').data('setCurr', rsList);
                        }else {
                           layer.msg('修改失败');
                        }
                     }
                     ,complete: function() {
                        layer.close(load);
                     }
                  });
               }
               // 构造批量设置放电参数的方法
               function getSetCurrParam(data, ratio) {
                  //console.log(data);
                  var rs = [];
                  for(var i=0; i<data.length; i++) {
                     var _data = data[i];
                     var disCurr = getDisCurr(_data.MonCapStd, ratio.hourrate);                     // 小时率
                     var chargeCurr = getChargeCurr(_data.MonCapStd, ratio.chargeCurrPer);            // 充电电流
                     var groupVolLow = getGroupVolLow(_data.MonVolStd, _data.MonCount, ratio.groupVolLowPer);      // 组端电压下限
                     var monVolLow = getMonVolLow(_data.MonVolStd, ratio.monVolLowPer);               // 单体电压下限
                     var monNumLow = getMonNumLow(_data.MonCount, ratio.monNumLow);                  // 单体数量下限
                     var disCap = getDisCap(_data.MonCapStd, ratio.disCapPer);                     // 放电容量
                     var temp= {
                        num: 0
                        ,dev_id: _data.FBSDeviceId         // 设备id
                        ,op_cmd: setParamCmd            // 设置参数命令
                        ,TestCmd: ratio.testType         // 测试类型
                        ,HourRate: ratio.hourrate         // 小时率
                        ,DisCurr: disCurr               // 放电电流
                        ,DisCap: disCap                  // 放电容量
                        ,DisTime: ratio.distime            // 放电时长
                        ,GroupVol_Low: groupVolLow         // 组端电压下限
                        ,MonomerVol_Low: monVolLow         // 单体电压下限
                        ,MonomerLowCount: monNumLow         // 单体数量下限
                        ,MonomerTmp_High: ratio.TempUpHighLimit      // 温度上限
                        ,OnlineLowAction: ratio.OnlineVolLowAction   // 在线电压低处理
                        ,ChargeCurrSet: chargeCurr         // 充电电流
                        ,DCVolHighLimit: ratio.DCVolHighLimit // 升压上限
                        ,BattGroupNum: _data.GroupIndexInFBSDevice+1      // 电池组的索引
                        ,StationName: _data.StationName            // 机房名称
                     }
                     rs.push(temp);
                  }
                  return rs;
               }
               // 获取批量设置的参数
               function getBtsPopup() {
                  var temp={
                     num: 0
                     ,testType: $('#discharge_type').val()             // 测试类型
                     ,distime: $('#distime').val()                  // 放电时长
                     ,hourrate: $('#hourrate').val()                  // 放电小时率
                     ,disCapPer: $('#disCapPer').val()               // 放电容量百分比
                     ,monVolLowPer: $('#monVolLowPer').val()            // 单体电压下限百分比
                     ,groupVolLowPer: $('#groupVolLowPer').val()       // 组端电压下限百分比
                     ,monNumLow: $('#monNumLow').val()               // 单体数量百分比
                     ,chargeCurrPer: $('#chargeCurrPer').val()         // 充电电流百分比
                     ,DCVolHighLimit: $('#DCVolHighLimit').val()         // 升压上限
                     ,TempUpHighLimit: $('#TempUpHighLimit').val()      // 温度上限
                     ,OnlineVolLowAction: $('#OnlineVolLowAction').val() // 在线电压低处理
                  };
                  return temp;
               }
               // 获取放电电流(标称容量的*小时率)
               function getDisCurr(monCapStd, ratio) {
                  return monCapStd*ratio/100;
               }
               // 获取组端电压下限(标称单体电压*单体数量*百分比)
               function getGroupVolLow(monVolStd, monCount, ratio) {
                  return monVolStd*monCount*ratio/100;
               }
               // 获取单体电压下限(标称单体电压*百分比)
               function getMonVolLow(monVolStd, ratio) {
                  return monVolStd*ratio/100;
               }
               // 单体数量下限(单体节数*百分比)
               function getMonNumLow(monCount, ratio) {
                  return Math.floor(monCount*ratio/100);
               }
               // 放电容量(标称容量*百分比)
               function getDisCap(monCapStd, ratio) {
                  return monCapStd*ratio/100;
               }
               // 充电电流(标称容量*百分比)
               function getChargeCurr(monCapStd, ratio) {
                  return monCapStd*ratio/100;
               }
               // 放电时长distime
               $('#distime').testVal({
               pattern: /^[0-9]+$/,
               regVal: true,
               min: 0,
               max: 5940,
               msg: '取值范围0~5940'
            });
            var regs = {
               pattern: /^[0-9]+$/,
               regVal: true,
               min: 0,
               max: 300,
               msg: '取值范围0~300'
            };
               // 小时率
            $('#hourrate').testVal(regs);
            // 放电容量百分比
            $('#disCapPer').testVal(regs);
            // 单体电压下限百分比
            $('#monVolLowPer').testVal(regs);
            // 组端下限百分比
            $('#groupVolLowPer').testVal(regs);
            // 充电电流百分比
            $('#chargeCurrPer').testVal(regs);
            // 单体下限数量
            $('#monNumLow').testVal({
               pattern: /^[0-9]+$/,
               regVal: true,
               min: 0,
               max: 100,
               msg: '取值范围0~100'
            });
            // 获取BTS面板的所有文本框
            $('#battInfo_popup').on('input propertychange', 'input[type=text]', function() {
               setBTSPopupStatus($(this).attr('id'), $(this).val());
            });
            // 启动测试
            $('#startTest').click(function() {
               var rsList = $('#setCurrIframe').data('setCurr');
               if(rsList.length == 0) {
                  layer.msg('暂无无法启动,请先设置放电参数!');
                  return;
               }
               // 显示面板
               layer.open({
                  type: 2
                  ,area: ['1200px', '500px']
                  ,resize: false
                  ,maxmin: true
                  ,fixed: true
                  ,content: 'iframe/setcurr.html'
               });
            });
            // 初始化设置参数的按钮
            var BTSBtn = {
               disabled: function() {
                  $('#btn_set').addClass('whyc-btn-disabled');   // 设置参数按钮无效
               },
               active:function() {
                  $('#btn_set').removeClass('whyc-btn-disabled');   // 设置参数按钮有效
               }
            };
            // 设置批量设置放电参数面板
               function setBtsPopup() {
                  $('#distime').val(600);            // 放电时长
                  $('#hourrate').val(10);            // 小时率
                  $('#disCapPer').val(60);         // 放电容量百分比
                  $('#monVolLowPer').val(90);         // 单体电压下限百分比
                  $('#groupVolLowPer').val(90);      // 组端电压下限百分比
                  $('#monNumLow').val(25);         // 单体数量百分比
                  $('#chargeCurrPer').val(10);      // 充电电流百分比
                  $('#DCVolHighLimit').val(56.4);      //  升压上限
                  $('#TempUpHighLimit').val(60);      //  温度上限
                  // 初始化面板状态
                  $('#battInfo_popup').find('input').removeClass('error-data');      // 移除错误提示
                  $('#battInfo_popup').find('.error-img').removeClass('error-data');   // 移除错误提示
                  BTSBtn.active();
               }
            //根据文本框内容设置61850的按钮状态
            function setBTSPopupStatus(id, val) {
               var textList = BTS_popup.popup.find('input[type=text]');
               var selectList = BTS_popup.popup.find('.popup-tbl select');
               var errorStatus = BTS_popup.popup.data().errorStatus; // 获取是否读取参数失败
               //console.log(BTS_popup.popup.data().attr);
               // 读取设备参数失败
               if(errorStatus) {
                  BTSBtn.disabled();
                  return false;   // 结束函数运行
               }
               // 遍历面板下的所有文本框查看是否有错误数据
               var isDisabled = false;
               textList.each(function() {
                  if($(this).hasClass('error-data')) {
                     isDisabled = true;
                  }
               });
               // 存在错误的数据
               if(isDisabled) {
                  BTSBtn.disabled();
                  return false;   // 结束函数运行
               }else {
                  BTSBtn.active();
               }
            }
            // 获取设置放电参数的下标
            function getSetCurrIndex(setData, allData) {
            // 处理添加机房信息的结果
            function formatSearchData(data) {
               console.log(data);
               var rs = [];
               // 遍历setData
               for(var i=0; i<setData.length; i++) {
                  var _setData = setData[i];
                  var setDevId = _setData.dev_id;
                  // 遍历allData
                  for(var k=0; k<allData.length; k++) {
                     var _allData = allData[i];
                     var allDevId = _allData.FBSDeviceId;
                     if(setDevId == allDevId) {
                        rs.push(k);
                     }
                  }
               // 遍历data的
               for(var i=0; i<data.length; i++) {
                  var _data = data[i];
                  
                  var obj = _data.obj[0];
                  var tmp = {};
                  tmp.num = _data.num;                  // 判断是否读取成功
                  tmp.readStatus = _data.num;
                  tmp.key_id = i;
                  tmp.dev_id = obj.dev_id;               // 设备ID
                  tmp.dev_ip = obj.dev_ip;               // 设备IP
                  tmp.StationName = _data.StationName;         // 机房名称
                  tmp.GroupConnType = 0;                  // 电池组连接类型
                  tmp.StationName9 = _data.StationName9;      // 设备版本号
                  tmp.GroupVol = obj.GroupVol;            // 电池组端标称电压(V)
                  tmp.STD_CAP = obj.STD_CAP;               // 电池标称容量(AH)
                  tmp.STD_CAP_b = _data.MonCapStd;
                  tmp.STD_CAP_bool = isNumEqual(_data.MonCapStd, obj.STD_CAP);
                  tmp.STD_RES = obj.STD_RES;               // 电池标称内阻(uΩ)
                  tmp.STD_RES_b = _data.MonSerStd;
                  tmp.STD_RES_bool = isNumEqual(_data.MonSerStd, obj.STD_RES);
                  tmp.BattGroupCount = obj.BattGroupCount;      // 电池组组数
                  tmp.BattGroupCount_b = _data.BattGroupNum;
                  tmp.BattGroupCount_bool = isNumEqual(_data.BattGroupNum, obj.BattGroupCount);
                  tmp.EachGroupBattCount = obj.EachGroupBattCount;   // 每组电池单体数量
                  tmp.EachGroupBattCount_b = _data.MonCount;
                  tmp.EachGroupBattCount_bool = isNumEqual(_data.MonCount, obj.EachGroupBattCount);
                  tmp.MonomerVol = obj.MonomerVol;   // 单体标称电压(V)
                  tmp.MonomerVol_b = _data.MonVolStd;
                  tmp.MonomerVol_bool = isNumEqual(_data.MonVolStd, obj.MonomerVol);
                  tmp.BattTemp = obj.BattTemp;   // 电池标称温度(℃)
                  tmp.BattTemp_b = _data.MonTmpStd;
                  tmp.BattTemp_bool = isNumEqual(_data.MonTmpStd, tmp.BattTemp);
                  tmp.FloatChargeVol = obj.FloatChargeVol;   // 电池浮充电压阀值(V)
                  tmp.FloatChargeVol_b = _data.FloatVolLevel;
                  tmp.FloatChargeVol_bool = isNumEqual(_data.FloatVolLevel, tmp.FloatChargeVol);
                  tmp.FloatChargeCurr = obj.FloatChargeCurr;      // 电池浮充电流阀值(A)
                  tmp.FloatChargeCurr_b = _data.BattFloatCurrent;
                  tmp.FloatChargeCurr_bool = isNumEqual(_data.BattFloatCurrent, tmp.FloatChargeCurr);
                  tmp.OnlineVolLow = obj.OnlineVolLow;      // 在线电压低阀值(V)
                  tmp.OnlineVolLow_b = _data.OfflineVolLevel;
                  tmp.OnlineVolLow_bool = isNumEqual(_data.OfflineVolLevel, tmp.OnlineVolLow);
                  rs.push(tmp);
               }
               
               return rs;
            }
            
            //  更新设备状态
            var BTS9100 = GLOBAL.BTS9100;
            var workStates = BTS9100.workstates;
            var alarmStates = BTS9100.alarmstates;
            function updateDevStatus() {
               var battlist = tOptions.data;
               clearInterval(updateDevStatus.timer);
               if(battlist.length > 0){
                  $.ajax({
                       type: "post",
                       url: "Fbs9100_setparamAction_action_serchByInfo",
                       async:true,
                       dataType:'text',
                       data:"json="+JSON.stringify(battlist),
                       dataType: 'json',
                       success: function(res){
                        var rs = JSON.parse(res.result);
                        if(rs.code == 1) {
                           var data = rs.data;
                           // console.log(data);
                           for(var i=0; i<data.length; i++) {
                              var obj = data[i];
                              if(obj.fstate.num > 0){
                                 var str = '';
                                 var index = obj.fstate.dev_workstate;
                                 // 内阻测试(工作状态为0, 内阻测试不为0)
                                 if(obj.fstate.dev_workstate ==0 && obj.fstate.dev_res_test_state != 0) {
                                    index = 3;
                                 }
                                 // 设置文本值
                                 str = "状态:"   + workStates[index]+
                                      ",告警:"+alarmStates[obj.fstate.dev_alarmstate]+
                                      ",组端电压(V):"+obj.fstate.dev_captest_groupvol+
                                      ",电流(A):"+obj.fstate.dev_captest_curr+
                                      ",容量(AH):"+obj.fstate.dev_captest_cap;
                                  if(index == 3){
                                     str = "状态:"+workStates[index]+
                                          ",组号:"+obj.fstate.dev_testgroupnum+
                                          ",当前单体编号:"+(obj.fstate.dev_restest_monindex+1)+
                                          ",被测单体总数:"+obj.fstate.dev_restest_moncount;
                                  }
                                  var temp = {
                                     devStatus: str         // 设备状态
                                     ,testTime: formatSeconds(obj.fstate.dev_captest_timelong)      // 测试时长
                                     ,signalNum: obj.fstate.dev_commcount
                                  }
                                 layuiTbl.updateTr(i, temp);
                              }
                           }
                        }
                        updateDevStatus.timer = setTimeout(updateDevStatus, 4000);
                     },
                  });
            // 获取两个数是否一致
            function isNumEqual(num1, num2) {
               return num1==num2;
            }
            // 获取被选中行的标识位
            function getKeyId(data) {
               var rs = [];
               // 遍历data的值
               for(var i=0; i<data.length; i++) {
                  var _data = data[i];
                  var tmp = {};
                  tmp.key_id = _data.key_id;
                  rs.push(tmp);
               }
            }
               return rs;
            }
            // 获取被选中的行的数据并处理返回指定的对象数组
            function getCheckedData(data) {
               var rs = [];
               // 处理数据
               for(var i=0; i<data.length; i++) {
                  var _data = data[i];
                  var tmp = {};
                  tmp.num = _data.num;                        // 判断是否读取成功
                  tmp.dev_id = _data.dev_id;                     // 设备ID
                  tmp.dev_ip = _data.dev_ip;                     // 设备IP
                  tmp.StationName = _data.StationName;            // 机房名称
                  tmp.GroupConnType = 0;                        // 电池组连接类型
                  tmp.StationName9 = _data.StationName9;            // 设备版本号
                  tmp.GroupVol = _data.GroupVol;                  // 电池组端标称电压(V)
                  tmp.STD_CAP = _data.STD_CAP;                  // 电池标称容量(AH)
                  tmp.STD_RES = _data.STD_RES;                  // 电池标称内阻(uΩ)
                  tmp.BattGroupCount = _data.BattGroupCount;         // 电池组组数
                  tmp.EachGroupBattCount = _data.EachGroupBattCount;   // 每组电池单体数量
                  tmp.MonomerVol = _data.MonomerVol;               // 单体标称电压(V)
                  tmp.BattTemp = _data.BattTemp;                  // 电池标称温度(℃)
                  tmp.FloatChargeVol = _data.FloatChargeVol;         // 电池浮充电压阀值(V)
                  tmp.FloatChargeCurr = _data.FloatChargeCurr;      // 电池浮充电流阀值(A)
                  tmp.OnlineVolLow = _data.OnlineVolLow;            // 在线电压低阀值(V)
                  tmp.readStatus = _data.readStatus;               // 读取状态
                  // 将数据放到返回的结果集中
                  rs.push(tmp);
               }
               return rs;
            }
            // 获取筛选条件的字符串
            function getFilterStr(data) {
               var rsString = '';
               rsString += data.StationName;
               rsString += '-'+data.MonVolStd+'V设备';
               rsString += '-'+(data.GroupIndexInFBSDevice == '0'?'电池组1': '电池组2');
               return rsString;
            }
            // 根据readStatus的值设置电池参数的值区分可设置参数的机房信息/不可设置参数的机房
            function getGoodAndBadHome(data) {
               let rs = {
                  good: []
                  ,bad: []
               };
               // 遍历data的值
               for(var i=0; i<data.length; i++) {
                  let _data = data[i];
                  let status = _data.readStatus;
                  if(status) {
                     rs.good.push(_data);
                  }else {
                     rs.bad.push(_data);
                  }
               }
               return rs;
            }
            
           });
        </script>
    </body>
</html>