@smarterplan/ngx-smarterplan-core 0.3.11

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

@@ -0,0 +1,454 @@
+/* eslint-disable class-methods-use-this */
+/* eslint-disable consistent-return */
+import { Inject, Injectable } from "@angular/core";
+import { Subject } from "rxjs";
+import { openModalForVisitSwitch } from "../../helpers.service";
+import { TicketType, TicketPriority, TicketStatus, EventStatus, EventType, PoiType } from "../../types.service";
+import { BaseObjectService } from "./base-object.service";
+import InformationIcon from "@iconify-icons/mdi/information-outline";
+import AccidentIcon from "@iconify-icons/mdi/alert";
+import WordOrderIcon from "@iconify-icons/mdi/account-hard-hat";
+import ReportingIcon from "@iconify-icons/mdi/file-document-outline";
+import MaintenanceIcon from "@iconify-icons/mdi/tools";
+import * as i0 from "@angular/core";
+import * as i1 from "./operation.service";
+import * as i2 from "./event.service";
+import * as i3 from "./affectation.service";
+import * as i4 from "./poi.service";
+import * as i5 from "../user.service";
+import * as i6 from "../navigator.service";
+import * as i7 from "../filter.service";
+import * as i8 from "../intervention.service";
+import * as i9 from "./navigation.service";
+import * as i10 from "../viewer.service";
+import * as i11 from "@ng-bootstrap/ng-bootstrap";
+export class TicketsService extends BaseObjectService {
+    constructor(apiInjected, operationService, eventService, affectationService, poiService, userService, navigatorService, filterService, interventionService, navigationService, viewerService, modalService) {
+        super(poiService, navigationService);
+        this.operationService = operationService;
+        this.eventService = eventService;
+        this.affectationService = affectationService;
+        this.userService = userService;
+        this.navigatorService = navigatorService;
+        this.filterService = filterService;
+        this.interventionService = interventionService;
+        this.viewerService = viewerService;
+        this.modalService = modalService;
+        this.currentTickets = {
+            zone: [],
+            space: [],
+        };
+        this.ticketTags = new Subject();
+        this.ticketsFiltered = [];
+        this.ticketsUpdated = new Subject();
+        this.reportingIcon = ReportingIcon;
+        this.maintenanceIcon = MaintenanceIcon;
+        this.workorderIcon = WordOrderIcon;
+        this.informationIcon = InformationIcon;
+        this.accidentIcon = AccidentIcon;
+        this.updateDone = new Subject();
+        this.updating = new Subject();
+        this.isMuseumUser = false;
+        this.API = apiInjected;
+        this.isMuseumUser = this.userService.hasOnlyMuseumRole();
+        this.initSubscriptions();
+        this.userService.isChanged.subscribe((isConnected) => {
+            if (isConnected) {
+                this.isMuseumUser = this.userService.hasOnlyMuseumRole();
+                this.initSubscriptions();
+            }
+            else {
+                if (this.navSubscription) {
+                    this.navSubscription.unsubscribe();
+                    this.filetrSubscription.unsubscribe();
+                }
+            }
+        });
+    }
+    async initTickets() {
+        let ticketsFiltered = [];
+        if (this.currentSpaceID) {
+            this.updating.next(true);
+            await this.getTicketsBySpace(this.currentSpaceID).then((tickets) => {
+                if (tickets) {
+                    ticketsFiltered = tickets;
+                }
+            });
+            ticketsFiltered =
+                await this.filterService.filterTicketsForCurrentUserInSpace(ticketsFiltered, this.currentSpaceID);
+            if (this.dateFilter) {
+                ticketsFiltered = this.filterService.filterObjectsForDateRange(ticketsFiltered, this.dateFilter);
+            }
+            if (this.ticketTypeFilter) {
+                ticketsFiltered = ticketsFiltered.filter((ticket) => this.ticketTypeFilter.includes(ticket.type));
+            }
+            this.currentTickets.space = ticketsFiltered;
+            this.ticketTags.next(ticketsFiltered); // tags without zone filter
+            if (this.zoneIDFilter) {
+                ticketsFiltered = await this.filterService.filterObjectsForZone(ticketsFiltered, this.zoneIDFilter);
+            }
+            this.currentTickets.zone = ticketsFiltered;
+            this.ticketsUpdated.next(this.currentTickets);
+            this.updating.next(false);
+        }
+        else {
+            this.ticketTags.next(null);
+        }
+    }
+    async adaptTicket(ticket) {
+        if (ticket.comments.items.length > 0) {
+            ticket.comments.items.sort((a, b) => {
+                // @ts-ignore
+                return new Date(b.createdAt) - new Date(a.createdAt);
+            });
+        }
+        if (ticket.events.items.length > 0) {
+            // Sort events by date
+            ticket.events.items.sort((event1, event2) => {
+                // @ts-ignore
+                return new Date(event2.createdAt) - new Date(event1.createdAt);
+            });
+        }
+        ticket.prestataire =
+            await this.interventionService.getPrestataireForTicket(ticket);
+        return ticket;
+    }
+    getPriorityColor(ticket) {
+        switch (ticket.priority) {
+            case TicketPriority.MAXIMUM:
+                return "crimson";
+            case TicketPriority.HIGH:
+                return "red";
+            case TicketPriority.MEDIUM:
+                return "orange";
+            case TicketPriority.LOW:
+                return "green";
+            case TicketPriority.MINIMUM:
+                return "blue";
+            default:
+                return "blue";
+        }
+    }
+    getStatusColor(ticket) {
+        switch (ticket.status) {
+            case TicketStatus.TO_BE_PROCESSED:
+                return "#B0B0B1";
+            case TicketStatus.PLANNED:
+                return "#EBDF27";
+            case TicketStatus.IN_PROGRESS:
+                return "#EBDF27";
+            case TicketStatus.WAITING_FOR_VALIDATION:
+                return "#EBDF27";
+            case TicketStatus.VALIDATED:
+                return "#BCE2E5";
+            case TicketStatus.REJECTED:
+                return "#e84c35";
+            case TicketStatus.RESOLVED:
+                return "#BCE2E5";
+            case TicketStatus.ARCHIVED:
+                return "#B0B0B1";
+            case TicketStatus.LATE:
+                return "#e84c35";
+            case TicketStatus.BLOCKED:
+                return "#e84c35";
+            case TicketStatus.COMPLETED:
+                return "#388659";
+            case TicketStatus.DELAYED:
+                return "#DB7543";
+            case TicketStatus.CANCELLED:
+                return "#e84c35";
+            case TicketStatus.TO_REDO:
+                return "#DB7543";
+            case TicketStatus.CREATED:
+                return "#B0B0B1";
+            default:
+                return "#BCE2E5";
+        }
+    }
+    getTicketPriorityNumber(t) {
+        return t.priority === TicketPriority.MINIMUM
+            ? -1
+            : t.priority === TicketPriority.LOW
+                ? 0
+                : t.priority === TicketPriority.MEDIUM
+                    ? 1
+                    : t.priority === TicketPriority.HIGH
+                        ? 2
+                        : t.priority === TicketPriority.MAXIMUM
+                            ? 3
+                            : -1;
+    }
+    getTicketIcon(type) {
+        // const typeIcon : TicketType = ticket.type;
+        switch (type) {
+            case TicketType.REPORTING:
+                return this.reportingIcon;
+            case TicketType.REQUEST_FOR_INTERVENTION:
+                return this.maintenanceIcon;
+            case TicketType.REQUEST_FOR_MAINTENANCE:
+                return this.maintenanceIcon;
+            case TicketType.WORK_ORDER:
+                return this.workorderIcon;
+            case TicketType.INCIDENT:
+                return this.accidentIcon;
+            case TicketType.INFORMATION:
+                return this.informationIcon;
+            default:
+                return this.maintenanceIcon;
+        }
+    }
+    async addEventToTicket(ticket, event) {
+        const currentMission = this.userService.currentMission(ticket.spaceID);
+        event.group = event.group ? event.group : "default";
+        event.ticketID = event.ticketID ? event.ticketID : ticket.id;
+        event.status = event.status ? event.status : EventStatus.CREATED;
+        event.type = event.type ? event.type : EventType.TICKET;
+        event.ownerID = event.ownerID ? event.ownerID : currentMission.id;
+        try {
+            const receivedEvent = await this.eventService.createEvent(event);
+            // console.log('Event successfully created !');
+            return receivedEvent;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    async addTicket(ticket) {
+        ticket.status = TicketStatus.CREATED;
+        if (!ticket.ownerMissionID) {
+            ticket.ownerMissionID = this.userService.currentMission(ticket.spaceID).id;
+        }
+        // TODO!!! filter missions by space of ticket
+        try {
+            const receivedTicket = await this.createTicket(ticket);
+            // console.log('!!! Response from creating ticket :');
+            // console.log(receivedTicket);
+            this.addEventToTicket(receivedTicket, {
+                title: "Création du ticket",
+                description: `Ticket créé par -`,
+                translationPath: "ticketEvent.ticket.created",
+            });
+            this.updateDone.next(true);
+            return receivedTicket; // instead of true
+        }
+        catch (error) {
+            console.log("Ticket creation FAILED");
+            console.log(JSON.stringify(error));
+        }
+    }
+    async updateTicketWithEvent(ticket, event) {
+        const receivedTicket = await this.updateTicket(ticket);
+        if (receivedTicket) {
+            console.log("Updated ticket :");
+            console.log(receivedTicket);
+            if (event) {
+                await this.addEventToTicket(receivedTicket, event);
+            }
+            this.updateDone.next(true);
+        }
+        return receivedTicket;
+    }
+    async removeAssigneeFromTicket(ticket, assignee) {
+        try {
+            const affectation = await this.affectationService.softDeleteAffectationByID(assignee.id);
+            if (!affectation) {
+                console.warn(`removeAssigneeFromTicket(${ticket.id}, ${assignee.id}) failed`);
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+        return ticket;
+    }
+    async updateTicketLocation(ticket, tagData) {
+        const poiInput = {
+            coordinate: tagData.getCoordinateString(),
+            type: PoiType.TICKET,
+            elementID: ticket.id,
+            metadata: tagData.getMetadataString(),
+            matterportSweepID: tagData.getSweepID(),
+        };
+        const poi = await this.poiService.createPOIForSpaceID(poiInput);
+        await this.addEventToTicket(ticket, {
+            title: "Changement position du ticket",
+            description: "Le point d'intérêt du ticket a été modifié",
+            status: EventStatus.POSITION_SET,
+            translationPath: "ticketEvent.position.set",
+        });
+        return poi;
+    }
+    async updateStatusOfTicket(ticket, status) {
+        const currentStatus = ticket.status;
+        const oldTicketStatus = ticket.status;
+        ticket.status = status;
+        if (currentStatus === status) {
+            return ticket;
+        }
+        console.log("Updating status");
+        return this.updateTicket({
+            id: ticket.id,
+            status,
+        });
+    }
+    async updateTypeOfTicket(ticket, type) {
+        const previousType = ticket.type;
+        ticket.type = type;
+        await this.updateTicketWithEvent({ id: ticket.id, type: ticket.type }, {
+            title: "Type changé",
+            description: `Changement de ${previousType} vers ${ticket.type}`,
+            metadata: JSON.stringify({ type: ticket.type }),
+            translationPath: "ticketEvent.ticket.type",
+        });
+        return ticket;
+    }
+    async getTicketsForUserForSpace(spaceID) {
+        const ticketsSpace = await this.getTicketsBySpace(spaceID);
+        return this.filterService.filterTicketsForCurrentUserInSpace(ticketsSpace, spaceID);
+    }
+    /** Basic CRUD operations */
+    async readTicket(id) {
+        return this.API.__proto__.GetTicket(id);
+    }
+    async createTicket(input) {
+        return this.API.__proto__.CreateTicket(input);
+    }
+    async updateTicket(input) {
+        return this.API.__proto__.UpdateTicket(input);
+    }
+    async deleteTicket(ticket) {
+        const deleted = await this.API.__proto__.DeleteTicket({ id: ticket.id });
+        // delete POI
+        const poi = await this.poiService.getPoiByElementId(ticket.id);
+        if (poi) {
+            this.poiService.deletePoi(poi.id);
+        }
+        // clean parentID
+        if (ticket.children.items.length > 0) {
+            ticket.children.items.map(async (childTicket) => {
+                try {
+                    await this.API.__proto__.UpdateTicket({
+                        id: childTicket.id,
+                        parentID: null,
+                    });
+                }
+                catch {
+                    console.warn("Could not update ticket", childTicket.id);
+                }
+                await this.API.__proto__.CreateEvent({
+                    title: "Ticket parent supprimé",
+                    ticketID: childTicket.id,
+                    description: `Ticket \"$ticket.title}\" a été supprimé`,
+                });
+            });
+        }
+        // delete events
+        await Promise.all(ticket.events.items.map(async (event_) => {
+            await this.API.__proto__.DeleteEvent({ id: event_.id });
+        }));
+        // delete affectationns
+        if (ticket.assignees.items.length > 0) {
+            for (const element of ticket.assignees.items) {
+                this.API.__proto__.DeleteAffectation({ id: element.id });
+            }
+        }
+        // delete comments
+        await Promise.all(ticket.comments.items.map(async (comment) => {
+            await this.API.__proto__.DeleteComment({ id: comment.id });
+        }));
+        await this.operationService.deleteOperationsForTicket(ticket.id);
+        return deleted;
+    }
+    /** Custom requests */
+    async getTicketsBySpace(spaceID) {
+        return this.API.__proto__.TicketsBySpace(spaceID).then((tickets) => tickets.items);
+    }
+    async updateIconForAllTicketsInSpace(tagIcon, spaceID) {
+        const tickets = await this.getTicketsBySpace(spaceID);
+        const pois = await this.updateIconForAllObjects(tickets, tagIcon);
+        return { tickets, pois };
+    }
+    /** Archive related */
+    /** Return true if the current user has archived this ticket */
+    isArchived(ticket) {
+        return ticket.archivedForMissionID
+            ? ticket.archivedForMissionID.includes(this.userService.currentMission(ticket.spaceID).id)
+            : false;
+    }
+    setArchived(ticket, archived) {
+        let archivedList = ticket.archivedForMissionID
+            ? ticket.archivedForMissionID
+            : [];
+        const missionID = this.userService.currentMission(ticket.spaceID).id;
+        archivedList = archivedList.filter((m) => m !== missionID);
+        if (archived) {
+            archivedList.push(missionID);
+        }
+        return this.updateTicketWithEvent({
+            id: ticket.id,
+            archivedForMissionID: archivedList,
+        });
+    }
+    async navigateToTicketIn3D(ticket, forceSwitchVisit = false) {
+        let url = `visit/${ticket.spaceID}`;
+        if (forceSwitchVisit) {
+            url += `/detail/${ticket.id}`;
+        }
+        const canGoToTag = await this.viewerService.action_move_to_tag(`${ticket.id}`);
+        if (canGoToTag) {
+            return;
+        }
+        const result = await this.getModel3dAndSweep(ticket);
+        if (!result || !result.model3D) {
+            alert("Error while getting virtual visit model");
+            return;
+        }
+        if (!forceSwitchVisit) {
+            /** Si on ne force pas la visite, on demande si on veut etre switch */
+            openModalForVisitSwitch(this.modalService, result.model3D, ticket.spaceID, { sweepToMove: result.sweep, rotation: result.rotation });
+        }
+        else {
+            /** Si on force le switch de la visit */
+            window.open(`${url}?model3D=${result.model3D}&sweep=true`, "_blank");
+        }
+    }
+    initSubscriptions() {
+        if (!this.isMuseumUser) {
+            this.navSubscription = this.navigatorService.zoneChange.subscribe((zone) => {
+                this.currentSpaceID = this.navigatorService.currentSpaceID;
+                if (!this.currentSpaceID) {
+                    this.ticketTags.next(null);
+                    this.ticketsUpdated.next({ space: [], zone: null });
+                    this.ticketTypeFilter = null;
+                    this.zoneIDFilter = null;
+                }
+                else if (zone.id !== this.zoneIDFilter) {
+                    this.zoneIDFilter = zone.id;
+                    // console.log("going to init tickets from zone");
+                    this.initTickets();
+                }
+            });
+            this.filetrSubscription = this.filterService.subscribeToDataFilterUpdate((dateRange) => {
+                this.dateFilter = dateRange;
+                this.initTickets();
+            });
+            this.dateFilter = this.filterService.currentDateFilter;
+            this.updateDone.subscribe(() => {
+                if (this.currentSpaceID) {
+                    this.initTickets();
+                }
+            });
+        }
+    }
+}
+TicketsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: TicketsService, deps: [{ token: 'currentAPIService' }, { token: i1.OperationService }, { token: i2.EventService }, { token: i3.AffectationService }, { token: i4.PoiService }, { token: i5.BaseUserService }, { token: i6.NavigatorService }, { token: i7.FilterService }, { token: i8.InterventionService }, { token: i9.NavigationService }, { token: i10.ViewerService }, { token: i11.NgbModal }], target: i0.ɵɵFactoryTarget.Injectable });
+TicketsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: TicketsService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: TicketsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['currentAPIService']
+                }] }, { type: i1.OperationService }, { type: i2.EventService }, { type: i3.AffectationService }, { type: i4.PoiService }, { type: i5.BaseUserService }, { type: i6.NavigatorService }, { type: i7.FilterService }, { type: i8.InterventionService }, { type: i9.NavigationService }, { type: i10.ViewerService }, { type: i11.NgbModal }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ticket.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-smarterplan-core/src/lib/services/models/ticket.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable class-methods-use-this */\r\n/* eslint-disable consistent-return */\r\nimport { Inject, Injectable } from \"@angular/core\";\r\nimport { NgbModal } from \"@ng-bootstrap/ng-bootstrap\";\r\nimport { Subject, Subscription } from \"rxjs\";\r\nimport { openModalForVisitSwitch } from \"../../helpers.service\";\r\nimport { MattertagData } from \"../../mattertagData\";\r\nimport { Event, Ticket, TicketType, TicketPriority, TicketStatus, EventStatus, EventType, Affectation, POI, PoiType, IUpdate } from \"../../types.service\";\r\nimport { FilterService } from \"../filter.service\";\r\nimport { NavigatorService } from \"../navigator.service\";\r\nimport { BaseUserService } from \"../user.service\";\r\nimport { ViewerService } from \"../viewer.service\";\r\nimport { BaseObjectService } from \"./base-object.service\";\r\nimport { NavigationService } from \"./navigation.service\";\r\nimport { OperationService } from \"./operation.service\";\r\nimport { PoiService } from \"./poi.service\";\r\nimport InformationIcon from \"@iconify-icons/mdi/information-outline\";\r\nimport AccidentIcon from \"@iconify-icons/mdi/alert\";\r\nimport WordOrderIcon from \"@iconify-icons/mdi/account-hard-hat\";\r\nimport ReportingIcon from \"@iconify-icons/mdi/file-document-outline\";\r\nimport MaintenanceIcon from \"@iconify-icons/mdi/tools\";\r\nimport { EventService } from \"./event.service\";\r\nimport { InterventionService } from \"../intervention.service\";\r\nimport { AffectationService } from \"./affectation.service\";\r\n\r\n\r\n@Injectable({\r\n    providedIn: \"root\",\r\n})\r\nexport class TicketsService extends BaseObjectService {\r\n    currentTickets: { zone: Ticket[]; space: Ticket[] } = {\r\n        zone: [],\r\n        space: [],\r\n    };\r\n\r\n    ticketTags: Subject<Ticket[]> = new Subject();\r\n\r\n    ticketsFiltered: Ticket[] = [];\r\n\r\n    ticketsUpdated: Subject<{\r\n        zone: Ticket[];\r\n        space: Ticket[];\r\n    }> = new Subject();\r\n\r\n    currentSpaceID: string;\r\n\r\n    zoneIDFilter: string;\r\n\r\n    dateFilter: Date[];\r\n\r\n    ticketTypeFilter: TicketType[];\r\n\r\n    reportingIcon = ReportingIcon;\r\n\r\n    maintenanceIcon = MaintenanceIcon;\r\n\r\n    workorderIcon = WordOrderIcon;\r\n\r\n    informationIcon = InformationIcon;\r\n\r\n    accidentIcon = AccidentIcon;\r\n\r\n    updateDone: Subject<boolean> = new Subject();\r\n\r\n    updating: Subject<boolean> = new Subject();\r\n\r\n    API: any;\r\n\r\n    isMuseumUser = false;\r\n\r\n    navSubscription: Subscription;\r\n\r\n    filetrSubscription: Subscription;\r\n\r\n    constructor(\r\n        @Inject('currentAPIService') apiInjected: any,\r\n        private operationService: OperationService,\r\n        private eventService: EventService,\r\n        private affectationService: AffectationService,\r\n        poiService: PoiService,\r\n        private userService: BaseUserService,\r\n        private navigatorService: NavigatorService,\r\n        private filterService: FilterService,\r\n        private interventionService: InterventionService,\r\n        navigationService: NavigationService,\r\n        private viewerService: ViewerService,\r\n        private modalService: NgbModal,\r\n    ) {\r\n        super(poiService, navigationService);\r\n        this.API = apiInjected;\r\n        this.isMuseumUser = this.userService.hasOnlyMuseumRole();\r\n        this.initSubscriptions();\r\n        this.userService.isChanged.subscribe((isConnected) => {\r\n            if (isConnected) {\r\n                this.isMuseumUser = this.userService.hasOnlyMuseumRole();\r\n                this.initSubscriptions();\r\n            } else {\r\n                if (this.navSubscription) {\r\n                    this.navSubscription.unsubscribe();\r\n                    this.filetrSubscription.unsubscribe();\r\n                }\r\n            }\r\n        });\r\n    }\r\n\r\n    async initTickets() {\r\n        let ticketsFiltered = [];\r\n        if (this.currentSpaceID) {\r\n            this.updating.next(true);\r\n            await this.getTicketsBySpace(this.currentSpaceID).then(\r\n                (tickets) => {\r\n                    if (tickets) {\r\n                        ticketsFiltered = tickets;\r\n                    }\r\n                },\r\n            );\r\n            ticketsFiltered =\r\n                await this.filterService.filterTicketsForCurrentUserInSpace(\r\n                    ticketsFiltered,\r\n                    this.currentSpaceID,\r\n                );\r\n            if (this.dateFilter) {\r\n                ticketsFiltered = this.filterService.filterObjectsForDateRange(\r\n                    ticketsFiltered,\r\n                    this.dateFilter,\r\n                );\r\n            }\r\n            if (this.ticketTypeFilter) {\r\n                ticketsFiltered = ticketsFiltered.filter((ticket) =>\r\n                    this.ticketTypeFilter.includes(ticket.type),\r\n                );\r\n            }\r\n            this.currentTickets.space = ticketsFiltered;\r\n            this.ticketTags.next(ticketsFiltered); // tags without zone filter\r\n\r\n            if (this.zoneIDFilter) {\r\n                ticketsFiltered = await this.filterService.filterObjectsForZone(\r\n                    ticketsFiltered,\r\n                    this.zoneIDFilter,\r\n                );\r\n            }\r\n            this.currentTickets.zone = ticketsFiltered;\r\n            this.ticketsUpdated.next(this.currentTickets);\r\n            this.updating.next(false);\r\n        } else {\r\n            this.ticketTags.next(null);\r\n        }\r\n    }\r\n\r\n    async adaptTicket(ticket: Ticket): Promise<Ticket> {\r\n        if (ticket.comments.items.length > 0) {\r\n            ticket.comments.items.sort((a, b) => {\r\n                // @ts-ignore\r\n                return new Date(b.createdAt) - new Date(a.createdAt);\r\n            });\r\n        }\r\n\r\n        if (ticket.events.items.length > 0) {\r\n            // Sort events by date\r\n            ticket.events.items.sort((event1, event2) => {\r\n                // @ts-ignore\r\n                return new Date(event2.createdAt) - new Date(event1.createdAt);\r\n            });\r\n        }\r\n        ticket.prestataire =\r\n            await this.interventionService.getPrestataireForTicket(ticket);\r\n        return ticket;\r\n    }\r\n\r\n    getPriorityColor(ticket: Ticket): string {\r\n        switch (ticket.priority) {\r\n            case TicketPriority.MAXIMUM:\r\n                return \"crimson\";\r\n            case TicketPriority.HIGH:\r\n                return \"red\";\r\n            case TicketPriority.MEDIUM:\r\n                return \"orange\";\r\n            case TicketPriority.LOW:\r\n                return \"green\";\r\n            case TicketPriority.MINIMUM:\r\n                return \"blue\";\r\n            default:\r\n                return \"blue\";\r\n        }\r\n    }\r\n\r\n    getStatusColor(ticket: Ticket): string {\r\n        switch (ticket.status) {\r\n            case TicketStatus.TO_BE_PROCESSED:\r\n                return \"#B0B0B1\";\r\n            case TicketStatus.PLANNED:\r\n                return \"#EBDF27\";\r\n            case TicketStatus.IN_PROGRESS:\r\n                return \"#EBDF27\";\r\n            case TicketStatus.WAITING_FOR_VALIDATION:\r\n                return \"#EBDF27\";\r\n            case TicketStatus.VALIDATED:\r\n                return \"#BCE2E5\";\r\n            case TicketStatus.REJECTED:\r\n                return \"#e84c35\";\r\n            case TicketStatus.RESOLVED:\r\n                return \"#BCE2E5\";\r\n            case TicketStatus.ARCHIVED:\r\n                return \"#B0B0B1\";\r\n            case TicketStatus.LATE:\r\n                return \"#e84c35\";\r\n            case TicketStatus.BLOCKED:\r\n                return \"#e84c35\";\r\n            case TicketStatus.COMPLETED:\r\n                return \"#388659\";\r\n            case TicketStatus.DELAYED:\r\n                return \"#DB7543\";\r\n            case TicketStatus.CANCELLED:\r\n                return \"#e84c35\";\r\n            case TicketStatus.TO_REDO:\r\n                return \"#DB7543\";\r\n            case TicketStatus.CREATED:\r\n                return \"#B0B0B1\";\r\n            default:\r\n                return \"#BCE2E5\";\r\n        }\r\n    }\r\n\r\n    getTicketPriorityNumber(t): number {\r\n        return t.priority === TicketPriority.MINIMUM\r\n            ? -1\r\n            : t.priority === TicketPriority.LOW\r\n            ? 0\r\n            : t.priority === TicketPriority.MEDIUM\r\n            ? 1\r\n            : t.priority === TicketPriority.HIGH\r\n            ? 2\r\n            : t.priority === TicketPriority.MAXIMUM\r\n            ? 3\r\n            : -1;\r\n    }\r\n\r\n    getTicketIcon(type: TicketType): any {\r\n        // const typeIcon : TicketType = ticket.type;\r\n        switch (type) {\r\n            case TicketType.REPORTING:\r\n                return this.reportingIcon;\r\n            case TicketType.REQUEST_FOR_INTERVENTION:\r\n                return this.maintenanceIcon;\r\n            case TicketType.REQUEST_FOR_MAINTENANCE:\r\n                return this.maintenanceIcon;\r\n            case TicketType.WORK_ORDER:\r\n                return this.workorderIcon;\r\n            case TicketType.INCIDENT:\r\n                return this.accidentIcon;\r\n            case TicketType.INFORMATION:\r\n                return this.informationIcon;\r\n            default:\r\n                return this.maintenanceIcon;\r\n        }\r\n    }\r\n\r\n    async addEventToTicket(ticket: Ticket, event: Event): Promise<Event> {\r\n        const currentMission = this.userService.currentMission(ticket.spaceID);\r\n        event.group = event.group ? event.group : \"default\";\r\n        event.ticketID = event.ticketID ? event.ticketID : ticket.id;\r\n        event.status = event.status ? event.status : EventStatus.CREATED;\r\n        event.type = event.type ? event.type : EventType.TICKET;\r\n        event.ownerID = event.ownerID ? event.ownerID : currentMission.id;\r\n        try {\r\n            const receivedEvent = await this.eventService.createEvent(event);\r\n            // console.log('Event successfully created !');\r\n            return receivedEvent;\r\n        } catch (error) {\r\n            return null;\r\n        }\r\n    }\r\n\r\n    async addTicket(ticket: Ticket): Promise<Ticket | void> {\r\n        ticket.status = TicketStatus.CREATED;\r\n        if (!ticket.ownerMissionID) {\r\n            ticket.ownerMissionID = this.userService.currentMission(\r\n                ticket.spaceID,\r\n            ).id;\r\n        }\r\n        // TODO!!! filter missions by space of ticket\r\n        try {\r\n            const receivedTicket = await this.createTicket(ticket);\r\n            // console.log('!!! Response from creating ticket :');\r\n            // console.log(receivedTicket);\r\n            this.addEventToTicket(receivedTicket, {\r\n                title: \"Création du ticket\",\r\n                description: `Ticket créé par -`,\r\n                translationPath: \"ticketEvent.ticket.created\",\r\n            });\r\n            this.updateDone.next(true);\r\n            return receivedTicket; // instead of true\r\n        } catch (error) {\r\n            console.log(\"Ticket creation FAILED\");\r\n            console.log(JSON.stringify(error));\r\n        }\r\n    }\r\n\r\n    async updateTicketWithEvent(\r\n        ticket: IUpdate & Partial<Ticket>,\r\n        event?: Event,\r\n    ): Promise<Ticket> {\r\n        const receivedTicket = await this.updateTicket(ticket);\r\n        if (receivedTicket) {\r\n            console.log(\"Updated ticket :\");\r\n            console.log(receivedTicket);\r\n            if (event) {\r\n                await this.addEventToTicket(receivedTicket, event);\r\n            }\r\n            this.updateDone.next(true);\r\n        }\r\n        return receivedTicket;\r\n    }\r\n\r\n    async removeAssigneeFromTicket(\r\n        ticket: Ticket,\r\n        assignee: Affectation,\r\n    ): Promise<Ticket> {\r\n        try {\r\n            const affectation =\r\n                await this.affectationService.softDeleteAffectationByID(\r\n                    assignee.id,\r\n                );\r\n            if (!affectation) {\r\n                console.warn(\r\n                    `removeAssigneeFromTicket(${ticket.id}, ${assignee.id}) failed`,\r\n                );\r\n            }\r\n        } catch (error) {\r\n            console.error(error);\r\n        }\r\n        return ticket;\r\n    }\r\n\r\n    async updateTicketLocation(\r\n        ticket: Ticket,\r\n        tagData: MattertagData\r\n    ): Promise<POI> {\r\n        const poiInput = {\r\n            coordinate: tagData.getCoordinateString(),\r\n            type: PoiType.TICKET,\r\n            elementID: ticket.id,\r\n            metadata: tagData.getMetadataString(),\r\n            matterportSweepID: tagData.getSweepID(),\r\n        } as POI;\r\n        const poi = await this.poiService.createPOIForSpaceID(poiInput);\r\n        await this.addEventToTicket(ticket, {\r\n            title: \"Changement position du ticket\",\r\n            description: \"Le point d'intérêt du ticket a été modifié\",\r\n            status: EventStatus.POSITION_SET,\r\n            translationPath: \"ticketEvent.position.set\",\r\n        });\r\n        return poi;\r\n    }\r\n\r\n    async updateStatusOfTicket(\r\n        ticket: Ticket,\r\n        status: TicketStatus,\r\n    ): Promise<any> {\r\n        const currentStatus = ticket.status;\r\n        const oldTicketStatus = ticket.status;\r\n        ticket.status = status;\r\n        if (currentStatus === status) {\r\n            return ticket;\r\n        }\r\n        console.log(\"Updating status\");\r\n        return this.updateTicket({\r\n            id: ticket.id,\r\n            status,\r\n        });\r\n    }\r\n\r\n    async updateTypeOfTicket(ticket: Ticket, type: TicketType): Promise<any> {\r\n        const previousType = ticket.type;\r\n        ticket.type = type;\r\n        await this.updateTicketWithEvent(\r\n            { id: ticket.id, type: ticket.type },\r\n            {\r\n                title: \"Type changé\",\r\n                description: `Changement de ${previousType} vers ${ticket.type}`,\r\n                metadata: JSON.stringify({ type: ticket.type }),\r\n                translationPath: \"ticketEvent.ticket.type\",\r\n            },\r\n        );\r\n        return ticket;\r\n    }\r\n\r\n    async getTicketsForUserForSpace(spaceID: string): Promise<Ticket[]> {\r\n        const ticketsSpace = await this.getTicketsBySpace(spaceID);\r\n        return this.filterService.filterTicketsForCurrentUserInSpace(\r\n            ticketsSpace,\r\n            spaceID,\r\n        );\r\n    }\r\n\r\n\r\n    /** Basic CRUD operations */\r\n    async readTicket(id: string) {\r\n        return this.API.__proto__.GetTicket(id);\r\n    }\r\n\r\n    async createTicket(input: Ticket): Promise<Ticket> {\r\n        return this.API.__proto__.CreateTicket(input);\r\n    }\r\n\r\n    async updateTicket(input: IUpdate & Partial<Ticket>): Promise<Ticket> {\r\n        return this.API.__proto__.UpdateTicket(input);\r\n    }\r\n\r\n    async deleteTicket(ticket: Ticket): Promise<Ticket> {\r\n        const deleted = await this.API.__proto__.DeleteTicket({ id: ticket.id });\r\n\r\n        // delete POI\r\n        const poi = await this.poiService.getPoiByElementId(ticket.id);\r\n        if (poi) {\r\n            this.poiService.deletePoi(poi.id);\r\n        }\r\n\r\n        // clean parentID\r\n        if (ticket.children.items.length > 0) {\r\n            ticket.children.items.map(async (childTicket) => {\r\n                try {\r\n                    await this.API.__proto__.UpdateTicket({\r\n                        id: childTicket.id,\r\n                        parentID: null,\r\n                    });\r\n                } catch {\r\n                    console.warn(\"Could not update ticket\", childTicket.id);\r\n                }\r\n\r\n                await this.API.__proto__.CreateEvent({\r\n                    title: \"Ticket parent supprimé\",\r\n                    ticketID: childTicket.id,\r\n                    description: `Ticket \\\"$ticket.title}\\\" a été supprimé`,\r\n                });\r\n            });\r\n        }\r\n        // delete events\r\n        await Promise.all(\r\n            ticket.events.items.map(async (event_) => {\r\n                await this.API.__proto__.DeleteEvent({ id: event_.id });\r\n            }),\r\n        );\r\n        // delete affectationns\r\n        if (ticket.assignees.items.length > 0) {\r\n            for (const element of ticket.assignees.items) {\r\n                this.API.__proto__.DeleteAffectation({ id: element.id });\r\n            }\r\n        }\r\n        // delete comments\r\n        await Promise.all(\r\n            ticket.comments.items.map(async (comment) => {\r\n                await this.API.__proto__.DeleteComment({ id: comment.id });\r\n            }),\r\n        );\r\n        await this.operationService.deleteOperationsForTicket(ticket.id);\r\n        return deleted;\r\n    }\r\n\r\n    /** Custom requests */\r\n    async getTicketsBySpace(spaceID: string): Promise<Ticket[]> {\r\n        return this.API.__proto__.TicketsBySpace(spaceID).then(\r\n            (tickets) => tickets.items,\r\n        );\r\n    }\r\n\r\n    async updateIconForAllTicketsInSpace(\r\n        tagIcon: string,\r\n        spaceID: string,\r\n    ): Promise<{ tickets: Ticket[]; pois: POI[] }> {\r\n        const tickets = await this.getTicketsBySpace(spaceID);\r\n        const pois = await this.updateIconForAllObjects(tickets, tagIcon);\r\n        return { tickets, pois };\r\n    }\r\n\r\n    /** Archive related */\r\n    /** Return true if the current user has archived this ticket */\r\n    isArchived(ticket: Ticket): boolean {\r\n        return ticket.archivedForMissionID\r\n            ? ticket.archivedForMissionID.includes(\r\n                  this.userService.currentMission(ticket.spaceID).id,\r\n              )\r\n            : false;\r\n    }\r\n\r\n    setArchived(ticket: Ticket, archived: boolean) {\r\n        let archivedList = ticket.archivedForMissionID\r\n            ? ticket.archivedForMissionID\r\n            : [];\r\n        const missionID = this.userService.currentMission(ticket.spaceID).id;\r\n\r\n        archivedList = archivedList.filter((m) => m !== missionID);\r\n\r\n        if (archived) {\r\n            archivedList.push(missionID);\r\n        }\r\n\r\n        return this.updateTicketWithEvent({\r\n            id: ticket.id,\r\n            archivedForMissionID: archivedList,\r\n        });\r\n    }\r\n\r\n    async navigateToTicketIn3D(\r\n        ticket: Ticket,\r\n        forceSwitchVisit: boolean = false,\r\n    ) {\r\n        let url = `visit/${ticket.spaceID}`;\r\n        if (forceSwitchVisit) {\r\n            url += `/detail/${ticket.id}`;\r\n        }\r\n        const canGoToTag = await this.viewerService.action_move_to_tag(\r\n            `${ticket.id}`,\r\n        );\r\n        if (canGoToTag) {\r\n            return;\r\n        }\r\n        const result = await this.getModel3dAndSweep(ticket);\r\n        if (!result || !result.model3D) {\r\n            alert(\"Error while getting virtual visit model\");\r\n            return;\r\n        }\r\n        if (!forceSwitchVisit) {\r\n            /** Si on ne force pas la visite, on demande si on veut etre switch */\r\n            openModalForVisitSwitch(\r\n                this.modalService,\r\n                result.model3D,\r\n                ticket.spaceID,\r\n                { sweepToMove: result.sweep, rotation: result.rotation },\r\n            );\r\n        } else {\r\n            /** Si on force le switch de la visit */\r\n            window.open(\r\n                `${url}?model3D=${result.model3D}&sweep=true`,\r\n                \"_blank\",\r\n            );\r\n        }\r\n    }\r\n\r\n    initSubscriptions() {\r\n        if (!this.isMuseumUser) {\r\n            this.navSubscription = this.navigatorService.zoneChange.subscribe((zone) => {\r\n                this.currentSpaceID = this.navigatorService.currentSpaceID;\r\n                if (!this.currentSpaceID) {\r\n                    this.ticketTags.next(null);\r\n                    this.ticketsUpdated.next({ space: [], zone: null });\r\n                    this.ticketTypeFilter = null;\r\n                    this.zoneIDFilter = null;\r\n                } else if (zone.id !== this.zoneIDFilter) {\r\n                    this.zoneIDFilter = zone.id;\r\n                    // console.log(\"going to init tickets from zone\");\r\n                    this.initTickets();\r\n                }\r\n            });\r\n            this.filetrSubscription = this.filterService.subscribeToDataFilterUpdate((dateRange) => {\r\n                this.dateFilter = dateRange;\r\n                this.initTickets();\r\n            });\r\n            this.dateFilter = this.filterService.currentDateFilter;\r\n            this.updateDone.subscribe(() => {\r\n                if (this.currentSpaceID) {\r\n                    this.initTickets();\r\n                }\r\n            });\r\n        }\r\n    }\r\n}\r\n"]}