jnpf-bpmn-v6x/lib/utils/bpmnLintUtil.ts

import ElementRegistry from 'diagram-js/lib/core/ElementRegistry';
import { typeTask, typeTrigger } from '../config/variableName';
import { changeTypeByTaskShape } from '../config';
export class BpmnLintError {
  public element: any;
  public message: string;
  constructor(element: any | any[], message: string) {
    this.element = element;
    this.message = message;
  }
}

// 自定义bpmnLint规则
abstract class BpmnLintBase {
  protected registry: ElementRegistry;
  protected root: any;
  protected constructor(registry: ElementRegistry, root: any) {
    this.registry = registry;
    this.root = root;
  }
  public abstract validate(): boolean;
  protected error: BpmnLintError | undefined;
  public getError(): BpmnLintError | undefined {
    return this.error;
  }
}
/**
 * xml元素校验
 *  1.流程必须要有一个【开始，结束】节点 且只能有一个。
 *  2.至少有一个【审批】节点，
 *  3.分流网关和合流官网必须成对关系。
 *  4.除了开始节点（只有出线）及结束节点（只有进线） 其它节点必须要含有出线和入线。
 *  5.分流节点出线必须有多条出线，只有一条进线； 合流节点必须有多条进线，只能有一条出线。
 *
 */
let jnpfProps: any;
class FormValidator extends BpmnLintBase {
  public constructor(registry: ElementRegistry, root: any, props: any) {
    super(registry, root);
    jnpfProps = props;
  }
  validate(): boolean {
    let errorList: any = [];
    let allElements = this.root.children;
    if (allElements && allElements.length > 0) {
      let newElementData = allElements.reduce((classified: any, element: any) => {
        // 获取元素类型 (网关元素存在分流和合流 所以需要取 wnGatewayType)
        let elementType = (element.type === 'bpmn:InclusiveGateway' ? element.wnGatewayType : element.type)?.replace('bpmn:', '')?.toLowerCase();
        // 如果分类对象中不存在当前类型的数组，则创建一个新数组
        if (!classified[elementType]) classified[elementType] = [];
        // 将元素添加到相应类型的数组中
        classified[elementType].push(element);
        return classified;
      }, {});
      if (newElementData) {
        if (!(newElementData.hasOwnProperty('startevent') && newElementData.hasOwnProperty('endevent') && newElementData.hasOwnProperty('usertask'))) {
          this.error = new BpmnLintError(null, '确保画布上至少包含【开始-审批-结束】节点');
          return false;
        }
        // 开始节点
        if (newElementData['startevent']) {
          if (newElementData['startevent'].length > 1) {
            // 开始 结束节点只有拥有一个
            this.error = new BpmnLintError(null, '画布上只能存在一个开始节点');
            return false;
          }
          // 开始节点只能有一个出线
          if (newElementData['startevent'][0]) {
            let outLine = newElementData['startevent'][0].outgoing;
            let inLine = newElementData['startevent'][0].incoming; // 进线
            if (inLine && inLine.length > 0) {
              errorList.push({
                element: newElementData['startevent'][0],
                error: '开始节点不存在进线，请删除多余线条！',
              });
            }
            if (!outLine) {
              errorList.push({
                element: newElementData['startevent'][0],
                error: '开始元素不能单独使用，请于其它元素进行连线使用！',
              });
            }
          }
        }
        // 结束节点：
        if (newElementData['endevent']) {
          if (newElementData['endevent'].length > 1) {
            this.error = new BpmnLintError(null, '画布上只能存在一个结束节点，请删除多余节点元素！');
            return false;
          }
          // 结束节点只能有一个进线
          if (newElementData['endevent'][0]) {
            let outLine = newElementData['endevent'][0].outgoing;
            let inLine = newElementData['endevent'][0].incoming; // 进线
            if (outLine && outLine.length > 0) {
              errorList.push({
                element: newElementData['endevent'][0],
                error: '结束节点不存在出线，请删除多余线条！',
              });
            }
            if (!inLine) {
              errorList.push({
                element: newElementData['endevent'][0],
                error: '结束元素不能单独使用，请于其它元素进行连线使用！',
              });
            }
          }
        }
        // 网关
        if (newElementData.hasOwnProperty('confluence') || newElementData.hasOwnProperty('divide')) {
          if (!(newElementData['confluence'] && newElementData['confluence'].length && newElementData['divide'] && newElementData['divide'].length)) {
            this.error = new BpmnLintError(null, '请您检查分流与合流是否成对使用！');
            return false;
          }
        }
        // 任务节点
        if (newElementData['usertask']) {
          // 遍历进线元素 必须有一条进线及出线元素
          let userTaskList = newElementData['usertask'];
          userTaskList.map((userTaskShape: any) => {
            let outLine = userTaskShape.outgoing;
            let inLine = userTaskShape.incoming; // 进线
            // 任务节点必须要有一个进线和出线
            if (!(outLine?.length && inLine?.length)) {
              if (!changeTypeByTaskShape[userTaskShape?.wnType] || (jnpfProps.type === 2 && changeTypeByTaskShape[userTaskShape?.wnType])) {
                errorList.push({
                  element: userTaskShape,
                  error: '元素不能单独使用，请确保连接至少一个执行节点',
                });
              } else if (changeTypeByTaskShape[userTaskShape?.wnType] && !inLine?.length) {
                errorList.push({
                  element: userTaskShape,
                  error: '执行元素不能单独使用，请确保连接到触发节点',
                });
              }
            }
            if (userTaskShape?.wnType === typeTask) {
              // 如果任务节点只有触发节点 则报错 需要连接其它节点或者结束节点。
              if (outLine.every(s => s.target.wnType === typeTrigger))
                errorList.push({
                  element: userTaskShape,
                  error: '审批元素不能只包含触发节点, 请确保至少有一条出线与其他元素相连接',
                });
            }
          });
        }
        if (errorList && errorList.length > 0) {
          this.error = new BpmnLintError(errorList, errorList[0].error);
          return false;
        }
      }
    } else {
      this.error = new BpmnLintError(null, '画布上不存在元素，至少包含【开始-审批-结束】节点');
      return false;
    }
    return true;
  }
}

export function validate(registry: ElementRegistry, root: any, props: any): BpmnLintError | undefined {
  /***/
  const validators = [new FormValidator(registry, root, props)];

  for (let validator of validators) {
    if (!validator.validate()) {
      return validator.getError();
    }
  }
}