no message

.gitignore

+.idea
+.vscode
+/out
+/node_modules
+/test
+*test*
+*.log
\ 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": "^6.2.3",
+    "node-xlsx": "^0.16.1",
+    "nodemailer": "^6.1.1",
+    "pyfl": "^1.1.4",
+    "request": "^2.88.0",
+    "svg-captcha": "^1.3.12",
+    "xml2js": "^0.4.23"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
+}

serverConfig.xml

+<config>
+    <port>40026</port>
+</config>
\ No newline at end of file

src/biz/jxgljsc.ts

+
+import { jxgljscTableData } from '../data/table/jxgljscData';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
+
+/*                            绩效管理驾驶舱                    */
+
+export function getData(req, res) {
+    let excelData = jxgljscTableData();
+
+    let ret:any = {};
+
+    let zfqymjqkfxPackageData = keyValuePackage(excelData['在孵企业面积情况分析'].dataList);
+    ret['zfqymjqkfx'] = getKeyValueOut('在孵企业面积情况分析', zfqymjqkfxPackageData);
+                    
+    let zfqymjbhqsPackageData = onceYBarChartPackage( excelData['在孵企业面积变化趋势'], '','');
+    ret['zfqymjbhqs'] = getOnceYBarChartOut('在孵企业面积变化趋势', zfqymjbhqsPackageData);
+                    
+    let cyjgPackageData = keyValuePackage(excelData['产业结构'].dataList);
+    ret['cyjg'] = getKeyValueOut('产业结构', cyjgPackageData);
+                    
+    let ykjqypyqkTableData = tablePackage(excelData["硬科技企业培育情况"].headerList[0], excelData["硬科技企业培育情况"].bodyList);
+    ret['ykjqypyqk'] = getTableOut( '硬科技企业培育情况', ykjqypyqkTableData);
+                    
+    let rcyjPackageData = keyValuePackage(excelData['人才引进'].dataList);
+    ret['rcyj'] = getKeyValueOut('人才引进', rcyjPackageData);
+                    
+    let fhqhzsjPackageData = keyValuePackage(excelData['孵化器汇总数据'].dataList);
+    ret['fhqhzsj'] = getKeyValueOut('孵化器汇总数据', fhqhzsjPackageData);
+                    
+    let xzzfqyqkPackageData = keyValuePackage(excelData['新增在孵企业情况'].dataList);
+    ret['xzzfqyqk'] = getKeyValueOut('新增在孵企业情况', xzzfqyqkPackageData);
+                    
+    let zyjjnlPackageData = keyValuePackage(excelData['资源集聚能力'].dataList);
+    ret['zyjjnl'] = getKeyValueOut('资源集聚能力', zyjjnlPackageData);
+                    
+    let zhnlPackageData = keyValuePackage(excelData['综合能力'].dataList);
+    ret['zhnl'] = getKeyValueOut('综合能力', zhnlPackageData);
+                    
+    let byqyqkPackageData = keyValuePackage(excelData['毕业企业情况'].dataList);
+    ret['byqyqk'] = getKeyValueOut('毕业企业情况', byqyqkPackageData);
+                    
+    let qycxfsddnlPackageData = keyValuePackage(excelData['区域创新辐射带动能力'].dataList);
+    ret['qycxfsddnl'] = getKeyValueOut('区域创新辐射带动能力', qycxfsddnlPackageData);
+                    
+    let yjPackageData = keyValuePackage(excelData['预警'].dataList);
+    ret['yj'] = getKeyValueOut('预警', yjPackageData);
+                    
+    let qyyjPackageData = keyValuePackage(excelData['企业预警'].dataList);
+    ret['qyyj'] = getKeyValueOut('企业预警', qyyjPackageData);
+                    
+    let qydtPackageData = keyValuePackage(excelData['企业动态'].dataList);
+    ret['qydt'] = getKeyValueOut('企业动态', qydtPackageData);
+                    
+    let zfqybhqsPackageData = onceYBarChartPackage( excelData['在孵企业变化趋势'], '家','');
+    ret['zfqybhqs'] = getOnceYBarChartOut('在孵企业变化趋势', zfqybhqsPackageData);
+                    
+    let jrfwPackageData = keyValuePackage(excelData['金融服务'].dataList);
+    ret['jrfw'] = getKeyValueOut('金融服务', jrfwPackageData);
+                    
+    let zysjePackageData = keyValuePackage(excelData['总营收金额'].dataList);
+    ret['zysje'] = getKeyValueOut('总营收金额', zysjePackageData);
+                    
+    let zfqyzysPackageData = keyValuePackage(excelData['在孵企业总营收'].dataList);
+    ret['zfqyzys'] = getKeyValueOut('在孵企业总营收', zfqyzysPackageData);
+                    
+    let tzlxPackageData = keyValuePackage(excelData['投资类型'].dataList);
+    ret['tzlx'] = getKeyValueOut('投资类型', tzlxPackageData);
+                    
+    let zfqyrzqkPackageData = keyValuePackage(excelData['在孵企业融资情况'].dataList);
+    ret['zfqyrzqk'] = getKeyValueOut('在孵企业融资情况', zfqyrzqkPackageData);
+                    
+    let ggjsfwPackageData = keyValuePackage(excelData['公共技术服务'].dataList);
+    ret['ggjsfw'] = getKeyValueOut('公共技术服务', ggjsfwPackageData);
+                    
+    let qyfhlPackageData = keyValuePackage(excelData['企业孵化率'].dataList);
+    ret['qyfhl'] = getKeyValueOut('企业孵化率', qyfhlPackageData);
+                    
+    let qyfhsPackageData = keyValuePackage(excelData['企业孵化数'].dataList);
+    ret['qyfhs'] = getKeyValueOut('企业孵化数', qyfhsPackageData);
+                     
+    res.send(ret);
+} 
\ No newline at end of file

src/biz/qyfw.ts

+
+import { qyfwTableData } from '../data/table/qyfwData';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
+
+/*                            企业服务                    */
+
+export function getData(req, res) {
+    let excelData = qyfwTableData();
+
+    let ret:any = {};
+
+    let qyjbqkPackageData = keyValuePackage(excelData['企业基本情况'].dataList);
+    ret['qyjbqk'] = getKeyValueOut('企业基本情况', qyjbqkPackageData);
+                    
+    let bhqsfxPackageData = onceYBarChartPackage( excelData['变化趋势分析'], '','');
+    ret['bhqsfx'] = getOnceYBarChartOut('变化趋势分析', bhqsfxPackageData);
+                    
+    let rfszfbPackageData = keyValuePackage(excelData['入孵时长分布'].dataList);
+    ret['rfszfb'] = getKeyValueOut('入孵时长分布', rfszfbPackageData);
+                    
+    let fhqyhylyzbPackageData = keyValuePackage(excelData['孵化企业行业领域占比'].dataList);
+    ret['fhqyhylyzb'] = getKeyValueOut('孵化企业行业领域占比', fhqyhylyzbPackageData);
+                    
+    let qyrcPackageData = onceYBarChartPackage( excelData['企业人才'], '','');
+    ret['qyrc'] = getOnceYBarChartOut('企业人才', qyrcPackageData);
+                    
+    let qyfwhzsjPackageData = keyValuePackage(excelData['企业服务汇总数据'].dataList);
+    ret['qyfwhzsj'] = getKeyValueOut('企业服务汇总数据', qyfwhzsjPackageData);
+                    
+    let qyxqdtPackageData = keyValuePackage(excelData['企业需求动态'].dataList);
+    ret['qyxqdt'] = getKeyValueOut('企业需求动态', qyxqdtPackageData);
+                    
+    let qyxqdtxxTableData = tablePackage(excelData["企业需求动态详细"].headerList[0], excelData["企业需求动态详细"].bodyList);
+    ret['qyxqdtxx'] = getTableOut( '企业需求动态详细', qyxqdtxxTableData);
+                    
+    let dtTableData = tablePackage(excelData["地图"].headerList[0], excelData["地图"].bodyList);
+    ret['dt'] = getTableOut( '地图', dtTableData);
+                    
+    let qybhqkPackageData = keyValuePackage(excelData['企业变化情况'].dataList);
+    ret['qybhqk'] = getKeyValueOut('企业变化情况', qybhqkPackageData);
+                    
+    let bhqsPackageData = onceYBarChartPackage( excelData['变化趋势'], '家','');
+    ret['bhqs'] = getOnceYBarChartOut('变化趋势', bhqsPackageData);
+                    
+    let jrfwPackageData = keyValuePackage(excelData['金融服务'].dataList);
+    ret['jrfw'] = getKeyValueOut('金融服务', jrfwPackageData);
+                    
+    let byrzqyPackageData = onceYBarChartPackage( excelData['本月融资企业'], '','');
+    ret['byrzqy'] = getOnceYBarChartOut('本月融资企业', byrzqyPackageData);
+                    
+    let byrzjePackageData = onceYBarChartPackage( excelData['本月融资金额'], '','');
+    ret['byrzje'] = getOnceYBarChartOut('本月融资金额', byrzjePackageData);
+                    
+    let zfqyzysPackageData = keyValuePackage(excelData['在孵企业总营收'].dataList);
+    ret['zfqyzys'] = getKeyValueOut('在孵企业总营收', zfqyzysPackageData);
+                    
+    let jrfwqyTableData = tablePackage(excelData["金融服务企业"].headerList[0], excelData["金融服务企业"].bodyList);
+    ret['jrfwqy'] = getTableOut( '金融服务企业', jrfwqyTableData);
+                    
+    let zscqPackageData = keyValuePackage(excelData['知识产权'].dataList);
+    ret['zscq'] = getKeyValueOut('知识产权', zscqPackageData);
+                    
+    let zscqbtPackageData = keyValuePackage(excelData['知识产权饼图'].dataList);
+    ret['zscqbt'] = getKeyValueOut('知识产权饼图', zscqbtPackageData);
+                    
+    let zscqxqTableData = tablePackage(excelData["知识产权详情"].headerList[0], excelData["知识产权详情"].bodyList);
+    ret['zscqxq'] = getTableOut( '知识产权详情', zscqxqTableData);
+                    
+    let qyzzflPackageData = keyValuePackage(excelData['企业资质分类'].dataList);
+    ret['qyzzfl'] = getKeyValueOut('企业资质分类', qyzzflPackageData);
+                    
+    let qyzzfl_xjrTableData = tablePackage(excelData["企业资质分类_小巨人"].headerList[0], excelData["企业资质分类_小巨人"].bodyList);
+    ret['qyzzfl_xjr'] = getTableOut( '企业资质分类_小巨人', qyzzfl_xjrTableData);
+                    
+    let qyzzfl_gxqyTableData = tablePackage(excelData["企业资质分类_高新企业"].headerList[0], excelData["企业资质分类_高新企业"].bodyList);
+    ret['qyzzfl_gxqy'] = getTableOut( '企业资质分类_高新企业', qyzzfl_gxqyTableData);
+                    
+    let qyzzfl_zjtxTableData = tablePackage(excelData["企业资质分类_专精特新"].headerList[0], excelData["企业资质分类_专精特新"].bodyList);
+    ret['qyzzfl_zjtx'] = getTableOut( '企业资质分类_专精特新', qyzzfl_zjtxTableData);
+                    
+    let qyzzfl_gqpyTableData = tablePackage(excelData["企业资质分类_高企培育"].headerList[0], excelData["企业资质分类_高企培育"].bodyList);
+    ret['qyzzfl_gqpy'] = getTableOut( '企业资质分类_高企培育', qyzzfl_gqpyTableData);
+                     
+    res.send(ret);
+} 
\ No newline at end of file

src/biz/qyszhx.ts

+
+import { qyszhxTableData } from '../data/table/qyszhxData';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, stringListPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getStringOut, getTableOut } from '../dataPackage/out';
+
+/*                            企业数字画像                    */
+
+export function getData(req, res) {
+    let excelData = qyszhxTableData();
+
+    let ret:any = {};
+
+    let qyjbqkPackageData = keyValuePackage(excelData['企业基本情况'].dataList);
+    ret['qyjbqk'] = getKeyValueOut('企业基本情况', qyjbqkPackageData);
+                    
+    let qyjbsjPackageData = keyValuePackage(excelData['企业基本数据'].dataList, "false");
+    ret['qyjbsj'] = getKeyValueOut('企业基本数据', qyjbsjPackageData);
+                    
+    let qybqPackageData = stringListPackage(excelData['企业标签'].dataList);
+    ret['qybq'] = getStringOut('企业标签', qybqPackageData);
+                    
+    let zscqPackageData = keyValuePackage(excelData['知识产权'].dataList);
+    ret['zscq'] = getKeyValueOut('知识产权', zscqPackageData);
+                    
+    let qyyghxPackageData = keyValuePackage(excelData['企业员工画像'].dataList);
+    ret['qyyghx'] = getKeyValueOut('企业员工画像', qyyghxPackageData);
+                    
+    let lnrczpqkPackageData = onceYBarChartPackage( excelData['历年人才招聘情况'], '','');
+    ret['lnrczpqk'] = getOnceYBarChartOut('历年人才招聘情况', lnrczpqkPackageData);
+                    
+    let qyhzsjPackageData = keyValuePackage(excelData['企业汇总数据'].dataList);
+    ret['qyhzsj'] = getKeyValueOut('企业汇总数据', qyhzsjPackageData);
+                    
+    let xjrTableData = tablePackage(excelData["小巨人"].headerList[0], excelData["小巨人"].bodyList);
+    ret['xjr'] = getTableOut( '小巨人', xjrTableData);
+                    
+    let gxqyTableData = tablePackage(excelData["高新企业"].headerList[0], excelData["高新企业"].bodyList);
+    ret['gxqy'] = getTableOut( '高新企业', gxqyTableData);
+                    
+    let zjtxTableData = tablePackage(excelData["专精特新"].headerList[0], excelData["专精特新"].bodyList);
+    ret['zjtx'] = getTableOut( '专精特新', zjtxTableData);
+                    
+    let ysqkPackageData = keyValuePackage(excelData['营收情况'].dataList);
+    ret['ysqk'] = getKeyValueOut('营收情况', ysqkPackageData);
+                    
+    let ysbhqsPackageData = onceYBarChartPackage( excelData['营收变化趋势'], '','');
+    ret['ysbhqs'] = getOnceYBarChartOut('营收变化趋势', ysbhqsPackageData);
+                    
+    let qydtTableData = tablePackage(excelData["企业动态"].headerList[0], excelData["企业动态"].bodyList);
+    ret['qydt'] = getTableOut( '企业动态', qydtTableData);
+                    
+    let fwxqPackageData = keyValuePackage(excelData['服务需求'].dataList, "false");
+    ret['fwxq'] = getKeyValueOut('服务需求', fwxqPackageData);
+                    
+    let hdbhqsfxPackageData = onceYBarChartPackage( excelData['活动变化趋势分析'], '','');
+    ret['hdbhqsfx'] = getOnceYBarChartOut('活动变化趋势分析', hdbhqsfxPackageData);
+                    
+    let fwjl_kjfwTableData = tablePackage(excelData["服务记录_空间服务"].headerList[0], excelData["服务记录_空间服务"].bodyList);
+    ret['fwjl_kjfw'] = getTableOut( '服务记录_空间服务', fwjl_kjfwTableData);
+                    
+    let fwjl_gsfwTableData = tablePackage(excelData["服务记录_工商服务"].headerList[0], excelData["服务记录_工商服务"].bodyList);
+    ret['fwjl_gsfw'] = getTableOut( '服务记录_工商服务', fwjl_gsfwTableData);
+                    
+    let fwjl_rzfwTableData = tablePackage(excelData["服务记录_融资服务"].headerList[0], excelData["服务记录_融资服务"].bodyList);
+    ret['fwjl_rzfw'] = getTableOut( '服务记录_融资服务', fwjl_rzfwTableData);
+                    
+    let fwjlPackageData = keyValuePackage(excelData['服务记录'].dataList);
+    ret['fwjl'] = getKeyValueOut('服务记录', fwjlPackageData);
+                    
+    let yqtzPackageData = keyValuePackage(excelData['园区通知'].dataList);
+    ret['yqtz'] = getKeyValueOut('园区通知', yqtzPackageData);
+                    
+    let yqtzxqTableData = tablePackage(excelData["园区通知详情"].headerList[0], excelData["园区通知详情"].bodyList);
+    ret['yqtzxq'] = getTableOut( '园区通知详情', yqtzxqTableData);
+                    
+    let yqhdPackageData = keyValuePackage(excelData['园区活动'].dataList);
+    ret['yqhd'] = getKeyValueOut('园区活动', yqhdPackageData);
+                    
+    let yqhdmxTableData = tablePackage(excelData["园区活动明细"].headerList[0], excelData["园区活动明细"].bodyList);
+    ret['yqhdmx'] = getTableOut( '园区活动明细', yqhdmxTableData);
+                     
+    res.send(ret);
+} 
\ No newline at end of file

src/biz/zhyy.ts

+
+import { zhyyTableData } from '../data/table/zhyyData';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
+
+/*                            智慧运营                    */
+
+export function getData(req, res) {
+    let excelData = zhyyTableData();
+
+    let ret:any = {};
+
+    let yqgkPackageData = keyValuePackage(excelData['园区概况'].dataList);
+    ret['yqgk'] = getKeyValueOut('园区概况', yqgkPackageData);
+                    
+    let zfqysjPackageData = keyValuePackage(excelData['在孵企业数据'].dataList);
+    ret['zfqysj'] = getKeyValueOut('在孵企业数据', zfqysjPackageData);
+                    
+    let rzqybhqsPackageData = onceYBarChartPackage( excelData['入驻企业变化趋势'], '','');
+    ret['rzqybhqs'] = getOnceYBarChartOut('入驻企业变化趋势', rzqybhqsPackageData);
+                    
+    let rzqyhylxPackageData = keyValuePackage(excelData['入驻企业行业类型'].dataList);
+    ret['rzqyhylx'] = getKeyValueOut('入驻企业行业类型', rzqyhylxPackageData);
+                    
+    let fhyyPackageData = keyValuePackage(excelData['孵化运营'].dataList);
+    ret['fhyy'] = getKeyValueOut('孵化运营', fhyyPackageData);
+                    
+    let fhmjbhqsPackageData = onceYBarChartPackage( excelData['孵化面积变化趋势'], '','');
+    ret['fhmjbhqs'] = getOnceYBarChartOut('孵化面积变化趋势', fhmjbhqsPackageData);
+                    
+    let zfqybhqsPackageData = onceYBarChartPackage( excelData['在孵企业变化趋势'], '','');
+    ret['zfqybhqs'] = getOnceYBarChartOut('在孵企业变化趋势', zfqybhqsPackageData);
+                    
+    let byqybhqsPackageData = onceYBarChartPackage( excelData['毕业企业变化趋势'], '','');
+    ret['byqybhqs'] = getOnceYBarChartOut('毕业企业变化趋势', byqybhqsPackageData);
+                    
+    let rzqyPackageData = onceYBarChartPackage( excelData['融资企业变化趋势'], '','');
+    ret['rzqy'] = getOnceYBarChartOut('融资企业变化趋势', rzqyPackageData);
+                    
+    let ryzzPackageData = keyValuePackage(excelData['荣誉资质'].dataList);
+    ret['ryzz'] = getKeyValueOut('荣誉资质', ryzzPackageData);
+                    
+    let zhyyhzsjPackageData = keyValuePackage(excelData['智慧运营汇总数据'].dataList);
+    ret['zhyyhzsj'] = getKeyValueOut('智慧运营汇总数据', zhyyhzsjPackageData);
+                    
+    let dtTableData = tablePackage(excelData["地图"].headerList[0], excelData["地图"].bodyList);
+    ret['dt'] = getTableOut( '地图', dtTableData);
+                    
+    let jyfxPackageData = keyValuePackage(excelData['就业分析'].dataList);
+    ret['jyfx'] = getKeyValueOut('就业分析', jyfxPackageData);
+                    
+    let jdjyrsqsfxPackageData = onceYBarChartPackage( excelData['季度就业人数趋势分析'], '','');
+    ret['jdjyrsqsfx'] = getOnceYBarChartOut('季度就业人数趋势分析', jdjyrsqsfxPackageData);
+                    
+    let cygmfxPackageData = keyValuePackage(excelData['产业规模分析'].dataList);
+    ret['cygmfx'] = getKeyValueOut('产业规模分析', cygmfxPackageData);
+                    
+    let zfqyyszbPackageData = keyValuePackage(excelData['在孵企业营收占比'].dataList);
+    ret['zfqyyszb'] = getKeyValueOut('在孵企业营收占比', zfqyyszbPackageData);
+                    
+    let qyfwPackageData = keyValuePackage(excelData['企业服务'].dataList);
+    ret['qyfw'] = getKeyValueOut('企业服务', qyfwPackageData);
+                    
+    let qyfwlxPackageData = keyValuePackage(excelData['企业服务类型'].dataList);
+    ret['qyfwlx'] = getKeyValueOut('企业服务类型', qyfwlxPackageData);
+                    
+    let fwzlTableData = tablePackage(excelData["服务质量"].headerList[0], excelData["服务质量"].bodyList);
+    ret['fwzl'] = getTableOut( '服务质量', fwzlTableData);
+                    
+    let yysrqsPackageData = onceYBarChartPackage( excelData['运营收入趋势'], '','');
+    ret['yysrqs'] = getOnceYBarChartOut('运营收入趋势', yysrqsPackageData);
+                    
+    let cyzcPackageData = keyValuePackage(excelData['产业政策'].dataList);
+    ret['cyzc'] = getKeyValueOut('产业政策', cyzcPackageData);
+                    
+    let cyzcxxPackageData = keyValuePackage(excelData['产业政策详细'].dataList);
+    ret['cyzcxx'] = getKeyValueOut('产业政策详细', cyzcxxPackageData);
+                    
+    let yqhdPackageData = keyValuePackage(excelData['园区活动'].dataList);
+    ret['yqhd'] = getKeyValueOut('园区活动', yqhdPackageData);
+                    
+    let yqxwPackageData = keyValuePackage(excelData['园区新闻'].dataList);
+    ret['yqxw'] = getKeyValueOut('园区新闻', yqxwPackageData);
+                     
+    res.send(ret);
+} 
\ No newline at end of file

src/config/enum.ts

+export enum INTERFACErEQUESTTYPEENUM {
+    即时更新 = 1,
+    定时更新
+}
\ No newline at end of file

src/config/interfaceConfig.ts

+
+import { INTERFACErEQUESTTYPEENUM } from "./enum";
+// 请把 "INTERFACErEQUESTTYPEENUM.即时更新" 改成 INTERFACErEQUESTTYPEENUM.即时更新  把引号去掉 【定时更新同理  】
+export const Config = {"维迈科企业数字画像":{"type":"INTERFACErEQUESTTYPEENUM.即时更新","time":3600000,"url":"url地址","reqType":"post","header":{},"body":{}},"绩效管理驾驶舱":{"type":"INTERFACErEQUESTTYPEENUM.即时更新","time":3600000,"url":"url地址","reqType":"post","header":{},"body":{}},"企业服务":{"type":"INTERFACErEQUESTTYPEENUM.即时更新","time":3600000,"url":"url地址","reqType":"post","header":{},"body":{}},"智慧运营":{"type":"INTERFACErEQUESTTYPEENUM.即时更新","time":3600000,"url":"url地址","reqType":"post","header":{},"body":{}}};
+
+    
\ No newline at end of file

src/config/serverConfig.ts

+const path = require('path');
+import * as fs from "fs";
+import { BizError } from "../util/bizError";
+import { analysisXml } from "../util/myXML";
+
+export let port = Number(process.env.PORT) || Number(process.argv[3]) || 7576; //如果xml里面没有配置 就会使用到这里的端口
+
+const ConfigName = "serverConfig.xml";
+export async function initConfig() {
+    try {
+        let buff = fs.readFileSync(path.join(__dirname.substring(0,__dirname.indexOf("out")), ConfigName));
+        let configStr = buff.toString();
+        let configInfo:any = await analysisXml(configStr);
+		if (!configInfo || !configInfo.config) console.log("xml中无配置加载");
+		else {
+				let config = configInfo.config;
+				port = config.port[0] || port;
+				
+		}
+
+    } catch(err) {
+        throw new BizError("服务器配置解析错误 请检查根目录下 serverConfig.xml 文件是否正确");
+    }
+}

src/data/interface/cronJob.ts

+//接口任务 定期更新
+
+import { INTERFACErEQUESTTYPEENUM } from "../../config/enum";
+import { Config } from "../../config/interfaceConfig";
+import { BizError } from "../../util/bizError";
+import { get, post, postForm } from "../../util/request";
+
+//初始化接口数据
+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 = {};
+
+//即时数据初始化
+export 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) {
+    const ThisConfig = Config[name];
+    let data:any;
+    if (ThisConfig.type == INTERFACErEQUESTTYPEENUM.即时更新) {
+        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) {
+            data = reqRes.data;
+        } else {
+           data = realTimeDataQueue[name];
+           console.log(`${name}请求失败, 读取缓存数据`);
+        }
+        
+    } else data = dataQueue[name];
+    
+    return data;
+}
+

src/data/interface/jxgljscData.ts

+
+import { changeListObjectToListByReflect, changeObjectKey, changeObjectToList, designativListKeyAddUnit, getDesignativByReflect } from "../../dataPackage/interfaceAnalysis";
+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+        
+function changeDataProcess(interfaceName, interfaceData, config) {
+    let result = {};
+    for (let dataName in config) {
+        let { type, operationsType, reflect, unitInfo } = config[dataName];
+        let fileData = interfaceData[dataName];
+        let fileType = typeof fileData;
+        let dataIsArray = Array.isArray(fileData);
+
+        if ( (type == "array" && !dataIsArray) || (type == "object" && dataIsArray) || 
+            (type == "object" && fileType != "object") || (type != "array" && fileType != type) ) {
+            throw new BizError(`接口 ${interfaceName}中的${dataName}类型错误应该为 ${type} 现在为${fileType}`);
+        }
+
+        let onceData;
+        switch (operationsType) {
+            case "object_ToList": onceData= changeObjectToList(fileData, reflect); break;
+            case "object_changeKey": onceData = changeObjectKey(fileData, reflect); break;
+            case "list_changeKey": onceData = changeListObjectToListByReflect(fileData, reflect); break;
+        }
+
+        if (unitInfo) onceData = designativListKeyAddUnit(onceData, unitInfo);
+
+        result[dataName] = onceData;
+    }
+
+    return result;
+}
+
+
+function jxgljscInterfaceData() {
+    
+    let jxgljscinterfaceName = "绩效管理驾驶舱";
+    let jxgljscData:any = getInterfaceByInterfaceName(jxgljscinterfaceName);
+            
+    /*
+     zfqymjqkfx = 在孵企业面积情况分析 ;
+     zfqymjbhqszfqymj = 在孵企业面积变化趋势在孵企业面积 ;
+     cyjg = 产业结构 ;
+     ykjqypyqk = 硬科技企业培育情况 ;
+     rcyj = 人才引进 ;
+     fhqhzsj = 孵化器汇总数据 ;
+     xzzfqyqk = 新增在孵企业情况 ;
+     zyjjnl = 资源集聚能力 ;
+     zhnl = 综合能力 ;
+     byqyqk = 毕业企业情况 ;
+     qycxfsddnl = 区域创新辐射带动能力 ;
+     yj = 预警 ;
+     qyyj = 企业预警 ;
+     qydt = 企业动态 ;
+     zfqybhqszfqy = 在孵企业变化趋势在孵企业 ;
+     jrfw = 金融服务 ;
+     zysje = 总营收金额 ;
+     zfqyzys = 在孵企业总营收 ;
+     tzlx = 投资类型 ;
+     zfqyrzqk = 在孵企业融资情况 ;
+     ggjsfw = 公共技术服务 ;
+     qyfhl = 企业孵化率 ;
+     qyfhs = 企业孵化数 ;
+    
+    */
+    let config = {"zfqymjqkfx":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"zfqymjbhqszfqymj":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"cyjg":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"ykjqypyqk":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"rcyj":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"fhqhzsj":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"xzzfqyqk":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"zyjjnl":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"zhnl":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"byqyqk":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"qycxfsddnl":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"yj":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"qyyj":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"qydt":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"zfqybhqszfqy":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"jrfw":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"zysje":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"zfqyzys":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"tzlx":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"zfqyrzqk":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"ggjsfw":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"qyfhl":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"qyfhs":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}}};
+
+    let interfaceData = Object.assign({}, jxgljscData );
+    let changeData = changeDataProcess('绩效管理驾驶舱', interfaceData, config);
+    //todo 剩下的就是将excel定好的数据和interface的数据关联起来了
+
+}

src/data/interface/qyfwData.ts

+
+import { changeListObjectToListByReflect, changeObjectKey, changeObjectToList, designativListKeyAddUnit, getDesignativByReflect } from "../../dataPackage/interfaceAnalysis";
+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+        
+function changeDataProcess(interfaceName, interfaceData, config) {
+    let result = {};
+    for (let dataName in config) {
+        let { type, operationsType, reflect, unitInfo } = config[dataName];
+        let fileData = interfaceData[dataName];
+        let fileType = typeof fileData;
+        let dataIsArray = Array.isArray(fileData);
+
+        if ( (type == "array" && !dataIsArray) || (type == "object" && dataIsArray) || 
+            (type == "object" && fileType != "object") || (type != "array" && fileType != type) ) {
+            throw new BizError(`接口 ${interfaceName}中的${dataName}类型错误应该为 ${type} 现在为${fileType}`);
+        }
+
+        let onceData;
+        switch (operationsType) {
+            case "object_ToList": onceData= changeObjectToList(fileData, reflect); break;
+            case "object_changeKey": onceData = changeObjectKey(fileData, reflect); break;
+            case "list_changeKey": onceData = changeListObjectToListByReflect(fileData, reflect); break;
+        }
+
+        if (unitInfo) onceData = designativListKeyAddUnit(onceData, unitInfo);
+
+        result[dataName] = onceData;
+    }
+
+    return result;
+}
+
+
+function qyfwInterfaceData() {
+    
+    let qyfwinterfaceName = "企业服务";
+    let qyfwData:any = getInterfaceByInterfaceName(qyfwinterfaceName);
+            
+    /*
+     qyjbqk = 企业基本情况 ;
+     bhqsfxzf = 变化趋势分析在孵 ;
+     bhqsfxby = 变化趋势分析毕业 ;
+     rfszfb = 入孵时长分布 ;
+     fhqyhylyzb = 孵化企业行业领域占比 ;
+     qyrcjyrs = 企业人才就业人数 ;
+     qyrccytdfb = 企业人才创业团队分布 ;
+     qyfwhzsj = 企业服务汇总数据 ;
+     qyxqdt = 企业需求动态 ;
+     qyxqdtxx = 企业需求动态详细 ;
+     dt = 地图 ;
+     qybhqk = 企业变化情况 ;
+     bhqsqys = 变化趋势企业数 ;
+     jrfw = 金融服务 ;
+     byrzqyrzqy = 本月融资企业融资企业 ;
+     byrzjerzje = 本月融资金额融资金额 ;
+     zfqyzys = 在孵企业总营收 ;
+     jrfwqy = 金融服务企业 ;
+     zscq = 知识产权 ;
+     zscqbt = 知识产权饼图 ;
+     zscqxq = 知识产权详情 ;
+     qyzzfl = 企业资质分类 ;
+     qyzzfl-xjr = 企业资质分类-小巨人 ;
+     qyzzfl-gxqy = 企业资质分类-高新企业 ;
+     qyzzfl-zjtx = 企业资质分类-专精特新 ;
+     qyzzfl-gqpy = 企业资质分类-高企培育 ;
+    
+    */
+    let config = {"qyjbqk":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"bhqsfxzf":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"bhqsfxby":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"rfszfb":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"fhqyhylyzb":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"qyrcjyrs":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"qyrccytdfb":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"qyfwhzsj":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"qyxqdt":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"qyxqdtxx":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"dt":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"qybhqk":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"bhqsqys":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"jrfw":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"byrzqyrzqy":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"byrzjerzje":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"zfqyzys":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"jrfwqy":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"zscq":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"zscqbt":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"zscqxq":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"qyzzfl":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"qyzzfl-xjr":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"qyzzfl-gxqy":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"qyzzfl-zjtx":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"qyzzfl-gqpy":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}}};
+
+    let interfaceData = Object.assign({}, qyfwData );
+    let changeData = changeDataProcess('企业服务', interfaceData, config);
+    //todo 剩下的就是将excel定好的数据和interface的数据关联起来了
+
+}

src/data/interface/wmkqyszhxData.ts

+
+import { changeListObjectToListByReflect, changeObjectKey, changeObjectToList, designativListKeyAddUnit, getDesignativByReflect } from "../../dataPackage/interfaceAnalysis";
+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+        
+function changeDataProcess(interfaceName, interfaceData, config) {
+    let result = {};
+    for (let dataName in config) {
+        let { type, operationsType, reflect, unitInfo } = config[dataName];
+        let fileData = interfaceData[dataName];
+        let fileType = typeof fileData;
+        let dataIsArray = Array.isArray(fileData);
+
+        if ( (type == "array" && !dataIsArray) || (type == "object" && dataIsArray) || 
+            (type == "object" && fileType != "object") || (type != "array" && fileType != type) ) {
+            throw new BizError(`接口 ${interfaceName}中的${dataName}类型错误应该为 ${type} 现在为${fileType}`);
+        }
+
+        let onceData;
+        switch (operationsType) {
+            case "object_ToList": onceData= changeObjectToList(fileData, reflect); break;
+            case "object_changeKey": onceData = changeObjectKey(fileData, reflect); break;
+            case "list_changeKey": onceData = changeListObjectToListByReflect(fileData, reflect); break;
+        }
+
+        if (unitInfo) onceData = designativListKeyAddUnit(onceData, unitInfo);
+
+        result[dataName] = onceData;
+    }
+
+    return result;
+}
+
+
+function wmkqyszhxInterfaceData() {
+    
+    let wmkqyszhxinterfaceName = "维迈科企业数字画像";
+    let wmkqyszhxData:any = getInterfaceByInterfaceName(wmkqyszhxinterfaceName);
+            
+    /*
+     qyjbqk = 企业基本情况 ;
+     qyjbsj = 企业基本数据 ;
+     qybq = 企业标签 ;
+     zscq = 知识产权 ;
+     qyyghx = 企业员工画像 ;
+     lnrczpqkzprs = 历年人才招聘情况招聘人数 ;
+     qyhzsj = 企业汇总数据 ;
+     xjr = 小巨人 ;
+     gxqy = 高新企业 ;
+     zjtx = 专精特新 ;
+     ysqk = 营收情况 ;
+     ysbhqsyysr = 营收变化趋势营业收入 ;
+     ysbhqsyftr = 营收变化趋势研发投入 ;
+     ysbhqsnsje = 营收变化趋势纳税金额 ;
+     qydt = 企业动态 ;
+     fwxq = 服务需求 ;
+     hdbhqsfxrze = 活动变化趋势分析融资额 ;
+     hdbhqsfxrzsj = 活动变化趋势分析融资事件 ;
+     fwjl-kjfw = 服务记录-空间服务 ;
+     fwjl-gsfw = 服务记录-工商服务 ;
+     fwjl-rzfw = 服务记录-融资服务 ;
+     fwjl = 服务记录 ;
+     yqtz = 园区通知 ;
+     yqtzxq = 园区通知详情 ;
+     yqhd = 园区活动 ;
+     yqhdmx = 园区活动明细 ;
+    
+    */
+    let config = {"qyjbqk":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"qyjbsj":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"qybq":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"zscq":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"qyyghx":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"lnrczpqkzprs":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"qyhzsj":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"xjr":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"gxqy":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"zjtx":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"ysqk":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"ysbhqsyysr":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"ysbhqsyftr":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"ysbhqsnsje":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"qydt":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"fwxq":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"hdbhqsfxrze":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"hdbhqsfxrzsj":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"fwjl-kjfw":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"fwjl-gsfw":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"fwjl-rzfw":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"fwjl":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"yqtz":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"yqtzxq":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"yqhd":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"yqhdmx":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}}};
+
+    let interfaceData = Object.assign({}, wmkqyszhxData );
+    let changeData = changeDataProcess('维迈科企业数字画像', interfaceData, config);
+    //todo 剩下的就是将excel定好的数据和interface的数据关联起来了
+
+}

src/data/interface/zhyyData.ts

+
+import { changeListObjectToListByReflect, changeObjectKey, changeObjectToList, designativListKeyAddUnit, getDesignativByReflect } from "../../dataPackage/interfaceAnalysis";
+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+        
+function changeDataProcess(interfaceName, interfaceData, config) {
+    let result = {};
+    for (let dataName in config) {
+        let { type, operationsType, reflect, unitInfo } = config[dataName];
+        let fileData = interfaceData[dataName];
+        let fileType = typeof fileData;
+        let dataIsArray = Array.isArray(fileData);
+
+        if ( (type == "array" && !dataIsArray) || (type == "object" && dataIsArray) || 
+            (type == "object" && fileType != "object") || (type != "array" && fileType != type) ) {
+            throw new BizError(`接口 ${interfaceName}中的${dataName}类型错误应该为 ${type} 现在为${fileType}`);
+        }
+
+        let onceData;
+        switch (operationsType) {
+            case "object_ToList": onceData= changeObjectToList(fileData, reflect); break;
+            case "object_changeKey": onceData = changeObjectKey(fileData, reflect); break;
+            case "list_changeKey": onceData = changeListObjectToListByReflect(fileData, reflect); break;
+        }
+
+        if (unitInfo) onceData = designativListKeyAddUnit(onceData, unitInfo);
+
+        result[dataName] = onceData;
+    }
+
+    return result;
+}
+
+
+function zhyyInterfaceData() {
+    
+    let zhyyinterfaceName = "智慧运营";
+    let zhyyData:any = getInterfaceByInterfaceName(zhyyinterfaceName);
+            
+    /*
+     yqgk = 园区概况 ;
+     zfqysj = 在孵企业数据 ;
+     rzqybhqsrzqys = 入驻企业变化趋势入驻企业数 ;
+     rzqyhylx = 入驻企业行业类型 ;
+     fhyy = 孵化运营 ;
+     fhmjbhqsfhmj = 孵化面积变化趋势孵化面积 ;
+     zfqybhqszfqy = 在孵企业变化趋势在孵企业 ;
+     byqybhqsbyqy = 毕业企业变化趋势毕业企业 ;
+     rzqybhqsrzqy = 融资企业变化趋势融资企业 ;
+     ryzz = 荣誉资质 ;
+     zhyyhzsj = 智慧运营汇总数据 ;
+     dt = 地图 ;
+     jyfx = 就业分析 ;
+     jdjyrsqsfxjyrs = 季度就业人数趋势分析就业人数 ;
+     cygmfx = 产业规模分析 ;
+     zfqyyszb = 在孵企业营收占比 ;
+     qyfw = 企业服务 ;
+     qyfwlx = 企业服务类型 ;
+     fwzl = 服务质量 ;
+     yysrqsczbt = 运营收入趋势财政补贴 ;
+     yysrqsfwsr = 运营收入趋势服务收入 ;
+     yysrqsfzsr = 运营收入趋势房租收入 ;
+     yysrqstzsr = 运营收入趋势投资收入 ;
+     cyzc = 产业政策 ;
+     cyzcxx = 产业政策详细 ;
+     yqhd = 园区活动 ;
+     yqxw = 园区新闻 ;
+    
+    */
+    let config = {"yqgk":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"zfqysj":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"rzqybhqsrzqys":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"rzqyhylx":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"fhyy":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"fhmjbhqsfhmj":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"zfqybhqszfqy":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"byqybhqsbyqy":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"rzqybhqsrzqy":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"ryzz":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"zhyyhzsj":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"dt":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"jyfx":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"jdjyrsqsfxjyrs":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"cygmfx":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"zfqyyszb":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"qyfw":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"qyfwlx":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"fwzl":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"yysrqsczbt":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"yysrqsfwsr":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"yysrqsfzsr":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"yysrqstzsr":{"type":"array","operationsType":"list_changeKey","reflect":"","unitInfo":{}},"cyzc":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"cyzcxx":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"yqhd":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}},"yqxw":{"type":"object","operationsType":"object_ToList","reflect":"","unitInfo":{}}};
+
+    let interfaceData = Object.assign({}, zhyyData );
+    let changeData = changeDataProcess('智慧运营', interfaceData, config);
+    //todo 剩下的就是将excel定好的数据和interface的数据关联起来了
+
+}

src/data/table/jxgljscData.ts

+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+export function jxgljscTableData() {
+    
+    let blockDataList = onceSheetBecomeOfblockData('yuyiServer.xlsx', '绩效管理驾驶舱');
+
+    let keyValueOrTitleList = ["在孵企业面积情况分析","产业结构","人才引进","孵化器汇总数据","新增在孵企业情况","资源集聚能力","综合能力","毕业企业情况","区域创新辐射带动能力","预警","企业预警","企业动态","金融服务","总营收金额","在孵企业总营收","投资类型","在孵企业融资情况","公共技术服务","企业孵化率","企业孵化数"];//适配 饼图 键值以及需要多个key的
+    let barChartList = ["在孵企业面积变化趋势","在孵企业变化趋势"]; //适配 柱状图 折线图 
+    let stringList = [];
+    let decollatePlanarList =["硬科技企业培育情况"];//适配 表格
+    let titltListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+
+        
+}
\ No newline at end of file

src/data/table/qyfwData.ts

+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+export function qyfwTableData() {
+    
+    let blockDataList = onceSheetBecomeOfblockData('yuyiServer.xlsx', '企业服务');
+
+    let keyValueOrTitleList = ["企业基本情况","入孵时长分布","孵化企业行业领域占比","企业服务汇总数据","企业需求动态","企业变化情况","金融服务","在孵企业总营收","知识产权","知识产权饼图","企业资质分类"];//适配 饼图 键值以及需要多个key的
+    let barChartList = ["变化趋势分析","企业人才","变化趋势","本月融资企业","本月融资金额"]; //适配 柱状图 折线图 
+    let stringList = [];
+    let decollatePlanarList =["企业需求动态详细","地图","金融服务企业","知识产权详情","企业资质分类_小巨人","企业资质分类_高新企业","企业资质分类_专精特新","企业资质分类_高企培育"];//适配 表格
+    let titltListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+
+        
+}
\ No newline at end of file

src/data/table/qyszhxData.ts

+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+export function qyszhxTableData() {
+    
+    let blockDataList = onceSheetBecomeOfblockData('yuyiServer.xlsx', '企业数字画像');
+
+    let keyValueOrTitleList = ["企业基本情况","企业基本数据","企业标签","知识产权","企业员工画像","企业汇总数据","营收情况","服务需求","服务记录","园区通知","园区活动"];//适配 饼图 键值以及需要多个key的
+    let barChartList = ["历年人才招聘情况","营收变化趋势","活动变化趋势分析"]; //适配 柱状图 折线图 
+    let stringList = [];
+    let decollatePlanarList =["小巨人","高新企业","专精特新","企业动态","服务记录_空间服务","服务记录_工商服务","服务记录_融资服务","园区通知详情","园区活动明细"];//适配 表格
+    let titltListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+
+        
+}
\ No newline at end of file

src/data/table/zhyyData.ts

+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+export function zhyyTableData() {
+    
+    let blockDataList = onceSheetBecomeOfblockData('yuyiServer.xlsx', '智慧运营');
+
+    let keyValueOrTitleList = ["园区概况","在孵企业数据","入驻企业行业类型","孵化运营","荣誉资质","智慧运营汇总数据","就业分析","产业规模分析","在孵企业营收占比","企业服务","企业服务类型","产业政策","产业政策详细","园区活动","园区新闻"];//适配 饼图 键值以及需要多个key的
+    let barChartList = ["入驻企业变化趋势","孵化面积变化趋势","在孵企业变化趋势","毕业企业变化趋势","融资企业变化趋势","季度就业人数趋势分析","运营收入趋势"]; //适配 柱状图 折线图 
+    let stringList = [];
+    let decollatePlanarList =["地图","服务质量"];//适配 表格
+    let titltListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+
+        
+}
\ No newline at end of file

src/dataPackage/inBackOut.ts

+//打包完数据之后的处理
+
+/**
+ * recombinationObject 重组对象 在打包完数据后使用 必须是keyvalue之后
+ * @param data [{key:key1, value:value1, unit:unit1 }, {key:key2, value:value2, unit:unit2}]
+ * @param check {"key2":[{key:"key1", name:""}] }
+ * @returns [{key:key1, value:value1, key2:key2, value2:value2}]
+ */
+ export function recombinationObject(data, checkInfo) {
+    let dataMap = {};
+    data.forEach(info => {
+        let { key } = info;
+        dataMap[key] = info;
+    });
+    let removeKeyMap = {};
+
+    for (let checkKey in checkInfo) {
+        let checkList = checkInfo[checkKey];
+        checkList.forEach(item => {
+            let {key, name} = item;
+
+            removeKeyMap[key] = 1;
+            let onceCheck = dataMap[key];
+           
+            dataMap[checkKey][name] = onceCheck.value;
+            dataMap[checkKey][`${name}Unit`] = onceCheck.unit;
+        });
+    }
+
+
+    let dataList = [];
+    data.forEach(info => {
+        let { key } = info;
+        if (removeKeyMap[key]) return;
+        dataList.push(dataMap[key]);
+    });
+
+    return dataList;
+}

src/dataPackage/inFrontOut.ts

+//out 前置逻辑
+import { BizError } from "../util/bizError";
+import { separateDataAndUint } from "./tool";
+
+/**
+ * stringListPackage 打包验证并返回 getStringOut 需要的格式
+ * @param dataList [{key, value},{}]
+ * @param keyName 
+ * @returns ["","",""]
+ */
+export function stringListPackage(dataList, keyName = "value") {
+    let result = [];
+    dataList.forEach(info => {
+        result.push(info[keyName]);
+    });
+    
+    return result;
+}
+
+/**
+ * onceYBarChartPackage  打包验证并返回 getOnceYBarChartOut 需要的格式
+ * @param dataList [{name:"", data:[{key, value}...] }]
+ * @param inYUnit y轴单位
+ * @param inXUnit 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 inLeftYUnit
+ * @param inRightYUnit
+ * @param data [{name:"", data:[{key, value}...] }]
+ * @param rightNameList  ["name", name] 右边y轴的名称
+ * @returns {xUnit:x轴单位, leftYUnit:左边y单位, rightYUnit:右边y单位 dataInfo:{"图表名称":{from:"left", subList:[{key:"数据key", value:"数据值", unit:"单位" }, {key:"数据key", value:"数据值", unit:"单位" } ]}    }   }
+ */
+export function doubleYBarCharPackage(data, rightNameList, inLeftYUnit, inRightYUnit, 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};
+        });
+    }
+
+    let leftYData = [];
+    let rightYData = [];
+    data.forEach(info => {
+        let {name} = info;
+        if (rightNameList.indexOf(name) > -1 ) rightYData.push(info);
+        else leftYData.push(info);
+    });
+
+    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].subList.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, notSeparate?) {
+    let data = [];
+    dataList.forEach(info => {
+        let key = info.key;
+        let value = info.value;
+        checkingError({value, key}, errorEnum.数据key是否为空);
+        let dataNum;
+        let dataUnit;
+        if (notSeparate == "false") {
+            dataNum = value;
+            dataUnit = "";
+        } else {
+            dataNum = separateDataAndUint(value).dataNum;
+            dataUnit = separateDataAndUint(value).dataUnit;
+        }
+        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 = "";
+
+        addInfo.value = value;
+        addInfo.unit = unit;
+        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) {
+        throw new BizError(str);
+    }
+}
+
+function isUndefinedOrNull(paramater) {
+    return paramater == undefined || paramater == null;
+}
\ No newline at end of file

src/dataPackage/interfaceAnalysis.ts

+/**
+ * changeObjectToList  将对象形式的数据转换为keyvalue的数组  对象中的键名称将作为key  传入mapping时 使用对应的change作为key的值
+ * @param data 数据{key1:value1, key2:value2, key3:value3...}
+ * @param reflect 对应关系 [{key:"key1",change:"名称1"},{key:"key2", change:"名称2"},{key:"key3", change:"名称3"}]
+ * @returns [{key:"名称1", value:value1}, {key:"名称2", value:value2}, {key:key3, value:value3}]
+ */
+export function changeObjectToList(data, reflect?) {
+    let keyList = [];
+    if (!reflect || !reflect.length) {
+        for (let key in data) {
+            keyList.push({key, change:key});
+        }
+    }
+
+    let dataList = [];
+    keyList.forEach(info => {
+        let {key, change} = info;
+        let value = data[key];
+        if (value) dataList.push({ key:change, value:`${value}`});
+    });
+
+   return dataList;
+}
+
+
+/**
+ * changeObjectKey  按mapping的对应关系修改 data中的key  如果对应关系中找不到，则会使用原来的key
+ * @param data {key1:value1, key2:value2, key3:value3...}
+ * @param reflect {"key1":"名称1", "key2":"名称2", "key3":"名称3"}
+ * @returns {"名称1":value1, "名称2":value2, "名称3":value3}
+ */
+export function changeObjectKey(data, reflect) {
+    let result = {};
+    for (let key in data) {
+        let changeKey = reflect[key] || key;
+        result[changeKey] = `${data[key]}`;
+    }
+
+    return result;
+}
+
+/**
+ * changeListObjectToListByReflect  将data中的object的key替换成 reflect对应的值
+ * @param data [{key1:value1, key2:value2...}, {key1:value1, key2:value2...}, {key1:value1, key2:value2...}]
+ * @param reflect 映射 不传就不会替换 {"key1":"名称1", "key2":"名称2", "key3":"名称3"}
+ * @returns  [{"名称1":value1, "名称2":value2...}, {"名称1":value1, "名称2":value2...}, {"名称1":value1, "名称2":value2...}]
+ */
+export function changeListObjectToListByReflect(data, reflect?) {
+    let dataList = [];
+    if (!reflect) return dataList;
+
+    data.forEach(item => {
+        let changeInfo = {};
+        for (let key in item) {
+            let newKey = reflect[key] || key;
+            changeInfo[newKey] = `${item[key]}`;
+        }
+        dataList.push(changeInfo);
+    });
+
+    return dataList;
+}
+
+
+
+/**
+ * getDesignativByReflect 获取data中指定的的key
+ * @param data  [{key1:value1, key2:value2, key3:value3...}, {key1:value1, key2:value2, key3:value3...}, {key1:value1, key2:value2, key3:value3...}] 或者 {key1:value1, key2:value2, key3:value3...}
+ * @param reflect List 映射 必须参数 ["key1", "key2"]  为key的名称 
+ * @returns [{key1:value1, key2:value2, ...}, {key1:value1, key2:value2, ...}, {key1:value1, key2:value2, ...}]
+ */
+export function getDesignativByReflect(data, reflect) {
+    if (typeof data != "object") return data;
+    let type = Array.isArray(data) ? "array" : "object";
+
+    if ((type == "array" && !reflect.length) || (type == "object" && !Object.keys(reflect) ) ) return data;
+    let reflectMap = {};
+    reflect.forEach(keyName => {reflectMap[keyName] = 1});
+
+    if (type=="array") {
+        let dataList = [];
+        data.forEach(item => {
+            let once = {};
+            for (let key in item) {
+                if (!reflectMap[key]) continue;
+                once[key] = item[key];
+            }
+            dataList.push(once);
+        });
+
+        return dataList;
+    } else {
+        let dataInfo = {};
+        for(let key in reflectMap) {
+            if (data[key]) dataInfo[key] = data[key];
+        }
+        return dataInfo;
+    }
+}
+
+/**
+ * designativListKeyAddUnit为集合中指定的key添加单位
+ * @param data [{key1:value1, key2:value2, key3:value3...}, {key1:value1, key2:value2, key3:value3...}, {key1:value1, key2:value2, key3:value3...}]
+ * @param reflect {key1:"%", key2:"个"}
+ * @returns [{key1:"value1%", ke2:"value2个", keys:"value3"}]
+ */
+export function designativListKeyAddUnit(data, reflect) {
+    let dataList = [];
+    data.forEach(item => {
+        let onceData = {};
+        for (let key in item) {
+            let unit = reflect[key] || '';
+            onceData[key] = `${item[key]}${unit}`
+        }
+        dataList.push(onceData);
+    });
+    return dataList;
+}
\ No newline at end of file

src/dataPackage/out.ts

+import { separateDataAndUint, unifiedMaxAndMinValueAndStep } from "./tool";
+//数据出口封装 只做封装 少量的数据校验
+
+/**
+ * getStringOut  获取文字列表返回结果
+ * @param title  数据标题
+ * @param data 数据体 格式:["txt...", "str..."]
+ * @returns {title, dataList:[string...]}
+ */
+export function getStringOut(title, data) {
+    let dataList = [];
+    data.forEach( (str) => {
+        dataList.push(str);
+    });
+    return { title, dataList};
+}
+
+/**
+ * getOnceYBarChartOut  获取单y轴柱状图
+ * @param title 数据标题 
+ * @param data  数据体  格式： {xUnit:x轴单位, yUnit:y单位, dataInfo:{"图表名称":[{key:"数据key", value:"数据值", unit:"单位" }, {key:"数据key", value:"数据值", unit:"单位" } ]    }   }
+ * @returns {title:标题, xUnit:x轴单位, yUnit:y轴单位, yMinValue:最小值, yMaxValue:最大值, yStepValue:间隔, 
+ * chartList:[{thisChartTitle:数据名称, total:总数, unit:单位, dataList:[{name:y轴名称, value:值, unit:单位}] } ]}
+ * 入参data里面的dataInfo中的unit可以为空 会读取yUnit 所以入参优先度 yUnit > unit  默认值都是空字符串
+ */
+export function getOnceYBarChartOut(title, data, stepCount?) {
+    let chartList = [];
+    let {xUnit, yUnit, dataInfo} = data;
+
+    let thisYUnit = yUnit ||"";
+
+    let min = new Date().valueOf();
+    let max = 0;
+    for (let dataName in dataInfo) {
+        let onceChartList = dataInfo[dataName];
+
+        let dataList = [];
+        let total = 0;
+
+        onceChartList.forEach(item => {
+            let {key, value, unit} = item;
+            min = Math.min(value, min);
+            max = Math.max(value, max);
+            total += value;
+            dataList.push({name:key, value, unit: unit || thisYUnit});
+        });
+
+        chartList.push({thisChartTitle:dataName, total, unit:thisYUnit, dataList});
+    }
+    
+    let {maxNumber, minNumber, stepNumber} = unifiedMaxAndMinValueAndStep(max, min, stepCount);
+
+    return {title, xUnit, yUnit:thisYUnit, yMinValue:minNumber, yMaxValue:maxNumber, yStepValue:stepNumber, chartList};
+}
+
+/**
+ * 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} = dataInfo[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 data 数据体 格式：{titleList:[], dataList:[{a,b,c},{a,b,c},{a,b,c}] }
+ * @returns {title:数据标题, total:数据总条数, titleList:[表头...], valueList:[[a,b,c,d...],[a,b,c,d...]] }
+ * 解出来的对象的key是需要有顺序的，所以进这里之前要把值a-z排好序，按显示要求排序，
+ */
+export function getTableOut(title, data) {
+    
+    let {titleList, dataList} = data;
+
+    let valueList = [];
+
+    dataList.forEach(info => {
+        let subList = [];
+        for (let key in info) {
+            subList.push(info[key]);
+        } 
+        valueList.push(subList);
+    });
+    return { title, total:dataList.length, titleList, valueList };
+}
+
+
+/**
+ * getKeyValueOut 获取键值的返回结果
+ * @param title 数据标题
+ * @param data 数据体 [{key:"", value:"", unit:""}]
+ * @returns {title:数据标题, dataList:[], total:数据值总数, count:数据总条数 }
+ */
+export function getKeyValueOut(title, data) {
+    let dataList = [];
+
+    let total = 0;
+    data.forEach(info => {
+        let {key, value, unit} = info;
+        let typeChangeValue;
+        if (!isNaN(value)) {
+            typeChangeValue = parseFloat(value); 
+            total+= typeChangeValue;
+        } else typeChangeValue = value;
+        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;
+    
+    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 };
+}
+
+
+/**
+ * getRadarChartOut 获取雷达图
+ * @param title 数据标题
+ * @param data 数据体  [{key, value, max, unit}]
+ * @returns {title:数据标题, dataList:[{name:"指标名称", max:"最大值", value:"当前值", unit:"单位"}]}
+ */
+export function getRadarChartOut(title, data) {
+    let dataList = [];
+    data.forEach(info => {
+        dataList.push({
+            name:info.key,
+            value:info.value, 
+            max:info.max,
+            unit:info.unit
+        });
+    });
+    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  获取撒点图的返回结果
+ * @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/dataPackage/planaryArrayAnalysis.ts

+import { BizError } from "../util/bizError";
+import pyfl from 'pyfl';
+//disintegrate 分解二维数据源数据
+
+
+/**
+ * planarArrForObjectList  解析二维数组
+ * @param planarArr 二维数组 例子:[[title1, title2, title3, title4],[value1, value2, value3, value4],[value5, value6, value7, value8]]
+ * @param titleIndex  标题集合所在第一层数组的下标 
+ * @param titleList 自定义标题列表 不传则会取每个title的中文首字母作为key
+ * @returns {"dataList":[{title1:value1, title2:value2, title3:value3, title4:value4}, {title1:value5, title2:value6, title3:value7, title4:value8}], titleList:[]}
+ */
+export function planarArrForObjectList(planarArr, titleIndex = 0, titleList = []) {
+    let dataTitleList = [];
+    let dataMaxLength = 0;
+    for (let i = titleIndex; i< planarArr.length; i++) {
+        let subList = planarArr[i];
+        if (i == titleIndex) {
+            dataTitleList = subList;
+            continue;
+        }
+        dataMaxLength = Math.max(subList.length, dataMaxLength);
+    }
+
+    let useTitleList = !titleList.length ? changeChineseTitleIntoEnglish(dataTitleList) : titleList;
+    if (dataMaxLength == 2 && !titleList.length) useTitleList = ["key", "value"];
+    
+    if (dataTitleList.length < dataMaxLength ) throw new BizError(`解析时数据异常 数据长度：${dataMaxLength} 大于 标题长度${dataTitleList}`);
+    if (titleList.length && titleList.length < dataMaxLength) throw new BizError(`解析时数据异常 传入标题长度${titleList.length} 数据最大长度${dataMaxLength}`);
+
+    let dataList = [];
+    for (let i = (titleIndex + 1); i< planarArr.length; i++) {
+        let subList = planarArr[i];
+        let addInfo:any = {};
+        subList.forEach((item, index) => {
+            let key = useTitleList[index];
+            let value = item;
+            addInfo[key] = value;
+        });
+        dataList.push(addInfo);
+    }
+
+    return {dataList, titleList:useTitleList };
+}
+
+function changeChineseTitleIntoEnglish(titles) {
+    let result = [];
+    titles.forEach(chineseStr => {
+        result.push(pyfl(chineseStr).toLowerCase());
+    });
+    return result;
+}
+
+/**
+ * planarArrDeconstruct 解构二维数组 
+ * 第一列是名称 
+ * @param planarArr 二维数组 例：[[name, 1月, 2月, 3月],[数据1, 1月数据, 2月数据,3月数据 ],[数据2, 1月数据, 2月数据,3月数据]]
+ * @param titleIndex 标题集合所在第一层数组的下标
+ * @returns [{"name":"", data:[{key:"1月", value:"1月数据"}, {key:"2月", value:"2月数据"} ]}];
+ */
+export function planarArrDeconstruct(planarArr, titleIndex = 0) {
+    let dataInfo = []
+    let titleList = [];
+    for (let i = titleIndex; i < planarArr.length; i++) {
+        let subList = planarArr[i];
+        if (titleIndex == i){
+            titleList = subList;
+        } else {
+            let thisDataName = "";
+            let thisDataList = [];
+            subList.forEach((item, index) => {
+                if (!index) {
+                    thisDataName = item;
+                    return;
+                }
+                let key = titleList[index];
+                thisDataList.push({key, value:item});
+            });
+            dataInfo.push({name:thisDataName, data:thisDataList});
+        }
+    }
+
+    return dataInfo;
+}
+
+/**
+ * planarArrDecollateForIndex 拆解二维数组
+ * @param planarArr 二维数组
+ * @param decollateIndex 拆解开始的下标
+ * @returns {headerList:decollateIndex下标之前的集合(包括decollateIndex), bodyList:decollateIndex下标之后的集合(不包括decollateIndex)}
+ */
+export function planarArrDecollateForIndex(planarArr, decollateIndex = 0) {
+    let headerList = planarArr.slice(decollateIndex, decollateIndex + 1);
+    let bodyList = planarArr.slice(decollateIndex + 1, planarArr.length);
+    return {headerList, bodyList};    
+}
+
+

src/dataPackage/public.ts

+//excel 和 接口都可以使用的格式化数据的方法
+
+/**
+ * objBecomeOfList  对象变成数组  value不限制类型
+ * @param obj 对象 {"key1":"value1", "key2":"value2"}
+ * @param keyName 指定key的名称 默认 name
+ * @param valueName 指定value的名称  默认 data
+ * @returns [{name:"key1", "data":"value1"}, ...]
+ */
+export function objBecomeOfList(obj, keyName="name", valueName="data") {
+    let result = [];
+    for (let key in obj) {
+        let once:any = {};
+        once[keyName] = key;
+        once[valueName] = obj[key];
+        result.push(once);
+    }
+    return result;
+}
+
+/**
+ * objChangeKey  obj改变key
+ * @param obj {"key1":"value1", "key2":"value2"}
+ * @param checkKeyInfo {"key1":"eKey1", "key2":"eKey2"}
+ * @returns  
+ */
+export function objChangeKey(obj, checkKeyInfo) {
+    let result = {};
+    for (let key in obj) {
+        let newKey = checkKeyInfo[key] || key;
+        result[newKey] = obj[key];
+    }
+    return result;
+}
+
+
+/**
+ * objListChangeKey  objList 改变key
+ * @param objList 
+ * @param checkKeyInfo 
+ * @returns 
+ */
+export function objListChangeKey(objList, checkKeyInfo) {
+    return 
+}
\ No newline at end of file

src/dataPackage/tool.ts

+/**
+ * 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};
+}
+
+/**
+ * unifiedMaxAndMinValueAndStep 求最大最小值以及间隙 
+ * @param max 最大
+ * @param min 最小
+ * @param count 分多少份 默认5
+ * @returns {maxNumber:向上留值最大, minNumber:向下留值最小, stepNumber:间隔};
+ */
+ export function unifiedMaxAndMinValueAndStep(max, min, count=5) {
+    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) / count);
+
+    return {maxNumber, minNumber, stepNumber};
+}
+

src/main.ts

+
+import { initInterfaceData } from "./data/interface/cronJob";
+import { httpServer } from "./net/http_server";
+import { initConfig, port } from "./config/serverConfig";
+
+async function lanuch() {
+    test();
+    await initConfig();
+    // initInterfaceData();
+    httpServer.createServer( port );
+
+    console.log('This indicates that the server is started successfully.');
+}
+
+function test() {
+}
+
+lanuch();

src/middleware/checkToken.ts

+
+export async function checkToken(req, res, next) { 
+    next();
+}
\ 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/middleware/sign.ts

+import { BizError } from "../util/bizError";
+const LRU = require("lru-cache")
+  , cacheOptions = { max: 500000
+              , maxAge: 1000 * 60 * 10 }
+  , cache = LRU(cacheOptions);
+
+export async function checkSign(req, res, next) {
+    let signKey = "12345678asd!@#%DFFGa";
+    let userId = req.headers.userid;
+    let playerId = req.headers.playerid;
+    let token = req.headers.token;
+    let timeStamp = req.headers.timestamp;
+    let platform = req.headers.platform;
+
+    if (req.path != '/api/system/servertime' && req.path.indexOf('admin') < 0 && req.headers.sign != 'xxakdfwosaddf!@3sadfhDAse') {
+        let now = Date.now();
+        if (Math.abs(now - timeStamp) > 120000) {
+            console.log(req.path, new Date(now), "timeStamp", timeStamp);
+            return next(new BizError('timeStamp error time difference error'))
+        }
+        let sign = getSign([signKey, userId, playerId, token, timeStamp, platform, req.path, signKey]);
+        let cacheSign = cache.get(sign);
+        if (cacheSign) {
+            if (cacheSign > 5) return next(new BizError("sign error repetitive sign"));
+            else {
+                cacheSign++;
+                cache.set(sign,cacheSign);
+            }
+        }
+        else {
+            cache.set(sign,1);
+        }
+        
+        if (sign != req.headers.sign) {
+            console.log(req.path, JSON.stringify(req.headers));
+            next(new BizError("sign error"))
+        }
+    }
+
+    next();
+}
+
+function getSign(...params) {
+    let s = "";
+    for (let i = 0; i < params.length; i++) {
+        if (!params[i]) continue;
+        s += params[i];
+    }
+    return new m().hex_md5(s);
+}
+
+
+export class m {
+    
+        public constructor() {
+    
+        }
+        private hexcase = 0;   /* hex output format. 0 - lowercase; 1 - uppercase        */
+        private b64pad = "";  /* base-64 pad character. "=" for strict RFC compliance   */
+    
+        /*
+        * These are the privates you'll usually want to call
+        * They take string arguments and return either hex or base-64 encoded strings
+        */
+        public hex_md5(s) { return this.rstr2hex(this.rstr_md5(this.str2rstr_utf8(s))); }//这个函数就行了，
+        public b64_md5(s) { return this.rstr2b64(this.rstr_md5(this.str2rstr_utf8(s))); }
+        public any_md5(s,e) { return this.rstr2any(this.rstr_md5(this.str2rstr_utf8(s)),e); }
+        public hex_hmac_md5(k,d)
+        { return this.rstr2hex(this.rstr_hmac_md5(this.str2rstr_utf8(k),this.str2rstr_utf8(d))); }
+        private b64_hmac_md5(k,d)
+        { return this.rstr2b64(this.rstr_hmac_md5(this.str2rstr_utf8(k),this.str2rstr_utf8(d))); }
+        private any_hmac_md5(k,d,e)
+        { return this.rstr2any(this.rstr_hmac_md5(this.str2rstr_utf8(k),this.str2rstr_utf8(d)),e); }
+    
+        /*
+        * Perform a simple self-test to see if the VM is working
+        */
+        public md5_vm_test() {
+            return this.hex_md5("abc").toLowerCase() == "900150983cd24fb0d6963f7d28e17f72";
+        }
+    
+        /*
+        * Calculate the MD5 of a raw string
+        */
+       public rstr_md5(s) {  
+             
+            return this.binl2rstr(this.binl_md5(this.rstr2binl(s),s.length * 8));
+        }
+    
+        /*
+        * Calculate the HMAC-MD5, of a key and some data (raw strings)
+        */
+        public rstr_hmac_md5(key,data) {
+            var bkey = this.rstr2binl(key);
+            if(bkey.length > 16) bkey = this.binl_md5(bkey,key.length * 8);
+    
+            var ipad = Array(16),opad = Array(16);
+            for(var i = 0;i < 16;i++) {
+                ipad[i] = bkey[i] ^ 0x36363636;
+                opad[i] = bkey[i] ^ 0x5C5C5C5C;
+            }
+            
+            var hash = this.binl_md5(ipad.concat(this.rstr2binl(data)),512 + data.length * 8);
+            return this.binl2rstr(this.binl_md5(opad.concat(hash),512 + 128));
+        }
+    
+        /*
+        * Convert a raw string to a hex string
+        */
+        public rstr2hex(input) {
+            try { this.hexcase } catch(e) { this.hexcase = 0; }
+            var hex_tab = this.hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
+            var output = "";
+            var x;
+            for(var i = 0;i < input.length;i++) {
+                x = input.charCodeAt(i);
+                output += hex_tab.charAt((x >>> 4) & 0x0F)
+                    + hex_tab.charAt(x & 0x0F);
+            }
+            return output;
+        }
+    
+        /*
+        * Convert a raw string to a base-64 string
+        */
+        public rstr2b64(input) {
+            try { this.b64pad } catch(e) { this.b64pad = ''; }
+            var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+            var output = "";
+            var len = input.length;
+            for(var i = 0;i < len;i += 3) {
+                var triplet = (input.charCodeAt(i) << 16)
+                    | (i + 1 < len ? input.charCodeAt(i + 1) << 8 : 0)
+                    | (i + 2 < len ? input.charCodeAt(i + 2) : 0);
+                for(var j = 0;j < 4;j++) {
+                    if(i * 8 + j * 6 > input.length * 8) output += this.b64pad;
+                    else output += tab.charAt((triplet >>> 6 * (3 - j)) & 0x3F);
+                }
+            }
+            return output;
+        }
+    
+        /*
+        * Convert a raw string to an arbitrary string encoding
+        */
+        public rstr2any(input,encoding) {
+            var divisor = encoding.length;
+            var i,j,q,x,quotient;
+    
+            /* Convert to an array of 16-bit big-endian values, forming the dividend */
+            var dividend = Array(Math.ceil(input.length / 2));
+            for(i = 0;i < dividend.length;i++) {
+                dividend[i] = (input.charCodeAt(i * 2) << 8) | input.charCodeAt(i * 2 + 1);
+            }
+    
+            /*
+            * Repeatedly perform a long division. The binary array forms the dividend,
+            * the length of the encoding is the divisor. Once computed, the quotient
+            * forms the dividend for the next step. All remainders are stored for later
+            * use.
+            */
+            var full_length = Math.ceil(input.length * 8 /
+                (Math.log(encoding.length) / Math.log(2)));
+            var remainders = Array(full_length);
+            for(j = 0;j < full_length;j++) {
+                quotient = Array();
+                x = 0;
+                for(i = 0;i < dividend.length;i++) {
+                    x = (x << 16) + dividend[i];
+                    q = Math.floor(x / divisor);
+                    x -= q * divisor;
+                    if(quotient.length > 0 || q > 0)
+                        quotient[quotient.length] = q;
+                }
+                remainders[j] = x;
+                dividend = quotient;
+            }
+    
+            /* Convert the remainders to the output string */
+            var output = "";
+            for(i = remainders.length - 1;i >= 0;i--)
+                output += encoding.charAt(remainders[i]);
+    
+            return output;
+        }
+    
+        /*
+        * Encode a string as utf-8.
+        * For efficiency, this assumes the input is valid utf-16.
+        */
+        public str2rstr_utf8(input) {
+            var output = "";
+            var i = -1;
+            var x,y;
+    
+            while(++i < input.length) {
+                /* Decode utf-16 surrogate pairs */
+                x = input.charCodeAt(i);
+                y = i + 1 < input.length ? input.charCodeAt(i + 1) : 0;
+                if(0xD800 <= x && x <= 0xDBFF && 0xDC00 <= y && y <= 0xDFFF) {
+                    x = 0x10000 + ((x & 0x03FF) << 10) + (y & 0x03FF);
+                    i++;
+                }
+    
+                /* Encode output as utf-8 */
+                if(x <= 0x7F)
+                    output += String.fromCharCode(x);
+                else if(x <= 0x7FF)
+                    output += String.fromCharCode(0xC0 | ((x >>> 6) & 0x1F),
+                        0x80 | (x & 0x3F));
+                else if(x <= 0xFFFF)
+                    output += String.fromCharCode(0xE0 | ((x >>> 12) & 0x0F),
+                        0x80 | ((x >>> 6) & 0x3F),
+                        0x80 | (x & 0x3F));
+                else if(x <= 0x1FFFFF)
+                    output += String.fromCharCode(0xF0 | ((x >>> 18) & 0x07),
+                        0x80 | ((x >>> 12) & 0x3F),
+                        0x80 | ((x >>> 6) & 0x3F),
+                        0x80 | (x & 0x3F));
+            }
+            return output;
+        }
+    
+        /*
+        * Encode a string as utf-16
+        */
+        public str2rstr_utf16le(input) {
+            var output = "";
+            for(var i = 0;i < input.length;i++)
+                output += String.fromCharCode(input.charCodeAt(i) & 0xFF,
+                    (input.charCodeAt(i) >>> 8) & 0xFF);
+            return output;
+        }
+    
+        public str2rstr_utf16be(input) {
+            var output = "";
+            for(var i = 0;i < input.length;i++)
+                output += String.fromCharCode((input.charCodeAt(i) >>> 8) & 0xFF,
+                    input.charCodeAt(i) & 0xFF);
+            return output;
+        }
+    
+        /*
+        * Convert a raw string to an array of little-endian words
+        * Characters >255 have their high-byte silently ignored.
+        */
+        public rstr2binl(input) {
+            var output = Array(input.length >> 2);
+            for(var i = 0;i < output.length;i++)
+                output[i] = 0;
+            for(var i = 0;i < input.length * 8;i += 8)
+                output[i >> 5] |= (input.charCodeAt(i / 8) & 0xFF) << (i % 32);
+            return output;
+        }
+    
+        /*
+        * Convert an array of little-endian words to a string
+        */
+        public binl2rstr(input) {
+            var output = "";
+            for(var i = 0;i < input.length * 32;i += 8)
+                output += String.fromCharCode((input[i >> 5] >>> (i % 32)) & 0xFF);
+            return output;
+        }
+    
+        /*
+        * Calculate the MD5 of an array of little-endian words, and a bit length.
+        */
+        public binl_md5(x,len) {
+            /* append padding */
+            x[len >> 5] |= 0x80 << ((len) % 32);
+            x[(((len + 64) >>> 9) << 4) + 14] = len;
+    
+            var a = 1732584193;
+            var b = -271733879;
+            var c = -1732584194;
+            var d = 271733878;
+    
+            for(var i = 0;i < x.length;i += 16) {
+                var olda = a;
+                var oldb = b;
+                var oldc = c;
+                var oldd = d;
+    
+                a = this.md5_ff(a,b,c,d,x[i + 0],7,-680876936);
+                d = this.md5_ff(d,a,b,c,x[i + 1],12,-389564586);
+                c = this.md5_ff(c,d,a,b,x[i + 2],17,606105819);
+                b = this.md5_ff(b,c,d,a,x[i + 3],22,-1044525330);
+                a = this.md5_ff(a,b,c,d,x[i + 4],7,-176418897);
+                d = this.md5_ff(d,a,b,c,x[i + 5],12,1200080426);
+                c = this.md5_ff(c,d,a,b,x[i + 6],17,-1473231341);
+                b = this.md5_ff(b,c,d,a,x[i + 7],22,-45705983);
+                a = this.md5_ff(a,b,c,d,x[i + 8],7,1770035416);
+                d = this.md5_ff(d,a,b,c,x[i + 9],12,-1958414417);
+                c = this.md5_ff(c,d,a,b,x[i + 10],17,-42063);
+                b = this.md5_ff(b,c,d,a,x[i + 11],22,-1990404162);
+                a = this.md5_ff(a,b,c,d,x[i + 12],7,1804603682);
+                d = this.md5_ff(d,a,b,c,x[i + 13],12,-40341101);
+                c = this.md5_ff(c,d,a,b,x[i + 14],17,-1502002290);
+                b = this.md5_ff(b,c,d,a,x[i + 15],22,1236535329);
+    
+                a = this.md5_gg(a,b,c,d,x[i + 1],5,-165796510);
+                d = this.md5_gg(d,a,b,c,x[i + 6],9,-1069501632);
+                c = this.md5_gg(c,d,a,b,x[i + 11],14,643717713);
+                b = this.md5_gg(b,c,d,a,x[i + 0],20,-373897302);
+                a = this.md5_gg(a,b,c,d,x[i + 5],5,-701558691);
+                d = this.md5_gg(d,a,b,c,x[i + 10],9,38016083);
+                c = this.md5_gg(c,d,a,b,x[i + 15],14,-660478335);
+                b = this.md5_gg(b,c,d,a,x[i + 4],20,-405537848);
+                a = this.md5_gg(a,b,c,d,x[i + 9],5,568446438);
+                d = this.md5_gg(d,a,b,c,x[i + 14],9,-1019803690);
+                c = this.md5_gg(c,d,a,b,x[i + 3],14,-187363961);
+                b = this.md5_gg(b,c,d,a,x[i + 8],20,1163531501);
+                a = this.md5_gg(a,b,c,d,x[i + 13],5,-1444681467);
+                d = this.md5_gg(d,a,b,c,x[i + 2],9,-51403784);
+                c = this.md5_gg(c,d,a,b,x[i + 7],14,1735328473);
+                b = this.md5_gg(b,c,d,a,x[i + 12],20,-1926607734);
+    
+                a = this.md5_hh(a,b,c,d,x[i + 5],4,-378558);
+                d = this.md5_hh(d,a,b,c,x[i + 8],11,-2022574463);
+                c = this.md5_hh(c,d,a,b,x[i + 11],16,1839030562);
+                b = this.md5_hh(b,c,d,a,x[i + 14],23,-35309556);
+                a = this.md5_hh(a,b,c,d,x[i + 1],4,-1530992060);
+                d = this.md5_hh(d,a,b,c,x[i + 4],11,1272893353);
+                c = this.md5_hh(c,d,a,b,x[i + 7],16,-155497632);
+                b = this.md5_hh(b,c,d,a,x[i + 10],23,-1094730640);
+                a = this.md5_hh(a,b,c,d,x[i + 13],4,681279174);
+                d = this.md5_hh(d,a,b,c,x[i + 0],11,-358537222);
+                c = this.md5_hh(c,d,a,b,x[i + 3],16,-722521979);
+                b = this.md5_hh(b,c,d,a,x[i + 6],23,76029189);
+                a = this.md5_hh(a,b,c,d,x[i + 9],4,-640364487);
+                d = this.md5_hh(d,a,b,c,x[i + 12],11,-421815835);
+                c = this.md5_hh(c,d,a,b,x[i + 15],16,530742520);
+                b = this.md5_hh(b,c,d,a,x[i + 2],23,-995338651);
+    
+                a = this.md5_ii(a,b,c,d,x[i + 0],6,-198630844);
+                d = this.md5_ii(d,a,b,c,x[i + 7],10,1126891415);
+                c = this.md5_ii(c,d,a,b,x[i + 14],15,-1416354905);
+                b = this.md5_ii(b,c,d,a,x[i + 5],21,-57434055);
+                a = this.md5_ii(a,b,c,d,x[i + 12],6,1700485571);
+                d = this.md5_ii(d,a,b,c,x[i + 3],10,-1894986606);
+                c = this.md5_ii(c,d,a,b,x[i + 10],15,-1051523);
+                b = this.md5_ii(b,c,d,a,x[i + 1],21,-2054922799);
+                a = this.md5_ii(a,b,c,d,x[i + 8],6,1873313359);
+                d = this.md5_ii(d,a,b,c,x[i + 15],10,-30611744);
+                c = this.md5_ii(c,d,a,b,x[i + 6],15,-1560198380);
+                b = this.md5_ii(b,c,d,a,x[i + 13],21,1309151649);
+                a = this.md5_ii(a,b,c,d,x[i + 4],6,-145523070);
+                d = this.md5_ii(d,a,b,c,x[i + 11],10,-1120210379);
+                c = this.md5_ii(c,d,a,b,x[i + 2],15,718787259);
+                b = this.md5_ii(b,c,d,a,x[i + 9],21,-343485551);
+    
+                a = this.safe_add(a,olda);
+                b = this.safe_add(b,oldb);
+                c = this.safe_add(c,oldc);
+                d = this.safe_add(d,oldd);
+            }
+            return [a,b,c,d];
+        }
+    
+        /*
+        * These privates implement the four basic operations the algorithm uses.
+        */
+        public md5_cmn(q,a,b,x,s,t) {
+            return this.safe_add(this.bit_rol(this.safe_add(this.safe_add(a,q),this.safe_add(x,t)),s),b);
+        }
+        public md5_ff(a,b,c,d,x,s,t) {
+            return this.md5_cmn((b & c) | ((~b) & d),a,b,x,s,t);
+        }
+        public md5_gg(a,b,c,d,x,s,t) {
+            return this.md5_cmn((b & d) | (c & (~d)),a,b,x,s,t);
+        }
+        public md5_hh(a,b,c,d,x,s,t) {
+            return this.md5_cmn(b ^ c ^ d,a,b,x,s,t);
+        }
+        public md5_ii(a,b,c,d,x,s,t) {
+            return this.md5_cmn(c ^ (b | (~d)),a,b,x,s,t);
+        }
+    
+        /*
+        * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+        * to work around bugs in some JS interpreters.
+        */
+        public safe_add(x,y) {
+            var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+            var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+            return (msw << 16) | (lsw & 0xFFFF);
+        }
+    
+        /*
+        * Bitwise rotate a 32-bit number to the left.
+        */
+        public bit_rol(num,cnt) {
+            return (num << cnt) | (num >>> (32 - cnt));
+        }
+}

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 * as fallback from 'express-history-api-fallback';
+import * as path from "path";
+
+
+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('public') );
+
+    httpServer.use(bodyParser.json({limit:"10kb"}));
+    httpServer.use(compression())
+    routers.setRouter(httpServer);
+
+    const root = path.join(__dirname, "../../public/")
+    httpServer.use(express.static(root))
+    httpServer.use(fallback('index.html', { root }))
+    console.log('web listen on port:'+port);
+    
+    
+    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 wmkqyszhxBiz from '../biz/qyszhx';
+        
+import * as jxgljscBiz from '../biz/jxgljsc';
+        
+import * as qyfwBiz from '../biz/qyfw';
+        
+import * as zhyyBiz from '../biz/zhyy';
+        
+export function setRouter(httpServer){
+
+    //======post
+    
+    httpServer.post('/qyszhx', asyncHandler(wmkqyszhxBiz.getData));
+        
+    httpServer.post('/jxgljsc', asyncHandler(jxgljscBiz.getData));
+        
+    httpServer.post('/qyfw', asyncHandler(qyfwBiz.getData));
+        
+    httpServer.post('/zhyy', asyncHandler(zhyyBiz.getData));
+        
+            
+    //======get
+    
+    httpServer.get('/qyszhx', asyncHandler(wmkqyszhxBiz.getData));
+        
+    httpServer.get('/jxgljsc', asyncHandler(jxgljscBiz.getData));
+        
+    httpServer.get('/qyfw', asyncHandler(qyfwBiz.getData));
+        
+    httpServer.get('/zhyy', asyncHandler(zhyyBiz.getData));
+        
+}
+    
\ No newline at end of file

src/util/analysisExcel.ts

+const xlsx = require('node-xlsx');
+const path = require('path');
+
+/**
+ *   onceSheetBecomeOfblockData 将excel文件的指定sheet解析成数据块数据
+ * @param fileName 文件名称
+ * @param sheetName 表名称
+ * @returns [ {blockData:数据块(二维数组), blockTitle:"数据标题"}]
+ */
+export function onceSheetBecomeOfblockData(fileName, sheetName) {
+    let {sheetMap} = getExcel( path.join(__dirname.substring(0,__dirname.indexOf("out")), "res", fileName ));
+    let thisBlockData = getBlockData(sheetMap[sheetName]);
+    return thisBlockData;
+}
+
+/**
+ * excelBecomeOfBlockData 将excel所有的sheet解析成数据块
+ * @param fileName 文件名称
+ * @returns {"sheetName1":[ {blockData:数据块(二维数组), blockTitle:"数据标题"}], ...}
+ */
+export function excelBecomeOfBlockData(fileName) {
+    let {sheetMap} = getExcel( path.join(__dirname.substring(0,__dirname.indexOf("out")), "res", fileName ));
+    let result = {};
+    for (let sheetName in sheetMap) {
+        result[sheetName] = getBlockData(sheetMap[sheetName]);
+    }
+    return result;
+}
+
+/**
+ *  planaryArrayBecomeOfBlockData  将符合excel规则的sheet二维数组转为 数据块
+ * @param dataList excel解出来的数据
+ * @returns thisBlockData 返回数据块集合 格式：blockList = [ {blockData:数据块(二维数组), blockTitle:"数据标题"}]
+ */
+export function planaryArrayBecomeOfBlockData(planaryArray) {
+    return getBlockData(planaryArray);;
+}
+
+
+//===
+
+/**
+ * getBlockData 数据分块 
+ * @param dataList  解析出来的excel二维数组
+ * @returns 返回数据块集合 格式：blockList = [ {blockData:数据块(二维数组), blockTitle:"数据标题"}]
+ */
+function getBlockData(dataList) {
+    let blockList = [];
+    for (let i = 0; i < 999; i++) {
+        let {blockData, blockTitle, notItem, delDataList} = checkBlock(dataList);
+        if (notItem) break;
+        dataList = delDataList;
+        if (blockTitle) blockList.push({blockData, blockTitle});
+    }
+    return blockList;
+}
+
+function getListFristNotNullItemIndex(list) { //获取起始坐标
+    if (!list.length) return null;
+    for (let i = 0; i < list.length; i++) {
+        if (list[i]) return i;
+    }
+}
+
+
+function getListFirstNullItemIndex(startX, list) { //获取第一个为空的坐标
+    if (!list.length) return null;
+    let checkItem = false;
+    let firstItemIndex = 0;
+    for (let i = startX; i <= list.length; i++) {
+        let item = list[i];
+        if (!checkItem && item) checkItem = true;
+        
+        if (checkItem && !item) {
+            firstItemIndex = i;
+            break;
+        }
+    }
+    return firstItemIndex;
+}
+function listRegionIsNull(list, startX, endX) { //指定区间内数据是否未空
+    let isNull = true;
+    if ( !list.length ) return isNull;
+
+    for (let i = startX; i < endX; i++) {
+        let item = list[i];
+        if (item) {
+            isNull = false;
+            break;
+        }
+    }
+    return isNull;
+}
+
+function thisListNotItem(list) {
+    for (let i = 0; i < list.length; i++) {
+        if (list[i]) return false;
+    }
+    return true
+}
+
+function checkBlock(dataList) {
+    //纵向有效起始点
+    let startY = 0;
+    let startX = 0;
+    let isNotBlockTitle = false; //没有块标题
+    let isLook = false;
+    let endX = 0;//x轴最长结束下标 【包括下标】
+    
+
+    let blockTitle = ''; //标题块名称
+
+    let notItem = true;
+
+    for (let i = 0; i < dataList.length; i++) {
+        let childList = dataList[i] || [];
+
+        if (!thisListNotItem(childList)) {
+            
+            if ( !isLook ) {
+                let thisRoowStartX = getListFristNotNullItemIndex(childList);
+                let thisRoowLastItem = childList[thisRoowStartX + 1];
+                let LastList = dataList[i+1] || [];
+                // let lastRoowStartX = getListFristNotNullItemIndex(LastList);
+                let lastRoowHaveItem = LastList[thisRoowStartX];
+                if ( thisRoowLastItem || (LastList.length && lastRoowHaveItem)  ) {
+                    
+                    if (lastRoowHaveItem && thisRoowLastItem ) {
+                        isNotBlockTitle = true; //不存在标题块
+                        blockTitle = `${thisRoowStartX}_${i}`;
+                        startY = i;
+                        startX = thisRoowStartX;
+                    }
+                    else {
+                        blockTitle = dataList[i][thisRoowStartX];
+                        dataList[i][thisRoowStartX] = null;
+
+                        if ( thisRoowLastItem ) { // 同行存在元素 标题在y轴上
+                            startY = i;
+                            startX = thisRoowStartX + 1;
+                        } else {  // 同行存在元素 标题在x轴上
+                            startY = i + 1;
+                            startX = thisRoowStartX;
+                        }
+                    }
+                    
+                    isLook = true;
+                } else { //只有标题 无内容
+                    console.log(dataList[i][thisRoowStartX]);
+                    dataList[i][thisRoowStartX] = null;
+                }
+                
+            } else {
+                //测量最大连续长度
+                let firstNullX = getListFirstNullItemIndex(startX, childList);
+                if (firstNullX) endX = Math.max(endX, firstNullX-1);
+                break;
+            }
+            notItem = false;
+        }
+    }
+    let endY = 0;//y轴连续下标 【包括下标】
+
+    let yInfoStart = false;
+    let yInfoEnd = false;
+
+    for (let y = startY; y < dataList.length; y++) {
+        //纵向找连续性
+        let thisRoow = dataList[y];
+        let regionIsNull = listRegionIsNull(thisRoow, startX, endX);
+        if (!regionIsNull) {
+            endY = y;
+            if (!yInfoStart) yInfoStart = true;
+        }
+        if (yInfoStart && regionIsNull) yInfoEnd = true;
+        if (yInfoEnd) break;
+    }
+    
+    let blockData = [];
+    for (let y = startY; y <= endY; y++) {
+        let onceList = [];
+        for (let x = startX; x <= endX; x++) {
+            onceList.push(dataList[y][x]);
+            dataList[y][x] = null;
+        }
+        blockData.push(onceList);
+    }
+
+    return {blockData, blockTitle, delDataList:dataList,notItem};
+}
+
+
+
+//获取单个excel文件的数据
+function getExcel(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}  
+}
\ No newline at end of file

src/util/bizError.ts

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

src/util/myXML.ts

+var xml2js = require("xml2js");
+
+
+/**
+ * 
+ * @param str 需要解析的xml文本
+ * @returns 解析好的对象
+ */
+export function analysisXml(str) {
+    return new Promise( (resolve, reject) => {
+        xml2js.parseString(str, (err, result) => {
+            if (err) return reject(err);
+            return resolve(result);
+        });
+    });
+   
+}
\ 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?, 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, body) {
+           const success = !err && res && res == 200;
+           let message = err || res.statusCode || "";
+           resolve({success, message, 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(err, res, body) {
+            const success = !err && res && res == 200;
+            let message = err || res.statusCode || "";
+            resolve({success, message, body});
+        });
+    })
+}
+
+export 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, body) {
+            const success = !err && res && res == 200;
+            let message = err || res.statusCode || "";
+            resolve({success, message, body});
+        });
+    })
+}

src/util/tools.ts

+
+//对象判空
+export function objectKeyIsNull(obj, ...keyNames) {
+    let isNull = false;
+    for (let i = 0; i < keyNames.length; i++) {
+        let keyStr = keyNames[i];
+        let moreKeyList = keyStr.split(".");
+        let lastObj;
+        for (let j = 0; j < moreKeyList.length; j++) {
+            lastObj = obj[moreKeyList[j]];
+            if (!lastObj) {
+                isNull = true;
+                break;
+            }
+        }
+        if (isNull) break;
+    }
+    return isNull;
+}
+

tsconfig.json

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