update sockets, account, auth

src/composables/http.ts

@@ -1,10 +1,8 @@
 
 import axios, { AxiosRequestConfig } from 'axios';
+import {config} from "@/config";
 
-const preFix = '/api';
-
-const baseURL = "http://127.0.0.1:3000" + preFix;
-
+const baseURL = config.BUSINESS_URL + config.BUSINESS_PREFIX;
 
 interface Request {
     endpoint: string;
@@ -12,7 +10,6 @@ interface Request {
     config?: Record<string, any>;
 }
 
-
 const makeQuery = (reqQuery: Record<string, any>) => {
 
     let result = '';

src/composables/ipcHandler.ts

@@ -0,0 +1,50 @@
+
+import { ipcMain, IpcMainInvokeEvent } from "electron";
+
+export class IpcHandler<InputType, ReturnType> implements IIpcHandler<InputType, ReturnType> {
+
+  readonly channel: string;
+
+  readonly _handlerCallback: IpcHandlerCallback<InputType, ReturnType>;
+
+  constructor(options: {
+      channel: string;
+      handlerCallback: IpcHandlerCallback<InputType, ReturnType>;
+  }) {
+    this.channel = options.channel;
+    this._handlerCallback = options.handlerCallback;
+  }
+
+  handle() {
+      ipcMain.handle(this.channel, this._onInvoke);
+  }
+
+  remove() {
+      ipcMain.removeHandler(this.channel);
+  }
+
+  private async _onInvoke(_e: IpcMainInvokeEvent, payload?: string | null): Promise<Error | ReturnType> {
+
+      return new Promise(async (resolve, reject) => {
+
+          console.log(`[IPC]:${this.channel}`);
+
+          try {
+
+              const params = payload ? JSON.parse(payload) : null;
+
+              const res = await this._handlerCallback(params);
+
+              resolve(res as unknown as ReturnType);
+
+          } catch(e) {
+              console.log(`[IPC]:${this.channel}`, e);
+              reject(e);
+          }
+      });
+  }
+
+}
+
+
+

src/composables/json.ts

@@ -1,9 +1,13 @@
+
+import {config} from "@/config";
+import fs from 'fs';
+
 export const saveToJson = (fileName: string, data: any) => {
 
-    fs.writeFile(configPath + fileName, JSON.stringify(data), (err) => {
+    fs.writeFile(config.configPath + fileName, JSON.stringify(data), (err) => {
         if (err) {
             console.log("Error when saving to json.")
-        }      
+        }
     })
 
-}
+}

src/composables/store.ts

@@ -0,0 +1,19 @@
+const Store = require('electron-store');
+
+const schema = {
+	key: {
+		type: 'string',
+	},
+};
+
+const store = new Store({
+    schema,
+    encryptionKey: "super user test"
+});
+
+export const getToken = (): string | undefined => (store.get("token"));
+
+export const clearToken = (): void => (store.delete("token"));
+
+export const setToken = (token: string): void => (store.set('token', token));
+

src/composables/websockets.ts

@@ -3,9 +3,18 @@
 
 import WebSocket from 'ws';
 
-export default function useWebSockets(onMessageCallback: (s: string) => void) {
 
-    let socket: WebSocket | null = null;
+const _connectionCheckTimeout = 4000;
+const _reconnectTimeout = 1000;
+let _connectionCheckInterval: ReturnType<typeof setTimeout>;
+
+
+export default function useWebSockets(
+    messageCallback: (message: string) => void,
+    connectionStatusCallback: (alive: boolean) => void,
+) {
+
+    let socket: WebSocket;
 
     const send = async (data: Record<string, any>): Promise<boolean> => {
         return new Promise((resolve, reject) => {
@@ -21,30 +30,52 @@ export default function useWebSockets(onMessageCallback: (s: string) => void) {
 
     const connect = (socketUrl: string, secret: string) => {
 
+        // avoid setting multiple interval;
+        if (_connectionCheckInterval) clearInterval(_connectionCheckInterval);
+
         /* create a new socket */
-        socket = new WebSocket(socketUrl)
+        socket = new WebSocket(socketUrl);
 
         /* add event listeners */
-
         socket.on("open", () => {
-            if (socket)
+
             socket.send(secret);
+
+            // ping server
+            _connectionCheckInterval = setInterval(() => {
+
+                socket.ping(null, true, (e: Error) => {
+                    if (e) {
+                        socket.close();
+                        connectionStatusCallback(false);
+                        setTimeout(() => connect(socketUrl, secret), _reconnectTimeout);
+                    }
+                });
+
+            }, _connectionCheckTimeout);
+
         });
 
         socket.on("message", (event: WebSocket.MessageEvent) => {
-            onMessageCallback(event.data.toString())
+            messageCallback(event.data.toString())
         });
 
-        socket.on("close", () => {
-            return
+        socket.on("close", (event: WebSocket.CloseEvent) => {
+            connectionStatusCallback(false);
+            clearInterval(_connectionCheckInterval);
+            if (!event.wasClean) {
+                setTimeout(() => connect(socketUrl, secret), _reconnectTimeout);
+            }
+
         });
 
+        socket.on("pong", () => connectionStatusCallback(true));
+
     }
 
     const close = () => {
         if (socket) {
             socket.close();
-            socket = null;
         }
     }