@5minds/processcube_engine
Version:
The ProcessCube Engine. Stores and executes BPMNs.
218 lines • 11.3 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.TimerFacade = void 0;
const cron_parser_1 = __importDefault(require("cron-parser"));
const dayjs_1 = __importDefault(require("dayjs"));
const inversify_1 = require("inversify");
const node_schedule_1 = __importDefault(require("node-schedule"));
const uuid = __importStar(require("uuid"));
const processcube_engine_sdk_1 = require("@5minds/processcube_engine_sdk");
const EventAggregator_1 = __importDefault(require("../../Tools/EventAggregator"));
let TimerFacade = class TimerFacade {
logger;
constructor() {
this.logger = new processcube_engine_sdk_1.Logger('timer_facade');
}
initializeTimer(flowNodeId, timerType, timerValue, timerCallback, flowNode, timerStartedDate) {
const timerExpiredEventName = `${flowNodeId}_${uuid.v4()}`;
switch (timerType) {
case processcube_engine_sdk_1.Model.Events.TimerType.timeCycle:
return this.startCycleTimer(timerValue, timerCallback, timerExpiredEventName, flowNode);
case processcube_engine_sdk_1.Model.Events.TimerType.timeDate:
return this.startDateTimer(timerValue, timerCallback, timerExpiredEventName);
case processcube_engine_sdk_1.Model.Events.TimerType.timeDuration:
return this.startDurationTimer(timerValue, timerCallback, timerExpiredEventName, timerStartedDate);
default:
return undefined;
}
}
startCycleTimer(timerValue, timerCallback, timerExpiredEventName, flowNode) {
this.logger.debug(`Starting new cyclic timer with definition ${timerValue} and event name ${timerExpiredEventName}`);
if (!timerCallback) {
this.logger.error('Must provide a callback when initializing a new timer!');
throw new processcube_engine_sdk_1.BadRequestError('Must provide a callback when initializing a new timer!');
}
this.validateCyclicTimer(timerValue, flowNode);
const subscription = EventAggregator_1.default.subscribe(timerExpiredEventName, (eventPayload, eventName) => {
this.logger.debug(`Cyclic timer ${eventName} has expired. Executing callback.`);
timerCallback(eventPayload);
});
const job = this.createTimer(processcube_engine_sdk_1.Model.Events.TimerType.timeCycle, timerValue, timerExpiredEventName);
return {
...subscription,
eventName: timerExpiredEventName,
job: job,
};
}
startDateTimer(timerValue, timerCallback, timerExpiredEventName) {
this.logger.debug(`Starting new date timer with definition ${timerValue} and event name ${timerExpiredEventName}`);
if (!timerCallback) {
this.logger.error('Must provide a callback when initializing a new timer!');
throw new processcube_engine_sdk_1.BadRequestError('Must provide a callback when initializing a new timer!');
}
this.validateDateTimer(timerValue);
let expirationDate;
// Accepts [D]D.[M]M.YYYY [[H]H:[M]M:[S]S]
const isGermanDate = /^([0-2]?[0-9]|3[0-1])\.([0]?[0-9]|1[0-2])\.([0-9]{4})(\s([0-1]?[0-9]|2[0-3]):([0-5]?[0-9])(:([0-5]?[0-9]))?)?$/.test(timerValue);
if (isGermanDate) {
expirationDate = (0, dayjs_1.default)(timerValue, 'DD.MM.YYYY HH:mm:ss');
}
if (!expirationDate || !expirationDate.isValid()) {
expirationDate = (0, dayjs_1.default)(timerValue);
}
const now = (0, dayjs_1.default)();
const dateIsPast = expirationDate.isBefore(now);
if (dateIsPast) {
const dateIsInThePast = `The given date definition ${expirationDate} is in the past and will be executed immediately.`;
this.logger.warn(dateIsInThePast);
return timerCallback({}, timerExpiredEventName);
}
const subscription = EventAggregator_1.default.subscribeOnce(timerExpiredEventName, (eventPayload, eventName) => {
this.logger.debug(`Date timer ${eventName} has expired. Executing callback.`);
timerCallback(eventPayload);
});
const job = this.createTimer(processcube_engine_sdk_1.Model.Events.TimerType.timeDate, expirationDate, timerExpiredEventName);
return {
...subscription,
eventName: timerExpiredEventName,
job: job,
};
}
startDurationTimer(timerValue, timerCallback, timerExpiredEventName, timerStartedDate) {
this.logger.debug(`Starting new duration timer with definition ${timerValue} and event name ${timerExpiredEventName}`);
if (!timerCallback) {
this.logger.error('Must provide a callback when initializing a new timer!');
throw new processcube_engine_sdk_1.BadRequestError('Must provide a callback when initializing a new timer!');
}
this.validateDurationTimer(timerValue);
const duration = dayjs_1.default.duration(timerValue);
const expirationDate = (0, dayjs_1.default)(timerStartedDate).add(duration);
const now = (0, dayjs_1.default)();
const dateIsPast = expirationDate.isBefore(now);
if (dateIsPast) {
return timerCallback({}, timerExpiredEventName);
}
const subscription = EventAggregator_1.default.subscribeOnce(timerExpiredEventName, (eventPayload, eventName) => {
this.logger.debug(`Duration timer ${eventName} has expired. Executing callback.`);
timerCallback(eventPayload);
});
const job = this.createTimer(processcube_engine_sdk_1.Model.Events.TimerType.timeDuration, expirationDate, timerExpiredEventName);
return {
...subscription,
eventName: timerExpiredEventName,
job: job,
};
}
triggerTimerImmediately(subscription, timerType) {
const reschedule = timerType === processcube_engine_sdk_1.Model.Events.TimerType.timeCycle;
subscription.job?.cancel(reschedule);
EventAggregator_1.default.publish(subscription.eventName);
}
cancelTimerSubscription(subscription) {
EventAggregator_1.default.unsubscribe(subscription);
subscription?.job?.cancel(false);
}
validateDateTimer(timerValue) {
const dateIsInvalid = !(0, dayjs_1.default)(timerValue, 'DD.MM.YYYY', true).isValid() && !(0, dayjs_1.default)(timerValue, undefined, true).isValid();
if (dateIsInvalid) {
const error = new processcube_engine_sdk_1.UnprocessableEntityError(`The given date definition \`${timerValue}\` is not in ISO8601 format!`, 'process');
this.logger.error(error.message);
throw error;
}
}
validateDurationTimer(timerValue) {
/**
* Taken from: https://stackoverflow.com/a/32045167
*/
const durationRegex = /^P(?!$)(\d+(?:\.\d+)?Y)?(\d+(?:\.\d+)?M)?(\d+(?:\.\d+)?W)?(\d+(?:\.\d+)?D)?(T(?=\d)(\d+(?:\.\d+)?H)?(\d+(?:\.\d+)?M)?(\d+(?:\.\d+)?S)?)?$/gm;
const durationIsInvalid = !durationRegex.test(timerValue);
if (durationIsInvalid) {
const error = new processcube_engine_sdk_1.UnprocessableEntityError(`The given duration definition \`${timerValue}\` is not in ISO8601 format`, 'process');
this.logger.error(error.message);
throw error;
}
}
validateCyclicTimer(timerValue, flowNode) {
if (flowNode && flowNode.bpmnType !== processcube_engine_sdk_1.BpmnType.startEvent) {
const error = new processcube_engine_sdk_1.UnprocessableEntityError('Cyclic timers are only allowed for TimerStartEvents!', 'process');
error.additionalInformation = flowNode;
this.logger.error(error.message, {
flowNode: flowNode,
});
throw error;
}
try {
cron_parser_1.default.parse(timerValue);
}
catch (error) {
const invalidCrontabError = new processcube_engine_sdk_1.UnprocessableEntityError(`${timerValue} is not a valid crontab!`, 'process');
invalidCrontabError.additionalInformation = {
validationError: error.message,
flowNode: flowNode,
};
this.logger.error(error.message, {
flowNode: flowNode,
});
throw invalidCrontabError;
}
}
createTimer(timerType, value, eventName) {
const timerValue = timerType === processcube_engine_sdk_1.Model.Events.TimerType.timeCycle ? value : value.toDate();
const job = node_schedule_1.default.scheduleJob(timerValue, () => EventAggregator_1.default.publish(eventName));
if (!job) {
throw new Error('an error occured during job scheduling');
}
return job;
}
};
exports.TimerFacade = TimerFacade;
exports.TimerFacade = TimerFacade = __decorate([
(0, inversify_1.injectable)(),
__metadata("design:paramtypes", [])
], TimerFacade);
//# sourceMappingURL=TimerFacade.js.map