@tachybase/module-workflow 0.23.8

package/dist/server/features/manual/ManualInstruction.js

@@ -0,0 +1,152 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ManualInstruction_exports = {};
+__export(ManualInstruction_exports, {
+  default: () => ManualInstruction_default
+});
+module.exports = __toCommonJS(ManualInstruction_exports);
+var import_utils = require("@tachybase/utils");
+var import__ = require("../..");
+var import_forms = __toESM(require("./forms"));
+const MULTIPLE_ASSIGNED_MODE = {
+  SINGLE: Symbol("single"),
+  ALL: Symbol("all"),
+  ANY: Symbol("any"),
+  ALL_PERCENTAGE: Symbol("all percentage"),
+  ANY_PERCENTAGE: Symbol("any percentage")
+};
+const Modes = {
+  [MULTIPLE_ASSIGNED_MODE.SINGLE]: {
+    getStatus(distribution, assignees) {
+      const done = distribution.find((item) => item.status !== import__.JOB_STATUS.PENDING && item.count > 0);
+      return done ? done.status : null;
+    }
+  },
+  [MULTIPLE_ASSIGNED_MODE.ALL]: {
+    getStatus(distribution, assignees) {
+      const resolved = distribution.find((item) => item.status === import__.JOB_STATUS.RESOLVED);
+      if (resolved && resolved.count === assignees.length) {
+        return import__.JOB_STATUS.RESOLVED;
+      }
+      const rejected = distribution.find((item) => item.status < import__.JOB_STATUS.PENDING);
+      if (rejected && rejected.count) {
+        return rejected.status;
+      }
+      return null;
+    }
+  },
+  [MULTIPLE_ASSIGNED_MODE.ANY]: {
+    getStatus(distribution, assignees) {
+      const resolved = distribution.find((item) => item.status === import__.JOB_STATUS.RESOLVED);
+      if (resolved && resolved.count) {
+        return import__.JOB_STATUS.RESOLVED;
+      }
+      const rejectedCount = distribution.reduce(
+        (count, item) => item.status < import__.JOB_STATUS.PENDING ? count + item.count : count,
+        0
+      );
+      if (rejectedCount === assignees.length) {
+        return import__.JOB_STATUS.REJECTED;
+      }
+      return null;
+    }
+  }
+};
+function getMode(mode) {
+  switch (true) {
+    case mode === 1:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ALL];
+    case mode === -1:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ANY];
+    case mode > 0:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ALL_PERCENTAGE];
+    case mode < 0:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ANY_PERCENTAGE];
+    default:
+      return Modes[MULTIPLE_ASSIGNED_MODE.SINGLE];
+  }
+}
+class ManualInstruction_default extends import__.Instruction {
+  constructor(workflow) {
+    super(workflow);
+    this.workflow = workflow;
+    (0, import_forms.default)(this);
+  }
+  formTypes = new import_utils.Registry();
+  async run(node, prevJob, processor) {
+    const { mode, ...config } = node.config;
+    const assignees = [...new Set(processor.getParsedValue(config.assignees, node.id).flat().filter(Boolean))];
+    const job = await processor.saveJob({
+      status: import__.JOB_STATUS.PENDING,
+      result: mode ? [] : null,
+      nodeId: node.id,
+      nodeKey: node.key,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    const UserJobModel = this.workflow.app.db.getModel("users_jobs");
+    await UserJobModel.bulkCreate(
+      assignees.map((userId) => ({
+        userId,
+        jobId: job.id,
+        nodeId: node.id,
+        executionId: job.executionId,
+        workflowId: node.workflowId,
+        status: import__.JOB_STATUS.PENDING
+      })),
+      {
+        // transaction: processor.transaction,
+      }
+    );
+    return job;
+  }
+  async resume(node, job, processor) {
+    var _a;
+    const { mode } = node.config;
+    const assignees = [...new Set(processor.getParsedValue(node.config.assignees, node.id).flat().filter(Boolean))];
+    const UserJobModel = this.workflow.app.db.getModel("users_jobs");
+    const distribution = await UserJobModel.count({
+      where: {
+        jobId: job.id
+      },
+      group: ["status"]
+      // transaction: processor.transaction,
+    });
+    const submitted = distribution.reduce(
+      (count, item) => item.status !== import__.JOB_STATUS.PENDING ? count + item.count : count,
+      0
+    );
+    const status = job.status || (getMode(mode).getStatus(distribution, assignees) ?? import__.JOB_STATUS.PENDING);
+    const result = mode ? (submitted || 0) / assignees.length : ((_a = job.latestUserJob) == null ? void 0 : _a.result) ?? job.result;
+    processor.logger.debug(`manual resume job and next status: ${status}`);
+    job.set({
+      status,
+      result
+    });
+    return job;
+  }
+}

package/dist/server/features/manual/Plugin.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from '@tachybase/server';
+export declare class PluginManual extends Plugin {
+    load(): Promise<void>;
+}

package/dist/server/features/manual/Plugin.js

@@ -0,0 +1,70 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Plugin_exports = {};
+__export(Plugin_exports, {
+  PluginManual: () => PluginManual
+});
+module.exports = __toCommonJS(Plugin_exports);
+var import_actions = __toESM(require("@tachybase/actions"));
+var import_server = require("@tachybase/server");
+var import__ = __toESM(require("../.."));
+var import_actions2 = require("./actions");
+var import_ManualInstruction = __toESM(require("./ManualInstruction"));
+class PluginManual extends import_server.Plugin {
+  async load() {
+    this.app.resourcer.define({
+      name: "users_jobs",
+      actions: {
+        list: {
+          filter: {
+            $or: [
+              {
+                "workflow.enabled": true
+              },
+              {
+                "workflow.enabled": false,
+                status: {
+                  $ne: import__.JOB_STATUS.PENDING
+                }
+              }
+            ]
+          },
+          handler: import_actions.default.list
+        },
+        submit: import_actions2.submit
+      }
+    });
+    this.app.acl.allow("users_jobs", ["list", "get", "submit"], "loggedIn");
+    const workflowPlugin = this.app.pm.get(import__.default);
+    workflowPlugin.registerInstruction("manual", import_ManualInstruction.default);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginManual
+});

package/dist/server/features/manual/actions.d.ts

@@ -0,0 +1,2 @@
+import { Context } from '@tachybase/actions';
+export declare function submit(context: Context, next: any): Promise<never>;

package/dist/server/features/manual/actions.js

@@ -0,0 +1,104 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var actions_exports = {};
+__export(actions_exports, {
+  submit: () => submit
+});
+module.exports = __toCommonJS(actions_exports);
+var import_actions = require("@tachybase/actions");
+var import__ = __toESM(require("../.."));
+async function submit(context, next) {
+  var _a, _b, _c;
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk, values } = context.action.params;
+  const { currentUser } = context.state;
+  if (!currentUser) {
+    return context.throw(401);
+  }
+  const plugin = context.app.getPlugin(import__.default);
+  const instruction = plugin.instructions.get("manual");
+  const userJob = await repository.findOne({
+    filterByTk,
+    // filter: {
+    //   userId: currentUser?.id
+    // },
+    appends: ["job", "node", "execution", "workflow"],
+    context
+  });
+  if (!userJob) {
+    return context.throw(404);
+  }
+  const { forms = {} } = userJob.node.config;
+  const [formKey] = Object.keys(values.result ?? {}).filter((key) => key !== "_");
+  const actionKey = (_a = values.result) == null ? void 0 : _a._;
+  const actionItem = (_c = (_b = forms[formKey]) == null ? void 0 : _b.actions) == null ? void 0 : _c.find((item) => item.key === actionKey);
+  if (userJob.status !== import__.JOB_STATUS.PENDING || userJob.job.status !== import__.JOB_STATUS.PENDING || userJob.execution.status !== import__.EXECUTION_STATUS.STARTED || !userJob.workflow.enabled || !actionKey || (actionItem == null ? void 0 : actionItem.status) == null) {
+    return context.throw(400);
+  }
+  userJob.execution.workflow = userJob.workflow;
+  const processor = plugin.createProcessor(userJob.execution);
+  await processor.prepare();
+  const assignees = processor.getParsedValue(userJob.node.config.assignees ?? [], userJob.nodeId).flat().filter(Boolean);
+  if (!assignees.includes(currentUser.id) || userJob.userId !== currentUser.id) {
+    return context.throw(403);
+  }
+  const presetValues = processor.getParsedValue(actionItem.values ?? {}, userJob.nodeId, {
+    // @deprecated
+    currentUser,
+    // @deprecated
+    currentRecord: values.result[formKey],
+    // @deprecated
+    currentTime: /* @__PURE__ */ new Date(),
+    $user: currentUser,
+    $nForm: values.result[formKey],
+    $nDate: {
+      now: /* @__PURE__ */ new Date()
+    }
+  });
+  userJob.set({
+    status: actionItem.status,
+    result: actionItem.status > import__.JOB_STATUS.PENDING ? { [formKey]: Object.assign(values.result[formKey], presetValues), _: actionKey } : Object.assign(userJob.result ?? {}, values.result)
+  });
+  const handler = instruction.formTypes.get(forms[formKey].type);
+  if (handler && userJob.status) {
+    await handler.call(instruction, userJob, forms[formKey], processor);
+  }
+  await userJob.save();
+  await processor.exit();
+  context.body = userJob;
+  context.status = 202;
+  await next();
+  userJob.job.execution = userJob.execution;
+  userJob.job.latestUserJob = userJob;
+  processor.logger.info(`manual node (${userJob.nodeId}) action trigger execution (${userJob.execution.id}) to resume`);
+  plugin.resume(userJob.job);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  submit
+});

package/dist/server/features/manual/forms/create.d.ts

@@ -0,0 +1,6 @@
+import { Processor } from '../../..';
+import ManualInstruction from '../ManualInstruction';
+export default function (this: ManualInstruction, instance: any, { dataSource, collection }: {
+    dataSource?: string;
+    collection: any;
+}, processor: Processor): Promise<void>;

package/dist/server/features/manual/forms/create.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var create_exports = {};
+__export(create_exports, {
+  default: () => create_default
+});
+module.exports = __toCommonJS(create_exports);
+async function create_default(instance, { dataSource = "main", collection }, processor) {
+  const repo = this.workflow.app.dataSourceManager.dataSources.get(dataSource).collectionManager.getRepository(collection);
+  if (!repo) {
+    throw new Error(`collection ${collection} for create data on manual node not found`);
+  }
+  const { _, ...form } = instance.result;
+  const [values] = Object.values(form);
+  await repo.create({
+    values: {
+      ...values ?? {},
+      createdBy: instance.userId,
+      updatedBy: instance.userId
+    },
+    context: {
+      executionId: processor.execution.id
+    },
+    transaction: processor.transaction
+  });
+}

package/dist/server/features/manual/forms/index.d.ts

@@ -0,0 +1,6 @@
+import { Processor } from '../../..';
+import ManualInstruction from '../ManualInstruction';
+export type FormHandler = (this: ManualInstruction, instance: any, formConfig: any, processor: Processor) => Promise<void>;
+export default function ({ formTypes }: {
+    formTypes: any;
+}): void;

package/dist/server/features/manual/forms/index.js

@@ -0,0 +1,38 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var forms_exports = {};
+__export(forms_exports, {
+  default: () => forms_default
+});
+module.exports = __toCommonJS(forms_exports);
+var import_create = __toESM(require("./create"));
+var import_update = __toESM(require("./update"));
+function forms_default({ formTypes }) {
+  formTypes.register("create", import_create.default);
+  formTypes.register("update", import_update.default);
+}

package/dist/server/features/manual/forms/update.d.ts

@@ -0,0 +1,7 @@
+import { Processor } from '../../..';
+import ManualInstruction from '../ManualInstruction';
+export default function (this: ManualInstruction, instance: any, { dataSource, collection, filter }: {
+    dataSource?: string;
+    collection: any;
+    filter?: {};
+}, processor: Processor): Promise<void>;

package/dist/server/features/manual/forms/update.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var update_exports = {};
+__export(update_exports, {
+  default: () => update_default
+});
+module.exports = __toCommonJS(update_exports);
+async function update_default(instance, { dataSource = "main", collection, filter = {} }, processor) {
+  const repo = this.workflow.app.dataSourceManager.dataSources.get(dataSource).collectionManager.getRepository(collection);
+  if (!repo) {
+    throw new Error(`collection ${collection} for update data on manual node not found`);
+  }
+  const { _, ...form } = instance.result;
+  const [values] = Object.values(form);
+  await repo.update({
+    filter: processor.getParsedValue(filter, instance.nodeId),
+    values: {
+      ...values ?? {},
+      updatedBy: instance.userId
+    },
+    context: {
+      executionId: processor.execution.id
+    },
+    transaction: processor.transaction
+  });
+}

package/dist/server/features/notice/NoticeInstruction.d.ts

@@ -0,0 +1,9 @@
+import Instruction from '../../instructions';
+declare class NoticeInstruction extends Instruction {
+    run(node: any, prevJob: any, processor: any): Promise<any>;
+    resume(node: any, job: any, processor: any): Promise<any>;
+    duplicateConfig(node: any, { transaction }: {
+        transaction: any;
+    }): Promise<any>;
+}
+export default NoticeInstruction;

package/dist/server/features/notice/NoticeInstruction.js

@@ -0,0 +1,172 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NoticeInstruction_exports = {};
+__export(NoticeInstruction_exports, {
+  default: () => NoticeInstruction_default
+});
+module.exports = __toCommonJS(NoticeInstruction_exports);
+var import_utils = require("@tachybase/utils");
+var import_constants = require("../../constants");
+var import_instructions = __toESM(require("../../instructions"));
+var import_constants2 = require("../common/constants");
+var import_constants3 = require("./constants");
+var import_tools = require("./tools");
+class NoticeInstruction extends import_instructions.default {
+  async run(node, prevJob, processor) {
+    const job = await processor.saveJob({
+      status: import_constants.JOB_STATUS.RESOLVED,
+      nodeId: node.id,
+      nodeKey: node.key,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    const notifiedPerson = await (0, import_tools.parsePerson)(node, processor);
+    if (notifiedPerson && notifiedPerson.length > 0) {
+      const { db } = processor.options.plugin;
+      const ApprovalRepo = db.getRepository("approvals");
+      const approval = await ApprovalRepo.findOne({
+        filter: {
+          "executions.id": processor.execution.id
+        },
+        fields: ["id", "status", "data", "summary", "collectionName"],
+        appends: ["approvalExecutions"],
+        except: ["data"]
+      });
+      const NoticeModel = db.getModel(import_constants2.COLLECTION_NOTICE_NAME);
+      const notifiedPersonMapData = notifiedPerson.map((userId, index) => ({
+        userId,
+        jobId: job.id,
+        nodeId: node.id,
+        executionId: job.executionId,
+        workflowId: node.workflowId,
+        index,
+        status: node.config.order && index ? import_constants3.NOTICE_ACTION_STATUS.ASSIGNED : import_constants3.NOTICE_ACTION_STATUS.APPROVED,
+        snapshot: approval.data,
+        summary: approval.summary,
+        collectionName: approval.collectionName,
+        dataKey: approval.dataKey
+      }));
+      await NoticeModel.bulkCreate(notifiedPersonMapData, {
+        transaction: processor.transaction
+      });
+    }
+    this.workflow.noticeManager.notify("workflow:regular", { msg: "done" });
+    return job;
+  }
+  // NOTE: 目前没有用处, 不过留着作为未来如果有动作的实现的参考
+  async resume(node, job, processor) {
+    if (job.nodeId !== node.id) {
+      const nodeJob = processor.findBranchParentJob(job, node);
+      if (job.status === import_constants.JOB_STATUS.RESOLVED) {
+        const jobNode = processor.nodesMap.get(job.nodeId);
+        const branchStart = processor.findBranchStartNode(jobNode);
+        if (branchStart.branchIndex === import_constants3.NOTICE_ACTION_STATUS.RETURNED) {
+          nodeJob.set("status", import_constants.JOB_STATUS.RETRY_NEEDED);
+        } else if (branchStart.branchIndex === import_constants3.NOTICE_ACTION_STATUS.REJECTED && node.config.endOnReject) {
+          nodeJob.set("status", import_constants.JOB_STATUS.REJECTED);
+        }
+        return nodeJob;
+      }
+      return processor.exit(job.status);
+    }
+    const { branchMode, negotiation, order } = node.config;
+    const notifiedPerson = await (0, import_tools.parsePerson)(node, processor);
+    const NoticeRepo = this.workflow.app.db.getRepository(import_constants2.COLLECTION_NOTICE_NAME);
+    const records = await NoticeRepo.find({
+      filter: {
+        jobId: job.id
+      },
+      except: ["snapshot"],
+      sort: ["index"],
+      transaction: processor.transaction
+    });
+    const distribution = records.reduce((prev, record) => {
+      const item = prev.find((item2) => item2.status === record.status);
+      if (item) {
+        item.count += 1;
+      } else {
+        prev.push({
+          status: record.status,
+          count: 1
+        });
+      }
+      return prev;
+    }, []);
+    const processing = Boolean(distribution.find((item) => item.status !== import_constants3.NOTICE_ACTION_STATUS.PENDING));
+    const status = job.status || ((0, import_tools.getNegotiationMode)(negotiation).getStatus(distribution, notifiedPerson, negotiation) ?? import_constants.JOB_STATUS.PENDING);
+    const result = import_tools.NoticeJobStatusMap[status];
+    processor.logger.debug(`notice resume job and next status: ${status}`);
+    job.set({
+      status: status && status !== import_constants.JOB_STATUS.CANCELED ? branchMode ? import_constants.JOB_STATUS.RESOLVED : status : status,
+      result
+    });
+    if (status && status !== import_constants.JOB_STATUS.CANCELED || negotiation && processing) {
+      await job.latestUserJob.approval.update(
+        {
+          status: import_constants3.NOTICE_STATUS.PROCESSING
+        },
+        { transaction: processor.transaction }
+      );
+    }
+    const nextPerson = notifiedPerson[notifiedPerson.indexOf(job.latestUserJob.userId) + 1];
+    if (!status && negotiation && order && nextPerson) {
+      await NoticeRepo.update({
+        values: {
+          status: import_constants3.NOTICE_ACTION_STATUS.PENDING
+        },
+        filter: {
+          jobId: job.id,
+          userId: nextPerson
+        },
+        transaction: processor.transaction
+      });
+    }
+    if (branchMode) {
+      const branchNode = processor.nodes.find((item) => item.upstream === node && item.branchIndex === result);
+      if (branchNode) {
+        await processor.saveJob(job);
+        await processor.run(branchNode, job);
+        return null;
+      }
+    }
+    return job;
+  }
+  async duplicateConfig(node, { transaction }) {
+    const uiSchemaRepo = this.workflow.app.db.getRepository("uiSchemas");
+    if (!node.config.showNoticeDetail) {
+      return node.config;
+    }
+    const result = await uiSchemaRepo.duplicate(node.config.showNoticeDetail, {
+      transaction
+    });
+    return {
+      ...node.config,
+      showNoticeDetail: (result == null ? void 0 : result["x-uid"]) ?? (0, import_utils.uid)()
+    };
+  }
+}
+var NoticeInstruction_default = NoticeInstruction;

package/dist/server/features/notice/actions.d.ts

@@ -0,0 +1,3 @@
+export declare function init({ app }: {
+    app: any;
+}): void;