@netgrif/components-core 6.0.1

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

@@ -0,0 +1,51 @@
+import { __extends } from "tslib";
+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';
+var CaseCreationDate = /** @class */ (function (_super) {
+    __extends(CaseCreationDate, _super);
+    function CaseCreationDate(operators, logger) {
+        return _super.call(this, [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) || this;
+    }
+    Object.defineProperty(CaseCreationDate.prototype, "inputPlaceholder", {
+        get: function () {
+            return CaseCreationDate._i18n + ".placeholder";
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CaseCreationDate.prototype.duplicate = function () {
+        return new CaseCreationDate(this._operatorService, this._log);
+    };
+    CaseCreationDate.prototype.serializeClass = function () {
+        return Categories.CASE_CREATION_DATE;
+    };
+    CaseCreationDate.prototype.serializeOperandValue = function (valueFormControl) {
+        return valueFormControl.value.valueOf();
+    };
+    CaseCreationDate.prototype.deserializeOperandValue = function (value) {
+        return of(moment(value));
+    };
+    CaseCreationDate._i18n = 'search.category.case.creationDate';
+    return CaseCreationDate;
+}(NoConfigurationCategory));
+export { CaseCreationDate };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/category/case/case-dataset.js

@@ -0,0 +1,444 @@
+import { __extends } from "tslib";
+import { Query } from '../../query/query';
+import { SearchInputType } from '../search-input-type';
+import { DatafieldMapKey } from '../../datafield-map-key';
+import { BooleanOperator } from '../../boolean-operator';
+import { CaseProcess } from './case-process';
+import { EqualsDate } from '../../operator/equals-date';
+import { Substring } from '../../operator/substring';
+import { EqualsDateTime } from '../../operator/equals-date-time';
+import { Equals } from '../../operator/equals';
+import { BehaviorSubject, of, ReplaySubject } from 'rxjs';
+import { Category } from '../category';
+import { NotEquals } from '../../operator/not-equals';
+import { MoreThan } from '../../operator/more-than';
+import { LessThan } from '../../operator/less-than';
+import { InRange } from '../../operator/in-range';
+import { IsNull } from '../../operator/is-null';
+import { Like } from '../../operator/like';
+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 { MoreThanDateTime } from '../../operator/more-than-date-time';
+import { LessThanDateTime } from '../../operator/less-than-date-time';
+import { InRangeDateTime } from '../../operator/in-range-date-time';
+import { ConfigurationInput } from '../../configuration-input';
+import { SearchIndex } from '../../search-index';
+import { Categories } from '../categories';
+import moment from 'moment';
+import { MoreThanEqual } from '../../operator/more-than-equal';
+import { LessThanEqual } from '../../operator/less-than-equal';
+import { MoreThanEqualDate } from '../../operator/more-than-equal-date';
+import { LessThanEqualDate } from '../../operator/less-than-equal-date';
+import { MoreThanEqualDateTime } from '../../operator/more-than-equal-date-time';
+import { LessThanEqualDateTime } from '../../operator/less-than-equal-date-time';
+import { UserAutocomplete } from '../user-autocomplete';
+var CaseDataset = /** @class */ (function (_super) {
+    __extends(CaseDataset, _super);
+    function CaseDataset(operators, logger, _optionalDependencies) {
+        var _this = _super.call(this, undefined, undefined, CaseDataset._i18n + ".name", undefined, logger, operators) || this;
+        _this._optionalDependencies = _optionalDependencies;
+        _this._processCategory = _this._optionalDependencies.categoryFactory.get(CaseProcess);
+        _this._processCategory.selectDefaultOperator();
+        _this._datafieldOptions = new Map();
+        _this._userAutocomplete = new UserAutocomplete(_this._optionalDependencies);
+        _this.createDatafieldOptions();
+        _this._DATAFIELD_INPUT = new ConfigurationInput(SearchInputType.AUTOCOMPLETE, 'search.category.case.dataset.placeholder.field', true, _this._datafieldOptions, function (mapKeys, newValue) {
+            return mapKeys.map(function (serializedMapKey) { return DatafieldMapKey.parse(serializedMapKey); })
+                .filter(function (mapKey) { return mapKey.title.toLocaleLowerCase().startsWith(newValue); });
+        });
+        _this._configurationInputs$ = new BehaviorSubject([_this._DATAFIELD_INPUT]);
+        _this._DATAFIELD_INPUT.valueChanges$().subscribe(function (newValue) {
+            if (newValue === undefined || typeof newValue === 'string') {
+                _this._configurationInputs$.next([_this._DATAFIELD_INPUT]);
+            }
+            else if (_this._configurationInputs$.getValue().length === 1) {
+                _this._configurationInputs$.next([_this._DATAFIELD_INPUT, _this._OPERATOR_INPUT]);
+            }
+            _this._operatorFormControl.setValue(undefined);
+        });
+        return _this;
+    }
+    CaseDataset.FieldTypeToInputType = function (fieldType) {
+        switch (fieldType) {
+            case 'date':
+                return SearchInputType.DATE;
+            case 'dateTime':
+                return SearchInputType.DATE_TIME;
+            case 'number':
+                return SearchInputType.NUMBER;
+            case 'boolean':
+                return SearchInputType.BOOLEAN;
+            case 'user':
+                return SearchInputType.AUTOCOMPLETE;
+            default:
+                return SearchInputType.TEXT;
+        }
+    };
+    CaseDataset.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+        this._configurationInputs$.complete();
+        this._datafieldOptionsInitialized$.complete();
+        if (this._allowedNetsSub && !this._allowedNetsSub.closed) {
+            this._allowedNetsSub.unsubscribe();
+        }
+        this._processCategory.destroy();
+    };
+    Object.defineProperty(CaseDataset.prototype, "configurationInputs$", {
+        get: function () {
+            return this._configurationInputs$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CaseDataset.prototype, "inputType", {
+        get: function () {
+            if (!this.hasSelectedDatafields) {
+                throw new Error('Input type of arguments cannot be determined before selecting a data field during the configuration.');
+            }
+            return CaseDataset.FieldTypeToInputType(this._selectedDatafields[0].fieldType);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CaseDataset.prototype, "allowedOperators", {
+        /**
+         * The allowed operators are dependant on the selected data field.
+         *
+         * Beware that if you want to change the order of the allowed operators, then you must also update the
+         * [selectDefaultOperator()]{@link Category#selectDefaultOperator} method, so that default operator for each data field type matches
+         * the default operator of the {@link CaseSimpleDataset} search category. Otherwise the transition of header search into the search GUI
+         * won't work properly.
+         */
+        get: function () {
+            if (!this.hasSelectedDatafields) {
+                return [];
+            }
+            switch (this._selectedDatafields[0].fieldType) {
+                case 'number':
+                    return [
+                        this._operatorService.getOperator(Equals),
+                        this._operatorService.getOperator(NotEquals),
+                        this._operatorService.getOperator(MoreThan),
+                        this._operatorService.getOperator(MoreThanEqual),
+                        this._operatorService.getOperator(LessThan),
+                        this._operatorService.getOperator(LessThanEqual),
+                        this._operatorService.getOperator(InRange),
+                        this._operatorService.getOperator(IsNull)
+                    ];
+                case 'boolean':
+                    return [
+                        this._operatorService.getOperator(Equals),
+                        this._operatorService.getOperator(NotEquals)
+                    ];
+                case 'user':
+                case 'userList':
+                    return [
+                        this._operatorService.getOperator(Equals),
+                        this._operatorService.getOperator(NotEquals),
+                        this._operatorService.getOperator(IsNull)
+                    ];
+                case 'date':
+                    return [
+                        this._operatorService.getOperator(EqualsDate),
+                        this._operatorService.getOperator(NotEqualsDate),
+                        this._operatorService.getOperator(MoreThanDate),
+                        this._operatorService.getOperator(MoreThanEqualDate),
+                        this._operatorService.getOperator(LessThanDate),
+                        this._operatorService.getOperator(LessThanEqualDate),
+                        this._operatorService.getOperator(InRangeDate),
+                        this._operatorService.getOperator(IsNull)
+                    ];
+                case 'dateTime':
+                    return [
+                        this._operatorService.getOperator(EqualsDateTime),
+                        this._operatorService.getOperator(MoreThanDateTime),
+                        this._operatorService.getOperator(MoreThanEqualDateTime),
+                        this._operatorService.getOperator(LessThanDateTime),
+                        this._operatorService.getOperator(LessThanEqualDateTime),
+                        this._operatorService.getOperator(InRangeDateTime),
+                        this._operatorService.getOperator(IsNull)
+                    ];
+                default:
+                    return [
+                        this._operatorService.getOperator(Substring),
+                        this._operatorService.getOperator(Equals),
+                        this._operatorService.getOperator(NotEquals),
+                        this._operatorService.getOperator(IsNull),
+                        this._operatorService.getOperator(Like)
+                    ];
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CaseDataset.prototype, "displayBold", {
+        /**
+         * @returns `CaseDataset` category is not displayed in bold for better readability
+         */
+        get: function () {
+            return false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CaseDataset.prototype, "hasSelectedDatafields", {
+        get: function () {
+            return this._DATAFIELD_INPUT.isOptionSelected;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CaseDataset.prototype, "_selectedDatafields", {
+        get: function () {
+            return this._datafieldOptions.get(this._DATAFIELD_INPUT.formControl.value.value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CaseDataset.prototype.reset = function () {
+        _super.prototype.reset.call(this);
+        this._DATAFIELD_INPUT.clear();
+    };
+    CaseDataset.prototype.duplicate = function () {
+        return new CaseDataset(this._operatorService, this._log, this._optionalDependencies);
+    };
+    Object.defineProperty(CaseDataset.prototype, "elasticKeywords", {
+        get: function () {
+            var _this = this;
+            if (!this.hasSelectedDatafields) {
+                return [];
+            }
+            else {
+                return this._selectedDatafields.map(function (datafield) { return _this.resolveElasticKeyword(datafield); });
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CaseDataset.prototype.resolveElasticKeyword = function (datafield) {
+        var resolver = this._optionalDependencies.searchIndexResolver;
+        switch (datafield.fieldType) {
+            case 'number':
+                return resolver.getIndex(datafield.fieldId, SearchIndex.NUMBER);
+            case 'date':
+            case 'dateTime':
+                return resolver.getIndex(datafield.fieldId, SearchIndex.TIMESTAMP);
+            case 'boolean':
+                return resolver.getIndex(datafield.fieldId, SearchIndex.BOOLEAN);
+            case 'file':
+            case 'fileList':
+                return resolver.getIndex(datafield.fieldId, SearchIndex.FILE_NAME, this.isSelectedOperator(Equals) || this.isSelectedOperator(NotEquals));
+            case 'user':
+            case 'userList':
+                return resolver.getIndex(datafield.fieldId, SearchIndex.USER_ID);
+            default:
+                return resolver.getIndex(datafield.fieldId, SearchIndex.FULLTEXT, this.isSelectedOperator(Equals) || this.isSelectedOperator(NotEquals));
+        }
+    };
+    Object.defineProperty(CaseDataset.prototype, "inputPlaceholder", {
+        get: function () {
+            if (!this.hasSelectedDatafields) {
+                return CaseDataset._i18n + ".placeholder.field";
+            }
+            return CaseDataset._i18n + ".placeholder.value";
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CaseDataset.prototype, "datafieldOptionsInitialized$", {
+        get: function () {
+            return this._datafieldOptionsInitialized$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CaseDataset.prototype.generateQuery = function (userInput) {
+        var _this = this;
+        var queryGenerationStrategy;
+        if (this.isSelectedOperator(IsNull)) {
+            queryGenerationStrategy = function (d, _) { return _this.isNullOperatorQueryGenerationStrategy(d); };
+        }
+        else if (this.inputType === SearchInputType.AUTOCOMPLETE) {
+            queryGenerationStrategy = function (d, ui) { return _this.standardQueryGenerationStrategy(d, ui[0], false); };
+        }
+        else {
+            queryGenerationStrategy = function (d, ui) { return _this.standardQueryGenerationStrategy(d, ui); };
+        }
+        var queries = this._selectedDatafields.map(function (datafield) { return queryGenerationStrategy(datafield, userInput); });
+        return Query.combineQueries(queries, BooleanOperator.OR);
+    };
+    CaseDataset.prototype.standardQueryGenerationStrategy = function (datafield, userInput, escapeInput) {
+        if (escapeInput === void 0) { escapeInput = true; }
+        var valueQuery = this.selectedOperator.createQuery(this.elasticKeywords, userInput, escapeInput);
+        var netQuery = this.generateNetConstraint(datafield);
+        return Query.combineQueries([valueQuery, netQuery], BooleanOperator.AND);
+    };
+    CaseDataset.prototype.isNullOperatorQueryGenerationStrategy = function (datafield) {
+        var constraint = this.generateNetConstraint(datafield);
+        return this._operatorService.getOperator(IsNull).createQueryWithConstraint(this.elasticKeywords, constraint);
+    };
+    CaseDataset.prototype.generateNetConstraint = function (datafield) {
+        return this._processCategory.generatePredicate([[datafield.netIdentifier]]).query;
+    };
+    CaseDataset.prototype.createDatafieldOptions = function () {
+        var _this = this;
+        this._datafieldOptionsInitialized$ = new ReplaySubject(1);
+        this._allowedNetsSub = this._optionalDependencies.allowedNetsService.allowedNets$.subscribe(function (allowedNets) {
+            allowedNets.forEach(function (petriNet) {
+                petriNet.immediateData
+                    .filter(function (immediateData) {
+                    return immediateData.title !== undefined
+                        && immediateData.title.trim().length > 0
+                        && !CaseDataset.DISABLED_TYPES.includes(immediateData.type);
+                })
+                    .forEach(function (immediateData) {
+                    var type = immediateData.type;
+                    // for search purposes, enumeration and multichoice maps are equivalent to their simpler counterparts
+                    if (type === 'enumeration_map') {
+                        type = 'enumeration';
+                    }
+                    else if (type === 'multichoice_map') {
+                        type = 'multichoice';
+                    }
+                    _this.addToDatafieldOptionsMap(DatafieldMapKey.serializedForm(immediateData.type, immediateData.title), {
+                        netIdentifier: petriNet.identifier,
+                        fieldId: immediateData.stringId,
+                        fieldType: immediateData.type,
+                    });
+                });
+            });
+            _this._datafieldOptionsInitialized$.next();
+        });
+    };
+    CaseDataset.prototype.filterOptions = function (userInput) {
+        if (!this.hasSelectedDatafields) {
+            throw new Error('The category must be fully configured before attempting to get autocomplete options!');
+        }
+        if (this.inputType !== SearchInputType.AUTOCOMPLETE) {
+            throw new Error('Cannot filter options of non-autocomplete operands');
+        }
+        return this._userAutocomplete.filterOptions(userInput);
+    };
+    CaseDataset.prototype.selectDatafields = function (datafieldMapKey, selectDefaultOperator) {
+        if (selectDefaultOperator === void 0) { selectDefaultOperator = true; }
+        if (!this._datafieldOptions.has(datafieldMapKey)) {
+            this._log.warn("The provided 'datafieldMapKey' (" + datafieldMapKey + ") does not exist.");
+            return;
+        }
+        this._DATAFIELD_INPUT.formControl.setValue(DatafieldMapKey.parse(datafieldMapKey));
+        if (selectDefaultOperator) {
+            this.selectDefaultOperator();
+        }
+    };
+    /**
+     * 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
+     */
+    CaseDataset.prototype.addToDatafieldOptionsMap = function (key, value) {
+        if (this._datafieldOptions.has(key)) {
+            this._datafieldOptions.get(key).push(value);
+        }
+        else {
+            this._datafieldOptions.set(key, [value]);
+        }
+    };
+    CaseDataset.prototype.isOperandValueSelected = function (newValue) {
+        if (!this.isOperatorSelected()) {
+            return false;
+        }
+        var inputType;
+        try {
+            inputType = this.inputType;
+        }
+        catch (e) {
+            return false;
+        }
+        switch (inputType) {
+            case SearchInputType.NUMBER:
+                return typeof newValue === 'number';
+            case SearchInputType.BOOLEAN:
+                return typeof newValue === 'boolean';
+            case SearchInputType.AUTOCOMPLETE:
+                return !(!newValue || typeof newValue === 'string');
+            default:
+                return !!newValue;
+        }
+    };
+    /**
+     * 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.
+     *
+     * @param value the FormControlValue
+     * @returns If the selected data field has input type `AUTOCOMPLETE` then returns the {@link SearchAutocompleteOption} `value`
+     * attribute. Otherwise performs an identity operation.
+     */
+    CaseDataset.prototype.transformCategoryValue = function (value) {
+        if (this.inputType === SearchInputType.AUTOCOMPLETE) {
+            return value.value;
+        }
+        return value;
+    };
+    CaseDataset.prototype.isSelectedOperator = function (operatorClass) {
+        return this.selectedOperator === this._operatorService.getOperator(operatorClass);
+    };
+    CaseDataset.prototype.serializeClass = function () {
+        return Categories.CASE_DATASET;
+    };
+    CaseDataset.prototype.serializeOperandValue = function (valueFormControl) {
+        switch (this.inputType) {
+            case SearchInputType.AUTOCOMPLETE:
+                return this._userAutocomplete.serializeOperandValue(valueFormControl);
+            case SearchInputType.DATE:
+            case SearchInputType.DATE_TIME:
+                return valueFormControl.value.valueOf();
+            default:
+                return _super.prototype.serializeOperandValue.call(this, valueFormControl);
+        }
+    };
+    CaseDataset.prototype.createMetadataConfiguration = function () {
+        var config = _super.prototype.createMetadataConfiguration.call(this);
+        config[CaseDataset.DATAFIELD_METADATA] = this._DATAFIELD_INPUT.formControl.value.toSerializedForm();
+        return config;
+    };
+    CaseDataset.prototype.loadConfigurationFromMetadata = function (configuration) {
+        var _this = this;
+        var result$ = new ReplaySubject(1);
+        this.datafieldOptionsInitialized$.subscribe(function () {
+            var serializedMapKey = configuration[CaseDataset.DATAFIELD_METADATA];
+            _this.selectDatafields(serializedMapKey, false);
+            if (!_this.hasSelectedDatafields) {
+                throw new Error("Searched data fields cannot be restored from the provided configuration (" + serializedMapKey + "). Make sure, that the correct allowed nets are provided in this view.");
+            }
+            _super.prototype.loadConfigurationFromMetadata.call(_this, configuration).subscribe(function () {
+                result$.next();
+                result$.complete();
+            });
+        });
+        return result$.asObservable();
+    };
+    CaseDataset.prototype.deserializeOperandValue = function (value) {
+        switch (this.inputType) {
+            case SearchInputType.AUTOCOMPLETE:
+                return this._userAutocomplete.deserializeOperandValue(value);
+            case SearchInputType.DATE:
+            case SearchInputType.DATE_TIME:
+                return of(moment(value));
+            default:
+                return _super.prototype.deserializeOperandValue.call(this, value);
+        }
+    };
+    CaseDataset.prototype.createConfigurationFilterTextSegments = function () {
+        return [{ segment: this._configurationInputs$.value[0].formControl.value.text, bold: true }];
+    };
+    CaseDataset._i18n = 'search.category.case.dataset';
+    CaseDataset.DISABLED_TYPES = ['button', 'taskRef', 'caseRef', 'filter'];
+    CaseDataset.DATAFIELD_METADATA = 'datafield';
+    CaseDataset.AUTOCOMPLETE_ICON = 'account_circle';
+    return CaseDataset;
+}(Category));
+export { CaseDataset };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"case-dataset.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/models/category/case/case-dataset.ts"],"names":[],"mappings":"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","sourcesContent":["import {OperatorService} from '../../../operator-service/operator.service';\nimport {LoggerService} from '../../../../logger/services/logger.service';\nimport {Operator} from '../../operator/operator';\nimport {Query} from '../../query/query';\nimport {OptionalDependencies} from '../../../category-factory/optional-dependencies';\nimport {SearchInputType} from '../search-input-type';\nimport {DatafieldMapKey} from '../../datafield-map-key';\nimport {SearchAutocompleteOption} from '../search-autocomplete-option';\nimport {BooleanOperator} from '../../boolean-operator';\nimport {CaseProcess} from './case-process';\nimport {EqualsDate} from '../../operator/equals-date';\nimport {Substring} from '../../operator/substring';\nimport {EqualsDateTime} from '../../operator/equals-date-time';\nimport {Equals} from '../../operator/equals';\nimport {BehaviorSubject, Observable, of, ReplaySubject, Subscription} from 'rxjs';\nimport {debounceTime, map, startWith, switchMap} from 'rxjs/operators';\nimport {hasContent} from '../../../../utility/pagination/page-has-content';\nimport {Category} from '../category';\nimport {NotEquals} from '../../operator/not-equals';\nimport {MoreThan} from '../../operator/more-than';\nimport {LessThan} from '../../operator/less-than';\nimport {InRange} from '../../operator/in-range';\nimport {IsNull} from '../../operator/is-null';\nimport {Like} from '../../operator/like';\nimport {NotEqualsDate} from '../../operator/not-equals-date';\nimport {MoreThanDate} from '../../operator/more-than-date';\nimport {LessThanDate} from '../../operator/less-than-date';\nimport {InRangeDate} from '../../operator/in-range-date';\nimport {MoreThanDateTime} from '../../operator/more-than-date-time';\nimport {LessThanDateTime} from '../../operator/less-than-date-time';\nimport {InRangeDateTime} from '../../operator/in-range-date-time';\nimport {AutocompleteOptions} from '../autocomplete-options';\nimport {ConfigurationInput} from '../../configuration-input';\nimport {SearchIndex} from '../../search-index';\nimport {Type} from '@angular/core';\nimport {Categories} from '../categories';\nimport {FormControl} from '@angular/forms';\nimport moment, {Moment} from 'moment';\nimport {CategoryMetadataConfiguration} from '../../persistance/generator-metadata';\nimport {MoreThanEqual} from '../../operator/more-than-equal';\nimport {LessThanEqual} from '../../operator/less-than-equal';\nimport {MoreThanEqualDate} from '../../operator/more-than-equal-date';\nimport {LessThanEqualDate} from '../../operator/less-than-equal-date';\nimport {MoreThanEqualDateTime} from '../../operator/more-than-equal-date-time';\nimport {LessThanEqualDateTime} from '../../operator/less-than-equal-date-time';\nimport {FilterTextSegment} from '../../persistance/filter-text-segment';\nimport {UserAutocomplete} from '../user-autocomplete';\n\ninterface Datafield {\n    netIdentifier: string;\n    fieldId: string;\n    fieldType: string;\n}\n\nexport class CaseDataset extends Category<Datafield> implements AutocompleteOptions {\n\n    private static readonly _i18n = 'search.category.case.dataset';\n    protected static DISABLED_TYPES = ['button', 'taskRef', 'caseRef', 'filter'];\n    protected static readonly DATAFIELD_METADATA = 'datafield';\n    private static readonly AUTOCOMPLETE_ICON = 'account_circle';\n\n    protected readonly _DATAFIELD_INPUT: ConfigurationInput;\n\n    protected _processCategory: CaseProcess;\n\n    protected _configurationInputs$: BehaviorSubject<Array<ConfigurationInput>>;\n\n    protected _datafieldOptions: Map<string, Array<Datafield>>;\n\n    private _datafieldOptionsInitialized$: ReplaySubject<void>;\n    private _allowedNetsSub: Subscription;\n    private _userAutocomplete: UserAutocomplete;\n\n    public static FieldTypeToInputType(fieldType: string): SearchInputType {\n        switch (fieldType) {\n            case 'date':\n                return SearchInputType.DATE;\n            case 'dateTime':\n                return SearchInputType.DATE_TIME;\n            case 'number':\n                return SearchInputType.NUMBER;\n            case 'boolean':\n                return SearchInputType.BOOLEAN;\n            case 'user':\n                return SearchInputType.AUTOCOMPLETE;\n            default:\n                return SearchInputType.TEXT;\n        }\n    }\n\n    constructor(operators: OperatorService, logger: LoggerService, protected _optionalDependencies: OptionalDependencies) {\n        super(undefined,\n            undefined,\n            `${CaseDataset._i18n}.name`,\n            undefined,\n            logger,\n            operators);\n\n        this._processCategory = this._optionalDependencies.categoryFactory.get(CaseProcess) as CaseProcess;\n        this._processCategory.selectDefaultOperator();\n\n        this._datafieldOptions = new Map<string, Array<Datafield>>();\n        this._userAutocomplete = new UserAutocomplete(this._optionalDependencies);\n        this.createDatafieldOptions();\n\n        this._DATAFIELD_INPUT = new ConfigurationInput(\n            SearchInputType.AUTOCOMPLETE,\n            'search.category.case.dataset.placeholder.field',\n            true,\n            this._datafieldOptions,\n            (mapKeys, newValue) => {\n                return mapKeys.map(serializedMapKey => DatafieldMapKey.parse(serializedMapKey))\n                    .filter(mapKey => mapKey.title.toLocaleLowerCase().startsWith(newValue));\n            }\n        );\n\n        this._configurationInputs$ = new BehaviorSubject<Array<ConfigurationInput>>([this._DATAFIELD_INPUT]);\n\n        this._DATAFIELD_INPUT.valueChanges$().subscribe(newValue => {\n            if (newValue === undefined || typeof newValue === 'string') {\n                this._configurationInputs$.next([this._DATAFIELD_INPUT]);\n            } else if (this._configurationInputs$.getValue().length === 1) {\n                this._configurationInputs$.next([this._DATAFIELD_INPUT, this._OPERATOR_INPUT]);\n            }\n            this._operatorFormControl.setValue(undefined);\n        });\n    }\n\n    destroy() {\n        super.destroy();\n        this._configurationInputs$.complete();\n        this._datafieldOptionsInitialized$.complete();\n        if (this._allowedNetsSub && !this._allowedNetsSub.closed) {\n            this._allowedNetsSub.unsubscribe();\n        }\n        this._processCategory.destroy();\n    }\n\n    get configurationInputs$(): Observable<Array<ConfigurationInput>> {\n        return this._configurationInputs$.asObservable();\n    }\n\n    public get inputType(): SearchInputType {\n        if (!this.hasSelectedDatafields) {\n            throw new Error('Input type of arguments cannot be determined before selecting a data field during the configuration.');\n        }\n        return CaseDataset.FieldTypeToInputType(this._selectedDatafields[0].fieldType);\n    }\n\n    /**\n     * The allowed operators are dependant on the selected data field.\n     *\n     * Beware that if you want to change the order of the allowed operators, then you must also update the\n     * [selectDefaultOperator()]{@link Category#selectDefaultOperator} method, so that default operator for each data field type matches\n     * the default operator of the {@link CaseSimpleDataset} search category. Otherwise the transition of header search into the search GUI\n     * won't work properly.\n     */\n    public get allowedOperators(): Array<Operator<any>> {\n        if (!this.hasSelectedDatafields) {\n            return [];\n        }\n        switch (this._selectedDatafields[0].fieldType) {\n            case 'number':\n                return [\n                    this._operatorService.getOperator(Equals),\n                    this._operatorService.getOperator(NotEquals),\n                    this._operatorService.getOperator(MoreThan),\n                    this._operatorService.getOperator(MoreThanEqual),\n                    this._operatorService.getOperator(LessThan),\n                    this._operatorService.getOperator(LessThanEqual),\n                    this._operatorService.getOperator(InRange),\n                    this._operatorService.getOperator(IsNull)\n                ];\n            case 'boolean':\n                return [\n                    this._operatorService.getOperator(Equals),\n                    this._operatorService.getOperator(NotEquals)\n                ];\n            case 'user':\n            case 'userList':\n                return [\n                    this._operatorService.getOperator(Equals),\n                    this._operatorService.getOperator(NotEquals),\n                    this._operatorService.getOperator(IsNull)\n                ];\n            case 'date':\n                return [\n                    this._operatorService.getOperator(EqualsDate),\n                    this._operatorService.getOperator(NotEqualsDate),\n                    this._operatorService.getOperator(MoreThanDate),\n                    this._operatorService.getOperator(MoreThanEqualDate),\n                    this._operatorService.getOperator(LessThanDate),\n                    this._operatorService.getOperator(LessThanEqualDate),\n                    this._operatorService.getOperator(InRangeDate),\n                    this._operatorService.getOperator(IsNull)\n                ];\n            case 'dateTime':\n                return [\n                    this._operatorService.getOperator(EqualsDateTime),\n                    this._operatorService.getOperator(MoreThanDateTime),\n                    this._operatorService.getOperator(MoreThanEqualDateTime),\n                    this._operatorService.getOperator(LessThanDateTime),\n                    this._operatorService.getOperator(LessThanEqualDateTime),\n                    this._operatorService.getOperator(InRangeDateTime),\n                    this._operatorService.getOperator(IsNull)\n                ];\n            default:\n                return [\n                    this._operatorService.getOperator(Substring),\n                    this._operatorService.getOperator(Equals),\n                    this._operatorService.getOperator(NotEquals),\n                    this._operatorService.getOperator(IsNull),\n                    this._operatorService.getOperator(Like)\n                ];\n        }\n    }\n\n    /**\n     * @returns `CaseDataset` category is not displayed in bold for better readability\n     */\n    get displayBold(): boolean {\n        return false;\n    }\n\n    public get hasSelectedDatafields(): boolean {\n        return this._DATAFIELD_INPUT.isOptionSelected;\n    }\n\n    protected get _selectedDatafields(): Array<Datafield> {\n        return this._datafieldOptions.get(this._DATAFIELD_INPUT.formControl.value.value);\n    }\n\n    public reset() {\n        super.reset();\n        this._DATAFIELD_INPUT.clear();\n    }\n\n    duplicate(): CaseDataset {\n        return new CaseDataset(this._operatorService, this._log, this._optionalDependencies);\n    }\n\n    protected get elasticKeywords(): Array<string> {\n        if (!this.hasSelectedDatafields) {\n            return [];\n        } else {\n            return this._selectedDatafields.map(datafield => this.resolveElasticKeyword(datafield));\n        }\n    }\n\n    protected resolveElasticKeyword(datafield: Datafield): string {\n        const resolver = this._optionalDependencies.searchIndexResolver;\n        switch (datafield.fieldType) {\n            case 'number':\n                return resolver.getIndex(datafield.fieldId, SearchIndex.NUMBER);\n            case 'date':\n            case 'dateTime':\n                return resolver.getIndex(datafield.fieldId, SearchIndex.TIMESTAMP);\n            case 'boolean':\n                return resolver.getIndex(datafield.fieldId, SearchIndex.BOOLEAN);\n            case 'file':\n            case 'fileList':\n                return resolver.getIndex(datafield.fieldId, SearchIndex.FILE_NAME,\n                    this.isSelectedOperator(Equals) || this.isSelectedOperator(NotEquals));\n            case 'user':\n            case 'userList':\n                return resolver.getIndex(datafield.fieldId, SearchIndex.USER_ID);\n            default:\n                return resolver.getIndex(datafield.fieldId, SearchIndex.FULLTEXT,\n                    this.isSelectedOperator(Equals) || this.isSelectedOperator(NotEquals));\n        }\n    }\n\n    get inputPlaceholder(): string {\n        if (!this.hasSelectedDatafields) {\n            return `${CaseDataset._i18n}.placeholder.field`;\n        }\n        return `${CaseDataset._i18n}.placeholder.value`;\n    }\n\n    protected get datafieldOptionsInitialized$(): Observable<void> {\n        return this._datafieldOptionsInitialized$.asObservable();\n    }\n\n    protected generateQuery(userInput: Array<unknown>): Query {\n        let queryGenerationStrategy;\n        if (this.isSelectedOperator(IsNull)) {\n            queryGenerationStrategy = (d, _) => this.isNullOperatorQueryGenerationStrategy(d);\n        } else if (this.inputType === SearchInputType.AUTOCOMPLETE) {\n            queryGenerationStrategy = (d, ui) => this.standardQueryGenerationStrategy(d, ui[0], false);\n        } else {\n            queryGenerationStrategy = (d, ui) => this.standardQueryGenerationStrategy(d, ui);\n        }\n\n        const queries = this._selectedDatafields.map(datafield => queryGenerationStrategy(datafield, userInput));\n        return Query.combineQueries(queries, BooleanOperator.OR);\n    }\n\n    protected standardQueryGenerationStrategy(datafield: Datafield, userInput: Array<unknown>, escapeInput = true): Query {\n        const valueQuery = this.selectedOperator.createQuery(this.elasticKeywords, userInput, escapeInput);\n        const netQuery = this.generateNetConstraint(datafield);\n        return Query.combineQueries([valueQuery, netQuery], BooleanOperator.AND);\n    }\n\n    protected isNullOperatorQueryGenerationStrategy(datafield: Datafield): Query {\n        const constraint = this.generateNetConstraint(datafield);\n        return (this._operatorService.getOperator(IsNull) as IsNull).createQueryWithConstraint(this.elasticKeywords, constraint);\n    }\n\n    protected generateNetConstraint(datafield: Datafield): Query {\n        return this._processCategory.generatePredicate([[datafield.netIdentifier]]).query;\n    }\n\n    protected createDatafieldOptions(): void {\n        this._datafieldOptionsInitialized$ = new ReplaySubject<void>(1);\n        this._allowedNetsSub = this._optionalDependencies.allowedNetsService.allowedNets$.subscribe(allowedNets => {\n            allowedNets.forEach(petriNet => {\n                petriNet.immediateData\n                    .filter(immediateData => {\n                        return immediateData.title !== undefined\n                            && immediateData.title.trim().length > 0\n                            && !CaseDataset.DISABLED_TYPES.includes(immediateData.type);\n                    })\n                    .forEach(immediateData => {\n                        let type = immediateData.type;\n\n                        // for search purposes, enumeration and multichoice maps are equivalent to their simpler counterparts\n                        if (type === 'enumeration_map') {\n                            type = 'enumeration';\n                        } else if (type === 'multichoice_map') {\n                            type = 'multichoice';\n                        }\n\n                        this.addToDatafieldOptionsMap(DatafieldMapKey.serializedForm(immediateData.type, immediateData.title), {\n                            netIdentifier: petriNet.identifier,\n                            fieldId: immediateData.stringId,\n                            fieldType: immediateData.type,\n                        });\n                    });\n            });\n            this._datafieldOptionsInitialized$.next();\n        });\n    }\n\n    filterOptions(userInput: Observable<string | SearchAutocompleteOption<Array<string>>>):\n        Observable<Array<SearchAutocompleteOption<Array<string>>>> {\n\n        if (!this.hasSelectedDatafields) {\n            throw new Error('The category must be fully configured before attempting to get autocomplete options!');\n        }\n        if (this.inputType !== SearchInputType.AUTOCOMPLETE) {\n            throw new Error('Cannot filter options of non-autocomplete operands');\n        }\n\n        return this._userAutocomplete.filterOptions(userInput);\n    }\n\n    public selectDatafields(datafieldMapKey: string, selectDefaultOperator = true): void {\n        if (!this._datafieldOptions.has(datafieldMapKey)) {\n            this._log.warn(`The provided 'datafieldMapKey' (${datafieldMapKey}) does not exist.`);\n            return;\n        }\n        this._DATAFIELD_INPUT.formControl.setValue(DatafieldMapKey.parse(datafieldMapKey));\n        if (selectDefaultOperator) {\n            this.selectDefaultOperator();\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 addToDatafieldOptionsMap(key: string, value: Datafield): void {\n        if (this._datafieldOptions.has(key)) {\n            this._datafieldOptions.get(key).push(value);\n        } else {\n            this._datafieldOptions.set(key, [value]);\n        }\n    }\n\n    protected isOperandValueSelected(newValue: any): boolean {\n        if (!this.isOperatorSelected()) {\n            return false;\n        }\n        let inputType: SearchInputType;\n        try {\n            inputType = this.inputType;\n        } catch (e) {\n            return false;\n        }\n\n        switch (inputType) {\n            case SearchInputType.NUMBER:\n                return typeof newValue === 'number';\n            case SearchInputType.BOOLEAN:\n                return typeof newValue === 'boolean';\n            case SearchInputType.AUTOCOMPLETE:\n                return !(!newValue || typeof newValue === 'string');\n            default:\n                return !!newValue;\n        }\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     * @param value the FormControlValue\n     * @returns If the selected data field has input type `AUTOCOMPLETE` then returns the {@link SearchAutocompleteOption} `value`\n     * attribute. Otherwise performs an identity operation.\n     */\n    protected transformCategoryValue(value: any): any {\n        if (this.inputType === SearchInputType.AUTOCOMPLETE) {\n            return (value as SearchAutocompleteOption<Array<number>>).value;\n        }\n        return value;\n    }\n\n    protected isSelectedOperator(operatorClass: Type<any>): boolean {\n        return this.selectedOperator === this._operatorService.getOperator(operatorClass);\n    }\n\n    serializeClass(): Categories | string {\n        return Categories.CASE_DATASET;\n    }\n\n    protected serializeOperandValue(valueFormControl: FormControl): unknown {\n        switch (this.inputType) {\n            case SearchInputType.AUTOCOMPLETE:\n                return this._userAutocomplete.serializeOperandValue(valueFormControl);\n            case SearchInputType.DATE:\n            case SearchInputType.DATE_TIME:\n                return (valueFormControl.value as Moment).valueOf();\n            default:\n                return super.serializeOperandValue(valueFormControl);\n        }\n    }\n\n    protected createMetadataConfiguration(): CategoryMetadataConfiguration {\n        const config = super.createMetadataConfiguration();\n        config[CaseDataset.DATAFIELD_METADATA] = (this._DATAFIELD_INPUT.formControl.value as DatafieldMapKey).toSerializedForm();\n        return config;\n    }\n\n    protected loadConfigurationFromMetadata(configuration: CategoryMetadataConfiguration): Observable<void> {\n        const result$ = new ReplaySubject<void>(1);\n        this.datafieldOptionsInitialized$.subscribe(() => {\n            const serializedMapKey = configuration[CaseDataset.DATAFIELD_METADATA] as string;\n            this.selectDatafields(serializedMapKey, false);\n            if (!this.hasSelectedDatafields) {\n                throw new Error(`Searched data fields cannot be restored from the provided configuration (${serializedMapKey\n                }). Make sure, that the correct allowed nets are provided in this view.`);\n            }\n            super.loadConfigurationFromMetadata(configuration).subscribe(() => {\n                result$.next();\n                result$.complete();\n            });\n        });\n        return result$.asObservable();\n    }\n\n    protected deserializeOperandValue(value: unknown): Observable<any> {\n        switch (this.inputType) {\n            case SearchInputType.AUTOCOMPLETE:\n                return this._userAutocomplete.deserializeOperandValue(value as SearchAutocompleteOption<Array<string>>);\n            case SearchInputType.DATE:\n            case SearchInputType.DATE_TIME:\n                return of(moment(value as string));\n            default:\n                return super.deserializeOperandValue(value);\n        }\n    }\n\n    protected createConfigurationFilterTextSegments(): Array<FilterTextSegment> {\n        return [{segment: this._configurationInputs$.value[0].formControl.value.text, bold: true}];\n    }\n}\n"]}

package/esm5/lib/search/models/category/case/case-net-attribute-autocomplete-category.js

@@ -0,0 +1,28 @@
+import { __extends } from "tslib";
+import { NetAttributeAutocompleteCategory } from '../net-attribute-autocomplete-category';
+import { CaseProcess } from './case-process';
+/**
+ * Utility class with the same use as its parent but witch Case search specific methods implemented.
+ */
+var CaseNetAttributeAutocompleteCategory = /** @class */ (function (_super) {
+    __extends(CaseNetAttributeAutocompleteCategory, _super);
+    function CaseNetAttributeAutocompleteCategory(elasticKeywords, allowedOperators, translationPath, log, operatorService, optionalDependencies) {
+        var _this = _super.call(this, elasticKeywords, allowedOperators, translationPath, log, operatorService, optionalDependencies) || this;
+        _this._processCategory = optionalDependencies.categoryFactory.get(CaseProcess);
+        _this._processCategory.selectDefaultOperator();
+        return _this;
+    }
+    CaseNetAttributeAutocompleteCategory.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+        this._processCategory.destroy();
+    };
+    CaseNetAttributeAutocompleteCategory.prototype.getProcessCategory = function () {
+        return this._processCategory;
+    };
+    CaseNetAttributeAutocompleteCategory.prototype.getPetriNetIdentifier = function (net) {
+        return net.identifier;
+    };
+    return CaseNetAttributeAutocompleteCategory;
+}(NetAttributeAutocompleteCategory));
+export { CaseNetAttributeAutocompleteCategory };
+//# sourceMappingURL=data:application/json;base64,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