Heartbeat (#35)

* fix: fixed error during logon when the user_data contain connection=false that resolve in an infinite loop of restart app;
* restored heathbeat API call after login;
* fix add connection check

Co-authored-by: Edoardo Spadoni <[email protected]>

Author: therockerline

package-lock.json

@@ -45,7 +45,7 @@
     "@fortawesome/react-fontawesome": "^0.2.0",
     "@headlessui/react": "^1.7.18",
     "@hookform/resolvers": "^3.3.4",
-    "@nethesis/phone-island": "^0.8.18",
+    "@nethesis/phone-island": "^0.8.20",
     "@tailwindcss/forms": "^0.5.7",
     "@types/lodash": "^4.14.202",
     "@types/node": "^18.19.9",

package.json

@@ -3,7 +3,7 @@ import fs, { access } from 'fs'
 import { Account, AuthAppData, ConfigFile } from '@shared/types'
 import { log } from '@shared/utils/logger'
 import { safeStorage } from 'electron'
-import { store, useStoreState } from '@/lib/mainStore'
+import { store } from '@/lib/mainStore'
 import { useNethVoiceAPI } from '@shared/useNethVoiceAPI'
 import { useLogin } from '@shared/useLogin'
 import { NetworkController } from './NetworkController'
@@ -128,16 +128,18 @@ export class AccountController {
 
 
   updateTheme(theme: any) {
-    const account = store.store.account
-    store.set('theme', theme)
-    if (account) {
-      account.theme = theme
+    if (store.store) {
+      const account = store.store.account
+      store.set('theme', theme)
+      if (account) {
+        account.theme = theme
 
-      store.set('account', account)
-      const auth = store.store.auth
+        store.set('account', account)
+        const auth = store.store.auth
 
-      auth!.availableAccounts[getAccountUID(account)] = account
-      store.set('auth', auth)
+        auth!.availableAccounts[getAccountUID(account)] = account
+        store.set('auth', auth)
+      }
     }
   }
 

src/main/classes/controllers/AccountController.ts

@@ -11,7 +11,7 @@ import { NethLinkController } from '@/classes/controllers/NethLinkController'
 import { AppController } from '@/classes/controllers/AppController'
 import moment from 'moment'
 import { store } from './mainStore'
-import { debouncer, getPageFromQuery, isDev } from '@shared/utils/utils'
+import { debouncer, getAccountUID, getPageFromQuery } from '@shared/utils/utils'
 import { NetworkController } from '@/classes/controllers/NetworkController'
 import { useLogin } from '@shared/useLogin'
 import { PhoneIslandWindow } from '@/classes/windows'
@@ -155,8 +155,13 @@ export function registerIpcEvents() {
 
 
   ipcMain.on(IPC_EVENTS.UPDATE_CONNECTION_STATE, (event, isOnline) => {
-    log('CONNECTION STATE', isOnline, event.sender.getTitle())
-    store.set('connection', isOnline)
+    if (store.store) {
+      log('CONNECTION STATE', isOnline)
+      store.set('connection', isOnline)
+      if (!store.store.account) {
+        store.saveToDisk()
+      }
+    }
   });
 
   ipcMain.on(IPC_EVENTS.REQUEST_SHARED_STATE, (event) => {
@@ -189,6 +194,15 @@ export function registerIpcEvents() {
   ipcMain.on(IPC_EVENTS.LOGIN_WINDOW_RESIZE, (event, h) => {
     LoginController.instance.resize(h)
   })
+  ipcMain.on(IPC_EVENTS.DELETE_ACCOUNT, (event, account: Account) => {
+    log('DELETE ACCOUNT', account)
+    const accountUID = getAccountUID(account)
+    const newStore = Object.assign({}, store.store)
+    delete newStore.auth!.availableAccounts[accountUID]
+    store.set('auth', newStore.auth, true)
+    store.updateStore(newStore, 'delete account')
+    store.saveToDisk(true)
+  })
   ipcMain.on(IPC_EVENTS.HIDE_LOGIN_WINDOW, () => {
     LoginController.instance.hide()
   })

src/main/lib/ipcEvents.ts

@@ -1,4 +1,4 @@
-import { LocalStorageData } from '@shared/types';
+import { Account, LocalStorageData } from '@shared/types';
 import { app, ipcMain } from 'electron';
 import path from 'path';
 import fs from 'fs';
@@ -7,12 +7,27 @@ import { log } from '@shared/utils/logger';
 import { difference, differenceBy, differenceWith } from 'lodash';
 
 const USER_DATA_PATH = path.join(app.getPath("userData"), 'user_data.json');
+const AVAILABLE_USER_DATA_PATH = path.join(app.getPath("userData"), 'available_user_data.json');
 
 class Store<T> {
 
+
   constructor() {
-    if (!fs.existsSync(USER_DATA_PATH)) {
-      fs.writeFileSync(USER_DATA_PATH, JSON.stringify({}))
+    if (!fs.existsSync(USER_DATA_PATH) || !fs.existsSync(AVAILABLE_USER_DATA_PATH)) {
+      if (!fs.existsSync(AVAILABLE_USER_DATA_PATH)) {
+        if (!fs.existsSync(USER_DATA_PATH)) {
+          fs.writeFileSync(AVAILABLE_USER_DATA_PATH, JSON.stringify({}))
+        } else {
+          const data = fs.readFileSync(USER_DATA_PATH, 'utf-8');
+          const retrivedStore: LocalStorageData = JSON.parse(data);
+          if (retrivedStore.auth?.availableAccounts) {
+            fs.writeFileSync(AVAILABLE_USER_DATA_PATH, JSON.stringify(retrivedStore.auth!.availableAccounts))
+          } else {
+            fs.writeFileSync(AVAILABLE_USER_DATA_PATH, JSON.stringify({}))
+          }
+        }
+      }
+      !fs.existsSync(USER_DATA_PATH) && fs.writeFileSync(USER_DATA_PATH, JSON.stringify({}))
     } else {
       this.store = this.getFromDisk()
     }
@@ -24,31 +39,47 @@ class Store<T> {
     return this.store[selector]
   }
 
-  set(selector: keyof T, value: any) {
+  set(selector: keyof T, value: any, force: boolean = false) {
     const o = Object.assign({}, this.store)
     o[selector] = value
     const diff = difference(Object.values(o), Object.values(this.store as any))
-    if (diff.length > 0) {
+    log({ diff })
+    if (diff.length > 0 || force) {
       this.store = o
       ipcMain.emit(IPC_EVENTS.UPDATE_SHARED_STATE, undefined, this.store, 'main', selector)
     }
   }
 
   updateStore(newState: T, from: string) {
-    const diff = difference(Object.values(newState as any), Object.values(this.store as any))
-    if (diff.length > 0) {
+    const diff = difference(Object.values(newState as any || {}), Object.values(this.store as any || {}))
+    if (diff.length > 0 || this.store === undefined) {
       this.store = Object.assign({}, newState)
     }
   }
 
-  saveToDisk() {
+  saveToDisk(forceSave: boolean = false) {
+    const availableUserData = (this.store as LocalStorageData).auth?.availableAccounts
     fs.writeFileSync(USER_DATA_PATH, JSON.stringify(this.store));
+    if (Object.keys(availableUserData || {}).length > 0 || forceSave) {
+      fs.writeFileSync(AVAILABLE_USER_DATA_PATH, JSON.stringify(availableUserData));
+    }
+  }
+
+  getAvailableFromDisk(): { [accountUID: string]: Account; } {
+    if (fs.existsSync(AVAILABLE_USER_DATA_PATH)) {
+      const availableUserData = fs.readFileSync(AVAILABLE_USER_DATA_PATH, 'utf-8');
+      return JSON.parse(availableUserData)
+    }
+    return {}
   }
 
   getFromDisk() {
     try {
       const data = fs.readFileSync(USER_DATA_PATH, 'utf-8');
-      return JSON.parse(data);
+      const availableUserData = fs.readFileSync(AVAILABLE_USER_DATA_PATH, 'utf-8');
+      const retrivedStore = JSON.parse(data);
+      (retrivedStore as LocalStorageData).auth!.availableAccounts = JSON.parse(availableUserData)
+      return retrivedStore
     } catch (error) {
       log('Error retrieving user data', error);
       // you may want to propagate the error, up to you
@@ -58,21 +89,6 @@ class Store<T> {
 }
 
 export const store: Store<LocalStorageData> = new Store<LocalStorageData>()
-export function useStoreState<T>(selector: keyof LocalStorageData): [T | undefined, (arg0: T | ((ex: T) => T | undefined) | undefined) => void] {
-
-  const setter = (arg0: (T | undefined) | ((ex: T) => T | undefined)) => {
-    let v: T | undefined = arg0 as (T | undefined)
-    if (typeof arg0 === 'function') {
-      v = (arg0 as (ex: T | undefined) => T | undefined)(store.store[selector] as T | undefined)
-    }
-    store.set(selector, v)
-  }
-
-  return [
-    store.get(selector) as T | undefined,
-    setter
-  ]
-}