@smarterplan/ngx-smarterplan-core 1.4.13 → 1.4.14

package/lib/pipes/hashtag-from-id.pipe.d.ts

@@ -4,6 +4,15 @@ import * as i0 from "@angular/core";
 export declare class HashtagFromIdPipe implements PipeTransform {
     private hashtagService;
     constructor(hashtagService: HashtagService);
+    /**
+     * Resolves a hashtag id to its display name.
+     *
+     * The cache is consulted for THIS id, and the network answers whenever the id is not
+     * in it.
+     *
+     * Hashtag ids are globally unique, so a cache holding entries from several spaces can
+     * only ever produce a correct hit or a miss, never a wrong name.
+     */
     transform(hashtagID: string): Promise<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<HashtagFromIdPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<HashtagFromIdPipe, "hashtagFromID", false>;

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

@@ -8,6 +8,8 @@ import { Object3DService } from './models/object3D.service';
 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 { BaseUserService } from './user.service';
 import { Vec3 } from './utils/matterport-transform.util';
 import * as i0 from "@angular/core";
@@ -37,13 +39,37 @@ export declare class MatterportTagCopyService {
     private featureService;
     private measurementService;
     private commentService;
+    private hashtagService;
+    private spaceService;
     private translate;
     copyProgress$: BehaviorSubject<CopyProgress | null>;
     copyLog$: BehaviorSubject<CopyLogEntry[]>;
     private spModule;
     private log;
     private errorSeq;
-    constructor(navigationService: NavigationService, userService: BaseUserService, poiService: PoiService, ticketService: TicketsService, equipmentService: EquipmentService, object3DService: Object3DService, featureService: FeatureService, measurementService: MeasurementService, commentService: CommentService, translate: TranslateService);
+    /** 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
+     *  reference to a Comment record (see the schema: "connection to comment.id"). */
+    private commentIds;
+    /** source Hashtag id -> its name. */
+    private sourceHashtagNames;
+    /** normalised hashtag name -> its id in the TARGET space (pre-existing or just created). */
+    private targetHashtagIdsByName;
+    /** ids of the hashtags this run created in the target space. */
+    private createdHashtagIds;
+    /** ids of the hashtags actually persisted on a successfully created feature. Anything in
+     *  createdHashtagIds but absent here is an orphan and is deleted at the end of the run. */
+    private usedHashtagIds;
+    /** 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;
+    /** 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);
     copyTagsFromVisit(sourceSpaceId: string, targetSpaceId: string, landmarkSourceA: Vec3, landmarkTargetA: Vec3, landmarkSourceB: Vec3, landmarkTargetB: Vec3): Promise<boolean>;
     /** Adds or updates a step line (identified by stepId) with new text, then republishes the log. */
     private setStepLog;
@@ -51,6 +77,10 @@ export declare class MatterportTagCopyService {
     private appendErrorLog;
     /** 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
+     *  singleton, so leftover mappings would silently link a new copy to records created
+     *  during the previous one. */
+    private resetRunState;
     /** Builds and sets a step's log line as "<translated label>: <percent>%", no step numbering. */
     private setStepProgress;
     /** Logs a translated, parameterized error line for a single failed item. */
@@ -58,14 +88,152 @@ export declare class MatterportTagCopyService {
     /** 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
-     *  investigate the same way a network/permission error is. */
+     *  investigate the same way a network/permission error is.
+     *  `extraParams` carries the placeholders a few keys need on top of {{name}}/{{error}}
+     *  (e.g. errorFeatureAttachment's {{feature}}, errorPoi's {{sweep}}), which used to be
+     *  rendered as raw "{{feature}}" text in the log. */
     private logCopyItemError;
     /**
-     * Heuristic duplicate-detection: compares title AND description together instead of
-     * title alone, to reduce false positives when several source items happen to share
-     * the same title. Not a perfect guarantee, but meaningfully more robust.
+     * Null-safe equivalent of FeatureService.isArchived(): true when the operator has archived
+     * this feature on that space. "No mission on the space" answers false (nothing archived)
+     * instead of throwing, which is what made a copy from a space the operator is not a member
+     * of fail outright.
+     */
+    private isArchivedForOperator;
+    /**
+     * 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.
+     */
+    private spacesShareOrganisation;
+    /** Normalised lookup key for a hashtag name, so "Moyen Âge" and "moyen âge " match. */
+    private hashtagKey;
+    /**
+     * READ-ONLY indexing of both spaces' hashtags. Creates nothing.
+     *
+     * `Feature.hashtags` stores Hashtag *ids*, and a Hashtag is a per-space record, so the
+     * ids have to be translated by name. The translation table is built here; the missing
+     * keywords are created later, one at a time, only when a POI that actually uses them is
+     * about to be written (see resolveHashtagIds()).
+     */
+    private loadHashtagIndex;
+    /**
+     * Translates one feature's hashtag ids into target-space ids, creating on the fly the
+     * keywords the target space does not have yet.
+     *
+     * Creation is LAZY on purpose. Doing it up front, for the whole source vocabulary, meant
+     * that a copy which failed or was closed halfway left behind keywords no POI referenced —
+     * pollution the operator had to clean up by hand. Here a keyword is only ever written
+     * when a POI that carries it is about to be created, so an interrupted copy stops
+     * creating keywords at the same POI it stops creating content.
+     *
+     * The residual window (keyword created, then createFeature fails) is closed by
+     * markHashtagsUsed() + cleanupUnusedCreatedHashtags().
+     *
+     * A keyword that can neither be found nor created is dropped rather than left as a
+     * dangling id.
+     */
+    private resolveHashtagIds;
+    /** Records that these hashtags are now referenced by a feature that really exists, so
+     *  the end-of-run cleanup leaves them alone. */
+    private markHashtagsUsed;
+    /**
+     * Deletes the hashtags this run created that no copied POI ended up referencing.
+     *
+     * Runs on every exit path — success, general failure, or exception — so the target space
+     * never keeps keywords that came from an aborted copy. Only ids created by THIS run are
+     * ever considered: a pre-existing keyword of the target space is never touched, even if
+     * no copied POI uses it.
+     */
+    private cleanupUnusedCreatedHashtags;
+    /**
+     * Orders a feature's media set exactly the way the UI will read it back, and repairs
+     * the ordering key when the source data cannot express the user's intended order.
+     *
+     * The viewer sorts each media family on its own (`setImages`, `setVideos`, `setAudio`,
+     * `setDocuments`, ... all do `.sort((a, b) => a.index - b.index)`), so `index` only has
+     * to be consistent WITHIN a CommentType. The attachment form however defaults `index`
+     * to 1 for every new attachment, so a multi-image POI very often holds several images
+     * all sharing index 1 — or null. Sorting those is left to DynamoDB's arbitrary scan
+     * order, which is why the copy came out in a different order than the original.
+     *
+     * Strategy: sort deterministically (index, then creation date, then id — i.e. the
+     * upload order the user actually saw), and only rewrite the indices of a family when
+     * they are ambiguous (null or duplicated). A family whose indices are already unique
+     * is copied untouched, so a deliberate ordering is never overwritten.
+     */
+    private orderCommentsForCopy;
+    /** Sort key for a comment's position; a missing index sorts last, not first. */
+    private orderingIndexOf;
+    /** Creation timestamp of a comment, used as the tie-breaker: it reflects the order in
+     *  which the user uploaded the media, which is the order they saw. */
+    private creationTimeOf;
+    /**
+     * Copies ONE media item (image, video, audio, document, text, link, embed, iframe...)
+     * of a feature, duplicating its file in S3 first when it has one.
+     *
+     * Every column of the Comment model is carried over. `description` and `metadata` were
+     * previously dropped, which emptied the captions of images/videos, the body of TEXT
+     * items — where the whole content lives, since a TEXT comment has no file — and any
+     * per-media settings stored in metadata.
+     */
+    private copyCommentForFeature;
+    /** Same, for an attachment carried by a ticket rather than by a feature. */
+    private copyCommentForTicket;
+    /** Shared body of the two above: `owner` carries whichever foreign key links the copy back
+     *  to its new parent, everything else is identical. */
+    private copyComment;
+    /**
+     * Creates the target-space copy of a source POI, with EVERY column of the POI model.
+     *
+     * Single entry point for all phases: the element phases (ticket, equipment, 3D object,
+     * feature, measurement) used to build their POI inline with only 5 fields — coordinate,
+     * type, elementID, metadata, sweep — which is precisely how museum POIs lost their
+     * pastille: `tagDescription` (the popup text), `tagIcon` (the custom icon) and
+     * `tagImageID` (the pastille's image) never left the source space.
+     */
+    private createCopiedPoi;
+    /**
+     * Adapts a POI's `metadata` (see MattertagData.getMetadataString(): { icon, normal, sid })
+     * to the target space.
+     *
+     *  - `sid` is the id of the Mattertag inside the SOURCE Matterport model. Carried over,
+     *    the viewer tries to re-create the target's tag with an id belonging to another
+     *    model ("already in use"), so the pastille fails to attach. It is dropped: the
+     *    viewer then allocates a fresh sid on first render.
+     *  - `normal` is the stem direction. It is a direction, so only the rotation applies
+     *    (never the translation); without it, a copied pastille points into the wall
+     *    whenever the two models are not aligned on the same axis.
+     *  - `icon` and anything else is kept as-is.
+     */
+    private getAdjustedPoiMetadata;
+    /**
+     * Resolves a POI's `tagImageID` — which the schema documents as a "connection to
+     * comment.id", i.e. the id of the Comment holding the image shown in the pastille.
+     *
+     * It is NOT an S3 key, so the previous "does it contain a slash?" heuristic never
+     * matched and the value travelled unchanged, leaving every copied pastille pointing at
+     * a Comment of the source space. It is now translated through the comment id map built
+     * while duplicating the media, and dropped when it cannot be resolved (the pastille
+     * then falls back to the feature's cover image instead of a broken reference).
+     */
+    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.
+     *
+     * 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
+     * all: both sides read `undefined`, every equipment therefore "matched" every other one,
+     * and a target space holding a single equipment silently caused the whole equipment phase
+     * to copy nothing.
      */
     private matchesExisting;
+    /** Serialises the identifying fields unambiguously, so that ["a", "b"] and ["ab", ""]
+     *  can never produce the same key. */
+    private identityKey;
     /**
      * Fetches the position of every sweep in a space and returns it as a Map for O(1) lookup.
      * Uses allSettled so a single failing sweep lookup doesn't abort the whole map —
@@ -90,6 +258,8 @@ export declare class MatterportTagCopyService {
     /**
      * Builds a new S3 key for a copied attachment and sanitizes the filename
      * to prevent AWS Amplify SignatureDoesNotMatch errors.
+     * `folderOverride` re-homes the copy into another prefix — used for tag icons, which
+     * are stored per space (`icons-tags/<spaceId>/`) and must follow the target space.
      */
     private buildCopiedAttachmentKey;
     /**
@@ -100,20 +270,31 @@ export declare class MatterportTagCopyService {
      * - Any other kind of failure (permissions, network, etc.) still throws a generic Error.
      */
     private copyS3KeyIfPresent;
+    /** True when the failure means the source object simply is not on S3 (orphaned reference). */
+    private isMissingS3File;
+    /** True when AppSync refused the operation for lack of permission, as opposed to failing it.
+     *  Nothing can be retried or worked around client-side: the account simply is not allowed
+     *  to write that model, which is a backend authorisation rule (@auth) to change. */
+    private isUnauthorized;
+    /** True for the SigV4 mismatch Storage.copy() raises on keys with special characters. */
+    private isSignatureMismatch;
     /**
      * Duplicates the file referenced by a POI's tagIcon (a JSON string shaped like
-     * { src, opacity }, per form-feature.component.ts). If the JSON can't be parsed or
-     * has no `src`, the value is returned unchanged rather than risk corrupting it.
+     * { src, opacity }, per form-feature.component.ts).
+     *
+     * Two behaviours matter here:
+     *  - the copy is re-homed under the TARGET space's icon folder
+     *    (`icons-tags/<targetSpaceId>/`, the layout form-feature.component.ts uploads to).
+     *    Keeping the source folder produced a target space whose icons all lived under
+     *    another space's prefix, so cleaning up the source space broke the copy's icons.
+     *  - a missing icon file is NOT fatal. It used to bubble up as a MissingS3FileError and
+     *    abort the whole POI — losing the pastille, its text and its media because of a
+     *    decorative file. The POI is now created with the icon reference dropped, which
+     *    renders the module's default icon, and a log line reports it.
      */
     private duplicateTagIcon;
-    /**
-     * Duplicates tagImageID if it looks like a reference to a file (contains a path
-     * separator, whether raw key or pre-signed URL). UNCONFIRMED ASSUMPTION: this
-     * field's exact semantics weren't verified — if it's actually an opaque reference
-     * to another DB record rather than a file, this heuristic may incorrectly attempt
-     * a copy. Confirm the real structure to tighten this if it causes issues.
-     */
-    private duplicateTagImageID;
+    /** Icon folder of the space being copied into, matching what the feature form uploads to. */
+    private buildTargetIconFolder;
     /**
      * Extracts and normalizes the raw S3 key from a stored value (which may be a full URL
      * or already a raw key).

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

@@ -15,6 +15,22 @@ export declare class CommentService {
     getComment(commentID: string): Promise<Comment>;
     deleteComment(commentID: string): Promise<Comment>;
     createComment(comment: Comment): Promise<Comment>;
+    /**
+     * Returns EVERY comment attached to a feature, following `nextToken` until the
+     * connection is exhausted.
+     *
+     * The `comments` connection nested inside FeaturesBySpace/GetFeature is capped by
+     * the AppSync resolver (`$util.defaultIfNull($context.args.limit, 100)`) and exposes
+     * a `nextToken` that nobody follows, so a media-rich POI silently loses every
+     * attachment past the first page. Anything that must see the complete media set of
+     * a feature (duplication, export, audit) has to use this method rather than
+     * `feature.comments.items`.
+     */
+    getAllCommentsForFeature(featureID: string): Promise<Comment[]>;
+    /** Same as getAllCommentsForFeature(), for the attachments of a ticket. */
+    getAllCommentsForTicket(ticketID: string): Promise<Comment[]>;
+    /** Drains a paginated comment query until its nextToken is exhausted. */
+    private getAllCommentsPaginated;
     updateComment(input: any): Promise<Comment>;
     uploadFileForComment(file: File, id?: string): Promise<string>;
     /** Create a new comment with an existing Annexe */

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

@@ -70,7 +70,10 @@ export declare class EquipmentService extends BaseObjectService {
      * S3 object itself has already been physically copied by the caller beforehand,
      * so this only needs to record the Note pointing at that new key.
      */
-    createNoteWithExistingAttachment(equipmentID: string, attachmentKey: string, type: TypeNote, ownerMissionID: string | null): Promise<Note>;
+    createNoteWithExistingAttachment(equipmentID: string, attachmentKey: string, type: TypeNote, ownerMissionID: string | null, dates?: {
+        signDate?: number | null;
+        expirationDate?: number | null;
+    }): Promise<Note>;
     uploadImage(equipment: Equipment, imageFile: File): Promise<Note>;
     updateEquipment(equip: any, file?: File, noteType?: TypeNote): Promise<Equipment>;
     getPrefixDoc(type: TypeNote): any;

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

@@ -48,6 +48,17 @@ export declare class FeatureService extends BaseObjectService {
     initFeatures(): Promise<void>;
     getFeaturesForSpace(spaceID: string, keepArchived?: boolean): Promise<Feature[]>;
     getFeaturesBySpaceWithoutFiltering(spaceID: string): Promise<Feature[]>;
+    /**
+     * 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;
     setCoverImage(feature: Feature): void;
     updateFeatureLocation(feature: Feature, tagData: MattertagData, spaceID: string): Promise<POI>;

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

@@ -6,6 +6,12 @@ export declare class HashtagService {
     API: any;
     constructor(apiInjected: any);
     getHashtag(hashtagID: string): Promise<Hashtag>;
+    /** Reads a space's keywords without touching the shared cache. */
+    listHashtagsForSpace(spaceID: string): Promise<Hashtag[]>;
+    /** Creates a keyword in a space without adding it to the shared cache. */
+    createHashtagForSpace(name: string, spaceID: string): Promise<Hashtag>;
+    /** Deletes a keyword without touching the shared cache. */
+    deleteHashtagById(hashtagID: string): Promise<Hashtag>;
     createHashtag(hashtag: Hashtag): Promise<Hashtag>;
     getHashtagsForSpace(spaceID?: string): Promise<Hashtag[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<HashtagService, never>;

package/lib/services/s3.service.d.ts

@@ -20,3 +20,17 @@ export declare const uploadJsonToS3: (path: string, json: string, filename: stri
  * to distinguish an orphaned DB reference from a genuine copy failure.
  */
 export declare const copyFileInS3: (sourceKey: string, destKey: string) => Promise<string>;
+/**
+ * Fallback duplication: downloads the object and re-uploads it under the new key.
+ *
+ * Storage.copy() builds the S3 `x-amz-copy-source` header by plain string concatenation
+ * (see @aws-amplify/storage AWSS3Provider.copy: `${bucket}/${srcPrefix}${srcKey}`), with no
+ * URL-encoding of the key. A key holding a space, an accent or a parenthesis therefore
+ * yields a header that does not match the signed canonical request, and S3 answers
+ * "The request signature we calculated does not match the signature you provided".
+ *
+ * Round-tripping the bytes avoids that header entirely and works for any key, at the cost
+ * of transferring the file through the browser — hence its use as a fallback only.
+ * IMPORTANT: like copyFileInS3, this must NOT swallow errors.
+ */
+export declare const copyFileInS3ViaDownload: (sourceKey: string, destKey: string) => Promise<string>;

package/lib/services/utils/matterport-transform.util.d.ts

@@ -15,7 +15,22 @@ export interface RigidTransform {
 export declare function computeRigidTransform(sourceA: Vec3, targetA: Vec3, sourceB: Vec3, targetB: Vec3): RigidTransform;
 /** Applies the rigid transform to a 3D position (x, y, z). */
 export declare function applyRigidTransformToPoint(p: Vec3, t: RigidTransform): Vec3;
-/** Applies the Y rotation (in degrees) to an orientation angle (a pose's yRotation). */
+/**
+ * Applies the Y rotation (in degrees) to an orientation angle (a pose's yRotation).
+ * A null/undefined/non-numeric angle is returned untouched: "no orientation stored"
+ * must stay "no orientation stored", not become the raw rotation delta.
+ */
 export declare function applyRigidTransformToYRotationDeg(yRotationDeg: number, t: RigidTransform): number;
 /** Euclidean distance between two points, useful to validate landmark quality. */
 export declare function distance(a: Vec3, b: Vec3): number;
+/**
+ * Applies ONLY the rotation part of the transform to a direction vector
+ * (a normal, a stem vector, ...).
+ *
+ * A direction has no origin, so the translation must NOT be applied to it —
+ * doing so would turn a unit normal into a point somewhere in the target model.
+ * Used for a POI's `metadata.normal`, which drives the orientation of the tag's
+ * stem: without this rotation, a pastille copied into a space whose model is
+ * rotated relative to the source ends up pointing into the wall it is stuck on.
+ */
+export declare function applyRigidTransformToDirection(v: Vec3, t: RigidTransform): Vec3;

package/package.json

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