no message

src/biz/createZip copy.ts

-import { ERRORENUM } from "../config/enum/errorEnum";
-import { BizError } from "../util/bizError";
-import * as archiver from 'archiver';
-import * as fs from 'fs-extra';
-import * as path from 'path';
-import * as ExcelJS from 'exceljs';
-import { selectData, selectManyTableData } from "../data/operationalData";
-import { OPERATIONALDATATYPE, TABLENAME } from "../config/enum/dbEnum";
-import { getAllDwOutPut } from './zaiFu';
-import * as enumConfig from "../config/enum/enum";
-import { changeAdd } from "../util/piecemeal";
-import { getMySqlMs } from "../tools/system";
-
-const moment = require("moment");
-const fetch = require('node-fetch');
-
-
-export async function newDow(eIds, options) {
-    /**拼excel表格数据 */
-    let selectParam: any = { 
-        // state: enumConfig.CHANGESTATE.已通过,
-        eId: { "%in%": eIds } // 只查询选中的企业
-    };
-     // 主表字段
-     let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "logonAddress", "qiYeGuiMo"];
-     let manyTableInfo: any = {}; 
-     // let rufuSelectParam = { state: { "%between%": [enumConfig.FUHUASTATE.实体孵化, enumConfig.FUHUASTATE.虚拟孵化] } };
-     manyTableInfo[TABLENAME.企业孵化信息] = { column: ["moveOutTime", "moveOutType", "startTime", "endTime"], where: {} };
-     
-     // 执行多表联查
-     let resInfo = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, selectParam, filesList, manyTableInfo);
-     
-     /**查询租赁表信息 */
-     let leaseWhere: any = { eId: { "%in%": eIds } };
-     let zuLingList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.租赁信息, leaseWhere, ["eId", "area", "startTime", "endTime", "building", "roomNumber"]);
-     let zaifuMap = {};
-     
-     if (zuLingList.length) {
-        zuLingList.forEach(info => {
-            zaifuMap[info.eId] = info;
-        });
-     }
-    let titleConfig = [
-        {
-            typeName:'基础信息', 
-            keyList:[
-                { key: '企业名称', value: 'enterpriseName' },
-                { key: '统一信用代码', value: 'uscc' },
-                { key: '注册时间', value: 'logonTime' },
-                { key: '行业领域', value: 'industry' },
-                { key: '注册地址', value: 'logonAddress' },
-                { key: '联系人', value: 'liaison' },
-                { key: '联系电话', value: 'liaisonPhone' },
-                { key: '企业规模', value: 'qiYeGuiMo' },
-                { key: '实缴资本', value: 'shijiaoziben' },
-                { key: '简介', value: 'jianJie' },
-                { key: '注册资本', value: 'zhuceziben' },
-                { key: '经营地址', value: 'operatingAddress' },
-                { key: '经营范围', value: 'jingYingFanWei' },
-                { key: '孵化时间', value: 'fuhuaTime' },
-                { key: '租赁面积', value: 'area' },
-                { key: '楼号', value: 'building' },
-                { key: '室号', value: 'roomNumber' }
-            ]
-        },
-        {
-            typeName:'经营数据', 
-            keyList:[
-                { key: '营收(万元)', value: 'BI' },
-                { key: '纳税(万元)', value: 'TXP' },
-                { key: '研发投入(万元)', value: 'RD' },
-                { key: '年度', value: 'annual' },
-                { key: '季度', value: 'quarter' }
-            ]
-        },
-        {
-            typeName:'融资情况', 
-            keyList:[
-                { key: '融资金额(万元)', value: 'financingAmount' },
-                { key: '融资轮次', value: 'financingRounds' },
-                { key: '孵化器是否参与投资', value: 'fuHuaQiInvestment' },
-                { key: '孵化器投资方式', value: 'fuHuaQiInvestmentStyle' },
-                { key: '孵化器投资金额', value: 'fuHuaQiInvestmentAmount' },
-                { key: '获得投资时间', value: 'investmentDate' },
-                { key: '投资机构名称', value: 'investmentInstitutionsName' },
-                { key: '估值', value: 'valuation' },
-            ]
-        },{
-            typeName:'荣誉奖项', 
-            keyList:[
-                { key: '荣誉奖项数量', value: 'awardCount' },
-                // { key: '奖项名称', value: 'awardName' },
-                // { key: '颁奖单位', value: 'awardingUnit' },
-                // { key: '获奖日期', value: 'awardTime' },
-                // { key: '奖项等级', value: 'awardLevel' }
-            ]
-        }
-    ];
-    let titleList = [];//拼接表头
-    for (let i = 0; i < titleConfig[0].keyList.length; i++) {
-        titleList.push(titleConfig[0].keyList[i].key);
-    }
-    let dataList = [];//结构:[{eId:"", subList:[数据...]}]
-    //拼接基础信息
-    let enterpriseNameMap = {};//用来给文件目录映射名称用 {eId:"名称"}
-    for (let info of resInfo) {
-        let { eId, enterpriseName, uscc, logonTime, logonAddress, qiYeGuiMo, enterprise_fuhuas } = info;
-
-        enterpriseNameMap[eId] = enterpriseName;
-        let leasesTime = '-';
-        if (zaifuMap[eId]?.startTime) {
-            leasesTime = `${moment(zaifuMap[eId].startTime).format("YYYY-MM-DD")}至${moment(zaifuMap[eId].endTime).format("YYYY-MM-DD")}`;
-        }
-
-        let fuhuaTime = '-';
-        if (enterprise_fuhuas[0]?.startTime) {
-            fuhuaTime = `${moment(enterprise_fuhuas[0].startTime).format("YYYY-MM-DD")}至${moment(enterprise_fuhuas[0].endTime).format("YYYY-MM-DD")}`;
-        }
-        let itemData = { 
-            eId, enterpriseName, uscc, logonTime: moment(logonTime).format("YYYY-MM-DD"), logonAddress: changeAdd(JSON.parse(logonAddress)), qiYeGuiMo, fuhuaTime, leasesTime, area: zaifuMap[eId]?.area ? `${zaifuMap[eId].area}㎡` : '-', building: zaifuMap[eId]?.building || '-', roomNumber: zaifuMap[eId]?.roomNumber || '-'
-        }
-        let subList = [];
-        for (let i = 0; i < titleConfig[0].keyList.length; i++) {
-            subList.push(itemData[titleConfig[0].keyList[i].value]||"");
-        }
-        dataList.push({eId, subList});
-    }
-    //拼接第经营数据 写法参考第一个拼接基础信息，但是需要注意的是，赋值的时候不能使用excelDataList.push(), 要用下标赋值，做到这里的时候来问我
-    /**查询经营表信息 */
-    let jinyingWhere: any = { eId: { "%in%": eIds },  isSubmit:enumConfig.STATE.是};
-    let jinyingList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业经营信息, jinyingWhere, ["eId", "annual", "quarter", "BI", "TXP", "RD", "createTime"]);
-    
-    // 根据年度季度获取最新一条已提交经营数据 // a.1 b.1 a.2 c.1
-    let jinyingListToTimeMap:any = {};
-    jinyingList.forEach(info => {
-        let {eId} = info;
-        if (!jinyingListToTimeMap[eId]) jinyingListToTimeMap[eId] = [];
-        jinyingListToTimeMap[eId].push(info);
-    });
-    let jinyingMap = {};//结构：{"eId":数据字段}
-    for (let eId in jinyingListToTimeMap) {
-        let thisEidJinyingList = jinyingListToTimeMap[eId];
-        thisEidJinyingList.sort((a, b) => {
-            //先按年度比较
-            if (b.annual !== a.annual) {
-                return new Date(b.annual).valueOf() - new Date(a.annual).valueOf();
-            }
-            //年度相同则按季度比较
-            return b.quarter - a.quarter;
-        });
-        //将数据进行格式化：枚举转换 时间格式转换
-        let thisjingyinInfo = thisEidJinyingList[0];
-        thisjingyinInfo.quarter = changeEnumValue(enumConfig.QUARTER, thisjingyinInfo.quarter);
-        thisjingyinInfo.annual = moment(thisjingyinInfo.annual).format("YYYY");
-        jinyingMap[eId] = thisjingyinInfo;
-    }
-    //拼接经营数据的表头
-    for (let i = 0; i < titleConfig[1].keyList.length; i++) {
-        titleList.push(titleConfig[1].keyList[i].key);
-    }
-    for (let i = 0; i< dataList.length; i++) {
-        let {eId, subList} = dataList[i];
-        for (let i = 0; i < titleConfig[1].keyList.length; i++) {//取经营数据的配置 按配置将jinyinMap的数据映射到 subList
-            if (!jinyingMap[eId]) {
-                subList.push("");
-            } else {
-                subList.push(jinyingMap[eId][titleConfig[1].keyList[i].value] || "");
-            }
-           
-        }
-    }
-
-    /**查询融资信息 拼接融资信息  同上注释*/
-    let rongziWhere:any = { eId: { "%in%": eIds } };
-    let rongziColumn = ["eId", "financingAmount", "financingRounds", "fuHuaQiInvestment", "fuHuaQiInvestmentStyle", "fuHuaQiInvestmentAmount", 
-    "investmentDate", "investmentInstitutionsName", "valuation"];
-    let rongziList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业融资, rongziWhere, rongziColumn);
-    
-    // 根据获得投资时间获取最新一条数据
-    let rongziListToTimeMap:any = {};
-    rongziList.forEach( info => {
-        let {eId} = info;
-        if (!rongziListToTimeMap[eId]) rongziListToTimeMap[eId] = [];
-        rongziListToTimeMap[eId].push(info);
-    });
-    let rongziMap = {};
-    for (let eId in rongziListToTimeMap) {
-        let thisEidRongZiList = rongziListToTimeMap[eId];
-        thisEidRongZiList.sort((a, b) => {
-            return new Date(b.investmentDate).valueOf() - new Date(a.investmentDate).valueOf();
-        })
-        //将数据格式化
-        let thisRongZiInfo = thisEidRongZiList[0];
-        thisRongZiInfo.financingRounds = changeEnumValue(enumConfig.FINANCINGROUNDS, thisRongZiInfo.financingRounds);
-        thisRongZiInfo.fuHuaQiInvestmentStyle = changeEnumValue(enumConfig.FUHUAQILNVESTMENTSTYLE, thisRongZiInfo.fuHuaQiInvestmentStyle);
-        thisRongZiInfo.investmentDate = moment(thisRongZiInfo.investmentDate).format("YYYY-MM-DD");
-        rongziMap[eId] = thisRongZiInfo;
-    }
-    //拼接融资数据的表头
-    for (let i = 0; i < titleConfig[2].keyList.length; i++) {
-        titleList.push(titleConfig[2].keyList[i].key);
-    }
-    for (let i = 0; i< dataList.length; i++) {
-        let {eId, subList} = dataList[i];
-        for (let i = 0; i < titleConfig[2].keyList.length; i++) {//取融资数据的配置 按配置将rongziMap的数据映射到 subList
-            if (!rongziMap[eId]) {
-                subList.push("");
-            }  else {
-                subList.push(rongziMap[eId][titleConfig[2].keyList[i].value] || "");
-            }
-        }
-    }
-
-    /**查询荣誉奖项信息 拼接荣誉奖项信息  同上注释*/
-    let rongyuWhere:any = {eId: { "%in%": eIds}};
-    let rongyuList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.企业荣誉, rongyuWhere, ["eId", "awardName", "awardingUnit", "awardTime", "awardLevel"]);
-
-    //统计荣誉奖项数量
-    let rongyuMap = {}
-    if (rongyuList.length) {
-        rongyuList.forEach(info => {
-            let {eId} = info;
-            if (!rongyuMap[eId]) rongyuMap[eId] = {"awardCount": 0};
-            else rongyuMap[eId]["awardCount"] += 1;
-        });
-    } else {
-        for (let i = 0; i < eIds.length; i++) {
-            if (!rongyuMap[eIds[i]]) rongyuMap[eIds[i]] = {"awardCount": 0};
-            else rongyuMap[eIds[i]]["awardCount"] += 1;
-        }
-    }
-    
-    //拼接荣誉奖项的表头
-    for (let i = 0; i < titleConfig[3].keyList.length; i++) {
-        titleList.push(titleConfig[3].keyList[i].key);
-    }
-    for (let i = 0; i< dataList.length; i++) {
-        let {eId, subList} = dataList[i];
-        for (let i = 0; i < titleConfig[3].keyList.length; i++) {//取荣誉奖项的配置 按配置将rongyuMap的数据映射到 subList
-            subList.push(rongyuMap[eId][titleConfig[3].keyList[i].value || ""]);
-        }
-    }
-    
-    //得到了excelDataList列表
-    let excelDataList = [ titleList ];//[[标题...]，[数据...]]
-    dataList.forEach(info => {
-        let {eId, subList} = info;
-        excelDataList.push(subList);
-    });
-    
-    /**接下来要获取对应的文件目录 */
-    console.log();
-    //1.首先要知道要获取一些什么文件  商标=>字段
-    let getFilesConf = {};//如果无需使用库中的命名，就用中文
-    getFilesConf[DOWNLOADTYPE.知识产权] = {
-        cheName:"知识产权",
-        itemConfList:[
-            {tableName:TABLENAME.专利, filesConfMap:{"iprUrl":"title"}},
-            {tableName:TABLENAME.软件著作权, filesConfMap:{"iprUrl":"name"}},
-            {tableName:TABLENAME.作品著作权, filesConfMap:{"iprUrl":"name"}},
-            {tableName:TABLENAME.商标, filesConfMap:{"imageUrl":"name"}}
-        ]
-    };
-    getFilesConf[DOWNLOADTYPE.租赁信息] = {
-        cheName:"租赁信息",
-        itemConfList:[{tableName:TABLENAME.租赁信息, filesConfMap:{
-            "sanFangXieYi":"三方协议",
-            "fuHuaXieYi":"孵化协议",
-            "fangWuZuLing":"房屋租赁合同",
-            "fuHuaXieYiBuChong":"孵化协议补充协议书",
-            "chengXinChengNuoHan":"诚信承诺函",
-            "yingYeZhiZhao":"营业执照复印件",
-            "ruFuZiLiao":"入孵资料明细",
-            "ruZhuJiHua":"入驻计划复印件",
-            "yaJinZhiFu":"押金支付凭证",
-            "cardCopy":"身份证复印件地址",
-        }}]
-    };
-    getFilesConf[DOWNLOADTYPE.资质证书] = {
-        cheName:"资质证书",
-        itemConfList:[{tableName:TABLENAME.企业资质, filesConfMap:{
-            "kxImg":"科技型中小企业证书",
-            "gaoXinJiShuImg":"高新技术证书",
-            "zjtxImg":"专精特新证书",
-            "xjrPyImg":"小巨人培育证书",
-            "cxImg":"创新型中小企业证书",
-        }}]
-    };
-    
-    
-    //2.拼接成 filesServer 需要的数据结构  
-    let filesServerFileList = [];//[ {enterpriseName:"", thisEnterpriseFilesList:[{dirName:"商标", subList:[{fileName:"商标名1", url:"" }] }, {}]  }]
-    
-    let enterpriseFilesMap = {};//{"企业名称"：{"商标", subList:[{fileName:"商标名1", url:"" }]} }
-    for (let dowType in getFilesConf) {
-        let {itemConfList, cheName} = getFilesConf[dowType];
-
-        for (let i = 0; i < itemConfList.length; i++) {
-            let {tableName, filesConfMap} = itemConfList[i];
-            let itemSelectFiles = ["eId"];
-            for (let filesConfKey in filesConfMap) {
-                if (/^[A-Za-z]+$/.test(filesConfMap[filesConfKey])) {
-                    itemSelectFiles.push(filesConfMap[filesConfKey]);
-                }
-                itemSelectFiles.push(filesConfKey);
-            }
-            let itemDBList = await selectData(OPERATIONALDATATYPE.查询多个, tableName, {eId: { "%in%": eIds}}, itemSelectFiles);
-            
-            itemDBList.forEach(info => {
-                //多个企业的待会在这里做判断 用名称做区分
-                if (!enterpriseFilesMap[info.eId]) enterpriseFilesMap[info.eId] = {};
-                if (!enterpriseFilesMap[info.eId][cheName]) enterpriseFilesMap[info.eId][cheName] = [];
-                
-               
-                for (let filesConfKey in filesConfMap) { // url:名称
-                    let infofileName = filesConfMap[filesConfKey];
-                    if (/^[A-Za-z]+$/.test(infofileName)) {
-                        infofileName = info[infofileName];
-                    }
-                    let thisInfoFileUrlList = [];
-                    if (info[filesConfKey]) {
-                        thisInfoFileUrlList = JSON.parse(info[filesConfKey])
-                    }
-                    thisInfoFileUrlList.forEach((subFileUrl, subFileUrlIndex) => {
-                        let subFileName = infofileName;
-                        if (subFileUrlIndex) {
-                            subFileName += `_${subFileUrlIndex+1}`;
-                        }
-                        enterpriseFilesMap[info.eId][cheName].push({
-                            fileName:subFileName,
-                            url:subFileUrl
-                        });
-                    })
-                    
-                }
-            });
-        }
-        
-    }
-
-    //[ {enterpriseName:"", thisEnterpriseFilesList:[{dirName:"商标", subList:[{fileName:"商标名1", url:"" }] }, {}]  }]
-    for (let eId in enterpriseFilesMap) {
-        let thisEnterpriseFilesList = [];
-        for (let cheName in enterpriseFilesMap[eId]) {
-            let subList = enterpriseFilesMap[eId][cheName];
-            thisEnterpriseFilesList.push({
-                dirName:cheName,
-                subList
-            });
-        }
-        filesServerFileList.push({
-            enterpriseName:enterpriseNameMap[eId],
-            thisEnterpriseFilesList
-        });
-    }
-    
-    let reqData = {
-        excelDataList:{name:"sheet1", data:excelDataList},//{ name:"sheet1", data:[[]]} ];
-        fileList:filesServerFileList,
-        zipFileName:`企业数据合并_${eIds.length}家_${moment().format('YYYYMMDDHHmmss')}`
-    };
-
-    let fileReqRes = await post(`${systemConfig.unZipFileUrl}/file/admin/zipdownload/consolidated`, reqData , {sign:"isdfalfdjasoiufoisjdlnad29230428029014i23mlkdslkf"});
-
-    return fileReqRes;
-}
-
-
-
-
-/**
- * 下载选中企业的zip包文件（最多10个）- 直接包含文件夹版本
- */
-export async function downloadSelectedEnterprisesZip(eIds: string[]) {
-    try {
-        if (!eIds || !Array.isArray(eIds)) {
-            throw new BizError(ERRORENUM.参数错误, '企业ID列表不能为空');
-        }
-        
-        if (eIds.length > 10) {
-            throw new BizError(ERRORENUM.参数错误, '一次最多只能下载10家企业');
-        }
-        
-        const projectRoot = path.resolve(__dirname, '../..');
-        const tempBaseDir = path.join(projectRoot, 'temp');
-        await fs.ensureDir(tempBaseDir);
-        
-        // 创建总临时目录
-        const tempDir = path.join(tempBaseDir, `temp_selected_enterprises_${Date.now()}`);
-        console.log(`创建总临时目录: ${tempDir}`);
-        await fs.ensureDir(tempDir);
-
-        // 步骤1: 获取选中企业的详细信息
-        console.log('=== 开始获取选中企业列表 ===');
-        const enterprises = await getSelectedEnterprises(eIds);
-        console.log(`获取到 ${enterprises.length} 家选中企业`);
-
-        if (enterprises.length === 0) {
-            throw new BizError(ERRORENUM.数据不存在, '未找到任何选中的企业数据');
-        }
-
-        // 步骤2: 为每家企业直接创建文件夹和文件（不生成单独的zip）
-        console.log('=== 开始为选中企业创建文件夹和文件 ===');
-        const enterpriseResults = await generateEnterpriseFolders(enterprises, tempDir);
-
-        // 步骤3: 创建包含所有企业文件夹的总zip文件
-        console.log('=== 创建总zip文件 ===');
-        const totalZipFileName = `选中企业完整数据_${moment().format('YYYYMMDDHHmmss')}.zip`;
-        const totalZipFilePath = path.join(tempBaseDir, totalZipFileName);
-
-        console.log(`创建总ZIP文件: ${totalZipFilePath}`);
-        await createZipArchive(tempDir, totalZipFilePath);
-
-        const zipStats = await fs.stat(totalZipFilePath);
-        console.log(`总ZIP文件创建成功，大小: ${zipStats.size} bytes`);
-
-        // 步骤4: 清理临时目录
-        console.log('清理临时目录...');
-        await fs.remove(tempDir);
-
-        // 统计信息
-        const successfulCount = enterpriseResults.filter(result => result.success).length;
-        const failedCount = enterpriseResults.filter(result => !result.success).length;
-
-        return {
-            success: true,
-            filePath: totalZipFilePath,
-            fileName: totalZipFileName,
-            statistics: {
-                total: enterprises.length,
-                successful: successfulCount,
-                failed: failedCount,
-                details: enterpriseResults
-            }
-        };
-    } catch (error) {
-        console.error('下载选中企业zip包失败:', error);
-        throw new BizError(ERRORENUM.系统错误, '批量打包失败: ' + error.message);
-    }
-}
-
-
-/**
- * 为每家企业直接创建文件夹和文件（不生成单独的zip）
- */
-async function generateEnterpriseFolders(enterprises: any[], baseTempDir: string): Promise<any[]> {
-    const results = [];
-    
-    // 限制并发数，避免内存溢出
-    const BATCH_SIZE = 3; // 每次同时处理3家企业
-    
-    for (let i = 0; i < enterprises.length; i += BATCH_SIZE) {
-        const batch = enterprises.slice(i, i + BATCH_SIZE);
-        console.log(`处理批次 ${Math.floor(i/BATCH_SIZE) + 1}: 企业 ${i+1} 到 ${i + batch.length}`);
-        
-        const batchPromises = batch.map(async (enterprise) => {
-            try {
-                const eId = enterprise.eId;
-                const enterpriseName = enterprise.enterpriseName || '未知企业';
-                
-                console.log(`\n=== 开始处理企业: ${enterpriseName} (${eId}) ===`);
-                
-                // 为每家企业创建文件夹（直接放在总目录下）
-                const safeEnterpriseName = sanitizeFileName(enterpriseName);
-                const enterpriseFolderName = `${safeEnterpriseName}_${eId}`;
-                const enterpriseFolderPath = path.join(baseTempDir, enterpriseFolderName);
-                await fs.ensureDir(enterpriseFolderPath);
-                
-                console.log(`创建企业文件夹: ${enterpriseFolderPath}`);
-                
-                // 生成企业详情Excel
-                await generateEnterpriseDetailExcel(eId, enterpriseName, enterpriseFolderPath);
-                
-                // 下载企业相关文件到企业文件夹
-                await downloadEnterpriseFiles(eId, enterpriseFolderPath);
-                
-                // 获取文件夹大小
-                const folderSize = await getFolderSize(enterpriseFolderPath);
-                
-                console.log(`✅ 企业 ${enterpriseName} 处理完成，文件夹大小: ${folderSize} bytes`);
-                
-                return {
-                    eId,
-                    enterpriseName,
-                    success: true,
-                    folderName: enterpriseFolderName,
-                    fileSize: folderSize,
-                    error: null
-                };
-            } catch (error) {
-                console.error(`❌ 企业 ${enterprise.enterpriseName} (${enterprise.eId}) 处理失败:`, error);
-                
-                return {
-                    eId: enterprise.eId,
-                    enterpriseName: enterprise.enterpriseName,
-                    success: false,
-                    folderName: null,
-                    fileSize: 0,
-                    error: error.message
-                };
-            }
-        });
-        
-        const batchResults = await Promise.allSettled(batchPromises);
-        
-        // 处理批次结果
-        for (const result of batchResults) {
-            if (result.status === 'fulfilled') {
-                results.push(result.value);
-            } else {
-                console.error('批次处理中出现未捕获的错误:', result.reason);
-                results.push({
-                    eId: 'unknown',
-                    enterpriseName: '未知企业',
-                    success: false,
-                    folderName: null,
-                    fileSize: 0,
-                    error: result.reason.message
-                });
-            }
-        }
-        
-        // 批次间延迟，避免服务器压力过大
-        if (i + BATCH_SIZE < enterprises.length) {
-            console.log('批次处理完成，等待2秒继续下一批...');
-            await new Promise(resolve => setTimeout(resolve, 2000));
-        }
-    }
-    
-    return results;
-}
-
-
-/**
- * 计算文件夹大小
- */
-async function getFolderSize(folderPath: string): Promise<number> {
-    try {
-        let totalSize = 0;
-        
-        const items = await fs.readdir(folderPath);
-        
-        for (const item of items) {
-            const itemPath = path.join(folderPath, item);
-            const stats = await fs.stat(itemPath);
-            
-            if (stats.isDirectory()) {
-                totalSize += await getFolderSize(itemPath);
-            } else {
-                totalSize += stats.size;
-            }
-        }
-        
-        return totalSize;
-    } catch (error) {
-        console.error(`计算文件夹大小失败: ${folderPath}`, error);
-        return 0;
-    }
-}
-
-
-/**
- * 修改下载企业文件方法，创建分类子文件夹
- */
-async function downloadEnterpriseFiles(eId: string, enterpriseFolderPath: string) {
-    // 创建分类子文件夹
-    const categories = {
-        '租赁信息': getLeaseFiles,
-        '商标': getTrademarkFiles,
-        '作品著作权': getCopyrightFiles,
-        '软件著作权': getSoftwareCopyrightFiles,
-        '专利': getPatentFiles
-    };
-    
-    console.log('=== 开始下载企业文件到分类文件夹 ===');
-    
-    for (const [categoryName, fileGetter] of Object.entries(categories)) {
-        try {
-            const categoryFolderPath = path.join(enterpriseFolderPath, categoryName);
-            await fs.ensureDir(categoryFolderPath);
-            
-            console.log(`下载 ${categoryName} 文件...`);
-            const files = await fileGetter(eId);
-            
-            // 先验证文件存在性
-            const validFiles: {url: string, fileName: string}[] = [];
-            
-            for (const file of files) {
-                const exists = await checkFileExists(file.url);
-                if (exists) {
-                    validFiles.push(file);
-                    console.log(`✅ 文件可用: ${file.fileName}`);
-                } else {
-                    console.warn(`❌ 文件不存在，跳过: ${file.fileName}`);
-                }
-            }
-            
-            console.log(`${categoryName} 有效文件数量: ${validFiles.length}/${files.length}`);
-            
-            // 只下载存在的文件
-            if (validFiles.length > 0) {
-                await downloadFilesToFolder(validFiles, categoryFolderPath);
-            }
-            
-        } catch (error) {
-            console.error(`下载 ${categoryName} 文件失败:`, error);
-            // 继续处理其他分类，不中断整个流程
-        }
-    }
-}
-
-/**
- * 下载文件到指定文件夹
- */
-async function downloadFilesToFolder(files: {url: string, fileName: string}[], targetFolder: string): Promise<void> {
-    if (files.length === 0) {
-        return;
-    }
-
-    const downloadPromises = files.map(async (file) => {
-        try {
-            if (!file.url || typeof file.url !== 'string') {
-                console.warn(`文件URL无效:`, file.url);
-                return;
-            }
-            
-            console.log(`开始下载文件: ${file.fileName} from ${file.url}`);
-            
-            const fetchOptions: any = {
-                method: 'GET',
-                timeout: 30000,
-                headers: {
-                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
-                    'Accept': '*/*'
-                }
-            };
-            
-            // 添加认证 token
-            const SECRET_TOKEN = "Ngz86cuAKxblwXR9OiKSWbfkj7oZ8R0lMU8pTfpVYBDCkvtUb0ZwbaBvwWyfv2O9";
-            
-            if (file.url.includes('192.168.0.71') || file.url.includes('fh.tninnopark.cn')) {
-                fetchOptions.headers['token'] = SECRET_TOKEN;
-            }
-            
-            const response = await fetch(file.url, fetchOptions);
-            
-            if (!response.ok) {
-                console.warn(`下载文件失败: ${file.url}, 状态码: ${response.status}`);
-                return;
-            }
-
-            const buffer = await response.buffer();
-            
-            if (buffer.length === 0) {
-                console.warn(`文件内容为空: ${file.fileName}`);
-                return;
-            }
-            
-            const filePath = path.join(targetFolder, file.fileName);
-            await fs.writeFile(filePath, buffer);
-            console.log(`✅ 文件下载成功: ${file.fileName}, 大小: ${buffer.length} bytes`);
-            
-        } catch (error) {
-            console.error(`下载文件失败: ${file.fileName} (${file.url})`, error.message);
-        }
-    });
-
-    const results = await Promise.allSettled(downloadPromises);
-    
-    const successful = results.filter(result => result.status === 'fulfilled').length;
-    const failed = results.filter(result => result.status === 'rejected').length;
-    
-    console.log(`文件夹 ${targetFolder} 下载完成: 成功 ${successful} 个, 失败 ${failed} 个`);
-}
-
-
-/**
- * 获取选中企业的详细信息
- */
-async function getSelectedEnterprises(eIds: string[]): Promise<any[]> {
-    try {
-        if (!eIds || eIds.length === 0) {
-            return [];
-        }
-        
-        let selectParam: any = { 
-            // state: enumConfig.CHANGESTATE.已通过,
-            eId: { "%in%": eIds } // 只查询选中的企业
-        };
-        
-        // 主表字段
-        let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "logonAddress", "qiYeGuiMo"];
-        let manyTableInfo: any = {}; 
-        // let rufuSelectParam = { state: { "%between%": [enumConfig.FUHUASTATE.实体孵化, enumConfig.FUHUASTATE.虚拟孵化] } };
-        manyTableInfo[TABLENAME.企业孵化信息] = { column: ["moveOutTime", "moveOutType", "startTime", "endTime"], where: {} };
-        
-        // 执行多表联查
-        let resInfo = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, selectParam, filesList, manyTableInfo);
-        
-        /**查询租赁表信息 */
-        let leaseWhere: any = { eId: { "%in%": eIds } };
-        let zuLingList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.租赁信息, leaseWhere, ["eId", "area", "startTime", "endTime", "building", "roomNumber"]);
-        let zaifuMap = {};
-        
-        if (zuLingList.length) {
-            zuLingList.forEach(info => {
-                zaifuMap[info.eId] = info;
-            });
-        }
-        
-        let selectedEnterprises = [];
-        
-        for (let info of resInfo) {
-            let {
-                eId,
-                enterpriseName,
-                uscc,
-                logonTime,
-                logonAddress,
-                qiYeGuiMo,
-                enterprise_fuhuas,
-            } = info;
-
-            let leasesTime = '-';
-            if (zaifuMap[eId]?.startTime) {
-                leasesTime = `${moment(zaifuMap[eId].startTime).format("YYYY-MM-DD")}至${moment(zaifuMap[eId].endTime).format("YYYY-MM-DD")}`;
-            }
-
-            let fuhuaTime = '-';
-            if (enterprise_fuhuas[0]?.startTime) {
-                fuhuaTime = `${moment(enterprise_fuhuas[0].startTime).format("YYYY-MM-DD")}至${moment(enterprise_fuhuas[0].endTime).format("YYYY-MM-DD")}`;
-            }
-
-            selectedEnterprises.push({
-                eId,
-                enterpriseName,
-                uscc,
-                logonTime: moment(logonTime).format("YYYY-MM-DD"),
-                logonAddress: changeAdd(JSON.parse(logonAddress)),
-                qiYeGuiMo,
-                fuhuaTime,
-                leasesTime,
-                area: zaifuMap[eId]?.area ? `${zaifuMap[eId].area}㎡` : '-',
-                building: zaifuMap[eId]?.building || '-',
-                roomNumber: zaifuMap[eId]?.roomNumber || '-'
-            });
-        }
-
-        console.log(`获取到 ${selectedEnterprises.length} 家选中企业`);
-        return selectedEnterprises;
-        
-    } catch (error) {
-        console.error('获取选中企业列表失败:', error);
-        throw new BizError(ERRORENUM.系统错误, '获取选中企业列表失败: ' + error.message);
-    }
-}
-
-
-/**
- * 获取所有企业列表（支持过滤条件）
- */
-async function getAllEnterprisesWithFilters(filters: {
-    enterpriseName?: string;
-    logonStartTime?: Number;
-    logonEndTime?: Number;
-    startTime?: Number;
-    endTime?: Number;
-    building?: number;
-} = {}): Promise<any[]> {
-    try {
-        let selectParam: any = { state: enumConfig.CHANGESTATE.已通过 };
-        
-        // 应用过滤条件
-        if (filters.enterpriseName) {
-            selectParam.enterpriseName = { "%like%": filters.enterpriseName };
-        }
-        if (filters.logonStartTime && filters.logonEndTime) {
-            selectParam.logonTime = { "%between%": [getMySqlMs(filters.logonStartTime), getMySqlMs(filters.logonEndTime)] };
-        }
-
-        // 主表字段
-        let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "logonAddress", "qiYeGuiMo"];
-        let manyTableInfo: any = {};
-        let rufuSelectParam = { state: { "%between%": [enumConfig.FUHUASTATE.实体孵化, enumConfig.FUHUASTATE.虚拟孵化] } };
-        manyTableInfo[TABLENAME.企业孵化信息] = { column: ["moveOutTime", "moveOutType", "startTime", "endTime"], where: rufuSelectParam };
-        
-        // 执行多表联查
-        let resInfo = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, selectParam, filesList, manyTableInfo);
-        
-        /**查询租赁表信息 */
-        let leaseWhere: any = {};
-        if (filters.building) {
-            leaseWhere.building = filters.building;
-        }
-        
-        // 时间范围过滤（如果需要的话）
-        // if (filters.startTime && filters.endTime) {
-        //     leaseWhere["%literal%"] = `(startTime BETWEEN '${getMySqlMs(filters.startTime)}' and '${getMySqlMs(filters.endTime)}' or endTime BETWEEN '${getMySqlMs(filters.startTime)}' and '${getMySqlMs(filters.endTime)}') `;
-        // }
-        
-        let zuLingList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.租赁信息, leaseWhere, ["eId", "area", "startTime", "endTime", "building", "roomNumber"]);
-        let zaifuMap = {};
-        
-        if (zuLingList.length) {
-            zuLingList.forEach(info => {
-                zaifuMap[info.eId] = info;
-            });
-        }
-        
-        let allEnterprises = [];
-        
-        for (let info of resInfo) {
-            let {
-                eId,
-                enterpriseName,
-                uscc,
-                logonTime,
-                logonAddress,
-                qiYeGuiMo,
-                enterprise_fuhuas,
-            } = info;
-
-            // 如果有租赁信息过滤条件，只包含有匹配租赁记录的企业
-            if (Object.keys(leaseWhere).length && !zaifuMap[eId]) {
-                continue;
-            }
-
-            let leasesTime = '-';
-            if (zaifuMap[eId]?.startTime) {
-                leasesTime = `${moment(zaifuMap[eId].startTime).format("YYYY-MM-DD")}至${moment(zaifuMap[eId].endTime).format("YYYY-MM-DD")}`;
-            }
-
-            let fuhuaTime = '-';
-            if (enterprise_fuhuas[0]?.startTime) {
-                fuhuaTime = `${moment(enterprise_fuhuas[0].startTime).format("YYYY-MM-DD")}至${moment(enterprise_fuhuas[0].endTime).format("YYYY-MM-DD")}`;
-            }
-
-            allEnterprises.push({
-                eId,
-                enterpriseName,
-                uscc,
-                logonTime: moment(logonTime).format("YYYY-MM-DD"),
-                logonAddress: changeAdd(JSON.parse(logonAddress)),
-                qiYeGuiMo,
-                fuhuaTime,
-                leasesTime,
-                area: zaifuMap[eId]?.area ? `${zaifuMap[eId].area}㎡` : '-',
-                building: zaifuMap[eId]?.building || '-',
-                roomNumber: zaifuMap[eId]?.roomNumber || '-'
-            });
-        }
-
-        console.log(`获取到 ${allEnterprises.length} 家符合条件的企业`);
-        return allEnterprises;
-        
-    } catch (error) {
-        console.error('获取企业列表失败:', error);
-        throw new BizError(ERRORENUM.系统错误, '获取企业列表失败: ' + error.message);
-    }
-}
-
-
-/**
- * 为每家企业生成单独的zip包
- */
-async function generateEnterpriseZips(enterprises: any[], baseTempDir: string): Promise<any[]> {
-    const results = [];
-    
-    // 限制并发数，避免内存溢出
-    const BATCH_SIZE = 3; // 每次同时处理3家企业
-    
-    for (let i = 0; i < enterprises.length; i += BATCH_SIZE) {
-        const batch = enterprises.slice(i, i + BATCH_SIZE);
-        console.log(`处理批次 ${Math.floor(i/BATCH_SIZE) + 1}: 企业 ${i+1} 到 ${i + batch.length}`);
-        
-        const batchPromises = batch.map(async (enterprise) => {
-            try {
-                const eId = enterprise.eId;
-                const enterpriseName = enterprise.enterpriseName || '未知企业';
-                
-                console.log(`\n=== 开始处理第${i+1}家企业: ${enterpriseName} (${eId}) ===`);
-                
-                // 为每家企业创建单独目录
-                const enterpriseTempDir = path.join(baseTempDir, `enterprise_${eId}`);
-                await fs.ensureDir(enterpriseTempDir);
-                
-                // 生成企业详情Excel
-                const excelFilePath = await generateEnterpriseDetailExcel(eId, enterpriseName, enterpriseTempDir);
-                
-                // 下载企业相关文件
-                await downloadEnterpriseFiles(eId, enterpriseTempDir);
-                
-                // 创建企业单独的zip包
-                const safeEnterpriseName = sanitizeFileName(enterpriseName);
-                const enterpriseZipFileName = `企业完整数据_${safeEnterpriseName}_${eId}.zip`;
-                
-                // 修复：直接创建到总目录，避免移动操作
-                const enterpriseZipFilePath = path.join(baseTempDir, enterpriseZipFileName);
-                
-                console.log(`创建企业ZIP文件: ${enterpriseZipFilePath}`);
-                await createZipArchive(enterpriseTempDir, enterpriseZipFilePath);
-                
-                // 清理企业临时目录
-                await fs.remove(enterpriseTempDir);
-                
-                const zipStats = await fs.stat(enterpriseZipFilePath);
-                
-                console.log(`✅ 企业 ${enterpriseName} 处理完成，文件大小: ${zipStats.size} bytes`);
-                
-                return {
-                    eId,
-                    enterpriseName,
-                    success: true,
-                    fileName: enterpriseZipFileName,
-                    fileSize: zipStats.size,
-                    error: null
-                };
-            } catch (error) {
-                console.error(`❌ 企业 ${enterprise.enterpriseName} (${enterprise.eId}) 处理失败:`, error);
-                
-                return {
-                    eId: enterprise.eId,
-                    enterpriseName: enterprise.enterpriseName,
-                    success: false,
-                    fileName: null,
-                    fileSize: 0,
-                    error: error.message
-                };
-            }
-        });
-        
-        const batchResults = await Promise.allSettled(batchPromises);
-        
-        // 处理批次结果
-        for (const result of batchResults) {
-            if (result.status === 'fulfilled') {
-                results.push(result.value);
-            } else {
-                console.error('批次处理中出现未捕获的错误:', result.reason);
-                results.push({
-                    eId: 'unknown',
-                    enterpriseName: '未知企业',
-                    success: false,
-                    fileName: null,
-                    fileSize: 0,
-                    error: result.reason.message
-                });
-            }
-        }
-        
-        // 批次间延迟，避免服务器压力过大
-        if (i + BATCH_SIZE < enterprises.length) {
-            console.log('批次处理完成，等待2秒继续下一批...');
-            await new Promise(resolve => setTimeout(resolve, 2000));
-        }
-    }
-    
-    return results;
-}
-
-
-/**
- * 改进的下载企业文件方法，增加超时和重试机制
- */
-async function downloadEnterpriseFilesWithRetry(eId: string, tempDir: string, maxRetries: number = 2): Promise<void> {
-    for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
-        try {
-            await downloadEnterpriseFiles(eId, tempDir);
-            return; // 成功则返回
-        } catch (error) {
-            console.warn(`下载企业文件尝试 ${attempt} 失败:`, error.message);
-            
-            if (attempt <= maxRetries) {
-                console.log(`等待 ${attempt * 2} 秒后重试...`);
-                await new Promise(resolve => setTimeout(resolve, attempt * 2000));
-            } else {
-                throw error; // 所有重试都失败，抛出错误
-            }
-        }
-    }
-}
-
-/**
- * 获取所有企业列表（去除分页效果）
- */
-async function getAllEnterprises(): Promise<any[]> {
-    try {
-        // 使用与 enterpriseList 相同的查询逻辑，但不进行分页
-        let selectParam: any = { state: enumConfig.CHANGESTATE.已通过 };
-        
-        // 主表字段过滤参数保持不变
-        let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "logonAddress", "qiYeGuiMo"];
-        let manyTableInfo: any = {};
-        let rufuSelectParam = { state: { "%between%": [enumConfig.FUHUASTATE.实体孵化, enumConfig.FUHUASTATE.虚拟孵化] } };
-        manyTableInfo[TABLENAME.企业孵化信息] = { column: ["moveOutTime", "moveOutType", "startTime", "endTime"], where: rufuSelectParam };
-        
-        // 执行多表联查，不添加分页参数
-        let resInfo = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, selectParam, filesList, manyTableInfo);
-        
-        /**查询租赁表信息 */
-        let zuLingList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.租赁信息, {}, ["eId", "area", "startTime", "endTime", "building", "roomNumber"]);
-        let zaifuMap = {};
-        
-        if (zuLingList.length) {
-            zuLingList.forEach(info => {
-                zaifuMap[info.eId] = info;
-            });
-        }
-        
-        let allEnterprises = [];
-        
-        for (let info of resInfo) {
-            let {
-                eId,
-                enterpriseName,
-                uscc,
-                logonTime,
-                logonAddress,
-                qiYeGuiMo,
-                enterprise_fuhuas,
-            } = info;
-
-            // 如果有租赁信息，只包含有租赁记录的企业
-            if (Object.keys(zaifuMap).length && !zaifuMap[eId]) {
-                continue;
-            }
-
-            let leasesTime = '-';
-            if (zaifuMap[eId]?.startTime) {
-                leasesTime = `${moment(zaifuMap[eId].startTime).format("YYYY-MM-DD")}至${moment(zaifuMap[eId].endTime).format("YYYY-MM-DD")}`;
-            }
-
-            let fuhuaTime = '-';
-            if (enterprise_fuhuas[0]?.startTime) {
-                fuhuaTime = `${moment(enterprise_fuhuas[0].startTime).format("YYYY-MM-DD")}至${moment(enterprise_fuhuas[0].endTime).format("YYYY-MM-DD")}`;
-            }
-
-            allEnterprises.push({
-                eId,
-                enterpriseName, // 企业名称
-                uscc, // 统一信用代码
-                logonTime: moment(logonTime).format("YYYY-MM-DD"), // 注册日期
-                logonAddress: changeAdd(JSON.parse(logonAddress)), // 注册地址
-                qiYeGuiMo, // 企业规模
-                fuhuaTime, // 孵化时间
-                leasesTime, // 租赁时间
-                area: zaifuMap[eId]?.area ? `${zaifuMap[eId].area}㎡` : '-',
-                building: zaifuMap[eId]?.building || '-',
-                roomNumber: zaifuMap[eId]?.roomNumber || '-'
-            });
-        }
-
-        console.log(`获取到 ${allEnterprises.length} 家在孵企业`);
-        return allEnterprises;
-        
-    } catch (error) {
-        console.error('获取企业列表失败:', error);
-        throw new BizError(ERRORENUM.系统错误, '获取企业列表失败: ' + error.message);
-    }
-}
-
-/**
- * 下载所有企业的zip包文件
- */
-export async function downloadAllEnterprisesZip() {
-    try {
-        const projectRoot = path.resolve(__dirname, '../..');
-        const tempBaseDir = path.join(projectRoot, 'temp');
-        await fs.ensureDir(tempBaseDir);
-        
-        // 创建总临时目录
-        const tempDir = path.join(tempBaseDir, `temp_all_enterprises_${Date.now()}`);
-        console.log(`创建总临时目录: ${tempDir}`);
-        await fs.ensureDir(tempDir);
-
-        // 步骤1: 获取所有企业列表
-        console.log('=== 开始获取所有企业列表 ===');
-        const enterprises = await getAllEnterprises();
-        console.log(`获取到 ${enterprises.length} 家企业`);
-
-        if (enterprises.length === 0) {
-            throw new BizError(ERRORENUM.数据不存在, '未找到任何企业数据');
-        }
-
-        // 步骤2: 为每家企业生成单独的zip包
-        console.log('=== 开始为每家企业生成zip包 ===');
-        const enterpriseZipResults = await generateEnterpriseZips(enterprises, tempDir);
-
-        // 步骤3: 创建包含所有企业zip包的总zip文件
-        console.log('=== 创建总zip文件 ===');
-        const totalZipFileName = `所有企业完整数据_${moment().format('YYYYMMDDHHmmss')}.zip`;
-        const totalZipFilePath = path.join(tempBaseDir, totalZipFileName);
-
-        console.log(`创建总ZIP文件: ${totalZipFilePath}`);
-        await createZipArchive(tempDir, totalZipFilePath);
-
-        const zipStats = await fs.stat(totalZipFilePath);
-        console.log(`总ZIP文件创建成功，大小: ${zipStats.size} bytes`);
-
-        // 步骤4: 清理临时目录
-        console.log('清理临时目录...');
-        await fs.remove(tempDir);
-
-        // 统计信息
-        const successfulCount = enterpriseZipResults.filter(result => result.success).length;
-        const failedCount = enterpriseZipResults.filter(result => !result.success).length;
-
-        return {
-            success: true,
-            filePath: totalZipFilePath,
-            fileName: totalZipFileName,
-            statistics: {
-                total: enterprises.length,
-                successful: successfulCount,
-                failed: failedCount,
-                details: enterpriseZipResults
-            }
-        };
-    } catch (error) {
-        console.error('下载所有企业zip包失败:', error);
-        throw new BizError(ERRORENUM.系统错误, '批量打包失败: ' + error.message);
-    }
-}
-
-
-/**
- * 增强的下载所有企业zip包方法（支持过滤条件）
- */
-export async function downloadAllEnterprisesZipWithFilters(filters?: {
-    enterpriseName?: string;
-    logonStartTime?: Number;
-    logonEndTime?: Number;
-    startTime?: Number;
-    endTime?: Number;
-    building?: number;
-}) {
-    try {
-        const projectRoot = path.resolve(__dirname, '../..');
-        const tempBaseDir = path.join(projectRoot, 'temp');
-        await fs.ensureDir(tempBaseDir);
-        
-        // 创建总临时目录
-        const tempDir = path.join(tempBaseDir, `temp_all_enterprises_${Date.now()}`);
-        console.log(`创建总临时目录: ${tempDir}`);
-        await fs.ensureDir(tempDir);
-
-        // 步骤1: 获取所有企业列表（带过滤条件）
-        console.log('=== 开始获取所有企业列表 ===');
-        const enterprises = await getAllEnterprisesWithFilters(filters);
-        console.log(`获取到 ${enterprises.length} 家企业`);
-
-        if (enterprises.length === 0) {
-            throw new BizError(ERRORENUM.数据不存在, '未找到任何符合条件的企业数据');
-        }
-
-        // 步骤2: 为每家企业生成单独的zip包
-        console.log('=== 开始为每家企业生成zip包 ===');
-        const enterpriseZipResults = await generateEnterpriseZips(enterprises, tempDir);
-
-        // 步骤3: 创建包含所有企业zip包的总zip文件
-        console.log('=== 创建总zip文件 ===');
-        const filterSuffix = filters ? '_筛选结果' : '';
-        const totalZipFileName = `所有企业完整数据${filterSuffix}_${moment().format('YYYYMMDDHHmmss')}.zip`;
-        const totalZipFilePath = path.join(tempBaseDir, totalZipFileName);
-
-        console.log(`创建总ZIP文件: ${totalZipFilePath}`);
-        await createZipArchive(tempDir, totalZipFilePath);
-
-        const zipStats = await fs.stat(totalZipFilePath);
-        console.log(`总ZIP文件创建成功，大小: ${zipStats.size} bytes`);
-
-        // 步骤4: 清理临时目录
-        console.log('清理临时目录...');
-        await fs.remove(tempDir);
-
-        // 统计信息
-        const successfulCount = enterpriseZipResults.filter(result => result.success).length;
-        const failedCount = enterpriseZipResults.filter(result => !result.success).length;
-
-        return {
-            success: true,
-            filePath: totalZipFilePath,
-            fileName: totalZipFileName,
-            statistics: {
-                total: enterprises.length,
-                successful: successfulCount,
-                failed: failedCount,
-                filters: filters || {},
-                details: enterpriseZipResults
-            }
-        };
-    } catch (error) {
-        console.error('下载所有企业zip包失败:', error);
-        throw new BizError(ERRORENUM.系统错误, '批量打包失败: ' + error.message);
-    }
-}
-
-
-/**
- * 下载企业相关文件、数据表格和详情Excel的zip包
- */
-export async function downloadEnterpriseFilesZip(eId: string) {
-    if (!eId) throw new BizError(ERRORENUM.参数错误, `下载企业文件缺失eId`);
-
-    try {
-        const projectRoot = path.resolve(__dirname, '../..');
-        const tempBaseDir = path.join(projectRoot, 'temp');
-        await fs.ensureDir(tempBaseDir);
-        
-        const tempDir = path.join(tempBaseDir, `temp_enterprise_files_${eId}_${Date.now()}`);
-        console.log(`创建临时目录: ${tempDir}`);
-        await fs.ensureDir(tempDir);
-
-        // 获取企业名称
-        console.log('=== 开始获取企业信息 ===');
-        const enterpriseInfo = await getEnterpriseInfo(eId);
-        const enterpriseName = enterpriseInfo?.enterpriseName || '未知企业';
-        console.log(`企业名称: ${enterpriseName}`);
-
-        // 步骤1: 获取企业详情数据并生成Excel
-        console.log('=== 开始生成企业详情Excel ===');
-        const excelFilePath = await generateEnterpriseDetailExcel(eId, enterpriseName, tempDir);
-        
-        // 步骤2: 下载企业相关文件
-        console.log('=== 开始下载企业文件 ===');
-        await downloadEnterpriseFiles(eId, tempDir);
-
-        // 步骤3: 创建zip文件
-        const safeEnterpriseName = sanitizeFileName(enterpriseName);
-        const zipFileName = `企业完整数据_${safeEnterpriseName}_${eId}_${moment().format('YYYYMMDDHHmmss')}.zip`;
-        const zipFilePath = path.join(tempBaseDir, zipFileName);
-
-        console.log(`创建ZIP文件: ${zipFilePath}`);
-        await createZipArchive(tempDir, zipFilePath);
-
-        const zipStats = await fs.stat(zipFilePath);
-        console.log(`ZIP文件创建成功，大小: ${zipStats.size} bytes`);
-
-        // 清理临时目录
-        console.log('清理临时目录...');
-        await fs.remove(tempDir);
-
-        return {
-            success: true,
-            filePath: zipFilePath,
-            fileName: zipFileName
-        };
-    } catch (error) {
-        console.error('下载企业文件zip包失败:', error);
-        throw new BizError(ERRORENUM.系统错误, '文件打包失败: ' + error.message);
-    }
-}
-
-
-/**
- * 生成企业详情Excel文件
- */
-async function generateEnterpriseDetailExcel(eId: string, enterpriseName: string, tempDir: string): Promise<string> {
-    try {
-        console.log('获取企业详情数据...');
-        const details = await getAllDwOutPut(eId);
-        
-        console.log('企业详情数据结构:', JSON.stringify(details, null, 2));
-        
-        const safeEnterpriseName = sanitizeFileName(enterpriseName);
-        const excelFileName = `企业详情_${safeEnterpriseName}_${eId}.xlsx`;
-        const excelFilePath = path.join(tempDir, excelFileName);
-
-        const workbook = new ExcelJS.Workbook();
-        
-        // 设置文档属性
-        workbook.creator = '企业管理系统';
-        workbook.lastModifiedBy = '企业管理系统';
-        workbook.created = new Date();
-        workbook.modified = new Date();
-
-        // 1. 基础信息工作表
-        await createBasicInfoSheet(workbook, details.enterprise, '基础信息');
-        
-        // 2. 经营数据工作表
-        await createBusinessDataSheet(workbook, details.manage, '经营数据');
-        
-        // 3. 融资情况工作表
-        await createFinancingSheet(workbook, details.financing, '融资情况');
-        
-        // 4. 荣誉奖项工作表
-        await createHonorSheet(workbook, details.honor, '荣誉奖项');
-
-        // 保存Excel文件
-        await workbook.xlsx.writeFile(excelFilePath);
-        console.log(`Excel文件生成成功: ${excelFilePath}`);
-
-        return excelFilePath;
-    } catch (error) {
-        console.error('生成企业详情Excel失败:', error);
-        throw new BizError(ERRORENUM.系统错误, '生成Excel文件失败: ' + error.message);
-    }
-}
-
-
-/**
- * 创建基础信息工作表 - 表格格式
- */
-async function createBasicInfoSheet(workbook: ExcelJS.Workbook, enterpriseData: any, sheetName: string) {
-    const worksheet = workbook.addWorksheet(sheetName);
-    
-    if (!enterpriseData || !enterpriseData.dataList || !Array.isArray(enterpriseData.dataList)) {
-        worksheet.getCell('A1').value = '暂无基础信息数据';
-        return;
-    }
-
-    const dataList = enterpriseData.dataList;
-    
-    // 设置列宽
-    worksheet.columns = [
-        { width: 15 },
-        { width: 20 },
-        { width: 15 },
-        { width: 25 },
-        { width: 12 },
-        { width: 25 },
-        { width: 12 },
-        { width: 8 },
-        { width: 8 }
-    ];
-
-    // 添加标题
-    worksheet.mergeCells('A1:I1');
-    const titleCell = worksheet.getCell('A1');
-    titleCell.value = '企业基础信息';
-    titleCell.font = { bold: true, size: 14 };
-    titleCell.alignment = { horizontal: 'center', vertical: 'middle' };
-    titleCell.fill = {
-        type: 'pattern',
-        pattern: 'solid',
-        fgColor: { argb: 'FFDDEBF7' }
-    };
-
-    // 添加表头（第一行）
-    if (dataList.length > 0 && Array.isArray(dataList[0])) {
-        const headerRow = worksheet.addRow(dataList[0]);
-        
-        // 设置表头样式
-        headerRow.font = { bold: true, color: { argb: 'FFFFFFFF' } };
-        headerRow.fill = {
-            type: 'pattern',
-            pattern: 'solid',
-            fgColor: { argb: 'FF2F75B5' }
-        };
-        headerRow.alignment = { horizontal: 'center', vertical: 'middle' };
-        headerRow.height = 25;
-    }
-
-    // 添加数据行（从第二行开始）
-    let currentRow = 3; // 标题占1行，表头占1行，数据从第3行开始
-    for (let i = 1; i < dataList.length; i++) {
-        if (Array.isArray(dataList[i])) {
-            const dataRow = worksheet.addRow(dataList[i]);
-            
-            // 设置数据行样式
-            dataRow.alignment = { horizontal: 'left', vertical: 'middle' };
-            
-            // 交替行颜色
-            if (i % 2 === 0) {
-                dataRow.fill = {
-                    type: 'pattern',
-                    pattern: 'solid',
-                    fgColor: { argb: 'FFF2F2F2' }
-                };
-            }
-            
-            currentRow++;
-        }
-    }
-
-    // 设置边框
-    const dataRange = `A2:I${currentRow}`;
-    for (let row = 2; row <= currentRow; row++) {
-        for (let col = 1; col <= 9; col++) {
-            const cell = worksheet.getCell(row, col);
-            cell.border = {
-                top: { style: 'thin' },
-                left: { style: 'thin' },
-                bottom: { style: 'thin' },
-                right: { style: 'thin' }
-            };
-        }
-    }
-
-    console.log(`基础信息工作表创建完成，共 ${dataList.length - 1} 条数据`);
-}
-
-
-/**
- * 创建经营数据工作表
- */
-async function createBusinessDataSheet(workbook: ExcelJS.Workbook, manageData: any, sheetName: string) {
-    const worksheet = workbook.addWorksheet(sheetName);
-    
-    if (!manageData || !manageData.dataList || !Array.isArray(manageData.dataList)) {
-        worksheet.getCell('A1').value = '暂无经营数据';
-        return;
-    }
-
-    const dataList = manageData.dataList;
-    
-    // 设置列宽
-    worksheet.columns = [
-        { width: 15 },
-        { width: 20 },
-        { width: 15 },
-        { width: 15 },
-        { width: 15 },
-        { width: 15 }
-    ];
-
-    // 添加标题
-    worksheet.mergeCells('A1:F1');
-    const titleCell = worksheet.getCell('A1');
-    titleCell.value = '企业经营数据';
-    titleCell.font = { bold: true, size: 14 };
-    titleCell.alignment = { horizontal: 'center', vertical: 'middle' };
-    titleCell.fill = {
-        type: 'pattern',
-        pattern: 'solid',
-        fgColor: { argb: 'FFE2EFDA' }
-    };
-
-    // 添加表头（第一行）
-    if (dataList.length > 0 && Array.isArray(dataList[0])) {
-        const headerRow = worksheet.addRow(dataList[0]);
-        
-        // 设置表头样式
-        headerRow.font = { bold: true, color: { argb: 'FFFFFFFF' } };
-        headerRow.fill = {
-            type: 'pattern',
-            pattern: 'solid',
-            fgColor: { argb: 'FF70AD47' }
-        };
-        headerRow.alignment = { horizontal: 'center', vertical: 'middle' };
-        headerRow.height = 25;
-    }
-
-    // 添加数据行
-    let currentRow = 3;
-    let hasData = false;
-    
-    for (let i = 1; i < dataList.length; i++) {
-        if (Array.isArray(dataList[i]) && dataList[i].some((cell: any) => cell && cell !== '-')) {
-            const dataRow = worksheet.addRow(dataList[i]);
-            
-            // 设置数据行样式
-            dataRow.alignment = { horizontal: 'left', vertical: 'middle' };
-            
-            // 交替行颜色
-            if (i % 2 === 0) {
-                dataRow.fill = {
-                    type: 'pattern',
-                    pattern: 'solid',
-                    fgColor: { argb: 'FFF2F2F2' }
-                };
-            }
-            
-            currentRow++;
-            hasData = true;
-        }
-    }
-
-    if (!hasData) {
-        worksheet.getCell('A3').value = '暂无经营数据';
-        worksheet.getCell('A3').alignment = { horizontal: 'center', vertical: 'middle' };
-    } else {
-        // 设置边框
-        const dataRange = `A2:F${currentRow}`;
-        for (let row = 2; row <= currentRow; row++) {
-            for (let col = 1; col <= 6; col++) {
-                const cell = worksheet.getCell(row, col);
-                cell.border = {
-                    top: { style: 'thin' },
-                    left: { style: 'thin' },
-                    bottom: { style: 'thin' },
-                    right: { style: 'thin' }
-                };
-            }
-        }
-    }
-
-    console.log(`经营数据工作表创建完成，共 ${dataList.length - 1} 条数据`);
-}
-
-
-/**
- * 创建融资情况工作表
- */
-async function createFinancingSheet(workbook: ExcelJS.Workbook, financingData: any, sheetName: string) {
-    const worksheet = workbook.addWorksheet(sheetName);
-    
-    if (!financingData || !financingData.dataList || !Array.isArray(financingData.dataList)) {
-        worksheet.getCell('A1').value = '暂无融资数据';
-        return;
-    }
-
-    const dataList = financingData.dataList;
-    
-    // 设置列宽
-    worksheet.columns = [
-        { width: 15 },
-        { width: 20 },
-        { width: 15 },
-        { width: 15 },
-        { width: 15 },
-        { width: 20 }
-    ];
-
-    // 添加标题
-    worksheet.mergeCells('A1:F1');
-    const titleCell = worksheet.getCell('A1');
-    titleCell.value = '企业融资情况';
-    titleCell.font = { bold: true, size: 14 };
-    titleCell.alignment = { horizontal: 'center', vertical: 'middle' };
-    titleCell.fill = {
-        type: 'pattern',
-        pattern: 'solid',
-        fgColor: { argb: 'FFFFE699' }
-    };
-
-    // 添加表头（第一行）
-    if (dataList.length > 0 && Array.isArray(dataList[0])) {
-        const headerRow = worksheet.addRow(dataList[0]);
-        
-        // 设置表头样式
-        headerRow.font = { bold: true, color: { argb: 'FFFFFFFF' } };
-        headerRow.fill = {
-            type: 'pattern',
-            pattern: 'solid',
-            fgColor: { argb: 'FFFFC000' }
-        };
-        headerRow.alignment = { horizontal: 'center', vertical: 'middle' };
-        headerRow.height = 25;
-    }
-
-    // 添加数据行
-    let currentRow = 3;
-    let hasData = false;
-    
-    for (let i = 1; i < dataList.length; i++) {
-        if (Array.isArray(dataList[i]) && dataList[i].some((cell: any) => cell && cell !== '-')) {
-            const dataRow = worksheet.addRow(dataList[i]);
-            
-            // 设置数据行样式
-            dataRow.alignment = { horizontal: 'left', vertical: 'middle' };
-            
-            // 交替行颜色
-            if (i % 2 === 0) {
-                dataRow.fill = {
-                    type: 'pattern',
-                    pattern: 'solid',
-                    fgColor: { argb: 'FFF2F2F2' }
-                };
-            }
-            
-            currentRow++;
-            hasData = true;
-        }
-    }
-
-    if (!hasData) {
-        worksheet.getCell('A3').value = '暂无融资数据';
-        worksheet.getCell('A3').alignment = { horizontal: 'center', vertical: 'middle' };
-    } else {
-        // 设置边框
-        for (let row = 2; row <= currentRow; row++) {
-            for (let col = 1; col <= 6; col++) {
-                const cell = worksheet.getCell(row, col);
-                cell.border = {
-                    top: { style: 'thin' },
-                    left: { style: 'thin' },
-                    bottom: { style: 'thin' },
-                    right: { style: 'thin' }
-                };
-            }
-        }
-    }
-
-    console.log(`融资情况工作表创建完成，共 ${dataList.length - 1} 条数据`);
-}
-
-
-/**
- * 创建荣誉奖项工作表
- */
-async function createHonorSheet(workbook: ExcelJS.Workbook, honorData: any, sheetName: string) {
-    const worksheet = workbook.addWorksheet(sheetName);
-    
-    if (!honorData || !honorData.dataList || !Array.isArray(honorData.dataList)) {
-        worksheet.getCell('A1').value = '暂无荣誉数据';
-        return;
-    }
-
-    const dataList = honorData.dataList;
-    
-    // 设置列宽
-    worksheet.columns = [
-        { width: 15 },
-        { width: 25 },
-        { width: 20 },
-        { width: 15 },
-        { width: 15 }
-    ];
-
-    // 添加标题
-    worksheet.mergeCells('A1:E1');
-    const titleCell = worksheet.getCell('A1');
-    titleCell.value = '企业荣誉奖项';
-    titleCell.font = { bold: true, size: 14 };
-    titleCell.alignment = { horizontal: 'center', vertical: 'middle' };
-    titleCell.fill = {
-        type: 'pattern',
-        pattern: 'solid',
-        fgColor: { argb: 'FFE6E0EC' }
-    };
-
-    // 添加表头（第一行）
-    if (dataList.length > 0 && Array.isArray(dataList[0])) {
-        const headerRow = worksheet.addRow(dataList[0]);
-        
-        // 设置表头样式
-        headerRow.font = { bold: true, color: { argb: 'FFFFFFFF' } };
-        headerRow.fill = {
-            type: 'pattern',
-            pattern: 'solid',
-            fgColor: { argb: 'FF8064A2' }
-        };
-        headerRow.alignment = { horizontal: 'center', vertical: 'middle' };
-        headerRow.height = 25;
-    }
-
-    // 添加数据行
-    let currentRow = 3;
-    let hasData = false;
-    
-    for (let i = 1; i < dataList.length; i++) {
-        if (Array.isArray(dataList[i]) && dataList[i].some((cell: any) => cell && cell !== '-')) {
-            const dataRow = worksheet.addRow(dataList[i]);
-            
-            // 设置数据行样式
-            dataRow.alignment = { horizontal: 'left', vertical: 'middle' };
-            
-            // 交替行颜色
-            if (i % 2 === 0) {
-                dataRow.fill = {
-                    type: 'pattern',
-                    pattern: 'solid',
-                    fgColor: { argb: 'FFF2F2F2' }
-                };
-            }
-            
-            currentRow++;
-            hasData = true;
-        }
-    }
-
-    if (!hasData) {
-        worksheet.getCell('A3').value = '暂无荣誉数据';
-        worksheet.getCell('A3').alignment = { horizontal: 'center', vertical: 'middle' };
-    } else {
-        // 设置边框
-        for (let row = 2; row <= currentRow; row++) {
-            for (let col = 1; col <= 5; col++) {
-                const cell = worksheet.getCell(row, col);
-                cell.border = {
-                    top: { style: 'thin' },
-                    left: { style: 'thin' },
-                    bottom: { style: 'thin' },
-                    right: { style: 'thin' }
-                };
-            }
-        }
-    }
-
-    console.log(`荣誉奖项工作表创建完成，共 ${dataList.length - 1} 条数据`);
-}
-
-
-/**
- * 获取企业信息
- */
-async function getEnterpriseInfo(eId: string): Promise<any> {
-    try {
-        // 根据你的数据库结构调整查询
-        const enterpriseInfo = await selectData(
-            OPERATIONALDATATYPE.查询单个,
-            'enterprise', // 或者你的企业表名
-            { eId },
-            ['enterpriseName'] // 可能的名称字段
-        );
-        
-        if (!enterpriseInfo) {
-            console.warn(`未找到企业信息: ${eId}`);
-            return null;
-        }
-        
-        console.log(`获取到企业信息:`, enterpriseInfo);
-        return enterpriseInfo;
-    } catch (error) {
-        console.error(`获取企业信息失败: ${eId}`, error);
-        return null;
-    }
-}
-
-
-/**
- * 清理文件名中的非法字符
- */
- function sanitizeFileName(fileName: string): string {
-    if (!fileName) return '未知企业';
-    
-    // 移除或替换文件名中的非法字符
-    return fileName
-        .replace(/[<>:"/\\|?*]/g, '_') // 替换Windows非法字符
-        .replace(/\s+/g, ' ')          // 合并多个空格
-        .trim()                         // 去除首尾空格
-        .substring(0, 100);            // 限制长度避免过长
-}
-
-
-/**
- * 验证并记录文件信息
- */
-async function validateAndLogFiles(files: {url: string, fileName: string}[], category: string) {
-    console.log(`\n=== ${category}文件验证 ===`);
-    console.log(`总数: ${files.length} 个文件`);
-    
-    let existingCount = 0;
-    
-    for (const file of files) {
-        console.log(`文件: ${file.fileName}`);
-        console.log(`URL: ${file.url}`);
-        
-        // 检查文件是否存在
-        const exists = await checkFileExists(file.url);
-        console.log(`存在性: ${exists ? '存在' : '不存在'}`);
-        
-        if (exists) {
-            existingCount++;
-        }
-        console.log('---');
-    }
-    
-    console.log(`${category}文件统计: 存在 ${existingCount}/${files.length} 个文件`);
-    return existingCount;
-}
-
-
-/**
- * 改进的下载函数 - 跳过不存在的文件
- */
-async function downloadAndSaveFiles(files: {url: string, fileName: string}[], targetDir: string, baseTempDir: string): Promise<void> {
-    if (files.length === 0) {
-        console.log(`没有文件需要下载到目录: ${targetDir}`);
-        return;
-    }
-
-    await fs.ensureDir(targetDir);
-
-    // 先检查所有文件的存在性
-    const validFiles: {url: string, fileName: string}[] = [];
-    
-    for (const file of files) {
-        const exists = await checkFileExists(file.url);
-        if (exists) {
-            validFiles.push(file);
-            console.log(`✅ 文件可用: ${file.fileName}`);
-        } else {
-            console.warn(`❌ 文件不存在，跳过: ${file.fileName} (${file.url})`);
-        }
-    }
-
-    console.log(`有效文件数量: ${validFiles.length}/${files.length}`);
-
-    if (validFiles.length === 0) {
-        console.log(`没有可下载的有效文件，跳过目录: ${targetDir}`);
-        return;
-    }
-
-    // 只下载存在的文件
-    const downloadPromises = validFiles.map(async (file) => {
-        try {
-            if (!file.url || typeof file.url !== 'string') {
-                console.warn(`文件URL无效:`, file.url);
-                return;
-            }
-            
-            console.log(`开始下载文件: ${file.fileName} from ${file.url}`);
-            
-            const fetchOptions: any = {
-                method: 'GET',
-                timeout: 30000,
-                headers: {
-                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
-                    'Accept': '*/*'
-                }
-            };
-            
-            // 关键修复：添加认证 token
-            const SECRET_TOKEN = "Ngz86cuAKxblwXR9OiKSWbfkj7oZ8R0lMU8pTfpVYBDCkvtUb0ZwbaBvwWyfv2O9";
-            
-            // 如果是内部文件服务器的URL，添加认证token
-            if (file.url.includes('192.168.0.71') || file.url.includes('fh.tninnopark.cn')) {
-                fetchOptions.headers['token'] = SECRET_TOKEN;
-                console.log(`添加认证token到请求头`);
-            }
-            
-            const response = await fetch(file.url, fetchOptions);
-            
-            if (!response.ok) {
-                console.warn(`下载文件失败: ${file.url}, 状态码: ${response.status}`);
-                return;
-            }
-
-            const buffer = await response.buffer();
-            
-            if (buffer.length === 0) {
-                console.warn(`文件内容为空: ${file.fileName}`);
-                return;
-            }
-            
-            const filePath = path.join(targetDir, file.fileName);
-            await fs.writeFile(filePath, buffer);
-            console.log(`✅ 文件下载成功: ${file.fileName}, 大小: ${buffer.length} bytes`);
-            
-        } catch (error) {
-            console.error(`下载文件失败: ${file.fileName} (${file.url})`, error.message);
-        }
-    });
-
-    const results = await Promise.allSettled(downloadPromises);
-    
-    const successful = results.filter(result => result.status === 'fulfilled').length;
-    const failed = results.filter(result => result.status === 'rejected').length;
-    
-    console.log(`目录 ${targetDir} 下载完成: 成功 ${successful} 个, 失败 ${failed} 个, 总共 ${validFiles.length} 个有效文件`);
-}
-
-
-/**
- * 检查文件是否存在于文件服务器
- */
-async function checkFileExists(url: string): Promise<boolean> {
-    try {
-        const SECRET_TOKEN = "Ngz86cuAKxblwXR9OiKSWbfkj7oZ8R0lMU8pTfpVYBDCkvtUb0ZwbaBvwWyfv2O9";
-        
-        const fetchOptions: any = {
-            method: 'HEAD',
-            timeout: 10000,
-            headers: {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-            }
-        };
-        
-        // 同样为HEAD请求添加认证token
-        if (url.includes('192.168.0.71') || url.includes('fh.tninnopark.cn')) {
-            fetchOptions.headers['token'] = SECRET_TOKEN;
-        }
-        
-        const response = await fetch(url, fetchOptions);
-        return response.ok;
-    } catch (error) {
-        console.log(`文件存在性检查失败: ${url}`, error.message);
-        return false;
-    }
-}
-
-
-/**
- * 安全的URL构建函数，避免中文编码问题
- */
- function buildSafeUrl(baseUrl: string, filePath: string): string {
-    // 确保基础URL格式正确
-    const cleanBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
-    
-    // 确保文件路径格式正确
-    const cleanFilePath = filePath.startsWith('/') ? filePath : `/${filePath}`;
-    
-    // 直接拼接，避免URL对象的自动编码
-    return `${cleanBaseUrl}${cleanFilePath}`;
-}
-
-
-/**
- * 统一处理文件路径，将相对路径转换为绝对URL
- * 修复中文文件名编码问题
- * http://192.168.0.71:9097
- * https://fh.tninnopark.cn
- */
-function processFilePath(filePath: any, baseUrl: string = 'http://192.168.0.71:9097'): string | null {
-    if (!filePath) {
-        console.log('文件路径为空');
-        return null;
-    }
-
-    console.log(`原始文件路径: ${filePath}, 类型: ${typeof filePath}`);
-    
-    // 如果是数组，取第一个元素
-    if (Array.isArray(filePath)) {
-        filePath = filePath[0];
-    }
-    
-    // 处理JSON字符串格式
-    if (typeof filePath === 'string' && filePath.startsWith('[')) {
-        try {
-            const pathArray = JSON.parse(filePath);
-            filePath = pathArray[0];
-            console.log(`解析JSON数组路径: ${filePath}`);
-        } catch (e) {
-            console.warn('解析文件路径数组失败:', filePath);
-            return null;
-        }
-    }
-    
-    // 验证路径格式
-    if (!filePath || typeof filePath !== 'string') {
-        return null;
-    }
-    
-    // 如果已经是完整的URL，直接返回
-    if (filePath.startsWith('http://') || filePath.startsWith('https://')) {
-        return filePath;
-    }
-    
-    // 格式化基础URL
-    const formattedBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
-    
-    // 关键修复：确保路径格式正确且中文不被编码
-    let finalPath = filePath;
-    if (!finalPath.startsWith('/')) {
-        finalPath = '/' + finalPath;
-    }
-    
-    // 构建完整的URL（不对路径部分进行编码）
-    const url = new URL(formattedBaseUrl);
-    url.pathname = finalPath;
-
-    const fullUrl = buildSafeUrl(baseUrl, finalPath);
-    console.log(`安全构建的URL: ${fullUrl}`);
-    return fullUrl;
-}
-
-
-/**
- * 获取租赁信息相关文件
- */
-async function getLeaseFiles(eId: string): Promise<{url: string, fileName: string}[]> {
-    const filesList = [
-        "sanFangXieYi", "fuHuaXieYi", "fangWuZuLing", "fuHuaXieYiBuChong",
-        "chengXinChengNuoHan", "yingYeZhiZhao", "ruFuZiLiao", "ruZhuJiHua",
-        "yaJinZhiFu", "cardCopy"
-    ];
-
-    const leaseInfo = await selectData(
-        OPERATIONALDATATYPE.查询多个, 
-        TABLENAME.租赁信息, 
-        { eId }, 
-        filesList
-    );
-
-    const files: {url: string, fileName: string}[] = [];
-
-    leaseInfo.forEach(lease => {
-        filesList.forEach(field => {
-            if (lease[field]) {
-                const processedUrl = processFilePath(lease[field]);
-                if (processedUrl) {
-                    const fileName = getLeaseFileName(field, lease);
-                    files.push({
-                        url: processedUrl,
-                        fileName: fileName
-                    });
-                }
-            }
-        });
-    });
-
-    return files;
-}
-
-
-/**
- * 获取租赁文件显示名称
- */
-function getLeaseFileName(field: string, lease: any): string {
-    const nameMap: {[key: string]: string} = {
-        sanFangXieYi: '三方协议',
-        fuHuaXieYi: '孵化协议',
-        fangWuZuLing: '房屋租赁合同',
-        fuHuaXieYiBuChong: '孵化协议补充协议书',
-        chengXinChengNuoHan: '诚信承诺函',
-        yingYeZhiZhao: '营业执照复印件',
-        ruFuZiLiao: '入孵资料明细',
-        ruZhuJiHua: '入驻计划复印件',
-        yaJinZhiFu: '押金支付凭证',
-        cardCopy: '身份证复印件'
-    };
-
-    const baseName = nameMap[field] || field;
-    
-    // 获取实际的文件扩展名
-    let extension = '';
-    if (lease[field] && typeof lease[field] === 'string') {
-        const processedUrl = processFilePath(lease[field]);
-        if (processedUrl) {
-            const ext = path.extname(processedUrl);
-            if (ext) {
-                extension = ext;
-            } else {
-                // 如果没有扩展名，根据字段类型推测
-                if (field === 'cardCopy' || field === 'yingYeZhiZhao') {
-                    extension = '.jpg'; // 身份证和营业执照通常是图片
-                } else {
-                    extension = '.pdf'; // 其他文件默认PDF
-                }
-            }
-        }
-    }
-    
-    // 确保文件名安全
-    const safeFileName = baseName.replace(/[<>:"/\\|?*]/g, '_');
-    return `${safeFileName}${extension}`;
-}
-
-
-/**
- * 获取商标相关文件
- */
-async function getTrademarkFiles(eId: string): Promise<{url: string, fileName: string}[]> {
-    const trademarkInfo = await selectData(
-        OPERATIONALDATATYPE.查询多个,
-        'trade_mark',
-        { eId },
-        ["tmId", "regNo", "name", "imageUrl"]
-    );
-
-    const files: {url: string, fileName: string}[] = [];
-
-    trademarkInfo.forEach(trademark => {
-        if (trademark.imageUrl) {
-            let processedUrl = processFilePath(trademark.imageUrl);
-            
-            // 特殊处理商标图片URL：移除多余的 /img 后缀
-            // if (processedUrl && processedUrl.endsWith('/img')) {
-            //     processedUrl = processedUrl.slice(0, -4); // 移除最后的 '/img'
-            //     console.log(`修复商标图片URL: ${processedUrl}`);
-            // }
-            
-            if (processedUrl) {
-                const extension = path.extname(processedUrl) || '.jpg';
-                // 清理文件名中的特殊字符
-                const safeName = (trademark.name || '').replace(/[<>:"/\\|?*]/g, '_');
-                const fileName = `商标_${trademark.regNo || trademark.tmId}_${safeName}${extension}`;
-                files.push({
-                    url: processedUrl,
-                    fileName: fileName
-                });
-            }
-        }
-    });
-
-    return files;
-}
-
-
-/**
- * 获取作品著作权相关文件
- */
-async function getCopyrightFiles(eId: string): Promise<{url: string, fileName: string}[]> {
-    const copyrightInfo = await selectData(
-        OPERATIONALDATATYPE.查询多个,
-        'copy_right',
-        { eId },
-        ["crId", "registerNo", "name", "iprUrl"]
-    );
-
-    const files: {url: string, fileName: string}[] = [];
-
-    copyrightInfo.forEach(copyright => {
-        if (copyright.iprUrl) {
-            const processedUrl = processFilePath(copyright.iprUrl);
-            if (processedUrl) {
-                const extension = path.extname(processedUrl) || '.pdf';
-                const fileName = `作品著作权_${copyright.registerNo || copyright.crId}_${copyright.name}${extension}`;
-                files.push({
-                    url: processedUrl,
-                    fileName: fileName
-                });
-            }
-        }
-    });
-
-    return files;
-}
-
-
-/**
- * 获取软件著作权相关文件
- */
-async function getSoftwareCopyrightFiles(eId: string): Promise<{url: string, fileName: string}[]> {
-    const softwareCopyrightInfo = await selectData(
-        OPERATIONALDATATYPE.查询多个,
-        'software_copyright',
-        { eId },
-        ["scId", "registerNo", "name", "iprUrl"]
-    );
-
-    const files: {url: string, fileName: string}[] = [];
-
-    softwareCopyrightInfo.forEach(software => {
-        if (software.iprUrl) {
-            const processedUrl = processFilePath(software.iprUrl);
-            if (processedUrl) {
-                const extension = path.extname(processedUrl) || '.pdf';
-                const fileName = `软件著作权_${software.registerNo || software.scId}_${software.name}${extension}`;
-                files.push({
-                    url: processedUrl,
-                    fileName: fileName
-                });
-            }
-        }
-    });
-
-    return files;
-}
-
-
-/**
- * 获取专利相关文件
- */
-async function getPatentFiles(eId: string): Promise<{url: string, fileName: string}[]> {
-    const patentInfo = await selectData(
-        OPERATIONALDATATYPE.查询多个,
-        'patent',
-        { eId },
-        ["patentId", "applicationNumber", "title", "iprUrl"]
-    );
-
-    const files: {url: string, fileName: string}[] = [];
-
-    patentInfo.forEach(patent => {
-        if (patent.iprUrl) {
-            const processedUrl = processFilePath(patent.iprUrl);
-            if (processedUrl) {
-                const extension = path.extname(processedUrl) || '.pdf';
-                const fileName = `专利_${patent.applicationNumber || patent.patentId}_${patent.title}${extension}`;
-                files.push({
-                    url: processedUrl,
-                    fileName: fileName
-                });
-            }
-        }
-    });
-
-    return files;
-}
-
-
-/**
- * 简单的图片文件头验证
- */
-function isValidImageHeader(header: string): boolean {
-    const validHeaders = [
-        'ffd8ffe0', // JPEG
-        'ffd8ffe1', // JPEG
-        'ffd8ffe2', // JPEG
-        '89504e47', // PNG
-        '47494638', // GIF
-        '424d'      // BMP (前2字节)
-    ];
-    
-    return validHeaders.some(valid => header.startsWith(valid));
-}
-
-
-/**
- * 创建ZIP压缩包
- */
-async function createZipArchive(sourceDir: string, outPath: string): Promise<void> {
-    return new Promise((resolve, reject) => {
-        const output = fs.createWriteStream(outPath);
-        const archive = archiver('zip', {
-            zlib: { level: 9 } // 最高压缩级别
-        });
-
-        output.on('close', () => {
-            console.log(`ZIP文件创建完成: ${outPath}, 大小: ${archive.pointer()} bytes`);
-            resolve();
-        });
-
-        archive.on('error', (err) => {
-            reject(err);
-        });
-
-        archive.pipe(output);
-        archive.directory(sourceDir, false);
-        archive.finalize();
-    });
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

src/biz/ledger.ts

@@ -130,7 +130,7 @@ import { AdminRegisterUpdateConfig } from "../config/eccParam/enterprise";
  * @param page 
  * @returns {dataList, dataCount} 数据列表， 数据总数
  */
-export async function ledgerList(enterpriseName:string, logonStartTime:Number, logonEndTime:Number, building: number, page:number ) {
+export async function ledgerList(enterpriseName:string, phone:string, logonStartTime:Number, logonEndTime:Number, building: number, page:number ) {
     let selectParam: any = {state: enumConfig.CHANGESTATE.已通过};
     if (enterpriseName) { 
         selectParam.enterpriseName = { "%like%": enterpriseName };
@@ -139,11 +139,17 @@ export async function ledgerList(enterpriseName:string, logonStartTime:Number, l
         selectParam.logonTime = {"%between%":[getMySqlMs(logonStartTime), getMySqlMs(logonEndTime)]}
     }
 
+    let userSelectParam:any = {};
+    if (phone) {
+        userSelectParam.phone = { "%like%": phone };;
+    }
+
     // 主表字段过滤参数保持不变
     let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "logonAddress", "qiYeGuiMo"];
     let manyTableInfo: any = {};
     let rufuSelectParam = { state: { "%between%": [enumConfig.FUHUASTATE.实体孵化, enumConfig.FUHUASTATE.虚拟孵化] } };
     manyTableInfo[TABLENAME.企业孵化信息] = { column:["moveOutTime", "moveOutType", "startTime", "endTime"], where: rufuSelectParam};
+    manyTableInfo[TABLENAME.企业用户表] = { column:["userName", "phone"], where: userSelectParam};
     let resInfo = await selectManyTableData( OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, selectParam, filesList, manyTableInfo );
     
     /**查询租赁表信息 */
@@ -260,6 +266,7 @@ export async function ledgerList(enterpriseName:string, logonStartTime:Number, l
             logonAddress,
             qiYeGuiMo,
             enterprise_fuhuas,
+            enterprise_users,
         } = info;
 
         // 过滤条件：如果没有租赁信息，跳过
@@ -288,10 +295,17 @@ export async function ledgerList(enterpriseName:string, logonStartTime:Number, l
             知识产权总数: 0
         };
 
+        // 获取企业登录信息
+        let phone = "-";
+        if (enterprise_users[0]?.phone) {
+            phone = enterprise_users[0]?.phone;
+        }
+
         zaifuList.push({
             eId,
             enterpriseName, // 企业名称
             uscc, // 统一信用代码
+            phone,//登录手机号
             logonTime: moment(logonTime).format("YYYY-MM-DD"), // 注册日期
             logonAddress: changeAdd(JSON.parse(logonAddress)), // 注册地址
             qiYeGuiMo, // 企业规模

src/biz/mail.ts

@@ -127,8 +127,8 @@ function getModel(name, type, otherStr?, code?) {
     if (!userInfo.mail) {
         new BizError(ERRORENUM.该用户邮箱为空, eId, eId.enterpriseName);
     } else {
-        // let result = await send(userInfo.mail, userInfo.enterpriseName, type, otherStr);
-        let result = "邮件发送成功"
+        let result = await send(userInfo.mail, userInfo.enterpriseName, type, otherStr);
+        // let result = "邮件发送成功"
     }
 
     return successResult();

src/biz/ruFu.ts

@@ -162,8 +162,212 @@ export async function settleInEnterpriseList(page:number, enterpriseName:string)
  * @param eId 
  * @returns 
  */
-export async function settleInEnterprisePass(eId:string) {
-    let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "state"];
+// export async function settleInEnterprisePass(eId:string) {
+//     let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "state"];
+//     let resInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业基础信息表, {eId}, filesList);
+
+//     if (!resInfo || !resInfo.eId) {
+//         throw new BizError(ERRORENUM.数据不存在);
+//     }
+    
+//     let updateInfo = {
+//         register:enumConfig.CHANGESTATE.已通过,
+//         randomCode:randomCode(),
+//         isNewApplication: enumConfig.STATE.是,
+//     }
+//     await operationalData(OPERATIONALDATATYPE.修改, TABLENAME.企业基础信息表, updateInfo, {eId});
+
+//     let addInfo = {
+//         approvalId: randomId(TABLEID.入孵申请审批表),
+//         eId,
+//         changeType: enumConfig.CHANGETYPE.入孵申请,
+//         changeState: enumConfig.CHANGESTATE.已通过,
+//         createTimeMs: getMySqlMs()
+//     }
+//     await operationalData( OPERATIONALDATATYPE.增加, TABLENAME.入孵申请审批表, addInfo, {} );
+
+//     //发送邮件
+//     await systemSendMail(eId, enumConfig.MAILTYPE.通过入孵申请 );
+
+//     return {isSuccess:true};
+// }
+
+/**
+ * 入孵申请通过
+ * @param eId 
+ * @returns 
+ */
+// export async function settleInEnterprisePass(eId:string) {
+//     let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "state", "emailReminder"];
+//     let resInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业基础信息表, {eId}, filesList);
+
+//     if (!resInfo || !resInfo.eId) {
+//         throw new BizError(ERRORENUM.数据不存在);
+//     }
+    
+//     let updateInfo = {
+//         register:enumConfig.CHANGESTATE.已通过,
+//         randomCode:randomCode(),
+//         isNewApplication: enumConfig.STATE.是,
+//     }
+//     await operationalData(OPERATIONALDATATYPE.修改, TABLENAME.企业基础信息表, updateInfo, {eId});
+
+//     let addInfo = {
+//         approvalId: randomId(TABLEID.入孵申请审批表),
+//         eId,
+//         changeType: enumConfig.CHANGETYPE.入孵申请,
+//         changeState: enumConfig.CHANGESTATE.已通过,
+//         createTimeMs: getMySqlMs()
+//     }
+//     await operationalData( OPERATIONALDATATYPE.增加, TABLENAME.入孵申请审批表, addInfo, {} );
+
+//     //发送邮件
+//     await systemSendMail(eId, enumConfig.MAILTYPE.通过入孵申请);
+
+//     // 如果emailReminder为"是"，设置7天后检查是否提交入孵材料的周期性提醒
+//     if (resInfo.emailReminder == enumConfig.STATE.是) {
+//         // 创建一个递归函数，用于周期性检查
+//         const scheduleReminderCheck = async () => {
+//             try {
+//                 // 检查是否应该继续提醒
+//                 const shouldContinue = await checkShouldContinue(eId);
+                
+//                 if (!shouldContinue) {
+//                     console.log(`为企业 ${eId} 停止周期性入孵材料提交提醒，时间：${new Date().toLocaleString()}`);
+//                     return; // 终止循环
+//                 }
+                
+//                 // 检查企业是否已提交入孵材料（即是否有入孵材料审批记录）
+//                 const materialCheck = await selectData(
+//                     OPERATIONALDATATYPE.查询单个,
+//                     TABLENAME.入孵申请审批表,
+//                     { 
+//                         eId,
+//                         changeType: enumConfig.CHANGETYPE.入孵材料审批 
+//                     },
+//                     ["approvalId"]
+//                 );
+
+//                 // 如果没有入孵材料审批记录，说明企业尚未提交入孵材料，发送提醒邮件
+//                 if (!materialCheck || !materialCheck.approvalId) {
+//                     const mailStr = `
+//                         <p>感谢贵公司对【雨艺孵化器】的关注与信任。经我们初步审核，贵公司提交的入孵申请已通过<span style='font-weight: 700;'>初审</span>。为推进下一阶段工作，请贵方协助完成以下事项：</p>
+//                         <p><span style='font-weight: 700;'>*电脑端：</span>通过点击链接上传入孵材料：</p>
+//                         <p>https://fh.tninnopark.cn/incubatorApply</p>
+//                         <p><span style='font-weight: 700;'>*手机端：</span>通过扫码上传入孵材料：</p>
+//                         <p><img src='https://fh.tninnopark.cn/yuyi/files/域名访问.png' /></p>
+//                         <p><span style='font-weight: 700;'>下一步事项：</span></p>
+//                         <p>如涉及提交实物材料（如：入驻计划复印件、孵化协议等），携带公司证明材料前往4-1201。</p>
+//                         <p>我们期待与贵公司的进一步合作，共同推动项目成长与落地</p>
+//                         <p>再次感谢您的积极参与！</p>
+//                         <p style='text-align: right;'>祝 商祺！</p>
+//                         <p style='text-align: right;'>雨艺孵化器</p>
+//                     `;
+
+//                     // 发送提醒邮件
+//                     await systemSendMail(eId, enumConfig.MAILTYPE.通过入孵申请, mailStr);
+                    
+//                     console.log(`入孵材料提交提醒邮件已发送给企业 ${eId}，时间：${new Date().toLocaleString()}`);
+//                 } else {
+//                     console.log(`企业 ${eId} 已提交入孵材料，无需发送提醒邮件，时间：${new Date().toLocaleString()}`);
+//                 }
+                
+//                 // 7天后再次检查（无论是否发送邮件）
+//                 setTimeout(scheduleReminderCheck, 7 * 24 * 60 * 60 * 1000);
+                
+//             } catch (error) {
+//                 console.error(`检查并发送入孵材料提交提醒邮件失败:`, error);
+//                 // 即使出错，7天后也重试
+//                 setTimeout(scheduleReminderCheck, 7 * 24 * 60 * 60 * 1000);
+//             }
+//         };
+        
+//         // 辅助函数：检查是否应该继续提醒
+//         const checkShouldContinue = async (enterpriseId: string): Promise<boolean> => {
+//             try {
+//                 // 1. 检查企业是否已提交入孵材料
+//                 const materialCheck = await selectData(
+//                     OPERATIONALDATATYPE.查询单个,
+//                     TABLENAME.入孵申请审批表,
+//                     { 
+//                         eId: enterpriseId,
+//                         changeType: enumConfig.CHANGETYPE.入孵材料审批 
+//                     },
+//                     ["approvalId"]
+//                 );
+                
+//                 if (materialCheck && materialCheck.approvalId) {
+//                     console.log(`企业 ${enterpriseId} 已提交入孵材料，符合终止条件`);
+//                     return false; // 已提交材料，停止提醒
+//                 }
+                
+//                 // 2. 检查企业是否已通过入孵材料审核（state = 已通过）
+//                 const enterpriseInfo = await selectData(
+//                     OPERATIONALDATATYPE.查询单个,
+//                     TABLENAME.企业基础信息表,
+//                     { eId: enterpriseId },
+//                     ["state", "emailReminder"]
+//                 );
+                
+//                 if (!enterpriseInfo) {
+//                     console.log(`企业 ${enterpriseId} 信息不存在，停止提醒`);
+//                     return false; // 企业不存在，停止提醒
+//                 }
+                
+//                 // 如果企业已通过入孵材料审核
+//                 if (enterpriseInfo.state == enumConfig.CHANGESTATE.已通过) {
+//                     console.log(`企业 ${enterpriseId} 已通过入孵材料审核，符合终止条件`);
+//                     return false; // 已通过审核，停止提醒
+//                 }
+                
+//                 // 3. 检查企业是否关闭了邮件提醒
+//                 if (enterpriseInfo.emailReminder != enumConfig.STATE.是) {
+//                     console.log(`企业 ${enterpriseId} 已关闭邮件提醒，符合终止条件`);
+//                     return false; // 已关闭提醒，停止
+//                 }
+                
+//                 // 4. 检查企业是否被驳回（如果被驳回，也不应该继续提醒提交材料）
+//                 const rejectedCheck = await selectData(
+//                     OPERATIONALDATATYPE.查询单个,
+//                     TABLENAME.入孵申请审批表,
+//                     { 
+//                         eId: enterpriseId,
+//                         changeType: enumConfig.CHANGETYPE.入孵申请,
+//                         changeState: enumConfig.CHANGESTATE.已驳回
+//                     },
+//                     ["approvalId"]
+//                 );
+                
+//                 if (rejectedCheck && rejectedCheck.approvalId) {
+//                     console.log(`企业 ${enterpriseId} 的入孵申请已被驳回，停止提醒`);
+//                     return false; // 申请被驳回，停止提醒
+//                 }
+                
+//                 // 所有检查通过，继续提醒
+//                 return true;
+                
+//             } catch (error) {
+//                 console.error(`检查终止条件失败，企业ID: ${enterpriseId}`, error);
+//                 return true; // 出错时默认继续，避免因临时错误而停止
+//             }
+//         };
+        
+//         // 7天后开始第一次检查
+//         setTimeout(scheduleReminderCheck, 7 * 24 * 60 * 60 * 1000);
+//         console.log(`已为企业 ${eId} 设置周期性入孵材料提交提醒，首次检查将在7天后进行`);
+//     }
+    
+//     return {isSuccess:true};
+// }
+
+/**
+ * 入孵申请通过
+ * @param eId 企业ID
+ * @param production 环境标识："production"表示生产环境，其他表示测试环境
+ * @returns 
+ */
+export async function settleInEnterprisePass(eId:string, production:string = "test") {
+    let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "state", "emailReminder"];
     let resInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业基础信息表, {eId}, filesList);
 
     if (!resInfo || !resInfo.eId) {
@@ -187,12 +391,172 @@ export async function settleInEnterprisePass(eId:string) {
     await operationalData( OPERATIONALDATATYPE.增加, TABLENAME.入孵申请审批表, addInfo, {} );
 
     //发送邮件
-    await systemSendMail(eId, enumConfig.MAILTYPE.通过入孵申请 );
+    await systemSendMail(eId, enumConfig.MAILTYPE.通过入孵申请);
+
+    // 如果emailReminder为"是"，设置周期性提醒机制
+    if (resInfo.emailReminder == enumConfig.STATE.是) {
+        // 根据参数确定提醒间隔
+        const REMINDER_INTERVAL = production === "production" 
+            ? 7 * 24 * 60 * 60 * 1000  // 生产环境：7天
+            : 60 * 1000;               // 测试环境：1分钟
+        
+        // 创建一个递归函数，用于周期性检查
+        const scheduleReminderCheck = async () => {
+            try {
+                // 检查是否应该继续提醒
+                const shouldContinue = await checkShouldContinue(eId);
+                
+                if (!shouldContinue) {
+                    console.log(`为企业 ${eId} 停止周期性入孵材料提交提醒，时间：${new Date().toLocaleString()}`);
+                    return; // 终止循环
+                }
+                
+                // 检查企业是否已提交入孵材料（即是否有入孵材料审批记录）
+                const materialCheck = await selectData(
+                    OPERATIONALDATATYPE.查询单个,
+                    TABLENAME.入孵申请审批表,
+                    { 
+                        eId,
+                        changeType: enumConfig.CHANGETYPE.入孵材料审批 
+                    },
+                    ["approvalId"]
+                );
+
+                // 如果没有入孵材料审批记录，说明企业尚未提交入孵材料，发送提醒邮件
+                if (!materialCheck || !materialCheck.approvalId) {
+                    const mailStr = `
+                        <p>感谢贵公司对【雨艺孵化器】的关注与信任。经我们初步审核，贵公司提交的入孵申请已通过<span style='font-weight: 700;'>初审</span>。为推进下一阶段工作，请贵方协助完成以下事项：</p>
+                        <p><span style='font-weight: 700;'>*电脑端：</span>通过点击链接上传入孵材料：</p>
+                        <p>https://fh.tninnopark.cn/incubatorApply</p>
+                        <p><span style='font-weight: 700;'>*手机端：</span>通过扫码上传入孵材料：</p>
+                        <p><img src='https://fh.tninnopark.cn/yuyi/files/域名访问.png' /></p>
+                        <p><span style='font-weight: 700;'>下一步事项：</span></p>
+                        <p>如涉及提交实物材料（如：入驻计划复印件、孵化协议等），携带公司证明材料前往4-1201。</p>
+                        <p>我们期待与贵公司的进一步合作，共同推动项目成长与落地</p>
+                        <p>再次感谢您的积极参与！</p>
+                        <p style='text-align: right;'>祝 商祺！</p>
+                        <p style='text-align: right;'>雨艺孵化器</p>
+                    `;
+
+                    // 发送提醒邮件
+                    await systemSendMail(eId, enumConfig.MAILTYPE.通过入孵申请, mailStr);
+                    
+                    console.log(`入孵材料提交提醒邮件已发送给企业 ${eId}，时间：${new Date().toLocaleString()}，环境：${production}`);
+                } else {
+                    console.log(`企业 ${eId} 已提交入孵材料，无需发送提醒邮件，时间：${new Date().toLocaleString()}`);
+                }
+                
+                // 设置下一次检查（无论是否发送邮件）
+                setTimeout(scheduleReminderCheck, REMINDER_INTERVAL);
+                
+            } catch (error) {
+                console.error(`检查并发送入孵材料提交提醒邮件失败:`, error);
+                // 即使出错，也尝试设置下一次检查
+                setTimeout(scheduleReminderCheck, REMINDER_INTERVAL);
+            }
+        };
+        
+        // 辅助函数：检查是否应该继续提醒
+        const checkShouldContinue = async (enterpriseId: string): Promise<boolean> => {
+            try {
+                // 1. 检查企业是否已提交入孵材料
+                const materialCheck = await selectData(
+                    OPERATIONALDATATYPE.查询单个,
+                    TABLENAME.入孵申请审批表,
+                    { 
+                        eId: enterpriseId,
+                        changeType: enumConfig.CHANGETYPE.入孵材料审批 
+                    },
+                    ["approvalId"]
+                );
+                
+                if (materialCheck && materialCheck.approvalId) {
+                    console.log(`企业 ${enterpriseId} 已提交入孵材料，符合终止条件`);
+                    return false; // 已提交材料，停止提醒
+                }
+                
+                // 2. 检查企业是否已通过入孵材料审核（state = 已通过）
+                const enterpriseInfo = await selectData(
+                    OPERATIONALDATATYPE.查询单个,
+                    TABLENAME.企业基础信息表,
+                    { eId: enterpriseId },
+                    ["state", "emailReminder"]
+                );
+                
+                if (!enterpriseInfo) {
+                    console.log(`企业 ${enterpriseId} 信息不存在，停止提醒`);
+                    return false; // 企业不存在，停止提醒
+                }
+                
+                // 如果企业已通过入孵材料审核
+                if (enterpriseInfo.state == enumConfig.CHANGESTATE.已通过) {
+                    console.log(`企业 ${enterpriseId} 已通过入孵材料审核，符合终止条件`);
+                    return false; // 已通过审核，停止提醒
+                }
+                
+                // 3. 检查企业是否关闭了邮件提醒
+                if (enterpriseInfo.emailReminder != enumConfig.STATE.是) {
+                    console.log(`企业 ${enterpriseId} 已关闭邮件提醒，符合终止条件`);
+                    return false; // 已关闭提醒，停止
+                }
+                
+                // 4. 检查企业是否被驳回（如果被驳回，也不应该继续提醒提交材料）
+                const rejectedCheck = await selectData(
+                    OPERATIONALDATATYPE.查询单个,
+                    TABLENAME.入孵申请审批表,
+                    { 
+                        eId: enterpriseId,
+                        changeType: enumConfig.CHANGETYPE.入孵申请,
+                        changeState: enumConfig.CHANGESTATE.已驳回
+                    },
+                    ["approvalId"]
+                );
+                
+                if (rejectedCheck && rejectedCheck.approvalId) {
+                    console.log(`企业 ${enterpriseId} 的入孵申请已被驳回，停止提醒`);
+                    return false; // 申请被驳回，停止提醒
+                }
+                
+                // 5. 检查企业是否已迁出
+                const movedOutCheck = await selectData(
+                    OPERATIONALDATATYPE.查询单个,
+                    TABLENAME.企业孵化信息,
+                    { eId: enterpriseId },
+                    ["state"]
+                );
+                
+                if (movedOutCheck && movedOutCheck.state == enumConfig.FUHUASTATE.迁出) {
+                    console.log(`企业 ${enterpriseId} 已迁出，停止提醒`);
+                    return false; // 企业已迁出，停止提醒
+                }
+                
+                // 所有检查通过，继续提醒
+                return true;
+                
+            } catch (error) {
+                console.error(`检查终止条件失败，企业ID: ${enterpriseId}`, error);
+                // 出错时默认继续提醒，避免因临时错误而停止
+                return true;
+            }
+        };
+        
+        // 记录提醒设置信息
+        console.log(`已为企业 ${eId} 设置周期性入孵材料提交提醒`, {
+            企业名称: resInfo.enterpriseName,
+            环境模式: production,
+            提醒间隔: `${REMINDER_INTERVAL}ms (${REMINDER_INTERVAL / (60 * 1000)}分钟)`,
+            首次提醒时间: new Date(Date.now() + REMINDER_INTERVAL).toLocaleString()
+        });
+        
+        // 设置第一次检查
+        setTimeout(scheduleReminderCheck, REMINDER_INTERVAL);
+    }
     
     return {isSuccess:true};
 }
 
 
+
 /**
  * 入孵申请回显
  * @param eId 
@@ -308,6 +672,88 @@ export async function settleInEnterpriseUpdate(eId:string, param) {
  * @param desc 
  * @returns 
  */
+// export async function settleInEnterpriseOut(eId:string, descType, desc:string) {
+//     let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "state", "emailReminder"];
+//     let resInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业基础信息表, {eId}, filesList);
+
+//     if (!resInfo || !resInfo.eId) {  
+//         throw new BizError(ERRORENUM.数据不存在);
+//     }
+
+//     let params = {
+//         register: enumConfig.CHANGESTATE.已驳回, 
+//         // isNewApplication: enumConfig.STATE.否
+//     };
+//     await operationalData( OPERATIONALDATATYPE.修改, TABLENAME.企业基础信息表,  params, { eId });
+    
+//     let descStr = "";
+//     for(let i = 0; i < descType.length; i++) {
+//         if (descType[i] == enumConfig.DESCTYPE.其他) {
+//             if (desc) descStr += `${desc}；`
+//         } else {
+//             descStr += `${changeEnumValue(enumConfig.DESCTYPE, descType[i])}；`;
+//         }
+//     }
+//     let descTypeStr = JSON.stringify(descType) || '[]';
+
+//     let addInfo = {
+//         approvalId: randomId(TABLEID.入孵申请审批表),
+//         eId,
+//         changeType: enumConfig.CHANGETYPE.入孵申请,
+//         changeState: enumConfig.CHANGESTATE.已驳回,
+//         createTimeMs: getMySqlMs(),
+//         descType:descTypeStr,
+//         desc:descStr,
+//     }
+//     await operationalData( OPERATIONALDATATYPE.增加, TABLENAME.入孵申请审批表, addInfo, {} );
+
+//     /**发送邮件 */
+//     let mailStr = "";
+//     mailStr += "<p>感谢贵公司对【雨艺孵化器】的关注与信任。经我们初步审核，遗憾地通知您，贵公司此次入孵申请<span style='font-weight: 700;'>未通过初审</span>。主要原因为：</p>";
+//     mailStr += `<ul>`;
+//     mailStr += `<li>${descStr}</li>`;
+//     mailStr += `</ul>`;
+//     mailStr += `<p>以上内容仅作为此次审核意见供参考，您可根据反馈进行优化调整。如后续有相关优化材料或补充说明，欢迎重新提交申请。</p>`;
+//     mailStr += `<p>我们期待未来与贵公司的合作机会，衷心祝愿贵公司业务发展顺利！</p>`;
+//     await systemSendMail(resInfo.eId, enumConfig.MAILTYPE.驳回入孵申请, mailStr );
+    
+//     /**如果emailReminder为是，则设置7天后再次提醒 */
+//     if (resInfo.emailReminder == enumConfig.STATE.是) {
+//         setTimeout( async() => {
+//             try {
+//                 //检查企业状态是否仍然是已驳回（未重新提交）
+//                 let currentInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业基础信息表, {eId}, ["register"]);
+//                 if (currentInfo && currentInfo.register === enumConfig.CHANGESTATE.已驳回) {
+//                     let reminderMailStr = "";
+//                     reminderMailStr += "<p>【雨艺孵化器】入孵申请提醒</p>";
+//                     reminderMailStr += "<p>尊敬的客户：</p>";
+//                     reminderMailStr += "<p>我们注意到您在7天前提交的入孵申请未通过初审，目前尚未收到您的重新提交。</p>";
+//                     reminderMailStr += `<p>驳回原因：${descStr}</p>`;
+//                     reminderMailStr += "<p>如果您仍有入驻意向，请根据审核意见完善资料后重新提交申请。</p>";
+//                     reminderMailStr += "<p>如有任何疑问，欢迎随时联系我们。</p>";
+//                     reminderMailStr += "<p>期待您的回复！</p>";
+                    
+//                     await systemSendMail(resInfo.eId, enumConfig.MAILTYPE.驳回入孵申请, reminderMailStr);
+//                     console.log(`7天后入孵申请驳回提醒邮件已发送给企业 ${resInfo.eId}`);
+//                 }
+//             } catch (error) {
+//                 console.error(`发送7天后入孵申请驳回提醒邮件失败:`, error);
+//             }
+//         }, 7 * 24 * 60 * 60 * 1000); // 7天后的毫秒数
+//     }
+    
+//     return {isSuccess:true};
+// }
+
+
+/**
+ * 入孵申请驳回
+ * @param eId 企业ID
+ * @param descType 驳回类型 [1, 2]
+ * @param desc 驳回原因
+ * @param production 环境标识："production"表示生产环境，其他表示测试环境
+ * @returns 
+ */
 export async function settleInEnterpriseOut(eId:string, descType, desc:string) {
     let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "state", "emailReminder"];
     let resInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业基础信息表, {eId}, filesList);
@@ -353,36 +799,333 @@ export async function settleInEnterpriseOut(eId:string, descType, desc:string) {
     mailStr += `<p>我们期待未来与贵公司的合作机会，衷心祝愿贵公司业务发展顺利！</p>`;
     await systemSendMail(resInfo.eId, enumConfig.MAILTYPE.驳回入孵申请, mailStr );
     
-    /**如果emailReminder为是，则设置7天后再次提醒 */
-    if (resInfo.emailReminder == enumConfig.STATE.是) {
-        setTimeout( async() => {
-            try {
-                //检查企业状态是否仍然是已驳回（未重新提交）
-                let currentInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业基础信息表, {eId}, ["register"]);
-                if (currentInfo && currentInfo.register === enumConfig.CHANGESTATE.已驳回) {
-                    let reminderMailStr = "";
-                    reminderMailStr += "<p>【雨艺孵化器】入孵申请提醒</p>";
-                    reminderMailStr += "<p>尊敬的客户：</p>";
-                    reminderMailStr += "<p>我们注意到您在7天前提交的入孵申请未通过初审，目前尚未收到您的重新提交。</p>";
-                    reminderMailStr += `<p>驳回原因：${descStr}</p>`;
-                    reminderMailStr += "<p>如果您仍有入驻意向，请根据审核意见完善资料后重新提交申请。</p>";
-                    reminderMailStr += "<p>如有任何疑问，欢迎随时联系我们。</p>";
-                    reminderMailStr += "<p>期待您的回复！</p>";
+    /**如果emailReminder为是，则设置周期性提醒机制 */
+    // if (resInfo.emailReminder == enumConfig.STATE.是) {
+    //     // 根据参数确定提醒间隔
+    //     const REMINDER_INTERVAL = production === "production" 
+    //         ? 7 * 24 * 60 * 60 * 1000  // 生产环境：7天
+    //         : 60 * 1000;               // 测试环境：1分钟
+        
+    //     // 创建申请驳回的周期性提醒函数
+    //     const scheduleApplicationRejectionReminder = async () => {
+    //         try {
+    //             // 检查是否应该继续提醒
+    //             const shouldContinue = await checkShouldContinueForApplicationRejection(eId);
+                
+    //             if (!shouldContinue) {
+    //                 console.log(`为企业 ${eId} 停止周期性入孵申请驳回提醒，时间：${new Date().toLocaleString()}`);
+    //                 return; // 终止循环
+    //             }
                 
-                    await systemSendMail(resInfo.eId, enumConfig.MAILTYPE.驳回入孵申请, reminderMailStr);
-                    console.log(`7天后入孵申请驳回提醒邮件已发送给企业 ${resInfo.eId}`);
-                }
-            } catch (error) {
-                console.error(`发送7天后入孵申请驳回提醒邮件失败:`, error);
-            }
-        }, 7 * 24 * 60 * 60 * 1000); // 7天后的毫秒数
-    }
+    //             // 获取最新的企业状态
+    //             const currentInfo = await selectData(
+    //                 OPERATIONALDATATYPE.查询单个, 
+    //                 TABLENAME.企业基础信息表, 
+    //                 {eId}, 
+    //                 ["register"]
+    //             );
+                
+    //             // 如果企业仍然是已驳回状态，发送提醒邮件
+    //             if (currentInfo && currentInfo.register === enumConfig.CHANGESTATE.已驳回) {
+    //                 let reminderMailStr = "";
+    //                 reminderMailStr += "<p>【雨艺孵化器】入孵申请提醒</p>";
+    //                 reminderMailStr += "<p>尊敬的客户：</p>";
+    //                 reminderMailStr += `<p>我们注意到您之前在${moment().subtract(REMINDER_INTERVAL / (24 * 60 * 60 * 1000), 'days').format("YYYY-MM-DD")}提交的入孵申请未通过初审，目前尚未收到您的重新提交。</p>`;
+    //                 reminderMailStr += `<p>驳回原因：${descStr}</p>`;
+    //                 reminderMailStr += "<p>如果您仍有入驻意向，请根据审核意见完善资料后重新提交申请。</p>";
+    //                 reminderMailStr += "<p>您可以通过以下方式重新提交：</p>";
+    //                 reminderMailStr += "<p><span style='font-weight: 700;'>*电脑端：</span>https://fh.tninnopark.cn/incubatorApply</p>";
+    //                 reminderMailStr += "<p><span style='font-weight: 700;'>*手机端：</span>扫描下方二维码：</p>";
+    //                 reminderMailStr += "<p><img src='https://fh.tninnopark.cn/yuyi/files/域名访问.png' /></p>";
+    //                 reminderMailStr += "<p>如有任何疑问，欢迎随时联系我们。</p>";
+    //                 reminderMailStr += "<p>期待您的回复！</p>";
+                    
+    //                 await systemSendMail(eId, enumConfig.MAILTYPE.驳回入孵申请, reminderMailStr);
+    //                 console.log(`入孵申请驳回提醒邮件已发送给企业 ${eId}，时间：${new Date().toLocaleString()}，环境：${production}`);
+    //             } else {
+    //                 console.log(`企业 ${eId} 已重新提交申请或状态已变更，无需发送提醒邮件，时间：${new Date().toLocaleString()}`);
+    //             }
+                
+    //             // 设置下一次检查（无论是否发送邮件）
+    //             setTimeout(scheduleApplicationRejectionReminder, REMINDER_INTERVAL);
+                
+    //         } catch (error) {
+    //             console.error(`检查并发送入孵申请驳回提醒邮件失败:`, error);
+    //             // 即使出错，也尝试设置下一次检查
+    //             setTimeout(scheduleApplicationRejectionReminder, REMINDER_INTERVAL);
+    //         }
+    //     };
+        
+    //     // 辅助函数：检查是否应该继续提醒（针对申请驳回场景）
+    //     const checkShouldContinueForApplicationRejection = async (enterpriseId: string): Promise<boolean> => {
+    //         try {
+    //             // 1. 检查企业是否关闭了邮件提醒
+    //             const enterpriseInfo = await selectData(
+    //                 OPERATIONALDATATYPE.查询单个,
+    //                 TABLENAME.企业基础信息表,
+    //                 { eId: enterpriseId },
+    //                 ["emailReminder", "register"]
+    //             );
+                
+    //             if (!enterpriseInfo) {
+    //                 console.log(`企业 ${enterpriseId} 信息不存在，停止提醒`);
+    //                 return false; // 企业不存在，停止提醒
+    //             }
+                
+    //             if (enterpriseInfo.emailReminder != enumConfig.STATE.是) {
+    //                 console.log(`企业 ${enterpriseId} 已关闭邮件提醒，符合终止条件`);
+    //                 return false; // 已关闭提醒，停止
+    //             }
+                
+    //             // 2. 检查企业是否已重新提交申请（register不再是已驳回）
+    //             if (enterpriseInfo.register != enumConfig.CHANGESTATE.已驳回) {
+    //                 console.log(`企业 ${enterpriseId} 已重新提交申请，符合终止条件`);
+    //                 return false; // 已重新提交，停止提醒
+    //             }
+                
+    //             // 3. 检查企业是否已通过入孵申请
+    //             const passCheck = await selectData(
+    //                 OPERATIONALDATATYPE.查询单个,
+    //                 TABLENAME.入孵申请审批表,
+    //                 { 
+    //                     eId: enterpriseId,
+    //                     changeType: enumConfig.CHANGETYPE.入孵申请,
+    //                     changeState: enumConfig.CHANGESTATE.已通过
+    //                 },
+    //                 ["approvalId"]
+    //             );
+                
+    //             if (passCheck && passCheck.approvalId) {
+    //                 console.log(`企业 ${enterpriseId} 的入孵申请已通过，停止提醒`);
+    //                 return false; // 申请已通过，停止提醒
+    //             }
+                
+    //             // 4. 检查企业是否已通过入孵材料审核
+    //             const materialPassCheck = await selectData(
+    //                 OPERATIONALDATATYPE.查询单个,
+    //                 TABLENAME.入孵申请审批表,
+    //                 { 
+    //                     eId: enterpriseId,
+    //                     changeType: enumConfig.CHANGETYPE.入孵材料审批,
+    //                     changeState: enumConfig.CHANGESTATE.已通过
+    //                 },
+    //                 ["approvalId"]
+    //             );
+                
+    //             if (materialPassCheck && materialPassCheck.approvalId) {
+    //                 console.log(`企业 ${enterpriseId} 已通过入孵材料审核，停止提醒`);
+    //                 return false; // 已通过材料审核，停止提醒
+    //             }
+                
+    //             // 所有检查通过，继续提醒
+    //             return true;
+                
+    //         } catch (error) {
+    //             console.error(`检查申请驳回终止条件失败，企业ID: ${enterpriseId}`, error);
+    //             return true; // 出错时默认继续
+    //         }
+    //     };
+        
+    //     // 记录提醒设置信息
+    //     console.log(`已为企业 ${eId} 设置周期性入孵申请驳回提醒`, {
+    //         企业名称: resInfo.enterpriseName,
+    //         环境模式: production,
+    //         提醒间隔: `${REMINDER_INTERVAL}ms (${REMINDER_INTERVAL / (60 * 1000)}分钟)`,
+    //         首次提醒时间: new Date(Date.now() + REMINDER_INTERVAL).toLocaleString()
+    //     });
+        
+    //     // 设置第一次检查
+    //     setTimeout(scheduleApplicationRejectionReminder, REMINDER_INTERVAL);
+    // }
     
     return {isSuccess:true};
 }
 
 
 /**
+ * 入孵申请驳回
+ * @param eId 
+ * @param descType 驳回类型 [1, 2]
+ * @param desc 
+ * @returns 
+ */
+// export async function settleInEnterpriseOut(eId:string, descType, desc:string) {
+//     let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "state", "emailReminder"];
+//     let resInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业基础信息表, {eId}, filesList);
+
+//     if (!resInfo || !resInfo.eId) {  
+//         throw new BizError(ERRORENUM.数据不存在);
+//     }
+
+//     let params = {
+//         register: enumConfig.CHANGESTATE.已驳回, 
+//         // isNewApplication: enumConfig.STATE.否
+//     };
+//     await operationalData( OPERATIONALDATATYPE.修改, TABLENAME.企业基础信息表,  params, { eId });
+    
+//     let descStr = "";
+//     for(let i = 0; i < descType.length; i++) {
+//         if (descType[i] == enumConfig.DESCTYPE.其他) {
+//             if (desc) descStr += `${desc}；`
+//         } else {
+//             descStr += `${changeEnumValue(enumConfig.DESCTYPE, descType[i])}；`;
+//         }
+//     }
+//     let descTypeStr = JSON.stringify(descType) || '[]';
+
+//     let addInfo = {
+//         approvalId: randomId(TABLEID.入孵申请审批表),
+//         eId,
+//         changeType: enumConfig.CHANGETYPE.入孵申请,
+//         changeState: enumConfig.CHANGESTATE.已驳回,
+//         createTimeMs: getMySqlMs(),
+//         descType:descTypeStr,
+//         desc:descStr,
+//     }
+//     await operationalData( OPERATIONALDATATYPE.增加, TABLENAME.入孵申请审批表, addInfo, {} );
+
+//     /**发送邮件 - 首次驳回通知 */
+//     let mailStr = "";
+//     mailStr += "<p>感谢贵公司对【雨艺孵化器】的关注与信任。经我们初步审核，遗憾地通知您，贵公司此次入孵申请<span style='font-weight: 700;'>未通过初审</span>。主要原因为：</p>";
+//     mailStr += `<ul>`;
+//     mailStr += `<li>${descStr}</li>`;
+//     mailStr += `</ul>`;
+//     mailStr += `<p>以上内容仅作为此次审核意见供参考，您可根据反馈进行优化调整。如后续有相关优化材料或补充说明，欢迎重新提交申请。</p>`;
+//     mailStr += `<p>我们期待未来与贵公司的合作机会，衷心祝愿贵公司业务发展顺利！</p>`;
+//     await systemSendMail(resInfo.eId, enumConfig.MAILTYPE.驳回入孵申请, mailStr );
+    
+//     /**如果emailReminder为是，则设置7天后重复提醒机制 */
+//     if (resInfo.emailReminder == enumConfig.STATE.是) {
+//         // 创建驳回申请的周期性提醒函数
+//         const scheduleRejectionReminder = async () => {
+//             try {
+//                 // 检查是否应该继续提醒
+//                 const shouldContinue = await checkShouldContinueForRejection(eId);
+                
+//                 if (!shouldContinue) {
+//                     console.log(`为企业 ${eId} 停止周期性入孵申请驳回提醒，时间：${new Date().toLocaleString()}`);
+//                     return; // 终止循环
+//                 }
+                
+//                 // 获取最新的企业状态
+//                 const currentInfo = await selectData(
+//                     OPERATIONALDATATYPE.查询单个, 
+//                     TABLENAME.企业基础信息表, 
+//                     {eId}, 
+//                     ["register"]
+//                 );
+                
+//                 // 如果企业仍然是已驳回状态，发送提醒邮件
+//                 if (currentInfo && currentInfo.register === enumConfig.CHANGESTATE.已驳回) {
+//                     let reminderMailStr = "";
+//                     reminderMailStr += "<p>【雨艺孵化器】入孵申请提醒</p>";
+//                     reminderMailStr += "<p>尊敬的客户：</p>";
+//                     reminderMailStr += "<p>我们注意到您之前在" + moment().subtract(7, 'days').format("YYYY-MM-DD") + "提交的入孵申请未通过初审，目前尚未收到您的重新提交。</p>";
+//                     reminderMailStr += `<p>驳回原因：${descStr}</p>`;
+//                     reminderMailStr += "<p>如果您仍有入驻意向，请根据审核意见完善资料后重新提交申请。</p>";
+//                     reminderMailStr += "<p>您可以通过以下方式重新提交：</p>";
+//                     reminderMailStr += "<p><span style='font-weight: 700;'>*电脑端：</span>https://fh.tninnopark.cn/incubatorApply</p>";
+//                     reminderMailStr += "<p><span style='font-weight: 700;'>*手机端：</span>扫描下方二维码：</p>";
+//                     reminderMailStr += "<p><img src='https://fh.tninnopark.cn/yuyi/files/域名访问.png' /></p>";
+//                     reminderMailStr += "<p>如有任何疑问，欢迎随时联系我们。</p>";
+//                     reminderMailStr += "<p>期待您的回复！</p>";
+                    
+//                     await systemSendMail(eId, enumConfig.MAILTYPE.驳回入孵申请, reminderMailStr);
+//                     console.log(`入孵申请驳回提醒邮件已发送给企业 ${eId}，时间：${new Date().toLocaleString()}`);
+//                 } else {
+//                     console.log(`企业 ${eId} 已重新提交申请或状态已变更，无需发送提醒邮件，时间：${new Date().toLocaleString()}`);
+//                 }
+                
+//                 // 7天后再次检查（无论是否发送邮件）
+//                 setTimeout(scheduleRejectionReminder, 7 * 24 * 60 * 60 * 1000);
+                
+//             } catch (error) {
+//                 console.error(`检查并发送入孵申请驳回提醒邮件失败:`, error);
+//                 // 即使出错，7天后也重试
+//                 setTimeout(scheduleRejectionReminder, 7 * 24 * 60 * 60 * 1000);
+//             }
+//         };
+        
+//         // 辅助函数：检查是否应该继续提醒（针对驳回场景）
+//         const checkShouldContinueForRejection = async (enterpriseId: string): Promise<boolean> => {
+//             try {
+//                 // 1. 检查企业是否关闭了邮件提醒
+//                 const enterpriseInfo = await selectData(
+//                     OPERATIONALDATATYPE.查询单个,
+//                     TABLENAME.企业基础信息表,
+//                     { eId: enterpriseId },
+//                     ["emailReminder", "register"]
+//                 );
+                
+//                 if (!enterpriseInfo) {
+//                     console.log(`企业 ${enterpriseId} 信息不存在，停止提醒`);
+//                     return false; // 企业不存在，停止提醒
+//                 }
+                
+//                 if (enterpriseInfo.emailReminder != enumConfig.STATE.是) {
+//                     console.log(`企业 ${enterpriseId} 已关闭邮件提醒，符合终止条件`);
+//                     return false; // 已关闭提醒，停止
+//                 }
+                
+//                 // 2. 检查企业是否已重新提交申请（register不再是已驳回）
+//                 if (enterpriseInfo.register != enumConfig.CHANGESTATE.已驳回) {
+//                     console.log(`企业 ${enterpriseId} 已重新提交申请，符合终止条件`);
+//                     return false; // 已重新提交，停止提醒
+//                 }
+                
+//                 // 3. 检查企业是否已通过入孵申请
+//                 const passCheck = await selectData(
+//                     OPERATIONALDATATYPE.查询单个,
+//                     TABLENAME.入孵申请审批表,
+//                     { 
+//                         eId: enterpriseId,
+//                         changeType: enumConfig.CHANGETYPE.入孵申请,
+//                         changeState: enumConfig.CHANGESTATE.已通过
+//                     },
+//                     ["approvalId"]
+//                 );
+                
+//                 if (passCheck && passCheck.approvalId) {
+//                     console.log(`企业 ${enterpriseId} 的入孵申请已通过，停止提醒`);
+//                     return false; // 申请已通过，停止提醒
+//                 }
+                
+//                 // 4. 检查企业是否已通过入孵材料审核
+//                 const materialPassCheck = await selectData(
+//                     OPERATIONALDATATYPE.查询单个,
+//                     TABLENAME.入孵申请审批表,
+//                     { 
+//                         eId: enterpriseId,
+//                         changeType: enumConfig.CHANGETYPE.入孵材料审批,
+//                         changeState: enumConfig.CHANGESTATE.已通过
+//                     },
+//                     ["approvalId"]
+//                 );
+                
+//                 if (materialPassCheck && materialPassCheck.approvalId) {
+//                     console.log(`企业 ${enterpriseId} 已通过入孵材料审核，停止提醒`);
+//                     return false; // 已通过材料审核，停止提醒
+//                 }
+                
+//                 // 所有检查通过，继续提醒
+//                 return true;
+                
+//             } catch (error) {
+//                 console.error(`检查驳回终止条件失败，企业ID: ${enterpriseId}`, error);
+//                 return true; // 出错时默认继续
+//             }
+//         };
+        
+//         // 7天后开始第一次检查
+//         setTimeout(scheduleRejectionReminder, 7 * 24 * 60 * 60 * 1000);
+//         console.log(`已为企业 ${eId} 设置周期性入孵申请驳回提醒，首次检查将在7天后进行`);
+//     }
+    
+//     return {isSuccess:true};
+// }
+
+
+/**
  * 获取未查看的新入孵申请数量
  */
 export async function getNewApplicationCount() {
@@ -500,6 +1243,7 @@ export async function enterpriseRegisterExamineList(enterpriseName, page) {
             eId:info.eId,
             enterpriseName:info.enterpriseName,
             randomCode:info.randomCode,
+            emailReminder:info.emailReminder,
             /**跳转用 - 文件链接 */
             ...fileDisplayInfo,
             /**显示用 - 文件名称（显示第一个文件） */
@@ -763,16 +1507,323 @@ export async function enterpriseRegisterExaminePass(eId:string) {
 
 
 /**
+ * 修改是否邮件通知状态
+ * @param eId 
+ * @param emailReminder 
+ */
+export async function updateEmailReminder(eId, emailReminder) {
+    if (!eId) throw new BizError(ERRORENUM.参数错误);
+    let manyTableInfo:any = {}
+    let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "state"];
+    manyTableInfo[TABLENAME.租赁信息] = {column:["sanFangXieYi", "fuHuaXieYi", "fangWuZuLing", "fuHuaXieYiBuChong", "chengXinChengNuoHan", "yingYeZhiZhao", "ruFuZiLiao", "ruZhuJiHua", "yaJinZhiFu", "cardCopy"], where:{} };
+    let resInfo = await selectManyTableData(OPERATIONALDATATYPE.多表单个, TABLENAME.企业基础信息表, {eId}, filesList, manyTableInfo);
+
+    if (!resInfo || !resInfo.eId) throw new BizError(ERRORENUM.数据不存在);
+
+    await operationalData(OPERATIONALDATATYPE.修改, TABLENAME.企业基础信息表, {emailReminder}, {eId});
+
+    return {isSuccess:true};
+}
+
+
+/**
+ * 入孵材料审核驳回
+ * @param eId 
+ * @param descType 驳回类型 [1, 2]
+ * @param desc 
+ * @returns 
+ */
+// export async function enterpriseRegisterExamineOut(eId:string, descType, desc:string) {
+//     if (!eId) throw new BizError(ERRORENUM.参数错误);
+//     if (!descType.length) throw new BizError(ERRORENUM.请选择驳回原因);
+//     let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "state"];
+//     let resInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业基础信息表, {eId}, filesList);
+
+//     if (!resInfo || !resInfo.eId) throw new BizError(ERRORENUM.数据不存在);
+//     let leaseInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.租赁信息, {eId}, []);
+
+//     let leaseConf = ["sanFangXieYi", "fuHuaXieYi", "fangWuZuLing", "fuHuaXieYiBuChong", "chengXinChengNuoHan", "yingYeZhiZhao", "ruFuZiLiao", "ruZhuJiHua", "cardCopy"];
+//     for (let i = 0; i < leaseConf.length; i++) {
+//         if(!leaseInfo[leaseConf[i]]) {
+//             throw new BizError(ERRORENUM.该企业暂未提交入孵材料);
+//         }
+//     }
+
+//     let updateLeaseInfo:any = {yaJinZhiFu:null};
+//     for (let i = 0; i < leaseConf.length; i++) {
+//         updateLeaseInfo[leaseConf[i]] = null;
+//     }
+//     await operationalData(OPERATIONALDATATYPE.修改, TABLENAME.租赁信息, updateLeaseInfo, {eId});
+
+//     await operationalData(OPERATIONALDATATYPE.修改, TABLENAME.企业基础信息表, {state:enumConfig.CHANGESTATE.已驳回, isNewApplication: enumConfig.STATE.是}, {eId});
+    
+//     let descStr = "";
+//     for(let i = 0; i < descType.length; i++) {
+//         if (descType[i] == enumConfig.FILEDESCTYPE.其他) {
+//             if (desc) descStr += `${desc}；`
+//         } else {
+//             descStr += `${changeEnumValue(enumConfig.FILEDESCTYPE, descType[i])}；`;
+//         }
+//     }
+//     let descTypeStr = JSON.stringify(descType) || '[]';
+
+//     let addInfo = {
+//         approvalId: randomId(TABLEID.入孵申请审批表),
+//         eId,
+//         changeType: enumConfig.CHANGETYPE.入孵材料审批,
+//         changeState: enumConfig.CHANGESTATE.已驳回,
+//         createTimeMs: getMySqlMs(),
+//         descType:descTypeStr,
+//         desc:descStr,
+//     }
+//     await operationalData( OPERATIONALDATATYPE.增加, TABLENAME.入孵申请审批表, addInfo, {} );
+
+//     /**发送邮件 - 首次驳回通知 */
+//     let mailStr = "";
+//     mailStr += "<p>感谢贵公司积极配合入孵流程。经审核，贵公司提交的入孵材料<span style='font-weight: 700;'>暂未通过审核</span>，主要原因如下：</p>";
+//     mailStr += `<ul>`;
+//     mailStr += `<li>${descStr}</li>`;
+//     mailStr += `</ul>`;
+//     mailStr += `<p>如贵司愿意继续推进入孵流程，可根据上述意见进行材料完善并重新提交。</p>`;
+//     mailStr += `<p>我们期待贵公司尽快完善材料，并欢迎继续申请入驻。</p>`;
+//     mailStr += `<p>感谢理解与配合！</p>`;
+//     await systemSendMail(resInfo.eId, enumConfig.MAILTYPE.驳回入孵材料申请, mailStr );
+    
+//     /**设置7天后再次提醒 */
+//     setTimeout(async () => {
+//         try {
+//             // 检查企业状态是否仍然是已驳回（未重新提交材料）
+//             let currentInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业基础信息表, {eId}, ["state"]);
+//             if (currentInfo && currentInfo.state === enumConfig.CHANGESTATE.已驳回) {
+//                 let reminderMailStr = "";
+//                 reminderMailStr += "<p>【雨艺孵化器】入孵材料审核提醒</p>";
+//                 reminderMailStr += "<p>尊敬的客户：</p>";
+//                 reminderMailStr += "<p>我们注意到您在7天前提交的入孵材料未通过审核，目前尚未收到您重新提交的完善材料。</p>";
+//                 reminderMailStr += `<p>驳回原因：${descStr}</p>`;
+//                 reminderMailStr += "<p>请您根据审核意见尽快完善相关材料并重新提交，以便我们继续为您处理入孵申请。</p>";
+//                 reminderMailStr += "<p>如有任何疑问，欢迎随时联系我们。</p>";
+//                 reminderMailStr += "<p>期待您的完善材料！</p>";
+                
+//                 await systemSendMail(resInfo.eId, enumConfig.MAILTYPE.驳回入孵材料申请, reminderMailStr);
+//                 console.log(`7天后入孵材料驳回提醒邮件已发送给企业 ${resInfo.eId}`);
+//             }
+//         } catch (error) {
+//             console.error(`发送7天后入孵材料驳回提醒邮件失败:`, error);
+//         }
+//     }, 7 * 24 * 60 * 60 * 1000); // 7天后的毫秒数
+
+//     return {isSuccess:true};
+// }
+
+/**
  * 入孵材料审核驳回
  * @param eId 
  * @param descType 驳回类型 [1, 2]
  * @param desc 
  * @returns 
  */
-export async function enterpriseRegisterExamineOut(eId:string, descType, desc:string) {
+// export async function enterpriseRegisterExamineOut(eId:string, descType, desc:string) {
+//     if (!eId) throw new BizError(ERRORENUM.参数错误);
+//     if (!descType.length) throw new BizError(ERRORENUM.请选择驳回原因);
+    
+//     // 添加emailReminder字段查询
+//     let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "state", "emailReminder"];
+//     let resInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业基础信息表, {eId}, filesList);
+
+//     if (!resInfo || !resInfo.eId) throw new BizError(ERRORENUM.数据不存在);
+//     let leaseInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.租赁信息, {eId}, []);
+
+//     let leaseConf = ["sanFangXieYi", "fuHuaXieYi", "fangWuZuLing", "fuHuaXieYiBuChong", "chengXinChengNuoHan", "yingYeZhiZhao", "ruFuZiLiao", "ruZhuJiHua", "cardCopy"];
+//     for (let i = 0; i < leaseConf.length; i++) {
+//         if(!leaseInfo[leaseConf[i]]) {
+//             throw new BizError(ERRORENUM.该企业暂未提交入孵材料);
+//         }
+//     }
+
+//     let updateLeaseInfo:any = {yaJinZhiFu:null};
+//     for (let i = 0; i < leaseConf.length; i++) {
+//         updateLeaseInfo[leaseConf[i]] = null;
+//     }
+//     await operationalData(OPERATIONALDATATYPE.修改, TABLENAME.租赁信息, updateLeaseInfo, {eId});
+
+//     await operationalData(OPERATIONALDATATYPE.修改, TABLENAME.企业基础信息表, {state:enumConfig.CHANGESTATE.已驳回, isNewApplication: enumConfig.STATE.是}, {eId});
+    
+//     let descStr = "";
+//     for(let i = 0; i < descType.length; i++) {
+//         if (descType[i] == enumConfig.FILEDESCTYPE.其他) {
+//             if (desc) descStr += `${desc}；`
+//         } else {
+//             descStr += `${changeEnumValue(enumConfig.FILEDESCTYPE, descType[i])}；`;
+//         }
+//     }
+//     let descTypeStr = JSON.stringify(descType) || '[]';
+
+//     let addInfo = {
+//         approvalId: randomId(TABLEID.入孵申请审批表),
+//         eId,
+//         changeType: enumConfig.CHANGETYPE.入孵材料审批,
+//         changeState: enumConfig.CHANGESTATE.已驳回,
+//         createTimeMs: getMySqlMs(),
+//         descType:descTypeStr,
+//         desc:descStr,
+//     }
+//     await operationalData( OPERATIONALDATATYPE.增加, TABLENAME.入孵申请审批表, addInfo, {} );
+
+//     /**发送邮件 - 首次驳回通知 */
+//     let mailStr = "";
+//     mailStr += "<p>感谢贵公司积极配合入孵流程。经审核，贵公司提交的入孵材料<span style='font-weight: 700;'>暂未通过审核</span>，主要原因如下：</p>";
+//     mailStr += `<ul>`;
+//     mailStr += `<li>${descStr}</li>`;
+//     mailStr += `</ul>`;
+//     mailStr += `<p>如贵司愿意继续推进入孵流程，可根据上述意见进行材料完善并重新提交。</p>`;
+//     mailStr += `<p>我们期待贵公司尽快完善材料，并欢迎继续申请入驻。</p>`;
+//     mailStr += `<p>感谢理解与配合！</p>`;
+//     await systemSendMail(resInfo.eId, enumConfig.MAILTYPE.驳回入孵材料申请, mailStr );
+    
+//     /**如果emailReminder为是，则设置7天后重复提醒机制 */
+//     if (resInfo.emailReminder == enumConfig.STATE.是) {
+//         // 创建材料驳回的周期性提醒函数
+//         const scheduleMaterialRejectionReminder = async () => {
+//             try {
+//                 // 检查是否应该继续提醒
+//                 const shouldContinue = await checkShouldContinueForMaterialRejection(eId);
+                
+//                 if (!shouldContinue) {
+//                     console.log(`为企业 ${eId} 停止周期性入孵材料驳回提醒，时间：${new Date().toLocaleString()}`);
+//                     return; // 终止循环
+//                 }
+                
+//                 // 获取最新的企业状态
+//                 const currentInfo = await selectData(
+//                     OPERATIONALDATATYPE.查询单个, 
+//                     TABLENAME.企业基础信息表, 
+//                     {eId}, 
+//                     ["state"]
+//                 );
+                
+//                 // 如果企业状态仍然是已驳回（材料未重新提交），发送提醒邮件
+//                 if (currentInfo && currentInfo.state === enumConfig.CHANGESTATE.已驳回) {
+//                     let reminderMailStr = "";
+//                     reminderMailStr += "<p>【雨艺孵化器】入孵材料审核提醒</p>";
+//                     reminderMailStr += "<p>尊敬的客户：</p>";
+//                     reminderMailStr += `<p>我们注意到您之前在${moment().subtract(7, 'days').format("YYYY-MM-DD")}提交的入孵材料未通过审核，目前尚未收到您重新提交的完善材料。</p>`;
+//                     reminderMailStr += `<p>驳回原因：${descStr}</p>`;
+//                     reminderMailStr += "<p>请您根据审核意见尽快完善相关材料并重新提交，以便我们继续为您处理入孵申请。</p>";
+//                     reminderMailStr += "<p>您可以通过以下方式重新提交材料：</p>";
+//                     reminderMailStr += "<p><span style='font-weight: 700;'>*电脑端：</span>https://fh.tninnopark.cn/incubatorApply</p>";
+//                     reminderMailStr += "<p><span style='font-weight: 700;'>*手机端：</span>扫描下方二维码：</p>";
+//                     reminderMailStr += "<p><img src='https://fh.tninnopark.cn/yuyi/files/域名访问.png' /></p>";
+//                     reminderMailStr += "<p>如有任何疑问，欢迎随时联系我们。</p>";
+//                     reminderMailStr += "<p>期待您的完善材料！</p>";
+                    
+//                     await systemSendMail(eId, enumConfig.MAILTYPE.驳回入孵材料申请, reminderMailStr);
+//                     console.log(`入孵材料驳回提醒邮件已发送给企业 ${eId}，时间：${new Date().toLocaleString()}`);
+//                 } else {
+//                     console.log(`企业 ${eId} 已重新提交材料或状态已变更，无需发送提醒邮件，时间：${new Date().toLocaleString()}`);
+//                 }
+                
+//                 // 7天后再次检查（无论是否发送邮件）
+//                 setTimeout(scheduleMaterialRejectionReminder, 7 * 24 * 60 * 60 * 1000);
+                
+//             } catch (error) {
+//                 console.error(`检查并发送入孵材料驳回提醒邮件失败:`, error);
+//                 // 即使出错，7天后也重试
+//                 setTimeout(scheduleMaterialRejectionReminder, 7 * 24 * 60 * 60 * 1000);
+//             }
+//         };
+        
+//         // 辅助函数：检查是否应该继续提醒（针对材料驳回场景）
+//         const checkShouldContinueForMaterialRejection = async (enterpriseId: string): Promise<boolean> => {
+//             try {
+//                 // 1. 检查企业是否关闭了邮件提醒
+//                 const enterpriseInfo = await selectData(
+//                     OPERATIONALDATATYPE.查询单个,
+//                     TABLENAME.企业基础信息表,
+//                     { eId: enterpriseId },
+//                     ["emailReminder", "state"]
+//                 );
+                
+//                 if (!enterpriseInfo) {
+//                     console.log(`企业 ${enterpriseId} 信息不存在，停止提醒`);
+//                     return false; // 企业不存在，停止提醒
+//                 }
+                
+//                 if (enterpriseInfo.emailReminder != enumConfig.STATE.是) {
+//                     console.log(`企业 ${enterpriseId} 已关闭邮件提醒，符合终止条件`);
+//                     return false; // 已关闭提醒，停止
+//                 }
+                
+//                 // 2. 检查企业状态是否不再是"已驳回"
+//                 if (enterpriseInfo.state != enumConfig.CHANGESTATE.已驳回) {
+//                     console.log(`企业 ${enterpriseId} 状态已变更，符合终止条件`);
+//                     return false; // 状态已变更（可能已重新提交或通过），停止提醒
+//                 }
+                
+//                 // 3. 检查企业是否已通过入孵材料审核
+//                 const materialPassCheck = await selectData(
+//                     OPERATIONALDATATYPE.查询单个,
+//                     TABLENAME.入孵申请审批表,
+//                     { 
+//                         eId: enterpriseId,
+//                         changeType: enumConfig.CHANGETYPE.入孵材料审批,
+//                         changeState: enumConfig.CHANGESTATE.已通过
+//                     },
+//                     ["approvalId"]
+//                 );
+                
+//                 if (materialPassCheck && materialPassCheck.approvalId) {
+//                     console.log(`企业 ${enterpriseId} 已通过入孵材料审核，停止提醒`);
+//                     return false; // 已通过材料审核，停止提醒
+//                 }
+                
+//                 // 4. 检查企业是否有新的入孵材料提交记录（即使还未审核通过）
+//                 const newMaterialSubmission = await selectData(
+//                     OPERATIONALDATATYPE.查询单个,
+//                     TABLENAME.租赁信息,
+//                     { eId: enterpriseId },
+//                     ["sanFangXieYi", "fuHuaXieYi"] // 检查任意文件字段
+//                 );
+                
+//                 // 如果有任一材料字段不为空，说明已重新提交
+//                 if (newMaterialSubmission && 
+//                     (newMaterialSubmission.sanFangXieYi || newMaterialSubmission.fuHuaXieYi)) {
+//                     console.log(`企业 ${enterpriseId} 已重新提交材料，停止提醒`);
+//                     return false; // 已重新提交材料，停止提醒
+//                 }
+                
+//                 // 所有检查通过，继续提醒
+//                 return true;
+                
+//             } catch (error) {
+//                 console.error(`检查材料驳回终止条件失败，企业ID: ${enterpriseId}`, error);
+//                 return true; // 出错时默认继续
+//             }
+//         };
+        
+//         // 7天后开始第一次检查
+//         setTimeout(scheduleMaterialRejectionReminder, 7 * 24 * 60 * 60 * 1000);
+//         console.log(`已为企业 ${eId} 设置周期性入孵材料驳回提醒，首次检查将在7天后进行`);
+//     }
+    
+//     return {isSuccess:true};
+// }
+
+
+
+/**
+ * 入孵材料审核驳回
+ * @param eId 企业ID
+ * @param descType 驳回类型 [1, 2]
+ * @param desc 驳回原因
+ * @param production 环境标识："production"表示生产环境，其他表示测试环境
+ * @returns 
+ */
+export async function enterpriseRegisterExamineOut(eId:string, descType, desc:string, production:string = "test") {
     if (!eId) throw new BizError(ERRORENUM.参数错误);
     if (!descType.length) throw new BizError(ERRORENUM.请选择驳回原因);
-    let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "state"];
+    
+    // 添加emailReminder字段查询
+    let filesList = ["eId", "enterpriseName", "uscc", "logonTime", "state", "emailReminder"];
     let resInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业基础信息表, {eId}, filesList);
 
     if (!resInfo || !resInfo.eId) throw new BizError(ERRORENUM.数据不存在);
@@ -825,33 +1876,150 @@ export async function enterpriseRegisterExamineOut(eId:string, descType, desc:st
     mailStr += `<p>感谢理解与配合！</p>`;
     await systemSendMail(resInfo.eId, enumConfig.MAILTYPE.驳回入孵材料申请, mailStr );
     
-    /**设置7天后再次提醒 */
-    setTimeout(async () => {
+    /**如果emailReminder为是，则设置周期性提醒机制 */
+    if (resInfo.emailReminder == enumConfig.STATE.是) {
+        // 根据参数确定提醒间隔
+        const REMINDER_INTERVAL = production === "production" 
+            ? 7 * 24 * 60 * 60 * 1000  // 生产环境：7天
+            : 60 * 1000;               // 测试环境：1分钟
+        
+        // 创建材料驳回的周期性提醒函数
+        const scheduleMaterialRejectionReminder = async () => {
             try {
-            // 检查企业状态是否仍然是已驳回（未重新提交材料）
-            let currentInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业基础信息表, {eId}, ["state"]);
+                // 检查是否应该继续提醒
+                const shouldContinue = await checkShouldContinueForMaterialRejection(eId);
+                
+                if (!shouldContinue) {
+                    console.log(`为企业 ${eId} 停止周期性入孵材料驳回提醒，时间：${new Date().toLocaleString()}`);
+                    return; // 终止循环
+                }
+                
+                // 获取最新的企业状态
+                const currentInfo = await selectData(
+                    OPERATIONALDATATYPE.查询单个, 
+                    TABLENAME.企业基础信息表, 
+                    {eId}, 
+                    ["state"]
+                );
+                
+                // 如果企业状态仍然是已驳回（材料未重新提交），发送提醒邮件
                 if (currentInfo && currentInfo.state === enumConfig.CHANGESTATE.已驳回) {
                     let reminderMailStr = "";
                     reminderMailStr += "<p>【雨艺孵化器】入孵材料审核提醒</p>";
                     reminderMailStr += "<p>尊敬的客户：</p>";
-                reminderMailStr += "<p>我们注意到您在7天前提交的入孵材料未通过审核，目前尚未收到您重新提交的完善材料。</p>";
+                    reminderMailStr += `<p>我们注意到您之前在${moment().subtract(REMINDER_INTERVAL / (24 * 60 * 60 * 1000), 'days').format("YYYY-MM-DD")}提交的入孵材料未通过审核，目前尚未收到您重新提交的完善材料。</p>`;
                     reminderMailStr += `<p>驳回原因：${descStr}</p>`;
                     reminderMailStr += "<p>请您根据审核意见尽快完善相关材料并重新提交，以便我们继续为您处理入孵申请。</p>";
+                    reminderMailStr += "<p>您可以通过以下方式重新提交材料：</p>";
+                    reminderMailStr += "<p><span style='font-weight: 700;'>*电脑端：</span>https://fh.tninnopark.cn/incubatorApply</p>";
+                    reminderMailStr += "<p><span style='font-weight: 700;'>*手机端：</span>扫描下方二维码：</p>";
+                    reminderMailStr += "<p><img src='https://fh.tninnopark.cn/yuyi/files/域名访问.png' /></p>";
                     reminderMailStr += "<p>如有任何疑问，欢迎随时联系我们。</p>";
                     reminderMailStr += "<p>期待您的完善材料！</p>";
                     
-                await systemSendMail(resInfo.eId, enumConfig.MAILTYPE.驳回入孵材料申请, reminderMailStr);
-                console.log(`7天后入孵材料驳回提醒邮件已发送给企业 ${resInfo.eId}`);
+                    await systemSendMail(eId, enumConfig.MAILTYPE.驳回入孵材料申请, reminderMailStr);
+                    console.log(`入孵材料驳回提醒邮件已发送给企业 ${eId}，时间：${new Date().toLocaleString()}，环境：${production}`);
+                } else {
+                    console.log(`企业 ${eId} 已重新提交材料或状态已变更，无需发送提醒邮件，时间：${new Date().toLocaleString()}`);
+                }
+                
+                // 设置下一次检查（无论是否发送邮件）
+                setTimeout(scheduleMaterialRejectionReminder, REMINDER_INTERVAL);
+                
+            } catch (error) {
+                console.error(`检查并发送入孵材料驳回提醒邮件失败:`, error);
+                // 即使出错，也尝试设置下一次检查
+                setTimeout(scheduleMaterialRejectionReminder, REMINDER_INTERVAL);
+            }
+        };
+        
+        // 辅助函数：检查是否应该继续提醒（针对材料驳回场景）
+        const checkShouldContinueForMaterialRejection = async (enterpriseId: string): Promise<boolean> => {
+            try {
+                // 1. 检查企业是否关闭了邮件提醒
+                const enterpriseInfo = await selectData(
+                    OPERATIONALDATATYPE.查询单个,
+                    TABLENAME.企业基础信息表,
+                    { eId: enterpriseId },
+                    ["emailReminder", "state"]
+                );
+                
+                if (!enterpriseInfo) {
+                    console.log(`企业 ${enterpriseId} 信息不存在，停止提醒`);
+                    return false; // 企业不存在，停止提醒
+                }
+                
+                if (enterpriseInfo.emailReminder != enumConfig.STATE.是) {
+                    console.log(`企业 ${enterpriseId} 已关闭邮件提醒，符合终止条件`);
+                    return false; // 已关闭提醒，停止
+                }
+                
+                // 2. 检查企业状态是否不再是"已驳回"
+                if (enterpriseInfo.state != enumConfig.CHANGESTATE.已驳回) {
+                    console.log(`企业 ${enterpriseId} 状态已变更，符合终止条件`);
+                    return false; // 状态已变更（可能已重新提交或通过），停止提醒
                 }
+                
+                // 3. 检查企业是否已通过入孵材料审核
+                const materialPassCheck = await selectData(
+                    OPERATIONALDATATYPE.查询单个,
+                    TABLENAME.入孵申请审批表,
+                    { 
+                        eId: enterpriseId,
+                        changeType: enumConfig.CHANGETYPE.入孵材料审批,
+                        changeState: enumConfig.CHANGESTATE.已通过
+                    },
+                    ["approvalId"]
+                );
+                
+                if (materialPassCheck && materialPassCheck.approvalId) {
+                    console.log(`企业 ${enterpriseId} 已通过入孵材料审核，停止提醒`);
+                    return false; // 已通过材料审核，停止提醒
+                }
+                
+                // 4. 检查企业是否有新的入孵材料提交记录（即使还未审核通过）
+                const newMaterialSubmission = await selectData(
+                    OPERATIONALDATATYPE.查询单个,
+                    TABLENAME.租赁信息,
+                    { eId: enterpriseId },
+                    ["sanFangXieYi", "fuHuaXieYi"] // 检查任意文件字段
+                );
+                
+                // 如果有任一材料字段不为空，说明已重新提交
+                if (newMaterialSubmission && 
+                    (newMaterialSubmission.sanFangXieYi || newMaterialSubmission.fuHuaXieYi)) {
+                    console.log(`企业 ${enterpriseId} 已重新提交材料，停止提醒`);
+                    return false; // 已重新提交材料，停止提醒
+                }
+                
+                // 所有检查通过，继续提醒
+                return true;
+                
             } catch (error) {
-            console.error(`发送7天后入孵材料驳回提醒邮件失败:`, error);
+                console.error(`检查材料驳回终止条件失败，企业ID: ${enterpriseId}`, error);
+                return true; // 出错时默认继续
+            }
+        };
+        
+        // 记录提醒设置信息
+        console.log(`已为企业 ${eId} 设置周期性入孵材料驳回提醒`, {
+            企业名称: resInfo.enterpriseName,
+            环境模式: production,
+            提醒间隔: `${REMINDER_INTERVAL}ms (${REMINDER_INTERVAL / (60 * 1000)}分钟)`,
+            首次提醒时间: new Date(Date.now() + REMINDER_INTERVAL).toLocaleString()
+        });
+        
+        // 设置第一次检查
+        setTimeout(scheduleMaterialRejectionReminder, REMINDER_INTERVAL);
     }
-    }, 7 * 24 * 60 * 60 * 1000); // 7天后的毫秒数
     
     return {isSuccess:true};
 }
 
 
+
+
+
 /**
  * 编辑入孵材料
  * @param eId 

src/biz/zaiFu.ts

@@ -3,14 +3,14 @@
  */
 
 import moment = require("moment");
-import { OPERATIONALDATATYPE, TABLENAME } from "../config/enum/dbEnum";
+import { OPERATIONALDATATYPE, TABLEID, TABLENAME } from "../config/enum/dbEnum";
 import { operationalData, paginateArray, selectData, selectManyTableData } from "../data/operationalData";
 import { changeAdd } from "../util/piecemeal";
 import { changeEnumManyValue, changeEnumValue } from "../util/verificationEnum";
 import * as enumConfig from "../config/enum/enum";
 import { BizError } from "../util/bizError";
 import { ERRORENUM } from "../config/enum/errorEnum";
-import { getMySqlMs, getPwdMd5 } from "../tools/system";
+import { getMySqlMs, getPwdMd5, randomId } from "../tools/system";
 import { BUILDING } from "../config/enum/enum";
 
 
@@ -234,6 +234,77 @@ export async function enterpriseMigrateList(enterpriseName:string, page:number)
 
 
 /**
+ * 移除迁出状态，返回在孵企业
+ * @param eId 企业ID
+ * @returns 
+ */
+export async function enterpriseReturnToIncubation(eId: string) {
+    // 1. 验证企业是否存在且处于迁出状态
+    let filesList = ["eId", "state", "startTime", "endTime"];
+    let resInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.企业孵化信息, { eId }, filesList);
+
+    if (!resInfo || !resInfo.eId) {
+        throw new BizError(ERRORENUM.数据不存在);
+    }
+
+    // 检查企业当前状态是否为迁出
+    if (resInfo.state !== enumConfig.FUHUASTATE.迁出) {
+        throw new BizError(ERRORENUM.该企业当前不在迁出状态);
+    }
+
+    // 2. 更新企业孵化信息为在孵状态
+    let updateInfo = {
+        state: enumConfig.FUHUASTATE.实体孵化, // 返回实体孵化状态
+        moveOutTime: null, // 清空迁出时间
+        moveOutType: null, // 清空迁出类型
+        moveOutTrace: null, // 清空迁出去向
+        returnTime: getMySqlMs() // 记录返回时间
+    };
+
+    await operationalData(OPERATIONALDATATYPE.修改, TABLENAME.企业孵化信息, updateInfo, { eId });
+
+    // 3. 同步创建返回记录到审批表
+    let addApprovalInfo = {
+        approvalId: randomId(TABLEID.入孵申请审批表),
+        eId,
+        changeType: enumConfig.CHANGETYPE.返回在孵, // 需要添加这个枚举值
+        changeState: enumConfig.CHANGESTATE.已通过,
+        createTimeMs: getMySqlMs(),
+        desc: "企业从迁出状态返回在孵"
+    };
+    
+    await operationalData(OPERATIONALDATATYPE.增加, TABLENAME.入孵申请审批表, addApprovalInfo, {});
+
+    // 4. 同步更新在孵企业面积
+    /**在孵企业 当前时间小于孵化结束时间 */
+    let 在孵面积 = 0;
+    let araeParam = {column:["area", "unitPrice", "roomNumber", "rent"], where:{} };
+    let zaifuTableInfo:any = {};
+    zaifuTableInfo[TABLENAME.租赁信息] = araeParam;
+    zaifuTableInfo[TABLENAME.企业孵化信息] = {
+        column:["state", "startTime", "endTime"], 
+        where:{state:{"%ne%":enumConfig.FUHUASTATE.迁出}} 
+    };
+    let zaifuResList = await selectManyTableData(OPERATIONALDATATYPE.多表联查, TABLENAME.企业基础信息表, {state:enumConfig.CHANGESTATE.已通过}, ["eId"], zaifuTableInfo );
+    
+    zaifuResList.forEach( info => {
+        info.enterprise_leases.forEach( lease => {
+            在孵面积 += parseFloat(lease.area);
+        })
+    })
+    let yuyiList = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.羽翼孵化器信息, {}, []);
+    if (在孵面积 != yuyiList.zaifuArea) await operationalData(OPERATIONALDATATYPE.修改, TABLENAME.羽翼孵化器信息, {zaifuArea:在孵面积}, {yId:yuyiList.yId});
+
+    console.log(`企业 ${eId} 已成功从迁出状态返回在孵`);
+    
+    return { 
+        isSuccess: true, 
+        message: "企业已成功返回在孵状态"
+    };
+}
+
+
+/**
  * 重置密码
  * @param eId 
  */

src/config/enum/enum.ts

@@ -288,7 +288,8 @@ export enum CHANGESTATE {
  */
 export enum CHANGETYPE {
     入孵申请 = 1,
-    入孵材料审批 = 2
+    入孵材料审批 = 2,
+    返回在孵 = 3,
 }
 
 

src/config/enum/errorEnum.ts

@@ -44,7 +44,8 @@ export enum ERRORENUM {
     请选择驳回原因,
     原密码错误,
     密码不一致,
-    系统错误
+    系统错误,
+    该企业当前不在迁出状态
 }
 
 export enum ERRORCODEENUM {

src/main.ts

@@ -14,7 +14,7 @@ async function lanuch() {
     httpServer.createServer(systemConfig.port);
     console.log('This indicates that the server is started successfully.');
 
-    // await initApiDataStorage();
+    await initApiDataStorage();
     
     // console.log("更新加密后密码格式...");
     // await migrateEnterpriseUserPasswords();

src/routers/admin.ts

@@ -35,6 +35,7 @@ export function setRouter(httpServer) {
     httpServer.post('/admin/enterprise/settlein/examine/list', checkUser, asyncHandler(examineSettleIn));
     httpServer.post('/admin/enterprise/settlein/examine/pass', checkUser, asyncHandler(examineSettleInPass)); //入孵材料审核 通过
     httpServer.post('/admin/enterprise/settlein/examine/out', checkUser, asyncHandler(examineSettleInOut)); //驳回
+    httpServer.post('/admin/enterprise/settlein/examine/emailreminder', checkUser, asyncHandler(updateEmailReminder));
     
     // //通知
     httpServer.post('/admin/notice/list', checkUser, asyncHandler(noticeList));
@@ -53,6 +54,7 @@ export function setRouter(httpServer) {
     httpServer.post('/admin/library/enterprise/list', checkUser, asyncHandler(enterpriseList));
     httpServer.post('/admin/library/enterprise/migrate/out', checkUser, asyncHandler(enterpriseMigrateOut));//在孵企业迁出功能
     httpServer.post('/admin/library/enterprise/migrate/list', checkUser, asyncHandler(enterpriseMigrateList));//迁出企业列表
+    httpServer.post('/admin/library/enterprise/toincubation', checkUser, asyncHandler(enterpriseReturnToIncubation));//二期新增-移除迁出状态，返回在孵企业
     httpServer.post('/admin/library/enterprise/details', checkUser, asyncHandler(enterpriseDetails));
     httpServer.post('/admin/library/enterprise/resetpwd', checkUser, asyncHandler(resetPwd));
     // httpServer.post('/admin/library/enterprise/details', checkUser, asyncHandler(enterpriseById));
@@ -393,6 +395,21 @@ async function enterpriseMigrateList(req, res) {
     res.success(result);
 }
 
+
+/**
+ * 移除迁出状态，返回在孵企业
+ * @param req 
+ * @param res 
+ */
+async function enterpriseReturnToIncubation(req, res) {
+    const UserInfo = req.userInfo;
+    let {eId} = req.body;
+    let result = await zaiFuBiz.enterpriseReturnToIncubation(eId);
+
+    res.success(result);
+}
+
+
 /**
  * 在孵企业详情
  * @param req 
@@ -820,20 +837,20 @@ async function settleIn(req, res) {
 
 
 /**
- * 
+ * 入孵申请通过
  * @param req 
  * @param res 
  */
 async function settleInPass(req, res) {
     const UserInfo = req.userInfo;
     let { eId } = req.body
-    let result = await ruFuBiz.settleInEnterprisePass(eId);
+    let result = await ruFuBiz.settleInEnterprisePass(eId, "production");
 
     res.success(result);
 }
 
 /**
- * 
+ * 入孵申请回显
  * @param req 
  * @param res 
  */
@@ -847,7 +864,7 @@ async function settleInById(req, res) {
 
 
 /**
- * 
+ * 入孵申请驳回
  * @param req 
  * @param res 
  */
@@ -966,8 +983,20 @@ async function examineSettleInPass(req, res) {
 async function examineSettleInOut(req, res) {
     const UserInfo = req.userInfo;
     let { eId, descType, desc  } = req.body;
-    let result = await ruFuBiz.enterpriseRegisterExamineOut(eId, descType, desc );
+    let result = await ruFuBiz.enterpriseRegisterExamineOut(eId, descType, desc, "production" );
+
+    res.success(result);
+}
 
+
+/**
+ * 修改是否邮件通知状态
+ * @param req 
+ * @param res 
+ */
+async function updateEmailReminder(req, res) {
+    let { eId, emailReminder } = req.body;
+    let result = await ruFuBiz.updateEmailReminder(eId, emailReminder);
     res.success(result);
 }
 

src/routers/ledger.ts

@@ -23,8 +23,8 @@ export function setRouter(httpServer) {
  */
 async function ledgerList(req, res) {
     const UserInfo = req.userInfo;
-    let {enterpriseName, logonStartTime, logonEndTime, building, page } = req.body
-    let result = await ledgerBiz.ledgerList(enterpriseName, logonStartTime, logonEndTime, building, page);
+    let {enterpriseName, phone, logonStartTime, logonEndTime, building, page } = req.body
+    let result = await ledgerBiz.ledgerList(enterpriseName, phone, logonStartTime, logonEndTime, building, page);
 
     res.success(result);
 }

src/routers/userRuFu.ts

@@ -13,7 +13,6 @@ export function setRouter(httpServer) {
     httpServer.post('/admin/enterprise/rufu/settleininfo', asyncHandler(settleInById));
     httpServer.post('/admin/enterprise/rufu/info', asyncHandler(getRuFu));
     httpServer.post('/admin/enterprise/rufu/update', asyncHandler(updateRuFu));
-
 }
 
 
@@ -23,7 +22,7 @@ export function setRouter(httpServer) {
  * @param res 
  */
  async function register(req, res) {
-    let {userName, phone, pwd } = req.body
+    let { userName, phone, pwd } = req.body
     let result = await userRuFuBiz.enterpriseRegister(userName, phone, pwd);
     res.success(result);
 }
@@ -35,20 +34,19 @@ export function setRouter(httpServer) {
  * @param res 
  */
  async function login(req, res) {
-    let {phone, pwd } = req.body
+    let { phone, pwd } = req.body
     let result = await userRuFuBiz.enterpriseLogin(phone, pwd);
     res.success(result);
 }
 
 
-
 /**
  * 获取入孵流程状态
  * @param req 
  * @param res 
  */
  async function ruFuState(req, res) {
-    let {uId } = req.body
+    let { uId } = req.body
     let result = await userRuFuBiz.getRuFuState(uId);
     res.success(result);
 }
@@ -66,8 +64,9 @@ export function setRouter(httpServer) {
     res.success(result);
 }
 
+
 /**
- * 
+ * 入孵申请回显
  * @param req 
  * @param res 
  */