no message

src/biz/qyfw.ts

@@ -63,12 +63,9 @@ export async function getData(req, res) {
     let xqclqk = keyValuePackage(dbData.需求处理情况.dataList);
     ret['xqclqk'] = getKeyValueOut('需求处理情况', xqclqk);
                     
-    let fwlx = keyValuePackage(dbData.服务类型.count);
+    let fwlx = keyValuePackage(dbData.服务类型);
     ret['fwlx'] = getKeyValueOut('服务类型', fwlx);
 
-    let fwlxxx = keyValuePackage(dbData.服务类型.dataList);
-    ret['fwlxxx'] = getKeyValueOut('服务类型详细', fwlxxx);
-
     ret['rfqyfwqk'] = {title:"入孵企业服务情况", dataList:dbData.入孵企业服务情况};
   
     res.send(ret);

src/biz/qyszhx.ts

@@ -3,7 +3,7 @@ import { keyValuePackage, stringListPackage, tablePackage } from '../dataPackage
 import { getKeyValueOut, getStringOut, getTableOut } from '../dataPackage/out';
 import { getQyszhx } from '../data/db/qyszhx';
 import { selectData } from '../data/db/operationalData';
-import { OPERATIONALDATATYPE, TABLENAME } from '../config/enum';
+import { INDUSTRY, OPERATIONALDATATYPE, TABLENAME } from '../config/enum';
 
 /*                            企业数字画像                    */
 
@@ -110,15 +110,16 @@ export async function getData(req, res) {
  * @param res 
  */
 export async function getPinyinName(req, res) {
-    let {pinyinName, page} = req.body;
+    let {pinyinName, industry, page} = req.body;
     let ret: any = {};
     
-    let dbList = await selectData(OPERATIONALDATATYPE.分页查询, TABLENAME.企业基础信息表, { pinyinName:{"%like%":pinyinName} }, null, page);
-    let dbCount = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业基础信息表, { pinyinName:{"%like%":pinyinName} }, null);
+    let param = { pinyinName:{"%like%":pinyinName}, industry: { "%like%": industry } };
+    let dbList = await selectData(OPERATIONALDATATYPE.分页查询, TABLENAME.企业基础信息表, param, ["eId", "enterpriseName"], page);
+    let dbCount = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.企业基础信息表, param, ["eId", "enterpriseName"]);
 
     let enterpriseNameList = [];
     dbList.forEach( info => {
-        enterpriseNameList.push(info.enterpriseName);
+        enterpriseNameList.push(info.eId, info.enterpriseName);
     })
 
     ret['qymcList'] = enterpriseNameList;
@@ -127,3 +128,26 @@ export async function getPinyinName(req, res) {
 }
 
 
+/**
+ * 行业领域下拉
+ * @param req 
+ * @param res 
+ */
+export async function getIndustry(req, res) {
+    let ret: any = {};
+
+    let dataList = [];
+    for (let key in INDUSTRY) {
+        let anyKey:any = key;
+        if (isNaN(anyKey)) {
+            dataList.push({key, value:INDUSTRY[key]});
+        }
+    }
+
+    ret['industry'] = dataList;
+
+    res.send(ret);
+}
+
+
+

src/data/db/jxgljsc.ts

@@ -5,21 +5,11 @@
 import moment = require("moment")
 import { FUHUASTATE, INDUSTRY, OPERATIONALDATATYPE, TABLENAME, ENTERPRISETEAM, EMIGRATIONTYPE, STATE, FOLLOWUPSTATUS, NEEDCATEGORY } from "../../config/enum";
 import { selectData, selectManyTableData } from "./operationalData";
-import { getChart, getKeyValue, getMonthList, getYearList } from "./out";
+import { getChart, getKeyValue, getMonthList, getYearList, get在孵企业面积, get在孵企业面积变化趋势 } from "./out";
 import { changeEnumValue } from "../../tools/eccEnum";
 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;
-}
-
 export async function getJxgljsc() {
     let jxgljsc = {
         在孵企业面积情况分析: { dataList: [], titleList: ['key', 'value'] }, //在孵面积占比
@@ -38,58 +28,10 @@ export async function getJxgljsc() {
 
 
     //在孵企业面积情况分析
-    //获取所有企业孵化信息
-    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 = {};
-
-    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 (industry) {
-            let industryStr = changeEnumValue(INDUSTRY, JSON.parse(industry)[0]);
-            if (!industryMap[industryStr]) industryMap[industryStr] = 0;
-            industryMap[industryStr] += 1;
-        }
-
-    });
-
-    //行业领域----按照企业选择的类型呈现
-    for (let key in INDUSTRY) {
-        let anyKey: any = key;
-        if (isNaN(anyKey)) {
-            let keyStr = key;
+    let {在孵企业面积变化趋势, 行业领域分布} = await get在孵企业面积变化趋势();
+    jxgljsc.在孵企业面积变化趋势.data = 在孵企业面积变化趋势;
 
-            jxgljsc.产业结构.dataList.push({ key: keyStr, value: industryMap[keyStr] });
-        }
-    }
-
-
-    jxgljsc.在孵企业面积变化趋势.data = Object.values(面积变化Map);
+    jxgljsc.产业结构.dataList = 行业领域分布;
 
     //获取在孵企业
     let fhColumn = ["fId", "eId", "startTime", "endTime", "state", "virtualCause", "virtualCauseDes", "moveOutType",
@@ -106,12 +48,14 @@ export async function getJxgljsc() {
     /**
     * 计算在孵企业面积占比：在孵企业总面积/孵化器或者园区总面积 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 zaifuAreaRatio = "0";
+    // if (!isNaN(孵化器信息数据.totalArea) && parseFloat(孵化器信息数据.totalArea) && areaCount) {
+    //     let zaifuAreaRatioNum = 100 * (areaCount / parseFloat(孵化器信息数据.totalArea));
+    //     zaifuAreaRatio = zaifuAreaRatioNum > 100 ? "100" : zaifuAreaRatioNum.toFixed(2);
+    // }
+    
+    let {孵化器总面积, 在孵企业面积, 在孵企业面积占比} = await get在孵企业面积();
+    jxgljsc.在孵企业面积情况分析.dataList.push({ key: "在孵面积占比", value: 在孵企业面积占比 });
 
 
     // 获取当前时间
@@ -127,8 +71,11 @@ export async function getJxgljsc() {
     jxgljsc.人才引进.dataList = await rcyj();//人才引进
 
     //获取羽翼孵化器
-    let 羽翼孵化器dbList = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.羽翼孵化器, {}, []);
-    let fhqhzsjInfo = await fhqhzsj(羽翼孵化器dbList, 在孵dbList, areaCount);
+    let fhqhzsjInfo = {
+        孵化器总面积: 孵化器总面积 + "㎡",
+        在孵企业: 在孵dbList.length + "家",
+        在孵企业面积: 在孵企业面积 + "㎡",
+    }
     jxgljsc.孵化器汇总数据.dataList = getKeyValue(fhqhzsjInfo);//孵化器汇总数据
 
     /**
@@ -337,20 +284,6 @@ async function rcyj() {
 
 
 /**
- * 孵化器汇总数据
- */
-async function fhqhzsj(data, zfData, areaCount) {
-    let fhqhzsj = {
-        孵化器总面积: data.totalArea + "㎡",
-        在孵企业: zfData.length + "家",
-        在孵企业面积: data.zaifuArea + "㎡",
-    }
-
-    return fhqhzsj;
-}
-
-
-/**
  * 预警
  */
 async function getyj() {

src/data/db/out.ts

 import moment = require("moment");
+import { FUHUASTATE, INDUSTRY, OPERATIONALDATATYPE, TABLENAME } from "../../config/enum";
+import { selectData, selectManyTableData } from "./operationalData";
+import { changeEnumValue } from "../../tools/eccEnum";
+
+
+export async function get在孵企业面积() {
+    // 获取当前时间
+    let nowTime = moment().format('YYYY-MM-DD HH:mm:ss');
+    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: {state: { "%between%": [FUHUASTATE.实体孵化, FUHUASTATE.虚拟孵化] }} };
+    manyTableInfo[TABLENAME.租赁信息] = { column: zlColumn, where: {"startTime": {"%lt%": nowTime}, "endTime": { "%gt%": nowTime }} };
+    let zldbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {}, ["industry", "eId"], manyTableInfo);
+
+    let 在孵企业面积 = 0;
+    let 在孵企业面积变化趋势 = [];
+    zldbList.forEach( info => {
+        let {enterprise_fuhuas, enterprise_leases} = info;
+        enterprise_leases.forEach( leases => {
+            在孵企业面积 += parseFloat(leases.area);
+        })
+    });
+
+    let 雨艺孵化器dbList = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.羽翼孵化器, {}, []);
+    let 孵化器总面积 = parseFloat(雨艺孵化器dbList.totalArea);
+
+    let 在孵企业面积占比 = ((在孵企业面积 / 孵化器总面积) * 100).toFixed(2) + "%";
+
+    return {孵化器总面积, 在孵企业面积, 在孵企业面积占比};
+}
+
+
+export async function get在孵企业面积变化趋势() {
+    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 = {};
+
+    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 (industry) {
+            let industryStr = changeEnumValue(INDUSTRY, JSON.parse(industry)[0]);
+            if (!industryMap[industryStr]) industryMap[industryStr] = 0;
+            industryMap[industryStr] += 1;
+        }
+
+    });
+
+    let 在孵企业面积变化趋势 = Object.values(面积变化Map);
+
+    let 行业领域分布 = [];
+    for (let key in INDUSTRY) {
+        let anyKey: any = key;
+        if (isNaN(anyKey)) {
+            let keyStr = key;
+            行业领域分布.push({ key: keyStr, value: industryMap[keyStr] });
+        }
+    }
+    
+    return {在孵企业面积变化趋势, 行业领域分布};
+}
+
+
+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 function getKeyValue(data) {
     let result = [];

src/data/db/qyfw.ts

@@ -5,7 +5,7 @@
 import moment = require("moment");
 import { FUHUASTATE, INDUSTRY, OPERATIONALDATATYPE, STATE, TABLENAME, IPRALLTYPE, EMIGRATIONTYPE, NEEDCATEGORY, FOLLOWUPSTATUS } from "../../config/enum";
 import { selectData, selectManyTableData } from "./operationalData";
-import { getChart, getKeyValue, getMonthList, getYearList } from "./out";
+import { getChart, getKeyValue, getMonthList, getYearList, get在孵企业面积, get在孵企业面积变化趋势 } from "./out";
 import { getMySqlMs } from "../../tools/systemTools";
 import { changeEnumValue } from "../../tools/eccEnum";
 
@@ -31,20 +31,10 @@ export async function getEnterprise() {
         企业需求情况: { bodyList: [], headerList: [['服务企业名称', '申请时间', '诉求类型']] },
         企业需求情况详细: { bodyList: [], headerList: [['申请时间', '企业名称', '诉求类型', '需求内容', '跟进状态']] },
         需求处理情况: { dataList: [], titleList: ['key', 'value'] },
-        服务类型: {count:[], dataList:[]},
+        服务类型: [],
         入孵企业服务情况: {}
     }
 
-    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 fhColumn = ["fId", "eId", "startTime", "endTime", "state", "virtualCause", "virtualCauseDes", "moveOutType",
         "moveOutTrace", "moveOutCause", "moveOutTime", "graduationTime", ];
     //获取所有企业孵化信息
@@ -64,39 +54,14 @@ export async function getEnterprise() {
     孵化企业includeConf[TABLENAME.企业基础信息表] = { cloum: 孵化企业Clumn, where: {} }
     let 孵化企业dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业孵化信息, {}, fhColumn, 孵化企业includeConf);
 
+    let {孵化器总面积, 在孵企业面积, 在孵企业面积占比} = await get在孵企业面积();
     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 {在孵企业面积变化趋势, 行业领域分布} = await get在孵企业面积变化趋势();
 
     //企业基本信息
     qyjbqk.在孵企业 = 在孵dbList.length;
@@ -116,14 +81,7 @@ export async function getEnterprise() {
     qyfw.拟毕业企业情况.dataList.bodyList = nbyqyqk.dataList;
 
     //入孵企业行业分布
-    for (let key in INDUSTRY) {
-        let anyKey: any = key;
-        if (isNaN(anyKey)) {
-            let keyStr = key;
-
-            qyfw.入孵企业行业分布.dataList.push({ key: keyStr, value: industryMap[keyStr] });
-        }
-    }
+    qyfw.入孵企业行业分布.dataList = 行业领域分布;
 
     //获取所有企业服务表联查企业信息表
     let 企业服务includeConf = {};
@@ -142,10 +100,9 @@ export async function getEnterprise() {
     let 已受理企业服务includeConf = {};
     已受理企业服务includeConf[TABLENAME.企业基础信息表] = { cloum: ["enterpriseName"], where: {} }
     let 已受理企业服务dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业服务表, {followUpStatus:{"%ne%":FOLLOWUPSTATUS.未受理}}, [], 已受理企业服务includeConf);
-    let { fwlx, rfqyfwqk } = await getRfqyfwqk(已受理企业服务dbList);
-    qyfw.服务类型.count = fwlx.count;
-    qyfw.服务类型.dataList = fwlx.dataList;
-    qyfw.入孵企业服务情况 = rfqyfwqk;
+    let fwlx = await getRfqyfwqk(已受理企业服务dbList);
+    qyfw.服务类型 = fwlx.count;
+    qyfw.入孵企业服务情况 = fwlx.dataList;
 
     return qyfw;
 }
@@ -413,24 +370,21 @@ async function getRfqyfwqk(已受理企业服务dbList) {
         fwxx[needCategoryStr].push(info);
     })
     
-    let fwlx = { count:[{key:"服务类型", value:needCategoryEnumLength}], dataList:[{key:"全部", value:已受理企业服务dbList.length}] };
-    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;
-            fwlx.dataList.push({
-                key: needCategoryStr,
-                value: value
-            });
-        }
+    let fwlx = { 
+        count:[{key:"服务类型", value:needCategoryEnumLength}], 
+        dataList:[
+            {
+                key:"全部", value:已受理企业服务dbList.length, 
+                chartList:[], 
+                tableData:{ bodyList: [], headerList: [['服务企业名称', '服务时间', "负责人", "服务状态"]] }
             }
+        ]
+    };
 
     let month = getMonthList();
-    let rfqyfwqk = {};
+    let rfqyfwqk = {"全部":{ chartList:[], tableData:{bodyList: [], headerList: [['服务企业名称', '服务时间', "负责人", "服务状态"]] }}};
     for (let key in fwxx) {
-        if (!rfqyfwqk[key]) rfqyfwqk[key] = {dataList:[], tableData:{ bodyList: [], headerList: [['服务企业名称', '服务时间', "负责人", "服务状态"]]}};
+        if (!rfqyfwqk[key]) rfqyfwqk[key] = { chartList:[], tableData:{bodyList: [], headerList: [['服务企业名称', '服务时间', "负责人", "服务状态"]] }};
         for(let i = 0; i < month.length; i++) {
             let fuwuMonth = 0;
             fwxx[key].forEach(info => {
@@ -440,7 +394,8 @@ async function getRfqyfwqk(已受理企业服务dbList) {
                     fuwuMonth += 1;
                 }
             })
-            rfqyfwqk[key].dataList.push({key:month[i], value:fuwuMonth});
+            rfqyfwqk["全部"].chartList.push({key:month[i], value:fuwuMonth});
+            rfqyfwqk[key].chartList.push({key:month[i], value:fuwuMonth});
         }
         
         let rffwqk = [];
@@ -451,10 +406,26 @@ async function getRfqyfwqk(已受理企业服务dbList) {
             let followUpStatus = changeEnumValue(FOLLOWUPSTATUS, info.followUpStatus);
             rffwqk.push([enterpriseName, shouLiTime, "赵老师", followUpStatus]);
         })
+        rfqyfwqk["全部"].tableData.bodyList = rffwqk;
         rfqyfwqk[key].tableData.bodyList = rffwqk;
     }
 
-    return { fwlx, rfqyfwqk }
+    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;
+            fwlx.dataList.push({
+                key: needCategoryStr,
+                value: value,
+                chartList:rfqyfwqk[needCategoryStr].chartList, 
+                tableData:rfqyfwqk[needCategoryStr].tableData
+            });
+        }
+    }
+
+    return fwlx;
 }
 
 

src/data/db/zhyy.ts

@@ -2,7 +2,7 @@ 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 { getChart, getYearList, get在孵企业面积, get在孵企业面积变化趋势 } from "./out";
 import { systemConfig } from "../../config/serverConfig";
 import { getMySqlMs } from "../../tools/systemTools";
 
@@ -84,9 +84,8 @@ async function calculateRevenue(start: string, end: string) {
 export async function getZhyy() {
     let zhyy = {
         孵化器概况:[],
-        在孵企业面积占比:[{key:"在孵企业面积占比", value:"82%"}],
-        孵化运营:{
-            count:[{key:"在孵企业", value:"102家"}], 
+        在孵企业面积占比:[],
+        孵化运营:{ count:[], 
             dataList:[
                 {key:"2019", value:"36"}, {key:"2020", value:"36"}, {key:"2021", value:"36"}, 
                 {key:"2022", value:"36"}, {key:"2023", value:"36"}, {key:"2024", value:"36"}
@@ -175,38 +174,38 @@ export async function getZhyy() {
         ]
     }
 
+    let {孵化器总面积, 在孵企业面积, 在孵企业面积占比} = await get在孵企业面积();
+
+    //孵化器概况
     let 雨艺孵化器dbList = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.羽翼孵化器, {}, []);
     let fhqgk = [
-        {key:"孵化器总面积", value:雨艺孵化器dbList.totalArea}, 
+        {key:"孵化器总面积", value:孵化器总面积}, 
         {key:"注册时间", value:雨艺孵化器dbList.registerTime},
         {key:"孵化器级别", value:雨艺孵化器dbList.incubateLv}, 
         {key:"出租率", value:雨艺孵化器dbList.rentRate},
     ];
     zhyy.孵化器概况 = fhqgk;
 
-    zhyy.在孵企业面积占比
-
-
+    //在孵企业面积占比
+    zhyy.在孵企业面积占比 = [{key:"在孵企业面积占比", value:在孵企业面积占比}];
     
+    //获取在孵企业
+    let fhColumn = ["fId", "eId", "startTime", "endTime", "state", "virtualCause", "virtualCauseDes", "moveOutType",
+    "moveOutTrace", "moveOutCause", "moveOutTime", "graduationTime", ];
+    let 在孵dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业孵化信息, {state: { "%between%": [FUHUASTATE.实体孵化, FUHUASTATE.虚拟孵化] }}, fhColumn);
+    zhyy.孵化运营.count = [{key:"在孵企业", value:"102家"}];
 
+    let {在孵企业面积变化趋势, 行业领域分布} = await get在孵企业面积变化趋势();
      
-    return zhyy;
-}
-
-
-/**
- * 孵化器概况
- * @param 雨艺孵化器dbList 
- */
-async function getFhqgk(雨艺孵化器dbList) {
 
-}
 
     
 
 
 
 
+    return zhyy;
+}
 
 
 

src/routers/router.ts

@@ -14,6 +14,7 @@ import * as publicBiz from '../biz/public';
 export function setRouter(httpServer){
 
     //======post
+    httpServer.post('/yuyi/viewserver/public/industry', asyncHandler(qyszhxBiz.getIndustry));
     httpServer.post('/yuyi/viewserver/getnamelist', asyncHandler(qyszhxBiz.getPinyinName))
     httpServer.post('/yuyi/viewserver/qyszhx', asyncHandler(qyszhxBiz.getData));
     httpServer.post('/yuyi/viewserver/jxgljsc', asyncHandler(jxgljscBiz.getData));