feat: add diff support for qlik script if remote script / local scrip…

…t differs closes #543
q-masters · Nov 1, 2020 · Oct 21, 2020 · Oct 21, 2020 · Oct 21, 2020 · Oct 21, 2020
commit fbc271c7fa96ac20f608aa88150de183640f089d
diff --git a/src/projects/extension/connection/utils/application.ts b/src/projects/extension/connection/utils/application.ts
@@ -20,6 +20,11 @@ export class Application {
     /** */
     private script: string | null = null;
 
+    /**
+     * last script which was persisted on server via vsqlik
+     */
+    private previousScript: string;
+
     public constructor(
         private globalContext: EngineAPI.IGlobal,
         private name: string,
@@ -47,18 +52,15 @@ export class Application {
 
     /**
      * return script for currrent application
-     * load only once since we need to persist it.
-     *
-     * if we save the script on server side (browser) we will simply override
-     * everything what exists since we are not aware of any changes
+     * if force is set to false script will cached
      */
     public async getScript(force = false): Promise<string> {
         if (!this.script || force) {
-            const doc    = await this.document;
-            const script = await doc.getScript();
+
+            const doc        = await this.document;
+            const script     = await doc.getScript();
 
             if (!force) {
-                console.log(script);
                 this.script = script;
             }
             return script;
@@ -75,13 +77,15 @@ export class Application {
 
     /** update a script */
     public async updateScript(content: string, persist = true): Promise<void> {
+
         this.script = content;
+        const doc = await this.doc;
 
         if (persist) {
-            const doc = await this.doc;
             await doc.setScript(content);
             await doc.doSave();
         }
+
     }
 
     public get appName(): string {

diff --git a/src/projects/extension/connection/utils/connection.helper.ts b/src/projects/extension/connection/utils/connection.helper.ts
@@ -4,7 +4,7 @@ import { create } from "enigma.js";
 import schema from "enigma.js/schemas/12.20.0.json";
 import WebSocket from "ws";
 import { WorkspaceSetting } from "@vsqlik/settings/api";
-import { container } from "tsyringe";
+import { container, singleton } from "tsyringe";
 import { SettingsRepository } from "@vsqlik/settings/settings.repository";
 import { VsQlikLoggerWebsocket } from "@vsqlik/logger";
 import { ConnectionSetting } from "../api";
@@ -14,7 +14,8 @@ export interface ConnectionSettingQuickPickItem extends vscode.QuickPickItem {
     setting: WorkspaceSetting
 }
 
-export abstract class ConnectionHelper {
+@singleton()
+export class ConnectionHelper {
 
     /**
      * build url by a given connection
@@ -39,9 +40,10 @@ export abstract class ConnectionHelper {
      */
     public static createEnigmaSession(
         model: ConnectionModel,
-        id?: string
+        id?: string,
+        uniqe = true
     ): enigmaJS.ISession {
-        const url = this.buildEnigmaWebsocketUri(model.setting, id);
+        const url = this.buildEnigmaWebsocketUri(model.setting, id, uniqe);
         return create({
             schema,
             url,
@@ -94,17 +96,24 @@ export abstract class ConnectionHelper {
     /**
      * create a websocket url by a given connection
      */
-    private static buildEnigmaWebsocketUri(connection: ConnectionSetting, id = "engineData"): string {
+    private static buildEnigmaWebsocketUri(connection: ConnectionSetting, id = "engineData", uniqe = true): string {
         const port = Number(connection.port);
-        const options = {
+
+        let options: any = {
             appId   : id,
             host    : connection.host,
-            identity: Math.random().toString(32).substr(2),
             secure  : connection.secure,
             port    : port && !isNaN(port) ? port : connection.secure ? 443 : 80,
             subpath : connection.path ?? ""
         };
 
+        if (uniqe) {
+            options = {
+                ...options,
+                identity: Math.random().toString(32).substr(2)
+            };
+        }
+
         return buildUrl(options);
     }
 

diff --git a/src/projects/extension/connection/utils/connection.ts b/src/projects/extension/connection/utils/connection.ts
@@ -87,6 +87,10 @@ export class Connection {
         return this.stateChange$.asObservable();
     }
 
+    public get model(): ConnectionModel {
+        return this.connectionModel;
+    }
+
     /**
      * runs a connection request
      */
@@ -145,7 +149,9 @@ export class Connection {
         if (!this.applications.has(id)) {
             const global = await this.engimaProvider.open(id);
             if (global) {
-                const app = new Application(global, id, this.serverSetting.label);
+
+                const app    = new Application(global, id, this.serverSetting.label);
+
                 app.onClose()
                     .pipe(take(1))
                     .subscribe(() => this.applications.delete(id));

diff --git a/src/projects/extension/connection/utils/enigma.provider.ts b/src/projects/extension/connection/utils/enigma.provider.ts
@@ -130,6 +130,7 @@ export class EnigmaSession {
         do {
             id = Math.random().toString(32).substr(2);
         } while(this.sessionCache.has(id));
+
         return this.open(EnigmaSession.GLOBAL_SESSION_KEY, keepAlive, id);
     }
 
@@ -173,7 +174,6 @@ export class EnigmaSession {
     private async createSessionObject(id: string, keepAlive = false, cacheId?: string): Promise<enigmaJS.IGeneratedAPI>
     {
         const cacheKey = cacheId ?? id;
-
         if (!this.connectionQueue.has(cacheKey)) {
             this.connectionQueue.set(cacheKey, this.resolveSession(id, keepAlive, cacheKey));
         }

diff --git a/src/projects/extension/script/commands/sync-script.ts b/src/projects/extension/script/commands/sync-script.ts
@@ -0,0 +1,29 @@
+import { ConnectionHelper, ConnectionProvider } from "@core/public.api";
+import { EntryType } from "@vsqlik/fs/data";
+import { container } from "tsyringe";
+import * as vscode from "vscode";
+
+const connectionProviver = container.resolve(ConnectionProvider);
+
+export async function ScriptSynchronizeCommand(uri: vscode.Uri, script: string): Promise<void> {
+    try {
+        /** get required data, connection, app and the text editor which contains the script */
+        const connection = await connectionProviver.resolve(uri);
+        const appEntry   = connection?.fileSystem.parent(uri, EntryType.APPLICATION);
+
+        if (!connection || !appEntry) {
+            return;
+        }
+
+        const session = ConnectionHelper.createEnigmaSession(connection.model, appEntry.id, false);
+        const global  = await session.open() as EngineAPI.IGlobal;
+        const app     = await global.openDoc(appEntry.id);
+
+        await app.setScript(script);
+        await app.getAppLayout();
+        await app.doSave();
+        await session.close();
+    } catch (error) {
+        console.log(error);
+    }
+}
diff --git a/src/projects/extension/script/data/commands.ts b/src/projects/extension/script/data/commands.ts
@@ -0,0 +1,6 @@
+export enum ScriptCommands {
+    CHECK_SYNTAX   = 'VsQlik.Script.CheckSyntax',
+    LOAD_DATA      = 'VsQlik.Script.LoadData',
+    RESOLVE_ACTIVE = 'VsQlik.Script.ResolveActive',
+    SYNCHRONIZE    = 'VsQlik.Script.Synchronize'
+}
diff --git a/src/projects/extension/script/files/script.file.ts b/src/projects/extension/script/files/script.file.ts
@@ -12,7 +12,7 @@ export class ScriptFileCtrl extends QixFsFileAdapter {
 
     public constructor(
         @inject(QixApplicationProvider) private appService: QixApplicationProvider,
-        @inject(FileSystemHelper) private fileSystemHelper: FileSystemHelper,
+        @inject(FileSystemHelper) private fileSystemHelper: FileSystemHelper
     ) {
         super();
     }
@@ -73,7 +73,7 @@ export class ScriptFileCtrl extends QixFsFileAdapter {
             fileUri = this.convertUri(uri);
         }
 
-        const connection = await this.getConnection(uri);
+        const connection  = await this.getConnection(uri);
         const app        = connection?.fileSystem.parent(fileUri, EntryType.APPLICATION);
 
         if (!app || !connection) {

diff --git a/src/projects/extension/script/script.module.ts b/src/projects/extension/script/script.module.ts
@@ -2,73 +2,40 @@ import * as vscode from "vscode";
 import { QixRouter } from "@core/router";
 import { ExtensionContext } from "@data/tokens";
 import { inject, singleton } from "tsyringe";
-import { EntryType } from "@vsqlik/fs/data";
-
-import { ConnectionProvider } from "../connection/utils/connection.provider";
-import { Application } from "../connection/utils/application";
 
 import { CheckScriptSyntax, ScriptLoadDataCommand, ScriptResolveActiveCommand } from "./commands";
 import { routes } from "./data/routes";
+import { ScriptSynchronizeCommand } from "./commands/sync-script";
+import { ScriptCommands } from "./data/commands";
 import { ScriptGuard } from "./utils/script.guard";
 
 @singleton()
 export class ScriptModule {
 
     constructor(
         @inject(ExtensionContext) private extensionContext: vscode.ExtensionContext,
-        @inject(ConnectionProvider) private connectionProvider: ConnectionProvider,
         @inject(QixRouter) private router: QixRouter<any>,
         @inject(ScriptGuard) private scriptGuard: ScriptGuard
-    ) { }
+    ) {
+    }
 
     /**
      * bootstrap script module
      */
     public bootstrap(): void {
         this.router.addRoutes(routes);
-
         this.registerCommands();
-        this.registerEvents();
-    }
-
-    /**
-     * a new textdocument has been opened
-     * check we handle a script file and if we do connect to appChange stream
-     */
-    private async onOpenDocument(doc: vscode.TextDocument) {
-
-        if (doc.uri.scheme !== "qix") {
-            return;
-        }
-
-        /** resolve connection and entry type */
-        const connection = await this.connectionProvider.resolve(doc.uri);
-        const fileEntry  = connection?.fileSystem.read(doc.uri.toString(true));
-        const appEntry   = connection?.fileSystem.parent(doc.uri, EntryType.APPLICATION);
-
-        if (!connection || !appEntry || fileEntry?.type !== EntryType.SCRIPT) {
-            return;
-        }
-
-        const app = await connection.getApplication(appEntry.id) as Application;
-        this.scriptGuard.add(doc, app);
-
-        vscode.commands.executeCommand(`VsQlik.Script.CheckSyntax`, doc.uri);
+        this.scriptGuard.init();
     }
 
     /**
      * register commands for vscode
      */
     private registerCommands(): void {
-        this.extensionContext.subscriptions.push(vscode.commands.registerCommand('VsQlik.Script.CheckSyntax', CheckScriptSyntax));
-        this.extensionContext.subscriptions.push(vscode.commands.registerCommand('VsQlik.Script.LoadData', ScriptLoadDataCommand));
-        this.extensionContext.subscriptions.push(vscode.commands.registerCommand('VsQlik.Script.ResolveActive', ScriptResolveActiveCommand));
-    }
-
-    /**
-     * register connection storage where all sessions are saved to
-     */
-    private registerEvents(): void {
-        vscode.workspace.onDidOpenTextDocument((document)   => this.onOpenDocument(document));
+        /** @todo move to enum */
+        this.extensionContext.subscriptions.push(vscode.commands.registerCommand(ScriptCommands.CHECK_SYNTAX  , CheckScriptSyntax));
+        this.extensionContext.subscriptions.push(vscode.commands.registerCommand(ScriptCommands.LOAD_DATA     , ScriptLoadDataCommand));
+        this.extensionContext.subscriptions.push(vscode.commands.registerCommand(ScriptCommands.RESOLVE_ACTIVE, ScriptResolveActiveCommand));
+        this.extensionContext.subscriptions.push(vscode.commands.registerCommand(ScriptCommands.SYNCHRONIZE   , ScriptSynchronizeCommand));
     }
 }