hgs-twilio-class-lib 1.1.72 → 1.1.74

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

@@ -0,0 +1,90 @@
+"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

@@ -0,0 +1,14 @@
+import { MultiFieldFilter, FilterDataObject } from "../../../common/interface/IFilter";
+import { Filter } from "../../../common/abstract/Filter";
+export declare class QueueDetailsFilterService extends Filter {
+    private data;
+    allowedFields: {
+        uniqueName: string;
+        periodNumber: string;
+    };
+    constructor(data: any[]);
+    applyFilter(data: any[]): any[];
+    filterApply(filterParams: MultiFieldFilter): any[];
+    private validateFilters;
+    static getFilterData(filterOptions: Record<string, any[]> | null): FilterDataObject[];
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueDetailsFilterService = void 0;
+const MainFilterService_1 = require("./MainFilterService");
+const Filter_1 = require("../../../common/abstract/Filter");
+const FilterTypes_1 = require("../../../common/enum/FilterTypes");
+class QueueDetailsFilterService extends Filter_1.Filter {
+    constructor(data) {
+        super({ fieldName: "", value: null, filterType: FilterTypes_1.FilterTypes.Equality, caseSensitive: false, ignoreNull: true });
+        this.allowedFields = {
+            uniqueName: "string",
+            periodNumber: "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 = {
+            uniqueName: {
+                type: "dropdown",
+                attributeName: "uniqueName",
+                label: "Unique Name",
+                dataList: filterOptions && filterOptions.uniqueName ? filterOptions.uniqueName : [], // Conditional dataList
+                isMultiselect: true
+            }
+        };
+        // Return as an array
+        return Object.values(fieldMappings);
+    }
+}
+exports.QueueDetailsFilterService = QueueDetailsFilterService;

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

@@ -0,0 +1,12 @@
+import { MultiFieldFilter, FilterDataObject } from "../../../common/interface/IFilter";
+import { TaskCompleteFilterFields } from "../../../models/types/TaskComplete.type";
+import { Filter } from "../../../common/abstract/Filter";
+export declare class TaskCompleteFilterService extends Filter {
+    private data;
+    allowedFields: TaskCompleteFilterFields;
+    constructor(data: any[]);
+    applyFilter(data: any[]): any[];
+    filterApply(filterParams: MultiFieldFilter): any[];
+    private validateFilters;
+    static getFilterData(filterOptions: Record<string, any[]> | null): FilterDataObject[];
+}

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskCompleteFilterService = void 0;
+const MainFilterService_1 = require("./MainFilterService");
+const Filter_1 = require("../../../common/abstract/Filter");
+const FilterTypes_1 = require("../../../common/enum/FilterTypes");
+class TaskCompleteFilterService extends Filter_1.Filter {
+    constructor(data) {
+        super({ fieldName: "", value: null, filterType: FilterTypes_1.FilterTypes.Equality, caseSensitive: false, ignoreNull: true });
+        this.allowedFields = {
+            sid: "string",
+            taskChannelUniqueName: "string",
+            assignmentStatus: "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 = {
+            sid: {
+                type: "input",
+                attributeName: "sid",
+                label: "Task sid"
+            },
+            taskChannelUniqueName: {
+                type: "input",
+                attributeName: "taskChannelUniqueName",
+                label: "Task channel"
+            },
+            assignmentStatus: {
+                type: "input",
+                attributeName: "assignmentStatus",
+                label: "Current status"
+            }
+        };
+        // Return as an array
+        return Object.values(fieldMappings);
+    }
+}
+exports.TaskCompleteFilterService = TaskCompleteFilterService;

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

@@ -0,0 +1,12 @@
+import { MultiFieldFilter, FilterDataObject } from "../../../common/interface/IFilter";
+import { Filter } from "../../../common/abstract/Filter";
+import { TaskInfoPanelFilterFields } from "../../../models/types/TaskInfoPanel.type";
+export declare class TaskInfoPanelFilterService extends Filter {
+    private data;
+    allowedFields: TaskInfoPanelFilterFields;
+    constructor(data: any[]);
+    applyFilter(data: any[]): any[];
+    filterApply(filterParams: MultiFieldFilter): any[];
+    private validateFilters;
+    static getFilterData(filterOptions: Record<string, any[]> | null): FilterDataObject[];
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskInfoPanelFilterService = void 0;
+const MainFilterService_1 = require("./MainFilterService");
+const Filter_1 = require("../../../common/abstract/Filter");
+const FilterTypes_1 = require("../../../common/enum/FilterTypes");
+class TaskInfoPanelFilterService extends Filter_1.Filter {
+    constructor(data) {
+        super({ fieldName: "", value: null, filterType: FilterTypes_1.FilterTypes.Equality, caseSensitive: false, ignoreNull: true });
+        this.allowedFields = {
+            callSid: "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 = {
+            callSid: {
+                type: "dropdown",
+                attributeName: "callSid",
+                label: "Call Sid",
+                dataList: filterOptions && filterOptions.callSid ? filterOptions.callSid : [], // Conditional dataList
+                isMultiselect: true
+            }
+        };
+        // Return as an array
+        return Object.values(fieldMappings);
+    }
+}
+exports.TaskInfoPanelFilterService = TaskInfoPanelFilterService;

package/lib/express/ApiResponse.d.ts

@@ -0,0 +1,15 @@
+type ValidStatusCodes = 200 | 400 | 401 | 404 | 500;
+interface IApiResponse<T> {
+    statusCode: ValidStatusCodes;
+    message?: string;
+    data?: T;
+    error?: string;
+}
+declare class ApiResponse<T> implements IApiResponse<T> {
+    statusCode: ValidStatusCodes;
+    message?: string;
+    data?: T;
+    error?: string;
+    constructor(statusCode: ValidStatusCodes, message?: string, data?: T, error?: string);
+}
+export default ApiResponse;

package/lib/express/ApiResponse.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ApiResponse {
+    constructor(statusCode, message, data, error) {
+        this.statusCode = statusCode;
+        this.message = message;
+        this.data = data;
+        this.error = error;
+    }
+}
+exports.default = ApiResponse;

package/lib/express/RequestValidator.d.ts

@@ -0,0 +1,50 @@
+import { Request } from 'express';
+/**
+ * Represents the result of a validation operation.
+ */
+interface ValidationResult {
+    /**
+     * Indicates whether the validation passed or not.
+     */
+    isValid: boolean;
+    /**
+     * An array containing the names of missing parameters.
+     */
+    missingParams: string[];
+}
+/**
+ * Class responsible for validating request parameters and body.
+ */
+declare class RequestValidator {
+    /**
+     * Validates the query parameters of the request.
+     * @param {Request} request - The Express request object.
+     * @param {{ name: string, type: string }[]} requiredParams - Array of required query parameters with their types.
+     * @returns {ValidationResult} The result of the validation operation.
+     */
+    static validateQueryParams(request: Request, requiredParams: {
+        name: string;
+        type: string;
+    }[]): ValidationResult;
+    /**
+     * Validates the request parameters (route params) of the request.
+     * @param {Request} request - The Express request object.
+     * @param {{ name: string, type: string }[]} requiredParams - Array of required request parameters with their types.
+     * @returns {ValidationResult} The result of the validation operation.
+     */
+    static validateRequestParams(request: Request, requiredParams: {
+        name: string;
+        type: string;
+    }[]): ValidationResult;
+    /**
+     * Validates the request body of the request.
+     * @param {Request} request - The Express request object.
+     * @param {{ name: string, type: string }[]} requiredFields - Array of required fields in the request body with their types.
+     * @returns {ValidationResult} The result of the validation operation.
+     */
+    static validateRequestBody(request: Request, requiredFields: {
+        name: string;
+        type: string;
+    }[]): ValidationResult;
+}
+export default RequestValidator;

package/lib/express/RequestValidator.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Class responsible for validating request parameters and body.
+ */
+class RequestValidator {
+    /**
+     * Validates the query parameters of the request.
+     * @param {Request} request - The Express request object.
+     * @param {{ name: string, type: string }[]} requiredParams - Array of required query parameters with their types.
+     * @returns {ValidationResult} The result of the validation operation.
+     */
+    static validateQueryParams(request, requiredParams) {
+        const queryParams = request.query;
+        const missingParams = [];
+        for (const param of requiredParams) {
+            const paramName = param.name;
+            const paramType = param.type;
+            if (!(paramName in queryParams) || typeof queryParams[paramName] !== paramType) {
+                missingParams.push(paramName);
+            }
+        }
+        return {
+            isValid: missingParams.length === 0,
+            missingParams
+        };
+    }
+    /**
+     * Validates the request parameters (route params) of the request.
+     * @param {Request} request - The Express request object.
+     * @param {{ name: string, type: string }[]} requiredParams - Array of required request parameters with their types.
+     * @returns {ValidationResult} The result of the validation operation.
+     */
+    static validateRequestParams(request, requiredParams) {
+        const requestParams = request.params;
+        const missingParams = [];
+        for (const param of requiredParams) {
+            const paramName = param.name;
+            const paramType = param.type;
+            if (!(paramName in requestParams) || typeof requestParams[paramName] !== paramType) {
+                missingParams.push(paramName);
+            }
+        }
+        return {
+            isValid: missingParams.length === 0,
+            missingParams
+        };
+    }
+    /**
+     * Validates the request body of the request.
+     * @param {Request} request - The Express request object.
+     * @param {{ name: string, type: string }[]} requiredFields - Array of required fields in the request body with their types.
+     * @returns {ValidationResult} The result of the validation operation.
+     */
+    static validateRequestBody(request, requiredFields) {
+        const requestBody = request.body;
+        const missingParams = [];
+        if (!requestBody) {
+            return {
+                isValid: false,
+                missingParams
+            };
+        }
+        for (const field of requiredFields) {
+            const fieldName = field.name;
+            const fieldType = field.type;
+            if (!(fieldName in requestBody) || typeof requestBody[fieldName] !== fieldType) {
+                missingParams.push(fieldName);
+            }
+        }
+        return {
+            isValid: missingParams.length === 0,
+            missingParams
+        };
+    }
+}
+exports.default = RequestValidator;

package/lib/express/RequireParamsPicker.d.ts

@@ -0,0 +1,7 @@
+export declare class RequiredParamsPicker {
+    private static requiredParamsMap;
+    static pick(apiName: string): {
+        name: string;
+        type: string;
+    }[] | undefined;
+}

package/lib/express/RequireParamsPicker.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredParamsPicker = void 0;
+class RequiredParamsPicker {
+    static pick(apiName) {
+        return this.requiredParamsMap[apiName];
+    }
+}
+exports.RequiredParamsPicker = RequiredParamsPicker;
+RequiredParamsPicker.requiredParamsMap = {
+    'commonApi': [{ name: 'server', type: 'string' }],
+    'getGpmAll': [],
+    // Add more API names and their corresponding required parameters here
+};

package/lib/express/ValidateRequireParameters.d.ts

@@ -0,0 +1,3 @@
+import { NextFunction, Request, Response } from "express";
+export declare function validateRequiredCommonParams(req: Request, res: Response, next: NextFunction): Response<any, Record<string, any>> | undefined;
+export declare function validateRequiredParams(req: Request, res: Response, next: NextFunction): Response<any, Record<string, any>> | undefined;

package/lib/express/ValidateRequireParameters.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRequiredParams = exports.validateRequiredCommonParams = void 0;
+const RequireParamsPicker_1 = require("./RequireParamsPicker");
+const RequestValidator_1 = __importDefault(require("./RequestValidator"));
+// Middleware function to validate common required parameters
+function validateRequiredCommonParams(req, res, next) {
+    const requiredParams = RequireParamsPicker_1.RequiredParamsPicker.pick('commonApi');
+    if (!requiredParams) {
+        return res.status(500).json({ error: 'Internal server error' });
+    }
+    const validateRes = RequestValidator_1.default.validateQueryParams(req, requiredParams);
+    if (validateRes.isValid) {
+        next();
+    }
+    else {
+        res.status(400).json({ error: 'Required parameters are missing ', missingParams: validateRes.missingParams });
+    }
+}
+exports.validateRequiredCommonParams = validateRequiredCommonParams;
+// Middleware function to validate required parameters
+function validateRequiredParams(req, res, next) {
+    const apiName = req.query.apiName;
+    const requiredParams = RequireParamsPicker_1.RequiredParamsPicker.pick(apiName);
+    if (!requiredParams) {
+        return res.status(400).json({ error: 'API name not found' });
+    }
+    const validateRes = RequestValidator_1.default.validateQueryParams(req, requiredParams);
+    if (validateRes.isValid) {
+        next();
+    }
+    else {
+        res.status(400).json({ error: 'Required parameters are missing ', missingParams: validateRes.missingParams });
+    }
+}
+exports.validateRequiredParams = validateRequiredParams;

package/lib/index.d.ts

@@ -0,0 +1,39 @@
+import { DatabaseFactory } from "./common/abstract/DatabaseFactory";
+import { GPMController } from "./controller/twilio/GPMController";
+import { TwilioAuthTokenConfig } from "./twilio/impl/TwilioAuthTokenConfig";
+import { SyncServiceFactory } from "./twilio/impl/sync/SyncServiceFactory";
+import { CallLogsController } from "./controller/twilio/CallLogsController";
+import { CxConfigAssetController } from "./controller/twilio/CxConfigAssetController";
+import { CxConfigController } from "./controller/twilio/CxConfigController";
+import { CxConfigOtherController } from "./controller/twilio/CxConfigOther";
+import { CxConfigExternalNumbersController } from "./controller/twilio/CxConfigExternalNumbersController";
+import { CxConfigQueueMenuController } from "./controller/twilio/CxConfigQueueMenuController";
+import { CxConfigUIConfigController } from "./controller/twilio/CxConfigUIconfigController";
+import { AuditLogController } from "./controller/twilio/AuditLogController";
+import { TwilioClient } from "./twilio/impl/TwilioClient";
+import { NavigationController } from "./controller/twilio/NavigationController";
+import { QuickLinksController } from "./controller/twilio/QuickLinkController";
+import { QualityFormsController } from "./controller/twilio/QualityFormsController";
+import { RealTimeReportsWGDetailsController } from "./controller/twilio/RealTimeReportsWGDetailsController";
+import { RealTimeReportsQueueDetailsController } from "./controller/twilio/RealTimeReportQueueDetailsController";
+import { PlaybackScreenrecordingsController } from "./controller/aws/PlaybackScreenrecordings";
+import { HoopProfilesListController } from "./controller/twilio/HoopProfilesListController";
+import { HoopOverrideBranchesController } from "./controller/twilio/HoopOverrideBranchesController";
+import { HoopOperationsController } from "./controller/twilio/HoopOperationsController";
+import { HoopHolidaysController } from "./controller/twilio/HoopHolidaysController";
+import { HoopPartialDaysController } from "./controller/twilio/HoopPartialDaysController";
+import { HoopBusinessHoursController } from './controller/twilio/HoopBusinessHoursController';
+import { CallbackAndVoicemailController } from "./controller/twilio/CallbackAndVoicemailController";
+import { HoopMainController } from "./controller/twilio/HoopMainController";
+import { HoopNotesController } from "./controller/twilio/HoopNotesController";
+import { HoopBusinessHoursControllerAConnect } from "./controller/aws/HoopBuisnessHours";
+import { AWSConnectAPIConfig } from "./aws/impl/AWSConnectAPIConfig";
+import { AWSClient } from "./aws/impl/AWSClient";
+import { HoopServiceFactory } from "./aws/impl/HoopServices/HoopServiceFactory";
+import { ChannelSettingsController } from "./controller/twilio/ChannelSettingsController";
+import { TaskInfoPanelController } from "./controller/twilio/TaskInfoPanelController";
+import { AgentScorecardController } from "./controller/twilio/AgentScorecardController";
+import { AgentActionsController } from "./controller/twilio/AgentActionsController";
+import * as models from "./models";
+export { DatabaseFactory, GPMController, TwilioAuthTokenConfig, SyncServiceFactory, CxConfigAssetController, CxConfigController, CallLogsController, CxConfigOtherController, CxConfigExternalNumbersController, CxConfigQueueMenuController, TwilioClient, AuditLogController, QuickLinksController, NavigationController, QualityFormsController, RealTimeReportsWGDetailsController, RealTimeReportsQueueDetailsController, PlaybackScreenrecordingsController, CxConfigUIConfigController, HoopProfilesListController, HoopOverrideBranchesController, HoopOperationsController, HoopHolidaysController, HoopPartialDaysController, HoopBusinessHoursController, CallbackAndVoicemailController, HoopMainController, HoopNotesController, HoopBusinessHoursControllerAConnect, AWSConnectAPIConfig, AWSClient, HoopServiceFactory, ChannelSettingsController, TaskInfoPanelController, AgentScorecardController, AgentActionsController };
+export { models };