Merge pull request axonivy#781 from axonivy/XIVY-16879_extension_improvements

Xivy 16879 extension improvements

Author: ivy-fhe

extension/src/base/ivyProjectSelection.ts

@@ -1,13 +1,24 @@
 import * as vscode from 'vscode';
 import { IvyProjectExplorer } from '../project-explorer/ivy-project-explorer';
+import { logErrorMessage } from './logging-util';
 
 export const getIvyProject = async (projectExplorer: IvyProjectExplorer) => {
   const projects = await projectExplorer.getIvyProjects();
+  let uri: string | undefined;
+
   if (!projects || projects.length === 0) {
-    vscode.window.showErrorMessage('No ivy-projects are open in the workspace.');
+    logErrorMessage('No ivy-projects are open in the workspace.');
     return;
+  } else if (projects.length === 1) {
+    uri = projects[0];
+  } else {
+    uri = await showIvyProjectPick(projects);
   }
 
+  return uri ? vscode.Uri.file(uri) : undefined;
+};
+
+const showIvyProjectPick = async (projects: Array<string>) => {
   const items = projects.map(project => ({
     label: project.substring(project.lastIndexOf('/') + 1),
     description: project,
@@ -21,6 +32,5 @@ export const getIvyProject = async (projectExplorer: IvyProjectExplorer) => {
   if (!selected) {
     return;
   }
-
-  return vscode.Uri.file(selected.uri);
+  return selected.uri;
 };

extension/src/base/logging-util.ts

@@ -0,0 +1,18 @@
+import * as vscode from 'vscode';
+
+const outputChannel = vscode.window.createOutputChannel('Axon Ivy Extension Log', { log: true });
+
+export const logErrorMessage = (message: string, ...items: Array<string>) => {
+  outputChannel.error(message, ...items);
+  return vscode.window.showErrorMessage(message, ...items);
+};
+
+export const logWarningMessage = (message: string, ...items: Array<string>) => {
+  outputChannel.warn(message, ...items);
+  return vscode.window.showWarningMessage(message, ...items);
+};
+
+export const logInformationMessage = (message: string, ...items: Array<string>) => {
+  outputChannel.info(message, ...items);
+  return vscode.window.showInformationMessage(message, ...items);
+};

extension/src/browser/ivy-browser-view-provider.ts

@@ -1,5 +1,6 @@
 import * as vscode from 'vscode';
 import { executeCommand, registerCommand } from '../base/commands';
+import { logErrorMessage } from '../base/logging-util';
 import { findRootEntry, parseBuildManifest } from '../editors/build-manifest';
 
 export class IvyBrowserViewProvider implements vscode.WebviewViewProvider {
@@ -57,7 +58,7 @@ export class IvyBrowserViewProvider implements vscode.WebviewViewProvider {
             const url = vscode.Uri.parse(e.url);
             vscode.env.openExternal(url);
           } catch {
-            vscode.window.showErrorMessage(`Couldn't open uri '${e.url}' in external browser.`);
+            logErrorMessage(`Couldn't open uri '${e.url}' in external browser.`);
           }
           break;
         case 'openHome':

extension/src/editors/cms-editor/open-cms-editor-cmd.ts

@@ -1,16 +1,18 @@
 import * as vscode from 'vscode';
 import { messenger } from '../..';
 import { registerCommand } from '../../base/commands';
+import { logErrorMessage } from '../../base/logging-util';
 import { IvyProjectExplorer } from '../../project-explorer/ivy-project-explorer';
-import { TreeSelection, treeSelectionToProjectPath } from '../../project-explorer/tree-selection';
+import { TreeSelection, treeSelectionToUri, treeUriToProjectPath } from '../../project-explorer/tree-selection';
 import { createWebViewContent } from '../webview-helper';
 import { setupCommunication } from './webview-communication';
 
 export const registerOpenCmsEditorCmd = (context: vscode.ExtensionContext, websocketUrl: URL) => {
   registerCommand('ivyBrowserView.openCmsEditor', context, async (selection: TreeSelection) => {
     let projectPath: string | undefined;
     try {
-      projectPath = await treeSelectionToProjectPath(selection, IvyProjectExplorer.instance.getIvyProjects());
+      const uri = await treeSelectionToUri(selection);
+      projectPath = await treeUriToProjectPath(uri, IvyProjectExplorer.instance.getIvyProjects());
     } catch (error) {
       showError(error instanceof Error ? error.message : String(error));
       return;
@@ -26,5 +28,5 @@ export const registerOpenCmsEditorCmd = (context: vscode.ExtensionContext, webso
 };
 
 const showError = (message: string) => {
-  vscode.window.showErrorMessage(`Open CMS Editor: ${message}`);
+  logErrorMessage(`Open CMS Editor: ${message}`);
 };

extension/src/editors/database-editor/open-database-editor-cmd.ts

@@ -1,16 +1,18 @@
 import * as vscode from 'vscode';
 import { messenger } from '../..';
 import { registerCommand } from '../../base/commands';
+import { logErrorMessage } from '../../base/logging-util';
 import { IvyProjectExplorer } from '../../project-explorer/ivy-project-explorer';
-import { TreeSelection, treeSelectionToProjectPath } from '../../project-explorer/tree-selection';
+import { TreeSelection, treeSelectionToUri, treeUriToProjectPath } from '../../project-explorer/tree-selection';
 import { createWebViewContent } from '../webview-helper';
 import { setupCommunication } from './webview-communication';
 
 export const registerOpenDatabaseEditorCmd = (context: vscode.ExtensionContext, websocketUrl: URL) => {
   registerCommand('ivyBrowserView.openDatabaseEditor', context, async (selection: TreeSelection) => {
     let projectPath: string | undefined;
     try {
-      projectPath = await treeSelectionToProjectPath(selection, IvyProjectExplorer.instance.getIvyProjects());
+      const uri = await treeSelectionToUri(selection);
+      projectPath = await treeUriToProjectPath(uri, IvyProjectExplorer.instance.getIvyProjects());
     } catch (error) {
       showError(error instanceof Error ? error.message : String(error));
       return;
@@ -28,5 +30,5 @@ export const registerOpenDatabaseEditorCmd = (context: vscode.ExtensionContext,
 };
 
 const showError = (message: string) => {
-  vscode.window.showErrorMessage(`Open Database Editor: ${message}`);
+  logErrorMessage(`Open Database Editor: ${message}`);
 };

extension/src/editors/process-editor/inscription-view/open-page.ts

@@ -3,6 +3,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as vscode from 'vscode';
 import { executeCommand } from '../../../base/commands';
+import { logInformationMessage } from '../../../base/logging-util';
 import { IvyBrowserViewProvider } from '../../../browser/ivy-browser-view-provider';
 import { IvyProjectExplorer } from '../../../project-explorer/ivy-project-explorer';
 import { InscriptionActionHandler } from './action-handlers';
@@ -42,7 +43,7 @@ function openInExplorer(absolutePath: string | null) {
   if (absolutePath) {
     executeCommand('vscode.open', vscode.Uri.file(absolutePath));
   } else {
-    vscode.window.showInformationMessage('The entered url is not valid.');
+    logInformationMessage('The entered url is not valid.');
   }
 }
 

extension/src/editors/process-editor/process-vscode-connector.ts

@@ -13,6 +13,7 @@ import {
   SetMarkersAction
 } from '@eclipse-glsp/vscode-integration';
 import * as vscode from 'vscode';
+import { logErrorMessage, logInformationMessage, logWarningMessage } from '../../base/logging-util';
 import { SelectedElement } from '../../base/process-editor-connector';
 import ProcessEditorProvider from './process-editor-provider';
 
@@ -121,17 +122,17 @@ export class ProcessVscodeConnector<D extends vscode.CustomDocument = vscode.Cus
     switch (message.action.severity) {
       case 'ERROR':
       case 'FATAL':
-        vscode.window.showErrorMessage(message.action.message);
+        logErrorMessage(message.action.message);
         break;
       case 'WARNING':
-        vscode.window.showWarningMessage(message.action.message);
+        logWarningMessage(message.action.message);
         break;
       case 'INFO':
       case 'OK':
         if (message.action.message.includes('Model loading')) {
           this.modelLoading.show();
         } else {
-          vscode.window.showInformationMessage(message.action.message);
+          logInformationMessage(message.action.message);
         }
         break;
       case 'NONE':

extension/src/editors/variable-editor/new-variable-file-cmd.ts

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import * as vscode from 'vscode';
 import { registerCommand } from '../../base/commands';
+import { logErrorMessage } from '../../base/logging-util';
 import { VariableEditorProvider } from './variable-editor-provider';
 
 const fileName = 'variables.yaml';
@@ -9,17 +10,17 @@ export const registerNewVariablesFileCmd = (context: vscode.ExtensionContext) =>
   registerCommand('yaml-variables-editor.new', context, () => {
     const workspaceFolders = vscode.workspace.workspaceFolders;
     if (!workspaceFolders || !workspaceFolders[0]) {
-      vscode.window.showErrorMessage('No workspace found');
+      logErrorMessage('No workspace found');
       return;
     }
     const configPath = vscode.Uri.joinPath(workspaceFolders[0].uri, 'config');
     if (!fs.existsSync(configPath.fsPath)) {
-      vscode.window.showErrorMessage(`No config directory found in the workspace`);
+      logErrorMessage(`No config directory found in the workspace`);
       return;
     }
     const variablesPath = vscode.Uri.joinPath(configPath, fileName);
     if (fs.existsSync(variablesPath.fsPath)) {
-      vscode.window.showErrorMessage(`${fileName} file already exists`);
+      logErrorMessage(`${fileName} file already exists`);
       return;
     }
     vscode.workspace.fs.writeFile(variablesPath, new TextEncoder().encode('Variables:'));

extension/src/editors/welcome-page/welcome-page.ts

@@ -1,10 +1,6 @@
 import * as vscode from 'vscode';
 import { Messenger } from 'vscode-messenger';
 import { NotificationType } from 'vscode-messenger-common';
-import { Command } from '../../base/commands';
-import { getIvyProject } from '../../base/ivyProjectSelection';
-import { IvyProjectExplorer } from '../../project-explorer/ivy-project-explorer';
-import { addNewProject } from '../../project-explorer/new-project';
 import { extensionVersion } from '../../version/extension-version';
 import { createWebViewContent } from '../webview-helper';
 
@@ -38,7 +34,9 @@ export const showWelcomePage = async (context: vscode.ExtensionContext) => {
   messenger.onNotification(openUrlType, (url: string) => {
     vscode.env.openExternal(vscode.Uri.parse(url));
   });
-  messenger.onNotification(commandType, (command: Command) => executeCommand(command));
+  messenger.onNotification(commandType, command => {
+    vscode.commands.executeCommand(command);
+  });
 
   panel.webview.html = createWebViewContent(context, panel.webview, 'welcome-page');
   currentPanel = panel;
@@ -50,43 +48,3 @@ export const showWelcomePage = async (context: vscode.ExtensionContext) => {
     currentPanel = undefined;
   });
 };
-
-const executeCommand = async (command: Command) => {
-  switch (command) {
-    case 'ivyProjects.addNewProject':
-      executeAddProject();
-      break;
-    case 'ivyProjects.addBusinessProcess':
-    case 'ivyProjects.addNewFormDialog':
-    case 'ivyProjects.importBpmnProcess':
-      addProjectEntity(command);
-      break;
-    default:
-      vscode.commands.executeCommand(command);
-  }
-};
-
-const executeAddProject = async () => {
-  const folder = await vscode.window.showWorkspaceFolderPick();
-  if (!folder) {
-    return;
-  }
-  addNewProject(folder.uri);
-};
-
-const addProjectEntity = async (command: Command) => {
-  const projectExplorer = IvyProjectExplorer.instance;
-  const project = await getIvyProject(projectExplorer);
-
-  switch (command) {
-    case 'ivyProjects.addBusinessProcess':
-      projectExplorer.addProcess(project, 'Business Process');
-      break;
-    case 'ivyProjects.addNewFormDialog':
-      projectExplorer.addUserDialog(project, 'Form');
-      break;
-    case 'ivyProjects.importBpmnProcess':
-      projectExplorer.importBpmnProcess(project);
-      break;
-  }
-};

extension/src/engine/api/axios-error-handler.ts

@@ -1,10 +1,10 @@
 import { AxiosError } from 'axios';
-import * as vscode from 'vscode';
+import { logErrorMessage } from '../../base/logging-util';
 
 export const handleAxiosError = (error: unknown) => {
   if (error instanceof AxiosError) {
     const message = error.response?.data.errorMessage ?? error;
-    vscode.window.showErrorMessage(message);
+    logErrorMessage(message);
     throw message;
   }
   throw error;