@steedos-labs/plugin-workflow 3.0.55 → 3.0.56

package/main/default/objects/instances/listviews/draft.listview.yml

@@ -16,11 +16,10 @@ filters: !!js/function |
     }
 sort: [['modified','desc']]
 searchable_fields:
+  - field: flow
   - field: name
   - field: submitter_name
-  - field: flow
   - field: applicant_organization_name
   - field: submit_date
   - field: state
-  - field: is_archived
 disableSwitch: true

package/main/default/objects/instances/listviews/monitor.listview.yml

@@ -25,12 +25,12 @@ filters: !!js/function |
     }
 sort: [['submit_date','desc']]
 searchable_fields:
+  - field: flow
   - field: name
   - field: submitter_name
   - field: applicant_organization_name
   - field: submit_date
   - field: state
-  - field: is_archived
 extra_columns:
   - extras
   - values

package/main/default/objects/instances/listviews/pending.listview.yml

@@ -25,13 +25,12 @@ filters: !!js/function |
     }
 sort: [['submit_date','desc']]
 searchable_fields:
+  - field: flow
   - field: name
   - field: submitter_name
-  - field: flow
   - field: applicant_organization_name
   - field: submit_date
   - field: state
-  - field: is_archived
 extra_columns:
   - extras
 disableSwitch: true

package/main/default/pages/page_instance_print.page.amis.json

@@ -106,7 +106,7 @@
                             "actions": [
                                 {
                                     "actionType": "custom",
-                                    "script": "doAction({actionType: 'setValue', componentId: 'u:print-width', args: {value: Number(event.data.value)}}); $('.steedos-instance-related-view-wrapper .instance-form').css('width', event.data.value + 'mm');"
+                                    "script": "doAction({actionType: 'setValue', componentId: 'u:print-width', args: {value: Number(event.data.value)}}); $('.steedos-instance-related-view-wrapper .instance-form').css('width', event.data.value + 'mm'); $('.steedos-instance-related-view-wrapper .instance-approve-history').css('width', event.data.value + 'mm');"
                                 }
                             ]
                         }
@@ -125,7 +125,7 @@
                             "actions": [
                                 {
                                     "actionType": "custom",
-                                    "script": "$('.steedos-instance-related-view-wrapper .instance-form').css('width', event.data.value + 'mm');"
+                                    "script": "$('.steedos-instance-related-view-wrapper .instance-form').css('width', event.data.value + 'mm'); $('.steedos-instance-related-view-wrapper .instance-approve-history').css('width', event.data.value + 'mm');"
                                 }
                             ]
                         }
@@ -241,6 +241,10 @@
             "width": "190mm",
             "transition": "width 0.5s ease-in-out"
         },
+        ".steedos-instance-related-view-wrapper .instance-approve-history": {
+            "width": "190mm",
+            "transition": "width 0.5s ease-in-out"
+        },
         ".steedos-instance-related-view-wrapper .steedos-amis-instance-view-content": {
             "display": "inline-block"
         },

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

@@ -174,7 +174,10 @@ router.post('/am/ai/form-design', async function auth(req, res, next) {
   - 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" }]
@@ -252,6 +255,8 @@ if (field.name === 'quantity' || field.name === 'unit_price') {
 10. 修改已有 grid 字段时，必须保留其完整的 gridData 和 children 数据，不要丢弃未被修改的子字段。如果用户未要求改动 grid 内容，应原样返回 grid 的所有属性
 11. 每个字段的类型特有属性必须完整返回：number 类型的 min/max/precision/thousandSeparator、text/textarea 的 maxLength/minLength、lookup 的 reference_to/lookupLabelField/lookupFillRules、member/org 的 pickerFillRules、reference 的 reference_to/displayFields 等。不要遗漏这些属性
 12. ⚠️ **type 与 formula 属性的严格对应**：只要字段包含公式表达式（formula 属性），其 type 就**必须**是 "formula"，绝对不能是 "number"、"text" 或其他类型。"number" 类型仅用于用户手工输入数字的字段（无公式）。错误示例：{ type: "number", formula: "${a + b}" }，正确示例：{ type: "formula", formula: "${a + b}", precision: 2 }。grid/table 的 children 子字段同样适用此规则
+13. ⚠️ **升级场景禁止自动设置配色**：当用户提供了 instance_template、form_script、flow_events 等旧版数据进行升级转换时，section（分组）、grid（网格）、table（子表）字段**不要自动添加** colorScheme、sectionColor、titleColor 等配色属性。配色属性只有在用户明确要求设置颜色/配色/主题色时才添加。升级的目标是忠实还原旧版表单的结构和逻辑，不要擅自美化
+14. **原样保留字段的 is_wide 属性**：is_wide 用于控制字段是否占满整行宽度。输出时必须保持每个字段的 is_wide 与输入完全一致：输入为 true 则输出 true，输入为 false 则输出 false，输入中没有该属性则不要添加。禁止擅自修改或统一设置 is_wide 的值
 
 ## 额外待转换的数据（升级场景）
 
@@ -377,15 +382,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_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_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/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
+};

package/main/default/utils/business_timeout.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * Business timeout calculation utilities.
+ * Ported from steedos-platform packages/core/src/holidays/business_timeout.ts
+ * 
+ * Uses @steedos/objectql (already a project dependency) to access holidays and
+ * business_hours objects, instead of @steedos/core.
+ */
+const moment = require('moment');
+const _ = require('lodash');
+const { getObject } = require('@steedos/objectql');
+const {
+    BusinessHoursCheckedType,
+    getBusinessHoursPerDay,
+    computeIsBusinessDate,
+    computeNextBusinessDate
+} = require('./business_hours');
+
+// Simple in-memory cache for holidays and business hours with TTL
+const CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
+const _holidaysCache = {};  // key: `${spaceId}-${year}`, value: { values: [...], timestamp }
+const _businessHoursCache = {}; // key: spaceId, value: { records: [...], timestamp }
+
+/**
+ * 从数据库中取出指定工作区内的节假日数据，支持缓存
+ * @param {string} spaceId
+ * @param {Array<number>} years
+ */
+async function getHolidays(spaceId, years) {
+    const holidaysFields = ["name", "type", "date", "adjusted_to", "space"];
+    for (const year of years) {
+        const cacheKey = `${spaceId}-${year}`;
+        const cached = _holidaysCache[cacheKey];
+        if (!cached || (Date.now() - cached.timestamp > CACHE_TTL_MS)) {
+            const yearStartDate = moment.utc(`${year}-01-01T00:00:00Z`).toDate();
+            const yearEndDate = moment.utc(`${year}-12-31T23:59:59Z`).toDate();
+            const objectHolidays = getObject("holidays");
+            const holidaysRecords = await objectHolidays.find({
+                filters: [["space", "=", spaceId], ["date", "between", [yearStartDate, yearEndDate]]],
+                fields: holidaysFields
+            });
+            _holidaysCache[cacheKey] = {
+                space: spaceId,
+                year: year,
+                values: (holidaysRecords && holidaysRecords.length) ? holidaysRecords : [],
+                timestamp: Date.now()
+            };
+        }
+    }
+    const result = [];
+    for (const year of years) {
+        const cacheKey = `${spaceId}-${year}`;
+        if (_holidaysCache[cacheKey] && _holidaysCache[cacheKey].values) {
+            result.push(..._holidaysCache[cacheKey].values);
+        }
+    }
+    return result;
+}
+
+/**
+ * 从数据库中取出指定工作区内的默认工作时间数据，支持缓存
+ * @param {string} spaceId
+ */
+async function getDefaultBusinessHours(spaceId) {
+    const cached = _businessHoursCache[spaceId];
+    if (cached && (Date.now() - cached.timestamp <= CACHE_TTL_MS)) {
+        return cached.records;
+    }
+    const objectBusinessHours = getObject("business_hours");
+    const records = await objectBusinessHours.find({
+        filters: [["space", "=", spaceId], ["is_default", "=", true]],
+        fields: ["name", "start", "end", "lunch_start", "lunch_end", "utc_offset", "working_days", "space"]
+    });
+    if (records && records.length) {
+        _businessHoursCache[spaceId] = { records, timestamp: Date.now() };
+    }
+    return records || [];
+}
+
+/**
+ * 计算以某个时间点开始，超时几个小时后，超时时间点是什么时候 (纯计算，不查数据库)
+ * @param {Date} start
+ * @param {number} timeoutHours
+ * @param {Array} holidays
+ * @param {object} businessHours
+ * @param {number} digitsForHours
+ * @returns {Date}
+ */
+function computeTimeoutDateWithoutHolidays(start, timeoutHours, holidays, businessHours, digitsForHours = 2) {
+    if (timeoutHours <= 0) {
+        return start;
+    }
+    const utcOffset = businessHours.utc_offset;
+    const businessHoursPerDay = getBusinessHoursPerDay(businessHours, digitsForHours);
+    const startBhct = computeIsBusinessDate(start, holidays, businessHours, digitsForHours);
+    let offsetMinutes = 0;
+    let startMoment = moment.utc(start);
+    let startClosingMoment = moment.utc(start);
+    if (startBhct <= 0) {
+        if (startBhct === BusinessHoursCheckedType.offLunch) {
+            startMoment.hours(businessHoursPerDay.lunchEndValue.hours - utcOffset);
+            startMoment.minutes(businessHoursPerDay.lunchEndValue.minutes);
+            start = startMoment.toDate();
+        } else if (startBhct === BusinessHoursCheckedType.offAm) {
+            startMoment.hours(businessHoursPerDay.startValue.hours - utcOffset);
+            startMoment.minutes(businessHoursPerDay.startValue.minutes);
+            start = startMoment.toDate();
+            startClosingMoment = moment.utc(start);
+            startClosingMoment.hours(businessHoursPerDay.lunchStartValue.hours - utcOffset);
+            startClosingMoment.minutes(businessHoursPerDay.lunchStartValue.minutes);
+            offsetMinutes = startClosingMoment.diff(startMoment, 'minute');
+            startMoment.hours(businessHoursPerDay.lunchEndValue.hours - utcOffset);
+            startMoment.minutes(businessHoursPerDay.lunchEndValue.minutes);
+            start = startMoment.toDate();
+        } else {
+            const nextBusinessDate = computeNextBusinessDate(start, holidays, businessHours, digitsForHours);
+            start = nextBusinessDate.start;
+            startMoment = moment.utc(start);
+            startClosingMoment = moment.utc(start);
+            startClosingMoment.hours(businessHoursPerDay.lunchStartValue.hours - utcOffset);
+            startClosingMoment.minutes(businessHoursPerDay.lunchStartValue.minutes);
+            offsetMinutes = startClosingMoment.diff(startMoment, 'minute');
+            startMoment.hours(businessHoursPerDay.lunchEndValue.hours - utcOffset);
+            startMoment.minutes(businessHoursPerDay.lunchEndValue.minutes);
+            start = startMoment.toDate();
+        }
+    } else {
+        if (startBhct === BusinessHoursCheckedType.onAm) {
+            startClosingMoment.hours(businessHoursPerDay.lunchStartValue.hours - utcOffset);
+            startClosingMoment.minutes(businessHoursPerDay.lunchStartValue.minutes);
+            offsetMinutes = startClosingMoment.diff(startMoment, 'minute');
+            startMoment.hours(businessHoursPerDay.lunchEndValue.hours - utcOffset);
+            startMoment.minutes(businessHoursPerDay.lunchEndValue.minutes);
+            start = startMoment.toDate();
+        } else {
+            startMoment = moment.utc(start);
+        }
+    }
+    startClosingMoment.hours(businessHoursPerDay.endValue.hours - utcOffset);
+    startClosingMoment.minutes(businessHoursPerDay.endValue.minutes);
+    offsetMinutes += startClosingMoment.diff(startMoment, 'minute');
+    const timeoutMinutes = timeoutHours * 60;
+    if (timeoutMinutes <= offsetMinutes) {
+        let subMinutes = offsetMinutes - timeoutMinutes;
+        if (subMinutes > 0) {
+            if (subMinutes >= businessHoursPerDay.computedPmMinutes) {
+                subMinutes += businessHoursPerDay.computedLunchMinutes;
+            }
+            startClosingMoment.subtract(subMinutes, 'm');
+        }
+        return startClosingMoment.toDate();
+    } else {
+        let nextMoment = startClosingMoment;
+        for (let i = 0; offsetMinutes < timeoutMinutes; i++) {
+            const nextBusinessDate = computeNextBusinessDate(nextMoment.toDate(), holidays, businessHours, digitsForHours);
+            if (nextBusinessDate) {
+                nextMoment = moment.utc(nextBusinessDate.end);
+                offsetMinutes += businessHoursPerDay.computedMinutes;
+            } else {
+                throw new Error("computeTimeoutDateWithoutHolidays:Maximum number of calls, The number of days in holidays may exceed 365.");
+            }
+        }
+        if (offsetMinutes > timeoutMinutes) {
+            let subMinutes = offsetMinutes - timeoutMinutes;
+            if (subMinutes >= businessHoursPerDay.computedPmMinutes) {
+                subMinutes += businessHoursPerDay.computedLunchMinutes;
+            }
+            nextMoment.subtract(subMinutes, 'm');
+            return nextMoment.toDate();
+        }
+        return nextMoment.toDate();
+    }
+}
+
+/**
+ * 计算在某个工作区下的节假日、工作时间数据基础上，以某个时间点开始，超时几个小时后，超时时间点是什么时候
+ * @param {Date} start
+ * @param {number} timeoutHours
+ * @param {string} spaceId
+ * @param {number} digitsForHours
+ * @returns {Promise<Date>}
+ */
+async function getTimeoutDateWithoutHolidays(start, timeoutHours, spaceId, digitsForHours = 2) {
+    let enableHolidays = false;
+    try {
+        const { getSteedosConfig } = require('@steedos/objectql');
+        const config = getSteedosConfig();
+        enableHolidays = !!config.enable_holidays;
+    } catch (e) {
+        // If config is not available, treat as holidays not enabled
+    }
+    if (!enableHolidays) {
+        return moment(start).add(timeoutHours, 'h').toDate();
+    }
+    const defaultBusinessHoursRecords = await getDefaultBusinessHours(spaceId);
+    const defaultBusinessHoursRecord = defaultBusinessHoursRecords && defaultBusinessHoursRecords[0];
+    if (!defaultBusinessHoursRecord) {
+        // 未配置工作时间，直接按未开启enable_holidays处理
+        return moment(start).add(timeoutHours, 'h').toDate();
+    }
+    const startUTCYear = start.getUTCFullYear();
+    const holidaysRecords = await getHolidays(spaceId, [startUTCYear, startUTCYear + 1]);
+    return computeTimeoutDateWithoutHolidays(start, timeoutHours, holidaysRecords, defaultBusinessHoursRecord, digitsForHours);
+}
+
+module.exports = {
+    getHolidays,
+    getDefaultBusinessHours,
+    getTimeoutDateWithoutHolidays,
+    computeTimeoutDateWithoutHolidays
+};