@pepperi-addons/ngx-lib 0.2.55 → 0.2.58-beta.1

package/esm2015/smart-filters/filter-builder/common/model/operator-unit.js

@@ -0,0 +1,42 @@
+import { PepSmartFilterOperatorUnits } from '../../../common/model/operator';
+const Days = {
+    legacy: 'Days',
+    smartFilter: PepSmartFilterOperatorUnits.Days
+};
+const Weeks = {
+    legacy: 'Weeks',
+    smartFilter: PepSmartFilterOperatorUnits.Weeks
+};
+const Months = {
+    legacy: 'Months',
+    smartFilter: PepSmartFilterOperatorUnits.Months
+};
+const Years = {
+    legacy: 'Years',
+    smartFilter: PepSmartFilterOperatorUnits.Years
+};
+const PepFilterBuilderOperationUnit = [
+    Days,
+    Weeks,
+    Months,
+    Years,
+];
+/**
+ * gets a smart filter operation unit item
+ * @param operationUnit legacy operation unit
+ * @returns smart filter operation unit item
+ */
+export function getSmartBuilderOperationUnit(operationUnit) {
+    const smartFilterOperationUnit = PepFilterBuilderOperationUnit.find(unit => unit.legacy === operationUnit);
+    return smartFilterOperationUnit ? smartFilterOperationUnit.smartFilter : null;
+}
+/**
+ * gets a legacy operation unit value
+ * @param operationUnit smart filter operation unit item
+ * @returns legacy operation unit value
+ */
+export function getLegacyOperationUnit(operationUnit) {
+    const legacyOperationUnit = PepFilterBuilderOperationUnit.find(unit => unit.smartFilter === operationUnit);
+    return legacyOperationUnit ? legacyOperationUnit.legacy : null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/smart-filters/filter-builder/common/model/operator.js

@@ -0,0 +1,207 @@
+import { PepSmartFilterOperators } from '../../../common/model/operator';
+const Equals = {
+    legacy: 'IsEqual',
+    smartFilter: PepSmartFilterOperators.Equals,
+    type: ['boolean', 'int', 'text']
+};
+const NotEqual = {
+    legacy: 'IsNotEqual',
+    smartFilter: PepSmartFilterOperators.NotEqual,
+    type: null
+};
+const LessThan = {
+    legacy: '<',
+    smartFilter: PepSmartFilterOperators.LessThan,
+    type: null
+};
+const GreaterThan = {
+    legacy: '>',
+    smartFilter: PepSmartFilterOperators.GreaterThan,
+    type: null
+};
+/*
+const GreaterThanOrEquals: IPepFilterBuilderOperator = {
+    legacy: {
+        operator: '>=',
+        type: 'Integer'
+    },
+    smartFilter: {
+        item: PepSmartFilterOperators.GreaterThanOrEquals,
+        type: 'int'
+    }
+};
+
+const LessThanOrEquals: IPepFilterBuilderOperator = {
+    legacy: {
+        operator: '<=',
+        type: 'Integer'
+    },
+    smartFilter: {
+        item: PepSmartFilterOperators.LessThanOrEquals,
+        type: 'int',
+        type: 'Integer'
+    }
+}; */
+const NumberRange = {
+    legacy: 'Between',
+    smartFilter: PepSmartFilterOperators.NumberRange,
+    type: ['int']
+};
+const Contains = {
+    legacy: 'Contains',
+    smartFilter: PepSmartFilterOperators.Contains,
+    type: null
+};
+/*
+const BeginsWith: IPepFilterBuilderOperator = {
+    legacy: {
+        operator: 'BeginsWith',
+        type: 'String'
+    },
+    smartFilter: {
+        item: PepSmartFilterOperators.BeginsWith,
+        type: 'text'
+    }
+};
+
+const EndsWith: IPepFilterBuilderOperator = {
+    legacy: {
+        operator: 'EndsWith',
+        type: 'String'
+    },
+    smartFilter: {
+        item: PepSmartFilterOperators.EndsWith,
+        type: 'text'
+    }
+};
+
+const Before: IPepFilterBuilderOperator = {
+    legacy: {
+        operator: 'Before',
+        type: 'Date'
+    },
+    smartFilter: {
+        item: PepSmartFilterOperators.Before,
+        type: 'date'
+    }
+};
+
+const After: IPepFilterBuilderOperator = {
+    legacy: {
+        operator: 'After',
+        type: 'Date'
+    },
+    smartFilter: {
+        item: PepSmartFilterOperators.After,
+        type: 'date'
+    }
+}; */
+const InTheLast = {
+    legacy: 'InTheLast',
+    smartFilter: PepSmartFilterOperators.InTheLast,
+    type: null
+};
+const NotInTheLast = {
+    legacy: 'NotInTheLast',
+    smartFilter: PepSmartFilterOperators.NotInTheLast,
+    type: null
+};
+const Today = {
+    legacy: 'Today',
+    smartFilter: PepSmartFilterOperators.Today,
+    type: null
+};
+const ThisWeek = {
+    legacy: 'ThisWeek',
+    smartFilter: PepSmartFilterOperators.ThisWeek,
+    type: null
+};
+const ThisMonth = {
+    legacy: 'ThisMonth',
+    smartFilter: PepSmartFilterOperators.ThisMonth,
+    type: null
+};
+const DateRange = {
+    legacy: 'Between',
+    smartFilter: PepSmartFilterOperators.DateRange,
+    type: ['date-time']
+};
+const DueIn = {
+    legacy: 'DueIn',
+    smartFilter: PepSmartFilterOperators.DueIn,
+    type: null
+};
+const NotDueIn = {
+    legacy: 'NotDueIn',
+    smartFilter: PepSmartFilterOperators.NotDueIn,
+    type: null
+};
+const On = {
+    legacy: 'On',
+    smartFilter: PepSmartFilterOperators.On,
+    type: null
+};
+const IsEmpty = {
+    legacy: 'IsEmpty',
+    smartFilter: PepSmartFilterOperators.IsEmpty,
+    type: null
+};
+const IsNotEmpty = {
+    legacy: 'IsNotEmpty',
+    smartFilter: PepSmartFilterOperators.IsNotEmpty,
+    type: null
+};
+const In = {
+    legacy: 'IsEqual',
+    smartFilter: PepSmartFilterOperators.In,
+    type: ['multi-select']
+};
+const PepFilterBuilderOperators = [
+    Equals,
+    NotEqual,
+    LessThan,
+    //   LessThanOrEquals,
+    GreaterThan,
+    //   GreaterThanOrEquals,
+    NumberRange,
+    Contains,
+    //   BeginsWith,
+    //   EndsWith,
+    //   After,
+    //   Before,
+    InTheLast,
+    NotInTheLast,
+    Today,
+    ThisWeek,
+    ThisMonth,
+    DateRange,
+    DueIn,
+    NotDueIn,
+    On,
+    IsEmpty,
+    IsNotEmpty,
+    In
+];
+/**
+ * gets a smart filter operator item
+ * @param operator legacy operator
+ * @param type smart filter's type
+ * @returns smart filter operator item
+ */
+export function getSmartBuilderOperator(operator, type) {
+    const smartFilterOperator = PepFilterBuilderOperators.find(item => item.legacy === operator &&
+        (item.type === null || item.type.includes(type)));
+    return smartFilterOperator ? smartFilterOperator.smartFilter : null;
+}
+/**
+ * gets a legacy operator value
+ * @param operator smart filter operator item
+ * @param type smart filter's type
+ * @returns legacy operator value
+ */
+export function getLegacyOperator(operator, type) {
+    const legacyOperator = PepFilterBuilderOperators.find(item => item.smartFilter === operator &&
+        (item.type === null || item.type.includes(type)));
+    return legacyOperator ? legacyOperator.legacy : null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operator.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-lib/smart-filters/filter-builder/common/model/operator.ts"],"names":[],"mappings":"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","sourcesContent":["import { PepSmartFilterOperators, IPepSmartFilterOperator } from '../../../common/model/operator';\nimport { PepSmartFilterType } from '../../../common/model/type';\n\nexport interface IPepFilterBuilderOperator {\n    legacy: string, //legacy Operator    \n    smartFilter: IPepSmartFilterOperator, //smart filter operator    \n    type: PepSmartFilterType[] | null //smart filter type\n}\n\nconst Equals: IPepFilterBuilderOperator = {\n    legacy: 'IsEqual',\n    smartFilter: PepSmartFilterOperators.Equals,\n    type: ['boolean', 'int', 'text']\n};\n\nconst NotEqual: IPepFilterBuilderOperator = {\n    legacy: 'IsNotEqual',\n    smartFilter: PepSmartFilterOperators.NotEqual,\n    type: null\n};\n\nconst LessThan: IPepFilterBuilderOperator = {\n    legacy: '<',\n    smartFilter: PepSmartFilterOperators.LessThan,\n    type: null\n};\n\nconst GreaterThan: IPepFilterBuilderOperator = {\n    legacy: '>',\n    smartFilter: PepSmartFilterOperators.GreaterThan,\n    type: null\n};\n\n/*\nconst GreaterThanOrEquals: IPepFilterBuilderOperator = {\n    legacy: {\n        operator: '>=',\n        type: 'Integer'\n    },\n    smartFilter: {\n        item: PepSmartFilterOperators.GreaterThanOrEquals,\n        type: 'int'\n    }\n};\n\nconst LessThanOrEquals: IPepFilterBuilderOperator = {\n    legacy: {\n        operator: '<=',\n        type: 'Integer'\n    },\n    smartFilter: {\n        item: PepSmartFilterOperators.LessThanOrEquals,\n        type: 'int',\n        type: 'Integer'\n    }\n}; */\n\nconst NumberRange: IPepFilterBuilderOperator = {\n    legacy: 'Between',\n    smartFilter: PepSmartFilterOperators.NumberRange,\n    type: ['int']\n};\n\nconst Contains: IPepFilterBuilderOperator = {\n    legacy: 'Contains',\n    smartFilter: PepSmartFilterOperators.Contains,\n    type: null\n};\n\n/*\nconst BeginsWith: IPepFilterBuilderOperator = {\n    legacy: {\n        operator: 'BeginsWith',\n        type: 'String'\n    },\n    smartFilter: {\n        item: PepSmartFilterOperators.BeginsWith,\n        type: 'text'\n    }\n};\n\nconst EndsWith: IPepFilterBuilderOperator = {\n    legacy: {\n        operator: 'EndsWith',\n        type: 'String'\n    },\n    smartFilter: {\n        item: PepSmartFilterOperators.EndsWith,\n        type: 'text'\n    }\n};\n\nconst Before: IPepFilterBuilderOperator = {\n    legacy: {\n        operator: 'Before',\n        type: 'Date'\n    },\n    smartFilter: {\n        item: PepSmartFilterOperators.Before,\n        type: 'date'\n    }\n};\n\nconst After: IPepFilterBuilderOperator = {\n    legacy: {\n        operator: 'After',\n        type: 'Date'\n    },\n    smartFilter: {\n        item: PepSmartFilterOperators.After,\n        type: 'date'\n    }\n}; */\n\nconst InTheLast: IPepFilterBuilderOperator = {\n    legacy: 'InTheLast',\n    smartFilter: PepSmartFilterOperators.InTheLast,\n    type: null\n};\n\nconst NotInTheLast: IPepFilterBuilderOperator = {\n    legacy: 'NotInTheLast',\n    smartFilter: PepSmartFilterOperators.NotInTheLast,\n    type: null\n};\n\nconst Today: IPepFilterBuilderOperator = {\n    legacy: 'Today',\n    smartFilter: PepSmartFilterOperators.Today,\n    type: null\n};\n\nconst ThisWeek: IPepFilterBuilderOperator = {\n    legacy: 'ThisWeek',\n    smartFilter: PepSmartFilterOperators.ThisWeek,\n    type: null\n};\n\nconst ThisMonth: IPepFilterBuilderOperator = {\n    legacy: 'ThisMonth',\n    smartFilter: PepSmartFilterOperators.ThisMonth,\n    type: null\n};\n\nconst DateRange: IPepFilterBuilderOperator = {\n    legacy: 'Between',\n    smartFilter: PepSmartFilterOperators.DateRange,\n    type: ['date-time']\n};\n\nconst DueIn: IPepFilterBuilderOperator = {\n    legacy: 'DueIn',\n    smartFilter: PepSmartFilterOperators.DueIn,\n    type: null\n};\n\nconst NotDueIn: IPepFilterBuilderOperator = {\n    legacy: 'NotDueIn',\n    smartFilter: PepSmartFilterOperators.NotDueIn,\n    type: null\n};\n\nconst On: IPepFilterBuilderOperator = {\n    legacy: 'On',\n    smartFilter: PepSmartFilterOperators.On,\n    type: null\n};\n\nconst IsEmpty: IPepFilterBuilderOperator = {\n    legacy: 'IsEmpty',\n    smartFilter: PepSmartFilterOperators.IsEmpty,\n    type: null\n};\n\nconst IsNotEmpty: IPepFilterBuilderOperator = {\n    legacy: 'IsNotEmpty',\n    smartFilter: PepSmartFilterOperators.IsNotEmpty,\n    type: null\n};\n\nconst In: IPepFilterBuilderOperator = {\n    legacy: 'IsEqual',\n    smartFilter: PepSmartFilterOperators.In,\n    type: ['multi-select']\n};\n\n\nconst PepFilterBuilderOperators = [\n    Equals,\n    NotEqual,\n    LessThan,\n    //   LessThanOrEquals,\n    GreaterThan,\n    //   GreaterThanOrEquals,\n    NumberRange,\n    Contains,\n    //   BeginsWith,\n    //   EndsWith,\n    //   After,\n    //   Before,\n    InTheLast,\n    NotInTheLast,\n    Today,\n    ThisWeek,\n    ThisMonth,\n    DateRange,\n    DueIn,\n    NotDueIn,\n    On,\n    IsEmpty,\n    IsNotEmpty,\n    In\n]\n\n/**\n * gets a smart filter operator item\n * @param operator legacy operator\n * @param type smart filter's type\n * @returns smart filter operator item\n */\nexport function getSmartBuilderOperator(operator: string, type: PepSmartFilterType): IPepSmartFilterOperator | null {\n    const smartFilterOperator = PepFilterBuilderOperators.find(item =>\n        item.legacy === operator &&\n        (item.type === null || item.type.includes(type))\n    );\n    return smartFilterOperator ? smartFilterOperator.smartFilter : null;\n}\n\n/**\n * gets a legacy operator value\n * @param operator smart filter operator item\n * @param type smart filter's type\n * @returns legacy operator value\n */\nexport function getLegacyOperator(operator: IPepSmartFilterOperator, type: PepSmartFilterType): string | null {\n    const legacyOperator = PepFilterBuilderOperators.find(item =>\n        item.smartFilter === operator &&\n        (item.type === null || item.type.includes(type))\n    );\n    return legacyOperator ? legacyOperator.legacy : null;\n}\n"]}

package/esm2015/smart-filters/filter-builder/common/model/type-map.js

@@ -0,0 +1,27 @@
+export class PepFilterBuilderTypeMap {
+    constructor() {
+        this.loadTypes();
+    }
+    loadTypes() {
+        this.map = new Map();
+        this.map.set('Bool', 'boolean');
+        this.map.set('JsonBool', 'boolean');
+        this.map.set('Integer', 'int');
+        this.map.set('Double', 'int');
+        this.map.set('String', 'text');
+        this.map.set('Guid', 'text');
+        this.map.set('Date', 'date');
+        this.map.set('DateTime', 'date-time');
+        this.map.set('MultipleStringValues', 'multi-select');
+    }
+    /**
+     * Converts legacy field type to smart builder type
+     * @param type legacy type
+     * @returns smart builder field type
+     */
+    getSmartBuilderType(key) {
+        let item = this.map.get(key);
+        return item ? item : null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/smart-filters/filter-builder/common/model/type.js

@@ -0,0 +1,6 @@
+export var PepOperatorTypes;
+(function (PepOperatorTypes) {
+    PepOperatorTypes["And"] = "AND";
+    PepOperatorTypes["Or"] = "OR";
+})(PepOperatorTypes || (PepOperatorTypes = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1saWIvc21hcnQtZmlsdGVycy9maWx0ZXItYnVpbGRlci9jb21tb24vbW9kZWwvdHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxnQkFHWDtBQUhELFdBQVksZ0JBQWdCO0lBQ3hCLCtCQUFXLENBQUE7SUFDWCw2QkFBUyxDQUFBO0FBQ2IsQ0FBQyxFQUhXLGdCQUFnQixLQUFoQixnQkFBZ0IsUUFHM0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBQZXBPcGVyYXRvclR5cGVzIHtcbiAgICBBbmQgPSAnQU5EJyxcbiAgICBPciA9ICdPUidcbn1cblxuXG5cblxuXG5cblxuIl19

package/esm2015/smart-filters/filter-builder/common/pipes/filter-item-counter.pipe.js

@@ -0,0 +1,18 @@
+import { Pipe } from '@angular/core';
+export class FilterItemCounterPipe {
+    transform(container) {
+        console.log('init filter', container);
+        let counter = 0;
+        Object.keys(container.controls).forEach(item => { if (item.includes('item') || item.includes('section')) {
+            counter++;
+        } });
+        console.log('filter counter', counter);
+        return counter;
+    }
+}
+FilterItemCounterPipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'filterItemCounter'
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLWl0ZW0tY291bnRlci5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LWxpYi9zbWFydC1maWx0ZXJzL2ZpbHRlci1idWlsZGVyL2NvbW1vbi9waXBlcy9maWx0ZXItaXRlbS1jb3VudGVyLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7QUFNcEQsTUFBTSxPQUFPLHFCQUFxQjtJQUM5QixTQUFTLENBQUMsU0FBb0I7UUFDMUIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxhQUFhLEVBQUUsU0FBUyxDQUFDLENBQUM7UUFDdEMsSUFBSSxPQUFPLEdBQUcsQ0FBQyxDQUFDO1FBQ2hCLE1BQU0sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxHQUFHLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxFQUFFO1lBQUUsT0FBTyxFQUFFLENBQUM7U0FBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQzNILE9BQU8sQ0FBQyxHQUFHLENBQUMsZ0JBQWdCLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDdkMsT0FBTyxPQUFPLENBQUM7SUFDbkIsQ0FBQzs7O1lBVkosSUFBSSxTQUFDO2dCQUNGLElBQUksRUFBRSxtQkFBbUI7YUFDNUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGb3JtR3JvdXAgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5cbkBQaXBlKHtcbiAgICBuYW1lOiAnZmlsdGVySXRlbUNvdW50ZXInXG59KVxuZXhwb3J0IGNsYXNzIEZpbHRlckl0ZW1Db3VudGVyUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICAgIHRyYW5zZm9ybShjb250YWluZXI6IEZvcm1Hcm91cCk6IG51bWJlciB7XG4gICAgICAgIGNvbnNvbGUubG9nKCdpbml0IGZpbHRlcicsIGNvbnRhaW5lcik7XG4gICAgICAgIGxldCBjb3VudGVyID0gMDtcbiAgICAgICAgT2JqZWN0LmtleXMoY29udGFpbmVyLmNvbnRyb2xzKS5mb3JFYWNoKGl0ZW0gPT4geyBpZiAoaXRlbS5pbmNsdWRlcygnaXRlbScpIHx8IGl0ZW0uaW5jbHVkZXMoJ3NlY3Rpb24nKSkgeyBjb3VudGVyKys7IH0gfSk7XG4gICAgICAgIGNvbnNvbGUubG9nKCdmaWx0ZXIgY291bnRlcicsIGNvdW50ZXIpO1xuICAgICAgICByZXR1cm4gY291bnRlcjtcbiAgICB9XG59Il19

package/esm2015/smart-filters/filter-builder/common/services/output-filter.service.js

@@ -0,0 +1,132 @@
+import { Injectable } from '@angular/core';
+import { getLegacyOperator } from '../model/operator';
+import { getLegacyOperationUnit } from '../model/operator-unit';
+import { PepSmartFilterOperators } from '../../../common/model/operator';
+import * as i0 from "@angular/core";
+export class PepOutputFilterService {
+    constructor() {
+    }
+    /**
+     * generates a legacy JSON
+     * @param json UI smart filters structure
+     * @param fields smart filter field
+     * @returns legacy JSON
+     */
+    generateJson(json, fields) {
+        this.initProperties();
+        this._fields = fields;
+        this.treeWalk(json);
+        return this._json ? this._json : this._firstItem ? this._firstItem : null;
+    }
+    /**
+     * reset properties
+     */
+    initProperties() {
+        this._json = undefined;
+        this._firstItem = undefined;
+        this._complexIdCounter = 1;
+        this._expressionIdCounter = 1;
+    }
+    /**
+     * a recursive function dynamically builds legacy JSON structure
+     * @param current UI object represents either a section or filter component
+     */
+    treeWalk(current) {
+        Object.keys(current).forEach(key => {
+            if (key.includes('item')) {
+                this.createItem({
+                    ExpressionId: (this._expressionIdCounter++).toString(),
+                    ApiName: current[key].fieldId,
+                    Operation: getLegacyOperator(current[key].operator, current[key].fieldType),
+                    Values: this.getItemValues(current[key])
+                }, current.operator);
+            }
+            else if (key.includes('section')) {
+                this.treeWalk(current[key]);
+            }
+        });
+    }
+    /**
+     * adds a filter to json and wrap it with complex operator
+     * @param item expression item
+     * @param operator complex operator
+     */
+    createItem(item, operator) {
+        if (this._json) {
+            this._json = this.createSection(this._json, item, operator);
+        }
+        else if (this._firstItem) {
+            this._json = this.createSection(this._firstItem, item, operator);
+        }
+        else {
+            this._firstItem = item;
+        }
+    }
+    /**
+     * creates a legacy complex object
+     * @param left LeftNode object
+     * @param right RightNode object
+     * @param operator AND/OR operator
+     * @returns complex object
+     */
+    createSection(left, right, operator) {
+        return {
+            ComplexId: (this._complexIdCounter++).toString(),
+            LeftNode: left,
+            RightNode: right,
+            Operation: operator
+        };
+    }
+    /**
+     * gets legacy filter values object
+     * @param current UI filter object's values
+     * @returns an array represents legacy values
+     */
+    getItemValues(current) {
+        var _a;
+        let values = [];
+        if ((_a = current === null || current === void 0 ? void 0 : current.values) === null || _a === void 0 ? void 0 : _a.first) {
+            if (current.operator === PepSmartFilterOperators.In) { //multi select 
+                values = current.values.first;
+            }
+            else if (current.operator === PepSmartFilterOperators.InTheLast ||
+                current.operator === PepSmartFilterOperators.NotInTheLast ||
+                current.operator === PepSmartFilterOperators.DueIn ||
+                current.operator === PepSmartFilterOperators.NotDueIn) { //operation unit            
+                values.push(current.values.first);
+                if (current.operatorUnit) {
+                    values.push(getLegacyOperationUnit(current.operatorUnit));
+                }
+            }
+            else {
+                values.push(current.values.first);
+                if (current.values.second) {
+                    values.push(current.values.second);
+                }
+            }
+        }
+        return values;
+    }
+    /**
+     * generates an array of keys of multi-select control
+     * @param values an array of the selected values
+     * @param id filter's selected field
+     * @returns an array of keys
+     */
+    getFieldKeys(values, id) {
+        let keys = [];
+        let field = this._fields.find(item => item.id === id);
+        if (field) {
+            keys = field === null || field === void 0 ? void 0 : field.options.filter(item => values.includes(item.value)).map((option) => option.key);
+        }
+        return keys;
+    }
+}
+PepOutputFilterService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PepOutputFilterService_Factory() { return new PepOutputFilterService(); }, token: PepOutputFilterService, providedIn: "root" });
+PepOutputFilterService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+PepOutputFilterService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"output-filter.service.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-lib/smart-filters/filter-builder/common/services/output-filter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { IPepJSONItem } from '../model/legacy';\nimport { getLegacyOperator } from '../model/operator';\nimport { getLegacyOperationUnit } from '../model/operator-unit';\nimport { PepSmartFilterOperators, IPepSmartFilterOperator } from '../../../common/model/operator';\nimport { IPepSmartFilterField } from 'projects/ngx-lib/smart-filters';\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class PepOutputFilterService {\n    private _json: any;\n    private _fields: Array<IPepSmartFilterField>;\n    private _firstItem: any;\n    private _complexIdCounter: number;\n    private _expressionIdCounter: number;\n\n    constructor() {\n\n    }\n\n    /**\n     * generates a legacy JSON \n     * @param json UI smart filters structure\n     * @param fields smart filter field\n     * @returns legacy JSON\n     */\n    generateJson(json: any, fields: Array<IPepSmartFilterField>) {\n        this.initProperties();\n        this._fields = fields;\n        this.treeWalk(json);\n        return this._json ? this._json : this._firstItem ? this._firstItem : null;\n    }\n\n    /**\n     * reset properties\n     */\n    private initProperties() {\n        this._json = undefined;\n        this._firstItem = undefined;\n        this._complexIdCounter = 1;\n        this._expressionIdCounter = 1;\n    }\n\n    /**\n     * a recursive function dynamically builds legacy JSON structure\n     * @param current UI object represents either a section or filter component\n     */\n    private treeWalk(current: any) {\n        Object.keys(current).forEach(key => {\n            if (key.includes('item')) {\n                this.createItem({\n                    ExpressionId: (this._expressionIdCounter++).toString(),\n                    ApiName: current[key].fieldId,\n                    Operation: getLegacyOperator(current[key].operator, current[key].fieldType),\n                    Values: this.getItemValues(current[key])\n                } as IPepJSONItem, current.operator);\n            } else if (key.includes('section')) {\n                this.treeWalk(current[key]);\n            }\n        });\n    }\n\n    /**\n     * adds a filter to json and wrap it with complex operator\n     * @param item expression item\n     * @param operator complex operator \n     */\n    private createItem(item: any, operator: string) {\n        if (this._json) {\n            this._json = this.createSection(this._json, item, operator);\n        } else if (this._firstItem) {\n            this._json = this.createSection(this._firstItem, item, operator);\n        } else {\n            this._firstItem = item;\n        }\n\n    }\n\n    /**\n     * creates a legacy complex object\n     * @param left LeftNode object\n     * @param right RightNode object\n     * @param operator AND/OR operator\n     * @returns complex object\n     */\n    private createSection(left: any, right: any, operator: string) {\n        return {\n            ComplexId: (this._complexIdCounter++).toString(),\n            LeftNode: left,\n            RightNode: right,\n            Operation: operator\n        }\n    }\n\n    /**\n     * gets legacy filter values object\n     * @param current UI filter object's values\n     * @returns an array represents legacy values\n     */\n    private getItemValues(current: any) {\n        let values: any[] = [];\n\n        if (current?.values?.first) {\n            if (current.operator === PepSmartFilterOperators.In) { //multi select \n                values = current.values.first;\n            } else if (\n                current.operator === PepSmartFilterOperators.InTheLast ||\n                current.operator === PepSmartFilterOperators.NotInTheLast ||\n                current.operator === PepSmartFilterOperators.DueIn ||\n                current.operator === PepSmartFilterOperators.NotDueIn\n            ) { //operation unit            \n                values.push(current.values.first);\n                if (current.operatorUnit) {\n                    values.push(getLegacyOperationUnit(current.operatorUnit));\n                }\n            } else {\n                values.push(current.values.first);\n                if (current.values.second) {\n                    values.push(current.values.second);\n                }\n            }\n        }\n\n        return values;\n    }\n\n    /**\n     * generates an array of keys of multi-select control\n     * @param values an array of the selected values\n     * @param id filter's selected field\n     * @returns an array of keys\n     */\n    private getFieldKeys(values: any[], id: string) {\n        let keys: any[] = [];\n\n        let field = this._fields.find(item => item.id === id);\n        if (field) {\n            keys = field?.options.filter(item => values.includes(item.value)).map((option: any) => option.key);\n        }\n\n        return keys;\n    }\n}"]}

package/esm2015/smart-filters/filter-builder/common/services/type-convertor.service.js

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PepTypeConvertorService {
+    constructor() {
+        this._operators = [];
+        this._booleans = [];
+        this.initOperators();
+        this.initBooleans();
+    }
+    get operators() {
+        return this._operators;
+    }
+    get booleans() {
+        return this._booleans;
+    }
+    initOperators() {
+        this._operators.push({
+            key: 'AND',
+            value: 'And'
+        });
+        this._operators.push({
+            key: 'OR',
+            value: 'Or'
+        });
+    }
+    initBooleans() {
+        this._booleans.push({
+            key: 'True',
+            value: 'True'
+        });
+        this._booleans.push({
+            key: 'False',
+            value: 'False'
+        });
+    }
+}
+PepTypeConvertorService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PepTypeConvertorService_Factory() { return new PepTypeConvertorService(); }, token: PepTypeConvertorService, providedIn: "root" });
+PepTypeConvertorService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+PepTypeConvertorService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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