Merge master into feature/q-dev-execution

Author: aws-toolkit-automation

packages/core/src/notifications/controller.ts

@@ -55,6 +55,7 @@ export class NotificationsController {
             startUp: {},
             emergency: {},
             dismissed: [],
+            newlyReceived: [],
         })
     }
 
@@ -97,6 +98,17 @@ export class NotificationsController {
             await this.writeState()
             void this.notificationsNode.focusPanel()
         }
+
+        // Process on-receive behavior for newly received notifications that passes rule engine
+        const newlyReceivedToDisplay = [...startUp, ...emergency].filter((n) => this.state.newlyReceived.includes(n.id))
+        if (newlyReceivedToDisplay.length > 0) {
+            await this.notificationsNode.onReceiveNotifications(newlyReceivedToDisplay)
+            // remove displayed notifications from newlyReceived
+            this.state.newlyReceived = this.state.newlyReceived.filter(
+                (id) => !newlyReceivedToDisplay.some((n) => n.id === id)
+            )
+            await this.writeState()
+        }
     }
 
     /**
@@ -121,10 +133,27 @@ export class NotificationsController {
             getLogger('notifications').verbose('No new notifications for category: %s', category)
             return
         }
+        // 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').verbose(
+                'New notifications received for category %s, ids: %s',
+                category,
+                addedNotifications.map((n: any) => n.id).join(', ')
+            )
+            this.state.newlyReceived.push(...addedNotifications.map((n: any) => n.id))
+        }
 
-        getLogger('notifications').verbose('ETAG has changed for notifications category: %s', category)
-
-        this.state[category].payload = JSON.parse(response.content)
+        this.state[category].payload = newPayload
         this.state[category].eTag = response.eTag
         await this.writeState()
 

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
@@ -126,15 +130,125 @@ export class NotificationsNode implements TreeNode {
     /**
      * Fired when a notification is clicked on in the panel. It will run any rendering
      * instructions included in the notification. See {@link ToolkitNotification.uiRenderInstructions}.
-     *
-     * 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':
+                // Render blocking modal
+                getLogger('notifications').verbose(`rendering modal for notificaiton: ${notification.id} ...`)
+                await this.showInformationWindow(notification, 'modal')
+                break
+            case 'openUrl':
+                if (!notification.uiRenderInstructions.onClick.url) {
+                    throw new ToolkitError('No url provided for onclick open url')
+                }
+                // Show open url option
+                getLogger('notifications').verbose(`opening url for notification: ${notification.id} ...`)
+                await vscode.env.openExternal(vscode.Uri.parse(notification.uiRenderInstructions.onClick.url))
+                break
+            case 'openTextDocument':
+                // Display read-only txt document
+                getLogger('notifications').verbose(`showing txt document for notification: ${notification.id} ...`)
+                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> {
+        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}`)
+        }
+    }
+
+    /**
+     * Renders information window with the notification's content and buttons.
+     * Can be either a blocking modal or a bottom-right corner toast
+     * Handles the button click actions based on the button type.
+     */
+    public async showInformationWindow(notification: ToolkitNotification, type: string = 'toast') {
+        const isModal = type === 'modal'
+
+        // modal has to have defined actions(buttons)
+        const buttons = notification.uiRenderInstructions.actions ?? []
+        const buttonLabels = buttons.map((actions) => actions.displayText['en-US'])
+        const detail = notification.uiRenderInstructions.content['en-US'].description
+
+        // we use toastPreview to display as titlefor toast, since detail won't be shown
+        const title = isModal
+            ? notification.uiRenderInstructions.content['en-US'].title
+            : (notification.uiRenderInstructions.content['en-US'].toastPreview ??
+              notification.uiRenderInstructions.content['en-US'].title)
+
+        const selectedText = await vscode.window.showInformationMessage(
+            title,
+            { modal: isModal, detail },
+            ...buttonLabels
         )
+
+        if (selectedText) {
+            const selectedButton = buttons.find((actions) => actions.displayText['en-US'] === selectedText)
+            // Different button options
+            if (selectedButton) {
+                switch (selectedButton.type) {
+                    case 'openTxt':
+                        await this.showReadonlyTextDocument(
+                            notification.uiRenderInstructions.content['en-US'].description
+                        )
+                        break
+                    case 'updateAndReload':
+                        await this.updateAndReload(notification.displayIf.extensionId)
+                        break
+                    case 'openUrl':
+                        if (selectedButton.url) {
+                            await vscode.env.openExternal(vscode.Uri.parse(selectedButton.url))
+                        } else {
+                            throw new ToolkitError('url not provided')
+                        }
+                        break
+                    default:
+                        throw new ToolkitError('button action not defined')
+                }
+            }
+        }
+    }
+
+    public async onReceiveNotifications(notifications: ToolkitNotification[]) {
+        for (const notification of notifications) {
+            void this.showInformationWindow(notification, notification.uiRenderInstructions.onRecieve)
+        }
+    }
+
+    private async updateAndReload(id: string) {
+        getLogger('notifications').verbose('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
+            toastPreview?: string // optional property for toast
         }
     }
-    // TODO actions
+    onRecieve: string
+    onClick: {
+        type: string
+        url?: string // optional property for 'openUrl'
+    }
+    actions?: Array<{
+        type: string
+        displayText: {
+            [`en-US`]: string
+        }
+        url?: string // optional property for 'openUrl'
+    }>
 }
 
 /** Condition/criteria section of a notification. */
@@ -87,14 +99,16 @@ export type NotificationsState = {
 
     // Util
     dismissed: string[]
+    newlyReceived: string[]
 }
 
 export const NotificationsStateConstructor: TypeConstructor<NotificationsState> = (v: unknown): NotificationsState => {
     const isNotificationsState = (v: Partial<NotificationsState>): v is NotificationsState => {
-        const requiredKeys: (keyof NotificationsState)[] = ['startUp', 'emergency', 'dismissed']
+        const requiredKeys: (keyof NotificationsState)[] = ['startUp', 'emergency', 'dismissed', 'newlyReceived']
         return (
             requiredKeys.every((key) => key in v) &&
             Array.isArray(v.dismissed) &&
+            Array.isArray(v.newlyReceived) &&
             typeof v.startUp === 'object' &&
             typeof v.emergency === 'object'
         )
@@ -106,7 +120,7 @@ export const NotificationsStateConstructor: TypeConstructor<NotificationsState>
     throw new Error('Cannot cast to NotificationsState.')
 }
 
-export type NotificationType = keyof Omit<NotificationsState, 'dismissed'>
+export type NotificationType = keyof Omit<NotificationsState, 'dismissed' | 'newlyReceived'>
 
 export interface RuleContext {
     readonly ideVersion: typeof vscode.version

packages/core/src/test/notifications/controller.test.ts

@@ -15,8 +15,11 @@ import { installFakeClock } from '../testUtil'
 import { NotificationFetcher, RemoteFetcher, ResourceResponse } from '../../notifications/controller'
 import { HttpResourceFetcher } from '../../shared/resourcefetcher/httpResourceFetcher'
 
+// one test node to use across different tests
+// re-declaration would cause a command conflict
+export const panelNode: NotificationsNode = new NotificationsNode()
+
 describe('Notifications Controller', function () {
-    const panelNode: NotificationsNode = new NotificationsNode()
     const ruleEngine: RuleEngine = new RuleEngine({
         ideVersion: '1.83.0',
         extensionVersion: '1.20.0',
@@ -116,6 +119,7 @@ describe('Notifications Controller', function () {
             },
             emergency: {},
             dismissed: [],
+            newlyReceived: ['id:startup2'],
         })
         assert.equal(panelNode.startUpNotifications.length, 1)
         assert.equal(panelNode.emergencyNotifications.length, 0)
@@ -146,6 +150,7 @@ describe('Notifications Controller', function () {
                 eTag,
             },
             dismissed: [content.notifications[0].id],
+            newlyReceived: ['id:emergency2'],
         })
         assert.equal(panelNode.startUpNotifications.length, 0)
         assert.equal(panelNode.emergencyNotifications.length, 1)
@@ -202,6 +207,7 @@ describe('Notifications Controller', function () {
                 eTag: eTag2,
             },
             dismissed: [emergencyContent.notifications[0].id],
+            newlyReceived: ['id:startup2', 'id:emergency2'],
         })
         assert.equal(panelNode.startUpNotifications.length, 1)
         assert.equal(panelNode.emergencyNotifications.length, 1)
@@ -234,6 +240,7 @@ describe('Notifications Controller', function () {
             },
             emergency: {},
             dismissed: [],
+            newlyReceived: [],
         })
 
         await dismissNotification(content.notifications[1])
@@ -246,6 +253,7 @@ describe('Notifications Controller', function () {
             },
             emergency: {},
             dismissed: [content.notifications[1].id],
+            newlyReceived: [],
         })
 
         assert.equal(panelNode.getChildren().length, 1)
@@ -284,6 +292,7 @@ describe('Notifications Controller', function () {
             },
             emergency: {},
             dismissed: [content.notifications[0].id],
+            newlyReceived: [],
         })
 
         assert.equal(panelNode.getChildren().length, 1)
@@ -335,6 +344,7 @@ describe('Notifications Controller', function () {
             },
             emergency: {},
             dismissed: [],
+            newlyReceived: ['id:startup2'],
         })
         assert.equal(panelNode.getChildren().length, 1)
 
@@ -351,6 +361,7 @@ describe('Notifications Controller', function () {
             },
             emergency: {},
             dismissed: [],
+            newlyReceived: ['id:startup2'],
         })
         assert.equal(panelNode.getChildren().length, 1)
     })
@@ -388,6 +399,7 @@ describe('Notifications Controller', function () {
                 eTag: '1',
             },
             dismissed: [emergencyContent.notifications[0].id, startUpContent.notifications[0].id],
+            newlyReceived: [],
         })
 
         const emptyContent = {
@@ -410,6 +422,7 @@ describe('Notifications Controller', function () {
                 eTag: '1',
             },
             dismissed: [emergencyContent.notifications[0].id],
+            newlyReceived: [],
         })
         assert.equal(panelNode.getChildren().length, 1)
 
@@ -429,6 +442,7 @@ describe('Notifications Controller', function () {
                 eTag: '1',
             },
             dismissed: [],
+            newlyReceived: [],
         })
 
         assert.equal(panelNode.getChildren().length, 0)
@@ -445,6 +459,27 @@ describe('Notifications Controller', function () {
         assert.doesNotThrow(() => new NotificationsController(panelNode, fetcher).pollForStartUp(ruleEngine))
         assert.ok(wasCalled)
     })
+
+    it('calls onReceiveNotifications when a new valid notification is added', async function () {
+        const eTag = randomUUID()
+        const content = {
+            schemaVersion: '1.x',
+            notifications: [getValidTestNotification('id:newValidNotification')],
+        }
+        fetcher.setStartUpContent({
+            eTag,
+            content: JSON.stringify(content),
+        })
+
+        const onReceiveSpy = sinon.spy(panelNode, 'onReceiveNotifications')
+
+        await controller.pollForStartUp(ruleEngine)
+
+        assert.equal(onReceiveSpy.callCount, 1)
+        assert.deepStrictEqual(onReceiveSpy.args[0][0], [content.notifications[0]])
+
+        onReceiveSpy.restore()
+    })
 })
 
 describe('RemoteFetcher', function () {
@@ -502,6 +537,11 @@ function getValidTestNotification(id: string) {
                     description: 'test',
                 },
             },
+            onRecieve: 'toast',
+            onClick: {
+                type: 'openUrl',
+                url: 'https://aws.amazon.com/visualstudiocode/',
+            },
         },
     }
 }