gfwleak/nezha-nezha-fronted
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

NEZ-3241 feat：Data，Data rate 支持选择 IEC标准或SI标准 换算方式

Browse Source
This commit is contained in:
zhangyu
2023-10-24 16:01:47 +08:00
parent 83961e8b6f
commit 725025990e
11 changed files with 420 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
nezha-fronted/src/components/chart/chart/chartTimeSeries.vue
View File

@@ -191,7 +191,7 @@ export default {
this.legends = []
this.series = chartOption.series = this.handleTimeSeries(this.chartInfo, chartOption.series[0], this.chartData) // 生成series和legends
console.log(this.$lodash.cloneDeep( this.chartData), ' this.chartData')
chartOption.series.forEach(item => {
if (item.lineStyle) {
item.lineStyle.width = this.lineOption.lineWidth
@@ -238,6 +238,7 @@ export default {
delete chartOption.tooltip.position
}
const option = this.renderYAxis(this.chartData, this.chartInfo)
console.log(option)
chartOption.yAxis[0] = { ...chartOption.yAxis[0], ...option.yAxis[0] }
chartOption.yAxis[1] = { ...chartOption.yAxis[1], ...option.yAxis[1] }
if (chartOption.toolbox.feature) {
@@ -611,7 +612,11 @@ export default {
yAxisLabelFormatter (minValue, maxValue, copies, unit, dot) {
const self = this
return function (val, index) {
const value = formatScientificNotation(val, 6)
console.log(val)
let value = formatScientificNotation(val, 6)
if (!val) {
value = 0
}
return unit.compute(value, index, -1, dot)
}
},

2
nezha-fronted/src/components/chart/chart/legend.vue
View File

@@ -350,7 +350,7 @@ export default {
maxValue = Math.abs(minValue)
}
maxValue = maxValue - minValue
maxValue = chartDataFormat.formatDatas(maxValue, unit.type, 'ceil', unit.ascii)
maxValue = chartDataFormat.formatDatas(maxValue, unit, 'ceil', unit.ascii)
let oldValue = maxValue
if (maxValue < 0) {
oldValue = Math.abs(maxValue)

2
nezha-fronted/src/components/chart/chart/line-chart-block.vue
View File

@@ -2083,7 +2083,7 @@ export default {
maxValue = Math.abs(minValue)
}
maxValue = maxValue - minValue
maxValue = chartDataFormat.formatDatas(maxValue, unit.type, 'ceil', unit.ascii)
maxValue = chartDataFormat.formatDatas(maxValue, unit, 'ceil', unit.ascii)
let oldValue = maxValue
let dot = 0
if (maxValue == 1) {

442
nezha-fronted/src/components/chart/chartDataFormat.js
View File

@@ -73,6 +73,22 @@ function bits (value, index, type = 1, dot = 0) {
return asciiCompute(num, 1024, ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 2)
}
}
function bitsSI (value, index, type = 1, dot = 0) {
const num = value / 8
if (value < 8) {
return value + 'b'
}
if (num < 1000) {
return num + 'B'
}
if (type == 1) {
return asciiCompute(num, 1000, ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 0)
} else if (type == -1) {
return asciiCompute(num, 1000, ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], dot)
} else {
return asciiCompute(num, 1000, ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 2)
}
}
function bytes (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 0)
@@ -82,6 +98,15 @@ function bytes (value, index, type = 1, dot) {
return asciiCompute(value, 1024, ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 2)
}
}
function bytesSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 0)
} else if (type == -1) {
return asciiCompute(value, 1000, ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], dot)
} else {
return asciiCompute(value, 1000, ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 2)
}
}
function kilobytes (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 0)
@@ -91,6 +116,15 @@ function kilobytes (value, index, type = 1, dot) {
return asciiCompute(value, 1024, ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 2)
}
}
function kilobytesSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 0)
} else if (type == -1) {
return asciiCompute(value, 1000, ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], dot)
} else {
return asciiCompute(value, 1000, ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 2)
}
}
function megabytes (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 0)
@@ -100,6 +134,15 @@ function megabytes (value, index, type = 1, dot) {
return asciiCompute(value, 1024, ['MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 2)
}
}
function megabytesSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 0)
} else if (type == -1) {
return asciiCompute(value, 1000, ['MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], dot)
} else {
return asciiCompute(value, 1000, ['MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 2)
}
}
function gigabytes (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 0)
@@ -109,6 +152,15 @@ function gigabytes (value, index, type = 1, dot) {
return asciiCompute(value, 1024, ['GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 2)
}
}
function gigabytesSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 0)
} else if (type == -1) {
return asciiCompute(value, 1000, ['GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], dot)
} else {
return asciiCompute(value, 1000, ['GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 2)
}
}
function terabytes (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['TB', 'PB', 'EB', 'ZB', 'YB'], 0)
@@ -118,6 +170,15 @@ function terabytes (value, index, type = 1, dot) {
return asciiCompute(value, 1024, ['TB', 'PB', 'EB', 'ZB', 'YB'], 2)
}
}
function terabytesSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['TB', 'PB', 'EB', 'ZB', 'YB'], 0)
} else if (type == -1) {
return asciiCompute(value, 1000, ['TB', 'PB', 'EB', 'ZB', 'YB'], dot)
} else {
return asciiCompute(value, 1000, ['TB', 'PB', 'EB', 'ZB', 'YB'], 2)
}
}
function petabytes (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['PB', 'EB', 'ZB', 'YB'], 0)
@@ -127,6 +188,15 @@ function petabytes (value, index, type = 1, dot) {
return asciiCompute(value, 1024, ['PB', 'EB', 'ZB', 'YB'], 2)
}
}
function petabytesSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['PB', 'EB', 'ZB', 'YB'], 0)
} else if (type == -1) {
return asciiCompute(value, 1024, ['PB', 'EB', 'ZB', 'YB'], dot)
} else {
return asciiCompute(value, 1024, ['PB', 'EB', 'ZB', 'YB'], 2)
}
}
function packetsSec (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['pps', 'Kpps', 'Mpps', 'Gpps', 'Tpps', 'Ppps', 'Epps', 'Zpps', 'Ypps'], 1)
@@ -137,6 +207,128 @@ function packetsSec (value, index, type = 1, dot) {
}
}
function bitsSec (value, index, type = 1, dot) {
const num = value / 8
if (value < 8) {
return value + 'b'
}
if (num < 1024) {
return num + 'B'
}
if (type == 1) {
return asciiCompute(value, 1024, ['bps', 'Kbps', 'Mbps', 'Gbps', 'Tbps', 'Pbps', 'Epps', 'Zpps', 'Ypps'], 1)
} else if (type == -1) {
return asciiCompute(value, 1024, ['bps', 'Kbps', 'Mbps', 'Gbps', 'Tbps', 'Pbps', 'Epps', 'Zpps', 'Ypps'], dot)
} else {
return asciiCompute(value, 1024, ['bps', 'Kbps', 'Mbps', 'Gbps', 'Tbps', 'Pbps', 'Epps', 'Zpps', 'Ypps'], 2)
}
}
function bytesSec (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['Bs', 'KBs', 'MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 1)
} else if (type == -1) {
return asciiCompute(value, 1024, ['Bs', 'KBs', 'MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], dot)
} else {
return asciiCompute(value, 1024, ['Bs', 'KBs', 'MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 2)
}
}
function kilobytesSec (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['KBs', 'MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 1)
} else if (type == -1) {
return asciiCompute(value, 1024, ['KBs', 'MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], dot)
} else {
return asciiCompute(value, 1024, ['KBs', 'MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 1)
}
}
function kilobitsSec (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['Kbps', 'Mbps', 'Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 1)
} else if (type == -1) {
return asciiCompute(value, 1024, ['Kbps', 'Mbps', 'Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], dot)
} else {
return asciiCompute(value, 1024, ['Kbps', 'Mbps', 'Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 2)
}
}
function megabytesSec (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 1)
} else if (type == -1) {
return asciiCompute(value, 1024, ['MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], dot)
} else {
return asciiCompute(value, 1024, ['MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 2)
}
}
function megabitsSec (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['Mbps', 'Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 1)
} else if (type == -1) {
return asciiCompute(value, 1024, ['Mbps', 'Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], dot)
} else {
return asciiCompute(value, 1024, ['Mbps', 'Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 2)
}
}
function gigabytesSec (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 1)
} else if (type == -1) {
return asciiCompute(value, 1024, ['GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], dot)
} else {
return asciiCompute(value, 1024, ['GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 2)
}
}
function gigabitsSec (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 1)
} else if (type == -1) {
return asciiCompute(value, 1024, ['Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], dot)
} else {
return asciiCompute(value, 1024, ['Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 2)
}
}
function terabytesSec (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 1)
} else if (type == -1) {
return asciiCompute(value, 1024, ['TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], dot)
} else {
return asciiCompute(value, 1024, ['TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 2)
}
}
function terabitsSec (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 1)
} else if (type == -1) {
return asciiCompute(value, 1024, ['Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], dot)
} else {
return asciiCompute(value, 1024, ['Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 2)
}
}
function petabytesSec (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['PBs', 'EBs', 'ZBs', 'YBs'], 1)
} else if (type == -1) {
return asciiCompute(value, 1024, ['PBs', 'EBs', 'ZBs', 'YBs'], dot)
} else {
return asciiCompute(value, 1024, ['PBs', 'EBs', 'ZBs', 'YBs'], 2)
}
}
function petabitsSec (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1024, ['Pbps', 'Ebps', 'Zbps', 'Ybps'], 1)
} else if (type == -1) {
return asciiCompute(value, 1024, ['Pbps', 'Ebps', 'Zbps', 'Ybps'], dot)
} else {
return asciiCompute(value, 1024, ['Pbps', 'Ebps', 'Zbps', 'Ybps'], 2)
}
}
function bitsSecSI (value, index, type = 1, dot) {
const num = value / 8
if (value < 8) {
return value + 'b'
}
if (num < 1000) {
return num + 'B'
}
if (type == 1) {
return asciiCompute(value, 1000, ['bps', 'Kbps', 'Mbps', 'Gbps', 'Tbps', 'Pbps', 'Epps', 'Zpps', 'Ypps'], 1)
} else if (type == -1) {
@@ -145,7 +337,7 @@ function bitsSec (value, index, type = 1, dot) {
return asciiCompute(value, 1000, ['bps', 'Kbps', 'Mbps', 'Gbps', 'Tbps', 'Pbps', 'Epps', 'Zpps', 'Ypps'], 2)
}
}
function bytesSec (value, index, type = 1, dot) {
function bytesSecSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['Bs', 'KBs', 'MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 1)
} else if (type == -1) {
@@ -154,7 +346,7 @@ function bytesSec (value, index, type = 1, dot) {
return asciiCompute(value, 1000, ['Bs', 'KBs', 'MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 2)
}
}
function kilobytesSec (value, index, type = 1, dot) {
function kilobytesSecSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['KBs', 'MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 1)
} else if (type == -1) {
@@ -163,7 +355,7 @@ function kilobytesSec (value, index, type = 1, dot) {
return asciiCompute(value, 1000, ['KBs', 'MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 1)
}
}
function kilobitsSec (value, index, type = 1, dot) {
function kilobitsSecSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['Kbps', 'Mbps', 'Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 1)
} else if (type == -1) {
@@ -172,7 +364,7 @@ function kilobitsSec (value, index, type = 1, dot) {
return asciiCompute(value, 1000, ['Kbps', 'Mbps', 'Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 2)
}
}
function megabytesSec (value, index, type = 1, dot) {
function megabytesSecSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 1)
} else if (type == -1) {
@@ -181,7 +373,7 @@ function megabytesSec (value, index, type = 1, dot) {
return asciiCompute(value, 1000, ['MBs', 'GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 2)
}
}
function megabitsSec (value, index, type = 1, dot) {
function megabitsSecSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['Mbps', 'Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 1)
} else if (type == -1) {
@@ -190,7 +382,7 @@ function megabitsSec (value, index, type = 1, dot) {
return asciiCompute(value, 1000, ['Mbps', 'Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 2)
}
}
function gigabytesSec (value, index, type = 1, dot) {
function gigabytesSecSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 1)
} else if (type == -1) {
@@ -199,7 +391,7 @@ function gigabytesSec (value, index, type = 1, dot) {
return asciiCompute(value, 1000, ['GBs', 'TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 2)
}
}
function gigabitsSec (value, index, type = 1, dot) {
function gigabitsSecSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 1)
} else if (type == -1) {
@@ -208,7 +400,7 @@ function gigabitsSec (value, index, type = 1, dot) {
return asciiCompute(value, 1000, ['Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 2)
}
}
function terabytesSec (value, index, type = 1, dot) {
function terabytesSecSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 1)
} else if (type == -1) {
@@ -217,7 +409,7 @@ function terabytesSec (value, index, type = 1, dot) {
return asciiCompute(value, 1000, ['TBs', 'PBs', 'EBs', 'ZBs', 'YBs'], 2)
}
}
function terabitsSec (value, index, type = 1, dot) {
function terabitsSecSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 1)
} else if (type == -1) {
@@ -226,7 +418,7 @@ function terabitsSec (value, index, type = 1, dot) {
return asciiCompute(value, 1000, ['Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'], 2)
}
}
function petabytesSec (value, index, type = 1, dot) {
function petabytesSecSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['PBs', 'EBs', 'ZBs', 'YBs'], 1)
} else if (type == -1) {
@@ -235,7 +427,7 @@ function petabytesSec (value, index, type = 1, dot) {
return asciiCompute(value, 1000, ['PBs', 'EBs', 'ZBs', 'YBs'], 2)
}
}
function petabitsSec (value, index, type = 1, dot) {
function petabitsSecSI (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['Pbps', 'Ebps', 'Zbps', 'Ybps'], 1)
} else if (type == -1) {
@@ -244,6 +436,7 @@ function petabitsSec (value, index, type = 1, dot) {
return asciiCompute(value, 1000, ['Pbps', 'Ebps', 'Zbps', 'Ybps'], 2)
}
}
function Hertz (value, index, type = 1, dot) {
if (type == 1) {
return asciiCompute(value, 1000, ['Hz', 'KHz', 'MHz', 'GHz', 'THz', 'PHz', 'EHz', 'ZHz', 'YHz'], 1)
@@ -549,37 +742,86 @@ const unitOptions = [
{
value: 6,
compute: bits,
label: 'bits'
label: 'bits(IEC)',
ascii: 1024
},
{
value: 36,
compute: bitsSI,
label: 'bits(SI)',
ascii: 1000
},
{
value: 7,
compute: bytes,
label: 'bytes'
label: 'bytes(IEC)',
ascii: 1024
},
{
value: 37,
compute: bytesSI,
label: 'bytes(SI)',
ascii: 1000
},
{
value: 8,
compute: kilobytes,
label: 'kilobytes'
label: 'kilobytes(IEC)',
ascii: 1024
},
{
value: 38,
compute: kilobytesSI,
label: 'kilobytes(SI)',
ascii: 1000
},
{
value: 9,
compute: megabytes,
label: 'megabytes'
label: 'megabytes(IEC)',
ascii: 1024
},
{
value: 39,
compute: megabytesSI,
label: 'megabytes(SI)',
ascii: 1000
},
{
value: 10,
compute: gigabytes,
label: 'gigabytes'
label: 'gigabytes(IEC)',
ascii: 1024
},
{
value: 40,
compute: gigabytesSI,
label: 'gigabytes(SI)',
ascii: 1000
},
{
value: 11,
compute: terabytes,
label: 'terabytes'
label: 'terabytes(IEC)',
ascii: 1024
},
{
value: 41,
compute: terabytesSI,
label: 'terabytes(SI)',
ascii: 1000
},
{
value: 12,
compute: petabytes,
label: 'petabytes'
label: 'petabytes(IEC)',
ascii: 1024
},
{
value: 42,
compute: petabytesSI,
label: 'petabytes(SI)',
ascii: 1000
}
]
}, // Data end
@@ -590,67 +832,152 @@ const unitOptions = [
{
value: 13,
compute: packetsSec,
label: 'packets/sec'
label: 'packets/sec',
ascii: 1024
},
{
value: 14,
compute: bitsSec,
label: 'bits/sec'
label: 'bits/sec(IEC)',
ascii: 1024
},
{
value: 43,
compute: bitsSecSI,
label: 'bits/sec(SI)',
ascii: 1000
},
{
value: 15,
compute: bytesSec,
label: 'bytes/sec'
label: 'bytes/sec(IEC)',
ascii: 1024
},
{
value: 44,
compute: bytesSecSI,
label: 'bytes/sec(SI)',
ascii: 1000
},
{
value: 16,
compute: kilobytesSec,
label: 'kilobytes/sec'
label: 'kilobytes/sec(IEC)',
ascii: 1024
},
{
value: 45,
compute: kilobytesSecSI,
label: 'kilobytes/sec(SI)',
ascii: 1000
},
{
value: 17,
compute: kilobitsSec,
label: 'kilobits/sec'
label: 'kilobits/sec(IEC)',
ascii: 1024
},
{
value: 46,
compute: kilobitsSecSI,
label: 'kilobits/sec(SI)',
ascii: 1000
},
{
value: 18,
compute: megabytesSec,
label: 'megabytes/sec'
label: 'megabytes/sec(IEC)',
ascii: 1024
},
{
value: 47,
compute: megabytesSecSI,
label: 'megabytes/sec(SI)',
ascii: 1000
},
{
value: 19,
compute: megabitsSec,
label: 'megabits/sec'
label: 'megabits/sec(IEC)',
ascii: 1024
},
{
value: 48,
compute: megabitsSecSI,
label: 'megabits/sec(SI)',
ascii: 1000
},
{
value: 20,
compute: gigabytesSec,
label: 'gigabytes/sec'
label: 'gigabytes/sec(IEC)',
ascii: 1024
},
{
value: 49,
compute: gigabytesSecSI,
label: 'gigabytes/sec(SI)',
ascii: 1000
},
{
value: 21,
compute: gigabitsSec,
label: 'gigabits/sec'
label: 'gigabits/sec(IEC)',
ascii: 1024
},
{
value: 50,
compute: gigabitsSec,
label: 'gigabits/sec(SI)',
ascii: 1000
},
{
value: 22,
compute: terabytesSec,
label: 'terabytes/sec'
label: 'terabytes/sec(IEC)',
ascii: 1024
},
{
value: 51,
compute: terabytesSecSI,
label: 'terabytes/sec(SI)',
ascii: 1000
},
{
value: 23,
compute: terabitsSec,
label: 'terabits/sec'
label: 'terabits/sec(IEC)',
ascii: 1024
},
{
value: 52,
compute: terabitsSecSI,
label: 'terabits/sec(SI)',
ascii: 1000
},
{
value: 24,
compute: petabytesSec,
label: 'petabytes/sec'
label: 'petabytes/sec(IEC)',
ascii: 1024
},
{
value: 53,
compute: petabytesSecSI,
label: 'petabytes/sec(SI)',
ascii: 1000
},
{
value: 25,
compute: petabitsSec,
label: 'petabits/sec'
label: 'petabits/sec(IEC)',
ascii: 1024
},
{
value: 54,
compute: petabitsSecSI,
label: 'petabits/sec(SI)',
ascii: 1000
}
]
}, // DataRate end
@@ -739,7 +1066,7 @@ export default {
unitOptions: function () {
return unitOptions
},
getUnit: function (index) {
getUnit: function (value) {
if (units.length < 1) {
unitOptions.forEach((item, index) => {
item.children.forEach((n, i) => {
@@ -747,13 +1074,15 @@ export default {
})
})
}
return units[index - 1]
return units.find(item => item.value === value)
},
formatData: function (value, unit) {
return this.getUnit(unit).compute(value, null, 2)
},
formatDatas: function (value, type, flow = 'ceil', ascii) {
formatDatas: function (value, unit, flow = 'ceil') {
let pow = 0
const ascii = unit.ascii || 1000
const type = unit.type
if (value < 1 && value != 0) {
while (value < 1) {
pow++
@@ -767,19 +1096,19 @@ export default {
if (type === 'Data') {
if (value > 1) {
while (value > 1024) {
while (value > ascii) {
pow++
value = value / 1024
value = value / ascii
}
if (flow === 'ceil') {
const length = JSON.stringify(Math.ceil(value)).length
value = value / Math.pow(10, length - 1)
return Math.ceil(value) * Math.pow(1024, pow) * Math.pow(10, length - 1)
return Math.ceil(value) * Math.pow(ascii, pow) * Math.pow(10, length - 1)
} else if (flow === 'floor') {
const length = JSON.stringify(Math.floor(value)).length
value = value / Math.pow(10, length - 1)
return Math.floor(value) * Math.pow(1024, pow) * Math.pow(10, length - 1)
return Math.floor(value) * Math.pow(ascii, pow) * Math.pow(10, length - 1)
}
} else {
return value
@@ -788,19 +1117,19 @@ export default {
if (type === 'Misc' || type === 'DataRate') {
if (value > 1) {
while (value > 1000) {
while (value > ascii) {
pow++
value = value / 1000
value = value / ascii
}
if (flow === 'ceil') {
const length = JSON.stringify(Math.ceil(value)).length
value = value / Math.pow(10, length - 1)
return Math.ceil(value) * Math.pow(1000, pow) * Math.pow(10, length - 1)
return Math.ceil(value) * Math.pow(ascii, pow) * Math.pow(10, length - 1)
} else if (flow === 'floor') {
const length = JSON.stringify(Math.floor(value)).length
value = value / Math.pow(10, length - 1)
return Math.floor(value) * Math.pow(1000, pow) * Math.pow(10, length - 1)
return Math.floor(value) * Math.pow(ascii, pow) * Math.pow(10, length - 1)
}
} else {
return value
@@ -823,7 +1152,10 @@ export default {
case 10: return 5
}
},
Interval: function (value, copies, type, interValType) {
Interval: function (value, copies, unit, interValType) {
console.log(unit)
const type = unit.type
const ascii = unit.ascii || 1000
if (!copies) {
copies = 1
}
@@ -834,12 +1166,12 @@ export default {
return value || 1
}
if (value < 1024 && type === 'Data') {
if (value < ascii && type === 'Data') {
let interVal = value / copies
interVal = !isNaN(interVal) ? interVal : 1
return interVal
}
if (value < 1000 && (type === 'DataRate' || type === 'Misc')) {
if (value < ascii && (type === 'DataRate' || type === 'Misc')) {
let interVal = value / copies
interVal = !isNaN(interVal) ? interVal : 1
return interVal
@@ -848,17 +1180,17 @@ export default {
let interVal = value / copies
let pow = 0
if (interVal) {
while (interVal > 1024) {
while (interVal > ascii) {
pow++
interVal = interVal / 1024
interVal = interVal / ascii
}
interVal = Math.ceil(interVal) * Math.pow(1024, pow)
interVal = Math.ceil(interVal) * Math.pow(ascii, pow)
}
interVal = !isNaN(interVal) ? interVal : 1
if (interVal >= 1 && interVal <= 512) {
interVal = 512
} else if (interVal > 512 && interVal <= 1024) {
interVal = 1024
if (interVal >= 1 && interVal <= ascii / 2) {
interVal = ascii / 2
} else if (interVal > 512 && interVal <= ascii) {
interVal = ascii
}
return interVal
}
@@ -866,11 +1198,11 @@ export default {
let interVal = value / copies
let pow = 0
if (interVal) {
while (interVal > 1000) {
while (interVal > ascii) {
pow++
interVal = interVal / 1000
interVal = interVal / ascii
}
interVal = Math.ceil(interVal) * Math.pow(1000, pow)
interVal = Math.ceil(interVal) * Math.pow(ascii, pow)
}
interVal = !isNaN(interVal) ? interVal : 1
return interVal

2
nezha-fronted/src/components/chart/chartMixin.js
View File

@@ -405,7 +405,7 @@ export default {
maxValue = Math.abs(minValue)
}
maxValue = maxValue - minValue
maxValue = chartDataFormat.formatDatas(maxValue, unit.type, 'ceil', unit.ascii)
maxValue = chartDataFormat.formatDatas(maxValue, unit, 'ceil', unit.ascii)
let oldValue = maxValue
if (maxValue < 0) {
oldValue = Math.abs(maxValue)

1
nezha-fronted/src/components/chart/panelChart.vue
View File

@@ -436,6 +436,7 @@ export default {
if (this.chartInfo.type === 'log') {
this.logChartDataFormat()
}
console.log(this.$lodash.cloneDeep(this.chartData), '123123')
}).catch(res => {
// console.info(res)
}).finally(() => {

18
nezha-fronted/src/components/chart/renderChart.js
View File

@@ -5,6 +5,7 @@ import { formatScientificNotation } from '@/components/common/js/tools'
export default {
methods: {
renderYAxis (chartDatas, chartInfo, type) {
console.log(chartDatas, '1')
let chartData = lodash.cloneDeep(chartDatas)
if (type === 'legend') {
chartData.forEach(item => {
@@ -12,6 +13,7 @@ export default {
})
chartData = chartData.map(item => [item])
}
console.log(chartDatas, '2')
const decimals = chartInfo.param.decimals || 2
const chartOption = {
yAxis: [
@@ -30,9 +32,10 @@ export default {
}
// 左y轴
const leftData = chartData.filter(item => item[0] && !item[0].yAxisIndex)
console.log(chartDatas, '3')
const leftInfo = this.getMinMaxFromData(leftData, chartInfo.unit, chartInfo.param) //
chartOption.yAxis[0].minInterval = chartDataFormat.Interval(leftInfo.maxValue, leftInfo.copies, leftInfo.unit.type, 'min')
chartOption.yAxis[0].maxInterval = chartDataFormat.Interval(leftInfo.maxValue, leftInfo.copies, leftInfo.unit.type, 'max') * Math.ceil(this.series.length / 5)
chartOption.yAxis[0].minInterval = chartDataFormat.Interval(leftInfo.maxValue, leftInfo.copies, leftInfo.unit, 'min')
chartOption.yAxis[0].maxInterval = chartDataFormat.Interval(leftInfo.maxValue, leftInfo.copies, leftInfo.unit, 'max') * Math.ceil(this.series.length / 5)
if (chartInfo.param.stack) {
chartOption.yAxis[0].maxInterval = chartOption.yAxis[0].maxInterval * (Math.ceil(leftData.length / 5) + 1)
}
@@ -61,11 +64,16 @@ export default {
// 如果全都为右y轴数据 则右y轴显示网格
const unit = chartDataFormat.getUnit(lodash.get(chartInfo, 'param.rightYAxis.unit', 2))
const allRight = this.series.every(item => item.yAxisIndex == 1)
console.log(allRight)
chartOption.yAxis[1].splitLine.show = allRight
console.log(chartDatas, '4')
const rightData = chartData.filter(item => item[0] && item[0].yAxisIndex)
console.log(chartDatas, '5')
console.log(rightData)
const rightInfo = this.getMinMaxFromData(rightData, lodash.get(chartInfo, 'param.rightYAxis.unit', 2), lodash.get(chartInfo, 'param.rightYAxis', {}))//
chartOption.yAxis[1].minInterval = chartDataFormat.Interval(rightInfo.maxValue, rightInfo.copies, rightInfo.unit.type, 'min')
chartOption.yAxis[1].maxInterval = chartDataFormat.Interval(rightInfo.maxValue, rightInfo.copies, rightInfo.unit.type, 'max') * Math.ceil(this.series.length / 5)
console.log(rightInfo)
chartOption.yAxis[1].minInterval = chartDataFormat.Interval(rightInfo.maxValue, rightInfo.copies, rightInfo.unit, 'min')
chartOption.yAxis[1].maxInterval = chartDataFormat.Interval(rightInfo.maxValue, rightInfo.copies, rightInfo.unit, 'max') * Math.ceil(this.series.length / 5)
if (chartInfo.param.stack) {
chartOption.yAxis[1].maxInterval = chartOption.yAxis[1].maxInterval * (Math.ceil(rightData.length / 5) + 1)
}
@@ -158,7 +166,7 @@ export default {
maxValue = Math.abs(minValue)
}
maxValue = maxValue - minValue
maxValue = chartDataFormat.formatDatas(maxValue, unit.type, 'ceil', unit.ascii) // 取最大值后 需要对其进行取整
maxValue = chartDataFormat.formatDatas(maxValue, unit, 'ceil', unit.ascii) // 取最大值后 需要对其进行取整
let oldValue = maxValue
let dot = 0
if (oldValue == 1) {

2
nezha-fronted/src/components/common/bottomBox/tabs/endpointTabNew.vue
View File

@@ -267,7 +267,9 @@ export default {
this.object.paramObj.push({ key: '', value: [] })
}
this.object.assetName = this.object.asset ? this.object.asset.name : ''
this.object.softwareAssetName = this.object.softwareAsset ? this.object.softwareAsset.name : ''
this.object.assetId = this.object.asset ? this.object.asset.id + '' : ''
this.object.softwareAssetId = this.object.softwareAsset ? this.object.softwareAsset.id + '' : ''
this.object.projectId = this.object.project.id
this.object.moduleId = this.object.module.id
this.object.type = this.object.module.type

4
nezha-fronted/src/components/common/bottomBox/tabs/licenseManagementTab.vue
View File

@@ -86,6 +86,7 @@ export default {
async handler (n) {
if (n) {
this.searchLabel = {}
this.tableData = []
this.getTableData()
}
}
@@ -152,6 +153,9 @@ export default {
this.toTopBtnHandler(this.scrollbarWrap)
})
}
} else {
console.log(response)
this.$message.error(response.msg || response.error)
}
})
},

4
nezha-fronted/src/components/common/table/asset/licenseMangeTable.vue
View File

@@ -110,13 +110,13 @@ export default {
tableTitle: [ // 原始table列
{
label: this.$t('licenseMange.product'),
prop: 'typename',
prop: 'name',
show: true,
width: 350
// sortable: 'custom'
}, {
label: this.$t('licenseMange.keyType'),
prop: 'name',
prop: 'typename',
minWidth: 200,
show: true
}, {

2
nezha-fronted/src/components/page/dashboard/overview/chart.vue
View File

@@ -684,7 +684,7 @@ export default {
maxValue = Math.abs(minValue)
}
maxValue = maxValue - minValue
maxValue = chartDataFormat.formatDatas(maxValue, unit.type, 'ceil', unit.ascii)
maxValue = chartDataFormat.formatDatas(maxValue, unit, 'ceil', unit.ascii)
let oldValue = maxValue
let dot = 0
if (maxValue == 1) {