@researchdatabox/redbox-core 0.0.0-bootstrap.0

package/dist/services/TriggerService.js

@@ -0,0 +1,554 @@
+"use strict";
+// Copyright (c) 2017 Queensland Cyber Infrastructure Foundation (http://www.qcif.edu.au/)
+//
+// GNU GENERAL PUBLIC LICENSE
+//    Version 2, June 1991
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Services = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const RBValidationError_1 = require("../model/RBValidationError");
+const CoreService_1 = require("../CoreService");
+const PopulateExportedMethods_decorator_1 = require("../decorator/PopulateExportedMethods.decorator");
+const momentShim_1 = require("../shims/momentShim");
+const numeral_1 = __importDefault(require("numeral"));
+var Services;
+(function (Services) {
+    /**
+     * Trigger related functions...
+     *
+     * Author: <a href='https://github.com/shilob' target='_blank'>Shilo Banihit</a>
+     *
+     */
+    let Trigger = class Trigger extends CoreService_1.Services.Core.Service {
+        /**
+         * Used in changing the workflow stages automatically based on configuration.
+         *
+         * @author <a target='_' href='https://github.com/shilob'>Shilo Banihit</a>
+         * @param  oid
+         * @param  record
+         * @param  options
+         * @return
+         */
+        transitionWorkflow(oid, record, options) {
+            const triggerCondition = String(_.get(options, "triggerCondition", ""));
+            const variables = {};
+            variables['imports'] = record;
+            const compiled = _.template(triggerCondition, variables);
+            const compileResult = compiled();
+            sails.log.verbose(`Trigger condition for ${oid} ==> "${triggerCondition}", has result: '${compileResult}'`);
+            if (_.isEqual(compileResult, "true")) {
+                const workflowStageTarget = _.get(options, "targetWorkflowStageName", _.get(record, 'workflow.stage'));
+                const workflowStageLabel = _.get(options, "targetWorkflowStageLabel", _.get(record, 'workflow.stageLabel'));
+                sails.log.verbose(`Trigger condition met for ${oid}, transitioning to: ${workflowStageTarget}`);
+                _.set(record, "workflow.stage", workflowStageTarget);
+                _.set(record, "workflow.stageLabel", workflowStageLabel);
+                // we need to update the form too!!!!
+                _.set(record, "metaMetadata.form", _.get(options, "targetForm", _.get(record, 'metaMetadata.form')));
+            }
+            return (0, rxjs_1.of)(record);
+        }
+        /**
+         *
+         * By default, hooks are launched asynch, this method allows for synch running of hooks while not blocking the save request thread.
+         * Will work as pre and post hooks.
+         *
+         *
+         * @author <a target='_' href='https://github.com/shilob'>Shilo Banihit</a>
+         * @param  oid
+         * @param  record
+         * @param  options
+         * map of:
+         *   "hooks" - array, same structure as that of hook option's "pre" and "post" fields
+         * @return
+         */
+        runHooksSync(oid, record, options, user) {
+            sails.log.debug(`runHooksSync, starting...`);
+            sails.log.debug(JSON.stringify(options));
+            const hookFnArray = _.get(options, 'hooks', []);
+            const hookFnDefArray = [];
+            _.each(hookFnArray, (hookFnDef) => {
+                const hookFnStr = _.get(hookFnDef, "function", null);
+                if (!_.isEmpty(hookFnStr) && _.isString(hookFnStr)) {
+                    const hookFn = eval(hookFnStr);
+                    const hookOpt = _.get(hookFnDef, "options");
+                    if (_.isFunction(hookFn)) {
+                        sails.log.debug(`runHooksSync, adding: ${hookFnStr}`);
+                        hookFnDefArray.push({ hookFn: hookFn, hookOpt: hookOpt });
+                    }
+                    else {
+                        sails.log.error(`runHooksSync, this is not a valid function: ${hookFnStr}`);
+                        sails.log.error(hookFnDef);
+                    }
+                }
+                else {
+                    sails.log.error(`runHooksSync, expected a string function name, got: ${hookFnStr}`);
+                    sails.log.error(hookFnDef);
+                }
+            });
+            if (!_.isEmpty(hookFnDefArray)) {
+                sails.log.debug(`runHooksSync, running..`);
+                return (0, rxjs_1.from)(hookFnDefArray)
+                    .pipe((0, operators_1.concatMap)((hookDef) => {
+                    return hookDef.hookFn(oid, record, hookDef.hookOpt ?? {}, user);
+                }), (0, operators_1.last)());
+            }
+            else {
+                sails.log.debug(`runHooksSync, no observables to run`);
+                return (0, rxjs_1.of)(record);
+            }
+        }
+        async applyFieldLevelPermissions(oid, record, options, user) {
+            // mandatory
+            const fieldDBNames = _.get(options, 'fieldDBNames', []);
+            // Allow a certain user to edit
+            const userWithPermissionToEdit = _.get(options, 'userWithPermissionToEdit', '');
+            const roleEditPermission = _.get(options, 'roleEditPermission', '');
+            if (user.username != userWithPermissionToEdit && !this.userHasRoleEditPermission(user, roleEditPermission)) {
+                const previousRecord = await RecordsService.getMeta(oid);
+                for (const fieldDBName of fieldDBNames) {
+                    const data = _.get(record, fieldDBName);
+                    sails.log.debug(`field name ${fieldDBName} value is ${data}`);
+                    const previousData = _.get(previousRecord, fieldDBName);
+                    sails.log.debug(`previous field name ${fieldDBName} value is ${previousData}`);
+                    if (previousData != null && String(previousData).trim() != '') {
+                        _.set(record, fieldDBName, previousData);
+                        sails.log.info(`Setting field name ${fieldDBName} of record with OID ${oid} to ${previousData}`);
+                    }
+                }
+            }
+            return record;
+        }
+        userHasRoleEditPermission(user, roleEditPermission) {
+            for (const role of user.roles ?? []) {
+                if (role.name === roleEditPermission) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        async validateFieldUsingRegex(oid, record, options) {
+            // mandatory
+            const fieldDBName = _.get(options, 'fieldDBName', '');
+            const errorLanguageCode = _.get(options, 'errorLanguageCode', '');
+            const regexPattern = _.get(options, 'regexPattern', '');
+            // optional
+            const fieldLanguageCode = _.get(options, 'fieldLanguageCode', '');
+            const arrayObjFieldDBName = _.get(options, 'arrayObjFieldDBName', '');
+            // trimLeadingAndTrailingSpacesBeforeValidation:
+            // Set false by default if not present this option will remove leading and trailing spaces from a none array value
+            // then it will modify the value in the record if the regex validation is passed therefore handle with care
+            const trimLeadingAndTrailingSpacesBeforeValidation = Boolean(_.get(options, 'trimLeadingAndTrailingSpacesBeforeValidation', false));
+            // default to true - is only false when set to bool false or string 'false'
+            const caseSensitive = String(_.get(options, 'caseSensitive', true)) !== 'false';
+            // default to true for backwards compatibility - is only false when set to bool false or string 'false'
+            const allowNulls = String(_.get(options, 'allowNulls', true)) !== 'false';
+            // re-usable functions
+            const textRegex = function (value) {
+                let flags = '';
+                if (!caseSensitive) {
+                    flags += 'i';
+                }
+                const re = new RegExp(regexPattern, flags);
+                return re.test(value);
+            };
+            const getError = function () {
+                let displayErrorDetail = TranslationService.t(errorLanguageCode);
+                const displayErrorMeta = { errorLanguageCode: errorLanguageCode };
+                if (fieldLanguageCode) {
+                    displayErrorDetail = `${TranslationService.t(fieldLanguageCode)} ${displayErrorDetail}`;
+                    displayErrorMeta.fieldLanguageCode = fieldLanguageCode;
+                }
+                return new RBValidationError_1.RBValidationError({
+                    message: `Failed validating field using regex record ${record} options ${options}`,
+                    displayErrors: [{ detail: displayErrorDetail, meta: displayErrorMeta }],
+                });
+            };
+            const hasValue = function (data) {
+                return data !== '' && data !== null && data !== undefined;
+            };
+            const evaluate = function (element, fieldName) {
+                let value = String(_.get(element, fieldName, ''));
+                if (trimLeadingAndTrailingSpacesBeforeValidation) {
+                    value = _.trim(value);
+                }
+                if (!hasValue(value) && !allowNulls) {
+                    return false;
+                }
+                else if (!hasValue(value) && allowNulls) {
+                    // this is ok
+                }
+                else if (!textRegex(value)) {
+                    return false;
+                }
+                if (trimLeadingAndTrailingSpacesBeforeValidation) {
+                    _.set(element, fieldName, value);
+                }
+                return true;
+            };
+            // get the data
+            const data = _.get(record, fieldDBName);
+            // early checks
+            if (!hasValue(data) && !allowNulls) {
+                throw getError();
+            }
+            if (!hasValue(data) && allowNulls) {
+                sails.log.debug('validateFieldUsingRegex', 'data value is null and value is allowed to be null', record, options);
+                return record;
+            }
+            if (!_.isArray(data) && arrayObjFieldDBName) {
+                throw getError();
+            }
+            if (_.isArray(data) && !arrayObjFieldDBName) {
+                throw getError();
+            }
+            // evaluate the record field against the regex
+            if (_.isArray(data)) {
+                for (const row of data) {
+                    if (!evaluate(row, arrayObjFieldDBName)) {
+                        throw getError();
+                    }
+                }
+            }
+            else {
+                if (!evaluate(record, fieldDBName)) {
+                    throw getError();
+                }
+            }
+            sails.log.debug('validateFieldUsingRegex', 'data value passed check', record, options);
+            return record;
+        }
+        /**
+         * Trigger function that will run a lodash template that can be used to validate a record.
+         * The trigger expects the template to return an array of error objects of the format:
+         *  {
+         *   name: 'the field name that is in validation error',
+         *   label: 'the human readable label for the field',
+         *   error: 'optional error message'
+         *  }
+         *
+         *  An empty array should be returned if no errors are found.
+         *
+         * @param oid
+         * @param record
+         * @param options
+         * @returns
+         */
+        async validateFieldsUsingTemplate(oid, record, options) {
+            sails.log.verbose('validateFieldsUsingTemplate - enter');
+            if (this.metTriggerCondition(oid, record, options) === "true") {
+                sails.log.verbose('validateFieldsUsingTemplate - metTriggerCondition');
+                const getErrorMessage = function (errorLanguageCode) {
+                    const baseErrorMessage = TranslationService.t(errorLanguageCode);
+                    return baseErrorMessage;
+                };
+                const addError = function (errorFieldList, name, label, errorLabel) {
+                    const errorField = {};
+                    _.set(errorField, 'name', name);
+                    _.set(errorField, 'label', getErrorMessage(label));
+                    const error = getErrorMessage(errorLabel);
+                    if (error != '') {
+                        _.set(errorField, 'error', error);
+                    }
+                    errorFieldList.push(errorField);
+                };
+                let template = _.get(options, 'template', "<% return []; %>");
+                const imports = {
+                    moment: momentShim_1.momentShim,
+                    numeral: numeral_1.default,
+                    _: _,
+                    TranslationService: TranslationService
+                };
+                const altErrorMessage = _.get(options, 'altErrorMessage', []);
+                if (_.isString(template)) {
+                    const compiledTemplate = _.template(template, { imports });
+                    options.template = compiledTemplate;
+                    template = compiledTemplate;
+                }
+                if (!_.isFunction(template)) {
+                    throw new Error('Template is not a string or function');
+                }
+                const errorFieldList = template({
+                    oid: oid, record: record, options: options, addError: addError,
+                    getErrorMessage: getErrorMessage
+                });
+                const errorMap = {
+                    altErrorMessage: altErrorMessage,
+                    errorFieldList: errorFieldList
+                };
+                if (!_.isEmpty(errorMap.errorFieldList)) {
+                    throw new RBValidationError_1.RBValidationError({
+                        message: `Field validation using template failed: errorMap ${JSON.stringify(errorMap)}`,
+                        displayErrors: [{ title: "Validation failed", meta: errorMap }]
+                    });
+                }
+                sails.log.debug('validateFieldsUsingTemplate data value passed check');
+            }
+            return record;
+        }
+        async validateFieldMapUsingRegex(oid, record, options) {
+            sails.log.verbose('validateFieldMapUsingRegex - enter');
+            if (this.metTriggerCondition(oid, record, options) === "true") {
+                sails.log.verbose('validateFieldMapUsingRegex - metTriggerCondition');
+                // re-usable functions
+                const textRegex = function (value, regexPattern, caseSensitive) {
+                    if (regexPattern == '') {
+                        return true;
+                    }
+                    else {
+                        let flags = '';
+                        if (!caseSensitive) {
+                            flags += 'i';
+                        }
+                        const re = new RegExp(regexPattern, flags);
+                        return re.test(value);
+                    }
+                };
+                const getError = function (errorLanguageCode) {
+                    const baseErrorMessage = TranslationService.t(errorLanguageCode);
+                    sails.log.error('validateFieldMapUsingRegex ' + baseErrorMessage);
+                    return baseErrorMessage;
+                };
+                const hasValue = function (data) {
+                    return data !== '' && data !== null && data !== undefined;
+                };
+                const evaluate = function (element, fieldName, trim, allowNulls, regexPattern, caseSensitive) {
+                    let value = '';
+                    if (_.isString(element) && fieldName == '') {
+                        value = element;
+                    }
+                    else if (fieldName != '') {
+                        value = _.get(element, fieldName);
+                        sails.log.debug('validateFieldMapUsingRegex evaluate fieldName ' + fieldName + ' value ' + value);
+                    }
+                    if (trim) {
+                        value = _.trim(value);
+                    }
+                    if (!hasValue(value) && !allowNulls) {
+                        return false;
+                    }
+                    else if (!hasValue(value) && allowNulls) {
+                        // this is ok
+                    }
+                    else if (!textRegex(value, regexPattern, caseSensitive)) {
+                        return false;
+                    }
+                    if (trim && _.isObject(element) && fieldName != '') {
+                        _.set(element, fieldName, value);
+                    }
+                    return true;
+                };
+                const fieldObjectList = _.get(options, 'fieldObjectList', []);
+                const altErrorMessage = _.get(options, 'altErrorMessage', []);
+                const errorMap = {
+                    altErrorMessage: altErrorMessage,
+                    errorFieldList: []
+                };
+                sails.log.debug('validateFieldMapUsingRegex fieldObjectList ' + JSON.stringify(fieldObjectList));
+                for (const field of fieldObjectList) {
+                    const fieldName = String(_.get(field, 'name', ''));
+                    const fieldLabel = String(_.get(field, 'label', ''));
+                    const fieldErrorLabel = String(_.get(field, 'errorLabel', ''));
+                    // get the data
+                    const data = _.get(record, 'metadata.' + fieldName);
+                    // caseSensitive default is true - is only false when set to bool false or string 'false'
+                    const caseSensitive = String(_.get(field, 'caseSensitive', true)) !== 'false';
+                    sails.log.debug('validateFieldMapUsingRegex field.allowNulls ' + _.get(field, 'allowNulls'));
+                    const allowNulls = String(_.get(field, 'allowNulls', true)) !== 'false';
+                    sails.log.debug('validateFieldMapUsingRegex allowNulls ' + allowNulls);
+                    const trim = Boolean(_.get(field, 'trim', true));
+                    const regexPattern = String(_.get(field, 'regexPattern', ''));
+                    sails.log.debug('validateFieldMapUsingRegex ' + fieldName + ' data ' + JSON.stringify(data));
+                    // early checks
+                    if (!hasValue(data) && !allowNulls) {
+                        const errorField = {};
+                        _.set(errorField, 'name', fieldName);
+                        _.set(errorField, 'label', getError(fieldLabel));
+                        const error = getError(fieldErrorLabel);
+                        if (error != '') {
+                            _.set(errorField, 'error', error);
+                        }
+                        errorMap.errorFieldList.push(errorField);
+                        sails.log.debug('validateFieldMapUsingRegex !hasValue(data) && !allowNulls');
+                        continue;
+                    }
+                    // evaluate the record field against the regex
+                    if (_.isArray(data)) {
+                        for (const row of data) {
+                            const innerFieldName = String(_.get(field, 'arrayObjFieldDBName', ''));
+                            if (!evaluate(row, innerFieldName, trim, allowNulls, regexPattern, caseSensitive)) {
+                                sails.log.debug('validateFieldMapUsingRegex evaluate arrayObjFieldDBName ' + fieldName);
+                                const errorField = {};
+                                _.set(errorField, 'name', fieldName);
+                                _.set(errorField, 'label', getError(fieldLabel));
+                                const error = getError(fieldErrorLabel);
+                                if (error != '') {
+                                    _.set(errorField, 'error', error);
+                                }
+                                errorMap.errorFieldList.push(errorField);
+                            }
+                        }
+                    }
+                    else {
+                        if (!evaluate(data, '', trim, allowNulls, regexPattern, caseSensitive)) {
+                            sails.log.debug('validateFieldMapUsingRegex evaluate field.name ' + fieldName);
+                            const errorField = {};
+                            _.set(errorField, 'name', fieldName);
+                            _.set(errorField, 'label', getError(fieldLabel));
+                            const error = getError(fieldErrorLabel);
+                            if (error != '') {
+                                _.set(errorField, 'error', error);
+                            }
+                            errorMap.errorFieldList.push(errorField);
+                        }
+                    }
+                }
+                sails.log.debug('validateFieldMapUsingRegex errorMap ' + JSON.stringify(errorMap));
+                if (!_.isEmpty(errorMap.errorFieldList)) {
+                    throw new RBValidationError_1.RBValidationError({
+                        message: `Field map validation using regex failed: errorMap ${JSON.stringify(errorMap)}`,
+                        displayErrors: [{ title: "Validation failed", meta: errorMap }]
+                    });
+                }
+                sails.log.debug('validateFieldMapUsingRegex data value passed check');
+            }
+            return record;
+        }
+        async runTemplatesOnRelatedRecord(relatedOid, relatedRecord, options, user) {
+            if (this.metTriggerCondition(relatedOid, relatedRecord, options) === "true") {
+                sails.log.verbose('runTemplatesOnRelatedRecord - metTriggerCondition');
+                const templates = _.get(options, 'templates', []);
+                sails.log.verbose(`runTemplatesOnRelatedRecord config: ${JSON.stringify(templates)}`);
+                sails.log.verbose(`runTemplatesOnRelatedRecord to oid: ${relatedOid} with user: ${JSON.stringify(user)}`);
+                const pathToRelatedOid = String(_.get(options, 'pathToRelatedOid', ''));
+                const innerPathToRelatedOid = String(_.get(options, 'innerPathToRelatedOid', ''));
+                const runPreSaveTriggers = Boolean(_.get(options, 'runPreSaveTriggers', false));
+                const runPostSaveTriggers = Boolean(_.get(options, 'runPostSaveTriggers', false));
+                const parseObject = Boolean(_.get(options, 'parseObject', false));
+                const oidStringOrArray = _.get(relatedRecord, pathToRelatedOid, '');
+                let record = null;
+                const oidList = [];
+                if (!_.isArray(oidStringOrArray) && _.isString(oidStringOrArray)) {
+                    oidList.push(oidStringOrArray);
+                }
+                else if (_.isArray(oidStringOrArray)) {
+                    if (innerPathToRelatedOid != '') {
+                        for (const oidObj of oidStringOrArray) {
+                            const tmpOid = _.get(oidObj, innerPathToRelatedOid, '');
+                            if (tmpOid != '' && _.isString(tmpOid)) {
+                                oidList.push(tmpOid);
+                            }
+                        }
+                    }
+                    else {
+                        for (const oid of oidStringOrArray) {
+                            if (_.isString(oid)) {
+                                oidList.push(oid);
+                            }
+                        }
+                    }
+                }
+                if (!_.isEmpty(oidList)) {
+                    for (const oid of oidList) {
+                        sails.log.verbose(`runTemplatesOnRelatedRecord trying to find related record with oid: ${oid}`);
+                        let tmplConfig = null;
+                        try {
+                            record = await RecordsService.getMeta(oid);
+                            if (_.isObject(record)) {
+                                sails.log.verbose(`runTemplatesOnRelatedRecord related record found and will run templates...`);
+                                _.each(templates, (templateConfig) => {
+                                    tmplConfig = templateConfig;
+                                    const imports = _.extend({
+                                        moment: momentShim_1.momentShim,
+                                        numeral: numeral_1.default
+                                    }, this);
+                                    const templateImportsData = {
+                                        imports: imports
+                                    };
+                                    const templateData = {
+                                        oid: oid,
+                                        record: record,
+                                        user: user,
+                                        options: options
+                                    };
+                                    const templateValue = templateConfig.template;
+                                    let templateFn = null;
+                                    if (_.isString(templateValue)) {
+                                        templateFn = _.template(templateValue, { imports: templateImportsData });
+                                    }
+                                    else if (_.isFunction(templateValue)) {
+                                        templateFn = templateValue;
+                                    }
+                                    if (!templateFn) {
+                                        throw new Error('Template is not a string or function');
+                                    }
+                                    const data = templateFn(templateData);
+                                    const fieldPath = String(_.get(templateConfig, 'field', ''));
+                                    if (parseObject) {
+                                        const obj = JSON.parse(data);
+                                        _.set(record, fieldPath, obj);
+                                    }
+                                    else {
+                                        _.set(record, fieldPath, data);
+                                    }
+                                });
+                                const brandId = _.get(record, 'metaMetadata.brandId', '');
+                                if (_.isEmpty(brandId)) {
+                                    throw new RBValidationError_1.RBValidationError({
+                                        message: 'Brand id not found for related record',
+                                        displayErrors: [{ title: 'Processing failed', meta: { oid: oid, relatedOid: relatedOid } }]
+                                    });
+                                }
+                                const brand = BrandingService.getBrandById(brandId);
+                                sails.log.verbose(`runTemplatesOnRelatedRecord Brand: ${JSON.stringify(brand)}`);
+                                await RecordsService.updateMeta(brand, oid, record, user, runPreSaveTriggers, runPostSaveTriggers);
+                            }
+                            else {
+                                sails.log.verbose(`runTemplatesOnRelatedRecord did't find related record using oid: ${oid} - object retrived is: ${JSON.stringify(record)}`);
+                            }
+                        }
+                        catch (e) {
+                            throw new RBValidationError_1.RBValidationError({
+                                message: `Failed to run one of the string templates for oid ${oid} relatedOid ${relatedOid}: ${JSON.stringify(tmplConfig)}`,
+                                options: { cause: e },
+                                displayErrors: [{ title: "Processing failed", meta: { oid: oid, relatedOid: relatedOid } }]
+                            });
+                        }
+                    }
+                }
+                else {
+                    sails.log.verbose(`runTemplatesOnRelatedRecord did't find related oid list: ${JSON.stringify(oidList)} - in specified path: ${pathToRelatedOid} - and inner path ${innerPathToRelatedOid}`);
+                }
+            }
+            return relatedRecord;
+        }
+    };
+    Trigger = __decorate([
+        PopulateExportedMethods_decorator_1.PopulateExportedMethods
+    ], Trigger);
+    Services.Trigger = Trigger;
+})(Services || (exports.Services = Services = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TriggerService.js","sourceRoot":"","sources":["../../src/services/TriggerService.ts"],"names":[],"mappings":"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"}