@tachybase/plugin-workflow-approval 0.23.8

package/dist/server/collections/approvals.js

@@ -0,0 +1,96 @@
+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 approvals_exports = {};
+__export(approvals_exports, {
+  default: () => approvals_default
+});
+module.exports = __toCommonJS(approvals_exports);
+var import_database = require("@tachybase/database");
+var approvals_default = (0, import_database.defineCollection)({
+  namespace: "workflow.approvals",
+  dumpRules: "required",
+  name: "approvals",
+  createdBy: true,
+  updatedBy: true,
+  fields: [
+    {
+      type: "string",
+      name: "collectionName"
+    },
+    {
+      type: "string",
+      name: "dataKey"
+    },
+    {
+      type: "belongsTo",
+      name: "workflow",
+      onDelete: "CASCADE"
+    },
+    {
+      type: "string",
+      name: "workflowKey"
+    },
+    {
+      type: "belongsToMany",
+      name: "executions",
+      through: "approvalExecutions",
+      targetKey: "id",
+      sourceKey: "id",
+      foreignKey: "approvalId",
+      otherKey: "executionId"
+    },
+    {
+      type: "hasMany",
+      name: "approvalExecutions",
+      target: "approvalExecutions",
+      onDelete: "CASCADE"
+    },
+    {
+      type: "belongsTo",
+      name: "latestApprovalExecution",
+      target: "approvalExecutions",
+      foreignKey: "latestExecutionId"
+    },
+    {
+      type: "hasMany",
+      name: "records",
+      target: "approvalRecords",
+      onDelete: "CASCADE"
+    },
+    {
+      type: "integer",
+      name: "status"
+    },
+    {
+      type: "json",
+      name: "data",
+      defaultValue: {}
+    },
+    {
+      type: "jsonb",
+      name: "summary",
+      defaultValue: {}
+    },
+    {
+      type: "belongsTo",
+      name: "applicantRole",
+      foreignKey: "applicantRoleName",
+      target: "roles"
+    }
+  ]
+});

package/dist/server/constants/error-code.d.ts

@@ -0,0 +1,22 @@
+export declare const ERROR_CODE_MAP: {
+    not_enable_workflow: {
+        code: number;
+        message: string;
+    };
+    execution_finished: {
+        code: number;
+        message: string;
+    };
+    job_finished: {
+        code: number;
+        message: string;
+    };
+    not_approval_pending: {
+        code: number;
+        message: string;
+    };
+    not_need_update: {
+        code: number;
+        message: string;
+    };
+};

package/dist/server/constants/error-code.js

@@ -0,0 +1,48 @@
+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 error_code_exports = {};
+__export(error_code_exports, {
+  ERROR_CODE_MAP: () => ERROR_CODE_MAP
+});
+module.exports = __toCommonJS(error_code_exports);
+const ERROR_CODE_MAP = {
+  ["not_enable_workflow"]: {
+    code: 9e3,
+    message: "not_enable_workflow"
+  },
+  ["execution_finished"]: {
+    code: 9001,
+    message: "execution_finished"
+  },
+  ["job_finished"]: {
+    code: 9002,
+    message: "job_finished"
+  },
+  ["not_approval_pending"]: {
+    code: 9003,
+    message: "not_approval_pending"
+  },
+  ["not_need_update"]: {
+    code: 9004,
+    message: "not_need_update"
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ERROR_CODE_MAP
+});

package/dist/server/constants/status.d.ts

@@ -0,0 +1,20 @@
+/** 审批发起的状态 */
+export declare const APPROVAL_STATUS: {
+    DRAFT: number;
+    RETURNED: number;
+    SUBMITTED: number;
+    PROCESSING: number;
+    APPROVED: number;
+    RESUBMIT: number;
+    REJECTED: number;
+    ERROR: number;
+};
+/** 审批执行的状态 */
+export declare const APPROVAL_ACTION_STATUS: {
+    ASSIGNED: any;
+    PENDING: number;
+    RETURNED: number;
+    APPROVED: number;
+    REJECTED: number;
+    CANCELED: number;
+};

package/dist/server/constants/status.js

@@ -0,0 +1,46 @@
+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 status_exports = {};
+__export(status_exports, {
+  APPROVAL_ACTION_STATUS: () => APPROVAL_ACTION_STATUS,
+  APPROVAL_STATUS: () => APPROVAL_STATUS
+});
+module.exports = __toCommonJS(status_exports);
+const APPROVAL_STATUS = {
+  DRAFT: 0,
+  RETURNED: 1,
+  SUBMITTED: 2,
+  PROCESSING: 3,
+  APPROVED: 4,
+  RESUBMIT: 5,
+  REJECTED: -1,
+  ERROR: -2
+};
+const APPROVAL_ACTION_STATUS = {
+  ASSIGNED: null,
+  PENDING: 0,
+  RETURNED: 1,
+  APPROVED: 2,
+  REJECTED: -1,
+  CANCELED: -2
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APPROVAL_ACTION_STATUS,
+  APPROVAL_STATUS
+});

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export { default } from './plugin';

package/dist/server/index.js

@@ -0,0 +1,33 @@
+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 server_exports = {};
+__export(server_exports, {
+  default: () => import_plugin.default
+});
+module.exports = __toCommonJS(server_exports);
+var import_plugin = __toESM(require("./plugin"));

package/dist/server/instructions/Approval.d.ts

@@ -0,0 +1,9 @@
+import { Instruction } from '@tachybase/module-workflow';
+/** 工作流节点:审批节点  */
+export default class ApprovalInstruction 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>;
+}

package/dist/server/instructions/Approval.js

@@ -0,0 +1,220 @@
+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 Approval_exports = {};
+__export(Approval_exports, {
+  default: () => ApprovalInstruction
+});
+module.exports = __toCommonJS(Approval_exports);
+var import_data_source = require("@tachybase/data-source");
+var import_module_workflow = require("@tachybase/module-workflow");
+var import_utils = require("@tachybase/utils");
+var import_status = require("../constants/status");
+var import_Approval = __toESM(require("../triggers/Approval"));
+var import_tools = require("./tools");
+class ApprovalInstruction extends import_module_workflow.Instruction {
+  async run(node, prevJob, processor) {
+    const job = await processor.saveJob({
+      status: import_module_workflow.JOB_STATUS.PENDING,
+      nodeId: node.id,
+      nodeKey: node.key,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    const assignees = await (0, import_tools.parseAssignees)(node, processor);
+    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", "createdBy"],
+      except: ["data"]
+    });
+    const approvalExecution = approval.approvalExecutions.find((item) => item.executionId === processor.execution.id);
+    if ([import_status.APPROVAL_STATUS.RESUBMIT, import_status.APPROVAL_STATUS.DRAFT].includes(approval.status)) {
+      return job;
+    }
+    const RecordModel = db.getModel("approvalRecords");
+    await RecordModel.bulkCreate(
+      assignees.map((userId, index) => {
+        var _a;
+        return {
+          approvalId: approval.id,
+          approvalExecutionId: approvalExecution.id,
+          createdById: (_a = approval.createdBy) == null ? void 0 : _a.id,
+          userId,
+          jobId: job.id,
+          nodeId: node.id,
+          executionId: job.executionId,
+          workflowId: node.workflowId,
+          index,
+          status: node.config.order && index ? import_status.APPROVAL_ACTION_STATUS.ASSIGNED : import_status.APPROVAL_ACTION_STATUS.PENDING,
+          snapshot: approvalExecution.snapshot,
+          summary: approval.summary,
+          collectionName: approval.collectionName
+        };
+      }),
+      {
+        transaction: processor.transaction
+      }
+    );
+    for (const userId of assignees) {
+      const message = {
+        userId,
+        title: '{{t("Approval", { ns: "@tachybase/plugin-workflow-approval" })}}',
+        content: "",
+        collectionName: approval.collectionName,
+        jsonContent: approval.summary,
+        schemaName: node.config.applyDetail
+      };
+      this.workflow.app.messageManager.sendMessage(+userId, message);
+    }
+    return job;
+  }
+  async resume(node, job, processor) {
+    if (job.nodeId !== node.id) {
+      const nodeJob = processor.findBranchParentJob(job, node);
+      if (job.status === import_module_workflow.JOB_STATUS.RESOLVED) {
+        const jobNode = processor.nodesMap.get(job.nodeId);
+        const branchStart = processor.findBranchStartNode(jobNode);
+        if (branchStart.branchIndex === import_status.APPROVAL_ACTION_STATUS.RETURNED) {
+          nodeJob.set("status", import_module_workflow.JOB_STATUS.RETRY_NEEDED);
+        } else if (branchStart.branchIndex === import_status.APPROVAL_ACTION_STATUS.REJECTED && node.config.endOnReject) {
+          nodeJob.set("status", import_module_workflow.JOB_STATUS.REJECTED);
+        }
+        return nodeJob;
+      }
+      return processor.exit(job.status);
+    }
+    const { branchMode, negotiation, order } = node.config;
+    const assignees = await (0, import_tools.parseAssignees)(node, processor);
+    const RecordRepo = this.workflow.app.db.getRepository("approvalRecords");
+    const records = await RecordRepo.find({
+      filter: {
+        jobId: job.id
+      },
+      appends: ["approval"],
+      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_status.APPROVAL_ACTION_STATUS.PENDING));
+    const status = (0, import_tools.getNegotiationMode)(+negotiation).getStatus(distribution, assignees, negotiation) ?? import_module_workflow.JOB_STATUS.PENDING;
+    const result = import_tools.ApprovalJobStatusMap[status];
+    processor.logger.debug(`approval resume job and next status: ${status}`);
+    job.set({
+      status: status && status !== import_module_workflow.JOB_STATUS.CANCELED ? branchMode ? import_module_workflow.JOB_STATUS.RESOLVED : status : status,
+      result
+    });
+    if (status && status !== import_module_workflow.JOB_STATUS.CANCELED || negotiation && processing) {
+      await job.latestUserJob.approval.update(
+        {
+          status: import_status.APPROVAL_STATUS.PROCESSING
+        },
+        { transaction: processor.transaction }
+      );
+    }
+    const nextAssignee = assignees[assignees.indexOf(job.latestUserJob.userId) + 1];
+    if (!status && negotiation && order && nextAssignee) {
+      await RecordRepo.update({
+        values: {
+          status: import_status.APPROVAL_ACTION_STATUS.PENDING
+        },
+        filter: {
+          jobId: job.id,
+          userId: nextAssignee
+        },
+        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;
+      }
+    }
+    try {
+      const approval = records[0].approval;
+      const [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(approval.collectionName);
+      const { repository } = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+      const workflow = await approval.getWorkflow({
+        where: {
+          id: approval.get("workflowId"),
+          type: import_Approval.default.TYPE,
+          enabled: true,
+          "config.collection": approval.collectionName
+        },
+        transaction: processor.transaction
+      });
+      const data = await repository.findOne({
+        filterByTk: approval.get("dataKey"),
+        appends: workflow.config.appends,
+        transaction: this.workflow.useDataSourceTransaction(dataSourceName, processor.transaction)
+      });
+      await RecordRepo.update({
+        values: {
+          snapshot: (0, import_module_workflow.toJSON)(data)
+        },
+        filter: {
+          jobId: job.id
+        },
+        transaction: processor.transaction
+      });
+    } catch (error) {
+      console.log("%c Line:269 \u{1F95B} error", error);
+    }
+    return job;
+  }
+  async duplicateConfig(node, { transaction }) {
+    const uiSchemaRepo = this.workflow.app.db.getRepository("uiSchemas");
+    if (!node.config.applyDetail) {
+      return node.config;
+    }
+    const result = await uiSchemaRepo.duplicate(node.config.applyDetail, {
+      transaction
+    });
+    return {
+      ...node.config,
+      applyDetail: (result == null ? void 0 : result["x-uid"]) ?? (0, import_utils.uid)()
+    };
+  }
+}

package/dist/server/instructions/ApprovalCarbonCopy.d.ts

@@ -0,0 +1,8 @@
+import { Instruction } from '@tachybase/module-workflow';
+/** 工作流节点: 审批抄送节点 */
+export default class ApprovalCarbonCopyInstruction extends Instruction {
+    run(node: any, prevJob: any, processor: any): Promise<any>;
+    duplicateConfig(node: any, { transaction }: {
+        transaction: any;
+    }): Promise<any>;
+}

package/dist/server/instructions/ApprovalCarbonCopy.js

@@ -0,0 +1,99 @@
+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 ApprovalCarbonCopy_exports = {};
+__export(ApprovalCarbonCopy_exports, {
+  default: () => ApprovalCarbonCopyInstruction
+});
+module.exports = __toCommonJS(ApprovalCarbonCopy_exports);
+var import_module_workflow = require("@tachybase/module-workflow");
+var import_collection_name = require("../../common/collection-name");
+var import_status = require("../constants/status");
+var import_tools = require("../tools");
+class ApprovalCarbonCopyInstruction extends import_module_workflow.Instruction {
+  async run(node, prevJob, processor) {
+    const job = await processor.saveJob({
+      status: import_module_workflow.JOB_STATUS.RESOLVED,
+      nodeId: node.id,
+      nodeKey: node.key,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    const targetPersonList = await (0, import_tools.parsePerson)({ node, processor, keyName: "carbonCopyPerson" });
+    if (targetPersonList && targetPersonList.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", "createdBy"],
+        except: ["data"]
+      });
+      if ([import_status.APPROVAL_STATUS.SUBMITTED].includes(approval.status)) {
+        const CarbonCopyModel = db.getModel(import_collection_name.COLLECTION_NAME_APPROVAL_CARBON_COPY);
+        const notifiedPersonDataMap = targetPersonList.map((userId, index) => {
+          var _a;
+          return {
+            userId,
+            jobId: job.id,
+            nodeId: node.id,
+            executionId: job.executionId,
+            workflowId: node.workflowId,
+            index,
+            createdById: (_a = approval.createdBy) == null ? void 0 : _a.id,
+            approvalId: approval.id,
+            status: approval.status,
+            snapshot: approval.data,
+            summary: approval.summary,
+            collectionName: approval.collectionName,
+            dataKey: approval.dataKey
+          };
+        });
+        await CarbonCopyModel.bulkCreate(notifiedPersonDataMap, {
+          transaction: processor.transaction
+        });
+        for (const userId of targetPersonList) {
+          const message = {
+            userId,
+            title: '{{t("Approval Carbon Copy", { ns: "@tachybase/plugin-workflow-approval" })}}',
+            content: "",
+            jsonContent: approval.summary,
+            collectionName: approval.collectionName,
+            schemaName: node.config.showCarbonCopyDetail
+          };
+          this.workflow.app.messageManager.sendMessage(+userId, message);
+        }
+      }
+    }
+    return job;
+  }
+  async duplicateConfig(node, { transaction }) {
+    const keyName = "showCarbonCopyDetail";
+    const uiSchemaRepo = this.workflow.app.db.getRepository("uiSchemas");
+    if (!node.config[keyName]) {
+      return node.config;
+    }
+    const resultSchema = await uiSchemaRepo.duplicate(node.config[keyName], {
+      transaction
+    });
+    return {
+      ...node.config,
+      [keyName]: resultSchema == null ? void 0 : resultSchema["x-uid"]
+    };
+  }
+}

package/dist/server/instructions/tools.d.ts

@@ -0,0 +1,11 @@
+export declare const ApprovalJobStatusMap: {
+    0: number;
+    1: number;
+    [-5]: number;
+    [-6]: number;
+    [-4]: number;
+};
+export declare function getNegotiationMode(mode: any): {
+    getStatus(distribution: any, assignees: any, mode: any): number;
+};
+export declare function parseAssignees(node: any, processor: any): Promise<unknown[]>;