no message

src/biz/jxgljsc.ts

@@ -56,6 +56,15 @@ export async function getData(req, res) {
     let qyfwgxqTop5 = keyValuePackage(dbList['企业服务高需求类型排行趋势'].dataList);
     ret['qyfwgxqTop5'] = getKeyValueOut('企业服务高需求类型排行趋势', qyfwgxqTop5);
 
+    let jrfw = keyValuePackage(dbList['金融服务'].dataList);
+    ret['jrfw'] = getKeyValueOut('金融服务', jrfw);
+
+    let qydkqs = keyValuePackage(dbList['融资金额变化趋势'].data);
+    ret['qydkqs'] = getKeyValueOut('融资金额变化趋势', qydkqs);
+
+    let rzfwxq = tablePackage(dbList["融资企业详情"].headerList[0], dbList["融资企业详情"].bodyList);
+    ret['rzfwxq'] = getTableOut('融资企业详情', rzfwxq);
+
     /**写死数据 */
     let fhqdfsjPackageData = keyValuePackage(excelData['孵化器得分数据'].dataList);
     ret['fhqdfsj'] = getKeyValueOut('孵化器得分数据', fhqdfsjPackageData);
@@ -75,15 +84,6 @@ export async function getData(req, res) {
     let qycxfsddnlPackageData = keyValuePackage(excelData['区域创新辐射带动能力'].dataList);
     ret['qycxfsddnl'] = getKeyValueOut('区域创新辐射带动能力', qycxfsddnlPackageData);
 
-    let jrfw = keyValuePackage(excelData['金融服务'].dataList);
-    ret['jrfw'] = getKeyValueOut('金融服务', jrfw);
-
-    let qydkqs = keyValuePackage(excelData['企业贷款趋势'].dataList);
-    ret['qydkqs'] = getKeyValueOut('企业贷款趋势', qydkqs);
-
-    let rzfwxq = tablePackage(excelData["融资服务详情"].headerList[0], excelData["融资服务详情"].bodyList);
-    ret['rzfwxq'] = getTableOut('融资服务详情', rzfwxq);
-
     res.send(ret);
 }
 

src/biz/qyfw.ts

@@ -19,7 +19,7 @@ export async function getData(req, res) {
     let dt = {}
     dtTable.dataList.forEach(info => {
         let { A, D, H } = info;
-        let loudongDetails = tablePackage(dtExcelData[A].headerList[0], dtExcelData[A].bodyList);
+        // let loudongDetails = tablePackage(dtExcelData[A].headerList[0], dtExcelData[A].bodyList);
         let imgUrl = `${systemConfig.imgPath}/${D}`;
         info["D"] = imgUrl;
         if (!dt[A]) dt[A] = { dataList: [], tableData: [] };
@@ -28,7 +28,12 @@ export async function getData(req, res) {
         })
         dt[A].dataList.push({key:"入驻率", value:dbData.入驻率入驻企业[H].入驻率});
         dt[A].dataList.push({key:"入驻企业", value:dbData.入驻率入驻企业[H].入驻企业});
-        dt[A].tableData = getTableOut("表格数据", loudongDetails);
+        
+        let loudongTable = {dataList:[], titleList:["企业名称", "入孵时间", "孵化时长", "行业领域", "企业规模"]};
+        let loudongDetails = dbData.明星企业列表;
+        loudongTable.dataList = loudongDetails[H];
+        dt[A].tableData = getTableOut("表格数据", loudongTable);
+        // dt[A].tableData = getTableOut("表格数据", loudongDetails);
     });
 
     ret['dt'] = {title:"地图", dataList:dt};

src/biz/qyszhx.ts

@@ -120,7 +120,7 @@ export async function getPinyinName(req, res) {
     let {pinyinName, industry, page} = req.body;
     let ret: any = {};
     
-    let selectParam = {};
+    let selectParam = {state: CHANGESTATE.已通过};
     if (pinyinName) selectParam["pinyinName"] = {"%like%":pinyinName};
     if (industry) selectParam["industry"] = { "%like%": industry };
     let dbList = await selectData(OPERATIONALDATATYPE.分页查询, TABLENAME.企业基础信息表, selectParam, ["eId", "enterpriseName"], page);

src/biz/zhyy.ts

@@ -21,7 +21,7 @@ export async function getData(req, res) {
     let dt = {}
     dtTable.dataList.forEach(info => {
         let { A, D, H } = info;
-        let loudongDetails = tablePackage(dtExcelData[A].headerList[0], dtExcelData[A].bodyList);
+        // let loudongDetails = tablePackage(dtExcelData[A].headerList[0], dtExcelData[A].bodyList);
         let imgUrl = `${systemConfig.imgPath}/${D}`;
         info["D"] = imgUrl;
         if (!dt[A]) dt[A] = { dataList: [], tableData: [] };
@@ -30,7 +30,12 @@ export async function getData(req, res) {
         })
         dt[A].dataList.push({key:"入驻率", value:dbData.入驻率入驻企业[H].入驻率});
         dt[A].dataList.push({key:"入驻企业", value:dbData.入驻率入驻企业[H].入驻企业});
-        dt[A].tableData = getTableOut("表格数据", loudongDetails);
+        
+        let loudongTable = {dataList:[], titleList:["企业名称", "入孵时间", "孵化时长", "行业领域", "企业规模"]};
+        let loudongDetails = dbData.明星企业列表;
+        loudongTable.dataList = loudongDetails[H];
+        dt[A].tableData = getTableOut("表格数据", loudongTable);
+        // dt[A].tableData = getTableOut("表格数据", loudongDetails);
     });
 
     ret['dt'] = { title: "地图", dataList: dt };

src/config/enum.ts

@@ -35,9 +35,9 @@ export enum TABLENAME {
     企业资质 = 'enterprise_qualification',
     参保记录 = 'enterprise_canbao',
     创业团队 = 'enterprise_team',
-    知识产权 = 'enterprise_ipr',
+    // 知识产权 = 'enterprise_ipr',
     法人信息表 = 'enterprise_legal_person',
-    企业专利表 = 'enterprise_patent',
+    // 企业专利表 = 'enterprise_patent',
     企业基础信息表 = 'enterprise',
     企业服务表 = 'enterprise_service',
     股权结构 = 'ownership',
@@ -55,6 +55,11 @@ export enum TABLENAME {
     运营推广信息表 = "info_operation_promotion",
     政策表 = "policy",
     入驻信息表 = "info_enter",
+    企业标签表 = "enterprise_label",
+    商标 = "trade_mark",
+    作品著作权 = "copy_right",
+    软件著作权 = "software_copyright",
+    专利 = "patent",
 }
 
 
@@ -378,13 +383,30 @@ export enum SELECTPARAM {
  * 知识产权 全类型
  */
 export enum IPRALLTYPE {
-    软件著作权 = 1,
-    专利 = 100,
-    发明专利 = 101,
-    海外专利 = 102,
-    其他 = 200,
-    植物新品种 = 201,
-    集成电路布图 =202
+    商标信息 = 1,
+    作品著作权,
+    软件著作权,
+    外观设计专利,
+    实用新型专利,
+    发明专利
+    // 软件著作权 = 1,
+    // 专利 = 100,
+    // 发明专利 = 101,
+    // 海外专利 = 102,
+    // 其他 = 200,
+    // 植物新品种 = 201,
+    // 集成电路布图 =202
+}
+
+
+/**
+ * 专利表属于知识产权类型中的详细分类
+ */
+export enum KUNDCODE {
+    发明公布 = 1,
+    发明授权,
+    实用新型,
+    外观设计
 }
 
 

src/data/db/jxgljsc.ts

@@ -3,7 +3,7 @@
  */
 
 import moment = require("moment")
-import { FUHUASTATE, OPERATIONALDATATYPE, TABLENAME, ENTERPRISETEAM, EMIGRATIONTYPE, STATE, FOLLOWUPSTATUS, NEEDCATEGORY, CHANGESTATE } from "../../config/enum";
+import { FUHUASTATE, OPERATIONALDATATYPE, TABLENAME, ENTERPRISETEAM, EMIGRATIONTYPE, STATE, FOLLOWUPSTATUS, NEEDCATEGORY, CHANGESTATE, FINANCINGROUNDS } from "../../config/enum";
 import { selectData, selectManyTableData } from "./operationalData";
 import { getChart, getKeyValue, getMonthList, getYearList, get在孵企业面积, get在孵企业面积变化趋势 } from "./out";
 import { changeEnumValue } from "../../tools/eccEnum";
@@ -24,6 +24,9 @@ export async function getJxgljsc() {
         企业服务需求响应率: { dataList: [], titleList: ['key', 'value'] },
         已响应需求处理进度: { dataList: [], titleList: ['key', 'value'] },
         企业服务高需求类型排行趋势: { dataList: [], titleList: ['key', 'value'] },
+        金融服务: { dataList: [], titleList: ['key', 'value'] }, //金融服务累计信息
+        融资金额变化趋势: { name: "融资金额变化趋势", data: [] },
+        融资企业详情: { bodyList: [], headerList: [['企业名称', '融资类型', '融资时间']] },
     };
 
 
@@ -88,7 +91,8 @@ export async function getJxgljsc() {
     /**
      * 孵化成果
      */
-    let 资质Column = ["qId", "eId", "kxTime", "zjtxTime", "xjrTime", "xjrPyTime", "goPublicTime", "gaoXinJiShuTime", "goPublicSector"];
+    // let 资质Column = ["qId", "eId", "kxTime", "zjtxTime", "xjrTime", "xjrPyTime", "goPublicTime", "gaoXinJiShuTime", "goPublicSector"];
+    let 资质Column = ["qId", "eId", "xjrState", "kxState", "gxjsState", "zjtxState"];
     let 企业资质联查includeConf = {};
     企业资质联查includeConf[TABLENAME.企业资质] = { cloum: 资质Column, where: {} }
     let 企业资质信息 = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {}, [], 企业资质联查includeConf);
@@ -140,6 +144,41 @@ export async function getJxgljsc() {
 
     jxgljsc.企业服务高需求类型排行趋势.dataList = await getRfqyfwqk(企业服务dbList);
 
+    /**
+     * 金融服务
+     */
+    let 企业基础信息联查includeConf = {};
+    企业基础信息联查includeConf[TABLENAME.企业基础信息表] = { cloum: ["enterpriseName"], where: {} }
+    let 金融服务dbList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业融资, {}, [], 企业基础信息联查includeConf);
+    let 金融服务 = {
+        累计融资企业:0,
+        累计融资金额:0,
+        累计融资类型:0
+    };
+
+    let 企业金融服务 = {};
+    let 累计融资类型 = {};
+    let 融资企业详情 = [];
+    金融服务dbList.forEach( info => {
+        let {enterprise, financingAmount, financingRounds, investmentDate} = info;
+        if (!企业金融服务[info.eId]) 企业金融服务[info.eId] = [];
+        企业金融服务[info.eId].push(info);
+        金融服务.累计融资金额 += parseFloat(financingAmount);
+        累计融资类型[financingRounds] += 1;
+
+        let 融资轮次 = changeEnumValue(FINANCINGROUNDS, financingRounds);
+        let 融资时间 = moment(investmentDate).format("YY/MM/DD")
+        融资企业详情.push([enterprise.enterpriseName, 融资轮次, 融资时间]);
+    })
+    金融服务.累计融资企业 = Object.keys(企业金融服务).length;
+    金融服务.累计融资类型 = Object.keys(累计融资类型).length;
+    jxgljsc.金融服务.dataList = getKeyValue(金融服务);
+
+    let 融资金额变化趋势 = await get融资金额变化趋势(金融服务dbList);
+    jxgljsc.融资金额变化趋势.data = 融资金额变化趋势;
+
+    jxgljsc.融资企业详情.bodyList = 融资企业详情;
+
     return jxgljsc;
 }
 
@@ -151,7 +190,10 @@ export async function getJxgljsc() {
  * @returns 
  */
 async function getRfqyslbhqsMonth(在孵dbList, 迁出dbList) {
-    let year = getYearList();
+    let minYear = Math.min( ...在孵dbList.map(item => new Date(item.investmentDate).getFullYear()) );
+    if (!在孵dbList.length) minYear = new Date().getFullYear();
+
+    let year = getYearList(minYear);
     let month = getMonthList();
     let currentMonth = moment().format('YY/MM'); //本月
     let lastMonth = moment().subtract(1, 'months').format('YY/MM');//上月
@@ -161,15 +203,18 @@ async function getRfqyslbhqsMonth(在孵dbList, 迁出dbList) {
     }
     
     let 本月在孵数量 = 0;
+    let 上月在孵数量 = 0;
     在孵dbList.forEach(info => {
         // 检查入孵开始时间的月份是否与当前月份相同
         let parsedStartTime = moment(info.startTime); // 获取入孵开始时间
         if (parsedStartTime.isValid() && moment(parsedStartTime).format("YY/MM") == currentMonth) {
-            本月在孵数量 += 1
+            本月在孵数量 += 1;
+        }
+        if (parsedStartTime.isValid() && moment(parsedStartTime).format("YY/MM") == lastMonth) {
+            上月在孵数量 += 1;
         }
     })
     
-    let 上月在孵数量 = 0;
     for(let i = 0; i < month.length; i++) {
         let qianruMonth = 0;
         let qianchuMonth = 0;
@@ -179,9 +224,6 @@ async function getRfqyslbhqsMonth(在孵dbList, 迁出dbList) {
             if (parsedStartTime.isValid() && moment(parsedStartTime).format("YY/MM") === month[i]) {
                 qianruMonth += 1;
             }
-            if (parsedStartTime.isValid() && moment(parsedStartTime).format("YY/MM") == lastMonth) {
-                上月在孵数量 += 1
-            }
         })
 
         迁出dbList.forEach(info => {
@@ -337,25 +379,29 @@ async function getyj() {
 }
 
 
-//企业孵化数
+/**
+ * 企业孵化数
+ * @param data 
+ * @returns 
+ */
 async function qyfhs(data) {
     //获取企业孵化数
     let qyfhs = {
-        "科小": 0,//新增"科小"
-        "小巨人": 0,
-        "高新企业": 0,
+        "科技小巨人": 0,
+        "科技型中小企业": 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.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;
+            // if (item.xjrPyState == STATE.是) qyfhs.小巨人培育 += 1;
         })
     })
 
@@ -364,4 +410,31 @@ async function qyfhs(data) {
 }
 
 
+/**
+ * 融资金额变化趋势
+ * @param 融资dbData 
+ * @returns 
+ */
+async function get融资金额变化趋势(融资dbData) {
+    let minYear = Math.min( ...融资dbData.map(item => new Date(item.investmentDate).getFullYear()) );
+    if (!融资dbData.length) minYear = new Date().getFullYear();
+    
+    let year = getYearList(minYear);
+
+    let rzqk = [];
+
+    for(let i = 0; i < year.length; i++) {
+        let 融资金额 = 0;
+        融资dbData.forEach(info => {
+            let 融资日期 = moment(info.investmentDate);
+            if (融资日期.isValid() && 融资日期.year() === year[i]) {
+                融资金额 += parseFloat(info.financingAmount || 0);
+            }
+        });
+        rzqk.push({key:year[i], value:融资金额});
+    }
+
+    return rzqk;
+}
+
 

src/data/db/out.ts

 import moment = require("moment");
-import { CHANGESTATE, FUHUASTATE, INDUSTRY, OPERATIONALDATATYPE, TABLENAME } from "../../config/enum";
+import { BUILDING, CHANGESTATE, FUHUASTATE, INDUSTRY, IPRALLTYPE, KUNDCODE, OPERATIONALDATATYPE, TABLENAME } from "../../config/enum";
 import { selectData, selectManyTableData } from "./operationalData";
 import { changeEnumValue } from "../../tools/eccEnum";
 
@@ -94,6 +94,71 @@ export async function get在孵企业面积变化趋势() {
 }
 
 
+export async function getAll知识产权() {
+    let 商标 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.商标, {}, ["tmId", "eId", "qccId", "regNo", "name", "categoryId", "category", "person", "imageUrl", "flowStatusDesc", "RegDate"]);
+    let 作品著作权 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.作品著作权, {}, ["crId", "eId", "owner", "category", "name", "registerNo", "registerDate", "publishDate", "finishDate"]);
+    let 软件著作权 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.软件著作权, {}, ["scId", "eId", "category", "publishDate", "versionNo", "registerNo", "registerAperDate", "name", "shortName", "owner", "finishDevelopDate"]);
+    let 专利 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.专利, {}, ["patentId", "eId", "category", "kindcode", "applicationNumber", "applicationDate", "publicationNumber", "publicationDate", "legalStatusDesc", "title", "agency", "kindCodeDesc", "IPCDesc", "inventorStringList", "assigneestringList"]);
+
+    let 知识产权Map:any = {};
+    知识产权Map[IPRALLTYPE.商标信息] = 商标;
+    知识产权Map[IPRALLTYPE.作品著作权] = 作品著作权;
+    知识产权Map[IPRALLTYPE.软件著作权] = 软件著作权;
+    知识产权Map[IPRALLTYPE.外观设计专利] = [];
+    知识产权Map[IPRALLTYPE.实用新型专利] = [];
+    知识产权Map[IPRALLTYPE.发明专利] = [];
+    
+    //1.发明公布，2.发明授权，3.实用新型，4.外观设计
+    专利.forEach( info => {
+        let {kindcode} = info;
+        if (kindcode == KUNDCODE.发明公布) {
+            知识产权Map[IPRALLTYPE.发明专利].push(info);
+        } else if (kindcode == KUNDCODE.发明授权) {
+            知识产权Map[IPRALLTYPE.发明专利].push(info);
+        } else if (kindcode == KUNDCODE.实用新型) {
+            知识产权Map[IPRALLTYPE.实用新型专利].push(info);
+        } else if (kindcode == KUNDCODE.外观设计) {
+            知识产权Map[IPRALLTYPE.外观设计专利].push(info);
+        }
+    })
+
+    return 知识产权Map;
+}
+
+
+export async function getById知识产权(eId) {
+    let 商标 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.商标, {eId}, ["tmId", "eId", "qccId", "regNo", "name", "categoryId", "category", "person", "imageUrl", "flowStatusDesc", "RegDate"]);
+    let 作品著作权 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.作品著作权, {eId}, ["crId", "eId", "owner", "category", "name", "registerNo", "registerDate", "publishDate", "finishDate"]);
+    let 软件著作权 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.软件著作权, {eId}, ["scId", "eId", "category", "publishDate", "versionNo", "registerNo", "registerAperDate", "name", "shortName", "owner", "finishDevelopDate"]);
+    let 专利 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.专利, {eId}, ["patentId", "eId", "category", "kindcode", "applicationNumber", "applicationDate", "publicationNumber", "publicationDate", "legalStatusDesc", "title", "agency", "kindCodeDesc", "IPCDesc", "inventorStringList", "assigneestringList"]);
+
+    let 知识产权Map:any = {};
+    知识产权Map[IPRALLTYPE.商标信息] = 商标;
+    知识产权Map[IPRALLTYPE.作品著作权] = 作品著作权;
+    知识产权Map[IPRALLTYPE.软件著作权] = 软件著作权;
+    知识产权Map[IPRALLTYPE.外观设计专利] = [];
+    知识产权Map[IPRALLTYPE.实用新型专利] = [];
+    知识产权Map[IPRALLTYPE.发明专利] = [];
+    
+    //1.发明公布，2.发明授权，3.实用新型，4.外观设计
+    专利.forEach( info => {
+        let {kindcode} = info;
+        if (kindcode == KUNDCODE.发明公布) {
+            知识产权Map[IPRALLTYPE.发明专利].push(info);
+        } else if (kindcode == KUNDCODE.发明授权) {
+            知识产权Map[IPRALLTYPE.发明专利].push(info);
+        } else if (kindcode == KUNDCODE.实用新型) {
+            知识产权Map[IPRALLTYPE.实用新型专利].push(info);
+        } else if (kindcode == KUNDCODE.外观设计) {
+            知识产权Map[IPRALLTYPE.外观设计专利].push(info);
+        }
+    })
+
+    return 知识产权Map;
+}
+
+
+
 function getStartAndEndTimeYearList(startTime, endTime) {
     let startYear = new Date(startTime).getFullYear();
     let endYear = new Date(endTime).getFullYear();
@@ -157,20 +222,31 @@ export function getMonthList() {
 }
 
 
-export function getYearList() {
-    // 获取当前年份
-    const currentTime = moment();
-    const sixMonthsAgo = currentTime.clone().subtract(6, 'year');
+/**
+ * 根据传入的年份生成当前年份与目标年份之间的所有年份列表
+ * @param targetYear 传入的年份
+ * @returns 
+ */
+export function getYearList(targetYear) {
     const currentYear = new Date().getFullYear();
-    
-    // 初始化一个空数组来存储年份
-    const years = [];
-    
-    // 使用一个循环来添加当前年份到6年后的每一个年份到数组中
-    for (let i = 0; i <= 6; i++) {
-        years.push(currentYear - i);
+  
+    // 生成目标年份与当前年份之间的年份列表
+    const startYear = Math.min(targetYear, currentYear);
+    const endYear = Math.max(targetYear, currentYear);
+    let years = [];
+    for (let year = startYear; year <= endYear; year++) {
+        years.push(year);
     }
 
+    // 如果结果不足5年，返回近5年列表
+    if (years.length < 5) {
+        years = [];
+        for (let year = currentYear - 4; year <= currentYear; year++) {
+        years.push(year);
+        }
+    }
+
+    // 确保输出顺序始终为时间正序
     years.sort((a, b) => {
         return a - b;
     })
@@ -208,7 +284,76 @@ export function getYearList() {
     }
     
     return result;
-  }
+}
+
+
+
+/**
+ * 获取各个楼栋的企业列表
+ * @returns 
+ */
+export async function get明星企业列表() {
+    // 获取当前时间
+    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 租赁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", "industry", "qiYeGuiMo"], 在孵租赁联查includeConf);
+
+    let 楼栋Map = {};
+    在孵租赁联查dbList.forEach( info => {
+        let {enterprise_fuhuas, enterprise_leases, enterpriseName, industry, qiYeGuiMo} = info;
+        let building = changeEnumValue(BUILDING, parseInt(enterprise_leases[0].building))
+        if (!楼栋Map[building]) 楼栋Map[building] = [];
+        // let intervalYear = getIntervalYear(new Date(enterprise_fuhuas[0].startTime), new Date(enterprise_fuhuas[0].endTime));
+        let intervalYear = getIntervalYear(new Date(enterprise_fuhuas[0].startTime), new Date());
+        let industryStr = changeEnumValue(INDUSTRY, industry) || "-";
+        楼栋Map[building].push([enterpriseName, moment(enterprise_fuhuas[0].startTime).format("YY/MM/DD"), intervalYear, industryStr, qiYeGuiMo]);
+    })
 
+    return 楼栋Map;
+}
+
+
+/**
+ * 计算间隔孵化时长
+ * @param startTime 
+ * @param endTime 
+ */
+function getIntervalYear(startTime, endTime) {
+    // 提取开始日期的年、月、日（注意月份需+1）
+    const startYear = startTime.getFullYear();
+    const startMonth = startTime.getMonth() + 1;
+    const startDay = startTime.getDate();
+
+    // 提取结束日期的年、月、日
+    const endYear = endTime.getFullYear();
+    const endMonth = endTime.getMonth() + 1;
+    const endDay = endTime.getDate();
+
+    // 计算总月份差
+    let totalMonths = (endYear - startYear) * 12 + (endMonth - startMonth);
+
+    // 处理天数不足的情况（未满整月）
+    if (endDay < startDay) {
+        totalMonths--;
+    }
+
+    // 处理时间倒流的情况
+    if (totalMonths < 0) {
+        return "0个月";
+    }
+
+    // 根据总月份判断输出年或月
+    if (totalMonths >= 12) {
+        const years = Math.floor(totalMonths / 12);
+        return `${years}年`;
+    } else {
+        return `${totalMonths}个月`;
+    }
+}
 
 

src/data/db/qyfw.ts

@@ -5,7 +5,7 @@
 import moment = require("moment");
 import { FUHUASTATE, INDUSTRY, OPERATIONALDATATYPE, TABLENAME, EMIGRATIONTYPE, NEEDCATEGORY, FOLLOWUPSTATUS, BUILDING } from "../../config/enum";
 import { selectData, selectManyTableData } from "./operationalData";
-import { getChart, getKeyValue, getMonthList, getYearList, get在孵企业面积, get在孵企业面积变化趋势 } from "./out";
+import { getChart, getKeyValue, getMonthList, getYearList, get在孵企业面积, get在孵企业面积变化趋势, get明星企业列表 } from "./out";
 import { changeEnumValue } from "../../tools/eccEnum";
 
 function getStartAndEndTimeYearList(startTime, endTime) {
@@ -32,7 +32,8 @@ export async function getEnterprise() {
         企业需求情况详细: { bodyList: [], headerList: [['申请时间', '企业名称', '诉求类型', '需求内容', '跟进状态']] },
         需求处理情况: { dataList: [], titleList: ['key', 'value'] },
         服务类型: [],
-        入孵企业服务情况: {}
+        入孵企业服务情况: {},
+        明星企业列表:{},
     }
 
     let 入驻Map = {};
@@ -119,6 +120,8 @@ export async function getEnterprise() {
     qyfw.服务类型 = fwlx.count;
     qyfw.入孵企业服务情况 = fwlx.dataList;
 
+    qyfw.明星企业列表 = await get明星企业列表();
+
     return qyfw;
 }
 
@@ -208,7 +211,10 @@ export async function getEnterpriseDetails(name, type) {
  * @returns 
  */
 function getRfqyslbhqsMonth(在孵dbList, 迁出dbList) {
-    let year = getYearList();
+    let minYear = Math.min( ...在孵dbList.map(item => new Date(item.investmentDate).getFullYear()) );
+    if (!在孵dbList.length) minYear = new Date().getFullYear();
+    
+    let year = getYearList(minYear);
     let month = getMonthList();
     let rfqyslbhqs = {
         "月":[],

src/data/db/qyszhx.ts

 import moment = require("moment");
 import { FINANCINGROUNDS, FOLLOWUPSTATUS, IPRALLTYPE, NEEDCATEGORY, OPERATIONALDATATYPE, QUARTER, TABLENAME } from "../../config/enum";
 import { selectData } from "./operationalData";
-import { getChart, getKeyValue, getRecentQuarters, getYearList } from "./out";
+import { getAll知识产权, getById知识产权, getChart, getKeyValue, getRecentQuarters, getYearList } from "./out";
 import { changeEnumValue } from "../../tools/eccEnum";
 
 
@@ -12,7 +12,7 @@ export async function getQyszhx(eId) {
         企业标签: { dataList: [], titleList: ['key', 'value'] },
         企业科创分: { count: [], dataList: [], chartData:[]}, //count:所属国际二级行业，chartData:饼图
         股权结构: { dataList: [], titleList: ['key', 'value'] },
-        资质认证: {count:[], bodyList: [], headerList: [['生效时间', '证书类型', '状态']]}, //count:资质认证总数
+        资质认证: {count:[], bodyList: [], headerList: [['生效时间', '证书名称', '状态']]}, //count:资质认证总数
         风险详情: {count:[], dataList:[]},
         // 失信详情: {count:[], dataList:[]},//todo
         // 违法核查: {count:[], dataList: []},//todo
@@ -56,8 +56,8 @@ export async function getQyszhx(eId) {
     qyszhx.企业基本情况.dataList = getKeyValue(qyjbqk);
 
     //企业标签
-    let 企业资质信息 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业资质, {eId}, []);
-    let qybq = get企业标签(企业资质信息);
+    let 企业标签信息 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业标签表, {eId}, ["labelName"]);
+    let qybq = get企业标签(企业标签信息);
     qyszhx.企业标签.dataList = qybq;
 
     //企业科创分
@@ -108,7 +108,7 @@ export async function getQyszhx(eId) {
     let 资质证书 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.资质证书, {eId}, ["eId", "name", "type", "startDate", "status"]);
     let zzzs = [];
     资质证书.forEach( info => {
-        zzzs.push([moment(info.startDate).format("YYYY-MM-DD"), info.type, info.status]);
+        zzzs.push([moment(info.startDate).format("YYYY-MM-DD"), info.name, info.status]);
     })
     qyszhx.资质认证.count = [{key:"资质认证", value:资质证书.length}];
     qyszhx.资质认证.bodyList = zzzs;
@@ -150,7 +150,8 @@ export async function getQyszhx(eId) {
     qyszhx.企业服务申请类型.dataList = qyfwsqlx;
 
     //知识产权
-    let 知识产权 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.知识产权, {eId}, []);
+    // let 知识产权 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.知识产权, {eId}, []);
+    let 知识产权 = await getById知识产权(eId);
     let zscq = get知识产权(知识产权);
     qyszhx.知识产权.count = [{key:"专利数量", value:zscq.count}];
     qyszhx.知识产权.dataList = getKeyValue(zscq.zscq);
@@ -180,15 +181,16 @@ export async function getQyszhx(eId) {
     let 参保记录Column = ["cId", "eId", "annual", "zhuanKe", "benKe", "shuoshi", "boShi", "boshiyishang", "qiTa"];
     let 参保记录信息 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.参保记录, { eId }, 参保记录Column);
 
+    let 企业资质信息 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业资质, {eId}, []);
     let zfbz = get租房补贴(企业资质信息, 知识产权, 参保记录信息);
     qyszhx.租房补贴.dataList = getKeyValue(zfbz);
 
     // 高新
-    let gx = get资质达标情况(企业资质信息, 'gaoXinJiShuTime');
+    let gx = get资质达标情况(企业资质信息, 'gxjsState');
     qyszhx.高新.dataList = getKeyValue(gx);
 
     // 科小
-    let kx = get资质达标情况(企业资质信息, 'kxTime');
+    let kx = get资质达标情况(企业资质信息, 'kxState');
     qyszhx.科小.dataList = getKeyValue(kx);
     
     //贷款补贴
@@ -304,9 +306,15 @@ function get企业自画像(企业经营信息, 企业融资信息, 企业专利
 
     // 3. 判断知识产权是否优秀
     let 专利总数 = 0;
-    企业专利信息.forEach(info => {
-        专利总数 += info.number;
-    });
+    if (Object.keys(企业专利信息).length) {
+        for (let key in 企业专利信息) {
+            if (企业专利信息[key].length) {
+                企业专利信息[key].forEach( info => {
+                    专利总数 += 1;
+                })
+            }
+        }
+    }
 
     qyzp["专利个数"] = 专利总数; // 返回专利个数
 
@@ -384,18 +392,28 @@ function get租房补贴(企业资质信息, 企业专利信息, 参保记录信
 
     // 检查软著状态
     let ruanzhuCompleted = false;
-    企业专利信息.forEach(patent => {
-        if (patent.iprType === IPRALLTYPE.软件著作权) {
-            ruanzhuCompleted = true;
+    if (Object.keys(企业专利信息).length) {
+        for (let key in 企业专利信息) {
+            if (企业专利信息[IPRALLTYPE.软件著作权].length) {
+                企业专利信息[key].forEach( info => {
+                    ruanzhuCompleted = true;
+                })
+            }
         }
-    });
+    }
+
+    // 企业专利信息.forEach(patent => {
+    //     if (patent.iprType === IPRALLTYPE.软件著作权) {
+    //         ruanzhuCompleted = true;
+    //     }
+    // });
     zfbt.软著 = ruanzhuCompleted ? "已完成" : "未完成";
 
     // 检查科小状态
     let kxCompleted = false;
     if (企业资质信息) {
         企业资质信息.forEach(item => {
-            if (item.kxTime) {
+            if (item.kxState) {
                 kxCompleted = true;
             }
         });
@@ -421,7 +439,7 @@ function get租房补贴(企业资质信息, 企业专利信息, 参保记录信
 /**
  * 获取企业资质达标情况的通用函数
  * @param data 企业资质数据
- * @param key 判断依据的字段名（如 'gaoXinJiShuTime', 'kxTime', 'xjrTime'）
+ * @param key 判断依据的字段名（如 'gxjsState', 'kxState', 'xjrState'）
  * @returns 达标情况对象
  */
 function get资质达标情况(data, key: string) {
@@ -445,20 +463,25 @@ function get资质达标情况(data, key: string) {
 
 
 function get企业标签(data) {
-    let qybqData = [];
+    // let qybqData = [];
+
+    // data.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("上市");
+    // })
 
-    data.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 });
+    // })
 
     let qybq = [];
-    qybqData.forEach(item => {
-        qybq.push({ key: "文本", value: item });
+    data.forEach(item => {
+        qybq.push({ key: "文本", value: item.labelName });
     })
 
     return qybq;
@@ -467,29 +490,43 @@ function get企业标签(data) {
 
 function get知识产权(data) {
     let zscq: any = {
-        软件著作权: 0,
-        发明专利: 0,
-        海外专利: 0,
-        植物新品种: 0,
-        集成电路布图: 0,
+        商标信息 : 0,
+        作品著作权 : 0,
+        软件著作权 : 0,
+        外观设计专利 : 0,
+        实用新型专利 : 0,
+        发明专利 : 0,
     }
     let count = 0;
 
-    data.forEach(patents => {
-        if (patents.iprType) {
-            let iprTypeStr = changeEnumValue(IPRALLTYPE, patents.iprType);
-            if (!zscq[iprTypeStr]) zscq[iprTypeStr] = 0;
-            zscq[iprTypeStr] += patents.number;
-        }
-        count += patents.number;
-    })
+    for (let key in data) {
+        let iprTypeStr = changeEnumValue(IPRALLTYPE, parseInt(key));
+        if (!zscq[iprTypeStr]) zscq[iprTypeStr] = 0;
+        let 知识产权Data = data[key];
+        知识产权Data.forEach(patents => {
+            zscq[iprTypeStr] += 1;
+            count += 1;
+        })
+    }
+
+    // data.forEach(patents => {
+    //     if (patents.iprType) {
+    //         let iprTypeStr = changeEnumValue(IPRALLTYPE, patents.iprType);
+    //         if (!zscq[iprTypeStr]) zscq[iprTypeStr] = 0;
+    //         zscq[iprTypeStr] += patents.number;
+    //     }
+    //     count += patents.number;
+    // })
 
     return {count, zscq};
 }
 
 
 function get融资情况(data) {
-    let year = getYearList();
+    let minYear = Math.min( ...data.map(item => new Date(item.investmentDate).getFullYear()) );
+    if (!data.length) minYear = new Date().getFullYear();
+    
+    let year = getYearList(minYear);
 
     let count = {
         融资金额:0,

src/data/db/zhyy.ts

 import moment = require("moment");
-import { BUILDING, FOLLOWUPSTATUS, FUHUASTATE, NEEDCATEGORY, OFFLINEPROMOTION, ONLINEPROMOTION, OPERATIONALDATATYPE, POLICYTYPE, PROMOTIONTYPE, TABLENAME } from "../../config/enum";
+import { BUILDING, FOLLOWUPSTATUS, FUHUASTATE, INDUSTRY, NEEDCATEGORY, OFFLINEPROMOTION, ONLINEPROMOTION, OPERATIONALDATATYPE, POLICYTYPE, PROMOTIONTYPE, TABLENAME } from "../../config/enum";
 import { selectData, selectManyTableData } from "./operationalData";
 import { changeEnumValue } from "../../tools/eccEnum";
-import { getRecentQuarters, get在孵企业面积, get在孵企业面积变化趋势 } from "./out";
+import { getAll知识产权, getRecentQuarters, get在孵企业面积, get在孵企业面积变化趋势, get明星企业列表 } from "./out";
 import { getMySqlMs } from "../../tools/systemTools";
 import { getKeyValue } from "./out";
 
@@ -76,7 +76,8 @@ export async function getZhyy() {
         服务记录:{ headerList: [['服务内容', '服务时间', '服务公司', '负责人']], bodyList: [] },
         服务成果:[],
         政策速递:[],
-        政策速递详情:[]
+        政策速递详情:[],
+        明星企业列表:{},
     }
 
     let 入驻Map = {};
@@ -102,7 +103,7 @@ export async function getZhyy() {
         {key:"孵化器总面积", value:`${孵化器总面积}㎡`}, 
         {key:"注册时间", value:雨艺孵化器dbList.registerTime},
         {key:"孵化器级别", value:雨艺孵化器dbList.incubateLv}, 
-        {key:"出租率", value:雨艺孵化器dbList.rentRate},
+        // {key:"出租率", value:雨艺孵化器dbList.rentRate},
     ];
     zhyy.孵化器概况 = fhqgk;
 
@@ -167,10 +168,13 @@ export async function getZhyy() {
         知识产权:0
     }
     
-    let 知识产权 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.知识产权, {}, []);
-    知识产权.forEach(info => {
-        hzsj.知识产权 += info.number;
-    })
+    let 知识产权 = await getAll知识产权();
+    for (let key in 知识产权) {
+        let 知识产权Data = 知识产权[key];
+        知识产权Data.forEach(patents => {
+            hzsj.知识产权 += 1;
+        })
+    }
 
     let 营收情况 = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, {}, []);
     营收情况.forEach(info => {
@@ -292,6 +296,8 @@ export async function getZhyy() {
     zhyy.政策速递 = getKeyValue(政策类型次数);
     zhyy.政策速递详情 = 政策速递详情;
 
+    zhyy.明星企业列表 = await get明星企业列表();
+
     return zhyy;
 }
 
@@ -363,7 +369,7 @@ async function get就业情况() {
     });
 
     // 计算同比增长率
-    let growthRate = "";
+    let growthRate = "0%";
     if (lastYearYearJobCount !== 0) {
         growthRate = (((currentYearJobCount - lastYearYearJobCount) / lastYearYearJobCount) * 100 ).toFixed(2) + "%";
     }
@@ -405,25 +411,28 @@ async function get就业情况() {
 async function get本季度新增规模() {
     let jidu = getRecentQuarters(2); //获取本季度和上季度
     let benjidu = jidu[0];
-    let 本季度营收dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, { annual:getMySqlMs(benjidu.year), quarter:benjidu.quarter }, null);
+    let annual = `${benjidu.year}-01-01 00:00:00`;
+    let 本季度营收dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, { annual, quarter:benjidu.quarter }, null);
     let 本季度 = 0;
     本季度营收dbList.forEach( info => {
-        本季度 += info.BI;
+        本季度 += parseFloat(info.BI);
     })
 
     let shangjidu = jidu[1];
-    let 上季度营收dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, { annual:getMySqlMs(shangjidu.year), quarter:shangjidu.quarter }, null);
+    let shangjiduAnnual = `${shangjidu.year}-01-01 00:00:00`;
+    let 上季度营收dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, { annual:shangjiduAnnual, quarter:shangjidu.quarter }, null);
     let 上季度 = 0;
     上季度营收dbList.forEach( info => {
-        上季度 += info.BI;
+        上季度 += parseFloat(info.BI);
     })
     let 同比上季度  = "0%";
     if (上季度) 同比上季度 = (((本季度 - 上季度) / 上季度)*100).toFixed(2) + "%";
 
-    let 去年本季度营收dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, { annual:getMySqlMs(benjidu.year - 1), quarter:benjidu.quarter }, null);
+    let qunianAnnual = `${benjidu.year - 1}-01-01 00:00:00`;
+    let 去年本季度营收dbList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, { annual:qunianAnnual, quarter:benjidu.quarter }, null);
     let 去年本季度 = 0;
     去年本季度营收dbList.forEach( info => {
-        去年本季度 += info.BI;
+        去年本季度 += parseFloat(info.BI);
     })
     let 环比同期 = "0%";
     if (去年本季度) 环比同期 = (((本季度 - 去年本季度) / 去年本季度)*100).toFixed(2) + "%";
@@ -433,3 +442,5 @@ async function get本季度新增规模() {
     return 本季度营收数据;
 }
 
+
+