Skip to content

V
visualDataServer
Commit f11532c7 by lixinming
Options

no message

parent aa36ca79
Showing with 417 additions and 180 deletions
src/cal/enter.ts deleted 100644 → 0
//标准化输入
/**
* analysisExcelDataOfObject 将excel解出来的数据块按需求解析成可用数据
* @param dataList excel解出来的数据
* @param isJumpTitle 是否跳过解析表头
* @param keyInX key是否横向排列
* @returns 返回 {"数据标题":数据对象 }
*/
export function analysisExcelDataOfObject(dataList, isJumpTitle?, keyInX?) {
let result = {};
if (keyInX) {
let keyList = dataList[0];
let valueList = dataList[1];
let i = isJumpTitle ? 1:0;
for (; i < keyList.length; i++) {
let key = keyList[i];
let value = valueList[i] || null;
result[key] = value;
}
} else {
let y = isJumpTitle ? 1: 0;
for (; y < dataList.length; y++) {
let childList = dataList[y];
let key = childList[0];
let value = childList[1] || null;
result[key] = value;
}
}
return result;
}
export function analysisExcelDataTime(dataList, isJumpTitle?, keyInX?) {
const HOURS = new Date().getHours() + 1;//获取当前时间
let result = {};
if (keyInX) {
let keyList = dataList[0];
let valueList = dataList[1];
let i = isJumpTitle ? 1:0;
for (; i < keyList.length; i++) {
let key = keyList[i];
let value = valueList[i] || null;
result[key] = value;
}
} else {
let y = isJumpTitle ? 1: 0;
for (; y <= HOURS; y++) {
let childList = dataList[y];
let key = childList[0];
let value = childList[1] || null;
result[key] = value;
}
}
return result;
}
/**
* analysisExcelDataOfMoreObject 将excel解出来的数据块按需求解析成可用数据
* @param dataList excel解出来的数据
* @param isJumpTitle 是否跳过解析表头
* @param headerInx 第一个表头数据是否横向排列
* @returns 返回 {"第一个表头数据":{"表头数据":值...} }
*/
export function analysisExcelDataOfMoreObject(dataList, headerInx?) {
let result = {};
let titleList = dataList[0];
if (!headerInx) {
for (let y =1; y < dataList.length; y++) {
let dataTitle = dataList[y][0];
let thisData = {};
for (let x = 1; x < dataList[y].length; x++) {
let key = titleList[x];
thisData[key] = dataList[y][x];
}
result[dataTitle] = thisData;
}
} else {
let indexKeyMap = {};
titleList.forEach((thisTitle, index) => {
if (!index) return;
indexKeyMap[index] = thisTitle;
result[thisTitle] = {};
});
for (let y =1; y < dataList.length; y++) {
let thisKey = dataList[y][0];
for (let x = 1; x < dataList[y].length; x++) {
let thisTitle = indexKeyMap[x];
result[thisTitle][thisKey] = dataList[y][x];
}
}
}
return result;
}
/**
* analysisExcelDataOfList 将excel解出来的数据块按需求解析成可用数据
* @param dataList excel解出来的数据
* @param keyObject 对应关系 {dataList表头名称: 英文}
* @param headerInx 第一个表头数据是否横向排列
* @returns 返回 {"第一个表头数据":{"表头数据":值...} }
*/
export function analysisExcelDataOfList(dataList, keyObject, headerInx?) {
let result = [];
if (!headerInx) {//在y轴上排列
let titleList = dataList[0];
let indexKeyNameMap = {};
titleList.forEach( (info, index) => {
indexKeyNameMap[index + 1] = info;
});
for (let i = 1; i < dataList.length; i++) {
let onceInfo = {};
let subList = dataList[i];
subList.forEach( (info, index) => {
let key = indexKeyNameMap[index + 1];
let checkKey = keyObject[key];
onceInfo[checkKey] = info;
});
result.push(onceInfo);
}
} else {//在x轴上排列
let indexKeyNameMap = {};
dataList.forEach( (info, index) => {
indexKeyNameMap[index + 1] = info[0];
});
let dataMap = {};
for(let y = 0; y < dataList.length; y++) {
let xList = dataList[y];
for (let x = 1; x < xList.length; x++) {
if (!dataMap[x]) dataMap[x] = {};
let key = indexKeyNameMap[y + 1];
let checkKey = keyObject[key];
dataMap[x][checkKey] = xList[x];
}
}
result = Object.values(dataMap);
}
return result;
}
export function analysisExcelDataOfStringList(dataList) {
let result = [];
for (let i = 0; i < dataList.length; i++) {
if (!i) continue;
let subList = dataList[i];
result.push(subList[1]);
}
return result;
}
src/cal/excelEnter.ts 0 → 100644
//标准化exce输入
/**
* planarArrBecomeKeyValueData 二维数组转keyvalue需要的结构
* @param dataList 数据列表 格式 [[标题1，标题2],[key1,value1],[key2, value2]] or [[标题1, key1, key2],[标题2,value1, value2] ]
* @param titleInY 标题是否垂直排列 or key是否横向排列 or key在x轴上 and 即当为false时输入为（默认为false）:[[标题1，标题2],[key1,value1],[key2, value2]]
* @returns {key:value}
*/
export function planarArrBecomeKeyValueData(dataList, titleInY = false) {
let result:any = {};
if (!titleInY) { //title 在x轴上
for (let y = 1; y < dataList.length; y++) {
let childList = dataList[y];
let key = childList[0];
let value = childList[1] || null;
result[key] = value;
}
} else {
let keyList = dataList[0];
let valueList = dataList[1];
for (let i = 1; i < keyList.length; i++) {
let key = keyList[i];
let value = valueList[i] || null;
result[key] = value;
}
}
return result;
}
/**
* planarArrBecomeChartData 二维数组转chart需要的结构
* @param dataList 数据列表 格式 [[标题说明占位符, key1, key2, key3],[数据名称a, a的value1, a的value2, a的value3],[数据名称b, b的value1, b的value2, b的value3]]
* or [[标题说明占位符, 数据名称a, 数据名称b ],[key1, a的value1, b的value1],[key2, a的value2, b的value2]]
* @param titleInY key是否在y轴上 默认为false时 [[标题说明占位符, 数据名称a, 数据名称b ],[key1, a的value1, b的value1],[key2, a的value2, b的value2]]
* @returns {"图表名称":{unit:"", dataInfo:[{key:"数据key", value:"数据值"}, {key:"数据key", value:"数据值"} ] } }
*/
export function planarArrBecomeChartData(dataList, titleInY = false) {
let result = {};
if (!titleInY) {
let keyList = dataList[0];
for (let y = 1; y < dataList.length; y++) {
let subList = dataList[y];
let dataName = subList[0];
let dataInfo = [];
for (let x = 1; x < subList.length; x++) {
let key = keyList[x] || `未知key${x}`;
let value = subList[x];
dataInfo.push({ key, value });
}
result[dataName] = {unit:'', dataInfo};
}
} else {
let dataIndexMap = {};
let dataNameList = dataList[0];
for (let x = 1; x < dataNameList.length; x++) {
let dataName = dataNameList[x];
dataIndexMap[x] = dataName;
result[dataName] = {unit:'', dataInfo:[]};
}
for (let y = 1; y < dataList.length; y++) {
let subList = dataList[y];
let key = subList[0];
for (let x = 1; x < subList.length; x++) {
let thisDataName = dataIndexMap[x];
let value = subList[x];
result[thisDataName].dataInfo.push( {key, value} );
}
}
}
return result;
}
/**
* planarArrBecomeStringListData 二维数组转字符列表需要的结构
* @param dataList dataList 数据列表 格式 [[标题1，标题2],[文本占位符,value1],[文本占位符, value2]] or [[标题1, 文本占位符, 文本占位符],[标题2,value1, value2] ]
* @param titleInY titleInY 标题是否垂直排列 or key是否横向排列 or key在x轴上 and 即当为false时输入为（默认为false）:[[标题1，标题2],[key1,value1],[key2, value2]]
* @returns ["文本1", "文本2"]
*/
export function planarArrBecomeStringListData(dataList, titleInY = false) {
let result = [];
if (!titleInY) { //title 在x轴上
for (let y = 1; y < dataList.length; y++) {
let childList = dataList[y];
let value = childList[1] || '';
result.push(value);
}
} else {
let valueList = dataList[1];
for (let i = 1; i < valueList.length; i++) {
let value = valueList[i] || '';
result.push(value);
}
}
return result;
}
/**
* planarArrBecomeListData 二维数组转列表需要的结构
* @param dataList 数据列表 格式 [[标题1, 标题2, 标题3],[a的value1, a的value2, a的value3],[b的value1, b的value2, b的value3]] or
* [[标题1, 标题2, 标题3, 标题4],[a的value1, a的value2, a的value3],[b的value1, b的value2, b的value3]]
* @param headerInx
* @returns
*/
export function planarArrBecomeListData(dataList, headerInx?) {
//todo
}
//todo ====
/**
* analysisExcelDataOfMoreObject 将excel解出来的数据块按需求解析成可用数据
* @param dataList excel解出来的数据
* @param isJumpTitle 是否跳过解析表头
* @param headerInx 第一个表头数据是否横向排列
* @returns 返回 {"第一个表头数据":{"表头数据":值...} }
*/
export function analysisExcelDataOfMoreObject(dataList, headerInx?) {
let result = {};
let titleList = dataList[0];
if (!headerInx) {
for (let y =1; y < dataList.length; y++) {
let dataTitle = dataList[y][0];
let thisData = {};
for (let x = 1; x < dataList[y].length; x++) {
let key = titleList[x];
thisData[key] = dataList[y][x];
}
result[dataTitle] = thisData;
}
} else {
let indexKeyMap = {};
titleList.forEach((thisTitle, index) => {
if (!index) return;
indexKeyMap[index] = thisTitle;
result[thisTitle] = {};
});
for (let y =1; y < dataList.length; y++) {
let thisKey = dataList[y][0];
for (let x = 1; x < dataList[y].length; x++) {
let thisTitle = indexKeyMap[x];
result[thisTitle][thisKey] = dataList[y][x];
}
}
}
return result;
}
/**
* analysisExcelDataOfList 将excel解出来的数据块按需求解析成可用数据
* @param dataList excel解出来的数据
* @param keyObject 对应关系 {dataList表头名称: 英文}
* @param headerInx 第一个表头数据是否横向排列
* @returns 返回 {"第一个表头数据":{"表头数据":值...} }
*/
export function analysisExcelDataOfList(dataList, keyObject, headerInx?) {
let result = [];
if (!headerInx) {//在y轴上排列
let titleList = dataList[0];
let indexKeyNameMap = {};
titleList.forEach( (info, index) => {
indexKeyNameMap[index + 1] = info;
});
for (let i = 1; i < dataList.length; i++) {
let onceInfo = {};
let subList = dataList[i];
subList.forEach( (info, index) => {
let key = indexKeyNameMap[index + 1];
let checkKey = keyObject[key];
onceInfo[checkKey] = info;
});
result.push(onceInfo);
}
} else {//在x轴上排列
let indexKeyNameMap = {};
dataList.forEach( (info, index) => {
indexKeyNameMap[index + 1] = info[0];
});
let dataMap = {};
for(let y = 0; y < dataList.length; y++) {
let xList = dataList[y];
for (let x = 1; x < xList.length; x++) {
if (!dataMap[x]) dataMap[x] = {};
let key = indexKeyNameMap[y + 1];
let checkKey = keyObject[key];
dataMap[x][checkKey] = xList[x];
}
}
result = Object.values(dataMap);
}
return result;
}
export function analysisExcelDataOfStringList(dataList) {
let result = [];
for (let i = 0; i < dataList.length; i++) {
if (!i) continue;
let subList = dataList[i];
result.push(subList[1]);
}
return result;
}
src/cal/innerUse.ts
//内部使用
\ No newline at end of file
//内部使用
/**
* planarArrayForEecomeStringList 二维数组转列表
* @param planarArray
*/
export function planarArrayForEecomeStringList(planarArray) {
}
\ No newline at end of file
src/cal/out.ts
//标准化输出
import { getUnitMaxOccNum, separateDataAndUint, unifiedMaxAndMinValueAndStep } from "./privateTools";
//标准化输出 这里的东西禁止 乱改以及临时更改
/**
* getStringOutData 获取文字列表返回结果
* @param title 数据标题
* @param valueList 数据体 格式:["txt...", "str..."]
* @returns {title, data:[string...]}
* @param data 数据体 格式:["txt...", "str..."]
* @returns {title, dataList:[string...]}
*/
export function getStringOutData(title, valueList) {
let result = { title, data:[] };
valueList.forEach( str => {
result.data.push(str);
export function getStringOutData(title, data) {
let dataList = [];
data.forEach( (str, index) => {
dataList.push({ key:index+1, value:str});
});
return result;
return { title, dataList};
}
/**
* getChartData 获取图表列表返回结果
* getChartData 获取图表返回结果
* @param title 数据标题
* @param data 数据体 格式：{"图表名称":{unit:"", dataInfo:[{key:"数据key", value:"数据值"}, {key:"数据key", value:"数据值"} ] } }
* @param haveMoreY 是否有多个y轴 默认false
* @returns
* @returns {title:标题, dataList:[{unit:单位, total:总数, yMinValue:最小值, yMaxValue:最大值, yStepValue:间隔, dataList:[{key:value}] }]}
*/
export function getChartData(title, data) {
let result = { title, dataList:[] };
export function getChartOutData(title, data) {
let dataList = [];
for (let chartName in data) {
let { unit, dataInfo } = data[chartName];
......@@ -37,7 +34,7 @@ export function getChartData(title, data) {
let min = new Date().valueOf();
let total = 0;
let thisUnitStats = {};
let dataList = [];
let onceDataList = [];
for (let i = 0; i < dataInfo.length; i++) {
let { key, value } = dataInfo[i];
let { dataNum, dataUnit } = separateDataAndUint(value);
......@@ -46,24 +43,125 @@ export function getChartData(title, data) {
thisUnitStats[dataUnit] = thisUnitStats[dataUnit] ? thisUnitStats[dataUnit] + 1 : 1;
total += dataNum;
dataList.push({key, value:dataNum, unit:dataUnit});
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"] = dataList;
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};
}
/**
* getKeyNumberValueOutData 获取值为数值的键值返回结果
* @param title 数据标题
* @param data 数据体 格式:{key:value, key:value}
* @returns { title:数据标题, dataList:[{key:"数据key", "value":"数据value", unit:"数据单位"}], total:数据值总数, count:数据总条数 }
*/
export function getKeyNumberValueOutData(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 };
}
result.dataList.push(addData);
/**
* getKeyStringValueOutData 获取值为字符串的键值返回结果
* @param title 数据标题
* @param data 数据体 格式:{key:value, key:value}
* @returns { title:数据标题, dataList:[{key:"数据key", "value":"数据value"}], count:数据总条数 }
*/
export function getKeyStringValueOutData(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
......@@ -6,6 +6,7 @@
* @returns {dataNumber:数据, dataUnit:单位}
*/
export function separateDataAndUint(str) {
str = `${str}`;
if (!str) return {dataNum:0, dataUnit:""};
let dataNum = parseFloat(str.replace(/[\u4E00-\u9FA5a-zA-Z]+/,""));
let dataUnit = str.replace(/^(-)?\d+(\.\d+)?/, "");
......
src/config/enum.ts
export enum ERRORENUM {
参数错误=`参数错误`,
}
export enum REQUESTENUM {
get=1,
post,
}
\ No newline at end of file
src/data/interface/getOnceInterfaceData.ts 0 → 100644
export async function getData(type, url, paramater) {
}
\ No newline at end of file
src/util/request.ts 0 → 100644
import * as request from 'request';
import { BizError } from './bizError';
export function get(url:string, query?, headers?) {
if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
return new Promise((resolve, reject)=>{
let paramater:any = { url, json:true };
if (query) paramater.qs = query;
if (headers) paramater.headers = headers;
request.get(paramater, function (err, r, body) {
if (err) return reject(err);
if (r && r.statusCode != 200) return reject(new Error('httpError:'+r.statusCode))
resolve(body);
});
})
}
export function post(url, body, headers) {
if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
let header = {"content-type": "application/json"};
return new Promise((resolve, reject)=>{
request({
url: url,
method: "POST",
json: true,
headers: Object.assign(header, headers),
body: body
}, function(error, response, body) {
if (!error && response.statusCode == 200) {
resolve(body);
}
else {
reject(error)
}
});
})
}
export function postForm(url, body, headers) {
if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
return new Promise((resolve, reject)=>{
request({
url: url,
method: "POST",
json: true,
form:body
}, function(error, response, res) {
if (!error) {
resolve(res);
}
else {
reject(error)
}
});
})
}
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