@netgrif/components-core 6.0.1

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

@@ -0,0 +1,524 @@
+import { Operator } from '../operator/operator';
+import { ElementaryPredicate } from '../predicate/elementary-predicate';
+import { SearchInputType } from './search-input-type';
+import { FormControl } from '@angular/forms';
+import { BehaviorSubject, forkJoin, of, ReplaySubject } from 'rxjs';
+import { debounceTime, defaultIfEmpty, map } from 'rxjs/operators';
+import { OperatorTemplatePart } from '../operator-template-part';
+import { IncrementingCounter } from '../../../utility/incrementing-counter';
+import { ConfigurationInput } from '../configuration-input';
+import { ofVoid } from '../../../utility/of-void';
+import { DATE_FORMAT_STRING, DATE_TIME_FORMAT_STRING } from '../../../moment/time-formats';
+/**
+ * The top level of abstraction in search query generation. Represents a set of indexed fields that can be searched.
+ * Encapsulates the the state and logic of the query construction process.
+ *
+ * As opposed to {@link Operator}s Categories are not stateless and shouldn't be shared.
+ * A single Category instance is capable of holding the state of one {@link EditablePredicate},
+ * or can be used as a builder to form an unlimited amount of [ElementaryPredicates]{@link ElementaryPredicate}.
+ *
+ * You can use {@link CategoryFactory} to get instances of Category classes.
+ * Alternatively you can use the [clone()]{@Link Category#clone} method to duplicate an existing instance.
+ *
+ * If you want to make your own Category class you have to make sure that the constructor takes {@link OperatorService} as it's first
+ * argument and {@link LoggerService} as it's second argument. Alternatively you can make your own implementation of the
+ * {@link CategoryFactory} so, that your style of constructors is supported.
+ *
+ * @typeparam T type of objects the category expects to generate queries from
+ */
+export class Category {
+    /**
+     * The constructor fills the values of all protected fields and then calls the [initializeCategory()]{@link Category#initializeCategory}
+     * method. If you want to override the category creation behavior override that method.
+     *
+     * @param _elasticKeywords Elasticsearch keywords that should be queried by queries generated with this category
+     * @param _allowedOperators Operators that can be used to generated queries on the above keywords
+     * @param translationPath path to the translation string
+     * @param _inputType input field type that should be used to enter operator arguments for this category
+     * @param _log used to record information about incorrect use of this class
+     * @param _operatorService used to resolve serialized operators during deserialization
+     */
+    constructor(_elasticKeywords, _allowedOperators, translationPath, _inputType, _log, _operatorService) {
+        this._elasticKeywords = _elasticKeywords;
+        this._allowedOperators = _allowedOperators;
+        this.translationPath = translationPath;
+        this._inputType = _inputType;
+        this._log = _log;
+        this._operatorService = _operatorService;
+        this._OPERATOR_INPUT = new ConfigurationInput(SearchInputType.OPERATOR, 'search.operator.name', false, new Map(), () => {
+            throw new Error('ConfigurationInput of type OPERATOR is a placeholder!'
+                + ' Use operator related methods from the Category class instead.');
+        });
+        this._operatorFormControl = this._OPERATOR_INPUT.formControl;
+        this._operandsFormControls$ = new ReplaySubject(1);
+        this._operatorTemplate$ = new BehaviorSubject(undefined);
+        this._operandsFormControls = [];
+        this._trackByIdGenerator = new IncrementingCounter();
+        this._generatedPredicate$ = new BehaviorSubject(undefined);
+        this.initializeCategory();
+        this.operandsFormControls$.pipe(map(formControls => {
+            if (!formControls) {
+                return undefined;
+            }
+            const parts = this.selectedOperator.getOperatorNameTemplate();
+            const fcs = [...formControls];
+            let first = true;
+            return parts.map(part => {
+                const template = new OperatorTemplatePart(part ? part : fcs.shift(), this._trackByIdGenerator.next(), part ? undefined : first);
+                if (!part) {
+                    first = false;
+                }
+                return template;
+            });
+        })).subscribe(template => {
+            this._operatorTemplate$.next(template);
+        });
+    }
+    /**
+     * Cleans up the internal state of the object before its destruction.
+     *
+     * The developer must call this method at an appropriate moment, as this object cannot hook into the Angular lifecycle.
+     */
+    destroy() {
+        this._operandsFormControls$.complete();
+        this._operatorTemplate$.complete();
+        this._generatedPredicate$.complete();
+    }
+    /**
+     * If you use the `Category` class as a sort of PredicateBuilder, then you want to use the
+     * [generatePredicate()]{@link Category#generatePredicate} method instead.
+     *
+     * This stream publishes either a new `Predicate` object or `undefined` based on changes to the `FormControls` that are
+     * managed by this class. If (based on user input) the `Category` reaches a state when construction of a `Predicate` is possible
+     * it will emit this `Predicate`. If it reaches a state when the `Predicate` can not longer be created `undefined` is emitted.
+     */
+    get generatedPredicate$() {
+        return this._generatedPredicate$.asObservable();
+    }
+    /**
+     * Returns the {@link Predicate} currently generated by the Category.
+     *
+     * For more information see [generatedPredicate$]{@link Category#generatedPredicate$}.
+     */
+    get generatedPredicate() {
+        return this._generatedPredicate$.getValue();
+    }
+    /**
+     * Beware that while most categories always return the same constant it is not a requirement.
+     * An example for such behavior is the {@link CaseDataset} category, where the argument input type depends
+     * on the selected data field type.
+     *
+     * @returns the required input type for arguments for this category
+     */
+    get inputType() {
+        return this._inputType;
+    }
+    /**
+     * @returns the set of Operators that can be used with this category. Iteration order determines the display order.
+     */
+    get allowedOperators() {
+        const result = [];
+        result.push(...this._allowedOperators);
+        return result;
+    }
+    /**
+     * @returns the currently selected operator or `undefined` if no operator is selected.
+     */
+    get selectedOperator() {
+        return this._operatorFormControl.value;
+    }
+    /**
+     * @returns an array of `FormControl` objects that contains as many controls as is the arity of the selected operator.
+     * Calling this method multiple times will return the same `FormControl` instances.
+     * When no operator is selected `undefined` is emitted.
+     */
+    get operandsFormControls$() {
+        return this._operandsFormControls$.asObservable();
+    }
+    /**
+     * A new value is emitted whenever the selected operator changes. `undefined` is emitted if no operator is selected.
+     *
+     * @returns [operators template]{@link Operator#getOperatorNameTemplate} in processed form fit for GUI rendering
+     */
+    get operatorTemplate$() {
+        return this._operatorTemplate$.asObservable();
+    }
+    /**
+     * @returns whether the category is fully configured and represents a valid predicate or not
+     */
+    get providesPredicate() {
+        return !!this._generatedPredicate$.getValue();
+    }
+    /**
+     * @returns the set of Elasticsearch keywords that should be queried by queries generated with this category.
+     * The method can be overridden if the keywords are not static and change based on some additional selection (eg. Data fields)
+     */
+    get elasticKeywords() {
+        const result = [];
+        result.push(...this._elasticKeywords);
+        return result;
+    }
+    /**
+     * @returns the arity of the selected operator. Throws an error if no operator is selected.
+     */
+    get selectedOperatorArity() {
+        if (!this.isOperatorSelected()) {
+            throw new Error('An operator mus be selected before its arity can be resolved!');
+        }
+        return this.selectedOperator.numberOfOperands;
+    }
+    /**
+     * Changes the state of the Category. Category can create queries when an {@link Operator} is selected.
+     *
+     * This method is useful if you want to use the Category class as predicate builder.
+     *
+     * @param operatorIndex index in the [allowedOperators]{@link Category#allowedOperators} array of the {@link Operator} that
+     * should be selected
+     */
+    selectOperator(operatorIndex) {
+        const operators = this.allowedOperators;
+        if (operatorIndex < 0 || operatorIndex >= operators.length) {
+            this._log.warn(`The provided 'operatorIndex' is out of range.`);
+            return;
+        }
+        this._operatorFormControl.setValue(operators[operatorIndex]);
+    }
+    /**
+     * Changes the state of the Category and generates a query if all necessary operands were set.
+     *
+     * If you are using the category as a builder. Consider using the [generatePredicate()]{@link Category#generatePredicate}
+     * method instead.
+     *
+     * @param userInput values entered by the user. The length of the array should match the
+     * [arity]{@link Operator#_numberOfOperands} of the selected Operator.
+     */
+    setOperands(userInput) {
+        const range = Math.min(userInput.length, this._operandsFormControls.length);
+        if (range < userInput.length) {
+            this._log.warn(`${userInput.length} operands are being set, but only ${range} inputs are available!`
+                + ' Extra operands will be ignored.');
+        }
+        for (let i = 0; i < range; i++) {
+            this._operandsFormControls[i].setValue(userInput[i]);
+        }
+        if (range !== 0) {
+            this.operandValueChanges(range - 1);
+        }
+    }
+    /**
+     * Resets the state of the Category, deselecting any selected category and removing other state
+     * information if the Category defines them.
+     *
+     * This method can be used to reset the state of the category after each predicate constructed,
+     * effectively turning the category instance into a predicate builder.
+     */
+    reset() {
+        this.clearOperatorSelection();
+        this._operandsFormControls.forEach(fc => {
+            fc.setValue(undefined);
+        });
+    }
+    /**
+     * Calls the [createQuery]{@link Operator#createQuery} method on the selected Operator.
+     *
+     * Throws an Error if no Operator is selected.
+     *
+     * Override this method if the query should be generated in some other way.
+     * @param userInput values entered by the user. The length of the array should match the
+     * [arity]{@link Operator#_numberOfOperands} of the selected Operator.
+     * @returns the Query generated by the selected Operator
+     */
+    generateQuery(userInput) {
+        if (!this.isOperatorSelected()) {
+            throw new Error('Category cannot generate a Query if no Operator is selected');
+        }
+        return this._operatorFormControl.value.createQuery(this._elasticKeywords, userInput);
+    }
+    /**
+     * Calls the [generateQuery]{@link Category#generateQuery} method and creates an {@link ElementaryPredicate} with the result.
+     * @param userInput values entered by the user. The length of the array should match the
+     * [arity]{@link Operator#_numberOfOperands} of the selected Operator.
+     * @returns Predicate with {@link Query} generated by this object's [generateQuery]{@link Category#generateQuery} method
+     */
+    generatePredicate(userInput) {
+        return new ElementaryPredicate(this.generateQuery(userInput));
+    }
+    /**
+     * Selects the default operator that should be used for query generation, when no Operator selection is provided to the user.
+     *
+     * The default implementation selects the first operator in the [_allowedOperators]{@link Category#allowedOperators} array.
+     *
+     * See [selectOperator()]{@link Category#selectOperator} for more information.
+     */
+    selectDefaultOperator() {
+        this.selectOperator(0);
+    }
+    /**
+     * @returns whether an operator is currently selected or not.
+     */
+    isOperatorSelected() {
+        return !!this._operatorFormControl.value;
+    }
+    /**
+     * Deselects the currently selected operator (if any)
+     */
+    clearOperatorSelection() {
+        this._operatorFormControl.setValue(undefined);
+    }
+    /**
+     * Provides the necessary information for the serialisation of this category's state.
+     *
+     * Not every state must be preservable. The default library implementation supports only the preservation of the final state when the
+     * Category is generating a predicate object.
+     *
+     * @returns an object containing all the necessary information for the reconstruction of this category's state,
+     * barring information about allowed nets. Returns `undefined` if the category is not in a state that generates a predicate.
+     * See [providesPredicate()]{@link Category#providesPredicate}.
+     */
+    createMetadata() {
+        if (!this.providesPredicate) {
+            return undefined;
+        }
+        return {
+            category: this.serializeClass(),
+            configuration: this.createMetadataConfiguration(),
+            values: this.createMetadataValues()
+        };
+    }
+    /**
+     * Restores the saved state contained in the provided metadata.
+     *
+     * @param metadata the metadata created by calling the [createMetadata()]{@link Category#createMetadata} method
+     *
+     * @returns an Observable. When the Observable emits the category has finished restoring its state.
+     */
+    loadFromMetadata(metadata) {
+        const result$ = new ReplaySubject(1);
+        this.loadConfigurationFromMetadata(metadata.configuration).subscribe(() => {
+            this.loadValuesFromMetadata(metadata.values).subscribe(() => {
+                result$.next();
+                result$.complete();
+            });
+        });
+        return result$.asObservable();
+    }
+    /**
+     * This method is calle in the constructor. Apart from calling this method, the constructor only creates instances to fill the protected
+     * fields of this class.
+     *
+     * The default implementation manages creation of operand `FormControl` instances and manages subscriptions to them.
+     *
+     * You can override this method to change the initialization of your category without having to rewrite the base
+     * constructor from scratch.
+     */
+    initializeCategory() {
+        this._operatorFormControl.valueChanges.subscribe((newOperator) => {
+            this._operandsFormControls.forEach(fc => {
+                fc.setValue(undefined);
+            });
+            if (!newOperator) {
+                // undefined is next-ed into the stream. Marked as code smell by sonar when explicitly stated
+                this._operandsFormControls$.next();
+                if (this._operandsFormControls.length === 0) {
+                    this._generatedPredicate$.next(undefined);
+                }
+                return;
+            }
+            if (newOperator.numberOfOperands > this._operandsFormControls.length) {
+                while (this._operandsFormControls.length < newOperator.numberOfOperands) {
+                    const fc = new FormControl();
+                    const currentLength = this._operandsFormControls.length;
+                    fc.valueChanges.pipe(debounceTime(600)).subscribe(() => {
+                        this.operandValueChanges(currentLength);
+                    });
+                    this._operandsFormControls.push(fc);
+                }
+            }
+            this._operandsFormControls$.next(this._operandsFormControls.slice(0, newOperator.numberOfOperands));
+            if (newOperator.numberOfOperands === 0) {
+                this._generatedPredicate$.next(this.generatePredicate([]));
+            }
+        });
+    }
+    /**
+     * The method that is (by default) called whenever an operand `FormControl` changes its value.
+     *
+     * @param operandIndex the index of the operand that changed its value
+     */
+    operandValueChanges(operandIndex) {
+        if (!this.isOperatorSelected()) {
+            this._generatedPredicate$.next(undefined);
+            return;
+        }
+        if (operandIndex >= this.selectedOperatorArity) {
+            return;
+        }
+        for (let i = 0; i < this.selectedOperatorArity; i++) {
+            if (!this.isOperandValueSelected(this._operandsFormControls[i].value)) {
+                if (this._generatedPredicate$.getValue()) {
+                    this._generatedPredicate$.next(undefined);
+                }
+                return;
+            }
+        }
+        this._generatedPredicate$.next(this.generatePredicate(this._operandsFormControls.map(fc => this.transformCategoryValue(fc.value))));
+    }
+    /**
+     * The default implementation serializes only the operator.
+     * If the category contains additional configuration, this method must be extended.
+     *
+     * @returns an object containing all the necessary information for the reconstruction of the configuration of this category instance
+     */
+    createMetadataConfiguration() {
+        return {
+            [Category.OPERATOR_METADATA]: this.selectedOperator.serialize()
+        };
+    }
+    /**
+     * The default implementation returns the value of all operand form control objects up to the current number of operands.
+     * To serialize value of each operand the [serializeOperandValue()]{@link Category#serializeOperandValue} method is used.
+     *
+     * If the values used by this category are not serializable, then either this method, or the `serializeOperandValue` method,
+     * must be overridden.
+     *
+     * @returns an array containing values input by the user in a serializable form
+     */
+    createMetadataValues() {
+        const result = [];
+        for (let i = 0; i < this.selectedOperatorArity; i++) {
+            result.push(this.serializeOperandValue(this._operandsFormControls[i]));
+        }
+        return result;
+    }
+    /**
+     * @param valueFormControl FormControl object of one operand
+     * @returns the value of the operand in a serialized form. The default implementation returns the FormControls `value` attribute.
+     */
+    serializeOperandValue(valueFormControl) {
+        return valueFormControl.value;
+    }
+    /**
+     * Restored the saved configuration from the metadata created by the
+     * [createMetadataConfiguration()]{@link Category#createMetadataConfiguration} method.
+     *
+     * The default implementation restores only the saved operator.
+     *
+     * If the Category overrides the serialization method, it must override this method as well.
+     *
+     * @param configuration the serialized configuration
+     *
+     * @returns an Observable. When the Observable emits the category has finished loading its configuration.
+     */
+    loadConfigurationFromMetadata(configuration) {
+        const resolvedOperator = this._operatorService.getFromMetadata(configuration[Category.OPERATOR_METADATA]);
+        this.selectOperator(this.allowedOperators.findIndex(op => op === resolvedOperator));
+        return ofVoid();
+    }
+    /**
+     * The default implementation sets the provided values into this Category's operand form controls.
+     *
+     * An operator must be set before calling this method! Otherwise an error will be thrown.
+     *
+     * If the number of values doesn't match the arity of the selected operator an error will be thrown!
+     *
+     * If this Category overrides the [serializeOperandValue()]{@link Category#serializeOperandValue}, it must also
+     * override its deserialization counterpart - [deserializeOperandValue()]{@link #Category#deserializeOperandValue}!
+     *
+     * @param values the serialized values that should be loaded into this Category instance
+     *
+     * @returns an Observable. When the Observable emits the category has finished loading its values.
+     */
+    loadValuesFromMetadata(values) {
+        if (!this.isOperatorSelected()) {
+            throw new Error('An operator must be selected before Category values can be resolved from metadata!');
+        }
+        if (this.selectedOperatorArity !== values.length) {
+            throw new Error(`The arity of the selected operator (${this.selectedOperatorArity}) doesn't match the number of the provided values (${values.length})!`);
+        }
+        const deserializedValuesObservables = values.map(v => this.deserializeOperandValue(v));
+        const result$ = new ReplaySubject(1);
+        forkJoin(deserializedValuesObservables).pipe(defaultIfEmpty([])).subscribe(deserializedValues => {
+            this.setOperands(deserializedValues);
+            result$.next();
+            result$.complete();
+        });
+        return result$.asObservable();
+    }
+    /**
+     * @param value the serialized output of the [serializeOperandValue()]{@link Category#serializeOperandValue} method
+     * @returns an `Observable` that emits the deserialized value, that can be set as FormControl value and then completes
+     *
+     * This method may throw na error if the value cannot be deserialized.
+     */
+    deserializeOperandValue(value) {
+        return of(value);
+    }
+    /**
+     * Performs a transformation of the `FormControl` value before passing it into the selected `Operator` for query generation.
+     * It is mostly useful only for AutocompleteCategories, where the selected value of the FormControl is an object.
+     *
+     * The default implementation performs an identity transformation - returns the input.
+     * @param value the FormControlValue
+     * @returns the value used for query generation
+     */
+    transformCategoryValue(value) {
+        return value;
+    }
+    /**
+     * @returns an Array containing text segments representing the content of the predicate generated by this category
+     */
+    createFilterTextSegments() {
+        if (!this.providesPredicate) {
+            return [];
+        }
+        return [
+            { segment: this.translationPath, bold: this.displayBold },
+            ...this.createConfigurationFilterTextSegments(),
+            ...this.createOperatorFilterTextSegments()
+        ];
+    }
+    /**
+     * @returns an Array containing text segments representing the operators with operands of this category
+     */
+    createOperatorFilterTextSegments() {
+        const result = [];
+        let operandIndex = 0;
+        for (const segment of this.selectedOperator.getOperatorNameTemplate()) {
+            if (segment === Operator.INPUT_PLACEHOLDER) {
+                result.push(this.createOperandFilterTextSegment(operandIndex));
+                operandIndex++;
+            }
+            else {
+                result.push({ segment });
+            }
+        }
+        return result;
+    }
+    /**
+     * @returns filter text segment representing the operand value at the specified index
+     */
+    createOperandFilterTextSegment(operandIndex) {
+        let segment;
+        const operand = this._operandsFormControls[operandIndex].value;
+        switch (this.inputType) {
+            case SearchInputType.AUTOCOMPLETE:
+                segment = operand.text;
+                break;
+            case SearchInputType.DATE:
+                segment = operand.format(DATE_FORMAT_STRING);
+                break;
+            case SearchInputType.DATE_TIME:
+                segment = operand.format(DATE_TIME_FORMAT_STRING);
+                break;
+            default:
+                segment = operand;
+                break;
+        }
+        return { segment, bold: true };
+    }
+}
+/**
+ * The {@link CategoryMetadataConfiguration} key for this Category's {@link Operator}
+ */
+Category.OPERATOR_METADATA = 'operator';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/models/category/category.ts"],"names":[],"mappings":"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","sourcesContent":["import {Operator} from '../operator/operator';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {Query} from '../query/query';\nimport {ElementaryPredicate} from '../predicate/elementary-predicate';\nimport {SearchInputType} from './search-input-type';\nimport {FormControl} from '@angular/forms';\nimport {BehaviorSubject, forkJoin, Observable, of, ReplaySubject} from 'rxjs';\nimport {debounceTime, defaultIfEmpty, map} from 'rxjs/operators';\nimport {OperatorTemplatePart} from '../operator-template-part';\nimport {IncrementingCounter} from '../../../utility/incrementing-counter';\nimport {ConfigurationInput} from '../configuration-input';\nimport {CategoryGeneratorMetadata, CategoryMetadataConfiguration} from '../persistance/generator-metadata';\nimport {Categories} from './categories';\nimport {OperatorService} from '../../operator-service/operator.service';\nimport {Operators} from '../operator/operators';\nimport {ofVoid} from '../../../utility/of-void';\nimport {FilterTextSegment} from '../persistance/filter-text-segment';\nimport {DATE_FORMAT_STRING, DATE_TIME_FORMAT_STRING} from '../../../moment/time-formats';\n\n/**\n * The top level of abstraction in search query generation. Represents a set of indexed fields that can be searched.\n * Encapsulates the the state and logic of the query construction process.\n *\n * As opposed to {@link Operator}s Categories are not stateless and shouldn't be shared.\n * A single Category instance is capable of holding the state of one {@link EditablePredicate},\n * or can be used as a builder to form an unlimited amount of [ElementaryPredicates]{@link ElementaryPredicate}.\n *\n * You can use {@link CategoryFactory} to get instances of Category classes.\n * Alternatively you can use the [clone()]{@Link Category#clone} method to duplicate an existing instance.\n *\n * If you want to make your own Category class you have to make sure that the constructor takes {@link OperatorService} as it's first\n * argument and {@link LoggerService} as it's second argument. Alternatively you can make your own implementation of the\n * {@link CategoryFactory} so, that your style of constructors is supported.\n *\n * @typeparam T type of objects the category expects to generate queries from\n */\nexport abstract class Category<T> {\n\n    /**\n     * The {@link CategoryMetadataConfiguration} key for this Category's {@link Operator}\n     */\n    protected static readonly OPERATOR_METADATA = 'operator';\n\n    /**\n     * Contains the `FormControl` object that is used to drive the operator selection.\n     *\n     * The category can subscribe to it if it wishes to react to the selection change by the user.\n     */\n    protected _operatorFormControl: FormControl;\n\n    /**\n     * Stores the `FormControl` objects that are pushed into the observable when the number of operands changes.\n     */\n    protected _operandsFormControls: Array<FormControl>;\n\n    /**\n     * Contains the `FormControl` objects that can be used to input search arguments.\n     */\n    protected _operandsFormControls$: ReplaySubject<Array<FormControl> | undefined>;\n\n    /**\n     * Contains the operator template parts that make up the operands GUI.\n     */\n    protected _operatorTemplate$: BehaviorSubject<Array<OperatorTemplatePart> | undefined>;\n\n    /**\n     * Generates IDs for template parts supplied to ng for.\n     */\n    protected _trackByIdGenerator: IncrementingCounter;\n\n    /**\n     * Emit a new `Predicate` if the `Category` is in a state that it can be created.\n     * Emits `undefined` if the `Category` is not in such state.\n     */\n    protected _generatedPredicate$: BehaviorSubject<ElementaryPredicate | undefined>;\n\n    /**\n     * Utility variable that can be used as value for the [configurationInputs$]{@link Category#configurationInputs$} `Observable`.\n     */\n    protected readonly _OPERATOR_INPUT: ConfigurationInput;\n\n    /**\n     * The constructor fills the values of all protected fields and then calls the [initializeCategory()]{@link Category#initializeCategory}\n     * method. If you want to override the category creation behavior override that method.\n     *\n     * @param _elasticKeywords Elasticsearch keywords that should be queried by queries generated with this category\n     * @param _allowedOperators Operators that can be used to generated queries on the above keywords\n     * @param translationPath path to the translation string\n     * @param _inputType input field type that should be used to enter operator arguments for this category\n     * @param _log used to record information about incorrect use of this class\n     * @param _operatorService used to resolve serialized operators during deserialization\n     */\n    protected constructor(protected readonly _elasticKeywords: Array<string>,\n                          protected readonly _allowedOperators: Array<Operator<any>>,\n                          public readonly translationPath: string,\n                          protected readonly _inputType: SearchInputType,\n                          protected _log: LoggerService,\n                          protected _operatorService: OperatorService) {\n        this._OPERATOR_INPUT = new ConfigurationInput(\n            SearchInputType.OPERATOR,\n            'search.operator.name',\n            false,\n            new Map<string, Array<unknown>>(),\n            () => {\n                throw new Error('ConfigurationInput of type OPERATOR is a placeholder!'\n                    + ' Use operator related methods from the Category class instead.');\n            }\n        );\n\n        this._operatorFormControl = this._OPERATOR_INPUT.formControl;\n        this._operandsFormControls$ = new ReplaySubject<Array<FormControl> | undefined>(1);\n        this._operatorTemplate$ = new BehaviorSubject<Array<OperatorTemplatePart> | undefined>(undefined);\n        this._operandsFormControls = [];\n        this._trackByIdGenerator = new IncrementingCounter();\n        this._generatedPredicate$ = new BehaviorSubject<ElementaryPredicate | undefined>(undefined);\n        this.initializeCategory();\n\n        this.operandsFormControls$.pipe(\n            map(formControls => {\n                if (!formControls) {\n                    return undefined;\n                }\n\n                const parts = this.selectedOperator.getOperatorNameTemplate();\n                const fcs = [...formControls];\n                let first = true;\n                return parts.map(part => {\n                    const template = new OperatorTemplatePart(part ? part : fcs.shift(),\n                        this._trackByIdGenerator.next(),\n                        part ? undefined : first);\n                    if (!part) {\n                        first = false;\n                    }\n                    return template;\n                });\n            })\n        ).subscribe(template => {\n            this._operatorTemplate$.next(template);\n        });\n    }\n\n    /**\n     * Cleans up the internal state of the object before its destruction.\n     *\n     * The developer must call this method at an appropriate moment, as this object cannot hook into the Angular lifecycle.\n     */\n    public destroy(): void {\n        this._operandsFormControls$.complete();\n        this._operatorTemplate$.complete();\n        this._generatedPredicate$.complete();\n    }\n\n    /**\n     * Configuration input represent the steps that are necessary to configure the category.\n     * The last input must always be of type [OPERATOR]{@link SearchInputType#OPERATOR}.\n     * Selecting the operator completes the configuration of the category and the arguments inputs\n     * (based on category input type and operator arity) are displayed.\n     *\n     * Beware that while most categories always return the same constant it must not always be the case.\n     *\n     * @returns the required input type for configuration steps of this category\n     */\n    public abstract get configurationInputs$(): Observable<Array<ConfigurationInput>>;\n\n    /**\n     * If you use the `Category` class as a sort of PredicateBuilder, then you want to use the\n     * [generatePredicate()]{@link Category#generatePredicate} method instead.\n     *\n     * This stream publishes either a new `Predicate` object or `undefined` based on changes to the `FormControls` that are\n     * managed by this class. If (based on user input) the `Category` reaches a state when construction of a `Predicate` is possible\n     * it will emit this `Predicate`. If it reaches a state when the `Predicate` can not longer be created `undefined` is emitted.\n     */\n    public get generatedPredicate$(): Observable<ElementaryPredicate | undefined> {\n        return this._generatedPredicate$.asObservable();\n    }\n\n    /**\n     * Returns the {@link Predicate} currently generated by the Category.\n     *\n     * For more information see [generatedPredicate$]{@link Category#generatedPredicate$}.\n     */\n    public get generatedPredicate(): ElementaryPredicate | undefined {\n        return this._generatedPredicate$.getValue();\n    }\n\n    /**\n     * Beware that while most categories always return the same constant it is not a requirement.\n     * An example for such behavior is the {@link CaseDataset} category, where the argument input type depends\n     * on the selected data field type.\n     *\n     * @returns the required input type for arguments for this category\n     */\n    public get inputType(): SearchInputType {\n        return this._inputType;\n    }\n\n    /**\n     * @returns the set of Operators that can be used with this category. Iteration order determines the display order.\n     */\n    public get allowedOperators(): Array<Operator<any>> {\n        const result = [];\n        result.push(...this._allowedOperators);\n        return result;\n    }\n\n    /**\n     * @returns the currently selected operator or `undefined` if no operator is selected.\n     */\n    public get selectedOperator(): Operator<any> {\n        return this._operatorFormControl.value;\n    }\n\n    /**\n     * @returns an array of `FormControl` objects that contains as many controls as is the arity of the selected operator.\n     * Calling this method multiple times will return the same `FormControl` instances.\n     * When no operator is selected `undefined` is emitted.\n     */\n    public get operandsFormControls$(): Observable<Array<FormControl> | undefined> {\n        return this._operandsFormControls$.asObservable();\n    }\n\n    /**\n     * A new value is emitted whenever the selected operator changes. `undefined` is emitted if no operator is selected.\n     *\n     * @returns [operators template]{@link Operator#getOperatorNameTemplate} in processed form fit for GUI rendering\n     */\n    public get operatorTemplate$(): Observable<Array<OperatorTemplatePart> | undefined> {\n        return this._operatorTemplate$.asObservable();\n    }\n\n    /**\n     * @returns whether the category is fully configured and represents a valid predicate or not\n     */\n    public get providesPredicate(): boolean {\n        return !!this._generatedPredicate$.getValue();\n    }\n\n    /**\n     * @returns the set of Elasticsearch keywords that should be queried by queries generated with this category.\n     * The method can be overridden if the keywords are not static and change based on some additional selection (eg. Data fields)\n     */\n    protected get elasticKeywords(): Array<string> {\n        const result = [];\n        result.push(...this._elasticKeywords);\n        return result;\n    }\n\n    /**\n     * @returns the arity of the selected operator. Throws an error if no operator is selected.\n     */\n    protected get selectedOperatorArity(): number {\n        if (!this.isOperatorSelected()) {\n            throw new Error('An operator mus be selected before its arity can be resolved!');\n        }\n        return this.selectedOperator.numberOfOperands;\n    }\n\n    /**\n     * Changes the state of the Category. Category can create queries when an {@link Operator} is selected.\n     *\n     * This method is useful if you want to use the Category class as predicate builder.\n     *\n     * @param operatorIndex index in the [allowedOperators]{@link Category#allowedOperators} array of the {@link Operator} that\n     * should be selected\n     */\n    public selectOperator(operatorIndex: number): void {\n        const operators = this.allowedOperators;\n        if (operatorIndex < 0 || operatorIndex >= operators.length) {\n            this._log.warn(`The provided 'operatorIndex' is out of range.`);\n            return;\n        }\n        this._operatorFormControl.setValue(operators[operatorIndex]);\n    }\n\n    /**\n     * Changes the state of the Category and generates a query if all necessary operands were set.\n     *\n     * If you are using the category as a builder. Consider using the [generatePredicate()]{@link Category#generatePredicate}\n     * method instead.\n     *\n     * @param userInput values entered by the user. The length of the array should match the\n     * [arity]{@link Operator#_numberOfOperands} of the selected Operator.\n     */\n    public setOperands(userInput: Array<T>): void {\n        const range = Math.min(userInput.length, this._operandsFormControls.length);\n        if (range < userInput.length) {\n            this._log.warn(`${userInput.length} operands are being set, but only ${range} inputs are available!`\n                + ' Extra operands will be ignored.');\n        }\n        for (let i = 0; i < range; i++) {\n            this._operandsFormControls[i].setValue(userInput[i]);\n        }\n        if (range !== 0) {\n            this.operandValueChanges(range - 1);\n        }\n    }\n\n    /**\n     * Resets the state of the Category, deselecting any selected category and removing other state\n     * information if the Category defines them.\n     *\n     * This method can be used to reset the state of the category after each predicate constructed,\n     * effectively turning the category instance into a predicate builder.\n     */\n    public reset(): void {\n        this.clearOperatorSelection();\n        this._operandsFormControls.forEach(fc => {\n            fc.setValue(undefined);\n        });\n    }\n\n    /**\n     * Calls the [createQuery]{@link Operator#createQuery} method on the selected Operator.\n     *\n     * Throws an Error if no Operator is selected.\n     *\n     * Override this method if the query should be generated in some other way.\n     * @param userInput values entered by the user. The length of the array should match the\n     * [arity]{@link Operator#_numberOfOperands} of the selected Operator.\n     * @returns the Query generated by the selected Operator\n     */\n    protected generateQuery(userInput: Array<T>): Query {\n        if (!this.isOperatorSelected()) {\n            throw new Error('Category cannot generate a Query if no Operator is selected');\n        }\n        return this._operatorFormControl.value.createQuery(this._elasticKeywords, userInput as unknown as Array<string>);\n    }\n\n    /**\n     * Calls the [generateQuery]{@link Category#generateQuery} method and creates an {@link ElementaryPredicate} with the result.\n     * @param userInput values entered by the user. The length of the array should match the\n     * [arity]{@link Operator#_numberOfOperands} of the selected Operator.\n     * @returns Predicate with {@link Query} generated by this object's [generateQuery]{@link Category#generateQuery} method\n     */\n    public generatePredicate(userInput: Array<T>): ElementaryPredicate {\n        return new ElementaryPredicate(this.generateQuery(userInput));\n    }\n\n    /**\n     * Selects the default operator that should be used for query generation, when no Operator selection is provided to the user.\n     *\n     * The default implementation selects the first operator in the [_allowedOperators]{@link Category#allowedOperators} array.\n     *\n     * See [selectOperator()]{@link Category#selectOperator} for more information.\n     */\n    public selectDefaultOperator(): void {\n        this.selectOperator(0);\n    }\n\n    /**\n     * @returns the translation string path for the text that should be displayed in the input placeholder\n     */\n    public abstract get inputPlaceholder(): string;\n\n    /**\n     * @returns whether the category text should be rendered with bold text when selected\n     */\n    public abstract get displayBold(): boolean;\n\n    /**\n     * @returns whether an operator is currently selected or not.\n     */\n    public isOperatorSelected(): boolean {\n        return !!this._operatorFormControl.value;\n    }\n\n    /**\n     * Deselects the currently selected operator (if any)\n     */\n    public clearOperatorSelection(): void {\n        this._operatorFormControl.setValue(undefined);\n    }\n\n    /**\n     * Creates a duplicate of the current category object. Note that a duplicate is NOT a clone.\n     * The state of the returned category is not necessarily the same as the state of this category.\n     *\n     * @returns a category instance of the same type as this category in its initial state.\n     */\n    public abstract duplicate(): Category<T>;\n\n    /**\n     * Provides the necessary information for the serialisation of this category's state.\n     *\n     * Not every state must be preservable. The default library implementation supports only the preservation of the final state when the\n     * Category is generating a predicate object.\n     *\n     * @returns an object containing all the necessary information for the reconstruction of this category's state,\n     * barring information about allowed nets. Returns `undefined` if the category is not in a state that generates a predicate.\n     * See [providesPredicate()]{@link Category#providesPredicate}.\n     */\n    public createMetadata(): CategoryGeneratorMetadata | undefined {\n        if (!this.providesPredicate) {\n            return undefined;\n        }\n        return {\n            category: this.serializeClass(),\n            configuration: this.createMetadataConfiguration(),\n            values: this.createMetadataValues()\n        };\n    }\n\n    /**\n     * Restores the saved state contained in the provided metadata.\n     *\n     * @param metadata the metadata created by calling the [createMetadata()]{@link Category#createMetadata} method\n     *\n     * @returns an Observable. When the Observable emits the category has finished restoring its state.\n     */\n    public loadFromMetadata(metadata: CategoryGeneratorMetadata): Observable<void> {\n        const result$ = new ReplaySubject<void>(1);\n        this.loadConfigurationFromMetadata(metadata.configuration).subscribe(() => {\n            this.loadValuesFromMetadata(metadata.values).subscribe(() => {\n                result$.next();\n                result$.complete();\n            });\n        });\n        return result$.asObservable();\n    }\n\n    /**\n     * This method is calle in the constructor. Apart from calling this method, the constructor only creates instances to fill the protected\n     * fields of this class.\n     *\n     * The default implementation manages creation of operand `FormControl` instances and manages subscriptions to them.\n     *\n     * You can override this method to change the initialization of your category without having to rewrite the base\n     * constructor from scratch.\n     */\n    protected initializeCategory(): void {\n        this._operatorFormControl.valueChanges.subscribe((newOperator: Operator<any>) => {\n            this._operandsFormControls.forEach(fc => {\n                fc.setValue(undefined);\n            });\n\n            if (!newOperator) {\n                // undefined is next-ed into the stream. Marked as code smell by sonar when explicitly stated\n                this._operandsFormControls$.next();\n                if (this._operandsFormControls.length === 0) {\n                    this._generatedPredicate$.next(undefined);\n                }\n                return;\n            }\n\n            if (newOperator.numberOfOperands > this._operandsFormControls.length) {\n                while (this._operandsFormControls.length < newOperator.numberOfOperands) {\n                    const fc = new FormControl();\n                    const currentLength = this._operandsFormControls.length;\n                    fc.valueChanges.pipe(debounceTime(600)).subscribe(() => {\n                        this.operandValueChanges(currentLength);\n                    });\n                    this._operandsFormControls.push(fc);\n                }\n            }\n\n            this._operandsFormControls$.next(this._operandsFormControls.slice(0, newOperator.numberOfOperands));\n\n            if (newOperator.numberOfOperands === 0) {\n                this._generatedPredicate$.next(this.generatePredicate([]));\n            }\n        });\n    }\n\n    /**\n     * The method that is (by default) called whenever an operand `FormControl` changes its value.\n     *\n     * @param operandIndex the index of the operand that changed its value\n     */\n    protected operandValueChanges(operandIndex: number): void {\n        if (!this.isOperatorSelected()) {\n            this._generatedPredicate$.next(undefined);\n            return;\n        }\n        if (operandIndex >= this.selectedOperatorArity) {\n            return;\n        }\n\n        for (let i = 0; i < this.selectedOperatorArity; i++) {\n            if (!this.isOperandValueSelected(this._operandsFormControls[i].value)) {\n                if (this._generatedPredicate$.getValue()) {\n                    this._generatedPredicate$.next(undefined);\n                }\n                return;\n            }\n        }\n\n        this._generatedPredicate$.next(this.generatePredicate(this._operandsFormControls.map(fc => this.transformCategoryValue(fc.value))));\n    }\n\n    /**\n     * @returns the category class in a serializable form\n     *\n     * @deprecated in 5.6.0 - Category serialisation should be done by utilising the {@link CategoryResolverService} instead\n     */\n    abstract serializeClass(): Categories | string;\n\n    /**\n     * The default implementation serializes only the operator.\n     * If the category contains additional configuration, this method must be extended.\n     *\n     * @returns an object containing all the necessary information for the reconstruction of the configuration of this category instance\n     */\n    protected createMetadataConfiguration(): CategoryMetadataConfiguration {\n        return {\n            [Category.OPERATOR_METADATA]: this.selectedOperator.serialize()\n        };\n    }\n\n    /**\n     * The default implementation returns the value of all operand form control objects up to the current number of operands.\n     * To serialize value of each operand the [serializeOperandValue()]{@link Category#serializeOperandValue} method is used.\n     *\n     * If the values used by this category are not serializable, then either this method, or the `serializeOperandValue` method,\n     * must be overridden.\n     *\n     * @returns an array containing values input by the user in a serializable form\n     */\n    protected createMetadataValues(): Array<unknown> {\n        const result = [];\n        for (let i = 0; i < this.selectedOperatorArity; i++) {\n            result.push(this.serializeOperandValue(this._operandsFormControls[i]));\n        }\n        return result;\n    }\n\n    /**\n     * @param valueFormControl FormControl object of one operand\n     * @returns the value of the operand in a serialized form. The default implementation returns the FormControls `value` attribute.\n     */\n    protected serializeOperandValue(valueFormControl: FormControl): unknown {\n        return valueFormControl.value;\n    }\n\n    /**\n     * Restored the saved configuration from the metadata created by the\n     * [createMetadataConfiguration()]{@link Category#createMetadataConfiguration} method.\n     *\n     * The default implementation restores only the saved operator.\n     *\n     * If the Category overrides the serialization method, it must override this method as well.\n     *\n     * @param configuration the serialized configuration\n     *\n     * @returns an Observable. When the Observable emits the category has finished loading its configuration.\n     */\n    protected loadConfigurationFromMetadata(configuration: CategoryMetadataConfiguration): Observable<void> {\n        const resolvedOperator = this._operatorService.getFromMetadata(configuration[Category.OPERATOR_METADATA] as Operators | string);\n        this.selectOperator(this.allowedOperators.findIndex(op => op === resolvedOperator));\n        return ofVoid();\n    }\n\n    /**\n     * The default implementation sets the provided values into this Category's operand form controls.\n     *\n     * An operator must be set before calling this method! Otherwise an error will be thrown.\n     *\n     * If the number of values doesn't match the arity of the selected operator an error will be thrown!\n     *\n     * If this Category overrides the [serializeOperandValue()]{@link Category#serializeOperandValue}, it must also\n     * override its deserialization counterpart - [deserializeOperandValue()]{@link #Category#deserializeOperandValue}!\n     *\n     * @param values the serialized values that should be loaded into this Category instance\n     *\n     * @returns an Observable. When the Observable emits the category has finished loading its values.\n     */\n    protected loadValuesFromMetadata(values: Array<unknown>): Observable<void> {\n        if (!this.isOperatorSelected()) {\n            throw new Error('An operator must be selected before Category values can be resolved from metadata!');\n        }\n        if (this.selectedOperatorArity !== values.length) {\n            throw new Error(`The arity of the selected operator (${this.selectedOperatorArity\n            }) doesn't match the number of the provided values (${values.length})!`);\n        }\n        const deserializedValuesObservables = values.map(v => this.deserializeOperandValue(v));\n        const result$ = new ReplaySubject<void>(1);\n        forkJoin(deserializedValuesObservables).pipe(defaultIfEmpty([])).subscribe(deserializedValues => {\n            this.setOperands(deserializedValues);\n            result$.next();\n            result$.complete();\n        });\n        return result$.asObservable();\n    }\n\n    /**\n     * @param value the serialized output of the [serializeOperandValue()]{@link Category#serializeOperandValue} method\n     * @returns an `Observable` that emits the deserialized value, that can be set as FormControl value and then completes\n     *\n     * This method may throw na error if the value cannot be deserialized.\n     */\n    protected deserializeOperandValue(value: unknown): Observable<any> {\n        return of(value);\n    }\n\n    /**\n     * @param newValue the value of the `FormControl` object that we want to test\n     * @returns `true` if the newly selected value is a valid value, `false` otherwise.\n     */\n    protected abstract isOperandValueSelected(newValue: any): boolean;\n\n    /**\n     * Performs a transformation of the `FormControl` value before passing it into the selected `Operator` for query generation.\n     * It is mostly useful only for AutocompleteCategories, where the selected value of the FormControl is an object.\n     *\n     * The default implementation performs an identity transformation - returns the input.\n     * @param value the FormControlValue\n     * @returns the value used for query generation\n     */\n    protected transformCategoryValue(value: any): T {\n        return value;\n    }\n\n    /**\n     * @returns an Array containing text segments representing the content of the predicate generated by this category\n     */\n    public createFilterTextSegments(): Array<FilterTextSegment> {\n        if (!this.providesPredicate) {\n            return [];\n        }\n        return [\n            {segment: this.translationPath, bold: this.displayBold},\n            ...this.createConfigurationFilterTextSegments(),\n            ...this.createOperatorFilterTextSegments()\n        ];\n    }\n\n    /**\n     * @returns an Array containing text segments representing the configuration inputs of this category\n     */\n    protected abstract createConfigurationFilterTextSegments(): Array<FilterTextSegment>;\n\n    /**\n     * @returns an Array containing text segments representing the operators with operands of this category\n     */\n    protected createOperatorFilterTextSegments(): Array<FilterTextSegment> {\n        const result: Array<FilterTextSegment> = [];\n        let operandIndex = 0;\n        for (const segment of this.selectedOperator.getOperatorNameTemplate()) {\n            if (segment === Operator.INPUT_PLACEHOLDER) {\n                result.push(this.createOperandFilterTextSegment(operandIndex));\n                operandIndex++;\n            } else {\n                result.push({segment});\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @returns filter text segment representing the operand value at the specified index\n     */\n    protected createOperandFilterTextSegment(operandIndex: number): FilterTextSegment {\n        let segment;\n        const operand = this._operandsFormControls[operandIndex].value;\n        switch (this.inputType) {\n            case SearchInputType.AUTOCOMPLETE:\n                segment = operand.text;\n                break;\n            case SearchInputType.DATE:\n                segment = operand.format(DATE_FORMAT_STRING);\n                break;\n            case SearchInputType.DATE_TIME:\n                segment = operand.format(DATE_TIME_FORMAT_STRING);\n                break;\n            default:\n                segment = operand;\n                break;\n        }\n        return {segment, bold: true};\n    }\n}\n"]}

package/esm2015/lib/search/models/category/name-id-pair.js

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