@smarterplan/ngx-smarterplan-core 1.4.15 → 1.4.17

package/esm2022/lib/services/tag.service.mjs

@@ -56,27 +56,27 @@ export class BaseTagService {
       throw new Error('updatePoiMetadata is not implemented in the base class.');
     }*/
     async prepareEquipmentHtml(equip) {
-        throw new Error(`prepareEquipmentHtml is not implemented in the base class.
+        throw new Error(`prepareEquipmentHtml is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     async prepareTicketHtml(ticket) {
-        throw new Error(`prepareTicketHtml is not implemented in the base class.
+        throw new Error(`prepareTicketHtml is not implemented in the base class.
                          Please override this method in your extended class.`);
     }
     async prepareFeatureHtml(feature) {
-        throw new Error(`prepareFeatureHtml is not implemented in the base class.
+        throw new Error(`prepareFeatureHtml is not implemented in the base class.
                          Please override this method in your extended class.`);
     }
     async prepareMeasurementHtml(measure) {
-        throw new Error(`prepareMeasurementHtml is not implemented in the base class.
+        throw new Error(`prepareMeasurementHtml is not implemented in the base class.
                          Please override this method in your extended class.`);
     }
     async prepareDeskHtml(feature) {
-        throw new Error(`prepareDeskHtml is not implemented in the base class.
+        throw new Error(`prepareDeskHtml is not implemented in the base class.
                          Please override this method in your extended class.`);
     }
     async prepareIndicatorHtml(feature) {
-        throw new Error(`prepareDeskHtml is not implemented in the base class.
+        throw new Error(`prepareDeskHtml is not implemented in the base class.
                          Please override this method in your extended class.`);
     }
     async getSignedTagIconSource(tagIconSrc) {
@@ -85,15 +85,15 @@ export class BaseTagService {
     getIconTagImageForFeature(feature, poi) {
         // const tagIcon = JSON.parse(poi.tagIcon);
         // return tagIcon.src;
-        throw new Error(`getIconTagImageForFeature is not implemented in the base class.
+        throw new Error(`getIconTagImageForFeature is not implemented in the base class.
                          Please override this method in your extended class.`);
     }
     getScriptForTag(object, tagType) {
-        throw new Error(`getScriptForTag is not implemented in the base class.
+        throw new Error(`getScriptForTag is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     getAnnexeForCommentTypeInFeature(feature, commentType) {
-        throw new Error(`getAnnexeForCommentTypeInFeature is not implemented in the base class.
+        throw new Error(`getAnnexeForCommentTypeInFeature is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     getBillboardMediaToEmbed(object) {
@@ -102,27 +102,27 @@ export class BaseTagService {
         return { comment: null, tagDescription: '' };
     }
     onActionDetailClick(url) {
-        throw new Error(`onActionDetailClick is not implemented in the base class.
+        throw new Error(`onActionDetailClick is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     onActionAudioClick(audioCommentID) {
-        throw new Error(`onActionDetailClick is not implemented in the base class.
+        throw new Error(`onActionDetailClick is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     onActionVideoClick(url) {
-        throw new Error(`onActionVideoClick is not implemented in the base class.
+        throw new Error(`onActionVideoClick is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     onActionImageClick(imageCommentID) {
-        throw new Error(`onActionImageClick is not implemented in the base class.
+        throw new Error(`onActionImageClick is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     onActionDocClick(url) {
-        throw new Error(`onActionDocClick is not implemented in the base class.
+        throw new Error(`onActionDocClick is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     onActionYoutubeClick(url) {
-        throw new Error(`onActionYoutubeClick is not implemented in the base class.
+        throw new Error(`onActionYoutubeClick is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseTagService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
@@ -134,4 +134,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tag.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/tag.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-case-declarations */\r\n/* eslint-disable class-methods-use-this */\r\nimport { Injectable } from '@angular/core';\r\nimport {\r\n  Comment,\r\n  DbObjectType,\r\n  Equipment,\r\n  Feature,\r\n  POI,\r\n  PoiType,\r\n  TagAction,\r\n  Ticket,\r\n  CommentType,\r\n} from '../types.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\n\r\nexport class BaseTagService {\r\n  constructor() { }\r\n\r\n  /** Base implementation for generating tag HTML. Override in derived classes. */\r\n  async getHtmlToInject(\r\n    tagType: PoiType,\r\n    object: DbObjectType\r\n  ): Promise<string> {\r\n    return \"\";\r\n  }\r\n\r\n  /** Base implementation for injecting HTML into a tag container. */\r\n  async injectHtml(container: HTMLElement, tagType: PoiType, object: DbObjectType): Promise<void> {\r\n    if (!container) {\r\n      console.warn('injectHtml: container is null');\r\n      return;\r\n    }\r\n    try {\r\n      const html = await this.getHtmlToInject(tagType, object);\r\n      if (!html || html.trim().length === 0) {\r\n        console.warn(`Empty HTML returned for ${tagType}`);\r\n        container.innerHTML = `<div class=\"tag-div\" style=\"color: white; padding: 10px;\">Base implementation: No content for ${tagType}</div>`;\r\n      } else {\r\n        container.innerHTML = html;\r\n      }\r\n    } catch (error: any) {\r\n      console.error('Error in injectHtml:', error);\r\n      container.innerHTML = `<div class=\"tag-div\" style=\"color: white; padding: 10px;\">Error: ${error.message}</div>`;\r\n    }\r\n  }\r\n\r\n  /** Returns the navigation URL for viewing details of a specific object type. */\r\n  getUrlForSeeDetails(object: DbObjectType, tagType: PoiType): string {\r\n    switch (tagType) {\r\n      case PoiType.TICKET: {\r\n        return `visit/${object.spaceID}/detail/${object.id}`;\r\n      }\r\n      case PoiType.EQUIPMENT: {\r\n        return `visit/${object.spaceID}/equip/${object.id}`;\r\n      }\r\n      case PoiType.MEASURE: {\r\n        return `visit/${object.spaceID}/measurement/${object.id}`;\r\n      }\r\n      case PoiType.DATA: {\r\n        return `visit/${object.spaceID}/feature/${object.id}`;\r\n      }\r\n      case PoiType.DESK: {\r\n        return `visit/${object.spaceID}/add_booking/${object.id}`;\r\n      }\r\n      default:\r\n        return '';\r\n    }\r\n  }\r\n\r\n  /*async updatePoiMetadata(poiId: string, metadata: string): Promise<void> {\r\n    throw new Error('updatePoiMetadata is not implemented in the base class.');\r\n  }*/\r\n\r\n  async prepareEquipmentHtml(equip: Equipment): Promise<string> {\r\n    throw new Error(`prepareEquipmentHtml is not implemented in the base class.\r\n        Please override this method in your extended class.`);\r\n  }\r\n\r\n  async prepareTicketHtml(ticket: Ticket): Promise<string> {\r\n    throw new Error(`prepareTicketHtml is not implemented in the base class.\r\n                         Please override this method in your extended class.`);\r\n  }\r\n\r\n  async prepareFeatureHtml(feature: Feature): Promise<string> {\r\n    throw new Error(`prepareFeatureHtml is not implemented in the base class.\r\n                         Please override this method in your extended class.`);\r\n  }\r\n\r\n  async prepareMeasurementHtml(measure: Comment): Promise<string> {\r\n    throw new Error(`prepareMeasurementHtml is not implemented in the base class.\r\n                         Please override this method in your extended class.`);\r\n  }\r\n\r\n  async prepareDeskHtml(feature: Feature): Promise<string> {\r\n    throw new Error(`prepareDeskHtml is not implemented in the base class.\r\n                         Please override this method in your extended class.`);\r\n  }\r\n\r\n  async prepareIndicatorHtml(feature: Feature): Promise<string> {\r\n    throw new Error(`prepareDeskHtml is not implemented in the base class.\r\n                         Please override this method in your extended class.`);\r\n  }\r\n\r\n  async getSignedTagIconSource(tagIconSrc: string): Promise<string | null> {\r\n    throw new Error(\r\n      `getSignedTagIconSource is not implemented in the base class.`\r\n    );\r\n  }\r\n\r\n  getIconTagImageForFeature(feature: DbObjectType, poi: POI): string {\r\n    // const tagIcon = JSON.parse(poi.tagIcon);\r\n    // return tagIcon.src;\r\n    throw new Error(`getIconTagImageForFeature is not implemented in the base class.\r\n                         Please override this method in your extended class.`);\r\n  }\r\n\r\n  getScriptForTag(object, tagType: PoiType): string {\r\n    throw new Error(`getScriptForTag is not implemented in the base class.\r\n        Please override this method in your extended class.`);\r\n  }\r\n  getAnnexeForCommentTypeInFeature(\r\n    feature: Feature,\r\n    commentType: CommentType\r\n  ): string {\r\n    throw new Error(`getAnnexeForCommentTypeInFeature is not implemented in the base class.\r\n        Please override this method in your extended class.`);\r\n  }\r\n\r\n  getBillboardMediaToEmbed(object: DbObjectType): {\r\n    comment: Comment;\r\n    tagDescription: string;\r\n  } {\r\n    // Default implementation to prevent crash if base class is instantiated directly.\r\n    // Extended classes should override this method.\r\n    return { comment: null, tagDescription: '' };\r\n  }\r\n\r\n  onActionDetailClick(url: string) {\r\n    throw new Error(`onActionDetailClick is not implemented in the base class.\r\n        Please override this method in your extended class.`);\r\n  }\r\n\r\n  onActionAudioClick(audioCommentID: string) {\r\n    throw new Error(`onActionDetailClick is not implemented in the base class.\r\n        Please override this method in your extended class.`);\r\n  }\r\n\r\n  onActionVideoClick(url: string) {\r\n    throw new Error(`onActionVideoClick is not implemented in the base class.\r\n        Please override this method in your extended class.`);\r\n  }\r\n\r\n  onActionImageClick(imageCommentID: string) {\r\n    throw new Error(`onActionImageClick is not implemented in the base class.\r\n        Please override this method in your extended class.`);\r\n  }\r\n\r\n  onActionDocClick(url: string) {\r\n    throw new Error(`onActionDocClick is not implemented in the base class.\r\n        Please override this method in your extended class.`);\r\n  }\r\n\r\n  onActionYoutubeClick(url: string) {\r\n    throw new Error(`onActionYoutubeClick is not implemented in the base class.\r\n        Please override this method in your extended class.`);\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tag.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/tag.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-case-declarations */\n/* eslint-disable class-methods-use-this */\nimport { Injectable } from '@angular/core';\nimport {\n  Comment,\n  DbObjectType,\n  Equipment,\n  Feature,\n  POI,\n  PoiType,\n  TagAction,\n  Ticket,\n  CommentType,\n} from '../types.service';\n\n@Injectable({\n  providedIn: 'root',\n})\n\nexport class BaseTagService {\n  constructor() { }\n\n  /** Base implementation for generating tag HTML. Override in derived classes. */\n  async getHtmlToInject(\n    tagType: PoiType,\n    object: DbObjectType\n  ): Promise<string> {\n    return \"\";\n  }\n\n  /** Base implementation for injecting HTML into a tag container. */\n  async injectHtml(container: HTMLElement, tagType: PoiType, object: DbObjectType): Promise<void> {\n    if (!container) {\n      console.warn('injectHtml: container is null');\n      return;\n    }\n    try {\n      const html = await this.getHtmlToInject(tagType, object);\n      if (!html || html.trim().length === 0) {\n        console.warn(`Empty HTML returned for ${tagType}`);\n        container.innerHTML = `<div class=\"tag-div\" style=\"color: white; padding: 10px;\">Base implementation: No content for ${tagType}</div>`;\n      } else {\n        container.innerHTML = html;\n      }\n    } catch (error: any) {\n      console.error('Error in injectHtml:', error);\n      container.innerHTML = `<div class=\"tag-div\" style=\"color: white; padding: 10px;\">Error: ${error.message}</div>`;\n    }\n  }\n\n  /** Returns the navigation URL for viewing details of a specific object type. */\n  getUrlForSeeDetails(object: DbObjectType, tagType: PoiType): string {\n    switch (tagType) {\n      case PoiType.TICKET: {\n        return `visit/${object.spaceID}/detail/${object.id}`;\n      }\n      case PoiType.EQUIPMENT: {\n        return `visit/${object.spaceID}/equip/${object.id}`;\n      }\n      case PoiType.MEASURE: {\n        return `visit/${object.spaceID}/measurement/${object.id}`;\n      }\n      case PoiType.DATA: {\n        return `visit/${object.spaceID}/feature/${object.id}`;\n      }\n      case PoiType.DESK: {\n        return `visit/${object.spaceID}/add_booking/${object.id}`;\n      }\n      default:\n        return '';\n    }\n  }\n\n  /*async updatePoiMetadata(poiId: string, metadata: string): Promise<void> {\n    throw new Error('updatePoiMetadata is not implemented in the base class.');\n  }*/\n\n  async prepareEquipmentHtml(equip: Equipment): Promise<string> {\n    throw new Error(`prepareEquipmentHtml is not implemented in the base class.\n        Please override this method in your extended class.`);\n  }\n\n  async prepareTicketHtml(ticket: Ticket): Promise<string> {\n    throw new Error(`prepareTicketHtml is not implemented in the base class.\n                         Please override this method in your extended class.`);\n  }\n\n  async prepareFeatureHtml(feature: Feature): Promise<string> {\n    throw new Error(`prepareFeatureHtml is not implemented in the base class.\n                         Please override this method in your extended class.`);\n  }\n\n  async prepareMeasurementHtml(measure: Comment): Promise<string> {\n    throw new Error(`prepareMeasurementHtml is not implemented in the base class.\n                         Please override this method in your extended class.`);\n  }\n\n  async prepareDeskHtml(feature: Feature): Promise<string> {\n    throw new Error(`prepareDeskHtml is not implemented in the base class.\n                         Please override this method in your extended class.`);\n  }\n\n  async prepareIndicatorHtml(feature: Feature): Promise<string> {\n    throw new Error(`prepareDeskHtml is not implemented in the base class.\n                         Please override this method in your extended class.`);\n  }\n\n  async getSignedTagIconSource(tagIconSrc: string): Promise<string | null> {\n    throw new Error(\n      `getSignedTagIconSource is not implemented in the base class.`\n    );\n  }\n\n  getIconTagImageForFeature(feature: DbObjectType, poi: POI): string {\n    // const tagIcon = JSON.parse(poi.tagIcon);\n    // return tagIcon.src;\n    throw new Error(`getIconTagImageForFeature is not implemented in the base class.\n                         Please override this method in your extended class.`);\n  }\n\n  getScriptForTag(object, tagType: PoiType): string {\n    throw new Error(`getScriptForTag is not implemented in the base class.\n        Please override this method in your extended class.`);\n  }\n  getAnnexeForCommentTypeInFeature(\n    feature: Feature,\n    commentType: CommentType\n  ): string {\n    throw new Error(`getAnnexeForCommentTypeInFeature is not implemented in the base class.\n        Please override this method in your extended class.`);\n  }\n\n  getBillboardMediaToEmbed(object: DbObjectType): {\n    comment: Comment;\n    tagDescription: string;\n  } {\n    // Default implementation to prevent crash if base class is instantiated directly.\n    // Extended classes should override this method.\n    return { comment: null, tagDescription: '' };\n  }\n\n  onActionDetailClick(url: string) {\n    throw new Error(`onActionDetailClick is not implemented in the base class.\n        Please override this method in your extended class.`);\n  }\n\n  onActionAudioClick(audioCommentID: string) {\n    throw new Error(`onActionDetailClick is not implemented in the base class.\n        Please override this method in your extended class.`);\n  }\n\n  onActionVideoClick(url: string) {\n    throw new Error(`onActionVideoClick is not implemented in the base class.\n        Please override this method in your extended class.`);\n  }\n\n  onActionImageClick(imageCommentID: string) {\n    throw new Error(`onActionImageClick is not implemented in the base class.\n        Please override this method in your extended class.`);\n  }\n\n  onActionDocClick(url: string) {\n    throw new Error(`onActionDocClick is not implemented in the base class.\n        Please override this method in your extended class.`);\n  }\n\n  onActionYoutubeClick(url: string) {\n    throw new Error(`onActionYoutubeClick is not implemented in the base class.\n        Please override this method in your extended class.`);\n  }\n}\n"]}

package/esm2022/lib/services/threejs-import.service.mjs

@@ -0,0 +1,151 @@
+import { Injectable } from '@angular/core';
+import { removeNullKeysFromObject, parseThreeJsPlacement } from '../helpers.service';
+import { LevelStatus, } from '../types.service';
+import { v4 as uuidv4 } from 'uuid';
+import * as i0 from "@angular/core";
+import * as i1 from "./models/navigation.service";
+import * as i2 from "./models/zone.service";
+import * as i3 from "./models/layer.service";
+import * as i4 from "./user.service";
+import * as i5 from "./models/plan.service";
+/** File extensions the Three.js viewer can load as a base model. */
+const SUPPORTED_MODEL_EXTENSIONS = ['.glb', '.gltf'];
+export class ThreeJsImportService {
+    navigationService;
+    zoneService;
+    layerService;
+    userService;
+    planService;
+    _spaceID;
+    get spaceID() {
+        return this._spaceID;
+    }
+    set spaceID(value) {
+        this._spaceID = value;
+    }
+    constructor(navigationService, zoneService, layerService, userService, planService) {
+        this.navigationService = navigationService;
+        this.zoneService = zoneService;
+        this.layerService = layerService;
+        this.userService = userService;
+        this.planService = planService;
+    }
+    /**
+     * Checks that an S3 key points at something the viewer can actually load.
+     *
+     * Returns the reason it can't, or null when it's fine. This runs before anything is written, so a
+     * mistyped key fails on the form rather than creating zones and navigation for a model that will
+     * 404 the first time someone opens the visit.
+     */
+    validateModelKey(key) {
+        if (!key || !key.trim()) {
+            return 'A 3D model file (.glb) is required for a Three.js visit.';
+        }
+        const trimmed = key.trim();
+        if (!SUPPORTED_MODEL_EXTENSIONS.some((extension) => trimmed.toLowerCase().endsWith(extension))) {
+            return `The 3D model must be a ${SUPPORTED_MODEL_EXTENSIONS.join(' or ')} file.`;
+        }
+        // A full https:// URL is a signed link that expires; the stored value has to be the key itself
+        // so a fresh URL can be signed on every visit.
+        if (/^https?:\/\//i.test(trimmed)) {
+            return 'Enter the S3 key of the file (e.g. visits/my-model.glb), not a full URL.';
+        }
+        return null;
+    }
+    async importData(spaceID, surface, reloading = false, node = null, overrideExisting = true, placementMetadata = null) {
+        if (reloading) {
+            // Reloading is not fully applicable to static 3D models the same way as Matterport
+            return Promise.resolve(true);
+        }
+        const keyError = this.validateModelKey(node?.model3D);
+        if (keyError) {
+            return Promise.reject(new Error(keyError));
+        }
+        this.spaceID = spaceID;
+        const zones = await this.zoneService.getZonesBySpace(spaceID);
+        const mainZone = zones.find((z) => !z.parentID);
+        if (!mainZone) {
+            return Promise.reject(new Error('Missing data (no main Building Zone)'));
+        }
+        console.log('[ThreeJsImportService] Importing data for Three.js model');
+        // 1. Check/create layer of building type
+        const layerBuilding = await this.getLayerByName('BUILDING');
+        // We generate a dummy ID to act as our single "sweep" equivalent
+        const dummySweepID = uuidv4();
+        // 2. Create the default Zone
+        const createdDefaultZone = await this.createZone(node.metadata || 'Three.js 3D Model', layerBuilding.id, surface, mainZone.id, [dummySweepID], node);
+        if (!createdDefaultZone) {
+            return Promise.resolve(false);
+        }
+        // 3. Create a blank Plan for the model (to ensure consistency in the app structure)
+        const plan = {
+            name: `plan_threejs_${node.id}`,
+            annexe: '', // No floorplan image generated automatically yet
+            zoneID: createdDefaultZone.id,
+            spaceID: this.spaceID,
+            isCurrentForZone: true,
+            isModified: false,
+            isImportedMatterport: false, // Explicitly not matterport
+        };
+        await this.planService.createPlan(plan);
+        // 4. Create the single Navigation entry this model is viewed from.
+        // Matterport derives these from its sweeps; a static model has no sweeps, so the placement
+        // comes from the metadata entered on the form, falling back to the origin.
+        const placement = parseThreeJsPlacement(placementMetadata);
+        const origin = { x: 0, y: 0, z: 0 };
+        const navigationInput = {
+            matterportSweepID: dummySweepID,
+            position: JSON.stringify(placement?.cameraPosition ?? origin),
+            rotation: JSON.stringify(placement?.rotation ?? origin),
+            level: LevelStatus.LOW,
+            nodeID: node.id,
+            spaceID,
+        };
+        const nav = await this.navigationService.createNavigation(navigationInput);
+        if (!nav) {
+            console.log('Could not create navigation for', navigationInput);
+        }
+        console.log('[ThreeJsImportService] Import done.');
+        return Promise.resolve(true);
+    }
+    async createZone(name, layerID, surface = null, parentID = null, sweeps = [], node = null, metadata = null) {
+        const zoneInput = {
+            name,
+            spaceID: this.spaceID,
+            layerID,
+            sweepIDs: sweeps,
+            nodeIDs: node ? [node.id] : null,
+        };
+        removeNullKeysFromObject(zoneInput);
+        if (surface) {
+            zoneInput.surface = surface;
+        }
+        if (parentID) {
+            zoneInput.parentID = parentID;
+        }
+        if (metadata) {
+            zoneInput.metadata = metadata;
+        }
+        const newLocal = await this.zoneService.create(zoneInput);
+        return newLocal;
+    }
+    async getLayerByName(name) {
+        const mission = this.userService.currentMission(this.spaceID);
+        const currentOrgId = mission.organisationID;
+        const layers = await this.layerService.getLayerByNameForOrganisation(name, currentOrgId);
+        if (layers.length > 0) {
+            return layers[0];
+        }
+        // Create it if it doesn't exist
+        return this.layerService.createLayerForOrganisation(name, currentOrgId);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThreeJsImportService, deps: [{ token: i1.NavigationService }, { token: i2.ZoneService }, { token: i3.LayerService }, { token: i4.BaseUserService }, { token: i5.PlanService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThreeJsImportService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThreeJsImportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.NavigationService }, { type: i2.ZoneService }, { type: i3.LayerService }, { type: i4.BaseUserService }, { type: i5.PlanService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"threejs-import.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/threejs-import.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { removeNullKeysFromObject, parseThreeJsPlacement } from '../helpers.service';\nimport {\n  LevelStatus,\n  Layer,\n  Node,\n  Zone,\n  Navigation,\n  Plan,\n} from '../types.service';\nimport { LayerService } from './models/layer.service';\nimport { NavigationService } from './models/navigation.service';\nimport { PlanService } from './models/plan.service';\nimport { ZoneService } from './models/zone.service';\nimport { BaseUserService } from './user.service';\nimport { v4 as uuidv4 } from 'uuid';\n\n/** File extensions the Three.js viewer can load as a base model. */\nconst SUPPORTED_MODEL_EXTENSIONS = ['.glb', '.gltf'];\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ThreeJsImportService {\n  private _spaceID: string;\n\n  public get spaceID(): string {\n    return this._spaceID;\n  }\n\n  public set spaceID(value: string) {\n    this._spaceID = value;\n  }\n\n  constructor(\n    private navigationService: NavigationService,\n    private zoneService: ZoneService,\n    private layerService: LayerService,\n    private userService: BaseUserService,\n    private planService: PlanService\n  ) {}\n\n  /**\n   * Checks that an S3 key points at something the viewer can actually load.\n   *\n   * Returns the reason it can't, or null when it's fine. This runs before anything is written, so a\n   * mistyped key fails on the form rather than creating zones and navigation for a model that will\n   * 404 the first time someone opens the visit.\n   */\n  validateModelKey(key: string): string | null {\n    if (!key || !key.trim()) {\n      return 'A 3D model file (.glb) is required for a Three.js visit.';\n    }\n    const trimmed = key.trim();\n    if (!SUPPORTED_MODEL_EXTENSIONS.some((extension) => trimmed.toLowerCase().endsWith(extension))) {\n      return `The 3D model must be a ${SUPPORTED_MODEL_EXTENSIONS.join(' or ')} file.`;\n    }\n    // A full https:// URL is a signed link that expires; the stored value has to be the key itself\n    // so a fresh URL can be signed on every visit.\n    if (/^https?:\\/\\//i.test(trimmed)) {\n      return 'Enter the S3 key of the file (e.g. visits/my-model.glb), not a full URL.';\n    }\n    return null;\n  }\n\n  async importData(\n    spaceID: string,\n    surface: number,\n    reloading: boolean = false,\n    node: Node = null,\n    overrideExisting = true,\n    placementMetadata: string = null\n  ): Promise<boolean> {\n    if (reloading) {\n      // Reloading is not fully applicable to static 3D models the same way as Matterport\n      return Promise.resolve(true);\n    }\n\n    const keyError = this.validateModelKey(node?.model3D);\n    if (keyError) {\n      return Promise.reject(new Error(keyError));\n    }\n\n    this.spaceID = spaceID;\n    const zones = await this.zoneService.getZonesBySpace(spaceID);\n    const mainZone = zones.find((z) => !z.parentID);\n    if (!mainZone) {\n      return Promise.reject(new Error('Missing data (no main Building Zone)'));\n    }\n\n    console.log('[ThreeJsImportService] Importing data for Three.js model');\n\n    // 1. Check/create layer of building type\n    const layerBuilding = await this.getLayerByName('BUILDING');\n    \n    // We generate a dummy ID to act as our single \"sweep\" equivalent\n    const dummySweepID = uuidv4();\n\n    // 2. Create the default Zone\n    const createdDefaultZone = await this.createZone(\n      node.metadata || 'Three.js 3D Model',\n      layerBuilding.id,\n      surface,\n      mainZone.id,\n      [dummySweepID],\n      node\n    );\n\n    if (!createdDefaultZone) {\n      return Promise.resolve(false);\n    }\n\n    // 3. Create a blank Plan for the model (to ensure consistency in the app structure)\n    const plan = {\n      name: `plan_threejs_${node.id}`,\n      annexe: '', // No floorplan image generated automatically yet\n      zoneID: createdDefaultZone.id,\n      spaceID: this.spaceID,\n      isCurrentForZone: true,\n      isModified: false,\n      isImportedMatterport: false, // Explicitly not matterport\n    } as Plan;\n    await this.planService.createPlan(plan);\n\n    // 4. Create the single Navigation entry this model is viewed from.\n    // Matterport derives these from its sweeps; a static model has no sweeps, so the placement\n    // comes from the metadata entered on the form, falling back to the origin.\n    const placement = parseThreeJsPlacement(placementMetadata);\n    const origin = { x: 0, y: 0, z: 0 };\n    const navigationInput = {\n      matterportSweepID: dummySweepID,\n      position: JSON.stringify(placement?.cameraPosition ?? origin),\n      rotation: JSON.stringify(placement?.rotation ?? origin),\n      level: LevelStatus.LOW,\n      nodeID: node.id,\n      spaceID,\n    } as Navigation;\n    \n    const nav = await this.navigationService.createNavigation(navigationInput);\n    if (!nav) {\n      console.log('Could not create navigation for', navigationInput);\n    }\n\n    console.log('[ThreeJsImportService] Import done.');\n    return Promise.resolve(true);\n  }\n\n  async createZone(\n    name: string,\n    layerID: string,\n    surface: number = null,\n    parentID: string = null,\n    sweeps: string[] = [],\n    node: Node = null,\n    metadata: string = null\n  ): Promise<Zone> {\n    const zoneInput = {\n      name,\n      spaceID: this.spaceID,\n      layerID,\n      sweepIDs: sweeps,\n      nodeIDs: node ? [node.id] : null,\n    } as Zone;\n    \n    removeNullKeysFromObject(zoneInput);\n    if (surface) {\n      zoneInput.surface = surface;\n    }\n    if (parentID) {\n      zoneInput.parentID = parentID;\n    }\n    if (metadata) {\n      zoneInput.metadata = metadata;\n    }\n    \n    const newLocal = await this.zoneService.create(zoneInput);\n    return newLocal;\n  }\n\n  async getLayerByName(name: string): Promise<Layer> {\n    const mission = this.userService.currentMission(this.spaceID);\n    const currentOrgId = mission.organisationID;\n    const layers = await this.layerService.getLayerByNameForOrganisation(\n      name,\n      currentOrgId\n    );\n    if (layers.length > 0) {\n      return layers[0];\n    }\n    // Create it if it doesn't exist\n    return this.layerService.createLayerForOrganisation(name, currentOrgId);\n  }\n}\n"]}