Skip to content

Y
yuyiViewServer
Commit 0917a6f1 by lixinming
Options

no message

parents
Showing with 2111 additions and 0 deletions
.gitignore 0 → 100644
.idea
.vscode
/out
/node_modules
/test
*test*
*.log
\ No newline at end of file
package-lock.json 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
package.json 0 → 100644
{
"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 0 → 100644
<config>
<port>40026</port>
</config>
\ No newline at end of file
src/biz/jxgljsc.ts 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
export enum INTERFACErEQUESTTYPEENUM {
即时更新 = 1,
定时更新
}
\ No newline at end of file
src/config/interfaceConfig.ts 0 → 100644
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 0 → 100644
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 0 → 100644
//接口任务 定期更新
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
//打包完数据之后的处理
/**
* 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/interfaceAnalysis.ts 0 → 100644
/**
* 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 0 → 100644
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 0 → 100644
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 0 → 100644
//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 0 → 100644
/**
* 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 0 → 100644
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 0 → 100644
export async function checkToken(req, res, next) {
next();
}
\ No newline at end of file
src/middleware/encryptionReturn.ts 0 → 100644
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 0 → 100644
var formidable = require("formidable");
export async function parseFormParam(req, res, next) {
    var form = new formidable.IncomingForm();
    form.parse(req, (err, fields, files)=>{
        if (err) {
           next(err)
        }
        else {
            req.fields = fields;
            req.files = files;
            next();
        }
    })
}
\ No newline at end of file
src/net/http_server.ts 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
export class BizError extends Error {
}
\ No newline at end of file
src/util/myXML.ts 0 → 100644
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 0 → 100644
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 0 → 100644
//对象判空
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 0 → 100644
{
"compilerOptions": {
"module": "commonjs",
"target": "es2017",
"sourceMap": true,
"rootDir":"./src",
"outDir":"./out"
},
"exclude": [
"node_modules"
]
}
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment