@shapediver/viewer.session-engine.session-engine 1.15.6 → 2.0.1

package/src/implementation/SessionOutputData.ts

@@ -0,0 +1,43 @@
+import { ShapeDiverResponseOutput } from '@shapediver/sdk.geometry-api-sdk-v2';
+import { AbstractTreeNodeData, ITreeNodeData } from '@shapediver/viewer.shared.node-tree'
+import { ISessionOutputData } from '../interfaces/ISessionOutputData';
+
+export class SessionOutputData extends AbstractTreeNodeData implements ISessionOutputData {
+    // #region Properties (1)
+
+    #responseOutput: ShapeDiverResponseOutput;
+
+    // #endregion Properties (1)
+
+    // #region Constructors (1)
+
+    constructor(
+        responseOutput: ShapeDiverResponseOutput,
+        id?: string
+    ) {
+        super(id);
+        this.#responseOutput = responseOutput;
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Accessors (2)
+
+    public get responseOutput(): ShapeDiverResponseOutput {
+		return this.#responseOutput;
+	}
+
+    public set responseOutput(value: ShapeDiverResponseOutput) {
+		this.#responseOutput = value;
+	}
+
+    // #endregion Public Accessors (2)
+
+    // #region Public Methods (1)
+
+    public clone(): ISessionOutputData {
+        return new SessionOutputData(this.responseOutput, this.id);
+    }
+
+    // #endregion Public Methods (1)
+}

package/src/implementation/SessionTreeNode.ts

@@ -0,0 +1,41 @@
+import { mat4 } from 'gl-matrix'
+import { ITransformation, ITreeNode, ITreeNodeData, TreeNode } from '@shapediver/viewer.shared.node-tree'
+import { ISessionTreeNode } from '../interfaces/ISessionTreeNode';
+
+export class SessionTreeNode extends TreeNode implements ISessionTreeNode {
+  // #region Properties (1)
+
+  readonly #sessionNode: boolean = true;
+
+  // #endregion Properties (1)
+
+  // #region Constructors (1)
+
+  /**
+   * Special scene graph node for session data. Only to be created internally.
+   * 
+   * @param name the name of the node 
+   * @param parent the parent of this node
+   * @param data the array of data 
+   * @param transformation the array of transformations
+   */
+  constructor(
+    name?: string,
+    parent?: ITreeNode,
+    data?: ITreeNodeData[],
+    transformations?: ITransformation[]
+  ) {
+    super(name, parent, data, transformations);
+  }
+
+  // #endregion Constructors (1)
+
+  // #region Public Accessors (1)
+
+  public get sessionNode(): boolean {
+    return this.#sessionNode;
+  }
+
+  // #endregion Public Accessors (1)
+
+}

package/src/implementation/dto/Export.ts

@@ -0,0 +1,223 @@
+import { ShapeDiverResponseExport, ShapeDiverResponseExportContent, ShapeDiverResponseExportDefinitionType, ShapeDiverResponseExportResult, ShapeDiverResponseModelComputationStatus, ShapeDiverResponseParameterGroup } from "@shapediver/sdk.geometry-api-sdk-v2";
+import { container } from "tsyringe";
+import { EventEngine, EVENTTYPE, InputValidator, Logger, LOGGING_TOPIC, ShapeDiverBackendError, ShapeDiverViewerError, UuidGenerator } from "@shapediver/viewer.shared.services";
+import { ITaskEvent, TASK_TYPE } from "@shapediver/viewer.shared.types";
+import { IExport } from "../../interfaces/dto/IExport";
+import { SessionEngine } from "../SessionEngine";
+
+export class Export implements IExport {
+  // #region Properties (24)
+
+  readonly #eventEngine: EventEngine = <EventEngine>container.resolve(EventEngine);
+  readonly #id: string;
+  readonly #inputValidator: InputValidator = <InputValidator>container.resolve(InputValidator);
+  readonly #logger: Logger = <Logger>container.resolve(Logger);
+  readonly #name: string;
+  readonly #sessionEngine: SessionEngine;
+  readonly #type: ShapeDiverResponseExportDefinitionType;
+  readonly #uuidGenerator: UuidGenerator = <UuidGenerator>container.resolve(UuidGenerator);
+
+  #content?: ShapeDiverResponseExportContent[];
+  #delay?: number;
+  #dependency!: string[];
+  #displayname?: string;
+  #filename?: string;
+  #group?: ShapeDiverResponseParameterGroup;
+  #hidden: boolean = false;
+  #maxWaitTime: number = 300000;
+  #msg?: string
+  #order?: number;
+  #result?: ShapeDiverResponseExportResult
+  #status_collect?: ShapeDiverResponseModelComputationStatus;
+  #status_computation?: ShapeDiverResponseModelComputationStatus;
+  #tooltip?: string;
+  #uid?: string;
+  #version?: string;
+
+  // #endregion Properties (24)
+
+  // #region Constructors (1)
+
+  constructor(exportDef: ShapeDiverResponseExport, sessionEngine: SessionEngine) {
+    this.#sessionEngine = sessionEngine;
+    this.#id = exportDef.id;
+    this.#name = exportDef.name;
+    this.#type = exportDef.type;
+
+    this.updateExportDefinition(exportDef);
+  }
+
+  // #endregion Constructors (1)
+
+  // #region Public Accessors (24)
+
+  public get content(): ShapeDiverResponseExportContent[] | undefined {
+    return this.#content;
+  }
+
+  public get delay(): number | undefined {
+    return this.#delay;
+  }
+
+  public get dependency(): string[] {
+    return this.#dependency;
+  }
+
+  public get displayname(): string | undefined {
+    return this.#displayname;
+  }
+
+  public set displayname(value: string | undefined) {
+    this.#displayname = value;
+  }
+
+  public get filename(): string | undefined {
+    return this.#filename;
+  }
+
+  public get group(): ShapeDiverResponseParameterGroup | undefined {
+    return this.#group;
+  }
+
+  public get hidden(): boolean {
+    return this.#hidden;
+  }
+
+  public set hidden(value: boolean) {
+    this.#hidden = value;
+  }
+
+  public get id(): string {
+    return this.#id;
+  }
+
+  public get maxWaitTime(): number {
+    return this.#maxWaitTime;
+  }
+
+  public set maxWaitTime(value: number) {
+    this.#maxWaitTime = value;
+  }
+
+  public get msg(): string | undefined {
+    return this.#msg;
+  }
+
+  public get name(): string {
+    return this.#name;
+  }
+
+  public get order(): number | undefined {
+    return this.#order;
+  }
+
+  public set order(value: number | undefined) {
+    this.#order = value;
+  }
+
+  public get result(): ShapeDiverResponseExportResult | undefined {
+    return this.#result;
+  }
+
+  public get status_collect(): ShapeDiverResponseModelComputationStatus | undefined {
+    return this.#status_collect;
+  }
+
+  public get status_computation(): ShapeDiverResponseModelComputationStatus | undefined {
+    return this.#status_computation;
+  }
+
+  public get tooltip(): string | undefined {
+    return this.#tooltip;
+  }
+
+  public set tooltip(value: string | undefined) {
+    this.#tooltip = value;
+  }
+
+  public get type(): ShapeDiverResponseExportDefinitionType {
+    return this.#type;
+  }
+
+  public get uid(): string | undefined {
+    return this.#uid;
+  }
+
+  public get version(): string | undefined {
+    return this.#version;
+  }
+
+  // #endregion Public Accessors (24)
+
+  // #region Public Methods (3)
+
+  public async request(parameters: { [key: string]: string } = {}): Promise<ShapeDiverResponseExport> {
+    const eventId = this.#uuidGenerator.create();
+    try {
+      const event: ITaskEvent = { type: TASK_TYPE.EXPORT_REQUEST, id: eventId, progress: 0, status: 'Requesting export' };
+      this.#eventEngine.emitEvent(EVENTTYPE.TASK.TASK_START, event);
+
+      this.#logger.debugLow(LOGGING_TOPIC.EXPORT, `Export(${this.#id}).request: Sending export request.`);
+      const currentParameters = this.#sessionEngine.parameterValues;
+      const exportParameters: { [key: string]: string } = {}
+
+      for (let parameter in currentParameters)
+        exportParameters[parameter] = parameters[parameter] || parameters[parameter] === '' ? parameters[parameter] : currentParameters[parameter];
+
+      this.#logger.info(LOGGING_TOPIC.EXPORT, `Export(${this.#id}).request: Sending export request with parameters ${JSON.stringify(exportParameters)}.`);
+
+      const exportDef = await this.#sessionEngine.requestExport(this.id, exportParameters, this.#maxWaitTime);
+      this.updateExportDefinition(exportDef);
+
+      const eventEnd: ITaskEvent = { type: TASK_TYPE.EXPORT_REQUEST, id: eventId, progress: 1, status: 'Returning export' };
+      this.#eventEngine.emitEvent(EVENTTYPE.TASK.TASK_END, eventEnd);
+
+      return exportDef;
+    } catch (e) {
+      const eventEnd: ITaskEvent = { type: TASK_TYPE.EXPORT_REQUEST, id: eventId, progress: 1, status: 'Export request failed' };
+      this.#eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventEnd);
+
+      if (e instanceof ShapeDiverViewerError || e instanceof ShapeDiverBackendError) throw e;
+      throw this.#logger.handleError(LOGGING_TOPIC.EXPORT, `Export(${this.#id}).request`, e);
+    }
+  }
+
+  public updateExport() {
+    const exportDef = this.#sessionEngine.exports[this.id];
+    this.#dependency = exportDef.dependency;
+    this.#uid = exportDef.uid;
+    this.#displayname = exportDef.displayname;
+    this.#order = exportDef.order;
+    this.#hidden = exportDef.hidden;
+    this.#tooltip = exportDef.tooltip;
+    this.#version = exportDef.version;
+    this.#delay = exportDef.delay;
+    this.#content = exportDef.content;
+    this.#msg = exportDef.msg;
+    this.#filename = exportDef.filename;
+    this.#result = exportDef.result;
+    this.#status_computation = exportDef.status_computation;
+    this.#status_collect = exportDef.status_collect;
+    this.#group = exportDef.group;
+  }
+
+  public updateExportDefinition(exportDef: ShapeDiverResponseExport) {
+    this.#dependency = exportDef.dependency;
+    this.#uid = exportDef.uid;
+    this.#displayname = exportDef.displayname;
+    this.#order = exportDef.order;
+    this.#hidden = exportDef.hidden;
+    this.#tooltip = exportDef.tooltip;
+    this.#version = exportDef.version;
+    this.#delay = exportDef.delay;
+    this.#content = exportDef.content;
+    this.#msg = exportDef.msg;
+    this.#filename = exportDef.filename;
+    this.#result = exportDef.result;
+    this.#status_computation = exportDef.status_computation;
+    this.#status_collect = exportDef.status_collect;
+    this.#group = exportDef.group;
+  }
+
+  // #endregion Public Methods (3)
+}

package/src/implementation/dto/FileParameter.ts

@@ -0,0 +1,71 @@
+import { ShapeDiverResponseParameter } from "@shapediver/sdk.geometry-api-sdk-v2";
+import { Logger, LOGGING_TOPIC, ShapeDiverViewerSessionError, UuidGenerator } from "@shapediver/viewer.shared.services";
+import { container } from "tsyringe";
+import { IFileParameter } from "../../interfaces/dto/IFileParameter";
+import { Parameter } from "./Parameter";
+import * as MimeTypeUtils from "@shapediver/viewer.utils.mime-type"
+import { SessionEngine } from "../SessionEngine";
+
+export class FileParameter extends Parameter<File | Blob | string> implements IFileParameter {
+    // #region Properties (5)
+
+    readonly #logger: Logger = <Logger>container.resolve(Logger);
+    readonly #sessionEngine: SessionEngine;
+    readonly #uuidGenerator: UuidGenerator = <UuidGenerator>container.resolve(UuidGenerator);
+
+    // #endregion Properties (5)
+
+    // #region Constructors (1)
+
+    constructor(paramDef: ShapeDiverResponseParameter, sessionEngine: SessionEngine) {
+        super(paramDef, sessionEngine);
+        this.#sessionEngine = sessionEngine;
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Methods (1)
+
+    public async upload() {
+        if (!this.value) return this.defval;
+        if (typeof this.value === 'string' && this.value.length === 36 && this.#uuidGenerator.validate(this.value)) return this.value;
+
+        const data = new File(
+            [
+                typeof this.value === 'string' ?
+                    new Blob([this.value], { type: 'text/plain' }) :
+                    this.value
+            ],
+            'upload',
+            { type: (<Blob | File>this.value).type }
+        );
+
+        let types = [data.type];
+        // get all endings that are possible for this type
+        const endings = MimeTypeUtils.mapMimeTypeToFileEndings(types);
+        // get all mimeTypes that are possible for these endings
+        endings.forEach((e: string) => types = types.concat(MimeTypeUtils.guessMimeTypeFromFilename(e)));
+
+        let type: string;
+        // check if one of the mime types is allowed
+        let allowedType = false;
+        for (let i = 0; i < types.length; i++) {
+            if (this.format?.includes(types[i])) {
+                allowedType = true;
+                type = types[i];
+                break;
+            }
+        }
+
+        if (!allowedType) {
+            const error = new ShapeDiverViewerSessionError(`Parameter(${this.id}).upload: Error uploading FileParameter, type of data (${data.type}) is not a valid type. Has to be ${this.format}.`);
+            throw this.#logger.handleError(LOGGING_TOPIC.PARAMETER, `Parameter(${this.id}).upload`, error);
+        }
+
+        this.#logger.debug(LOGGING_TOPIC.PARAMETER, `Parameter(${this.id}).upload: Uploading FileParameter.`);
+
+        return await this.#sessionEngine.uploadFile(this.id, data, type!)
+    }
+
+    // #endregion Public Methods (1)
+}

package/src/implementation/dto/Output.ts

@@ -0,0 +1,221 @@
+import { ShapeDiverResponseModelComputationStatus, ShapeDiverResponseOutput } from "@shapediver/sdk.geometry-api-sdk-v2";
+import { container } from "tsyringe";
+import { ITreeNode, TreeNode } from "@shapediver/viewer.shared.node-tree";
+import { InputValidator, UuidGenerator, LOGGING_TOPIC, ShapeDiverViewerError, ShapeDiverBackendError, Logger } from "@shapediver/viewer.shared.services";
+import { IOutput, ShapeDiverResponseOutputContent, ShapeDiverResponseOutputChunk } from "../../interfaces/dto/IOutput";
+import { SessionEngine } from "../SessionEngine";
+
+export class Output implements IOutput {
+  // #region Properties (23)
+
+  readonly #id: string;
+  readonly #inputValidator: InputValidator = <InputValidator>container.resolve(InputValidator);
+  readonly #logger: Logger = <Logger>container.resolve(Logger);
+  readonly #name: string;
+  readonly #sessionEngine: SessionEngine;
+  readonly #uuidGenerator: UuidGenerator = <UuidGenerator>container.resolve(UuidGenerator);
+
+  #bbmax?: number[];
+  #bbmin?: number[];
+  #chunks?: ShapeDiverResponseOutputChunk[];
+  #content?: ShapeDiverResponseOutputContent[];
+  #delay?: number;
+  #dependency!: string[];
+  #displayname?: string;
+  #hidden: boolean = false;
+  #material?: string;
+  #msg?: string;
+  #order?: number;
+  #status_collect?: ShapeDiverResponseModelComputationStatus;
+  #status_computation?: ShapeDiverResponseModelComputationStatus;
+  #tooltip?: string;
+  #uid?: string;
+  #updateCallback: ((newNode?: ITreeNode, oldNode?: ITreeNode) => void) | null = null;
+  #version: string;
+
+  // #endregion Properties (23)
+
+  // #region Constructors (1)
+
+  constructor(outputDef: ShapeDiverResponseOutput, sessionEngine: SessionEngine) {
+    this.#sessionEngine = sessionEngine;
+
+    this.#id = outputDef.id;
+    this.#name = outputDef.name;
+    this.#version = outputDef.version;
+    this.updateOutputDefinition(outputDef);
+  }
+
+  // #endregion Constructors (1)
+
+  // #region Public Accessors (28)
+
+  public get bbmax(): number[] | undefined {
+    return this.#bbmax;
+  }
+
+  public get bbmin(): number[] | undefined {
+    return this.#bbmin;
+  }
+
+  public get chunks(): ShapeDiverResponseOutputChunk[] | undefined {
+    return this.#chunks;
+  }
+
+  public get content(): ShapeDiverResponseOutputContent[] | undefined {
+    return this.#content;
+  }
+
+  public set content(value: ShapeDiverResponseOutputContent[] | undefined) {
+    this.#content = value;
+  }
+
+  public get delay(): number | undefined {
+    return this.#delay;
+  }
+
+  public get dependency(): string[] {
+    return this.#dependency;
+  }
+
+  public get displayname(): string | undefined {
+    return this.#displayname;
+  }
+
+  public set displayname(value: string | undefined) {
+    this.#displayname = value;
+  }
+
+  public get format(): string[] {
+    return this.#content ? this.#content.map(c => c.format) : [];
+  }
+
+  public get freeze(): boolean {
+    return this.#sessionEngine.outputsFreeze[this.#id];
+  }
+
+  public set freeze(value: boolean) {
+    this.#sessionEngine.outputsFreeze[this.#id] = value;
+  }
+
+  public get hidden(): boolean {
+    return this.#hidden;
+  }
+
+  public set hidden(value: boolean) {
+    this.#hidden = value;
+  }
+
+  public get id(): string {
+    return this.#id;
+  }
+
+  public get material(): string | undefined {
+    return this.#material;
+  }
+
+  public get msg(): string | undefined {
+    return this.#msg;
+  }
+
+  public get name(): string {
+    return this.#name;
+  }
+
+  public get node(): ITreeNode {
+    return this.#sessionEngine.node.children.find(c => c.name === this.id)!;
+  }
+
+  public get order(): number | undefined {
+    return this.#order;
+  }
+
+  public set order(value: number | undefined) {
+    this.#order = value;
+  }
+
+  public get status_collect(): ShapeDiverResponseModelComputationStatus | undefined {
+    return this.#status_collect;
+  }
+
+  public get status_computation(): ShapeDiverResponseModelComputationStatus | undefined {
+    return this.#status_computation;
+  }
+
+  public get tooltip(): string | undefined {
+    return this.#tooltip;
+  }
+
+  public set tooltip(value: string | undefined) {
+    this.#tooltip = value;
+  }
+
+  public get uid(): string | undefined {
+    return this.#uid;
+  }
+
+  public get updateCallback(): ((newNode?: ITreeNode, oldNode?: ITreeNode) => void) | null {
+    return this.#updateCallback;
+  }
+
+  public set updateCallback(value: ((newNode?: ITreeNode, oldNode?: ITreeNode) => void) | null) {
+    this.#updateCallback = value;
+  }
+
+  public get version(): string {
+    return this.#version;
+  }
+
+  public set version(value: string) {
+    this.#version = value;
+  }
+
+  // #endregion Public Accessors (28)
+
+  // #region Public Methods (3)
+
+  public updateOutput(newNode?: TreeNode, oldNode?: TreeNode) {
+    const outputDef = this.#sessionEngine.outputs[this.id];
+    this.updateOutputDefinition(outputDef);
+
+    // add chunk nodes
+    if (this.chunks && newNode) {
+      for (let i = 0; i < newNode.children.length; i++) {
+        for (let j = 0; j < this.chunks.length; j++) {
+          this.chunks[j].node = newNode.children[i].children.find(child => child.name === this.chunks![j].id);
+        }
+      }
+    }
+
+    if (this.#updateCallback) this.#updateCallback(newNode, oldNode);
+  }
+
+  public async updateOutputContent(outputContent: ShapeDiverResponseOutputContent[], preventUpdate: boolean = false): Promise<ITreeNode | undefined> {
+    this.#sessionEngine.outputs[this.id].content = outputContent;
+    this.#sessionEngine.outputs[this.id].version = this.#uuidGenerator.create();
+    if (!preventUpdate) await this.#sessionEngine.updateOutputs();
+    return this.node;
+  }
+
+  public updateOutputDefinition(outputDef: ShapeDiverResponseOutput) {
+    this.#dependency = outputDef.dependency;
+    this.#uid = outputDef.uid;
+    this.#material = outputDef.material;
+    this.#chunks = outputDef.chunks;
+    this.#msg = outputDef.msg;
+    if (this.#msg !== undefined)
+      this.#logger.warn(LOGGING_TOPIC.OUTPUT, `Output(${this.id}): ${this.#msg}`);
+    this.#bbmin = outputDef.bbmin;
+    this.#bbmax = outputDef.bbmax;
+    this.#status_computation = outputDef.status_computation;
+    this.#status_collect = outputDef.status_collect;
+    this.#content = outputDef.content;
+    this.#delay = outputDef.delay;
+    this.#version = outputDef.version;
+    this.#displayname = outputDef.displayname;
+    this.#order = outputDef.order;
+    this.#hidden = outputDef.hidden;
+  }
+
+  // #endregion Public Methods (3)
+}