@smarterplan/ngx-smarterplan-core 1.4.9 → 1.4.10

package/fesm2022/smarterplan-ngx-smarterplan-core.mjs

@@ -734,9 +734,15 @@ class SecurityCamera extends SceneComponent {
         this.highlight = new THREE.Mesh(roomMesh.geometry, shader);
     }
     toggleViewFrustum() {
-        this.highlight.visible = !this.highlight.visible;
-        this.edges.visible = !this.edges.visible;
-        this.pivot.visible = !this.pivot.visible;
+        if (this.highlight) {
+            this.highlight.visible = !this.highlight.visible;
+        }
+        if (this.edges) {
+            this.edges.visible = !this.edges.visible;
+        }
+        if (this.pivot) {
+            this.pivot.visible = !this.pivot.visible;
+        }
     }
     makeAnimation() {
         const THREE = this.context.three;
@@ -2227,7 +2233,67 @@ class MatterportNavigationService {
     currentRooms = [];
     /** Sequence number of the floor currently visible in sdk.Floor.current (null = single-floor or unknown). */
     currentFloorSequence = null;
+    // ── Bidirectional sid ↔ uuid lookup maps ──
+    // sid  = short runtime key used by Matterport SDK (collection keys, Sweep.moveTo, Camera.pose.sweep)
+    // uuid = persistent identifier stored in the database (zone.sweepIDs, poi.matterportSweepID, startSweepID)
+    sidToUuid = new Map();
+    uuidToSid = new Map();
     constructor() { }
+    // ── Sweep ID translation helpers ──
+    /**
+     * Builds the bidirectional sid ↔ uuid maps from the sweep collection.
+     * Must be called every time the sweep collection is updated.
+     */
+    buildSweepIdMaps(collection) {
+        this.sidToUuid.clear();
+        this.uuidToSid.clear();
+        if (!collection)
+            return;
+        for (const sid of Object.keys(collection)) {
+            const sweepData = collection[sid];
+            const uuid = sweepData?.uuid;
+            if (uuid && uuid !== sid) {
+                this.sidToUuid.set(sid, uuid);
+                this.uuidToSid.set(uuid, sid);
+            }
+            // Also map sid→sid and uuid→uuid for pass-through cases
+            this.sidToUuid.set(sid, uuid || sid);
+            if (uuid) {
+                this.uuidToSid.set(uuid, sid);
+            }
+        }
+        if (isDevMode()) {
+            console.debug(`[MatterportNavigation] Built sweep ID maps: ${this.sidToUuid.size} sids, ${this.uuidToSid.size} uuids`);
+        }
+    }
+    /**
+     * Resolves any sweep identifier (sid or uuid) to the SDK runtime **sid**.
+     * This is what sdk.Sweep.moveTo() and sdk.Sweep.disable() expect.
+     * Falls back to the input if no mapping exists.
+     */
+    resolveSweepSid(idOrUuid) {
+        if (!idOrUuid)
+            return idOrUuid;
+        // If it's already a known sid (exists as a key in sweepCollection), return it
+        if (this.sidToUuid.has(idOrUuid))
+            return idOrUuid;
+        // Otherwise try to map from uuid → sid
+        return this.uuidToSid.get(idOrUuid) ?? idOrUuid;
+    }
+    /**
+     * Resolves any sweep identifier (sid or uuid) to the persistent **uuid**.
+     * This is what the database stores (zone.sweepIDs, poi.matterportSweepID).
+     * Falls back to the input if no mapping exists.
+     */
+    resolveSweepUuid(sidOrUuid) {
+        if (!sidOrUuid)
+            return sidOrUuid;
+        // If it's already a known uuid, return it
+        if (this.uuidToSid.has(sidOrUuid))
+            return sidOrUuid;
+        // Otherwise try to map from sid → uuid
+        return this.sidToUuid.get(sidOrUuid) ?? sidOrUuid;
+    }
     async action_toolbox_floorplan(sdk) {
         if (this.inTransitionMode || this.inTransitionSweep) {
             console.log('viewer is in transition, cannot go floorplan');
@@ -2295,15 +2361,23 @@ class MatterportNavigationService {
             console.warn('No matterport floor found to move to');
         }
     }
+    /**
+     * Navigate to a sweep. The caller can pass either a sid or a uuid;
+     * this method resolves it to the SDK sid before calling Sweep.moveTo().
+     */
     async action_go_to_sweep(sdk, sweep, rotation) {
-        if (this.forbiddenSweeps.includes(sweep)) {
+        const resolvedSid = this.resolveSweepSid(sweep);
+        if (this.forbiddenSweeps.includes(sweep) || this.forbiddenSweeps.includes(resolvedSid)) {
             console.log('user is not allowed to go to this sweep');
             return;
         }
+        if (isDevMode() && resolvedSid !== sweep) {
+            console.debug(`[action_go_to_sweep] Resolved uuid "${sweep}" → sid "${resolvedSid}"`);
+        }
         setTimeout(async () => {
             try {
                 this.inTransitionSweep = true;
-                await sdk.Sweep.moveTo(sweep, {
+                await sdk.Sweep.moveTo(resolvedSid, {
                     transition: sdk.Camera.TransitionType.INSTANT,
                     transitionTime: 1500
                 });
@@ -2317,12 +2391,16 @@ class MatterportNavigationService {
             }
         }, 1000);
     }
+    /**
+     * Disable forbidden sweeps. Resolves each sweep ID to sid before calling SDK.
+     */
     async removeForbiddenSweeps(sdk, forbiddenSweeps) {
         this.forbiddenSweeps = [...forbiddenSweeps];
         let removed = 0;
         await Promise.all(forbiddenSweeps.map(async (sweep) => {
+            const resolvedSid = this.resolveSweepSid(sweep);
             try {
-                await sdk.Sweep.disable(sweep);
+                await sdk.Sweep.disable(resolvedSid);
                 removed += 1;
             }
             catch (error) {
@@ -2331,8 +2409,15 @@ class MatterportNavigationService {
         }));
         console.log('removed sweeps:', removed);
     }
+    /**
+     * Returns the current sweep as a **uuid** (for database matching).
+     * The SDK's poseCamera.sweep is a sid; we translate it.
+     */
     getCurrentSweep(poseCamera) {
-        return poseCamera?.sweep || null;
+        const sid = poseCamera?.sweep || null;
+        if (!sid)
+            return null;
+        return this.resolveSweepUuid(sid);
     }
     setCameraMode(mode) {
         this.inTransitionSweep = false;
@@ -3450,8 +3535,12 @@ class MatterportTagService {
             if (mattertagData.elementID === elementID) {
                 tagID = mattertagID;
                 const sweep = mattertagData.getSweepID();
-                if (sweep && sweeps && sweeps.includes(sweep)) {
-                    sweepID = sweep;
+                if (sweep && sweeps) {
+                    // sweep is a uuid; sweeps array contains sids – check both formats
+                    const resolvedSid = this.navigationService.resolveSweepSid(sweep);
+                    if (sweeps.includes(sweep) || sweeps.includes(resolvedSid)) {
+                        sweepID = sweep;
+                    }
                 }
             }
         }
@@ -3516,23 +3605,34 @@ class MatterportTagService {
             else if (sdk) {
                 const { comment, tagDescription } = this.tagService.getBillboardMediaToEmbed(object);
                 if (comment) {
-                    const attachmentID = await sdk.Tag.registerAttachment({
-                        type: 'media',
-                        data: {
-                            url: comment.externalLink,
-                            label: object.title || 'Media',
-                        },
-                    });
+                    // 1) Register the media attachment by passing the URL string(s).
+                    //    registerAttachment returns an array of attachment IDs.
+                    const [attachmentID] = await sdk.Tag.registerAttachment(comment.externalLink);
+                    // 2) Attach the registered media to the tag.
                     await sdk.Tag.attach(tagID, attachmentID);
-                    const billboardAttachmentID = await sdk.Tag.registerAttachment({
-                        type: 'billboard',
-                        data: {
-                            title: object.title,
-                            description: tagDescription,
+                    // 3) Determine media type for the billboard (PHOTO or VIDEO).
+                    //    Use a simple heuristic: YouTube/Vimeo -> VIDEO, otherwise PHOTO.
+                    //    The SDK exposes MediaType on the Tag namespace.
+                    const isVideo = /youtube\.com|youtu\.be|vimeo\.com/i.test(comment.externalLink);
+                    const mediaType = isVideo ? sdk.Mattertag.MediaType.VIDEO : sdk.Mattertag.MediaType.PHOTO;
+                    // 4) Update the billboard text and media using editBillboard.
+                    //    editBillboard accepts Partial<Tag.EditableProperties> such as label, description, media.
+                    await sdk.Tag.editBillboard(tagID, {
+                        label: object.title || 'Media',
+                        description: tagDescription || '',
+                        media: {
+                            type: mediaType,
+                            src: comment.externalLink,
                         },
                     });
-                    await sdk.Tag.attach(tagID, billboardAttachmentID);
-                    this.tagsAttachments[tagID] = billboardAttachmentID;
+                    // 5) Keep a local reference
+                    this.tagsAttachments[tagID] = {
+                        attachmentID,
+                        title: object.title || 'Media',
+                        description: tagDescription || '',
+                        mediaSrc: comment.externalLink,
+                        mediaType,
+                    };
                 }
             }
         }
@@ -3862,13 +3962,16 @@ class MatterportService {
                     onCollectionUpdated: function subscr(collection) {
                         this.sweeps = Object.keys(collection);
                         this.sweepCollection = collection;
+                        // Rebuild sid ↔ uuid maps whenever the collection updates
+                        this.navigationService.buildSweepIdMaps(collection);
                     }.bind(this),
                 });
-                // subscribe to current sweep
+                // subscribe to current sweep – emit uuid (DB format) instead of raw sid
                 this.sdk.Sweep.current.subscribe(function subscr(currentSweep) {
                     if (currentSweep.sid === '')
                         return;
-                    this.currentSweep.next(currentSweep.sid);
+                    const uuid = this.navigationService.resolveSweepUuid(currentSweep.sid);
+                    this.currentSweep.next(uuid);
                 }.bind(this));
                 // Subscribe to Floor data
                 this.sdk.Floor.data.subscribe({
@@ -3994,11 +4097,14 @@ class MatterportService {
             });
         });
     }
+    /**
+     * @deprecated Use navigationService.resolveSweepUuid() instead.
+     * Kept temporarily for backwards compatibility.
+     */
     getSweepUUIDForSid(sid) {
-        const collection = this.sweepCollection;
-        if (!collection || !collection[sid])
-            return null;
-        return collection[sid].uuid ?? null;
+        return this.navigationService.resolveSweepUuid(sid) !== sid
+            ? this.navigationService.resolveSweepUuid(sid)
+            : null;
     }
     setLightingOff() {
         this.noLightForObjects = true;
@@ -4374,7 +4480,7 @@ class MatterportService {
             mattertagData.setPosition(JSON.parse(poi.coordinate));
             mattertagData.setPoi(poi); // to keep custom tagIcon and opacity
         }
-        mattertagData.setSweepID(this.poseCamera.sweep);
+        mattertagData.setSweepID(this.navigationService.resolveSweepUuid(this.poseCamera.sweep));
         mattertagData.setRotation(this.poseCamera.rotation);
         mattertagData.setObject(element, poiType);
         this.mattertagToFollow = await this.addMattertagToViewer(mattertagData);
@@ -4387,7 +4493,7 @@ class MatterportService {
      */
     async addMattertagWhenAdding(poiType) {
         const mattertagData = new MattertagData(poiType);
-        mattertagData.setSweepID(this.poseCamera.sweep);
+        mattertagData.setSweepID(this.navigationService.resolveSweepUuid(this.poseCamera.sweep));
         mattertagData.setRotation(this.poseCamera.rotation);
         this.setInteractionMode(ViewerInteractions.ADDING);
         await this.addCursorMattertag(mattertagData);
@@ -4746,7 +4852,8 @@ class ViewerService {
     setMode(indexMode) {
         this.viewerMode = indexMode;
     }
-    setTourUrl(model3d, showIconPlan = true, showIconDollhouse = true, showIconFloors = true, showQuickStart = true, showFullscreen = true, showGuidedTour = true, showHighlightReel = true) {
+    setTourUrl(options) {
+        const { model3d, showIconPlan = true, showIconDollhouse = true, showIconFloors = true, showQuickStart = true, showFullscreen = true, showGuidedTour = true, showHighlightReel = true, showDefurnish = true, showRoomMeasurements = true } = options;
         const baseUrl = `/assets/bundle/showcase.html`;
         const params = [];
         // Modèle
@@ -4789,6 +4896,14 @@ class ViewerService {
         if (!showFullscreen) {
             params.push(`fs=0`);
         }
+        // Defurnish
+        if (showDefurnish) {
+            params.push(`ad=1`);
+        }
+        // Room Measurements
+        if (showRoomMeasurements) {
+            params.push(`measurements=1`);
+        }
         this.tourUrl = `${baseUrl}?${params.join("&")}`;
     }
     async clearAll() {
@@ -6187,26 +6302,29 @@ class FilterService {
     zoneID = null, zone = null) {
         const filteredObjects = [];
         await Promise.all(objects.map(async (object) => {
-            const [poi] = object.pois.items;
-            if (poi && zone) {
-                if (zone.sweepIDs && zone.sweepIDs.includes(poi.matterportSweepID)) {
-                    if (this.poiService.poiIsVirtual(poi) && zone.layer && zone.layer.name === "FLOOR") {
-                        // we include in Floor zone only
-                        filteredObjects.push(object);
+            const pois = object.pois;
+            if (pois) {
+                const [poi] = pois.items;
+                if (poi && zone) {
+                    if (zone.sweepIDs && zone.sweepIDs.includes(poi.matterportSweepID)) {
+                        if (this.poiService.poiIsVirtual(poi) && zone.layer && zone.layer.name === "FLOOR") {
+                            // we include in Floor zone only
+                            filteredObjects.push(object);
+                        }
+                        if (!this.poiService.poiIsVirtual(poi)) {
+                            filteredObjects.push(object);
+                        }
                     }
-                    if (!this.poiService.poiIsVirtual(poi)) {
+                }
+                if (poi && !zone && zoneID) {
+                    const zones = await this.zoneService.getZonesForObject(object);
+                    if (zones &&
+                        zones.some((zone_) => zone_.id === zoneID ||
+                            zone_.parentID === zoneID)) {
                         filteredObjects.push(object);
                     }
                 }
             }
-            if (poi && !zone && zoneID) {
-                const zones = await this.zoneService.getZonesForObject(object);
-                if (zones &&
-                    zones.some((zone_) => zone_.id === zoneID ||
-                        zone_.parentID === zoneID)) {
-                    filteredObjects.push(object);
-                }
-            }
         }));
         return filteredObjects;
     }
@@ -7166,10 +7284,9 @@ class NavigatorService {
         if (!this.currentSweep) {
             return;
         }
-        const uuid = this.matterportService.getSweepUUIDForSid(this.currentSweep);
-        console.log('uuid', uuid);
-        const sweepToMatch = uuid ?? this.currentSweep;
-        let zonesForSweep = this.zonesForUserForSpace?.filter((zone) => zone.sweepIDs && zone.sweepIDs.includes(sweepToMatch));
+        // currentSweep is already a uuid (translated at the source in MatterportService),
+        // so it matches directly against zone.sweepIDs which store uuids from the import.
+        let zonesForSweep = this.zonesForUserForSpace?.filter((zone) => zone.sweepIDs && zone.sweepIDs.includes(this.currentSweep));
         const audioZones = this.audioZonesForUserForSpace?.filter((zone) => zone.sweepIDs && zone.sweepIDs.includes(this.currentSweep));
         this.audioZonesChange.next(audioZones);
         this.currentAudioZones = audioZones;
@@ -7478,7 +7595,7 @@ class TicketsService extends BaseObjectService {
     awsKinesisAnalytics; //AWS
     isMuseumUser = false;
     navSubscription;
-    filetrSubscription;
+    filterSubscription;
     floorsPerSpace = null;
     selectedFloor = null;
     destroy$ = new Subject();
@@ -7506,7 +7623,7 @@ class TicketsService extends BaseObjectService {
             else {
                 if (this.navSubscription) {
                     this.navSubscription.unsubscribe();
-                    this.filetrSubscription.unsubscribe();
+                    this.filterSubscription.unsubscribe();
                 }
             }
         });
@@ -7517,6 +7634,9 @@ class TicketsService extends BaseObjectService {
         });
     }
     async initTickets() {
+        if (this.userService.getSpModule() === SpModule.MUSEUM) {
+            return;
+        }
         let ticketsFiltered = [];
         if (this.currentSpaceID) {
             this.updating.next(true);
@@ -7689,11 +7809,8 @@ class TicketsService extends BaseObjectService {
         if (!ticket.ownerMissionID) {
             ticket.ownerMissionID = this.userService.currentMission(ticket.spaceID).id;
         }
-        // TODO!!! filter missions by space of ticket
         try {
             const receivedTicket = await this.createTicket(ticket);
-            // console.log('!!! Response from creating ticket :');
-            // console.log(receivedTicket);
             this.addEventToTicket(receivedTicket, {
                 title: 'Création du ticket',
                 description: `Ticket créé par -`,
@@ -7750,7 +7867,6 @@ class TicketsService extends BaseObjectService {
     }
     async updateStatusOfTicket(ticket, status) {
         const currentStatus = ticket.status;
-        const oldTicketStatus = ticket.status;
         ticket.status = status;
         if (currentStatus === status) {
             return ticket;
@@ -7916,32 +8032,33 @@ class TicketsService extends BaseObjectService {
         }
     }
     initSubscriptions() {
-        if (!this.isMuseumUser) {
-            this.navSubscription = this.zoneChangeService.zoneChange.subscribe((zone) => {
-                this.currentSpaceID = this.navigatorService.currentSpaceID;
-                if (!this.currentSpaceID) {
-                    this.ticketTags.next(null);
-                    this.ticketsUpdated.next({ space: [], zone: null });
-                    this.ticketTypeFilter = null;
-                    this.zoneIDFilter = null;
-                }
-                else if (zone.id !== this.zoneIDFilter) {
-                    this.zoneIDFilter = zone.id;
-                    // console.log("going to init tickets from zone");
-                    this.initTickets().catch((e) => console.log(e.message));
-                }
-            });
-            this.filetrSubscription = this.filterService.subscribeToDataFilterUpdate((dateRange) => {
-                this.dateFilter = dateRange;
-                this.initTickets().catch((e) => console.log(e.message));
-            });
-            this.dateFilter = this.filterService.currentDateFilter;
-            this.updateDone.subscribe(() => {
-                if (this.currentSpaceID) {
-                    this.initTickets().catch((e) => console.log(e.message));
-                }
-            });
+        if (this.userService.getSpModule() === SpModule.MUSEUM) {
+            return;
         }
+        this.navSubscription = this.zoneChangeService.zoneChange.subscribe((zone) => {
+            this.currentSpaceID = this.navigatorService.currentSpaceID;
+            if (!this.currentSpaceID) {
+                this.ticketTags.next(null);
+                this.ticketsUpdated.next({ space: [], zone: null });
+                this.ticketTypeFilter = null;
+                this.zoneIDFilter = null;
+            }
+            else if (zone.id !== this.zoneIDFilter) {
+                this.zoneIDFilter = zone.id;
+                // console.log("going to init tickets from zone");
+                this.initTickets().catch((e) => console.log(e.message));
+            }
+        });
+        this.filterSubscription = this.filterService.subscribeToDataFilterUpdate((dateRange) => {
+            this.dateFilter = dateRange;
+            this.initTickets().catch((e) => console.log(e.message));
+        });
+        this.dateFilter = this.filterService.currentDateFilter;
+        this.updateDone.subscribe(() => {
+            if (this.currentSpaceID) {
+                this.initTickets().catch((e) => console.log(e.message));
+            }
+        });
     }
     unsubscribe() {
         this.destroy$.next(true);
@@ -8335,7 +8452,7 @@ class EquipmentService extends BaseObjectService {
         });
     }
     async initEquips() {
-        if (!this.currentSpaceID) {
+        if (!this.currentSpaceID || this.userService.getSpModule() === SpModule.MUSEUM) {
             return;
         }
         this.updating.next(true);
@@ -8563,64 +8680,56 @@ class EquipmentService extends BaseObjectService {
         }); // for lateral menu
     }
     initSubscriptions() {
-        if (!this.isMuseumUser) {
-            this.zoneChangeService.zoneChange
-                .pipe(takeUntil(this.destroy$))
-                .subscribe((zone) => {
-                if (!zone || !this.navigatorService.currentSpaceID) {
-                    this.currentSpaceID = this.navigatorService.currentSpaceID;
-                    this.equipmentsTags.next(null);
-                    this.equipmentsUpdated.next({ space: [], zone: null });
-                    this.zoneIDFilter = null;
-                    this.currentEquipments = {
-                        space: [],
-                        zonesMap: new Map(),
-                    };
-                    return;
-                }
-                if (zone.id !== this.zoneIDFilter) {
-                    this.zoneIDFilter = zone.id;
-                    this.currentZone = zone;
-                    if (this.currentSpaceID === this.navigatorService.currentSpaceID) {
-                        // same space,  only zone update
-                        // console.log(
-                        //     "going to update equips for zone (same space)",
-                        //     zone,
-                        // );
-                        this.updateEquipsForZone();
-                    }
-                    else {
-                        this.currentSpaceID = this.navigatorService.currentSpaceID;
-                        // console.log(
-                        //     "going to init equips for zone for new space",
-                        //     this.currentSpaceID,
-                        // );
-                        this.initEquips();
-                    }
-                }
-            });
-            this.deleteObservable
-                .pipe(takeUntil(this.destroy$))
-                .subscribe((equipment) => {
-                if (this.currentSpaceID) {
-                    this.updateDueToDelete(equipment);
-                }
-            });
-            this.createObservable
-                .pipe(takeUntil(this.destroy$))
-                .subscribe((equipment) => {
-                if (this.currentSpaceID) {
-                    this.updateDueToCreate(equipment);
+        if (this.userService.getSpModule() === SpModule.MUSEUM) {
+            return;
+        }
+        this.zoneChangeService.zoneChange
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((zone) => {
+            if (!zone || !this.navigatorService.currentSpaceID) {
+                this.currentSpaceID = this.navigatorService.currentSpaceID;
+                this.equipmentsTags.next(null);
+                this.equipmentsUpdated.next({ space: [], zone: null });
+                this.zoneIDFilter = null;
+                this.currentEquipments = {
+                    space: [],
+                    zonesMap: new Map(),
+                };
+                return;
+            }
+            if (zone.id !== this.zoneIDFilter) {
+                this.zoneIDFilter = zone.id;
+                this.currentZone = zone;
+                if (this.currentSpaceID === this.navigatorService.currentSpaceID) {
+                    this.updateEquipsForZone();
                 }
-            });
-            this.updateObservable
-                .pipe(takeUntil(this.destroy$))
-                .subscribe((equipment) => {
-                if (this.currentSpaceID) {
-                    this.updateDueToEquipUpdated(equipment);
+                else {
+                    this.currentSpaceID = this.navigatorService.currentSpaceID;
+                    this.initEquips();
                 }
-            });
-        }
+            }
+        });
+        this.deleteObservable
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((equipment) => {
+            if (this.currentSpaceID) {
+                this.updateDueToDelete(equipment);
+            }
+        });
+        this.createObservable
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((equipment) => {
+            if (this.currentSpaceID) {
+                this.updateDueToCreate(equipment);
+            }
+        });
+        this.updateObservable
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((equipment) => {
+            if (this.currentSpaceID) {
+                this.updateDueToEquipUpdated(equipment);
+            }
+        });
     }
     unsubscribe() {
         this.destroy$.next(true);
@@ -9632,8 +9741,11 @@ class CommentService {
         if (comment.ticketID && !comment.ticket) {
             comment.ticket = await this.API.__proto__.GetTicket(comment.ticketID);
         }
-        const values = comment.dimensions;
-        const numberPoints = values.length + 1;
+        let values = comment.dimensions;
+        let numberPoints = 0;
+        if (values) {
+            numberPoints = values.length + 1;
+        }
         const poi = await this.poiService.getPoiByElementId(commentID);
         const measure = {
             id: comment.id,
@@ -12546,7 +12658,7 @@ class MatterportImportService {
         if (!iframe) {
             throw new Error('Cannot create iframe');
         }
-        this.viewerService.setTourUrl(modelID);
+        this.viewerService.setTourUrl({ model3d: modelID });
         const url = this.viewerService.getTourUrl();
         iframe.setAttribute('src', url);
         iframe.allow = 'xr-spatial-tracking';
@@ -12680,20 +12792,47 @@ class MatterportImportService {
         const newLocal = await this.zoneService.create(zoneInput);
         return newLocal;
     }
+    // --- Main import function (complete) ---
     async import360images(overrideExisting = true) {
         console.log('Importing 360 images');
         this.importingImages.next(true);
         return new Promise(async (resolve) => {
             const scans = Object.values(this.sweeps);
-            const nmbScans = Object.keys(scans).length;
+            const nmbScans = scans.length;
             this.totalSweepsCount.next(nmbScans);
             const start = overrideExisting ? 0 : await this.getUploadedImageCount(this.modelID);
             for (let index = start; index < nmbScans; index += 1) {
-                if (!this.stop) {
-                    await this.sdk.Sweep.moveTo(scans[index].uuid, { rotation: { x: 0, y: 0 }, transition: this.sdk.Camera.TransitionType.INSTANT, transitionTime: 0 });
-                    const img = await this.sdk.Renderer.takeEquirectangular({ width: 2048, height: 1024 }, { mattertags: false, sweeps: true });
-                    /**Upload on S3 are asynchronous, in order to no slow down the process*/
-                    uploadBase64ImageWithRetry(img, scans[index].uuid, `visits/${this.modelID}/sweeps/`, 'sweep', 5).then((r) => {
+                if (this.stop) {
+                    console.log('Abandoning import because it was cancelled');
+                    resolve(false);
+                    this.removeFrame();
+                    break;
+                }
+                const sweep = scans[index];
+                console.log('Moving to sweep:', sweep);
+                // Prefer legacy .id first, then uuid, then sid as last resort
+                const moveId = sweep.id || sweep.uuid || sweep.sid;
+                try {
+                    // Move to sweep (use the best available id)
+                    await this.sdk.Sweep.moveTo(moveId, {
+                        rotation: { x: 0, y: 0 },
+                        transition: this.sdk.Camera && this.sdk.Camera.TransitionType
+                            ? this.sdk.Camera.TransitionType.INSTANT
+                            : undefined,
+                        transitionTime: 0,
+                    });
+                    // Capture with automatic retry (ensures renderer readiness each attempt)
+                    const img = await this.captureEquirectangularWithRetry({ width: 2048, height: 1024 }, { mattertags: false, sweeps: true }, {
+                        maxAttempts: 3,
+                        initialBackoffMs: 500,
+                        perAttemptTimeoutMs: 8000,
+                        sweepIdForReadyCheck: moveId,
+                        waitForSweepTimeoutMs: 12000
+                    });
+                    // Upload asynchronously (do not await to keep throughput)
+                    uploadBase64ImageWithRetry(img, 
+                    // prefer using uuid for storage name if available, else fallback to moveId
+                    sweep.uuid || moveId, `visits/${this.modelID}/sweeps/`, 'sweep', 5).then(() => {
                         this.sweepProcessedCount.next(index);
                         if (index === nmbScans - 1) {
                             console.log('Import 360 done');
@@ -12705,17 +12844,156 @@ class MatterportImportService {
                         console.log("Error uploading scan : ", e);
                     });
                 }
-                else {
-                    console.log('Abandoning import because it was cancelled');
-                    resolve(false);
-                    this.removeFrame();
-                    break;
+                catch (err) {
+                    // capture failed after retries — log and continue to next sweep
+                    console.error(`Failed to capture sweep ${moveId} after retries:`, err);
+                    this.sweepProcessedCount.next(index);
+                    // continue to next sweep (change to `throw err` if you want to abort on first failure)
+                    continue;
                 }
             }
+            // If loop finishes without hitting the final resolve in upload promise:
             resolve(true);
             this.removeFrame();
         });
     }
+    // --- capture with retry and backoff ---
+    // options: renderer size; renderOptions: renderer flags; cfg: retry config
+    async captureEquirectangularWithRetry(options, renderOptions, { maxAttempts = 3, initialBackoffMs = 500, perAttemptTimeoutMs = 8000, sweepIdForReadyCheck = null, waitForSweepTimeoutMs = 12000 } = {}) {
+        let attempt = 0;
+        let lastError = null;
+        while (attempt < maxAttempts) {
+            attempt += 1;
+            try {
+                // Ensure sweep is ready before each attempt if requested
+                if (sweepIdForReadyCheck) {
+                    await this.waitForSweepReady(sweepIdForReadyCheck, waitForSweepTimeoutMs);
+                    // small safety delay to let renderer finalize
+                    await this.sleep(120);
+                }
+                // Race the takeEquirectangular call against a per-attempt timeout
+                const img = await Promise.race([
+                    this.sdk.Renderer.takeEquirectangular(options, renderOptions),
+                    this.timeoutPromise(perAttemptTimeoutMs, `takeEquirectangular timed out after ${perAttemptTimeoutMs}ms`)
+                ]);
+                // success
+                return img;
+            }
+            catch (err) {
+                lastError = err;
+                console.warn(`takeEquirectangular attempt ${attempt} failed:`, err);
+                if (attempt >= maxAttempts) {
+                    throw lastError;
+                }
+                // exponential backoff before next attempt
+                const backoff = initialBackoffMs * Math.pow(2, attempt - 1);
+                // add small jitter to reduce thundering herd
+                const jitter = Math.floor(Math.random() * 100);
+                await this.sleep(backoff + jitter);
+                // loop to next attempt
+            }
+        }
+        throw lastError || new Error('captureEquirectangularWithRetry failed without error');
+    }
+    // --- Wait until the SDK reports the target sweep as current ---
+    // Tries: sdk.Sweep.current.waitUntil -> sdk.Sweep.current.subscribe -> polling getCurrent/value
+    // This function matches targetId against multiple fields and prioritizes .id matching.
+    waitForSweepReady(targetId, timeoutMs = 10000) {
+        const sdk = this.sdk;
+        // helper to match multiple id fields, prioritizing id first
+        const matchesTarget = (data) => {
+            if (!data)
+                return false;
+            // check .id first (legacy), then uuid, sid, uid
+            const fields = [data.id, data.uuid, data.sid, data.uid];
+            return fields.some(f => !!f && String(f) === String(targetId));
+        };
+        // 1) prefer waitUntil if available on the observable
+        if (sdk.Sweep && sdk.Sweep.current && typeof sdk.Sweep.current.waitUntil === 'function') {
+            return Promise.race([
+                sdk.Sweep.current.waitUntil((data) => matchesTarget(data)),
+                this.timeoutPromise(timeoutMs, `Timeout waiting for sweep ${targetId}`)
+            ]);
+        }
+        // 2) subscribe if available
+        if (sdk.Sweep && sdk.Sweep.current && typeof sdk.Sweep.current.subscribe === 'function') {
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    if (off)
+                        off();
+                    reject(new Error(`Timeout waiting for sweep ${targetId}`));
+                }, timeoutMs);
+                let off = null;
+                try {
+                    // subscribe may return an unsubscribe function or an object with unsubscribe()
+                    const subResult = sdk.Sweep.current.subscribe((data) => {
+                        if (matchesTarget(data)) {
+                            clearTimeout(timer);
+                            try {
+                                if (typeof subResult === 'function')
+                                    subResult();
+                                else if (subResult && typeof subResult.unsubscribe === 'function')
+                                    subResult.unsubscribe();
+                            }
+                            catch (e) { /*ignore*/ }
+                            resolve();
+                        }
+                    });
+                    // if subscribe returned an unsubscribe function, keep it as off
+                    if (typeof subResult === 'function')
+                        off = subResult;
+                    else if (subResult && typeof subResult.unsubscribe === 'function')
+                        off = () => subResult.unsubscribe();
+                }
+                catch (e) {
+                    clearTimeout(timer);
+                    reject(new Error('sdk.Sweep.current.subscribe not usable'));
+                }
+            });
+        }
+        // 3) polling fallback: try getCurrent(), sdk.Sweep.current() function, or .value, else poll renderer readiness
+        return new Promise(async (resolve, reject) => {
+            const pollInterval = 200;
+            const timer = setTimeout(() => {
+                clearInterval(interval);
+                reject(new Error(`Timeout waiting for sweep ${targetId}`));
+            }, timeoutMs);
+            const checkNow = async () => {
+                try {
+                    let current = null;
+                    if (sdk.Sweep && typeof sdk.Sweep.getCurrent === 'function') {
+                        current = await sdk.Sweep.getCurrent();
+                    }
+                    else if (sdk.Sweep && typeof sdk.Sweep.current === 'function') {
+                        // some builds expose a function
+                        current = await sdk.Sweep.current();
+                    }
+                    else if (sdk.Sweep && sdk.Sweep.current && sdk.Sweep.current.value) {
+                        // some observables expose a .value
+                        current = sdk.Sweep.current.value;
+                    }
+                    if (matchesTarget(current)) {
+                        clearTimeout(timer);
+                        clearInterval(interval);
+                        resolve();
+                    }
+                }
+                catch (e) {
+                    // ignore and retry until timeout
+                }
+            };
+            // initial immediate check
+            await checkNow();
+            const interval = setInterval(checkNow, pollInterval);
+        });
+    }
+    // --- small helpers ---
+    sleep(ms) {
+        return new Promise(res => setTimeout(res, ms));
+    }
+    timeoutPromise(ms, message) {
+        return new Promise((_, reject) => setTimeout(() => reject(new Error(message)), ms));
+    }
     async getUploadedImageCount(modelID) {
         try {
             const images = await listFilesInFolder(`visits/${modelID}/sweeps/`);