implemented on-click and on-receive notification rendering

Author: tomcat323

packages/core/src/notifications/controller.ts

@@ -42,7 +42,7 @@ export class NotificationsController {
 
     constructor(
         private readonly notificationsNode: NotificationsNode,
-        private readonly fetcher: NotificationFetcher = new RemoteFetcher()
+        private readonly fetcher: NotificationFetcher = new LocalFetcher()
     ) {
         if (!NotificationsController.#instance) {
             // Register on first creation only.
@@ -63,6 +63,7 @@ export class NotificationsController {
     }
 
     public pollForEmergencies(ruleEngine: RuleEngine) {
+        getLogger().info('polling .....')
         return this.poll(ruleEngine, 'emergency')
     }
 
@@ -121,8 +122,25 @@ export class NotificationsController {
             getLogger('notifications').verbose('No new notifications for category: %s', category)
             return
         }
-
-        getLogger('notifications').verbose('ETAG has changed for notifications category: %s', category)
+        // Parse the notifications
+        const newPayload = JSON.parse(response.content)
+        const newNotifications = newPayload.notifications ?? []
+
+        // Get the current notifications
+        const currentNotifications = this.state[category].payload?.notifications ?? []
+        const currentNotificationIds = new Set(currentNotifications.map((n: any) => n.id))
+
+        // Compare and find if there's any notifications newly added
+        const addedNotifications = newNotifications.filter((n: any) => !currentNotificationIds.has(n.id))
+
+        if (addedNotifications.length > 0) {
+            getLogger('notifications').info(
+                'New notifications received for category %s, ids: %s',
+                category,
+                addedNotifications.map((n: any) => n.id).join(', ')
+            )
+            await this.onReceiveNotifications(addedNotifications)
+        }
 
         this.state[category].payload = JSON.parse(response.content)
         this.state[category].eTag = response.eTag
@@ -136,6 +154,23 @@ export class NotificationsController {
         )
     }
 
+    private async onReceiveNotifications(notifications: ToolkitNotification[]) {
+        for (const notification of notifications) {
+            switch (notification.uiRenderInstructions.onRecieve) {
+                case 'modal':
+                    // Handle modal case
+                    void this.notificationsNode.renderModal(notification)
+                    break
+                case 'toast':
+                    // toast case, no user input needed
+                    void vscode.window.showInformationMessage(
+                        notification.uiRenderInstructions.content['en-US'].descriptionPreview ??
+                            notification.uiRenderInstructions.content['en-US'].title
+                    )
+                    break
+            }
+        }
+    }
     /**
      * Write the latest memory state to global state.
      */

packages/core/src/notifications/panelNode.ts

@@ -11,6 +11,10 @@ import { contextKey, setContext } from '../shared/vscode/setContext'
 import { NotificationType, ToolkitNotification } from './types'
 import { ToolkitError } from '../shared/errors'
 import { isAmazonQ } from '../shared/extensionUtilities'
+import { getLogger } from '../shared/logger/logger'
+import { tempDirPath } from '../shared/filesystemUtilities'
+import path from 'path'
+import fs from '../shared/fs/fs'
 
 /**
  * Controls the "Notifications" side panel/tree in each extension. It takes purely UX actions
@@ -129,12 +133,105 @@ export class NotificationsNode implements TreeNode {
      *
      * TODO: implement more rendering possibilites.
      */
-    private async openNotification(notification: ToolkitNotification) {
-        await vscode.window.showTextDocument(
-            await vscode.workspace.openTextDocument({
-                content: notification.uiRenderInstructions.content['en-US'].description,
-            })
+    public async openNotification(notification: ToolkitNotification) {
+        switch (notification.uiRenderInstructions.onClick.type) {
+            case 'modal':
+                // Handle modal case
+                await this.renderModal(notification)
+                break
+            case 'openUrl':
+                if (!notification.uiRenderInstructions.onClick.url) {
+                    throw new ToolkitError('No url provided for onclick open url')
+                }
+                // Handle openUrl case
+                await vscode.env.openExternal(vscode.Uri.parse(notification.uiRenderInstructions.onClick.url))
+                break
+            case 'openTextDocument':
+                // Handle openTextDocument case
+                await this.showReadonlyTextDocument(notification.uiRenderInstructions.content['en-US'].description)
+                break
+        }
+    }
+
+    /**
+     * Shows a read only txt file for the contect of notification on a side column
+     * It's read-only so that the "save" option doesn't appear when user closes the notification
+     */
+    private async showReadonlyTextDocument(content: string): Promise<void> {
+        getLogger('notifications').info('showing txt document ... ')
+        try {
+            const tempFilePath = path.join(tempDirPath, 'AWSToolkitNotifications.txt')
+
+            if (await fs.existsFile(tempFilePath)) {
+                // If file exist, make sure it has write permission (0o644)
+                await fs.chmod(tempFilePath, 0o644)
+            }
+
+            await fs.writeFile(tempFilePath, content)
+
+            // Set the file permissions to read-only (0o444)
+            await fs.chmod(tempFilePath, 0o444)
+
+            // Now, open the document
+            const document = await vscode.workspace.openTextDocument(tempFilePath)
+
+            const options: vscode.TextDocumentShowOptions = {
+                viewColumn: vscode.ViewColumn.Beside,
+                preserveFocus: true,
+                preview: true,
+            }
+
+            await vscode.window.showTextDocument(document, options)
+        } catch (error) {
+            throw new ToolkitError(`Error showing text document: ${error}`)
+        }
+    }
+
+    public async renderModal(notification: ToolkitNotification) {
+        getLogger('notifications').info('rendering modal ... ')
+        if (!notification.uiRenderInstructions.buttons) {
+            throw new ToolkitError('no button defined for modal')
+            return
+        }
+
+        const buttons = notification.uiRenderInstructions.buttons
+
+        const buttonLabels = buttons.map((buttons) => buttons.displayText['en-US'])
+
+        const detail = notification.uiRenderInstructions.content['en-US'].description
+
+        const selectedButton = await vscode.window.showInformationMessage(
+            notification.uiRenderInstructions.content['en-US'].title,
+            { modal: true, detail },
+            ...buttonLabels
         )
+
+        if (selectedButton) {
+            const buttons = notification.uiRenderInstructions.buttons.find(
+                (buttons) => buttons.displayText['en-US'] === selectedButton
+            )
+
+            if (buttons) {
+                switch (buttons.type) {
+                    case 'updateAndReload':
+                        await this.updateAndReload(notification.displayIf.extensionId)
+                        break
+                    case 'openUrl':
+                        if (buttons.url) {
+                            await vscode.env.openExternal(vscode.Uri.parse(buttons.url))
+                        }
+                        break
+                    default:
+                        getLogger().warn(`Unhandled button type: ${buttons.type}`)
+                }
+            }
+        }
+    }
+
+    private async updateAndReload(id: string) {
+        getLogger('notifications').info('Updating and reloading the extension...')
+        await vscode.commands.executeCommand('workbench.extensions.installExtension', id)
+        await vscode.commands.executeCommand('workbench.action.reloadWindow')
     }
 
     /**

packages/core/src/notifications/types.ts

@@ -51,9 +51,21 @@ export interface UIRenderInstructions {
         [`en-US`]: {
             title: string
             description: string
+            descriptionPreview?: string // optional property for toast
         }
     }
-    // TODO actions
+    onRecieve: string
+    onClick: {
+        type: string
+        url?: string // optional property for 'openUrl'
+    }
+    buttons?: Array<{
+        type: string
+        displayText: {
+            [`en-US`]: string
+        }
+        url?: string // optional property for 'openUrl'
+    }>
 }
 
 /** Condition/criteria section of a notification. */