@flashphoner/sfusdk 1.0.1-35 → 1.0.40

package/src/sdk/sfu-extended.js

@@ -22,7 +22,6 @@ let state = SFU_STATE.NEW;
 let connectionConfig;
 let user;
 let im;
-let pendingUserList = [];
 
 function setupConnection(connection) {
     connection.onMessage = function(name, msg){
@@ -33,15 +32,28 @@ function setupConnection(connection) {
                     notify(SFU_EVENT.MESSAGE, msg[0].message);
                 } else if (msg[0].type === SFU_INTERNAL.MESSAGE_STATE) {
                     im.onMessageState(msg);
+                    notify(SFU_EVENT.MESSAGE_STATE, msg[0].status);
                 } else if (msg[0].type === SFU_INTERNAL.USER_LIST) {
-                    while (pendingUserList.length > 0) {
-                        const promise = pendingUserList.pop();
-                        promise.resolve(msg[0].list);
-                    }
+                    promises.resolve(msg[0].internalMessageId, msg[0].list);
                     notify(SFU_EVENT.USER_LIST, msg[0].list);
                 } else if (msg[0].type === SFU_INTERNAL.USER_CALENDAR) {
                     promises.resolve(msg[0].internalMessageId, msg[0].calendar);
                     notify(SFU_EVENT.USER_CALENDAR, msg[0].calendar);
+                } else if (msg[0].type === SFU_INTERNAL.NEW_CHAT) {
+                    if(!promises.resolve(msg[0].internalMessageId, msg[0].info)) {
+                        notify(SFU_EVENT.NEW_CHAT, msg[0].info);
+                    }
+                } else if (msg[0].type === SFU_INTERNAL.CHAT_DELETED) {
+                    notify(SFU_EVENT.CHAT_DELETED, msg[0].info);
+                } else if (msg[0].type === SFU_INTERNAL.CHAT_UPDATED) {
+                    promises.resolve(msg[0].internalMessageId, msg[0].info);
+                    notify(SFU_EVENT.CHAT_UPDATED, msg[0].info);
+                } else if (msg[0].type === SFU_INTERNAL.USER_CHATS) {
+                    promises.resolve(msg[0].internalMessageId, msg[0].chats);
+                    notify(SFU_EVENT.USER_CHATS, msg[0].chats);
+                } else if (msg[0].type === SFU_INTERNAL.CHAT_LOADED) {
+                    promises.resolve(msg[0].internalMessageId, msg[0].chat);
+                    notify(SFU_EVENT.CHAT_LOADED, msg[0].chat);
                 } else if (msg[0].type === constants.SFU_ROOM_EVENT.OPERATION_FAILED && promises.promised(msg[0].internalMessageId)) {
                     promises.reject(msg[0].internalMessageId, msg[0]);
                 } else if (msg[0].type === constants.SFU_EVENT.ACK && promises.promised(msg[0].internalMessageId)) {
@@ -128,7 +140,8 @@ const connect = function(options) {
 /**
  * Send message
  * @param {Object} msg Message
- * @param {String} msg.to Recipient's id
+ * @param {String} msg.to Recipient's id (deprecated, use chatId instead)
+ * @param {String} msg.chatId Indicates chat this message belongs to
  * @param {String} msg.body Message body
  * @returns {Promise} Promise will resolve upon message delivery and reject if delivery was unsuccessful
  * @throws {Error} error if api isn't connected
@@ -144,26 +157,18 @@ const sendMessage = function(msg) {
 /**
  * Fetch available user list from server
  * @returns {Promise<Array<FlashphonerSFUExtended.UserListEntry>>}
- * @throws {Error} error if api isn't connected
  * @memberOf FlashphonerSFUExtended
 
  */
 const getUserList = function() {
-    if (state !== SFU_STATE.AUTHENTICATED) {
-        throw new Error("Can't get user list while in " + state + " state");
-    }
     return new Promise(function (resolve, reject){
         if (state !== SFU_STATE.AUTHENTICATED) {
             reject(new Error("Can't get user list while in " + state + " state"));
             return;
         }
-        if (pendingUserList.length > 0) {
-            pendingUserList.push({resolve: resolve, reject: reject});
-            return;
-        } else {
-            pendingUserList.push({resolve: resolve, reject: reject});
-        }
-        connection.send(constants.SFU_INTERNAL_API.GET_USER_LIST);
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.GET_USER_LIST, {internalMessageId: id});
     });
 };
 
@@ -229,6 +234,126 @@ const removeCalendarEvent = function(event) {
     });
 };
 
+/**
+ * Fetch available chats from server
+ * @returns {Promise<Array<FlashphonerSFUExtended.UserCalendar>>}
+ * @memberOf FlashphonerSFUExtended
+ */
+const getUserChats = function() {
+    return new Promise(function (resolve, reject){
+        if (state !== SFU_STATE.AUTHENTICATED) {
+            reject(new Error("Can't get user chats while in " + state + " state"));
+            return;
+        }
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.GET_USER_CHATS, {internalMessageId: id});
+    });
+};
+
+/**
+ * Fetch chat data from server
+ * @returns {Promise<Array<FlashphonerSFUExtended.UserCalendar>>}
+ * @memberOf FlashphonerSFUExtended
+ */
+const loadChat = function(chat) {
+    return new Promise(function (resolve, reject){
+        if (state !== SFU_STATE.AUTHENTICATED) {
+            reject(new Error("Can't load chats while in " + state + " state"));
+            return;
+        }
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.LOAD_CHAT, {id: chat.id, internalMessageId: id});
+    });
+};
+
+/**
+ * Create chat
+ * @returns {Promise<Array<FlashphonerSFUExtended.UserCalendar>>}
+ * @memberOf FlashphonerSFUExtended
+ */
+const createChat = function(chat) {
+    return new Promise(function (resolve, reject){
+        if (state !== SFU_STATE.AUTHENTICATED) {
+            reject(new Error("Can't create chats while in " + state + " state"));
+            return;
+        }
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.CREATE_CHAT, {id: chat.id, name: chat.name, members: chat.members, internalMessageId: id});
+    });
+};
+
+/**
+ * Delete chat
+ * @returns {Promise<Array<FlashphonerSFUExtended.UserCalendar>>}
+ * @memberOf FlashphonerSFUExtended
+ */
+const deleteChat = function(chat) {
+    return new Promise(function (resolve, reject){
+        if (state !== SFU_STATE.AUTHENTICATED) {
+            reject(new Error("Can't delete chats while in " + state + " state"));
+            return;
+        }
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.DELETE_CHAT, {id: chat.id, internalMessageId: id});
+    });
+};
+
+/**
+ * Rename chat
+ * @returns {Promise<Array<FlashphonerSFUExtended.UserCalendar>>}
+ * @memberOf FlashphonerSFUExtended
+ */
+const renameChat = function(chat) {
+    return new Promise(function (resolve, reject){
+        if (state !== SFU_STATE.AUTHENTICATED) {
+            reject(new Error("Can't rename chats while in " + state + " state"));
+            return;
+        }
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.RENAME_CHAT, {id: chat.id, name: chat.name, internalMessageId: id});
+    });
+};
+
+/**
+ * Add member to chat
+ * @returns {Promise<Array<FlashphonerSFUExtended.UserCalendar>>}
+ * @memberOf FlashphonerSFUExtended
+ */
+const addMemberToChat = function(chat) {
+    return new Promise(function (resolve, reject){
+        if (state !== SFU_STATE.AUTHENTICATED) {
+            reject(new Error("Can't add member to chat while in " + state + " state"));
+            return;
+        }
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.ADD_MEMBER_TO_CHAT, {id: chat.id, member: chat.member, internalMessageId: id});
+    });
+};
+
+/**
+ * Remove member from chat
+ * @returns {Promise<Array<FlashphonerSFUExtended.UserCalendar>>}
+ * @memberOf FlashphonerSFUExtended
+ */
+const removeMemberFromChat = function(chat) {
+    return new Promise(function (resolve, reject){
+        if (state !== SFU_STATE.AUTHENTICATED) {
+            reject(new Error("Can't remove member to chat while in " + state + " state"));
+            return;
+        }
+        const id = uuidv4();
+        promises.add(id, resolve, reject);
+        connection.send(constants.SFU_INTERNAL_API.REMOVE_MEMBER_FROM_CHAT, {id: chat.id, member: chat.member, internalMessageId: id});
+    });
+};
+
+
 /**
  * Create room
  *
@@ -326,8 +451,6 @@ const disconnect = function() {
         value.leaveRoom();
     }
     user = undefined;
-    pendingUserList = [];
-    pendingUserCalendar = [];
     connection.close();
     connection = ws.createConnection();
     state = SFU_STATE.DISCONNECTED;
@@ -341,6 +464,13 @@ sfu.getUserList = getUserList;
 sfu.getUserCalendar = getUserCalendar;
 sfu.addCalendarEvent = addCalendarEvent;
 sfu.removeCalendarEvent = removeCalendarEvent;
+sfu.getUserChats = getUserChats;
+sfu.loadChat = loadChat;
+sfu.createChat = createChat;
+sfu.deleteChat = deleteChat;
+sfu.renameChat = renameChat;
+sfu.addMemberToChat = addMemberToChat;
+sfu.removeMemberFromChat = removeMemberFromChat;
 sfu.room = room;
 
 

package/src/tests/sdk/sfu-extended.test.js

@@ -0,0 +1,151 @@
+const sfu = require("../../sdk/sfu-extended");
+const constants = require("../../sdk/constants");
+
+const SERVER = "ws://127.0.0.1:8080";
+const USER = "bob@flashphoner.com";
+const PASSWD = "123456";
+const CHAT_ID = "test-chat-id";
+const CHAT_NAME = "test-chat";
+const CHAT_NAME2 = "test-chat2";
+const USER2 = "alice@flashphoner.com";
+const MESSAGE_BODY = "This is a test message";
+const MEMBERS = [
+    "bob@flashphoner.com",
+    "alice@flashphoner.com",
+    "kiri@flashphoner.com"
+];
+
+beforeAll( async () => {
+    await sfu.connect({
+        url: SERVER,
+        username: USER,
+        password: PASSWD
+    });
+    const chats = await sfu.getUserChats();
+    if (chats) {
+        Object.entries(chats).map(async ([key, value]) => {
+            await sfu.deleteChat({id: value.id});
+        });
+    }
+});
+
+afterAll(() => {
+    return sfu.disconnect();
+});
+
+
+describe("connection", () => {
+    test("should connect to server", () => {
+        expect(sfu.state()).toBe(constants.SFU_STATE.AUTHENTICATED);
+    });
+});
+
+describe("contacts", () => {
+    test("should load user list", () => {
+        return sfu.getUserList();
+    });
+});
+
+describe("calendar", () => {
+    test("should load calendar", () => {
+        return sfu.getUserCalendar().then((calendar) => {
+            expect(calendar).toHaveProperty("events");
+        })
+    })
+});
+
+describe("chat", () => {
+    test("should create new chat", () => {
+        return sfu.createChat({
+            id: CHAT_ID,
+            name: CHAT_NAME
+        });
+    });
+    test("should load chats", () => {
+        return sfu.getUserChats().then((chats) => {
+            expect(chats).toBeTruthy();
+        });
+    });
+    test("should add new member", () => {
+        return sfu.addMemberToChat({
+            id: CHAT_ID,
+            member: USER2
+        });
+    });
+    test("should send a message", () => {
+        return sfu.sendMessage({
+            chatId: CHAT_ID,
+            body: MESSAGE_BODY
+        })
+    });
+    test("should load chat", () => {
+        return sfu.loadChat({
+            id: CHAT_ID
+        }).then((chat) => {
+            expect(chat.id).toBe(CHAT_ID);
+            expect(chat.name).toBe(CHAT_NAME);
+            expect(chat.members).toContain(USER);
+            expect(Array.isArray(chat.messages)).toBe(true);
+            expect(chat.messages.length).toBeGreaterThan(0);
+        });
+    });
+    test("should remove member", () => {
+        return sfu.removeMemberFromChat({
+            id: CHAT_ID,
+            member: USER2
+        });
+    });
+    test("should rename chat", () => {
+        return sfu.renameChat({
+            id: CHAT_ID,
+            name: CHAT_NAME2
+        });
+    });
+    test.skip("should receive message", (done) => {
+        sfu.on(constants.SFU_EVENT.MESSAGE, (msg) => {
+            done();
+        })
+        sfu.sendMessage({
+            chatId: CHAT_ID,
+            body: MESSAGE_BODY
+        });
+    });
+    test("should receive ACK message", (done) => {
+        sfu.on(constants.SFU_EVENT.MESSAGE_STATE, (state) => {
+            done();
+        })
+        sfu.sendMessage({
+            chatId: CHAT_ID,
+            body: MESSAGE_BODY
+        });
+    });
+    test("should create new chat without id", () => {
+        return sfu.createChat({
+            name: CHAT_NAME
+        });
+    });
+    test("should create new chat with member list", () => {
+        return sfu.createChat({
+            name: CHAT_NAME,
+            members: MEMBERS
+        });
+    });
+    test("should create new chat without name based on members", async () => {
+        const chat = await sfu.createChat({
+            members: MEMBERS
+        });
+        expect(chat.name).toBeTruthy();
+    });
+    test("should delete chat", () => {
+        return sfu.deleteChat({
+            id: CHAT_ID
+        });
+    });
+    test("should change name after member was added", async () => {
+        const chat = await sfu.createChat({});
+        expect(chat.name).toBeTruthy();
+        const name1 = chat.name;
+        const sameChat = await sfu.addMemberToChat({id: chat.id, member: USER2});
+        expect(sameChat.name !== name1).toBeTruthy();
+    });
+});