Actions/Custom Variables/Profiles overhaul

src/api/actions.ts

@@ -0,0 +1,81 @@
+import vscode, { l10n } from "vscode";
+import IBMi from "./IBMi";
+import { Action } from "./types";
+
+export async function getActions(workspace?: vscode.WorkspaceFolder) {
+  return workspace ? await getLocalActions(workspace) : (IBMi.connectionManager.get<Action[]>(`actions`) || []);
+}
+
+export async function updateAction(action: Action, workspace?: vscode.WorkspaceFolder, options?: { newName?: string, delete?: boolean }) {
+  const actions = await getActions(workspace);
+  const currentIndex = actions.findIndex(a => action.name === a.name);
+
+  action.name = options?.newName || action.name;
+
+  if (options?.delete) {
+    if (currentIndex >= 0) {
+      actions.splice(currentIndex, 1);
+    }
+    else {
+      throw new Error(l10n.t("Cannot find action {0} for delete operation", action.name));
+    }
+  }
+  else {
+    actions[currentIndex >= 0 ? currentIndex : actions.length] = action;
+  }
+
+  if (workspace) {
+    const actionsFile = (await getLocalActionsFiles(workspace)).at(0);
+    if (actionsFile) {
+      await vscode.workspace.fs.writeFile(actionsFile, Buffer.from(JSON.stringify(actions, undefined, 2), "utf-8"));
+    }
+    else {
+      throw new Error(l10n.t("No local actions file defined in workspace {0}", workspace.name));
+    }
+  }
+  else {
+    await IBMi.connectionManager.set(`actions`, actions);
+  }
+}
+
+export async function getLocalActionsFiles(workspace: vscode.WorkspaceFolder) {
+  return workspace ? await vscode.workspace.findFiles(new vscode.RelativePattern(workspace, `**/.vscode/actions.json`)) : [];
+}
+
+async function getLocalActions(currentWorkspace: vscode.WorkspaceFolder) {
+  const actions: Action[] = [];
+
+  if (currentWorkspace) {
+    const actionsFiles = await getLocalActionsFiles(currentWorkspace);
+
+    for (const file of actionsFiles) {
+      const actionsContent = await vscode.workspace.fs.readFile(file);
+      try {
+        const actionsJson: Action[] = JSON.parse(actionsContent.toString());
+
+        // Maybe one day replace this with real schema validation
+        if (Array.isArray(actionsJson)) {
+          actionsJson.forEach((action, index) => {
+            if (
+              typeof action.name === `string` &&
+              typeof action.command === `string` &&
+              [`ile`, `pase`, `qsh`].includes(action.environment) &&
+              (!action.extensions || Array.isArray(action.extensions))
+            ) {
+              actions.push({
+                ...action,
+                type: `file`
+              });
+            } else {
+              throw new Error(`Invalid Action defined at index ${index}.`);
+            }
+          })
+        }
+      } catch (e: any) {
+        vscode.window.showErrorMessage(`Error parsing ${file.fsPath}: ${e.message}\n`);
+      }
+    };
+  }
+
+  return actions;
+}

src/api/configuration/config/ConnectionManager.ts

@@ -14,7 +14,6 @@ function initialize(parameters: Partial<ConnectionConfig>): ConnectionConfig {
     autoClearTempData: parameters.autoClearTempData || false,
     customVariables: parameters.customVariables || [],
     connectionProfiles: parameters.connectionProfiles || [],
-    commandProfiles: parameters.commandProfiles || [],
     ifsShortcuts: parameters.ifsShortcuts || [],
     /** Default auto sorting of shortcuts to off  */
     autoSortIFSShortcuts: parameters.autoSortIFSShortcuts || false,
@@ -87,7 +86,7 @@ export class ConnectionManager {
   }
 
   async storeNew(data: ConnectionData) {
-    const connections = await this.getAll();
+    const connections = this.getAll();
     const newId = connections.length;
     connections.push(data);
     await this.setAll(connections);

src/api/configuration/config/types.ts

@@ -1,5 +1,5 @@
 import { FilterType } from "../../Filter";
-import { DeploymentMethod, ConnectionData } from "../../types";
+import { ConnectionData, DeploymentMethod } from "../../types";
 
 export type DefaultOpenMode = "browse" | "edit";
 export type ReconnectMode = "always" | "never" | "ask";
@@ -8,7 +8,6 @@ export interface ConnectionConfig extends ConnectionProfile {
   host: string;
   autoClearTempData: boolean;
   connectionProfiles: ConnectionProfile[];
-  commandProfiles: CommandProfile[];
   autoSortIFSShortcuts: boolean;
   tempLibrary: string;
   tempDir: string;
@@ -33,6 +32,7 @@ export interface ConnectionConfig extends ConnectionProfile {
   protectedPaths: string[];
   showHiddenFiles: boolean;
   lastDownloadLocation: string;
+  currentProfile?: string
   [name: string]: any;
 }
 
@@ -64,11 +64,7 @@ export interface ConnectionProfile {
   objectFilters: ObjectFilters[]
   ifsShortcuts: string[]
   customVariables: CustomVariable[]
-}
-
-export interface CommandProfile {
-  name: string;
-  command: string;
+  setLibraryListCommand?: string
 }
 
 export interface StoredConnection {

src/api/configuration/storage/ConnectionStorage.ts

@@ -45,14 +45,6 @@ export class ConnectionStorage {
     await this.internalStorage.set(SOURCE_LIST_KEY, sourceList);
   }
 
-  getLastProfile() {
-    return this.internalStorage.get<string>(LAST_PROFILE_KEY);
-  }
-
-  async setLastProfile(lastProfile: string) {
-    await this.internalStorage.set(LAST_PROFILE_KEY, lastProfile);
-  }
-
   getPreviousCurLibs() {
     return this.internalStorage.get<string[]>(PREVIOUS_CUR_LIBS_KEY) || [];
   }
@@ -94,6 +86,15 @@ export class ConnectionStorage {
     await this.internalStorage.set(RECENTLY_OPENED_FILES_KEY, undefined);
   }
 
+  /** @deprecated stored in ConnectionSettings now */
+  getLastProfile() {
+    return this.internalStorage.get<string>(LAST_PROFILE_KEY);
+  }
+
+  async clearDeprecatedLastProfile() {
+    await this.internalStorage.set(LAST_PROFILE_KEY, undefined);
+  }
+
   async grantExtensionAuthorisation(extensionId: string, displayName: string) {
     const extensions = this.getAuthorisedExtensions();
     if (!this.getExtensionAuthorisation(extensionId)) {

src/api/connectionProfiles.ts

@@ -0,0 +1,91 @@
+import { l10n } from "vscode";
+import { instance } from "../instantiate";
+import IBMi from "./IBMi";
+import { ConnectionProfile } from "./types";
+
+export async function updateConnectionProfile(profile: ConnectionProfile, options?: { newName?: string, delete?: boolean }) {
+  const config = instance.getConnection()?.getConfig();
+  if (config) {
+    const profiles = config.connectionProfiles;
+    const index = profiles.findIndex(p => p.name === profile.name);
+
+    if (options?.delete) {
+      if (index < 0) {
+        throw new Error(l10n.t("Profile {0} not found for deletion.", profile.name));
+      }
+      profiles.splice(index, 1);
+    }
+    else {
+      profile.name = options?.newName || profile.name;
+      profiles[index < 0 ? profiles.length : index] = profile;
+    }
+
+    if (isActiveProfile(profile)) {
+      //Only update the setLibraryListCommand in the current config since the editor is the only place it can be changed
+      config.setLibraryListCommand = profile.setLibraryListCommand;
+    }
+
+    await IBMi.connectionManager.update(config);
+  }
+}
+
+/**
+ * @returns ann arry of {@link ConnectionProfile} stored in the config; except the default profile (with a blank name), only used internally
+ */
+export function getConnectionProfiles() {
+  const config = instance.getConnection()?.getConfig();
+  if (config) {
+    return config.connectionProfiles.filter(profile => Boolean(profile.name));
+  }
+  else {
+    throw new Error(l10n.t("Not connected to an IBM i"));
+  }
+}
+
+export function getConnectionProfile(profileName: string) {
+  return getConnectionProfiles().filter(p => p.name === profileName).at(0);
+}
+
+export function getDefaultProfile() {
+  const config = instance.getConnection()?.getConfig();
+  if (config) {
+    let defaultProfile = config.connectionProfiles.filter(profile => !profile.name).at(0);
+    if (!defaultProfile) {
+      defaultProfile = {
+        name: '',
+        homeDirectory: '',
+        ifsShortcuts: [],
+        currentLibrary: '',
+        objectFilters: [],
+        customVariables: [],
+        libraryList: []
+      };
+
+      config.connectionProfiles.push(defaultProfile);
+    }
+
+    return defaultProfile;
+  }
+  else {
+    throw new Error(l10n.t("Not connected to an IBM i"));
+  }
+}
+
+export function assignProfile(fromProfile: ConnectionProfile, toProfile: ConnectionProfile) {
+  toProfile.homeDirectory = fromProfile.homeDirectory;
+  toProfile.currentLibrary = fromProfile.currentLibrary;
+  toProfile.libraryList = fromProfile.libraryList;
+  toProfile.objectFilters = fromProfile.objectFilters;
+  toProfile.ifsShortcuts = fromProfile.ifsShortcuts;
+  toProfile.customVariables = fromProfile.customVariables;
+  toProfile.setLibraryListCommand = fromProfile.setLibraryListCommand;
+  return toProfile;
+}
+
+export function cloneProfile(fromProfile: ConnectionProfile, newName: string): ConnectionProfile {
+  return assignProfile(fromProfile, { name: newName } as ConnectionProfile);
+}
+
+export function isActiveProfile(profile: ConnectionProfile) {
+  return instance.getConnection()?.getConfig().currentProfile === profile.name;
+}

src/api/types.ts

@@ -37,7 +37,7 @@ export interface CommandData extends StandardIO {
 
 export interface CommandResult {
   code: number;
-  signal?: string|null;
+  signal?: string | null;
   stdout: string;
   stderr: string;
   command?: string;
@@ -72,10 +72,6 @@ export interface Server {
   name: string
 }
 
-export interface Profile {
-  profile: string
-}
-
 export interface QsysPath {
   asp?: string,
   library: string,

src/api/variables.ts

@@ -22,7 +22,7 @@ export class Variables extends Map<string, string> {
         .set(`&WORKDIR`, config.homeDirectory);
 
       for (const variable of config.customVariables) {
-        this.set(`&${variable.name.toUpperCase()}`, variable.value);
+        this.set(`&${variable.name.toUpperCase()}`, variable.value || '');
       }
     }
   }