fix:修复table类型聚合bug

nezha-fronted/src/components/charts/chart-table.vue

@@ -375,9 +375,16 @@ export default {
 
           let mapping
           if (type == 'value') {
-            mapping = mappings.find(t => { return Number(t.value) == value })
+            mapping = mappings.find(t => {
+              let mappingValue = t.value ===''?'':Number(t.value) //Number('') 值为0
+              return mappingValue === value
+            })
           } else {
-            mapping = mappings.find(t => { return Number(t.from) <= value && Number(t.to) >= value })
+            mapping = mappings.find(t => {
+              let mappingFrom = t.from ===''?'':Number(t.from)
+              let mappingTo = t.to ===''?'':Number(t.to)
+              return Number(mappingFrom) <= value && Number(mappingTo) >= value
+            })
           }
           this.mapping = mapping
           item.mapping = mapping
@@ -423,97 +430,160 @@ export default {
         this.endLoading()
       }
     },
-    getStatisticsResult (statistics, seriesItem) {
+    getStatisticsResult: function (statistics, seriesItem) {
       if (!seriesItem || !seriesItem.length > 0) return []
       if (!statistics) return seriesItem
       let copy = JSON.parse(JSON.stringify(seriesItem))
-      const last = copy.sort((x, y) => { return parseFloat(y.data[0]) - parseFloat(x.data[0]) })[0]
+      copy.sort((x, y) => { return parseFloat(y.data[0]) - parseFloat(x.data[0]) })[0]
+      let classifies=[];
+      let maxGroup=0
+      let map = new Map();//用于记录在第几组
+      copy.forEach(item => {
+        let element = item.element.element;
+        let group = map.get(element);
+        if(typeof group != "undefined"){
+          classifies[group].push(item)
+        }else{
+          classifies.push([item]);
+          map.set(element,maxGroup++)
+        }
+      })
+
       let result
       switch (statistics) {
         case 'null': {
-          return copy.map(item => {
+
+          result = copy.map(item => {
             return {
               element: item.element,
               time: bus.timeFormate(new Date(item.data[0]), 'yyyy-MM-dd hh:mm:ss'),
               value: item.data[1]
             }
           })
+          break
         }
         case 'min': {
-          result = copy.sort((x, y) => { return parseFloat(x.data[1]) - parseFloat(y.data[1]) })[0]
+          result = classifies.map(group=>{
-          result = [{
+              let groupMin = group.sort((x, y) => {
-            element: result.element,
+                return parseFloat(x.data[1]) - parseFloat(y.data[1])
-            time: bus.timeFormate(new Date(result.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              })[0]
-            value: result.data[1]
+
-          }]
+              return {
+                element: groupMin.element,
+                time: bus.timeFormate(new Date(groupMin.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+                value: groupMin.data[1]
+              }
+          })
           break
         }
         case 'max': {
-          result = copy.sort((x, y) => { return parseFloat(y.data[1]) - parseFloat(x.data[1]) })[0]
+          result = classifies.map(group=>{
-          result = [{
+            let groupMax = group.sort((x, y) => {
-            element: result.element,
+              return parseFloat(y.data[1]) - parseFloat(x.data[1])
-            time: bus.timeFormate(new Date(result.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+            })[0]
-            value: result.data[1]
+
-          }]
+            return {
+              element: groupMax.element,
+              time: bus.timeFormate(new Date(groupMax.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: groupMax.data[1]
+            }
+          })
           break
         }
         case 'average': {
-          copy = copy.map(t => parseFloat(t.data[1]))
+          result = classifies.map(group=>{
-          const sum = eval(copy.join('+'))
+            let groupData=group.map(t => parseFloat(t.data[1]))
-          const avg = sum / copy.length
+            const sum = eval(groupData.join('+'))
-          result = [{
+            const avg = sum / groupData.length
-            element: last.element,
+            let last = group.sort((x, y) => {
-            time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              return parseFloat(y.data[0]) - parseFloat(x.data[0])
-            value: avg
+            })[0]
-          }]
+            return {
+              element: last.element,
+              time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: avg
+            }
+          })
           break
         }
         case 'total': {
-          copy = copy.map(t => parseFloat(t.data[1]))
+          result = classifies.map(group=>{
-          const total = eval(copy.join('+'))
+            let groupData=group.map(t => parseFloat(t.data[1]))
-          result = [{
+            const total = eval(groupData.join('+'))
-            element: last.element,
+            let last = group.sort((x, y) => {
-            time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              return parseFloat(y.data[0]) - parseFloat(x.data[0])
-            value: total
+            })[0]
-          }]
+            return {
+              element: last.element,
+              time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: total
+            }
+          })
           break
         }
         case 'first': {
-          result = copy.sort((x, y) => { return parseFloat(y.data[0]) - parseFloat(x.data[0]) })[copy.length - 1]
+          result = classifies.map(group=>{
-          result = [{
+            let first = group.sort((x, y) => {
-            element: result.element,
+              return parseFloat(y.data[0]) - parseFloat(x.data[0])
-            time: bus.timeFormate(new Date(result.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+            })[copy.length - 1]
-            value: result.data[1]
+
-          }]
+            return {
+              element: first.element,
+              time: bus.timeFormate(new Date(first.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: first.data[1]
+            }
+          })
           break
         }
         case 'last': {
-          result = last
+          result = classifies.map(group=>{
-          result = [{
+
-            element: result.element,
+            let last = group.sort((x, y) => {
-            time: bus.timeFormate(new Date(result.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              return parseFloat(y.data[0]) - parseFloat(x.data[0])
-            value: result.data[1]
+            })[0]
-          }]
+            return {
+              element: last.element,
+              time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: last.data[1]
+            }
+          })
           break
         }
         case 'range': {
-          const sort = copy.sort((x, y) => { return parseFloat(y.data[1]) - parseFloat(x.data[1]) })
+          result = classifies.map(group=>{
-          const max = sort[0]
+
-          const min = sort[sort.length - 1]
+            const sort = JSON.parse(JSON.stringify(group)).sort((x, y) => {
-          result = [{
+              return parseFloat(y.data[1]) - parseFloat(x.data[1])
-            element: last.element,
+            })
-            time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+            let last = group.sort((x, y) => {
-            value: max.data[1] - min.data[1]
+              return parseFloat(y.data[0]) - parseFloat(x.data[0])
-          }]
+            })[0]
+            const max = sort[0]
+            const min = sort[sort.length - 1]
+            let range = max.data[1] - min.data[1];
+            return {
+              element: last.element,
+              time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: range
+            }
+          })
           break
         }
         case 'different': {
-          const first = copy.sort((x, y) => { return parseFloat(y.data[0]) - parseFloat(x.data[0]) })[copy.length - 1]
+          result = classifies.map(group=>{
-          result = [{
+
-            element: last.element,
+            const sort = group.sort((x, y) => {
-            time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              return parseFloat(y.data[0]) - parseFloat(x.data[0])
-            value: last.data[1] - first.data[1]
+            })
-          }]
+            let last = sort[0]
+            let first = sort[copy.length - 1]
+            return {
+              element: last.element,
+              time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: last.data[1] - first.data[1]
+            }
+          })
+
           break
         }
       }

nezha-fronted/src/components/charts/chartPreview.vue

@@ -1388,95 +1388,160 @@ export default {
       this.tableShow = true
       this.$refs.loadingPreview.endLoading()
     },
-    getStatisticsResult (statistics, seriesItem) {
+    getStatisticsResult: function (statistics, seriesItem) {
+      if (!seriesItem || !seriesItem.length > 0) return []
+      if (!statistics) return seriesItem
       let copy = JSON.parse(JSON.stringify(seriesItem))
-      const last = copy.sort((x, y) => { return parseFloat(y[0]) - parseFloat(x[0]) })[0]
+      copy.sort((x, y) => { return parseFloat(y.data[0]) - parseFloat(x.data[0]) })[0]
+      let classifies=[];
+      let maxGroup=0
+      let map = new Map();//用于记录在第几组
+      copy.forEach(item => {
+        let element = item.element.element;
+        let group = map.get(element);
+        if(typeof group != "undefined"){
+          classifies[group].push(item)
+        }else{
+          classifies.push([item]);
+          map.set(element,maxGroup++)
+        }
+      })
+
       let result
       switch (statistics) {
         case 'null': {
-          return copy.map(item => {
+
+          result = copy.map(item => {
             return {
               element: item.element,
               time: bus.timeFormate(new Date(item.data[0]), 'yyyy-MM-dd hh:mm:ss'),
               value: item.data[1]
             }
           })
+          break
         }
         case 'min': {
-          result = copy.sort((x, y) => { return parseFloat(x.data[1]) - parseFloat(y.data[1]) })[0]
+          result = classifies.map(group=>{
-          result = [{
+            let groupMin = group.sort((x, y) => {
-            element: result.element,
+              return parseFloat(x.data[1]) - parseFloat(y.data[1])
-            time: bus.timeFormate(new Date(result.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+            })[0]
-            value: result.data[1]
+
-          }]
+            return {
+              element: groupMin.element,
+              time: bus.timeFormate(new Date(groupMin.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: groupMin.data[1]
+            }
+          })
           break
         }
         case 'max': {
-          result = copy.sort((x, y) => { return parseFloat(y.data[1]) - parseFloat(x.data[1]) })[0]
+          result = classifies.map(group=>{
-          result = [{
+            let groupMax = group.sort((x, y) => {
-            element: result.element,
+              return parseFloat(y.data[1]) - parseFloat(x.data[1])
-            time: bus.timeFormate(new Date(result.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+            })[0]
-            value: result.data[1]
+
-          }]
+            return {
+              element: groupMax.element,
+              time: bus.timeFormate(new Date(groupMax.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: groupMax.data[1]
+            }
+          })
           break
         }
         case 'average': {
-          copy = copy.map(t => parseFloat(t.data[1]))
+          result = classifies.map(group=>{
-          const sum = eval(copy.join('+'))
+            let groupData=group.map(t => parseFloat(t.data[1]))
-          const avg = sum / copy.length
+            const sum = eval(groupData.join('+'))
-          result = [{
+            const avg = sum / groupData.length
-            element: last.element,
+            let last = group.sort((x, y) => {
-            time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              return parseFloat(y.data[0]) - parseFloat(x.data[0])
-            value: avg
+            })[0]
-          }]
+            return {
+              element: last.element,
+              time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: avg
+            }
+          })
           break
         }
         case 'total': {
-          copy = copy.map(t => parseFloat(t.data[1]))
+          result = classifies.map(group=>{
-          const total = eval(copy.join('+'))
+            let groupData=group.map(t => parseFloat(t.data[1]))
-          result = [{
+            const total = eval(groupData.join('+'))
-            element: last.element,
+            let last = group.sort((x, y) => {
-            time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              return parseFloat(y.data[0]) - parseFloat(x.data[0])
-            value: total
+            })[0]
-          }]
+            return {
+              element: last.element,
+              time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: total
+            }
+          })
           break
         }
         case 'first': {
-          result = copy.sort((x, y) => { return parseFloat(y.data[0]) - parseFloat(x.data[0]) })[copy.length - 1]
+          result = classifies.map(group=>{
-          result = [{
+            let first = group.sort((x, y) => {
-            element: result.element,
+              return parseFloat(y.data[0]) - parseFloat(x.data[0])
-            time: bus.timeFormate(new Date(result.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+            })[copy.length - 1]
-            value: result.data[1]
+
-          }]
+            return {
+              element: first.element,
+              time: bus.timeFormate(new Date(first.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: first.data[1]
+            }
+          })
           break
         }
         case 'last': {
-          result = last
+          result = classifies.map(group=>{
-          result = [{
+
-            element: result.element,
+            let last = group.sort((x, y) => {
-            time: bus.timeFormate(new Date(result.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              return parseFloat(y.data[0]) - parseFloat(x.data[0])
-            value: result.data[1]
+            })[0]
-          }]
+            return {
+              element: last.element,
+              time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: last.data[1]
+            }
+          })
           break
         }
         case 'range': {
-          const sort = copy.sort((x, y) => { return parseFloat(y.data[1]) - parseFloat(x.data[1]) })
+          result = classifies.map(group=>{
-          const max = sort[0]
+
-          const min = sort[sort.length - 1]
+            const sort = JSON.parse(JSON.stringify(group)).sort((x, y) => {
-          result = [{
+              return parseFloat(y.data[1]) - parseFloat(x.data[1])
-            element: last.element,
+            })
-            time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+            let last = group.sort((x, y) => {
-            value: max.data[1] - min.data[1]
+              return parseFloat(y.data[0]) - parseFloat(x.data[0])
-          }]
+            })[0]
+            const max = sort[0]
+            const min = sort[sort.length - 1]
+            let range = max.data[1] - min.data[1];
+            return {
+              element: last.element,
+              time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: range
+            }
+          })
           break
         }
         case 'different': {
-          const first = copy.sort((x, y) => { return parseFloat(y.data[0]) - parseFloat(x.data[0]) })[copy.length - 1]
+          result = classifies.map(group=>{
-          result = [{
+
-            element: last.element,
+            const sort = group.sort((x, y) => {
-            time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              return parseFloat(y.data[0]) - parseFloat(x.data[0])
-            value: last.data[1] - first.data[1]
+            })
-          }]
+            let last = sort[0]
+            let first = sort[copy.length - 1]
+            return {
+              element: last.element,
+              time: bus.timeFormate(new Date(last.data[0]), 'yyyy-MM-dd hh:mm:ss'),
+              value: last.data[1] - first.data[1]
+            }
+          })
+
           break
         }
       }

nezha-fronted/src/components/common/language/cn.js

@@ -147,7 +147,8 @@ const cn = {
     reloadTimeout: '重新启动服务器花了太多时间，安装可能有一些问题',
     hadConfig: '已经有人开始配置系统',
     invalidCode: '身份验证无效，请按照{page}中的描述继续',
-    welcomePage: '欢迎页面'
+    welcomePage: '欢迎页面',
+    inited: '系统已经被初始化',
   },
   webshell: {
     shellTitle: '本地 Shell',

nezha-fronted/src/components/common/language/en.js

@@ -153,7 +153,8 @@ const en = {
     reloadTimeout: 'It took too much time to restart the server, there may be some problems when you install',
     hadConfig: 'Someone has started to configure the system',
     invalidCode: "The authentication is invalid ,please follow the description in {page} 'To continue'",
-    welcomePage: 'Welcome page'
+    welcomePage: 'Welcome page',
+    inited:'The system has been initialized',
   },
   webshell: {
     shellTitle: 'Local Shell',

nezha-fronted/src/components/page/config/setup.vue

@@ -237,6 +237,16 @@ export default {
           } else {
             this.getValidateCode()
             this.$get('setup/checkCode?code=' + this.validateCode).then(response => {
+              if(response.status == 404){
+                this.$alert(this.$t('setup.hadConfig'), { type: 'warning' })
+                const self = this;
+                setTimeout(()=>{
+                  self.$router.push({
+                    path: '/'
+                  })
+                },2000)
+                return;
+              }
               if (response.code == 200) {
                 this.activeStep = 1
                 this.step = 1

nezha-fronted/src/components/page/dashboard/chartBox.vue

@@ -439,7 +439,7 @@
       <button @click="preview" id="chart-box-preview" class="nz-btn nz-btn-size-normal-new nz-btn-style-normal-new" v-else>
         <span>{{$t('overall.preview')}}</span>
       </button>
-      <button id="chart-box-save" v-has="'panel_chart_save'" :class="{'nz-btn-disabled':prevent_opt.save}" :disabled="prevent_opt.save" class="nz-btn nz-btn-size-normal-new nz-btn-style-normal-new" @click="confirmAdd" >
+      <button id="chart-box-save" v-has="'panel_chart_add'" :class="{'nz-btn-disabled':prevent_opt.save}" :disabled="prevent_opt.save" class="nz-btn nz-btn-size-normal-new nz-btn-style-normal-new" @click="confirmAdd" >
         <span>{{$t('overall.save')}}</span>
       </button>
     </div>