Merge pull request #2547 from RedisInsight/feature/RI-4723-open_RI_from_SM

Feature/ri 4723 open ri from sm

Author: mariasergeenko

redisinsight/desktop/app.ts

@@ -16,12 +16,15 @@ import {
 } from 'desktopSrc/lib'
 import { wrapErrorMessageSensitiveData } from 'desktopSrc/utils'
 import { configMain as config } from 'desktopSrc/config'
+import { deepLinkHandler, deepLinkWindowHandler } from 'desktopSrc/lib/app/deep-link.handlers'
 
 if (!config.isProduction) {
   const sourceMapSupport = require('source-map-support')
   sourceMapSupport.install()
 }
 
+let deepLink: undefined | string
+
 const init = async () => {
   await launchApiServer()
   initLogging()
@@ -45,23 +48,42 @@ const init = async () => {
   try {
     await app.whenReady()
 
-    // todo: create and move to some on app ready handler
+    deepLink = process.argv?.[1] || deepLink
+
     // deep linking
     // register our application to handle custom protocol
     if (process.defaultApp) {
-      if (process.argv.length >= 2) {
-        app.setAsDefaultProtocolClient(config.schema, process.execPath, [path.resolve(process.argv[1])])
+      if (deepLink) {
+        app.setAsDefaultProtocolClient(config.schema, process.execPath, [path.resolve(deepLink)])
       }
     } else {
       app.setAsDefaultProtocolClient(config.schema)
     }
 
     const splashWindow = await windowFactory(WindowType.Splash)
-    await windowFactory(WindowType.Main, splashWindow)
+
+    let parsedDeepLink
+
+    if (deepLink) {
+      parsedDeepLink = await deepLinkHandler(deepLink)
+    }
+
+    await windowFactory(WindowType.Main, splashWindow, { parsedDeepLink })
   } catch (_err) {
     const error = _err as Error
     console.log(wrapErrorMessageSensitiveData(error))
   }
 }
 
+// deep link open (darwin)
+// if app is not ready then we store url and continue in init function
+app.on('open-url', async (event, url) => {
+  event.preventDefault()
+
+  deepLink = url
+  if (app.isReady()) {
+    await deepLinkWindowHandler(await deepLinkHandler(url))
+  }
+})
+
 export default init

redisinsight/desktop/preload.ts

@@ -22,6 +22,9 @@ contextBridge.exposeInMainWorld('app', {
   cloudOauthCallback: ((connected: any) => {
     ipcRenderer.on(IpcOnEvent.cloudOauthCallback, connected)
   }),
+  deepLinkAction: ((parsedDeepLink: any) => {
+    ipcRenderer.on(IpcOnEvent.deepLinkAction, parsedDeepLink)
+  }),
   ipc: ipcHandler,
   config: {
     apiPort: config.apiPort

redisinsight/desktop/src/lib/app/app.handlers.ts

@@ -1,7 +1,7 @@
 import { app } from 'electron'
 import log from 'electron-log'
-import { getBackendGracefulShutdown, WindowType, getWindows, windowFactory, windows } from 'desktopSrc/lib'
-import { deepLinkHandler } from 'desktopSrc/lib/app/deep-link.handlers'
+import { getBackendGracefulShutdown, WindowType, getWindows, windowFactory } from 'desktopSrc/lib'
+import { deepLinkHandler, deepLinkWindowHandler } from 'desktopSrc/lib/app/deep-link.handlers'
 
 export const initAppHandlers = () => {
   app.on('activate', () => {
@@ -44,27 +44,8 @@ export const initAppHandlers = () => {
     }
   })
 
-  // deep link open (unix)
-  app.on('open-url', async (event, url) => {
-    event.preventDefault()
-    // todo: implement url handler to map url to a proper function
-    await deepLinkHandler(url)
-
-    if (windows.size) {
-      const win = windows.values().next().value
-      if (win.isMinimized()) win.restore()
-      win.focus()
-    }
-  })
-
-  // deep link open (win)
+  // deep link open (win + linux)
   app.on('second-instance', async (_event, commandLine) => {
-    await deepLinkHandler(commandLine?.pop())
-    // Someone tried to run a second instance, we should focus our window.
-    if (windows.size) {
-      const win = windows.values().next().value
-      if (win.isMinimized()) win.restore()
-      win.focus()
-    }
+    await deepLinkWindowHandler(await deepLinkHandler(commandLine?.pop()))
   })
 }

redisinsight/desktop/src/lib/app/deep-link.handlers.ts

@@ -1,23 +1,54 @@
 import log from 'electron-log'
 import { parse } from 'url'
 import {
-  cloudDeepLinkHandler
+  cloudDeepLinkHandler, focusWindow, getWindows, windowFactory, WindowType
 } from 'desktopSrc/lib'
 import { wrapErrorMessageSensitiveData } from 'desktopSrc/utils'
+import { IpcOnEvent } from 'uiSrc/electron/constants'
 
-export const deepLinkHandler = async (from?: string) => {
-  if (!from) return
-  try {
-    const url = parse(from, true)
+export interface IParsedDeepLink {
+  initialPage?: string
+  target?: string
+  from?: string
+}
+
+export const deepLinkHandler = async (from?: string): Promise<undefined | IParsedDeepLink> => {
+  if (from) {
+    try {
+      const url = parse(from, true)
+      switch (url?.hostname) {
+        case 'cloud':
+          await cloudDeepLinkHandler(url)
+          break
+        default:
+          return {
+            from: encodeURIComponent(from),
+            target: url.query?.target || '_self',
+            initialPage: url.query?.initialPage,
+          } as IParsedDeepLink
+      }
+    } catch (e) {
+      log.error(wrapErrorMessageSensitiveData(e as Error))
+    }
+  }
+
+  return undefined
+}
+
+export const deepLinkWindowHandler = async (parsedDeepLink?: IParsedDeepLink) => {
+  // tbd: implement mechanism to find current window
+  const [currentWindow] = getWindows().values()
 
-    switch (url?.hostname) {
-      case 'cloud':
-        await cloudDeepLinkHandler(url)
-        break
-      default:
-        log.warn('Unknown deep link hostname', url?.hostname)
+  if (parsedDeepLink) {
+    if (parsedDeepLink?.target === '_blank') {
+      await windowFactory(WindowType.Main, null, { parsedDeepLink })
+    } else if (currentWindow) {
+      currentWindow?.webContents.send(IpcOnEvent.deepLinkAction, parsedDeepLink)
+      focusWindow(currentWindow)
+    } else {
+      await windowFactory(WindowType.Main, null, { parsedDeepLink })
     }
-  } catch (e) {
-    log.error(wrapErrorMessageSensitiveData(e as Error))
+  } else if (currentWindow) {
+    focusWindow(currentWindow)
   }
 }

redisinsight/desktop/src/lib/app/index.ts

@@ -1,3 +1,4 @@
+import { initWindowIPCHandlers } from 'desktopSrc/lib/window'
 import { initAppHandlers } from './app.handlers'
 import { initDialogHandlers } from './dialog.handlers'
 import { initIPCHandlers } from './ipc.handlers'
@@ -6,4 +7,6 @@ export const initElectronHandlers = () => {
   initAppHandlers()
   initIPCHandlers()
   initDialogHandlers()
+
+  initWindowIPCHandlers()
 }

redisinsight/desktop/src/lib/window/browserWindow.ts

@@ -2,13 +2,18 @@ import contextMenu from 'electron-context-menu'
 import { BrowserWindow } from 'electron'
 import { v4 as uuidv4 } from 'uuid'
 
+import { IParsedDeepLink } from 'desktopSrc/lib/app/deep-link.handlers'
 import { configMain as config } from 'desktopSrc/config'
 import { updateTray } from 'desktopSrc/lib'
 import { resolveHtmlPath } from 'desktopSrc/utils'
 import { initWindowHandlers } from './window.handlers'
 
 export const windows = new Map<string, BrowserWindow>()
 export const getWindows = () => windows
+export const focusWindow = (win: BrowserWindow) => {
+  if (win.isMinimized()) win.restore()
+  win.focus()
+}
 
 export enum WindowType {
   Splash = 'splash',
@@ -54,7 +59,7 @@ export const createWindow = async ({
     return newWindow
   }
 
-  newWindow.loadURL(resolveHtmlPath(htmlFileName))
+  newWindow.loadURL(resolveHtmlPath(htmlFileName, options?.parsedDeepLink))
 
   initWindowHandlers(newWindow, prevWindow, windows, id)
 
@@ -69,7 +74,8 @@ export const createWindow = async ({
 
 export const windowFactory = async (
   windowType: WindowType,
-  prevWindow: BrowserWindow | null = null
+  prevWindow: BrowserWindow | null = null,
+  options?: { parsedDeepLink?: IParsedDeepLink }
 ): Promise<BrowserWindow> => {
   switch (windowType) {
     case WindowType.Splash:
@@ -88,6 +94,7 @@ export const windowFactory = async (
         htmlFileName: 'index.html',
         windowType,
         options: {
+          ...options,
           ...config.mainWindow,
           preloadPath: config.preloadPath
         }

redisinsight/desktop/src/lib/window/window.handlers.ts

@@ -1,13 +1,16 @@
-import { BrowserWindow, app, shell } from 'electron'
+import { BrowserWindow, app, shell, ipcMain } from 'electron'
 import {
   MenuBuilder,
   getDisplayAppInTrayValue,
   getIsQuiting,
   getTray,
   getTrayInstance,
-  electronStore
+  electronStore,
+  windowFactory,
+  WindowType,
 } from 'desktopSrc/lib'
-import { ElectronStorageItem, IpcOnEvent } from 'uiSrc/electron/constants'
+import { IpcInvokeEvent, ElectronStorageItem, IpcOnEvent } from 'uiSrc/electron/constants'
+import { Pages } from 'uiSrc/constants/pages'
 
 export const initWindowHandlers = (
   newWindow: BrowserWindow,
@@ -92,3 +95,9 @@ export const initWindowHandlers = (
     return { action: 'deny' }
   })
 }
+
+export const initWindowIPCHandlers = () => {
+  ipcMain.handle(IpcInvokeEvent.windowOpen, async (_event, { location }) => {
+    await windowFactory(WindowType.Main, null, { parsedDeepLink: { initialPage: location } })
+  })
+}

redisinsight/desktop/src/utils/resolveHtmlPath.ts

@@ -1,14 +1,36 @@
 /* eslint import/prefer-default-export: off */
-import { URL } from 'url'
+import { URL, URLSearchParams } from 'url'
 import path from 'path'
 import { configMain as config } from 'desktopSrc/config'
+import { IParsedDeepLink } from 'desktopSrc/lib/app/deep-link.handlers'
 
-export const resolveHtmlPath = (htmlFileName: string) => {
+export const resolveHtmlPath = (htmlFileName: string, parsedDeepLink?: IParsedDeepLink) => {
   if (config.isDevelopment) {
     const port = process.env.PORT || 1212
     const url = new URL(`http://localhost:${port}`)
     url.pathname = htmlFileName
     return url.href
   }
-  return `file://${path.resolve(__dirname, '../renderer/', htmlFileName)}`
+
+  let resolved = `file://${path.resolve(__dirname, '../renderer/', htmlFileName)}#/`
+
+  if (parsedDeepLink) {
+    try {
+      if (parsedDeepLink.initialPage) {
+        const initialPage = parsedDeepLink.initialPage.slice(+parsedDeepLink.initialPage.startsWith('/'))
+        resolved += initialPage
+      }
+
+      const queryParameters = new URLSearchParams([
+        ['from', parsedDeepLink.from || ''],
+        ['target', parsedDeepLink.target || ''],
+      ])
+
+      resolved += `${resolved.indexOf('?') !== -1 ? '&' : '?'}${queryParameters.toString()}`
+    } catch (e) {
+      // todo: log error
+    }
+  }
+
+  return resolved
 }

redisinsight/ui/src/components/config/Config.spec.tsx

@@ -69,6 +69,7 @@ describe('Config', () => {
       getWBTutorials(),
       getFeatureFlags(),
       getUserConfigSettings(),
+      setSettingsPopupState(false)
     ]
     expect(store.getActions()).toEqual([...afterRenderActions])
   })

redisinsight/ui/src/components/config/Config.tsx

@@ -141,9 +141,7 @@ const Config = () => {
     const specConsents = spec?.agreements
     const appliedConsents = config?.agreements
 
-    if (isDifferentConsentsExists(specConsents, appliedConsents)) {
-      dispatch(setSettingsPopupState(true))
-    }
+    dispatch(setSettingsPopupState(isDifferentConsentsExists(specConsents, appliedConsents)))
   }
 
   return null