@vgroup/dialbox 0.2.61 → 0.2.62

package/fesm2015/vgroup-dialbox.mjs

@@ -2493,9 +2493,10 @@ class CallProgressComponent {
     callContact(contact) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            console.log("Adding participant:", contact);
-            if (!this.call || this.call.status() !== 'open') {
-                console.error('No active call');
+            console.log("Starting second call:", contact);
+            // Must have active Call A
+            if (!this.call || this.call.status() !== "open") {
+                console.error("No active call to start second call");
                 return;
             }
             const phoneNumber = (_b = (_a = contact === null || contact === void 0 ? void 0 : contact.numbersList) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.number;
@@ -2504,45 +2505,87 @@ class CallProgressComponent {
                 return;
             }
             try {
-                // ---- HOLD CURRENT CALL ----
+                // ---- HOLD CALL A ----
                 this.heldCall = this.call;
                 this.isCallOnHold = true;
                 this.heldCall.mute(true);
+                console.log("Call A placed on hold");
                 this.showContactsPanel = false;
                 this.showRingAnimation = true;
-                if (!this.conferenceId) {
-                    console.error("No conferenceId found for active call");
-                    swal("Error", "Cannot add participant: conference not found", "error");
-                    this.showRingAnimation = false;
-                    return;
-                }
-                // ---- BUILD PAYLOAD ----
-                setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                    var _c, _d;
-                    yield this.addParticipantToCall({
-                        from: (_c = this.callData) === null || _c === void 0 ? void 0 : _c.from,
-                        route: "OUTGOING",
-                        participantNumber: (_d = this.callData) === null || _d === void 0 ? void 0 : _d.phone,
-                        conferenceId: this.conferenceId
-                    });
-                }), 1000);
-                console.log("API Response:", this.conferenceId);
+                // ---- START CALL B ----
+                yield this.startSecondOutboundCall(phoneNumber, contact);
                 this.showRingAnimation = false;
-                swal("Success", "Participant is being added to your call", "success");
-                // UI enters conference mode
-                this.isConference = true;
+                console.log("Second call started successfully");
             }
             catch (err) {
-                console.error("Error adding participant:", err);
-                swal("Error", "Failed to add participant", "error");
-                this.showRingAnimation = false;
+                console.error("Error starting second call:", err);
+                // Restore call A
                 if (this.heldCall) {
                     this.call = this.heldCall;
                     this.heldCall = undefined;
-                    this.call.mute(false);
                     this.isCallOnHold = false;
+                    this.call.mute(false);
                 }
+                this.showRingAnimation = false;
+                swal("Error", "Failed to start second call", "error");
+            }
+        });
+    }
+    startSecondOutboundCall(phoneNumber, contact) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("Dialing second call to", phoneNumber);
+            // 1️⃣ Prepare data for new call
+            const payload = {
+                channelId: environment.channelId,
+                userId: localStorage.getItem("userId"),
+                to: phoneNumber,
+                scope: "local",
+                fromNumber: this.callData.from
+            };
+            const response = yield this.initiateCall(payload);
+            if (response.status !== 200) {
+                throw new Error("Backend failed to initiate call");
             }
+            const { id: callAuthId, recordCall } = yield this.getCallAuthId(response);
+            this.recordCall = recordCall;
+            const tokenData = yield this.getOutgoingCallToken(callAuthId);
+            // 2️⃣ Setup Twilio Device (same as your current code)
+            const options = {
+                codecPreferences: ["opus", "pcmu"],
+                closeProtection: true,
+            };
+            if (!this.device) {
+                this.device = new Device(tokenData.token.value, options);
+                yield this.device.register();
+            }
+            else if (this.device.updateToken) {
+                yield this.device.updateToken(tokenData.token.value);
+            }
+            // 3️⃣ Start NEW CALL B
+            const newCall = yield this.device.connect({
+                params: {
+                    From: this.callData.from,
+                    To: phoneNumber,
+                    Env: environment.abb,
+                    Token: tokenData.token.id,
+                    Ext: this.callData.extNum
+                },
+                rtcConstraints: { audio: { deviceId: "default" } }
+            });
+            // 4️⃣ Set new call B as active call
+            this.call = newCall;
+            // Update call data UI
+            this.callData = {
+                phone: phoneNumber,
+                from: this.callData.from,
+                extNum: this.callData.extNum,
+                name: `${contact.firstName} ${contact.middleName || ""} ${contact.lastName || ""}`.trim(),
+                img: contact.img || "assets/images/user.jpg",
+                displayNum: phoneNumber
+            };
+            this.setupEventListeners();
+            this.pollCallStatus(callAuthId);
+            console.log("Call B is now active");
         });
     }
     acceptConcurrentCall(incomingCall) {
@@ -2598,15 +2641,47 @@ class CallProgressComponent {
         console.log('Updated callData:', this.callData);
         this.cdr.detectChanges();
     }
+    // mergeCalls() {
+    //   // Merge functionality - unmute both calls for conference
+    //   if (this.heldCall && this.call) {
+    //     this.heldCall.mute(false);
+    //     this.call.mute(false);
+    //     this.isCallOnHold = false;
+    //     this.isConference = true;
+    //     this.cdr.detectChanges();
+    //   }
+    // }
     mergeCalls() {
-        // Merge functionality - unmute both calls for conference
-        if (this.heldCall && this.call) {
-            this.heldCall.mute(false);
-            this.call.mute(false);
-            this.isCallOnHold = false;
-            this.isConference = true;
-            this.cdr.detectChanges();
-        }
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.conferenceId) {
+                swal("Error", "Unable to merge: conference ID missing", "error");
+                return;
+            }
+            if (!((_a = this.callData) === null || _a === void 0 ? void 0 : _a.phone)) {
+                swal("Error", "Second call number is missing", "error");
+                return;
+            }
+            try {
+                this.showRingAnimation = true;
+                const payload = {
+                    from: this.callData.from,
+                    route: "OUTGOING",
+                    participantNumber: this.callData.phone,
+                    conferenceId: this.conferenceId
+                };
+                console.log("Calling addParticipant API:", payload);
+                yield this.addParticipantToCall(payload);
+                this.showRingAnimation = false;
+                this.isConference = true;
+                swal("Success", "Calls have been merged", "success");
+            }
+            catch (error) {
+                console.error("Merge failed:", error);
+                this.showRingAnimation = false;
+                swal("Error", "Failed to merge calls", "error");
+            }
+        });
     }
     endHeldCall() {
         if (this.heldCall) {