@smarterplan/ngx-smarterplan-core 1.4.15 → 1.4.17

package/lib/helpers.service.d.ts

@@ -1,6 +1,49 @@
 import { NgbModal } from "@ng-bootstrap/ng-bootstrap";
 import { TranslateService } from "@ngx-translate/core";
 import { EquipmentDocument, LevelStatus, Locale, Mission, PoiType, RoleStatus } from "./types.service";
+/**
+ * Maps the coordinate space POI positions were captured in onto the loaded model's own space.
+ *
+ * Tag coordinates come from whichever viewer created them - typically Matterport - and the .glb is
+ * a separate capture with its own origin, axes and units. Without this, a tag created in one viewer
+ * lands in the wrong place in the other even though both read the same record.
+ */
+export interface ThreeJsAlignment {
+    translation?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Euler angles in radians, applied XYZ. */
+    rotation?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    scale?: number;
+}
+/** Where the camera starts when a Three.js visit is opened. */
+export interface ThreeJsPlacement {
+    cameraPosition?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    alignment?: ThreeJsAlignment;
+}
+/**
+ * Parses the placement stored in a Three.js capture's metadata, or null when there is none.
+ *
+ * Both the import (writing the navigation entry) and the viewer (framing the camera) need this, so
+ * it lives here rather than on either service. Placement is optional - the viewer frames the model
+ * automatically without it - so unusable metadata is warned about and dropped, never thrown.
+ */
+export declare function parseThreeJsPlacement(metadata: string): ThreeJsPlacement | null;
 export declare function getDistanceBetweenTwoPoints(startPoint: any, endPoint: any): number;
 export declare function poiTypeToString(type: PoiType): string;
 export declare function wait(timeout: number): Promise<void>;

package/lib/services/models/base-object.service.d.ts

@@ -1,11 +1,13 @@
 import { Equipment, Feature, POI, Ticket } from "../../types.service";
 import { NavigationService } from "./navigation.service";
 import { PoiService } from "./poi.service";
+import { VisitService } from "./visit.service";
 import * as i0 from "@angular/core";
 export declare class BaseObjectService {
     protected poiService: PoiService;
     private navigationService;
-    constructor(poiService: PoiService, navigationService: NavigationService);
+    private visitService;
+    constructor(poiService: PoiService, navigationService: NavigationService, visitService: VisitService);
     getModel3dAndSweep(object: Feature | Ticket | Equipment): Promise<{
         model3D: string;
         sweep: string;
@@ -14,6 +16,14 @@ export declare class BaseObjectService {
             y: number;
         };
     } | void>;
+    /**
+     * The space's 3D visit, or null when it has none.
+     *
+     * Takes the first one the database returns. That is not the space's chosen default - the
+     * default ordering lives in SpaceService, which cannot be injected here. The POI does not record
+     * which capture it was placed in, so with several 3D models this is a guess either way.
+     */
+    private getThreeJsVisitForSpace;
     updateIconForAllObjects(objects: Ticket[] | Feature[] | Equipment[], tagIcon: string): Promise<POI[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BaseObjectService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BaseObjectService>;

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

@@ -10,6 +10,7 @@ import { BaseObjectService } from './base-object.service';
 import { NavigationService } from './navigation.service';
 import { OperationService } from './operation.service';
 import { PoiService } from './poi.service';
+import { VisitService } from './visit.service';
 import { TicketsService } from './ticket.service';
 import { ZoneChangeService } from "../zoneChange.service";
 import * as i0 from "@angular/core";
@@ -49,7 +50,7 @@ export declare class EquipmentService extends BaseObjectService {
     awsKinesisAnalytics: any;
     isMuseumUser: boolean;
     private destroy$;
-    constructor(apiInjected: any, awsKinesisAnalyticsInjected: any, poiService: PoiService, navigationService: NavigationService, operationService: OperationService, ticketsService: TicketsService, navigatorService: NavigatorService, filterService: FilterService, userService: BaseUserService, viewerService: ViewerService, modalService: NgbModal, zoneChangeService: ZoneChangeService);
+    constructor(apiInjected: any, awsKinesisAnalyticsInjected: any, poiService: PoiService, navigationService: NavigationService, visitService: VisitService, operationService: OperationService, ticketsService: TicketsService, navigatorService: NavigatorService, filterService: FilterService, userService: BaseUserService, viewerService: ViewerService, modalService: NgbModal, zoneChangeService: ZoneChangeService);
     readEquipment(id: string): Promise<Equipment>;
     createEquipment(equip: Equipment, imageFile: File, documentFile: File): Promise<Equipment | void>;
     getSignedUrlsForEquipment(equip: Equipment): Promise<Equipment>;

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

@@ -9,6 +9,7 @@ import { CommentService } from "./comment.service";
 import { HashtagService } from "./hashtag.service";
 import { NavigationService } from "./navigation.service";
 import { PoiService } from "./poi.service";
+import { VisitService } from "./visit.service";
 import { ZoneChangeService } from "../zoneChange.service";
 import * as i0 from "@angular/core";
 export declare class FeatureService extends BaseObjectService {
@@ -40,7 +41,7 @@ export declare class FeatureService extends BaseObjectService {
     currentHashtags: Hashtag[];
     createObservable: Subject<Feature>;
     deleteObservable: Subject<Feature>;
-    constructor(apiInjected: any, navigatorService: NavigatorService, filterService: FilterService, poiService: PoiService, commentService: CommentService, userService: BaseUserService, navigationService: NavigationService, hashtagService: HashtagService, zoneChangeService: ZoneChangeService);
+    constructor(apiInjected: any, navigatorService: NavigatorService, filterService: FilterService, poiService: PoiService, commentService: CommentService, userService: BaseUserService, navigationService: NavigationService, visitService: VisitService, hashtagService: HashtagService, zoneChangeService: ZoneChangeService);
     createFeature(feature: Feature): Promise<Feature>;
     deleteFeature(feature: Feature): Promise<Feature>;
     updateFeature(feature: any): Promise<Feature>;

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

@@ -1,5 +1,5 @@
 import { Subject } from "rxjs";
-import { Space, Layer } from "../../types.service";
+import { Space, Layer, Visit } from "../../types.service";
 import { BaseUserService } from "../user.service";
 import { CaptureService } from "./capture.service";
 import { EquipmentService } from "./equipment.service";
@@ -33,6 +33,27 @@ export declare class SpaceService {
     updateSpace(input: any): Promise<Space>;
     getSpace(id: string): Promise<Space>;
     getModel3DForSpace(spaceID: string): Promise<string>;
+    /**
+     * The visit the current user is allowed to open for this space.
+     *
+     * Callers need more than the model reference - which viewer the visit was captured with decides
+     * whether it opens in Matterport or Three.js - so the whole visit is returned here.
+     */
+    getAllowedVisitForSpace(spaceID: string): Promise<Visit>;
+    /**
+     * Every visit the current user may open for this space.
+     *
+     * A site can carry more than one - a Matterport capture plus one or more 3D models - and the
+     * viewer offers them as a list, so the caller needs all of them rather than just the first.
+     */
+    getAllowedVisitsForSpace(spaceID: string): Promise<Visit[]>;
+    /**
+     * Sets which capture a visitor opens by default for this space.
+     *
+     * Pass null to clear it. Writing a single field on the space is what keeps the answer unique:
+     * there is nothing to clear elsewhere, and no way for two captures to both claim it.
+     */
+    setDefaultCapture(spaceID: string, captureID: string | null): Promise<Space>;
     getAllowedModel3DForSpace(spaceID: string): Promise<string>;
     softDeleteSpace(spaceID: string): Promise<void>;
     /**

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

@@ -10,6 +10,7 @@ import { BaseObjectService } from './base-object.service';
 import { NavigationService } from './navigation.service';
 import { OperationService } from './operation.service';
 import { PoiService } from './poi.service';
+import { VisitService } from './visit.service';
 import { EventService } from './event.service';
 import { InterventionService } from '../intervention.service';
 import { AffectationService } from './affectation.service';
@@ -38,6 +39,8 @@ export declare class TicketsService extends BaseObjectService {
     }>;
     currentSpaceID: string;
     zoneIDFilter: string;
+    /** Set while a viewer without zone navigation (Three.js) is showing a space. */
+    private spaceSubscription;
     dateFilter: Date[];
     ticketTypeFilter: TicketType[];
     reportingIcon: import("@iconify/types").IconifyIcon;
@@ -55,7 +58,7 @@ export declare class TicketsService extends BaseObjectService {
     floorsPerSpace: Zone[];
     selectedFloor: Zone;
     private destroy$;
-    constructor(awsKinesisAnalyticsInjected: any, apiInjected: any, operationService: OperationService, eventService: EventService, affectationService: AffectationService, poiService: PoiService, userService: BaseUserService, navigatorService: NavigatorService, filterService: FilterService, interventionService: InterventionService, navigationService: NavigationService, viewerService: ViewerService, zoneChangeService: ZoneChangeService, modalService: NgbModal);
+    constructor(awsKinesisAnalyticsInjected: any, apiInjected: any, operationService: OperationService, eventService: EventService, affectationService: AffectationService, poiService: PoiService, userService: BaseUserService, navigatorService: NavigatorService, filterService: FilterService, interventionService: InterventionService, navigationService: NavigationService, visitService: VisitService, viewerService: ViewerService, zoneChangeService: ZoneChangeService, modalService: NgbModal);
     initTickets(): Promise<void>;
     adaptTicket(ticket: Ticket): Promise<Ticket>;
     getPriorityColor(ticket: Ticket): string;

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

@@ -15,7 +15,15 @@ export declare class VisitService {
     private userService;
     choosenPlan: Plan;
     constructor(captureService: CaptureService, nodeService: NodeService, navigationService: NavigationService, zoneService: ZoneService, planService: PlanService, userService: BaseUserService);
-    getVisitsForSpaceForUser(spaceID: string): Promise<Visit[]>;
+    /**
+     * The visits a user may open for a space.
+     *
+     * `includeImageCount` drives one S3 listing per node, awaited in sequence, purely to fill
+     * `nmbImagesImported`. Callers that only need to know which visits exist - the viewer's model
+     * picker, for one - should pass false: waiting on S3 to draw a button is a visible delay, and
+     * the count is not read on that path.
+     */
+    getVisitsForSpaceForUser(spaceID: string, includeImageCount?: boolean): Promise<Visit[]>;
     deleteVisit(visit: Visit, spaceID: string): Promise<Visit>;
     loadImagesForSpace(space: Space): Promise<any>;
     getDefaultZoneForVisit(visit: Visit): Promise<Zone>;

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

@@ -1,6 +1,14 @@
 import { Equipment } from "../types.service";
 export declare const deleteFromS3: (path: any) => Promise<void>;
 export declare const uploadFileToS3: (path: string, file: File, objectId: string | null) => Promise<string>;
+/**
+ * Uploads a file, reporting progress as a 0-1 fraction.
+ *
+ * uploadFileToS3 above swallows progress, which is fine for a photo and unusable for a 3D model:
+ * these run to hundreds of megabytes, and an upload with no feedback is indistinguishable from a
+ * frozen page. Returns the stored key, which is what gets saved on the record.
+ */
+export declare const uploadFileToS3WithProgress: (path: string, file: File, onProgress?: (fraction: number) => void) => Promise<string>;
 export declare const getSignedImageUrlForEquipment: (equip: Equipment) => Promise<string | null>;
 export declare const getSignedImageUrlForProfile: (profile: any) => Promise<string | void>;
 export declare const getSignedImageUrlForSpace: (space: any) => Promise<string | void>;

package/lib/services/threejs-import.service.d.ts

@@ -0,0 +1,31 @@
+import { Layer, Node, Zone } from '../types.service';
+import { LayerService } from './models/layer.service';
+import { NavigationService } from './models/navigation.service';
+import { PlanService } from './models/plan.service';
+import { ZoneService } from './models/zone.service';
+import { BaseUserService } from './user.service';
+import * as i0 from "@angular/core";
+export declare class ThreeJsImportService {
+    private navigationService;
+    private zoneService;
+    private layerService;
+    private userService;
+    private planService;
+    private _spaceID;
+    get spaceID(): string;
+    set spaceID(value: string);
+    constructor(navigationService: NavigationService, zoneService: ZoneService, layerService: LayerService, userService: BaseUserService, planService: PlanService);
+    /**
+     * Checks that an S3 key points at something the viewer can actually load.
+     *
+     * Returns the reason it can't, or null when it's fine. This runs before anything is written, so a
+     * mistyped key fails on the form rather than creating zones and navigation for a model that will
+     * 404 the first time someone opens the visit.
+     */
+    validateModelKey(key: string): string | null;
+    importData(spaceID: string, surface: number, reloading?: boolean, node?: Node, overrideExisting?: boolean, placementMetadata?: string): Promise<boolean>;
+    createZone(name: string, layerID: string, surface?: number, parentID?: string, sweeps?: string[], node?: Node, metadata?: string): Promise<Zone>;
+    getLayerByName(name: string): Promise<Layer>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThreeJsImportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThreeJsImportService>;
+}