Merge branch 'master' of http://123.207.147.179:8888/node_server/yuyiViewServer

src/biz/jxgljsc.ts

@@ -19,6 +19,87 @@ export async function getData(req, res) {
     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 rcyjPackageData = keyValuePackage(dbList['人才引进'].dataList);
+    ret['rcyj'] = getKeyValueOut('人才引进', rcyjPackageData);
+                    
+    let fhqhzsjPackageData = keyValuePackage(dbList['孵化器汇总数据'].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(dbList['企业动态'].dataList);
+    ret['qydt'] = getKeyValueOut('企业动态', qydtPackageData);
+                    
+    let zfqybhqsPackageData = onceYBarChartPackage( dbList['在孵企业变化趋势'], '家','');
+    ret['zfqybhqs'] = getOnceYBarChartOut('在孵企业变化趋势', zfqybhqsPackageData);
+                    
+    let jrfwPackageData = keyValuePackage(excelData['金融服务'].dataList);
+    ret['jrfw'] = getKeyValueOut('金融服务', jrfwPackageData);
+                    
+    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 zfqyrzqkPackageData = keyValuePackage(dbList['在孵企业融资情况'].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(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);
                     
@@ -84,3 +165,5 @@ export async function getData(req, res) {
                      
     res.send(ret);
 } 
+
+

src/biz/qyfw.ts

@@ -13,6 +13,106 @@ export async function getData(req, res) {
 
     let ret:any = {};
 
+    let qyjbqkPackageData = keyValuePackage(dbData['企业基本情况'].dataList);
+    ret['qyjbqk'] = getKeyValueOut('企业基本情况', qyjbqkPackageData);
+                    
+    let bhqsfxPackageData = onceYBarChartPackage( excelData['变化趋势分析'], '','');
+    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( excelData['企业人才'], '','');
+    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 get备份(req, res) {
+    let dbData = await getEnterprise();
+    let excelData = qyfwTableData();
+
+    let ret:any = {};
+
     let qyjbqkPackageData = keyValuePackage(excelData['企业基本情况'].dataList);
     ret['qyjbqk'] = getKeyValueOut('企业基本情况', qyjbqkPackageData);
                     
@@ -103,4 +203,6 @@ export async function getData(req, res) {
     ret['qyzzfl_gqpy'] = getTableOut( '企业资质分类_高企培育', qyzzfl_gqpyTableData);
                      
     res.send(ret);
-} 
+} 
\ No newline at end of file
+
+

src/config/enum.ts

@@ -25,6 +25,7 @@ export enum OPERATIONALDATATYPE {
  * 表名
  */
 export enum TABLENAME {
+    羽翼孵化器='system_yuyi',
     企业孵化信息='enterprise_fuhua',
     租赁信息='enterprise_lease',
     企业用户表='enterprise_user', 

src/data/db/jxgljsc.ts

@@ -3,25 +3,24 @@
  */
 
 import moment = require("moment")
-import { FUHUASTATE, INDUSTRY, MOVEOUTTYPE, OPERATIONALDATATYPE, TABLENAME, FINANCINGROUNDS } from "../../config/enum";
+import { FUHUASTATE, INDUSTRY, MOVEOUTTYPE, OPERATIONALDATATYPE, TABLENAME, FINANCINGROUNDS, ENTERPRISETEAM } from "../../config/enum";
 import { selectData, selectManyTableData } from "./operationalData";
 import { keyValuePackage } from "../../dataPackage/inFrontOut";
 import { info } from "console";
+import { getChart, getKeyValue, getYearList } from "./out";
 
 
 export async function getJxgljsc() {
     let jxgljsc = {
-        "cyjg": { dataList: [], titleList: ['key', 'value'] },//产业结构
-        "rcyj": { dataList: [], titleList: ['key', 'value'] },//人才引进
-        "fhqhzsj": { dataList: [], titleList: ['key', 'value'] },//孵化器汇总数据
-        "qydt": { dataList: [], titleList: ['key', 'value'] },//企业动态
-        "zfqybhqs": [],//在孵企业变化趋势
-        "zysje": { dataList: [], titleList: ['key', 'value'] },//总营收金额
-        "zfqyzys": { dataList: [], titleList: ['key', 'value'] },//在孵企业总营收
-        "tzlx": { dataList: [], titleList: ['key', 'value'] },//投资类型
-        "zfqyrzqk": { dataList: [], titleList: ['key', 'value'] },//在孵企业融资情况
-        "qyfhl": { dataList: [], titleList: ['key', 'value'] },//企业孵化率
-        "qyfhs": { 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'] },//企业孵化数
     }
 
     // 获取当前时间
@@ -31,17 +30,45 @@ export async function getJxgljsc() {
     //获取在孵企业
     let 在孵dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, { "endTime": { "%gt%": nowTime } }, fhColumn);
 
-    jxgljsc.cyjg.dataList = await cyjg();//产业结构
-    jxgljsc.rcyj.dataList = await rcyj();//人才引进
-    jxgljsc.fhqhzsj.dataList = await fhqhzsj();//孵化器汇总数据
-    jxgljsc.qydt.dataList = await qydt();//企业动态
-    jxgljsc.zfqybhqs = await zfqybhqs(在孵dbList, jxgljsc);//在孵企业变化趋势
-    jxgljsc.zysje.dataList = await zysje();//总营收金额
-    jxgljsc.zfqyzys.dataList = await zfqyzys(在孵dbList, jxgljsc, 在孵dbList);//在孵企业总营收
-    jxgljsc.tzlx.dataList = await tzlx();//投资类型
-    jxgljsc.zfqyrzqk.dataList = await zfqyrzqk();//在孵企业融资情况
-    jxgljsc.qyfhl.dataList = await qyfhl();//企业孵化率
-    jxgljsc.qyfhs.dataList = await qyfhs();//企业孵化数
+    //获取在孵企业租赁信息
+    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 fhqhzsjInfo = await fhqhzsj(羽翼孵化器dbList, 在孵dbList);
+    jxgljsc.孵化器汇总数据.dataList = getKeyValue(fhqhzsjInfo);//孵化器汇总数据
+
+    let qydtInfo = await qydt(在孵dbList);
+    jxgljsc.企业动态.dataList = getKeyValue(qydtInfo);//企业动态
+
+    jxgljsc.在孵企业变化趋势 = await zfqybhqs(在孵dbList);//在孵企业变化趋势
+
+    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.tzlx.dataList = await tzlx();//投资类型
+
+    jxgljsc.在孵企业融资情况.dataList = await zfqyrzqk();//在孵企业融资情况
+
+    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;
 }
@@ -67,228 +94,144 @@ async function cyjg() {
 //人才引进
 
 async function rcyj() {
-    let rcyj = {
-        "国家级人才": 0,
-        "上海市级人才": 0,
-        "浦东区级人才": 0,
-        "海外人才": 0,
-        "博士人才": 0
-    }
+    let result = [];
 
     // 分别获取不同表的数据并合并处理
-    let 创业团队List = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.创业团队, {}, null);
-
-    let result = [];
-    for (let rcyjItem of [创业团队List]) {
-        if (rcyjItem.title == "国家级人才") {
-            rcyj.国家级人才 += 1;
-        } else if (rcyjItem.city == "上海市") {
-            rcyj.上海市级人才 += 1;
-        } else if (rcyjItem.city == "浦东区") {
-            rcyj.浦东区级人才 += 1;
-        } else if (rcyjItem.city == "海外") {
-            rcyj.海外人才 += 1;
-        } else if (rcyjItem.title == "博士") {
-            rcyj.博士人才 += 1;
+    // 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 })
         }
-        // 将 rcyj 对象转换为数组
-        let result = Object.entries(rcyj).map(([key, value]) => ({ key: key, value: value }));
     }
 
-
     return result;
 }
 
 
 
 //孵化器汇总数据
-async function fhqhzsj() {
-    let result = [];
-
+async function fhqhzsj(data, zfData) {
     let fhqhzsj = {
-        "在孵企业": 0,
-        "在孵面积": 0
+        孵化器总面积:data.totalArea + "㎡",
+        在孵企业: zfData.length,
+        在孵面积: data.zaifuArea + "㎡"
     }
-    let 孵化信息dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {}, null);
-    孵化信息dbList.forEach(item => {
-        fhqhzsj.在孵面积 += parseInt(item.area);;
-    });
-
-
-    let fhColumn = ["fId", "eId", "startTime", "endTime", "state", "virtualCause", "virtualCauseDes", "moveOutType",
-        "moveOutTrace", "moveOutCause", "moveOutTime", "graduationTime"];
-    //获取所有企业孵化表联查企业信息表
-    let 孵化企业includeConf = {};
-    let 孵化企业Clumn = ["enterpriseName", "industry"];
-    孵化企业includeConf[TABLENAME.企业基础信息表] = { cloum: 孵化企业Clumn, where: {} }
-    let 孵化企业dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业孵化信息, {}, fhColumn, 孵化企业includeConf);
-
-    fhqhzsj.在孵企业 = 孵化企业dbList.length;
 
-    result.push({ key: "在孵企业", value: fhqhzsj.在孵企业 });
-    result.push({ key: "在孵面积", value: fhqhzsj.在孵面积 });
-
-    return result;
+    return fhqhzsj;
 }
 
 //企业动态---------
-async function qydt() {
+async function qydt(data) {
 
     let result = [];
     let qydt = {
         "本月新加入在孵企业": 0,
-        "同比上月": 0,
-        "环比去年": 0
+        "同比上月": "",
+        "环比去年": ""
     }
 
-    let qydtList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {}, null);
     //本月新加入在孵企业
     let nowTime = moment().format('YYYY-MM-DD HH:mm:ss');
-    let monthAgo = moment().subtract(1, 'month').format('YYYY-MM-DD HH:mm:ss');
-    let monthAgoList = qydtList.filter(item => {
-        return moment(item.createTime) > moment(monthAgo) && moment(item.createTime) < moment(nowTime);
-    });
-    qydt.本月新加入在孵企业 = monthAgoList.length;
+    let monthAgo = moment().format('YYYY-MM-01 00:00:00');
     //同比上月
-    let monthAgo2 = moment().subtract(2, 'month').format('YYYY-MM-DD HH:mm:ss');
-    let monthAgo2List = qydtList.filter(item => {
-        return moment(item.createTime) > moment(monthAgo2) && moment(item.createTime) < moment(monthAgo);
-    });
-    qydt.同比上月 = monthAgoList.length - monthAgo2List.length;
+    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 yearAgo = moment().subtract(1, 'year').format('YYYY-MM-DD HH:mm:ss');
-    let yearAgoList = qydtList.filter(item => {
-        return moment(item.createTime) > moment(yearAgo) && moment(item.createTime) < moment(monthAgo);
-    });
-    qydt.环比去年 = monthAgoList.length - yearAgoList.length;
+    let thisYear = moment().format('YYYY-01-01 00:00:00');
+    let yearAgo = moment().subtract(1, 'year').format('YYYY-01-01 00:00:00');
+    let yearAgoEnd = moment().subtract(1, 'year').format('YYYY-12-31 00:00:00');
+    
+    
+    let 上月 = 0;
+    let 今年 = 0;
+    let 去年 = 0;
+    data.forEach( info => {
+        if (moment( info.startTime) > moment(monthAgo) && moment(info.startTime) < moment(nowTime)) {
+            qydt.本月新加入在孵企业 += 1;
+        }
+        if (moment( info.startTime) > moment(monthAgo2) && moment(info.startTime) < moment(monthAgo2End)) {
+            上月 += 1;
+        }
+        if (moment( info.startTime) > moment(thisYear) && moment(info.startTime) < moment(nowTime)) {
+            今年 += 1;
+        }
+        if (moment( info.startTime) > moment(yearAgo) && moment(info.startTime) < moment(yearAgoEnd)) {
+            去年 += 1;
+        }
+    })
 
-    result.push({ key: "本月新加入在孵企业", value: qydt.本月新加入在孵企业 });
-    result.push({ key: "同比上月", value: qydt.同比上月 });
-    result.push({ key: "环比去年", value: qydt.环比去年 });
+    let 同比 = ((qydt.本月新加入在孵企业 - 上月) / 上月) * 100;
+    qydt.同比上月 = 同比.toFixed(2) + "%";
+
+    let 环比 = ((今年 - 去年) / 去年) * 100;
+    qydt.环比去年 = 环比.toFixed(2) + "%";
 
     return result;
 }
 
 
-async function zfqybhqs(data,在孵dbList) {
-    let 企业孵化信息List = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {}, null);
-    let result = [];
-
-    let year = ["2017", "2018", "2019", "2020", "2021", "2022", "2023", "2024"];
-    let zfqybhqsData = {
-        "在孵企业": []
+function zfqybhqs(data){
+    let year = getYearList();
+    let zhqy = {
+        "在孵企业":[]
     }
     for (let i = 0; i < year.length; i++) {
         let count = 0;
-        data.forEach(info => {
+        data.forEach( info => {
             let startTimeYear = moment(info.startTime).year(); //获取入孵开始时间
             let thisYear = parseInt(year[i]);
             if (startTimeYear === thisYear) count += 1;
-        });
-        zfqybhqsData.在孵企业.push({ key: year[i], value: count });
+        })
+        zhqy.在孵企业.push({key:year[i], value:count});
     }
 
-    let zfqybhqs = getChart(zfqybhqsData);
+    let zhqybhqs = getChart(zhqy);
 
-    function getChart(data) {
-        let result = [];
-        for (let key in data) {
-            result.push({ name: key, data: data[key] })
-        }
-    }
-    return result;
+    return zhqybhqs;
 }
 
-//总营收金额
-async function zysje() {
-    let result = [];
-    let zysjeList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, {}, null);
 
+
+//总营收金额
+async function zysje(data) {
     //获取总营收金额
-    let zysje = 0;
-    zysjeList.forEach(item => {
-        zysje += parseFloat(item.totalRevenue);
+    let zysje = {
+        总营收金额:0
+    };
+    data.forEach(item => {
+        zysje.总营收金额 += parseFloat(item.BI);
     });
 
-    result.push({ key: "总营收金额", value: zysje + "千万元" });
-
-    return result;
+    return zysje;
 }
 
 //在孵企业总营收
-async function zfqyzys(在孵dbList: any[], jxgljsc: any, data: any[] = []) {
-
-    let result = [];
-
-    //在孵企业总营收
-    // let zfqyzys = getZfqyzys(在孵dbList);
-    // jxgljsc.zfqyzys.dataList = getKeyValue(zfqyzys);
-
+async function zfqyzys(data) {
     let zfqyzys = {
-        "500万以下": 0,
-        "500万-1000万": 0,
-        "1000万-2000万": 0,
-        "2000万以上": 0
+        "500万以下":0,
+        "500万-1000万":0,
+        "1000万-2000万":0,
+        "2000万以上":0
     }
 
     for (let i = 0; i < data.length; i++) {
         //获取在孵企业经营数据
-        let 经营信息dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, { eId: data[i].eId }, null);
-        经营信息dbList.forEach(info => { //BI（单位万元）
+        let 经营信息dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, {eId:data[i].eId}, null);
+        经营信息dbList.forEach( info => { //BI（单位万元）
             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;
         })
     }
-    // 将 zfqyzys 转换为键值对形式
-    result = getKeyValue(zfqyzys);
-
-    return result;
 
-    function getKeyValue(data) {
-        let result = [];
-        for (let key in data) {
-            result.push({ key, value: data[key] });
-        }
-
-        return result;
-    }
+    return zfqyzys
 }
 
-//投资类型
-async function tzlx() {
-    let result = [];
-    let 融资dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业融资, {}, null);
-
-    //获取投资类型
-    let 投资类型 = {
-        "设备": 0,
-        "租金": 0,
-        "服务": 0,
-        "其他": 0
-    };
-    融资dbList.forEach(item => {
-        let type = item.type;
-        if (type === "设备") 投资类型.设备 += 1;
-        else if (type === "租金") 投资类型.租金 += 1;
-        else if (type === "服务") 投资类型.服务 += 1;
-        else 投资类型.其他 += 1;
-    });
-
-    result = getKeyValue(投资类型);
-
-    return result;
-
-    function getKeyValue(data) {
-        let result = [];
-        for (let key in data) {
-            result.push({ key, value: data[key] });
-        }
-
-        return result;
-    }
-}
 
 //在孵企业融资情况
 async function zfqyrzqk() {
@@ -298,7 +241,7 @@ async function zfqyrzqk() {
         let anyKey: any = key;
         if (isNaN(anyKey)) {
             let financingRounds = FINANCINGROUNDS[key];
-            let count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业融资, {}, null);
+            let count = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业融资, {financingRounds}, null);
             result.push({ key: key, value: count })
         }
     }
@@ -314,7 +257,7 @@ async function qyfhl() {
 
     //获取企业孵化率
     let qyfhl = {
-        "企业孵化率": 0,
+        "企业毕业率": 0,
         "环比去年孵化率": 0
     };
     let nowYear = new Date().getFullYear();
@@ -326,55 +269,40 @@ async function qyfhl() {
         let startTime = new Date(item.startTime).getFullYear();
 
         if (endTime === nowYear) {
-            qyfhl.企业孵化率 += 1;
+            qyfhl.企业毕业率 += 1;
             if (startTime <= lastYear && endTime >= lastYear) {
                 qyfhl.环比去年孵化率 += 1;
             }
         }
     }
 
-    result.push({ key: "企业孵化率", value: qyfhl.企业孵化率 });
+    result.push({ key: "企业孵化率", value: qyfhl.企业毕业率 });
     result.push({ key: "环比去年孵化率", value: qyfhl.环比去年孵化率 });
 
     return result;
 }
 
 //企业孵化数
-async function qyfhs() {
-    let result = [];
-    let 企业孵化信息List = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {}, null);
-
+async function qyfhs(data) {
     //获取企业孵化数
     let qyfhs = {
         "小巨人": 0,
-        "高企培育": 0,
         "高新企业": 0,
-        "科技型中小企业": 0,
-        "专精特精": 0
+        "专精特新": 0,
+        "小巨人培育": 0,
     };
-    let 企业资质List = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业资质, {}, null);
-
-    for (let i = 0; i < 企业孵化信息List.length; i++) {
-        let item = 企业孵化信息List[i];
-        let 企业资质dbList = 企业资质List.filter(q => q.eId === item.eId);
-       
-        企业资质dbList.forEach(q => {
-            let 企业类型 = q.industry;
-            if (企业类型 === "小巨人") qyfhs.小巨人 += 1;
-            else if (企业类型 === "高企培育") qyfhs.高企培育 += 1;
-            else if (企业类型 === "高新企业") qyfhs.高新企业 += 1;
-            else if (企业类型 === "科技型中小企业") qyfhs.科技型中小企业 += 1;
-            else if (企业类型 === "专精特精") qyfhs.专精特精 += 1;
-        });
-    }
 
-    result.push({ key: "小巨人", value: qyfhs.小巨人 });
-    result.push({ key: "高企培育", value: qyfhs.高企培育 });
-    result.push({ key: "高新企业", value: qyfhs.高新企业 });
-    result.push({ key: "科技型中小企业", value: qyfhs.科技型中小企业 });
-    result.push({ key: "专精特精", value: qyfhs.专精特精 });
+    data.forEach( info => {
+        let {enterprise_qualifications} = info;
+        enterprise_qualifications.forEach( item => {
+            if (item.xjrTime) qyfhs.小巨人 += 1;
+            else if (item.gaoXinJiShuTime) qyfhs.高新企业 += 1;
+            else if (item.zjtxTime) qyfhs.专精特新 += 1;
+            else if (item.xjrPyTime) qyfhs.小巨人培育 += 1;
+        })
+    })
 
-    return result;
+    return qyfhs;
 }
 
 

src/data/db/qyfw.ts

@@ -26,12 +26,12 @@ export async function getEnterprise() {
         金融服务企业:{bodyList:[], headerList:[['企业名称', '融资金额', '融资时间']]}, //金融服务企业 todo
         知识产权:{dataList:[], titleList:['key', 'value']}, //知识产权
         知识产权饼图:{dataList:[], titleList:['key', 'value']}, //知识产权饼图
-        知识产权详情:{bodyList:[], headerList:[['企业名称', '专利数量', '企业需求']]}, //知识产权详情
+        知识产权详情:{bodyList:[], headerList:[['企业名称', '专利数量', '企业需求']]}, //知识产权详情 todo
         企业资质分类:{dataList:[], titleList:['key', 'value']}, //企业资质分类
         企业资质分类_小巨人:{bodyList:[], headerList:[['企业名称', '资质类型']]}, //企业资质分类_小巨人
         企业资质分类_高新企业:{bodyList:[], headerList:[['企业名称', '资质类型']]}, //企业资质分类_高新企业
         企业资质分类_专精特新:{bodyList:[], headerList:[['企业名称', '资质类型']]}, //企业资质分类_专精特新
-        企业资质分类_高企培育:{bodyList:[], headerList:[['企业名称', '资质类型']]}, //企业资质分类_高企培育
+        企业资质分类_小巨人培育:{bodyList:[], headerList:[['企业名称', '资质类型']]}, //企业资质分类_小巨人培育
     }
 
     let nowTime = new Date().valueOf();
@@ -140,21 +140,25 @@ export async function getEnterprise() {
     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:["needContent"], where:{}}
     let 知识产权详情dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {}, ["enterpriseName"], 知识产权联查includeConf);
-    let zscqxq = await getZscqxq(知识产权详情dbList)
+    let zscqxq = await getZscqxq(知识产权详情dbList);
 
     //企业资质分类
-    let 企业资质Column = ["qId", "eId", "kxTime", "zjtxTime", "xjrTime", "xjrPyTime", "goPublicTime", "gaoXinJiShuTime", "goPublicSector"];
+    let 资质Column = ["qId", "eId", "kxTime", "zjtxTime", "xjrTime", "xjrPyTime", "goPublicTime", "gaoXinJiShuTime", "goPublicSector"];
     let 企业资质联查includeConf = {};
-    企业资质联查includeConf[TABLENAME.企业基础信息表] = {cloum:["enterpriseName"], where:{}}
-    let 企业资质dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业资质, {}, 企业资质Column, 融资企业联查includeConf);
-    let qyzzfl = getQyzzfl();
-    let qyzzfl_xjr = getQyzzfl();
+    企业资质联查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.小巨人培育;
 
     return qyfw;
 }
@@ -225,21 +229,21 @@ async function getQyfwhzsj() {
     };
     let 经营信息dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, {}, null);
     经营信息dbList.forEach( info => {
-        qyfwhzsj.企业总营收额 += info.BI;
-        qyfwhzsj.企业纳税 += info.TXP;
+        qyfwhzsj.企业总营收额 += parseFloat(info.BI);
+        qyfwhzsj.企业纳税 += parseFloat(info.TXP);
     })
 
     let 企业融资dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业融资, {}, null);
     企业融资dbList.forEach( info => {
-        qyfwhzsj.融资企业 += info.financingAmount;
+        qyfwhzsj.融资企业 += parseFloat(info.financingAmount);
     })
 
     let 企业专利dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业专利表, {}, null);
     企业专利dbList.forEach( info => {
-        qyfwhzsj.企业专利 += info.alienPatent;
-        qyfwhzsj.企业专利 += info.classIPatent;
-        qyfwhzsj.企业专利 += info.secondClassPatent;
-        qyfwhzsj.企业专利 += info.thirdPentent;
+        qyfwhzsj.企业专利 += parseFloat(info.alienPatent);
+        qyfwhzsj.企业专利 += parseFloat(info.classIPatent);
+        qyfwhzsj.企业专利 += parseFloat(info.secondClassPatent);
+        qyfwhzsj.企业专利 += parseFloat(info.thirdPentent);
     })
 
     return qyfwhzsj;
@@ -375,7 +379,7 @@ async function getByrzqy(企业融资dbList){
             let parsedTime = moment(info.investmentDate).format("YYYY-MM"); //获取融资时间
             if (parsedTime === month[i]) {
                 企业count += 1;
-                金额count += info.financingAmount;
+                金额count += parseFloat(info.financingAmount);
             }
         })
         byrzqy.融资企业.push({key:month[i], value:企业count});
@@ -474,16 +478,44 @@ function getZscqxq(data) {
 /**
  * 企业资质分类
  */
-function getQyzzfl() {
+function getQyzzfl(data) {
     let qyzzfl = {
         小巨人:0,
         高新企业:0,
-        专精特精: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}
 }
 
 

src/data/table/qyfwData.ts

@@ -28,7 +28,7 @@ export function qyfwTableData() {
     let keyValueOrTitleList = ["企业基本情况","入孵时长分布","孵化企业行业领域占比","企业服务汇总数据","企业需求动态","企业变化情况","金融服务","在孵企业总营收","知识产权","知识产权饼图","企业资质分类"];//适配 饼图 键值以及需要多个key的
     let barChartList = ["变化趋势分析","企业人才","变化趋势","本月融资企业","本月融资金额"]; //适配 柱状图 折线图 
     let stringList = [];
-    let decollatePlanarList =["企业需求动态详细","地图","金融服务企业","知识产权详情","企业资质分类_小巨人","企业资质分类_高新企业","企业资质分类_专精特新","企业资质分类_高企培育"];//适配 表格
+    let decollatePlanarList =["企业需求动态详细","地图","金融服务企业","知识产权详情","企业资质分类_小巨人","企业资质分类_高新企业","企业资质分类_专精特新","企业资质分类_小巨人培育"];//适配 表格
     let titltListConfig = {};
 
     let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);