export from another namespace with confirmation, #41

Author: daimor

commands/export.ts

@@ -34,11 +34,13 @@ export const getFileName = (folder: string, name: string, split: boolean, addCat
   return [folder, cat, name].filter(notNull).join(path.sep);
 };
 
-export async function exportFile(workspaceFolder: string, name: string, fileName: string): Promise<void> {
+export async function exportFile(
+  workspaceFolder: string, namespace: string, name: string, fileName: string): Promise<void> {
   if (!config("conn", workspaceFolder).active) {
     return Promise.reject("Connection not active");
   }
   const api = new AtelierAPI(workspaceFolder);
+  api.setNamespace(namespace);
   const log = (status) => outputChannel.appendLine(`export "${name}" as "${fileName}" - ${status}`);
   const folders = path.dirname(fileName);
   return mkdirSyncRecursive(folders)
@@ -111,7 +113,7 @@ export async function exportFile(workspaceFolder: string, name: string, fileName
     });
 }
 
-export async function exportList(files: string[], workspaceFolder: string): Promise<any> {
+export async function exportList(files: string[], workspaceFolder: string, namespace: string): Promise<any> {
   if (!files || !files.length) {
     vscode.window.showWarningMessage("Nothing to export");
   }
@@ -121,7 +123,7 @@ export async function exportList(files: string[], workspaceFolder: string): Prom
   const run = async (fileList) => {
     const errors = [];
     for (const file of fileList) {
-      await exportFile(workspaceFolder, file, getFileName(root, file, atelier, addCategory))
+      await exportFile(workspaceFolder, namespace, file, getFileName(root, file, atelier, addCategory))
         .catch((error) => { errors.push(`${file} - ${error}`); });
     }
     outputChannel.appendLine(`Exported items: ${fileList.length - errors.length}`);
@@ -147,21 +149,32 @@ export async function exportAll(workspaceFolder?: string): Promise<any> {
   if (!config("conn", workspaceFolder).active) {
     return;
   }
-  const api = new AtelierAPI();
-  api.setConnection(workspaceFolder);
+  const api = new AtelierAPI(workspaceFolder);
   outputChannel.show(true);
-  const { category, generated, filter } = config("export", workspaceFolder);
+  const { category, generated, filter, ns } = config("export", workspaceFolder);
   const files = (data) => data.result.content.filter(filesFilter).map((file) => file.name);
   return api.getDocNames({ category, generated, filter }).then((data) => {
-    return exportList(files(data), workspaceFolder);
+    return exportList(files(data), workspaceFolder, ns);
   });
 }
 
 export async function exportExplorerItem(node: RootNode | PackageNode | ClassNode | RoutineNode): Promise<any> {
-  if (!config("conn", node.workspaceFolder).active) {
-    return;
+  const origNamespace = config("conn").ns;
+  if (origNamespace !== node.namespace) {
+    const answer = await vscode.window.showWarningMessage(
+      `
+You are going to export items from another namespace.
+Would you like to continue?`,
+      {
+        modal: true,
+      },
+      "Yes",
+    );
+    if (answer !== "Yes") {
+      return;
+    }
   }
-  const workspaceFolder = node.workspaceFolder;
+  const { workspaceFolder, namespace } = node;
   const nodesList = node instanceof RootNode ? node.getChildren(node) : Promise.resolve([node]);
   return nodesList
     .then((nodes) =>
@@ -171,6 +184,6 @@ export async function exportExplorerItem(node: RootNode | PackageNode | ClassNod
       ),
     )
     .then((items) => {
-      return exportList(items, workspaceFolder);
+      return exportList(items, workspaceFolder, namespace);
     });
 }

explorer/explorer.ts

@@ -64,7 +64,7 @@ export class ObjectScriptExplorerProvider implements vscode.TreeDataProvider<Nod
     const workspaceFolders = vscode.workspace.workspaceFolders || [];
     workspaceFolders.forEach((workspaceFolder) => {
       const conn: any = config("conn", workspaceFolder.name);
-      if (conn.active) {
+      if (conn.active && conn.ns) {
         node = new WorkspaceNode(workspaceFolder.name, this._onDidChangeTreeData);
         rootNodes.push(node);
 

explorer/models/classesNode.ts

@@ -7,14 +7,10 @@ export class ClassNode extends NodeBase {
   constructor(
     public readonly label: string,
     public readonly fullName: string,
-    private _workspaceFolder: string,
-    private _namespace: string,
+    workspaceFolder: string,
+    namespace: string,
   ) {
-    super(label);
-  }
-
-  get workspaceFolder(): string {
-    return this._workspaceFolder;
+    super(label, workspaceFolder, namespace);
   }
 
   public getTreeItem(): vscode.TreeItem {
@@ -23,7 +19,7 @@ export class ClassNode extends NodeBase {
     return {
       collapsibleState: vscode.TreeItemCollapsibleState.None,
       command: {
-        arguments: [DocumentContentProvider.getUri(this.fullName, this._workspaceFolder, this._namespace, true)],
+        arguments: [DocumentContentProvider.getUri(this.fullName, this.workspaceFolder, this.namespace, true)],
         command: "vscode-objectscript.explorer.openClass",
         title: "Open class",
       },

explorer/models/nodeBase.ts

@@ -1,11 +1,20 @@
 import * as vscode from "vscode";
+import { config } from "../../extension";
 
 export class NodeBase {
-  public readonly label: string;
   public readonly fullName: string;
+  public readonly conn: any;
+  public readonly extraNode: boolean;
 
-  protected constructor(label: string) {
-    this.label = label;
+
+  protected constructor(
+    public readonly label: string,
+    public readonly workspaceFolder,
+    public readonly namespace: string,
+  ) {
+    this.conn = config("conn", workspaceFolder);
+    this.namespace = namespace || this.conn.ns;
+    this.extraNode = (this.conn.ns !== this.namespace);
   }
 
   public getTreeItem(): vscode.TreeItem {

explorer/models/packageNode.ts

@@ -7,14 +7,10 @@ export class PackageNode extends NodeBase {
   constructor(
     public readonly label: string,
     private readonly _items,
-    private readonly _workspaceFolder: string,
-    private _namespace: string,
+    workspaceFolder: string,
+    namespace: string,
   ) {
-    super(label);
-  }
-
-  get workspaceFolder(): string {
-    return this._workspaceFolder;
+    super(label, workspaceFolder, namespace);
   }
 
   public getTreeItem(): vscode.TreeItem {
@@ -34,8 +30,8 @@ export class PackageNode extends NodeBase {
   public async getChildren(element): Promise<NodeBase[]> {
     return this._items.map(({ name, fullName, nodes }) =>
       nodes.length
-        ? new PackageNode(name, nodes, this._workspaceFolder, this._namespace)
-        : new ClassNode(name, fullName, this._workspaceFolder, this._namespace),
+        ? new PackageNode(name, nodes, this.workspaceFolder, this.namespace)
+        : new ClassNode(name, fullName, this.workspaceFolder, this.namespace),
     );
   }
 

explorer/models/rootNode.ts

@@ -10,14 +10,10 @@ export class RootNode extends NodeBase {
     public readonly contextValue: string,
     public eventEmitter: vscode.EventEmitter<NodeBase>,
     private _items: any[],
-    private _workspaceFolder: string,
-    private _namespace: string,
+    workspaceFolder: string,
+    namespace: string,
   ) {
-    super(label);
-  }
-
-  get workspaceFolder(): string {
-    return this._workspaceFolder;
+    super(label, workspaceFolder, namespace);
   }
 
   public getTreeItem(): vscode.TreeItem {
@@ -41,11 +37,11 @@ export class RootNode extends NodeBase {
   private async getClasses(): Promise<PackageNode[]> {
     const items = this.makeTree(this._items);
 
-    return items.map(({ name, nodes }) => new PackageNode(name, nodes, this._workspaceFolder, this._namespace));
+    return items.map(({ name, nodes }) => new PackageNode(name, nodes, this.workspaceFolder, this.namespace));
   }
 
   private async getRoutines(): Promise<RoutineNode[]> {
-    return this._items.map(({ name }) => new RoutineNode(name, name, this._workspaceFolder, this._namespace));
+    return this._items.map(({ name }) => new RoutineNode(name, name, this.workspaceFolder, this.namespace));
   }
 
   private makeTree(items: any[]): any[] {

explorer/models/routineNode.ts

@@ -7,14 +7,10 @@ export class RoutineNode extends NodeBase {
   constructor(
     public readonly label: string,
     public readonly fullName: string,
-    private _workspaceFolder: string,
-    private _namespace: string,
+    workspaceFolder: string,
+    namespace: string,
   ) {
-    super(label);
-  }
-
-  get workspaceFolder(): string {
-    return this._workspaceFolder;
+    super(label, workspaceFolder, namespace);
   }
 
   public getTreeItem(): vscode.TreeItem {
@@ -23,7 +19,7 @@ export class RoutineNode extends NodeBase {
     return {
       collapsibleState: vscode.TreeItemCollapsibleState.None,
       command: {
-        arguments: [DocumentContentProvider.getUri(this.fullName, this._workspaceFolder, this._namespace)],
+        arguments: [DocumentContentProvider.getUri(this.fullName, this.workspaceFolder, this.namespace)],
         command: "vscode-objectscript.explorer.openRoutine",
         title: "Open routine",
       },

explorer/models/workspaceNode.ts

@@ -1,51 +1,44 @@
 import * as vscode from "vscode";
 
 import { AtelierAPI } from "../../api";
-import { config } from "../../extension";
 import { NodeBase } from "./nodeBase";
 import { RootNode } from "./rootNode";
 
 export class WorkspaceNode extends NodeBase {
-  private _conn: any;
-  private _extraNode: boolean;
 
   constructor(
     public readonly label: string,
     public eventEmitter: vscode.EventEmitter<NodeBase>,
-    private _namespace?: string,
+    namespace?: string,
   ) {
-    super(label);
-    this._conn = config("conn", this.label);
-    this._namespace = _namespace || this._conn.ns;
-    this._extraNode = (this._conn.ns !== this._namespace);
+    super(label, label, namespace);
   }
 
-  get ns(): string {
-    return this._namespace;
-  }
+  // get ns(): string {
+  //   return this._namespace;
+  // }
 
   public getTreeItem(): vscode.TreeItem {
     return {
       collapsibleState: vscode.TreeItemCollapsibleState.Expanded,
-      contextValue: `serverNode${this._extraNode ? "Extra:" + this._namespace : ""}`,
-      label: `${this.label}${this._extraNode ? `[${this._namespace}]` : ""}`,
+      contextValue: `serverNode${this.extraNode ? "Extra:" + this.namespace : ""}`,
+      label: `${this.label}${this.extraNode ? `[${this.namespace}]` : ""}`,
     };
   }
 
   public async getChildren(element): Promise<NodeBase[]> {
     const children = [];
     let node: RootNode;
     let data: any;
-    const workspaceFolder = element.label;
 
     data = await this.getDocNames("CLS");
     node = new RootNode("Classes", "dataRootNode:classesRootNode",
-      this.eventEmitter, data, workspaceFolder, this._namespace);
+      this.eventEmitter, data, this.workspaceFolder, this.namespace);
     children.push(node);
 
     data = await this.getDocNames("RTN");
     node = new RootNode("Routines", "dataRootNode:routinesRootNode",
-      this.eventEmitter, data, workspaceFolder, this._namespace);
+      this.eventEmitter, data, this.workspaceFolder, this.namespace);
     children.push(node);
 
     return children;
@@ -73,10 +66,10 @@ export class WorkspaceNode extends NodeBase {
     const generated = 0;
     const filter = "";
 
-    const systemFiles = (this._namespace === "%SYS") ? "1" : "0";
+    const systemFiles = (this.namespace === "%SYS") ? "1" : "0";
 
     const api = new AtelierAPI(this.label);
-    api.setNamespace(this._namespace);
+    api.setNamespace(this.namespace);
     return api
       .actionQuery(sql, [
         spec,

extension.ts

@@ -122,7 +122,6 @@ export async function activate(
       .serverInfo()
       .then(async (info) => {
         panel.text = `${connInfo} - Connected`;
-        explorerProvider.refresh();
       })
       .catch((error) => {
         let message = error.message;
@@ -138,6 +137,9 @@ export async function activate(
         }
         panel.text = `${connInfo} - ERROR`;
         panel.tooltip = message;
+      })
+      .finally(() => {
+        explorerProvider.refresh();
       });
   };
   checkConnection();
@@ -242,7 +244,7 @@ export async function activate(
       (workspaceNode: WorkspaceNode) => {
         return explorerProvider.closeExtra4Workspace(
           workspaceNode.label,
-          workspaceNode.ns,
+          workspaceNode.namespace,
         );
       },
     ),