ax-common-ui-lib 1.0.0-qa.0

package/esm2020/lib/data-view-lib/data-view-filters/data-view-filters.service.mjs

@@ -0,0 +1,102 @@
+import { DataViewFilter } from './../data-view/data-view-filter';
+import { Injectable } from '@angular/core';
+import { AxExpression } from '../../enlighten-lib/ax-expression/ax-expression';
+import { Attribute, AttributeTypes } from '../../enlighten-lib/data-model/attribute';
+import { AxDate } from '../../enlighten-lib/fields/types/ax-date';
+import { AxNumber } from '../../enlighten-lib/fields/types/ax-number';
+import { AxText } from '../../enlighten-lib/fields/types/ax-text';
+import { AxTime } from '../../enlighten-lib/fields/types/ax-time';
+import { DateTime } from '../../enlighten-lib/fields/types/datetime';
+import { ConditionType, FilterType, ScopeType } from '../../enlighten-lib/filters/condition-type';
+import { SearchNode } from '../../enlighten-lib/filters/search-node';
+import { WidgetSubType } from '../../forms/page/common/widget-enums';
+import * as i0 from "@angular/core";
+export class DataViewFiltersService {
+    constructor() { }
+    /**
+     * Add new filter functionality
+     *
+     * @param appVersion
+     * @param event
+     * @param filters
+     * @param scopeType
+     * @param x
+     * @returns  filter array
+     */
+    generateBasicFilter(appVersion, event, filters, scopeType, x, formId) {
+        const widget = event.option.value;
+        const expression = new AxExpression();
+        const attribute = new Attribute();
+        if (widget.subType === WidgetSubType.referenceList) {
+            attribute.formId = widget.referenceForm;
+        }
+        else {
+            attribute.formId = formId;
+        }
+        attribute.widgetType = widget.type;
+        attribute.widgetSubType = widget.subType;
+        attribute.name = widget.identifier;
+        attribute.identifier = widget.identifier;
+        attribute.attributeType = AttributeTypes.widgetType;
+        expression.field = attribute;
+        expression.field.label = widget.prompt;
+        const searchNode = new SearchNode();
+        if (widget.subType === 'numeric') {
+            expression.field.enlightenType = new AxNumber();
+        }
+        else {
+            expression.field.enlightenType.matIcon = new AxText().matIcon;
+        }
+        if (widget.type === 'datepicker-widget') {
+            expression.field.enlightenType = this.setEnlightenType(widget);
+        }
+        searchNode.expression = expression;
+        searchNode.type = ConditionType.condition;
+        const axFilter = new DataViewFilter();
+        axFilter.type = FilterType.basic;
+        axFilter.formId = formId;
+        axFilter.appVersionId = appVersion;
+        axFilter.scope = ScopeType.global;
+        axFilter.searchNodes.push(searchNode);
+        axFilter.type = FilterType.basic;
+        // if (event.option.selected) {
+        //   filters.push(axFilter);
+        // } else {
+        //   {
+        //     filters.forEach((filter, index) => {
+        //       if (filter.searchNodes[0].expression.field.name === widget.identifier) {
+        //         filters[index].isDeleted = true;
+        //         filters[index].searchNodes[0].expression.value.isSearchable = false;
+        //       }
+        //     });
+        //   }
+        // }
+        return axFilter;
+    }
+    /**
+     * To set expression field Enlighten Type
+     *
+     * @param attributeData
+     *
+     */
+    setEnlightenType(attributeData) {
+        switch (attributeData.subType) {
+            case 'datetime':
+                return new DateTime();
+            case 'date':
+                return new AxDate();
+            case 'time':
+                return new AxTime();
+            case 'timestamp':
+                return new DateTime();
+            default:
+                return new DateTime();
+        }
+    }
+}
+DataViewFiltersService.ɵfac = function DataViewFiltersService_Factory(t) { return new (t || DataViewFiltersService)(); };
+DataViewFiltersService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DataViewFiltersService, factory: DataViewFiltersService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DataViewFiltersService, [{
+        type: Injectable
+    }], function () { return []; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-view-filters.service.js","sourceRoot":"","sources":["../../../../../../src/ax-app-common-lib/src/lib/data-view-lib/data-view-filters/data-view-filters.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataViewFilter } from './../data-view/data-view-filter';\nimport { Injectable } from '@angular/core';\nimport { MatSelectChange } from '@angular/material/select';\nimport { AxExpression } from '../../enlighten-lib/ax-expression/ax-expression';\nimport { Attribute, AttributeTypes } from '../../enlighten-lib/data-model/attribute';\nimport { AxDate } from '../../enlighten-lib/fields/types/ax-date';\nimport { AxNumber } from '../../enlighten-lib/fields/types/ax-number';\nimport { AxText } from '../../enlighten-lib/fields/types/ax-text';\nimport { AxTime } from '../../enlighten-lib/fields/types/ax-time';\nimport { DateTime } from '../../enlighten-lib/fields/types/datetime';\nimport { IEnlightenType } from '../../enlighten-lib/fields/types/ienlighten-type';\nimport { AxFilter } from '../../enlighten-lib/filters/ax-filter';\nimport { ConditionType, FilterType, ScopeType } from '../../enlighten-lib/filters/condition-type';\nimport { SearchNode } from '../../enlighten-lib/filters/search-node';\nimport { WidgetSubType } from '../../forms/page/common/widget-enums';\nimport { Widget } from '../../forms/page/widgets/widget';\n\n@Injectable()\nexport class DataViewFiltersService {\n\n  constructor() { }\n\n  /**\n   * Add new filter functionality\n   *\n   * @param appVersion\n   * @param event\n   * @param filters\n   * @param scopeType\n   * @param x\n   * @returns  filter array\n   */\n   generateBasicFilter(appVersion: number, event: MatSelectChange | any, filters: Array<AxFilter>, scopeType: number, x: number, formId?: number): AxFilter{\n    const widget = event.option.value;\n    const expression = new AxExpression();\n    const attribute = new Attribute();\n    if (widget.subType === WidgetSubType.referenceList) {\n      attribute.formId = widget.referenceForm;\n    }\n    else{\n      attribute.formId = formId;\n    }\n    attribute.widgetType = widget.type;\n    attribute.widgetSubType = widget.subType;\n    attribute.name = widget.identifier;\n    attribute.identifier = widget.identifier;\n    attribute.attributeType = AttributeTypes.widgetType;\n    expression.field = attribute;\n    expression.field.label = widget.prompt;\n    const searchNode = new SearchNode();\n    if (widget.subType === 'numeric') {\n      expression.field.enlightenType = new AxNumber();\n    }\n    else {\n      expression.field.enlightenType.matIcon = new AxText().matIcon;\n    }\n    if (widget.type === 'datepicker-widget') {\n      expression.field.enlightenType = this.setEnlightenType(widget);\n    }\n    searchNode.expression = expression;\n    searchNode.type = ConditionType.condition;\n    const axFilter = new DataViewFilter();\n    axFilter.type = FilterType.basic;\n    axFilter.formId = formId;\n    axFilter.appVersionId = appVersion;\n    axFilter.scope = ScopeType.global;\n    axFilter.searchNodes.push(searchNode);\n    axFilter.type = FilterType.basic;\n    // if (event.option.selected) {\n    //   filters.push(axFilter);\n    // } else {\n    //   {\n    //     filters.forEach((filter, index) => {\n    //       if (filter.searchNodes[0].expression.field.name === widget.identifier) {\n    //         filters[index].isDeleted = true;\n    //         filters[index].searchNodes[0].expression.value.isSearchable = false;\n    //       }\n    //     });\n    //   }\n    // }\n    return axFilter;\n  }\n\n\n  /**\n   * To set expression field Enlighten Type\n   *\n   * @param attributeData\n   *\n   */\n   setEnlightenType(attributeData: Widget): IEnlightenType {\n    switch (attributeData.subType) {\n      case 'datetime':\n        return new DateTime();\n      case 'date':\n        return new AxDate();\n      case 'time':\n        return new AxTime();\n      case 'timestamp':\n        return new DateTime();\n      default:\n        return new DateTime();\n\n    }\n  }\n}\n"]}