@netgrif/components-core 6.0.1

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

@@ -0,0 +1,397 @@
+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';
+export class CaseDataset extends Category {
+    constructor(operators, logger, _optionalDependencies) {
+        super(undefined, undefined, `${CaseDataset._i18n}.name`, undefined, logger, operators);
+        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, (mapKeys, newValue) => {
+            return mapKeys.map(serializedMapKey => DatafieldMapKey.parse(serializedMapKey))
+                .filter(mapKey => mapKey.title.toLocaleLowerCase().startsWith(newValue));
+        });
+        this._configurationInputs$ = new BehaviorSubject([this._DATAFIELD_INPUT]);
+        this._DATAFIELD_INPUT.valueChanges$().subscribe(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);
+        });
+    }
+    static FieldTypeToInputType(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;
+        }
+    }
+    destroy() {
+        super.destroy();
+        this._configurationInputs$.complete();
+        this._datafieldOptionsInitialized$.complete();
+        if (this._allowedNetsSub && !this._allowedNetsSub.closed) {
+            this._allowedNetsSub.unsubscribe();
+        }
+        this._processCategory.destroy();
+    }
+    get configurationInputs$() {
+        return this._configurationInputs$.asObservable();
+    }
+    get inputType() {
+        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);
+    }
+    /**
+     * 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 allowedOperators() {
+        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)
+                ];
+        }
+    }
+    /**
+     * @returns `CaseDataset` category is not displayed in bold for better readability
+     */
+    get displayBold() {
+        return false;
+    }
+    get hasSelectedDatafields() {
+        return this._DATAFIELD_INPUT.isOptionSelected;
+    }
+    get _selectedDatafields() {
+        return this._datafieldOptions.get(this._DATAFIELD_INPUT.formControl.value.value);
+    }
+    reset() {
+        super.reset();
+        this._DATAFIELD_INPUT.clear();
+    }
+    duplicate() {
+        return new CaseDataset(this._operatorService, this._log, this._optionalDependencies);
+    }
+    get elasticKeywords() {
+        if (!this.hasSelectedDatafields) {
+            return [];
+        }
+        else {
+            return this._selectedDatafields.map(datafield => this.resolveElasticKeyword(datafield));
+        }
+    }
+    resolveElasticKeyword(datafield) {
+        const 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));
+        }
+    }
+    get inputPlaceholder() {
+        if (!this.hasSelectedDatafields) {
+            return `${CaseDataset._i18n}.placeholder.field`;
+        }
+        return `${CaseDataset._i18n}.placeholder.value`;
+    }
+    get datafieldOptionsInitialized$() {
+        return this._datafieldOptionsInitialized$.asObservable();
+    }
+    generateQuery(userInput) {
+        let queryGenerationStrategy;
+        if (this.isSelectedOperator(IsNull)) {
+            queryGenerationStrategy = (d, _) => this.isNullOperatorQueryGenerationStrategy(d);
+        }
+        else if (this.inputType === SearchInputType.AUTOCOMPLETE) {
+            queryGenerationStrategy = (d, ui) => this.standardQueryGenerationStrategy(d, ui[0], false);
+        }
+        else {
+            queryGenerationStrategy = (d, ui) => this.standardQueryGenerationStrategy(d, ui);
+        }
+        const queries = this._selectedDatafields.map(datafield => queryGenerationStrategy(datafield, userInput));
+        return Query.combineQueries(queries, BooleanOperator.OR);
+    }
+    standardQueryGenerationStrategy(datafield, userInput, escapeInput = true) {
+        const valueQuery = this.selectedOperator.createQuery(this.elasticKeywords, userInput, escapeInput);
+        const netQuery = this.generateNetConstraint(datafield);
+        return Query.combineQueries([valueQuery, netQuery], BooleanOperator.AND);
+    }
+    isNullOperatorQueryGenerationStrategy(datafield) {
+        const constraint = this.generateNetConstraint(datafield);
+        return this._operatorService.getOperator(IsNull).createQueryWithConstraint(this.elasticKeywords, constraint);
+    }
+    generateNetConstraint(datafield) {
+        return this._processCategory.generatePredicate([[datafield.netIdentifier]]).query;
+    }
+    createDatafieldOptions() {
+        this._datafieldOptionsInitialized$ = new ReplaySubject(1);
+        this._allowedNetsSub = this._optionalDependencies.allowedNetsService.allowedNets$.subscribe(allowedNets => {
+            allowedNets.forEach(petriNet => {
+                petriNet.immediateData
+                    .filter(immediateData => {
+                    return immediateData.title !== undefined
+                        && immediateData.title.trim().length > 0
+                        && !CaseDataset.DISABLED_TYPES.includes(immediateData.type);
+                })
+                    .forEach(immediateData => {
+                    let 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();
+        });
+    }
+    filterOptions(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);
+    }
+    selectDatafields(datafieldMapKey, 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
+     */
+    addToDatafieldOptionsMap(key, value) {
+        if (this._datafieldOptions.has(key)) {
+            this._datafieldOptions.get(key).push(value);
+        }
+        else {
+            this._datafieldOptions.set(key, [value]);
+        }
+    }
+    isOperandValueSelected(newValue) {
+        if (!this.isOperatorSelected()) {
+            return false;
+        }
+        let 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.
+     */
+    transformCategoryValue(value) {
+        if (this.inputType === SearchInputType.AUTOCOMPLETE) {
+            return value.value;
+        }
+        return value;
+    }
+    isSelectedOperator(operatorClass) {
+        return this.selectedOperator === this._operatorService.getOperator(operatorClass);
+    }
+    serializeClass() {
+        return Categories.CASE_DATASET;
+    }
+    serializeOperandValue(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.serializeOperandValue(valueFormControl);
+        }
+    }
+    createMetadataConfiguration() {
+        const config = super.createMetadataConfiguration();
+        config[CaseDataset.DATAFIELD_METADATA] = this._DATAFIELD_INPUT.formControl.value.toSerializedForm();
+        return config;
+    }
+    loadConfigurationFromMetadata(configuration) {
+        const result$ = new ReplaySubject(1);
+        this.datafieldOptionsInitialized$.subscribe(() => {
+            const 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.loadConfigurationFromMetadata(configuration).subscribe(() => {
+                result$.next();
+                result$.complete();
+            });
+        });
+        return result$.asObservable();
+    }
+    deserializeOperandValue(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.deserializeOperandValue(value);
+        }
+    }
+    createConfigurationFilterTextSegments() {
+        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';
+//# 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":"AAGA,OAAO,EAAC,KAAK,EAAC,MAAM,mBAAmB,CAAC;AAExC,OAAO,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAC,eAAe,EAAC,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAC,eAAe,EAAC,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAC,UAAU,EAAC,MAAM,4BAA4B,CAAC;AACtD,OAAO,EAAC,SAAS,EAAC,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAC,cAAc,EAAC,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAC7C,OAAO,EAAC,eAAe,EAAc,EAAE,EAAE,aAAa,EAAe,MAAM,MAAM,CAAC;AAGlF,OAAO,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAC;AACrC,OAAO,EAAC,SAAS,EAAC,MAAM,2BAA2B,CAAC;AACpD,OAAO,EAAC,QAAQ,EAAC,MAAM,0BAA0B,CAAC;AAClD,OAAO,EAAC,QAAQ,EAAC,MAAM,0BAA0B,CAAC;AAClD,OAAO,EAAC,OAAO,EAAC,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAAC,MAAM,EAAC,MAAM,wBAAwB,CAAC;AAC9C,OAAO,EAAC,IAAI,EAAC,MAAM,qBAAqB,CAAC;AACzC,OAAO,EAAC,aAAa,EAAC,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAC,YAAY,EAAC,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAC,YAAY,EAAC,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAC,WAAW,EAAC,MAAM,8BAA8B,CAAC;AACzD,OAAO,EAAC,gBAAgB,EAAC,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAC,gBAAgB,EAAC,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAC,eAAe,EAAC,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAAC,kBAAkB,EAAC,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAEzC,OAAO,MAAgB,MAAM,QAAQ,CAAC;AAEtC,OAAO,EAAC,aAAa,EAAC,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAC,aAAa,EAAC,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAC,iBAAiB,EAAC,MAAM,qCAAqC,CAAC;AACtE,OAAO,EAAC,iBAAiB,EAAC,MAAM,qCAAqC,CAAC;AACtE,OAAO,EAAC,qBAAqB,EAAC,MAAM,0CAA0C,CAAC;AAC/E,OAAO,EAAC,qBAAqB,EAAC,MAAM,0CAA0C,CAAC;AAE/E,OAAO,EAAC,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AAQtD,MAAM,OAAO,WAAY,SAAQ,QAAmB;IAoChD,YAAY,SAA0B,EAAE,MAAqB,EAAY,qBAA2C;QAChH,KAAK,CAAC,SAAS,EACX,SAAS,EACT,GAAG,WAAW,CAAC,KAAK,OAAO,EAC3B,SAAS,EACT,MAAM,EACN,SAAS,CAAC,CAAC;QANsD,0BAAqB,GAArB,qBAAqB,CAAsB;QAQhH,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,qBAAqB,CAAC,eAAe,CAAC,GAAG,CAAC,WAAW,CAAgB,CAAC;QACnG,IAAI,CAAC,gBAAgB,CAAC,qBAAqB,EAAE,CAAC;QAE9C,IAAI,CAAC,iBAAiB,GAAG,IAAI,GAAG,EAA4B,CAAC;QAC7D,IAAI,CAAC,iBAAiB,GAAG,IAAI,gBAAgB,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QAC1E,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAE9B,IAAI,CAAC,gBAAgB,GAAG,IAAI,kBAAkB,CAC1C,eAAe,CAAC,YAAY,EAC5B,gDAAgD,EAChD,IAAI,EACJ,IAAI,CAAC,iBAAiB,EACtB,CAAC,OAAO,EAAE,QAAQ,EAAE,EAAE;YAClB,OAAO,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;iBAC1E,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,iBAAiB,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC;QACjF,CAAC,CACJ,CAAC;QAEF,IAAI,CAAC,qBAAqB,GAAG,IAAI,eAAe,CAA4B,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC;QAErG,IAAI,CAAC,gBAAgB,CAAC,aAAa,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE;YACvD,IAAI,QAAQ,KAAK,SAAS,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE;gBACxD,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC;aAC5D;iBAAM,IAAI,IAAI,CAAC,qBAAqB,CAAC,QAAQ,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE;gBAC3D,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;aAClF;YACD,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACP,CAAC;IArDM,MAAM,CAAC,oBAAoB,CAAC,SAAiB;QAChD,QAAQ,SAAS,EAAE;YACf,KAAK,MAAM;gBACP,OAAO,eAAe,CAAC,IAAI,CAAC;YAChC,KAAK,UAAU;gBACX,OAAO,eAAe,CAAC,SAAS,CAAC;YACrC,KAAK,QAAQ;gBACT,OAAO,eAAe,CAAC,MAAM,CAAC;YAClC,KAAK,SAAS;gBACV,OAAO,eAAe,CAAC,OAAO,CAAC;YACnC,KAAK,MAAM;gBACP,OAAO,eAAe,CAAC,YAAY,CAAC;YACxC;gBACI,OAAO,eAAe,CAAC,IAAI,CAAC;SACnC;IACL,CAAC;IAwCD,OAAO;QACH,KAAK,CAAC,OAAO,EAAE,CAAC;QAChB,IAAI,CAAC,qBAAqB,CAAC,QAAQ,EAAE,CAAC;QACtC,IAAI,CAAC,6BAA6B,CAAC,QAAQ,EAAE,CAAC;QAC9C,IAAI,IAAI,CAAC,eAAe,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE;YACtD,IAAI,CAAC,eAAe,CAAC,WAAW,EAAE,CAAC;SACtC;QACD,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;IACpC,CAAC;IAED,IAAI,oBAAoB;QACpB,OAAO,IAAI,CAAC,qBAAqB,CAAC,YAAY,EAAE,CAAC;IACrD,CAAC;IAED,IAAW,SAAS;QAChB,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE;YAC7B,MAAM,IAAI,KAAK,CAAC,sGAAsG,CAAC,CAAC;SAC3H;QACD,OAAO,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IACnF,CAAC;IAED;;;;;;;OAOG;IACH,IAAW,gBAAgB;QACvB,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE;YAC7B,OAAO,EAAE,CAAC;SACb;QACD,QAAQ,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE;YAC3C,KAAK,QAAQ;gBACT,OAAO;oBACH,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAC;oBACzC,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,SAAS,CAAC;oBAC5C,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,QAAQ,CAAC;oBAC3C,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,aAAa,CAAC;oBAChD,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,QAAQ,CAAC;oBAC3C,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,aAAa,CAAC;oBAChD,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,OAAO,CAAC;oBAC1C,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAC;iBAC5C,CAAC;YACN,KAAK,SAAS;gBACV,OAAO;oBACH,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAC;oBACzC,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,SAAS,CAAC;iBAC/C,CAAC;YACN,KAAK,MAAM,CAAC;YACZ,KAAK,UAAU;gBACX,OAAO;oBACH,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAC;oBACzC,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,SAAS,CAAC;oBAC5C,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAC;iBAC5C,CAAC;YACN,KAAK,MAAM;gBACP,OAAO;oBACH,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,UAAU,CAAC;oBAC7C,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,aAAa,CAAC;oBAChD,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,YAAY,CAAC;oBAC/C,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,iBAAiB,CAAC;oBACpD,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,YAAY,CAAC;oBAC/C,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,iBAAiB,CAAC;oBACpD,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,WAAW,CAAC;oBAC9C,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAC;iBAC5C,CAAC;YACN,KAAK,UAAU;gBACX,OAAO;oBACH,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,cAAc,CAAC;oBACjD,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,gBAAgB,CAAC;oBACnD,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,qBAAqB,CAAC;oBACxD,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,gBAAgB,CAAC;oBACnD,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,qBAAqB,CAAC;oBACxD,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,eAAe,CAAC;oBAClD,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAC;iBAC5C,CAAC;YACN;gBACI,OAAO;oBACH,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,SAAS,CAAC;oBAC5C,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAC;oBACzC,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,SAAS,CAAC;oBAC5C,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAC;oBACzC,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,IAAI,CAAC;iBAC1C,CAAC;SACT;IACL,CAAC;IAED;;OAEG;IACH,IAAI,WAAW;QACX,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,IAAW,qBAAqB;QAC5B,OAAO,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,CAAC;IAClD,CAAC;IAED,IAAc,mBAAmB;QAC7B,OAAO,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACrF,CAAC;IAEM,KAAK;QACR,KAAK,CAAC,KAAK,EAAE,CAAC;QACd,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;IAClC,CAAC;IAED,SAAS;QACL,OAAO,IAAI,WAAW,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,qBAAqB,CAAC,CAAC;IACzF,CAAC;IAED,IAAc,eAAe;QACzB,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE;YAC7B,OAAO,EAAE,CAAC;SACb;aAAM;YACH,OAAO,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC,CAAC;SAC3F;IACL,CAAC;IAES,qBAAqB,CAAC,SAAoB;QAChD,MAAM,QAAQ,GAAG,IAAI,CAAC,qBAAqB,CAAC,mBAAmB,CAAC;QAChE,QAAQ,SAAS,CAAC,SAAS,EAAE;YACzB,KAAK,QAAQ;gBACT,OAAO,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;YACpE,KAAK,MAAM,CAAC;YACZ,KAAK,UAAU;gBACX,OAAO,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;YACvE,KAAK,SAAS;gBACV,OAAO,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;YACrE,KAAK,MAAM,CAAC;YACZ,KAAK,UAAU;gBACX,OAAO,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC,SAAS,EAC7D,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;YAC/E,KAAK,MAAM,CAAC;YACZ,KAAK,UAAU;gBACX,OAAO,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;YACrE;gBACI,OAAO,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC,QAAQ,EAC5D,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;SAClF;IACL,CAAC;IAED,IAAI,gBAAgB;QAChB,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE;YAC7B,OAAO,GAAG,WAAW,CAAC,KAAK,oBAAoB,CAAC;SACnD;QACD,OAAO,GAAG,WAAW,CAAC,KAAK,oBAAoB,CAAC;IACpD,CAAC;IAED,IAAc,4BAA4B;QACtC,OAAO,IAAI,CAAC,6BAA6B,CAAC,YAAY,EAAE,CAAC;IAC7D,CAAC;IAES,aAAa,CAAC,SAAyB;QAC7C,IAAI,uBAAuB,CAAC;QAC5B,IAAI,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE;YACjC,uBAAuB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,qCAAqC,CAAC,CAAC,CAAC,CAAC;SACrF;aAAM,IAAI,IAAI,CAAC,SAAS,KAAK,eAAe,CAAC,YAAY,EAAE;YACxD,uBAAuB,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;SAC9F;aAAM;YACH,uBAAuB,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;SACpF;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,uBAAuB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC;QACzG,OAAO,KAAK,CAAC,cAAc,CAAC,OAAO,EAAE,eAAe,CAAC,EAAE,CAAC,CAAC;IAC7D,CAAC;IAES,+BAA+B,CAAC,SAAoB,EAAE,SAAyB,EAAE,WAAW,GAAG,IAAI;QACzG,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;QACnG,MAAM,QAAQ,GAAG,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC;QACvD,OAAO,KAAK,CAAC,cAAc,CAAC,CAAC,UAAU,EAAE,QAAQ,CAAC,EAAE,eAAe,CAAC,GAAG,CAAC,CAAC;IAC7E,CAAC;IAES,qCAAqC,CAAC,SAAoB;QAChE,MAAM,UAAU,GAAG,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC;QACzD,OAAQ,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAY,CAAC,yBAAyB,CAAC,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;IAC7H,CAAC;IAES,qBAAqB,CAAC,SAAoB;QAChD,OAAO,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACtF,CAAC;IAES,sBAAsB;QAC5B,IAAI,CAAC,6BAA6B,GAAG,IAAI,aAAa,CAAO,CAAC,CAAC,CAAC;QAChE,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,qBAAqB,CAAC,kBAAkB,CAAC,YAAY,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE;YACtG,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAC3B,QAAQ,CAAC,aAAa;qBACjB,MAAM,CAAC,aAAa,CAAC,EAAE;oBACpB,OAAO,aAAa,CAAC,KAAK,KAAK,SAAS;2BACjC,aAAa,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC;2BACrC,CAAC,WAAW,CAAC,cAAc,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;gBACpE,CAAC,CAAC;qBACD,OAAO,CAAC,aAAa,CAAC,EAAE;oBACrB,IAAI,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC;oBAE9B,qGAAqG;oBACrG,IAAI,IAAI,KAAK,iBAAiB,EAAE;wBAC5B,IAAI,GAAG,aAAa,CAAC;qBACxB;yBAAM,IAAI,IAAI,KAAK,iBAAiB,EAAE;wBACnC,IAAI,GAAG,aAAa,CAAC;qBACxB;oBAED,IAAI,CAAC,wBAAwB,CAAC,eAAe,CAAC,cAAc,CAAC,aAAa,CAAC,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE;wBACnG,aAAa,EAAE,QAAQ,CAAC,UAAU;wBAClC,OAAO,EAAE,aAAa,CAAC,QAAQ;wBAC/B,SAAS,EAAE,aAAa,CAAC,IAAI;qBAChC,CAAC,CAAC;gBACP,CAAC,CAAC,CAAC;YACX,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,6BAA6B,CAAC,IAAI,EAAE,CAAC;QAC9C,CAAC,CAAC,CAAC;IACP,CAAC;IAED,aAAa,CAAC,SAAuE;QAGjF,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE;YAC7B,MAAM,IAAI,KAAK,CAAC,sFAAsF,CAAC,CAAC;SAC3G;QACD,IAAI,IAAI,CAAC,SAAS,KAAK,eAAe,CAAC,YAAY,EAAE;YACjD,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;SACzE;QAED,OAAO,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;IAC3D,CAAC;IAEM,gBAAgB,CAAC,eAAuB,EAAE,qBAAqB,GAAG,IAAI;QACzE,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE;YAC9C,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,mCAAmC,eAAe,mBAAmB,CAAC,CAAC;YACtF,OAAO;SACV;QACD,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,QAAQ,CAAC,eAAe,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC;QACnF,IAAI,qBAAqB,EAAE;YACvB,IAAI,CAAC,qBAAqB,EAAE,CAAC;SAChC;IACL,CAAC;IAED;;;;;OAKG;IACO,wBAAwB,CAAC,GAAW,EAAE,KAAgB;QAC5D,IAAI,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YACjC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SAC/C;aAAM;YACH,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;SAC5C;IACL,CAAC;IAES,sBAAsB,CAAC,QAAa;QAC1C,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,EAAE;YAC5B,OAAO,KAAK,CAAC;SAChB;QACD,IAAI,SAA0B,CAAC;QAC/B,IAAI;YACA,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;SAC9B;QAAC,OAAO,CAAC,EAAE;YACR,OAAO,KAAK,CAAC;SAChB;QAED,QAAQ,SAAS,EAAE;YACf,KAAK,eAAe,CAAC,MAAM;gBACvB,OAAO,OAAO,QAAQ,KAAK,QAAQ,CAAC;YACxC,KAAK,eAAe,CAAC,OAAO;gBACxB,OAAO,OAAO,QAAQ,KAAK,SAAS,CAAC;YACzC,KAAK,eAAe,CAAC,YAAY;gBAC7B,OAAO,CAAC,CAAC,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC;YACxD;gBACI,OAAO,CAAC,CAAC,QAAQ,CAAC;SACzB;IACL,CAAC;IAED;;;;;;;OAOG;IACO,sBAAsB,CAAC,KAAU;QACvC,IAAI,IAAI,CAAC,SAAS,KAAK,eAAe,CAAC,YAAY,EAAE;YACjD,OAAQ,KAAiD,CAAC,KAAK,CAAC;SACnE;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IAES,kBAAkB,CAAC,aAAwB;QACjD,OAAO,IAAI,CAAC,gBAAgB,KAAK,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IACtF,CAAC;IAED,cAAc;QACV,OAAO,UAAU,CAAC,YAAY,CAAC;IACnC,CAAC;IAES,qBAAqB,CAAC,gBAA6B;QACzD,QAAQ,IAAI,CAAC,SAAS,EAAE;YACpB,KAAK,eAAe,CAAC,YAAY;gBAC7B,OAAO,IAAI,CAAC,iBAAiB,CAAC,qBAAqB,CAAC,gBAAgB,CAAC,CAAC;YAC1E,KAAK,eAAe,CAAC,IAAI,CAAC;YAC1B,KAAK,eAAe,CAAC,SAAS;gBAC1B,OAAQ,gBAAgB,CAAC,KAAgB,CAAC,OAAO,EAAE,CAAC;YACxD;gBACI,OAAO,KAAK,CAAC,qBAAqB,CAAC,gBAAgB,CAAC,CAAC;SAC5D;IACL,CAAC;IAES,2BAA2B;QACjC,MAAM,MAAM,GAAG,KAAK,CAAC,2BAA2B,EAAE,CAAC;QACnD,MAAM,CAAC,WAAW,CAAC,kBAAkB,CAAC,GAAI,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,KAAyB,CAAC,gBAAgB,EAAE,CAAC;QACzH,OAAO,MAAM,CAAC;IAClB,CAAC;IAES,6BAA6B,CAAC,aAA4C;QAChF,MAAM,OAAO,GAAG,IAAI,aAAa,CAAO,CAAC,CAAC,CAAC;QAC3C,IAAI,CAAC,4BAA4B,CAAC,SAAS,CAAC,GAAG,EAAE;YAC7C,MAAM,gBAAgB,GAAG,aAAa,CAAC,WAAW,CAAC,kBAAkB,CAAW,CAAC;YACjF,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;YAC/C,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE;gBAC7B,MAAM,IAAI,KAAK,CAAC,4EAA4E,gBAC5F,wEAAwE,CAAC,CAAC;aAC7E;YACD,KAAK,CAAC,6BAA6B,CAAC,aAAa,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;gBAC9D,OAAO,CAAC,IAAI,EAAE,CAAC;gBACf,OAAO,CAAC,QAAQ,EAAE,CAAC;YACvB,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;QACH,OAAO,OAAO,CAAC,YAAY,EAAE,CAAC;IAClC,CAAC;IAES,uBAAuB,CAAC,KAAc;QAC5C,QAAQ,IAAI,CAAC,SAAS,EAAE;YACpB,KAAK,eAAe,CAAC,YAAY;gBAC7B,OAAO,IAAI,CAAC,iBAAiB,CAAC,uBAAuB,CAAC,KAAgD,CAAC,CAAC;YAC5G,KAAK,eAAe,CAAC,IAAI,CAAC;YAC1B,KAAK,eAAe,CAAC,SAAS;gBAC1B,OAAO,EAAE,CAAC,MAAM,CAAC,KAAe,CAAC,CAAC,CAAC;YACvC;gBACI,OAAO,KAAK,CAAC,uBAAuB,CAAC,KAAK,CAAC,CAAC;SACnD;IACL,CAAC;IAES,qCAAqC;QAC3C,OAAO,CAAC,EAAC,OAAO,EAAE,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAC,CAAC,CAAC;IAC/F,CAAC;;AApauB,iBAAK,GAAG,8BAA8B,CAAC;AAC9C,0BAAc,GAAG,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;AACnD,8BAAkB,GAAG,WAAW,CAAC;AACnC,6BAAiB,GAAG,gBAAgB,CAAC","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/esm2015/lib/search/models/category/case/case-net-attribute-autocomplete-category.js

@@ -0,0 +1,23 @@
+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.
+ */
+export class CaseNetAttributeAutocompleteCategory extends NetAttributeAutocompleteCategory {
+    constructor(elasticKeywords, allowedOperators, translationPath, log, operatorService, optionalDependencies) {
+        super(elasticKeywords, allowedOperators, translationPath, log, operatorService, optionalDependencies);
+        this._processCategory = optionalDependencies.categoryFactory.get(CaseProcess);
+        this._processCategory.selectDefaultOperator();
+    }
+    destroy() {
+        super.destroy();
+        this._processCategory.destroy();
+    }
+    getProcessCategory() {
+        return this._processCategory;
+    }
+    getPetriNetIdentifier(net) {
+        return net.identifier;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,73 @@
+import { Query } from '../../query/query';
+import { Equals } from '../../operator/equals';
+import { BooleanOperator } from '../../boolean-operator';
+import { NoConfigurationAutocompleteCategory } from '../no-configuration-autocomplete-category';
+import { NotEquals } from '../../operator/not-equals';
+import { Categories } from '../categories';
+import { CaseSearch } from './case-search.enum';
+export class CaseProcess extends NoConfigurationAutocompleteCategory {
+    constructor(operators, logger, _optionalDependencies) {
+        super([CaseSearch.PROCESS_IDENTIFIER], [operators.getOperator(Equals), operators.getOperator(NotEquals)], `${CaseProcess._i18n}.name`, logger, operators);
+        this._optionalDependencies = _optionalDependencies;
+        this._uniqueOptionsMap = new Map();
+    }
+    destroy() {
+        super.destroy();
+        if (this._allowedNetsSub && !this._allowedNetsSub.closed) {
+            this._allowedNetsSub.unsubscribe();
+        }
+        this._destroyed = true;
+    }
+    createOptions() {
+        if (this._destroyed) {
+            return;
+        }
+        this._allowedNetsSub = this._optionalDependencies.allowedNetsService.allowedNets$.subscribe(allowedNets => {
+            this._optionsMap.clear();
+            allowedNets.forEach(petriNet => {
+                if (this.isUniqueOption(petriNet.title, petriNet.identifier)) {
+                    this.addToMap(petriNet.title, petriNet.identifier);
+                }
+            });
+            this.updateOptions();
+        });
+    }
+    /**
+     * Checks whether the provided option is unique and updates the list of unique options with it.
+     * @param key autocomplete option key
+     * @param value autocomplete option value
+     * @returns `true` if the option has not yet been checked as unique. `false` if the option has been checked before.
+     */
+    isUniqueOption(key, value) {
+        if (!this._uniqueOptionsMap.has(key)) {
+            this._uniqueOptionsMap.set(key, new Set([value]));
+            return true;
+        }
+        if (this._uniqueOptionsMap.get(key).has(value)) {
+            return false;
+        }
+        else {
+            this._uniqueOptionsMap.get(key).add(value);
+            return true;
+        }
+    }
+    generateQuery(userInput) {
+        if (this.selectedOperator.numberOfOperands !== 1) {
+            throw new Error('Only unary operators are currently supported by the CaseProcess implementation');
+        }
+        const operand = userInput[0];
+        const queries = operand.map(id => this.selectedOperator.createQuery(this.elasticKeywords, [id]));
+        return Query.combineQueries(queries, BooleanOperator.OR);
+    }
+    get inputPlaceholder() {
+        return `${CaseProcess._i18n}.placeholder`;
+    }
+    duplicate() {
+        return new CaseProcess(this._operatorService, this._log, this._optionalDependencies);
+    }
+    serializeClass() {
+        return Categories.CASE_PROCESS;
+    }
+}
+CaseProcess._i18n = 'search.category.case.process';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"case-process.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/models/category/case/case-process.ts"],"names":[],"mappings":"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","sourcesContent":["import {Query} from '../../query/query';\nimport {OperatorService} from '../../../operator-service/operator.service';\nimport {LoggerService} from '../../../../logger/services/logger.service';\nimport {Equals} from '../../operator/equals';\nimport {BooleanOperator} from '../../boolean-operator';\nimport {OptionalDependencies} from '../../../category-factory/optional-dependencies';\nimport {NoConfigurationAutocompleteCategory} from '../no-configuration-autocomplete-category';\nimport {NotEquals} from '../../operator/not-equals';\nimport {Categories} from '../categories';\nimport {Subscription} from 'rxjs';\nimport {CaseSearch} from './case-search.enum';\n\nexport class CaseProcess extends NoConfigurationAutocompleteCategory<string> {\n\n    private static readonly _i18n = 'search.category.case.process';\n\n    protected _uniqueOptionsMap: Map<string, Set<string>>;\n    private _allowedNetsSub: Subscription;\n    private _destroyed: boolean;\n\n    constructor(operators: OperatorService, logger: LoggerService, protected _optionalDependencies: OptionalDependencies) {\n        super([CaseSearch.PROCESS_IDENTIFIER],\n            [operators.getOperator(Equals), operators.getOperator(NotEquals)],\n            `${CaseProcess._i18n}.name`,\n            logger,\n            operators);\n        this._uniqueOptionsMap = new Map<string, Set<string>>();\n    }\n\n    destroy() {\n        super.destroy();\n        if (this._allowedNetsSub && !this._allowedNetsSub.closed) {\n            this._allowedNetsSub.unsubscribe();\n        }\n        this._destroyed = true;\n    }\n\n    protected createOptions(): void {\n        if (this._destroyed) {\n            return;\n        }\n\n        this._allowedNetsSub = this._optionalDependencies.allowedNetsService.allowedNets$.subscribe(allowedNets => {\n            this._optionsMap.clear();\n            allowedNets.forEach(petriNet => {\n                if (this.isUniqueOption(petriNet.title, petriNet.identifier)) {\n                    this.addToMap(petriNet.title, petriNet.identifier);\n                }\n            });\n            this.updateOptions();\n        });\n    }\n\n    /**\n     * Checks whether the provided option is unique and updates the list of unique options with it.\n     * @param key autocomplete option key\n     * @param value autocomplete option value\n     * @returns `true` if the option has not yet been checked as unique. `false` if the option has been checked before.\n     */\n    protected isUniqueOption(key: string, value: string): boolean {\n        if (!this._uniqueOptionsMap.has(key)) {\n            this._uniqueOptionsMap.set(key, new Set<string>([value]));\n            return true;\n        }\n        if (this._uniqueOptionsMap.get(key).has(value)) {\n            return false;\n        } else {\n            this._uniqueOptionsMap.get(key).add(value);\n            return true;\n        }\n    }\n\n    protected generateQuery(userInput: Array<Array<string>>): Query {\n        if (this.selectedOperator.numberOfOperands !== 1) {\n            throw new Error('Only unary operators are currently supported by the CaseProcess implementation');\n        }\n        const operand = userInput[0];\n        const queries = operand.map(id => this.selectedOperator.createQuery(this.elasticKeywords, [id]));\n        return Query.combineQueries(queries, BooleanOperator.OR);\n    }\n\n    get inputPlaceholder(): string {\n        return `${CaseProcess._i18n}.placeholder`;\n    }\n\n    duplicate(): CaseProcess {\n        return new CaseProcess(this._operatorService, this._log, this._optionalDependencies);\n    }\n\n    serializeClass(): Categories | string {\n        return Categories.CASE_PROCESS;\n    }\n}\n"]}

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

@@ -0,0 +1,24 @@
+import { Equals } from '../../operator/equals';
+import { NotEquals } from '../../operator/not-equals';
+import { CaseNetAttributeAutocompleteCategory } from './case-net-attribute-autocomplete-category';
+import { Categories } from '../categories';
+import { CaseSearch } from './case-search.enum';
+export class CaseRole extends CaseNetAttributeAutocompleteCategory {
+    constructor(operators, logger, optionalDependencies) {
+        super([CaseSearch.ENABLED_ROLES], [operators.getOperator(Equals), operators.getOperator(NotEquals)], `${CaseRole._i18n}.name`, logger, operators, optionalDependencies);
+    }
+    extractAttributes(petriNet) {
+        return petriNet.roles.map(r => ({ id: r.stringId, name: r.name }));
+    }
+    get inputPlaceholder() {
+        return `${CaseRole._i18n}.placeholder`;
+    }
+    duplicate() {
+        return new CaseRole(this._operatorService, this._log, this._optionalDependencies);
+    }
+    serializeClass() {
+        return Categories.CASE_ROLE;
+    }
+}
+CaseRole._i18n = 'search.category.case.role';
+//# sourceMappingURL=data:application/json;base64,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