@steedos-labs/plugin-workflow 3.0.54 → 3.0.56

package/main/default/routes/api_workflow_ai_form_design_stream.router.js

@@ -527,7 +527,10 @@ function buildSystemPrompt() {
   - reference_to: 字符串，关联对象的 API 名称，如 "contracts"、"accounts"
   - lookupLabelField: 字符串，用于搜索和显示的名称字段，默认 "name"
   - pickerMultiple: 布尔值，是否允许多选，默认 false
-  - lookupFilters: 字符串，OData 过滤表达式，如 "status eq 'active'"
+  - lookupFilters: 字符串，DevExpress JSON 格式的过滤表达式，支持 {fieldName} 占位符引用其他表单字段值（运行时自动替换为实际值）
+    - 静态过滤示例：'[["enablestate","=","2"],"and",["hidden","<>",true]]'
+    - 动态过滤示例（引用其他字段值）：'[["company_id","=","{company_id}"],"and",["enablestate","=","2"]]' — 当表单中 company_id 字段值变化时，{company_id} 会被自动替换为该字段的实际值
+    - 格式规则：eq → "="，ne → "<>"，gt → ">"，ge → ">="，lt → "<"，le → "<="，contains → "contains"，startswith → "startswith"。布尔值不加引号（true/false）
   - lookupDisplayFields: 数组，关联数据后额外展示的字段，格式 [{ "field": "字段API名", "label": "显示标签" }]
   - lookupFillRules: 数组，填充规则，选择关联记录后将源字段值自动填充到表单其他字段。格式 [{ "sourceField": "关联对象的字段API名", "targetField": "当前表单中的目标字段name" }]
     - 示例：选择合同后自动填充合同金额到表单的金额字段：lookupFillRules: [{ "sourceField": "amount", "targetField": "contract_amount" }]
@@ -612,6 +615,8 @@ if (field.name === 'quantity' || field.name === 'unit_price') {
 7. 如果用户只要求修改字段，则 events 保持原样不变
 8. 返回完整的 fields 数组和 events 对象
 9. ⚠️ **type 与 formula 属性的严格对应**：只要字段包含公式表达式（formula 属性），其 type 就**必须**是 "formula"，绝对不能是 "number"、"text" 或其他类型。"number" 类型仅用于用户手工输入数字的字段（无公式）。错误示例：{ type: "number", formula: "\${a + b}" }，正确示例：{ type: "formula", formula: "\${a + b}", valueType: "number", precision: 2 }。grid/table 的 children 子字段同样适用此规则
+10. ⚠️ **升级场景禁止自动设置配色**：当用户提供了 instance_template、form_script、flow_events 等旧版数据进行升级转换时，section（分组）、grid（网格）、table（子表）字段**不要自动添加** colorScheme、sectionColor、titleColor 等配色属性。配色属性只有在用户明确要求设置颜色/配色/主题色时才添加。升级的目标是忠实还原旧版表单的结构和逻辑，不要擅自美化
+11. **原样保留字段的 is_wide 属性**：is_wide 用于控制字段是否占满整行宽度。输出时必须保持每个字段的 is_wide 与输入完全一致：输入为 true 则输出 true，输入为 false 则输出 false，输入中没有该属性则不要添加。禁止擅自修改或统一设置 is_wide 的值
 
 ## 额外待转换的数据（升级场景）
 
@@ -749,15 +754,16 @@ if (field.name === 'quantity' || field.name === 'unit_price') {
 
 ### 旧公式字段跨对象引用迁移
 - 旧版表单中，公式字段可能通过 \`{applicant.organization.name}\`、\`{applicant.name}\` 等语法引用成员的关联属性。这种跨对象引用在新版中不再通过公式实现，而是通过**成员字段的 pickerFillRules（填充规则）**来替代。
+- ⚠️ **重要：applicant（申请人）是系统内置字段**，name 固定为 \`__applicant\`，不要创建新的 member 字段。在 fields 数组中输出 { "name": "__applicant", "label": "申请人", "type": "member", "pickerFillRules": [...] } 即可覆盖系统默认配置。该字段在拟稿状态下可编辑（用户可更换申请人），pickerFillRules 会在选人后自动触发填充。
 - 迁移方式：
   1. 将引用跨对象属性的公式字段改为**普通文本字段**（type: "text"）作为目标字段
-  2. 在成员字段（type: "member"）上配置 **pickerFillRules**，使用点号表示法的 sourceField（如 "organization.name"），targetField 指向该文本字段
+  2. 在 \`__applicant\` 字段上配置 **pickerFillRules**，使用点号表示法的 sourceField（如 "organization.name"），targetField 指向该文本字段
   3. 如果 targetField 字段应为只读展示（即旧版是纯展示的公式字段），设置 readonly: true
 - 迁移示例：
   旧版公式字段：\`{applicant.organization.name}\` 用于显示申请人所属部门名称
   新版迁移方式：
   1. 创建文本字段 { "name": "dept_name", "label": "所属部门", "type": "text", "readonly": true }
-  2. 在成员字段上配置 pickerFillRules: [{ "sourceField": "organization.name", "targetField": "dept_name" }]
+  2. 输出 __applicant 字段：{ "name": "__applicant", "label": "申请人", "type": "member", "pickerFillRules": [{ "sourceField": "organization.name", "targetField": "dept_name" }] }
 - 常见映射：
   - \`{applicant.organization.name}\` → sourceField: "organization.name"
   - \`{applicant.organization.fullname}\` → sourceField: "organization.fullname"

package/main/default/routes/api_workflow_export.router.js

@@ -11,8 +11,8 @@ const express = require('express');
 const router = express.Router();
 const { requireAuthentication } = require("@steedos/auth");
 const WorkflowManager = require('../manager/workflow_manager');
+const { getCollection } = require('../utils/collection');
 const _ = require('underscore');
-const Fiber = function(fun){console.log('TODO Fiber...')}
 const moment = require('moment')
 const fs = require('fs')
 const path = require('path')
@@ -35,160 +35,105 @@ const path = require('path')
  */
 router.get('/api/workflow/export/instances', requireAuthentication, async function (req, res) {
     try {
-        let userSession = req.user;
-        const spaceId = userSession.spaceId;
+        const userSession = req.user;
         const userId = userSession.userId;
-        const isSpaceAdmin = userSession.is_space_admin;
-        Fiber(async function () {
-            try {
-                var ejs, end_date, fields, fileName, flow, flow_id, flow_ids, form, form_name, formatDate, ins_to_xls, lang, last_month_date, now, query, ret, selector, space, space_id, start_date, str, table_fields, template, timezoneoffset, type, uid, utcOffset;
-                query = req.query;
-                space_id = query.space_id;
-                flow_id = query.flow_id;
-                type = parseInt(query.type);
-                timezoneoffset = parseInt(query.timezoneoffset);
-                flow = db.flows.findOne({
-                    _id: flow_id
-                }, {
-                    fields: {
-                        form: 1
-                    }
-                });
-                form = db.forms.findOne({
-                    _id: flow.form
-                }, {
-                    fields: {
-                        name: 1,
-                        'current.fields': 1
-                    }
-                });
-                form_name = form.name;
-                fields = form.current.fields;
-                table_fields = new Array;
-                _.each(form.current.fields, function (field) {
-                    if (field.type === "table") {
-                        return table_fields.push(field);
-                    }
-                });
-                ins_to_xls = new Array;
-                start_date = null;
-                end_date = null;
-                now = new Date;
-                selector = {
-                    space: space_id,
-                    flow: flow_id
-                };
-                selector.state = {
-                    $in: ["pending", "completed"]
-                };
-                uid = userId;
-                space = db.spaces.findOne({_id: space_id});
-                if (!space) {
-                    selector.state = "none";
-                }
-                if (!space.admins.includes(uid)) {
-                    flow_ids = WorkflowManager.getMyAdminOrMonitorFlows(space_id, uid);
-                    if (!flow_ids.includes(selector.flow)) {
-                        selector.$or = [
-                            {
-                                submitter: uid
-                            },
-                            {
-                                applicant: uid
-                            },
-                            {
-                                inbox_users: uid
-                            },
-                            {
-                                outbox_users: uid
-                            }
-                        ];
-                    }
-                }
-                // 0-本月
-                if (type === 0) {
-                    start_date = new Date(now.getFullYear(), now.getMonth(), 1);
-                    selector.submit_date = {
-                        $gte: start_date
-                    };
-                    ins_to_xls = db.instances.find(selector, {
-                        sort: {
-                            submit_date: 1
-                        }
-                    }).fetch();
-                    // 1-上月
-                } else if (type === 1) {
-                    last_month_date = new Date(new Date(now.getFullYear(), now.getMonth(), 1) - 1000 * 60 * 60 * 24);
-                    start_date = new Date(last_month_date.getFullYear(), last_month_date.getMonth(), 1);
-                    end_date = new Date(now.getFullYear(), now.getMonth(), 1);
-                    selector.submit_date = {
-                        $gte: start_date,
-                        $lte: end_date
-                    };
-                    ins_to_xls = db.instances.find(selector, {
-                        sort: {
-                            submit_date: 1
-                        }
-                    }).fetch();
-                    // 2-整个年度
-                } else if (type === 2) {
-                    start_date = new Date(now.getFullYear(), 0, 1);
-                    selector.submit_date = {
-                        $gte: start_date
-                    };
-                    ins_to_xls = db.instances.find(selector, {
-                        sort: {
-                            submit_date: 1
-                        }
-                    }).fetch();
-                    // 3-所有
-                } else if (type === 3) {
-                    ins_to_xls = db.instances.find(selector, {
-                        sort: {
-                            submit_date: 1
-                        }
-                    }).fetch();
-                }
-                ejs = require('ejs');
-                str = fs.readFileSync(path.resolve(__dirname, '../server/ejs/export_instances.ejs'), 'utf8');
-                // 检测是否有语法错误
-                // ejsLint = require('ejs-lint')
-                // if ejsLint.lint
-                // 	error_obj = ejsLint.lint(str, {})
-                // else
-                // 	error_obj = ejsLint(str, {})
-                // if error_obj
-                // 	console.error "===/api/workflow/export:"
-                // 	console.error error_obj
-                template = ejs.compile(str);
-                lang = 'en';
-                if (userSession.locale === 'zh-cn') {
-                    lang = 'zh-CN';
-                }
-                utcOffset = timezoneoffset / -60;
-                formatDate = function (date, formater) {
-                    return moment(date).utcOffset(utcOffset).format(formater);
-                };
-                ret = template({
-                    lang: lang,
-                    formatDate: formatDate,
-                    form_name: form_name,
-                    fields: fields,
-                    table_fields: table_fields,
-                    ins_to_xls: ins_to_xls
-                });
-                fileName = "SteedOSWorkflow_" + moment().format('YYYYMMDDHHmm') + ".xls";
-                res.setHeader("Content-type", "application/octet-stream");
-                res.setHeader("Content-Disposition", "attachment;filename=" + encodeURI(fileName));
-                return res.end(ret);
-            } catch (e) {
-                console.error(e);
-                res.status(200).send({
-                    errors: [{ errorMessage: e.message }]
-                });
+        const query = req.query;
+        const space_id = query.space_id;
+        const flow_id = query.flow_id;
+        const type = parseInt(query.type);
+        const timezoneoffset = parseInt(query.timezoneoffset);
+
+        const flowsCollection = await getCollection('flows');
+        const formsCollection = await getCollection('forms');
+        const spacesCollection = await getCollection('spaces');
+        const instancesCollection = await getCollection('instances');
+
+        const flow = await flowsCollection.findOne(
+            { _id: flow_id },
+            { projection: { form: 1 } }
+        );
+        const form = await formsCollection.findOne(
+            { _id: flow.form },
+            { projection: { name: 1, 'current.fields': 1 } }
+        );
+        const form_name = form.name;
+        const fields = form.current.fields;
+        const table_fields = [];
+        _.each(fields, function (field) {
+            if (field.type === "table") {
+                table_fields.push(field);
             }
-        }).run()
+        });
+
+        let ins_to_xls = [];
+        const now = new Date();
+        const selector = {
+            space: space_id,
+            flow: flow_id,
+            state: { $in: ["pending", "completed"] }
+        };
+
+        const uid = userId;
+        const space = await spacesCollection.findOne({ _id: space_id });
+        if (!space) {
+            selector.state = "none";
+        }
+        if (space && !space.admins.includes(uid)) {
+            const flow_ids = await WorkflowManager.getMyAdminOrMonitorFlows(space_id, uid);
+            if (!flow_ids.includes(flow_id)) {
+                selector.$or = [
+                    { submitter: uid },
+                    { applicant: uid },
+                    { inbox_users: uid },
+                    { outbox_users: uid }
+                ];
+            }
+        }
+
+        // 0-本月
+        if (type === 0) {
+            const start_date = new Date(now.getFullYear(), now.getMonth(), 1);
+            selector.submit_date = { $gte: start_date };
+        // 1-上月
+        } else if (type === 1) {
+            const last_month_date = new Date(new Date(now.getFullYear(), now.getMonth(), 1) - 1000 * 60 * 60 * 24);
+            const start_date = new Date(last_month_date.getFullYear(), last_month_date.getMonth(), 1);
+            const end_date = new Date(now.getFullYear(), now.getMonth(), 1);
+            selector.submit_date = { $gte: start_date, $lte: end_date };
+        // 2-整个年度
+        } else if (type === 2) {
+            const start_date = new Date(now.getFullYear(), 0, 1);
+            selector.submit_date = { $gte: start_date };
+        }
+        // 3-所有: 不加 submit_date 过滤
+
+        ins_to_xls = await instancesCollection.find(selector).sort({ submit_date: 1 }).toArray();
+
+        const ejs = require('ejs');
+        const str = fs.readFileSync(path.resolve(__dirname, '../server/ejs/export_instances.ejs'), 'utf8');
+        const template = ejs.compile(str);
+        let lang = 'en';
+        if (userSession.locale === 'zh-cn') {
+            lang = 'zh-CN';
+        }
+        const utcOffset = timezoneoffset / -60;
+        const formatDate = function (date, formater) {
+            return moment(date).utcOffset(utcOffset).format(formater);
+        };
+        const ret = template({
+            lang: lang,
+            formatDate: formatDate,
+            form_name: form_name,
+            fields: fields,
+            table_fields: table_fields,
+            ins_to_xls: ins_to_xls
+        });
+        const fileName = "SteedOSWorkflow_" + moment().format('YYYYMMDDHHmm') + ".xls";
+        res.setHeader("Content-type", "application/octet-stream");
+        res.setHeader("Content-Disposition", "attachment;filename=" + encodeURI(fileName));
+        return res.end(ret);
     } catch (e) {
+        console.error(e);
         res.status(200).send({
             errors: [{ errorMessage: e.message }]
         });

package/main/default/routes/api_workflow_instance_forward.router.js

@@ -155,7 +155,18 @@ router.post("/api/workflow/v2/instance/forward", requireAuthentication, async fu
         const old_values = ins.values;
         let new_values = {};
         const form = await UUFlowManager.getForm(flow.form, { fields: { historys: 0 } });
-        const fields = form.current.fields || [];
+        const rawFields = form.current.fields || [];
+
+        // Normalize fields: ensure every field (and sub-fields) has `code` (fallback to `name`)
+        const normalizeFields = (list) => (list || []).map(f => {
+            const normalized = f.code ? f : { ...f, code: f.name };
+            if (['table', 'section'].includes(normalized.type) && _.isArray(normalized.fields)) {
+                normalized.fields = normalizeFields(normalized.fields);
+            }
+            return normalized;
+        });
+
+        const fields = normalizeFields(rawFields);
 
         const formCollection = await getCollection('forms')
 
@@ -176,6 +187,9 @@ router.post("/api/workflow/v2/instance/forward", requireAuthentication, async fu
             }
         }
 
+        // Normalize old_fields using the same helper
+        old_fields = normalizeFields(old_fields);
+
         // Process fields
         for (const field of fields) {
             const exists_field = _.find(old_fields, f => f.type == field.type && f.code == field.code);

package/main/default/routes/api_workflow_instance_permissions.router.js

@@ -20,8 +20,8 @@ router.get('/api/workflow/v2/instance/:instanceId/permission', requireAuthentica
         }
         const user = await db.users.findOne({_id: current_user_id});
         const instance = await db.instances.findOne({_id: instanceId})
-        console.log(`user`, user)
-        console.log(`instance`, instance)
+        // console.log(`user`, user)
+        // console.log(`instance`, instance)
         const permission = await WorkflowManager.hasInstancePermissions(user, instance)
         res.status(200).send({
             data: {

package/main/default/routes/api_workflow_nav.router.js

@@ -147,10 +147,16 @@ const getCategoriesMonitor = async (userSession, req, currentUrl) => {
   // Only the string 'false' will disable the filtering
   const enableCategoryFilter = process.env.STEEDOS_WORKFLOW_ENABLE_CATEGORY_FILTER !== 'false';
 
+  // When set to 'false', skip monitor children (category/flow) computation, only show root node
+  // Defaults to the value of STEEDOS_WORKFLOW_ENABLE_CATEGORY_FILTER
+  const enableMonitorCategoryFilter = process.env.STEEDOS_WORKFLOW_ENABLE_MONITOR_CATEGORY_FILTER
+    ? process.env.STEEDOS_WORKFLOW_ENABLE_MONITOR_CATEGORY_FILTER !== 'false'
+    : enableCategoryFilter;
+
   try {
     let flows = [];
     
-    if (!enableCategoryFilter) {
+    if (!enableMonitorCategoryFilter) {
       // When category filtering is disabled, return empty array (no sub-navigation)
       // Only box-level items will be shown
       // Still need to check permissions for hasFlowsPer (used to control monitor box visibility)

package/main/default/routes/api_workflow_next_step.router.js

@@ -70,7 +70,7 @@ const getNextSteps = async (flow, flowVersionId, instance, currentStep, judge, a
     }
     switch (currentStep.step_type) {
         case 'condition': //条件
-            const stepIds = await UUFlowManager.getNextSteps(instance, flow, currentStep, judge, autoFormDoc);
+            const stepIds = await UUFlowManager.getNextSteps(instance, flow, currentStep, judge, autoFormDoc, true);
             nextSteps = getStepsById(flow, flowVersionId, stepIds);
             if (!nextSteps.length)
                 throw new Error('未能根据条件找到下一步');

package/main/default/services/instance.service.js

@@ -156,7 +156,7 @@ module.exports = {
                     break;
                 case 'pending':
                     filter.push(['state', '=', 'pending']);
-                    filter.push([['submitter', '=', userId], 'or', ['applicant', '=', userId]]);
+                    filter.push(['submitterOrApplicant', '=', userId]);
                     break;
                 case 'completed':
                     filter.push(['submitter', '=', userId]);

package/main/default/utils/business_hours.js

@@ -0,0 +1,210 @@
+"use strict";
+/**
+ * Business hours calculation utilities.
+ * Ported from steedos-platform packages/core/src/holidays/business_hours.ts
+ */
+const moment = require('moment');
+
+// BusinessHoursCheckedType enum values
+const BusinessHoursCheckedType = {
+    onAm: 1,       // 上午班
+    onPm: 2,       // 下午班
+    offDay: 0,     // 非工作日，即节假日、周未等
+    offAm: -1,     // 工作日，下班时间，非午休，早上0点到上午上班时间
+    offPm: -2,     // 工作日，下班时间，非午休，下午下班时间到第二天早上0点
+    offLunch: -3   // 工作日，午休时间
+};
+
+/**
+ * 把09:33这种字符串解析出来对应的时间值
+ * @param {string} str
+ * @param {number} digitsForHours
+ * @returns {object} { hours, minutes, valueToHours, valueToMinutes }
+ */
+function getStringTimeValue(str, digitsForHours = 2) {
+    str = str.trim();
+    if (!/^\d{1,2}:\d{1,2}$/.test(str)) {
+        throw new Error("getStringTimeValue:Time format error, please enter HH:MM this format of 24 hours time character.");
+    }
+    const splits = str.split(":");
+    const h = parseInt(splits[0]);
+    const m = parseInt(splits[1]);
+    if (h > 24 || m > 60) {
+        throw new Error("getStringTimeValue:Time format error, please enter HH:MM this format of 24 hours time character.");
+    } else if (h === 24 && m > 0) {
+        throw new Error("getStringTimeValue:Time format error, please enter HH:MM this format of 24 hours time character.");
+    }
+    const valueToMinutes = h * 60 + m;
+    const valueToHours = Number((valueToMinutes / 60).toFixed(digitsForHours));
+    return { hours: h, minutes: m, valueToHours, valueToMinutes };
+}
+
+/**
+ * 计算09:00-18:00这种开始时间结束时间代表的每天工作时间长度
+ */
+function computeBusinessHoursPerDay(start, end, lunch_start, lunch_end, digitsForHours = 2) {
+    const startValue = getStringTimeValue(start, digitsForHours);
+    const endValue = getStringTimeValue(end, digitsForHours);
+    const lunchStartValue = getStringTimeValue(lunch_start, digitsForHours);
+    const lunchEndValue = getStringTimeValue(lunch_end, digitsForHours);
+    if (startValue && endValue && lunchStartValue && lunchEndValue) {
+        let computedMinutes = endValue.valueToMinutes - startValue.valueToMinutes;
+        const computedAmMinutes = lunchStartValue.valueToMinutes - startValue.valueToMinutes;
+        const computedPmMinutes = endValue.valueToMinutes - lunchEndValue.valueToMinutes;
+        const computedLunchMinutes = lunchEndValue.valueToMinutes - lunchStartValue.valueToMinutes;
+        computedMinutes = computedMinutes - computedLunchMinutes;
+        if (computedMinutes <= 0 || computedLunchMinutes <= 0) {
+            throw new Error("computeBusinessHoursPerDay:The end or lunch_end time value must be later than the start or lunch_start time.");
+        } else if (lunchStartValue.valueToMinutes <= startValue.valueToMinutes || lunchEndValue.valueToMinutes >= endValue.valueToMinutes) {
+            throw new Error("computeBusinessHoursPerDay:The lunch time must between the working time.");
+        } else {
+            const computedHours = Number((computedMinutes / 60).toFixed(digitsForHours));
+            const computedAmHours = Number((computedAmMinutes / 60).toFixed(digitsForHours));
+            const computedPmHours = Number((computedPmMinutes / 60).toFixed(digitsForHours));
+            const computedLunchHours = Number((computedLunchMinutes / 60).toFixed(digitsForHours));
+            return {
+                computedHours, computedMinutes,
+                computedAmHours, computedAmMinutes,
+                computedPmHours, computedPmMinutes,
+                computedLunchHours, computedLunchMinutes,
+                startValue, endValue, lunchStartValue, lunchEndValue
+            };
+        }
+    } else {
+        throw new Error("computeBusinessHoursPerDay:start or end is not valid.");
+    }
+}
+
+/**
+ * 根据businessHours取其对应的每天工作时间长度，并把值缓存到其computedPerDay属性中
+ */
+function getBusinessHoursPerDay(businessHours, digitsForHours = 2) {
+    if (businessHours.computedPerDay) {
+        return businessHours.computedPerDay;
+    }
+    const computedPerDay = computeBusinessHoursPerDay(
+        businessHours.start, businessHours.end,
+        businessHours.lunch_start, businessHours.lunch_end,
+        digitsForHours
+    );
+    businessHours.computedPerDay = computedPerDay;
+    return computedPerDay;
+}
+
+/**
+ * 计算某个日期是不是工作日
+ */
+function computeIsBusinessDay(date, holidays, workingDays) {
+    const value = moment.utc(date);
+    value.hours(0);
+    value.minutes(0);
+    value.seconds(0);
+    value.milliseconds(0);
+    const holiday = holidays.find((item) => {
+        return item.date && item.date.getTime() === value.toDate().getTime();
+    });
+    if (holiday) {
+        switch (holiday.type) {
+            case "adjusted_working_day":
+                return true;
+            case "adjusted_holiday":
+                return false;
+            case "public":
+                return false;
+        }
+    } else {
+        return workingDays.indexOf(value.day().toString()) > -1;
+    }
+}
+
+/**
+ * 计算某个时间点是不是工作时间（只判断时间点，不判断日期）
+ */
+function computeIsBusinessHours(date, businessHours, digitsForHours = 2) {
+    const utcOffset = businessHours.utc_offset;
+    const businessHoursPerDay = getBusinessHoursPerDay(businessHours, digitsForHours);
+    const startMoment = moment.utc(date);
+    startMoment.hours(businessHoursPerDay.startValue.hours - utcOffset);
+    startMoment.minutes(businessHoursPerDay.startValue.minutes);
+    const endMoment = moment.utc(date);
+    endMoment.hours(businessHoursPerDay.endValue.hours - utcOffset);
+    endMoment.minutes(businessHoursPerDay.endValue.minutes);
+    const lunchStartMoment = moment.utc(date);
+    lunchStartMoment.hours(businessHoursPerDay.lunchStartValue.hours - utcOffset);
+    lunchStartMoment.minutes(businessHoursPerDay.lunchStartValue.minutes);
+    const lunchEndMoment = moment.utc(date);
+    lunchEndMoment.hours(businessHoursPerDay.lunchEndValue.hours - utcOffset);
+    lunchEndMoment.minutes(businessHoursPerDay.lunchEndValue.minutes);
+    const startTimeValue = startMoment.toDate().getTime();
+    const endTimeValue = endMoment.toDate().getTime();
+    const lunchStartTimeValue = lunchStartMoment.toDate().getTime();
+    const lunchEndTimeValue = lunchEndMoment.toDate().getTime();
+    const dateTimeValue = date.getTime();
+    if (dateTimeValue <= endTimeValue && dateTimeValue >= startTimeValue) {
+        if (dateTimeValue <= lunchStartTimeValue) {
+            return BusinessHoursCheckedType.onAm;
+        } else if (dateTimeValue >= lunchEndTimeValue) {
+            return BusinessHoursCheckedType.onPm;
+        } else {
+            return BusinessHoursCheckedType.offLunch;
+        }
+    } else {
+        if (dateTimeValue > endTimeValue) {
+            return BusinessHoursCheckedType.offPm;
+        } else {
+            return BusinessHoursCheckedType.offAm;
+        }
+    }
+}
+
+/**
+ * 计算某个时间点是不是工作时间，包括节假日及非工作时间都要排除
+ */
+function computeIsBusinessDate(date, holidays, businessHours, digitsForHours = 2) {
+    if (computeIsBusinessDay(date, holidays, businessHours.working_days)) {
+        return computeIsBusinessHours(date, businessHours, digitsForHours);
+    } else {
+        return BusinessHoursCheckedType.offDay;
+    }
+}
+
+/**
+ * 根据来源时间所在日期计算下一个工作日的开始时间
+ */
+function computeNextBusinessDate(source, holidays, businessHours, digitsForHours = 2) {
+    const utcOffset = businessHours.utc_offset;
+    const businessHoursPerDay = getBusinessHoursPerDay(businessHours, digitsForHours);
+    const workingDays = businessHours.working_days;
+    const sourceMoment = moment.utc(source);
+    sourceMoment.hours(businessHoursPerDay.startValue.hours - utcOffset);
+    sourceMoment.minutes(businessHoursPerDay.startValue.minutes);
+    let startMoment = null;
+    const maxCount = 365;
+    for (let i = 0; i < maxCount; i++) {
+        sourceMoment.add(1, 'd');
+        if (computeIsBusinessDay(sourceMoment.toDate(), holidays, workingDays)) {
+            startMoment = sourceMoment;
+            break;
+        }
+    }
+    if (startMoment) {
+        const start = startMoment.toDate();
+        startMoment.hours(businessHoursPerDay.endValue.hours - utcOffset);
+        startMoment.minutes(businessHoursPerDay.endValue.minutes);
+        const end = startMoment.toDate();
+        return { start, end };
+    } else {
+        return null;
+    }
+}
+
+module.exports = {
+    BusinessHoursCheckedType,
+    getStringTimeValue,
+    computeBusinessHoursPerDay,
+    getBusinessHoursPerDay,
+    computeIsBusinessDay,
+    computeIsBusinessHours,
+    computeIsBusinessDate,
+    computeNextBusinessDate
+};