@netgrif/components-core 6.0.1

package/esm2015/lib/event/services/event.service.js

@@ -0,0 +1,57 @@
+import { Injectable } from '@angular/core';
+import { EventConstants } from '../model/event-constants';
+import * as i0 from "@angular/core";
+export class EventService {
+    constructor() {
+    }
+    parseChangedFieldsFromOutcomeTree(outcome) {
+        const changedFieldsMap = {};
+        if (!!outcome.outcomes && outcome.outcomes.length > 0) {
+            return this.parseChangedFieldsFromOutcomeTreeRecursive(outcome.outcomes, changedFieldsMap);
+        }
+        else
+            return changedFieldsMap;
+    }
+    parseChangedFieldsFromOutcomeTreeRecursive(outcomes, changedFieldsMap) {
+        outcomes.forEach(childOutcome => {
+            if (EventConstants.CHANGED_FIELDS in childOutcome
+                && !!childOutcome.aCase
+                && !!childOutcome.task) {
+                const setDataOutcome = childOutcome;
+                const outcomeChangedFields = childOutcome.changedFields.changedFields;
+                const caseId = setDataOutcome.aCase.stringId;
+                if (!Object.keys(changedFieldsMap).includes(caseId)) {
+                    changedFieldsMap[caseId] = {};
+                }
+                const taskId = setDataOutcome.task.stringId;
+                if (!Object.keys(changedFieldsMap[caseId]).includes(taskId)) {
+                    changedFieldsMap[caseId][taskId] = {
+                        taskId
+                    };
+                }
+                Object.keys(outcomeChangedFields).forEach(fieldId => {
+                    if (Object.keys(changedFieldsMap[caseId][taskId]).includes(fieldId)) {
+                        Object.keys(outcomeChangedFields[fieldId]).forEach(attribute => {
+                            changedFieldsMap[caseId][taskId][fieldId][attribute] = outcomeChangedFields[fieldId][attribute];
+                        });
+                    }
+                    else {
+                        changedFieldsMap[caseId][taskId][fieldId] = setDataOutcome.changedFields.changedFields[fieldId];
+                    }
+                });
+            }
+            if (!!childOutcome.outcomes && childOutcome.outcomes.length > 0) {
+                this.parseChangedFieldsFromOutcomeTreeRecursive(childOutcome.outcomes, changedFieldsMap);
+            }
+        });
+        return changedFieldsMap;
+    }
+}
+EventService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EventService_Factory() { return new EventService(); }, token: EventService, providedIn: "root" });
+EventService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+EventService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/event/services/interfaces/changed-fields-map.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhbmdlZC1maWVsZHMtbWFwLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL2V2ZW50L3NlcnZpY2VzL2ludGVyZmFjZXMvY2hhbmdlZC1maWVsZHMtbWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0NoYW5nZWRGaWVsZHN9IGZyb20gJy4uLy4uLy4uL2RhdGEtZmllbGRzL21vZGVscy9jaGFuZ2VkLWZpZWxkcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ2hhbmdlZEZpZWxkc01hcCB7XG4gICAgW2Nhc2VJZDogc3RyaW5nXToge1xuICAgICAgICBbdGFza0lkOiBzdHJpbmddOiBDaGFuZ2VkRmllbGRzXG4gICAgfTtcbn1cbiJdfQ==

package/esm2015/lib/event-queue/model/queued-event.js

@@ -0,0 +1,31 @@
+/**
+ * Wrapper for a scheduled event
+ */
+export class QueuedEvent {
+    /**
+     * @param _isRelevant a method that determines if the event is still relevant at the time of its execution.
+     * Returns `true` if the event is still relevant (e.g. the set field is still editable). Returns `false` otherwise.
+     * @param _execute executes the scheduled event and then performs the provided after action
+     * @param _revert reverts the scheduled event and then performs the provided after action
+     */
+    constructor(_isRelevant, _execute, _revert = (a) => {
+        a.resolve(true);
+    }) {
+        this._isRelevant = _isRelevant;
+        this._execute = _execute;
+        this._revert = _revert;
+    }
+    /**
+     * Executes the event if it is still relevant, or reverts it if it is not.
+     * Performs the provided after action, once the event is resolved.
+     */
+    resolve(afterAction) {
+        if (this._isRelevant()) {
+            this._execute(afterAction);
+        }
+        else {
+            this._revert(afterAction);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/event-queue/public-api.js

@@ -0,0 +1,5 @@
+/* SERVICES */
+export * from './services/event-queue.service';
+/* MODEL */
+export * from './model/queued-event';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9ldmVudC1xdWV1ZS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWM7QUFDZCxjQUFjLGdDQUFnQyxDQUFDO0FBRS9DLFdBQVc7QUFDWCxjQUFjLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyogU0VSVklDRVMgKi9cbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvZXZlbnQtcXVldWUuc2VydmljZSc7XG5cbi8qIE1PREVMICovXG5leHBvcnQgKiBmcm9tICcuL21vZGVsL3F1ZXVlZC1ldmVudCc7XG4iXX0=

package/esm2015/lib/event-queue/services/event-queue.service.js

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core';
+import { LoggerService } from '../../logger/services/logger.service';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+import { CallChainService } from '../../utility/call-chain/call-chain.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../logger/services/logger.service";
+import * as i2 from "../../utility/call-chain/call-chain.service";
+/**
+ * This service handles the queuing and execution of task related events (assign, finish, cancel, delegate, setData and getData)
+ */
+export class EventQueueService {
+    constructor(_log, _afterActionService) {
+        this._log = _log;
+        this._afterActionService = _afterActionService;
+        this._queue = [];
+        this._performingEvent = new LoadingEmitter();
+    }
+    /**
+     * Schedules the execution of the provided event
+     * @param event
+     */
+    scheduleEvent(event) {
+        if (this._performingEvent.isActive) {
+            this._log.debug(`Adding scheduled event to queue. Position in queue: ${this._queue.length}`);
+            this._queue.push(event);
+        }
+        else {
+            this._log.debug('Event queue is empty. Executing scheduled event immediately.');
+            this._performingEvent.on();
+            this.executeEvent(event);
+        }
+    }
+    executeEvent(event) {
+        event.resolve(this._afterActionService.create(() => {
+            this.executeNextEventFromQueue();
+        }));
+    }
+    executeNextEventFromQueue() {
+        this._log.debug('Event finished execution.');
+        if (this._queue.length === 0) {
+            this._performingEvent.off();
+            this._log.debug('Last event in queue was executed.');
+            return;
+        }
+        this._log.debug('Executing next event in queue.');
+        this.executeEvent(this._queue.shift());
+    }
+}
+EventQueueService.ctorParameters = () => [
+    { type: LoggerService },
+    { type: CallChainService }
+];
+EventQueueService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EventQueueService_Factory() { return new EventQueueService(i0.ɵɵinject(i1.LoggerService), i0.ɵɵinject(i2.CallChainService)); }, token: EventQueueService, providedIn: "root" });
+EventQueueService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+EventQueueService.ctorParameters = () => [
+    { type: LoggerService },
+    { type: CallChainService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/filter/filter.repository.js

@@ -0,0 +1,141 @@
+import { Injectable } from '@angular/core';
+import { ConfigurationService } from '../configuration/configuration.service';
+import { LoggerService } from '../logger/services/logger.service';
+import { FilterType } from './models/filter-type';
+import { SimpleFilter } from './models/simple-filter';
+import { MergedFilter } from './models/merged-filter';
+import * as i0 from "@angular/core";
+import * as i1 from "../configuration/configuration.service";
+import * as i2 from "../logger/services/logger.service";
+/**
+ * Allows access to filters defined in nae.json during runtime.
+ *
+ * Filters are always returned as copies to avoid unintended side effects when operating on them.
+ *
+ * Also see {@link Filter}.
+ */
+export class FilterRepository {
+    /**
+     * Loads and creates filters declared in nae.json.
+     */
+    constructor(_configService, _log) {
+        this._configService = _configService;
+        this._log = _log;
+        /**
+         * Stores the filters managed by the repository. Keys are filterIds.
+         */
+        this._filters = new Map();
+        const filters = _configService.get().filters;
+        if (!filters) {
+            return;
+        }
+        Object.keys(filters).forEach(filterId => {
+            const configFilter = filters[filterId];
+            // TODO 17.4.2020 - don't ignore filter.access property
+            if (!configFilter.type || !configFilter.body) {
+                _log.warn(`Filter '${filterId}' doesn't define all the necessary properties. Skipping.`);
+                return;
+            }
+            if (Array.isArray(configFilter.body)) {
+                if (!configFilter.mergeOperator) {
+                    _log.warn(`Filter '${filterId}' contains multiple filters, but doesn't define a merge operator. Skipping.`);
+                    return;
+                }
+                this.warnIfFilterExists(filterId);
+                const filter = new MergedFilter(filterId, configFilter.type, configFilter.body, configFilter.mergeOperator, configFilter.title);
+                this._filters.set(filterId, filter);
+            }
+            else {
+                this.warnIfFilterExists(filterId);
+                const filter = new SimpleFilter(filterId, configFilter.type, configFilter.body, configFilter.title);
+                this._filters.set(filterId, filter);
+            }
+        });
+    }
+    /**
+     * Logs a warning if filter with the given id already exists. The warning states that the filter will be replaced.
+     * @param filterId ID of the filter who's existence should be checked
+     */
+    warnIfFilterExists(filterId) {
+        if (this._filters.has(filterId)) {
+            this._log.warn(`Filter with id '${filterId}' already exists in the repository and will be replaced!`);
+        }
+    }
+    /**
+     * @param filterId ID of the filter that should be retrieved
+     * @returns a copy of the specified filter, or `undefined` if such filter doesn't exist in the repository.
+     */
+    getFilter(filterId) {
+        let filter = this._filters.get(filterId);
+        if (!!filter) {
+            filter = filter.clone();
+        }
+        return filter;
+    }
+    /**
+     * Stores a new filter into the repository. If the repository already contains a filter with the same ID, the stored filter
+     * will be replaced and a warning will be logged.
+     *
+     * The repository stores a copy of the provided filter, to ensure that the objects in the repository aren't referenced from outside.
+     * @param filter the filter that should be stored
+     */
+    saveFilter(filter) {
+        this.warnIfFilterExists(filter.id);
+        this._filters.set(filter.id, filter.clone());
+    }
+    /**
+     * @returns list of case filter identifiers stored in the repository
+     */
+    getCaseFilterList() {
+        return this.getFilterList(filter => filter.type === FilterType.CASE);
+    }
+    /**
+     * @returns list of task filter identifiers stored in the repository
+     */
+    getTaskFilterList() {
+        return this.getFilterList(filter => filter.type === FilterType.TASK);
+    }
+    /**
+     * @param predicate condition that must be fulfilled by the filters in the repository in order to be included in the result
+     * @returns list of filter identifiers that fulfill the given predicate
+     */
+    getFilterList(predicate) {
+        const result = [];
+        this._filters.forEach(filter => {
+            if (predicate(filter)) {
+                result.push(filter.id);
+            }
+        });
+        return result;
+    }
+    /**
+     * @param filterIds list of ids of filters that should be returned
+     * @returns list of copies of specified filters. If some of the filters don't exist in the repository, they won't be included
+     * and the array will contain less elements than the input array.
+     */
+    getFilters(filterIds) {
+        const result = [];
+        filterIds.forEach(id => {
+            const filter = this.getFilter(id);
+            if (filter !== undefined) {
+                result.push(filter);
+            }
+        });
+        return result;
+    }
+}
+FilterRepository.ctorParameters = () => [
+    { type: ConfigurationService },
+    { type: LoggerService }
+];
+FilterRepository.ɵprov = i0.ɵɵdefineInjectable({ factory: function FilterRepository_Factory() { return new FilterRepository(i0.ɵɵinject(i1.ConfigurationService), i0.ɵɵinject(i2.LoggerService)); }, token: FilterRepository, providedIn: "root" });
+FilterRepository.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+FilterRepository.ctorParameters = () => [
+    { type: ConfigurationService },
+    { type: LoggerService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter.repository.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/filter/filter.repository.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {ConfigurationService} from '../configuration/configuration.service';\nimport {ConfigFilter} from '../../commons/schema';\nimport {LoggerService} from '../logger/services/logger.service';\nimport {MergeOperator} from './models/merge-operator';\nimport {FilterType} from './models/filter-type';\nimport {SimpleFilter} from './models/simple-filter';\nimport {Filter} from './models/filter';\nimport {MergedFilter} from './models/merged-filter';\n\n\n/**\n * Allows access to filters defined in nae.json during runtime.\n *\n * Filters are always returned as copies to avoid unintended side effects when operating on them.\n *\n * Also see {@link Filter}.\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class FilterRepository {\n\n    /**\n     * Stores the filters managed by the repository. Keys are filterIds.\n     */\n    protected _filters: Map<string, Filter> = new Map<string, Filter>();\n\n    /**\n     * Loads and creates filters declared in nae.json.\n     */\n    constructor(protected _configService: ConfigurationService, protected _log: LoggerService) {\n        const filters = _configService.get().filters;\n        if (!filters) {\n            return;\n        }\n\n        Object.keys(filters).forEach(filterId => {\n            const configFilter: ConfigFilter = filters[filterId];\n            // TODO 17.4.2020 - don't ignore filter.access property\n            if (!configFilter.type || !configFilter.body) {\n                _log.warn(`Filter '${filterId}' doesn't define all the necessary properties. Skipping.`);\n                return;\n            }\n            if (Array.isArray(configFilter.body)) {\n                if (!configFilter.mergeOperator) {\n                    _log.warn(`Filter '${filterId}' contains multiple filters, but doesn't define a merge operator. Skipping.`);\n                    return;\n                }\n                this.warnIfFilterExists(filterId);\n\n                const filter = new MergedFilter(filterId, configFilter.type as FilterType,\n                    configFilter.body, configFilter.mergeOperator as MergeOperator, configFilter.title);\n                this._filters.set(filterId, filter);\n\n            } else {\n                this.warnIfFilterExists(filterId);\n                const filter = new SimpleFilter(filterId, configFilter.type as FilterType, configFilter.body, configFilter.title);\n                this._filters.set(filterId, filter);\n            }\n        });\n    }\n\n    /**\n     * Logs a warning if filter with the given id already exists. The warning states that the filter will be replaced.\n     * @param filterId ID of the filter who's existence should be checked\n     */\n    protected warnIfFilterExists(filterId: string): void {\n        if (this._filters.has(filterId)) {\n            this._log.warn(`Filter with id '${filterId}' already exists in the repository and will be replaced!`);\n        }\n    }\n\n    /**\n     * @param filterId ID of the filter that should be retrieved\n     * @returns a copy of the specified filter, or `undefined` if such filter doesn't exist in the repository.\n     */\n    public getFilter(filterId: string): Filter | undefined {\n        let filter = this._filters.get(filterId);\n        if (!!filter) {\n            filter = filter.clone();\n        }\n        return filter;\n    }\n\n    /**\n     * Stores a new filter into the repository. If the repository already contains a filter with the same ID, the stored filter\n     * will be replaced and a warning will be logged.\n     *\n     * The repository stores a copy of the provided filter, to ensure that the objects in the repository aren't referenced from outside.\n     * @param filter the filter that should be stored\n     */\n    public saveFilter(filter: Filter): void {\n        this.warnIfFilterExists(filter.id);\n        this._filters.set(filter.id, filter.clone());\n    }\n\n    /**\n     * @returns list of case filter identifiers stored in the repository\n     */\n    public getCaseFilterList(): Array<string> {\n        return this.getFilterList(filter => filter.type === FilterType.CASE);\n    }\n\n    /**\n     * @returns list of task filter identifiers stored in the repository\n     */\n    public getTaskFilterList(): Array<string> {\n        return this.getFilterList(filter => filter.type === FilterType.TASK);\n    }\n\n    /**\n     * @param predicate condition that must be fulfilled by the filters in the repository in order to be included in the result\n     * @returns list of filter identifiers that fulfill the given predicate\n     */\n    protected getFilterList(predicate: (f: Filter) => boolean): Array<string> {\n        const result = [];\n        this._filters.forEach(filter => {\n            if (predicate(filter)) {\n                result.push(filter.id);\n            }\n        });\n        return result;\n    }\n\n    /**\n     * @param filterIds list of ids of filters that should be returned\n     * @returns list of copies of specified filters. If some of the filters don't exist in the repository, they won't be included\n     * and the array will contain less elements than the input array.\n     */\n    public getFilters(filterIds: Array<string>): Array<Filter> {\n        const result = [];\n        filterIds.forEach(id => {\n            const filter = this.getFilter(id);\n            if (filter !== undefined) {\n               result.push(filter);\n            }\n        });\n        return result;\n    }\n}\n"]}

package/esm2015/lib/filter/models/case-search-request-body.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/filter/models/filter-type.js

@@ -0,0 +1,11 @@
+/**
+ * Determines the type of resource the Filter can search for.
+ *
+ * See {@link Filter} for more information.
+ */
+export var FilterType;
+(function (FilterType) {
+    FilterType["TASK"] = "Task";
+    FilterType["CASE"] = "Case";
+})(FilterType || (FilterType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLXR5cGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvZmlsdGVyL21vZGVscy9maWx0ZXItdHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsTUFBTSxDQUFOLElBQVksVUFHWDtBQUhELFdBQVksVUFBVTtJQUNsQiwyQkFBYSxDQUFBO0lBQ2IsMkJBQWEsQ0FBQTtBQUNqQixDQUFDLEVBSFcsVUFBVSxLQUFWLFVBQVUsUUFHckIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIERldGVybWluZXMgdGhlIHR5cGUgb2YgcmVzb3VyY2UgdGhlIEZpbHRlciBjYW4gc2VhcmNoIGZvci5cbiAqXG4gKiBTZWUge0BsaW5rIEZpbHRlcn0gZm9yIG1vcmUgaW5mb3JtYXRpb24uXG4gKi9cbmV4cG9ydCBlbnVtIEZpbHRlclR5cGUge1xuICAgIFRBU0sgPSAnVGFzaycsXG4gICAgQ0FTRSA9ICdDYXNlJyxcbn1cbiJdfQ==

package/esm2015/lib/filter/models/filter.js

@@ -0,0 +1,56 @@
+/**
+ * Abstraction of backend search requests that defines a limited set of operations on them.
+ */
+export class Filter {
+    /**
+     * If no name is provided the filter will be identified by it's ID when necessary.
+     * @param _id identifier of the filter
+     * @param _type type of resources that the filter can query
+     * @param _title human readable filter name
+     */
+    constructor(_id, _type, _title = '') {
+        this._id = _id;
+        this._type = _type;
+        this._title = _title;
+    }
+    /**
+     * Unique filter identifier
+     */
+    get id() {
+        return this._id;
+    }
+    set id(id) {
+        this._id = id;
+    }
+    /**
+     * Determines the type of resource this Filter can filter.
+     */
+    get type() {
+        return this._type;
+    }
+    /**
+     * Human readable filter title.
+     *
+     * Defaults to empty string.
+     */
+    get title() {
+        return this._title;
+    }
+    /**
+     * Returns the necessary request params for the filter. Default implementation returns an empty object.
+     * The params are added on top of the request when sending it to the backend by the respective service methods.
+     * @returns an empty object `{}`
+     */
+    getRequestParams() {
+        return {};
+    }
+    /**
+     * Creates a deep copy of a simple object.
+     * @param obj object that should be copied
+     * @returns a deep copy of the argument
+     */
+    deepCopy(obj) {
+        return JSON.parse(JSON.stringify(obj));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/filter/models/filters-filter-injection-token.js

@@ -0,0 +1,9 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Used for providing any additional constraints to the filter case filtering, when
+ * user filters are loaded via the {@link UserFiltersService}.
+ *
+ * The provided filter must be of type `Case` as it is used for the filtering of cases representing saved user filters.
+ */
+export const NAE_FILTERS_FILTER = new InjectionToken('NaeFiltersFilter');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVycy1maWx0ZXItaW5qZWN0aW9uLXRva2VuLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL2ZpbHRlci9tb2RlbHMvZmlsdGVycy1maWx0ZXItaW5qZWN0aW9uLXRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFHN0M7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxJQUFJLGNBQWMsQ0FBUyxrQkFBa0IsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3Rpb25Ub2tlbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0ZpbHRlcn0gZnJvbSAnLi9maWx0ZXInO1xuXG4vKipcbiAqIFVzZWQgZm9yIHByb3ZpZGluZyBhbnkgYWRkaXRpb25hbCBjb25zdHJhaW50cyB0byB0aGUgZmlsdGVyIGNhc2UgZmlsdGVyaW5nLCB3aGVuXG4gKiB1c2VyIGZpbHRlcnMgYXJlIGxvYWRlZCB2aWEgdGhlIHtAbGluayBVc2VyRmlsdGVyc1NlcnZpY2V9LlxuICpcbiAqIFRoZSBwcm92aWRlZCBmaWx0ZXIgbXVzdCBiZSBvZiB0eXBlIGBDYXNlYCBhcyBpdCBpcyB1c2VkIGZvciB0aGUgZmlsdGVyaW5nIG9mIGNhc2VzIHJlcHJlc2VudGluZyBzYXZlZCB1c2VyIGZpbHRlcnMuXG4gKi9cbmV4cG9ydCBjb25zdCBOQUVfRklMVEVSU19GSUxURVIgPSBuZXcgSW5qZWN0aW9uVG9rZW48RmlsdGVyPignTmFlRmlsdGVyc0ZpbHRlcicpO1xuIl19

package/esm2015/lib/filter/models/merge-operator.js

@@ -0,0 +1,11 @@
+/**
+ * Determines whether the combination of Filters is an union (AND) or an intersection (OR).
+ *
+ * See {@link MergedFilter} for more information.
+ */
+export var MergeOperator;
+(function (MergeOperator) {
+    MergeOperator["AND"] = "AND";
+    MergeOperator["OR"] = "OR";
+})(MergeOperator || (MergeOperator = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVyZ2Utb3BlcmF0b3IuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvZmlsdGVyL21vZGVscy9tZXJnZS1vcGVyYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsTUFBTSxDQUFOLElBQVksYUFHWDtBQUhELFdBQVksYUFBYTtJQUNyQiw0QkFBVyxDQUFBO0lBQ1gsMEJBQVMsQ0FBQTtBQUNiLENBQUMsRUFIVyxhQUFhLEtBQWIsYUFBYSxRQUd4QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRGV0ZXJtaW5lcyB3aGV0aGVyIHRoZSBjb21iaW5hdGlvbiBvZiBGaWx0ZXJzIGlzIGFuIHVuaW9uIChBTkQpIG9yIGFuIGludGVyc2VjdGlvbiAoT1IpLlxuICpcbiAqIFNlZSB7QGxpbmsgTWVyZ2VkRmlsdGVyfSBmb3IgbW9yZSBpbmZvcm1hdGlvbi5cbiAqL1xuZXhwb3J0IGVudW0gTWVyZ2VPcGVyYXRvciB7XG4gICAgQU5EID0gJ0FORCcsXG4gICAgT1IgPSAnT1InLFxufVxuIl19

package/esm2015/lib/filter/models/merged-filter-params.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVyZ2VkLWZpbHRlci1wYXJhbXMuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvZmlsdGVyL21vZGVscy9tZXJnZWQtZmlsdGVyLXBhcmFtcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBIVFRQIHJlcXVlc3QgcGFyYW1zIGZvciB0aGUge0BsaW5rIE1lcmdlZEZpbHRlcn0uXG4gKlxuICogU2VlIHtAbGluayBNZXJnZWRGaWx0ZXJ9IGFuZCB7QGxpbmsgUGFyYW1zfSBmb3IgbW9yZSBpbmZvcm1hdGlvbi5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBNZXJnZWRGaWx0ZXJQYXJhbXMge1xuICAgIC8qKlxuICAgICAqIFRoZSBvcGVyYXRpb24gdGhhdCBpcyB1c2VkIHRvIG1lcmdlIHRoZSBmaWx0ZXJzLlxuICAgICAqXG4gICAgICogU2VlIHtAbGluayBNZXJnZU9wZXJhdG9yfSBmb3IgbW9yZSBpbmZvcm1hdGlvbi5cbiAgICAgKi9cbiAgICAnb3BlcmF0aW9uJzogJ0FORCcgfCAnT1InO1xufVxuIl19

package/esm2015/lib/filter/models/merged-filter.js

@@ -0,0 +1,111 @@
+import { Filter } from './filter';
+import { MergeOperator } from './merge-operator';
+import { FilterType } from './filter-type';
+/**
+ * Represents an union or an intersection of {@link SimpleFilter}s and allows limited manipulation with it.
+ */
+export class MergedFilter extends Filter {
+    /**
+     * @param id identifier of the filter
+     * @param type type of resources that the filter can query
+     * @param filterBodies `Array` of search requests matching this filter's type
+     * @param _operator boolean operator that is used to combine the filters
+     * @param title human readable filter name
+     */
+    constructor(id, type, filterBodies, _operator, title) {
+        super(id, type, title);
+        this._operator = _operator;
+        this._filters = [];
+        filterBodies.forEach(body => {
+            this._filters.push(this.deepCopy(body));
+        });
+    }
+    /**
+     * Creates a filter with the provided body and the provided type
+     * @param filterBody the body of the new filter
+     * @param operator the merge operator that is used to combine the filters
+     * @param type the type of the new filter. Type must match the type of the body.
+     * @returns a filter with the given body, operator and type. `id` of the new filter is set to an empty string.
+     */
+    static fromQuery(filterBody, operator, type) {
+        return new MergedFilter('', type, filterBody, operator);
+    }
+    /**
+     * Creates a case filter with the provided body
+     * @param filterBody the body of the new filter
+     * @param operator the merge operator that is used to combine the filters
+     * @returns a case filter with the given body and operator. `id` of the new filter is set to an empty string.
+     */
+    static fromCaseQuery(filterBody, operator) {
+        return MergedFilter.fromQuery(filterBody, operator, FilterType.CASE);
+    }
+    /**
+     * Creates a task filter with the provided body
+     * @param filterBody the body of the new filter
+     * @param operator the merge operator that is used to combine the filters
+     * @returns a task filter with the given body and operator. `id` of the new filter is set to an empty string.
+     */
+    static fromTaskQuery(filterBody, operator) {
+        return MergedFilter.fromQuery(filterBody, operator, FilterType.TASK);
+    }
+    set operator(operator) {
+        this._operator = operator;
+    }
+    get operator() {
+        return this._operator;
+    }
+    /**
+     * See [Filter.clone()]{@link Filter#clone}
+     */
+    clone() {
+        return new MergedFilter(this.id, this.type, this._filters, this._operator, this.title);
+    }
+    /**
+     * Filters that are merged must share the same type and the same merge operator.
+     *
+     * See [Filter.merge()]{@link Filter#merge} for information about parameters.
+     */
+    merge(filter, operator) {
+        if (filter.type !== this.type) {
+            throw new Error('Can\'t merge filters with different types');
+        }
+        if (this._operator !== operator || (filter instanceof MergedFilter && filter._operator !== this._operator)) {
+            throw new Error('Can\'t merge filters with different merge operators');
+        }
+        const id = `${this.id}${operator === MergeOperator.AND ? '&' : '|'}${filter.id}`;
+        const combinedFilters = [];
+        combinedFilters.push(...this._filters);
+        const otherFilters = filter.getRequestBody();
+        if (Array.isArray(otherFilters)) {
+            combinedFilters.push(...otherFilters);
+        }
+        else {
+            combinedFilters.push(otherFilters);
+        }
+        return new MergedFilter(id, this.type, combinedFilters, this._operator);
+    }
+    /**
+     * See [Filter.getRequestBody()]{@link Filter#getRequestBody}
+     */
+    getRequestBody() {
+        return this.deepCopy(this._filters);
+    }
+    /**
+     * See [Filter.bodyContainsQuery()]{@link Filter#bodyContainsQuery}
+     */
+    bodyContainsQuery() {
+        return this._filters.some(f => f.query !== undefined && f.query !== null);
+    }
+    /**
+     * Returns the necessary request params for the filter.
+     * @returns params with `operation` set to either `AND` or `OR` based on this object's `_operator` property.
+     *
+     * See {@link MergedFilterParams} for more information.
+     */
+    getRequestParams() {
+        return {
+            operation: this._operator
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"merged-filter.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/filter/models/merged-filter.ts"],"names":[],"mappings":"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","sourcesContent":["import {Filter} from './filter';\nimport {MergeOperator} from './merge-operator';\nimport {TaskSearchRequestBody} from './task-search-request-body';\nimport {CaseSearchRequestBody} from './case-search-request-body';\nimport {FilterType} from './filter-type';\nimport {Params} from '../../resources/resource-provider.service';\nimport {MergedFilterParams} from './merged-filter-params';\n\n/**\n * Represents an union or an intersection of {@link SimpleFilter}s and allows limited manipulation with it.\n */\nexport class MergedFilter extends Filter {\n\n    /**\n     * @ignore\n     * Stores the underlying filter data\n     */\n    private readonly _filters: Array<CaseSearchRequestBody> | Array<TaskSearchRequestBody>;\n\n    /**\n     * Creates a filter with the provided body and the provided type\n     * @param filterBody the body of the new filter\n     * @param operator the merge operator that is used to combine the filters\n     * @param type the type of the new filter. Type must match the type of the body.\n     * @returns a filter with the given body, operator and type. `id` of the new filter is set to an empty string.\n     */\n    public static fromQuery(filterBody: Array<CaseSearchRequestBody> | Array<TaskSearchRequestBody>, operator: MergeOperator,\n                            type: FilterType): Filter {\n        return new MergedFilter('', type, filterBody, operator);\n    }\n\n    /**\n     * Creates a case filter with the provided body\n     * @param filterBody the body of the new filter\n     * @param operator the merge operator that is used to combine the filters\n     * @returns a case filter with the given body and operator. `id` of the new filter is set to an empty string.\n     */\n    public static fromCaseQuery(filterBody: Array<CaseSearchRequestBody>, operator: MergeOperator): Filter {\n        return MergedFilter.fromQuery(filterBody, operator, FilterType.CASE);\n    }\n\n    /**\n     * Creates a task filter with the provided body\n     * @param filterBody the body of the new filter\n     * @param operator the merge operator that is used to combine the filters\n     * @returns a task filter with the given body and operator. `id` of the new filter is set to an empty string.\n     */\n    public static fromTaskQuery(filterBody: Array<TaskSearchRequestBody>, operator: MergeOperator): Filter {\n        return MergedFilter.fromQuery(filterBody, operator, FilterType.TASK);\n    }\n\n    /**\n     * @param id identifier of the filter\n     * @param type type of resources that the filter can query\n     * @param filterBodies `Array` of search requests matching this filter's type\n     * @param _operator boolean operator that is used to combine the filters\n     * @param title human readable filter name\n     */\n    constructor(id: string, type: FilterType, filterBodies: Array<CaseSearchRequestBody> | Array<TaskSearchRequestBody>,\n                protected _operator: MergeOperator, title?: string) {\n        super(id, type, title);\n        this._filters = [];\n        filterBodies.forEach(body => {\n            this._filters.push(this.deepCopy(body));\n        });\n    }\n\n    public set operator(operator: MergeOperator) {\n        this._operator = operator;\n    }\n\n    public get operator(): MergeOperator {\n        return this._operator;\n    }\n\n    /**\n     * See [Filter.clone()]{@link Filter#clone}\n     */\n    clone(): Filter {\n        return new MergedFilter(this.id, this.type, this._filters, this._operator, this.title);\n    }\n\n    /**\n     * Filters that are merged must share the same type and the same merge operator.\n     *\n     * See [Filter.merge()]{@link Filter#merge} for information about parameters.\n     */\n    merge(filter: Filter, operator: MergeOperator): MergedFilter {\n        if (filter.type !== this.type) {\n            throw new Error('Can\\'t merge filters with different types');\n        }\n        if (this._operator !== operator || (filter instanceof MergedFilter && filter._operator !== this._operator)) {\n            throw new Error('Can\\'t merge filters with different merge operators');\n        }\n\n        const id = `${this.id}${operator === MergeOperator.AND ? '&' : '|'}${filter.id}`;\n\n        const combinedFilters: Array<CaseSearchRequestBody> | Array<TaskSearchRequestBody> = [];\n        combinedFilters.push(...this._filters);\n        const otherFilters = filter.getRequestBody();\n        if (Array.isArray(otherFilters)) {\n            combinedFilters.push(...otherFilters);\n        } else {\n            combinedFilters.push(otherFilters);\n        }\n\n        return new MergedFilter(id, this.type, combinedFilters, this._operator);\n    }\n\n    /**\n     * See [Filter.getRequestBody()]{@link Filter#getRequestBody}\n     */\n    getRequestBody(): Array<TaskSearchRequestBody> | Array<CaseSearchRequestBody> {\n        return this.deepCopy(this._filters) as Array<CaseSearchRequestBody> | Array<TaskSearchRequestBody>;\n    }\n\n    /**\n     * See [Filter.bodyContainsQuery()]{@link Filter#bodyContainsQuery}\n     */\n    bodyContainsQuery(): boolean {\n        return this._filters.some(f => f.query !== undefined && f.query !== null);\n    }\n\n    /**\n     * Returns the necessary request params for the filter.\n     * @returns params with `operation` set to either `AND` or `OR` based on this object's `_operator` property.\n     *\n     * See {@link MergedFilterParams} for more information.\n     */\n    getRequestParams(): MergedFilterParams & Params {\n        return {\n            operation: this._operator\n        };\n    }\n}\n"]}