hgs-twilio-class-lib 1.1.52 → 1.1.54

package/lib/controller/twilio/filterImpl/CxConfigOtherFilter.js

@@ -1 +1,52 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.CXConfigOtherFilterService=void 0;const e=require("./MainFilterService"),t=require("../../../common/abstract/Filter"),r=require("../../../common/enum/FilterTypes");class i extends t.Filter{constructor(e){super({fieldName:"",value:null,filterType:r.FilterTypes.Equality,caseSensitive:!1,ignoreNull:!0}),this.allowedFields={name:"string",key:"string"},this.data=e}applyFilter(e){return e}filterApply(t){const r={filters:this.validateFilters(t)};return e.MainFilterService.applyFilter(this.data,r)}validateFilters(e){return e.filters.filter((e=>{const t=this.allowedFields[e.fieldName];return!!t&&("string"===t&&("string"==typeof e.value||"object"==typeof e.value))}))}static getFilterData(e){return Object.values({name:{type:"input",attributeName:"name",label:"Name"}})}}exports.CXConfigOtherFilterService=i;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CXConfigOtherFilterService = void 0;
+const MainFilterService_1 = require("./MainFilterService");
+const Filter_1 = require("../../../common/abstract/Filter");
+const FilterTypes_1 = require("../../../common/enum/FilterTypes");
+class CXConfigOtherFilterService extends Filter_1.Filter {
+    constructor(data) {
+        super({ fieldName: "", value: null, filterType: FilterTypes_1.FilterTypes.Equality, caseSensitive: false, ignoreNull: true });
+        // Define allowed fields
+        this.allowedFields = {
+            name: "string",
+            key: "string"
+        };
+        this.data = data;
+    }
+    applyFilter(data) {
+        // Implementation of applyFilter if needed
+        return data;
+    }
+    filterApply(filterParams) {
+        const validFilters = this.validateFilters(filterParams);
+        const filteredParams = { filters: validFilters };
+        return MainFilterService_1.MainFilterService.applyFilter(this.data, filteredParams);
+    }
+    validateFilters(filterParams) {
+        return filterParams.filters.filter(filter => {
+            const expectedType = this.allowedFields[filter.fieldName];
+            if (!expectedType)
+                return false;
+            switch (expectedType) {
+                case "string":
+                    return typeof filter.value === "string" || typeof filter.value === "object";
+                default:
+                    return false;
+            }
+        });
+    }
+    static getFilterData(filterOptions) {
+        // Create the filter data mappings with conditional dataList population
+        const fieldMappings = {
+            name: {
+                type: "input",
+                attributeName: "name",
+                label: "Name"
+            },
+        };
+        // Return as an array
+        return Object.values(fieldMappings);
+    }
+}
+exports.CXConfigOtherFilterService = CXConfigOtherFilterService;

package/lib/controller/twilio/filterImpl/CxConfigQueueMenuFilter.d.ts

@@ -15,4 +15,3 @@ export declare class CXConfigQueueMenuFilterService extends Filter {
     private validateFilters;
     static getFilterData(filterOptions: Record<string, any[]> | null): FilterDataObject[];
 }
-//# sourceMappingURL=CxConfigQueueMenuFilter.d.ts.map

package/lib/controller/twilio/filterImpl/CxConfigQueueMenuFilter.js

@@ -1 +1,78 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.CXConfigQueueMenuFilterService=void 0;const e=require("./MainFilterService"),t=require("../../../common/abstract/Filter"),r=require("../../../common/enum/FilterTypes");class i extends t.Filter{constructor(e){super({fieldName:"",value:null,filterType:r.FilterTypes.Equality,caseSensitive:!1,ignoreNull:!0}),this.allowedFields={name:"string",type:"string",voice:"string",order:"number",category:"string"},this.data=e}applyFilter(e){return e}filterApply(t){const r={filters:this.validateFilters(t)};return e.MainFilterService.applyFilter(this.data,r)}validateFilters(e){return e.filters.filter((e=>{const t=this.allowedFields[e.fieldName];if(!t)return!1;switch(t){case"string":return"string"==typeof e.value||"object"==typeof e.value;case"number":return"string"==typeof e.value||"number"==typeof e.value;default:return!1}}))}static getFilterData(e){const t={name:{type:"input",attributeName:"name",label:"Name"},order:{type:"dropdown",attributeName:"order",label:"Order",dataList:e&&e.order?e.order:[],isMultiselect:!0},type:{type:"dropdown",attributeName:"type",label:"Type",dataList:e&&e.type?e.type:[],isMultiselect:!0},voice:{type:"dropdown",attributeName:"voice",label:"Voice",dataList:e&&e.voice?e.voice:[],isMultiselect:!0}};return Object.values(t)}}exports.CXConfigQueueMenuFilterService=i;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CXConfigQueueMenuFilterService = void 0;
+const MainFilterService_1 = require("./MainFilterService");
+const Filter_1 = require("../../../common/abstract/Filter");
+const FilterTypes_1 = require("../../../common/enum/FilterTypes");
+class CXConfigQueueMenuFilterService extends Filter_1.Filter {
+    constructor(data) {
+        super({ fieldName: "", value: null, filterType: FilterTypes_1.FilterTypes.Equality, caseSensitive: false, ignoreNull: true });
+        // Define allowed fields for AuditLog filters
+        this.allowedFields = {
+            name: "string",
+            type: "string",
+            voice: "string",
+            order: "number",
+            category: "string"
+        };
+        this.data = data;
+    }
+    applyFilter(data) {
+        // Implementation of applyFilter if needed
+        return data;
+    }
+    filterApply(filterParams) {
+        const validFilters = this.validateFilters(filterParams);
+        const filteredParams = { filters: validFilters };
+        return MainFilterService_1.MainFilterService.applyFilter(this.data, filteredParams);
+    }
+    validateFilters(filterParams) {
+        return filterParams.filters.filter(filter => {
+            const expectedType = this.allowedFields[filter.fieldName];
+            if (!expectedType)
+                return false;
+            switch (expectedType) {
+                case "string":
+                    return typeof filter.value === "string" || typeof filter.value === "object";
+                case "number":
+                    return typeof filter.value === "string" || typeof filter.value === "number";
+                default:
+                    return false;
+            }
+        });
+    }
+    static getFilterData(filterOptions) {
+        // Create the filter data mappings with conditional dataList population
+        const fieldMappings = {
+            name: {
+                type: "input",
+                attributeName: "name",
+                label: "Name"
+            },
+            order: {
+                type: "dropdown",
+                attributeName: "order",
+                label: "Order",
+                dataList: filterOptions && filterOptions.order ? filterOptions.order : [], // Conditional dataList
+                isMultiselect: true
+            },
+            type: {
+                type: "dropdown",
+                attributeName: "type",
+                label: "Type",
+                dataList: filterOptions && filterOptions.type ? filterOptions.type : [], // Conditional dataList
+                isMultiselect: true
+            },
+            voice: {
+                type: "dropdown",
+                attributeName: "voice",
+                label: "Voice",
+                dataList: filterOptions && filterOptions.voice ? filterOptions.voice : [], // Conditional dataList
+                isMultiselect: true
+            }
+        };
+        // Return as an array
+        return Object.values(fieldMappings);
+    }
+}
+exports.CXConfigQueueMenuFilterService = CXConfigQueueMenuFilterService;

package/lib/controller/twilio/filterImpl/CxConfigUIconfigFilter.d.ts

@@ -10,4 +10,3 @@ export declare class CXConfigUIConfigFilterService extends Filter {
     private validateFilters;
     static getFilterData(filterOptions: Record<string, any[]> | null): FilterDataObject[];
 }
-//# sourceMappingURL=CxConfigUIconfigFilter.d.ts.map

package/lib/controller/twilio/filterImpl/CxConfigUIconfigFilter.js

@@ -1 +1,51 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.CXConfigUIConfigFilterService=void 0;const e=require("./MainFilterService"),t=require("../../../common/abstract/Filter"),i=require("../../../common/enum/FilterTypes");class r extends t.Filter{constructor(e){super({fieldName:"",value:null,filterType:i.FilterTypes.Equality,caseSensitive:!1,ignoreNull:!0}),this.allowedFields={name:"string"},this.data=e}applyFilter(e){return e}filterApply(t){const i={filters:this.validateFilters(t)};return e.MainFilterService.applyFilter(this.data,i)}validateFilters(e){return e.filters.filter((e=>{const t=this.allowedFields[e.fieldName];return!!t&&("string"===t&&("string"==typeof e.value||"object"==typeof e.value))}))}static getFilterData(e){return Object.values({name:{type:"input",attributeName:"name",label:"Name"}})}}exports.CXConfigUIConfigFilterService=r;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CXConfigUIConfigFilterService = void 0;
+const MainFilterService_1 = require("./MainFilterService");
+const Filter_1 = require("../../../common/abstract/Filter");
+const FilterTypes_1 = require("../../../common/enum/FilterTypes");
+class CXConfigUIConfigFilterService extends Filter_1.Filter {
+    constructor(data) {
+        super({ fieldName: "", value: null, filterType: FilterTypes_1.FilterTypes.Equality, caseSensitive: false, ignoreNull: true });
+        // Define allowed fields for AuditLog filters
+        this.allowedFields = {
+            name: "string",
+        };
+        this.data = data;
+    }
+    applyFilter(data) {
+        // Implementation of applyFilter if needed
+        return data;
+    }
+    filterApply(filterParams) {
+        const validFilters = this.validateFilters(filterParams);
+        const filteredParams = { filters: validFilters };
+        return MainFilterService_1.MainFilterService.applyFilter(this.data, filteredParams);
+    }
+    validateFilters(filterParams) {
+        return filterParams.filters.filter(filter => {
+            const expectedType = this.allowedFields[filter.fieldName];
+            if (!expectedType)
+                return false;
+            switch (expectedType) {
+                case "string":
+                    return typeof filter.value === "string" || typeof filter.value === "object";
+                default:
+                    return false;
+            }
+        });
+    }
+    static getFilterData(filterOptions) {
+        // Create the filter data mappings with conditional dataList population
+        const fieldMappings = {
+            name: {
+                type: "input",
+                attributeName: "name",
+                label: "Name"
+            },
+        };
+        // Return as an array
+        return Object.values(fieldMappings);
+    }
+}
+exports.CXConfigUIConfigFilterService = CXConfigUIConfigFilterService;

package/lib/controller/twilio/filterImpl/HoopHolidaysFilter.d.ts

@@ -10,4 +10,3 @@ export declare class HoopHolidaysFilterService extends Filter {
     private validateFilters;
     static getFilterData(filterOptions: Record<string, any[]> | null): FilterDataObject[];
 }
-//# sourceMappingURL=HoopHolidaysFilter.d.ts.map

package/lib/controller/twilio/filterImpl/HoopHolidaysFilter.js

@@ -1 +1,55 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.HoopHolidaysFilterService=void 0;const e=require("./MainFilterService"),t=require("../../../common/abstract/Filter"),a=require("../../../common/enum/FilterTypes");class r extends t.Filter{constructor(e){super({fieldName:"",value:null,filterType:a.FilterTypes.Equality,caseSensitive:!1,ignoreNull:!0}),this.allowedFields={date:"dateRange"},this.data=e}applyFilter(e){return e}filterApply(t){const a={filters:this.validateFilters(t)};return e.MainFilterService.applyFilter(this.data,a)}validateFilters(e){return e.filters.filter((e=>{const t=this.allowedFields[e.fieldName];return!!t&&("dateRange"===t&&(e.value&&"string"==typeof e.value.startDate&&"string"==typeof e.value.endDate&&!isNaN(Date.parse(e.value.startDate))&&!isNaN(Date.parse(e.value.endDate))))}))}static getFilterData(e){return Object.values({date:{type:"dateRange",attributeName:"date",label:"Date"}})}}exports.HoopHolidaysFilterService=r;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoopHolidaysFilterService = void 0;
+const MainFilterService_1 = require("./MainFilterService");
+const Filter_1 = require("../../../common/abstract/Filter");
+const FilterTypes_1 = require("../../../common/enum/FilterTypes");
+class HoopHolidaysFilterService extends Filter_1.Filter {
+    constructor(data) {
+        super({ fieldName: "", value: null, filterType: FilterTypes_1.FilterTypes.Equality, caseSensitive: false, ignoreNull: true });
+        // Define allowed fields for AuditLog filters
+        this.allowedFields = {
+            date: "dateRange"
+        };
+        this.data = data;
+    }
+    applyFilter(data) {
+        // Implementation of applyFilter if needed
+        return data;
+    }
+    filterApply(filterParams) {
+        const validFilters = this.validateFilters(filterParams);
+        const filteredParams = { filters: validFilters };
+        return MainFilterService_1.MainFilterService.applyFilter(this.data, filteredParams);
+    }
+    validateFilters(filterParams) {
+        return filterParams.filters.filter(filter => {
+            const expectedType = this.allowedFields[filter.fieldName];
+            if (!expectedType)
+                return false;
+            switch (expectedType) {
+                case "dateRange":
+                    return (filter.value &&
+                        typeof filter.value.startDate === "string" &&
+                        typeof filter.value.endDate === "string" &&
+                        !isNaN(Date.parse(filter.value.startDate)) &&
+                        !isNaN(Date.parse(filter.value.endDate)));
+                default:
+                    return false;
+            }
+        });
+    }
+    static getFilterData(filterOptions) {
+        // Create the filter data mappings with conditional dataList population
+        const fieldMappings = {
+            date: {
+                type: "dateRange",
+                attributeName: "date",
+                label: "Date"
+            }
+        };
+        // Return as an array
+        return Object.values(fieldMappings);
+    }
+}
+exports.HoopHolidaysFilterService = HoopHolidaysFilterService;

package/lib/controller/twilio/filterImpl/HoopNotesFilter.d.ts

@@ -10,4 +10,3 @@ export declare class HoopNotesFilterService extends Filter {
     private validateFilters;
     static getFilterData(filterOptions: Record<string, any[]> | null): FilterDataObject[];
 }
-//# sourceMappingURL=HoopNotesFilter.d.ts.map

package/lib/controller/twilio/filterImpl/HoopNotesFilter.js

@@ -1 +1,51 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.HoopNotesFilterService=void 0;const e=require("./MainFilterService"),t=require("../../../common/abstract/Filter"),i=require("../../../common/enum/FilterTypes");class r extends t.Filter{constructor(e){super({fieldName:"",value:null,filterType:i.FilterTypes.Equality,caseSensitive:!1,ignoreNull:!0}),this.allowedFields={heading:"string"},this.data=e}applyFilter(e){return e}filterApply(t){const i={filters:this.validateFilters(t)};return e.MainFilterService.applyFilter(this.data,i)}validateFilters(e){return e.filters.filter((e=>{const t=this.allowedFields[e.fieldName];return!!t&&("string"===t&&("string"==typeof e.value||"object"==typeof e.value))}))}static getFilterData(e){return Object.values({heading:{type:"input",attributeName:"heading",label:"Note"}})}}exports.HoopNotesFilterService=r;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoopNotesFilterService = void 0;
+const MainFilterService_1 = require("./MainFilterService");
+const Filter_1 = require("../../../common/abstract/Filter");
+const FilterTypes_1 = require("../../../common/enum/FilterTypes");
+class HoopNotesFilterService extends Filter_1.Filter {
+    constructor(data) {
+        super({ fieldName: "", value: null, filterType: FilterTypes_1.FilterTypes.Equality, caseSensitive: false, ignoreNull: true });
+        // Define allowed fields for AuditLog filters
+        this.allowedFields = {
+            heading: "string"
+        };
+        this.data = data;
+    }
+    applyFilter(data) {
+        // Implementation of applyFilter if needed
+        return data;
+    }
+    filterApply(filterParams) {
+        const validFilters = this.validateFilters(filterParams);
+        const filteredParams = { filters: validFilters };
+        return MainFilterService_1.MainFilterService.applyFilter(this.data, filteredParams);
+    }
+    validateFilters(filterParams) {
+        return filterParams.filters.filter(filter => {
+            const expectedType = this.allowedFields[filter.fieldName];
+            if (!expectedType)
+                return false;
+            switch (expectedType) {
+                case "string":
+                    return typeof filter.value === "string" || typeof filter.value === "object";
+                default:
+                    return false;
+            }
+        });
+    }
+    static getFilterData(filterOptions) {
+        // Create the filter data mappings with conditional dataList population
+        const fieldMappings = {
+            heading: {
+                type: "input",
+                attributeName: "heading",
+                label: "Note"
+            }
+        };
+        // Return as an array
+        return Object.values(fieldMappings);
+    }
+}
+exports.HoopNotesFilterService = HoopNotesFilterService;

package/lib/controller/twilio/filterImpl/HoopPartialDaysFilter.d.ts

@@ -10,4 +10,3 @@ export declare class HoopPartialDaysFilterService extends Filter {
     private validateFilters;
     static getFilterData(filterOptions: Record<string, any[]> | null): FilterDataObject[];
 }
-//# sourceMappingURL=HoopPartialDaysFilter.d.ts.map

package/lib/controller/twilio/filterImpl/HoopPartialDaysFilter.js

@@ -1 +1,55 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.HoopPartialDaysFilterService=void 0;const e=require("./MainFilterService"),t=require("../../../common/abstract/Filter"),a=require("../../../common/enum/FilterTypes");class r extends t.Filter{constructor(e){super({fieldName:"",value:null,filterType:a.FilterTypes.Equality,caseSensitive:!1,ignoreNull:!0}),this.allowedFields={date:"dateRange"},this.data=e}applyFilter(e){return e}filterApply(t){const a={filters:this.validateFilters(t)};return e.MainFilterService.applyFilter(this.data,a)}validateFilters(e){return e.filters.filter((e=>{const t=this.allowedFields[e.fieldName];return!!t&&("dateRange"===t&&(e.value&&"string"==typeof e.value.startDate&&"string"==typeof e.value.endDate&&!isNaN(Date.parse(e.value.startDate))&&!isNaN(Date.parse(e.value.endDate))))}))}static getFilterData(e){return Object.values({date:{type:"dateRange",attributeName:"date",label:"Date"}})}}exports.HoopPartialDaysFilterService=r;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoopPartialDaysFilterService = void 0;
+const MainFilterService_1 = require("./MainFilterService");
+const Filter_1 = require("../../../common/abstract/Filter");
+const FilterTypes_1 = require("../../../common/enum/FilterTypes");
+class HoopPartialDaysFilterService extends Filter_1.Filter {
+    constructor(data) {
+        super({ fieldName: "", value: null, filterType: FilterTypes_1.FilterTypes.Equality, caseSensitive: false, ignoreNull: true });
+        // Define allowed fields for AuditLog filters
+        this.allowedFields = {
+            date: "dateRange"
+        };
+        this.data = data;
+    }
+    applyFilter(data) {
+        // Implementation of applyFilter if needed
+        return data;
+    }
+    filterApply(filterParams) {
+        const validFilters = this.validateFilters(filterParams);
+        const filteredParams = { filters: validFilters };
+        return MainFilterService_1.MainFilterService.applyFilter(this.data, filteredParams);
+    }
+    validateFilters(filterParams) {
+        return filterParams.filters.filter(filter => {
+            const expectedType = this.allowedFields[filter.fieldName];
+            if (!expectedType)
+                return false;
+            switch (expectedType) {
+                case "dateRange":
+                    return (filter.value &&
+                        typeof filter.value.startDate === "string" &&
+                        typeof filter.value.endDate === "string" &&
+                        !isNaN(Date.parse(filter.value.startDate)) &&
+                        !isNaN(Date.parse(filter.value.endDate)));
+                default:
+                    return false;
+            }
+        });
+    }
+    static getFilterData(filterOptions) {
+        // Create the filter data mappings with conditional dataList population
+        const fieldMappings = {
+            date: {
+                type: "dateRange",
+                attributeName: "date",
+                label: "Date"
+            }
+        };
+        // Return as an array
+        return Object.values(fieldMappings);
+    }
+}
+exports.HoopPartialDaysFilterService = HoopPartialDaysFilterService;

package/lib/controller/twilio/filterImpl/MainFilterService.d.ts

@@ -2,4 +2,3 @@ import { MultiFieldFilter } from "../../../common/interface/IFilter";
 export declare class MainFilterService {
     static applyFilter(data: any[], filters: MultiFieldFilter): any[];
 }
-//# sourceMappingURL=MainFilterService.d.ts.map

package/lib/controller/twilio/filterImpl/MainFilterService.js

@@ -1 +1,108 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.MainFilterService=void 0;const e=require("tslib"),t=require("../../../common/abstract/Filter"),r=require("../../../common/enum/FilterTypes"),s=e.__importDefault(require("moment"));exports.MainFilterService=class{static applyFilter(e,i){return i.filters.reduce(((e,i)=>{const a=new class extends t.Filter{applyFilter(e){return e.filter((e=>{const t=e[this.fieldName],i=(e,t)=>t.every((t=>e.includes(t)));return Array.isArray(t)&&Array.isArray(this.value)?i(t,this.value):"string"==typeof t&&Array.isArray(this.value)?this.value.some((e=>this.caseSensitive?t.includes(e):t.toLowerCase().includes(e.toLowerCase()))):"string"==typeof t&&"string"==typeof this.value?this.caseSensitive?t.includes(this.value):t.toLowerCase().includes(this.value.toLowerCase()):((e,t)=>{if(null==e||null==t)return!1;switch(this.filterType){case r.FilterTypes.Equality:return Array.isArray(t)&&Array.isArray(e)?i(e,t):"string"==typeof e&&"string"==typeof t?this.caseSensitive?e.includes(t):e.toLowerCase().includes(t.toLowerCase()):e===t;case r.FilterTypes.Inequality:return Array.isArray(t)&&Array.isArray(e)?!i(e,t):"string"==typeof e&&"string"==typeof t?this.caseSensitive?!e.includes(t):!e.toLowerCase().includes(t.toLowerCase()):e!==t;case r.FilterTypes.Range:return!(!Array.isArray(t)||2!==t.length)&&(e>=t[0]&&e<=t[1]);case r.FilterTypes.DateRange:if("string"!=typeof t.startDate||"string"!=typeof t.endDate)return!1;const a=(0,s.default)(t.startDate).format(),n=(0,s.default)(t.endDate).format(),l=(0,s.default)(e).format();return(0,s.default)(l).isBetween(a,n,void 0,"[]");case r.FilterTypes.DateTimeRange:if("string"!=typeof t.startDate||"string"!=typeof t.startTime||"string"!=typeof t.endDate||"string"!=typeof t.endTime)return!1;const o=(0,s.default)(`${t.startDate}T${t.startTime||"00:00"}`).format(),u=(0,s.default)(`${t.endDate}T${t.endTime||"23:59"}`).format(),y=(0,s.default)(e).format();return(0,s.default)(y).isBetween(o,u,void 0,"[]");case r.FilterTypes.Regex:if("string"==typeof t){return new RegExp(t,this.caseSensitive?"":"i").test(String(e))}return!1;default:return!1}})(t,this.value)}))}}(i);return a.applyFilter(e)}),e)}};
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MainFilterService = void 0;
+const Filter_1 = require("../../../common/abstract/Filter");
+const FilterTypes_1 = require("../../../common/enum/FilterTypes");
+const moment_1 = __importDefault(require("moment"));
+class MainFilterService {
+    static applyFilter(data, filters) {
+        return filters.filters.reduce((filteredData, filter) => {
+            const filterInstance = new (class extends Filter_1.Filter {
+                applyFilter(data) {
+                    return data.filter(item => {
+                        const fieldValue = item[this.fieldName];
+                        // if (this.ignoreNull && (fieldValue == null || this.value == null)) return true;
+                        // Helper function to ensure all filter values are in the field array
+                        const containsAllValues = (fieldArray, filterArray) => {
+                            return filterArray.every(value => fieldArray.includes(value));
+                        };
+                        // Main comparison logic
+                        const processComparison = (field, filterValue) => {
+                            if (field == null || filterValue == null)
+                                return false;
+                            switch (this.filterType) {
+                                case FilterTypes_1.FilterTypes.Equality:
+                                    if (Array.isArray(filterValue) && Array.isArray(field)) {
+                                        // Strict condition: ensure all values from the filter are in the field
+                                        return containsAllValues(field, filterValue);
+                                    }
+                                    if (typeof field === "string" && typeof filterValue === "string") {
+                                        // Partial match for strings
+                                        return this.caseSensitive
+                                            ? field.includes(filterValue)
+                                            : field.toLowerCase().includes(filterValue.toLowerCase());
+                                    }
+                                    // Direct match for other types
+                                    return field === filterValue;
+                                case FilterTypes_1.FilterTypes.Inequality:
+                                    if (Array.isArray(filterValue) && Array.isArray(field)) {
+                                        // Ensure none of the filter values are in the field
+                                        return !containsAllValues(field, filterValue);
+                                    }
+                                    if (typeof field === "string" && typeof filterValue === "string") {
+                                        return this.caseSensitive
+                                            ? !field.includes(filterValue)
+                                            : !field.toLowerCase().includes(filterValue.toLowerCase());
+                                    }
+                                    return field !== filterValue;
+                                case FilterTypes_1.FilterTypes.Range:
+                                    return Array.isArray(filterValue) && filterValue.length === 2
+                                        ? field >= filterValue[0] && field <= filterValue[1]
+                                        : false;
+                                case FilterTypes_1.FilterTypes.DateRange:
+                                    if (typeof filterValue.startDate !== "string" ||
+                                        typeof filterValue.endDate !== "string")
+                                        return false;
+                                    const startDate = (0, moment_1.default)(filterValue.startDate).format();
+                                    const endDate = (0, moment_1.default)(filterValue.endDate).format();
+                                    const itemDate = (0, moment_1.default)(field).format();
+                                    return (0, moment_1.default)(itemDate).isBetween(startDate, endDate, undefined, '[]');
+                                case FilterTypes_1.FilterTypes.DateTimeRange:
+                                    if (typeof filterValue.startDate !== "string" ||
+                                        typeof filterValue.startTime !== "string" ||
+                                        typeof filterValue.endDate !== "string" ||
+                                        typeof filterValue.endTime !== "string")
+                                        return false;
+                                    const startDateTime = (0, moment_1.default)(`${filterValue.startDate}T${filterValue.startTime || "00:00"}`).format();
+                                    const endDateTime = (0, moment_1.default)(`${filterValue.endDate}T${filterValue.endTime || "23:59"}`).format();
+                                    const itemDateTime = (0, moment_1.default)(field).format();
+                                    return (0, moment_1.default)(itemDateTime).isBetween(startDateTime, endDateTime, undefined, '[]');
+                                case FilterTypes_1.FilterTypes.Regex:
+                                    if (typeof filterValue === "string") {
+                                        const regex = new RegExp(filterValue, this.caseSensitive ? "" : "i");
+                                        return regex.test(String(field));
+                                    }
+                                    return false;
+                                default:
+                                    return false;
+                            }
+                        };
+                        // If field and value are arrays, check strict condition for array match
+                        if (Array.isArray(fieldValue) && Array.isArray(this.value)) {
+                            return containsAllValues(fieldValue, this.value);
+                        }
+                        // If field is a string and value is an array, check if field matches any value in the array
+                        if (typeof fieldValue === "string" && Array.isArray(this.value)) {
+                            return this.value.some(v => this.caseSensitive
+                                ? fieldValue.includes(v)
+                                : fieldValue.toLowerCase().includes(v.toLowerCase()));
+                        }
+                        // If field is a string and value is a string, perform partial string match
+                        if (typeof fieldValue === "string" && typeof this.value === "string") {
+                            return this.caseSensitive
+                                ? fieldValue.includes(this.value)
+                                : fieldValue.toLowerCase().includes(this.value.toLowerCase());
+                        }
+                        // For other types, perform direct comparison
+                        return processComparison(fieldValue, this.value);
+                    });
+                }
+            })(filter);
+            return filterInstance.applyFilter(filteredData);
+        }, data);
+    }
+}
+exports.MainFilterService = MainFilterService;

package/lib/controller/twilio/filterImpl/NavigationFilter.d.ts

@@ -18,4 +18,3 @@ export declare class NavigationFilterService extends Filter {
     private validateFilters;
     static getFilterData(filterOptions: Record<string, any[]> | null): FilterDataObject[];
 }
-//# sourceMappingURL=NavigationFilter.d.ts.map

package/lib/controller/twilio/filterImpl/NavigationFilter.js

@@ -1 +1,90 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.NavigationFilterService=void 0;const e=require("./MainFilterService"),t=require("../../../common/abstract/Filter"),a=require("../../../common/enum/FilterTypes");class i extends t.Filter{constructor(e){super({fieldName:"",value:null,filterType:a.FilterTypes.Equality,caseSensitive:!1,ignoreNull:!0}),this.allowedFields={name:"string",is_enabled:"boolean",appliedVersion:"string",latestVersion:"string",dateOflatestVersion:"dateRange",visible:"boolean",featureAccessRoles:"string",managementAccessRoles:"string"},this.data=e}applyFilter(e){return e}filterApply(t){const a={filters:this.validateFilters(t)};return e.MainFilterService.applyFilter(this.data,a)}validateFilters(e){return e.filters.filter((e=>{const t=this.allowedFields[e.fieldName];if(!t)return!1;switch(t){case"string":return"string"==typeof e.value||"object"==typeof e.value;case"boolean":return"boolean"==typeof e.value;case"dateRange":return e.value&&"string"==typeof e.value.startDate&&"string"==typeof e.value.endDate&&!isNaN(Date.parse(e.value.startDate))&&!isNaN(Date.parse(e.value.endDate));default:return!1}}))}static getFilterData(e){const t={name:{type:"input",attributeName:"name",label:"Title"},is_enabled:{type:"switch",attributeName:"is_enabled",label:"Status"},appliedVersion:{type:"dropdown",attributeName:"appliedVersion",label:"Enabled version",dataList:e&&e.appliedVersion?e.appliedVersion:[],isMultiselect:!0},latestVersion:{type:"dropdown",attributeName:"latestVersion",label:"Latest version",dataList:e&&e.latestVersion?e.latestVersion:[],isMultiselect:!0},dateOflatestVersion:{type:"dateRange",attributeName:"dateOflatestVersion",label:"Latest version date"}};return Object.values(t)}}exports.NavigationFilterService=i;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NavigationFilterService = void 0;
+const MainFilterService_1 = require("./MainFilterService");
+const Filter_1 = require("../../../common/abstract/Filter");
+const FilterTypes_1 = require("../../../common/enum/FilterTypes");
+class NavigationFilterService extends Filter_1.Filter {
+    constructor(data) {
+        super({ fieldName: "", value: null, filterType: FilterTypes_1.FilterTypes.Equality, caseSensitive: false, ignoreNull: true });
+        // Define allowed fields for AuditLog filters
+        this.allowedFields = {
+            name: "string",
+            is_enabled: "boolean",
+            appliedVersion: "string",
+            latestVersion: "string",
+            dateOflatestVersion: "dateRange",
+            visible: "boolean",
+            featureAccessRoles: "string",
+            managementAccessRoles: "string"
+        };
+        this.data = data;
+    }
+    applyFilter(data) {
+        // Implementation of applyFilter if needed
+        return data;
+    }
+    filterApply(filterParams) {
+        const validFilters = this.validateFilters(filterParams);
+        const filteredParams = { filters: validFilters };
+        return MainFilterService_1.MainFilterService.applyFilter(this.data, filteredParams);
+    }
+    validateFilters(filterParams) {
+        return filterParams.filters.filter(filter => {
+            const expectedType = this.allowedFields[filter.fieldName];
+            if (!expectedType)
+                return false;
+            switch (expectedType) {
+                case "string":
+                    return typeof filter.value === "string" || typeof filter.value === "object";
+                case "boolean":
+                    return typeof filter.value === "boolean";
+                case "dateRange":
+                    return (filter.value &&
+                        typeof filter.value.startDate === "string" &&
+                        typeof filter.value.endDate === "string" &&
+                        !isNaN(Date.parse(filter.value.startDate)) &&
+                        !isNaN(Date.parse(filter.value.endDate)));
+                default:
+                    return false;
+            }
+        });
+    }
+    static getFilterData(filterOptions) {
+        // Create the filter data mappings with conditional dataList population
+        const fieldMappings = {
+            name: {
+                type: "input",
+                attributeName: "name",
+                label: "Title"
+            },
+            is_enabled: {
+                type: "switch",
+                attributeName: "is_enabled",
+                label: "Status"
+            },
+            appliedVersion: {
+                type: "dropdown",
+                attributeName: "appliedVersion",
+                label: "Enabled version",
+                dataList: filterOptions && filterOptions.appliedVersion ? filterOptions.appliedVersion : [], // Conditional dataList
+                isMultiselect: true
+            },
+            latestVersion: {
+                type: "dropdown",
+                attributeName: "latestVersion",
+                label: "Latest version",
+                dataList: filterOptions && filterOptions.latestVersion ? filterOptions.latestVersion : [], // Conditional dataList
+                isMultiselect: true
+            },
+            dateOflatestVersion: {
+                type: "dateRange",
+                attributeName: "dateOflatestVersion",
+                label: "Latest version date"
+            }
+        };
+        // Return as an array
+        return Object.values(fieldMappings);
+    }
+}
+exports.NavigationFilterService = NavigationFilterService;

package/lib/controller/twilio/filterImpl/QueueDetailsFilter.d.ts

@@ -12,4 +12,3 @@ export declare class QueueDetailsFilterService extends Filter {
     private validateFilters;
     static getFilterData(filterOptions: Record<string, any[]> | null): FilterDataObject[];
 }
-//# sourceMappingURL=QueueDetailsFilter.d.ts.map