import { typeTask, typeTrigger } from '../config/variableName';
|
import { changeTypeByTaskShape } from '../config';
|
export class BpmnLintError {
|
element;
|
message;
|
constructor(element, message) {
|
this.element = element;
|
this.message = message;
|
}
|
}
|
class BpmnLintBase {
|
registry;
|
root;
|
constructor(registry, root) {
|
this.registry = registry;
|
this.root = root;
|
}
|
error;
|
getError() {
|
return this.error;
|
}
|
}
|
let jnpfProps;
|
class FormValidator extends BpmnLintBase {
|
constructor(registry, root, props) {
|
super(registry, root);
|
jnpfProps = props;
|
}
|
validate() {
|
let errorList = [];
|
let allElements = this.root.children;
|
if (allElements && allElements.length > 0) {
|
let newElementData = allElements.reduce((classified, element) => {
|
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) => {
|
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, root, props) {
|
const validators = [new FormValidator(registry, root, props)];
|
for (let validator of validators) {
|
if (!validator.validate()) {
|
return validator.getError();
|
}
|
}
|
}
|
