@netgrif/components-core 6.0.1

package/esm2015/lib/search/header-search-service/header-search.service.js

@@ -0,0 +1,226 @@
+import { Injectable, Optional } from '@angular/core';
+import { SearchService } from '../search-service/search.service';
+import { HeaderType } from '../../header/models/header-type';
+import { filter } from 'rxjs/operators';
+import { HeaderChangeType } from '../../header/models/user-changes/header-change-type';
+import { HeaderMode } from '../../header/models/header-mode';
+import { HeaderColumnType } from '../../header/models/header-column';
+import { CaseMetaField } from '../../header/case-header/case-menta-enum';
+import { CategoryFactory } from '../category-factory/category-factory';
+import { CaseVisualId } from '../models/category/case/case-visual-id';
+import { CaseAuthor } from '../models/category/case/case-author';
+import { CaseCreationDate } from '../models/category/case/case-creation-date';
+import { CaseTitle } from '../models/category/case/case-title';
+import { CaseStringId } from '../models/category/case/case-string-id';
+import { ProcessService } from '../../process/process.service';
+import { CaseSimpleDataset } from '../models/category/case/case-simple-dataset';
+import { TranslateService } from '@ngx-translate/core';
+import { LoggerService } from '../../logger/services/logger.service';
+/**
+ * Acts as an intermediary between the {@link AbstractHeaderService} instances of various types and the {@link SearchService}
+ */
+export class HeaderSearchService {
+    constructor(_categoryFactory, _processService, _translate, _logger, _searchService) {
+        this._categoryFactory = _categoryFactory;
+        this._processService = _processService;
+        this._translate = _translate;
+        this._logger = _logger;
+        this._searchService = _searchService;
+        this._columnToConfiguration = new Map();
+        this._typeToCategory = new Map();
+        [
+            { k: CaseMetaField.VISUAL_ID, v: CaseVisualId },
+            { k: CaseMetaField.TITLE, v: CaseTitle },
+            { k: CaseMetaField.CREATION_DATE, v: CaseCreationDate },
+            { k: CaseMetaField.AUTHOR, v: CaseAuthor },
+            { k: CaseMetaField.MONGO_ID, v: CaseStringId }
+        ].forEach(pair => {
+            this._typeToCategory.set(pair.k, this._categoryFactory.getWithDefaultOperator(pair.v));
+        });
+        this._typeToCategory.set(HeaderColumnType.IMMEDIATE, this._categoryFactory.get(CaseSimpleDataset));
+    }
+    ngOnDestroy() {
+        if (this._headerSub) {
+            this._headerSub.unsubscribe();
+        }
+        if (this._searchSub) {
+            this._searchSub.unsubscribe();
+        }
+        for (const cat of this._typeToCategory.values()) {
+            cat.destroy();
+        }
+    }
+    set headerService(headerService) {
+        if (headerService.headerType === HeaderType.CASE || headerService.headerType === HeaderType.TASK) {
+            this._headerService = headerService;
+        }
+        if (headerService && this._searchService) {
+            this.initializeHeaderSearch();
+        }
+    }
+    /**
+     * {@link HeaderSearchService} can only be initialized if it successfully injected a {@link SearchService}
+     * and a {@link AbstractHeaderService} instance of any of the supported types was set into it.
+     *
+     * Currently only task and case header searching is supported.
+     */
+    initializeHeaderSearch() {
+        if (!this._searchService) {
+            this._logger.error('You can\'t call initializeHeaderSearch without providing a SearchService to be injected!');
+            return;
+        }
+        if (!this._headerService) {
+            this._logger.error('You can\'t call initializeHeaderSearch without setting an AbstractHeaderService implementation instance!');
+            return;
+        }
+        this._headerSub = this._headerService.headerChange$
+            .pipe(filter(change => change.changeType === HeaderChangeType.SEARCH || change.changeType === HeaderChangeType.MODE_CHANGED))
+            .subscribe(change => {
+            if (change.changeType === HeaderChangeType.SEARCH) {
+                this.processSearchChange(change.headerType, change.description);
+            }
+            else if (change.description.previousMode === HeaderMode.SEARCH) {
+                this.processModeChange();
+            }
+        });
+        this._searchSub =
+            this._searchService.predicateRemoved$.subscribe(event => this.handlePredicateRemoval(event.index, event.clearInput));
+    }
+    /**
+     * Pushes all the predicates from the headers into the search interface and clears the header inputs
+     */
+    processModeChange() {
+        const addedPredicateIds = [];
+        this._columnToConfiguration.forEach(config => {
+            this._searchService.removePredicate(config.predicateId);
+            let editableCategory;
+            if (config.type === HeaderColumnType.META) {
+                editableCategory = this._typeToCategory.get(config.fieldIdentifier).duplicate();
+                editableCategory.selectDefaultOperator();
+                editableCategory.setOperands(config.userInput);
+            }
+            else {
+                const dataset = this._typeToCategory.get(HeaderColumnType.IMMEDIATE);
+                editableCategory = dataset.transformToCaseDataset(config.fieldType, config.fieldTitle, config.userInput);
+            }
+            addedPredicateIds.push(this._searchService.addGeneratedLeafPredicate(editableCategory));
+        });
+        this._searchService.show(addedPredicateIds);
+        this._columnToConfiguration.clear();
+    }
+    /**
+     * Transforms the {@link HeaderChange} object into a search predicate
+     */
+    processSearchChange(headerType, changeDescription) {
+        if (headerType === HeaderType.CASE) {
+            this.processCaseSearch(changeDescription);
+        }
+    }
+    /**
+     * Processes the change object and resolves it into the appropriate case search predicate change
+     * @param changeDescription the change object that should be resolved
+     */
+    processCaseSearch(changeDescription) {
+        if (this.emptyInput(changeDescription)) {
+            this.removePredicate(changeDescription.columnIdentifier);
+            return;
+        }
+        if (changeDescription.type === HeaderColumnType.META) {
+            this.processCaseMetaSearch(changeDescription);
+        }
+        else {
+            this.processCaseDataSearch(changeDescription);
+        }
+    }
+    /**
+     * Processes the change object of a case meta header and resolves it into the appropriate case search predicate change
+     * @param changeDescription the change object that should be resolved
+     */
+    processCaseMetaSearch(changeDescription) {
+        const config = {
+            fieldIdentifier: changeDescription.fieldIdentifier,
+            userInput: [changeDescription.searchInput]
+        };
+        const category = this._typeToCategory.get(config.fieldIdentifier);
+        const predicate = category.generatePredicate(config.userInput);
+        this.addPredicate(changeDescription.columnIdentifier, predicate, Object.assign({ type: HeaderColumnType.META }, config));
+    }
+    /**
+     * Processes the change object of a case immediate data header and resolves it into the appropriate case search predicate change
+     * @param changeDescription the change object that should be resolved
+     */
+    processCaseDataSearch(changeDescription) {
+        this._processService.getNet(changeDescription.petriNetIdentifier).subscribe(net => {
+            const config = {
+                fieldType: changeDescription.fieldType,
+                fieldTitle: changeDescription.fieldTitle,
+                userInput: [changeDescription.searchInput]
+            };
+            const category = this._typeToCategory.get(changeDescription.type);
+            category.configure(changeDescription.fieldIdentifier, config.fieldType, [net.identifier]);
+            const predicate = category.generatePredicate(config.userInput);
+            this.addPredicate(changeDescription.columnIdentifier, predicate, Object.assign({ type: HeaderColumnType.IMMEDIATE }, config));
+        });
+    }
+    /**
+     * @param changeDescription information about the search header change
+     * @returns whether the input was cleared
+     */
+    emptyInput(changeDescription) {
+        return changeDescription.searchInput === undefined
+            || changeDescription.searchInput === null
+            || (typeof changeDescription.searchInput === 'string' && changeDescription.searchInput.length === 0);
+    }
+    /**
+     * Updates a Predicate for a given column.
+     * Removes an existing predicate for this column if it exists and adds the new Predicate.
+     * @param column the index of the header column
+     * @param predicate the Predicate that should be added
+     * @param configuration data necessary for the configuration of the {@link Category} that generates the added predicate
+     */
+    addPredicate(column, predicate, configuration) {
+        this.removePredicate(column, !this._columnToConfiguration.has(column));
+        const predicateId = this._searchService.addPredicate(predicate);
+        this._columnToConfiguration.set(column, Object.assign({ predicateId }, configuration));
+    }
+    /**
+     * Removes a predicate that corresponds to the provided column
+     * @param column the index of the column that cleared it's search
+     * @param clearInput whether the corresponding header search input should be cleared
+     */
+    removePredicate(column, clearInput = true) {
+        const predicateConfig = this._columnToConfiguration.get(column);
+        if (predicateConfig !== undefined) {
+            this._searchService.removePredicate(predicateConfig.predicateId, clearInput);
+            this._columnToConfiguration.delete(column);
+        }
+    }
+    /**
+     * @param removedId the id of the removed {@link Predicate}
+     * @param clearInput whether the corresponding header search input should be cleared
+     */
+    handlePredicateRemoval(removedId, clearInput = true) {
+        if (this._headerService && clearInput) {
+            this._headerService.clearHeaderSearch(removedId);
+        }
+        this._columnToConfiguration.delete(removedId);
+    }
+}
+HeaderSearchService.ctorParameters = () => [
+    { type: CategoryFactory },
+    { type: ProcessService },
+    { type: TranslateService },
+    { type: LoggerService },
+    { type: SearchService, decorators: [{ type: Optional }] }
+];
+HeaderSearchService.decorators = [
+    { type: Injectable }
+];
+HeaderSearchService.ctorParameters = () => [
+    { type: CategoryFactory },
+    { type: ProcessService },
+    { type: TranslateService },
+    { type: LoggerService },
+    { type: SearchService, decorators: [{ type: Optional }] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"header-search.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/header-search-service/header-search.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy, Optional} from '@angular/core';\nimport {SearchService} from '../search-service/search.service';\nimport {AbstractHeaderService} from '../../header/abstract-header-service';\nimport {HeaderType} from '../../header/models/header-type';\nimport {filter} from 'rxjs/operators';\nimport {HeaderChangeType} from '../../header/models/user-changes/header-change-type';\nimport {HeaderMode} from '../../header/models/header-mode';\nimport {ModeChangeDescription} from '../../header/models/user-changes/mode-change-description';\nimport {SearchChangeDescription} from '../../header/models/user-changes/search-change-description';\nimport {HeaderColumnType} from '../../header/models/header-column';\nimport {CaseMetaField} from '../../header/case-header/case-menta-enum';\nimport {CategoryFactory} from '../category-factory/category-factory';\nimport {CaseVisualId} from '../models/category/case/case-visual-id';\nimport {Category} from '../models/category/category';\nimport {CaseAuthor} from '../models/category/case/case-author';\nimport {CaseCreationDate} from '../models/category/case/case-creation-date';\nimport {CaseTitle} from '../models/category/case/case-title';\nimport {CaseStringId} from '../models/category/case/case-string-id';\nimport {Predicate} from '../models/predicate/predicate';\nimport {ProcessService} from '../../process/process.service';\nimport {CaseSimpleDataset} from '../models/category/case/case-simple-dataset';\nimport {TranslateService} from '@ngx-translate/core';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {Subscription} from 'rxjs';\n\n/**\n * Holds the Id of the predicate in the {@link SearchService}\n */\ninterface PredicateId {\n    predicateId: number;\n}\n\n/**\n * Holds the information necessary for the configuration of a {@link Category} class to generate\n * a predicate for a Meta header field\n */\ninterface MetaGeneratorConfiguration {\n    type: HeaderColumnType.META;\n    fieldIdentifier: string;\n    userInput: Array<any>;\n}\n\n/**\n * Holds the information necessary for the configuration of a {@link Category} class to generate\n * a predicate for a Data header field\n */\ninterface DataGeneratorConfiguration {\n    type: HeaderColumnType.IMMEDIATE;\n    fieldType: string;\n    fieldTitle: string;\n    userInput: Array<any>;\n}\n\ntype HeaderConfiguration = PredicateId & (MetaGeneratorConfiguration | DataGeneratorConfiguration);\n\n/**\n * Acts as an intermediary between the {@link AbstractHeaderService} instances of various types and the {@link SearchService}\n */\n@Injectable()\nexport class HeaderSearchService implements OnDestroy {\n\n    protected _headerService: AbstractHeaderService;\n    protected _columnToConfiguration: Map<number, HeaderConfiguration>;\n    protected _typeToCategory: Map<string, Category<any>>;\n    protected _headerSub: Subscription;\n    protected _searchSub: Subscription;\n\n    constructor(protected _categoryFactory: CategoryFactory,\n                protected _processService: ProcessService,\n                protected _translate: TranslateService,\n                protected _logger: LoggerService,\n                @Optional() protected _searchService: SearchService) {\n        this._columnToConfiguration = new Map<number, HeaderConfiguration>();\n        this._typeToCategory = new Map<string, Category<any>>();\n        [\n            {k: CaseMetaField.VISUAL_ID, v: CaseVisualId},\n            {k: CaseMetaField.TITLE, v: CaseTitle},\n            {k: CaseMetaField.CREATION_DATE, v: CaseCreationDate},\n            {k: CaseMetaField.AUTHOR, v: CaseAuthor},\n            {k: CaseMetaField.MONGO_ID, v: CaseStringId}\n        ].forEach(pair => {\n            this._typeToCategory.set(pair.k, this._categoryFactory.getWithDefaultOperator(pair.v));\n        });\n        this._typeToCategory.set(HeaderColumnType.IMMEDIATE, this._categoryFactory.get(CaseSimpleDataset));\n    }\n\n    ngOnDestroy(): void {\n        if (this._headerSub) {\n            this._headerSub.unsubscribe();\n        }\n        if (this._searchSub) {\n            this._searchSub.unsubscribe();\n        }\n        for (const cat of this._typeToCategory.values()) {\n            cat.destroy();\n        }\n    }\n\n    public set headerService(headerService: AbstractHeaderService) {\n        if (headerService.headerType === HeaderType.CASE || headerService.headerType === HeaderType.TASK) {\n            this._headerService = headerService;\n        }\n\n        if (headerService && this._searchService) {\n            this.initializeHeaderSearch();\n        }\n    }\n\n    /**\n     * {@link HeaderSearchService} can only be initialized if it successfully injected a {@link SearchService}\n     * and a {@link AbstractHeaderService} instance of any of the supported types was set into it.\n     *\n     * Currently only task and case header searching is supported.\n     */\n    protected initializeHeaderSearch(): void {\n        if (!this._searchService) {\n            this._logger.error('You can\\'t call initializeHeaderSearch without providing a SearchService to be injected!');\n            return;\n        }\n        if (!this._headerService) {\n            this._logger.error('You can\\'t call initializeHeaderSearch without setting an AbstractHeaderService implementation instance!');\n            return;\n        }\n\n        this._headerSub = this._headerService.headerChange$\n            .pipe(filter(change => change.changeType === HeaderChangeType.SEARCH || change.changeType === HeaderChangeType.MODE_CHANGED))\n            .subscribe(change => {\n                if (change.changeType === HeaderChangeType.SEARCH) {\n                    this.processSearchChange(change.headerType, change.description as SearchChangeDescription);\n                } else if ((change.description as ModeChangeDescription).previousMode === HeaderMode.SEARCH) {\n                    this.processModeChange();\n                }\n            });\n\n        this._searchSub =\n            this._searchService.predicateRemoved$.subscribe(event => this.handlePredicateRemoval(event.index, event.clearInput));\n    }\n\n    /**\n     * Pushes all the predicates from the headers into the search interface and clears the header inputs\n     */\n    protected processModeChange(): void {\n        const addedPredicateIds = [];\n        this._columnToConfiguration.forEach(config => {\n            this._searchService.removePredicate(config.predicateId);\n\n            let editableCategory;\n            if (config.type === HeaderColumnType.META) {\n                editableCategory = this._typeToCategory.get(config.fieldIdentifier).duplicate();\n                editableCategory.selectDefaultOperator();\n                editableCategory.setOperands(config.userInput);\n            } else {\n                const dataset = (this._typeToCategory.get(HeaderColumnType.IMMEDIATE) as CaseSimpleDataset);\n                editableCategory = dataset.transformToCaseDataset(config.fieldType, config.fieldTitle, config.userInput);\n            }\n            addedPredicateIds.push(this._searchService.addGeneratedLeafPredicate(editableCategory));\n        });\n\n        this._searchService.show(addedPredicateIds);\n\n        this._columnToConfiguration.clear();\n    }\n\n    /**\n     * Transforms the {@link HeaderChange} object into a search predicate\n     */\n    protected processSearchChange(headerType: HeaderType, changeDescription: SearchChangeDescription): void {\n        if (headerType === HeaderType.CASE) {\n            this.processCaseSearch(changeDescription);\n        }\n    }\n\n    /**\n     * Processes the change object and resolves it into the appropriate case search predicate change\n     * @param changeDescription the change object that should be resolved\n     */\n    protected processCaseSearch(changeDescription: SearchChangeDescription): void {\n        if (this.emptyInput(changeDescription)) {\n            this.removePredicate(changeDescription.columnIdentifier);\n            return;\n        }\n\n        if (changeDescription.type === HeaderColumnType.META) {\n            this.processCaseMetaSearch(changeDescription);\n        } else {\n            this.processCaseDataSearch(changeDescription);\n        }\n    }\n\n    /**\n     * Processes the change object of a case meta header and resolves it into the appropriate case search predicate change\n     * @param changeDescription the change object that should be resolved\n     */\n    protected processCaseMetaSearch(changeDescription: SearchChangeDescription): void {\n        const config = {\n            fieldIdentifier: changeDescription.fieldIdentifier,\n            userInput: [changeDescription.searchInput]\n        };\n        const category = this._typeToCategory.get(config.fieldIdentifier);\n        const predicate = category.generatePredicate(config.userInput);\n        this.addPredicate(changeDescription.columnIdentifier, predicate, {\n            type: HeaderColumnType.META,\n            ...config\n        });\n    }\n\n    /**\n     * Processes the change object of a case immediate data header and resolves it into the appropriate case search predicate change\n     * @param changeDescription the change object that should be resolved\n     */\n    protected processCaseDataSearch(changeDescription: SearchChangeDescription): void {\n        this._processService.getNet(changeDescription.petriNetIdentifier).subscribe(net => {\n            const config = {\n                fieldType: changeDescription.fieldType,\n                fieldTitle: changeDescription.fieldTitle,\n                userInput: [changeDescription.searchInput]\n            };\n            const category = this._typeToCategory.get(changeDescription.type) as CaseSimpleDataset;\n            category.configure(changeDescription.fieldIdentifier, config.fieldType, [net.identifier]);\n            const predicate = category.generatePredicate(config.userInput);\n            this.addPredicate(changeDescription.columnIdentifier, predicate, {\n                type: HeaderColumnType.IMMEDIATE,\n                ...config\n            });\n        });\n    }\n\n    /**\n     * @param changeDescription information about the search header change\n     * @returns whether the input was cleared\n     */\n    protected emptyInput(changeDescription: SearchChangeDescription): boolean {\n        return changeDescription.searchInput === undefined\n            || changeDescription.searchInput === null\n            || (typeof changeDescription.searchInput === 'string' && changeDescription.searchInput.length === 0);\n    }\n\n    /**\n     * Updates a Predicate for a given column.\n     * Removes an existing predicate for this column if it exists and adds the new Predicate.\n     * @param column the index of the header column\n     * @param predicate the Predicate that should be added\n     * @param configuration data necessary for the configuration of the {@link Category} that generates the added predicate\n     */\n    protected addPredicate(column: number,\n                           predicate: Predicate,\n                           configuration: MetaGeneratorConfiguration | DataGeneratorConfiguration): void {\n\n        this.removePredicate(column, !this._columnToConfiguration.has(column));\n        const predicateId = this._searchService.addPredicate(predicate);\n        this._columnToConfiguration.set(column, {predicateId, ...configuration});\n    }\n\n    /**\n     * Removes a predicate that corresponds to the provided column\n     * @param column the index of the column that cleared it's search\n     * @param clearInput whether the corresponding header search input should be cleared\n     */\n    protected removePredicate(column: number, clearInput = true): void {\n        const predicateConfig = this._columnToConfiguration.get(column);\n        if (predicateConfig !== undefined) {\n            this._searchService.removePredicate(predicateConfig.predicateId, clearInput);\n            this._columnToConfiguration.delete(column);\n        }\n    }\n\n    /**\n     * @param removedId the id of the removed {@link Predicate}\n     * @param clearInput whether the corresponding header search input should be cleared\n     */\n    protected handlePredicateRemoval(removedId: number, clearInput = true): void {\n        if (this._headerService && clearInput) {\n            this._headerService.clearHeaderSearch(removedId);\n        }\n        this._columnToConfiguration.delete(removedId);\n    }\n}\n"]}

package/esm2015/lib/search/models/base-filter-injection-token.js

@@ -0,0 +1,6 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Provides the base filter of a {@link SearchService}
+ */
+export const NAE_BASE_FILTER = new InjectionToken('NaeBaseFilter');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1maWx0ZXItaW5qZWN0aW9uLXRva2VuLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NlYXJjaC9tb2RlbHMvYmFzZS1maWx0ZXItaW5qZWN0aW9uLXRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFHN0M7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsSUFBSSxjQUFjLENBQWEsZUFBZSxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGlvblRva2VufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7QmFzZUZpbHRlcn0gZnJvbSAnLi9iYXNlLWZpbHRlcic7XG5cbi8qKlxuICogUHJvdmlkZXMgdGhlIGJhc2UgZmlsdGVyIG9mIGEge0BsaW5rIFNlYXJjaFNlcnZpY2V9XG4gKi9cbmV4cG9ydCBjb25zdCBOQUVfQkFTRV9GSUxURVIgPSBuZXcgSW5qZWN0aW9uVG9rZW48QmFzZUZpbHRlcj4oJ05hZUJhc2VGaWx0ZXInKTtcbiJdfQ==

package/esm2015/lib/search/models/base-filter.js

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

package/esm2015/lib/search/models/boolean-operator.js

@@ -0,0 +1,10 @@
+// TODO 23.4.2020 - Same as MergeOperator for Filters, should these Enums be kept separate, or should just one exist?
+/**
+ * Determines the way {@link Predicate}s are combined together.
+ */
+export var BooleanOperator;
+(function (BooleanOperator) {
+    BooleanOperator["AND"] = "AND";
+    BooleanOperator["OR"] = "OR";
+})(BooleanOperator || (BooleanOperator = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9vbGVhbi1vcGVyYXRvci5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9zZWFyY2gvbW9kZWxzL2Jvb2xlYW4tb3BlcmF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEscUhBQXFIO0FBQ3JIOztHQUVHO0FBQ0gsTUFBTSxDQUFOLElBQVksZUFHWDtBQUhELFdBQVksZUFBZTtJQUN2Qiw4QkFBVyxDQUFBO0lBQ1gsNEJBQVMsQ0FBQTtBQUNiLENBQUMsRUFIVyxlQUFlLEtBQWYsZUFBZSxRQUcxQiIsInNvdXJjZXNDb250ZW50IjpbIi8vIFRPRE8gMjMuNC4yMDIwIC0gU2FtZSBhcyBNZXJnZU9wZXJhdG9yIGZvciBGaWx0ZXJzLCBzaG91bGQgdGhlc2UgRW51bXMgYmUga2VwdCBzZXBhcmF0ZSwgb3Igc2hvdWxkIGp1c3Qgb25lIGV4aXN0P1xuLyoqXG4gKiBEZXRlcm1pbmVzIHRoZSB3YXkge0BsaW5rIFByZWRpY2F0ZX1zIGFyZSBjb21iaW5lZCB0b2dldGhlci5cbiAqL1xuZXhwb3J0IGVudW0gQm9vbGVhbk9wZXJhdG9yIHtcbiAgICBBTkQgPSAnQU5EJyxcbiAgICBPUiA9ICdPUidcbn1cbiJdfQ==

package/esm2015/lib/search/models/category/autocomplete-category.js

@@ -0,0 +1,129 @@
+import { Category } from './category';
+import { SearchInputType } from './search-input-type';
+import { BehaviorSubject, combineLatest, ReplaySubject } from 'rxjs';
+import { filter, map, startWith, take } from 'rxjs/operators';
+/**
+ * Represents a Search Category whose values are a known set. The value selection is done with an autocomplete field.
+ *
+ * @typeparam T type of the object that the autocomplete option values use and in turn is used to generate queries
+ */
+export class AutocompleteCategory extends Category {
+    constructor(elasticKeywords, allowedOperators, translationPath, log, operatorService) {
+        super(elasticKeywords, allowedOperators, translationPath, SearchInputType.AUTOCOMPLETE, log, operatorService);
+        this._optionsMap = new Map();
+        this._options$ = new BehaviorSubject([]);
+        // timeout is used to bypass javascript object initialization bugs.
+        // Injected properties of inherited classes were not set in the function call.
+        this._timeoutId = setTimeout(() => {
+            this.createOptions();
+        });
+    }
+    destroy() {
+        super.destroy();
+        this._options$.complete();
+        clearTimeout(this._timeoutId);
+    }
+    /**
+     * Options the user can select from for this search Category.
+     */
+    get options() {
+        return this._options$.value;
+    }
+    /**
+     * An Observable of the options the user can select from for this search Category.
+     *
+     * The Observable is updated when the base set of options changes, not when the available options are
+     * filtered, see [filterOptions()]{@link AutocompleteCategory#filterOptions}.
+     *
+     * The Observable initially contains an empty array and the options may appear at a later point in time
+     * (based on the concrete AutocompleteCategory subclass implementation)
+     */
+    get options$() {
+        return this._options$.asObservable();
+    }
+    /**
+     * Publishes a new value in the [_options$]{@link AutocompleteCategory#_options$} Subject generated from the
+     * [_optionsMap]{@link AutocompleteCategory#_optionsMap}.
+     *
+     * The default implementation iterates trough the [_optionsMap]{@link AutocompleteCategory#_optionsMap} and
+     * creates options with the keys as [text]{@link SearchAutocompleteOption#text}
+     * and values as [value]{@link SearchAutocompleteOption#value}.
+     */
+    updateOptions() {
+        const result = [];
+        for (const entry of this._optionsMap.entries()) {
+            result.push(this.createSearchAutocompleteOption(entry[0], entry[1]));
+        }
+        this._options$.next(result);
+    }
+    /**
+     * The function that is used to filter shown options in the autocomplete field.
+     *
+     * By default the options that start with the input string are returned (case insensitive).
+     *
+     * By default a new value is emitted, whenever either the user input or the base set of options changes.
+     * @param userInput user search input
+     * @returns options that satisfy the autocomplete condition
+     */
+    filterOptions(userInput) {
+        return combineLatest([
+            userInput.pipe(startWith(''), map(input => typeof input === 'string' ? input.toLocaleLowerCase() : input.text)),
+            this.options$
+        ]).pipe(map(([input, options]) => {
+            return options.filter(o => o.text.toLocaleLowerCase().startsWith(input));
+        }));
+    }
+    /**
+     * Adds a new entry or pushes value into an existing entry.
+     * When a new entry is created, it is created as an Array of one element.
+     * @param key where in the map should the value be added
+     * @param value the value that should be added to the map
+     */
+    addToMap(key, value) {
+        if (this._optionsMap.has(key)) {
+            this._optionsMap.get(key).push(value);
+        }
+        else {
+            this._optionsMap.set(key, [value]);
+        }
+    }
+    isOperandValueSelected(newValue) {
+        return !(!newValue || typeof newValue === 'string');
+    }
+    /**
+     * Performs a transformation of the `FormControl` value before passing it into the selected `Operator` for query generation.
+     * It is mostly useful only for AutocompleteCategories, where the selected value of the FormControl is an object.
+     *
+     * The default AutocompleteCategory implementation returns the {@link SearchAutocompleteOption} `value` attribute.
+     * @param value the FormControlValue
+     * @returns the value used for query generation
+     */
+    transformCategoryValue(value) {
+        return value.value;
+    }
+    serializeOperandValue(valueFormControl) {
+        return valueFormControl.value.text;
+    }
+    /**
+     * @param text the serialized output of the [serializeOperandValue()]{@link Category#serializeOperandValue} method
+     * @returns the deserialized value, that can be set as FormControl value
+     *
+     * This method throws na error if the serialized value is not one of the autocomplete options.
+     */
+    deserializeOperandValue(text) {
+        const result$ = new ReplaySubject(1);
+        this.options$.pipe(filter(o => o.length > 0), take(1)).subscribe(() => {
+            const value = this._optionsMap.get(text);
+            if (value === undefined) {
+                throw new Error(`The serialized autocomplete value '${value}' does not map to any autocomplete options and cannot be deserialized!`);
+            }
+            result$.next(this.createSearchAutocompleteOption(text, value));
+            result$.complete();
+        });
+        return result$.asObservable();
+    }
+    createSearchAutocompleteOption(text, value) {
+        return { text, value };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autocomplete-category.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/models/category/autocomplete-category.ts"],"names":[],"mappings":"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","sourcesContent":["import {Category} from './category';\nimport {Operator} from '../operator/operator';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {SearchInputType} from './search-input-type';\nimport {SearchAutocompleteOption} from './search-autocomplete-option';\nimport {BehaviorSubject, combineLatest, Observable, ReplaySubject} from 'rxjs';\nimport {filter, map, startWith, take} from 'rxjs/operators';\nimport {AutocompleteOptions} from './autocomplete-options';\nimport {FormControl} from '@angular/forms';\nimport {OperatorService} from '../../operator-service/operator.service';\n\n/**\n * Represents a Search Category whose values are a known set. The value selection is done with an autocomplete field.\n *\n * @typeparam T type of the object that the autocomplete option values use and in turn is used to generate queries\n */\nexport abstract class AutocompleteCategory<T> extends Category<Array<T>> implements AutocompleteOptions {\n\n    /**\n     * Autocomplete categories usually require a map to represent mapping of display names\n     * of their options to objects that are needed to construct their queries.\n     *\n     * You are not required to use this map when you implement your own Category,\n     * but it comes with helpful functions and might save you some time.\n     *\n     * See [options()]{@link AutocompleteCategory#options} and [addToMap()]{@link AutocompleteCategory#addToMap}.\n     */\n    protected _optionsMap: Map<string, Array<T>>;\n\n    protected _options$: BehaviorSubject<Array<SearchAutocompleteOption<Array<T>>>>;\n\n    private readonly _timeoutId: number;\n\n    protected constructor(elasticKeywords: Array<string>,\n                          allowedOperators: Array<Operator<any>>,\n                          translationPath: string,\n                          log: LoggerService,\n                          operatorService: OperatorService) {\n        super(elasticKeywords, allowedOperators, translationPath, SearchInputType.AUTOCOMPLETE, log, operatorService);\n        this._optionsMap = new Map<string, Array<T>>();\n        this._options$ = new BehaviorSubject<Array<SearchAutocompleteOption<Array<T>>>>([]);\n        // timeout is used to bypass javascript object initialization bugs.\n        // Injected properties of inherited classes were not set in the function call.\n        this._timeoutId = setTimeout(() => {\n            this.createOptions();\n        });\n    }\n\n    destroy() {\n        super.destroy();\n        this._options$.complete();\n        clearTimeout(this._timeoutId);\n    }\n\n    /**\n     * Options the user can select from for this search Category.\n     */\n    public get options(): Array<SearchAutocompleteOption<Array<T>>> {\n        return this._options$.value;\n    }\n\n    /**\n     * An Observable of the options the user can select from for this search Category.\n     *\n     * The Observable is updated when the base set of options changes, not when the available options are\n     * filtered, see [filterOptions()]{@link AutocompleteCategory#filterOptions}.\n     *\n     * The Observable initially contains an empty array and the options may appear at a later point in time\n     * (based on the concrete AutocompleteCategory subclass implementation)\n     */\n    public get options$(): Observable<Array<SearchAutocompleteOption<Array<T>>>> {\n        return this._options$.asObservable();\n    }\n\n    /**\n     * Publishes a new value in the [_options$]{@link AutocompleteCategory#_options$} Subject generated from the\n     * [_optionsMap]{@link AutocompleteCategory#_optionsMap}.\n     *\n     * The default implementation iterates trough the [_optionsMap]{@link AutocompleteCategory#_optionsMap} and\n     * creates options with the keys as [text]{@link SearchAutocompleteOption#text}\n     * and values as [value]{@link SearchAutocompleteOption#value}.\n     */\n    protected updateOptions(): void {\n        const result = [];\n        for (const entry of this._optionsMap.entries()) {\n            result.push(this.createSearchAutocompleteOption(entry[0], entry[1]));\n        }\n        this._options$.next(result);\n    }\n\n    /**\n     * Populates the [_options]{@link AutocompleteCategory#_options} field with options for this category.\n     *\n     * You must call this method yourself in an appropriate place of Category creation.\n     */\n    protected abstract createOptions(): void;\n\n    /**\n     * The function that is used to filter shown options in the autocomplete field.\n     *\n     * By default the options that start with the input string are returned (case insensitive).\n     *\n     * By default a new value is emitted, whenever either the user input or the base set of options changes.\n     * @param userInput user search input\n     * @returns options that satisfy the autocomplete condition\n     */\n    public filterOptions(userInput: Observable<string | SearchAutocompleteOption<Array<T>>>):\n        Observable<Array<SearchAutocompleteOption<Array<T>>>> {\n        return combineLatest([\n            userInput.pipe(\n                startWith(''),\n                map(input => typeof input === 'string' ? input.toLocaleLowerCase() : input.text)\n            ),\n            this.options$\n        ]).pipe(\n            map(([input, options]) => {\n                return options.filter(o => o.text.toLocaleLowerCase().startsWith(input));\n            })\n        );\n    }\n\n    /**\n     * Adds a new entry or pushes value into an existing entry.\n     * When a new entry is created, it is created as an Array of one element.\n     * @param key where in the map should the value be added\n     * @param value the value that should be added to the map\n     */\n    protected addToMap(key: any, value: T): void {\n        if (this._optionsMap.has(key)) {\n            this._optionsMap.get(key).push(value);\n        } else {\n            this._optionsMap.set(key, [value]);\n        }\n    }\n\n    protected isOperandValueSelected(newValue: SearchAutocompleteOption<Array<T>> | string): boolean {\n        return !(!newValue || typeof newValue === 'string');\n    }\n\n    /**\n     * Performs a transformation of the `FormControl` value before passing it into the selected `Operator` for query generation.\n     * It is mostly useful only for AutocompleteCategories, where the selected value of the FormControl is an object.\n     *\n     * The default AutocompleteCategory implementation returns the {@link SearchAutocompleteOption} `value` attribute.\n     * @param value the FormControlValue\n     * @returns the value used for query generation\n     */\n    protected transformCategoryValue(value: SearchAutocompleteOption<Array<T>>): Array<T> {\n        return value.value;\n    }\n\n    protected serializeOperandValue(valueFormControl: FormControl): unknown {\n        return (valueFormControl.value as SearchAutocompleteOption<unknown>).text;\n    }\n\n    /**\n     * @param text the serialized output of the [serializeOperandValue()]{@link Category#serializeOperandValue} method\n     * @returns the deserialized value, that can be set as FormControl value\n     *\n     * This method throws na error if the serialized value is not one of the autocomplete options.\n     */\n    protected deserializeOperandValue(text: unknown): Observable<any> {\n        const result$ = new ReplaySubject(1);\n        this.options$.pipe(filter(o => o.length > 0), take(1)).subscribe(() => {\n            const value = this._optionsMap.get(text as string);\n            if (value === undefined) {\n                throw new Error(`The serialized autocomplete value '${value\n                }' does not map to any autocomplete options and cannot be deserialized!`);\n            }\n            result$.next(this.createSearchAutocompleteOption(text as string, value));\n            result$.complete();\n        });\n        return result$.asObservable();\n    }\n\n    protected createSearchAutocompleteOption(text: string, value: Array<T>): SearchAutocompleteOption<Array<T>> {\n        return {text, value};\n    }\n}\n"]}

package/esm2015/lib/search/models/category/autocomplete-options.js

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

package/esm2015/lib/search/models/category/case/case-author.js

@@ -0,0 +1,21 @@
+import { Equals } from '../../operator/equals';
+import { NotEquals } from '../../operator/not-equals';
+import { Categories } from '../categories';
+import { CaseSearch } from './case-search.enum';
+import { NoConfigurationUserAutocompleteCategory } from '../no-configuration-user-autocomplete-category';
+export class CaseAuthor extends NoConfigurationUserAutocompleteCategory {
+    constructor(operators, logger, optionalDependencies) {
+        super([CaseSearch.AUTHOR], [operators.getOperator(Equals), operators.getOperator(NotEquals)], `${CaseAuthor._i18n}.name`, logger, operators, 'CaseAuthor', optionalDependencies);
+    }
+    get inputPlaceholder() {
+        return `${CaseAuthor._i18n}.placeholder`;
+    }
+    duplicate() {
+        return new CaseAuthor(this._operatorService, this._log, this._optionalDependencies);
+    }
+    serializeClass() {
+        return Categories.CASE_AUTHOR;
+    }
+}
+CaseAuthor._i18n = 'search.category.case.author';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/category/case/case-creation-date-time.js

@@ -0,0 +1,43 @@
+import moment from 'moment';
+import { SearchInputType } from '../search-input-type';
+import { NoConfigurationCategory } from '../no-configuration-category';
+import { Categories } from '../categories';
+import { of } from 'rxjs';
+import { EqualsDateTime } from '../../operator/equals-date-time';
+import { MoreThanDateTime } from '../../operator/more-than-date-time';
+import { MoreThanEqualDateTime } from '../../operator/more-than-equal-date-time';
+import { LessThanEqualDateTime } from '../../operator/less-than-equal-date-time';
+import { InRangeDateTime } from '../../operator/in-range-date-time';
+import { LessThanDateTime } from '../../operator/less-than-date-time';
+import { CaseSearch } from './case-search.enum';
+import { NotEqualsDateTime } from '../../operator/not-equals-date-time';
+export class CaseCreationDateTime extends NoConfigurationCategory {
+    constructor(operators, logger) {
+        super([CaseSearch.CREATION_DATE], [
+            operators.getOperator(EqualsDateTime),
+            operators.getOperator(NotEqualsDateTime),
+            operators.getOperator(MoreThanDateTime),
+            operators.getOperator(MoreThanEqualDateTime),
+            operators.getOperator(LessThanDateTime),
+            operators.getOperator(LessThanEqualDateTime),
+            operators.getOperator(InRangeDateTime)
+        ], `${CaseCreationDateTime._i18n}.name`, SearchInputType.DATE_TIME, logger, operators);
+    }
+    get inputPlaceholder() {
+        return `${CaseCreationDateTime._i18n}.placeholder`;
+    }
+    duplicate() {
+        return new CaseCreationDateTime(this._operatorService, this._log);
+    }
+    serializeClass() {
+        return Categories.CASE_CREATION_DATE_TIME;
+    }
+    serializeOperandValue(valueFormControl) {
+        return valueFormControl.value.valueOf();
+    }
+    deserializeOperandValue(value) {
+        return of(moment(value));
+    }
+}
+CaseCreationDateTime._i18n = 'search.category.case.creationDateTime';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FzZS1jcmVhdGlvbi1kYXRlLXRpbWUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvc2VhcmNoL21vZGVscy9jYXRlZ29yeS9jYXNlL2Nhc2UtY3JlYXRpb24tZGF0ZS10aW1lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sTUFBZ0IsTUFBTSxRQUFRLENBQUM7QUFHdEMsT0FBTyxFQUFDLGVBQWUsRUFBQyxNQUFNLHNCQUFzQixDQUFDO0FBQ3JELE9BQU8sRUFBQyx1QkFBdUIsRUFBQyxNQUFNLDhCQUE4QixDQUFDO0FBQ3JFLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFekMsT0FBTyxFQUFhLEVBQUUsRUFBQyxNQUFNLE1BQU0sQ0FBQztBQUNwQyxPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0saUNBQWlDLENBQUM7QUFDL0QsT0FBTyxFQUFDLGdCQUFnQixFQUFDLE1BQU0sb0NBQW9DLENBQUM7QUFDcEUsT0FBTyxFQUFDLHFCQUFxQixFQUFDLE1BQU0sMENBQTBDLENBQUM7QUFDL0UsT0FBTyxFQUFDLHFCQUFxQixFQUFDLE1BQU0sMENBQTBDLENBQUM7QUFDL0UsT0FBTyxFQUFDLGVBQWUsRUFBQyxNQUFNLG1DQUFtQyxDQUFDO0FBQ2xFLE9BQU8sRUFBQyxnQkFBZ0IsRUFBQyxNQUFNLG9DQUFvQyxDQUFDO0FBQ3BFLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxvQkFBb0IsQ0FBQztBQUM5QyxPQUFPLEVBQUMsaUJBQWlCLEVBQUMsTUFBTSxxQ0FBcUMsQ0FBQztBQUd0RSxNQUFNLE9BQU8sb0JBQXFCLFNBQVEsdUJBQStCO0lBSXJFLFlBQVksU0FBMEIsRUFBRSxNQUFxQjtRQUN6RCxLQUFLLENBQUMsQ0FBQyxVQUFVLENBQUMsYUFBYSxDQUFDLEVBQzVCO1lBQ0ksU0FBUyxDQUFDLFdBQVcsQ0FBQyxjQUFjLENBQUM7WUFDckMsU0FBUyxDQUFDLFdBQVcsQ0FBQyxpQkFBaUIsQ0FBQztZQUN4QyxTQUFTLENBQUMsV0FBVyxDQUFDLGdCQUFnQixDQUFDO1lBQ3ZDLFNBQVMsQ0FBQyxXQUFXLENBQUMscUJBQXFCLENBQUM7WUFDNUMsU0FBUyxDQUFDLFdBQVcsQ0FBQyxnQkFBZ0IsQ0FBQztZQUN2QyxTQUFTLENBQUMsV0FBVyxDQUFDLHFCQUFxQixDQUFDO1lBQzVDLFNBQVMsQ0FBQyxXQUFXLENBQUMsZUFBZSxDQUFDO1NBQ3pDLEVBQ0QsR0FBRyxvQkFBb0IsQ0FBQyxLQUFLLE9BQU8sRUFDcEMsZUFBZSxDQUFDLFNBQVMsRUFDekIsTUFBTSxFQUNOLFNBQVMsQ0FBQyxDQUFDO0lBQ25CLENBQUM7SUFFRCxJQUFJLGdCQUFnQjtRQUNoQixPQUFPLEdBQUcsb0JBQW9CLENBQUMsS0FBSyxjQUFjLENBQUM7SUFDdkQsQ0FBQztJQUVELFNBQVM7UUFDTCxPQUFPLElBQUksb0JBQW9CLENBQUMsSUFBSSxDQUFDLGdCQUFnQixFQUFFLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUN0RSxDQUFDO0lBRUQsY0FBYztRQUNWLE9BQU8sVUFBVSxDQUFDLHVCQUF1QixDQUFDO0lBQzlDLENBQUM7SUFFUyxxQkFBcUIsQ0FBQyxnQkFBNkI7UUFDekQsT0FBTyxnQkFBZ0IsQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDNUMsQ0FBQztJQUVTLHVCQUF1QixDQUFDLEtBQWM7UUFDNUMsT0FBTyxFQUFFLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDN0IsQ0FBQzs7QUFyQ3VCLDBCQUFLLEdBQUcsdUNBQXVDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgbW9tZW50LCB7TW9tZW50fSBmcm9tICdtb21lbnQnO1xuaW1wb3J0IHtPcGVyYXRvclNlcnZpY2V9IGZyb20gJy4uLy4uLy4uL29wZXJhdG9yLXNlcnZpY2Uvb3BlcmF0b3Iuc2VydmljZSc7XG5pbXBvcnQge0xvZ2dlclNlcnZpY2V9IGZyb20gJy4uLy4uLy4uLy4uL2xvZ2dlci9zZXJ2aWNlcy9sb2dnZXIuc2VydmljZSc7XG5pbXBvcnQge1NlYXJjaElucHV0VHlwZX0gZnJvbSAnLi4vc2VhcmNoLWlucHV0LXR5cGUnO1xuaW1wb3J0IHtOb0NvbmZpZ3VyYXRpb25DYXRlZ29yeX0gZnJvbSAnLi4vbm8tY29uZmlndXJhdGlvbi1jYXRlZ29yeSc7XG5pbXBvcnQge0NhdGVnb3JpZXN9IGZyb20gJy4uL2NhdGVnb3JpZXMnO1xuaW1wb3J0IHtGb3JtQ29udHJvbH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHtPYnNlcnZhYmxlLCBvZn0gZnJvbSAncnhqcyc7XG5pbXBvcnQge0VxdWFsc0RhdGVUaW1lfSBmcm9tICcuLi8uLi9vcGVyYXRvci9lcXVhbHMtZGF0ZS10aW1lJztcbmltcG9ydCB7TW9yZVRoYW5EYXRlVGltZX0gZnJvbSAnLi4vLi4vb3BlcmF0b3IvbW9yZS10aGFuLWRhdGUtdGltZSc7XG5pbXBvcnQge01vcmVUaGFuRXF1YWxEYXRlVGltZX0gZnJvbSAnLi4vLi4vb3BlcmF0b3IvbW9yZS10aGFuLWVxdWFsLWRhdGUtdGltZSc7XG5pbXBvcnQge0xlc3NUaGFuRXF1YWxEYXRlVGltZX0gZnJvbSAnLi4vLi4vb3BlcmF0b3IvbGVzcy10aGFuLWVxdWFsLWRhdGUtdGltZSc7XG5pbXBvcnQge0luUmFuZ2VEYXRlVGltZX0gZnJvbSAnLi4vLi4vb3BlcmF0b3IvaW4tcmFuZ2UtZGF0ZS10aW1lJztcbmltcG9ydCB7TGVzc1RoYW5EYXRlVGltZX0gZnJvbSAnLi4vLi4vb3BlcmF0b3IvbGVzcy10aGFuLWRhdGUtdGltZSc7XG5pbXBvcnQge0Nhc2VTZWFyY2h9IGZyb20gJy4vY2FzZS1zZWFyY2guZW51bSc7XG5pbXBvcnQge05vdEVxdWFsc0RhdGVUaW1lfSBmcm9tICcuLi8uLi9vcGVyYXRvci9ub3QtZXF1YWxzLWRhdGUtdGltZSc7XG5cblxuZXhwb3J0IGNsYXNzIENhc2VDcmVhdGlvbkRhdGVUaW1lIGV4dGVuZHMgTm9Db25maWd1cmF0aW9uQ2F0ZWdvcnk8TW9tZW50PiB7XG5cbiAgICBwcml2YXRlIHN0YXRpYyByZWFkb25seSBfaTE4biA9ICdzZWFyY2guY2F0ZWdvcnkuY2FzZS5jcmVhdGlvbkRhdGVUaW1lJztcblxuICAgIGNvbnN0cnVjdG9yKG9wZXJhdG9yczogT3BlcmF0b3JTZXJ2aWNlLCBsb2dnZXI6IExvZ2dlclNlcnZpY2UpIHtcbiAgICAgICAgc3VwZXIoW0Nhc2VTZWFyY2guQ1JFQVRJT05fREFURV0sXG4gICAgICAgICAgICBbXG4gICAgICAgICAgICAgICAgb3BlcmF0b3JzLmdldE9wZXJhdG9yKEVxdWFsc0RhdGVUaW1lKSxcbiAgICAgICAgICAgICAgICBvcGVyYXRvcnMuZ2V0T3BlcmF0b3IoTm90RXF1YWxzRGF0ZVRpbWUpLFxuICAgICAgICAgICAgICAgIG9wZXJhdG9ycy5nZXRPcGVyYXRvcihNb3JlVGhhbkRhdGVUaW1lKSxcbiAgICAgICAgICAgICAgICBvcGVyYXRvcnMuZ2V0T3BlcmF0b3IoTW9yZVRoYW5FcXVhbERhdGVUaW1lKSxcbiAgICAgICAgICAgICAgICBvcGVyYXRvcnMuZ2V0T3BlcmF0b3IoTGVzc1RoYW5EYXRlVGltZSksXG4gICAgICAgICAgICAgICAgb3BlcmF0b3JzLmdldE9wZXJhdG9yKExlc3NUaGFuRXF1YWxEYXRlVGltZSksXG4gICAgICAgICAgICAgICAgb3BlcmF0b3JzLmdldE9wZXJhdG9yKEluUmFuZ2VEYXRlVGltZSlcbiAgICAgICAgICAgIF0sXG4gICAgICAgICAgICBgJHtDYXNlQ3JlYXRpb25EYXRlVGltZS5faTE4bn0ubmFtZWAsXG4gICAgICAgICAgICBTZWFyY2hJbnB1dFR5cGUuREFURV9USU1FLFxuICAgICAgICAgICAgbG9nZ2VyLFxuICAgICAgICAgICAgb3BlcmF0b3JzKTtcbiAgICB9XG5cbiAgICBnZXQgaW5wdXRQbGFjZWhvbGRlcigpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gYCR7Q2FzZUNyZWF0aW9uRGF0ZVRpbWUuX2kxOG59LnBsYWNlaG9sZGVyYDtcbiAgICB9XG5cbiAgICBkdXBsaWNhdGUoKTogQ2FzZUNyZWF0aW9uRGF0ZVRpbWUge1xuICAgICAgICByZXR1cm4gbmV3IENhc2VDcmVhdGlvbkRhdGVUaW1lKHRoaXMuX29wZXJhdG9yU2VydmljZSwgdGhpcy5fbG9nKTtcbiAgICB9XG5cbiAgICBzZXJpYWxpemVDbGFzcygpOiBDYXRlZ29yaWVzIHwgc3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIENhdGVnb3JpZXMuQ0FTRV9DUkVBVElPTl9EQVRFX1RJTUU7XG4gICAgfVxuXG4gICAgcHJvdGVjdGVkIHNlcmlhbGl6ZU9wZXJhbmRWYWx1ZSh2YWx1ZUZvcm1Db250cm9sOiBGb3JtQ29udHJvbCk6IHVua25vd24ge1xuICAgICAgICByZXR1cm4gdmFsdWVGb3JtQ29udHJvbC52YWx1ZS52YWx1ZU9mKCk7XG4gICAgfVxuXG4gICAgcHJvdGVjdGVkIGRlc2VyaWFsaXplT3BlcmFuZFZhbHVlKHZhbHVlOiB1bmtub3duKTogT2JzZXJ2YWJsZTxhbnk+IHtcbiAgICAgICAgcmV0dXJuIG9mKG1vbWVudCh2YWx1ZSkpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2015/lib/search/models/category/case/case-creation-date.js

@@ -0,0 +1,43 @@
+import moment from 'moment';
+import { EqualsDate } from '../../operator/equals-date';
+import { SearchInputType } from '../search-input-type';
+import { NoConfigurationCategory } from '../no-configuration-category';
+import { NotEqualsDate } from '../../operator/not-equals-date';
+import { MoreThanDate } from '../../operator/more-than-date';
+import { LessThanDate } from '../../operator/less-than-date';
+import { InRangeDate } from '../../operator/in-range-date';
+import { Categories } from '../categories';
+import { of } from 'rxjs';
+import { MoreThanEqualDate } from '../../operator/more-than-equal-date';
+import { LessThanEqualDate } from '../../operator/less-than-equal-date';
+import { CaseSearch } from './case-search.enum';
+export class CaseCreationDate extends NoConfigurationCategory {
+    constructor(operators, logger) {
+        super([CaseSearch.CREATION_DATE], [
+            operators.getOperator(EqualsDate),
+            operators.getOperator(NotEqualsDate),
+            operators.getOperator(MoreThanDate),
+            operators.getOperator(MoreThanEqualDate),
+            operators.getOperator(LessThanDate),
+            operators.getOperator(LessThanEqualDate),
+            operators.getOperator(InRangeDate)
+        ], `${CaseCreationDate._i18n}.name`, SearchInputType.DATE, logger, operators);
+    }
+    get inputPlaceholder() {
+        return `${CaseCreationDate._i18n}.placeholder`;
+    }
+    duplicate() {
+        return new CaseCreationDate(this._operatorService, this._log);
+    }
+    serializeClass() {
+        return Categories.CASE_CREATION_DATE;
+    }
+    serializeOperandValue(valueFormControl) {
+        return valueFormControl.value.valueOf();
+    }
+    deserializeOperandValue(value) {
+        return of(moment(value));
+    }
+}
+CaseCreationDate._i18n = 'search.category.case.creationDate';
+//# sourceMappingURL=data:application/json;base64,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