no message

.gitignore

+.idea
+/out
+/node_modules
+/test
+*test*
+*.log
\ No newline at end of file

.vscode/launch.json

+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+    
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "启动程序",
+            "program": "${workspaceFolder}/src/main.ts",
+            "outFiles": [
+                "${workspaceFolder}/**/*.js"
+            ]
+        }
+    ]
+}
\ No newline at end of file

package.json

+{
+  "name": "gameserver",
+  "version": "1.0.0",
+  "description": "",
+  "main": "main.ts",
+  "dependencies": {
+    "@alicloud/sms-sdk": "^1.1.6",
+    "@types/node": "^10.12.18",
+    "compression": "^1.7.4",
+    "express": "^4.17.1",
+    "express-async-handler": "^1.1.4",
+    "express-history-api-fallback": "^2.2.1",
+    "formidable": "^1.2.1",
+    "lru-cache": "^4.1.5",
+    "md5": "^2.2.1",
+    "moment": "^2.24.0",
+    "mongoose": "^5.4.0",
+    "mysql": "^2.18.1",
+    "node-xlsx": "^0.16.1",
+    "nodemailer": "^6.1.1",
+    "request": "^2.88.0",
+    "svg-captcha": "^1.3.12",
+    "ws": "^5.2.2"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
+}

src/biz/jgfwnl/csfx.ts

+import { getCsfx } from "../../data/interface/csfx";
+
+
+export async function getData(req, res) {
+    let ret = await getCsfx();
+    res.send(ret);
+}
\ No newline at end of file

src/biz/jgfwnl/csgk.ts

+import { getCsgk } from "../../data/interface/csgk";
+
+export async function getData(req, res) {
+    let ret = await getCsgk();
+    res.send(ret);
+}
\ No newline at end of file

src/biz/jgfwnl/yzy.ts

+import { getDataBySql } from "../../data/mysql/getData";
+import { SQLENUM } from "../../data/mysql/sql";
+
+
+export async function getData(req, res) {
+    let ret:any = {};
+
+    let computingCloudResources = await getDataBySql(SQLENUM.计算云资源);
+    
+    let cloudResourceUsage = await getDataBySql(SQLENUM.计算云资源使用率);
+
+    let physicalResources = await getDataBySql(SQLENUM.物理资源);
+    
+    res.send(ret);
+}
\ No newline at end of file

src/biz/jgfwnl_RSUfsl.ts

+import { getKeyValueNumberOutData, getChartOutData, getKeyValueNotNumberOutData, getListOutData, getScatterFigureOutData, getStringOutData } from "../cal/out";
+    import { get监管服务能力_RSU发送量 } from "../data/analysisExcelData";
+    
+    export function getData(req, res) {
+        let ret:any = {};
+
+        let excelData:any = get监管服务能力_RSU发送量();
+        ret["api1"] = getListOutData("RSU", excelData.RSU );
+
+        res.send(ret);
+    }

src/biz/jgfwnl_clcszl.ts

+
+    import { getKeyValueNumberOutData, getChartOutData, getKeyValueNotNumberOutData, getListOutData, getScatterFigureOutData, getStringOutData } from "../cal/out";
+    import { get监管服务能力_车辆测试总览 } from "../data/analysisExcelData";
+    
+    export function getData(req, res) {
+        let ret:any = {};
+
+        let excelData:any = get监管服务能力_车辆测试总览();
+        ret["api1"] = getChartOutData("每月测试里程和时长分布", excelData.每月测试里程和时长分布 );
+        ret["api2"] = getKeyValueNumberOutData("各企业违规次数", excelData.各企业违规次数 );
+        ret["api3"] = getKeyValueNumberOutData("企业脱离自动驾驶比率", excelData.企业脱离自动驾驶比率 );
+        ret["api4"] = getListOutData("测试车辆列表", excelData.测试车辆列表 );
+    
+        res.send(ret);
+    }
+    
\ No newline at end of file

src/biz/jgfwnl_qycsfx.ts

+
+    import { getKeyValueNumberOutData, getChartOutData, getKeyValueNotNumberOutData, getListOutData, getScatterFigureOutData, getStringOutData } from "../cal/out";
+    import { get监管服务能力_企业测试分析 } from "../data/analysisExcelData";
+    
+    export function getData(req, res) {
+        let ret:any = {};
+
+        let excelData:any = get监管服务能力_企业测试分析();
+        ret["api1"] = getKeyValueNumberOutData("企业测试分析", excelData.企业测试分析 );
+        ret["api2"] = getChartOutData("各企业测试里程和时长分析", excelData.各企业测试里程和时长分析 );
+        ret["api3"] = getKeyValueNumberOutData("功能测试总和", excelData.功能测试总和 );
+        ret["api4"] = getChartOutData("各企业功能测试里程碑和时长分析", excelData.各企业功能测试里程碑和时长分析 );
+    
+        res.send(ret);
+    }
+    
\ No newline at end of file

src/biz/jgfwnl_sp.ts

+
+    import { getKeyValueNumberOutData, getChartOutData, getKeyValueNotNumberOutData, getListOutData, getScatterFigureOutData, getStringOutData } from "../cal/out";
+    import { get监管服务能力_视频 } from "../data/analysisExcelData";
+    
+    export function getData(req, res) {
+        let ret:any = {};
+
+        let excelData:any = get监管服务能力_视频();
+        ret["api1"] = getKeyValueNumberOutData("设备", excelData.设备 );
+        ret["api2"] = getKeyValueNotNumberOutData("视频", excelData.视频 );
+        
+        res.send(ret);
+    }
+    
\ No newline at end of file

src/biz/jgfwnl_wlzy.ts

+
+    import { getKeyValueNumberOutData, getChartOutData, getKeyValueNotNumberOutData, getListOutData, getScatterFigureOutData, getStringOutData } from "../cal/out";
+    import { get监管服务能力_物理资源 } from "../data/analysisExcelData";
+    
+    export function getData(req, res) {
+        let ret:any = {};
+
+        let excelData:any = get监管服务能力_物理资源();
+        ret["api1"] = getKeyValueNumberOutData("物理资源", excelData.物理资源 );
+        ret["api2"] = getKeyValueNumberOutData("设备型号", excelData.设备型号 );
+        ret["api3"] = getKeyValueNumberOutData("设备故障", excelData.设备故障 );
+        ret["api4"] = getChartOutData("每月故障趋势", excelData.每月故障趋势 );
+    
+        res.send(ret);
+    }
+    
\ No newline at end of file

src/biz/jgfwnl_yzy.ts

+
+    import { getKeyValueNumberOutData, getChartOutData, getKeyValueNotNumberOutData, getListOutData, getScatterFigureOutData, getStringOutData } from "../cal/out";
+    import { get监管服务能力_云资源 } from "../data/analysisExcelData";
+    
+    export function getData(req, res) {
+        let ret:any = {};
+
+        let excelData:any = get监管服务能力_云资源();
+        ret["api1"] = getKeyValueNumberOutData("云资源", excelData.云资源 );
+        ret["api2"] = getKeyValueNumberOutData("Pass", excelData.Pass );
+        ret["api3"] = getKeyValueNumberOutData("Default_Group", excelData.Default_Group );
+        ret["api4"] = getKeyValueNumberOutData("Gpu", excelData.Gpu );
+        ret["api5"] = getKeyValueNumberOutData("存储", excelData.存储 );
+        // ret["api6"] = getKeyValueNumberOutData("ECS实例1", excelData.ECS实例1 );
+        // ret["api7"] = getKeyValueNumberOutData("ECS实例2", excelData.ECS实例2 );
+        // ret["api8"] = getKeyValueNumberOutData("ECS实例3", excelData.ECS实例3 );
+        let ECS图例data = excelData.ECS图例;
+        let list = [];
+        for (let key in ECS图例data) {
+            list.push(ECS图例data[key]);
+        }
+        
+        ret["api9"] = {title:"ECS图例", dataList: list };
+
+        //getKeyValueNumberOutData("ECS图例", excelData.ECS图例 )
+        let 实例data = [
+            getKeyValueNumberOutData("ECS实例1", excelData.ECS实例1), 
+            getKeyValueNumberOutData("ECS实例2", excelData.ECS实例2), 
+            getKeyValueNumberOutData("ECS实例3", excelData.ECS实例3)
+        ];
+        
+        ret["api10"] = {name: "资源利用率", dataList: 实例data};
+        res.send(ret);
+    }

src/cal/excelEnter.ts

+//标准化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, a的值1, b的值1],[标题2, a的值2, b的值2],[标题3, a的值3, b的值3]]
+ * @param titleInY  titleInY 标题是否垂直排列 or key是否横向排列 or key在x轴上 and 即当为false时输入为（默认为false）:[[标题1, 标题2, 标题3],[a的value1, a的value2, a的value3],[b的value1, b的value2, b的value3]]
+ * @returns 返回 [{key:"标题1", values:[a的value1, b的value1, c的value1] }, {key:"标题2", values:[a的value2, b的value2, c的value2] }]
+ */
+export function planarArrBecomeListData(dataList, titleInY = false) {
+    let result = [];
+
+    if (!titleInY) {
+        
+        let dataTitle = dataList[0];
+        for (let y = 1; y < dataList.length; y++) {
+            let subValueList = dataList[y];
+    
+            for (let x = 0; x < subValueList.length; x++){
+                let value = subValueList[x];
+                let key = dataTitle[x];
+                if ( !result[x] ) result[x] = {key, values:[] };
+                result[x].values.push(value);
+            }
+        }
+
+    } else {
+        for (let y = 1; y < dataList.length; y++) {
+            let subValueList = dataList[y];
+            result.push({
+                key:subValueList[0],
+                values:subValueList.slice(1, subValueList.length)
+            })
+        }
+        
+    }
+   
+    return result;
+}
+
+
+/**
+ * analysisExcelDataOfList  将excel解出来的数据块按需求解析成可用数据
+ * @param dataList excel解出来的数据 [[x, y, name], [x值, y值, name值], [x, y, name], [x, y, name]] or
+ * [[x, a的x, b的x, c的x], [y, a的y, b的y, c的y ], [name,  a的name, b的name, c的name] ]
+ * @param titleInY 第一个表头数据是否横向排列
+ * @returns 返回  [{x:a的x, y:a的y, name:a的name}, {x:b的x, y:b的y, name:b的name}, {x:c的x, y:c的y, name:c的name} ]
+ */
+ export function analysisExcelDataOfList(dataList, titleInY = false) {
+    let result = [];
+    if (!titleInY) {//在y轴上排列
+        for (let i = 0; i < dataList.length; i++) {
+            let list = [];
+            let subList = dataList[i];
+            let keys = subList[0];
+            for (let x = 1; x < subList.length; x++){
+                let itemList = {};
+                let addInfo:any = {};
+                addInfo[keys] = keys;
+                itemList[addInfo[keys]] = subList[x];
+                list.push(itemList);
+            }
+            result.push(list);
+        }
+    } else {
+        for (let i = 1; i < dataList.length; i++) {
+            let itemList = dataList[i];
+            let x = itemList[0];
+            let y = itemList[1];
+            let name = itemList[2] || "";
+
+            if (isNaN(x) || isNaN(y) ) continue;
+
+            result.push({ x, y, name});
+        }
+        
+    }
+
+    return result;
+}
+
+/**
+ * analysisExcelDataOfMoreObject  将excel解出来的数据块按需求解析成可用数据
+ * @param dataList excel解出来的数据 
+ * @param isJumpTitle 是否跳过解析表头
+ * @param headerInx 第一个表头数据是否横向排列
+ * @returns 返回 {"第一个表头数据":{"表头数据":值...} }
+ */
+ export function analysisExcelDataOfMoreObject(dataList, titleInY = false) {
+    let result = {};
+    let titleList = dataList[0];
+    if (!titleInY) {
+
+        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;
+}
+

src/cal/out.ts

+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

+//仅限cal中使用的工具  禁止做任何修改
+
+/**
+ * separateDataAndUint 截取字符串中的单位
+ * @param str 待处理字符串
+ * @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+)?/, "");
+    return {dataNum, dataUnit};
+}
+
+/**
+ * getUnitMaxOccNum  获取出现次数最多的单位
+ * @param unitMap 统计后的出现过的单位情况 结构{unit:出现次数}
+ * @returns 出现次数最多的单位
+ */1
+export function getUnitMaxOccNum(unitMap) {
+    let max = 0;
+    let maxUnit = "";
+    for (let unit in unitMap) {
+        let occNum = unitMap[unit];
+        if (occNum > max) {
+            max = occNum;
+            maxUnit = unit;
+        }
+    }
+    return maxUnit;
+}
+
+/**
+ * unifiedMaxAndMinValueAndStep 求最大最小值以及间隙 固定分10份
+ * @param max 最大
+ * @param min 最小
+ * @returns {maxNumber:向上留值最大, minNumber:向下留值最小, stepNumber:间隔};
+ */
+export function unifiedMaxAndMinValueAndStep(max, min) {
+    let maxNumber = Math.ceil(max);
+    let minNumber = Math.floor(min);
+
+    function getNumberInLength(length) {
+        let lengthCount = 1;
+        for (let i = 1; i < length; i++) {
+            lengthCount = lengthCount * 10;
+        }
+        return lengthCount;
+    }
+
+    let maxNumberLength = getNumberInLength(`${maxNumber}`.length);
+    let minNumberLength = getNumberInLength(`${minNumber}`.length);
+    
+    if (maxNumber <= 10 && maxNumber > 0) maxNumber = 10;
+    else maxNumber = Math.ceil(maxNumber / maxNumberLength) * maxNumberLength;
+    minNumber =  Math.floor(minNumber / minNumberLength) * minNumberLength;
+    
+    let stepNumber = Math.ceil((maxNumber - minNumber) / 10);
+
+    return {maxNumber, minNumber, stepNumber};
+}
\ No newline at end of file

src/config/enum.ts

+export enum ERRORENUM {
+    参数错误=`参数错误`,
+}
+
+export enum INTERFACEREQUESTTYPEENUM {
+    即时更新 = 1,
+    定时更新
+}

src/data/analysisExcelData.ts

+
+    import { limitEnteNameString, changeDataName } from "../util/tools";
+    import { planarArrBecomeKeyValueData, planarArrBecomeChartData, planarArrBecomeStringListData, planarArrBecomeListData} from "../cal/excelEnter";
+    import { getExcelDataBySheetName } from "../util/analysisExcel";
+    
+    export function get监管服务能力_云资源() {
+        let bolckDataList = getExcelDataBySheetName('安亭汽车城数据模板.xlsx', '监管服务能力_云资源');
+        let result = {};
+        let forKeyValueList = ["云资源","Pass","Default_Group","Gpu","存储","ECS实例1","ECS实例2","ECS实例3","ECS实例4","ECS实例5","ECS实例6","ECS图例"];
+        let forChartList = [];
+        let forStringList = [];
+        let forListData = [];
+        for (let i = 0; i < bolckDataList.length; i++) {
+            let {blockData, blockTitle} = bolckDataList[i];
+
+            let changeName = changeDataName(blockTitle);
+
+            if (forKeyValueList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeKeyValueData(blockData);
+            if (forChartList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeChartData(blockData);
+            if (forStringList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeStringListData(blockData);
+            if (forListData.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeListData(blockData);
+
+        }
+        
+        return result;
+    }
+    export function get监管服务能力_物理资源() {
+        let bolckDataList = getExcelDataBySheetName('安亭汽车城数据模板.xlsx', '监管服务能力_物理资源');
+        let result = {};
+        let forKeyValueList = ["物理资源","设备型号","设备故障"];
+        let forChartList = ["每月故障趋势"];
+        let forStringList = [];
+        let forListData = [];
+        for (let i = 0; i < bolckDataList.length; i++) {
+            let {blockData, blockTitle} = bolckDataList[i];
+
+            let changeName = changeDataName(blockTitle);
+
+            if (forKeyValueList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeKeyValueData(blockData);
+            if (forChartList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeChartData(blockData);
+            if (forStringList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeStringListData(blockData);
+            if (forListData.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeListData(blockData);
+
+        }
+        
+        return result;
+    }
+    export function get监管服务能力_视频() {
+        let bolckDataList = getExcelDataBySheetName('安亭汽车城数据模板.xlsx', '监管服务能力_视频');
+        let result = {};
+        let forKeyValueList = ["设备", "视频"];
+        let forChartList = [];
+        let forStringList = [];
+        let forListData = [];
+        for (let i = 0; i < bolckDataList.length; i++) {
+            let {blockData, blockTitle} = bolckDataList[i];
+
+            let changeName = changeDataName(blockTitle);
+
+            if (forKeyValueList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeKeyValueData(blockData);
+            if (forChartList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeChartData(blockData);
+            if (forStringList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeStringListData(blockData);
+            if (forListData.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeListData(blockData);
+
+        }
+        
+        return result;
+    }
+
+    export function get监管服务能力_企业测试分析() {
+        let bolckDataList = getExcelDataBySheetName('安亭汽车城数据模板.xlsx', '监管服务能力_企业测试分析');
+        let result = {};
+        let forKeyValueList = ["企业测试分析", "功能测试总和"];
+        let forChartList = ["各企业测试里程和时长分析","各企业功能测试里程碑和时长分析"];
+        let forStringList = [];
+        let forListData = [];
+        for (let i = 0; i < bolckDataList.length; i++) {
+            let {blockData, blockTitle} = bolckDataList[i];
+
+            let changeName = changeDataName(blockTitle);
+
+            if (forKeyValueList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeKeyValueData(blockData);
+            if (forChartList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeChartData(blockData);
+            if (forStringList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeStringListData(blockData);
+            if (forListData.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeListData(blockData);
+
+        }
+        
+        return result;
+    }
+    export function get监管服务能力_车辆测试总览() {
+        let bolckDataList = getExcelDataBySheetName('安亭汽车城数据模板.xlsx', '监管服务能力_车辆测试总览');
+        let result = {};
+        let forKeyValueList = ["各企业违规次数","企业脱离自动驾驶比率"];
+        let forChartList = ["每月测试里程和时长分布"];
+        let forStringList = [];
+        let forListData = ["测试车辆列表"];
+        for (let i = 0; i < bolckDataList.length; i++) {
+            let {blockData, blockTitle} = bolckDataList[i];
+
+            let changeName = changeDataName(blockTitle);
+
+            if (forKeyValueList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeKeyValueData(blockData);
+            if (forChartList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeChartData(blockData);
+            if (forStringList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeStringListData(blockData);
+            if (forListData.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeListData(blockData);
+
+        }
+        
+        return result;
+    }
+
+    export function get监管服务能力_RSU发送量() {
+        let bolckDataList = getExcelDataBySheetName('安亭汽车城数据模板.xlsx', '监管服务能力_RSU列表');
+        let result = {};
+        let forKeyValueList = [];
+        let forChartList = [];
+        let forStringList = [];
+        let forListData = ["RSU"];
+        for (let i = 0; i < bolckDataList.length; i++) {
+            let {blockData, blockTitle} = bolckDataList[i];
+
+            let changeName = changeDataName(blockTitle);
+
+            if (forKeyValueList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeKeyValueData(blockData);
+            if (forChartList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeChartData(blockData);
+            if (forStringList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeStringListData(blockData);
+            if (forListData.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeListData(blockData);
+
+        }
+        
+        return result;
+    }
\ No newline at end of file

src/data/interface/cronJob.ts

+//接口任务 定期更新
+import * as request from 'request';
+import { INTERFACEREQUESTTYPEENUM } from "../../config/enum";
+import { BizError } from "../../util/bizError";
+import { Config } from './interfaceConfig';
+
+//初始化接口数据
+export async function initInterfaceData() {
+    const InitTaskSuccess = await taskUpdate();
+    if (!InitTaskSuccess) throw new BizError("服务器启动失败: 初始化定时接口数据时出现问题 请检查目标服务器或本地请求配置");
+    const InitRealTimeSuccess = await initRealTime();
+    if (!InitRealTimeSuccess) throw new BizError("服务器启动失败: 初始化实时接口数据时出现问题 请检查目标服务器或本地请求配置");
+    console.log("初始化接口数据成功");
+    setInterval(() => {
+        taskUpdate();
+    }, 10000);
+}
+
+//异常接口 不更新数据
+let errorInterfaceInfo = {};
+
+//定时接口 数据更新情况
+let updateInfo = {
+    "接口名称":{lastTime:0, updateUseTime:0},//使用时间是毫秒
+};
+
+//定时接口 缓存数据
+let dataQueue = {};
+
+async function taskUpdate() {
+    let thisTaskInfo = [];//此次任务
+    let defaultUseTime =  60000;
+
+    let thisTime = new Date().valueOf();
+
+    let initSuccess = true;
+
+    for (let interfaceName in Config) {
+        const LastReqError = errorInterfaceInfo[interfaceName];
+        if (LastReqError) {
+            console.log(`${interfaceName} 请求时出现过 ${LastReqError} 异常 保险起见此次更新不再请求`);
+            continue;
+        }
+
+        const ThisConfig = Config[interfaceName];
+        if (ThisConfig.type == INTERFACEREQUESTTYPEENUM.即时更新) continue;
+
+        let lastTaskInfo = updateInfo[interfaceName];
+        if ( !lastTaskInfo ) thisTaskInfo.push({name:defaultUseTime, useTime:defaultUseTime});
+        else if ( lastTaskInfo && (thisTime - lastTaskInfo) > ThisConfig.time ) {
+            thisTaskInfo.push({name:defaultUseTime, useTime:lastTaskInfo.updateUseTime});
+        }
+        defaultUseTime += 1;
+    }
+    thisTaskInfo.sort((a, b) => {return a.useTime - b.useTime});//耗时短的优先
+
+    for (let i = 0; i < thisTaskInfo.length; i++) { //更新数据
+        let {name} = thisTaskInfo[i];
+        const ThisConfig = Config[name];
+        const StartTime = new Date().valueOf();
+        
+        let reqRes;
+        switch(ThisConfig.reqType) {
+            case "get": reqRes = await get(ThisConfig.url, ThisConfig.body, ThisConfig.header); break;
+            case "post": reqRes = await post(ThisConfig.url, ThisConfig.body, ThisConfig.header); break;
+            case "postForm": reqRes = await postForm(ThisConfig.url, ThisConfig.body); break;
+        }
+        const UseTime = new Date().valueOf() - StartTime;
+        if (reqRes.success) {
+            if (!updateInfo[name]) updateInfo[name] = {lastTime:thisTime, updateUseTime:UseTime};
+            else {
+                updateInfo[name].lastTime = thisTime;
+                updateInfo[name].updateUseTime = UseTime;
+            }
+            if (dataQueue[name]) delete dataQueue[name];
+            dataQueue[name] = JSON.stringify(reqRes.body);//放入缓存
+        } else {
+            let errorMsg = reqRes.message;
+            if (reqRes.message && reqRes.message.code == "ESOCKETTIMEDOUT") errorMsg = "超时";
+            console.log(`接口 ${name} 请求失败 失败原因${errorMsg}`);
+            if (["404", "503"].indexOf(errorMsg) > -1) { //下次不再请求
+                errorInterfaceInfo[name] = errorMsg;
+            }
+            initSuccess = false;
+        }
+    }
+    return initSuccess;
+}
+
+
+//即时数据缓存 当请求失败时会用到这里的数据
+let realTimeDataQueue = {};
+
+//即时数据初始化
+async function initRealTime() {
+    let initSuccess = true;
+    for (let interfaceName in Config) {
+        const ThisConfig = Config[interfaceName];
+        if (ThisConfig.type == INTERFACEREQUESTTYPEENUM.定时更新) continue;
+        let reqRes;
+        switch(ThisConfig.reqType) {
+            case "get": reqRes = await get(ThisConfig.url, ThisConfig.body, ThisConfig.header); break;
+            case "post": reqRes = await post(ThisConfig.url, ThisConfig.body, ThisConfig.header); break;
+            case "postForm": reqRes = await postForm(ThisConfig.url, ThisConfig.body); break;
+        }
+        if (!reqRes.success) {
+            console.log(`${interfaceName} 接口请求失败 请求地址为 ${ThisConfig.url} 失败原因 ${reqRes.message}`);
+            initSuccess = false;
+        }
+        realTimeDataQueue[interfaceName] = reqRes.data;
+    }
+    return initSuccess;
+}
+
+export async function getInterfaceByInterfaceName(name, body?, header?) {
+    const ThisConfig = Config[name];
+    let data:any;
+    if (ThisConfig.type == INTERFACEREQUESTTYPEENUM.即时更新) {
+        let reqRes;
+        let reqBody = Object.assign( ThisConfig.body|| {},  body || {});
+        let reqHeader = Object.assign( ThisConfig.header|| {},  header || {});
+        switch(ThisConfig.reqType) {
+            case "get": reqRes = await get(ThisConfig.url, reqBody, reqHeader); break;
+            case "post": reqRes = await post(ThisConfig.url, reqBody, reqHeader); break;
+            case "postForm": reqRes = await postForm(ThisConfig.url, reqBody ); break;
+        }
+        if (reqRes.success) {
+            data = reqRes.data;
+        } else {
+           data = realTimeDataQueue[name];
+        }
+        
+    } else data = dataQueue[name];
+    return data;
+}
+
+
+function get(url:string, query?, headers?, timeOut?) {
+    timeOut = timeOut || 5000;
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    return new Promise((resolve, reject)=>{
+        let paramater:any = { url, json:true, timeout:timeOut };
+        if (query) paramater.qs = query;
+        if (headers) paramater.headers = headers;
+        request.get(paramater, function (err, res, data) {
+           const success = !err && res && res.statusCode == 200;
+           let message = err || res.statusCode || "";
+           resolve({success, message, data});
+        })
+    })
+}
+
+
+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(err, res, data) {
+            const success = !err && res && res.statusCode == 200;
+            let message = err || res.statusCode || "";
+            resolve({success, message, data});
+        });
+    })
+}
+
+function postForm(url, body) {
+    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(err, res, data) {
+            const success = !err && res && res.statusCode == 200;
+            let message = err || res.statusCode || "";
+            resolve({success, message, data});
+        });
+    })
+}

src/data/interface/csfx.ts

+import { separateDataAndUint } from "../../cal/privateTools";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getCsfx() {
+    let interfaceName = "测试分析";
+    // let {monthlyTestMileageDistribution, monthlyTestDurationDistribution, enterpriseTestMileageDistribution, enterpriseTestDurationDistribution, enterpriseDisengagementAutopilotRatio} = await getInterfaceByInterfaceName(interfaceName, {});
+
+    let a = {
+        test:[
+            {
+                time:"2020.11",
+                milage:"320km"
+            },
+            {
+                time:"2020.12",
+                milage:"80km"
+            }
+        ],
+        functionalTest:[
+            {
+                time:"2020.11",
+                milage:"320km"
+            },
+            {
+                time:"2020.11",
+                milage:"320km"
+            }
+        ]
+    }
+
+    let atest = a.test;
+    let afunctionalTest = a.functionalTest;
+    console.log(afunctionalTest)
+
+    for (let i = 0; i < atest.length; i++) {
+        let {time, milage} = atest[i];
+        
+    }
+
+    return {a};
+}
+
+function getKeyValueUnit(data) {
+    let result = [];
+    for (let i = 0; i < data.length; i++) {
+        let dataTodayData = data[i];
+
+        let key = dataTodayData.name;
+        let value = dataTodayData.value;
+        let {dataNum, dataUnit} = separateDataAndUint(value);
+        result.push({key, value, unit: dataUnit});
+    }
+
+    return result;
+}
\ No newline at end of file

src/data/interface/csgk.ts

+import { separateDataAndUint } from "../../cal/privateTools";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getCsgk() {
+    let interfaceName = "测试概况";
+    let {basicData, dataToday, testToday, functionalTestToday, testLicense, roadsideSurveillanceVideo} = await getInterfaceByInterfaceName(interfaceName, {});
+
+    let basicInfo = [];//测试概况基础数据
+
+    for (let i = 0; i < basicData.length; i++) {
+        let dataTodayData = basicData[i];
+
+        let key = dataTodayData.name;
+        let value = dataTodayData.value;
+        let testName = ["测试企业数", "企业牌照数", "测试总里程", "测试总时长", "功能测试总里程", "功能测试总时长"]
+
+        let {dataNum, dataUnit} = separateDataAndUint(value);
+        for (let j = 0; j < testName.length; j++) {
+            if (key == testName[j]) {
+                let img = j+1 + ".png";
+                basicInfo.push({key, value, img, unit: dataUnit});
+            }
+        }
+        
+    }
+
+    let dataTodayInfo = getKeyValueUnit(dataToday); //今日数据
+
+    let testTodayInfo = getKeyValueUnit(testToday); //今日测试
+
+    let functionalTestTodayInfo = getKeyValueUnit(functionalTestToday); //今日功能测试
+
+    let testLicenseInfo = getKeyValueUnit(testLicense); //测试牌照发布
+
+    //路侧监控视频
+
+    return {basicInfo, dataTodayInfo, testTodayInfo, functionalTestTodayInfo, testLicenseInfo};
+}
+
+function getKeyValueUnit(data) {
+    let result = [];
+    for (let i = 0; i < data.length; i++) {
+        let dataTodayData = data[i];
+
+        let key = dataTodayData.name;
+        let value = dataTodayData.value;
+        let {dataNum, dataUnit} = separateDataAndUint(value);
+        result.push({key, value, unit: dataUnit});
+    }
+
+    return result;
+}
\ No newline at end of file

src/data/interface/interfaceConfig.ts

+import { INTERFACEREQUESTTYPEENUM } from "../../config/enum";
+
+//配置
+// "接口名称":{
+//     type:"1是即时更新 2是即时更新 使用 INTERFACErEQUESTTYPEENUM", 
+//     time:"更新频率毫秒 例如1小时这里就是 3600000", 
+//     url:"url地址", 
+//     reqType:"get还是post get = get post = post", 
+//     header:{}, 
+//     body:{} 
+// }
+export const Config = {
+    "测试概况": {type: INTERFACEREQUESTTYPEENUM.即时更新, time: 3600000*24, url: "", reqType: "post", header: {}, body: {}},
+}
\ No newline at end of file

src/data/mysql/getData.ts

+import { mysql_ddptDB } from "../../db/mysql/mysql_init";
+import { BizError } from "../../util/bizError";
+export function getDataBySql(sql, ...param) {
+    let paramList = [];
+    param.forEach(thisStr => {
+        paramList.push(thisStr);
+    });
+    return new Promise( (resolve, reject) => {
+        mysql_ddptDB.query(sql, paramList, (err, results, fields) => {
+            if (err) throw new BizError(err);
+            else resolve(results);
+        });
+    });
+}
+
+export function getDataCountBySql(sql, ...param) {
+    let paramList = [];
+    param.forEach(thisStr => {
+        paramList.push(thisStr);
+    });
+    return new Promise( (resolve, reject) => {
+        mysql_ddptDB.query(sql, paramList, (err, results, fields) => {
+            if (err) throw new BizError(err);
+            else resolve(results[0].count);
+        });
+    });
+}
\ No newline at end of file

src/data/mysql/sql.ts

+// sql语句
+export enum SQLENUM {
+    计算云资源 = ``,
+    计算云资源使用率 = ``,
+    物理资源 = ``
+}
\ No newline at end of file

src/db/mongo/db_connect.ts

+import mongoose = require('mongoose');
+import mongoClient = require('mongodb');
+
+let defaultOptions = {
+  // useNewUrlParser:true,
+  auto_reconnect:true,
+  reconnectTries:1000,
+  reconnectInterval:3000,
+  keepAlive: 1,
+  connectTimeoutMS: 30000
+};
+
+
+export async function createDbConnect(connectUrl:string, options?:object) {
+    if (!connectUrl) throw new Error(`wrong connect url ${connectUrl}`);
+    if (!options) options = defaultOptions;
+    console.log("connection mongo=> ",connectUrl);
+    return await mongoose.createConnection(connectUrl, options).catch((err)=>{throw err});
+}

src/db/mongo/db_init.ts

+//初始化db
+import { mongoServerConstVal } from '../../serverConfig';
+import {createDbConnect} from './db_connect';
+import { tableInit } from './table_init';
+
+let db;
+
+export async function init() {
+    console.log('connect to mongodb success');
+
+    db = await createDbConnect(mongoServerConstVal.dbUrl).catch((err)=>{throw err;});
+
+    process.stdin.emit('dbinit success');
+    tableInit();
+
+}
+ 
+export {db};
\ No newline at end of file

src/db/mongo/table_init.ts

+
+export function tableInit() {
+
+    console.log("tableinit success");
+}
\ No newline at end of file

src/db/mysql/mysql_connect.ts

+import * as mysql from 'mysql'
+
+export function createMySqlConnect(host:string, port:number, user:string, password:string, database:string) {
+    return mysql.createConnection({ host, port, user, password, database });
+}

src/db/mysql/mysql_init.ts

+
+import { mySqlConfig } from '../../serverConfig';
+import { createMySqlConnect} from './mysql_connect';
+
+let mysql_ddptDB;
+
+export function initMysqlDB() {
+    const dataBase = 'ddpt';
+
+    mysql_ddptDB = createMySqlConnect(mySqlConfig.mysqlHost, mySqlConfig.mysqlPort, mySqlConfig.mysqlUser, mySqlConfig.mysqlPwd, dataBase);
+    mysql_ddptDB.connect(handleError);
+    mysql_ddptDB.on('error', handleError);
+}
+function handleError (err) {
+    if (err) {
+      // 如果是连接断开，自动重新连接
+      if (err.code === 'PROTOCOL_CONNECTION_LOST') {
+        initMysqlDB();
+      } else {
+        console.error(err.stack || err);
+      }
+    }
+  }
+
+export { mysql_ddptDB };
\ No newline at end of file

src/excelCmd.js

+let fs = require('fs');
+const xlsx = require('node-xlsx');
+const path = require('path');
+//excel的名字
+//const excelName = "其他数据模板.xlsx";
+// const excelAnalysisName = "其他数据规则.xlsx";
+const excelName = "安亭汽车城数据模板.xlsx";
+const excelAnalysisName = "安亭汽车城解析规则.xlsx";
+
+
+let typeEnum = {
+    "柱状数据":1,
+    "列表数据":1,
+    "单轴多柱状数据":1,
+    "双轴多柱状数据":1,
+}
+
+function changeDataName(str) {
+    let result = str.replace(/[()""“”/（）-]/, "_");
+    for (let i =0; i < 10; i++) {
+        result = result.replace(/[()""“”/（）-]/, "_");
+    }
+    return result;
+}
+
+let createBizAndDataConfigMap = {
+    
+};
+
+//配置解析excel
+function analysisConfigExcel() {
+    const workSheetsFromFile = xlsx.parse(`../res/${excelAnalysisName}`);
+    let sheetMap = {};
+    let sheetList = [];
+
+    for (let i = 0; i < workSheetsFromFile.length; i++) {
+        let sheetInfo = workSheetsFromFile[i];
+        sheetMap[sheetInfo.name] = sheetInfo.data;
+        sheetList.push(sheetInfo);
+    }
+
+    return sheetMap
+}
+
+function createConfig() {
+    let excelData = analysisConfigExcel();
+    for (let configSheetName in excelData) {
+        let data = excelData[configSheetName];
+        
+        for (let y = 1; y < data.length; y++) {
+            let valueList = data[y];
+            let pageName = valueList[0];
+            let sheetName = valueList[1];
+            let type = valueList[2];
+            let dataName = changeDataName(valueList[3]);
+            let title = valueList[4];
+            let unit = valueList[5];
+            let total = valueList[6];
+            let percent = valueList[7];
+            let titleList = valueList[8] ? JSON.parse(valueList[8]) : "";
+            let keyValueObj = valueList[9] ? JSON.parse(valueList[9]) : "" ;
+            if (!createBizAndDataConfigMap[pageName] ) createBizAndDataConfigMap[pageName]  = {sheetName, apiList:[]};
+            createBizAndDataConfigMap[pageName].apiList.push({ type ,dataName ,title ,unit ,total ,percent, titleList, keyValueObj });
+
+        }
+    }
+}
+createConfig();
+
+//创建data层
+function createData() {
+    let str = `
+    import { limitEnteNameString, changeDataName } from "../util/tools";
+    import { planarArrBecomeKeyValueData, planarArrBecomeChartData, planarArrBecomeStringListData, planarArrBecomeListData} from "../cal/excelEnter";
+    import { getExcelDataBySheetName } from "../util/analysisExcel";
+    `;
+
+    for (let pangeName in createBizAndDataConfigMap) {
+        let { sheetName } = createBizAndDataConfigMap[pangeName];
+
+        let forKeyValueList = []; 
+        let forChartList = [];
+        let forStringList = [];
+        let forListData = [];
+
+        createBizAndDataConfigMap[pangeName].apiList.forEach( info => {
+            if (info.type == "双轴多柱状数据" || info.type == "单轴多柱状数据" || info.type == "柱状数据") forChartList.push(info.dataName);
+            else if (info.type == "键值数据") forKeyValueList.push(info.dataName);
+            else if (info.type == "列表数据") forListData.push(info.dataName);
+            else if (info.type == "字符数据") forStringList.push(info.dataName);
+        });
+    
+
+    str += `
+    export function get${sheetName}() {
+        let bolckDataList = getExcelDataBySheetName('${excelName}', '${sheetName}');
+        let result = {};
+        let forKeyValueList = ${JSON.stringify(forKeyValueList)};
+        let forChartList = ${JSON.stringify(forChartList)};
+        let forStringList = ${JSON.stringify(forStringList)};
+        let forListData = ${JSON.stringify(forListData)};
+        for (let i = 0; i < bolckDataList.length; i++) {
+            let {blockData, blockTitle} = bolckDataList[i];
+
+            let changeName = changeDataName(blockTitle);
+
+            if (forKeyValueList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeKeyValueData(blockData);
+            if (forChartList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeChartData(blockData);
+            if (forStringList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeStringListData(blockData);
+            if (forListData.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeListData(blockData);
+
+        }
+        
+        return result;
+    }`;
+    }
+
+    let path = `./data/analysisExcelData1.ts`;
+    fs.access(path, (err) => {
+        if (!err) {
+            console.error(path, "文件已存在");
+            return;
+        }
+        
+        fs.writeFileSync(path,  str);
+        console.log(path, "创建文件成功")
+    });
+}
+
+//创建biz层
+function createBiz(){
+    for (let pageName in createBizAndDataConfigMap) {
+        let { apiList, sheetName } = createBizAndDataConfigMap[pageName];
+
+        let thisBizData = getBizStr(apiList, sheetName);
+
+        let path = `./biz/${pageName}.ts`;
+        fs.access(path, (err) => {
+            if (!err) {
+                console.error(path, "文件已存在");
+                return;
+            }
+            
+            fs.writeFileSync(path,  thisBizData);
+            console.log(path, "创建文件成功")
+        });
+
+    }
+}
+
+
+function getBizStr(apiList, sheetName) {
+    let str = `
+    import { getKeyValueNumberOutData, getChartOutData, getKeyValueNotNumberOutData, getListOutData, getScatterFigureOutData, getStringOutData } from "../cal/out";
+    import { get${sheetName} } from "../data/analysisExcelData";
+    `;
+    str += `
+    export function getData(req, res) {
+        let ret:any = {};
+
+        let excelData:any = get${sheetName}();
+    `;
+    apiList.forEach((info, index) => {
+        let  {dataName, unit, total, percent, type, titleList, keyValueObj} = info;
+        const apiName = `api${index+1}`;
+
+        let functionStr = "";
+        
+        switch(type) {
+            case "键值数据": functionStr = `getKeyValueNumberOutData`;
+            break;
+            case "柱状数据":  
+            case "单轴多柱状数据": 
+            case "双轴多柱状数据": functionStr = `getChartOutData`;
+            break;
+            case "列表数据": functionStr = `getListOutData`;
+            break;
+            case "字符串数据":
+            case "图片": functionStr = `getStringOutData`;
+            break;
+        };
+        let subStr = `ret["${apiName}"] = ${functionStr}("${dataName}", excelData.${dataName} );`;
+
+        str+=
+    `${subStr}
+    `
+
+    });
+   
+    
+    str += `
+        res.send(ret);
+    }
+    `
+    return str;
+}
+
+//创建Router层
+function createRouter() {
+    let importName =``;
+    let routergetName=``;
+    let routerpostName=``;
+
+    for (let pageName in createBizAndDataConfigMap) {
+        importName+=`
+import * as ${pageName}Biz from '../biz/${pageName}';`;
+        routergetName+=`
+    httpServer.get('/${pageName}', asyncHandler(${pageName}Biz.getData));`;
+        routerpostName+=`
+    httpServer.post('/${pageName}', asyncHandler(${pageName}Biz.getData));`;
+    }
+
+    let str=`
+import * as asyncHandler from 'express-async-handler'
+${importName}
+
+export function setRouter(httpServer){
+        ${routergetName}
+        ${routerpostName}
+}`;
+
+    let path = `./routers/router1.ts`;
+    fs.access(path, (err) => {
+        if (!err) {
+            console.error(path, "文件已存在");
+            return;
+        }
+        
+        fs.writeFileSync(path, str);
+        console.log(path, "创建router文件成功")
+    });
+}
+
+createData();
+createBiz();
+createRouter();
+
+
+
+

src/main.ts

+
+import { getCsfx } from "./data/interface/csfx";
+import { getCsgk } from "./data/interface/csgk";
+import { httpServer } from "./net/http_server";
+import { getPort } from "./serverConfig";
+
+
+async function lanuch() {
+    // httpServer.createServer(getPort());
+    getCsfx();
+    // getCsgk();
+    console.log('This indicates that the server is started successfully.');
+}
+
+lanuch();
\ No newline at end of file

src/middleware/encryptionReturn.ts

+export async function encryptionReturn(req, res, next) {
+    res.on('end', function(){
+        console.log(res.body);
+    });
+
+    let resSend = res.send;
+    res.send = (obj)=>{
+        changeNumber(obj);
+        //递归修改number型
+        resSend.call(res, obj);
+    };
+    
+    next();
+}
+
+function changeNumber(obj) {
+    if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++) {
+            let arrItem = obj[i];
+            if (typeof arrItem == "number") {
+                obj[i] = getSameLenNumber(arrItem);
+            }
+            else if (typeof arrItem == "object") {
+                changeNumber(arrItem);
+            }
+        }
+    }
+    else {
+        for (let key in obj) {
+            let objItem = obj[key];
+            if (typeof objItem == "number") {
+                if (key == "x" || key == "y") continue;
+                
+                obj[key] = getSameLenNumber(objItem);
+            }
+            else if (typeof objItem == "object") {
+                changeNumber(objItem);
+            }
+        }
+    }
+}
+
+function getSameLenNumber(num) {
+    let numStr = String(num);
+    //疑似年份的不做加密
+    if (numStr.length == 4 && (numStr.indexOf("19") == 0 || numStr.indexOf("20") == 0)) return num;
+    let str = "";
+    for (let i = 0; i < numStr.length; i++) {
+        if (numStr[i] == '.') str += numStr[i];
+        else str += "6";
+    }
+
+    return Number(str);
+}
\ No newline at end of file

src/middleware/fromParam.ts

+var formidable = require("formidable");
+
+export async function parseFormParam(req, res, next) {
+        var form = new formidable.IncomingForm();
+        form.parse(req, (err, fields, files)=>{
+            if (err) {
+                next(err)
+            }
+            else {
+                req.fields = fields;
+                req.files = files;
+                next();
+            }
+        })
+    }
\ No newline at end of file

src/net/http_server.ts

+import express = require('express');
+import bodyParser = require('body-parser');
+import sign = require('../middleware/sign');
+import routers = require('../routers/router');
+import compression = require('compression');
+import { encryptionReturn } from '../middleware/encryptionReturn';
+import { getEnv } from '../serverConfig';
+import * as path from "path";
+import * as fallback from 'express-history-api-fallback';
+
+
+export class httpServer {
+   static createServer(port:number) {
+    var httpServer = express();
+    
+    httpServer.all('*',function (req, res, next) {
+      res.header('Access-Control-Allow-Origin', req.headers.origin);
+      res.header("Access-Control-Allow-Headers", "X-Requested-With");
+      res.header('Access-Control-Allow-Headers', 'Content-Type');
+      res.header("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,OPTIONS");
+      res.header('Access-Control-Allow-Credentials', true);
+      res.header("X-Powered-By", ' 3.2.1');
+      if(req.method === 'OPTIONS'){
+          res.statusCode = 200;
+          res.end();
+        }else{
+            next();
+        }
+    });
+
+    httpServer.use(express.static('video') );
+
+    httpServer.use(bodyParser.json({limit:"10kb"}));
+    httpServer.use(compression())
+    //演示环境加密数据
+    if (getEnv() == "dem") {
+      console.log("演示环境 开启数据加密");
+      httpServer.use(encryptionReturn);
+    }
+    routers.setRouter(httpServer);
+
+    const root = path.join(__dirname, "../../public");
+    httpServer.use(express.static(root));
+    httpServer.use(fallback('index.html', { root }));
+        
+    httpServer.listen(port);
+    console.log('server listen on port:'+port);
+    
+    return httpServer;
+  }
+}

src/routers/router.ts

+
+import * as asyncHandler from 'express-async-handler'
+
+import * as jgfwnl_yzyBiz from '../biz/jgfwnl_yzy';
+import * as jgfwnl_wlzyBiz from '../biz/jgfwnl_wlzy';
+import * as jgfwnl_spBiz from '../biz/jgfwnl_sp';
+import * as jgfwnl_qycsfxBiz from '../biz/jgfwnl_qycsfx';
+import * as jgfwnl_clcszlBiz from '../biz/jgfwnl_clcszl';
+import * as jgfwnl_RSUfslBiz from '../biz/jgfwnl_RSUfsl';
+import * as csgkBiz from '../biz/jgfwnl/csgk';
+import * as csfxBiz from '../biz/jgfwnl/csfx';
+import * as yzy from '../biz/jgfwnl/yzy';
+
+export function setRouter(httpServer){
+        
+    httpServer.get('/jgfwnl_yzy', asyncHandler(jgfwnl_yzyBiz.getData));
+    httpServer.get('/jgfwnl_wlzy', asyncHandler(jgfwnl_wlzyBiz.getData));
+    httpServer.get('/jgfwnl_sp', asyncHandler(jgfwnl_spBiz.getData));
+    httpServer.get('/jgfwnl_qycsfx', asyncHandler(jgfwnl_qycsfxBiz.getData));
+    httpServer.get('/jgfwnl_clcszl', asyncHandler(jgfwnl_clcszlBiz.getData));
+    httpServer.get('/jgfwnl_RSUfsl', asyncHandler(jgfwnl_RSUfslBiz.getData));
+        
+    httpServer.post('/jgfwnl_yzy', asyncHandler(jgfwnl_yzyBiz.getData));
+    httpServer.post('/jgfwnl_wlzy', asyncHandler(jgfwnl_wlzyBiz.getData));
+    httpServer.post('/jgfwnl_sp', asyncHandler(jgfwnl_spBiz.getData));
+    httpServer.post('/jgfwnl_qycsfx', asyncHandler(jgfwnl_qycsfxBiz.getData));
+    httpServer.post('/jgfwnl_clcszl', asyncHandler(jgfwnl_clcszlBiz.getData));
+    httpServer.post('/jgfwnl_RSUfsl', asyncHandler(jgfwnl_RSUfslBiz.getData));
+
+
+    //接口
+    httpServer.get('/testOverview', asyncHandler(csgkBiz.getData)); //测试概况
+    httpServer.get('/testAnalysis', asyncHandler(csfxBiz.getData)); //测试分析
+    httpServer.get('/cloudResoures', asyncHandler(yzy.getData)); //云资源
+
+    httpServer.post('/testOverview', asyncHandler(csgkBiz.getData));
+    httpServer.post('/testAnalysis', asyncHandler(csfxBiz.getData));
+    httpServer.post('/cloudResoures', asyncHandler(yzy.getData));
+
+
+}
\ No newline at end of file

src/serverConfig.ts

+
+//端口
+export function getPort() : number {
+    return Number(process.env.PORT) || Number(process.argv[3]) || 30001;//30001 是给前端的地址
+}
+
+// sit 测试环境 prod 生产环境 dem 演示环境(测试数据，前端无密码访问)
+export function getEnv() : string {
+    return process.argv[2] || "sit";
+}
+
+//mongo数据库连接字符
+export const mongoServerConstVal = {
+    dbUrl:'mongodb://192.168.12.79:27017/zjsc?w=1&wtimeoutMS=30000'
+}
+
+//mysql数据库连接对象
+export const mySqlConfig = {
+    mysqlHost: 'localhost',
+    mysqlPort: 3306,
+    mysqlUser: 'root',
+    mysqlPwd: '123456',
+    // mysqlHost:'10.96.240.55',
+    // mysqlPort:3306,
+    // mysqlUser:'ddtest',
+    // mysqlPwd:'ddtest123^',
+};
+
+
+
+export const interfaceConfig = {
+    企业信息数据列表: '/openapi/company/list',
+    创投机构数据列表: '/openapi/investorg/list',
+    科技金融产品: '/openapi/product/list'
+}
\ No newline at end of file

src/util/bizError.ts

+export class BizError extends Error {
+
+}
\ No newline at end of file

src/util/excel.ts

+const fs = require('fs');
+const xlsx = require('node-xlsx');
+const path = require('path');
+
+//获取单个目录下的单个excel文件数据 只能有一个文件
+export function getExcelDataByPath (dir) {
+    console.log(path.join(__dirname,dir))
+    let files = fs.readdirSync( path.join(__dirname,dir));
+
+    for (let i = 0; i < files.length; i++) {
+        if (files[i].indexOf('~') == 0 || files[i].indexOf('.') == 0) continue;
+        const workSheetsFromFile = xlsx.parse(dir+'/'+files[i]);
+        let sheetMap = {};
+        let sheetList = [];
+        for (let i = 0; i < workSheetsFromFile.length; i++) {
+            let sheetInfo = workSheetsFromFile[i];
+            sheetMap[sheetInfo.name] = sheetInfo.data;
+            sheetList.push(sheetInfo.data)
+        }
+    
+        return {sheetMap, sheetList}
+    }   
+}
+
+export function updateExcel(data, fileName) {
+    try{
+        fs.writeFileSync('output.xlsx', xlsx.build(data), "binary");
+        console.log(`写入 ${fileName} 成功`);
+    }catch(err) {
+        console.log(err);
+    }
+    
+}
+
+//获取单个excel文件的数据
+export function getExcelDataByFile(filePath) {
+    const workSheetsFromFile = xlsx.parse(filePath);
+    let sheetMap = {};
+    let sheetList = [];
+    for (let i = 0; i < workSheetsFromFile.length; i++) {
+        let sheetInfo = workSheetsFromFile[i];
+        sheetMap[sheetInfo.name] = sheetInfo.data;
+        sheetList.push(sheetInfo);
+    }
+
+    return {sheetMap, sheetList}  
+}
+
+export function arrayToObject(dataArr, keyNameArr) {
+    let obj = {};
+    for (let i = 0; i < dataArr.length; i++) {
+        obj[keyNameArr[i]] = dataArr[i];
+    }
+
+    return obj;
+}
\ No newline at end of file

src/util/mockData.ts

+/**
+ * 
+ * @param keyList 要生成的键名称集合 例如: ["键1", "键2"]
+ * @param valLen 要生成的值的长度 例如 十位数就传1 百位数就传2  例如: 1  则会生成 键1或键2 的数据是1-10的随机数 
+ * @param haveUnit 单位信息： 如果传 % 号则会把生成的随机数再求百分比 传false 则不生成单位  传 数组 例如：["家","个"] 则 键1的单位是 家， 键2的单位是个
+ * @param title 数据标题
+ * @param subTitle  数据副标题
+ * @param total 是否要求和 
+ * @returns 
+ */
+export function mock键值数据模板(keyList, valLen, haveUnit, title, subTitle, total) {
+    let data = {
+        "title": "",
+        "subTitle": "",
+        "total": 0,
+        "list": []
+    };
+    if (title) data.title = title;
+    if (subTitle) data.subTitle = subTitle || title;
+    if ( haveUnit && haveUnit == "%" ) {
+        let random = Math.ceil(  Math.random() * 20 );
+        let avg = Math.ceil((100 - random) / keyList.length);
+        keyList.forEach((key, index) => {
+            let valut = index == 0 ? avg + random : avg;
+            let onceInfo:any = {
+                "key":key,
+                "value": valut,
+                unit:"%"
+            };
+            data.list.push(onceInfo);
+        });
+
+    } else {
+        let unitIndex = 0;
+        for (let i = 0; i < keyList.length; i++) {
+            let key = keyList[i];
+            let onceInfo:any = {
+                "key":key,
+                "value": getValueByLength(valLen)
+            };
+            if (haveUnit) {
+                if (typeof haveUnit == "string") onceInfo.unit = haveUnit;
+                else onceInfo.unit = haveUnit[unitIndex];
+            }
+            data.list.push(onceInfo);
+            unitIndex += 1;
+        }
+    
+        if (total) {
+            data.list.forEach(keyValue=>{
+                data.total += keyValue.value;
+            })
+        }
+    }
+    return data;
+}
+
+//键值数据 值为字符串
+export function mock键值数据字符串模板(title, subTitle, obj) {
+    let data = { title: "", subTitle: "", total: 0, list: [] };
+    if (title) data.title = title;
+    if (subTitle) data.subTitle = subTitle || title;
+    for (let key in obj) {
+        data.list.push({
+            key,
+            value:obj[key]
+        });
+    }
+
+    return data;
+}
+
+//列表数据 obj:{ "表格1":{title1:1, title2:2, title3:3... } }
+export function mock列表模板( obj, number ) {
+    let tableNumber = Object.keys(obj).length;
+    if (tableNumber > 1) {
+        let data = [];
+        for (let key in obj) {
+            let onceTable:any = {title:key, total:number, subTitle:key, titleList:[], valueList:[] };
+            onceTable.titleList = Object.keys(obj[key]);
+            for (let i = 0; i < number; i++) {
+                onceTable.valueList.push(Object.values(obj[key]) );
+            }
+    
+            data.push(onceTable);
+        }
+        return data;
+    } else {
+        let onceTable:any = {};
+        for (let key in obj) {
+            onceTable = {title:key, total:number, subTitle:key, titleList:[], valueList:[] };
+            onceTable.titleList = Object.keys(obj[key]);
+            for (let i = 0; i < number; i++) {
+                onceTable.valueList.push(Object.values(obj[key]) );
+            }
+    
+        }
+        return onceTable;
+    }
+   
+}
+
+export function mock图形数据模板(keyList, title, number?, subTitleList?) {
+    if (!number) number = 1;
+   
+    if (number == 1) {
+        let data = {
+            "title": title ? title : "测试标题",
+            "yMaxValue": 100,
+            "yMinValue": 0,
+            "yStepValue": 10,
+            "unit": "个",
+            "data": {
+                "title": "测试数据标题",
+                "subTitle": "测试数据副标题",
+                "total": 1,
+                "list": []
+            }
+        }
+        for (let i = 0; i < keyList.length; i++) {
+            let key = keyList[i];
+            let onceInfo:any = {
+                key,
+                "value": Math.floor(Math.random()*99+1),
+                "unit": "个"
+            };
+            
+            data.data.list.push(onceInfo)
+        }
+    
+        data.data.list.forEach(keyValue=>{
+            data.data.total += keyValue.value;
+        });
+        return data;
+    } else {
+        let data = {
+            "title": title ? title : "测试标题",
+            "yMaxValue": 100,
+            "yMinValue": 0,
+            "yStepValue": 10,
+            "unit": "个",
+            "data": []
+        };
+        for (let y = 0; y < number; y++) {
+            let onceData = {
+                "title": subTitleList[y],
+                "subTitle": subTitleList[y],
+                "total": 1,
+                "list": []
+            }
+            for (let i = 0; i < keyList.length; i++) {
+                let key = keyList[i];
+                let onceInfo:any = {
+                    key,
+                    "value": Math.floor(Math.random()*99+1),
+                    "unit": "个"
+                };
+                
+                onceData.list.push(onceInfo)
+            }
+        
+            onceData.list.forEach(keyValue=>{
+                onceData.total += keyValue.value;
+            });
+            data.data.push(onceData);
+        }
+       
+        return data;
+    }
+
+}
+
+// 柱状图数据模板 模拟数据
+export function mock柱状图数据模板(len, title?) {
+    let data = {
+        "title": title ? title : "测试标题",
+        "yMaxValue": 100,
+        "yMinValue": 0,
+        "yStepValue": 10,
+        "unit": "个",
+        "data": {
+            "title": "测试数据标题",
+            "subTitle": "测试数据副标题",
+            "total": 1,
+            "list": [
+              
+            ]
+        }
+      }
+    
+    for (let i = 0; i < len; i++) {
+        let onceInfo:any = {
+            "key": 2010 + i,
+            "value": Math.floor(Math.random()*99+1),
+            "unit": "个"
+        };
+        
+        data.data.list.push(onceInfo)
+    }
+
+    data.data.list.forEach(keyValue=>{
+        data.data.total += keyValue.value;
+    })
+
+    return data;
+}
+
+export function mock多柱柱状数据模板(len, 数组长度, title?) {
+    let data = {
+        "title": title ? title : "测试标题",
+        "yMaxValue": 100,
+        "yMinValue": 0,
+        "yStepValue": 10,
+        "unit": "个",
+        "data": []
+      }
+    
+    for (let arrLen = 0; arrLen < 数组长度; arrLen++) {
+        let obj = {
+            "title": "测试数据标题",
+            "subTitle": "测试数据副标题",
+            "total": 0,
+            "list": [
+              
+            ]
+        }
+
+        for (let i = 0; i < len; i++) {
+            let onceInfo:any = {
+                "key": 2010 + i,
+                "value": Math.floor(Math.random()*99+1),
+                "unit": "个"
+            };
+            
+            obj.list.push(onceInfo)
+        }
+    
+        obj.list.forEach(keyValue=>{
+            obj.total += keyValue.value;
+        });
+
+        data.data.push(obj);
+    }
+
+    return data;
+}
+
+//获取特定长度的测试文字
+export function getTestStrByLength(strLen, strType) {
+    let testStr = ``;
+    if (strType == 'c') {//中文
+        if (strLen < 5) {
+            testStr += `测试文本`.substring(0, strLen);
+        } else {
+            testStr += `测试`;
+            getPlaByLength((strLen - 4), () => {
+                testStr += '-';
+            });
+            testStr += `文本`
+        }
+    } else {//英文
+        testStr += `te`;
+        getPlaByLength((strLen - 4), () => {
+            testStr += '-';
+        });
+        testStr += `st`
+    }
+    return testStr;
+}
+function getValueByLength(length) {
+    let i = 1;
+    getPlaByLength(length, () => {
+        i= i * 10;
+    });
+    return Math.floor(Math.random() * i);
+}
+
+//获取特定长度的 占位符号
+function getPlaByLength(num, callback) {
+    for (let i =0; i < num; i++) {
+        callback();
+    }
+}
+
+
+
+// 地图数据模板 模拟数据
+export function mock地图数据模板(len) {
+    let data = {
+        "typeNameList": [
+          "type1","type2","type3"
+        ],
+        "list": [
+          
+        ]
+    }
+
+    for (let i = 0; i < len; i++) {
+        data.list.push({
+            "x": Math.floor(Math.random()*500),
+            "y": Math.floor(Math.random()*500),
+            "typeName": "type"+(i%3+1),
+            "title": "测试标题",
+            "address": "测试地址",
+            "data": "测试数据<b>加粗</b></br>等等"
+          })
+    }
+
+    return data;
+}
+
+export function mock表数据模板(表头长度, 数据长度) {
+    let data = {
+        title:"",
+        titleList:[],
+        valueList:[]
+    }
+
+    for (let i = 0; i < 表头长度; i++) {
+        data.titleList.push("表头"+i);
+    }
+
+    for(let j = 0; j < 数据长度; j++) {
+        for (let i = 0; i < 表头长度; i++) {
+            data.titleList.push("数据"+i);
+        }
+    }
+}
+
+export function randomNumber(max, min=0) {
+    return Math.floor(Math.random()*(max-min))+min;
+}
\ No newline at end of file

src/util/request.ts

+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)
+            }
+        });
+    })
+}

tsconfig.json

+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2017",
+    "sourceMap": true,
+    "rootDir":"./src",
+    "outDir":"./out"
+  },
+  "exclude": [
+    "node_modules"
+  ]
+} 
\ No newline at end of file