@shapediver/viewer.session-engine.session-engine 2.2.2 → 2.3.0

package/src/implementation/SessionEngine.ts

@@ -4,7 +4,7 @@ import { HttpClient, HttpResponse, PerformanceEvaluator, UuidGenerator, SystemIn
 import { OutputDelayException } from './OutputDelayException'
 import { OutputLoader } from './OutputLoader'
 import { SessionTreeNode } from './SessionTreeNode'
-import { ISessionEngine, PARAMETER_TYPE } from '../interfaces/ISessionEngine'
+import { ISessionEngine, ISettingsSections, PARAMETER_TYPE } from '../interfaces/ISessionEngine'
 import { SessionData } from './SessionData'
 import { create, ShapeDiverError as ShapeDiverBackendError, ShapeDiverResponseErrorType, ShapeDiverRequestGltfUploadQueryConversion, ShapeDiverResponseDto, ShapeDiverResponseError, ShapeDiverResponseExport, ShapeDiverResponseExportDefinitionType, ShapeDiverResponseOutput, ShapeDiverResponseParameter, ShapeDiverSdk, ShapeDiverSdkConfigType, ShapeDiverResponseModelComputationStatus } from '@shapediver/sdk.geometry-api-sdk-v2'
 import { AxiosRequestConfig } from 'axios'
@@ -154,8 +154,8 @@ export class SessionEngine implements ISessionEngine {
     }
 
     public set excludeViewports(value: string[]) {
-        this._excludeViewports = value;
-        this._node.excludeViewports = value;
+        this._excludeViewports = JSON.parse(JSON.stringify(value));
+        this._node.excludeViewports = JSON.parse(JSON.stringify(value));
     }
 
     public get exports(): { [key: string]: IExport; } {
@@ -226,13 +226,7 @@ export class SessionEngine implements ISessionEngine {
 
     // #region Public Methods (22)
 
-    public applySettings(response: ShapeDiverResponseDto, sections?: {
-        session?: {
-            parameter?: { displayname?: boolean | undefined; order?: boolean | undefined; hidden?: boolean | undefined; value?: boolean | undefined } | undefined;
-            export?: { displayname?: boolean | undefined; order?: boolean | undefined; hidden?: boolean | undefined } | undefined
-        } | undefined;
-        viewport?: { ar?: boolean | undefined; scene?: boolean | undefined; camera?: boolean | undefined; light?: boolean | undefined; environment?: boolean | undefined; general?: boolean | undefined } | undefined
-    }) {
+    public applySettings(response: ShapeDiverResponseDto, sections?: ISettingsSections) {
         try {
             sections = sections || {};
             if (sections.session === undefined) {
@@ -252,15 +246,15 @@ export class SessionEngine implements ISessionEngine {
             if ((<ShapeDiverResponseDto>response).viewer !== undefined) {
                 config = (<ShapeDiverResponseDto>response).viewer!.config;
             } else {
-                const error = new ShapeDiverViewerSettingsError('Api.applySettings: No config object available.');
-                throw this._logger.handleError(LOGGING_TOPIC.SETTINGS, 'Api.applySettings', error);
+                const error = new ShapeDiverViewerSettingsError('Session.applySettings: No config object available.');
+                throw this._logger.handleError(LOGGING_TOPIC.SETTINGS, 'Session.applySettings', error);
             }
 
             try {
                 validate(config)
             } catch (e) {
-                const error = new ShapeDiverViewerSettingsError('Api.applySettings: Was not able to validate config object.');
-                throw this._logger.handleError(LOGGING_TOPIC.SETTINGS, 'Api.applySettings', error);
+                const error = new ShapeDiverViewerSettingsError('Session.applySettings: Was not able to validate config object.');
+                throw this._logger.handleError(LOGGING_TOPIC.SETTINGS, 'Session.applySettings', error);
             }
 
             const settings = <ISettingsV3_1>convert(config, '3.1');
@@ -355,7 +349,7 @@ export class SessionEngine implements ISessionEngine {
 
         } catch (e) {
             if (e instanceof ShapeDiverViewerError || e instanceof ShapeDiverBackendError) throw e;
-            throw this._logger.handleError(LOGGING_TOPIC.GENERAL, 'Api.applySettings', e);
+            throw this._logger.handleError(LOGGING_TOPIC.GENERAL, 'Session.applySettings', e);
         }
     }
 
@@ -526,7 +520,7 @@ export class SessionEngine implements ISessionEngine {
 
             this._warningCreator();
 
-            this.node.excludeViewports = this._excludeViewports;
+            this.node.excludeViewports = JSON.parse(JSON.stringify(this._excludeViewports));
 
             for (let r in this._stateEngine.renderingEngines)
                 if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
@@ -553,9 +547,23 @@ export class SessionEngine implements ISessionEngine {
         }
     }
 
-    public customizeParallel(parameterValues: { [key: string]: string }, force: boolean): Promise<ITreeNode> {
-        // https://shapediver.atlassian.net/browse/SS-5408
-        throw new Error('Method not implemented.')
+    public async customizeParallel(parameterValues: { [key: string]: string }): Promise<ITreeNode> {
+        try {
+            const parameterSet: {
+                [key: string]: string
+            } = {};
+
+            // create a set of the current validated parameter values
+            for (const parameterId in this.parameters)
+                parameterSet[parameterId] = parameterValues[parameterId] !== undefined ? (' ' + parameterValues[parameterId]).slice(1) : this.parameters[parameterId].stringify()
+
+            const newNode = await this.customizeSession(parameterSet, () => false, true);
+            newNode.excludeViewports = JSON.parse(JSON.stringify(this._excludeViewports));
+            return newNode;
+        } catch (e) {
+            if (e instanceof ShapeDiverViewerError || e instanceof ShapeDiverBackendError) throw e;
+            throw this._logger.handleError(LOGGING_TOPIC.SESSION, `Session(${this.id}).customize`, e);
+        }
     }
 
     public async goBack(): Promise<ITreeNode> {
@@ -616,7 +624,12 @@ export class SessionEngine implements ISessionEngine {
 
         try {
             this._performanceEvaluator.startSection('sessionResponse');
-            this._responseDto = await this._sdk.session.init(this._ticket, parameterValues);
+
+            const parameterSet: { [key: string]: string } = {};
+            for (const parameterId in parameterValues)
+                parameterSet[parameterId] = (' ' + parameterValues[parameterId]).slice(1);
+
+            this._responseDto = await this._sdk.session.init(this._ticket, parameterSet);
             this._performanceEvaluator.endSection('sessionResponse');
 
             this._viewerSettings = this._responseDto.viewer?.config;
@@ -634,7 +647,7 @@ export class SessionEngine implements ISessionEngine {
             if (!this._modelId)
                 throw new ShapeDiverViewerSessionError(`Session.init: Initialization of session failed. ResponseDto did not have a model.id.`)
 
-            this.updateResponseDto(this._responseDto, parameterValues);
+            this.updateResponseDto(this._responseDto, parameterSet);
             this._initialized = true;
         } catch (e) {
             await this.handleError(LOGGING_TOPIC.SESSION, 'Session.init', e, retry);
@@ -642,6 +655,63 @@ export class SessionEngine implements ISessionEngine {
         }
     }
 
+    
+    /**
+     * Load the outputs and return the scene graph node of the result.
+     * In case the outputs have a delay property, another customization request with the parameter set is sent.
+     * 
+     * @param parameters the parameter set to update the session 
+     * @param outputs the outputs to load
+     * @returns promise with a scene graph node
+     */
+     public async loadOutputsParallel(responseDto: ShapeDiverResponseDto, cancelRequest: () => boolean = () => false, retry = false): Promise<ISessionTreeNode> {
+        this.checkAvailability();
+
+        let outputs: {
+            [key: string]: IOutput;
+        } = {}
+        let outputsFreeze: {
+            [key: string]: boolean;
+        } = {}
+        
+        for (let outputId in responseDto.outputs) {
+            responseDto.outputs[outputId].id = outputId;
+            if (this.outputsFreeze[outputId] === undefined) outputsFreeze[outputId] = false;
+            outputs[outputId] = new Output(<ShapeDiverResponseOutput>responseDto.outputs[outputId], this);
+        }
+
+        try {
+            const node = await this._outputLoader.loadOutputs(this._responseDto!.model?.name || 'model', outputs, outputsFreeze);
+            node.data.push(new SessionData(responseDto));      
+            return node;
+        }
+        catch (e) {
+            if (e instanceof OutputDelayException) {
+                await this.timeout(e.delay);
+            } else {
+                await this.handleError(LOGGING_TOPIC.SESSION, 'Session.loadOutputsParallel', e, retry);
+                if (cancelRequest()) return new SessionTreeNode();
+                return await this.loadOutputsParallel(responseDto, cancelRequest, true);
+            }
+
+            if (cancelRequest()) return new SessionTreeNode();
+            let outputMapping: { [key: string]: string } = {};
+            for (let output in outputs)
+                outputMapping[output] = outputs[output].version;
+
+            try {
+                const responseDto = await this._sdk.output.getCache(this._sessionId!, outputMapping);
+                if (cancelRequest()) return new SessionTreeNode();
+                this.updateResponseDto(responseDto);
+                return await this.loadOutputsParallel(responseDto, cancelRequest);
+            } catch (e) {
+                await this.handleError(LOGGING_TOPIC.SESSION, 'Session.loadOutputsParallel', e, retry);
+                if (cancelRequest()) return new SessionTreeNode();
+                return await this.loadOutputsParallel(responseDto, cancelRequest, true);
+            }
+        }
+    }
+
     /**
      * Load the outputs and return the scene graph node of the result.
      * In case the outputs have a delay property, another customization request with the parameter set is sent.
@@ -656,7 +726,7 @@ export class SessionEngine implements ISessionEngine {
         const o = Object.assign({}, this._outputs);
         const of = Object.assign({}, this._outputsFreeze);
         try {
-            const node = await this._outputLoader.loadOutputs(this._responseDto!, o, of);
+            const node = await this._outputLoader.loadOutputs(this._responseDto!.model?.name || 'model', o, of);
             node.data.push(new SessionData(this._responseDto!));
 
             if (cancelRequest()) return node;            
@@ -665,7 +735,7 @@ export class SessionEngine implements ISessionEngine {
             this._node = node;
             if (this._automaticSceneUpdate) this._sceneTree.addNode(this._node);
 
-            this.node.excludeViewports = this._excludeViewports;
+            this.node.excludeViewports = JSON.parse(JSON.stringify(this._excludeViewports));
 
             return node;
         }
@@ -699,7 +769,10 @@ export class SessionEngine implements ISessionEngine {
     public async requestExport(exportId: string, parameters: { [key: string]: string }, maxWaitTime: number, retry = false): Promise<ShapeDiverResponseExport> {
         this.checkAvailability('export');
         try {
-            const responseDto = await this._sdk.utils.submitAndWaitForExport(this._sdk, this._sessionId!, { exports: { id: exportId }, parameters }, maxWaitTime)
+            const parameterSet: { [key: string]: string } = {};
+            for (const parameterId in parameters)
+                parameterSet[parameterId] = (' ' + parameters[parameterId]).slice(1);
+            const responseDto = await this._sdk.utils.submitAndWaitForExport(this._sdk, this._sessionId!, { exports: { id: exportId }, parameters: parameterSet }, maxWaitTime)
             this.updateResponseDto(responseDto);
             return this.exports[exportId];
         } catch (e) {
@@ -708,6 +781,33 @@ export class SessionEngine implements ISessionEngine {
         }
     }
 
+    public resetSettings(sections?: ISettingsSections): void {
+        if (!this._responseDto) {
+            const error = new ShapeDiverViewerSessionError(`Session.resetSettings: responseDto not available.`);
+            throw this._logger.handleError(LOGGING_TOPIC.SESSION, 'Session.resetSettings', error);
+        }
+        try {
+            sections = sections || {};
+            if (sections.session === undefined) {
+                sections.session = {
+                    parameter: { displayname: true, order: true, hidden: true },
+                    export: { displayname: true, order: true, hidden: true }
+                };
+            }
+            if (sections.session.parameter === undefined)
+                sections.session.parameter = { displayname: true, order: true, hidden: true, value: true };
+            if (sections.session.export === undefined)
+                sections.session.export = { displayname: true, order: true, hidden: true };
+            if (sections.viewport === undefined)
+                sections.viewport = { ar: true, scene: true, camera: true, light: true, environment: true, general: true };
+
+            return this.applySettings(this._responseDto, sections);
+        } catch (e) {
+            if (e instanceof ShapeDiverViewerError || e instanceof ShapeDiverBackendError) throw e;
+            throw this._logger.handleError(LOGGING_TOPIC.GENERAL, 'Session.resetSettings', e);
+        }
+    }
+
     public async saveDefaultParameterValues(): Promise<boolean> {
         try {
             this._logger.debugLow(LOGGING_TOPIC.SESSION, `Session(${this.id}).saveDefaultParameters: Saving default parameters.`);
@@ -944,7 +1044,7 @@ export class SessionEngine implements ISessionEngine {
             this.exports[exportId].updateExport();
 
         this._warningCreator();
-        this.node.excludeViewports = this.excludeViewports;
+        this.node.excludeViewports = JSON.parse(JSON.stringify(this._excludeViewports));
 
         for (let r in this._stateEngine.renderingEngines)
             if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
@@ -1100,19 +1200,19 @@ export class SessionEngine implements ISessionEngine {
         return this.customizeSession(this._parameterValues, cancelRequest);
     }
 
-    private async customizeSession(parameters: { [key: string]: string }, cancelRequest: () => boolean, retry = false): Promise<ISessionTreeNode> {
+    private async customizeSession(parameters: { [key: string]: string }, cancelRequest: () => boolean, parallel = false, retry = false): Promise<ISessionTreeNode> {
         this.checkAvailability('customize');
         try {
             this._performanceEvaluator.startSection('sessionResponse');
             const responseDto = await this._sdk.utils.submitAndWaitForCustomization(this._sdk, this._sessionId!, parameters);
             this._performanceEvaluator.endSection('sessionResponse');
             if (cancelRequest()) return new SessionTreeNode();            
-            this.updateResponseDto(responseDto);
-            return this.loadOutputs(cancelRequest);
+            if (parallel === false) this.updateResponseDto(responseDto);
+            return parallel === false ? this.loadOutputs(cancelRequest) : this.loadOutputsParallel(responseDto, cancelRequest);
         } catch (e) {
             await this.handleError(LOGGING_TOPIC.SESSION, 'Session.customizeSession', e, retry);
             if (cancelRequest()) return new SessionTreeNode();
-            return await this.customizeSession(parameters, cancelRequest, true);
+            return await this.customizeSession(parameters, cancelRequest, parallel, true);
         }
     }
 

package/src/index.ts

@@ -1,5 +1,5 @@
 import { SessionEngine } from './implementation/SessionEngine'
-import { ISessionEngine, PARAMETER_TYPE, PARAMETER_VISUALIZATION } from './interfaces/ISessionEngine'
+import { ISessionEngine, ISettingsSections, PARAMETER_TYPE, PARAMETER_VISUALIZATION } from './interfaces/ISessionEngine'
 import { SessionOutputData } from './implementation/SessionOutputData'
 import { SessionData } from './implementation/SessionData'
 import { ISessionData } from './interfaces/ISessionData'
@@ -14,7 +14,7 @@ import { IOutput, ShapeDiverResponseOutputChunk, ShapeDiverResponseOutputContent
 import { IParameter } from './interfaces/dto/IParameter'
 
 export {
-  ISessionData, SessionData, ISessionOutputData, SessionOutputData
+  ISessionData, SessionData, ISessionOutputData, SessionOutputData, ISettingsSections
 }
 
 export {

package/src/interfaces/ISessionEngine.ts

@@ -59,6 +59,44 @@ export enum PARAMETER_VISUALIZATION {
   DIAL = 'dial',
   TEXT = 'text'
 }
+
+export interface ISettingsSections {
+  session?: {
+      parameter?: { 
+          /** Option to update the displayname of the parameters (default: false) */
+          displayname?: boolean, 
+          /** Option to update the order of the parameters (default: false) */
+          order?: boolean, 
+          /** Option to update the hidden state of the parameters (default: false) */
+          hidden?: boolean, 
+          /** Option to update the value of the parameters (default: false) */
+          value?: boolean 
+      },
+      export?: { 
+          /** Option to update the displayname of the exports (default: false) */
+          displayname?: boolean, 
+          /** Option to update the order of the exports (default: false) */
+          order?: boolean, 
+          /** Option to update the hidden state of the exports (default: false) */
+          hidden?: boolean 
+      }
+  },
+  viewport?: {
+      /** Option to update the ar settings (default: false) */
+      ar?: boolean,
+      /** Option to update the scene settings (default: false) */
+      scene?: boolean,
+      /** Option to update the camera settings (default: false) */
+      camera?: boolean,
+      /** Option to update the light settings (default: false) */
+      light?: boolean,
+      /** Option to update the environment settings (default: false) */
+      environment?: boolean
+      /** Option to update the general settings (default: false) */
+      general?: boolean
+  }
+};
+
 export interface ISessionEngine {
   // #region Properties (11)
 
@@ -79,39 +117,19 @@ export interface ISessionEngine {
 
   // #region Public Methods (18)
 
-  applySettings(response: ShapeDiverResponseDto, sections?: {
-    session?: {
-      parameter?: {
-        displayname?: boolean,
-        order?: boolean,
-        hidden?: boolean,
-        value?: boolean
-      },
-      export?: {
-        displayname?: boolean,
-        order?: boolean,
-        hidden?: boolean
-      }
-    },
-    viewport?: {
-      scene?: boolean,
-      camera?: boolean,
-      light?: boolean,
-      environment?: boolean
-    }
-  }): void;
+  applySettings(response: ShapeDiverResponseDto, sections?: ISettingsSections): void;
   canGoBack(): boolean;
   canGoForward(): boolean;
   close(): Promise<void>;
   customize(force: boolean): Promise<ITreeNode>;
-  customizeParallel(parameterValues: { [key: string]: string }, force: boolean): Promise<ITreeNode>;
+  customizeParallel(parameterValues: { [key: string]: string }): Promise<ITreeNode>;
   goBack(): Promise<ITreeNode>;
   goForward(): Promise<ITreeNode>;
-  init(parameterValues?: {
-    [key: string]: string;
-  }): Promise<void>;
+  init(parameterValues?: { [key: string]: string; }): Promise<void>;
   loadOutputs(cancelRequest: () => boolean): Promise<ITreeNode>;
+  loadOutputsParallel(responseDto: ShapeDiverResponseDto, cancelRequest: () => boolean): Promise<ITreeNode>;
   requestExport(exportId: string, parameters: { [key: string]: string }, maxWaitTime: number): Promise<ShapeDiverResponseExport>;
+  resetSettings(sections?: ISettingsSections): void;
   saveDefaultParameterValues(): Promise<boolean>;
   saveSettings(viewportId?: string): Promise<boolean>;
   saveUiProperties(): Promise<boolean>;