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

package/esm2020/lib/filters/filters.module.mjs

@@ -0,0 +1,196 @@
+import { SingleSelectFilterComponent } from './single-select-filter/single-select-filter.component';
+import { AxoSearchBarModule } from './../axo-search-bar/axo-search-bar.module';
+import { UserFilterService } from './user-filter/user-filter.service';
+import { MetaColumnFilterBuilderService } from './meta-column-filter-builder/meta-column-filter-builder.service';
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FiltersComponent } from './filters.component';
+import { GridsterModule } from 'angular-gridster2';
+import { MatMenuModule } from '@angular/material/menu';
+import { CalenderFilterComponent } from './calender-filter/calender-filter.component';
+import { MultiSelectFilterComponent } from './multi-select-filter/multi-select-filter.component';
+import { NumberFilterComponent } from './number-filter/number-filter.component';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatSelectModule } from '@angular/material/select';
+import { MatNativeDateModule, MatOptionModule } from '@angular/material/core';
+import { MatMomentDateModule } from '@angular/material-moment-adapter';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatListModule } from '@angular/material/list';
+import { MatRadioModule } from '@angular/material/radio';
+import { MatSortModule } from '@angular/material/sort';
+import { MatTableModule } from '@angular/material/table';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { AxoUtilsModule } from '../axo-utils/axo-utils.module';
+import { TimeFilterComponent } from './time-filter/time-filter.component';
+import { NgxDaterangepickerMd } from 'ngx-daterangepicker-material';
+import { DateTimeFilterComponent } from './date-time-filter/date-time-filter.component';
+import { NgxMatDatetimePickerModule, NgxMatNativeDateModule, NgxMatTimepickerModule } from '@angular-material-components/datetime-picker';
+import { CategoryFilterComponent } from './category-filter/category-filter.component';
+import { ReferenceListFilterComponent } from './reference-list-filter/reference-list-filter.component';
+import { FilterFooterComponent } from './filter-footer/filter-footer.component';
+import { ChoiceListFilterComponent } from './choice-list-filter/choice-list-filter.component';
+import { UserFilterComponent } from './user-filter/user-filter.component';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { CommonFilterComponent } from './common-filter/common-filter.component';
+import { CommonFilterService } from './common-filter/common-filter.service';
+import { ChoiceSearchPipe } from '../axo-utils/public-api';
+import { CustomScrollDirective } from './custom-scroll-directives';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-daterangepicker-material";
+export class FiltersModule {
+}
+FiltersModule.ɵfac = function FiltersModule_Factory(t) { return new (t || FiltersModule)(); };
+FiltersModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: FiltersModule });
+FiltersModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+        MetaColumnFilterBuilderService,
+        UserFilterService,
+        CommonFilterService
+    ], imports: [[
+            CommonModule,
+            GridsterModule,
+            FormsModule,
+            MatFormFieldModule,
+            MatSelectModule,
+            MatOptionModule,
+            MatIconModule,
+            MatRadioModule,
+            ReactiveFormsModule,
+            MatInputModule,
+            MatDatepickerModule,
+            MatNativeDateModule,
+            MatMomentDateModule,
+            MatListModule,
+            MatCheckboxModule,
+            MatTableModule,
+            MatSortModule,
+            MatTooltipModule,
+            MatMenuModule,
+            AxoUtilsModule,
+            NgxDaterangepickerMd.forRoot({
+                separator: ' - ',
+            }),
+            NgxMatDatetimePickerModule,
+            NgxMatTimepickerModule,
+            NgxMatNativeDateModule,
+            MatSlideToggleModule,
+            AxoSearchBarModule
+        ]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FiltersModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [
+                    FiltersComponent,
+                    CalenderFilterComponent,
+                    MultiSelectFilterComponent,
+                    ChoiceListFilterComponent,
+                    NumberFilterComponent,
+                    DateTimeFilterComponent,
+                    TimeFilterComponent,
+                    CategoryFilterComponent,
+                    ReferenceListFilterComponent,
+                    FilterFooterComponent,
+                    UserFilterComponent,
+                    CommonFilterComponent,
+                    ChoiceSearchPipe,
+                    SingleSelectFilterComponent,
+                    CustomScrollDirective
+                ],
+                imports: [
+                    CommonModule,
+                    GridsterModule,
+                    FormsModule,
+                    MatFormFieldModule,
+                    MatSelectModule,
+                    MatOptionModule,
+                    MatIconModule,
+                    MatRadioModule,
+                    ReactiveFormsModule,
+                    MatInputModule,
+                    MatDatepickerModule,
+                    MatNativeDateModule,
+                    MatMomentDateModule,
+                    MatListModule,
+                    MatCheckboxModule,
+                    MatTableModule,
+                    MatSortModule,
+                    MatTooltipModule,
+                    MatMenuModule,
+                    AxoUtilsModule,
+                    NgxDaterangepickerMd.forRoot({
+                        separator: ' - ',
+                    }),
+                    NgxMatDatetimePickerModule,
+                    NgxMatTimepickerModule,
+                    NgxMatNativeDateModule,
+                    MatSlideToggleModule,
+                    AxoSearchBarModule
+                ],
+                exports: [
+                    FiltersComponent,
+                    CalenderFilterComponent,
+                    MultiSelectFilterComponent,
+                    NumberFilterComponent,
+                    DateTimeFilterComponent,
+                    TimeFilterComponent,
+                    CategoryFilterComponent,
+                    ReferenceListFilterComponent,
+                    ChoiceListFilterComponent
+                ],
+                providers: [
+                    MetaColumnFilterBuilderService,
+                    UserFilterService,
+                    CommonFilterService
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(FiltersModule, { declarations: [FiltersComponent,
+        CalenderFilterComponent,
+        MultiSelectFilterComponent,
+        ChoiceListFilterComponent,
+        NumberFilterComponent,
+        DateTimeFilterComponent,
+        TimeFilterComponent,
+        CategoryFilterComponent,
+        ReferenceListFilterComponent,
+        FilterFooterComponent,
+        UserFilterComponent,
+        CommonFilterComponent,
+        ChoiceSearchPipe,
+        SingleSelectFilterComponent,
+        CustomScrollDirective], imports: [CommonModule,
+        GridsterModule,
+        FormsModule,
+        MatFormFieldModule,
+        MatSelectModule,
+        MatOptionModule,
+        MatIconModule,
+        MatRadioModule,
+        ReactiveFormsModule,
+        MatInputModule,
+        MatDatepickerModule,
+        MatNativeDateModule,
+        MatMomentDateModule,
+        MatListModule,
+        MatCheckboxModule,
+        MatTableModule,
+        MatSortModule,
+        MatTooltipModule,
+        MatMenuModule,
+        AxoUtilsModule, i1.NgxDaterangepickerMd, NgxMatDatetimePickerModule,
+        NgxMatTimepickerModule,
+        NgxMatNativeDateModule,
+        MatSlideToggleModule,
+        AxoSearchBarModule], exports: [FiltersComponent,
+        CalenderFilterComponent,
+        MultiSelectFilterComponent,
+        NumberFilterComponent,
+        DateTimeFilterComponent,
+        TimeFilterComponent,
+        CategoryFilterComponent,
+        ReferenceListFilterComponent,
+        ChoiceListFilterComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filters.module.js","sourceRoot":"","sources":["../../../../../src/ax-common-ui-lib/src/lib/filters/filters.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { SingleSelectFilterComponent } from './single-select-filter/single-select-filter.component';\nimport { AxoSearchBarModule } from './../axo-search-bar/axo-search-bar.module';\nimport { UserFilterService } from './user-filter/user-filter.service';\nimport { MetaColumnFilterBuilderService } from './meta-column-filter-builder/meta-column-filter-builder.service';\nimport { NgModule } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { FiltersComponent } from './filters.component';\nimport { GridsterModule } from 'angular-gridster2';\nimport { MatMenuModule } from '@angular/material/menu';\nimport { CalenderFilterComponent } from './calender-filter/calender-filter.component';\nimport { MultiSelectFilterComponent } from './multi-select-filter/multi-select-filter.component';\nimport { NumberFilterComponent } from './number-filter/number-filter.component';\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatSelectModule } from '@angular/material/select';\nimport { MatNativeDateModule, MatOptionModule } from '@angular/material/core';\nimport { MatMomentDateModule } from '@angular/material-moment-adapter';\nimport { MatCheckboxModule } from '@angular/material/checkbox';\nimport { MatDatepickerModule } from '@angular/material/datepicker';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatInputModule } from '@angular/material/input';\nimport { MatListModule } from '@angular/material/list';\nimport { MatRadioModule } from '@angular/material/radio';\nimport { MatSortModule } from '@angular/material/sort';\nimport { MatTableModule } from '@angular/material/table';\nimport { MatTooltipModule } from '@angular/material/tooltip';\nimport { AxoUtilsModule } from '../axo-utils/axo-utils.module';\nimport { TimeFilterComponent } from './time-filter/time-filter.component';\nimport { NgxDaterangepickerMd } from 'ngx-daterangepicker-material';\nimport { DateTimeFilterComponent } from './date-time-filter/date-time-filter.component';\n\nimport {\n  NgxMatDatetimePickerModule,\n  NgxMatNativeDateModule,\n  NgxMatTimepickerModule\n} from '@angular-material-components/datetime-picker';\nimport { CategoryFilterComponent } from './category-filter/category-filter.component';\nimport { ReferenceListFilterComponent } from './reference-list-filter/reference-list-filter.component';\nimport { FilterFooterComponent } from './filter-footer/filter-footer.component';\nimport { ChoiceListFilterComponent } from './choice-list-filter/choice-list-filter.component';\nimport { UserFilterComponent } from './user-filter/user-filter.component';\nimport { MatSlideToggleModule } from '@angular/material/slide-toggle';\nimport { CommonFilterComponent } from './common-filter/common-filter.component';\nimport { CommonFilterService } from './common-filter/common-filter.service';\nimport { ChoiceSearchPipe } from '../axo-utils/public-api';\nimport { CustomScrollDirective } from './custom-scroll-directives';\n@NgModule({\n  declarations: [\n    FiltersComponent,\n    CalenderFilterComponent,\n    MultiSelectFilterComponent,\n    ChoiceListFilterComponent,\n    NumberFilterComponent,\n    DateTimeFilterComponent,\n    TimeFilterComponent,\n    CategoryFilterComponent,\n    ReferenceListFilterComponent,\n    FilterFooterComponent,\n    UserFilterComponent,\n    CommonFilterComponent,\n    ChoiceSearchPipe,\n    SingleSelectFilterComponent,\n    CustomScrollDirective\n  ],\n  imports: [\n    CommonModule,\n    GridsterModule,\n    FormsModule,\n    MatFormFieldModule,\n    MatSelectModule,\n    MatOptionModule,\n    MatIconModule,\n    MatRadioModule,\n    ReactiveFormsModule,\n    MatInputModule,\n    MatDatepickerModule,\n    MatNativeDateModule,\n    MatMomentDateModule,\n    MatListModule,\n    MatCheckboxModule,\n    MatTableModule,\n    MatSortModule,\n    MatTooltipModule,\n    MatMenuModule,\n    AxoUtilsModule,\n    NgxDaterangepickerMd.forRoot({\n      separator: ' - ',\n    }),\n    NgxMatDatetimePickerModule,\n    NgxMatTimepickerModule,\n    NgxMatNativeDateModule,\n    MatSlideToggleModule,\n    AxoSearchBarModule\n  ],\n  exports: [\n    FiltersComponent,\n    CalenderFilterComponent,\n    MultiSelectFilterComponent,\n    NumberFilterComponent,\n    DateTimeFilterComponent,\n    TimeFilterComponent,\n    CategoryFilterComponent,\n    ReferenceListFilterComponent,\n    ChoiceListFilterComponent\n  ],\n  providers:[\n    MetaColumnFilterBuilderService,\n    UserFilterService,\n    CommonFilterService\n  ]\n})\nexport class FiltersModule { }\n\n"]}

package/esm2020/lib/filters/filters.service.mjs

@@ -0,0 +1,147 @@
+import { MetaColumnFilterBuilderService } from './meta-column-filter-builder/meta-column-filter-builder.service';
+import { EventEmitter, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./meta-column-filter-builder/meta-column-filter-builder.service";
+export class FiltersService {
+    /**
+     * Constructor
+     */
+    constructor(_metaColumnBuilderService) {
+        this._metaColumnBuilderService = _metaColumnBuilderService;
+        /**
+         * Component variables.
+         */
+        // filter selection change emitter.
+        this.filterSelectionChange = new EventEmitter();
+        this.filterCategorySelectionChange = new EventEmitter();
+        this._activeFilterList = []; // This is list of filter. the selected filter from this list. it will be global or local filter list.
+        this._activeFilterCategoryList = []; // This is list of filter. the selected filter from this list. it will be global or local filter list.
+    }
+    /**
+     * Get Active filter list.
+     *
+     * @returns Array of AXFilters
+     */
+    getActiveFilterList() {
+        return this._activeFilterList;
+    }
+    /**
+     * Get Active filter category list.
+     *
+     * @returns Array of AXFilters
+     */
+    getActiveFilterCategoryList() {
+        return this._activeFilterCategoryList;
+    }
+    /**
+     * set Active  Filters list.
+     *
+     * @param filters;
+     */
+    setActiveFilterList(filters) {
+        this._activeFilterList = filters;
+    }
+    setActiveFilterCategoryList(filters) {
+        this._activeFilterCategoryList = filters;
+    }
+    /**
+     * Check Filter value is empty or NOT
+     *
+     * @param filters
+     * @returns
+     */
+    getValidFilter(filters, filterType = 0) {
+        if (filters.length === 0) {
+            return [];
+        }
+        return filters.filter(filter => filter.searchNodes[0].expression.searchable() && !filter.isDeleted);
+    }
+    /**
+     * Check filter category is empty or Not
+     *
+     * @param filterCategory
+     * @returns
+     */
+    getValidFilterCategory(filterCategory, filterType = 0) {
+        if (filterCategory.length === 0) {
+            return null;
+        }
+        return filterCategory.filter(category => category.isSearchable && !category.isDeleted && category.filters.length);
+    }
+    /**
+     * checks value has a property value and checks the value is valid or not.
+     *
+     * @param filter
+     * @returns
+     */
+    getValidValue(filter) {
+        const value = filter.searchNodes[0].expression.value;
+        if (value && value.hasOwnProperty('value')) {
+            return this.returnValidValue(value.value);
+        }
+        else {
+            return this.returnValidValue(value);
+        }
+    }
+    /**
+     * return value is value or not as per the value type.
+     * i.e string,number,object
+     *
+     * @param value
+     * @returns
+     */
+    returnValidValue(value) {
+        switch (typeof value) {
+            case 'number':
+                return value ? true : false;
+            case 'string':
+                return value ? true : false;
+            case 'object':
+                if (Array.isArray(value)) {
+                    return value.length > 0;
+                }
+                else {
+                    return value ? true : false;
+                }
+            default:
+                return false;
+        }
+    }
+    /**
+     * Generate Filter for meta column.
+     *
+     * @param metaColumnType
+     */
+    generateMetaColumnFilter(metaColumnType, appVersionId) {
+        const _filter = this._metaColumnBuilderService.buildMetaColumn(metaColumnType, appVersionId);
+        return _filter;
+    }
+    /**
+     * returns true if there is a visible filter present
+     * @param filters
+     * @param filterCategory
+     * @returns
+     */
+    setVisibilityOfFilterComponent(filters = [], filterCategory = []) {
+        var isFilterPresent = false;
+        filters.forEach(filter => {
+            if (filter.isVisible) {
+                isFilterPresent = true;
+                return isFilterPresent;
+            }
+        });
+        filterCategory.forEach(filterCategory => {
+            if (filterCategory.isVisible) {
+                isFilterPresent = true;
+                return isFilterPresent;
+            }
+        });
+        return isFilterPresent;
+    }
+}
+FiltersService.ɵfac = function FiltersService_Factory(t) { return new (t || FiltersService)(i0.ɵɵinject(i1.MetaColumnFilterBuilderService)); };
+FiltersService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FiltersService, factory: FiltersService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FiltersService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.MetaColumnFilterBuilderService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filters.service.js","sourceRoot":"","sources":["../../../../../src/ax-common-ui-lib/src/lib/filters/filters.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { MetaColumnFilterBuilderService } from './meta-column-filter-builder/meta-column-filter-builder.service';\nimport { EventEmitter, Injectable } from '@angular/core';\nimport { AxFilter } from '../enlighten-lib/filters/ax-filter';\nimport { FilterCategory } from '../enlighten-lib/filters/filter-category';\nimport { MetaColumnTypes } from './metaColumnTypes';\n\n@Injectable()\nexport class FiltersService {\n    /**\n     * Component variables.\n     */\n    // filter selection change emitter.\n    filterSelectionChange: EventEmitter<AxFilter> = new EventEmitter();\n    filterCategorySelectionChange: EventEmitter<FilterCategory> = new EventEmitter();\n\n    private _activeFilterList: Array<AxFilter> = []; // This is list of filter. the selected filter from this list. it will be global or local filter list.\n    private _activeFilterCategoryList: Array<FilterCategory> = []; // This is list of filter. the selected filter from this list. it will be global or local filter list.\n\n    /**\n     * Constructor\n     */\n    constructor(\n        private _metaColumnBuilderService: MetaColumnFilterBuilderService\n    ) { }\n\n    /**\n     * Get Active filter list.\n     *\n     * @returns Array of AXFilters\n     */\n    getActiveFilterList(): Array<AxFilter>{\n        return this._activeFilterList;\n    }\n\n    /**\n     * Get Active filter category list.\n     *\n     * @returns Array of AXFilters\n     */\n    getActiveFilterCategoryList(): Array<FilterCategory>{\n        return this._activeFilterCategoryList;\n    }\n\n\n    /**\n     * set Active  Filters list.\n     *\n     * @param filters;\n     */\n    setActiveFilterList(filters: Array<AxFilter>): void{\n        this._activeFilterList = filters;\n    }\n\n    setActiveFilterCategoryList(filters: Array<FilterCategory>): void{\n        this._activeFilterCategoryList = filters;\n    }\n\n    /**\n     * Check Filter value is empty or NOT\n     *\n     * @param filters\n     * @returns\n     */\n    getValidFilter(filters: Array<AxFilter>, filterType: number = 0): Array<AxFilter> {\n        if (filters.length === 0) {\n            return [];\n        }\n        return filters.filter(filter => filter.searchNodes[0].expression.searchable()  && !filter.isDeleted\n        );\n    }\n\n    /**\n     * Check filter category is empty or Not\n     *\n     * @param filterCategory\n     * @returns\n     */\n    getValidFilterCategory(filterCategory: Array<FilterCategory>, filterType: number = 0): Array<FilterCategory> {\n        if (filterCategory.length === 0) {\n            return null;\n        }\n        return filterCategory.filter(category => category.isSearchable && !category.isDeleted && category.filters.length);\n    }\n\n    /**\n     * checks value has a property value and checks the value is valid or not.\n     *\n     * @param filter\n     * @returns\n     */\n    getValidValue(filter: any): boolean {\n        const value = filter.searchNodes[0].expression.value as any;\n        if (value && value.hasOwnProperty('value')) {\n            return this.returnValidValue(value.value);\n        }\n        else {\n            return this.returnValidValue(value);\n        }\n    }\n\n    /**\n     * return value is value or not as per the value type.\n     * i.e string,number,object\n     *\n     * @param value\n     * @returns\n     */\n    returnValidValue(value: any): boolean {\n        switch (typeof value) {\n            case 'number':\n                return value ? true : false;\n            case 'string':\n                return value ? true : false;\n            case 'object':\n                if (Array.isArray(value)) {\n                    return value.length > 0;\n                }\n                else {\n                    return value ? true : false;\n                }\n            default:\n                return false;\n        }\n    }\n\n    /**\n     * Generate Filter for meta column.\n     *\n     * @param metaColumnType\n     */\n    generateMetaColumnFilter(metaColumnType: MetaColumnTypes,appVersionId: number): AxFilter{\n        const _filter = this._metaColumnBuilderService.buildMetaColumn(metaColumnType,appVersionId);\n        return _filter;\n    }\n\n\n    /**\n     * returns true if there is a visible filter present\n     * @param filters\n     * @param filterCategory\n     * @returns\n     */\n    setVisibilityOfFilterComponent(filters: Array<AxFilter> = [],filterCategory: Array<FilterCategory> = []): boolean{\n        var isFilterPresent = false;\n        filters.forEach(filter => {\n            if(filter.isVisible){\n                isFilterPresent = true;\n                return isFilterPresent;\n            }\n        });\n        filterCategory.forEach(filterCategory => {\n            if(filterCategory.isVisible){\n                isFilterPresent = true;\n                return isFilterPresent;\n            }\n        });\n        return isFilterPresent;\n    }\n}\n"]}

package/esm2020/lib/filters/meta-column-filter-builder/meta-column-filter-builder.service.mjs

@@ -0,0 +1,202 @@
+import { MetaColumnIdentifiers } from './../metaColumnTypes';
+import { ChoiceListOption } from './../../forms/page/widgets/widget-value/choice-list-options';
+import { UserService } from './../../core/user/user.service';
+import { Injectable } from '@angular/core';
+import { AxExpression } from '../../enlighten-lib/ax-expression/ax-expression';
+import { Attribute, AttributeTypes } from '../../enlighten-lib/data-model/attribute';
+import { AxFilter } from '../../enlighten-lib/filters/ax-filter';
+import { ConditionType, FilterType, ScopeType } from '../../enlighten-lib/filters/condition-type';
+import { SearchNode } from '../../enlighten-lib/filters/search-node';
+import { WidgetSubType, WidgetType } from '../../forms/page/common/widget-enums';
+import { MetaColumnTypes } from '../metaColumnTypes';
+import { ExpressionValueSubType } from '../../enlighten-lib/ax-expression/exp-sub-type';
+import * as i0 from "@angular/core";
+import * as i1 from "./../../core/user/user.service";
+export class MetaColumnFilterBuilderService {
+    constructor(_userService) {
+        this._userService = _userService;
+    }
+    /**
+     * Build Meta Column Filter by meta Column type
+     *
+     * @param MetaColumnTypes
+     * @returns
+     */
+    buildMetaColumn(metaColumnType, appVersionId) {
+        this.appVersionId = appVersionId;
+        const _filter = this.generateFilter();
+        switch (metaColumnType) {
+            case MetaColumnTypes.taskStatus:
+                return this.buildTaskStatusFilter(_filter, metaColumnType);
+            case MetaColumnTypes.taskAssignedTo:
+                return this.buildUserMetaFilter(_filter, metaColumnType);
+            case MetaColumnTypes.taskCompletedDate:
+                return this.builderGenericDateFilter(_filter, metaColumnType);
+            case MetaColumnTypes.taskCreatedDate:
+                return this.builderGenericDateFilter(_filter, metaColumnType);
+        }
+        return;
+    }
+    /**
+     * Generate Attribute object by meta column type
+     *
+     * @param metaColumnType
+     * @returns
+     */
+    generateAttribute(metaColumnType) {
+        const attribute = new Attribute();
+        attribute.identifier = MetaColumnIdentifiers.getMetaColumnIdentifier(metaColumnType);
+        attribute.name = attribute.identifier;
+        attribute.label = metaColumnType;
+        attribute.attributeType = AttributeTypes.metaType;
+        return attribute;
+    }
+    /**
+     * Generate Search node for meta column filter
+     *
+     * @returns
+     */
+    generateSearchNode() {
+        const searchNode = new SearchNode();
+        searchNode.type = ConditionType.condition;
+        return searchNode;
+    }
+    /**
+     * Generate Filter Object
+     *
+     * @returns
+     */
+    generateFilter() {
+        const axFilter = new AxFilter();
+        axFilter.type = FilterType.basic;
+        axFilter.scope = ScopeType.global;
+        axFilter.appVersionId = this.appVersionId;
+        return axFilter;
+    }
+    /**
+     * Build Task Status Filter
+     *
+     * @returns
+     */
+    buildTaskStatusFilter(filter, metaColumnType) {
+        const searchNode = this.generateSearchNode();
+        const expression = new AxExpression();
+        const attribute = this.generateAttribute(metaColumnType);
+        const options = [
+            {
+                value: '0',
+                label: 'To Do',
+                img: '',
+                visible: true,
+            },
+            {
+                value: '1',
+                label: 'DELIVERED',
+                img: '',
+                visible: false,
+            },
+            {
+                value: '2',
+                label: 'Done',
+                img: '',
+                visible: true,
+            },
+            {
+                value: '3',
+                label: 'Rejected',
+                img: '',
+                visible: false,
+            },
+            {
+                value: '4',
+                label: 'UNASSIGNED',
+                img: '',
+                visible: false
+            },
+            {
+                value: '5',
+                label: 'FAILED',
+                img: '',
+                visible: false,
+            },
+            {
+                value: '6',
+                label: 'Cancelled',
+                img: '',
+                visible: false,
+            },
+        ];
+        attribute.choices = options;
+        attribute.widgetType = WidgetType.choiceList;
+        attribute.widgetSubType = WidgetSubType.imageFixedList;
+        attribute.formId = 0;
+        expression.field = attribute;
+        searchNode.expression = expression;
+        filter.searchNodes.push(searchNode);
+        return filter;
+    }
+    /**
+     * Generate Task Assign To filter
+     *
+     * @param filter
+     * @param metaColumnType
+     * @returns
+     */
+    buildUserMetaFilter(filter, metaColumnType) {
+        const searchNode = this.generateSearchNode();
+        const expression = new AxExpression();
+        const attribute = this.generateAttribute(metaColumnType);
+        attribute.choices = [];
+        attribute.widgetType = WidgetType.choiceList;
+        attribute.widgetSubType = WidgetSubType.userList;
+        attribute.formId = 0;
+        expression.field = attribute;
+        expression.value = expression.getExpressionValueObject(ExpressionValueSubType.textList);
+        searchNode.expression = expression;
+        filter.searchNodes.push(searchNode);
+        return filter;
+    }
+    /**
+     * Generate User filter
+     *
+     * @param users
+     * @returns
+     */
+    builderChoiceListOptionsForUsers(users) {
+        const choiceListOptions = [];
+        users.forEach(((user) => {
+            const choiceListOption = new ChoiceListOption();
+            choiceListOption.img = user.avatar;
+            choiceListOption.value = user.id;
+            choiceListOption.label = user.firstName + ' ' + user.lastName;
+            choiceListOptions.push(choiceListOption);
+        }));
+        return choiceListOptions;
+    }
+    /**
+     * Generate generic date filter.
+     *
+     * @param filter
+     * @param metaColumnType
+     * @returns
+     */
+    builderGenericDateFilter(filter, metaColumnType) {
+        const searchNode = this.generateSearchNode();
+        const expression = new AxExpression();
+        const attribute = this.generateAttribute(metaColumnType);
+        attribute.choices = [];
+        attribute.widgetType = WidgetType.dateTime;
+        attribute.widgetSubType = WidgetSubType.date;
+        attribute.formId = 0;
+        expression.field = attribute;
+        searchNode.expression = expression;
+        filter.searchNodes.push(searchNode);
+        return filter;
+    }
+}
+MetaColumnFilterBuilderService.ɵfac = function MetaColumnFilterBuilderService_Factory(t) { return new (t || MetaColumnFilterBuilderService)(i0.ɵɵinject(i1.UserService)); };
+MetaColumnFilterBuilderService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: MetaColumnFilterBuilderService, factory: MetaColumnFilterBuilderService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MetaColumnFilterBuilderService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.UserService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"meta-column-filter-builder.service.js","sourceRoot":"","sources":["../../../../../../src/ax-common-ui-lib/src/lib/filters/meta-column-filter-builder/meta-column-filter-builder.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { MetaColumnIdentifiers } from './../metaColumnTypes';\nimport { ChoiceListOption } from './../../forms/page/widgets/widget-value/choice-list-options';\nimport { UserService } from './../../core/user/user.service';\nimport { Injectable } from '@angular/core';\nimport { AxExpression } from '../../enlighten-lib/ax-expression/ax-expression';\nimport { Attribute, AttributeTypes } from '../../enlighten-lib/data-model/attribute';\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, WidgetType } from '../../forms/page/common/widget-enums';\nimport { MetaColumnTypes } from '../metaColumnTypes';\nimport { User } from '../../core/user/user.types';\nimport { ExpressionValueSubType } from '../../enlighten-lib/ax-expression/exp-sub-type';\n@Injectable()\nexport class MetaColumnFilterBuilderService {\n    //<-----------------(Service Variables)----------->\n    appVersionId: number;\n\n  constructor(\n    private _userService: UserService\n  ) { }\n     /**\n      * Build Meta Column Filter by meta Column type\n      *\n      * @param MetaColumnTypes\n      * @returns\n      */\n    buildMetaColumn(metaColumnType: MetaColumnTypes,appVersionId: number): AxFilter{\n        this.appVersionId = appVersionId;\n        const _filter = this.generateFilter();\n        switch(metaColumnType){\n            case MetaColumnTypes.taskStatus:\n                return this.buildTaskStatusFilter(_filter,metaColumnType);\n            case MetaColumnTypes.taskAssignedTo:\n                return this.buildUserMetaFilter(_filter,metaColumnType);\n            case MetaColumnTypes.taskCompletedDate:\n                return this.builderGenericDateFilter(_filter,metaColumnType);\n            case MetaColumnTypes.taskCreatedDate:\n                return this.builderGenericDateFilter(_filter,metaColumnType);\n        }\n        return;\n    }\n\n    /**\n     * Generate Attribute object by meta column type\n     *\n     * @param metaColumnType\n     * @returns\n     */\n    generateAttribute(metaColumnType: MetaColumnTypes): Attribute{\n        const attribute = new Attribute();\n        attribute.identifier = MetaColumnIdentifiers.getMetaColumnIdentifier(metaColumnType);\n        attribute.name = attribute.identifier;\n        attribute.label = metaColumnType;\n        attribute.attributeType = AttributeTypes.metaType;\n        return attribute;\n    }\n\n    /**\n     * Generate Search node for meta column filter\n     *\n     * @returns\n     */\n    generateSearchNode(): SearchNode{\n        const searchNode = new SearchNode();\n        searchNode.type = ConditionType.condition;\n        return searchNode;\n\n    }\n\n    /**\n     * Generate Filter Object\n     *\n     * @returns\n     */\n    generateFilter(): AxFilter{\n        const axFilter = new AxFilter();\n        axFilter.type = FilterType.basic;\n        axFilter.scope = ScopeType.global;\n        axFilter.appVersionId = this.appVersionId;\n        return axFilter;\n\n    }\n\n\n    /**\n     * Build Task Status Filter\n     *\n     * @returns\n     */\n     buildTaskStatusFilter(filter: AxFilter,metaColumnType: MetaColumnTypes): AxFilter{\n\n        const searchNode = this.generateSearchNode();\n        const expression = new AxExpression();\n        const attribute = this.generateAttribute(metaColumnType);\n\n        const options: Array<ChoiceListOption> = [\n            {\n                value:'0',\n                label:'To Do',\n                img:'',\n                visible:true,\n            },\n            {\n                value:'1',\n                label:'DELIVERED',\n                img:'',\n                visible:false,\n            },\n            {\n                value:'2',\n                label:'Done',\n                img:'',\n                visible:true,\n            },\n            {\n                value:'3',\n                label:'Rejected',\n                img:'',\n                visible:false,\n            },\n            {\n                value:'4',\n                label:'UNASSIGNED',\n                img:'',\n                visible:false\n            },\n            {\n                value:'5',\n                label:'FAILED',\n                img:'',\n                visible:false,\n            },\n            {\n                value:'6',\n                label:'Cancelled',\n                img:'',\n                visible:false,\n            },\n        ];\n        attribute.choices = options;\n        attribute.widgetType = WidgetType.choiceList;\n        attribute.widgetSubType = WidgetSubType.imageFixedList;\n        attribute.formId = 0;\n        expression.field = attribute;\n        searchNode.expression = expression;\n        filter.searchNodes.push(searchNode);\n        return filter;\n    }\n\n    /**\n     * Generate Task Assign To filter\n     *\n     * @param filter\n     * @param metaColumnType\n     * @returns\n     */\n    buildUserMetaFilter(filter: AxFilter,metaColumnType: MetaColumnTypes): AxFilter{\n        const searchNode = this.generateSearchNode();\n        const expression = new AxExpression();\n        const attribute = this.generateAttribute(metaColumnType);\n        attribute.choices =[];\n        attribute.widgetType = WidgetType.choiceList;\n        attribute.widgetSubType = WidgetSubType.userList;\n        attribute.formId = 0;\n        expression.field = attribute;\n        expression.value = expression.getExpressionValueObject(ExpressionValueSubType.textList);\n        searchNode.expression = expression;\n        filter.searchNodes.push(searchNode);\n        return filter;\n    }\n    /**\n     * Generate User filter\n     *\n     * @param users\n     * @returns\n     */\n    builderChoiceListOptionsForUsers(users: Array<User>): Array<ChoiceListOption>{\n        const choiceListOptions: Array<ChoiceListOption> = [];\n            users.forEach(((user)=>{\n                const choiceListOption = new ChoiceListOption();\n                choiceListOption.img = user.avatar;\n                choiceListOption.value = user.id;\n                choiceListOption.label = user.firstName+' '+user.lastName;\n                choiceListOptions.push(choiceListOption);\n            }));\n        return choiceListOptions;\n    }\n\n    /**\n     * Generate generic date filter.\n     *\n     * @param filter\n     * @param metaColumnType\n     * @returns\n     */\n    builderGenericDateFilter(filter: AxFilter,metaColumnType: MetaColumnTypes): AxFilter{\n        const searchNode = this.generateSearchNode();\n        const expression = new AxExpression();\n        const attribute = this.generateAttribute(metaColumnType);\n        attribute.choices =[];\n        attribute.widgetType = WidgetType.dateTime;\n        attribute.widgetSubType = WidgetSubType.date;\n        attribute.formId = 0;\n        expression.field = attribute;\n        searchNode.expression = expression;\n        filter.searchNodes.push(searchNode);\n        return filter;\n    }\n\n\n}\n"]}

package/esm2020/lib/filters/metaColumnTypes.mjs

@@ -0,0 +1,36 @@
+/**
+ * Enum For meta column types
+ */
+export var MetaColumnTypes;
+(function (MetaColumnTypes) {
+    MetaColumnTypes["taskStatus"] = "Status";
+    MetaColumnTypes["taskAssignedTo"] = "Assigned to";
+    MetaColumnTypes["taskAssignedBy"] = "Assigned by";
+    MetaColumnTypes["taskWorkflow"] = "Workflows";
+    MetaColumnTypes["taskCreatedDate"] = "Created Date";
+    MetaColumnTypes["taskCompletedDate"] = "Completed Date";
+})(MetaColumnTypes || (MetaColumnTypes = {}));
+/**
+ * @Class MetaColumnIdentifiers
+ * Return Identifier for meta column
+ */
+export class MetaColumnIdentifiers {
+    static getMetaColumnIdentifier(metaColumnTypes) {
+        switch (metaColumnTypes) {
+            case MetaColumnTypes.taskStatus:
+                return 'task_status';
+            case MetaColumnTypes.taskAssignedTo:
+                return 'task_user_id';
+            case MetaColumnTypes.taskAssignedBy:
+                return 'task_assigned_by';
+            case MetaColumnTypes.taskWorkflow:
+                return 'task_workflowinstance_id';
+            case MetaColumnTypes.taskCreatedDate:
+                return 'task_created_at';
+            case MetaColumnTypes.taskCompletedDate:
+                return 'task_completed_date';
+        }
+        return;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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