hgs-twilio-class-lib 1.1.72 → 1.1.74

package/lib/models/impl/TaskChannelModel.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskChannelModel = void 0;
+const BaseModel_1 = require("../abstract/BaseModel");
+class TaskChannelModel extends BaseModel_1.BaseModel {
+    constructor(channel, capacity, isAvailable) {
+        super();
+        this._channel = channel;
+        this._capacity = capacity;
+        this._isAvailable = isAvailable;
+    }
+    // Getters and Setters
+    get channel() {
+        return this._channel;
+    }
+    set channel(value) {
+        if (typeof value === "string" && value.trim() !== "") {
+            this._channel = value;
+        }
+        else {
+            throw new Error("Invalid channel");
+        }
+    }
+    get capacity() {
+        return this._capacity;
+    }
+    set capacity(value) {
+        if (typeof value === "number" && value >= 0) {
+            this._capacity = value;
+        }
+        else {
+            throw new Error("Invalid capacity");
+        }
+    }
+    get isAvailable() {
+        return this._isAvailable;
+    }
+    set isAvailable(value) {
+        if (typeof value === "boolean") {
+            this._isAvailable = value;
+        }
+        else {
+            throw new Error("Invalid isAvailable value");
+        }
+    }
+    // Validate data
+    validateData() {
+        this.validationMessages = [];
+        const validationRules = {
+            channel: (value) => typeof value === "string" && value.trim() !== "",
+            capacity: (value) => typeof value === "number" && value >= 0,
+            isAvailable: (value) => typeof value === "boolean",
+        };
+        // Validate each property
+        Object.keys(validationRules).forEach((key) => {
+            const validator = validationRules[key];
+            const fieldValue = this[key];
+            if (!validator(fieldValue)) {
+                this.validationMessages.push({
+                    type: "Error",
+                    fieldDescription: key,
+                    message: `${key} is not valid`,
+                });
+            }
+        });
+        return this.validationMessages;
+    }
+}
+exports.TaskChannelModel = TaskChannelModel;

package/lib/models/impl/TaskComplete.js

@@ -0,0 +1 @@
+"use strict";

package/lib/models/impl/TaskInfoPanelModel.d.ts

@@ -0,0 +1,16 @@
+import { BaseModel } from "../abstract/BaseModel";
+import { validationMessage } from "../interface/IBaseModel";
+export declare class TaskInfoPanelModel extends BaseModel {
+    private _id;
+    private _callSid;
+    private _ivrPath;
+    constructor(id: string, callSid: string, ivrPath: string);
+    get id(): string;
+    get callSid(): string;
+    get ivrPath(): string;
+    set id(value: string);
+    set callSid(value: string);
+    set ivrPath(value: string);
+    validateData(): validationMessage[];
+    setValidationMessages(message: validationMessage): void;
+}

package/lib/models/impl/TaskInfoPanelModel.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskInfoPanelModel = void 0;
+const BaseModel_1 = require("../abstract/BaseModel");
+const uuid_1 = require("uuid");
+// id: uuidv4(),
+// callSid,
+// ivrPath: `${Digits}`,
+class TaskInfoPanelModel extends BaseModel_1.BaseModel {
+    constructor(id, callSid, ivrPath) {
+        super();
+        // Initialize private attributes
+        this._id = id;
+        this._callSid = callSid;
+        this._ivrPath = ivrPath;
+        this.validateData();
+    }
+    // Getters
+    get id() {
+        return this._id;
+    }
+    get callSid() {
+        return this._callSid;
+    }
+    get ivrPath() {
+        return this._ivrPath;
+    }
+    //setters
+    set id(value) {
+        if (!(0, uuid_1.validate)(value)) {
+            throw new Error("Invalid ID format.");
+        }
+        this._id = value;
+    }
+    set callSid(value) {
+        if (typeof value !== "string" || value.trim() === "") {
+            throw new Error("callSid must be a non-empty string.");
+        }
+        this._callSid = value;
+    }
+    set ivrPath(value) {
+        this._ivrPath = value;
+    }
+    // Validation logic
+    validateData() {
+        this.validationMessages = [];
+        const validationRules = {
+            id: (value) => typeof value === "string" && (0, uuid_1.validate)(value),
+            callSid: (value) => typeof value === "string" && value.trim() !== "",
+            ivrPath: (value) => typeof value === "string" || value === null
+        };
+        for (const key in validationRules) {
+            const validator = validationRules[key];
+            const value = this[key];
+            if (!validator(value)) {
+                this.setValidationMessages({
+                    type: "Error",
+                    fieldDescription: key,
+                    message: `${key} is invalid.`,
+                });
+            }
+        }
+        return this.validationMessages;
+    }
+    setValidationMessages(message) {
+        this.validationMessages.push(message);
+    }
+}
+exports.TaskInfoPanelModel = TaskInfoPanelModel;

package/lib/models/impl/TaskModel.d.ts

@@ -0,0 +1,59 @@
+import { validationMessage } from "../interface/IBaseModel";
+import { BaseModel } from "../abstract/BaseModel";
+import { TaskAttributesModel } from "./TaskAttributesModel";
+export declare enum AssignmentStatusEnum {
+    reserved = "reserved",
+    pending = "pending",
+    assigned = "assigned",
+    completed = "completed",
+    canceled = "canceled"
+}
+export declare class TaskModel extends BaseModel {
+    private _accountSid;
+    private _age;
+    private _assignmentStatus;
+    private _attributes;
+    private _dateCreated;
+    private _dateUpdated;
+    private _priority;
+    private _reason;
+    private _sid;
+    private _taskQueueSid;
+    private _timeout;
+    private _workflowSid;
+    private _workspaceSid;
+    private _workflowFriendlyName;
+    private _queueFriendlyName;
+    private _routingTarget;
+    private _requiredAttention;
+    constructor(accountSid: string, age: number, assignmentStatus: AssignmentStatusEnum, attributes: TaskAttributesModel, dateCreated: Date, dateUpdated: Date, priority: number, reason: string, sid: string, taskQueueSid: string, timeout: number, workflowSid: string, workspaceSid: string, workflowFriendlyName: string, queueFriendlyName: string, routingTarget: string, requiredAttention: boolean);
+    set accountSid(value: string);
+    get age(): number;
+    get assignmentStatus(): AssignmentStatusEnum;
+    set assignmentStatus(value: AssignmentStatusEnum);
+    get attributes(): TaskAttributesModel;
+    set attributes(value: TaskAttributesModel);
+    get dateCreated(): Date;
+    get dateUpdated(): Date;
+    get priority(): number;
+    set priority(value: number);
+    get reason(): string;
+    set reason(value: string);
+    get sid(): string;
+    set sid(value: string);
+    get taskQueueSid(): string;
+    set taskQueueSid(value: string);
+    get timeout(): number;
+    set timeout(value: number);
+    get workflowSid(): string;
+    set workflowSid(value: string);
+    get workspaceSid(): string;
+    get workflowFriendlyName(): string;
+    get queueFriendlyName(): string;
+    set queueFriendlyName(value: string);
+    get routingTarget(): string;
+    set routingTarget(value: string);
+    get requiredAttention(): boolean;
+    set requiredAttention(value: boolean);
+    validateData(): validationMessage[];
+}

package/lib/models/impl/TaskModel.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskModel = exports.AssignmentStatusEnum = void 0;
+const BaseModel_1 = require("../abstract/BaseModel");
+const TaskAttributesModel_1 = require("./TaskAttributesModel");
+var AssignmentStatusEnum;
+(function (AssignmentStatusEnum) {
+    AssignmentStatusEnum["reserved"] = "reserved";
+    AssignmentStatusEnum["pending"] = "pending";
+    AssignmentStatusEnum["assigned"] = "assigned";
+    AssignmentStatusEnum["completed"] = "completed";
+    AssignmentStatusEnum["canceled"] = "canceled";
+})(AssignmentStatusEnum || (exports.AssignmentStatusEnum = AssignmentStatusEnum = {}));
+class TaskModel extends BaseModel_1.BaseModel {
+    constructor(accountSid, age, assignmentStatus, attributes, dateCreated, dateUpdated, priority, reason, sid, taskQueueSid, timeout, workflowSid, workspaceSid, workflowFriendlyName, queueFriendlyName, routingTarget, requiredAttention) {
+        super();
+        this._accountSid = accountSid;
+        this._age = age;
+        this._assignmentStatus = assignmentStatus;
+        this._attributes = attributes;
+        this._dateCreated = dateCreated;
+        this._dateUpdated = dateUpdated;
+        this._priority = priority;
+        this._reason = reason;
+        this._sid = sid;
+        this._taskQueueSid = taskQueueSid;
+        this._timeout = timeout;
+        this._workflowSid = workflowSid;
+        this._workspaceSid = workspaceSid;
+        this._workflowFriendlyName = workflowFriendlyName;
+        this._queueFriendlyName = queueFriendlyName;
+        this._routingTarget = routingTarget;
+        this._requiredAttention = requiredAttention;
+    }
+    // Getters and Setters
+    set accountSid(value) {
+        this._accountSid = value;
+    }
+    get age() {
+        return this._age;
+    }
+    get assignmentStatus() {
+        return this._assignmentStatus;
+    }
+    set assignmentStatus(value) {
+        this._assignmentStatus = value;
+    }
+    get attributes() {
+        return this._attributes;
+    }
+    set attributes(value) {
+        this._attributes = value;
+    }
+    get dateCreated() {
+        return this._dateCreated;
+    }
+    get dateUpdated() {
+        return this._dateUpdated;
+    }
+    get priority() {
+        return this._priority;
+    }
+    set priority(value) {
+        this._priority = value;
+    }
+    get reason() {
+        return this._reason;
+    }
+    set reason(value) {
+        this._reason = value;
+    }
+    get sid() {
+        return this._sid;
+    }
+    set sid(value) {
+        this._sid = value;
+    }
+    get taskQueueSid() {
+        return this._taskQueueSid;
+    }
+    set taskQueueSid(value) {
+        this._taskQueueSid = value;
+    }
+    get timeout() {
+        return this._timeout;
+    }
+    set timeout(value) {
+        this._timeout = value;
+    }
+    get workflowSid() {
+        return this._workflowSid;
+    }
+    set workflowSid(value) {
+        this._workflowSid = value;
+    }
+    get workspaceSid() {
+        return this._workspaceSid;
+    }
+    get workflowFriendlyName() {
+        return this._workflowFriendlyName;
+    }
+    get queueFriendlyName() {
+        return this._queueFriendlyName;
+    }
+    set queueFriendlyName(value) {
+        this._queueFriendlyName = value;
+    }
+    get routingTarget() {
+        return this._routingTarget;
+    }
+    set routingTarget(value) {
+        this._routingTarget = value;
+    }
+    get requiredAttention() {
+        return this._requiredAttention;
+    }
+    set requiredAttention(value) {
+        this._requiredAttention = value;
+    }
+    // Validation Method
+    validateData() {
+        this.validationMessages = [];
+        if (typeof this._accountSid !== "string" || !this._accountSid.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "accountSid",
+                message: "AccountSid must be a non-empty string",
+            });
+        }
+        if (typeof this._age !== "number" || this._age < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "age",
+                message: "Age must be a non-negative number",
+            });
+        }
+        if (!Object.values(AssignmentStatusEnum).includes(this._assignmentStatus)) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "assignmentStatus",
+                message: "AssignmentStatus must be a valid enum value",
+            });
+        }
+        if (!(this._attributes instanceof TaskAttributesModel_1.TaskAttributesModel)) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "attributes",
+                message: "Attributes must be an instance of TaskAttributesModel",
+            });
+        }
+        else {
+            // Validate TaskAttributesModel fields
+            if (typeof this._attributes.channelType !== "string" || !this._attributes.channelType.trim()) {
+                this.validationMessages.push({
+                    type: "Error",
+                    fieldDescription: "attributes.channelType",
+                    message: "ChannelType must be a non-empty string",
+                });
+            }
+            if (typeof this._attributes.from !== "string" || !this._attributes.from.trim()) {
+                this.validationMessages.push({
+                    type: "Error",
+                    fieldDescription: "attributes.from",
+                    message: "From must be a non-empty string",
+                });
+            }
+            if (typeof this._attributes.email !== "string" || !this._attributes.email.trim()) {
+                this.validationMessages.push({
+                    type: "Error",
+                    fieldDescription: "attributes.email",
+                    message: "Email must be a non-empty string",
+                });
+            }
+            if (typeof this._attributes.customerDevice !== "string" || !this._attributes.customerDevice.trim()) {
+                this.validationMessages.push({
+                    type: "Error",
+                    fieldDescription: "attributes.customerDevice",
+                    message: "CustomerDevice must be a non-empty string",
+                });
+            }
+            if (typeof this._attributes.onHoldTime !== "number" || this._attributes.onHoldTime < 0) {
+                this.validationMessages.push({
+                    type: "Error",
+                    fieldDescription: "attributes.onHoldTime",
+                    message: "OnHoldTime must be a non-negative number",
+                });
+            }
+            if (typeof this._attributes.conversationSid !== "string" || !this._attributes.conversationSid.trim()) {
+                this.validationMessages.push({
+                    type: "Error",
+                    fieldDescription: "attributes.conversationSid",
+                    message: "ConversationSid must be a non-empty string",
+                });
+            }
+        }
+        if (typeof this._sid !== "string" || !this._sid.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "sid",
+                message: "Sid must be a non-empty string",
+            });
+        }
+        if (typeof this._taskQueueSid !== "string" || !this._taskQueueSid.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "taskQueueSid",
+                message: "TaskQueueSid must be a non-empty string",
+            });
+        }
+        if (this._timeout < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "timeout",
+                message: "Timeout must be a non-negative number",
+            });
+        }
+        if (typeof this._workflowSid !== "string" || !this._workflowSid.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "workflowSid",
+                message: "WorkflowSid must be a non-empty string",
+            });
+        }
+        if (typeof this._workspaceSid !== "string" || !this._workspaceSid.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "workspaceSid",
+                message: "WorkspaceSid must be a non-empty string",
+            });
+        }
+        return this.validationMessages;
+    }
+}
+exports.TaskModel = TaskModel;

package/lib/models/impl/WorkGroupDetailsModel.d.ts

@@ -0,0 +1,63 @@
+import { BaseModel } from "../abstract/BaseModel";
+import { validationMessage } from "../interface/IBaseModel";
+export declare class WorkGroupDetailsModel extends BaseModel {
+    private _id;
+    private _totalAgents;
+    private _loggedOn;
+    private _agentsAvailable;
+    private _percentAvailable;
+    private _agentsAvailableToTakeCalls;
+    private _nonAcdInteractions;
+    private _availableForAcdInteractions;
+    private _notAvailableForAcdInteractions;
+    private _inboundAcdInteractions;
+    private _outboundAcdInteractions;
+    private _inboundAcw;
+    private _outboundAcw;
+    private _interactionWaiting;
+    private _interactionOnhold;
+    private _longestInteractionWaiting;
+    private _longestAvailable;
+    private _createdAt;
+    private _updatedAt;
+    constructor(id: string, totalAgents: number, loggedOn: number, agentsAvailable: number, percentAvailable: number, agentsAvailableToTakeCalls: number, nonAcdInteractions: number, availableForAcdInteractions: number, notAvailableForAcdInteractions: number, inboundAcdInteractions: number, outboundAcdInteractions: number, inboundAcw: number, outboundAcw: number, interactionWaiting: number, interactionOnhold: number, longestInteractionWaiting: string, longestAvailable: number, createdAt?: Date, updatedAt?: Date);
+    validateData(): validationMessage[];
+    get id(): string;
+    set id(value: string);
+    get totalAgents(): number;
+    set totalAgents(value: number);
+    get loggedOn(): number;
+    set loggedOn(value: number);
+    get agentsAvailable(): number;
+    set agentsAvailable(value: number);
+    get percentAvailable(): number;
+    set percentAvailable(value: number);
+    get agentsAvailableToTakeCalls(): number;
+    set agentsAvailableToTakeCalls(value: number);
+    get nonAcdInteractions(): number;
+    set nonAcdInteractions(value: number);
+    get availableForAcdInteractions(): number;
+    set availableForAcdInteractions(value: number);
+    get notAvailableForAcdInteractions(): number;
+    set notAvailableForAcdInteractions(value: number);
+    get inboundAcdInteractions(): number;
+    set inboundAcdInteractions(value: number);
+    get outboundAcdInteractions(): number;
+    set outboundAcdInteractions(value: number);
+    get inboundAcw(): number;
+    set inboundAcw(value: number);
+    get outboundAcw(): number;
+    set outboundAcw(value: number);
+    get interactionWaiting(): number;
+    set interactionWaiting(value: number);
+    get interactionOnhold(): number;
+    set interactionOnhold(value: number);
+    get longestInteractionWaiting(): string;
+    set longestInteractionWaiting(value: string);
+    get longestAvailable(): number;
+    set longestAvailable(value: number);
+    get createdAt(): Date | undefined;
+    set createdAt(value: Date | undefined);
+    get updatedAt(): Date | undefined;
+    set updatedAt(value: Date | undefined);
+}