@smarterplan/ngx-smarterplan-core 1.4.14 → 1.4.15

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

@@ -1207,6 +1207,22 @@ class MissionService {
     async getMissionsForSpace(spaceID) {
         return this.API.__proto__.MissionsBySpace(spaceID).then((missions) => missions.items);
     }
+    /**
+     * Same as getMissionsForSpace(), but follows `nextToken` until the connection is
+     * exhausted instead of returning only the first page.
+     */
+    async getAllMissionsForSpace(spaceID) {
+        const all = [];
+        let nextToken = null;
+        do {
+            const page = await this.API.__proto__.MissionsBySpace(spaceID, undefined, undefined, 1000, nextToken);
+            if (page?.items?.length > 0) {
+                all.push(...page.items.filter((mis) => !!mis && !mis.deletedAt));
+            }
+            nextToken = page?.nextToken ?? null;
+        } while (nextToken);
+        return all;
+    }
     activateMission(mis) {
         if (mis &&
             (!mis.groups || !mis.groups.includes(ProfileStatus.ACTIVE))) {
@@ -8799,7 +8815,9 @@ class EquipmentService extends BaseObjectService {
                     const subEquips = [];
                     await Promise.all(equip.subequipmentsIDs.map(async (subId) => {
                         const subEquip = await this.API.GetEquipment(subId);
-                        subEquips.push(subEquip);
+                        if (subEquip) {
+                            subEquips.push(subEquip);
+                        }
                     }));
                     equip.subEquipments = subEquips;
                 }
@@ -11781,12 +11799,6 @@ class FeatureService extends BaseObjectService {
     /**
      * Returns EVERY feature of a space, following `nextToken` until the index is
      * exhausted, with no user/archive filtering at all.
-     *
-     * `getFeaturesBySpaceWithoutFiltering()` reads a single page (the AppSync default
-     * caps it at 100 items) and calls `isArchived()`, which dereferences the current
-     * user's mission ON THAT SPACE — so it both truncates large spaces and throws for a
-     * space the operator has no mission on. Duplication has to see the raw, complete
-     * list, hence this separate accessor rather than a change of the existing one.
      */
     async getAllFeaturesBySpaceRaw(spaceID) {
         if (!spaceID) {
@@ -14252,6 +14264,100 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     args: ['currentAPIService']
                 }] }, { type: BaseUserService }, { type: NavigatorService }, { type: ZoneChangeService }, { type: FilterService }] });
 
+class DomainService {
+    API; //AWS
+    constructor(apiInjected) {
+        this.API = apiInjected;
+    }
+    async getGenericDomainsAndForOrganisation(organisationID) {
+        return this.API.__proto__.ListDomains().then((domains) => {
+            return domains.items.filter((dom) => {
+                return (dom.organisationID === organisationID || !dom.organisationID);
+            });
+        });
+    }
+    /**
+     * Same as getGenericDomainsAndForOrganisation(), but drains every page instead of only
+     * the first. `ListDomains` has no per-organisation index — every call already scans the
+     * WHOLE table across every organisation before filtering client-side — so a catalogue
+     * past the first page was silently invisible to callers that need the complete list
+     * (e.g. matching an organisation-specific domain by name across a space-to-space copy).
+     */
+    async getAllGenericDomainsAndForOrganisation(organisationID) {
+        const all = [];
+        let nextToken = null;
+        do {
+            const page = await this.API.__proto__.ListDomains(undefined, 1000, nextToken);
+            if (page?.items?.length > 0) {
+                all.push(...page.items.filter((dom) => !!dom));
+            }
+            nextToken = page?.nextToken ?? null;
+        } while (nextToken);
+        return all.filter(dom => dom.organisationID === organisationID || !dom.organisationID);
+    }
+    async getGenericDomainsAndForOrgAndOrderedOrg(orgID, orderedOrgID = null) {
+        // TODO: Change this (UUID can change depending on DB)
+        if (orgID === "6e28201f-4679-4c29-9d2d-8a325f57cee9") {
+            // I am SmarterPlan, i can see all
+            return this.API.__proto__.ListDomains().then((response) => response.items);
+        }
+        const currentOrgDomains = await this.getGenericDomainsAndForOrganisation(orgID);
+        if (!orderedOrgID || orgID === orderedOrgID) {
+            return currentOrgDomains;
+        }
+        const orderedOrgDomains = await this.getGenericDomainsAndForOrganisation(orderedOrgID);
+        const merged = [...currentOrgDomains, ...orderedOrgDomains];
+        return filterUniqueArrayByID(merged);
+    }
+    async getDomainsForOrgExcludingTypes(types, organisationID) {
+        return this.getGenericDomainsAndForOrganisation(organisationID).then((domains) => {
+            return domains.filter((dom) => !types.includes(dom.type));
+        });
+    }
+    async getDomain(id) {
+        return this.API.__proto__.GetDomain(id);
+    }
+    async updateDomain(input) {
+        return this.API.__proto__.UpdateDomain(input);
+    }
+    async deleteDomain(id) {
+        return this.API.__proto__.DeleteDomain({ id });
+    }
+    async getRootDomains(orgID) {
+        const allDomains = await this.getGenericDomainsAndForOrganisation(orgID);
+        const root = allDomains.filter((dom) => !dom.parentID);
+        return root.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async createDomain(input) {
+        return this.API.__proto__.CreateDomain(input);
+    }
+    async getDomainsForOrgForType(type, organisationID, orderedOrg = null) {
+        return this.getGenericDomainsAndForOrgAndOrderedOrg(organisationID, orderedOrg).then((domains) => {
+            return domains.filter((dom) => dom.type === type);
+        });
+    }
+    async getParentDomainsForOrgAndOrderedOrgForType(type, organisationID, orderedOrg = null) {
+        return this.getGenericDomainsAndForOrgAndOrderedOrg(organisationID, orderedOrg).then((domains) => {
+            return domains.filter((dom) => dom.type === type && !dom.parentID);
+        });
+    }
+    async getDomainsForMissionsForOrg(orgID) {
+        const domains = await this.getDomainsForOrgExcludingTypes([DomainType.BOOKING, DomainType.FEATURE, DomainType.MISSION], orgID);
+        return domains.filter((dom) => !dom.parentID);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DomainService, deps: [{ token: 'currentAPIService' }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DomainService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DomainService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['currentAPIService']
+                }] }] });
+
 /** Safely extracts a readable message from an unknown catch value, including Amplify's
  *  GraphQL error shape ({ data, errors: [{ errorType, message }] }). */
 function toErrorMessage(err) {
@@ -14304,7 +14410,9 @@ class MatterportTagCopyService {
     measurementService;
     commentService;
     hashtagService;
-    spaceService;
+    missionService;
+    operationService;
+    domainService;
     translate;
     // Emits progress updates during copyTagsFromVisit(); null when idle
     copyProgress$ = new BehaviorSubject(null);
@@ -14312,7 +14420,8 @@ class MatterportTagCopyService {
     copyLog$ = new BehaviorSubject([]);
     spModule;
     log = [];
-    errorSeq = 0;
+    /** Unique-id sequence shared by every permanent (non-step) log line — errors and healed-item notices alike. */
+    logSeq = 0;
     // ---- Per-run remapping state (reset by resetRunState() at the start of every copy) ----
     /** source element id -> id of its copy in the target space. */
     elementIds = {};
@@ -14335,12 +14444,36 @@ class MatterportTagCopyService {
     /** source ids of the elements whose POIs were already created by an element phase.
      *  Guards the standalone POI phase against creating a second, impoverished copy. */
     handledElementIds = new Set();
-    /** true when source and target spaces belong to the same organisation. Domains are
-     *  organisation-scoped (no spaceID), so domainID survives the copy only in that case. */
-    sameOrganisation = false;
+    // Comment authorship: `Comment.ownerID` is a foreign key to a Mission, and a Mission is
+    // scoped to ONE space (userID + spaceID). A source comment's ownerID therefore points at
+    // nobody in the target space, so it has to be translated to the Mission of the SAME user
+    // there — see resolveCommentOwnerID().
+    /** source Mission id -> its userID. */
+    sourceMissionUserIds = new Map();
+    /** userID -> that user's Mission id in the TARGET space (only set when they have one). */
+    targetMissionIdsByUserId = new Map();
+    // Domain (equipment/ticket/feature/POI category) resolution mirrors the exact rule the
+    // edit forms use to populate their own category dropdown —
+    // DomainService.getDomainsForOrgForType(type, mission.organisationID,
+    // mission.orderedOrganisationID) — keyed to the OPERATOR's own Mission on each space,
+    // NOT to the Space's own organisationID. Two spaces in different organisations can
+    // still share a domain through that Mission link (an operator whose mission on the
+    // target space carries an `orderedOrganisationID` matching the domain's own
+    // organisationID sees — and can reuse — it directly). See resolveDomainID().
+    /** id -> Domain, for every domain visible from EITHER space's operator mission (its
+     *  organisationID, its orderedOrganisationID, or generic/no-organisation domains) — a
+     *  superset covering whatever a source object's domainID could point at. */
+    domainsById = new Map();
+    /** organisationIDs the TARGET operator's mission can see domains from. A domain whose
+     *  own organisationID is in this set (or has none at all) is already directly
+     *  selectable in the target space's own dropdown, so its id is reused unchanged. */
+    targetVisibleDomainOrgIds = new Set();
+    /** `${type}::${normalised name}` -> that domain's id, among domains visible to the
+     *  TARGET operator — used to find an equivalent when the exact id isn't reusable. */
+    targetDomainIdsByTypeAndName = new Map();
     /** Target space id of the run in progress — used to re-home copied tag icons. */
     targetSpaceId = null;
-    constructor(navigationService, userService, poiService, ticketService, equipmentService, object3DService, featureService, measurementService, commentService, hashtagService, spaceService, translate) {
+    constructor(navigationService, userService, poiService, ticketService, equipmentService, object3DService, featureService, measurementService, commentService, hashtagService, missionService, operationService, domainService, translate) {
         this.navigationService = navigationService;
         this.userService = userService;
         this.poiService = poiService;
@@ -14351,7 +14484,9 @@ class MatterportTagCopyService {
         this.measurementService = measurementService;
         this.commentService = commentService;
         this.hashtagService = hashtagService;
-        this.spaceService = spaceService;
+        this.missionService = missionService;
+        this.operationService = operationService;
+        this.domainService = domainService;
         this.translate = translate;
         this.spModule = userService.getSpModule();
     }
@@ -14360,6 +14495,7 @@ class MatterportTagCopyService {
     //
     async copyTagsFromVisit(sourceSpaceId, targetSpaceId, landmarkSourceA, landmarkTargetA, landmarkSourceB, landmarkTargetB) {
         let errorCount = 0;
+        let healedCount = 0;
         this.resetLog();
         this.resetRunState(targetSpaceId);
         try {
@@ -14369,7 +14505,7 @@ class MatterportTagCopyService {
                 phase: 'collecting',
                 processedInPhase: 0, totalInPhase: 0,
                 processedOverall: 0, totalOverall: 0,
-                percent: 0, errorCount: 0
+                percent: 0, errorCount: 0, healedCount: 0
             });
             const targetMission = this.userService.currentMission(targetSpaceId);
             const targetMissionId = targetMission ? targetMission.id : null;
@@ -14379,9 +14515,6 @@ class MatterportTagCopyService {
                 refSource: transform.refSource,
                 refTarget: transform.refTarget
             });
-            // Domains are organisation-scoped, hashtags are space-scoped: both need to know
-            // whether we stay inside the same organisation before anything is remapped.
-            this.sameOrganisation = await this.spacesShareOrganisation(sourceSpaceId, targetSpaceId);
             const sourceSweepIds = await this.navigationService.getAllowedSweepsIDsForUserInSpace(sourceSpaceId);
             const targetSweepIds = await this.navigationService.getAllowedSweepsIDsForUserInSpace(targetSpaceId);
             this.setStepProgress('collecting', 'collecting', 30);
@@ -14422,6 +14555,14 @@ class MatterportTagCopyService {
             // Keywords: index both vocabularies now (read-only). The keywords the target space
             // is missing are created later, POI by POI, only for those actually used.
             await this.loadHashtagIndex(sourceSpaceId, targetSpaceId);
+            // Missions: index both spaces now (read-only), so copied comments can credit
+            // their real author instead of whoever is running the copy.
+            await this.loadMissionIndex(sourceSpaceId, targetSpaceId);
+            // Domains: index every domain either operator's mission can see (read-only), so
+            // a category survives a copy across two DIFFERENT organisations whenever it
+            // genuinely would be selectable in the target space's own dropdown — see
+            // loadDomainIndex() for why this is keyed to Mission, not to the Space itself.
+            await this.loadDomainIndex(sourceSpaceId, targetSpaceId);
             if (this.spModule == SpModule.IMMO) {
                 sourceMeasurements = await this.measurementService.getMeasurementsForSpaceForUser(sourceSpaceId);
                 targetMeasurements = await this.measurementService.getMeasurementsForSpaceForUser(targetSpaceId);
@@ -14479,7 +14620,7 @@ class MatterportTagCopyService {
                     processedOverall,
                     totalOverall,
                     percent: totalOverall > 0 ? Math.round((processedOverall / totalOverall) * 100) : 0,
-                    errorCount
+                    errorCount, healedCount
                 });
             };
             if (this.spModule == SpModule.IMMO) {
@@ -14487,8 +14628,8 @@ class MatterportTagCopyService {
                 for (let i = 0; i < sourceTickets.length; i++) {
                     const sourceObj = sourceTickets[i];
                     try {
-                        const existsInTarget = this.matchesExisting(sourceObj, targetTickets, (t) => [t.title, t.description]);
-                        if (!existsInTarget) {
+                        const existingMatch = this.findExisting(sourceObj, targetTickets, (t) => [t.title, t.description]);
+                        if (!existingMatch) {
                             const rawSource = sourceObj;
                             const ticketInput = {
                                 title: rawSource.title,
@@ -14509,8 +14650,9 @@ class MatterportTagCopyService {
                                 spaceID: targetSpaceId,
                                 // Remapped in the second pass below, once every ticket exists.
                                 parentID: null,
-                                // Domains are organisation-scoped, like for equipments and features.
-                                domainID: this.sameOrganisation ? (rawSource.domainID || null) : null,
+                                // Reused unchanged in the same organisation, matched by name
+                                // across two — see resolveDomainID().
+                                domainID: this.resolveDomainID(rawSource.domainID),
                                 ownerMissionID: targetMissionId
                             };
                             const createdObj = await this.ticketService.createTicket(ticketInput);
@@ -14531,7 +14673,7 @@ class MatterportTagCopyService {
                                 }
                                 for (const sourceComment of this.orderCommentsForCopy(sourceComments)) {
                                     try {
-                                        const created = await this.copyCommentForTicket(sourceComment, createdObj.id, targetSpaceId, targetMissionId);
+                                        const created = await this.copyCommentForTicket(sourceComment, createdObj.id, targetSpaceId);
                                         if (created?.id && sourceComment.id) {
                                             this.commentIds.set(sourceComment.id, created.id);
                                         }
@@ -14549,6 +14691,18 @@ class MatterportTagCopyService {
                                 await this.createCopiedPoi(sourcePoi, createdObj.id, sourceNavPositions, targetNavPositions, transform);
                             }
                         }
+                        else {
+                            // Same reasoning as the EQUIPMENTS phase (see the comment there):
+                            // a ticket matching this one already exists in the target space,
+                            // most likely from an earlier, incomplete run. Fill in whatever
+                            // identity field it is missing rather than leaving it untouched.
+                            elementIds[sourceObj.id] = existingMatch.id;
+                            const healedFields = await this.healTicketIdentity(sourceObj, existingMatch);
+                            if (healedFields.length > 0) {
+                                healedCount++;
+                                this.logHealedItem('ticketHealed', sourceObj?.title || sourceObj?.id, healedFields);
+                            }
+                        }
                     }
                     catch (itemError) {
                         console.error(`Error copying ticket "${sourceObj?.title}" (id: ${sourceObj?.id}):`, itemError);
@@ -14593,8 +14747,8 @@ class MatterportTagCopyService {
                     try {
                         // Equipment has no `title`/`description`: it identifies itself by name, and by
                         // serial number when one is recorded.
-                        const existsInTarget = this.matchesExisting(sourceObj, targetEquipments, (e) => [e.name, e.serialNumber]);
-                        if (!existsInTarget) {
+                        const existingMatch = this.findExisting(sourceObj, targetEquipments, (e) => [e.name, e.serialNumber]);
+                        if (!existingMatch) {
                             const rawSource = sourceObj;
                             let copiedPhotoKey = null;
                             if (rawSource.photo) {
@@ -14602,6 +14756,12 @@ class MatterportTagCopyService {
                             }
                             const equipmentInput = {
                                 name: rawSource.name,
+                                // Unlike every other model this file copies, Equipment declares
+                                // `createdAt` as a plain client-settable field rather than an
+                                // AppSync-managed timestamp (see schema.graphql) — so, uniquely
+                                // here, the original commissioning date can actually be kept
+                                // instead of the copy silently getting today's date.
+                                createdAt: rawSource.createdAt ?? null,
                                 annotation: rawSource.annotation ?? null,
                                 status: rawSource.status,
                                 // Full identity of the equipment — all of these were dropped
@@ -14618,8 +14778,9 @@ class MatterportTagCopyService {
                                 // while hiding the item from no one — reset it, as for features.
                                 archivedForMissionID: null,
                                 spaceID: targetSpaceId,
-                                // Domains are organisation-scoped, like for features and POIs.
-                                domainID: this.sameOrganisation ? (rawSource.domainID || null) : null,
+                                // Reused unchanged in the same organisation, matched by name
+                                // across two — see resolveDomainID().
+                                domainID: this.resolveDomainID(rawSource.domainID),
                                 photo: copiedPhotoKey,
                                 // `subequipmentsIDs` is deliberately absent: it is remapped to the
                                 // copied equipments in the second pass, once they all exist.
@@ -14656,6 +14817,30 @@ class MatterportTagCopyService {
                                 await this.createCopiedPoi(sourcePoi, createdObj.id, sourceNavPositions, targetNavPositions, transform);
                             }
                         }
+                        else {
+                            // An equipment matching this one already exists in the target space —
+                            // most often because a PREVIOUS run of this copy already created it.
+                            // That earlier run may have been interrupted, or hit a bug that has
+                            // since been fixed (missing family/manufacturer/domainID/... were once
+                            // dropped entirely — see the comment above), leaving an equipment with
+                            // its identity fields empty forever: re-running the copy used to skip
+                            // it outright, since it already "exists", so the gap could never heal.
+                            //
+                            // Re-running the tool must be able to repair that: any identity field
+                            // the existing target equipment is missing, and the source has, is
+                            // filled in. Fields the target already carries a value for are left
+                            // untouched, so a manual edit made in the target space is never
+                            // overwritten by an older or different source value. Notes and POIs are
+                            // NOT re-created here: unlike scalar fields they cannot be "missing vs.
+                            // present" checked the same way, and re-adding them on every re-run of
+                            // an already-healthy copy would duplicate them.
+                            elementIds[sourceObj.id] = existingMatch.id;
+                            const healedFields = await this.healEquipmentIdentity(sourceObj, existingMatch);
+                            if (healedFields.length > 0) {
+                                healedCount++;
+                                this.logHealedItem('equipmentHealed', sourceObj?.name || sourceObj?.id, healedFields);
+                            }
+                        }
                     }
                     catch (itemError) {
                         console.error(`Error copying equipment "${sourceObj?.name}" (id: ${sourceObj?.id}):`, itemError);
@@ -14692,6 +14877,50 @@ class MatterportTagCopyService {
                         }
                     }
                 }
+                // OPERATIONS — the Ticket<->Equipment join (drives "Tickets actuels" on the
+                // equipment page and the linked-equipment list on the ticket page). Both the
+                // TICKETS and EQUIPMENTS phases above copy the record itself, but neither one
+                // touches this join table, so every link between a copied ticket and a copied
+                // equipment was silently dropped: both sides existed in the target space, but
+                // pointing at nobody.
+                //
+                // Runs after both phases, over every SOURCE ticket that ended up mapped in
+                // the target space (freshly created OR healed — elementIds covers both), so a
+                // re-run over an already-copied pair of spaces can still pick up links that
+                // an earlier, incomplete run never created.
+                for (const sourceTicket of sourceTickets) {
+                    const newTicketId = elementIds[sourceTicket.id];
+                    if (!newTicketId) {
+                        continue;
+                    }
+                    try {
+                        const sourceOps = await this.operationService.getOperationsByTicketID(sourceTicket.id);
+                        if (sourceOps.length === 0) {
+                            continue;
+                        }
+                        // Read what the target ticket is already linked to, so a re-run never
+                        // creates a duplicate Operation for a link that already exists.
+                        const targetOps = await this.operationService.getOperationsByTicketID(newTicketId);
+                        const linkedEquipmentIds = new Set(targetOps.map(op => op.equipmentID));
+                        for (const sourceOp of sourceOps) {
+                            const newEquipmentId = sourceOp.equipmentID ? elementIds[sourceOp.equipmentID] : null;
+                            // No copied counterpart for the source equipment (not collected,
+                            // outside the current filter, ...) — same rule as everywhere else
+                            // in this file: drop the link rather than point it at nothing or
+                            // at the source space's equipment.
+                            if (!newEquipmentId || linkedEquipmentIds.has(newEquipmentId)) {
+                                continue;
+                            }
+                            await this.operationService.createOperation({ ticketID: newTicketId, equipmentID: newEquipmentId });
+                            linkedEquipmentIds.add(newEquipmentId);
+                        }
+                    }
+                    catch (opError) {
+                        console.error(`Error copying ticket-equipment links for "${sourceTicket?.title}":`, opError);
+                        errorCount++;
+                        this.logCopyItemError(opError, 'errorOperation', sourceTicket?.title || sourceTicket?.id);
+                    }
+                }
             }
             // OBJECTS 3D (the 3D model file itself — `path` — is physically duplicated in S3)
             for (let i = 0; i < sourceObjects3D.length; i++) {
@@ -14814,8 +15043,8 @@ class MatterportTagCopyService {
             for (let i = 0; i < sourceFeatures.length; i++) {
                 const sourceObj = sourceFeatures[i];
                 try {
-                    const existsInTarget = this.matchesExisting(sourceObj, targetFeatures, (f) => [f.title, f.description]);
-                    if (!existsInTarget) {
+                    const existingMatch = this.findExisting(sourceObj, targetFeatures, (f) => [f.title, f.description]);
+                    if (!existingMatch) {
                         const rawSource = sourceObj;
                         // Resolved just before the write: a keyword is only created in the target
                         // space when the POI carrying it is about to be created.
@@ -14841,9 +15070,9 @@ class MatterportTagCopyService {
                             // equivalent hashtags of the target space (created on demand).
                             hashtags: resolvedHashtags,
                             description: rawSource.description || null,
-                            // Domains are organisation-scoped, so the category survives a copy
-                            // inside one organisation and only has to be dropped across two.
-                            domainID: this.sameOrganisation ? (rawSource.domainID || null) : null,
+                            // Reused unchanged in the same organisation, matched by name
+                            // across two — see resolveDomainID().
+                            domainID: this.resolveDomainID(rawSource.domainID),
                             spaceID: targetSpaceId,
                             ownerMissionID: targetMissionId
                         };
@@ -14868,7 +15097,7 @@ class MatterportTagCopyService {
                             }
                             for (const sourceComment of this.orderCommentsForCopy(sourceComments)) {
                                 try {
-                                    const created = await this.copyCommentForFeature(sourceComment, createdObj.id, targetSpaceId, targetMissionId);
+                                    const created = await this.copyCommentForFeature(sourceComment, createdObj.id, targetSpaceId);
                                     if (created?.id && sourceComment.id) {
                                         this.commentIds.set(sourceComment.id, created.id);
                                     }
@@ -14889,6 +15118,18 @@ class MatterportTagCopyService {
                             }
                         }
                     }
+                    else {
+                        // Same reasoning as the EQUIPMENTS phase (see the comment there): a
+                        // feature matching this one already exists in the target space, most
+                        // likely from an earlier, incomplete run. Fill in whatever identity
+                        // field it is missing rather than leaving it untouched.
+                        elementIds[sourceObj.id] = existingMatch.id;
+                        const healedFields = await this.healFeatureIdentity(sourceObj, existingMatch);
+                        if (healedFields.length > 0) {
+                            healedCount++;
+                            this.logHealedItem('featureHealed', sourceObj?.title || sourceObj?.id, healedFields);
+                        }
+                    }
                 }
                 catch (itemError) {
                     console.error(`Error copying feature "${sourceObj?.title}" (id: ${sourceObj?.id}):`, itemError);
@@ -14921,6 +15162,9 @@ class MatterportTagCopyService {
                                 dimensions: rawComment.dimensions || null,
                                 annexe: copiedAnnexe,
                                 spaceID: targetSpaceId,
+                                // Same authorship rule as every other copied comment — see
+                                // resolveCommentOwnerID().
+                                ownerID: this.resolveCommentOwnerID(rawComment.ownerID),
                             };
                             const createdComment = await this.commentService.createComment(commentInput);
                             if (createdComment && createdComment.id && rawComment.id) {
@@ -14987,11 +15231,17 @@ class MatterportTagCopyService {
                 phase: 'done',
                 processedInPhase: 0, totalInPhase: 0,
                 processedOverall, totalOverall,
-                percent: 100, errorCount
+                percent: 100, errorCount, healedCount
             });
             this.setStepLog('done', errorCount > 0
                 ? this.translate.instant('matterportCopy.doneWithErrors', { count: errorCount })
                 : this.translate.instant('matterportCopy.done'));
+            // Separate summary line, on top of (not instead of) the done/doneWithErrors one
+            // above: healing is orthogonal to success/failure, an already-complete run can
+            // still have repaired items left over from an earlier, incomplete attempt.
+            if (healedCount > 0) {
+                this.setStepLog('healedSummary', this.translate.instant('matterportCopy.healedSummary', { count: healedCount }));
+            }
             return true;
         }
         catch (error) {
@@ -15007,6 +15257,17 @@ class MatterportTagCopyService {
             await this.cleanupUnusedCreatedHashtags();
         }
     }
+    /**
+     * Serialises the current copy log (step lines as last emitted, plus every error and
+     * healed-item notice) to a plain-text file and triggers a browser download — wired to a
+     * "download log" button in the copy UI, so an operator can keep or share the full report
+     * of a run rather than only the ~200px scrollable panel showing it.
+     */
+    downloadLog(filename) {
+        const text = this.log.map(entry => entry.text).join('\n');
+        const defaultName = `matterport-copy-log-${new Date().toISOString().replace(/[:.]/g, '-')}.txt`;
+        downloadBlob(new Blob([text], { type: 'text/plain;charset=utf-8' }), filename || defaultName);
+    }
     //
     // ---------- Progress / log helpers ----------
     //
@@ -15024,14 +15285,21 @@ class MatterportTagCopyService {
     }
     /** Appends a new, permanent log line (never overwritten), then republishes the log. */
     appendErrorLog(text) {
-        this.errorSeq++;
-        this.log.push({ id: `error-${this.errorSeq}`, type: 'error', text });
+        this.logSeq++;
+        this.log.push({ id: `error-${this.logSeq}`, type: 'error', text });
+        this.copyLog$.next([...this.log]);
+    }
+    /** Appends a permanent log line for an item that was repaired rather than newly
+     *  created — see healEquipmentIdentity() and its ticket/feature equivalents. */
+    appendHealedLog(text) {
+        this.logSeq++;
+        this.log.push({ id: `healed-${this.logSeq}`, type: 'healed', text });
         this.copyLog$.next([...this.log]);
     }
     /** Resets the log for a new run. */
     resetLog() {
         this.log = [];
-        this.errorSeq = 0;
+        this.logSeq = 0;
         this.copyLog$.next([]);
     }
     /** Clears every id map carried over from a previous run. The service is a root-level
@@ -15045,7 +15313,11 @@ class MatterportTagCopyService {
         this.createdHashtagIds = new Set();
         this.usedHashtagIds = new Set();
         this.handledElementIds = new Set();
-        this.sameOrganisation = false;
+        this.sourceMissionUserIds = new Map();
+        this.targetMissionIdsByUserId = new Map();
+        this.domainsById = new Map();
+        this.targetVisibleDomainOrgIds = new Set();
+        this.targetDomainIdsByTypeAndName = new Map();
         this.targetSpaceId = targetSpaceId;
     }
     /** Builds and sets a step's log line as "<translated label>: <percent>%", no step numbering. */
@@ -15058,6 +15330,16 @@ class MatterportTagCopyService {
         const text = this.translate.instant(`matterportCopy.${translationKey}`, params);
         this.appendErrorLog(text);
     }
+    /** Logs a translated line for an item that already existed in the target space and had
+     *  its missing identity fields filled in, so the operator can tell it apart from a
+     *  freshly created item in the copy report. */
+    logHealedItem(translationKey, itemLabel, healedFields) {
+        const text = this.translate.instant(`matterportCopy.${translationKey}`, {
+            name: itemLabel,
+            fields: healedFields.join(', ')
+        });
+        this.appendHealedLog(text);
+    }
     /** Logs an item-level error, using a specific "missing file / orphaned reference"
      *  translation key when the cause is a MissingS3FileError, and the generic per-type
      *  key otherwise. Keeps the copy log readable: a missing file is not a bug to
@@ -15094,27 +15376,87 @@ class MatterportTagCopyService {
     //
     // ---------- Cross-space reference remapping ----------
     //
+    /** Normalised lookup key for a domain: type disambiguates same-named domains used for
+     *  different purposes (equipment vs. ticket vs. feature categories, ...). */
+    domainKey(type, name) {
+        return `${type || ''}::${(name || '').trim().toLowerCase()}`;
+    }
     /**
-     * True when both spaces belong to the same organisation.
-     * Domains (POI/Feature categories) are organisation-scoped records with no spaceID, so
-     * a domainID stays meaningful inside one organisation and only becomes a dangling
-     * reference across two. A failed lookup answers "no": dropping a category is recoverable,
-     * pointing at another organisation's domain is not.
+     * READ-ONLY indexing of every domain either operator's Mission can see. Creates
+     * nothing — unlike hashtags, a domain is a business taxonomy entry an operator manages
+     * deliberately; this tool only ever reuses an EXISTING equivalent, it never invents one.
+     *
+     * Visibility is keyed to `currentMission(spaceId).organisationID` /
+     * `.orderedOrganisationID` for EACH space — exactly what
+     * `DomainService.getDomainsForOrgForType()` uses to populate the category dropdown on
+     * the equipment/ticket/feature edit forms (see form-equipment.component.ts,
+     * batch-edit-equipment.component.ts, form-feature.component.ts). Comparing the spaces'
+     * OWN `organisationID` instead — the previous approach — missed every domain reachable
+     * only through the operator's `orderedOrganisationID` (set when a mission is created "on
+     * behalf of" another organisation — see form-mission.component.ts), which is exactly how
+     * a domain ends up visible on two spaces that belong to different organisations.
      */
-    async spacesShareOrganisation(sourceSpaceId, targetSpaceId) {
+    async loadDomainIndex(sourceSpaceId, targetSpaceId) {
+        const sourceMission = this.userService.currentMission(sourceSpaceId);
+        const targetMission = this.userService.currentMission(targetSpaceId);
+        const sourceOrgIds = [sourceMission?.organisationID, sourceMission?.orderedOrganisationID]
+            .filter((id) => !!id);
+        const targetOrgIds = [targetMission?.organisationID, targetMission?.orderedOrganisationID]
+            .filter((id) => !!id);
+        this.targetVisibleDomainOrgIds = new Set(targetOrgIds);
+        const allOrgIds = Array.from(new Set([...sourceOrgIds, ...targetOrgIds]));
+        if (allOrgIds.length === 0) {
+            // The operator has no mission on either space — nothing to resolve against;
+            // every domainID will be dropped, same as an unresolvable lookup elsewhere.
+            return;
+        }
         try {
-            const [sourceSpace, targetSpace] = await Promise.all([
-                this.spaceService.getSpace(sourceSpaceId),
-                this.spaceService.getSpace(targetSpaceId)
-            ]);
-            const sourceOrg = sourceSpace?.organisationID;
-            const targetOrg = targetSpace?.organisationID;
-            return !!sourceOrg && !!targetOrg && sourceOrg === targetOrg;
+            const domainLists = await Promise.all(allOrgIds.map(orgId => this.domainService.getAllGenericDomainsAndForOrganisation(orgId)));
+            for (const list of domainLists) {
+                for (const domain of list || []) {
+                    if (domain?.id) {
+                        this.domainsById.set(domain.id, domain);
+                    }
+                }
+            }
         }
         catch (error) {
-            console.warn('[MatterportTagCopyService] Could not compare the spaces\' organisations, categories will be dropped:', error);
-            return false;
+            console.warn('[MatterportTagCopyService] Could not read the domains, cross-organisation categories will be dropped:', error);
+            return;
+        }
+        for (const domain of this.domainsById.values()) {
+            const visibleToTarget = !domain.organisationID || this.targetVisibleDomainOrgIds.has(domain.organisationID);
+            if (visibleToTarget && domain.name) {
+                this.targetDomainIdsByTypeAndName.set(this.domainKey(domain.type, domain.name), domain.id);
+            }
+        }
+    }
+    /**
+     * Resolves a source domainID (equipment/ticket/feature/POI category) for use in the
+     * target space.
+     *
+     *  - generic domain (no organisationID of its own — a shared taxonomy entry, e.g. a
+     *    standard category created by the platform): reused unchanged, valid everywhere.
+     *  - the domain's own organisationID is already one the TARGET operator's mission can
+     *    see (its organisationID, or its orderedOrganisationID): reused unchanged too — the
+     *    id is directly selectable in the target space's own dropdown as-is.
+     *  - otherwise: matched by (type, name) against the domains visible to the TARGET
+     *    operator (loadDomainIndex()); dropped when no equivalent exists there.
+     */
+    resolveDomainID(sourceDomainId) {
+        if (!sourceDomainId) {
+            return null;
+        }
+        const domain = this.domainsById.get(sourceDomainId);
+        if (!domain) {
+            // Not visible to either operator's mission (lookup failed, or it belongs to
+            // neither) — unchanged, safest to drop.
+            return null;
         }
+        if (!domain.organisationID || this.targetVisibleDomainOrgIds.has(domain.organisationID)) {
+            return sourceDomainId;
+        }
+        return this.targetDomainIdsByTypeAndName.get(this.domainKey(domain.type, domain.name)) ?? null;
     }
     /** Normalised lookup key for a hashtag name, so "Moyen Âge" and "moyen âge " match. */
     hashtagKey(name) {
@@ -15204,6 +15546,61 @@ class MatterportTagCopyService {
         }
         return resolved.length > 0 ? resolved : null;
     }
+    /**
+     * READ-ONLY indexing of both spaces' missions.
+     *
+     * A Mission is scoped to one space (it pairs a userID with a spaceID), so the id a
+     * source comment's `ownerID` points at never designates anyone in the target space.
+     * This builds the two lookup tables resolveCommentOwnerID() needs to translate it:
+     * which user a source Mission id belongs to, and which Mission (if any) that same
+     * user already holds in the target space.
+     */
+    async loadMissionIndex(sourceSpaceId, targetSpaceId) {
+        let sourceMissions = [];
+        let targetMissions = [];
+        try {
+            [sourceMissions, targetMissions] = await Promise.all([
+                this.missionService.getAllMissionsForSpace(sourceSpaceId),
+                this.missionService.getAllMissionsForSpace(targetSpaceId)
+            ]);
+        }
+        catch (error) {
+            console.warn('[MatterportTagCopyService] Could not read the missions, comment authorship will be dropped:', error);
+            return;
+        }
+        for (const mission of sourceMissions || []) {
+            if (mission?.id && mission.userID) {
+                this.sourceMissionUserIds.set(mission.id, mission.userID);
+            }
+        }
+        for (const mission of targetMissions || []) {
+            if (mission?.id && mission.userID && !this.targetMissionIdsByUserId.has(mission.userID)) {
+                this.targetMissionIdsByUserId.set(mission.userID, mission.id);
+            }
+        }
+    }
+    /**
+     * Translates a source comment's `ownerID` (a per-space Mission id) into the Mission of
+     * the SAME user in the target space, so the copy keeps crediting its real author.
+     *
+     * Substituting the current operator's mission — the way `ownerMissionID` legitimately
+     * does for tickets/equipment/features, which really do change owner on a copy — would
+     * misattribute every comment to whoever ran the copy instead of who actually wrote it.
+     *
+     * When the original author has no mission in the target space (never granted access
+     * there), the comment is left with no owner rather than a wrong one: an absent author
+     * is honest, a misattributed one is not.
+     */
+    resolveCommentOwnerID(sourceOwnerID) {
+        if (!sourceOwnerID) {
+            return null;
+        }
+        const userID = this.sourceMissionUserIds.get(sourceOwnerID);
+        if (!userID) {
+            return null;
+        }
+        return this.targetMissionIdsByUserId.get(userID) ?? null;
+    }
     /** Records that these hashtags are now referenced by a feature that really exists, so
      *  the end-of-run cleanup leaves them alone. */
     markHashtagsUsed(hashtagIds) {
@@ -15317,16 +15714,16 @@ class MatterportTagCopyService {
      * items — where the whole content lives, since a TEXT comment has no file — and any
      * per-media settings stored in metadata.
      */
-    async copyCommentForFeature(sourceComment, targetFeatureId, targetSpaceId, targetMissionId) {
-        return this.copyComment(sourceComment, targetSpaceId, targetMissionId, { featureID: targetFeatureId });
+    async copyCommentForFeature(sourceComment, targetFeatureId, targetSpaceId) {
+        return this.copyComment(sourceComment, targetSpaceId, { featureID: targetFeatureId });
     }
     /** Same, for an attachment carried by a ticket rather than by a feature. */
-    async copyCommentForTicket(sourceComment, targetTicketId, targetSpaceId, targetMissionId) {
-        return this.copyComment(sourceComment, targetSpaceId, targetMissionId, { ticketID: targetTicketId });
+    async copyCommentForTicket(sourceComment, targetTicketId, targetSpaceId) {
+        return this.copyComment(sourceComment, targetSpaceId, { ticketID: targetTicketId });
     }
     /** Shared body of the two above: `owner` carries whichever foreign key links the copy back
      *  to its new parent, everything else is identical. */
-    async copyComment(sourceComment, targetSpaceId, targetMissionId, owner) {
+    async copyComment(sourceComment, targetSpaceId, owner) {
         const rawComment = sourceComment;
         let copiedAnnexe = null;
         if (rawComment.annexe) {
@@ -15344,7 +15741,11 @@ class MatterportTagCopyService {
             shownInTag: rawComment.shownInTag,
             isCoverImage: rawComment.isCoverImage,
             spaceID: targetSpaceId,
-            ownerID: targetMissionId,
+            // Keeps crediting the ORIGINAL author when they also have a mission in the
+            // target space, and leaves the comment un-owned otherwise — see
+            // resolveCommentOwnerID(). Never the current operator's own mission: that
+            // would silently reassign authorship to whoever happens to run the copy.
+            ownerID: this.resolveCommentOwnerID(rawComment.ownerID),
             ...owner
         };
         return this.commentService.createComment(commentInput);
@@ -15383,7 +15784,7 @@ class MatterportTagCopyService {
             level: raw.level ?? null,
             role: raw.role ?? null,
             category: raw.category ?? null,
-            domainID: this.sameOrganisation ? (raw.domainID || null) : null,
+            domainID: this.resolveDomainID(raw.domainID),
             // --- Matterport anchoring ---
             metadata: this.getAdjustedPoiMetadata(sourcePoi.metadata, transform)
         };
@@ -15447,7 +15848,9 @@ class MatterportTagCopyService {
     //
     /**
      * Heuristic duplicate-detection: compares several identifying fields together rather than
-     * a single label, to reduce false positives when items share one of them.
+     * a single label, to reduce false positives when items share one of them. Returns the
+     * matched target item (or undefined) rather than a boolean, so the caller can act on the
+     * existing record — heal its missing fields — instead of only skipping it.
      *
      * The fields are supplied by the caller because the models do not agree on them. The
      * previous version hard-coded `title`/`description`, which do not exist on Equipment at
@@ -15455,9 +15858,95 @@ class MatterportTagCopyService {
      * and a target space holding a single equipment silently caused the whole equipment phase
      * to copy nothing.
      */
-    matchesExisting(source, targetList, identity) {
+    findExisting(source, targetList, identity) {
         const sourceKey = this.identityKey(identity(source));
-        return targetList.some(target => this.identityKey(identity(target)) === sourceKey);
+        return targetList.find(target => this.identityKey(identity(target)) === sourceKey);
+    }
+    /**
+     * Builds a patch of whichever fields in `fields` the existing target record is missing
+     * (`null`/`undefined`/empty array) but the source has, plus `domainID` when requested —
+     * domains are organisation-scoped everywhere in this file, so that one is only ever
+     * healed across the SAME organisation, exactly like at creation time.
+     *
+     * Never overwrites a field the target already carries a value for: a value entered by
+     * hand in the target space since an earlier, incomplete copy must not be clobbered by
+     * an older or different source value.
+     *
+     * Returns both the patch to send and the list of healed field names, so the caller can
+     * both perform the update and describe it in the copy log.
+     */
+    buildHealPatch(sourceObj, existingTarget, fields, includeDomain) {
+        const patch = {};
+        const healedFields = [];
+        const fillIfMissing = (key, sourceValue) => {
+            const currentValue = existingTarget[key];
+            const isMissing = currentValue === null || currentValue === undefined
+                || (Array.isArray(currentValue) && currentValue.length === 0);
+            if (isMissing && sourceValue !== null && sourceValue !== undefined) {
+                patch[key] = sourceValue;
+                healedFields.push(key);
+            }
+        };
+        for (const field of fields) {
+            fillIfMissing(field, sourceObj[field]);
+        }
+        if (includeDomain && (existingTarget.domainID === null || existingTarget.domainID === undefined)) {
+            const resolvedDomainId = this.resolveDomainID(sourceObj.domainID);
+            if (resolvedDomainId) {
+                patch.domainID = resolvedDomainId;
+                healedFields.push('domainID');
+            }
+        }
+        return { patch, healedFields };
+    }
+    /**
+     * Fills in whichever identity field a PRE-EXISTING target equipment is missing but the
+     * source has — see the call site in the EQUIPMENTS phase for why re-running the copy
+     * has to be able to repair a previously-copied equipment, not just skip it again.
+     *
+     * A failed update is left to bubble up to the caller's existing per-item try/catch, the
+     * same as a failed creation — it gets the same visible error line, rather than a silent
+     * console warning.
+     *
+     * Returns the list of fields that were actually healed (empty if nothing was missing).
+     */
+    async healEquipmentIdentity(sourceObj, existingTarget) {
+        const { patch, healedFields } = this.buildHealPatch(sourceObj, existingTarget, ['status', 'annotation', 'family', 'sku', 'manufacturer', 'installDate', 'warrantyEndDate', 'metadata', 'isCreatedByAI'], true);
+        if (!existingTarget.photo && sourceObj.photo) {
+            patch.photo = await this.copyS3KeyIfPresent(sourceObj.photo, `equipment photo "${sourceObj.name}"`);
+            healedFields.push('photo');
+        }
+        if (healedFields.length === 0) {
+            return healedFields;
+        }
+        patch.id = existingTarget.id;
+        await this.equipmentService.updateEquipment(patch);
+        return healedFields;
+    }
+    /**
+     * Same idea as healEquipmentIdentity(), for a pre-existing ticket. `title`/`description`
+     * are the pair findExisting() matched on to find this ticket in the first place, so they
+     * are never part of the heal — by construction, they already agree with the source.
+     */
+    async healTicketIdentity(sourceObj, existingTarget) {
+        const { patch, healedFields } = this.buildHealPatch(sourceObj, existingTarget, ['friendlyLabel', 'status', 'type', 'priority', 'level', 'metadata', 'read', 'projectID', 'problemCode'], true);
+        if (healedFields.length === 0) {
+            return healedFields;
+        }
+        patch.id = existingTarget.id;
+        await this.ticketService.updateTicket(patch);
+        return healedFields;
+    }
+    /** Same idea, for a pre-existing feature. Keywords, media and POIs are not healed here
+     *  for the same reason notes/POIs are not healed on equipment — see healEquipmentIdentity(). */
+    async healFeatureIdentity(sourceObj, existingTarget) {
+        const { patch, healedFields } = this.buildHealPatch(sourceObj, existingTarget, ['shortDescription', 'level', 'type', 'index', 'stripeProductID', 'stripePriceID', 'bookingPriceMetadata', 'locale'], true);
+        if (healedFields.length === 0) {
+            return healedFields;
+        }
+        patch.id = existingTarget.id;
+        await this.featureService.updateFeature(patch);
+        return healedFields;
     }
     /** Serialises the identifying fields unambiguously, so that ["a", "b"] and ["ab", ""]
      *  can never produce the same key. */
@@ -15734,13 +16223,13 @@ class MatterportTagCopyService {
         // for the CopySource header. Do NOT re-encode it here.
         return extracted;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagCopyService, deps: [{ token: NavigationService }, { token: BaseUserService }, { token: PoiService }, { token: TicketsService }, { token: EquipmentService }, { token: Object3DService }, { token: FeatureService }, { token: MeasurementService }, { token: CommentService }, { token: HashtagService }, { token: SpaceService }, { token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagCopyService, deps: [{ token: NavigationService }, { token: BaseUserService }, { token: PoiService }, { token: TicketsService }, { token: EquipmentService }, { token: Object3DService }, { token: FeatureService }, { token: MeasurementService }, { token: CommentService }, { token: HashtagService }, { token: MissionService }, { token: OperationService }, { token: DomainService }, { token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagCopyService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagCopyService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: NavigationService }, { type: BaseUserService }, { type: PoiService }, { type: TicketsService }, { type: EquipmentService }, { type: Object3DService }, { type: FeatureService }, { type: MeasurementService }, { type: CommentService }, { type: HashtagService }, { type: SpaceService }, { type: i1.TranslateService }] });
+        }], ctorParameters: () => [{ type: NavigationService }, { type: BaseUserService }, { type: PoiService }, { type: TicketsService }, { type: EquipmentService }, { type: Object3DService }, { type: FeatureService }, { type: MeasurementService }, { type: CommentService }, { type: HashtagService }, { type: MissionService }, { type: OperationService }, { type: DomainService }, { type: i1.TranslateService }] });
 
 /* eslint-disable class-methods-use-this */
 class OrganisationService {
@@ -15814,81 +16303,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     args: ['currentAPIService']
                 }] }] });
 
-class DomainService {
-    API; //AWS
-    constructor(apiInjected) {
-        this.API = apiInjected;
-    }
-    async getGenericDomainsAndForOrganisation(organisationID) {
-        return this.API.__proto__.ListDomains().then((domains) => {
-            return domains.items.filter((dom) => {
-                return (dom.organisationID === organisationID || !dom.organisationID);
-            });
-        });
-    }
-    async getGenericDomainsAndForOrgAndOrderedOrg(orgID, orderedOrgID = null) {
-        // TODO: Change this (UUID can change depending on DB)
-        if (orgID === "6e28201f-4679-4c29-9d2d-8a325f57cee9") {
-            // I am SmarterPlan, i can see all
-            return this.API.__proto__.ListDomains().then((response) => response.items);
-        }
-        const currentOrgDomains = await this.getGenericDomainsAndForOrganisation(orgID);
-        if (!orderedOrgID || orgID === orderedOrgID) {
-            return currentOrgDomains;
-        }
-        const orderedOrgDomains = await this.getGenericDomainsAndForOrganisation(orderedOrgID);
-        const merged = [...currentOrgDomains, ...orderedOrgDomains];
-        return filterUniqueArrayByID(merged);
-    }
-    async getDomainsForOrgExcludingTypes(types, organisationID) {
-        return this.getGenericDomainsAndForOrganisation(organisationID).then((domains) => {
-            return domains.filter((dom) => !types.includes(dom.type));
-        });
-    }
-    async getDomain(id) {
-        return this.API.__proto__.GetDomain(id);
-    }
-    async updateDomain(input) {
-        return this.API.__proto__.UpdateDomain(input);
-    }
-    async deleteDomain(id) {
-        return this.API.__proto__.DeleteDomain({ id });
-    }
-    async getRootDomains(orgID) {
-        const allDomains = await this.getGenericDomainsAndForOrganisation(orgID);
-        const root = allDomains.filter((dom) => !dom.parentID);
-        return root.sort((a, b) => a.name.localeCompare(b.name));
-    }
-    async createDomain(input) {
-        return this.API.__proto__.CreateDomain(input);
-    }
-    async getDomainsForOrgForType(type, organisationID, orderedOrg = null) {
-        return this.getGenericDomainsAndForOrgAndOrderedOrg(organisationID, orderedOrg).then((domains) => {
-            return domains.filter((dom) => dom.type === type);
-        });
-    }
-    async getParentDomainsForOrgAndOrderedOrgForType(type, organisationID, orderedOrg = null) {
-        return this.getGenericDomainsAndForOrgAndOrderedOrg(organisationID, orderedOrg).then((domains) => {
-            return domains.filter((dom) => dom.type === type && !dom.parentID);
-        });
-    }
-    async getDomainsForMissionsForOrg(orgID) {
-        const domains = await this.getDomainsForOrgExcludingTypes([DomainType.BOOKING, DomainType.FEATURE, DomainType.MISSION], orgID);
-        return domains.filter((dom) => !dom.parentID);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DomainService, deps: [{ token: 'currentAPIService' }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DomainService, providedIn: "root" });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DomainService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: "root",
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['currentAPIService']
-                }] }] });
-
 class TemplateService {
     API; //AWS
     constructor(apiInjected) {