@samparkchat/sampark-web-chat 0.0.1

package/sampark/sampark-chat/sdk/client/Groupchat.js

@@ -0,0 +1,457 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { io } from "socket.io-client";
+import axios from "axios";
+import { apiUrl } from "../enum/constant";
+import { CreateGroupChatRequest } from "../types/CreateGroupChatRequest";
+import { AddParticipantRequest } from "../types/AddParticipentRequest";
+import { RemoveParticipantRequest } from "../types/RemoveParticipentRequest";
+import { DeleteGroupRequest } from "../types/DeleteGroupRequest";
+import { GetParticipantsRequest } from "../types/GetParticipentRequest";
+import { GetGroupsRequest } from "../types/GetGroupsRequest";
+import { GroupChatHistoryRequest } from "../types/GroupChatHistoryRequest";
+import { UpdateGroupStatusRequest } from "../types/UpdateGroupStatus";
+import { GetRegisteredUserDetailsRequest } from "../types/GetRegisteredUserDetailsRequest";
+import { UpdateGroupAdminRequest } from "../types/UpdateGroupAdminRequest";
+var GroupChat = /** @class */ (function () {
+    function GroupChat(organizationId, applicationId) {
+        this.socket = io(apiUrl);
+        this.organizationId = organizationId;
+        this.applicationId = applicationId;
+    }
+    GroupChat.prototype.test = function () {
+        console.log("Test function calling ....");
+    };
+    GroupChat.prototype.sendOnlineStatus = function (userId) {
+        if (this.socket && this.organizationId) {
+            this.socket.emit('userOnline', { userId: userId, organizationId: this.organizationId });
+            console.log("User ".concat(userId, " is online in org: ").concat(this.organizationId));
+        }
+        else {
+            console.log('Socket not initialized or organization ID missing');
+        }
+    };
+    GroupChat.prototype.connectUser = function (OnStatusUpdate) {
+        var _a;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('userStatusChanged', function (organizationId, userId, status) {
+            console.log("".concat(organizationId, " in the ").concat(userId, " has the ").concat(status));
+            if (OnStatusUpdate) {
+                console.log("".concat(userId, " has online ").concat(organizationId));
+                OnStatusUpdate({ organizationId: organizationId, userId: userId, status: status });
+            }
+        });
+    };
+    GroupChat.prototype.sendTyping = function (roomId, userId, userName) {
+        if (this.socket) {
+            // console.log(`${userId} starts typing in this ${roomId}`),
+            this.socket.emit('typing', { roomId: roomId, userId: userId, userName: userName });
+        }
+        else {
+            console.error('Socket not initialized');
+        }
+    };
+    GroupChat.prototype.sendStopTyping = function (roomId, userId, userName) {
+        if (this.socket) {
+            // console.log(`${userId} stop typing in this ${roomId}`),
+            this.socket.emit('stopTyping', { roomId: roomId, userId: userId, userName: userName });
+        }
+        else {
+            console.error('Socket not initialized');
+        }
+    };
+    GroupChat.prototype.connectTyping = function (onTyping) {
+        var _a;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('userTyping', function (_a) {
+            var userId = _a.userId, userName = _a.userName, roomId = _a.roomId, isTyping = _a.isTyping;
+            // console.log('Received userTyping event:', { userId, userName, roomId, isTyping });
+            if (onTyping) {
+                // console.log(`${userId} with ${userName} is typing in this ${roomId} with status ${isTyping}`);
+                onTyping({ userId: userId, userName: userName, roomId: roomId, isTyping: isTyping });
+            }
+        });
+    };
+    GroupChat.prototype.createGroupChat = function (adminId, roomType, groupName, participants) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload, response, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        payload = new CreateGroupChatRequest(adminId, this.organizationId, roomType = roomType, groupName = groupName, participants = participants, this.applicationId);
+                        return [4 /*yield*/, axios.post("".concat(apiUrl, "/chat/createGroupChat"), payload)];
+                    case 1:
+                        response = _a.sent();
+                        if (response.data && response.data.status === 200) {
+                            return [2 /*return*/, response.data.data.room_id];
+                        }
+                        else {
+                            return [2 /*return*/, ''];
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_1 = _a.sent();
+                        console.error("Error creating group chat:", error_1);
+                        return [2 /*return*/, ''];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    GroupChat.prototype.JoinGroupRoom = function (roomId, userId, userName) {
+        if (this.socket) {
+            this.socket.emit('joinGroup', { roomId: roomId, userId: userId, userName: userName });
+        }
+        else {
+            console.error('socket not initilized');
+        }
+    };
+    GroupChat.prototype.addParticipantToGroup = function (roomId, groupName, participants) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload, response, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        payload = new AddParticipantRequest(roomId = roomId, groupName = groupName, this.organizationId, participants = participants);
+                        return [4 /*yield*/, axios.post("".concat(apiUrl, "/chat/addParticipants"), payload)];
+                    case 1:
+                        response = _a.sent();
+                        if (response.data && response.data.status === 200) {
+                            return [2 /*return*/, response.data.data.room_id];
+                        }
+                        else {
+                            return [2 /*return*/, ''];
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_2 = _a.sent();
+                        return [2 /*return*/, ''];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    GroupChat.prototype.removeParticipentFromGroup = function (roomId, participants) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload, response, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        payload = new RemoveParticipantRequest(roomId = roomId, participants = participants);
+                        return [4 /*yield*/, axios.post("".concat(apiUrl, "/chat/removeParticipent"), payload)];
+                    case 1:
+                        response = _a.sent();
+                        if (response.data && response.data.status === 200) {
+                            return [2 /*return*/, response.data.data.room_id];
+                        }
+                        else {
+                            return [2 /*return*/, ''];
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_3 = _a.sent();
+                        console.error("Error adding participant:", error_3);
+                        return [2 /*return*/, ''];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    GroupChat.prototype.deleteGroupByUser = function (roomId, participants) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload, response, error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        payload = new DeleteGroupRequest(this.organizationId, roomId = roomId, participants = participants);
+                        return [4 /*yield*/, axios.post("".concat(apiUrl, "/chat/deleteGroupByUser"), payload)];
+                    case 1:
+                        response = _a.sent();
+                        if (response.data && response.data.status === 200) {
+                            return [2 /*return*/, response.data.message];
+                        }
+                        else {
+                            return [2 /*return*/, ''];
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_4 = _a.sent();
+                        console.error("Error adding participant:", error_4);
+                        return [2 /*return*/, ''];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    GroupChat.prototype.getParticipant = function (roomId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload, response, error_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        payload = new GetParticipantsRequest(roomId = roomId, this.organizationId);
+                        return [4 /*yield*/, axios.post("".concat(apiUrl, "/chat/getParticipents"), payload)];
+                    case 1:
+                        response = _a.sent();
+                        if (response.data && response.data.status === 200) {
+                            return [2 /*return*/, response.data.data.participants];
+                        }
+                        else {
+                            return [2 /*return*/, null];
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_5 = _a.sent();
+                        console.error("Error retrieving participents", error_5);
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    GroupChat.prototype.sendGroupMessage = function (roomId, message, userId, userName) {
+        if (this.socket) {
+            this.socket.emit('sendGroupMessage', { organizationId: this.organizationId, roomId: roomId, message: message, userId: userId, userName: userName, applicationId: this.applicationId });
+        }
+        else {
+            console.error('Socket not initialized');
+        }
+    };
+    // connectUser(OnStatusUpdate: OnStatusUpdateCallback
+    // ): void {
+    //   this.socket?.on('userStatusChanged',(organizationId:string,userId:string,status:boolean)=>{
+    //     console.log(`${organizationId} in the ${userId} has the ${status}`)
+    //     if(OnStatusUpdate){
+    //       console.log(`${userId} has online ${organizationId}`) 
+    //       OnStatusUpdate({organizationId,userId,status});
+    //     }
+    //   })
+    // }  
+    GroupChat.prototype.connect = function (onGroupMessageReceived) {
+        var _this = this;
+        var _a, _b, _c, _d, _e, _f;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.off('receiveGroupMessage');
+        (_b = this.socket) === null || _b === void 0 ? void 0 : _b.on('connect', function () {
+            onGroupMessageReceived({ msg: 'connected' });
+        });
+        (_c = this.socket) === null || _c === void 0 ? void 0 : _c.on('receiveGroupMessage', function (message, userId, userName, roomId, time) {
+            if (onGroupMessageReceived) {
+                onGroupMessageReceived({ message: message, userId: userId, userName: userName, roomId: roomId, userRemoved: false, time: time });
+            }
+        });
+        (_d = this.socket) === null || _d === void 0 ? void 0 : _d.on('userRemovedFromGroup', function (userId, removedRoomId) {
+            if (onGroupMessageReceived) {
+                onGroupMessageReceived({ userId: userId, userRemoved: true, removedRoomId: removedRoomId });
+            }
+        });
+        (_e = this.socket) === null || _e === void 0 ? void 0 : _e.on('userStatusChanged', function (_a) {
+            var userId = _a.userId, status = _a.status, organizationId = _a.organizationId;
+            console.log("User ".concat(userId, " status updated to"), status ? "online" : "offline");
+            if (organizationId === _this.organizationId) {
+                console.log("User ".concat(userId, " status updated to"), status ? "online" : "offline");
+            }
+        });
+        (_f = this.socket) === null || _f === void 0 ? void 0 : _f.on('disconnect', function () {
+            console.log('Disconnected from group chat server');
+        });
+    };
+    GroupChat.prototype.getRoomsByUserId = function (userId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload, response, error_6;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        payload = new GetGroupsRequest(userId = userId, this.organizationId);
+                        return [4 /*yield*/, axios.post("".concat(apiUrl, "/chat/getRoomsById"), payload)];
+                    case 1:
+                        response = _a.sent();
+                        if (response.data && response.data.status === 200) {
+                            return [2 /*return*/, response.data.data.rooms];
+                        }
+                        else {
+                            return [2 /*return*/, null];
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_6 = _a.sent();
+                        console.error("Error retrieving rooms:", error_6);
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    GroupChat.prototype.getGroupChatHistory = function (roomId, userGroupStatus, userGroupUpdatedAt, page, limit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload, response, error_7;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        payload = new GroupChatHistoryRequest(roomId = roomId, this.organizationId, userGroupStatus, userGroupUpdatedAt, page = page, limit = limit);
+                        return [4 /*yield*/, axios.post("".concat(apiUrl, "/chat/getPaginatedGroupChat"), payload)];
+                    case 1:
+                        response = _a.sent();
+                        if (response.data && response.data.status == 200) {
+                            return [2 /*return*/, response.data.data];
+                        }
+                        else {
+                            return [2 /*return*/, null];
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_7 = _a.sent();
+                        console.error("Error validating credentials:", error_7);
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    GroupChat.prototype.leaveGroup = function (roomId, userId) {
+        if (this.socket) {
+            this.socket.emit('leaveGroup', { roomId: roomId, userId: userId });
+            this.socket.on('userRemoved', function (removedUserId) {
+                if (removedUserId === userId) {
+                    // console.log(`You (${userId}) have successfully left the group.`);
+                }
+                else {
+                    // console.log(`User ${removedUserId} has left the group.`);
+                }
+            });
+            this.socket.on('error', function (errorMessage) {
+                console.error("Error: ".concat(errorMessage));
+            });
+        }
+        else {
+            console.error('Socket not initialized');
+        }
+    };
+    GroupChat.prototype.updateGroupStatusByParticipant = function (participantId, groupId, groupStatus) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload, response, error_8;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        payload = new UpdateGroupStatusRequest(this.organizationId, participantId, groupId, groupStatus);
+                        return [4 /*yield*/, axios.post("".concat(apiUrl, "/chat/updateGroupStatusByParticipant"), payload)];
+                    case 1:
+                        response = _a.sent();
+                        if (response.data && response.data.status == 200) {
+                            return [2 /*return*/, response.data];
+                        }
+                        else {
+                            return [2 /*return*/, null];
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_8 = _a.sent();
+                        console.error("Error validating credentials:", error_8);
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    GroupChat.prototype.getRegisteredParticipantDetails = function (participantId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload, response, error_9;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        payload = new GetRegisteredUserDetailsRequest(this.organizationId, participantId);
+                        return [4 /*yield*/, axios.post("".concat(apiUrl, "/chat/getRegisteredUserDetails"), payload)];
+                    case 1:
+                        response = _a.sent();
+                        if (response.data && response.data.status == 200) {
+                            return [2 /*return*/, response.data];
+                        }
+                        else {
+                            return [2 /*return*/, null];
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_9 = _a.sent();
+                        console.error("Error validating credentials:", error_9);
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    GroupChat.prototype.updateGroupAdmin = function (room_id, organizationId, current_admin_id, new_admin_id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload, response, error_10;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        payload = new UpdateGroupAdminRequest(room_id, organizationId, current_admin_id, new_admin_id);
+                        return [4 /*yield*/, axios.post("".concat(apiUrl, "/chat/updateGroupAdmin"), payload)];
+                    case 1:
+                        response = _a.sent();
+                        if (response.data && response.data.status == 200) {
+                            return [2 /*return*/, response.data];
+                        }
+                        else {
+                            return [2 /*return*/, null];
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_10 = _a.sent();
+                        console.error("Error validating credentials:", error_10);
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    GroupChat.prototype.disconnect = function () {
+        if (this.socket) {
+            this.socket.disconnect();
+        }
+    };
+    return GroupChat;
+}());
+export { GroupChat };
+export default GroupChat;

package/sampark/sampark-chat/sdk/client/PeerChat.d.ts

@@ -0,0 +1,34 @@
+import { ISamparkPeerChatService } from '../interface/SamparkPeerChatService';
+type OnMessageReceivedCallback = (message: any) => void;
+type OnTypingCallback = (typingData: {
+    userId: string;
+    userName: string;
+    room_id: string;
+    isTyping: boolean;
+}) => void;
+export declare class PeerChat implements ISamparkPeerChatService {
+    private socket?;
+    private isSocketConnected?;
+    private organizationId;
+    private applicationId;
+    constructor(orgId: string, appId: string);
+    test(): void;
+    getOrganizationId(): string;
+    sendOnlineStatus(userId: string, userName: string): void;
+    peerConnectUser(onUserStatusUpdate: (data: {
+        organizationId: string;
+        userId: string;
+        status: string;
+    }) => void, onInitialOnlineUsers: (onlineUsers: string[]) => void): void;
+    getChatHistory(roomId: string, page: number, limit: number): Promise<any>;
+    registerUser(participantId: string, participantName: string): Promise<string>;
+    connect(onMessageReceived: OnMessageReceivedCallback): void;
+    joinChatSession(room_id: string): void;
+    sendPeerTyping(room_id: string, userId: string, userName: string): void;
+    sendStopPeerTyping(room_id: string, userId: string, userName: string): void;
+    peerConnectTyping(onTyping: OnTypingCallback): void;
+    getChatRoomId(userId: string, userName: string, peerId: string, peerName: string): Promise<string>;
+    sendMessage(room_id: string, message: string, userId: string, userName: string, peerId: string, peerName: string): void;
+    disconnect(): void;
+}
+export default PeerChat;