@smarterplan/ngx-smarterplan-core 1.4.14 → 1.4.15

package/lib/services/matterport-tag-copy.service.d.ts

@@ -9,7 +9,9 @@ import { FeatureService } from './models/feature.service';
 import { MeasurementService } from './models/measurement.service';
 import { CommentService } from './models/comment.service';
 import { HashtagService } from './models/hashtag.service';
-import { SpaceService } from './models/space.service';
+import { MissionService } from './models/mission.service';
+import { OperationService } from './models/operation.service';
+import { DomainService } from './models/domain.service';
 import { BaseUserService } from './user.service';
 import { Vec3 } from './utils/matterport-transform.util';
 import * as i0 from "@angular/core";
@@ -22,11 +24,16 @@ export interface CopyProgress {
     totalOverall: number;
     percent: number;
     errorCount: number;
+    /** Items that already existed in the target space and had missing identity fields
+     *  filled in, rather than being newly created — see healEquipmentIdentity() and its
+     *  ticket/feature equivalents. */
+    healedCount: number;
 }
-/** A single line in the copy log — either a step status (updated in place) or an error (appended once). */
+/** A single line in the copy log — a step status (updated in place), or an error / healed
+ *  item notice (appended once, permanent). */
 export interface CopyLogEntry {
     id: string;
-    type: 'step' | 'error';
+    type: 'step' | 'error' | 'healed';
     text: string;
 }
 export declare class MatterportTagCopyService {
@@ -40,13 +47,16 @@ export declare class MatterportTagCopyService {
     private measurementService;
     private commentService;
     private hashtagService;
-    private spaceService;
+    private missionService;
+    private operationService;
+    private domainService;
     private translate;
     copyProgress$: BehaviorSubject<CopyProgress | null>;
     copyLog$: BehaviorSubject<CopyLogEntry[]>;
     private spModule;
     private log;
-    private errorSeq;
+    /** Unique-id sequence shared by every permanent (non-step) log line — errors and healed-item notices alike. */
+    private logSeq;
     /** source element id -> id of its copy in the target space. */
     private elementIds;
     /** source Comment id -> id of its copy. Needed to remap POI.tagImageID, which is a
@@ -64,17 +74,39 @@ export declare 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. */
     private handledElementIds;
-    /** 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. */
-    private sameOrganisation;
+    /** source Mission id -> its userID. */
+    private sourceMissionUserIds;
+    /** userID -> that user's Mission id in the TARGET space (only set when they have one). */
+    private targetMissionIdsByUserId;
+    /** 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. */
+    private domainsById;
+    /** 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. */
+    private targetVisibleDomainOrgIds;
+    /** `${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. */
+    private targetDomainIdsByTypeAndName;
     /** Target space id of the run in progress — used to re-home copied tag icons. */
     private targetSpaceId;
-    constructor(navigationService: NavigationService, userService: BaseUserService, poiService: PoiService, ticketService: TicketsService, equipmentService: EquipmentService, object3DService: Object3DService, featureService: FeatureService, measurementService: MeasurementService, commentService: CommentService, hashtagService: HashtagService, spaceService: SpaceService, translate: TranslateService);
+    constructor(navigationService: NavigationService, userService: BaseUserService, poiService: PoiService, ticketService: TicketsService, equipmentService: EquipmentService, object3DService: Object3DService, featureService: FeatureService, measurementService: MeasurementService, commentService: CommentService, hashtagService: HashtagService, missionService: MissionService, operationService: OperationService, domainService: DomainService, translate: TranslateService);
     copyTagsFromVisit(sourceSpaceId: string, targetSpaceId: string, landmarkSourceA: Vec3, landmarkTargetA: Vec3, landmarkSourceB: Vec3, landmarkTargetB: Vec3): Promise<boolean>;
+    /**
+     * 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?: string): void;
     /** Adds or updates a step line (identified by stepId) with new text, then republishes the log. */
     private setStepLog;
     /** Appends a new, permanent log line (never overwritten), then republishes the log. */
     private appendErrorLog;
+    /** Appends a permanent log line for an item that was repaired rather than newly
+     *  created — see healEquipmentIdentity() and its ticket/feature equivalents. */
+    private appendHealedLog;
     /** Resets the log for a new run. */
     private resetLog;
     /** Clears every id map carried over from a previous run. The service is a root-level
@@ -85,6 +117,10 @@ export declare class MatterportTagCopyService {
     private setStepProgress;
     /** Logs a translated, parameterized error line for a single failed item. */
     private logItemError;
+    /** 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. */
+    private logHealedItem;
     /** 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
@@ -100,14 +136,38 @@ export declare class MatterportTagCopyService {
      * of fail outright.
      */
     private isArchivedForOperator;
+    /** Normalised lookup key for a domain: type disambiguates same-named domains used for
+     *  different purposes (equipment vs. ticket vs. feature categories, ...). */
+    private domainKey;
+    /**
+     * 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.
+     */
+    private loadDomainIndex;
     /**
-     * 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.
+     * 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.
      */
-    private spacesShareOrganisation;
+    private resolveDomainID;
     /** Normalised lookup key for a hashtag name, so "Moyen Âge" and "moyen âge " match. */
     private hashtagKey;
     /**
@@ -136,6 +196,29 @@ export declare class MatterportTagCopyService {
      * dangling id.
      */
     private resolveHashtagIds;
+    /**
+     * 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.
+     */
+    private loadMissionIndex;
+    /**
+     * 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.
+     */
+    private resolveCommentOwnerID;
     /** Records that these hashtags are now referenced by a feature that really exists, so
      *  the end-of-run cleanup leaves them alone. */
     private markHashtagsUsed;
@@ -222,7 +305,9 @@ export declare class MatterportTagCopyService {
     private resolveTagImageID;
     /**
      * 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
@@ -230,7 +315,42 @@ export declare class MatterportTagCopyService {
      * and a target space holding a single equipment silently caused the whole equipment phase
      * to copy nothing.
      */
-    private matchesExisting;
+    private findExisting;
+    /**
+     * 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.
+     */
+    private buildHealPatch;
+    /**
+     * 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).
+     */
+    private healEquipmentIdentity;
+    /**
+     * 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.
+     */
+    private healTicketIdentity;
+    /** 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(). */
+    private healFeatureIdentity;
     /** Serialises the identifying fields unambiguously, so that ["a", "b"] and ["ab", ""]
      *  can never produce the same key. */
     private identityKey;

package/lib/services/models/domain.service.d.ts

@@ -4,6 +4,14 @@ export declare class DomainService {
     API: any;
     constructor(apiInjected: any);
     getGenericDomainsAndForOrganisation(organisationID: string): Promise<any | void>;
+    /**
+     * 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).
+     */
+    getAllGenericDomainsAndForOrganisation(organisationID: string): Promise<Domain[]>;
     getGenericDomainsAndForOrgAndOrderedOrg(orgID: string, orderedOrgID?: string): Promise<Domain[]>;
     getDomainsForOrgExcludingTypes(types: DomainType[], organisationID: string): Promise<Domain[]>;
     getDomain(id: string): Promise<Domain>;

package/lib/services/models/feature.service.d.ts

@@ -51,12 +51,6 @@ export declare 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.
      */
     getAllFeaturesBySpaceRaw(spaceID: string): Promise<Feature[]>;
     isBookingPlace(feature: Feature): void;

package/lib/services/models/mission.service.d.ts

@@ -21,6 +21,11 @@ export declare class MissionService {
     getActivatedMissions(missions: Mission[]): Mission[];
     getMissionsForZone(zoneID: string): Promise<Mission[]>;
     getMissionsForSpace(spaceID: string): Promise<Mission[]>;
+    /**
+     * Same as getMissionsForSpace(), but follows `nextToken` until the connection is
+     * exhausted instead of returning only the first page.
+     */
+    getAllMissionsForSpace(spaceID: string): Promise<Mission[]>;
     activateMission(mis: Mission): void;
     getMissionsByTemplate(templateID: string): Promise<Mission[]>;
     getMission(missionID: string): Promise<Mission>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smarterplan/ngx-smarterplan-core",
-  "version": "1.4.14",
+  "version": "1.4.15",
   "dependencies": {
     "tslib": "^2.5.0"
   },