Use websocket notify

app/utils/NotifyApiClient.js

@@ -12,6 +12,10 @@ const notifyAvailable = () => {
         && $STM_Config.notify_service && $STM_Config.notify_service.host;
 };
 
+const notifyWsAvailable = () => {
+    return notifyAvailable() && $STM_Config.notify_service.host_ws
+}
+
 const notifyUrl = (pathname) => {
     return new URL(pathname, window.$STM_Config.notify_service.host).toString();
 };
@@ -36,6 +40,67 @@ function saveSession(response) {
     localStorage.setItem('X-Session', session);
 }
 
+async function connectNotifyWs() {
+    if (!window.notifyWs) {
+        window.notifyWsReq = { id: 0, requests: {}, callbacks: {} }
+        await new Promise((resolve, reject) => {
+            const notifyWs = new WebSocket($STM_Config.notify_service.host_ws)
+            window.notifyWs = notifyWs
+
+            notifyWs.addEventListener('open', () => {
+                notifyWs.isOpen = true
+                resolve()
+            })
+
+            notifyWs.addEventListener('сlose', () => {
+                if (!notifyWs.isOpen) {
+                    const err = new Error('notifyWs - cannot connect')
+                    reject(err)
+                }
+            })
+
+            notifyWs.addEventListener('message', (msg) => {
+                console.log('notifyWs message:', msg)
+                const data = JSON.parse(msg.data)
+                const id = data.id
+                const request = window.notifyWsReq.requests[id]
+                if (request) {
+                    if (data.err) {
+                        request.callback(new Error(data.err.code + ': ' + data.err.msg), data)
+                        return
+                    }
+                    request.callback(null, data.data)
+                } else if (!id && data.data && data.data.event) {
+                    const { event } = data.data
+                    const callback = window.notifyWsReq.callbacks[event]
+                    if (callback) {
+                        callback.callback(null, data.data)
+                    }
+                }
+            })
+        })
+    }
+}
+
+async function notifyWsSend(api, args, callback = null, eventCallback = null) {
+    await connectNotifyWs()
+    const id = window.notifyWsReq.id++
+    let msg = {
+        api,
+        args,
+        id
+    }
+    msg = JSON.stringify(msg)
+    if (callback) {
+        window.notifyWsReq.requests[id] = { callback }
+    }
+    if (eventCallback) {
+        const { event, callback } = eventCallback
+        window.notifyWsReq.callbacks[event] = { callback }
+    }
+    window.notifyWs.send(msg)
+}
+
 export function notifyApiLogin(account, authSession) {
     if (!notifyAvailable()) return;
     let request = Object.assign({}, request_base, {
@@ -71,6 +136,24 @@ export function getNotifications(account) {
     });
 }
 
+export async function getNotificationsWs(account) {
+    if (!notifyWsAvailable()) {
+        console.error('getNotificationsWs - no notify_service.host_ws in config?')
+        return null
+    }
+    return await new Promise(async (resolve, reject) => {
+        await notifyWsSend('counters', {
+            account
+        }, (err, res) => {
+            if (err) {
+                reject(err)
+                return
+            }
+            resolve(res.counters)
+        })
+    })
+}
+
 export function markNotificationRead(account, fields) {
     if (!notifyAvailable()) return Promise.resolve(null);
     let request = Object.assign({}, request_base, {method: 'put', mode: 'cors'});
@@ -84,6 +167,59 @@ export function markNotificationRead(account, fields) {
     });
 }
 
+export async function markNotificationReadWs(account, fields) {
+    if (!notifyWsAvailable()) return null
+    const xSession = notifySession()
+    const scopes = fields.join(',')
+    return await new Promise(async (resolve, reject) => {
+        await notifyWsSend('counters/read', {
+            account,
+            'X-Session': xSession,
+            scopes,
+        }, (err, res) => {
+            if (err) {
+                reject(err)
+                return
+            }
+            resolve(res.counters)
+        })
+    })
+}
+
+export async function counterSubscribeWs(account, callback) {
+    if (!notifyWsAvailable()) return null
+    const xSession = notifySession()
+    return await new Promise(async (resolve, reject) => {
+        await notifyWsSend('counters/subscribe', {
+            account,
+            'X-Session': xSession,
+        }, (err, res) => {
+            if (err) {
+                reject(err)
+                return
+            }
+            resolve(res)
+        }, callback)
+    })
+}
+
+export async function counterUnsubscribeWs(account) {
+    if (!notifyWsAvailable()) return null
+    const xSession = notifySession()
+    return await new Promise(async (resolve, reject) => {
+        await notifyWsSend('counters/unsubscribe', {
+            account,
+            'X-Session': xSession,
+        }, (err, res) => {
+            if (err) {
+                reject(err)
+                return
+            }
+            resolve(res)
+        })
+    })
+}
+
 export async function notificationSubscribe(account, scopes = 'message', sidKey = '__subscriber_id') {
     if (!notifyAvailable()) return;
     if (window[sidKey]) return;
@@ -172,7 +308,11 @@ export async function notificationTake(account, removeTaskIds, forEach, sidKey =
 
 if (process.env.BROWSER) {
     window.getNotifications = getNotifications;
+    window.getNotificationsWs = getNotificationsWs
     window.markNotificationRead = markNotificationRead;
+    window.markNotificationReadWs = markNotificationReadWs
+    window.counterSubscribeWs = counterSubscribeWs
+    window.counterUnsubscribeWs = counterUnsubscribeWs
     window.notificationSubscribe = notificationSubscribe;
     window.notificationUnsubscribe = notificationUnsubscribe;
     window.notificationTake = notificationTake;