Skip to content

V
visualDataServer
Commit c218dd52 by lixinming
Options

no message

parent 136736b6
Showing with 790 additions and 88 deletions
src/cal/encapsulation.ts 0 → 100644
//封装数据 变成可以给out使用的格式
import { BizError } from "../util/bizError";
import { separateDataAndUint } from "./privateTools";
//主要逻辑 做类型验证等
const assert = require('assert');
/**
* stringListPackage 打包验证并返回 getStringOut 需要的格式
* @param dataList ["","",""]
* @returns ["","",""]
*/
export function stringListPackage(dataList) {
// //todo不做验证，只做判空
let result = [];
dataList.forEach((str, index) => {
checkingError({str, index}, errorEnum.类型为string);
});
return result;
}
/**
* onceYBarChartPackage 打包验证并返回 getOnceYBarChartOut 需要的格式
* @param dataList [{name:"", data:[{key, value}...] }]
* @param yUnit y轴单位
* @param xUnit x轴单位
* @returns {xUnit:x轴单位, yUnit:y单位, dataInfo:{"图表名称":[{key:"数据key", value:"数据值", unit:"单位" }, {key:"数据key", value:"数据值", unit:"单位" } ] } }
*/
export function onceYBarChartPackage(inDataList, inYUnit, inXUnit="") {
let dataInfo = {};
const InYUnitIsNull = !inYUnit;
let checkingDataHaveUnitMap = {};
let yUnit = "";
inDataList.forEach(info => {
let name = info.name;
let data = info.data;
checkingError({name, data}, errorEnum.必要参数);
let onceDataList = [];
//判空 去重
let distinctMap = {};
//验证工作
data.forEach(subInfo => {
let key = subInfo.key;
let value = subInfo.value;
checkingError({name, key}, errorEnum.数据key是否为空);
checkingError({name, value}, errorEnum.数据value是否为数值);
checkingError({name, distinctMap, key}, errorEnum.barChart中x轴的key重复出现);
distinctMap[key] = 1;
let {dataNum, dataUnit} = separateDataAndUint(value);
checkingDataHaveUnitMap[dataUnit] = 1;
onceDataList.push({key, value:dataNum, unit:dataUnit|| "" });
});
dataInfo[name] = onceDataList;
});
let dataUnitList = Object.keys(checkingDataHaveUnitMap);
let dataHaveUnitCount = dataUnitList.length;
if (!dataHaveUnitCount && InYUnitIsNull ) {
//todo 这里可以加逻辑 挖个坑
} else if(dataHaveUnitCount> 1) throw new BizError(`在 onceYBarChartPackage 中 单个y轴的柱状图中出现多个单位:${JSON.stringify(dataUnitList)}`);
else {
yUnit = dataUnitList[0] || inYUnit;
for (let key in dataInfo) {
dataInfo[key].forEach(info => {
info.unit = yUnit;
});
}
}
return {xUnit:inXUnit, yUnit, dataInfo };
}
/**
* doubleYBarCharPackage 打包验证并返回 getDoubleYBarChartOut 需要的格式
* @param leftYUnit
* @param rightYUnit
* @param leftYData [{name:"", data:[{key, value}...] }]
* @returns {xUnit:x轴单位, leftYUnit:左边y单位, rightYUnit:右边y单位 dataInfo:{"图表名称":{from:"left", subList:[{key:"数据key", value:"数据值", unit:"单位" }, {key:"数据key", value:"数据值", unit:"单位" } ]} } }
*/
export function doubleYBarCharPackage(inLeftYUnit, inRightYUnit, leftYData, rightYData, xUnit = "") {
let leftAndRightDistinctMap = {};//比对两种图表名称有没有冲突
let dataInfo = {};
let leftUnitDistinctMap = {};
let rightUnitDistinctMap = {};
function checkOnceData(subFunCheckingList, dataType) {
subFunCheckingList.forEach(info => {
let name = info.name;
let data = info.data;
checkingError({name, data}, errorEnum.必要参数);
if (leftAndRightDistinctMap[name]) throw new BizError(`在 doubleYBarCharPackage 中leftYData 和 rightYData 重复出现了 ${name}`);
leftAndRightDistinctMap[name] = 1;
let subList = [];
let distinctMap = {};
data.forEach(subInfo => {
let key = subInfo.key;
let value = subInfo.value;
checkingError({name, key}, errorEnum.数据key是否为空);
checkingError({name, value}, errorEnum.数据value是否为数值);
checkingError({name, distinctMap, key}, errorEnum.barChart中x轴的key重复出现);
distinctMap[key] = 1;
let {dataNum, dataUnit} = separateDataAndUint(value);
if (dataUnit) dataType == "left" ? leftUnitDistinctMap[dataUnit] = 1 : rightUnitDistinctMap[dataUnit] = 1;
subList.push({key, value:dataNum, unit:dataUnit || ""});
});
dataInfo[name] = {from:dataType, subList};
});
}
checkOnceData(leftYData, "left");
checkOnceData(rightYData, "right");
let leftUnitList = Object.keys(leftUnitDistinctMap);
let leftUnitCount = leftUnitList.length;
let rightUnitList = Object.keys(rightUnitDistinctMap);
let rightUnitCount = rightUnitList.length;
if (leftUnitCount > 1) throw new BizError(`在 onceYBarChartPackage 中 双y轴的柱状图中 leftData数据中出现了多个单位:${JSON.stringify(leftUnitList)}`);
if (rightUnitCount > 1) throw new BizError(`在 onceYBarChartPackage 中 双y轴的柱状图中 rightData数据中出现多个单位:${JSON.stringify(rightUnitList)}`);
let leftYUnit = leftUnitList[0] || inLeftYUnit;
let rightYUnit = rightUnitList[0] || inRightYUnit;
for (let key in dataInfo) {
let {from } = dataInfo[key];
dataInfo[key].forEach(info => {
if (from == "left") info.unit = leftYUnit;
else info.unit = rightYUnit;
});
}
return {xUnit, leftYUnit, rightYUnit, dataInfo };
}
/**
* tablePackage 获得 getTableOut 需要的数据
* @titleList ["","","",""]
* @param data [[a,b,c],[a,b,c],[a,b,c],[a,b,c]]
* @returns {titleList:[], dataList:[{a,b,c},{a,b,c},{a,b,c}] }
*/
export function tablePackage(titleList, data) {
var aForZkeyList = [];
for(var i = 65; i < 91; i++){
aForZkeyList.push(String.fromCharCode(i));
}
//验证长度
let dataMaxLenght = 0;
let dataList = [];
data.forEach(subDataList => {
let onceData = {};
subDataList.forEach((info, index) => {
let key = aForZkeyList[index];
onceData[key] = info || "";
});
dataMaxLenght = Math.max(dataMaxLenght, subDataList.length);
dataList.push(onceData);
});
if (titleList.length < dataMaxLenght) throw new BizError( `在 tablePackage 中 titleList长度比单个data最大长度小 titleList长度 ${titleList.length} 单个数据个数 ${dataMaxLenght}"`);
return {titleList, dataList};
}
/**
* keyValuePackage 将返回 getKeyValueOut 所需要的数据格式
* @param dataList [{key, value}]
* @returns [{key:"", value:"", unit:""}]
*/
export function keyValuePackage(dataList) {
let data = [];
dataList.forEach(info => {
let key = info.key;
let value = info.value;
checkingError({value, key}, errorEnum.数据key是否为空);
let {dataNum, dataUnit} = separateDataAndUint(value);
let analysisValue;
let analysisUnit;
if (isNaN(dataNum) || dataUnit == value){
analysisValue = value;
analysisUnit = "";
} else {
analysisValue = dataNum;
analysisUnit = dataUnit;
}
data.push({key, value:analysisValue, unit:analysisUnit });
});
return data;
}
/**
* objectListPackage 将返回 getObjectListOut 所需要的数据格式
* @param dataList [{key...}]
* @returns [{key...}]
*/
export function objectListPackage(dataList) {
let data = [];
dataList.forEach(info => {
let addInfo = {};
for (let key in info) {
checkingError({key, value:info[key]}, errorEnum.值为undefined或null);
addInfo[key] == info;
}
data.push(addInfo);
});
return data;
}
/**
* rankPackage 将返回 getRankOut 需要的数据
* @param orderIsDesc 默认 true desc(降序,从大到小)
* @param data [{key, value, details}]
* @param max 最大值
* @param unit 单位
* @returns {unit, max, dataInfo:[{key, value, details, unit}, {}, {}, {}] }
*/
export function rankPackage(data, orderIsDesc = true, unit?, max?) {
let dataInfo = [];
let valueIsString = false;
let dataUnitDistinctMap = {};
data.forEach( info => {
let key = info.key;
let value = info.value;
let details = info.details || "";
let onceUnit = "";
checkingError({key}, errorEnum.数据key是否为空);
if ((value == undefined || value == null) || `${value}`.search(/^(-)?\d+(\.\d+)?/) == -1 ) {
valueIsString = true;
} else {
let {dataNum, dataUnit} = separateDataAndUint(value);
if (dataUnit) {
dataUnitDistinctMap[dataUnit] = 1;
onceUnit = dataUnit;
}
value = dataNum;
}
dataInfo.push({key, value, details, unit:onceUnit});
});
let dataUnitList = Object.keys(dataUnitDistinctMap);
if (dataUnitList.length > 1) throw new BizError(`在 rankPackage 中 数据中的value解析出来不统一的单位:${JSON.stringify(dataUnitList)}`);
if (dataUnitList.length && unit && unit != dataUnitList.length) throw new BizError(`在 rankPackage 中 入参单位${unit} 与 数据中解析出来的单位 ${dataUnitList[0]} 不一致`);
let dataUnit = dataUnitList[0] || unit;
//统一单位
dataInfo.forEach(info => {info.unit = dataUnit});
if (!valueIsString) {
dataInfo.sort( (a, b) => {
return orderIsDesc ? b.value - a.value : a.value - b.value;
});
}
return {unit:dataUnit, max:max || 0, dataInfo};
}
/**
* radarChartPackage 将会返回 getRadarChartOut 需要的数据
* @param data [{key, value, max}]
* @returns [{key, value, max, unit}]
*/
export function radarChartPackage(data) {
let dataList = [];
data.forEach(info => {
let key = info.key;
let value = info.value;
let max = info.max;
checkingError({key}, errorEnum.数据key是否为空);
checkingError({name:key, value}, errorEnum.数据value是否为数值);
let {dataNum, dataUnit} = separateDataAndUint(value);
dataList.push({key, value:dataNum, unit:dataUnit, max});
});
return data;
}
/**
* mapPackage 返回 getMapOut 所需要的数据
* @param data [{key:数据名称, x:x坐标, y:坐标, longitude:经度, latitude:纬度, value:值, details:补充}]
* @returns [{name:数据名称, x:x坐标, y:坐标, coordinate:[经度, 纬度], unit:单位, value:值, details:"补充"}]
*/
export function mapPackage(data, isCoordinate=true, isXY=false) {
let dataList = [];
data.forEach((info, index) => {
checkingError({key:info.key}, errorEnum.数据key是否为空);
let longitude = info.longitude;
let latitude = info.latitude;
let x = info.x;
let y = info.y;
let addInfo:any = {key:info.key, details:info.details || ""};
checkingError({x, y, longitude, latitude, index}, errorEnum.地图坐标判空);
if (isCoordinate) {
longitude = isUndefinedOrNull(longitude) ? 0 : longitude;
latitude = isUndefinedOrNull(latitude) ? 0 : latitude;
let coordinate = [longitude, latitude];
addInfo.coordinate = coordinate;
}
if (isXY) {
x = isUndefinedOrNull(x) ? 0 : x;
y = isUndefinedOrNull(y) ? 0 : y;
addInfo.x = x;
addInfo.y = y;
}
let value;
let unit = "";
if (info.value && `${info.value}`.search(/^(-)?\d+(\.\d+)?/) > -1) {
let {dataNum, dataUnit} = separateDataAndUint(info.value);
value = dataNum;
unit = dataUnit;
} else if (info.value && `${info.value}`.search(/^(-)?\d+(\.\d+)?/) == -1) {
value = info.value;
} else value = "";
dataList.push(addInfo);
});
return dataList;
}
/**
* scatterFigurePackage 返回 getScatterFigureOutData 需要的格式
* @param data [{x, y, name}, {x, y, name}, {x, y, name}, {x, y, name}]
* @returns [{x, y, name}, {x, y, name}, {x, y, name}, {x, y, name}]
*/
export function scatterFigurePackage(data) {
let dataList = [];
data.forEach((info, index) => {
let x = info.x;
let y = info.y;
checkingError({x, y, index}, errorEnum.散点图判空);
dataList.push({x, y, name:info.name || ""});
});
return dataList;
}
enum errorEnum {
必要参数 = 1,
数据key是否为空,
数据value是否为数值,
类型为string,
barChart中x轴的key重复出现,
值为undefined或null,
地图坐标判空,
散点图判空
};
function checkingError(param, errorEnumType) {
let str = ``;
let isError = false;
switch(errorEnumType) {
case errorEnum.类型为string:
if ( typeof param.str != "string") {
isError = true;
str += `下标为${param.index}的数据 不为string,当前为${param.str}`;
}
break;
case errorEnum.必要参数:
let paramNullErrorStr = '必要参数: ';
for (let key in param) {
if (!param[key]) {
isError = true;
paramNullErrorStr += `${key}为空 `;
}
}
str += paramNullErrorStr;
break;
case errorEnum.数据key是否为空 :
if (!param.key) {
isError = true;
str += `${param.name}中有key缺失数据`;
}
break;
case errorEnum.数据value是否为数值:
if (`${param.value}`.search(/^(-)?\d+(\.\d+)?/) == -1) {
isError = true;
str += `${param.name}中 key为${param.key} 的数据为字符串`;
}
break;
case errorEnum.barChart中x轴的key重复出现:
if (param.distinctMap[param.key]) {
isError = true;
str += `${param.name}中 key为${param.key} 在数据中重复出现`;
}
break;
case errorEnum.值为undefined或null:
if ( isUndefinedOrNull(param.value) ) {
isError = true;
str += `${param.key}的值 为 undefined 或 null`;
}
break;
case errorEnum.地图坐标判空:
if (isUndefinedOrNull(param.x) && isUndefinedOrNull(param.y) && isUndefinedOrNull(param.longitude) && isUndefinedOrNull(param.latitude)) {
isError = true;
str += `第${param.index+1}个数据中坐标异常 所有表示坐标的属性都为空`;
}
if ( (isUndefinedOrNull(param.x) || isUndefinedOrNull(param.y)) && isUndefinedOrNull(param.longitude) || isUndefinedOrNull(param.latitude) ) {
isError = true;
str += `第${param.index+1}个数据中坐标异常 xy坐标缺失的同时经纬度也缺失`;
}
break;
case errorEnum.散点图判空:
if (isUndefinedOrNull(param.x) || isUndefinedOrNull(param.y)) {
isError = true;
str += `第${param.index+1}个数据中坐标异常 x为${param.x} y为${param.y}`;
}
break;
}
if (isError) {
Error.prepareStackTrace = function(_, stack) { return stack; };
let err = new Error;
let stack:any = err.stack;
let funName = stack[1].getFileName(); // stack[0]为当前函数, stack[1]为调用者，stack[2]为上层调用者
throw new BizError(`在 ${funName} 中 ${str}`);
}
}
function isUndefinedOrNull(paramater) {
return paramater == undefined || paramater == null;
}
\ No newline at end of file
src/cal/out.ts
import { getUnitMaxOccNum, separateDataAndUint, unifiedMaxAndMinValueAndStep } from "./privateTools"; import { getUnitMaxOccNum, separateDataAndUint, unifiedMaxAndMinValueAndStep } from "./privateTools";
//标准化输出 这里的东西禁止 乱改以及临时更改
//此层只做出口封装 尽量减少数据处理的逻辑 逻辑放在上一层
/** /**
* getStringOutData 获取文字列表返回结果 * getStringOut 获取文字列表返回结果
* @param title 数据标题 * @param title 数据标题
* @param data 数据体 格式:["txt...", "str..."] * @param data 数据体 格式:["txt...", "str..."]
* @returns {title, dataList:[string...]} * @returns {title, dataList:[string...]}
*/ */
export function getStringOutData(title, data) { export function getStringOut(title, data) {
let dataList = []; let dataList = [];
data.forEach( (str, index) => { data.forEach( (str) => {
dataList.push({ key:index+1, value:str}); dataList.push(str);
}); });
return { title, dataList}; return { title, dataList};
} }
/** /**
* getChartData 获取图表返回结果 * getOnceYBarChartOut 获取单y轴柱状图
* @param title 数据标题 * @param title 数据标题
* @param data 数据体 格式：{"图表名称":{unit:"", dataInfo:[{key:"数据key", value:"数据值"}, {key:"数据key", value:"数据值"} ] } } * @param data 数据体 格式： {xUnit:x轴单位, yUnit:y单位, dataInfo:{"图表名称":[{key:"数据key", value:"数据值", unit:"单位" }, {key:"数据key", value:"数据值", unit:"单位" } ] } }
* @param haveMoreY 是否有多个y轴 默认false * @returns {title:标题, xUnit:x轴单位, yUnit:y轴单位, yMinValue:最小值, yMaxValue:最大值, yStepValue:间隔,
* @returns {title:标题, dataList:[{unit:单位, total:总数, yMinValue:最小值, yMaxValue:最大值, yStepValue:间隔, dataList:[{key:value}] }]} * dataList:[{subTitle:数据名称, total:总数, unit:单位, subDataList:[{name:y轴名称, value:值, unit:单位}] } ]}
* 入参data里面的dataInfo中的unit可以为空 会读取yUnit 所以入参优先度 yUnit > unit 默认值都是空字符串
*/ */
export function getChartOutData(title, data) { export function getOnceYBarChartOut(title, data, stepCount?) {
let dataList = []; let dataList = [];
let {xUnit, yUnit, dataInfo} = data;
for (let chartName in data) { let thisYUnit = yUnit ||"";
let { unit, dataInfo } = data[chartName];
let addData:any = { title: chartName }; let min = new Date().valueOf();
let max = 0;
for (let dataName in dataInfo) {
let onceChartList = data[dataName];
let max = 0; let subDataList = [];
let min = new Date().valueOf();
let total = 0; let total = 0;
let thisUnitStats = {};
let onceDataList = []; onceChartList.forEach(item => {
for (let i = 0; i < dataInfo.length; i++) { let {key, value, unit} = item;
let { key, value } = dataInfo[i]; min = Math.min(value, min);
let { dataNum, dataUnit } = separateDataAndUint(value); max = Math.max(value, max);
min = Math.min(min, dataNum); total += value;
max = Math.max(max, dataNum); subDataList.push({name:key, value, unit: unit || thisYUnit});
thisUnitStats[dataUnit] = thisUnitStats[dataUnit] ? thisUnitStats[dataUnit] + 1 : 1; });
total += dataNum;
dataList.push({subTitle:dataName, total, unit:thisYUnit, subDataList});
onceDataList.push({key, value:dataNum, unit:dataUnit});
}
let statsUnit = getUnitMaxOccNum(thisUnitStats);
let thisChartUnit = unit || statsUnit || "";
addData["unit"] = thisChartUnit;
addData["total"] = total;
let {maxNumber, minNumber, stepNumber} = unifiedMaxAndMinValueAndStep(max, min);
addData["yMinValue"] = minNumber;
addData["yMaxValue"] = maxNumber;
addData["yStepValue"] = stepNumber;
addData["dataList"] = onceDataList;
dataList.push(addData);
} }
let {maxNumber, minNumber, stepNumber} = unifiedMaxAndMinValueAndStep(max, min, stepCount);
return {title, dataList}; return {title, xUnit, yUnit:thisYUnit, yMinValue:minNumber, yMaxValue:maxNumber, yStepValue:stepNumber, dataList};
} }
/** /**
* getListOutData 获取列表返回结果 * getDoubleYBarChartOut 获取双y轴柱状图
* @param title 数据标题
* @param data 数据体 格式：{xUnit:x轴单位, leftYUnit:左边y单位, rightYUnit:右边y单位 dataInfo:{"图表名称":{from:"left", subList:[{key:"数据key", value:"数据值", unit:"单位" }, {key:"数据key", value:"数据值", unit:"单位" } ]} } }
* @returns {title:标题, xUnit:x轴单位, leftYUnit:左边单位, rightYUnit:右边单位, leftYMinValue:左边最小值, leftYMaxValue:左边最大值, leftYStepValue:左边间隔,
* rightYMinValue:右边最小值, rightYMaxValue:右边最大值, rightYStepValue:右边间隔,
* dataList:[{subTitle:数据名称, total:总数, unit:单位, subDataList:[{name:y轴名称, value:值, unit:单位}] }] }
* 入参data里面的dataInfo中的unit可以为空 会读取yUnit 所以入参优先度 yUnit > unit 默认值都是空字符串
*/
export function getDoubleYBarChartOut(title, data, stepCountInfo?) {
stepCountInfo = stepCountInfo || {left:5, right:5};
let dataList = [];
let {xUnit, leftYUnit, rightYUnit, dataInfo} = data;
let thisLeftYUnit = leftYUnit || "";
let thisRightYUnit = rightYUnit || "";
let leftMin = new Date().valueOf();
let leftMax = 0;
let rightMin = new Date().valueOf();
let rightMax = 0;
for (let dataName in dataInfo) {
let {subList, from} = data[dataName];
let subDataList = [];
let total = 0;
let thisDataUnit = from == "left" ? thisLeftYUnit : thisRightYUnit;
subList.forEach(item => {
let {key, value, unit} = item;
if (from == "left") {
leftMin = Math.min(value, leftMin);
leftMax = Math.max(value, leftMax);
} else {
rightMin = Math.min(value, rightMin);
rightMax = Math.max(value, rightMax);
}
total += value;
subDataList.push({name:key, value, unit:unit || thisDataUnit});
});
dataList.push({subTitle:dataName, total, unit:thisDataUnit, subDataList});
}
let leftInfo = unifiedMaxAndMinValueAndStep(leftMax, leftMin,stepCountInfo.left);
let rightInfo = unifiedMaxAndMinValueAndStep(rightMax, rightMin,stepCountInfo.right);
return {title, xUnit, leftYUnit:thisLeftYUnit, rightYUnit:thisRightYUnit, leftYMinValue:leftInfo.minNumber, leftYMaxValue:leftInfo.maxNumber, leftYStepValue:leftInfo.stepNumber,
rightYMinValue:rightInfo.minNumber, rightYMaxValue:rightInfo.maxNumber, rightYStepValue:rightInfo.stepNumber, dataList}
}
/**
* getTableOut 获取列表返回
* @param title 数据标题 * @param title 数据标题
* @param data 数据体 格式：[{key:"key1", values:[data1value1, data2value1, data3value1] }, {key:"key2", values:[data1value2, data2value2, data3value2] }] * @param data 数据体 格式：{titleList:[], dataList:[{a,b,c},{a,b,c},{a,b,c}] }
* @returns {title:数据标题, total:数据总条数, titleList:[表头...], valueList:[[数据列表...],[数据列表...]]} * @returns {title:数据标题, total:数据总条数, titleList:[表头...], valueList:[[a,b,c,d...],[a,b,c,d...]] }
* 解出来的对象的key是需要有顺序的，所以进这里之前要把值a-z排好序，按显示要求排序，
*/ */
export function getListOutData(title, data) { export function getTableOut(title, data) {
let titleList = [];
let valueList = []; let {titleList, dataList} = data;
let maxLength = 0; let valueList = [];
data.forEach( onceData => { dataList.forEach(info => {
let { key, values } = onceData; let subList = [];
titleList.push(key); titleList.forEach(keyStr => {
for (let i = 0; i < values.length; i++) { let value = info[keyStr] || "";
let value = values[i] || ""; subList.push(value);
valueList[i] ? valueList[i].push(value) : valueList[i] = [value]; });
Math.max(maxLength, i+1); valueList.push(subList);
}
}); });
return {title, total:0, titleList, valueList}; return { title, total:dataList.length, titleList, valueList };
} }
/** /**
* getKeyValueNumberOutData 获取值为数值的键值返回结果 * getKeyValueOut 获取键值的返回结果
* @param title 数据标题 * @param title 数据标题
* @param data 数据体 格式:{key:value, key:value} * @param data 数据体 [{key:"", value:"", unit:""}]
* @returns { title:数据标题, dataList:[{key:"数据key", "value":"数据value", unit:"数据单位"}], total:数据值总数, count:数据总条数 } * @returns {title:数据标题, dataList:[], total:数据值总数, count:数据总条数 }
*/ */
export function getKeyValueNumberOutData(title, data) { export function getKeyValueOut(title, data) {
let dataList = []; let dataList = [];
let total = 0; let total = 0;
let count = 0; data.forEach(info => {
let {key, value, unit} = info;
for (let key in data) { let typeChangeValue;
let {dataNum, dataUnit} = separateDataAndUint(data[key]); if (!isNaN(value)) {
total += dataNum; typeChangeValue = parseFloat(value);
count += 1; total+= typeChangeValue;
let addData = {key, value:dataNum, unit:dataUnit}; } else typeChangeValue = value;
dataList.push(addData); dataList.push({name:key, value:typeChangeValue, unit});
} });
return {title, total, count:dataList.length, dataList};
}
/**
* getObjectListOut 获取对象数组结果
* @param title 数据标题
* @param data 数据体 [{value:"", value:"", unit:""}]
* @returns {title:数据标题, dataList:[{name:"", value:"", key1:"", key2:""}] }
*/
export function getObjectListOut(title, data) {
//todo 没有特殊逻辑
return {title, dataList:data};
}
/**
* getRankOut 获取排名结果
* @param title 数据标题
* @param data 数据体 {unit, max, dataInfo:[{key, value, details}, {}, {}, {}] }
* @returns {title:数据标题, max, unit dataList:[{name, value, unit, rankNumber}] }
*/
export function getRankOut(title, data) {
let {unit, max, dataInfo} = data;
return { title, dataList, total, count }; let dataList = [];
dataInfo.forEach((info, index) => {
let {key, value} = info;
let rankNumber = index + 1;
dataList.push({name:key, value, details:info.details, rankNumber});
});
return { title, unit, max, dataList };
} }
/** /**
* getKeyValueNotNumberOutData 获取值为非数值的键值返回结果 * getRadarChartOut 获取雷达图
* @param title 数据标题 * @param title 数据标题
* @param data 数据体 格式:{key:value, key:value} * @param data 数据体 [{key, value, max, unit}]
* @returns { title:数据标题, dataList:[{key:"数据key", "value":"数据value"}], count:数据总条数 } * @returns {title:数据标题, dataList:[{name:"指标名称", max:"最大值", value:"当前值", unit:"单位"}]}
*/ */
export function getKeyValueNotNumberOutData(title, data) { export function getRadarChartOut(title, data) {
let dataList = []; let dataList = [];
let count = 0; data.forEach(info => {
for (let key in data) { dataList.push({
let addData = {key, value:data[key]}; name:info.key,
dataList.push(addData); value:info.value,
count += 1; max:info.max,
} unit:info.unit
return { title, dataList, count}; });
});
return {title, dataList};
} }
/**
* getMapOut 地图数据
* @param title 数据标题
* @param data 数据体 [{name:数据名称, x:x坐标, y:坐标, coordinate:[经度, 纬度], unit:单位, value:值, details:"补充"}]
* @returns {title:数据标题, dataList:[{name:数据名称, x:x坐标, y:坐标, coordinate:[经度, 纬度], unit:单位, value:值, details:"补充"} ] }
*/
export function getMapOut(title, data) {
//todo 无特殊逻辑
return {title, dataList:data};
}
/** /**
* getScatterFigureOutData 获取撒点图的返回结果 * getScatterFigureOutData 获取撒点图的返回结果
......
src/cal/outOld.ts 0 → 100644
import { getUnitMaxOccNum, separateDataAndUint, unifiedMaxAndMinValueAndStep } from "./privateTools";
//标准化输出 这里的东西禁止 乱改以及临时更改
/**
* getStringOutData 获取文字列表返回结果
* @param title 数据标题
* @param data 数据体 格式:["txt...", "str..."]
* @returns {title, dataList:[string...]}
*/
export function getStringOutData(title, data) {
let dataList = [];
data.forEach( (str) => {
dataList.push(str);
});
return { title, dataList};
}
/**
* getChartData 获取图表返回结果
* @param title 数据标题
* @param data 数据体 格式：{"图表名称":{unit:"", dataInfo:[{key:"数据key", value:"数据值"}, {key:"数据key", value:"数据值"} ] } }
* @param haveMoreY 是否有多个y轴 默认false
* @returns {title:标题, dataList:[{unit:单位, total:总数, yMinValue:最小值, yMaxValue:最大值, yStepValue:间隔, dataList:[{key:value}] }]}
*/
export function getChartOutData(title, data) {
let dataList = [];
for (let chartName in data) {
let { unit, dataInfo } = data[chartName];
let addData:any = { title: chartName };
let max = 0;
let min = new Date().valueOf();
let total = 0;
let thisUnitStats = {};
let onceDataList = [];
for (let i = 0; i < dataInfo.length; i++) {
let { key, value } = dataInfo[i];
let { dataNum, dataUnit } = separateDataAndUint(value);
min = Math.min(min, dataNum);
max = Math.max(max, dataNum);
thisUnitStats[dataUnit] = thisUnitStats[dataUnit] ? thisUnitStats[dataUnit] + 1 : 1;
total += dataNum;
onceDataList.push({key, value:dataNum, unit:dataUnit});
}
let statsUnit = getUnitMaxOccNum(thisUnitStats);
let thisChartUnit = unit || statsUnit || "";
addData["unit"] = thisChartUnit;
addData["total"] = total;
let {maxNumber, minNumber, stepNumber} = unifiedMaxAndMinValueAndStep(max, min);
addData["yMinValue"] = minNumber;
addData["yMaxValue"] = maxNumber;
addData["yStepValue"] = stepNumber;
addData["dataList"] = onceDataList;
dataList.push(addData);
}
return {title, dataList};
}
/**
* getListOutData 获取列表返回结果
* @param title 数据标题
* @param data 数据体 格式：[{key:"key1", values:[data1value1, data2value1, data3value1] }, {key:"key2", values:[data1value2, data2value2, data3value2] }]
* @returns {title:数据标题, total:数据总条数, titleList:[表头...], valueList:[[数据列表...],[数据列表...]]}
*/
export function getListOutData(title, data) {
let titleList = [];
let valueList = [];
let maxLength = 0;
data.forEach( onceData => {
let { key, values } = onceData;
titleList.push(key);
for (let i = 0; i < values.length; i++) {
let value = values[i] || "";
valueList[i] ? valueList[i].push(value) : valueList[i] = [value];
Math.max(maxLength, i+1);
}
});
return {title, total:0, titleList, valueList};
}
/**
* getKeyValueNumberOutData 获取值为数值的键值返回结果
* @param title 数据标题
* @param data 数据体 格式:{key:value, key:value}
* @returns { title:数据标题, dataList:[{key:"数据key", "value":"数据value", unit:"数据单位"}], total:数据值总数, count:数据总条数 }
*/
export function getKeyValueNumberOutData(title, data) {
let dataList = [];
let total = 0;
let count = 0;
for (let key in data) {
let {dataNum, dataUnit} = separateDataAndUint(data[key]);
total += dataNum;
count += 1;
let addData = {key, value:dataNum, unit:dataUnit};
dataList.push(addData);
}
return { title, dataList, total, count };
}
/**
* getKeyValueNotNumberOutData 获取值为非数值的键值返回结果
* @param title 数据标题
* @param data 数据体 格式:{key:value, key:value}
* @returns { title:数据标题, dataList:[{key:"数据key", "value":"数据value"}], count:数据总条数 }
*/
export function getKeyValueNotNumberOutData(title, data) {
let dataList = [];
let count = 0;
for (let key in data) {
let addData = {key, value:data[key]};
dataList.push(addData);
count += 1;
}
return { title, dataList, count};
}
/**
* getScatterFigureOutData 获取撒点图的返回结果
* @param title 标题
* @param data 数据 格式 [{x, y, name}, {x, y, name}, {x, y, name}, {x, y, name}]
* @returns { title:标题, xMax:x轴最大值, xMin:x最小值, yMax:y最大值, yMin:y最小值, dataList:[{name:点的名称, value:[x坐标, y坐标]} ] };
*/
export function getScatterFigureOutData(title, data) {
let dataList = [];
let xMaxNumber = 0;
let xMinNumber = new Date().valueOf();
let yMaxNumber = 0;
let yMinNumber = new Date().valueOf();
data.forEach(item => {
let { x, y, name } = item;
let xCoordinateInfo = separateDataAndUint(x);
let yCoordinateInfo = separateDataAndUint(y);
const XNumber = xCoordinateInfo.dataNum;
const YNumber = yCoordinateInfo.dataNum;
yMaxNumber = Math.max(YNumber, yMaxNumber);
yMinNumber = Math.min(YNumber, yMinNumber);
xMaxNumber = Math.max(XNumber, xMaxNumber);
xMinNumber = Math.min(XNumber, xMinNumber);
let value = [XNumber, YNumber];
dataList.push({ value, name:name || "" });
});
let xMaxMinInfo = unifiedMaxAndMinValueAndStep(xMaxNumber, xMinNumber);
let yMaxMinInfo = unifiedMaxAndMinValueAndStep(yMaxNumber, yMinNumber);
return { title, xMax:xMaxMinInfo.maxNumber, xMin:xMaxMinInfo.minNumber, yMax:yMaxMinInfo.maxNumber, yMin:yMaxMinInfo.minNumber, dataList };
}
src/cal/privateTools.ts
...@@ -32,12 +32,13 @@ export function getUnitMaxOccNum(unitMap) { ...@@ -32,12 +32,13 @@ export function getUnitMaxOccNum(unitMap) {
} }
/** /**
* unifiedMaxAndMinValueAndStep 求最大最小值以及间隙 固定分10份 * unifiedMaxAndMinValueAndStep 求最大最小值以及间隙
* @param max 最大 * @param max 最大
* @param min 最小 * @param min 最小
* @param count 分多少份 默认5
* @returns {maxNumber:向上留值最大, minNumber:向下留值最小, stepNumber:间隔}; * @returns {maxNumber:向上留值最大, minNumber:向下留值最小, stepNumber:间隔};
*/ */
export function unifiedMaxAndMinValueAndStep(max, min) { export function unifiedMaxAndMinValueAndStep(max, min, count=5) {
let maxNumber = Math.ceil(max); let maxNumber = Math.ceil(max);
let minNumber = Math.floor(min); let minNumber = Math.floor(min);
...@@ -56,7 +57,8 @@ export function unifiedMaxAndMinValueAndStep(max, min) { ...@@ -56,7 +57,8 @@ export function unifiedMaxAndMinValueAndStep(max, min) {
else maxNumber = Math.ceil(maxNumber / maxNumberLength) * maxNumberLength; else maxNumber = Math.ceil(maxNumber / maxNumberLength) * maxNumberLength;
minNumber = Math.floor(minNumber / minNumberLength) * minNumberLength; minNumber = Math.floor(minNumber / minNumberLength) * minNumberLength;
let stepNumber = Math.ceil((maxNumber - minNumber) / 10); let stepNumber = Math.ceil((maxNumber - minNumber) / count);
return {maxNumber, minNumber, stepNumber}; return {maxNumber, minNumber, stepNumber};
} }
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment