@smarterplan/ngx-smarterplan-core 1.2.45 → 1.2.47

package/esm2020/lib/services/models/space.service.mjs

@@ -1,204 +1,204 @@
-/* eslint-disable class-methods-use-this */
-import { Inject, Injectable } from "@angular/core";
-import { Subject } from "rxjs";
-import { filterUniqueArrayByID, sortAlphabeticallyOnName } from "../../helpers.service";
-import { PropertyType } from "../../types.service";
-import { getSignedImageUrlForSpace } from "../s3.service";
-import * as i0 from "@angular/core";
-import * as i1 from "./visit.service";
-import * as i2 from "../user.service";
-import * as i3 from "./property.service";
-import * as i4 from "./capture.service";
-import * as i5 from "./mission.service";
-import * as i6 from "./ticket.service";
-import * as i7 from "./equipment.service";
-import * as i8 from "./feature.service";
-import * as i9 from "./measurement.service";
-export class SpaceService {
-    constructor(visitService, userService, propertyService, captureService, missionService, ticketService, equipService, featureService, measurementService, apiInjected) {
-        this.visitService = visitService;
-        this.userService = userService;
-        this.propertyService = propertyService;
-        this.captureService = captureService;
-        this.missionService = missionService;
-        this.ticketService = ticketService;
-        this.equipService = equipService;
-        this.featureService = featureService;
-        this.measurementService = measurementService;
-        this.locationsForUser = [];
-        this.locationUpdated = new Subject();
-        this.API = apiInjected;
-    }
-    async listSpaces() {
-        return this.API.__proto__.ListSpaces().then((spaces) => spaces.items.filter((sp) => !sp.deletedAt));
-    }
-    async getLocationsForCurrentUser() {
-        const missions = this.userService.currentMissions;
-        if (!missions)
-            return [];
-        let locations = [];
-        await Promise.all(missions.map(async (mission) => {
-            if (mission.space && !mission.space.deletedAt) {
-                const space = await this.getSpace(mission.space.id);
-                await this.signUrlForSpace(space);
-                await this.visitService
-                    .getVisitsForSpaceForUser(space.id)
-                    .then((visits) => {
-                    if (visits) {
-                        space.visits = visits;
-                    }
-                });
-                locations.push(space);
-            }
-        }));
-        if (locations.length > 0) {
-            locations = sortAlphabeticallyOnName(filterUniqueArrayByID(locations));
-        }
-        this.locationsForUser = locations;
-        this.locationUpdated.next(locations);
-        return locations;
-    }
-    async signUrlForSpace(loc) {
-        if (loc.annexes) {
-            getSignedImageUrlForSpace(loc).then((url) => {
-                if (url) {
-                    loc.annexes = url;
-                }
-            });
-        }
-    }
-    async getAllowedSpacesForOrg(orgID, userOrgID) {
-        if (userOrgID === "6e28201f-4679-4c29-9d2d-8a325f57cee9" ||
-            orgID === "6e28201f-4679-4c29-9d2d-8a325f57cee9") {
-            return this.listSpaces();
-        }
-        return this.getSpacesForOrg(userOrgID);
-    }
-    async getSpacesForOrg(orgID) {
-        const properties = await this.propertyService.getPropertiesForOrganisation(orgID);
-        if (properties.length > 0) {
-            const spaces = [];
-            for (const property of properties) {
-                if (property.space && !property.space.deletedAt) {
-                    spaces.push(property.space);
-                }
-            }
-            return spaces;
-        }
-        return null;
-    }
-    async createSpace(values, layer) {
-        const loc = await this.API.__proto__.CreateSpace(values);
-        const zoneInput = {
-            name: values.name,
-            spaceID: loc.id,
-            surface: 0,
-            layerID: layer ? layer.id : null,
-        };
-        await this.API.__proto__.CreateZone(zoneInput);
-        return loc;
-    }
-    async updateSpace(input) {
-        return this.API.__proto__.UpdateSpace(input);
-    }
-    async getSpace(id) {
-        return this.API.__proto__.GetSpace(id);
-    }
-    async getModel3DForSpace(spaceID) {
-        const captures = await this.captureService.getCapturesBySpace(spaceID);
-        if (captures.length > 0 && captures[0].nodes.items.length > 0) {
-            return captures[0].nodes.items[0].model3D;
-        }
-        return null;
-    }
-    async getAllowedModel3DForSpace(spaceID) {
-        const visits = await this.visitService.getVisitsForSpaceForUser(spaceID);
-        if (visits.length > 0) {
-            return visits[0].model3d;
-        }
-        return null;
-    }
-    async softDeleteSpace(spaceID) {
-        await this.updateSpace({
-            id: spaceID,
-            deletedAt: Date.now(),
-        });
-        const missions = await this.missionService.getMissionsForSpace(spaceID);
-        const properties = await this.propertyService.listPropertiesForSpace(spaceID);
-        if (this.userService.isSPAdmin()) {
-            // delete all properties
-            await Promise.all(properties.map(async (property) => {
-                await this.propertyService.deleteProperty(property.id);
-            }));
-            // delete all missions
-            await Promise.all(missions.map(async (mission) => {
-                await this.missionService.update({
-                    id: mission.id,
-                    deletedAt: Date.now(),
-                });
-            }));
-        }
-        else {
-            // delete property for current Org
-            const currentOrg = this.userService.currentOrganisation(spaceID);
-            const propertyToDelete = properties.find((property) => property.organisationID === currentOrg.id);
-            if (propertyToDelete) {
-                await this.propertyService.deleteProperty(propertyToDelete.id);
-            }
-            const missionsToDelete = missions.filter((mission) => mission.organisationID === currentOrg.id ||
-                mission.orderedOrganisationID === currentOrg.id);
-            await Promise.all(missionsToDelete.map(async (mission) => {
-                await this.missionService.update({
-                    id: mission.id,
-                    deletedAt: Date.now(),
-                });
-            }));
-        }
-        const tickets = await this.ticketService.getTicketsBySpace(spaceID);
-        await Promise.all(tickets.map(async (ticket) => {
-            await this.ticketService.deleteTicket(ticket);
-        }));
-        const equips = await this.equipService.getEquipmentsForSpace(spaceID);
-        await Promise.all(equips.map(async (eq) => {
-            await this.equipService.deleteEquipment(eq);
-        }));
-        const features = await this.featureService.getFeaturesForSpace(spaceID);
-        await Promise.all(features.map(async (feature) => {
-            await this.featureService.deleteFeature(feature);
-        }));
-        // measurements
-        const measures = await this.measurementService.getMeasurementsForSpaceForUser(spaceID);
-        await Promise.all(measures.map(async (measure) => {
-            await this.measurementService.deleteMeasurement(measure);
-        }));
-        // remove from list
-        this.locationsForUser = this.locationsForUser.filter((space) => space.id !== spaceID);
-        this.locationUpdated.next(this.locationsForUser);
-    }
-    /**
-     * If current user can archive a space (only if his organisation is owning the property (PropertyType.PROPERTY))
-     * @param spaceID
-     * @returns
-     */
-    async canArchiveSpace(spaceID) {
-        const currentOrg = this.userService.currentOrganisation(spaceID);
-        const orgProperties = await this.propertyService.getPropertiesForOrganisation(currentOrg.id);
-        const property = orgProperties.find((property_) => property_.spaceID === spaceID);
-        if (property.type === PropertyType.PROPERTY) {
-            return true;
-        }
-        return false;
-    }
-}
-SpaceService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SpaceService, deps: [{ token: i1.VisitService }, { token: i2.BaseUserService }, { token: i3.PropertyService }, { token: i4.CaptureService }, { token: i5.MissionService }, { token: i6.TicketsService }, { token: i7.EquipmentService }, { token: i8.FeatureService }, { token: i9.MeasurementService }, { token: 'currentAPIService' }], target: i0.ɵɵFactoryTarget.Injectable });
-SpaceService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SpaceService, providedIn: "root" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SpaceService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: "root",
-                }]
-        }], ctorParameters: function () { return [{ type: i1.VisitService }, { type: i2.BaseUserService }, { type: i3.PropertyService }, { type: i4.CaptureService }, { type: i5.MissionService }, { type: i6.TicketsService }, { type: i7.EquipmentService }, { type: i8.FeatureService }, { type: i9.MeasurementService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['currentAPIService']
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"space.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-smarterplan-core/src/lib/services/models/space.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable class-methods-use-this */\nimport { Inject, Injectable } from \"@angular/core\";\nimport { Subject } from \"rxjs\";\nimport { filterUniqueArrayByID, sortAlphabeticallyOnName } from \"../../helpers.service\";\nimport { Space, Layer, PropertyType } from \"../../types.service\";\nimport { getSignedImageUrlForSpace } from \"../s3.service\";\nimport { BaseUserService } from \"../user.service\";\nimport { CaptureService } from \"./capture.service\";\nimport { EquipmentService } from \"./equipment.service\";\nimport { FeatureService } from \"./feature.service\";\nimport { MeasurementService } from \"./measurement.service\";\nimport { MissionService } from \"./mission.service\";\nimport { PropertyService } from \"./property.service\";\nimport { TicketsService } from \"./ticket.service\";\nimport { VisitService } from \"./visit.service\";\n\n\n@Injectable({\n    providedIn: \"root\",\n})\nexport class SpaceService {\n\n    locationsForUser: Space[] = [];\n\n    locationUpdated: Subject<Space[]> = new Subject<Space[]>();\n\n    API: any; //AWS\n\n    constructor(\n        private visitService: VisitService,\n        private userService: BaseUserService,\n        private propertyService: PropertyService,\n        private captureService: CaptureService,\n        private missionService: MissionService,\n        private ticketService: TicketsService,\n        private equipService: EquipmentService,\n        private featureService: FeatureService,\n        private measurementService: MeasurementService,\n        @Inject('currentAPIService') apiInjected: any\n    ) {\n        this.API = apiInjected;\n    }\n\n    async listSpaces(): Promise<Space[]> {\n        return this.API.__proto__.ListSpaces().then((spaces) =>\n            spaces.items.filter((sp) => !sp.deletedAt),\n        );\n    }\n\n    async getLocationsForCurrentUser(): Promise<Space[]> {\n        const missions = this.userService.currentMissions;\n        if (!missions) return [];\n        let locations = [];\n        await Promise.all(\n            missions.map(async (mission) => {\n                if (mission.space && !mission.space.deletedAt) {\n                    const space = await this.getSpace(mission.space.id);\n                    await this.signUrlForSpace(space);\n                    await this.visitService\n                        .getVisitsForSpaceForUser(space.id)\n                        .then((visits) => {\n                            if (visits) {\n                                space.visits = visits;\n                            }\n                        });\n                    locations.push(space);\n                }\n            }),\n        );\n        if (locations.length > 0) {\n            locations = sortAlphabeticallyOnName(\n                filterUniqueArrayByID(locations),\n            );\n        }\n        this.locationsForUser = locations;\n        this.locationUpdated.next(locations);\n        return locations;\n    }\n\n    async signUrlForSpace(loc: Space) {\n        if (loc.annexes) {\n            getSignedImageUrlForSpace(loc).then((url) => {\n                if (url) {\n                    loc.annexes = url;\n                }\n            });\n        }\n    }\n\n    async getAllowedSpacesForOrg(\n        orgID: string,\n        userOrgID: string,\n    ): Promise<Space[]> {\n        if (\n            userOrgID === \"6e28201f-4679-4c29-9d2d-8a325f57cee9\" ||\n            orgID === \"6e28201f-4679-4c29-9d2d-8a325f57cee9\"\n        ) {\n            return this.listSpaces();\n        }\n        return this.getSpacesForOrg(userOrgID);\n    }\n\n    async getSpacesForOrg(orgID: string): Promise<Space[]> {\n        const properties =\n            await this.propertyService.getPropertiesForOrganisation(orgID);\n        if (properties.length > 0) {\n            const spaces = [];\n            for (const property of properties) {\n                if (property.space && !property.space.deletedAt) {\n                    spaces.push(property.space);\n                }\n            }\n            return spaces;\n        }\n        return null;\n    }\n\n    async createSpace(values: Space, layer?: Layer): Promise<any> {\n        const loc = await this.API.__proto__.CreateSpace(values);\n        const zoneInput = {\n            name: values.name,\n            spaceID: loc.id,\n            surface: 0,\n            layerID: layer ? layer.id : null,\n        };\n        await this.API.__proto__.CreateZone(zoneInput);\n        return loc;\n    }\n\n    async updateSpace(input: any): Promise<Space> {\n        return this.API.__proto__.UpdateSpace(input);\n    }\n\n    async getSpace(id: string): Promise<Space> {\n        return this.API.__proto__.GetSpace(id);\n    }\n\n    async getModel3DForSpace(spaceID: string): Promise<string> {\n        const captures = await this.captureService.getCapturesBySpace(spaceID);\n        if (captures.length > 0 && captures[0].nodes.items.length > 0) {\n            return captures[0].nodes.items[0].model3D;\n        }\n        return null;\n    }\n\n    async getAllowedModel3DForSpace(spaceID: string): Promise<string> {\n        const visits = await this.visitService.getVisitsForSpaceForUser(\n            spaceID,\n        );\n        if (visits.length > 0) {\n            return visits[0].model3d;\n        }\n        return null;\n    }\n\n    async softDeleteSpace(spaceID: string) {\n        await this.updateSpace({\n            id: spaceID,\n            deletedAt: Date.now(),\n        });\n        const missions = await this.missionService.getMissionsForSpace(spaceID);\n        const properties = await this.propertyService.listPropertiesForSpace(spaceID);\n        if (this.userService.isSPAdmin()) {\n            // delete all properties\n            await Promise.all(\n                properties.map(async (property) => {\n                    await this.propertyService.deleteProperty(property.id);\n                }),\n            );\n            // delete all missions\n            await Promise.all(\n                missions.map(async (mission) => {\n                    await this.missionService.update({\n                        id: mission.id,\n                        deletedAt: Date.now(),\n                    });\n                }),\n            );\n        } else {\n            // delete property for current Org\n            const currentOrg = this.userService.currentOrganisation(spaceID);\n            const propertyToDelete = properties.find(\n                (property) => property.organisationID === currentOrg.id,\n            );\n            if (propertyToDelete) {\n                await this.propertyService.deleteProperty(propertyToDelete.id);\n            }\n            const missionsToDelete = missions.filter(\n                (mission) =>\n                    mission.organisationID === currentOrg.id ||\n                    mission.orderedOrganisationID === currentOrg.id,\n            );\n            await Promise.all(\n                missionsToDelete.map(async (mission) => {\n                    await this.missionService.update({\n                        id: mission.id,\n                        deletedAt: Date.now(),\n                    });\n                }),\n            );\n        }\n        const tickets = await this.ticketService.getTicketsBySpace(spaceID);\n        await Promise.all(\n            tickets.map(async (ticket) => {\n                await this.ticketService.deleteTicket(ticket);\n            }),\n        );\n        const equips = await this.equipService.getEquipmentsForSpace(spaceID);\n        await Promise.all(\n            equips.map(async (eq) => {\n                await this.equipService.deleteEquipment(eq);\n            }),\n        );\n        const features = await this.featureService.getFeaturesForSpace(spaceID);\n        await Promise.all(\n            features.map(async (feature) => {\n                await this.featureService.deleteFeature(feature);\n            }),\n        );\n\n        // measurements\n        const measures = await this.measurementService.getMeasurementsForSpaceForUser(spaceID);\n        await Promise.all(\n            measures.map(async (measure) => {\n                await this.measurementService.deleteMeasurement(measure);\n            }),\n        );\n        // remove from list\n        this.locationsForUser = this.locationsForUser.filter((space) => space.id !== spaceID);\n        this.locationUpdated.next(this.locationsForUser);\n    }\n\n    /**\n     * If current user can archive a space (only if his organisation is owning the property (PropertyType.PROPERTY))\n     * @param spaceID\n     * @returns\n     */\n    async canArchiveSpace(spaceID: string): Promise<boolean> {\n        const currentOrg = this.userService.currentOrganisation(spaceID);\n        const orgProperties =\n            await this.propertyService.getPropertiesForOrganisation(\n                currentOrg.id,\n            );\n        const property = orgProperties.find(\n            (property_) => property_.spaceID === spaceID,\n        );\n        if (property.type === PropertyType.PROPERTY) {\n            return true;\n        }\n        return false;\n    }\n}\n"]}
+/* eslint-disable class-methods-use-this */
+import { Inject, Injectable } from "@angular/core";
+import { Subject } from "rxjs";
+import { filterUniqueArrayByID, sortAlphabeticallyOnName } from "../../helpers.service";
+import { PropertyType } from "../../types.service";
+import { getSignedImageUrlForSpace } from "../s3.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./visit.service";
+import * as i2 from "../user.service";
+import * as i3 from "./property.service";
+import * as i4 from "./capture.service";
+import * as i5 from "./mission.service";
+import * as i6 from "./ticket.service";
+import * as i7 from "./equipment.service";
+import * as i8 from "./feature.service";
+import * as i9 from "./measurement.service";
+export class SpaceService {
+    constructor(visitService, userService, propertyService, captureService, missionService, ticketService, equipService, featureService, measurementService, apiInjected) {
+        this.visitService = visitService;
+        this.userService = userService;
+        this.propertyService = propertyService;
+        this.captureService = captureService;
+        this.missionService = missionService;
+        this.ticketService = ticketService;
+        this.equipService = equipService;
+        this.featureService = featureService;
+        this.measurementService = measurementService;
+        this.locationsForUser = [];
+        this.locationUpdated = new Subject();
+        this.API = apiInjected;
+    }
+    async listSpaces() {
+        return this.API.__proto__.ListSpaces().then((spaces) => spaces.items.filter((sp) => !sp.deletedAt));
+    }
+    async getLocationsForCurrentUser() {
+        const missions = this.userService.currentMissions;
+        if (!missions)
+            return [];
+        let locations = [];
+        await Promise.all(missions.map(async (mission) => {
+            if (mission.space && !mission.space.deletedAt) {
+                const space = await this.getSpace(mission.space.id);
+                await this.signUrlForSpace(space);
+                await this.visitService
+                    .getVisitsForSpaceForUser(space.id)
+                    .then((visits) => {
+                    if (visits) {
+                        space.visits = visits;
+                    }
+                });
+                locations.push(space);
+            }
+        }));
+        if (locations.length > 0) {
+            locations = sortAlphabeticallyOnName(filterUniqueArrayByID(locations));
+        }
+        this.locationsForUser = locations;
+        this.locationUpdated.next(locations);
+        return locations;
+    }
+    async signUrlForSpace(loc) {
+        if (loc.annexes) {
+            getSignedImageUrlForSpace(loc).then((url) => {
+                if (url) {
+                    loc.annexes = url;
+                }
+            });
+        }
+    }
+    async getAllowedSpacesForOrg(orgID, userOrgID) {
+        if (userOrgID === "6e28201f-4679-4c29-9d2d-8a325f57cee9" ||
+            orgID === "6e28201f-4679-4c29-9d2d-8a325f57cee9") {
+            return this.listSpaces();
+        }
+        return this.getSpacesForOrg(userOrgID);
+    }
+    async getSpacesForOrg(orgID) {
+        const properties = await this.propertyService.getPropertiesForOrganisation(orgID);
+        if (properties.length > 0) {
+            const spaces = [];
+            for (const property of properties) {
+                if (property.space && !property.space.deletedAt) {
+                    spaces.push(property.space);
+                }
+            }
+            return spaces;
+        }
+        return null;
+    }
+    async createSpace(values, layer) {
+        const loc = await this.API.__proto__.CreateSpace(values);
+        const zoneInput = {
+            name: values.name,
+            spaceID: loc.id,
+            surface: 0,
+            layerID: layer ? layer.id : null,
+        };
+        await this.API.__proto__.CreateZone(zoneInput);
+        return loc;
+    }
+    async updateSpace(input) {
+        return this.API.__proto__.UpdateSpace(input);
+    }
+    async getSpace(id) {
+        return this.API.__proto__.GetSpace(id);
+    }
+    async getModel3DForSpace(spaceID) {
+        const captures = await this.captureService.getCapturesBySpace(spaceID);
+        if (captures.length > 0 && captures[0].nodes.items.length > 0) {
+            return captures[0].nodes.items[0].model3D;
+        }
+        return null;
+    }
+    async getAllowedModel3DForSpace(spaceID) {
+        const visits = await this.visitService.getVisitsForSpaceForUser(spaceID);
+        if (visits.length > 0) {
+            return visits[0].model3d;
+        }
+        return null;
+    }
+    async softDeleteSpace(spaceID) {
+        await this.updateSpace({
+            id: spaceID,
+            deletedAt: Date.now(),
+        });
+        const missions = await this.missionService.getMissionsForSpace(spaceID);
+        const properties = await this.propertyService.listPropertiesForSpace(spaceID);
+        if (this.userService.isSPAdmin()) {
+            // delete all properties
+            await Promise.all(properties.map(async (property) => {
+                await this.propertyService.deleteProperty(property.id);
+            }));
+            // delete all missions
+            await Promise.all(missions.map(async (mission) => {
+                await this.missionService.update({
+                    id: mission.id,
+                    deletedAt: Date.now(),
+                });
+            }));
+        }
+        else {
+            // delete property for current Org
+            const currentOrg = this.userService.currentOrganisation(spaceID);
+            const propertyToDelete = properties.find((property) => property.organisationID === currentOrg.id);
+            if (propertyToDelete) {
+                await this.propertyService.deleteProperty(propertyToDelete.id);
+            }
+            const missionsToDelete = missions.filter((mission) => mission.organisationID === currentOrg.id ||
+                mission.orderedOrganisationID === currentOrg.id);
+            await Promise.all(missionsToDelete.map(async (mission) => {
+                await this.missionService.update({
+                    id: mission.id,
+                    deletedAt: Date.now(),
+                });
+            }));
+        }
+        const tickets = await this.ticketService.getTicketsBySpace(spaceID);
+        await Promise.all(tickets.map(async (ticket) => {
+            await this.ticketService.deleteTicket(ticket);
+        }));
+        const equips = await this.equipService.getEquipmentsForSpace(spaceID);
+        await Promise.all(equips.map(async (eq) => {
+            await this.equipService.deleteEquipment(eq);
+        }));
+        const features = await this.featureService.getFeaturesForSpace(spaceID);
+        await Promise.all(features.map(async (feature) => {
+            await this.featureService.deleteFeature(feature);
+        }));
+        // measurements
+        const measures = await this.measurementService.getMeasurementsForSpaceForUser(spaceID);
+        await Promise.all(measures.map(async (measure) => {
+            await this.measurementService.deleteMeasurement(measure);
+        }));
+        // remove from list
+        this.locationsForUser = this.locationsForUser.filter((space) => space.id !== spaceID);
+        this.locationUpdated.next(this.locationsForUser);
+    }
+    /**
+     * If current user can archive a space (only if his organisation is owning the property (PropertyType.PROPERTY))
+     * @param spaceID
+     * @returns
+     */
+    async canArchiveSpace(spaceID) {
+        const currentOrg = this.userService.currentOrganisation(spaceID);
+        const orgProperties = await this.propertyService.getPropertiesForOrganisation(currentOrg.id);
+        const property = orgProperties.find((property_) => property_.spaceID === spaceID);
+        if (property.type === PropertyType.PROPERTY) {
+            return true;
+        }
+        return false;
+    }
+}
+SpaceService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SpaceService, deps: [{ token: i1.VisitService }, { token: i2.BaseUserService }, { token: i3.PropertyService }, { token: i4.CaptureService }, { token: i5.MissionService }, { token: i6.TicketsService }, { token: i7.EquipmentService }, { token: i8.FeatureService }, { token: i9.MeasurementService }, { token: 'currentAPIService' }], target: i0.ɵɵFactoryTarget.Injectable });
+SpaceService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SpaceService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SpaceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.VisitService }, { type: i2.BaseUserService }, { type: i3.PropertyService }, { type: i4.CaptureService }, { type: i5.MissionService }, { type: i6.TicketsService }, { type: i7.EquipmentService }, { type: i8.FeatureService }, { type: i9.MeasurementService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['currentAPIService']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"space.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-smarterplan-core/src/lib/services/models/space.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable class-methods-use-this */\r\nimport { Inject, Injectable } from \"@angular/core\";\r\nimport { Subject } from \"rxjs\";\r\nimport { filterUniqueArrayByID, sortAlphabeticallyOnName } from \"../../helpers.service\";\r\nimport { Space, Layer, PropertyType } from \"../../types.service\";\r\nimport { getSignedImageUrlForSpace } from \"../s3.service\";\r\nimport { BaseUserService } from \"../user.service\";\r\nimport { CaptureService } from \"./capture.service\";\r\nimport { EquipmentService } from \"./equipment.service\";\r\nimport { FeatureService } from \"./feature.service\";\r\nimport { MeasurementService } from \"./measurement.service\";\r\nimport { MissionService } from \"./mission.service\";\r\nimport { PropertyService } from \"./property.service\";\r\nimport { TicketsService } from \"./ticket.service\";\r\nimport { VisitService } from \"./visit.service\";\r\n\r\n\r\n@Injectable({\r\n    providedIn: \"root\",\r\n})\r\nexport class SpaceService {\r\n\r\n    locationsForUser: Space[] = [];\r\n\r\n    locationUpdated: Subject<Space[]> = new Subject<Space[]>();\r\n\r\n    API: any; //AWS\r\n\r\n    constructor(\r\n        private visitService: VisitService,\r\n        private userService: BaseUserService,\r\n        private propertyService: PropertyService,\r\n        private captureService: CaptureService,\r\n        private missionService: MissionService,\r\n        private ticketService: TicketsService,\r\n        private equipService: EquipmentService,\r\n        private featureService: FeatureService,\r\n        private measurementService: MeasurementService,\r\n        @Inject('currentAPIService') apiInjected: any\r\n    ) {\r\n        this.API = apiInjected;\r\n    }\r\n\r\n    async listSpaces(): Promise<Space[]> {\r\n        return this.API.__proto__.ListSpaces().then((spaces) =>\r\n            spaces.items.filter((sp) => !sp.deletedAt),\r\n        );\r\n    }\r\n\r\n    async getLocationsForCurrentUser(): Promise<Space[]> {\r\n        const missions = this.userService.currentMissions;\r\n        if (!missions) return [];\r\n        let locations = [];\r\n        await Promise.all(\r\n            missions.map(async (mission) => {\r\n                if (mission.space && !mission.space.deletedAt) {\r\n                    const space = await this.getSpace(mission.space.id);\r\n                    await this.signUrlForSpace(space);\r\n                    await this.visitService\r\n                        .getVisitsForSpaceForUser(space.id)\r\n                        .then((visits) => {\r\n                            if (visits) {\r\n                                space.visits = visits;\r\n                            }\r\n                        });\r\n                    locations.push(space);\r\n                }\r\n            }),\r\n        );\r\n        if (locations.length > 0) {\r\n            locations = sortAlphabeticallyOnName(\r\n                filterUniqueArrayByID(locations),\r\n            );\r\n        }\r\n        this.locationsForUser = locations;\r\n        this.locationUpdated.next(locations);\r\n        return locations;\r\n    }\r\n\r\n    async signUrlForSpace(loc: Space) {\r\n        if (loc.annexes) {\r\n            getSignedImageUrlForSpace(loc).then((url) => {\r\n                if (url) {\r\n                    loc.annexes = url;\r\n                }\r\n            });\r\n        }\r\n    }\r\n\r\n    async getAllowedSpacesForOrg(\r\n        orgID: string,\r\n        userOrgID: string,\r\n    ): Promise<Space[]> {\r\n        if (\r\n            userOrgID === \"6e28201f-4679-4c29-9d2d-8a325f57cee9\" ||\r\n            orgID === \"6e28201f-4679-4c29-9d2d-8a325f57cee9\"\r\n        ) {\r\n            return this.listSpaces();\r\n        }\r\n        return this.getSpacesForOrg(userOrgID);\r\n    }\r\n\r\n    async getSpacesForOrg(orgID: string): Promise<Space[]> {\r\n        const properties =\r\n            await this.propertyService.getPropertiesForOrganisation(orgID);\r\n        if (properties.length > 0) {\r\n            const spaces = [];\r\n            for (const property of properties) {\r\n                if (property.space && !property.space.deletedAt) {\r\n                    spaces.push(property.space);\r\n                }\r\n            }\r\n            return spaces;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    async createSpace(values: Space, layer?: Layer): Promise<any> {\r\n        const loc = await this.API.__proto__.CreateSpace(values);\r\n        const zoneInput = {\r\n            name: values.name,\r\n            spaceID: loc.id,\r\n            surface: 0,\r\n            layerID: layer ? layer.id : null,\r\n        };\r\n        await this.API.__proto__.CreateZone(zoneInput);\r\n        return loc;\r\n    }\r\n\r\n    async updateSpace(input: any): Promise<Space> {\r\n        return this.API.__proto__.UpdateSpace(input);\r\n    }\r\n\r\n    async getSpace(id: string): Promise<Space> {\r\n        return this.API.__proto__.GetSpace(id);\r\n    }\r\n\r\n    async getModel3DForSpace(spaceID: string): Promise<string> {\r\n        const captures = await this.captureService.getCapturesBySpace(spaceID);\r\n        if (captures.length > 0 && captures[0].nodes.items.length > 0) {\r\n            return captures[0].nodes.items[0].model3D;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    async getAllowedModel3DForSpace(spaceID: string): Promise<string> {\r\n        const visits = await this.visitService.getVisitsForSpaceForUser(\r\n            spaceID,\r\n        );\r\n        if (visits.length > 0) {\r\n            return visits[0].model3d;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    async softDeleteSpace(spaceID: string) {\r\n        await this.updateSpace({\r\n            id: spaceID,\r\n            deletedAt: Date.now(),\r\n        });\r\n        const missions = await this.missionService.getMissionsForSpace(spaceID);\r\n        const properties = await this.propertyService.listPropertiesForSpace(spaceID);\r\n        if (this.userService.isSPAdmin()) {\r\n            // delete all properties\r\n            await Promise.all(\r\n                properties.map(async (property) => {\r\n                    await this.propertyService.deleteProperty(property.id);\r\n                }),\r\n            );\r\n            // delete all missions\r\n            await Promise.all(\r\n                missions.map(async (mission) => {\r\n                    await this.missionService.update({\r\n                        id: mission.id,\r\n                        deletedAt: Date.now(),\r\n                    });\r\n                }),\r\n            );\r\n        } else {\r\n            // delete property for current Org\r\n            const currentOrg = this.userService.currentOrganisation(spaceID);\r\n            const propertyToDelete = properties.find(\r\n                (property) => property.organisationID === currentOrg.id,\r\n            );\r\n            if (propertyToDelete) {\r\n                await this.propertyService.deleteProperty(propertyToDelete.id);\r\n            }\r\n            const missionsToDelete = missions.filter(\r\n                (mission) =>\r\n                    mission.organisationID === currentOrg.id ||\r\n                    mission.orderedOrganisationID === currentOrg.id,\r\n            );\r\n            await Promise.all(\r\n                missionsToDelete.map(async (mission) => {\r\n                    await this.missionService.update({\r\n                        id: mission.id,\r\n                        deletedAt: Date.now(),\r\n                    });\r\n                }),\r\n            );\r\n        }\r\n        const tickets = await this.ticketService.getTicketsBySpace(spaceID);\r\n        await Promise.all(\r\n            tickets.map(async (ticket) => {\r\n                await this.ticketService.deleteTicket(ticket);\r\n            }),\r\n        );\r\n        const equips = await this.equipService.getEquipmentsForSpace(spaceID);\r\n        await Promise.all(\r\n            equips.map(async (eq) => {\r\n                await this.equipService.deleteEquipment(eq);\r\n            }),\r\n        );\r\n        const features = await this.featureService.getFeaturesForSpace(spaceID);\r\n        await Promise.all(\r\n            features.map(async (feature) => {\r\n                await this.featureService.deleteFeature(feature);\r\n            }),\r\n        );\r\n\r\n        // measurements\r\n        const measures = await this.measurementService.getMeasurementsForSpaceForUser(spaceID);\r\n        await Promise.all(\r\n            measures.map(async (measure) => {\r\n                await this.measurementService.deleteMeasurement(measure);\r\n            }),\r\n        );\r\n        // remove from list\r\n        this.locationsForUser = this.locationsForUser.filter((space) => space.id !== spaceID);\r\n        this.locationUpdated.next(this.locationsForUser);\r\n    }\r\n\r\n    /**\r\n     * If current user can archive a space (only if his organisation is owning the property (PropertyType.PROPERTY))\r\n     * @param spaceID\r\n     * @returns\r\n     */\r\n    async canArchiveSpace(spaceID: string): Promise<boolean> {\r\n        const currentOrg = this.userService.currentOrganisation(spaceID);\r\n        const orgProperties =\r\n            await this.propertyService.getPropertiesForOrganisation(\r\n                currentOrg.id,\r\n            );\r\n        const property = orgProperties.find(\r\n            (property_) => property_.spaceID === spaceID,\r\n        );\r\n        if (property.type === PropertyType.PROPERTY) {\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n}\r\n"]}

package/esm2020/lib/services/models/template.service.mjs

@@ -1,41 +1,41 @@
-import { Inject, Injectable } from "@angular/core";
-import * as i0 from "@angular/core";
-export class TemplateService {
-    constructor(apiInjected) {
-        this.API = apiInjected;
-    }
-    // --CRUD---
-    async create(template) {
-        return this.API.__proto__.CreateVisitTemplate(template);
-    }
-    async update(template) {
-        return this.API.__proto__.UpdateVisitTemplate(template);
-    }
-    async detele(templateID) {
-        return this.API.__proto__.DeleteVisitTemplate({ id: templateID });
-    }
-    async softDelete(templateID) {
-        return this.update({ id: templateID, deletedAt: Date.now() });
-    }
-    async get(templateID) {
-        return this.API.__proto__.GetVisitTemplate(templateID);
-    }
-    async getTemplatesBySpace(spaceID) {
-        return this.API.__proto__.TemplatesBySpace(spaceID).then((response) => response.items);
-    }
-    async getTemplatesByZone(zoneID) {
-        return this.API.__proto__.TemplatesByZone(zoneID).then((response) => response.items);
-    }
-}
-TemplateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: TemplateService, deps: [{ token: 'currentAPIService' }], target: i0.ɵɵFactoryTarget.Injectable });
-TemplateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: TemplateService, providedIn: "root" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: TemplateService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: "root",
-                }]
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['currentAPIService']
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+import { Inject, Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class TemplateService {
+    constructor(apiInjected) {
+        this.API = apiInjected;
+    }
+    // --CRUD---
+    async create(template) {
+        return this.API.__proto__.CreateVisitTemplate(template);
+    }
+    async update(template) {
+        return this.API.__proto__.UpdateVisitTemplate(template);
+    }
+    async detele(templateID) {
+        return this.API.__proto__.DeleteVisitTemplate({ id: templateID });
+    }
+    async softDelete(templateID) {
+        return this.update({ id: templateID, deletedAt: Date.now() });
+    }
+    async get(templateID) {
+        return this.API.__proto__.GetVisitTemplate(templateID);
+    }
+    async getTemplatesBySpace(spaceID) {
+        return this.API.__proto__.TemplatesBySpace(spaceID).then((response) => response.items);
+    }
+    async getTemplatesByZone(zoneID) {
+        return this.API.__proto__.TemplatesByZone(zoneID).then((response) => response.items);
+    }
+}
+TemplateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: TemplateService, deps: [{ token: 'currentAPIService' }], target: i0.ɵɵFactoryTarget.Injectable });
+TemplateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: TemplateService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: TemplateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['currentAPIService']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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