Skip to content

Y
yuyiViewServer
Commit d0f5e79b by chenjinjing
Options

no message

parent 60aa85a1
Showing with 447 additions and 1823 deletions
res/yuyiServer.xlsx
No preview for this file type
src/biz/jxgljsc.ts
...@@ -2,8 +2,8 @@ ...@@ -2,8 +2,8 @@
// import { getJxgljsc, getKXCertificationDetails } from '../data/db/jxgljsc'; // import { getJxgljsc, getKXCertificationDetails } from '../data/db/jxgljsc';
import { getJxgljsc } from '../data/db/jxgljsc'; import { getJxgljsc } from '../data/db/jxgljsc';
import { jxgljscTableData } from '../data/table/jxgljscData'; import { jxgljscTableData } from '../data/table/jxgljscData';
import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut'; import { keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out'; import { getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
/* 绩效管理驾驶舱 */ /* 绩效管理驾驶舱 */
...@@ -20,126 +20,44 @@ export async function getData(req, res) { ...@@ -20,126 +20,44 @@ export async function getData(req, res) {
let zfqymjbhqsPackageData = onceYBarChartPackage([dbList.在孵企业面积变化趋势], '', ''); let zfqymjbhqsPackageData = onceYBarChartPackage([dbList.在孵企业面积变化趋势], '', '');
ret['zfqymjbhqs'] = getOnceYBarChartOut('在孵企业面积变化趋势', zfqymjbhqsPackageData); ret['zfqymjbhqs'] = getOnceYBarChartOut('在孵企业面积变化趋势', zfqymjbhqsPackageData);
let zfqyslfx = keyValuePackage(dbList['在孵企业数量变化趋势'].count);
ret['zfqyslfx'] = getKeyValueOut('在孵企业数量分析', zfqyslfx);
ret['zfqyslbhqs'] = {title:"在孵企业数量变化趋势", dataList:dbList["在孵企业数量变化趋势"].dataList};
let cyjgPackageData = keyValuePackage(dbList['产业结构'].dataList); let cyjgPackageData = keyValuePackage(dbList['产业结构'].dataList);
ret['cyjg'] = getKeyValueOut('产业结构', cyjgPackageData); ret['cyjg'] = getKeyValueOut('产业结构', cyjgPackageData);
// let ykjqypyqkTableData = tablePackage(excelData["硬科技企业培育情况"].headerList[0], excelData["硬科技企业培育情况"].bodyList);
// ret['ykjqypyqk'] = getTableOut( '硬科技企业培育情况', ykjqypyqkTableData);
let kjxzxqyrdqkPackageData = keyValuePackage(dbList['科技型中小企业认定情况'].dataList);
ret['kjxzxqyrdqk'] = getKeyValueOut('科技型中小企业认定情况', kjxzxqyrdqkPackageData);
// let kjxzxqyrdqkxxTableData = tablePackage(excelData["科技型中小企业认定情况"].headerList[0], excelData["科技型中小企业认定情况"].bodyList);
// ret['kjxzxqyrdqk'] = getTableOut( '科技型中小企业认定情况', kjxzxqyrdqkxxTableData);
let kjxzxqyrdqkxxTableData = tablePackage(dbList["科技型中小企业认定情况详细"].headerList[0], dbList["科技型中小企业认定情况详细"].bodyList);
ret['kjxzxqyrdqkxx'] = getTableOut('科技型中小企业认定情况详细', kjxzxqyrdqkxxTableData);
let rcyjPackageData = keyValuePackage(dbList['人才引进'].dataList); let rcyjPackageData = keyValuePackage(dbList['人才引进'].dataList);
ret['rcyj'] = getKeyValueOut('人才引进', rcyjPackageData); ret['rcyj'] = getKeyValueOut('人才引进', rcyjPackageData);
let fhqhzsjPackageData = keyValuePackage(dbList['孵化器汇总数据'].dataList); let fhqhzsj = keyValuePackage(dbList['孵化器汇总数据'].dataList);
ret['fhqhzsj'] = getKeyValueOut('孵化器汇总数据', fhqhzsjPackageData); ret['fhqhzsj'] = getKeyValueOut('孵化器汇总数据', fhqhzsj);
// let fhqdfsjPackageData = keyValuePackage(dbList['孵化器得分数据'].dataList);
// ret['fhqdfsj'] = getKeyValueOut('孵化器得分数据', fhqdfsjPackageData);
let fhqdfsjPackageData = keyValuePackage(excelData['孵化器得分数据'].dataList);
ret['fhqdfsj'] = getKeyValueOut('孵化器得分数据', fhqdfsjPackageData);
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);//设计图有改动todo
// ret['yj'] = getKeyValueOut('预警', yjPackageData);
let yjPackageData = keyValuePackage(dbList['预警'].dataList); let yjPackageData = keyValuePackage(dbList['预警'].dataList);
ret['yj'] = getKeyValueOut('预警', yjPackageData); ret['yj'] = getKeyValueOut('预警', yjPackageData);
// let qyyjPackageData = keyValuePackage(excelData['企业预警'].dataList); let qyyj = tablePackage(dbList["企业预警"].headerList[0], dbList["企业预警"].bodyList);
// ret['qyyj'] = getKeyValueOut('企业预警', qyyjPackageData); ret['qyyj'] = getTableOut('企业预警', qyyj);
let qyyjTableData = tablePackage(dbList["企业预警"].headerList[0], dbList["企业预警"].bodyList);
ret['qyyj'] = getTableOut('企业预警', qyyjTableData);
let qydtPackageData = keyValuePackage(dbList['企业动态'].dataList);
ret['qydt'] = getKeyValueOut('企业动态', qydtPackageData);
let zfqybhqsPackageData = onceYBarChartPackage(dbList['在孵企业变化趋势'], '家', '');
ret['zfqybhqs'] = getOnceYBarChartOut('在孵企业变化趋势', zfqybhqsPackageData);
// let jrfwPackageData = keyValuePackage(excelData['金融服务'].dataList);
// ret['jrfw'] = getKeyValueOut('金融服务', jrfwPackageData);//后台填报todo
let jrfwPackageData = keyValuePackage(dbList['金融服务'].dataList);
ret['jrfw'] = getKeyValueOut('金融服务', jrfwPackageData);//后台填报todo
let zysjePackageData = keyValuePackage(dbList['总营收金额'].dataList);
ret['zysje'] = getKeyValueOut('总营收金额', zysjePackageData);
let zfqyzysPackageData = keyValuePackage(dbList['在孵企业总营收'].dataList);
ret['zfqyzys'] = getKeyValueOut('在孵企业总营收', zfqyzysPackageData);
let tzlxPackageData = keyValuePackage(excelData['投资类型'].dataList);
ret['tzlx'] = getKeyValueOut('投资类型', tzlxPackageData);
let tzlxfbtPackageData = onceYBarChartPackage(dbList['投资类型分布图'], '', '');
ret['tzlxfbt'] = getOnceYBarChartOut('投资类型分布图', tzlxfbtPackageData);
let zfqyrzqkPackageData = keyValuePackage(dbList['在孵企业融资情况'].dataList);
ret['zfqyrzqk'] = getKeyValueOut('在孵企业融资情况', zfqyrzqkPackageData);
let zfqyrzqkzbPackageData = keyValuePackage(dbList['在孵企业融资情况占比'].dataList); let qybyl = keyValuePackage(dbList['孵化成果'].count);
ret['zfqyrzqkzb'] = getKeyValueOut('在孵企业融资情况占比', zfqyrzqkzbPackageData); ret['qybyl'] = getKeyValueOut('企业毕业率', qybyl);
let ggjsfwPackageData = keyValuePackage(excelData['公共技术服务'].dataList);//去掉 let fhcg = keyValuePackage(dbList['孵化成果'].dataList);
ret['ggjsfw'] = getKeyValueOut('公共技术服务', ggjsfwPackageData); ret['fhcg'] = getKeyValueOut('孵化成果', fhcg);
let qyfhlPackageData = keyValuePackage(excelData['企业孵化率'].dataList); let qyfwxqxyl = keyValuePackage(dbList['企业服务需求响应率'].dataList);
ret['qyfhl'] = getKeyValueOut('企业孵化率', qyfhlPackageData); ret['qyfwxqxyl'] = getKeyValueOut('企业服务需求响应率', qyfwxqxyl);
let qyfhsPackageData = keyValuePackage(dbList['企业孵化数'].dataList); let yxyxqcljd = keyValuePackage(dbList['已响应需求处理进度'].dataList);
ret['qyfhs'] = getKeyValueOut('企业孵化数', qyfhsPackageData); ret['yxyxqcljd'] = getKeyValueOut('已响应需求处理进度', yxyxqcljd);
res.send(ret); let qyfwgxqTop5 = keyValuePackage(dbList['企业服务高需求类型排行趋势'].dataList);
} ret['qyfwgxqTop5'] = getKeyValueOut('企业服务高需求类型排行趋势', qyfwgxqTop5);
export async function get备份(req, res) {
let dbList = await getJxgljsc();
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 fhqdfsjPackageData = keyValuePackage(excelData['孵化器得分数据'].dataList);
ret['fhqdfsj'] = getKeyValueOut('孵化器得分数据', fhqdfsjPackageData);
let rcyjPackageData = keyValuePackage(excelData['人才引进'].dataList);
ret['rcyj'] = getKeyValueOut('人才引进', rcyjPackageData);
let fhqhzsjPackageData = keyValuePackage(excelData['孵化器汇总数据'].dataList);
ret['fhqhzsj'] = getKeyValueOut('孵化器汇总数据', fhqhzsjPackageData);
let xzzfqyqkPackageData = keyValuePackage(excelData['新增在孵企业情况'].dataList); let xzzfqyqkPackageData = keyValuePackage(excelData['新增在孵企业情况'].dataList);
ret['xzzfqyqk'] = getKeyValueOut('新增在孵企业情况', xzzfqyqkPackageData); ret['xzzfqyqk'] = getKeyValueOut('新增在孵企业情况', xzzfqyqkPackageData);
...@@ -156,43 +74,15 @@ export async function get备份(req, res) { ...@@ -156,43 +74,15 @@ export async function get备份(req, res) {
let qycxfsddnlPackageData = keyValuePackage(excelData['区域创新辐射带动能力'].dataList); let qycxfsddnlPackageData = keyValuePackage(excelData['区域创新辐射带动能力'].dataList);
ret['qycxfsddnl'] = getKeyValueOut('区域创新辐射带动能力', qycxfsddnlPackageData); ret['qycxfsddnl'] = getKeyValueOut('区域创新辐射带动能力', qycxfsddnlPackageData);
let yjPackageData = keyValuePackage(excelData['预警'].dataList); let jrfw = keyValuePackage(excelData['金融服务'].dataList);
ret['yj'] = getKeyValueOut('预警', yjPackageData); ret['jrfw'] = getKeyValueOut('金融服务', jrfw);
let qyyjPackageData = keyValuePackage(excelData['企业预警'].dataList);
ret['qyyj'] = getKeyValueOut('企业预警', qyyjPackageData);
let qydtPackageData = keyValuePackage(excelData['企业动态'].dataList);
ret['qydt'] = getKeyValueOut('企业动态', qydtPackageData);
let zfqybhqsPackageData = onceYBarChartPackage(excelData['在孵企业变化趋势'], '家', ''); let qydkqs = keyValuePackage(excelData['企业贷款趋势'].dataList);
ret['zfqybhqs'] = getOnceYBarChartOut('在孵企业变化趋势', zfqybhqsPackageData); ret['qydkqs'] = getKeyValueOut('企业贷款趋势', qydkqs);
let jrfwPackageData = keyValuePackage(excelData['金融服务'].dataList); let rzfwxq = tablePackage(excelData["融资服务详情"].headerList[0], excelData["融资服务详情"].bodyList);
ret['jrfw'] = getKeyValueOut('金融服务', jrfwPackageData); ret['rzfwxq'] = getTableOut('融资服务详情', rzfwxq);
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); res.send(ret);
} }
src/biz/qyfw.ts
import { systemConfig } from '../config/serverConfig'; import { systemConfig } from '../config/serverConfig';
import { getEnterprise, getEnterpriseDetails } from '../data/db/qyfw'; import { getEnterprise, getEnterpriseDetails, get入孵企业数量变化趋势 } from '../data/db/qyfw';
import { qyfwTableData } from '../data/table/qyfwData'; import { zhyyTableData } from '../data/table/zhyyData';
import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut'; import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out'; import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
...@@ -9,210 +8,99 @@ import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut ...@@ -9,210 +8,99 @@ import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut
export async function getData(req, res) { export async function getData(req, res) {
let dbData = await getEnterprise(); let dbData = await getEnterprise();
let excelData = qyfwTableData(); let excelData = zhyyTableData();
let ret:any = {}; let ret:any = {};
let qyjbqkPackageData = keyValuePackage(dbData['企业基本情况'].dataList);
ret['qyjbqk'] = getKeyValueOut('企业基本情况', qyjbqkPackageData);
let bhqsfxPackageData = onceYBarChartPackage( dbData['变化趋势分析'], '','');
ret['bhqsfx'] = getOnceYBarChartOut('变化趋势分析', bhqsfxPackageData);
let rfszfbPackageData = keyValuePackage(dbData['入孵时长分布'].dataList);
ret['rfszfb'] = getKeyValueOut('入孵时长分布', rfszfbPackageData);
let fhqyhylyzbPackageData = keyValuePackage(dbData['孵化企业行业领域占比'].dataList);
ret['fhqyhylyzb'] = getKeyValueOut('孵化企业行业领域占比', fhqyhylyzbPackageData);
let qyrcPackageData = onceYBarChartPackage( dbData['企业人才'], '','');
ret['qyrc'] = getOnceYBarChartOut('企业人才', qyrcPackageData);
let qyfwhzsjPackageData = keyValuePackage(dbData['企业服务汇总数据'].dataList);
ret['qyfwhzsj'] = getKeyValueOut('企业服务汇总数据', qyfwhzsjPackageData);
let qyxqdtPackageData = keyValuePackage(dbData['企业需求动态'].dataList);
ret['qyxqdt'] = getKeyValueOut('企业需求动态', qyxqdtPackageData);
// let qyxqdtxxTableData = tablePackage(excelData["企业需求动态详细"].headerList[0], excelData["企业需求动态详细"].bodyList);
// let itemDataList = []
// qyxqdtxxTableData.dataList.forEach(info => {
// info.eId = "xxxx";
// itemDataList.push(info);
// });
// qyxqdtxxTableData.dataList = itemDataList;
// ret['qyxqdtxx'] = getTableOut( '企业需求动态详细', qyxqdtxxTableData);
let qyxqdtxxTableData = tablePackage(dbData["企业需求动态详细"].headerList[0], dbData["企业需求动态详细"].bodyList);
ret['qyxqdtxx'] = getTableOut( '企业需求动态详细', qyxqdtxxTableData);
let dtTableData = tablePackage(excelData["地图"].headerList[0], excelData["地图"].bodyList); let dtTableData = tablePackage(excelData["地图"].headerList[0], excelData["地图"].bodyList);
let dt = {dataList:[], titleList:dtTableData.titleList}; let dt = {}
dtTableData.dataList.forEach(info => { dtTableData.dataList.forEach(info => {
let {D} = info; let { A, D } = info;
let loudongDetails = tablePackage(excelData[A].headerList[0], excelData[A].bodyList);
let imgUrl = `${systemConfig.imgPath}/${D}`; let imgUrl = `${systemConfig.imgPath}/${D}`;
info["D"] = imgUrl; info["D"] = imgUrl;
dt.dataList.push(info); if (!dt[A]) dt[A] = {dataList:[], tableData:[]};
Object.keys(info).forEach((key, index) => {
dt[A].dataList.push({key:dtTableData.titleList[index], value:info[key]});
}) })
ret['dt'] = getTableOut( '地图', dt); dt[A].tableData = getTableOut("表格数据", loudongDetails);
});
let qybhqkPackageData = keyValuePackage(dbData['企业变化情况'].dataList);
ret['qybhqk'] = getKeyValueOut('企业变化情况', qybhqkPackageData);
let bhqsPackageData = onceYBarChartPackage( dbData['企业变化情况变化趋势'], '家','');
ret['bhqs'] = getOnceYBarChartOut('变化趋势', bhqsPackageData);
let jrfwPackageData = keyValuePackage(dbData['金融服务'].dataList);
ret['jrfw'] = getKeyValueOut('金融服务', jrfwPackageData);
let byrzqyPackageData = onceYBarChartPackage( dbData['本月融资企业'], '',''); ret['dt'] = {title:"地图", dataList:dt};
ret['byrzqy'] = getOnceYBarChartOut('本月融资企业', byrzqyPackageData);
let byrzjePackageData = onceYBarChartPackage( dbData['本月融资金额'], '',''); let qyjbqk = keyValuePackage(dbData.企业基本情况.dataList);
ret['byrzje'] = getOnceYBarChartOut('本月融资金额', byrzjePackageData); ret['qyjbqk'] = getKeyValueOut('企业基本情况', qyjbqk);
let zfqyzysPackageData = keyValuePackage(dbData['在孵企业总营收'].dataList); ret['rfqyslbhqs'] = {title:"入孵企业数量变化趋势", dataList:dbData.入孵企业数量变化趋势};
ret['zfqyzys'] = getKeyValueOut('在孵企业总营收', zfqyzysPackageData);
let jrfwqyTableData = tablePackage(dbData["金融服务企业"].headerList[0], dbData["金融服务企业"].bodyList); let rfscfb = keyValuePackage(dbData.入孵时长分布.dataList);
ret['jrfwqy'] = getTableOut( '金融服务企业', jrfwqyTableData); ret['rfscfb'] = getKeyValueOut('入孵时长分布', rfscfb);
let zscqPackageData = keyValuePackage(dbData['知识产权'].dataList); let jjdqqys = keyValuePackage(dbData.拟毕业企业情况.count);
ret['zscq'] = getKeyValueOut('知识产权', zscqPackageData); ret['jjdqqys'] = getKeyValueOut('即将到期企业数', jjdqqys);
let zscqbtPackageData = keyValuePackage(dbData['知识产权饼图'].dataList); let nbyqyqk = tablePackage(dbData.拟毕业企业情况.dataList.headerList[0], dbData.拟毕业企业情况.dataList.bodyList);
ret['zscqbt'] = getKeyValueOut('知识产权饼图', zscqbtPackageData); ret['nbyqyqk'] = getTableOut( '拟毕业企业情况', nbyqyqk);
let zscqxqTableData = tablePackage(dbData["知识产权详情"].headerList[0], dbData["知识产权详情"].bodyList); let rfqyhyfb = keyValuePackage(dbData.入孵企业行业分布.dataList);
ret['zscqxq'] = getTableOut( '知识产权详情', zscqxqTableData); ret['rfqyhyfb'] = getKeyValueOut('入孵企业行业分布', rfqyhyfb);
let qyzzflPackageData = keyValuePackage(dbData['企业资质分类'].dataList); let qyfwhzsj = keyValuePackage(dbData.企业服务汇总数据.dataList);
ret['qyzzfl'] = getKeyValueOut('企业资质分类', qyzzflPackageData); ret['qyfwhzsj'] = getKeyValueOut('企业服务汇总数据', qyfwhzsj);
let qyzzfl_xjrTableData = tablePackage(dbData["企业资质分类_小巨人"].headerList[0], dbData["企业资质分类_小巨人"].bodyList); let jzmqqyxqs = keyValuePackage(dbData.企业需求服务.count);
ret['qyzzfl_xjr'] = getTableOut( '企业资质分类_小巨人', qyzzfl_xjrTableData); ret['jzmqqyxqs'] = getKeyValueOut('截止目前企业需求数', jzmqqyxqs);
let qyzzfl_gxqyTableData = tablePackage(dbData["企业资质分类_高新企业"].headerList[0], dbData["企业资质分类_高新企业"].bodyList); let qyxqxzqs = keyValuePackage(dbData.企业需求服务.dataList);
ret['qyzzfl_gxqy'] = getTableOut( '企业资质分类_高新企业', qyzzfl_gxqyTableData); ret['qyxqxzqs'] = getKeyValueOut('企业需求新增趋势', qyxqxzqs);
let qyzzfl_zjtxTableData = tablePackage(dbData["企业资质分类_专精特新"].headerList[0], dbData["企业资质分类_专精特新"].bodyList); let qyxqqk = tablePackage(dbData.企业需求情况.headerList[0], dbData.企业需求情况.bodyList);
ret['qyzzfl_zjtx'] = getTableOut( '企业资质分类_专精特新', qyzzfl_zjtxTableData); ret['qyxqqk'] = getTableOut( '企业需求情况', qyxqqk);
let qyzzfl_gqpyTableData = tablePackage(dbData["企业资质分类_小巨人培育"].headerList[0], dbData["企业资质分类_小巨人培育"].bodyList); let qyxqqkxx = tablePackage(dbData.企业需求情况详细.headerList[0], dbData.企业需求情况详细.bodyList);
ret['qyzzfl_gqpy'] = getTableOut( '企业资质分类_小巨人培育', qyzzfl_gqpyTableData); ret['qyxqqkxx'] = getTableOut( '企业需求情况详情', qyxqqkxx);
res.send(ret); let xqclqk = keyValuePackage(dbData.需求处理情况.dataList);
} ret['xqclqk'] = getKeyValueOut('需求处理情况', xqclqk);
let fwlx = keyValuePackage(dbData.服务类型.count);
ret['fwlx'] = getKeyValueOut('服务类型', fwlx);
export async function getEnterpriseByName(req, res) { let fwlxxx = keyValuePackage(dbData.服务类型.dataList);
let {name, type} = req.body; ret['fwlxxx'] = getKeyValueOut('服务类型详细', fwlxxx);
let dbData = await getEnterpriseDetails(name, type);
let ret:any = {}; ret['rfqyfwqk'] = {title:"入孵企业服务情况", dataList:dbData.入孵企业服务情况};
ret['qylist'] = {data:dbData, count:dbData.length};
res.send(ret); res.send(ret);
} }
export async function getQianRuQianChu(req, res) {
let {rufuType, rufuTime, rufuState} = req.body;
export async function get备份(req, res) { //"月", "25/04", "全部"
let dbData = await getEnterprise();
let excelData = qyfwTableData();
let ret:any = {}; let ret:any = {};
let qyjbqkPackageData = keyValuePackage(excelData['企业基本情况'].dataList); let rufuqiyeTable = await get入孵企业数量变化趋势(rufuType, rufuTime, rufuState);
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['rufuqiye'] = {title:"入孵企业数量变化趋势表格", dataList:rufuqiyeTable};
ret['qyfwhzsj'] = getKeyValueOut('企业服务汇总数据', qyfwhzsjPackageData);
let qyxqdtPackageData = keyValuePackage(excelData['企业需求动态'].dataList); res.send(ret);
ret['qyxqdt'] = getKeyValueOut('企业需求动态', qyxqdtPackageData); }
// let qyxqdtxxTableData = tablePackage(excelData["企业需求动态详细"].headerList[0], excelData["企业需求动态详细"].bodyList);
// let itemDataList = []
// qyxqdtxxTableData.dataList.forEach(info => {
// info.eId = "xxxx";
// itemDataList.push(info);
// });
// qyxqdtxxTableData.dataList = itemDataList;
// ret['qyxqdtxx'] = getTableOut( '企业需求动态详细', qyxqdtxxTableData);
let qyxqdtxxTableData = tablePackage(dbData["企业需求动态详细"].headerList[0], dbData["企业需求动态详细"].bodyList);
ret['qyxqdtxx'] = getTableOut( '企业需求动态详细', qyxqdtxxTableData);
let dtTableData = tablePackage(excelData["地图"].headerList[0], excelData["地图"].bodyList);
let dt = {dataList:[], titleList:dtTableData.titleList};
dtTableData.dataList.forEach(info => {
let {D} = info;
let imgUrl = `${systemConfig.imgPath}/${D}`;
info["D"] = imgUrl;
dt.dataList.push(info);
})
ret['dt'] = getTableOut( '地图', dt);
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); * 单企业
* @param req
* @param res
*/
export async function getEnterpriseByName(req, res) {
let {name, type} = req.body;
let dbData = await getEnterpriseDetails(name, type);
let qyzzfl_gqpyTableData = tablePackage(excelData["企业资质分类_高企培育"].headerList[0], excelData["企业资质分类_高企培育"].bodyList); let ret:any = {};
ret['qyzzfl_gqpy'] = getTableOut( '企业资质分类_高企培育', qyzzfl_gqpyTableData); ret['qylist'] = {data:dbData, count:dbData.length};
res.send(ret); res.send(ret);
} }
......
src/biz/zhyy.ts
import { log } from 'console';
import { systemConfig } from '../config/serverConfig'; import { systemConfig } from '../config/serverConfig';
import { getZhyy } from '../data/db/zhyy'; import { getZhyy } from '../data/db/zhyy';
import { zhyyTableData } from '../data/table/zhyyData'; import { zhyyTableData } from '../data/table/zhyyData';
...@@ -17,7 +15,6 @@ export async function getData(req, res) { ...@@ -17,7 +15,6 @@ export async function getData(req, res) {
let dtTableData = tablePackage(excelData["地图"].headerList[0], excelData["地图"].bodyList); let dtTableData = tablePackage(excelData["地图"].headerList[0], excelData["地图"].bodyList);
let dt = {} let dt = {}
let dtDetails =
dtTableData.dataList.forEach(info => { dtTableData.dataList.forEach(info => {
let { A, D } = info; let { A, D } = info;
let loudongDetails = tablePackage(excelData[A].headerList[0], excelData[A].bodyList); let loudongDetails = tablePackage(excelData[A].headerList[0], excelData[A].bodyList);
......
src/data/db/jxgljsc.ts
...@@ -3,13 +3,11 @@ ...@@ -3,13 +3,11 @@
*/ */
import moment = require("moment") import moment = require("moment")
import { FUHUASTATE, INDUSTRY, MOVEOUTTYPE, OPERATIONALDATATYPE, TABLENAME, FINANCINGROUNDS, ENTERPRISETEAM, FUHUAQILNVESTMENTSTYLE, EMIGRATIONTYPE, STATE } from "../../config/enum"; import { FUHUASTATE, INDUSTRY, OPERATIONALDATATYPE, TABLENAME, ENTERPRISETEAM, EMIGRATIONTYPE, STATE, FOLLOWUPSTATUS, NEEDCATEGORY } from "../../config/enum";
import { selectData, selectManyTableData } from "./operationalData"; import { selectData, selectManyTableData } from "./operationalData";
import { keyValuePackage } from "../../dataPackage/inFrontOut"; import { getChart, getKeyValue, getMonthList, getYearList } from "./out";
import { info, log } from "console";
import { getChart, getKeyValue, getYearList } from "./out";
import { get } from "http";
import { changeEnumValue } from "../../tools/eccEnum"; import { changeEnumValue } from "../../tools/eccEnum";
import { getMySqlMs } from "../../tools/systemTools";
function getStartAndEndTimeYearList(startTime, endTime) { function getStartAndEndTimeYearList(startTime, endTime) {
...@@ -24,24 +22,18 @@ function getStartAndEndTimeYearList(startTime, endTime) { ...@@ -24,24 +22,18 @@ function getStartAndEndTimeYearList(startTime, endTime) {
export async function getJxgljsc() { export async function getJxgljsc() {
let jxgljsc = { let jxgljsc = {
在孵企业面积情况分析: { dataList: [], titleList: ['key', 'value'] }, //在孵面积占比
在孵企业面积变化趋势: { name: "在孵企业面积", data: [] },
在孵企业数量变化趋势: {count:[], dataList:[]}, // count:本月新加入在孵企业、同比上月，dataList:入孵企业按月、按年的迁入、迁出数量
产业结构: { dataList: [], titleList: ['key', 'value'] },//产业结构 产业结构: { dataList: [], titleList: ['key', 'value'] },//产业结构
科技型中小企业认定情况: { dataList: [], titleList: ['key', 'value'] },//创业团队
科技型中小企业认定情况详细: { bodyList: [], headerList: [['企业名称', '认定时间']] },//新增科技型中小企业认定情况
人才引进: { dataList: [], titleList: ['key', 'value'] },//人才引进 人才引进: { dataList: [], titleList: ['key', 'value'] },//人才引进
孵化器汇总数据: { dataList: [], titleList: ['key', 'value'] },//孵化器汇总数据 孵化器汇总数据: { dataList: [], titleList: ['key', 'value'] },//孵化器汇总数据
企业动态: { dataList: [], titleList: ['key', 'value'] },//企业动态
在孵企业变化趋势: [],//在孵企业变化趋势
总营收金额: { dataList: [], titleList: ['key', 'value'] },//总营收金额
在孵企业总营收: { dataList: [], titleList: ['key', 'value'] },//在孵企业总营收
投资类型分布图: [],//新增投资类型
在孵企业融资情况: { dataList: [], titleList: ['key', 'value'] },//在孵企业融资情况
在孵企业融资情况占比: { dataList: [], titleList: ['key', 'value'] },
企业孵化数: { dataList: [], titleList: ['key', 'value'] },//企业孵化数
金融服务: { dataList: [], titleList: ['key', 'value'] },//新增后台填报
预警: { dataList: [], titleList: ['key', 'value'] },//预警 预警: { dataList: [], titleList: ['key', 'value'] },//预警
企业预警: { bodyList: [], headerList: [['企业名称', '风险等级']] }, 企业预警: { bodyList: [], headerList: [['企业名称', '风险等级']] },
在孵企业面积情况分析: { dataList: [] }, //在孵企业面积情况分析 孵化成果: {count:[], dataList:[]},//孵化成果
在孵企业面积变化趋势: { name: "在孵企业面积", data: [] } 企业服务需求响应率: { dataList: [], titleList: ['key', 'value'] },
已响应需求处理进度: { dataList: [], titleList: ['key', 'value'] },
企业服务高需求类型排行趋势: { dataList: [], titleList: ['key', 'value'] },
}; };
...@@ -56,7 +48,6 @@ export async function getJxgljsc() { ...@@ -56,7 +48,6 @@ export async function getJxgljsc() {
let 面积变化Map = {};//孵化面积变化 let 面积变化Map = {};//孵化面积变化
let thisYear = new Date().getFullYear(); let thisYear = new Date().getFullYear();
let industryMap = {}; let industryMap = {};
let 在孵企业变化趋势map = {};
fhdbList.forEach(info => { fhdbList.forEach(info => {
let { industry, enterprise_fuhuas, enterprise_leases } = info; let { industry, enterprise_fuhuas, enterprise_leases } = info;
...@@ -75,9 +66,6 @@ export async function getJxgljsc() { ...@@ -75,9 +66,6 @@ export async function getJxgljsc() {
if (itemYear > thisYear) return; if (itemYear > thisYear) return;
if (!面积变化Map[itemYear]) 面积变化Map[itemYear] = { key: itemYear, value: 0 }; if (!面积变化Map[itemYear]) 面积变化Map[itemYear] = { key: itemYear, value: 0 };
面积变化Map[itemYear].value += parseFloat(area); 面积变化Map[itemYear].value += parseFloat(area);
if (!在孵企业变化趋势map[itemYear]) 在孵企业变化趋势map[itemYear] = 0;
在孵企业变化趋势map[itemYear] += 1;
}); });
} }
} }
...@@ -90,15 +78,6 @@ export async function getJxgljsc() { ...@@ -90,15 +78,6 @@ export async function getJxgljsc() {
}); });
let 在孵企业变化趋势 = [];
for (let key in 在孵企业变化趋势map) {
在孵企业变化趋势.push({ key, value: 在孵企业变化趋势map[key] });
}
在孵企业变化趋势.sort((a, b) => { return parseInt(a.key) - parseInt(b.key) });
jxgljsc.在孵企业变化趋势 = getChart({ "在孵企业": 在孵企业变化趋势 });//在孵企业变化趋势
//行业领域----按照企业选择的类型呈现 //行业领域----按照企业选择的类型呈现
for (let key in INDUSTRY) { for (let key in INDUSTRY) {
let anyKey: any = key; let anyKey: any = key;
...@@ -112,6 +91,17 @@ export async function getJxgljsc() { ...@@ -112,6 +91,17 @@ export async function getJxgljsc() {
jxgljsc.在孵企业面积变化趋势.data = Object.values(面积变化Map); jxgljsc.在孵企业面积变化趋势.data = Object.values(面积变化Map);
//获取在孵企业
let fhColumn = ["fId", "eId", "startTime", "endTime", "state", "virtualCause", "virtualCauseDes", "moveOutType",
"moveOutTrace", "moveOutCause", "moveOutTime", "graduationTime", ];
let 在孵dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {state: { "%between%": [FUHUASTATE.实体孵化, FUHUASTATE.虚拟孵化] }}, fhColumn);
let 迁出dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, { state: FUHUASTATE.迁出 }, fhColumn);
//入孵企业数量变化趋势
let {rfqyslbhqs, zfqy} = await getRfqyslbhqsMonth(在孵dbList, 迁出dbList);
jxgljsc.在孵企业数量变化趋势.count = getKeyValue(zfqy);
jxgljsc.在孵企业数量变化趋势.dataList = getChart(rfqyslbhqs);
let 孵化器信息数据 = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.羽翼孵化器, {}, null); let 孵化器信息数据 = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.羽翼孵化器, {}, null);
/** /**
* 计算在孵企业面积占比：在孵企业总面积/孵化器或者园区总面积 x 100% * 计算在孵企业面积占比：在孵企业总面积/孵化器或者园区总面积 x 100%
...@@ -126,12 +116,6 @@ export async function getJxgljsc() { ...@@ -126,12 +116,6 @@ export async function getJxgljsc() {
// 获取当前时间 // 获取当前时间
let nowTime = moment().format('YYYY-MM-DD HH:mm:ss'); let nowTime = moment().format('YYYY-MM-DD HH:mm:ss');
let fhColumn = ["fId", "eId", "startTime", "endTime", "state", "virtualCause", "virtualCauseDes", "moveOutType",
"moveOutTrace", "moveOutCause", "moveOutTime", "graduationTime"];
//获取在孵企业
// let 在孵dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, { "endTime": { "%gt%": nowTime } }, fhColumn);
let 在孵dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, { state: { "%between%": [FUHUASTATE.实体孵化, FUHUASTATE.虚拟孵化] } }, fhColumn);
// let 在孵dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {state:{"%notIn%":FUHUASTATE.迁出} }, fhColumn);
//获取在孵企业租赁信息 //获取在孵企业租赁信息
let 租赁Column = ["eId", "year", "alienPatent", "classIPatent", "secondClassPatent", "thirdPentent"]; let 租赁Column = ["eId", "year", "alienPatent", "classIPatent", "secondClassPatent", "thirdPentent"];
...@@ -140,24 +124,11 @@ export async function getJxgljsc() { ...@@ -140,24 +124,11 @@ export async function getJxgljsc() {
在孵租赁联查includeConf[TABLENAME.租赁信息] = { cloum: 租赁Column, where: {} } 在孵租赁联查includeConf[TABLENAME.租赁信息] = { cloum: 租赁Column, where: {} }
let 在孵租赁联查dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {}, ["enterpriseName"], 在孵租赁联查includeConf); let 在孵租赁联查dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {}, ["enterpriseName"], 在孵租赁联查includeConf);
//获取羽翼孵化器
let 羽翼孵化器dbList = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.羽翼孵化器, {}, []);
// jxgljsc.产业结构.dataList = await cyjg();//产业结构
jxgljsc.人才引进.dataList = await rcyj();//人才引进 jxgljsc.人才引进.dataList = await rcyj();//人才引进
//科技型中小企业认定情况 //获取羽翼孵化器
let KXdbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业基础信息表, {}, null); let 羽翼孵化器dbList = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.羽翼孵化器, {}, []);
let KXrdCount = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业资质, {}, null);
let { kjxzxqyrdqk, kjxzxqyrdqkxx } = await getKXrdqk(KXdbList, KXrdCount);
jxgljsc.科技型中小企业认定情况.dataList = getKeyValue(kjxzxqyrdqk);
//科技型中小企业认定情况详细列表
jxgljsc.科技型中小企业认定情况详细.bodyList = kjxzxqyrdqkxx;
let fhqhzsjInfo = await fhqhzsj(羽翼孵化器dbList, 在孵dbList, areaCount); let fhqhzsjInfo = await fhqhzsj(羽翼孵化器dbList, 在孵dbList, areaCount);
jxgljsc.孵化器汇总数据.dataList = getKeyValue(fhqhzsjInfo);//孵化器汇总数据 jxgljsc.孵化器汇总数据.dataList = getKeyValue(fhqhzsjInfo);//孵化器汇总数据
/** /**
...@@ -167,66 +138,185 @@ export async function getJxgljsc() { ...@@ -167,66 +138,185 @@ export async function getJxgljsc() {
jxgljsc.预警.dataList = getKeyValue(yj) jxgljsc.预警.dataList = getKeyValue(yj)
jxgljsc.企业预警.bodyList = riskEnterprises//企业预警 jxgljsc.企业预警.bodyList = riskEnterprises//企业预警
/**
* 孵化成果
*/
let 资质Column = ["qId", "eId", "kxTime", "zjtxTime", "xjrTime", "xjrPyTime", "goPublicTime", "gaoXinJiShuTime", "goPublicSector"];
let 企业资质联查includeConf = {};
企业资质联查includeConf[TABLENAME.企业资质] = { cloum: 资质Column, where: {} }
let 企业资质信息 = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {}, [], 企业资质联查includeConf);
let qyfhsInfo = await qyfhs(企业资质信息);
jxgljsc.孵化成果.dataList = getKeyValue(qyfhsInfo)//企业孵化数
let 毕业Count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业孵化信息, { "moveOutType": EMIGRATIONTYPE.毕业迁出 }, []);
let 孵化Count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业孵化信息, {}, null);
let currentYear = moment().format("YYYY")+"-01-01";
let 今年Param = { startTime:{"%between%": [currentYear, getMySqlMs()]} };
let 今年毕业Param = {moveOutTime:{"%between%": [currentYear, getMySqlMs()]}, moveOutType:EMIGRATIONTYPE.毕业迁出};
let 今年毕业Count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业孵化信息, 今年毕业Param, []);
let 今年孵化Count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业孵化信息, 今年Param, null);
let lastYearMonthStart = moment().subtract(1, 'years').startOf('year').format('YYYY-MM-DD');
let lastYearMonthEnd = moment().subtract(1, 'years').endOf('year').format('YYYY-MM-DD');
let 去年Param = { startTime:{"%between%": [lastYearMonthStart, lastYearMonthEnd]} };
let 去年毕业Param = {moveOutTime:{"%between%": [lastYearMonthStart, lastYearMonthEnd]}, moveOutType:EMIGRATIONTYPE.毕业迁出};
let 去年毕业Count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业孵化信息, 去年毕业Param, []);
let 去年孵化Count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业孵化信息, 去年Param, null);
let 毕业率 = {企业毕业率:"", 环比去年: ""};
let 企业毕业率 = ((毕业Count / 孵化Count) * 100).toFixed(2);//企业毕业率 = (毕业企业数量/所有孵化企业数量) * 100%
let 今年企业毕业率 = (今年毕业Count / 今年孵化Count);
let 去年企业毕业率 = (去年毕业Count / 去年孵化Count);
毕业率.企业毕业率 = 企业毕业率 + "%";
let 环比去年毕业率 = "0";//环比去年毕业率 = [(今年企业毕业率 - 去年企业毕业率) / 去年企业毕业率] * 100%
if (去年企业毕业率) 环比去年毕业率 = (((今年企业毕业率 - 去年企业毕业率) / 去年企业毕业率) * 100 / 100).toFixed(2);
毕业率.环比去年 = 环比去年毕业率 + "%";
jxgljsc.孵化成果.count = getKeyValue(毕业率);
let qydtInfo = await qydt(在孵dbList); /**
jxgljsc.企业动态.dataList = getKeyValue(qydtInfo);//企业动态 * 企业服务分析
*/
//获取所有企业服务表联查企业信息表
let 企业服务dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业服务表, {}, []);
//已受理企业服务
let 已受理企业服务Count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业服务表, {followUpStatus:{"%ne%":FOLLOWUPSTATUS.未受理}}, []);
let 已完成企业服务Count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业服务表, {followUpStatus:FOLLOWUPSTATUS.已完成}, []);
let 企业服务需求响应率 = ((已受理企业服务Count / 企业服务dbList.length) * 100).toFixed(2) + "%";
jxgljsc.企业服务需求响应率.dataList = [{key:"企业服务需求响应率", value:企业服务需求响应率}];
let 已响应需求处理进度 = ((已完成企业服务Count / 已受理企业服务Count) * 100).toFixed(2) + "%";
jxgljsc.已响应需求处理进度.dataList = [{key:"已响应需求处理进度", value:已响应需求处理进度}];
jxgljsc.企业服务高需求类型排行趋势.dataList = await getRfqyfwqk(企业服务dbList);
/** return jxgljsc;
* 金融服务 }
*/
let jrfwInfo = await jrfw(羽翼孵化器dbList);
jxgljsc.金融服务.dataList = getKeyValue(jrfwInfo);
let zysjeList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, {}, null); /**
let zysjeInfo = await zysje(zysjeList); * 入孵企业数量变化趋势
jxgljsc.总营收金额.dataList = getKeyValue(zysjeInfo);//总营收金额 * @param 在孵dbList
* @param 迁出dbList
* @returns
*/
async function getRfqyslbhqsMonth(在孵dbList, 迁出dbList) {
let year = getYearList();
let month = getMonthList();
let currentMonth = moment().format('YY/MM'); //本月
let lastMonth = moment().subtract(1, 'months').format('YY/MM');//上月
let rfqyslbhqs = {
"月":[],
"年":[]
}
let 本月在孵数量 = 0;
let 上月在孵数量 = 0;
for(let i = 0; i < month.length; i++) {
let qianruMonth = 0;
let qianchuMonth = 0;
在孵dbList.forEach(info => {
// 检查入孵开始时间的月份是否与当前月份相同
let parsedStartTime = moment(info.startTime); // 获取入孵开始时间
if (parsedStartTime.isValid() && moment(parsedStartTime).format("YY/MM") === month[i]) {
qianruMonth += 1;
}
if (parsedStartTime.isValid() && moment(parsedStartTime).format("YY/MM") == currentMonth) {
本月在孵数量 += 1
}
if (parsedStartTime.isValid() && moment(parsedStartTime).format("YY/MM") == lastMonth) {
上月在孵数量 += 1
}
})
let zfqyzysInfo = await zfqyzys(在孵dbList); 迁出dbList.forEach(info => {
jxgljsc.在孵企业总营收.dataList = getKeyValue(zfqyzysInfo);//在孵企业总营收 // 检查迁出时间的年份是否与当前年份相同
let parsedMoveOutTime = moment(info.moveOutTime); // 获取迁出时间
if (parsedMoveOutTime.isValid() && moment(parsedMoveOutTime).format("YY/MM") === month[i]) {
qianchuMonth += 1;
}
})
// 投资类型 rfqyslbhqs.月.push({key:month[i], qianru:qianruMonth, qianchu:qianchuMonth});
jxgljsc.投资类型分布图 = await tzlxfb();//投资类型分布图 }
for(let i = 0; i < year.length; i++) {
let qianruYear = 0;
let qianchuYear = 0;
在孵dbList.forEach(info => {
// 检查入孵开始时间的年份是否与当前年份相同
let parsedStartTime = moment(info.startTime); // 获取入孵开始时间
if (parsedStartTime.isValid() && parsedStartTime.year() === year[i]) {
qianruYear += 1;
}
})
jxgljsc.在孵企业融资情况.dataList = await zfqyrzqk();//在孵企业融资情况 迁出dbList.forEach(info => {
jxgljsc.在孵企业融资情况占比.dataList = await zfqyrzqkzb(); // 检查迁出时间的年份是否与当前年份相同
let parsedMoveOutTime = moment(info.moveOutTime); // 获取迁出时间
if (parsedMoveOutTime.isValid() && parsedMoveOutTime.year() === year[i]) {
qianchuYear += 1;
}
})
rfqyslbhqs.年.push({key:year[i], qianru:qianruYear, qianchu:qianchuYear});
}
let 资质Column = ["qId", "eId", "kxTime", "zjtxTime", "xjrTime", "xjrPyTime", "goPublicTime", "gaoXinJiShuTime", "goPublicSector"]; let yoy = "";
let 企业资质联查includeConf = {}; if (上月在孵数量 === 0) yoy = "0%";
企业资质联查includeConf[TABLENAME.企业资质] = { cloum: 资质Column, where: {} } else yoy = ((本月在孵数量 - 上月在孵数量) / 上月在孵数量 * 100).toFixed(2) + "%";
let 企业资质信息 = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {}, [], 企业资质联查includeConf); let zfqy = {
let qyfhsInfo = await qyfhs(企业资质信息); 本月新加入在孵企业:本月在孵数量,
jxgljsc.企业孵化数.dataList = getKeyValue(qyfhsInfo)//企业孵化数 同比上月: yoy
}
return jxgljsc; return {rfqyslbhqs, zfqy};
} }
//产业结构---按照企业选择的类型呈现todo /**
async function cyjg() { * 入孵企业服务情况
let result = []; * @param 入孵企业服务dbList
*/
async function getRfqyfwqk(企业服务dbList) {
let fuWuQiYeTypeMap = {};//企业服务类型
企业服务dbList.forEach( info => {
let needCategoryStr = changeEnumValue(NEEDCATEGORY, info.needCategory)
if (!fuWuQiYeTypeMap[needCategoryStr]) {
fuWuQiYeTypeMap[needCategoryStr] = 0;
}
fuWuQiYeTypeMap[needCategoryStr] += 1;
})
for (let key in INDUSTRY) { let fwlx = [];
let anyKey: any = key; for (let key in NEEDCATEGORY) {
if (isNaN(anyKey)) { let enumValue = NEEDCATEGORY[key];
let keyStr = key; // 跳过未显式赋值的枚举成员（如果有的话，它们默认为枚举前一个成员的值加1）
let industry = INDUSTRY[key]; if (isNaN(Number(key))) { // 这里检查 key 是否可以被转换为数字，以识别枚举成员名称
let count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业基础信息表, { industry: { "%like%": industry } }, null); let needCategoryStr = changeEnumValue(NEEDCATEGORY, enumValue);
if (count > 0) { let value = fuWuQiYeTypeMap[needCategoryStr] || 0;
result.push({ key: keyStr, value: count }); fwlx.push({
} key: needCategoryStr,
value: value
});
} }
} }
return result; fwlx.sort( (a, b) => {
return b.value - a.value;
})
let top5 = fwlx.slice(0, 5);
return top5;
} }
/**
* 人才引进
* @returns
*/
async function rcyj() { async function rcyj() {
let result = []; let result = [];
...@@ -245,62 +335,6 @@ async function rcyj() { ...@@ -245,62 +335,6 @@ async function rcyj() {
return result; return result;
} }
/**
* 科技型中小企业认定情况
*/
// async function getKXrdqk(KXdbList, KXrdCount) {
// let kjxzxqyrdqk = {
// 科技型中小企业认定总数: 0,
// }
// // kjxzxqyrdqk.科技型中小企业认定总数 = KXrdCount;
// let kjxzxqyrdqkxx = [];
// //获取所有企业服务表联查企业信息表
// let qyzzColumn = ["qId", "eId", "kxTime", "kxNumber","kxState"];
// let 企业服务includeConf = {};
// 企业服务includeConf[TABLENAME.企业基础信息表] = { cloum: ["enterpriseName"], where: {} }
// let 企业资质dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业资质, {}, qyzzColumn, 企业服务includeConf);
// 企业资质dbList.forEach(info => {
// if (info.kxTime) {
// kjxzxqyrdqk.科技型中小企业认定总数++;
// }
// //认定时间
// if (info.kxTime) {
// let kxTime = moment(info.kxTime).format('YYYY-MM-DD');
// kjxzxqyrdqkxx.push([info.enterprise.enterpriseName, kxTime,]);
// }
// })
// return { kjxzxqyrdqk, kjxzxqyrdqkxx };
// }
async function getKXrdqk(KXdbList, KXrdCount) {
let kjxzxqyrdqk = {
科技型中小企业认定总数: 0,
};
let kjxzxqyrdqkxx = [];
let qyzzColumn = ["qId", "eId", "kxTime", "kxNumber", "kxState"];
let 企业服务includeConf = {};
企业服务includeConf[TABLENAME.企业基础信息表] = { cloum: ["enterpriseName"], where: {} };
let 企业资质dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业资质, {}, qyzzColumn, 企业服务includeConf);
// 按 kxTime 排序（降序）
let sorted企业资质dbList = 企业资质dbList
.filter(info => info.kxTime) // 确保 kxTime 存在
.sort((a, b) => moment(b.kxTime).diff(moment(a.kxTime))); // 按时间降序排序
// 遍历排序后的数据并生成结果
sorted企业资质dbList.forEach(info => {
if (info.kxTime) {
kjxzxqyrdqk.科技型中小企业认定总数++;
let kxTime = `${moment(info.kxTime).format('YYYY')}年`;
kjxzxqyrdqkxx.push([info.enterprise.enterpriseName, kxTime]);
}
});
return { kjxzxqyrdqk, kjxzxqyrdqkxx };
}
/** /**
* 孵化器汇总数据 * 孵化器汇总数据
...@@ -309,8 +343,7 @@ async function fhqhzsj(data, zfData, areaCount) { ...@@ -309,8 +343,7 @@ async function fhqhzsj(data, zfData, areaCount) {
let fhqhzsj = { let fhqhzsj = {
孵化器总面积: data.totalArea + "㎡", 孵化器总面积: data.totalArea + "㎡",
在孵企业: zfData.length + "家", 在孵企业: zfData.length + "家",
在孵面积: data.zaifuArea + "㎡", 在孵企业面积: data.zaifuArea + "㎡",
// 在孵面积: `${areaCount.toFixed(2)}㎡`
} }
return fhqhzsj; return fhqhzsj;
...@@ -321,7 +354,6 @@ async function fhqhzsj(data, zfData, areaCount) { ...@@ -321,7 +354,6 @@ async function fhqhzsj(data, zfData, areaCount) {
* 预警 * 预警
*/ */
async function getyj() { async function getyj() {
let yj = { let yj = {
高风险: 0, 高风险: 0,
中低风险: 0, 中低风险: 0,
...@@ -368,248 +400,6 @@ async function getyj() { ...@@ -368,248 +400,6 @@ async function getyj() {
} }
/**
* 企业预警
*/
async function qyyj() {
}
/**
* 企业动态---------
*/
async function qydt(data) {
let result = [];
let qydt = {
"本月新加入在孵企业": 0,
"同比上月": "",
"环比去年": ""
}
// //本月新加入在孵企业
// let nowTime = moment().format('YYYY-MM-DD HH:mm:ss');
// let monthAgo = moment().format('YYYY-MM-01 00:00:00');
// //同比上月
// let monthAgo2 = moment().subtract(1, 'month').format('YYYY-MM-01 00:00:00');
// let monthAgo2End = moment().subtract(1, 'month').endOf('month').format('YYYY-MM-DD 00:00:00');
// //环比去年
// let lastYearThieMonthAgo = moment().startOf("M").subtract(1, 'year').format('YYYY-MM-DD 00:00:00');
// let lastYearThieMonthAgoEnd = moment().endOf("M").subtract(1, 'year').format('YYYY-MM-DD 00:00:00');
//本月新加入在孵企业
let nowTime = moment().format('YYYY-MM');
//同比上月
let monthAgo2 = moment().subtract(1, 'month').format('YYYY-MM');
//环比去年
let lastYearThieMonthAgo = moment().startOf("M").subtract(1, 'year').format('YYYY-MM');
let 上月 = 0;
let 去年本月 = 0;
data.forEach(info => {
let { startTime } = info;
let startTimeMonth = moment(startTime).format('YYYY-MM');
// if (moment(startTime) > moment(monthAgo) && moment(startTime) < moment(nowTime)) {
// qydt.本月新加入在孵企业 += 1;
// }
if (startTimeMonth == nowTime) {
qydt.本月新加入在孵企业 += 1;
}
if (startTimeMonth == monthAgo2) {
上月 += 1;
}
if (startTimeMonth == lastYearThieMonthAgo) {
去年本月 += 1;
}
})
// let 同比 = ((qydt.本月新加入在孵企业 - 上月) / 上月) * 100;
// qydt.同比上月 = 同比.toFixed(2) + "%" || "0%";
// let 环比 = ((今年 - 去年) / 去年) * 100;
// qydt.环比去年 = 环比.toFixed(2) + "%";
qydt.同比上月 = "0%";
if (上月) {
let 同比 = ((qydt.本月新加入在孵企业 - 上月) / 上月) * 100;
qydt.同比上月 = 同比.toFixed(2) + "%";
}
qydt.环比去年 = "0%";
if (去年本月 && qydt.本月新加入在孵企业) {
let 环比 = ((qydt.本月新加入在孵企业 - 去年本月) / 去年本月) * 100;
qydt.环比去年 = 环比.toFixed(2) + "%";
}
// result.push(qydt); // 将 qydt 对象添加到 result 数组中
return qydt;
}
//金融服务
async function jrfw(data) {
let jrfw = {
总资产投入金额: data.totalAssetInvestmentAmount,
引入机构数量: data.numberOfInstitutionsIntroduced,
引入机构投资: data.introduceInstitutionalInvestment
}
return jrfw;
}
function zfqybhqs(data) {
let year = getYearList();
let zhqy = {
"在孵企业": []
}
for (let i = 0; i < year.length; i++) {
let count = 0;
data.forEach(info => {
let startTimeYear = moment(info.startTime).year(); //获取入孵开始时间
let thisYear = parseInt(year[i]);
if (startTimeYear === thisYear) count += 1;
})
zhqy.在孵企业.push({ key: year[i], value: count });
}
let zhqybhqs = getChart(zhqy);
return zhqybhqs;
}
//总营收金额
async function zysje(data) {
//获取总营收金额
let zysje = {
总营收金额: 0
};
data.forEach(item => {
zysje.总营收金额 += parseFloat(item.BI);
});
return zysje;
}
//在孵企业总营收
async function zfqyzys(data) {
let distinctMap = {};
data.forEach(info => {
distinctMap[info.eId] = { BI: 0 };
});
let zfqyzys = {
"500万以下": 0,
"500万-1000万": 0,
"1000万-2000万": 0,
"2000万以上": 0
}
let 经营信息dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, {}, null);
//获取在孵企业经营数据
// 经营信息dbList.forEach( info => { //BI（单位万元）
// distinctMap[info.eId].BI += parseFloat(info.BI);
// });
// 获取在孵企业经营数据并进行累加
经营信息dbList.forEach(info => {
if (!info.BI) return; // 检查 info 是否有 BI 属性
if (!distinctMap[info.eId]) {
distinctMap[info.eId] = { BI: 0 }; // 初始化 distinctMap 中的 eId
}
distinctMap[info.eId].BI += parseFloat(info.BI || 0); // 确保 BI 存在并且可以转换为数字
});
for (let key in distinctMap) {
if (!distinctMap[key].BI) continue;
let info = distinctMap[key];
if (info.BI < 500) zfqyzys["500万以下"] += 1;
else if (info.BI >= 500 && info.BI < 1000) zfqyzys["500万-1000万"] += 1;
else if (info.BI >= 1000 && info.BI < 2000) zfqyzys["1000万-2000万"] += 1;
else zfqyzys["2000万以上"] += 1;
}
return zfqyzys
}
//在孵企业融资情况
async function zfqyrzqk() {
let result = [];
for (let key in FINANCINGROUNDS) {
let anyKey: any = key;
if (isNaN(anyKey)) {
let financingRounds = FINANCINGROUNDS[key];
let count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业融资, { financingRounds }, null);
result.push({ key: key, value: count })
}
}
// // 计算总融资数量
// let totalFinancing = result.reduce((acc, item) => acc + item.value, 0);
// // 计算各类型占比
// for (let i = 0; i < result.length; i++) {
// let percentage = ((result[i].value / totalFinancing) * 100).toFixed(2);
// result[i].percentage = `${percentage}%`;
// }
return result;
}
async function zfqyrzqkzb() {
// 获取原始的融资情况数据
let financingData = await zfqyrzqk();
// 计算总融资数量
let totalFinancing = financingData.reduce((acc, item) => acc + item.value, 0);
// 计算各类型占比并存储在新数组中
let percentageData = financingData.map(item => ({
key: item.key,
value: ((item.value / totalFinancing) * 100).toFixed(2) + '%'
}));
return percentageData;
}
//企业孵化率
async function qyfhl() {
let result = [];
let qyfhlList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {}, null);
//获取企业孵化率
let qyfhl = {
"企业毕业率": 0,
"环比去年孵化率": 0
};
let nowYear = new Date().getFullYear();
let lastYear = nowYear - 1;
for (let i = 0; i < qyfhlList.length; i++) {
let item = qyfhlList[i];
let endTime = new Date(item.endTime).getFullYear();
let startTime = new Date(item.startTime).getFullYear();
if (endTime === nowYear) {
qyfhl.企业毕业率 += 1;
if (startTime <= lastYear && endTime >= lastYear) {
qyfhl.环比去年孵化率 += 1;
}
}
}
result.push({ key: "企业孵化率", value: qyfhl.企业毕业率 });
result.push({ key: "环比去年孵化率", value: qyfhl.环比去年孵化率 });
return result;
}
//企业孵化数 //企业孵化数
async function qyfhs(data) { async function qyfhs(data) {
//获取企业孵化数 //获取企业孵化数
...@@ -637,35 +427,4 @@ async function qyfhs(data) { ...@@ -637,35 +427,4 @@ async function qyfhs(data) {
} }
/**
* 投资类型：自有资金、参与基金、自有基金todo
*/
async function tzlxfb() {
let tzlxList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业融资, {}, null);
let tzlx = [
{ key: '自有资金', value: 0 },
{ key: '参与基金', value: 0 },
{ key: '自有基金', value: 0 }
]
// 遍历融资记录并统计
tzlxList.forEach(info => {
let { fuHuaQiInvestmentStyle } = info;
if (fuHuaQiInvestmentStyle === FUHUAQILNVESTMENTSTYLE.自有资金) {
tzlx[0].value += 1;
} else if (fuHuaQiInvestmentStyle === FUHUAQILNVESTMENTSTYLE.参与基金) {
tzlx[1].value += 1;
} else if (fuHuaQiInvestmentStyle === FUHUAQILNVESTMENTSTYLE.自有基金) {
tzlx[2].value += 1;
}
});
//将结果格式化为所需的输出格式
let result = [
{
name: '投资类型',
data: tzlx
}
];
return result;
}
\ No newline at end of file
src/data/db/qyfw.ts
...@@ -3,7 +3,7 @@ ...@@ -3,7 +3,7 @@
*/ */
import moment = require("moment"); import moment = require("moment");
import { FUHUASTATE, INDUSTRY, OPERATIONALDATATYPE, STATE, TABLENAME, IPRALLTYPE, EMIGRATIONTYPE } from "../../config/enum"; import { FUHUASTATE, INDUSTRY, OPERATIONALDATATYPE, STATE, TABLENAME, IPRALLTYPE, EMIGRATIONTYPE, NEEDCATEGORY, FOLLOWUPSTATUS } from "../../config/enum";
import { selectData, selectManyTableData } from "./operationalData"; import { selectData, selectManyTableData } from "./operationalData";
import { getChart, getKeyValue, getMonthList, getYearList } from "./out"; import { getChart, getKeyValue, getMonthList, getYearList } from "./out";
import { getMySqlMs } from "../../tools/systemTools"; import { getMySqlMs } from "../../tools/systemTools";
...@@ -24,37 +24,15 @@ export async function getEnterprise() { ...@@ -24,37 +24,15 @@ export async function getEnterprise() {
企业基本情况: { dataList: [], titleList: ['key', 'value'] }, // 在孵企业面积，在孵企业，毕业企业 企业基本情况: { dataList: [], titleList: ['key', 'value'] }, // 在孵企业面积，在孵企业，毕业企业
入孵企业数量变化趋势: [], // 入孵企业按月、按年的迁入、迁出数量 入孵企业数量变化趋势: [], // 入孵企业按月、按年的迁入、迁出数量
入孵时长分布: { dataList: [], titleList: ['key', 'value'] }, 入孵时长分布: { dataList: [], titleList: ['key', 'value'] },
拟毕业企业情况: {count:0, dataList: { bodyList: [], headerList: [['企业名称', '预计毕业时间']] }}, // count:即将到期企业数（小于3个月） 拟毕业企业情况: {count:[], dataList: { bodyList: [], headerList: [['企业名称', '预计毕业时间']] }}, // count:即将到期企业数（小于3个月）
入孵企业行业分布: { dataList: [], titleList: ['key', 'value'] }, //行业领域分布 入孵企业行业分布: { dataList: [], titleList: ['key', 'value'] }, //行业领域分布
企业服务汇总数据: { dataList: [], titleList: ['key', 'value'] }, //中间汇总数据 企业服务汇总数据: { dataList: [], titleList: ['key', 'value'] }, //中间汇总数据
企业需求服务: { count:0, dataList: []}, //count:所有企业提出的需求服务数量 企业需求服务: { count:[], dataList: []}, //count:所有企业提出的需求服务数量
企业需求情况: { bodyList: [], headerList: [['服务企业名称', '申请时间', '诉求类型']] }, 企业需求情况: { bodyList: [], headerList: [['服务企业名称', '申请时间', '诉求类型']] },
企业需求情况详细: { bodyList: [], headerList: [['企业名称']] }, 企业需求情况详细: { bodyList: [], headerList: [['申请时间', '企业名称', '诉求类型', '需求内容', '跟进状态']] },
需求处理情况: { dataList: [], titleList: ['key', 'value'] },
// 企业基本情况: { dataList: [], titleList: ['key', 'value'] }, //企业基本情况 服务类型: {count:[], dataList:[]},
// 变化趋势分析: [], //变化趋势分析 入孵企业服务情况: {}
// 入孵时长分布: { dataList: [], titleList: ['key', 'value'] }, //入孵时长分布
// 孵化企业行业领域占比: { dataList: [], titleList: ['key', 'value'] }, //孵化企业行业领域占比
// 企业人才: [], //企业人才
// 企业服务汇总数据: { dataList: [], titleList: ['key', 'value'] }, //企业服务汇总数据
// 企业需求动态: { dataList: [], titleList: ['key', 'value'] }, //企业需求动态
// // 企业需求动态详细: { bodyList: [], headerList: [['企业名称', '类型', 'eId']] }, //企业需求动态详细
// 企业需求动态详细: { bodyList: [], headerList: [['企业名称']] },
// 企业变化情况: { dataList: [], titleList: ['key', 'value'] }, //企业变化情况
// 企业变化情况变化趋势: [], //企业变化情况——变化趋势
// 金融服务: { dataList: [], titleList: ['key', 'value'] }, //金融服务
// 本月融资企业: [], //本月融资企业
// 本月融资金额: [], //本月融资金额
// 在孵企业总营收: { dataList: [], titleList: ['key', 'value'] }, //在孵企业总营收
// 金融服务企业: { bodyList: [], headerList: [['企业名称', '融资金额(万元)', '融资时间']] }, //金融服务企业 todo
// 知识产权: { dataList: [], titleList: ['key', 'value'] }, //知识产权
// 知识产权饼图: { dataList: [], titleList: ['key', 'value'] }, //知识产权饼图
// 知识产权详情: { bodyList: [], headerList: [['企业名称', '知识产权数']] }, //知识产权详情 todo
// 企业资质分类: { dataList: [], titleList: ['key', 'value'] }, //企业资质分类
// 企业资质分类_小巨人: { bodyList: [], headerList: [['企业名称', '资质类型']] }, //企业资质分类_小巨人
// 企业资质分类_高新企业: { bodyList: [], headerList: [['企业名称', '资质类型']] }, //企业资质分类_高新企业
// 企业资质分类_专精特新: { bodyList: [], headerList: [['企业名称', '资质类型']] }, //企业资质分类_专精特新
// 企业资质分类_小巨人培育: { bodyList: [], headerList: [['企业名称', '资质类型']] }, //企业资质分类_小巨人培育
} }
let nowTime = new Date().valueOf(); let nowTime = new Date().valueOf();
...@@ -72,8 +50,8 @@ export async function getEnterprise() { ...@@ -72,8 +50,8 @@ export async function getEnterprise() {
//获取所有企业孵化信息 //获取所有企业孵化信息
let fhdbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {}, fhColumn); let fhdbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {}, fhColumn);
//获取在孵企业 //获取在孵企业
// let 在孵dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {state: { "%between%": [FUHUASTATE.实体孵化, FUHUASTATE.虚拟孵化] }}, fhColumn); let 在孵dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {state: { "%between%": [FUHUASTATE.实体孵化, FUHUASTATE.虚拟孵化] }}, fhColumn);
let 在孵dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {state:{"%notIn%":FUHUASTATE.迁出} }, fhColumn); // let 在孵dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {state:{"%ne%":FUHUASTATE.迁出} }, fhColumn);
//获取毕业企业 //获取毕业企业
let 毕业dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, { "moveOutType": EMIGRATIONTYPE.毕业迁出 }, fhColumn); let 毕业dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, { "moveOutType": EMIGRATIONTYPE.毕业迁出 }, fhColumn);
...@@ -83,7 +61,7 @@ export async function getEnterprise() { ...@@ -83,7 +61,7 @@ export async function getEnterprise() {
//获取所有企业孵化表联查企业信息表 //获取所有企业孵化表联查企业信息表
let 孵化企业includeConf = {}; let 孵化企业includeConf = {};
let 孵化企业Clumn = ["enterpriseName", "industry"]; let 孵化企业Clumn = ["enterpriseName", "industry"];
孵化企业includeConf[TABLENAME.企业基础信息表] = { cloum: 孵化企业Clumn, where: {state: STATE.是} } 孵化企业includeConf[TABLENAME.企业基础信息表] = { cloum: 孵化企业Clumn, where: {} }
let 孵化企业dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业孵化信息, {}, fhColumn, 孵化企业includeConf); let 孵化企业dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业孵化信息, {}, fhColumn, 孵化企业includeConf);
let qyjbqk = { let qyjbqk = {
...@@ -134,7 +112,7 @@ export async function getEnterprise() { ...@@ -134,7 +112,7 @@ export async function getEnterprise() {
qyfw.入孵时长分布.dataList = getKeyValue(rfscfb); qyfw.入孵时长分布.dataList = getKeyValue(rfscfb);
//拟毕业企业情况 //拟毕业企业情况
qyfw.拟毕业企业情况.count = nbyqyqk.count; qyfw.拟毕业企业情况.count = [{key:"即将到期企业数", value:nbyqyqk.count}];
qyfw.拟毕业企业情况.dataList.bodyList = nbyqyqk.dataList; qyfw.拟毕业企业情况.dataList.bodyList = nbyqyqk.dataList;
//入孵企业行业分布 //入孵企业行业分布
...@@ -147,133 +125,79 @@ export async function getEnterprise() { ...@@ -147,133 +125,79 @@ export async function getEnterprise() {
} }
} }
//企业服务汇总数据`
let 企业服务Count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业服务表, {}, null);
//获取所有企业服务表联查企业信息表 //获取所有企业服务表联查企业信息表
let qyfwColumn = ["esId", "eId", "needCategory", "needContent"];
let 企业服务includeConf = {}; let 企业服务includeConf = {};
企业服务includeConf[TABLENAME.企业基础信息表] = { cloum: ["enterpriseName"], where: {} } 企业服务includeConf[TABLENAME.企业基础信息表] = { cloum: ["enterpriseName"], where: {} }
let 企业服务dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业服务表, {}, qyfwColumn, 企业服务includeConf); let 企业服务dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业服务表, {}, [], 企业服务includeConf);
//企业需求服务
let { hzsj, qyxqfw, qyxqqk } = await getQyxqfw(企业服务dbList); let { hzsj, qyxqfw, qyxqqk, qyxqqkxq, xqclqk } = await getQyxqfw(企业服务dbList);
// let { hzsj, qyxqdt, qyxqdtxx } = await getQyxqdt(孵化企业dbList, 企业服务Count, 毕业dbList.length);
qyfw.企业服务汇总数据.dataList = getKeyValue(hzsj); qyfw.企业服务汇总数据.dataList = getKeyValue(hzsj);
qyfw.企业需求服务.count = [{key:"截止目前企业需求数", value:qyxqfw.count}];
qyfw.企业需求服务.dataList = getKeyValue(qyxqfw.dataList);
qyfw.企业需求情况.bodyList = qyxqqk;
qyfw.企业需求情况详细.bodyList = qyxqqkxq;
qyfw.需求处理情况.dataList = getKeyValue(xqclqk);
//入孵企业服务情况
let 已受理企业服务includeConf = {};
已受理企业服务includeConf[TABLENAME.企业基础信息表] = { cloum: ["enterpriseName"], where: {} }
let 已受理企业服务dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业服务表, {followUpStatus:{"%ne%":FOLLOWUPSTATUS.未受理}}, [], 已受理企业服务includeConf);
let { fwlx, rfqyfwqk } = await getRfqyfwqk(已受理企业服务dbList);
qyfw.服务类型.count = fwlx.count;
qyfw.服务类型.dataList = fwlx.dataList;
qyfw.入孵企业服务情况 = rfqyfwqk;
//企业需求动态 return qyfw;
// qyfw.企业需求服务.dataList = getKeyValue(qyxqdt); }
// //企业需求动态详细 上面3中汇总数据类型的所有企业列表，由于毕业认证企业取不到数据，只汇总入孵申请和企业需求数的企业列表
// qyfw.企业需求情况详细.bodyList = qyxqdtxx;
// //变化趋势分析 //todo 需要日志表
// // getBhqsfx(fhdbList);
// let 在孵企业变化趋势 = getZfqy(在孵企业变化趋势map, 毕业dbList);
// qyfw.变化趋势分析 = getChart(在孵企业变化趋势);
// //入孵时长分布
// let rfscfb = getRfscfx(fhdbList);
// qyfw.入孵时长分布.dataList = getKeyValue(rfscfb);
// for (let key in INDUSTRY) {
// let anyKey: any = key;
// if (isNaN(anyKey)) {
// let keyStr = key;
// qyfw.孵化企业行业领域占比.dataList.push({ key: keyStr, value: industryMap[keyStr] });
// }
// }
// //企业需求动态
// let 入孵申请dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业基础信息表, { state: STATE.是 }, null);
// let 企业服务Count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业服务表, {}, null);
// let { qyxqdt, qyxqdtxx } = await getQyxqdt(入孵申请dbList, 企业服务Count, 毕业dbList.length);
// qyfw.企业需求动态.dataList = getKeyValue(qyxqdt);
// //企业需求动态详细 上面3中汇总数据类型的所有企业列表，由于毕业认证企业取不到数据，只汇总入孵申请和企业需求数的企业列表
// qyfw.企业需求动态详细.bodyList = qyxqdtxx;
// //企业变化情况
// let qybhqk = getQybhqk(在孵dbList, 迁出dbList);
// qyfw.企业变化情况.dataList = getKeyValue(qybhqk);
export async function get入孵企业数量变化趋势(type, time, state) {
// //企业变化情况——变化趋势 let fuHuaParam:any = {state:{"%ne%":0}};
// let hbqs = []; if (state == "迁入") {
// for (let key in 在孵企业变化趋势map) { fuHuaParam = {state:{"%between%": [2, 3]}};
// hbqs.push({ key, value: 在孵企业变化趋势map[key] }); } else if(state == "迁出") {
// } fuHuaParam = {state:4};
// hbqs.sort((a, b) => { return parseInt(a.key) - parseInt(b.key) }); }
// qyfw.企业变化情况变化趋势 = getChart({"企业数": hbqs});
// let 企业融资dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业融资, {}, null); let fhColumn = ["fId", "eId", "startTime", "endTime", "state", "virtualCause", "virtualCauseDes", "moveOutType",
// //金融服务 "moveOutTrace", "moveOutCause", "moveOutTime", "graduationTime", ];
// let jrfw = await getJrfw(在孵dbList, 企业融资dbList); //获取所有企业孵化表联查企业信息表
// qyfw.金融服务.dataList = getKeyValue(jrfw); let 孵化企业includeConf = {};
let 孵化企业Clumn = ["enterpriseName", "industry"];
孵化企业includeConf[TABLENAME.企业基础信息表] = { cloum: 孵化企业Clumn, where: {} }
let 孵化企业dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业孵化信息, fuHuaParam, fhColumn, 孵化企业includeConf);
// //本月融资企业 let rfqyslbhqs = { bodyList: [], headerList: [['时间', '企业名称', '企业类型', '状态']] };
// let byrzqy = await getByrzqy(企业融资dbList);
// qyfw.本月融资企业 = byrzqy.byrzqybhqs;
// //本月融资金额 孵化企业dbList.forEach(info => {
// qyfw.本月融资金额 = byrzqy.byrzjebhqs; // 检查入孵开始时间的月份是否与当前月份相同
let enterpriseName = info.enterprise.enterpriseName;
let industry = changeEnumValue(INDUSTRY, info.enterprise.industry) || "-";
let qianruqianchu = ""; //迁入、迁出类型
let parsedTime:any = "";
let paramTime:any = "";
// //在孵企业总营收 if (info.state == FUHUASTATE.迁出) {
// let zfqyzys = await getZfqyzys(); qianruqianchu = "迁出";
// qyfw.在孵企业总营收.dataList = getKeyValue(zfqyzys); paramTime = moment(info.moveOutTime); // 获取迁出时间
} else {
qianruqianchu = "迁入";
paramTime = moment(info.startTime); // 获取入孵开始时间
}
if (type == "年") parsedTime = paramTime.year().toString();
if (type == "月") parsedTime = moment(paramTime).format("YY/MM");
// //金融服务企业 if (parsedTime == time) {
// let rzqylcColumn = ["rId", "eId", "financingAmount", "financingRounds", "fuHuaQiInvestment", "fuHuaQiInvestmentStyle", "fuHuaQiInvestmentAmount", rfqyslbhqs.bodyList.push([moment(paramTime).format("YYYY-MM-DD"), enterpriseName, industry, qianruqianchu])
// "investmentDate", "investmentInstitutionsName", "valuation"]; }
// let 融资企业联查includeConf = {}; })
// let 融资企业联查Clumn = ["enterpriseName"];
// 融资企业联查includeConf[TABLENAME.企业基础信息表] = { cloum: 融资企业联查Clumn, where: {} }
// let 融资企业联查dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业融资, {}, rzqylcColumn, 融资企业联查includeConf);
// let jrfwqy = getJrfwqy(融资企业联查dbList);
// qyfw.金融服务企业.bodyList = jrfwqy;
// //知识产权 return rfqyslbhqs;
// // let 企业专利dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业专利表, {}, null); }
// let 企业专利dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.知识产权, {}, null);
// let { zscqbt } = getZscq(企业专利dbList);
// // qyfw.知识产权.dataList = getKeyValue(zscq);
// qyfw.知识产权饼图.dataList = getKeyValue(zscqbt);
// //知识产权详情 专利数据和服务数据没法保持一致，不知道要怎么样实现在一个表格展现 todo
// let 专利Column = ["eId", "year", "alienPatent", "classIPatent", "secondClassPatent", "thirdPentent"];
// let 知识产权联查includeConf = {};
// // 知识产权联查includeConf[TABLENAME.企业专利表] = {cloum:专利Column, where:{}}
// 知识产权联查includeConf[TABLENAME.知识产权] = { cloum: ["number"], where: {} }
// let 知识产权详情dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {}, ["enterpriseName"], 知识产权联查includeConf);
// let zscqxq = await getZscqxq(知识产权详情dbList);
// qyfw.知识产权详情.bodyList = zscqxq;
// //企业资质分类
// let 资质Column = ["qId", "eId", "kxTime", "zjtxTime", "xjrTime", "xjrPyTime", "goPublicTime", "gaoXinJiShuTime", "goPublicSector"];
// let 企业资质联查includeConf = {};
// 企业资质联查includeConf[TABLENAME.企业资质] = { cloum: 资质Column, where: {} }
// let 企业资质dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {}, [], 企业资质联查includeConf);
// let { qyzzfl, qyzzflTable } = getQyzzfl(企业资质dbList);
// qyfw.企业资质分类.dataList = getKeyValue(qyzzfl);
// qyfw.企业资质分类_小巨人.bodyList = qyzzflTable.小巨人;
// qyfw.企业资质分类_高新企业.bodyList = qyzzflTable.高新企业;
// qyfw.企业资质分类_专精特新.bodyList = qyzzflTable.专精特新;
// qyfw.企业资质分类_小巨人培育.bodyList = qyzzflTable.小巨人培育;
// let 企业人才就业人数 = await getQyrc();
// qyfw.企业人才 = getChart(企业人才就业人数);
return qyfw;
}
export async function getEnterpriseDetails(name, type) { export async function getEnterpriseDetails(name, type) {
...@@ -309,6 +233,12 @@ export async function getEnterpriseDetails(name, type) { ...@@ -309,6 +233,12 @@ export async function getEnterpriseDetails(name, type) {
} }
/**
* 入孵企业数量变化趋势
* @param 在孵dbList
* @param 迁出dbList
* @returns
*/
function getRfqyslbhqsMonth(在孵dbList, 迁出dbList) { function getRfqyslbhqsMonth(在孵dbList, 迁出dbList) {
let year = getYearList(); let year = getYearList();
let month = getMonthList(); let month = getMonthList();
...@@ -405,544 +335,126 @@ function getRfqyslbhqsMonth(在孵dbList, 迁出dbList) { ...@@ -405,544 +335,126 @@ function getRfqyslbhqsMonth(在孵dbList, 迁出dbList) {
* @param 企业服务dbList * @param 企业服务dbList
*/ */
async function getQyxqfw(企业服务dbList) { async function getQyxqfw(企业服务dbList) {
//对企业eId进行去重
let uniqueEid = [...new Map(企业服务dbList.map(item => [item.eId, item])).values()];
let needCategoryEnumLength = Object.keys(NEEDCATEGORY).filter(key => isNaN(Number(key))).length; // 过滤掉数字键（反向映射）
//汇总数据 //汇总数据
let hzsj = { let hzsj = {
服务企业: 0, 服务企业: uniqueEid.length,
服务内容: "7项", 服务内容: needCategoryEnumLength + "项",
服务数量:0 服务数量:企业服务dbList.length
}; };
//对企业eId进行去重
let uniqueEid = [...new Map(企业服务dbList.map(item => [item.eId, item])).values()];
hzsj.服务企业 = uniqueEid.length;
hzsj.服务数量 = 企业服务dbList.length;
//企业需求服务 //企业需求服务
let qyxqfw = { let qyxqfw = {
count:0, count: 企业服务dbList.length,
dataList:[] dataList:[]
}; };
let month = getMonthList();
//企业需求情况 for(let i = 0; i < month.length; i++) {
let qyxqqk = []; let fuwuMonth = 0;
企业服务dbList.forEach(info => {
企业服务dbList.forEach( item => { // 检查企业申请时间的月份是否与当前月份相同
let parsedStartTime = moment(info.applyTime); // 获取企业申请时间
}) if (parsedStartTime.isValid() && moment(parsedStartTime).format("YY/MM") === month[i]) {
fuwuMonth += 1;
return { hzsj, qyxqfw, qyxqqk };
}
/**
* 企业需求动态
*/
async function getQyxqdt(入孵申请dbList, 企业服务Count, 毕业企业数) {
let hzsj = {
服务企业: 0,
服务内容: 0,
服务数量:0
}
let qyxqdt = {
入孵申请: 0,
毕业认证企业: 0,
企业需求数: 0
} }
qyxqdt.入孵申请 = 入孵申请dbList.length;
qyxqdt.企业需求数 = 企业服务Count;
qyxqdt.毕业认证企业 = 毕业企业数;
let qyxqdtxx = [];
入孵申请dbList.forEach(info => {
// qyxqdtxx.push([info.enterpriseName, "入孵申请", info.eId]);
qyxqdtxx.push([info.enterpriseName]);
}) })
// 企业服务dbList.forEach(info => {
// // qyxqdtxx.push([info.enterprise.enterpriseName, "企业需求", info.enterprise.eId]);
// qyxqdtxx.push([info.enterprise.enterpriseName]);
// })
return { hzsj, qyxqdt, qyxqdtxx };
}
qyxqfw.dataList.push({key:month[i], value:fuwuMonth});
/**
* 变化趋势分析
* @param data
*/
function getBhqsfx(data) {
let bhqsfx = {
"在孵": [],
"毕业": []
} }
//todo 变化趋势分析 需要日志表 //企业需求情况
bhqsfx["在孵"] = [ let qyxqqk = [];
{ key: "2019", value: 4 }, //企业需求情况详情
{ key: "2020", value: 4 }, let qyxqqkxq = [];
]; //需求处理情况
bhqsfx["毕业"] = [ let xqclqk = {
{ key: "2019", value: 4 }, 已完成:0,
{ key: "2020", value: 4 }, 受理中:0,
]; 未受理:0
data.forEach(item => {
})
}
function getZfqy(在孵企业变化趋势map, 毕业dbList) {
let year = getYearList();
let bhqsfx = {
"在孵": [],
"毕业": []
};
let moveOutMap = {}
毕业dbList.forEach(info => {
let moveOutTimeYear = moment(info.moveOutTime).year(); // 获取入孵开始时间
if (!moveOutMap[moveOutTimeYear]) moveOutMap[moveOutTimeYear] = 0;
moveOutMap[moveOutTimeYear] += 1;
});
year.forEach(year => {
bhqsfx.在孵.push({key:year, value:在孵企业变化趋势map[year] || 0});
bhqsfx.毕业.push({key:year, value:moveOutMap[year] || 0});
});
return bhqsfx;
}
/**
* 企业服务汇总数据
* @param data
*/
async function getQyfwhzsj() {
let qyfwhzsj = {
"企业总营收额": 0,
"企业纳税": 0,
"融资企业": "",
"企业专利": 0,
};
let 经营信息dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, {}, null);
经营信息dbList.forEach(info => {
qyfwhzsj.企业总营收额 += parseFloat(info.BI);
qyfwhzsj.企业纳税 += parseFloat(info.TXP);
})
let 企业融资dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业融资, {}, null);
let distinctMap = {};
企业融资dbList.forEach(info => {
let {eId} = info;
distinctMap[eId] = 1;
})
let 企业专利dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.知识产权, {}, null);
企业专利dbList.forEach(info => {
qyfwhzsj.企业专利 += parseInt(info.number || 0);
})
return {
"企业总营收额": `${qyfwhzsj.企业总营收额}万`, // 添加带单位的字段
"企业纳税": `${qyfwhzsj.企业纳税}万` ,// 添加带单位的字段
"融资企业": `${Object.keys(distinctMap).length}家`,
"企业专利": `${qyfwhzsj.企业专利}个` // 添加带单位的字段
}; };
}
/** 企业服务dbList.forEach( info => {
* 企业变化情况 let {enterprise} = info;
* @param data let enterpriseName = enterprise.enterpriseName;
*/ let applyTime = moment(info.applyTime).format("YYYY-MM-DD");
// function getQybhqk(data) { let needCategory = changeEnumValue(NEEDCATEGORY, info.needCategory);
// let qybhqk = { let followUpStatus = changeEnumValue(FOLLOWUPSTATUS, info.followUpStatus);
// 新增企业: 0, //统计当前年份入孵企业 qyxqqk.push([enterpriseName, applyTime, needCategory])
// 迁出企业: 0 qyxqqkxq.push([applyTime, enterpriseName, needCategory, info.needContent, followUpStatus]);
// }
if (info.followUpStatus == FOLLOWUPSTATUS.已完成) xqclqk.已完成 += 1;
// let nowTime = moment(); if (info.followUpStatus == FOLLOWUPSTATUS.受理中) xqclqk.受理中 += 1;
// data.forEach(info => { if (info.followUpStatus == FOLLOWUPSTATUS.未受理) xqclqk.未受理 += 1;
// let parsedStartTime = moment(info.startTime); //获取入孵开始时间
// // 检查日期字段的年份是否与当前年份相同
// if (parsedStartTime.isValid() && parsedStartTime.year() === nowTime.year()) {
// qybhqk.新增企业 += 1;
// }
// })
// return qybhqk;
// }
function getQybhqk(在孵dbList, 迁出dbList) {
let qybhqk = {
新增企业: 0, // 统计当前年份入孵企业
迁出企业: 0 // 统计当前年份迁出企业
}
let nowTime = moment();
在孵dbList.forEach(info => {
let parsedStartTime = moment(info.startTime); // 获取入孵开始时间
let parsedMoveOutTime = moment(info.moveOutTime); // 获取迁出时间
// 检查入孵开始时间的年份是否与当前年份相同
if (parsedStartTime.isValid() && parsedStartTime.year() === nowTime.year()) {
qybhqk.新增企业 += 1;
}
// 检查迁出时间的年份是否与当前年份相同
// if (parsedMoveOutTime.isValid() && parsedMoveOutTime.year() === nowTime.year()) {
// qybhqk.迁出企业 += 1;
// }
})
迁出dbList.forEach(info => {
let parsedMoveOutTime = moment(info.moveOutTime); // 获取迁出时间
// 检查迁出时间的年份是否与当前年份相同
if (parsedMoveOutTime.isValid() && parsedMoveOutTime.year() === nowTime.year()) {
qybhqk.迁出企业 += 1;
}
}) })
return { hzsj, qyxqfw, qyxqqk, qyxqqkxq, xqclqk };
return qybhqk;
} }
/** /**
* 企业变化情况——变化趋势 * 入孵企业服务情况
* @param 入孵企业服务dbList
*/ */
function getQybhqkbhqs(data) { async function getRfqyfwqk(已受理企业服务dbList) {
let year = getYearList(); let needCategoryEnumLength = Object.keys(NEEDCATEGORY).filter(key => isNaN(Number(key))).length; // 过滤掉数字键（反向映射）
let hbqs = {
"企业数": [] let fuWuQiYeTypeMap = {};//企业服务类型
} let fwxx = {};
for (let i = 0; i < year.length; i++) { 已受理企业服务dbList.forEach( info => {
let count = 0; let needCategoryStr = changeEnumValue(NEEDCATEGORY, info.needCategory)
data.forEach(info => { if (!fuWuQiYeTypeMap[needCategoryStr]) {
let startTimeYear = moment(info.startTime).year(); //获取入孵开始时间 fuWuQiYeTypeMap[needCategoryStr] = 0;
let thisYear = parseInt(year[i]); fwxx[needCategoryStr] = [];
if (startTimeYear === thisYear) count += 1; }
fuWuQiYeTypeMap[needCategoryStr] += 1;
fwxx[needCategoryStr].push(info);
}) })
hbqs.企业数.push({ key: year[i], value: count });
}
let qybhqkbhqs = getChart(hbqs);
return qybhqkbhqs;
}
/** let fwlx = { count:[{key:"服务类型", value:needCategoryEnumLength}], dataList:[{key:"全部", value:已受理企业服务dbList.length}] };
* 金融服务 for (let key in NEEDCATEGORY) {
*/ let enumValue = NEEDCATEGORY[key];
async function getJrfw(data, 企业融资dbList) { // 跳过未显式赋值的枚举成员（如果有的话，它们默认为枚举前一个成员的值加1）
let jrfw = { if (isNaN(Number(key))) { // 这里检查 key 是否可以被转换为数字，以识别枚举成员名称
本月融资企业: 0, let needCategoryStr = changeEnumValue(NEEDCATEGORY, enumValue);
本月融资金额: 0, let value = fuWuQiYeTypeMap[needCategoryStr] || 0;
在孵企业总营收: 0 fwlx.dataList.push({
key: needCategoryStr,
value: value
});
} }
let nowTime = moment();
企业融资dbList.forEach(info => {
let parsedTime = moment(info.investmentDate).format("YY/MM"); //获取融资时间
if (parsedTime === moment(nowTime).format("YY/MM")) {
jrfw.本月融资企业 += 1;
jrfw.本月融资金额 += parseFloat(info.financingAmount);
} }
})
// jrfw.本月融资金额 = Math.round((jrfw.本月融资金额 / 100000000) * 100) / 100; //单位换算成万亿
jrfw.本月融资金额 = Math.round((jrfw.本月融资金额) * 100) / 100; //单位换算成万亿
let 经营信息dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, {}, null);
经营信息dbList.forEach(info => {
jrfw.在孵企业总营收 += parseFloat(info.BI);
})
return jrfw;
}
/**
* 本月融资企业
* @param data
* @returns
*/
async function getByrzqy(企业融资dbList) {
/**获取距离当前时间的前6个月 */
let month = getMonthList(); let month = getMonthList();
let rfqyfwqk = {};
let byrzqy = { for (let key in fwxx) {
"融资企业": [] if (!rfqyfwqk[key]) rfqyfwqk[key] = {dataList:[], tableData:{ bodyList: [], headerList: [['服务企业名称', '服务时间', "负责人", "服务状态"]]}};
} for(let i = 0; i < month.length; i++) {
let byrzje = { let fuwuMonth = 0;
"融资金额": [] fwxx[key].forEach(info => {
} // 检查受理时间的月份是否与当前月份相同
for (let i = 0; i < month.length; i++) { let parsedStartTime = moment(info.shouLiTime); // 获取受理时间
let 企业count = 0; if (parsedStartTime.isValid() && moment(parsedStartTime).format("YY/MM") === month[i]) {
let 金额count = 0; fuwuMonth += 1;
企业融资dbList.forEach(info => {
let parsedTime = moment(info.investmentDate).format("YY/MM"); //获取融资时间
if (parsedTime === month[i]) {
企业count += 1;
金额count += parseFloat(info.financingAmount);
}
})
// 金额count = 金额count / 100000000; //单位换算成万亿
byrzqy["融资企业"].push({ key: month[i], value: 企业count });
byrzje["融资金额"].push({ key: month[i], value: 金额count });
}
let byrzqybhqs = getChart(byrzqy);
let byrzjebhqs = getChart(byrzje);
return { byrzqybhqs, byrzjebhqs };
}
/**
* 在孵企业总营收
*/
async function getZfqyzys() {
let zfqyzys = {
"500万以下": 0,
"500万-1000万": 0,
"1000万-2000万": 0,
"2000万以上": 0
} }
let 经营信息dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, {}, null);
经营信息dbList.forEach(info => { //BI（单位万元）
let BI = parseInt(info.BI || "0");
if ( BI< 500) zfqyzys["500万以下"] += 1;
else if (BI >= 500 && BI < 1000) zfqyzys["500万-1000万"] += 1;
else if (BI >= 1000 && BI < 2000) zfqyzys["1000万-2000万"] += 1;
else zfqyzys["2000万以上"] += 1;
}) })
rfqyfwqk[key].dataList.push({key:month[i], value:fuwuMonth});
return zfqyzys
}
/**
* 金融服务企业
* @param data
*/
function getJrfwqy(data) {
let jrfwqy = [];
data.forEach(info => {
let { financingAmount, enterprise, investmentDate } = info;
let thisTime = moment(investmentDate).format("YYYY-MM-DD");
jrfwqy.push([enterprise.enterpriseName, financingAmount, thisTime]);
})
return jrfwqy;
}
/**
* 知识产权-------设计图有改动todo
*/
function getZscq(data) {
let zscqbt = {
// 软件著作: 0,
软件著作权: 0,
发明专利: 0,
海外专利: 0,
其他: 0
// 植物新品种: 0,
// 集成电路布图: 0
} }
data.forEach(info => { let rffwqk = [];
switch (info.iprType) { fwxx[key].forEach(info => {
case IPRALLTYPE.软件著作权: let {enterprise} = info;
zscqbt.软件著作权 += info.number; let enterpriseName = enterprise.enterpriseName;
break; let shouLiTime = moment(info.shouLiTime).format("YYYY-MM-DD");
case IPRALLTYPE.发明专利: let followUpStatus = changeEnumValue(FOLLOWUPSTATUS, info.followUpStatus);
zscqbt.发明专利 += info.number; rffwqk.push([enterpriseName, shouLiTime, "赵老师", followUpStatus]);
break;
case IPRALLTYPE.海外专利:
zscqbt.海外专利 += info.number;
break;
case IPRALLTYPE.植物新品种:
case IPRALLTYPE.集成电路布图:
zscqbt.其他 += info.number;
break;
}
}) })
rfqyfwqk[key].tableData.bodyList = rffwqk;
return { zscqbt };
}
/**
* 知识产权详情
*/
// function getZscqxq(data) {
// let dataList = [];
// data.forEach( info => {
// let {enterprise_patents, enterprise_iprs, enterpriseName} = info;
// let patentsCount = 0;
// let iprsCount = 0;
// enterprise_patents.forEach(item => {
// if(item.alienPatent) patentsCount += item.alienPatent;
// if(item.classIPatent) patentsCount += item.classIPatent;
// if(item.secondClassPatent) patentsCount += item.secondClassPatent;
// if(item.thirdPentent) patentsCount += item.thirdPentent;
// });
// enterprise_iprs.forEach(item => {
// if(item.number) iprsCount += item.number;
// });
// dataList.push([enterpriseName, patentsCount, iprsCount]);
// });
// return dataList;
// }
function getZscqxq(data) {
let dataList = [];
data.forEach(info => {
let { enterprise_iprs, enterpriseName } = info;
let iprsCount = 0;
enterprise_iprs.forEach(item => {
let {number} = item;
iprsCount += parseInt(number);
});
dataList.push([enterpriseName, iprsCount]);
});
return dataList;
}
/**
* 企业资质分类
*/
function getQyzzfl(data) {
let qyzzfl = {
专精特新: 0,
小巨人: 0,
高新企业: 0,
小巨人培育: 0,
}
let qyzzflTable = {
专精特新: [],
小巨人: [],
高新企业: [],
小巨人培育: [],
};
data.forEach(info => {
let { enterprise_qualifications } = info;
enterprise_qualifications.forEach(item => {
if (item.xjrTime) {
qyzzfl.小巨人 += 1;
qyzzflTable.小巨人.push([info.enterpriseName, "小巨人"]);
} }
else if (item.gaoXinJiShuTime) {
qyzzfl.高新企业 += 1;
qyzzflTable.高新企业.push([info.enterpriseName, "高新企业"]);
}
else if (item.zjtxTime) {
qyzzfl.专精特新 += 1;
qyzzflTable.专精特新.push([info.enterpriseName, "专精特新"]);
}
else if (item.xjrPyTime) {
qyzzfl.小巨人培育 += 1;
qyzzflTable.小巨人培育.push([info.enterpriseName, "小巨人培育"]);
}
})
})
return { qyzzfl, qyzzflTable }
}
return { fwlx, rfqyfwqk }
/**
* 企业人才--创业团队分布todo
*/
async function getQyrc() {
// let year = getYearList();
let qyrc = {
"就业人数": [],
// "创业团队分布": []
}
//就业
let jiuYeList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.参保记录, {}, null);
let 年度就业人数趋势分析Map = {};
jiuYeList.forEach(info => {
let { eId, annual } = info;
let itemCount = 0;
let itemYear = new Date(annual).getFullYear();
if (info.zhuanKe) itemCount += parseInt(info.zhuanKe);
if (info.benKe) itemCount += parseInt(info.benKe);
if (info.shuoshi) itemCount += parseInt(info.shuoshi);
if (info.boShi) itemCount += parseInt(info.boShi);
if (info.boshiyishang) itemCount += parseInt(info.boshiyishang);
if (info.qiTa) itemCount += parseInt(info.qiTa);
if (!年度就业人数趋势分析Map[itemYear]) 年度就业人数趋势分析Map[itemYear] = { key: itemYear, value: 0 };
年度就业人数趋势分析Map[itemYear].value += itemCount;
});
let 年度就业人数趋势分析 = Object.values(年度就业人数趋势分析Map);
qyrc["就业人数"] = 年度就业人数趋势分析;
//创业团队分布
// let qyrcList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.创业团队, {}, null);
// qyrcList.forEach(info => {
// let { eId, name, sex, birth, degree, graduationSchool, talentType, des } = info;
// qyrc["创业团队分布"].push({
// eId,
// name,
// sex,
// birth,
// degree,
// graduationSchool,
// talentType,
// des,
// });
// });
// // 统计每年的创业团队数量 学历
// let 年度创业团队趋势分析Map = {};
// qyrcList.forEach(info => {
// let birthYear = new Date(info.birth).getFullYear();
// if (!年度创业团队趋势分析Map[birthYear]) 年度创业团队趋势分析Map[birthYear] = { key: birthYear, value: 0 };
// 年度创业团队趋势分析Map[birthYear].value += 1;
// });
// // let 年度创业团队趋势分析 = Object.values(年度创业团队趋势分析Map);
// let 年度创业团队趋势分析 = Object.values(年度创业团队趋势分析Map) as { key: number; value: number }[];
// 年度创业团队趋势分析.sort((a, b) => a.key - b.key);
// qyrc["创业团队分布"] = 年度创业团队趋势分析;
return qyrc;
} }
......
src/data/db/zhyy.ts
...@@ -82,15 +82,10 @@ async function calculateRevenue(start: string, end: string) { ...@@ -82,15 +82,10 @@ async function calculateRevenue(start: string, end: string) {
export async function getZhyy() { export async function getZhyy() {
let zhyy = { let zhyy = {
孵化器概况:[ 孵化器概况:[],
{key:"孵化器总面积", value:"27844㎡"},
{key:"注册时间", value:"2013"},
{key:"孵化器级别", value:"市级"},
{key:"出租率", value:"95%"}
],
在孵企业面积占比:[{key:"在孵企业面积占比", value:"82%"}], 在孵企业面积占比:[{key:"在孵企业面积占比", value:"82%"}],
孵化运营:{ 孵化运营:{
count:[{key:"在孵企业", value:"82%"}], count:[{key:"在孵企业", value:"102家"}],
dataList:[ dataList:[
{key:"2019", value:"36"}, {key:"2020", value:"36"}, {key:"2021", value:"36"}, {key:"2019", value:"36"}, {key:"2020", value:"36"}, {key:"2021", value:"36"},
{key:"2022", value:"36"}, {key:"2023", value:"36"}, {key:"2024", value:"36"} {key:"2022", value:"36"}, {key:"2023", value:"36"}, {key:"2024", value:"36"}
...@@ -179,459 +174,44 @@ export async function getZhyy() { ...@@ -179,459 +174,44 @@ export async function getZhyy() {
] ]
} }
return zhyy; let 雨艺孵化器dbList = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.羽翼孵化器, {}, []);
let fhqgk = [
{key:"孵化器总面积", value:雨艺孵化器dbList.totalArea},
{key:"注册时间", value:雨艺孵化器dbList.registerTime},
{key:"孵化器级别", value:雨艺孵化器dbList.incubateLv},
{key:"出租率", value:雨艺孵化器dbList.rentRate},
];
zhyy.孵化器概况 = fhqgk;
//获取所有企业孵化信息
let fhColumn = ["industry", "eId"];
let manyTableInfo: any = {}
manyTableInfo[TABLENAME.企业孵化信息] = { column: ["fId", "eId", "startTime", "endTime", "state"], where: {} };
manyTableInfo[TABLENAME.租赁信息] = { column: ["area", "startTime", "endTime"], where: {} };
let fhdbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {state:1}, fhColumn, manyTableInfo);
let 在孵dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {state:{"%ne%":0}}, ["fId", "eId", "startTime", "endTime", "state", "virtualCause",
"virtualCauseDes", "moveOutType", "moveOutTrace", "moveOutCause", "moveOutTime", "graduationTime"]);
//入驻企业变化趋势
let industryMap = {};//行业领域
let ruZhuMap = {};//入驻企业变化趋势
let ruZhuCount = 在孵dbList.length;//入驻数
let areaCount = 0;//在孵企业总面积
let 面积变化Map = {};//孵化面积变化
let thisYear = new Date().getFullYear();
let firstDayMsOfMonth = moment().startOf('month').valueOf();
let checlTimeMs = moment(firstDayMsOfMonth).subtract(8, 'months').valueOf();
let 在孵企业变化趋势map = {};
let 在孵企业数量 = 0;
fhdbList.forEach(info => {
let { industry, enterprise_fuhuas, enterprise_leases } = info;
let startTime = enterprise_fuhuas[0].startTime;
if (!startTime) return;
let startTimeMs = new Date(startTime).valueOf();
if (startTimeMs >= checlTimeMs) {
let timeStr = moment(startTime).format("YY/MM");
if (!ruZhuMap[timeStr]) ruZhuMap[timeStr] = 0;
ruZhuMap[timeStr] += 1;
}
//行业领域分布
if (industry) {
let industryStr = changeEnumValue(INDUSTRY, JSON.parse(industry)[0]);
if (!industryMap[industryStr]) industryMap[industryStr] = 0;
industryMap[industryStr] += 1;
}
let area = enterprise_leases[0].area || 0;
if (area) {
areaCount += parseFloat(area);//租赁面积累加
if (enterprise_leases[0].startTime && enterprise_leases[0].endTime) {
let leasesYearList = getStartAndEndTimeYearList(enterprise_leases[0].startTime, enterprise_leases[0].endTime);
leasesYearList.forEach(itemYear => {
if (itemYear > thisYear) return;
if (!面积变化Map[itemYear]) 面积变化Map[itemYear] = { key: itemYear, value: 0 };
面积变化Map[itemYear].value += parseFloat(area);
if (!在孵企业变化趋势map[itemYear]) 在孵企业变化趋势map[itemYear] = 0;
在孵企业变化趋势map[itemYear] += 1;
});
}
}
if (enterprise_fuhuas[0].state == FUHUASTATE.实体孵化 || enterprise_fuhuas[0].state == FUHUASTATE.虚拟孵化) 在孵企业数量 += 1;
});
/**
*入驻统计
*/
//到期退组和违约退组
let wytzCount = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业孵化信息, { state: FUHUASTATE.迁出, moveOutType: EMIGRATIONTYPE.违约退租 }, null);
let dqtzCount = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业孵化信息, { state: FUHUASTATE.迁出, moveOutType: EMIGRATIONTYPE.到期退租 }, null);
let 入驻企业变化趋势 = [];
for (let i = 6; i >= 0; i-- ) {
let key = moment().subtract(i, 'M').format('YY/MM');
入驻企业变化趋势.push({ key, value: ruZhuMap[key] || 0 });
}
let 在孵企业变化趋势 = [];
for (let key in 在孵企业变化趋势map) {
在孵企业变化趋势.push({ key, value: 在孵企业变化趋势map[key] });
}
在孵企业变化趋势.sort((a, b) => { return parseInt(a.key) - parseInt(b.key) });
/**
* 孵化运营——毕业企业数量
*/
let biYeOutCount = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业孵化信息, { state: FUHUASTATE.迁出, moveOutType: EMIGRATIONTYPE.毕业迁出 }, null);
let qianChuCount = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业孵化信息, { state: FUHUASTATE.迁出 }, null);
/**
* 毕业企业变化趋势todo——年
*/
// 获取当前年份
let currentYear = new Date().getFullYear();
// 计算近6年的起始年份
let startYear = currentYear - 5;
// 初始化毕业企业变化趋势map
let 毕业企业变化趋势map = {};
// 遍历近6年的每一年
for (let year = startYear; year <= currentYear; year++) {
毕业企业变化趋势map[year] = 0;
}
// 遍历在孵dbList，统计每年的毕业企业数量
在孵dbList.forEach(info => {
let moveOutType = info.moveOutType;
let moveOutTime = info.moveOutTime;
if (moveOutType === EMIGRATIONTYPE.毕业迁出 && moveOutTime) {
let moveOutYear = new Date(moveOutTime).getFullYear();
if (moveOutYear >= startYear && moveOutYear <= currentYear) {
毕业企业变化趋势map[moveOutYear]++;
}
}
});
// 将map转换为数组，并按年份排序
let 毕业企业变化趋势 = [];
for (let key in 毕业企业变化趋势map) {
毕业企业变化趋势.push({ key, value: 毕业企业变化趋势map[key] });
}
毕业企业变化趋势.sort((a, b) => parseInt(a.key) - parseInt(b.key));
let rongZiList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业融资, {}, null);
let rongZiMap = {};
let 融资企业变化趋势Map = {};
rongZiList.forEach(info => {
let { eId, investmentDate } = info;
if (!rongZiMap[eId]) rongZiMap[eId] = 0;
rongZiMap[eId] += 1;
let itemYear = new Date(investmentDate).getFullYear();
if (!融资企业变化趋势Map[itemYear]) 融资企业变化趋势Map[itemYear] = {};
融资企业变化趋势Map[itemYear][eId] = 1;
});
let rongZiQiYeCount = Object.keys(rongZiMap).length;
let 融资企业变化趋势 = [];
for (let key in 融资企业变化趋势Map) {
融资企业变化趋势.push({
key,
value: Object.keys(融资企业变化趋势Map[key]).length
});
}
/**
* 企业服务
*/
let fuWuCount = 0;//服务数
let fuWuQiYeCountMap = {};//服务覆盖企业
let fuWuQiYeTypeMap = {};//企业服务类型
let fuWuList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业服务表, {}, null);
fuWuList.forEach(info => {
let { followUpStatus, eId, needCategory } = info;
if (followUpStatus == FOLLOWUPSTATUS.已完成) {
fuWuCount += 1;
if (!fuWuQiYeCountMap[eId]) {
fuWuQiYeCountMap[eId] = 0;
}
fuWuQiYeCountMap[eId] += 1;
let needCategoryStr = changeEnumValue(NEEDCATEGORY, needCategory)
if (!fuWuQiYeTypeMap[needCategoryStr]) fuWuQiYeTypeMap[needCategoryStr] = 0;
fuWuQiYeTypeMap[needCategoryStr] += 1;
}
});
let fuWuQiYeCount = Object.keys(fuWuQiYeCountMap).length;//服务覆盖企业
// 计算服务覆盖企业占比
let fuWuQiYeCountPercentage = fuWuCount > 0 ? ((fuWuQiYeCount / fuWuCount) * 100).toFixed(2) : 0;
let fuWuQiYeTypeList = []; zhyy.在孵企业面积占比
for (let key in NEEDCATEGORY) {
let enumValue = NEEDCATEGORY[key];
// 跳过未显式赋值的枚举成员（如果有的话，它们默认为枚举前一个成员的值加1）
if (isNaN(Number(key))) { // 这里检查 key 是否可以被转换为数字，以识别枚举成员名称
let needCategoryStr = changeEnumValue(NEEDCATEGORY, enumValue);
let value = fuWuQiYeTypeMap[needCategoryStr] || 0;
fuWuQiYeTypeList.push({
key: needCategoryStr,
value: value
});
}
}
/**
* 荣誉资质统计
*/
let guojiaJiCount = 0;
let shengJiCount = 0;
let shiJiCount = 0;
let imgList = [];
let awardList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业荣誉, {}, null);
awardList.forEach(info => {
let { awardLevel, awardImg } = info;
// info.awardImg = `${systemConfig.imgPath}${JSON.parse(awardImg)[0]}`;
info.awardImg = `${systemConfig.imgFileUrl}${JSON.parse(awardImg)[0]}`;//imgFileUrl
imgList.push(info.awardImg);
if (awardLevel == AWARDLEVEL.国家级) {
guojiaJiCount += 1;
} else if (awardLevel == AWARDLEVEL.省级) {
shengJiCount += 1;
} else if (awardLevel == AWARDLEVEL.市级) {
shiJiCount += 1;
}
});
/** return zhyy;
* 企业自行填报，人员数量：从业人员填报数据总和todo }
*/
let canbaoList =
await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.参保记录, {}, null);
let totalEmployeeCount = 0;
canbaoList.forEach(info => {
let itemCount = 0;
if (info.zhuanKe) itemCount += parseInt(info.zhuanKe);
if (info.benKe) itemCount += parseInt(info.benKe);
if (info.shuoshi) itemCount += parseInt(info.shuoshi);
if (info.boShi) itemCount += parseInt(info.boShi);
if (info.boshiyishang) itemCount += parseInt(info.boshiyishang);
totalEmployeeCount += itemCount;
});
let 孵化器信息数据 = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.羽翼孵化器, {}, null); /**
/** * 孵化器概况
* 计算在孵企业面积占比：在孵企业总面积/孵化器或者园区总面积 x 100% * @param 雨艺孵化器dbList
*/ */
let zaifuAreaRatio = "0"; async function getFhqgk(雨艺孵化器dbList) {
if (!isNaN(孵化器信息数据.totalArea) && parseFloat(孵化器信息数据.totalArea) && areaCount) {
let zaifuAreaRatioNum = 100 * (areaCount / parseFloat(孵化器信息数据.totalArea));
zaifuAreaRatio = zaifuAreaRatioNum > 100 ? "100" : zaifuAreaRatioNum.toFixed(2);
}
let 园区概况 = [ }
{ key: "园区面积", value: `${孵化器信息数据.parkArea}㎡` },
{ key: "产值规模", value: `${孵化器信息数据.industrialScale}亿元` },
{ key: "企业数量", value: `${孵化器信息数据.enterpriseNum}家` },
{ key: "员工数量", value: `${totalEmployeeCount}人` },
];
let 在孵企业数据 = [
{ key: "在孵企业面积占比", value: `${zaifuAreaRatio}%` },
{ key: "入驻", value: `${ruZhuCount}家` },
{ key: "迁出", value: `${qianChuCount}家` },
{ key: "到期退租", value: `${dqtzCount}家` },
{ key: "违约退租", value: `${wytzCount}家` },
];
let 孵化运营 = [
{ key: "孵化面积", value: `${areaCount}㎡` },//企业自行填报
{ key: "在孵企业", value: `${在孵企业数量}家` },
{ key: "毕业企业", value: `${biYeOutCount}家` },
{ key: "融资企业", value: `${rongZiQiYeCount}家` },
];
let 智慧运营汇总数据 = [
{ key: "配套服务", value: `0项` },
{ key: "第三方供应商", value: `0家` },
{ key: "累计服务企业", value: `${fuWuQiYeCount}家` },
];
let 企业服务 = [
{ key: "服务数", value: fuWuCount },
{ key: "服务覆盖企业", value: `${fuWuQiYeCountPercentage}%` },
];
/**
* 改成企业上传todo
*/
let 荣誉资质 = [
{ key: "国家级", value: `${guojiaJiCount}项` },
{ key: "省级", value: `${shengJiCount}项` },
{ key: "市级", value: `${shiJiCount}项` },
];
/**
* 就业分析
*/
// 获取当前日期
// const currentYear = currentDate.getFullYear();
// 计算当前年份的开始时间和结束时间
const StartOfYear = new Date(`${currentYear}-01-01 00:00:00`).valueOf();
const EndOfYear = new Date(`${currentYear}-12-31 23:59:59`).valueOf();
// 计算去年的开始时间和结束时间
const StartOfLastYearYear = new Date(`${currentYear-1}-01-01 00:00:00`).valueOf();
const EndOfLastYearYear = new Date(`${currentYear-1}-12-31 23:59:59`).valueOf();
// 查询本年新增就业数据
let currentYearNewJobs = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.参保记录, { annual: { "%between%": [getMySqlMs(StartOfYear), getMySqlMs(EndOfYear)] } }, null);
// 查询去年同期新增就业数据
let lastYearMonthNewJobs = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.参保记录, { annual: { "%between%": [getMySqlMs(StartOfLastYearYear), getMySqlMs(EndOfLastYearYear)] } }, null);
// 计算本年新增就业人数
let currentYearJobCount = 0;
currentYearNewJobs.forEach(info => {
let itemCount = 0;
if (info.zhuanKe) itemCount += parseInt(info.zhuanKe);
if (info.benKe) itemCount += parseInt(info.benKe);
if (info.shuoshi) itemCount += parseInt(info.shuoshi);
if (info.boShi) itemCount += parseInt(info.boShi);
if (info.boshiyishang) itemCount += parseInt(info.boshiyishang);
if (info.qiTa) itemCount += parseInt(info.qiTa);
currentYearJobCount += itemCount;
});
// 计算去年同期新增就业人数
let lastYearYearJobCount = 0;
lastYearMonthNewJobs.forEach(info => {
let itemCount = 0;
if (info.zhuanKe) itemCount += parseInt(info.zhuanKe);
if (info.benKe) itemCount += parseInt(info.benKe);
if (info.shuoshi) itemCount += parseInt(info.shuoshi);
if (info.boShi) itemCount += parseInt(info.boShi);
if (info.boshiyishang) itemCount += parseInt(info.boshiyishang);
if (info.qiTa) itemCount += parseInt(info.qiTa);
lastYearYearJobCount += itemCount;
});
// 计算同比增长率
let growthRate = 0;
if (lastYearYearJobCount !== 0) {
growthRate = ((currentYearJobCount - lastYearYearJobCount) / lastYearYearJobCount) * 100;
}
/**
* 年度就业人数趋势分析
*/
let jiuYeList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.参保记录, {}, null);
let 年度就业人数趋势分析Map = {};
jiuYeList.forEach(info => {
let { eId, annual } = info;
let itemCount = 0;
let itemYear = new Date(annual).getFullYear();
if (info.zhuanKe) itemCount += parseInt(info.zhuanKe);
if (info.benKe) itemCount += parseInt(info.benKe);
if (info.shuoshi) itemCount += parseInt(info.shuoshi);
if (info.boShi) itemCount += parseInt(info.boShi);
if (info.boshiyishang) itemCount += parseInt(info.boshiyishang);
if (info.qiTa) itemCount += parseInt(info.qiTa);
if (!年度就业人数趋势分析Map[itemYear]) 年度就业人数趋势分析Map[itemYear] = { key: itemYear, value: 0 };
年度就业人数趋势分析Map[itemYear].value += itemCount;
});
let 年度就业人数趋势分析 = Object.values(年度就业人数趋势分析Map);
/**
* 产业规模分析
*/
let jingYingThisYear = moment().startOf("year").format("YYYY-MM-DD HH:mm:ss");
let jingYingList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, { annual: jingYingThisYear }, null);
let 产业规模企业Map = {};
jingYingList.forEach(info => {
let { BI, eId } = info;
if (!产业规模企业Map[eId]) 产业规模企业Map[eId] = 0;
产业规模企业Map[eId] += parseFloat(BI);
});
let 产业规模分析List = [
{ num: 400, key: "超400万", value: 0 },
{ num: 300, key: "300-400万", value: 0 },
{ num: 200, key: "200-300万", value: 0 },
{ num: 100, key: "100-200万", value: 0 },
{ num: 1, key: "<100万", value: 0 },
];
for (let key in 产业规模企业Map) {
let itemCount = 产业规模企业Map[key];
for (let i = 0; i < 产业规模分析List.length; i++) {
let { num } = 产业规模分析List[i];
if (itemCount > num) {
产业规模分析List[i].value += 1;
break;
}
}
}
let 在孵企业营收占比 = [];
产业规模分析List.forEach(info => {
let { key, value } = info;
在孵企业营收占比.push({ key, value });
})
// let zhyy = {
// 园区概况: { dataList: 园区概况, title: ["key", "value"] },
// 在孵企业数据: { dataList: 在孵企业数据, titleList: ['key', 'value'] },
// 融资企业变化趋势: [{ name: "融资企业变化趋势", data: 融资企业变化趋势 }],
// 入驻企业变化趋势: [{ name: "入驻企业变化趋势", data: 入驻企业变化趋势 }],
// 孵化面积变化趋势: [{ name: "孵化面积变化趋势", data: Object.values(面积变化Map) }],
// 在孵企业变化趋势: [{ name: "在孵企业变化趋势", data: 在孵企业变化趋势 }],
// 毕业企业变化趋势: [{ name: "毕业企业变化趋势", data: 毕业企业变化趋势 }],
// 入驻企业行业类型: { dataList: [], titleList: ['key', 'value'] },//行业领域
// 孵化运营: { dataList: 孵化运营, titleList: ['key', 'value'] },
// 智慧运营汇总数据: { dataList: 智慧运营汇总数据, titleList: ['key', 'value'] },
// // 企业服务: { dataList: 企业服务, titleList: ['key', 'value'] },
// // 企业服务类型: { dataList: fuWuQiYeTypeList, titleList: ['key', 'value'] },
// 荣誉资质: { dataList: 荣誉资质, titleList: ['key', 'value'] },
// // 荣誉资质图片: 荣誉资质图片,
// 就业分析: {
// dataList: [
// { key: "本年就业人数", value: `${currentYearJobCount}人` },
// { key: "同比去年", value: `${growthRate.toFixed(2)}%` }
// ], titleList: ['key', 'value']
// },
// 年度就业人数趋势分析: [{ name: "年度就业人数趋势分析", data: 年度就业人数趋势分析 }],
// 在孵企业营收占比: { dataList: 在孵企业营收占比, title: ["key", "value"] },
// 企业服务: {
// dataList: [
// { key: "服务数", value: fuWuCount },
// // { key: "服务覆盖企业", value:fuWuQiYeCount }
// { key: "服务覆盖企业", value: `${fuWuQiYeCountPercentage}%` }
// ],
// titleList: ['key', 'value']
// },
// 企业服务类型: {
// dataList: fuWuQiYeTypeList,
// titleList: ['key', 'value']
// }
// }
// //行业领域----按照企业选择的类型呈现
// for (let key in INDUSTRY) {
// let anyKey: any = key;
// if (isNaN(anyKey)) {
// let keyStr = key;
// zhyy.入驻企业行业类型.dataList.push({ key: keyStr, value: industryMap[keyStr] });
// }
// }
return zhyy;
}
/** /**
* 企业服务数据按年度展示 * 企业服务数据按年度展示
......
src/data/table/jxgljscData.ts
...@@ -25,13 +25,11 @@ export function jxgljscTableData() { ...@@ -25,13 +25,11 @@ export function jxgljscTableData() {
let blockDataList = onceSheetBecomeOfblockData('yuyiServer.xlsx', '绩效管理驾驶舱'); let blockDataList = onceSheetBecomeOfblockData('yuyiServer.xlsx', '绩效管理驾驶舱');
let keyValueOrTitleList = ["在孵企业面积情况分析", "产业结构", "人才引进", "孵化器汇总数据","孵化器得分数据", "新增在孵企业情况", let keyValueOrTitleList = ["孵化器得分数据", "新增在孵企业情况", "资源集聚能力", "综合能力", "毕业企业情况", "区域创新辐射带动能力",
"资源集聚能力", "综合能力", "毕业企业情况", "区域创新辐射带动能力", "预警", "企业预警", "企业动态", "金融服务", "总营收金额", "金融服务", "企业贷款趋势"];//适配 饼图 键值以及需要多个key的
"在孵企业总营收", "在孵企业融资情况","在孵企业融资情况占比", "公共技术服务", "企业孵化率", "企业孵化数", "投资类型", let barChartList = []; //适配 柱状图 折线图,
"科技型中小企业认定情况"];//适配 饼图 键值以及需要多个key的
let barChartList = ["在孵企业面积变化趋势", "在孵企业变化趋势"]; //适配 柱状图 折线图,
let stringList = []; let stringList = [];
let decollatePlanarList = ["硬科技企业培育情况","科技型中小企业认定情况"];//适配 表格 let decollatePlanarList = ["融资服务详情"];//适配 表格
let titltListConfig = {}; let titltListConfig = {};
let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList); let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
......
src/data/table/zhyyData.ts
...@@ -23,7 +23,7 @@ function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, ...@@ -23,7 +23,7 @@ function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList,
export function zhyyTableData() { export function zhyyTableData() {
let blockDataList = onceSheetBecomeOfblockData('yuyiServer.xlsx', '智慧运营'); let blockDataList = onceSheetBecomeOfblockData('yuyiServer.xlsx', '地图数据');
let keyValueOrTitleList = [];//适配 饼图 键值以及需要多个key的 let keyValueOrTitleList = [];//适配 饼图 键值以及需要多个key的
let barChartList = []; //适配 柱状图 折线图 let barChartList = []; //适配 柱状图 折线图
......
src/routers/router.ts
...@@ -18,6 +18,7 @@ export function setRouter(httpServer){ ...@@ -18,6 +18,7 @@ export function setRouter(httpServer){
httpServer.post('/yuyi/viewserver/qyszhx', asyncHandler(wmkqyszhxBiz.getData)); httpServer.post('/yuyi/viewserver/qyszhx', asyncHandler(wmkqyszhxBiz.getData));
httpServer.post('/yuyi/viewserver/jxgljsc', asyncHandler(jxgljscBiz.getData)); httpServer.post('/yuyi/viewserver/jxgljsc', asyncHandler(jxgljscBiz.getData));
httpServer.post('/yuyi/viewserver/qyfw', asyncHandler(qyfwBiz.getData)); httpServer.post('/yuyi/viewserver/qyfw', asyncHandler(qyfwBiz.getData));
httpServer.post('/yuyi/viewserver/qianruqianchutable', asyncHandler(qyfwBiz.getQianRuQianChu));
httpServer.post('/yuyi/viewserver/qyfwbyname', asyncHandler(qyfwBiz.getEnterpriseByName)); httpServer.post('/yuyi/viewserver/qyfwbyname', asyncHandler(qyfwBiz.getEnterpriseByName));
httpServer.post('/yuyi/viewserver/zhyy', asyncHandler(zhyyBiz.getData));//智慧运营 httpServer.post('/yuyi/viewserver/zhyy', asyncHandler(zhyyBiz.getData));//智慧运营
httpServer.post('/yuyi/viewserver/public/selectparam', asyncHandler(publicBiz.publicRouter)); httpServer.post('/yuyi/viewserver/public/selectparam', asyncHandler(publicBiz.publicRouter));
......
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