no message

serverConfig.xml

 <config>
     <port>40015</port>
     <dbPort>9096</dbPort>
-    <dbHost>192.168.0.105</dbHost>
+    <dbHost>192.168.0.71</dbHost>
     <sign>xxx90909082fsdahfjosadjfpoiwausjorip2hjklrhn1ioud0u124rx0qwejfokasjfolksaujfoas</sign>
     <!-- <imgPath>http://127.0.0.1:4980/yuyi/viewpage</imgPath> -->
     <imgPath>http://192.168.0.189:40015</imgPath>

src/biz/old/jxgljsc.ts

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

src/biz/old/public.ts

+/**
+ * 公共资源
+ */
+import * as enumConfig from '../config/enum';
+
+const config = {
+    "/public/selectparam":enumConfig.SELECTPARAM, //企业搜索下拉框选择
+}
+
+export function publicRouter(req, res) {
+    let ret:any = {};
+
+    ret['selectparam'] = getEnumItf(config['/public/selectparam']);
+
+    res.send(ret);
+}
+
+
+/**
+ * 
+ * @param req 
+ * @param res 
+ */
+function getEnumItf(enumCof) {
+    let dataList = [];
+    for (let key in enumCof) {
+        let anyKey:any = key;
+        if (isNaN(anyKey)) {
+            dataList.push({key, value:enumCof[key]});
+        }
+    }
+
+    return dataList;
+}
\ No newline at end of file

src/biz/old/qyfw.ts

+
+import { systemConfig } from '../config/serverConfig';
+import { getEnterprise, getEnterpriseDetails } from '../data/db/qyfw';
+import { qyfwTableData } from '../data/table/qyfwData';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
+
+/*                            企业服务                    */
+
+export async function getData(req, res) {
+    let dbData = await getEnterprise();
+    let excelData = qyfwTableData();
+
+    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 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(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['byrzqy'] = getOnceYBarChartOut('本月融资企业', byrzqyPackageData);
+                    
+    let byrzjePackageData = onceYBarChartPackage( dbData['本月融资金额'], '','');
+    ret['byrzje'] = getOnceYBarChartOut('本月融资金额', byrzjePackageData);
+                    
+    let zfqyzysPackageData = keyValuePackage(dbData['在孵企业总营收'].dataList);
+    ret['zfqyzys'] = getKeyValueOut('在孵企业总营收', zfqyzysPackageData);
+                    
+    let jrfwqyTableData = tablePackage(dbData["金融服务企业"].headerList[0], dbData["金融服务企业"].bodyList);
+    ret['jrfwqy'] = getTableOut( '金融服务企业', jrfwqyTableData);
+                    
+    let zscqPackageData = keyValuePackage(dbData['知识产权'].dataList);
+    ret['zscq'] = getKeyValueOut('知识产权', zscqPackageData);
+                    
+    let zscqbtPackageData = keyValuePackage(dbData['知识产权饼图'].dataList);
+    ret['zscqbt'] = getKeyValueOut('知识产权饼图', zscqbtPackageData);
+                    
+    let zscqxqTableData = tablePackage(dbData["知识产权详情"].headerList[0], dbData["知识产权详情"].bodyList);
+    ret['zscqxq'] = getTableOut( '知识产权详情', zscqxqTableData);
+                    
+    let qyzzflPackageData = keyValuePackage(dbData['企业资质分类'].dataList);
+    ret['qyzzfl'] = getKeyValueOut('企业资质分类', qyzzflPackageData);
+                    
+    let qyzzfl_xjrTableData = tablePackage(dbData["企业资质分类_小巨人"].headerList[0], dbData["企业资质分类_小巨人"].bodyList);
+    ret['qyzzfl_xjr'] = getTableOut( '企业资质分类_小巨人', qyzzfl_xjrTableData);
+                    
+    let qyzzfl_gxqyTableData = tablePackage(dbData["企业资质分类_高新企业"].headerList[0], dbData["企业资质分类_高新企业"].bodyList);
+    ret['qyzzfl_gxqy'] = getTableOut( '企业资质分类_高新企业', qyzzfl_gxqyTableData);
+                    
+    let qyzzfl_zjtxTableData = tablePackage(dbData["企业资质分类_专精特新"].headerList[0], dbData["企业资质分类_专精特新"].bodyList);
+    ret['qyzzfl_zjtx'] = getTableOut( '企业资质分类_专精特新', qyzzfl_zjtxTableData);
+                    
+    let qyzzfl_gqpyTableData = tablePackage(dbData["企业资质分类_小巨人培育"].headerList[0], dbData["企业资质分类_小巨人培育"].bodyList);
+    ret['qyzzfl_gqpy'] = getTableOut( '企业资质分类_小巨人培育', qyzzfl_gqpyTableData);
+                     
+    res.send(ret);
+} 
+
+
+export async function getEnterpriseByName(req, res) {
+    let {name, type} = req.body;
+    let dbData = await getEnterpriseDetails(name, type);
+
+    let ret:any = {};
+    ret['qylist'] = {data:dbData, count:dbData.length};
+
+    res.send(ret);
+}
+
+
+
+
+export async function get备份(req, res) {
+    let dbData = await getEnterprise();
+    let excelData = qyfwTableData();
+
+    let ret:any = {};
+
+    let qyjbqkPackageData = keyValuePackage(excelData['企业基本情况'].dataList);
+    ret['qyjbqk'] = getKeyValueOut('企业基本情况', qyjbqkPackageData);
+                    
+    let bhqsfxPackageData = onceYBarChartPackage( excelData['变化趋势分析'], '','');
+    ret['bhqsfx'] = getOnceYBarChartOut('变化趋势分析', bhqsfxPackageData);
+                    
+    let rfszfbPackageData = keyValuePackage(excelData['入孵时长分布'].dataList);
+    ret['rfszfb'] = getKeyValueOut('入孵时长分布', rfszfbPackageData);
+                    
+    let fhqyhylyzbPackageData = keyValuePackage(excelData['孵化企业行业领域占比'].dataList);
+    ret['fhqyhylyzb'] = getKeyValueOut('孵化企业行业领域占比', fhqyhylyzbPackageData);
+                    
+    let qyrcPackageData = onceYBarChartPackage( excelData['企业人才'], '','');
+    ret['qyrc'] = getOnceYBarChartOut('企业人才', qyrcPackageData);
+                    
+    let qyfwhzsjPackageData = keyValuePackage(excelData['企业服务汇总数据'].dataList);
+    ret['qyfwhzsj'] = getKeyValueOut('企业服务汇总数据', qyfwhzsjPackageData);
+                    
+    let qyxqdtPackageData = keyValuePackage(excelData['企业需求动态'].dataList);
+    ret['qyxqdt'] = getKeyValueOut('企业需求动态', qyxqdtPackageData);
+                    
+    // let qyxqdtxxTableData = tablePackage(excelData["企业需求动态详细"].headerList[0], excelData["企业需求动态详细"].bodyList);
+    
+    // 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);
+                    
+    let qyzzfl_gqpyTableData = tablePackage(excelData["企业资质分类_高企培育"].headerList[0], excelData["企业资质分类_高企培育"].bodyList);
+    ret['qyzzfl_gqpy'] = getTableOut( '企业资质分类_高企培育', qyzzfl_gqpyTableData);
+                     
+    res.send(ret);
+} 
+
+

src/biz/old/qyszhx.ts

+
+import { fxyjTableData, qyszhxTableData } from '../data/table/qyszhxData';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, stringListPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getStringOut, getTableOut } from '../dataPackage/out';
+import { systemConfig } from '../config/serverConfig';
+import { getQyszhx } from '../data/db/qyszhx';
+
+/*                            企业数字画像                    */
+
+export async function getData(req, res) {
+    let eId = req.body.eId;
+
+    let dbData = await getQyszhx(eId);
+    let excelData = qyszhxTableData();
+    let fxyjExcelData = fxyjTableData();
+
+    let ret: any = {};
+
+    let qyjbqkPackageData = keyValuePackage(dbData['企业基本情况'].dataList);
+    // let qyjbqk = [];
+    // qyjbqkPackageData.forEach( info => {
+    //     let {key, value} = info;
+    //     if (key == "企业图片") {
+    //         info.value = `${systemConfig.imgPath}/${value}`;
+    //     }
+    //     qyjbqk.push(info);
+    // })
+    ret['qyjbqk'] = getKeyValueOut('企业基本情况', qyjbqkPackageData);
+
+    let qyjbsjPackageData = keyValuePackage(dbData['企业基本数据'].dataList, "false");
+    ret['qyjbsj'] = getKeyValueOut('企业基本数据', qyjbsjPackageData);
+
+    let qymcPackageData = keyValuePackage(dbData['企业名称'].dataList);
+    ret['qymc'] = getKeyValueOut('企业名称', qymcPackageData);
+
+    let qybqPackageData = stringListPackage(dbData['企业标签'].dataList);
+    ret['qybq'] = getStringOut('企业标签', qybqPackageData);
+
+    let yfzbPackageData = keyValuePackage(dbData['研发占比'].dataList);
+    ret['yfzb'] = getKeyValueOut('研发占比', yfzbPackageData);
+
+    let qyzhxPackageData = keyValuePackage(dbData['企业自画像'].dataList);
+    ret['qyzhx'] = getKeyValueOut('企业自画像', qyzhxPackageData);
+
+    let zfbtPackageData = keyValuePackage(dbData['租房补贴'].dataList);
+    ret['zfbt'] = getKeyValueOut('租房补贴', zfbtPackageData);
+
+    let gxPackageData = keyValuePackage(dbData['高新'].dataList);
+    ret['gz'] = getKeyValueOut('高新', gxPackageData);
+
+    let kxPackageData = keyValuePackage(dbData['科小'].dataList);
+    ret['kx'] = getKeyValueOut('科小', kxPackageData);
+
+    let xjrPackageData = keyValuePackage(dbData['小巨人'].dataList);
+    ret['xjr'] = getKeyValueOut('小巨人', xjrPackageData);
+
+    let zzrzPackageData = keyValuePackage(dbData['资质认证'].dataList);
+    ret['zzrz'] = getKeyValueOut('资质认证', zzrzPackageData);
+
+    let zzrzbhqsPackageData = onceYBarChartPackage(dbData['资质认证变化趋势'], '', '');//新增
+    ret['zzrzbhqs'] = getOnceYBarChartOut('资质认证变化趋势', zzrzbhqsPackageData);
+
+    let zscqPackageData = keyValuePackage(dbData['知识产权'].dataList);
+    ret['zscq'] = getKeyValueOut('知识产权', zscqPackageData);
+
+    let qyyghxPackageData = keyValuePackage(dbData['企业员工画像'].dataList);
+    ret['qyyghx'] = getKeyValueOut('企业员工画像', qyyghxPackageData);
+
+    let lnrczpqkPackageData = onceYBarChartPackage(dbData['历年人才招聘情况'], '', '');
+    ret['lnrczpqk'] = getOnceYBarChartOut('历年人才招聘情况', lnrczpqkPackageData);
+
+    let qyhzsjPackageData = keyValuePackage(dbData['企业汇总数据'].dataList);
+    ret['qyhzsj'] = getKeyValueOut('企业汇总数据', qyhzsjPackageData);
+
+    // let xjrTableData = tablePackage(excelData["小巨人"].headerList[0], excelData["小巨人"].bodyList);
+    // ret['xjr'] = getTableOut( '小巨人', xjrTableData);
+
+    // let gxqyTableData = tablePackage(excelData["高新企业"].headerList[0], excelData["高新企业"].bodyList);
+    // ret['gxqy'] = getTableOut( '高新企业', gxqyTableData);
+
+    // let zjtxTableData = tablePackage(excelData["专精特新"].headerList[0], excelData["专精特新"].bodyList);
+    // ret['zjtx'] = getTableOut( '专精特新', zjtxTableData);
+
+    let ysqkPackageData = keyValuePackage(dbData['营收情况'].dataList);
+    ret['ysqk'] = getKeyValueOut('营收情况', ysqkPackageData);
+
+    let ysbhqsPackageData = onceYBarChartPackage(dbData['营收变化趋势'], '', '');
+    ret['ysbhqs'] = getOnceYBarChartOut('营收变化趋势', ysbhqsPackageData);
+
+    let qydtTableData = tablePackage(dbData["企业动态"].headerList[0], dbData["企业动态"].bodyList);
+    let qydt = { dataList: [], titleList: qydtTableData.titleList };
+    // qydtTableData.dataList.forEach(info => {
+    //     let {A} = info;
+    //     let imgUrl = JSON.parse(A);
+    //     info["A"] = imgUrl[0];
+    //     qydt.dataList.push(info);
+    // })
+    ret['qydt'] = getTableOut('企业动态', qydtTableData);
+
+    let fxyjInfo = {};
+    fxyjExcelData['风险预警'].dataList.forEach(info => {
+        let { key, value } = info;
+        fxyjInfo[key] = info;
+    })
+    let qymc = dbData['企业名称'].dataList[0].value;
+    ret['fxyj'] = { title: "风险预警", dataList: fxyjInfo[qymc]? [fxyjInfo[qymc]] : []};
+
+    let fwxqPackageData = keyValuePackage(dbData['服务需求'].dataList, "false");
+    ret['fwxq'] = getKeyValueOut('服务需求', fwxqPackageData);
+
+    let hdbhqsfxPackageData = onceYBarChartPackage(dbData['活动变化趋势分析'], '', '');
+    ret['hdbhqsfx'] = getOnceYBarChartOut('活动变化趋势分析', hdbhqsfxPackageData);
+
+    // let ryzzPackageData = keyValuePackage(excelData['荣誉资质'].dataList);
+    // let ryzz = [];
+    // ryzzPackageData.forEach(info => {
+    //     let { key, value } = info;
+    //     info.value = `${systemConfig.imgPath}/${value}`;
+    //     ryzz.push(info);
+    // })
+    // ret['ryzz'] = getKeyValueOut('荣誉资质', ryzz);
+    let ryzztp = dbData["荣誉资质图片"];
+    ret['ryzztp'] = { title: "荣誉资质图片", dataList: ryzztp };
+
+
+    let fwjl_kjfwTableData = tablePackage(dbData["服务记录_空间服务"].headerList[0], dbData["服务记录_空间服务"].bodyList);
+    ret['fwjl_kjfw'] = getTableOut('服务记录_空间服务', fwjl_kjfwTableData);
+
+    let fwjl_gsfwTableData = tablePackage(dbData["服务记录_工商服务"].headerList[0], dbData["服务记录_工商服务"].bodyList);
+    ret['fwjl_gsfw'] = getTableOut('服务记录_工商服务', fwjl_gsfwTableData);
+
+    let fwjl_rzfwTableData = tablePackage(dbData["服务记录_融资服务"].headerList[0], dbData["服务记录_融资服务"].bodyList);
+    ret['fwjl_rzfw'] = getTableOut('服务记录_融资服务', fwjl_rzfwTableData);
+
+    let fwjlPackageData = keyValuePackage(dbData['服务记录'].dataList);
+    ret['fwjl'] = getKeyValueOut('服务记录', fwjlPackageData);
+
+    let yqtzPackageData = keyValuePackage(excelData['园区通知'].dataList);
+    ret['yqtz'] = getKeyValueOut('园区通知', yqtzPackageData);
+
+    let yqtzxqTableData = tablePackage(excelData["园区通知详情"].headerList[0], excelData["园区通知详情"].bodyList);
+    // let yqtzxq = {dataList:[], titleList:yqtzxqTableData.titleList};
+    // yqtzxqTableData.dataList.forEach(info => {
+    //     let {A} = info;
+    //     let imgUrl = `${systemConfig.imgPath}/${A}`;
+    //     info["A"] = imgUrl;
+    //     yqtzxq.dataList.push(info);
+    // })
+    ret['yqtzxq'] = getTableOut('园区通知详情', yqtzxqTableData);
+
+    let yqhdPackageData = keyValuePackage(excelData['园区活动'].dataList);
+    ret['yqhd'] = getKeyValueOut('园区活动', yqhdPackageData);
+
+    let yqhdmxTableData = tablePackage(excelData["园区活动明细"].headerList[0], excelData["园区活动明细"].bodyList);
+    ret['yqhdmx'] = getTableOut('园区活动明细', yqhdmxTableData);
+
+
+    res.send(ret);
+}
+
+
+
+export async function getData备份(req, res) {
+    let eId = req.body.eId;
+
+    let excelData = qyszhxTableData();
+
+    let ret: any = {};
+
+    let qyjbqkPackageData = keyValuePackage(excelData['企业基本情况'].dataList);
+    let qyjbqk = [];
+    qyjbqkPackageData.forEach(info => {
+        let { key, value } = info;
+        if (key == "企业图片") {
+            info.value = `${systemConfig.imgPath}/${value}`;
+        }
+        qyjbqk.push(info);
+    })
+    ret['qyjbqk'] = getKeyValueOut('企业基本情况', qyjbqk);
+
+    let qyjbsjPackageData = keyValuePackage(excelData['企业基本数据'].dataList, "false");
+    ret['qyjbsj'] = getKeyValueOut('企业基本数据', qyjbsjPackageData);
+
+    let qybqPackageData = stringListPackage(excelData['企业标签'].dataList);
+    ret['qybq'] = getStringOut('企业标签', qybqPackageData);
+
+    let zscqPackageData = keyValuePackage(excelData['知识产权'].dataList);
+    ret['zscq'] = getKeyValueOut('知识产权', zscqPackageData);
+
+    let qyyghxPackageData = keyValuePackage(excelData['企业员工画像'].dataList);
+    ret['qyyghx'] = getKeyValueOut('企业员工画像', qyyghxPackageData);
+
+    let lnrczpqkPackageData = onceYBarChartPackage(excelData['历年人才招聘情况'], '', '');
+    ret['lnrczpqk'] = getOnceYBarChartOut('历年人才招聘情况', lnrczpqkPackageData);
+
+    let qyhzsjPackageData = keyValuePackage(excelData['企业汇总数据'].dataList);
+    ret['qyhzsj'] = getKeyValueOut('企业汇总数据', qyhzsjPackageData);
+
+    let xjrTableData = tablePackage(excelData["小巨人"].headerList[0], excelData["小巨人"].bodyList);
+    ret['xjr'] = getTableOut('小巨人', xjrTableData);
+
+    let gxqyTableData = tablePackage(excelData["高新企业"].headerList[0], excelData["高新企业"].bodyList);
+    ret['gxqy'] = getTableOut('高新企业', gxqyTableData);
+
+    let zjtxTableData = tablePackage(excelData["专精特新"].headerList[0], excelData["专精特新"].bodyList);
+    ret['zjtx'] = getTableOut('专精特新', zjtxTableData);
+
+    let ysqkPackageData = keyValuePackage(excelData['营收情况'].dataList);
+    ret['ysqk'] = getKeyValueOut('营收情况', ysqkPackageData);
+
+    let ysbhqsPackageData = onceYBarChartPackage(excelData['营收变化趋势'], '', '');
+    ret['ysbhqs'] = getOnceYBarChartOut('营收变化趋势', ysbhqsPackageData);
+
+    let qydtTableData = tablePackage(excelData["企业动态"].headerList[0], excelData["企业动态"].bodyList);
+    let qydt = { dataList: [], titleList: qydtTableData.titleList };
+    qydtTableData.dataList.forEach(info => {
+        let { A } = info;
+        let imgUrl = `${systemConfig.imgPath}/${A}`;
+        info["A"] = imgUrl;
+        qydt.dataList.push(info);
+    })
+    ret['qydt'] = getTableOut('企业动态', qydt);
+
+    let fwxqPackageData = keyValuePackage(excelData['服务需求'].dataList, "false");
+    ret['fwxq'] = getKeyValueOut('服务需求', fwxqPackageData);
+
+    let hdbhqsfxPackageData = onceYBarChartPackage(excelData['活动变化趋势分析'], '', '');
+    ret['hdbhqsfx'] = getOnceYBarChartOut('活动变化趋势分析', hdbhqsfxPackageData);
+
+    let fwjl_kjfwTableData = tablePackage(excelData["服务记录_空间服务"].headerList[0], excelData["服务记录_空间服务"].bodyList);
+    ret['fwjl_kjfw'] = getTableOut('服务记录_空间服务', fwjl_kjfwTableData);
+
+    let fwjl_gsfwTableData = tablePackage(excelData["服务记录_工商服务"].headerList[0], excelData["服务记录_工商服务"].bodyList);
+    ret['fwjl_gsfw'] = getTableOut('服务记录_工商服务', fwjl_gsfwTableData);
+
+    let fwjl_rzfwTableData = tablePackage(excelData["服务记录_融资服务"].headerList[0], excelData["服务记录_融资服务"].bodyList);
+    ret['fwjl_rzfw'] = getTableOut('服务记录_融资服务', fwjl_rzfwTableData);
+
+    let fwjlPackageData = keyValuePackage(excelData['服务记录'].dataList);
+    ret['fwjl'] = getKeyValueOut('服务记录', fwjlPackageData);
+
+    let yqtzPackageData = keyValuePackage(excelData['园区通知'].dataList);
+    ret['yqtz'] = getKeyValueOut('园区通知', yqtzPackageData);
+
+    let yqtzxqTableData = tablePackage(excelData["园区通知详情"].headerList[0], excelData["园区通知详情"].bodyList);
+    let yqtzxq = { dataList: [], titleList: yqtzxqTableData.titleList };
+    yqtzxqTableData.dataList.forEach(info => {
+        let { A } = info;
+        let imgUrl = `${systemConfig.imgPath}/${A}`;
+        info["A"] = imgUrl;
+        yqtzxq.dataList.push(info);
+    })
+    ret['yqtzxq'] = getTableOut('园区通知详情', yqtzxq);
+
+    let yqhdPackageData = keyValuePackage(excelData['园区活动'].dataList);
+    ret['yqhd'] = getKeyValueOut('园区活动', yqhdPackageData);
+
+    let yqhdmxTableData = tablePackage(excelData["园区活动明细"].headerList[0], excelData["园区活动明细"].bodyList);
+    ret['yqhdmx'] = getTableOut('园区活动明细', yqhdmxTableData);
+
+    res.send(ret);
+}
\ No newline at end of file

src/biz/old/zhyy.ts

+
+import { log } from 'console';
+import { systemConfig } from '../config/serverConfig';
+import { getZhyy } from '../data/db/zhyy';
+import { zhyyTableData } from '../data/table/zhyyData';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
+
+/*                            智慧运营                    */
+
+export async function getData(req, res) {
+    let excelData = zhyyTableData();
+    let dbData = await getZhyy();
+
+    let ret: any = {};
+
+    let yqgkPackageData = keyValuePackage(dbData['园区概况'].dataList);
+    ret['yqgk'] = getKeyValueOut('园区概况', yqgkPackageData);
+
+    let zfqysjPackageData = keyValuePackage(dbData['在孵企业数据'].dataList);
+    ret['zfqysj'] = getKeyValueOut('在孵企业数据', zfqysjPackageData);
+
+    let rzqybhqsPackageData = onceYBarChartPackage(dbData['入驻企业变化趋势'], '', '');
+    ret['rzqybhqs'] = getOnceYBarChartOut('入驻企业变化趋势', rzqybhqsPackageData);
+
+    let rzqyhylxPackageData = keyValuePackage(dbData['入驻企业行业类型'].dataList);
+    ret['rzqyhylx'] = getKeyValueOut('入驻企业行业类型', rzqyhylxPackageData);
+
+    let fhyyPackageData = keyValuePackage(dbData['孵化运营'].dataList);
+    ret['fhyy'] = getKeyValueOut('孵化运营', fhyyPackageData);
+
+    let fhmjbhqsPackageData = onceYBarChartPackage(dbData['孵化面积变化趋势'], '', '');
+    ret['fhmjbhqs'] = getOnceYBarChartOut('孵化面积变化趋势', fhmjbhqsPackageData);
+
+    // let zfqybhqsPackageData = onceYBarChartPackage( excelData['在孵企业变化趋势'], '','');
+    let zfqybhqsPackageData = onceYBarChartPackage(dbData["在孵企业变化趋势"], '', '');
+    ret['zfqybhqs'] = getOnceYBarChartOut('在孵企业变化趋势', zfqybhqsPackageData);
+
+    // let byqybhqsPackageData = onceYBarChartPackage( excelData['毕业企业变化趋势'], '','');
+    let byqybhqsPackageData = onceYBarChartPackage(dbData["毕业企业变化趋势"], '', '');
+    ret['byqybhqs'] = getOnceYBarChartOut('毕业企业变化趋势', byqybhqsPackageData);
+
+    let rzqyPackageData = onceYBarChartPackage(dbData['融资企业变化趋势'], '', '');
+    ret['rzqy'] = getOnceYBarChartOut('融资企业变化趋势', rzqyPackageData);
+
+    let ryzzPackageData = keyValuePackage(dbData['荣誉资质'].dataList);
+    ret['ryzz'] = getKeyValueOut('荣誉资质', ryzzPackageData);
+
+    // let ryzztp = dbData["荣誉资质图片"];
+    // // let ryzztpList = [];
+    // // for (let i = 0; i < ryzztp.length; i++) {
+    // //     ryzztpList.push(`${systemConfig.imgPath}/${ryzztp[i][0]}`);//systemConfig.imgFileUrl = imgFileUrl[0];
+    // // }
+    // ret['ryzztp'] = { title: "荣誉资质图片", dataList: ryzztp };
+
+    let zhyyhzsjPackageData = keyValuePackage(dbData['智慧运营汇总数据'].dataList);
+    ret['zhyyhzsj'] = getKeyValueOut('智慧运营汇总数据', zhyyhzsjPackageData);
+
+    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 jyfxPackageData = keyValuePackage(excelData['就业分析'].dataList);
+    // ret['jyfx'] = getKeyValueOut('就业分析', jyfxPackageData);
+    let jyfxPackageData = keyValuePackage(dbData['就业分析'].dataList);
+    ret['jyfx'] = getKeyValueOut('就业分析', jyfxPackageData);
+
+    let jdjyrsqsfxPackageData = onceYBarChartPackage(dbData['年度就业人数趋势分析'], '', '');
+    ret['jdjyrsqsfx'] = getOnceYBarChartOut('年度就业人数趋势分析', jdjyrsqsfxPackageData);
+
+    let cygmfxPackageData = keyValuePackage(excelData['产业规模分析'].dataList);
+    ret['cygmfx'] = getKeyValueOut('产业规模分析', cygmfxPackageData);
+
+    let zfqyyszbPackageData = keyValuePackage(dbData['在孵企业营收占比'].dataList);
+    ret['zfqyyszb'] = getKeyValueOut('在孵企业营收占比', zfqyyszbPackageData);
+
+    let qyfwPackageData = keyValuePackage(dbData['企业服务'].dataList);
+    ret['qyfw'] = getKeyValueOut('企业服务', qyfwPackageData);
+
+    let qyfwlxPackageData = keyValuePackage(dbData['企业服务类型'].dataList);
+    ret['qyfwlx'] = getKeyValueOut('企业服务类型', qyfwlxPackageData);
+
+    let fwzlTableData = tablePackage(excelData["服务质量"].headerList[0], excelData["服务质量"].bodyList);//todo111
+    ret['fwzl'] = getTableOut('服务质量', fwzlTableData);
+
+    let yysrqsPackageData = onceYBarChartPackage(excelData['运营收入趋势'], '', '');
+    ret['yysrqs'] = getOnceYBarChartOut('运营收入趋势', yysrqsPackageData);
+
+    let cyzcPackageData = keyValuePackage(excelData['产业政策'].dataList);
+    ret['cyzc'] = getKeyValueOut('产业政策', cyzcPackageData);
+
+    let cyzcxxPackageData = keyValuePackage(excelData['产业政策详细'].dataList);
+    ret['cyzcxx'] = getKeyValueOut('产业政策详细', cyzcxxPackageData);
+
+    let yqhdPackageData = keyValuePackage(excelData['园区活动'].dataList);
+    let yqhd = [];
+    yqhdPackageData.forEach(info => {
+        let { key, value } = info;
+        info.value = `${systemConfig.imgPath}/${value}`;
+        yqhd.push(info);
+    })
+    ret['yqhd'] = getKeyValueOut('园区活动', yqhd);
+
+    let yqxwPackageData = keyValuePackage(excelData['园区新闻'].dataList);
+    let yqxw = [];
+    yqxwPackageData.forEach(info => {
+        let { key, value } = info;
+        info.value = `${systemConfig.imgPath}/${value}`;
+        yqxw.push(info);
+    })
+    ret['yqxw'] = getKeyValueOut('园区新闻', yqxw);
+
+    res.send(ret);
+} 
\ No newline at end of file

src/data/db/old/jxgljsc.ts

+/**
+ * 绩效管理驾驶仓
+ */
+
+import moment = require("moment")
+import { FUHUASTATE, INDUSTRY, MOVEOUTTYPE, OPERATIONALDATATYPE, TABLENAME, FINANCINGROUNDS, ENTERPRISETEAM, FUHUAQILNVESTMENTSTYLE, EMIGRATIONTYPE, STATE } from "../../config/enum";
+import { selectData, selectManyTableData } from "./operationalData";
+import { keyValuePackage } from "../../dataPackage/inFrontOut";
+import { info, log } from "console";
+import { getChart, getKeyValue, getYearList } from "./out";
+import { get } from "http";
+import { changeEnumValue } from "../../tools/eccEnum";
+
+
+function getStartAndEndTimeYearList(startTime, endTime) {
+    let startYear = new Date(startTime).getFullYear();
+    let endYear = new Date(endTime).getFullYear();
+    let result = [];
+    for (let i = startYear; i <= endYear; i++) {
+        result.push(i);
+    }
+    return result;
+}
+
+export async function getJxgljsc() {
+    let jxgljsc = {
+        产业结构: { 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'] },//预警
+        企业预警: { bodyList: [], headerList: [['企业名称', '风险等级']] },
+        在孵企业面积情况分析: { dataList: [] }, //在孵企业面积情况分析
+        在孵企业面积变化趋势: { name: "在孵企业面积", data: [] }
+    };
+
+
+    //在孵企业面积情况分析
+    //获取所有企业孵化信息
+    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 }, ["industry", "eId"], manyTableInfo);
+    
+    let areaCount = 0;
+    let 面积变化Map = {};//孵化面积变化
+    let thisYear = new Date().getFullYear();
+    let industryMap = {};
+    let 在孵企业变化趋势map = {};
+
+    fhdbList.forEach(info => {
+        let { industry, enterprise_fuhuas, enterprise_leases } = info;
+        // 迁出状态
+        if (enterprise_fuhuas[0].state === FUHUASTATE.迁出) return;
+        let startTime = enterprise_fuhuas[0].startTime;
+        if (!startTime) return;
+
+        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 (industry) {
+            let industryStr = changeEnumValue(INDUSTRY, JSON.parse(industry)[0]);
+            if (!industryMap[industryStr]) industryMap[industryStr] = 0;
+            industryMap[industryStr] += 1;
+        }
+
+    });
+
+
+    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) {
+        let anyKey: any = key;
+        if (isNaN(anyKey)) {
+            let keyStr = key;
+
+            jxgljsc.产业结构.dataList.push({ key: keyStr, value: industryMap[keyStr] });
+        }
+    }
+
+
+    jxgljsc.在孵企业面积变化趋势.data = Object.values(面积变化Map);
+
+    let 孵化器信息数据 = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.羽翼孵化器, {}, null);
+    /**
+    * 计算在孵企业面积占比：在孵企业总面积/孵化器或者园区总面积 x 100%
+    */
+    let zaifuAreaRatio = "0";
+    if (!isNaN(孵化器信息数据.totalArea) && parseFloat(孵化器信息数据.totalArea) && areaCount) {
+        let zaifuAreaRatioNum = 100 * (areaCount / parseFloat(孵化器信息数据.totalArea));
+        zaifuAreaRatio = zaifuAreaRatioNum > 100 ? "100" : zaifuAreaRatioNum.toFixed(2);
+    }
+    jxgljsc.在孵企业面积情况分析.dataList.push({ key: "在孵面积占比", value: zaifuAreaRatio });
+
+
+    // 获取当前时间
+    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 在孵租赁联查includeConf = {};
+    在孵租赁联查includeConf[TABLENAME.企业孵化信息] = { cloum: fhColumn, where: { "endTime": { "%gt%": nowTime } } };
+    在孵租赁联查includeConf[TABLENAME.租赁信息] = { cloum: 租赁Column, where: {} }
+    let 在孵租赁联查dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {}, ["enterpriseName"], 在孵租赁联查includeConf);
+
+    //获取羽翼孵化器
+    let 羽翼孵化器dbList = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.羽翼孵化器, {}, []);
+
+
+    // jxgljsc.产业结构.dataList = await cyjg();//产业结构
+
+    jxgljsc.人才引进.dataList = await rcyj();//人才引进
+
+    //科技型中小企业认定情况
+    let KXdbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业基础信息表, {}, null);
+    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);
+
+    jxgljsc.孵化器汇总数据.dataList = getKeyValue(fhqhzsjInfo);//孵化器汇总数据
+
+    /**
+     * 预警
+     */
+    let { yj, riskEnterprises } = await getyj();
+    jxgljsc.预警.dataList = getKeyValue(yj)
+    jxgljsc.企业预警.bodyList = riskEnterprises//企业预警
+
+
+    let qydtInfo = await qydt(在孵dbList);
+    jxgljsc.企业动态.dataList = getKeyValue(qydtInfo);//企业动态
+
+
+
+
+    /**
+     * 金融服务
+     */
+    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);//总营收金额
+
+    let zfqyzysInfo = await zfqyzys(在孵dbList);
+    jxgljsc.在孵企业总营收.dataList = getKeyValue(zfqyzysInfo);//在孵企业总营收
+
+    // 投资类型
+    jxgljsc.投资类型分布图 = await tzlxfb();//投资类型分布图
+
+
+    jxgljsc.在孵企业融资情况.dataList = await zfqyrzqk();//在孵企业融资情况
+    jxgljsc.在孵企业融资情况占比.dataList = await zfqyrzqkzb();
+
+
+    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)//企业孵化数
+
+    return jxgljsc;
+}
+
+
+//产业结构---按照企业选择的类型呈现todo
+async function cyjg() {
+    let result = [];
+
+    for (let key in INDUSTRY) {
+        let anyKey: any = key;
+        if (isNaN(anyKey)) {
+            let keyStr = key;
+            let industry = INDUSTRY[key];
+            let count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业基础信息表, { industry: { "%like%": industry } }, null);
+            if (count > 0) {
+                result.push({ key: keyStr, value: count });
+            }
+        }
+    }
+
+    return result;
+}
+
+
+async function rcyj() {
+    let result = [];
+
+    // 分别获取不同表的数据并合并处理
+    // let 创业团队List = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.创业团队, {}, null);
+    for (let key in ENTERPRISETEAM) {
+        let anyKey: any = key;
+        if (isNaN(anyKey)) {
+            let keyStr = key;
+            let talentType = ENTERPRISETEAM[key];
+            let count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.创业团队, { talentType }, null);
+            result.push({ key: keyStr, value: count })
+        }
+    }
+
+    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 };
+}
+
+
+/**
+ * 孵化器汇总数据
+ */
+async function fhqhzsj(data, zfData, areaCount) {
+    let fhqhzsj = {
+        孵化器总面积: data.totalArea + "㎡",
+        在孵企业: zfData.length + "家",
+        在孵面积: data.zaifuArea + "㎡",
+        // 在孵面积: `${areaCount.toFixed(2)}㎡`
+    }
+
+    return fhqhzsj;
+}
+
+
+/**
+ * 预警
+ */
+async function getyj() {
+
+    let yj = {
+        高风险: 0,
+        中低风险: 0,
+        关注: 0
+    }
+    let riskEnterprises: any[] = [];
+    let fhColumn = ["enterpriseName", "industry", "eId", "shijiaoziben"];
+    //获取所有企业孵化信息
+
+    let manyTableInfo: any = {}
+    // manyTableInfo[TABLENAME.企业孵化信息] = { column: ["fId", "eId", "startTime", "endTime", "state"], where: { state: FUHUASTATE.实体孵化 } };
+    manyTableInfo[TABLENAME.企业孵化信息] = { column: ["fId", "eId", "moveOutTime", "moveOutType"], where: {} };
+    // manyTableInfo[TABLENAME.企业经营信息] = { column: ["annual"], where: {} };
+    let fhdbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {}, fhColumn, manyTableInfo);
+
+    let manageList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, {}, ["annual", "eId"]);
+
+    let map = {};
+    manageList.forEach(info => {
+        map[info.eId] = 1;
+    });
+
+    // let 高风险 = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业孵化信息, {moveOutType:{"%between%":[MOVEOUTTYPE.企业注销, MOVEOUTTYPE.非毕业迁出]}}, null);
+
+    fhdbList.forEach(info => {
+        let riskLevel = "";
+        if (info.enterprise_fuhuas[0].moveOutType == EMIGRATIONTYPE.违约退租 || info.enterprise_fuhuas[0].moveOutType == EMIGRATIONTYPE.到期退租) {
+            yj.高风险 += 1;
+            riskLevel = "高风险";
+        } else if (!map[info.eId]) {
+            yj.中低风险 += 1;
+            riskLevel = "中低风险";
+        }
+
+        riskEnterprises.push([
+            info.enterpriseName,
+            riskLevel
+        ]);
+    });
+    return {
+        yj,
+        riskEnterprises
+    };
+}
+
+
+/**
+ * 企业预警
+ */
+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) {
+    //获取企业孵化数
+    let qyfhs = {
+        "科小": 0,//新增"科小"
+        "小巨人": 0,
+        "高新企业": 0,
+        "专精特新": 0,
+        "小巨人培育": 0,
+    };
+
+    data.forEach(info => {
+        let { enterprise_qualifications } = info;
+        enterprise_qualifications.forEach(item => {
+            if (item.kxState == STATE.是) qyfhs.科小 += 1;//新增"科小"
+            if (item.xjrState == STATE.是) qyfhs.小巨人 += 1;
+            if (item.gxjsState == STATE.是) qyfhs.高新企业 += 1;
+            if (item.zjtxState == STATE.是) qyfhs.专精特新 += 1;
+            if (item.xjrPyState == STATE.是) qyfhs.小巨人培育 += 1;
+        })
+    })
+
+
+    return qyfhs;
+}
+
+
+/**
+ * 投资类型：自有资金、参与基金、自有基金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/old/operationalData.ts

+import { OPERATIONALDATATYPE, TABLENAME } from "../../config/enum";
+import { ERRORENUM } from "../../config/errorEnum";
+import { systemConfig } from "../../config/serverConfig";
+import { BizError } from "../../util/bizError";
+import { post } from "../../util/request";
+
+
+/**
+ * 操作数据库 新增  修改  删除
+ * @param url url地址 根据枚举获取值
+ * @param tableName 表名
+ * @param data 数据
+ * @param param 条件
+ */
+export async function operationalData(url:string, tableName:string, data, param) {
+    let header = {table:tableName, sign:systemConfig.sign};
+    let queray:any = {};
+
+    if (url == OPERATIONALDATATYPE.增加) {
+        queray.data = data;
+    } else if (url == OPERATIONALDATATYPE.修改) {
+        queray.data = data;
+        queray.param = param;
+    } else if (url == OPERATIONALDATATYPE.删除) {
+        queray.param = param;
+    } else {
+        throw new BizError(ERRORENUM.该方法仅可进行数据操作, '使用操作数据库的方法进行查询调用');
+    }
+
+    let result:any = await post(`${systemConfig.dbPath}${url}`, queray, header );
+    if (result.code != 200) throw new BizError(ERRORENUM.数据操作失败, result.code);
+    if (!result.data || !result.data.isSuccess) throw new BizError(ERRORENUM.数据操作失败, JSON.stringify(result.data));
+
+    return true;
+}
+
+
+/**
+ * 查询
+ * @param url url地址 根据枚举获取值
+ * @param tableName 表名
+ * @param param 条件
+ * @param pageNumber 分页传入的页数  非分页可不传
+ * @param pageSize 分页传入的单页大小  非分页可不传
+ */
+export async function selectData(url, tableName, param, column,  pageNumber?, pageSize?) {
+    if (url != OPERATIONALDATATYPE.查询单个 && url != OPERATIONALDATATYPE.查询多个 && url != OPERATIONALDATATYPE.查询数据量 &&  url != OPERATIONALDATATYPE.分页查询) {
+        throw new BizError(ERRORENUM.该方法仅可进行查询操作, '该方法仅可进行查询操作');
+    }
+    let header = {table:tableName, sign:systemConfig.sign};
+    let queray:any = {param};
+    if (column && column.length) {
+        queray.column = column;
+    }
+
+    if (url == OPERATIONALDATATYPE.分页查询) {
+        if (!pageNumber) throw new BizError(ERRORENUM.分页请设置当前页数, `pageNumber:${pageNumber};pageSize:${pageSize}`);
+        queray.pageNumber = pageNumber;
+        queray.pageSize = pageSize || 10;
+    }
+
+    let result:any = await post(`${systemConfig.dbPath}${url}`, queray, header );
+    if (result.code != 200) throw new BizError(ERRORENUM.数据查询失败, result.code);
+    if (!result.data || result.data.data == null || result.data.data == undefined) throw new BizError(ERRORENUM.数据查询失败, JSON.stringify(result.data));
+    return result.data.data;
+}
+ 
+
+/**
+ * 多表联查
+ * @param url 
+ * @param tableName 
+ * @param param 
+ * @param column 
+ * @param includeConf 
+ * @param pageNumber 
+ * @param pageSize 
+ * @returns 
+ */
+export async function selectManyTableData(url, tableName, param, column,  includeConf, pageNumber?, pageSize?) {
+    if (url != OPERATIONALDATATYPE.多表联查 && url != OPERATIONALDATATYPE.多表分页 && url != OPERATIONALDATATYPE.多表单个) {
+        throw new BizError(ERRORENUM.该方法仅可进行联合查询操作, '该方法仅可进行联合查询操作');
+    }
+    let header = {table:tableName, sign:systemConfig.sign};
+    let queray:any = {param, includeConf};
+    if (column && column.length) {
+        queray.column = column;
+    }
+    
+    if (url == OPERATIONALDATATYPE.多表分页) {
+        if (!pageNumber) throw new BizError(ERRORENUM.分页请设置当前页数, `pageNumber:${pageNumber};pageSize:${pageSize}`);
+        queray.pageNumber = pageNumber;
+        queray.pageSize = pageSize || 10;
+    }
+
+    let result:any = await post(`${systemConfig.dbPath}${url}`, queray, header );
+    if (result.code != 200) throw new BizError(ERRORENUM.数据联合查询失败, result.code);
+    if (!result.data || !result.data.data) throw new BizError(ERRORENUM.数据联合查询失败, JSON.stringify(result.data));
+    return result.data.data;
+}
\ No newline at end of file

src/data/db/old/out.ts

+import moment = require("moment");
+
+export function getKeyValue(data) {
+    let result = [];
+    for (let key in data) {
+        result.push({key, value:data[key]});
+    }
+
+    return result;
+}
+
+
+export function getChart(data) {
+    let result = [];
+    for(let key in data) {
+        result.push({name:key, data:data[key]})
+    }
+
+    return result;
+}
+
+
+export function getMonthList() {
+    // 获取当前时间
+    const currentTime = moment();
+    
+    // 获取6个月前的时间
+    const sixMonthsAgo = currentTime.clone().subtract(6, 'months');
+    
+    // 创建一个数组来存储每个月份的第一天
+    const monthsArray = [];
+    
+    // 使用moment的range函数（如果可用）或者手动循环来遍历月份
+    // 注意：moment.js的官方库中并没有直接的range函数用于月份遍历，
+    // 但我们可以使用.month()和.date(1)结合循环来实现。
+    
+    // 由于moment没有内置的range函数用于月份，我们需要手动处理
+    let currentMonth = sixMonthsAgo.clone();
+    while (currentMonth.isBefore(currentTime) || currentMonth.isSame(currentTime, 'month')) {
+        // 获取当前循环月份的第一天
+        const firstDayOfMonth = currentMonth.clone().date(1);
+        
+        // 将月份添加到数组中
+        monthsArray.push(moment(firstDayOfMonth.clone().toDate()).format("YY/MM")); // 如果你需要Date对象
+        // monthsArray.push(firstDayOfMonth.format('YYYY-MM-DD')); // 如果你需要格式化字符串
+        
+        // 移动到下一个月
+        currentMonth.add(1, 'months');
+    }
+
+    return monthsArray;
+}
+
+
+export function getYearList() {
+    // 获取当前年份
+    const currentTime = moment();
+    const sixMonthsAgo = currentTime.clone().subtract(6, 'year');
+    const currentYear = new Date().getFullYear();
+    
+    // 初始化一个空数组来存储年份
+    const years = [];
+    
+    // 使用一个循环来添加当前年份到6年后的每一个年份到数组中
+    for (let i = 0; i <= 6; i++) {
+        years.push(currentYear - i);
+    }
+
+    years.sort((a, b) => {
+        return a - b;
+    })
+
+    return years;
+}

src/data/db/old/qyfw.ts

+/**
+ * 企业服务
+ */
+
+import moment = require("moment");
+import { FUHUASTATE, INDUSTRY, OPERATIONALDATATYPE, STATE, TABLENAME, IPRALLTYPE, EMIGRATIONTYPE } from "../../config/enum";
+import { selectData, selectManyTableData } from "./operationalData";
+import { getChart, getKeyValue, getMonthList, getYearList } from "./out";
+import { getMySqlMs } from "../../tools/systemTools";
+import { changeEnumValue } from "../../tools/eccEnum";
+
+function getStartAndEndTimeYearList(startTime, endTime) {
+    let startYear = new Date(startTime).getFullYear();
+    let endYear = new Date(endTime).getFullYear();
+    let result = [];
+    for (let i = startYear; i <= endYear; i++) {
+        result.push(i);
+    }
+    return result;
+}
+
+export async function getEnterprise() {
+    let qyfw = {
+        企业基本情况: { dataList: [], titleList: ['key', 'value'] }, //企业基本情况
+        变化趋势分析: [], //变化趋势分析
+        入孵时长分布: { 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 selectParam = {  };
+    let zlColumn = ["eId", "area", "unitPrice", "isDeposit", "startTime", "endTime", "rentFreeStart", "rentFreeEnd", "roomNumber",
+        "rent", "notes", "leaseContract", "entryPlan", "businessLicense", "agreement"];
+    /**在孵：获取租赁结束时间大于当前时间的租赁信息 */
+    
+    let manyTableInfo: any = {}
+    manyTableInfo[TABLENAME.企业孵化信息] = { column: ["fId", "eId", "startTime", "endTime", "state"], where: {} };
+    manyTableInfo[TABLENAME.租赁信息] = { column: zlColumn, where: selectParam };
+    let zldbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {state:1}, ["industry", "eId"], manyTableInfo);
+
+    // let zldbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.租赁信息, selectParam, zlColumn);
+
+    //"endTime": { "%gt%": getMySqlMs(nowTime) }
+
+    let qyjbqk = {
+        "孵化面积": 0,
+        "在孵企业": 0,
+        "毕业企业": 0
+    };
+
+    let thisYear = new Date().getFullYear();
+    let industryMap = {};//行业领域
+    let 在孵企业变化趋势map = {};
+    zldbList.forEach(item => {
+        let {enterprise_leases, industry} = item;
+        let {area, startTime, endTime} = enterprise_leases[0];
+        if ( nowTime < new Date(endTime).valueOf() ) qyjbqk.孵化面积 += parseInt(area);
+
+        if (area) {
+            if (startTime && endTime) {
+                let leasesYearList = getStartAndEndTimeYearList(startTime, endTime);
+                leasesYearList.forEach(itemYear => {
+                    if (parseInt(itemYear) > thisYear) return;
+                    if (!在孵企业变化趋势map[itemYear]) 在孵企业变化趋势map[itemYear] = 0;
+                    在孵企业变化趋势map[itemYear] += 1;
+                    
+                });
+            }
+        }
+
+        //行业领域分布
+        if (industry) {
+            let industryStr = changeEnumValue(INDUSTRY, JSON.parse(industry)[0]);
+            if (!industryMap[industryStr]) industryMap[industryStr] = 0;
+            industryMap[industryStr] += 1;
+        }
+    })
+
+    let fhColumn = ["fId", "eId", "startTime", "endTime", "state", "virtualCause", "virtualCauseDes", "moveOutType",
+        "moveOutTrace", "moveOutCause", "moveOutTime", "graduationTime"];
+    //获取所有企业孵化信息
+    let fhdbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {}, fhColumn);
+    //获取在孵企业
+    // 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 毕业dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, { "moveOutType": MOVEOUTTYPE.毕业迁出 }, fhColumn);
+    let 毕业dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, { "moveOutType": EMIGRATIONTYPE.毕业迁出 }, fhColumn);
+    
+    let 迁出dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {}, fhColumn);
+    
+    //获取所有企业孵化表联查企业信息表
+    let 孵化企业includeConf = {};
+    let 孵化企业Clumn = ["enterpriseName", "industry"];
+    孵化企业includeConf[TABLENAME.企业基础信息表] = { cloum: 孵化企业Clumn, where: {} }
+    // let 孵化企业dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业孵化信息, {}, fhColumn, 孵化企业includeConf);
+
+    //企业基本信息
+    qyjbqk.在孵企业 = 在孵dbList.length;
+    qyjbqk.毕业企业 = 毕业dbList.length;
+    qyfw.企业基本情况.dataList = getKeyValue(qyjbqk);
+
+    //变化趋势分析 //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 qyfwhzsj = await getQyfwhzsj();
+    qyfw.企业服务汇总数据.dataList = getKeyValue(qyfwhzsj);
+
+    //企业需求动态
+    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);
+    
+
+    //企业变化情况——变化趋势
+    let hbqs = [];
+    for (let key in 在孵企业变化趋势map) {
+        hbqs.push({ key, value: 在孵企业变化趋势map[key] });
+    }
+    hbqs.sort((a, b) => { return parseInt(a.key) - parseInt(b.key) });
+    qyfw.企业变化情况变化趋势 = getChart({"企业数": hbqs});
+
+    let 企业融资dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业融资, {}, null);
+    //金融服务
+    let jrfw = await getJrfw(在孵dbList, 企业融资dbList);
+    qyfw.金融服务.dataList = getKeyValue(jrfw);
+
+    //本月融资企业
+    let byrzqy = await getByrzqy(企业融资dbList);
+    qyfw.本月融资企业 = byrzqy.byrzqybhqs;
+
+    //本月融资金额
+    qyfw.本月融资金额 = byrzqy.byrzjebhqs;
+
+    //在孵企业总营收
+    let zfqyzys = await getZfqyzys();
+    qyfw.在孵企业总营收.dataList = getKeyValue(zfqyzys);
+
+    //金融服务企业
+    let rzqylcColumn = ["rId", "eId", "financingAmount", "financingRounds", "fuHuaQiInvestment", "fuHuaQiInvestmentStyle", "fuHuaQiInvestmentAmount",
+        "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;
+
+    //知识产权
+    // 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) {
+    let nowTime = new Date().valueOf();
+
+    let selectParam = {};
+    if (name) selectParam["enterpriseName"] = { "%like%": name };
+
+    let dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, selectParam, ["eId", "enterpriseName"], {});
+    // let dbList = [];
+    // if (type.length != 0) {
+    //     for (let i = 0; i < type.length; i++) {
+    //         let manyTableInfo: any = {};
+    //         let info = type[i];
+    //         switch (info) {
+    //             case SELECTPARAM.在孵企业:
+    //                 manyTableInfo[TABLENAME.企业孵化信息] = { column: [], where: { "endTime": { "%gt%": nowTime } } };
+    //                 break;
+    //             case SELECTPARAM.融资企业:
+    //                 manyTableInfo[TABLENAME.企业融资] = { column: [], where: { "financingAmount": { "%ne%": null } } };
+    //                 break;
+    //             case SELECTPARAM.知识产权:
+    //                 manyTableInfo[TABLENAME.知识产权] = { column: [], where: {} };
+    //                 break;
+    //             case SELECTPARAM.专利:
+    //                 manyTableInfo[TABLENAME.企业专利表] = { column: [], where: {} };
+    //                 break;
+    //             case SELECTPARAM.科小:
+    //                 manyTableInfo[TABLENAME.企业资质] = { column: [], where: { "kxTime": { "%ne%": null } } };
+    //                 break;
+    //             case SELECTPARAM.专精特新:
+    //                 manyTableInfo[TABLENAME.企业资质] = { column: [], where: { "zjtxTime": { "%ne%": null } } };
+    //                 break;
+    //             case SELECTPARAM.小巨人:
+    //                 manyTableInfo[TABLENAME.企业资质] = { column: [], where: { "xjrTime": { "%ne%": null } } };
+    //                 break;
+    //             case SELECTPARAM.小巨人培育:
+    //                 manyTableInfo[TABLENAME.企业资质] = { column: [], where: { "xjrPyTime": { "%ne%": null } } };
+    //                 break;
+    //             case SELECTPARAM.高新技术:
+    //                 manyTableInfo[TABLENAME.企业资质] = { column: [], where: { "gaoXinJiShuTime": { "%ne%": null } } };
+    //                 break;
+    //         }
+
+    //         let enterpriseData = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, selectParam, ["eId", "enterpriseName"], manyTableInfo);
+    //         enterpriseData.forEach(item => {
+    //             dbList.push(item);
+    //         });
+    //     }
+    // } else {
+    //     dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, selectParam, ["eId", "enterpriseName"], {});
+    // }
+
+    let dataChange = [];
+    dbList.forEach(item => {
+        let { eId, enterpriseName } = item;
+        dataChange.push({ eId, enterpriseName });
+    })
+
+    //toupdate 要改掉 少用语法糖
+    /**
+     * @author: xiaoyouyou
+     */
+    // let dataList = [...new Map(dataChange.map(item => [item.eId, item])).values()];
+    let dataList = [];
+    let map = new Map();
+    for (let i = 0; i < dataChange.length; i++) {
+        let item = dataChange[i];
+        if (!map.has(item.eId)) {
+            map.set(item.eId, true);
+            dataList.push(item);
+        }
+    }
+
+    return dataList;
+}
+
+
+
+/**
+ * 变化趋势分析
+ * @param data 
+ */
+function getBhqsfx(data) {
+    let bhqsfx = {
+        "在孵": [],
+        "毕业": []
+    }
+
+    //todo 变化趋势分析 需要日志表
+    bhqsfx["在孵"] = [
+        { key: "2019", value: 4 },
+        { key: "2020", value: 4 },
+    ];
+    bhqsfx["毕业"] = [
+        { key: "2019", value: 4 },
+        { key: "2020", value: 4 },
+    ];
+    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;
+}
+
+
+/**
+ * 入孵时长分布--到期时间为孵化截至todo
+ * @param data 
+ */
+function getRfscfx(data) {
+    let rfscfx = {
+        "即将到期": 0, //3个月
+        "1年以内": 0,
+        "1-2年": 0,
+        "2-3年": 0,
+        "3-4年": 0
+    };
+
+    let nowTime = moment();
+    data.forEach(item => {
+        let parsedEndTime = moment(item.endTime); //获取入孵结束时间
+        let monthDiff = parsedEndTime.diff(nowTime, 'months');// 获取月份差值
+        
+        if (monthDiff >= 0 && monthDiff < 3) rfscfx.即将到期 += 1;
+        else if (monthDiff >= 3 && monthDiff < 12) rfscfx["1年以内"] += 1;
+        else if (monthDiff >= 12 && monthDiff < 24) rfscfx["1-2年"] += 1;
+        else if (monthDiff >= 24 && monthDiff < 36) rfscfx["2-3年"] += 1;
+        else if (monthDiff >= 36 && monthDiff < 48) rfscfx["3-4年"] += 1;
+    })
+
+    return rfscfx;
+}
+
+
+/**
+ * 企业服务汇总数据
+ * @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.企业专利}个` // 添加带单位的字段
+    };
+}
+
+
+/**
+ * 企业需求动态
+ */
+async function getQyxqdt(入孵申请dbList, 企业服务Count, 毕业企业数) {
+    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]);
+    })
+    //获取所有企业服务表联查企业信息表
+    let qyfwColumn = ["esId", "eId", "needCategory", "needContent"];
+    let 企业服务includeConf = {};
+    企业服务includeConf[TABLENAME.企业基础信息表] = { cloum: ["enterpriseName"], where: {} }
+    let 企业服务dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业服务表, {}, qyfwColumn, 企业服务includeConf);
+    企业服务dbList.forEach(info => {
+        // qyxqdtxx.push([info.enterprise.enterpriseName, "企业需求", info.enterprise.eId]);
+        qyxqdtxx.push([info.enterprise.enterpriseName]);
+    })
+
+    return { qyxqdt, qyxqdtxx };
+}
+
+
+/**
+ * 企业变化情况
+ * @param data 
+ */
+// function getQybhqk(data) {
+//     let qybhqk = {
+//         新增企业: 0, //统计当前年份入孵企业
+//         迁出企业: 0
+//     }
+
+//     let nowTime = moment();
+//     data.forEach(info => {
+//         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 qybhqk;
+}
+
+
+/**
+ * 企业变化情况——变化趋势
+ */
+function getQybhqkbhqs(data) {
+    let year = getYearList();
+    let hbqs = {
+        "企业数": []
+    }
+    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;
+        })
+        hbqs.企业数.push({ key: year[i], value: count });
+    }
+
+    let qybhqkbhqs = getChart(hbqs);
+
+    return qybhqkbhqs;
+}
+
+
+/**
+ * 金融服务
+ */
+async function getJrfw(data, 企业融资dbList) {
+    let jrfw = {
+        本月融资企业: 0,
+        本月融资金额: 0,
+        在孵企业总营收: 0
+    }
+
+    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 byrzqy = {
+        "融资企业": []
+    }
+    let byrzje = {
+        "融资金额": []
+    }
+    for (let i = 0; i < month.length; i++) {
+        let 企业count = 0;
+        let 金额count = 0;
+        企业融资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;
+    })
+
+    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 => {
+        switch (info.iprType) {
+            case IPRALLTYPE.软件著作权:
+                zscqbt.软件著作权 += info.number;
+                break;
+            case IPRALLTYPE.发明专利:
+                zscqbt.发明专利 += info.number;
+                break;
+            case IPRALLTYPE.海外专利:
+                zscqbt.海外专利 += info.number;
+                break;
+            case IPRALLTYPE.植物新品种:
+            case IPRALLTYPE.集成电路布图:
+                zscqbt.其他 += info.number;
+                break;
+        }
+    })
+
+    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 }
+}
+
+
+
+/**
+ * 企业人才--创业团队分布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/old/qyszhx.ts

+import moment = require("moment");
+import { AWARDLEVEL, DEGREE, FINANCINGROUNDS, IPRALLTYPE, NEEDCATEGORY, OPERATIONALDATATYPE, QUARTER, TABLENAME } from "../../config/enum";
+import { selectData, selectManyTableData } from "./operationalData";
+import { getChart, getKeyValue, getYearList } from "./out";
+import { changeEnumValue } from "../../tools/eccEnum";
+import { getMySqlMs } from "../../tools/systemTools";
+import { connectLogger } from "log4js";
+import { systemConfig } from "../../config/serverConfig";
+
+
+
+export async function getQyszhx(eId) {
+    let qyszhx = {
+        企业基本情况: { 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'] },
+        企业名称: { dataList: [], titleList: ['key', 'value'] },
+        营收情况: { dataList: [], titleList: ['key', 'value'] },
+        营收变化趋势: [],
+        企业动态: { bodyList: [], headerList: [['获奖数量', '获奖名称', '获奖时间', '颁奖单位', '奖项等级']] },
+        // 风险预警:{ bodyList: [], headerList: [['风险预警名称', '风险预警时间', '风险预警类型', '风险预警原因']] },
+        服务需求: { dataList: [], titleList: ['key', 'value'] },
+        活动变化趋势分析: [],
+        荣誉资质图片: {},
+        服务记录_空间服务: { bodyList: [], headerList: [['服务名称', '服务时间', '服务内容']] },
+        服务记录_工商服务: { bodyList: [], headerList: [['服务名称', '服务时间', '服务内容']] },
+        服务记录_融资服务: { bodyList: [], headerList: [['服务名称', '服务时间', '服务内容']] },
+        服务记录: { dataList: [], titleList: ['key', 'value'] },
+        历年人才招聘情况: [],
+    }
+
+    /**数据库查询 */
+    let 企业基础信息 = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业基础信息表, { eId }, null);
+    if (!Object.keys(企业基础信息).length) console.log('eId：', eId);
+
+    // let column = ["eId", "enterpriseName", "uscc", "", "", "", "", "", "", "", "", "", "", "", ""];
+    let 孵化Column = ["fId", "eId", "startTime", "endTime", "state", "virtualCause", "virtualCauseDes", "moveOutType", "moveOutTrace", "moveOutCause", "moveOutTime",
+        "graduationTime", "jiShuHeTongJiaoYi"];
+
+    let 企业孵化联查includeConf = {};
+    企业孵化联查includeConf[TABLENAME.企业孵化信息] = { cloum: 孵化Column, where: {} }
+    let 企业孵化信息 = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, { eId }, [], 企业孵化联查includeConf);
+
+    let 资质Column = ["qId", "eId", "kxTime", "zjtxTime", "xjrTime", "xjrPyTime", "goPublicTime", "gaoXinJiShuTime", "goPublicSector"];
+    let 企业资质联查includeConf = {};
+    企业资质联查includeConf[TABLENAME.企业资质] = { cloum: 资质Column, where: {} }
+    let 企业资质信息 = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, { eId }, [], 企业资质联查includeConf);
+
+    let 专利Column = ["iprId", "eId", "year", "number", "iprType", "selectedValue", "iprName", "iprUrl"];
+    let 企业专利联查includeConf = {};
+    企业专利联查includeConf[TABLENAME.知识产权] = { cloum: 专利Column, where: {} }
+    let 企业专利信息 = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, { eId }, [], 企业专利联查includeConf);
+
+    let 创业团队Column = ["tId", "eId", "name", "sex", "birth", "degree", "graduationSchool", "talentType", "des"];
+    let 创业团队联查includeConf = {};
+    创业团队联查includeConf[TABLENAME.创业团队] = { cloum: 创业团队Column, where: {} }
+    let 创业团队信息 = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, { eId }, [], 创业团队联查includeConf);
+
+    let 企业经营Column = ["mId", "eId", "annual", "BI", "TXP", "RD", "createTime", "state"];
+    let 企业经营联查includeConf = {};
+    企业经营联查includeConf[TABLENAME.企业经营信息] = { cloum: 企业经营Column, where: {} }
+    let 企业经营信息 = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, { eId }, [], 企业经营联查includeConf);
+
+    let 企业荣誉Column = ["hId", "eId", "awardName", "awardingUnit", "awardTime", "awardLevel", "awardImg"];
+    let 企业荣誉联查includeConf = {};
+    企业荣誉联查includeConf[TABLENAME.企业荣誉] = { cloum: 企业荣誉Column, where: {} }
+    let 企业荣誉信息 = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, { eId }, [], 企业荣誉联查includeConf);
+
+    let 企业融资Column = ["rId", "eId", "financingAmount", "financingRounds", "fuHuaQiInvestment", "fuHuaQiInvestmentStyle",
+        "fuHuaQiInvestmentAmount", "investmentDate", "investmentInstitutionsName", "valuation"];
+    let 企业融资联查includeConf = {};
+    企业融资联查includeConf[TABLENAME.企业融资] = { cloum: 企业融资Column, where: {} }
+    let 企业融资信息 = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, { eId }, [], 企业融资联查includeConf);
+
+    let 企业服务Column = ["esId", "eId", "needCategory", "needContent", "applyTime", "followUpStatus", "resolveTime", "fangKui",
+        "shouLiTime", "outcome", "desc"];
+    let 企业服务联查includeConf = {};
+    企业服务联查includeConf[TABLENAME.企业服务表] = { cloum: 企业服务Column, where: {} }
+    let 企业服务信息 = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, { eId }, [], 企业服务联查includeConf);
+
+    let 参保记录Column = ["cId", "eId", "annual", "zhuanKe", "benKe", "shuoshi", "boShi", "boshiyishang", "qiTa"];
+    let 参保记录联查includeConf = {};
+    参保记录联查includeConf[TABLENAME.参保记录] = { cloum: 参保记录Column, where: {} }
+    // let 参保记录信息 = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, { eId }, [], 参保记录联查includeConf);
+    let 参保记录信息 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.参保记录, { eId }, 参保记录Column);
+
+    let 租赁信息Column = ["leaseId", "eId", "area", "startTime", "endTime"];
+    let 租赁信息联查includeConf = {};
+    租赁信息联查includeConf[TABLENAME.租赁信息] = { cloum: 租赁信息Column, where: {} }
+    let 租赁信息 = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, { eId }, [], 租赁信息联查includeConf);
+
+    //企业基本情况
+    let qyjbqk = {
+        企业介绍: 企业基础信息.jianJie,
+        // 企业图片: "企业照片占位图.png",
+    };
+    //企业基本数据
+    qyszhx.企业基本情况.dataList = getKeyValue(qyjbqk);
+
+    /**
+     * 企业名称
+     */
+    let qyName = {
+        企业名称: 企业基础信息.enterpriseName
+    };
+    qyszhx.企业名称.dataList = getKeyValue(qyName);
+
+
+    let qyjbsj = {
+        注册时间: "-",
+        迁入时间: "-",
+        首次入孵时间: "-",
+    };
+    if (企业基础信息.logonTime) qyjbsj.注册时间 = moment(企业基础信息.logonTime).format("YYYY-MM-DD")
+    if (企业孵化信息[0]) {
+        if (企业孵化信息[0].enterprise_fuhuas[0].startTime) qyjbsj.首次入孵时间 = moment(企业孵化信息[0].enterprise_fuhuas[0].startTime).format("YYYY-MM-DD")
+    }
+    if (企业基础信息.firstLoginTime) qyjbsj.迁入时间 = moment(企业基础信息.firstLoginTime).format("YYYY-MM-DD")
+    qyszhx.企业基本数据.dataList = getKeyValue(qyjbsj);
+
+    //企业标签 todo
+    let qybq = get企业标签(企业资质信息);
+    qyszhx.企业标签.dataList = qybq;
+
+    // 计算研发占比
+    let yfzb = get研发占比(企业经营信息);
+    // 将研发占比数据添加到 qyszhx 对象中
+    qyszhx.研发占比.dataList = getKeyValue(yfzb);
+
+    /**
+     * 企业自画像
+     */
+    let qyzp = get企业自画像(企业经营信息, 企业融资信息, 企业专利信息);
+    qyszhx.企业自画像.dataList = getKeyValue(qyzp);
+
+    //租房补贴
+    let zfbz = get租房补贴(企业资质信息, 企业专利信息, 参保记录信息);
+    qyszhx.租房补贴.dataList = getKeyValue(zfbz);
+
+    // //高新
+    // let gx = get高新(企业资质信息);
+    // qyszhx.高新.dataList = getKeyValue(gx);
+
+    // //科小
+    // let kx = get科小(企业资质信息);
+    // qyszhx.科小.dataList = getKeyValue(kx);
+
+    // //小巨人
+    // let xjt = get小巨人(企业资质信息);
+    // qyszhx.小巨人.dataList = getKeyValue(xjt);
+
+    // 高新
+    let gx = get资质达标情况(企业资质信息, 'gaoXinJiShuTime');
+    qyszhx.高新.dataList = getKeyValue(gx);
+
+    // 科小
+    let kx = get资质达标情况(企业资质信息, 'kxTime');
+    qyszhx.科小.dataList = getKeyValue(kx);
+
+    // 小巨人
+    let xjrData = get资质达标情况(企业资质信息, 'xjrTime');
+    qyszhx.小巨人.dataList = getKeyValue(xjrData);
+
+    //资质认证
+    let zzrz = get资质认证(企业资质信息);
+    qyszhx.资质认证.dataList = getKeyValue(zzrz);
+
+    //资质认证变化趋势
+    let zzrzbsqs = get资质认证变化趋势(企业资质信息);
+    qyszhx.资质认证变化趋势 = zzrzbsqs;
+
+    //知识产权
+    let zscq = get知识产权(企业专利信息);
+    qyszhx.知识产权.dataList = getKeyValue(zscq);
+
+    //企业员工画像
+    let qyyghx = await get企业员工画像(参保记录信息);
+    qyszhx.企业员工画像.dataList = getKeyValue(qyyghx);
+
+    let 专利总数 = 0;
+    for (let key in zscq) {
+        专利总数 += zscq[key];
+    }
+    //企业汇总数据
+    let qyhzsj = {
+        // 企业认证:0, //todo 
+        资质认证: qybq.length,
+        专利数: 专利总数,
+    };
+
+    qyszhx.企业汇总数据.dataList = getKeyValue(qyhzsj);
+
+    //营收情况
+    let { ysqk, ysbhqs } = get营收情况(企业经营信息);
+    qyszhx.营收情况.dataList = getKeyValue(ysqk);
+
+    //营收变化趋势
+    qyszhx.营收变化趋势 = ysbhqs;
+
+    //企业动态
+    let qydt = get企业动态(企业荣誉信息);
+    qyszhx.企业动态.bodyList = qydt;
+
+    //风险预警
+    // let fxyj = get风险预警(企业融资信息);
+    // qyszhx.风险预警.bodyList = fxyj;
+
+
+    //服务需求
+    let fwxq = get服务需求(企业融资信息);
+    qyszhx.服务需求.dataList = getKeyValue(fwxq);
+
+    //活动变化趋势分析
+    let hdbhqsfx = get活动变化趋势分析(企业融资信息);
+    qyszhx.活动变化趋势分析 = hdbhqsfx;
+
+    //荣誉资质
+    let ryzz = get荣誉资质(企业荣誉信息);
+    qyszhx.荣誉资质图片 = ryzz;
+
+
+    //服务记录_空间服务
+    let fwjlxx = get服务记录(企业服务信息);
+    // qyszhx.服务记录_空间服务.bodyList = fwjlxx.空间服务;
+    qyszhx.服务记录_工商服务.bodyList = fwjlxx.工商服务;
+    qyszhx.服务记录_融资服务.bodyList = fwjlxx.融资服务;
+
+    //服务记录
+    let fwjl = {
+        // 空间服务次数: fwjlxx.空间服务.length,
+        工商服务次数: fwjlxx.工商服务.length,
+        融资服务次数: fwjlxx.融资服务.length,
+    }
+    qyszhx.服务记录.dataList = getKeyValue(fwjl);
+
+
+
+    //就业
+    let jiuYeList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.参保记录, { eId }, null);
+    let 年度就业人数趋势分析Map = {};
+    jiuYeList.forEach(info => {
+        let { 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 (!年度就业人数趋势分析Map[itemYear]) 年度就业人数趋势分析Map[itemYear] = { key: itemYear, value: 0 };
+        年度就业人数趋势分析Map[itemYear].value += itemCount;
+    });
+    qyszhx.历年人才招聘情况 = [{ name: "历年人才招聘情况", data: Object.values(年度就业人数趋势分析Map) }];
+
+    return qyszhx;
+}
+
+/**
+ * 计算研发占比的函数
+*/
+// function get研发占比(data) {
+//     let yfzb = [];
+
+//     data.forEach(info => {
+//         let { enterprise_manages } = info;
+//         enterprise_manages.forEach(manage => {
+//             if (parseFloat(manage.BI) > 0) {
+//                 let ratio = parseFloat(manage.RD) / parseFloat(manage.BI);
+//                 let 百分比 = (ratio * 100).toFixed(2) + "%";
+//                 let 达标状态: string;
+//                 // 判断是否已达标
+//                 if(ratio * 100 >= 80.5){
+//                     达标状态 = "已达标";
+//                 }else{
+//                     达标状态 = "继续努力";
+
+//                 }
+
+//                 yfzb.push({
+//                     年份: moment(manage.annual).format("YYYY"), 
+//                     研发占比: 百分比,
+//                     达标状态: 达标状态
+//                 });
+//             }
+//         });
+//     });
+
+//     return yfzb;
+// }
+
+function get研发占比(data) {
+    let yfzb = {
+        研发占比: "0%",
+        是否达标: "继续努力",
+        目标值: "20%",
+    }
+
+    data.forEach(info => {
+        let { enterprise_manages } = info;
+        let quarterlyRD = { [QUARTER.第一季度]: 0, [QUARTER.第二季度]: 0, [QUARTER.第三季度]: 0, [QUARTER.第四季度]: 0 };
+        let quarterlyBI = { [QUARTER.第一季度]: 0, [QUARTER.第二季度]: 0, [QUARTER.第三季度]: 0, [QUARTER.第四季度]: 0 };
+
+        enterprise_manages.forEach(manage => {
+            if (parseFloat(manage.BI) > 0) {
+                const quarter = getQuarter(manage.annual);
+                quarterlyRD[quarter] += parseFloat(manage.RD);
+                quarterlyBI[quarter] += parseFloat(manage.BI);
+            }
+        });
+
+        // 计算每个季度的研发占比，并生成年份信息
+        for (let quarter of [QUARTER.第一季度, QUARTER.第二季度, QUARTER.第三季度, QUARTER.第四季度]) {
+            if (quarterlyBI[quarter] > 0) {
+                let ratio = quarterlyRD[quarter] / quarterlyBI[quarter];
+                let 百分比 = (ratio * 100).toFixed(2) + "%";
+                let 达标状态: string;
+
+                if (ratio * 100 >= 20) {
+                    达标状态 = "已达标";
+                } else {
+                    达标状态 = "继续努力";
+                }
+                yfzb.研发占比 = 百分比;
+                yfzb.是否达标 = 达标状态;
+                yfzb.目标值 = "20%";
+
+                // // 确保年份信息从 manage 中正确提取
+                // let 年份 = moment(enterprise_manages[0]?.annual).format("YYYY"); // 假设所有季度属于同一年
+                // yfzb.push({
+                //     年份,
+                //     研发占比: 百分比,
+                //     达标状态,
+                //     目标值: "20%",
+                // });
+            }
+        }
+    });
+
+    return yfzb;
+}
+
+function getQuarter(dateString: string): QUARTER {
+    const date = moment(dateString);
+    if (!date.isValid()) {
+        console.error("无效的日期字符串:", dateString);
+        return QUARTER.第一季度; // 或者抛出异常，具体取决于业务需求
+    }
+
+    const month = date.month() + 1; // JavaScript 月份从0开始
+    if (month <= 3) return QUARTER.第一季度;
+    if (month <= 6) return QUARTER.第二季度;
+    if (month <= 9) return QUARTER.第三季度;
+    return QUARTER.第四季度;
+}
+/**
+ *  企业自画像
+*/
+function get企业自画像(企业经营信息, 企业融资信息, 企业专利信息) {
+    // 初始化企业自画像数据
+    let qyzp = {
+        企业总得分: "-",
+        企业融资: "-",
+        // 总融资金额: 0, // 新增总融资金额字段
+        本年融资额: 0,
+        短期营收: "-",
+        营收金额: 0,
+        知识产权: "-",
+        专利个数: 0,
+        研发投入: "-",
+        投入金额: 0,
+        研发占比: "-",
+    };
+
+    // 获取当前月份
+    // const 当前月份 = new Date().getMonth() + 1; // JavaScript 月份从0开始
+    const 当前年份 = new Date().getFullYear();
+
+    // 计算各维度得分
+    let 优秀维度计数 = 0;
+
+    // 1. 判断企业融资是否优秀
+    let 本年融资总额 = 0;
+    let 总融资金额 = 0;
+    企业融资信息.forEach(info => {
+        let { enterprise_financings } = info;
+        if (Array.isArray(enterprise_financings)) {
+            enterprise_financings.forEach(financing => {
+                const 融资日期 = new Date(financing.investmentDate);
+                if (
+                    融资日期.getFullYear() === 当前年份
+                    // 融资日期.getMonth() + 1 === 当前月份
+                ) {
+                    本年融资总额 += parseFloat(financing.financingAmount || 0);
+                }
+                // 累加总融资金额
+                总融资金额 += parseFloat(financing.financingAmount || 0);
+            });
+        }
+    });
+
+    qyzp["本年融资额"] = 本年融资总额; // 返回本月融资额
+    // qyzp["总融资金额"] = 总融资金额; // 返回总融资金额
+
+    if (总融资金额 > 0) {
+        if (总融资金额 >= 10) { // 修改为企业融资：10W及以上为优秀,
+            qyzp["企业融资"] = "优秀";
+            优秀维度计数++;
+        } else {
+            qyzp["企业融资"] = "良好";
+        }
+    } else {
+        qyzp["企业融资"] = "-";
+    }
+
+
+    // 2. 判断短期营收是否优秀
+    let 短期营收总额 = 0;
+    企业经营信息.forEach(info => {
+        let { enterprise_manages } = info;
+        enterprise_manages.forEach(manage => {
+            短期营收总额 += parseFloat(manage.BI);
+        });
+    });
+
+    qyzp["营收金额"] = 短期营收总额; // 返回营收金额
+
+    if (短期营收总额 > 0) {
+        if (短期营收总额 >= 1000000) { // 修改为营收:100W及以上为优秀
+            qyzp["短期营收"] = "优秀";
+            优秀维度计数++;
+        } else {
+            qyzp["短期营收"] = "良好";
+        }
+    } else {
+        qyzp["短期营收"] = "-";
+    }
+
+    // 3. 判断知识产权是否优秀
+    let 专利总数 = 0;
+    企业专利信息.forEach(info => {
+        let { enterprise_iprs } = info;
+        专利总数 += enterprise_iprs.length;
+    });
+
+    qyzp["专利个数"] = 专利总数; // 返回专利个数
+
+    if (专利总数 > 0) {
+        if (专利总数 >= 2) { // 修改为知识产权：两个及以上为优秀
+            qyzp["知识产权"] = "优秀";
+            优秀维度计数++;
+        } else if (专利总数 === 1) {
+            qyzp["知识产权"] = "良好";
+        }
+    } else {
+        qyzp["知识产权"] = "-";
+    }
+
+
+    // 4. 判断研发投入是否优秀
+    let 研发投入总额 = 0;
+    let 总收入 = 0;
+    企业经营信息.forEach(info => {
+        let { enterprise_manages } = info;
+        enterprise_manages.forEach(manage => {
+            研发投入总额 += parseFloat(manage.RD);
+            总收入 += parseFloat(manage.BI);
+        });
+    });
+
+    let 研发占比 = 总收入 > 0 ? (研发投入总额 / 总收入) : 0;
+    qyzp["投入金额"] = 研发投入总额; // 返回研发投入金额
+    qyzp["研发占比"] = `${(研发占比 * 100).toFixed(2)}%`;
+
+    if (研发占比 > 0) {
+        if (研发占比 >= 0.2) { // 修改为研发占比：20%以上为优秀
+            qyzp["研发投入"] = "优秀";
+            优秀维度计数++;
+        } else {
+            qyzp["研发投入"] = "良好";
+        }
+    } else {
+        qyzp["研发投入"] = "-";
+    }
+
+    // 根据优秀维度计数确定企业总评等级
+    if (优秀维度计数 > 0) {
+        if (优秀维度计数 >= 2) {
+            qyzp["企业总得分"] = "优秀";
+        } else {
+            qyzp["企业总得分"] = "良好";
+        }
+    } else {
+        qyzp["企业总得分"] = "-";
+    }
+
+    return qyzp;
+}
+
+/**
+ * 租房补贴
+ */
+function get租房补贴(企业资质信息, 企业专利信息, 参保记录信息) {
+    let zfbt = {
+        租房补贴占比: "",
+        是否达标: "",
+        社保: "",
+        软著: "",
+        科小: "",
+    };
+
+    // 检查社保状态
+    let shebaoCompleted = false;
+    if (参保记录信息[0]) {
+        
+        if (参保记录信息[0].zhuanKe || 参保记录信息[0].benKe || 参保记录信息[0].shuoshi || 参保记录信息[0].boShi || 参保记录信息[0].boshiyishang || 参保记录信息[0].qiTa ) {
+            shebaoCompleted = true;
+        }
+    }
+
+    zfbt.社保 = shebaoCompleted ? "已完成" : "未完成";
+
+    // 检查软著状态
+    let ruanzhuCompleted = false;
+    企业专利信息.forEach(info => {
+        let { enterprise_iprs } = info;
+        enterprise_iprs.forEach(patent => {
+            if (patent.iprType === IPRALLTYPE.软件著作权) {
+                ruanzhuCompleted = true;
+            }
+        });
+    });
+    zfbt.软著 = ruanzhuCompleted ? "已完成" : "未完成";
+
+    // 检查科小状态
+    let kxCompleted = false;
+    企业资质信息.forEach(info => {
+        let { enterprise_qualifications } = info;
+        enterprise_qualifications.forEach(item => {
+            if (item.kxTime) {
+                kxCompleted = true;
+            }
+        });
+    });
+    zfbt.科小 = kxCompleted ? "已完成" : "未完成";
+
+    // 计算租房补贴占比
+    const 完成条件数 = [shebaoCompleted, ruanzhuCompleted, kxCompleted].filter(status => status).length;
+    const 总条件数 = 3;
+    const 租房补贴占比 = (完成条件数 / 总条件数) * 100;
+
+    // 判断是否达标
+    const 是否达标 = 完成条件数 === 总条件数 ? "已达标" : "继续努力";
+
+    zfbt.租房补贴占比 = `${租房补贴占比.toFixed(2)}%`;
+    zfbt.是否达标 = 是否达标;
+
+    return zfbt;
+}
+
+// /**
+//  * 高新
+//  */
+// function get高新(data) {
+//     let gx = {
+//         高新占比: 0,
+//         是否达标: "未达标",
+//     };
+
+//     data.forEach(info => {
+//         let { enterprise_qualifications } = info;
+//         enterprise_qualifications.forEach(item => {
+//             if (item.gaoXinJiShuTime) {
+//                 gx.高新占比 = 100;
+//                 gx.是否达标 = "已达标";
+//             }
+//         });
+//     });
+
+//     return gx;
+// }
+
+// /**
+//  * 科小
+//  */
+// function get科小(data) {
+//     let kx = {
+//         科小占比: 0,
+//         是否达标: "未达标",
+//     };
+
+//     data.forEach(info => {
+//         let { enterprise_qualifications } = info;
+//         enterprise_qualifications.forEach(item => {
+//             if (item.kxTime) {
+//                 kx.科小占比 = 100;
+//                 kx.是否达标 = "已达标";
+//             }
+//         })
+//     })
+
+//     return kx;
+// }
+
+// /**
+//  * 小巨人
+//  */
+// function get小巨人(data){
+//     let xjrData = {
+//         小巨人占比: 0,
+//         是否达标: "未达标",
+//     };
+
+//     data.forEach(info => {
+//         let { enterprise_qualifications } = info;
+//         enterprise_qualifications.forEach(item => {
+//             if (item.xjrTime) {
+//                 xjrData.小巨人占比 = 100;
+//                 xjrData.是否达标 = "已达标";
+//             }
+//         })
+//     })
+
+//     return xjrData;
+// }
+
+/**
+ * 获取企业资质达标情况的通用函数
+ * @param data 企业资质数据
+ * @param key 判断依据的字段名（如 'gaoXinJiShuTime', 'kxTime', 'xjrTime'）
+ * @returns 达标情况对象
+ */
+function get资质达标情况(data, key: string) {
+    let result = {
+        占比: 0,
+        是否达标: "继续努力",
+    };
+
+    data.forEach(info => {
+        let { enterprise_qualifications } = info;
+        enterprise_qualifications.forEach(item => {
+            if (item[key]) {
+                result.占比 = 100;
+                result.是否达标 = "已达标";
+            } else {
+                result.占比 = 0;
+                result.是否达标 = "继续努力";
+            }
+        });
+    });
+
+    return result;
+}
+
+
+function get企业标签(data) {
+    let qybqData = [];
+
+    data.forEach(info => {
+        let { enterprise_qualifications } = info;
+        enterprise_qualifications.forEach(item => {
+            if (item.xjrTime) qybqData.push("小巨人");
+            if (item.gaoXinJiShuTime) qybqData.push("高新企业");
+            if (item.zjtxTime) qybqData.push("专精特新");
+            if (item.xjrPyTime) qybqData.push("小巨人培育");
+            if (item.kxTime) qybqData.push("科小");
+            if (item.goPublicTime) qybqData.push("上市");
+        })
+    })
+
+    let qybq = [];
+    qybqData.forEach(item => {
+        qybq.push({ key: "文本", value: item });
+    })
+
+    return qybq;
+}
+
+
+/** 资质认证
+ * @returns 
+ */
+function get资质认证(data) {
+    let zzrz = {
+        资质认证总数: 0,
+    };
+
+    data.forEach(info => {
+        let { enterprise_qualifications } = info;
+        let certifications = new Set(); // 使用 Set 来存储不同的资质认证
+
+        enterprise_qualifications.forEach(item => {
+            if (item.kxTime) certifications.add("科小");
+            if (item.zjtxTime) certifications.add("专精特新");
+            if (item.xjrTime) certifications.add("小巨人");
+            if (item.xjrPyTime) certifications.add("小巨人培育");
+            if (item.gaoXinJiShuTime) certifications.add("高新企业");
+            if (item.goPublicTime) certifications.add("上市");
+        });
+
+        zzrz.资质认证总数 += certifications.size; // 计算不同资质的数量
+    });
+
+    return zzrz;
+}
+
+/**
+ * 资质认证变化趋势
+ */
+function get资质认证变化趋势(data) {
+    let zzrzbhqsInfo = {
+        资质认证数量: []
+    };
+
+    let yearList = getYearList();
+
+    for (let i = 0; i < yearList.length; i++) {
+        let year = parseInt(yearList[i]);
+        let 资质认证数量 = 0;
+
+        data.forEach(info => {
+            let { enterprise_qualifications } = info;
+            enterprise_qualifications.forEach(item => {
+                const times = [
+                    item.kxTime,
+                    item.zjtxTime,
+                    item.xjrTime,
+                    item.xjrPyTime,
+                    item.gaoXinJiShuTime,
+                    item.goPublicTime
+                ];
+
+                times.forEach(time => {
+                    if (time && moment(time).year() === year) {
+                        资质认证数量++;
+                    }
+                });
+            });
+        });
+
+        zzrzbhqsInfo.资质认证数量.push({ key: year, value: 资质认证数量 });
+    }
+
+    let zzrzbhqs = getChart(zzrzbhqsInfo);
+
+    return zzrzbhqs;
+}
+
+
+function get知识产权(data) {
+    let zscq: any = {
+        // 软件著作:0,
+        软件著作权: 0,
+        发明专利: 0,
+        海外专利: 0,
+        植物新品种: 0,
+        集成电路布图: 0,
+    }
+
+    data.forEach(info => {
+        let { enterprise_iprs } = info;
+        enterprise_iprs.forEach(patents => {
+            if (patents.iprType) {
+                let iprTypeStr = changeEnumValue(IPRALLTYPE, patents.iprType);
+                if (!zscq[iprTypeStr]) zscq[iprTypeStr] = 0;
+                zscq[iprTypeStr] += patents.number;
+            }
+        })
+
+    })
+
+    // data.forEach(info => {
+    //     let { enterprise_patents } = info;
+    //     enterprise_patents.forEach(patents => {
+    //         zscq.一级专利 += patents.classIPatent;
+    //         zscq.二级专利 += patents.secondClassPatent
+    //         zscq.三级专利 += patents.thirdPentent;
+    //         zscq.海外专利 += patents.alienPatent;
+    //     })
+    // })
+
+    return zscq;
+}
+
+
+async function get企业员工画像(data) {
+    let qyyghx = {
+        "专科":0,
+        "本科":0,
+        "硕士":0,
+        "博士":0,
+        "博士以上":0,
+        "其他":0,
+    };
+
+    if (data && data[0]) {
+        qyyghx["专科"] = data[0].zhuanKe || 0;
+        qyyghx["本科"] = data[0].benKe || 0;
+        qyyghx["硕士"] = data[0].shuoshi || 0;
+        qyyghx["博士"] = data[0].boShi || 0;
+        qyyghx["博士以上"] = data[0].boshiyishang || 0;
+        qyyghx["其他"] = data[0].qiTa || 0;
+    }
+   
+
+
+    // for (let key in DEGREE) {
+    //     let anyKey: any = key;
+    //     if (isNaN(anyKey)) {
+    //         let keyStr = key;
+    //         if (!qyyghx[keyStr]) qyyghx[keyStr] = 0;
+    //         let degree = DEGREE[key];
+    //         data.forEach(info => {
+    //             let { enterprise_teams } = info;
+    //             if (enterprise_teams && Array.isArray(enterprise_teams)) {
+    //                 enterprise_teams.forEach(team => {
+    //                     if (degree == team.degree) {
+    //                         qyyghx[keyStr] += 1;
+    //                     }
+    //                 })
+    //             }
+    //         })
+    //     }
+    // }
+
+    return qyyghx;
+}
+
+
+function get营收情况(data) {
+    let ysqk = {
+        // 累计营收: 0,
+        "24年累计营收": 0,
+        累计研发投入: 0,
+        // 累计纳税: 0
+    }
+
+    let ysbhqsInfo = {
+        营业收入: [],
+        研发投入: [],
+        // 纳税金额: [],
+    }
+
+    let year = getYearList();
+
+    data.forEach(info => {
+        let { enterprise_manages } = info;
+        enterprise_manages.forEach(manage => {
+            // ysqk.累计营收 += parseFloat(manage.BI);
+            let thisAnnual = moment(manage.annual).year();
+            if (thisAnnual === 2024) {
+                ysqk["24年累计营收"] += parseFloat(manage.BI);
+            }
+            ysqk.累计研发投入 += parseFloat(manage.RD);
+            // ysqk.累计纳税 += parseFloat(manage.TXP);
+
+        })
+    })
+
+
+    for (let i = 0; i < year.length; i++) {
+        let 营业收入 = 0;
+        let 研发投入 = 0;
+        // let 纳税金额 = 0;
+        data.forEach(info => {
+            let { enterprise_manages } = info;
+            enterprise_manages.forEach(manage => {
+                let thisAnnual = moment(manage.annual).year();
+                let thisYear = parseInt(year[i]);
+                if (thisAnnual === thisYear) {
+                    营业收入 += parseFloat(manage.BI);
+                    研发投入 += parseFloat(manage.RD);
+                    // 纳税金额 += parseFloat(manage.TXP);
+                }
+
+            })
+        })
+        // ysbhqsInfo.营业收入.push({ key: year[i], value: 营业收入 });
+        // ysbhqsInfo.研发投入.push({ key: year[i], value: 研发投入 });
+        // 将营业收入和研发投入转换为“千万”单位
+        ysbhqsInfo.营业收入.push({ key: year[i], value: 营业收入 / 1000 });
+        ysbhqsInfo.研发投入.push({ key: year[i], value: 研发投入 / 1000 });
+        // ysbhqsInfo.纳税金额.push({ key: year[i], value: 纳税金额 });
+    }
+
+    let ysbhqs = getChart(ysbhqsInfo);
+
+    return { ysqk, ysbhqs };
+}
+
+/**
+ * 企业动态
+ */
+// function get企业动态(data) {
+//     let qydt = [];
+
+//     data.forEach(info => {
+//         let { enterprise_honors } = info;
+//         enterprise_honors.forEach(honors => {
+//             let awardLevel = changeEnumValue(AWARDLEVEL, honors.awardLevel);
+//             let awardImg = JSON.parse(honors.awardImg)
+//             let awardTime = moment(honors.awardTime).format("YYYY-MM-DD");
+//             qydt.push([awardImg[0], honors.awardName, awardTime, honors.awardingUnit, awardLevel]);
+//         })
+//     })
+
+//     return qydt;
+// }
+function get企业动态(data) {
+    let qydt = [];
+    let honorsCount = 0;
+
+    data.forEach(info => {
+        let { enterprise_honors } = info;
+        honorsCount += enterprise_honors.length;
+        enterprise_honors.forEach(honors => {
+            let awardLevel = changeEnumValue(AWARDLEVEL, honors.awardLevel);
+            let awardTime = moment(honors.awardTime).format("YYYY");
+            qydt.push([honorsCount, honors.awardName, awardTime, honors.awardingUnit, awardLevel]);
+        })
+    })
+
+    return qydt;
+}
+
+/**
+ *风险预警
+ */
+function get风险预警(data) {
+}
+
+function get服务需求(data) {
+    let newestFinancing: any = {};
+    data.forEach(info => {
+        let { enterprise_financings } = info;
+        let enterprise_financingsData = [];
+
+        enterprise_financings.forEach(financings => {
+            enterprise_financingsData.push({
+                financingAmount: financings.financingAmount,
+                financingRounds: financings.financingRounds,
+                investmentDate: new Date(financings.investmentDate).valueOf(),
+                investmentInstitutionsName: financings.investmentInstitutionsName
+            })
+        })
+        //获取最新时间的融资信息
+        enterprise_financingsData.sort((a, b) => {
+            return b.investmentDate - a.investmentDate;
+        })
+        newestFinancing = enterprise_financingsData[0];
+    })
+
+    // 确保 financingAmount 不为 undefined 或 null，否则设置为 0
+    const financingAmount = newestFinancing.financingAmount !== undefined && newestFinancing.financingAmount !== null ? newestFinancing.financingAmount : 0;
+
+
+    let fwxq = {
+        // 融资金额: `${newestFinancing.financingAmount}万元`,
+        融资金额: `${financingAmount}万元`,
+        融资轮次: changeEnumValue(FINANCINGROUNDS, newestFinancing.financingRounds),
+        融资时间: "-",
+        投资机构: newestFinancing.investmentInstitutionsName
+    };
+
+    if (newestFinancing.investmentDate) fwxq.融资时间 = moment(newestFinancing.investmentDate).format("YYYY-MM-DD");
+
+    return fwxq;
+}
+
+
+function get活动变化趋势分析(data) {
+    let hdbhqsfxInfo = {
+        融资额: [],
+        // 融资事件: [],
+    }
+    let year = getYearList();
+    for (let i = 0; i < year.length; i++) {
+        let 融资额 = 0;
+        // let 融资事件 = 0;
+        data.forEach(info => {
+            let { enterprise_financings } = info;
+            enterprise_financings.forEach(financings => {
+                let thisAnnual = moment(financings.investmentDate).year();
+                let thisYear = parseInt(year[i]);
+                if (thisAnnual === thisYear) {
+                    融资额 += parseFloat(financings.financingAmount);
+                    // 融资事件 += 1;
+                }
+
+            })
+
+        })
+        hdbhqsfxInfo.融资额.push({ key: year[i], value: 融资额 });
+        // hdbhqsfxInfo.融资事件.push({ key: year[i], value: 融资事件 });
+    }
+
+    let hdbhqsfx = getChart(hdbhqsfxInfo);
+
+    return hdbhqsfx;
+}
+
+//荣誉资质
+// function get荣誉资质(data) {
+//     let ryzz = [];
+//     data.forEach(info => {
+//         let { enterprise_honors } = info;
+//         enterprise_honors.forEach(honors => {
+//             let awardLevel = changeEnumValue(AWARDLEVEL, honors.awardLevel);
+//             let awardImg = JSON.parse(honors.awardImg)
+//             let imgPath = `${systemConfig.imgFileUrl}${awardImg[0]}`;
+//             ryzz.push([imgPath, awardLevel]);
+//         })
+//     })
+
+//     return ryzz;
+// }
+
+// 修改后的荣誉资质函数
+function get荣誉资质(data) {
+    let ryzz = [];
+    data.forEach(info => {
+        let { enterprise_honors } = info;
+        enterprise_honors.forEach(honors => {
+            let awardLevel = changeEnumValue(AWARDLEVEL, honors.awardLevel);
+            let awardImg = JSON.parse(honors.awardImg);
+            // 遍历所有图片
+            awardImg.forEach(imgName => {
+                let imgPath = `${systemConfig.imgFileUrl}${imgName}`;
+                ryzz.push([imgPath, awardLevel]);
+            });
+        })
+    })
+    return ryzz;
+}
+
+function get服务记录(data) {
+    let fwjl = {
+        // 空间服务: [],
+        工商服务: [],
+        融资服务: []
+    };
+
+    data.forEach(info => {
+        let { enterprise_services } = info;
+        enterprise_services.forEach(service => {
+            let needCategory = changeEnumValue(NEEDCATEGORY, service.needCategory);
+            // if ( service.needCategory == NEEDCATEGORY.空间服务) {
+            //     fwjl.空间服务.push([needCategory, service.resolveTime, service.needContent])
+            // } else 
+            if (service.needCategory == NEEDCATEGORY.工商服务) {
+                fwjl.工商服务.push([needCategory, service.resolveTime, service.needContent])
+            } else if (service.needCategory == NEEDCATEGORY.融资服务) {
+                fwjl.融资服务.push([needCategory, service.resolveTime, service.needContent])
+            }
+        })
+    })
+
+    return fwjl;
+}
+

src/data/db/old/zhyy.ts

+import moment = require("moment");
+import { AWARDLEVEL, EMIGRATIONTYPE, FOLLOWUPSTATUS, FUHUASTATE, INDUSTRY, MOVEOUTTYPE, NEEDCATEGORY, OPERATIONALDATATYPE, QUARTER, TABLENAME } from "../../config/enum";
+import { selectData, selectManyTableData } from "./operationalData";
+import { changeEnumValue } from "../../tools/eccEnum";
+import { getChart, getYearList } from "./out";
+import { systemConfig } from "../../config/serverConfig";
+import { getMySqlMs } from "../../tools/systemTools";
+
+
+function getStartAndEndTimeYearList(startTime, endTime) {
+    let startYear = new Date(startTime).getFullYear();
+    let endYear = new Date(endTime).getFullYear();
+    let result = [];
+    for (let i = startYear; i <= endYear; i++) {
+        result.push(i);
+    }
+    return result;
+}
+
+// 获取当前年份的四个季度
+function getQuarterList(year: number) {
+    const quarters = [];
+    for (let quarter = 1; quarter <= 4; quarter++) {
+        const start = moment()
+            .year(year)
+            .quarter(quarter)
+            .startOf('quarter')
+            .format('YYYY-MM-DD HH:mm:ss');
+        const end = moment()
+            .year(year)
+            .quarter(quarter)
+            .endOf('quarter')
+            .format('YYYY-MM-DD HH:mm:ss');
+        quarters.push({ quarter, start, end });
+    }
+    return quarters;
+}
+
+/**
+ * 获取指定季度的起止时间
+ * @param year 年份
+ * @param quarter 季度 (1-4)
+ * @returns 当前季度的起止时间对象 { start, end }
+ */
+function getQuarterRange(year: number, quarter: number) {
+    const start = moment()
+        .year(year)
+        .quarter(quarter)
+        .startOf('quarter')
+        .format('YYYY-MM-DD HH:mm:ss');
+    const end = moment()
+        .year(year)
+        .quarter(quarter)
+        .endOf('quarter')
+        .format('YYYY-MM-DD HH:mm:ss');
+    return { start, end };
+}
+
+/**
+ * 查询指定时间段的企业经营信息并计算总营收
+ * @param start 开始时间
+ * @param end 结束时间
+ * @returns 总营收
+ */
+async function calculateRevenue(start: string, end: string) {
+    const data = await selectData(
+        OPERATIONALDATATYPE.查询多个,
+        TABLENAME.企业经营信息,
+        { annual: { "%between%": [start, end] } },
+        ["BI"] // BI 字段表示营收
+    );
+
+    let totalRevenue = 0;
+    data.forEach(info => {
+        if (info.BI) {
+            totalRevenue += parseFloat(info.BI);
+        }
+    });
+
+    return totalRevenue;
+}
+
+export async function getZhyy() {
+    //获取所有企业孵化信息
+    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 = [];
+
+    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;
+        }
+    });
+
+
+    /**
+     * 企业自行填报，人员数量：从业人员填报数据总和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%
+    */
+    let zaifuAreaRatio = "0";
+    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;
+}
+
+/**
+ * 企业服务数据按年度展示
+ * */
+async function getServiceDataByYear(year: number): Promise<any> {
+    let fuWuCount = 0;
+    let fuWuQiYeCountMap = {};
+    let fuWuQiYeTypeMap = {};
+
+    // 假设 TABLENAME.企业服务表 中有一个字段 applyTime 表示申请时间
+    let applyTime = new Date(`${year}-01-01T00:00:00`);
+    let resolveTime = new Date(`${year + 1}-01-01T00:00:00`);
+
+    let fuWuList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业服务表, { applyTime: { "%between%": [applyTime, resolveTime] } }, 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 fuWuQiYeTypeList = [];
+
+    for (let key in NEEDCATEGORY) {
+        let enumValue = NEEDCATEGORY[key];
+        if (isNaN(Number(key))) {
+            let needCategoryStr = changeEnumValue(NEEDCATEGORY, enumValue);
+            let value = fuWuQiYeTypeMap[needCategoryStr] || 0;
+            fuWuQiYeTypeList.push({
+                key: needCategoryStr,
+                value: value
+            });
+        }
+    }
+
+    return {
+        year,
+        fuWuCount,
+        fuWuQiYeCount,
+        fuWuQiYeTypeList
+    };
+}
+
+
+/**
+ * 在孵企业——变化趋势
+ */
+function getZfqy(data) {
+    let year = getYearList();
+    let hbqs = {
+        "企业数": []
+    }
+    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;
+        })
+        hbqs.企业数.push({ key: year[i], value: count });
+    }
+
+    let qybhqkbhqs = getChart(hbqs);
+
+    return qybhqkbhqs;
+}
+
+
+

src/data/db/qyfw.ts

@@ -21,49 +21,50 @@ function getStartAndEndTimeYearList(startTime, endTime) {
 
 export async function getEnterprise() {
     let qyfw = {
-        企业基本情况: { dataList: [], titleList: ['key', 'value'] }, //企业基本情况
-        变化趋势分析: [], //变化趋势分析
-        入孵时长分布: { 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: [['企业名称', '资质类型']] }, //企业资质分类_小巨人培育
+        企业基本情况: { dataList: [], titleList: ['key', 'value'] }, // 在孵企业面积，在孵企业，毕业企业
+        入孵企业数量变化趋势: [], // 入孵企业按月、按年的迁入、迁出数量
+        入孵时长分布: { dataList: [], titleList: ['key', 'value'] },
+        拟毕业企业情况: {count:0, dataList: []}, // count:即将到期企业数（小于3个月）
+        入孵企业行业分布: { 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: [['企业名称', '类型', '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 selectParam = {  };
+    let selectParam = {};
     let zlColumn = ["eId", "area", "unitPrice", "isDeposit", "startTime", "endTime", "rentFreeStart", "rentFreeEnd", "roomNumber",
         "rent", "notes", "leaseContract", "entryPlan", "businessLicense", "agreement"];
-    /**在孵：获取租赁结束时间大于当前时间的租赁信息 */
-    
+
     let manyTableInfo: any = {}
     manyTableInfo[TABLENAME.企业孵化信息] = { column: ["fId", "eId", "startTime", "endTime", "state"], where: {} };
     manyTableInfo[TABLENAME.租赁信息] = { column: zlColumn, where: selectParam };
     let zldbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {state:1}, ["industry", "eId"], manyTableInfo);
 
-    // let zldbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.租赁信息, selectParam, zlColumn);
-
-    //"endTime": { "%gt%": getMySqlMs(nowTime) }
-
     let qyjbqk = {
-        "孵化面积": 0,
+        "在孵企业面积": 0,
         "在孵企业": 0,
         "毕业企业": 0
     };
@@ -74,7 +75,7 @@ export async function getEnterprise() {
     zldbList.forEach(item => {
         let {enterprise_leases, industry} = item;
         let {area, startTime, endTime} = enterprise_leases[0];
-        if ( nowTime < new Date(endTime).valueOf() ) qyjbqk.孵化面积 += parseInt(area);
+        if ( nowTime < new Date(endTime).valueOf() ) qyjbqk.在孵企业面积 += parseInt(area);
 
         if (area) {
             if (startTime && endTime) {
@@ -110,118 +111,126 @@ export async function getEnterprise() {
     let 毕业dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, { "moveOutType": EMIGRATIONTYPE.毕业迁出 }, fhColumn);
     
     let 迁出dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {}, fhColumn);
-    
-    //获取所有企业孵化表联查企业信息表
-    let 孵化企业includeConf = {};
-    let 孵化企业Clumn = ["enterpriseName", "industry"];
-    孵化企业includeConf[TABLENAME.企业基础信息表] = { cloum: 孵化企业Clumn, where: {} }
-    // let 孵化企业dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业孵化信息, {}, fhColumn, 孵化企业includeConf);
-
-    //企业基本信息
-    qyjbqk.在孵企业 = 在孵dbList.length;
-    qyjbqk.毕业企业 = 毕业dbList.length;
-    qyfw.企业基本情况.dataList = getKeyValue(qyjbqk);
-
-    //变化趋势分析 //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 rfqyslbhqsMonth = getRfqyslbhqsMonth(fhdbList);
 
 
-    //企业服务汇总数据`
-    let qyfwhzsj = await getQyfwhzsj();
-    qyfw.企业服务汇总数据.dataList = getKeyValue(qyfwhzsj);
 
-    //企业需求动态
-    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);
     
+    // //获取所有企业孵化表联查企业信息表
+    // let 孵化企业includeConf = {};
+    // let 孵化企业Clumn = ["enterpriseName", "industry"];
+    // 孵化企业includeConf[TABLENAME.企业基础信息表] = { cloum: 孵化企业Clumn, where: {} }
+    // // let 孵化企业dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业孵化信息, {}, fhColumn, 孵化企业includeConf);
 
-    //企业变化情况——变化趋势
-    let hbqs = [];
-    for (let key in 在孵企业变化趋势map) {
-        hbqs.push({ key, value: 在孵企业变化趋势map[key] });
-    }
-    hbqs.sort((a, b) => { return parseInt(a.key) - parseInt(b.key) });
-    qyfw.企业变化情况变化趋势 = getChart({"企业数": hbqs});
+    // //企业基本信息
+    // qyjbqk.在孵企业 = 在孵dbList.length;
+    // qyjbqk.毕业企业 = 毕业dbList.length;
+    // qyfw.企业基本情况.dataList = getKeyValue(qyjbqk);
 
-    let 企业融资dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业融资, {}, null);
-    //金融服务
-    let jrfw = await getJrfw(在孵dbList, 企业融资dbList);
-    qyfw.金融服务.dataList = getKeyValue(jrfw);
-
-    //本月融资企业
-    let byrzqy = await getByrzqy(企业融资dbList);
-    qyfw.本月融资企业 = byrzqy.byrzqybhqs;
-
-    //本月融资金额
-    qyfw.本月融资金额 = byrzqy.byrzjebhqs;
-
-    //在孵企业总营收
-    let zfqyzys = await getZfqyzys();
-    qyfw.在孵企业总营收.dataList = getKeyValue(zfqyzys);
-
-    //金融服务企业
-    let rzqylcColumn = ["rId", "eId", "financingAmount", "financingRounds", "fuHuaQiInvestment", "fuHuaQiInvestmentStyle", "fuHuaQiInvestmentAmount",
-        "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;
-
-    //知识产权
-    // 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(企业人才就业人数);
+    // //变化趋势分析 //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 qyfwhzsj = await getQyfwhzsj();
+    // qyfw.企业服务汇总数据.dataList = getKeyValue(qyfwhzsj);
+
+    // //企业需求动态
+    // 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);
+    
+
+    // //企业变化情况——变化趋势
+    // let hbqs = [];
+    // for (let key in 在孵企业变化趋势map) {
+    //     hbqs.push({ key, value: 在孵企业变化趋势map[key] });
+    // }
+    // hbqs.sort((a, b) => { return parseInt(a.key) - parseInt(b.key) });
+    // qyfw.企业变化情况变化趋势 = getChart({"企业数": hbqs});
+
+    // let 企业融资dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业融资, {}, null);
+    // //金融服务
+    // let jrfw = await getJrfw(在孵dbList, 企业融资dbList);
+    // qyfw.金融服务.dataList = getKeyValue(jrfw);
+
+    // //本月融资企业
+    // let byrzqy = await getByrzqy(企业融资dbList);
+    // qyfw.本月融资企业 = byrzqy.byrzqybhqs;
+
+    // //本月融资金额
+    // qyfw.本月融资金额 = byrzqy.byrzjebhqs;
+
+    // //在孵企业总营收
+    // let zfqyzys = await getZfqyzys();
+    // qyfw.在孵企业总营收.dataList = getKeyValue(zfqyzys);
+
+    // //金融服务企业
+    // let rzqylcColumn = ["rId", "eId", "financingAmount", "financingRounds", "fuHuaQiInvestment", "fuHuaQiInvestmentStyle", "fuHuaQiInvestmentAmount",
+    //     "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;
+
+    // //知识产权
+    // // 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;
 }
@@ -303,6 +312,97 @@ export async function getEnterpriseDetails(name, type) {
 }
 
 
+function getRfqyslbhqsMonth(在孵dbList, 迁出dbList) {
+    let year = getYearList();
+    let month = getMonthList();
+    let rfqyslbhqs = {
+        "月":{},
+        "年":{}
+    }
+    for(let i = 0; i < month.length; i++) {
+        let 月 = 0;
+        在孵dbList.forEach(info => {
+            // 检查入孵开始时间的月份是否与当前月份相同
+            let parsedStartTime = moment(info.startTime); // 获取入孵开始时间
+            if (parsedStartTime.isValid() && parsedStartTime.month() === month[i].month()) {
+                月 += 1;
+            }
+        })
+        
+    }
+    
+
+    迁出dbList.forEach(info => {
+        let parsedMoveOutTime = moment(info.moveOutTime); // 获取迁出时间
+
+        // 检查迁出时间的年份是否与当前年份相同
+        if (parsedMoveOutTime.isValid() && parsedMoveOutTime.year() === nowTime.year()) {
+            qybhqk.迁出企业 += 1;
+        }
+    })
+
+
+}
+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 qybhqk;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 /**
  * 变化趋势分析