Refactor socket, network_monitor, ...

Author: mohammad-deriv

src/javascript/_common/base/client_base.js

@@ -5,7 +5,6 @@ const LocalStore       = require('../storage').LocalStore;
 const State            = require('../storage').State;
 const getPropertyValue = require('../utility').getPropertyValue;
 const isEmptyObject    = require('../utility').isEmptyObject;
-const BinarySocket     = require('../../app/base/socket');
 
 const ClientBase = (() => {
     const storage_key = 'client.accounts';
@@ -172,13 +171,6 @@ const ClientBase = (() => {
         return true;
     };
 
-    const sendLogoutRequest = (show_login_page) => {
-        if (show_login_page) {
-            sessionStorage.setItem('showLoginPage', 1);
-        }
-        BinarySocket.send({ logout: '1' });
-    };
-
     const currentLandingCompany = () => {
         const landing_company_response = State.getResponse('landing_company') || {};
         const this_shortcode           = get('landing_company_shortcode');
@@ -302,7 +294,6 @@ const ClientBase = (() => {
         shouldAcceptTnc,
         clearAllAccounts,
         setNewAccount,
-        sendLogoutRequest,
         currentLandingCompany,
         shouldCompleteTax,
         getMT5AccountType,

src/javascript/_common/base/network_monitor_base.js

@@ -0,0 +1,116 @@
+const BinarySocket = require('./socket_base');
+
+/*
+ * Monitors the network status and initialises the WebSocket connection
+ * 1. online : check the WS status (init/send: blink after timeout, open/message: online)
+ * 2. offline: it is offline
+ */
+const NetworkMonitorBase = (() => {
+    const status_config = {
+        online  : { class: 'online',  tooltip: 'Online' },
+        offline : { class: 'offline', tooltip: 'Offline' },
+        blinking: { class: 'blinker', tooltip: 'Connecting to server' },
+    };
+    const pendings = {};
+    const pending_keys = {
+        ws_init   : 'ws_init',
+        ws_request: 'ws_request',
+    };
+    const pending_timeouts = {
+        [pending_keys.ws_init]   : 5000,
+        [pending_keys.ws_request]: 10000,
+    };
+
+    let ws_config,
+        network_status,
+        updateUI;
+
+    const init = (socket_general_functions, fncUpdateUI) => {
+        updateUI  = fncUpdateUI;
+        ws_config = Object.assign({ wsEvent, isOnline }, socket_general_functions);
+
+        if ('onLine' in navigator) {
+            window.addEventListener('online',  setStatus);
+            window.addEventListener('offline', setStatus);
+        } else { // if not supported, default to online and fallback to WS checks
+            navigator.onLine = true;
+        }
+
+        if (isOnline()) {
+            BinarySocket.init(ws_config);
+        }
+
+        setStatus(isOnline() ? 'online' : 'offline');
+    };
+
+    const isOnline = () => navigator.onLine;
+
+    const wsReconnect = () => {
+        if (isOnline() && BinarySocket.hasReadyState(2, 3)) { // CLOSING or CLOSED
+            BinarySocket.init(ws_config);
+        } else {
+            BinarySocket.send({ ping: 1 }); // trigger a request to get stable status sooner
+        }
+    };
+
+    const setStatus = (status) => {
+        if (!isOnline()) {
+            network_status = 'offline';
+        } else if (pending_keys[status] || network_status === 'offline') {
+            network_status = 'blinking';
+            wsReconnect();
+        } else {
+            network_status = 'online';
+        }
+
+        if (typeof updateUI === 'function') {
+            updateUI(status_config[network_status], isOnline());
+        }
+    };
+
+    const ws_events_map = {
+        init   : () => setPending(pending_keys.ws_init),
+        open   : () => clearPendings(pending_keys.ws_init),
+        send   : () => setPending(pending_keys.ws_request),
+        message: () => clearPendings(),
+        close  : () => setPending(pending_keys.ws_init),
+    };
+
+    const wsEvent = (event) => {
+        if (typeof ws_events_map[event] === 'function') {
+            ws_events_map[event]();
+        }
+    };
+
+    const setPending = (key) => {
+        if (!pendings[key]) {
+            pendings[key] = setTimeout(() => {
+                pendings[key] = undefined;
+                setStatus(key);
+            }, pending_timeouts[key]);
+        }
+    };
+
+    const clearPendings = (key) => {
+        const clear = (k) => {
+            clearTimeout(pendings[k]);
+            pendings[k] = undefined;
+            if (k === pending_keys.ws_request) {
+                setStatus('online');
+            }
+        };
+
+        if (key) {
+            clear(key);
+        } else {
+            Object.keys(pendings).forEach(clear);
+        }
+    };
+
+    return {
+        init,
+        wsEvent,
+    };
+})();
+
+module.exports = NetworkMonitorBase;