@tiba-spark/client-shared-lib 10.4.0-319 → 10.4.0-331

package/esm2022/libraries/modules/guest/guest.state.mjs

@@ -0,0 +1,602 @@
+import { __decorate } from "tslib";
+import { DatePipe } from '@angular/common';
+import { Injectable } from '@angular/core';
+import { Action, Selector, State } from '@ngxs/store';
+import { tap } from 'rxjs/operators';
+import { NotificationClass } from '../../components/notification/notification-config';
+import { Localization, ProfileTypeText } from '../../enums';
+import { Cloud, Edge } from '../../service-proxy';
+import { createMessageText, getAddress, lowerCaseFirstLetter, markEntitiesAsChanged, markEntityAsUnchanged, RowOperation } from '../../utils';
+import { SendEmailFromEntityAction } from '../email-server/email-server.actions';
+import { FacilityState } from '../facility/facility.state';
+import { ClearGuestAction, ClearGuestProfilesAction, ClearGuestsListAction, CollapsedGuestsByBatchIdAction, CreateBasicBatchAction, CreateBasicGuestAction, CreateBatchAction, CreateGuestAction, DeleteGuestAction, ExpandGuestsByBatchIdAction, ExportGuestsAction, LoadGuestByIdAction, LoadGuestProfilesAction, LoadGuestsAction, LoadGuestsByBatchIdAction, LoadGuestsByBatchIdCancelledAction, SendEmailToGuest, SendGuestPassesToEmailAction, SetGuestsAction, UpdateBasicGuestAction, UpdateBasicGuestTempAction, UpdateGuestAction, UpdateGuestLocationAction } from './guest.actions';
+var GuestEntityParams = Edge.GuestEntityParams;
+var ProfileType = Edge.ProfileType;
+var VGuestWithBatchDto = Edge.VGuestWithBatchDto;
+var SendEmailRequestDto = Cloud.SendEmailRequestDto;
+var TemplateType = Cloud.TemplateType;
+import * as i0 from "@angular/core";
+import * as i1 from "@ngxs/store";
+import * as i2 from "../../service-proxy";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "../../components/message-bar/message-bar.service";
+import * as i5 from "../../components/notification/command-notification/command-notification.service";
+import * as i6 from "../../services/tenant.service";
+import * as i7 from "../../services/export-file.service";
+import * as i8 from "../parker/parker.service";
+export class VGuestWithBatchTableData extends VGuestWithBatchDto {
+}
+;
+let GuestState = class GuestState {
+    constructor(store, guestServiceProxy, translate, batchServiceProxy, messageBarService, commandNotificationService, translateService, tenantService, exportFileService, parkerService) {
+        this.store = store;
+        this.guestServiceProxy = guestServiceProxy;
+        this.translate = translate;
+        this.batchServiceProxy = batchServiceProxy;
+        this.messageBarService = messageBarService;
+        this.commandNotificationService = commandNotificationService;
+        this.translateService = translateService;
+        this.tenantService = tenantService;
+        this.exportFileService = exportFileService;
+        this.parkerService = parkerService;
+        this.datePipe = new DatePipe('en-US');
+        this.L = Localization;
+        this.toDateString = (value) => this.datePipe.transform(value.toDate(), this.tenantService.secondaryDateTimeFormat) || '-';
+        this.isGuestChild = (guest) => guest.guestID !== null && guest.batchID > 0;
+    }
+    static guestCounter(state) {
+        return state.counter;
+    }
+    static archivedGuests(state) {
+        return state.archived;
+    }
+    static displayedGuests(state) {
+        return state.displayed;
+    }
+    static profiles(state) {
+        return state.profiles;
+    }
+    static selected(state) {
+        return state.selected;
+    }
+    onLoadGuestByIdAction(ctx, action) {
+        const getGuest$ = this.guestServiceProxy.getGuestById(action.guestId, action.parkId, action.guid);
+        return getGuest$.pipe(tap(guest => {
+            ctx.patchState({
+                selected: guest.data
+            });
+        }));
+    }
+    onClearGuestAction(ctx) {
+        ctx.patchState({
+            selected: null
+        });
+    }
+    onLoadGuestsAction(ctx, action) {
+        const getGuests$ = this.guestServiceProxy.getGuests(action.parkId, action.guid, action.guestsFilterDto);
+        return getGuests$.pipe(tap((guestsWrapper) => {
+            ctx.patchState({
+                archived: guestsWrapper.data.entities,
+                counter: guestsWrapper.data.counter,
+            });
+        }));
+    }
+    onSetGuestsAction(ctx, action) {
+        ctx.patchState({
+            displayed: action.guests || [],
+        });
+    }
+    onClearGuestListAction(ctx) {
+        ctx.patchState({
+            archived: [],
+            displayed: [],
+            counter: 0,
+        });
+    }
+    onCreateGuestAction(ctx, action) {
+        const messageBarPayload = {
+            entity: this.translate.instant(Localization.guest),
+            entityName: `${action.guest.firstName} ${action.guest.lastName}`,
+            action: lowerCaseFirstLetter(this.translate.instant(Localization.created)),
+        };
+        this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));
+        return this.guestServiceProxy.createGuest(action.guid, action.guest).pipe(tap({
+            next: (handled) => {
+                const displayNewGuestInTable = this.isGuestCreatedFromSelectedFacility(handled.data, action.guid);
+                this.addGuestToStore(ctx, handled.data, displayNewGuestInTable);
+                this.messageBarService.success(displayNewGuestInTable ? Localization.entity_success : Localization.entity_success_not_currently_visible, createMessageText(messageBarPayload));
+            },
+            error: () => {
+                messageBarPayload.entity = lowerCaseFirstLetter(messageBarPayload.entity);
+                messageBarPayload.action = lowerCaseFirstLetter(this.translate.instant(Localization.create));
+                this.messageBarService.error(Localization.entity_failed, createMessageText(messageBarPayload));
+            }
+        }));
+    }
+    onCreateBatchAction(ctx, action) {
+        const messageBarPayload = {
+            entity: this.translate.instant(Localization.guest_group),
+            entityName: action.batchCommand.name,
+            action: lowerCaseFirstLetter(this.translate.instant(Localization.created)),
+        };
+        this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));
+        return this.batchServiceProxy.createBatch(action.facilityWithGuid.guid, action.batchCommand).pipe(tap({
+            next: (newGuests) => {
+                const displayNewGuestInTable = this.isGuestCreatedFromSelectedFacility(newGuests.data[0], action.facilityWithGuid.guid);
+                this.messageBarService.success(displayNewGuestInTable ? Localization.entity_success : Localization.entity_success_not_currently_visible, createMessageText(messageBarPayload));
+                if (displayNewGuestInTable) {
+                    const newBatch = this.convertGuestsToTableData(newGuests.data);
+                    markEntitiesAsChanged([newBatch], RowOperation.Insert);
+                    markEntitiesAsChanged(newBatch.entities, RowOperation.Insert);
+                    const displayedGuests = ctx.getState().displayed;
+                    displayedGuests.unshift(...newBatch.entities);
+                    displayedGuests.unshift(newBatch);
+                    ctx.patchState({
+                        displayed: [...displayedGuests],
+                        counter: ctx.getState().counter + 1,
+                    });
+                }
+            },
+            error: (e) => {
+                action.errorMessage = e.data.detail;
+            }
+        }));
+    }
+    onCreateBasicBatchAction(ctx, action) {
+        const messageBarPayload = {
+            entity: this.translate.instant(Localization.guest_group),
+            entityName: action.batchCommand.name,
+            action: lowerCaseFirstLetter(this.translate.instant(Localization.created)),
+        };
+        this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));
+        return this.batchServiceProxy.createBasicBatch(action.facilityWithGuid.guid, action.batchCommand).pipe(tap({
+            next: (newGuests) => {
+                const displayNewGuestInTable = this.isGuestCreatedFromSelectedFacility(newGuests.data[0], action.facilityWithGuid.guid);
+                this.messageBarService.success(displayNewGuestInTable ? Localization.entity_success : Localization.entity_success_not_currently_visible, createMessageText(messageBarPayload));
+                if (displayNewGuestInTable) {
+                    const newBatch = this.convertGuestsToTableData(newGuests.data);
+                    markEntitiesAsChanged([newBatch], RowOperation.Insert);
+                    markEntitiesAsChanged(newBatch.entities, RowOperation.Insert);
+                    const displayedGuests = ctx.getState().displayed;
+                    displayedGuests.unshift(...newBatch.entities);
+                    displayedGuests.unshift(newBatch);
+                    ctx.patchState({
+                        displayed: [...displayedGuests],
+                        counter: ctx.getState().counter + 1,
+                    });
+                }
+            },
+            error: (e) => {
+                action.errorMessage = e.data.detail;
+            }
+        }));
+    }
+    onUpdateGuestAction(ctx, action) {
+        const messageBarPayload = {
+            entity: this.translate.instant(Localization.guest),
+            entityName: `${action.guest.firstName} ${action.guest.lastName}`,
+            action: this.translate.instant(Localization.updated),
+        };
+        this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));
+        return this.guestServiceProxy.updateGuest(action.guid, action.guest).pipe(tap({
+            next: (handled) => {
+                this.updateGuestInStore(ctx, handled.data, action.guid);
+                this.messageBarService.success(Localization.entity_success, createMessageText(messageBarPayload));
+            },
+            error: () => {
+                messageBarPayload.entity = lowerCaseFirstLetter(messageBarPayload.entity);
+                messageBarPayload.action = lowerCaseFirstLetter(this.translate.instant(Localization.update));
+                this.messageBarService.error(Localization.entity_failed, createMessageText(messageBarPayload));
+            }
+        }));
+    }
+    onUpdateGuestLocationAction(ctx, action) {
+        debugger;
+        const config = {
+            messages: [{ value: action.updateGuestLocationCommand.name, class: NotificationClass.body }],
+            command: this.translateService.instant(Localization.update_location)
+        };
+        const guest$ = this.guestServiceProxy.updateGuestLocation(action.guid, action.updateGuestLocationCommand);
+        return guest$.pipe(this.commandNotificationService.display(config));
+    }
+    onDeleteGuestAction(ctx, action) {
+        const interpolatedGuestName = action.guest.name.trim() === Localization.card_holder ?
+            this.translateService.instant(Localization.card_holder) : action.guest.name;
+        const messageBarPayload = {
+            entity: this.translate.instant(Localization.guest),
+            entityName: interpolatedGuestName,
+            action: this.translate.instant(Localization.deleted),
+        };
+        this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));
+        return this.guestServiceProxy.deleteGuest(action.guest.guestID, action.guest.parkID, action.guid).pipe(tap(() => {
+            this.messageBarService.success(Localization.entity_success, createMessageText(messageBarPayload));
+            action.guest.deleted = 1;
+            this.deleteGuestFromStore(ctx, action.guest, action.guid);
+        }, () => {
+            messageBarPayload.entity = lowerCaseFirstLetter(messageBarPayload.entity);
+            messageBarPayload.action = lowerCaseFirstLetter(this.translate.instant(Localization.delete));
+            this.messageBarService.error(Localization.entity_failed, createMessageText(messageBarPayload));
+        }));
+    }
+    onCreateBasicGuestAction(ctx, action) {
+        const messageBarPayload = {
+            entity: this.translate.instant(Localization.guest),
+            entityName: `${action.guest.firstName} ${action.guest.lastName}`,
+            action: lowerCaseFirstLetter(this.translate.instant(Localization.created)),
+        };
+        this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));
+        return this.guestServiceProxy.createBasicGuest(action.guid, action.guest).pipe(tap({
+            next: (handled) => {
+                const displayNewGuestInTable = this.isGuestCreatedFromSelectedFacility(handled.data, action.guid);
+                this.addGuestToStore(ctx, handled.data, displayNewGuestInTable);
+                this.messageBarService.success(displayNewGuestInTable ? Localization.entity_success : Localization.entity_success_not_currently_visible, createMessageText(messageBarPayload));
+            },
+            error: () => {
+                messageBarPayload.entity = lowerCaseFirstLetter(messageBarPayload.entity);
+                messageBarPayload.action = lowerCaseFirstLetter(this.translate.instant(Localization.create));
+                this.messageBarService.error(Localization.entity_failed, createMessageText(messageBarPayload));
+            }
+        }));
+    }
+    onUpdateBasicGuestAction(ctx, action) {
+        const messageBarPayload = {
+            entity: this.translate.instant(Localization.guest),
+            entityName: `${action.guest.firstName} ${action.guest.lastName}`,
+            action: this.translate.instant(Localization.updated),
+        };
+        this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));
+        return this.guestServiceProxy.updateBasicGuest(action.guid, action.guest).pipe(tap({
+            next: (handled) => this.onUpdateBasicGuestNext(ctx, action, handled, messageBarPayload),
+            error: () => this.onUpdateBasicGuestError(messageBarPayload)
+        }));
+    }
+    onUpdateBasicGuestTempAction(ctx, action) {
+        const messageBarPayload = {
+            entity: this.translate.instant(Localization.guest),
+            entityName: `${action.guest.firstName} ${action.guest.lastName}`,
+            action: this.translate.instant(Localization.updated),
+        };
+        this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));
+        return this.guestServiceProxy.updateBasicGuestTemp(action.guid, action.guest).pipe(tap({
+            next: (handled) => this.onUpdateBasicGuestNext(ctx, action, handled, messageBarPayload),
+            error: () => this.onUpdateBasicGuestError(messageBarPayload)
+        }));
+    }
+    onSendEmailToGuestAction(ctx, action) {
+        return this.guestServiceProxy.sendGuestEmail(action.guid, action.sendEmailCommand).pipe(tap({
+            next: () => this.messageBarService.success(Localization.email_sent_successfully),
+            error: () => this.messageBarService.error(Localization.email_sending_failed),
+        }));
+    }
+    onLoadGuestsByBatchId(ctx, action) {
+        const results$ = this.guestServiceProxy.getGuestsByBatchID(action.parkId, action.batchID, action.guid, action.guestsFilterDto);
+        return results$.pipe(tap((guests) => {
+            this.addGuestsByBatchIdToStore(ctx, action.batchID, guests.data);
+        }));
+    }
+    onLoadGuestsByBatchIdCancelledAction(ctx, action) {
+        const displayedGuestsBatches = ctx.getState().displayed;
+        const guestBatchIndex = displayedGuestsBatches.findIndex(guest => guest instanceof VGuestWithBatchDto && guest.batchID === action.batchId);
+        if (guestBatchIndex !== -1) {
+            const guestBatch = markEntityAsUnchanged(displayedGuestsBatches[guestBatchIndex]);
+            displayedGuestsBatches[guestBatchIndex] = Object.assign(new VGuestWithBatchDto(), guestBatch);
+            ctx.patchState({
+                displayed: [...displayedGuestsBatches]
+            });
+        }
+    }
+    onExpandGuestsByBatchIdAction(ctx, action) {
+        this.addGuestsByBatchIdToStore(ctx, action.batchID, action.guests);
+    }
+    onCollapsedGuestsByBatchIdAction(ctx, action) {
+        let displayedGusetBatches = ctx.getState().displayed;
+        const guestBatchIndex = displayedGusetBatches.findIndex(gb => gb.batchID === action.batchID);
+        if (guestBatchIndex !== -1) {
+            displayedGusetBatches = displayedGusetBatches.filter(entity => entity.batchID !== action.batchID || !entity.guestID);
+            ctx.patchState({
+                displayed: [...displayedGusetBatches],
+            });
+        }
+    }
+    onLoadGuestProfilesAction(ctx, action) {
+        const guestProfiles$ = this.guestServiceProxy.getProfiles(action.parkId, action.searchParamsDto?.maxResults, action.searchParamsDto?.searchTerm, action.searchParamsDto?.orderBy.column, action.searchParamsDto?.orderBy.orderDirection, action.guid);
+        return guestProfiles$.pipe(tap(profiles => {
+            ctx.patchState({
+                profiles: profiles.data,
+            });
+        }));
+    }
+    onClearGuestProfilesAction(ctx) {
+        ctx.patchState({
+            profiles: [],
+        });
+    }
+    async onSendGuestPassesToEmail(ctx, action) {
+        const data = {
+            modalTitle: this.translate.instant(Localization.send_stickers_to_email),
+            sendEmail: false,
+            sendEmailReqeust: await this.populateSendEmailRequest(action) // only version >= 8.1 support this feature
+        };
+        data.sendEmailReqeust.to = action.email;
+        ctx.dispatch(new SendEmailFromEntityAction(data.sendEmailReqeust));
+    }
+    onExportGuestsAction(ctx, action) {
+        const getGuests$ = this.guestServiceProxy.getGuests(action.parkId, action.guid, action.guestsFilterDto);
+        return getGuests$.pipe(tap({
+            next: (guestsWrapper) => {
+                const tableRows = [];
+                const guestWithBatchDtoList = guestsWrapper.data.entities;
+                guestWithBatchDtoList.forEach((guest) => {
+                    tableRows.push([guest.name,
+                        this.translate.instant(ProfileTypeText[ProfileType[guest.mType]]),
+                        guest.mobile,
+                        guest.carPlate,
+                        this.exportFileService.getDateFieldValue(action.fileType, guest, 'validFromDate'),
+                        this.exportFileService.getDateFieldValue(action.fileType, guest, 'validToDate'),
+                        guest.companyName,
+                        guest.subCompanyName,
+                        this.parkerService.getHistoryItemAction(guest.location, null),
+                        this.exportFileService.getDateFieldValue(action.fileType, guest, 'producedDate')]);
+                });
+                this.exportFileService.export(action.fileType, tableRows, action.columnsHeader, Localization.guests);
+            },
+            error: () => {
+                this.messageBarService.error(this.translateService.instant(this.L.failed_export_file));
+            }
+        }));
+    }
+    addGuestsByBatchIdToStore(ctx, batchID, guests) {
+        const displayedGusetBatches = ctx.getState().displayed;
+        const guestBatchIndex = displayedGusetBatches.findIndex(gb => gb.batchID === batchID);
+        if (guestBatchIndex !== -1) {
+            displayedGusetBatches[guestBatchIndex].entities = guests;
+            displayedGusetBatches.splice(guestBatchIndex + 1, 0, ...guests);
+            ctx.patchState({
+                displayed: [...displayedGusetBatches],
+            });
+        }
+    }
+    convertGuestsToTableData(guests) {
+        const batch = guests.find(g => g.batchID > 0 && g.guestID === null);
+        batch.isRowExpandable = true;
+        batch.entities = guests.filter(g => g.batchID !== null && g.guestID !== null);
+        return batch;
+    }
+    addGuestToStore(ctx, guest, displayNewGuestInTable) {
+        if (displayNewGuestInTable) {
+            const displayedGuests = ctx.getState().displayed;
+            markEntitiesAsChanged([guest], RowOperation.Insert);
+            displayedGuests.unshift(guest);
+            ctx.patchState({
+                displayed: [...displayedGuests],
+                counter: ctx.getState().counter + 1,
+            });
+        }
+    }
+    isGuestCreatedFromSelectedFacility(guest, guid) {
+        const selectedParkID = this.store.selectSnapshot(FacilityState.parkId);
+        const selectedGuid = this.store.selectSnapshot(FacilityState.guid);
+        return selectedParkID === guest.parkID && selectedGuid === guid;
+    }
+    getParantAndChildIndex(ctx, guestDto) {
+        const displayedGuests = ctx.getState().displayed;
+        // if I am children find my parent, after that find me
+        const parent = displayedGuests.findIndex(guest => guest.batchID === guestDto.batchID && guest.guestID === null);
+        const child = (displayedGuests[parent].entities || []).findIndex(guest => guest.guestID === guestDto.guestID);
+        return { parent, child };
+    }
+    updateGuestInStore(ctx, guest, guid) {
+        const displayedGuests = ctx.getState().displayed;
+        const guestIndex = this.getGuestIndex(displayedGuests, guest.guestID);
+        if (guestIndex !== -1) {
+            displayedGuests[guestIndex] = guest;
+            markEntitiesAsChanged([guest], RowOperation.Update);
+        }
+        if (this.isGuestChild(guest)) {
+            const { child, parent } = this.getParantAndChildIndex(ctx, guest);
+            if (parent !== -1) {
+                if (child !== -1) {
+                    displayedGuests[parent].entities[child] = guest;
+                }
+                markEntitiesAsChanged([displayedGuests[parent]]);
+            }
+        }
+        ctx.patchState({
+            displayed: [...displayedGuests],
+        });
+    }
+    deleteGuestFromStore(ctx, guest, guid) {
+        let counter = ctx.getState().counter;
+        const displayedGuests = ctx.getState().displayed;
+        const guestIndex = this.getGuestIndex(displayedGuests, guest.guestID);
+        if (guestIndex !== -1) {
+            displayedGuests.splice(guestIndex, 1);
+            markEntitiesAsChanged([guest], RowOperation.Delete);
+        }
+        if (this.isGuestChild(guest)) {
+            const { child, parent } = this.getParantAndChildIndex(ctx, guest);
+            if (parent !== -1) {
+                if (child !== -1) {
+                    displayedGuests[parent].entities.splice(child, 1);
+                }
+                markEntitiesAsChanged([displayedGuests[parent]]);
+            }
+        }
+        else {
+            counter--;
+        }
+        ctx.patchState({
+            displayed: [...displayedGuests],
+            counter: counter,
+        });
+    }
+    async populateSendEmailRequest(action) {
+        let pdfPagesParametersList = [];
+        let guestEmailTemplate = '';
+        if (action.guest.entities && action.guest.entities.length > 0) {
+            pdfPagesParametersList = [];
+            action.guest.entities.forEach(guest => {
+                const paramList = this.getParameters(guest, action.facility);
+                pdfPagesParametersList.push(paramList);
+            });
+            guestEmailTemplate = action.guest.batchName;
+        }
+        else {
+            pdfPagesParametersList.push(this.getParameters(action.guest, action.facility));
+            guestEmailTemplate = action.guest.name;
+        }
+        const sendEmailRequest = new SendEmailRequestDto({
+            entity: new GuestEntityParams({
+                qrPlainText: action.guest.qrPlainText,
+                id: action.guest.guestID || action.guest.batchID,
+                qrCode: action.guest.qrCode
+            }),
+            to: action.email,
+            templateType: TemplateType.Guest,
+            pdfPagesParametersList,
+            pdfPagesParameters: null,
+            parameters: {
+                guestEmailTemplate,
+            }
+        });
+        return sendEmailRequest;
+    }
+    getParameters(guest, facility) {
+        const parameters = {
+            validFromDateTime: this.toDateString(guest.validFromDate),
+            validToDateTime: this.toDateString(guest.validToDate),
+            companyName: guest.companyName,
+            subCompanyName: guest.subCompanyName,
+            parkName: facility?.data?.name,
+            producedDateTime: this.toDateString(guest.producedDate),
+            id: guest.guestID,
+            firstName: guest.firstName,
+            lastName: guest.lastName,
+            plateId: guest.carPlate,
+            name: guest.name,
+            card: guest.credit,
+            address: getAddress(guest.city, guest.street),
+            qrCode: guest.qrCode,
+            guid: facility.guid,
+            parkId: facility.data.id,
+            qrPlainText: guest.qrPlainText
+        };
+        return parameters;
+    }
+    getGuestIndex(displayedGuests, guestId) {
+        return displayedGuests.findIndex(guest => guest.guestID === guestId);
+    }
+    onUpdateBasicGuestNext(ctx, action, handled, messageBarPayload) {
+        this.updateGuestInStore(ctx, handled.data, action.guid);
+        this.messageBarService.success(Localization.entity_success, createMessageText(messageBarPayload));
+    }
+    onUpdateBasicGuestError(messageBarPayload) {
+        messageBarPayload.entity = lowerCaseFirstLetter(messageBarPayload.entity);
+        messageBarPayload.action = lowerCaseFirstLetter(this.translate.instant(Localization.update));
+        this.messageBarService.error(Localization.entity_failed, createMessageText(messageBarPayload));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GuestState, deps: [{ token: i1.Store }, { token: i2.Edge.GuestServiceProxy }, { token: i3.TranslateService }, { token: i2.Edge.BatchServiceProxy }, { token: i4.MessageBarService }, { token: i5.CommandNotificationService }, { token: i3.TranslateService }, { token: i6.TenantService }, { token: i7.ExportFileService }, { token: i8.ParkerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GuestState }); }
+};
+__decorate([
+    Action(LoadGuestByIdAction, { cancelUncompleted: true })
+], GuestState.prototype, "onLoadGuestByIdAction", null);
+__decorate([
+    Action(ClearGuestAction, { cancelUncompleted: true })
+], GuestState.prototype, "onClearGuestAction", null);
+__decorate([
+    Action(LoadGuestsAction, { cancelUncompleted: true })
+], GuestState.prototype, "onLoadGuestsAction", null);
+__decorate([
+    Action(SetGuestsAction)
+], GuestState.prototype, "onSetGuestsAction", null);
+__decorate([
+    Action(ClearGuestsListAction)
+], GuestState.prototype, "onClearGuestListAction", null);
+__decorate([
+    Action(CreateGuestAction)
+], GuestState.prototype, "onCreateGuestAction", null);
+__decorate([
+    Action(CreateBatchAction)
+], GuestState.prototype, "onCreateBatchAction", null);
+__decorate([
+    Action(CreateBasicBatchAction)
+], GuestState.prototype, "onCreateBasicBatchAction", null);
+__decorate([
+    Action(UpdateGuestAction)
+], GuestState.prototype, "onUpdateGuestAction", null);
+__decorate([
+    Action(UpdateGuestLocationAction)
+], GuestState.prototype, "onUpdateGuestLocationAction", null);
+__decorate([
+    Action(DeleteGuestAction)
+], GuestState.prototype, "onDeleteGuestAction", null);
+__decorate([
+    Action(CreateBasicGuestAction)
+], GuestState.prototype, "onCreateBasicGuestAction", null);
+__decorate([
+    Action(UpdateBasicGuestAction)
+], GuestState.prototype, "onUpdateBasicGuestAction", null);
+__decorate([
+    Action(UpdateBasicGuestTempAction)
+], GuestState.prototype, "onUpdateBasicGuestTempAction", null);
+__decorate([
+    Action(SendEmailToGuest)
+], GuestState.prototype, "onSendEmailToGuestAction", null);
+__decorate([
+    Action(LoadGuestsByBatchIdAction, { cancelUncompleted: true })
+], GuestState.prototype, "onLoadGuestsByBatchId", null);
+__decorate([
+    Action(LoadGuestsByBatchIdCancelledAction, { cancelUncompleted: false })
+], GuestState.prototype, "onLoadGuestsByBatchIdCancelledAction", null);
+__decorate([
+    Action(ExpandGuestsByBatchIdAction)
+], GuestState.prototype, "onExpandGuestsByBatchIdAction", null);
+__decorate([
+    Action(CollapsedGuestsByBatchIdAction)
+], GuestState.prototype, "onCollapsedGuestsByBatchIdAction", null);
+__decorate([
+    Action(LoadGuestProfilesAction, { cancelUncompleted: true })
+], GuestState.prototype, "onLoadGuestProfilesAction", null);
+__decorate([
+    Action(ClearGuestProfilesAction)
+], GuestState.prototype, "onClearGuestProfilesAction", null);
+__decorate([
+    Action(SendGuestPassesToEmailAction)
+], GuestState.prototype, "onSendGuestPassesToEmail", null);
+__decorate([
+    Action(ExportGuestsAction, { cancelUncompleted: true })
+], GuestState.prototype, "onExportGuestsAction", null);
+__decorate([
+    Selector()
+], GuestState, "guestCounter", null);
+__decorate([
+    Selector()
+], GuestState, "archivedGuests", null);
+__decorate([
+    Selector()
+], GuestState, "displayedGuests", null);
+__decorate([
+    Selector()
+], GuestState, "profiles", null);
+__decorate([
+    Selector()
+], GuestState, "selected", null);
+GuestState = __decorate([
+    State({
+        name: 'guest',
+        defaults: {
+            archived: [],
+            displayed: [],
+            counter: 0,
+            guest: null,
+            profiles: [],
+            selected: null,
+        },
+    })
+], GuestState);
+export { GuestState };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GuestState, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.Edge.GuestServiceProxy }, { type: i3.TranslateService }, { type: i2.Edge.BatchServiceProxy }, { type: i4.MessageBarService }, { type: i5.CommandNotificationService }, { type: i3.TranslateService }, { type: i6.TenantService }, { type: i7.ExportFileService }, { type: i8.ParkerService }]; }, propDecorators: { onLoadGuestByIdAction: [], onClearGuestAction: [], onLoadGuestsAction: [], onSetGuestsAction: [], onClearGuestListAction: [], onCreateGuestAction: [], onCreateBatchAction: [], onCreateBasicBatchAction: [], onUpdateGuestAction: [], onUpdateGuestLocationAction: [], onDeleteGuestAction: [], onCreateBasicGuestAction: [], onUpdateBasicGuestAction: [], onUpdateBasicGuestTempAction: [], onSendEmailToGuestAction: [], onLoadGuestsByBatchId: [], onLoadGuestsByBatchIdCancelledAction: [], onExpandGuestsByBatchIdAction: [], onCollapsedGuestsByBatchIdAction: [], onLoadGuestProfilesAction: [], onClearGuestProfilesAction: [], onSendGuestPassesToEmail: [], onExportGuestsAction: [] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"guest.state.js","sourceRoot":"","sources":["../../../../../../projects/client-shared-lib/src/libraries/modules/guest/guest.state.ts"],"names":[],"mappings":"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","sourcesContent":["import { DatePipe } from '@angular/common';\nimport { Injectable } from '@angular/core';\nimport { TranslateService } from '@ngx-translate/core';\nimport { Action, Selector, State, StateContext, Store } from '@ngxs/store';\nimport { Moment } from 'moment';\nimport { Observable } from 'rxjs';\nimport { tap } from 'rxjs/operators';\nimport { MessageBarPayload } from '../../components/message-bar/message-bar-text.interface';\nimport { MessageBarService } from '../../components/message-bar/message-bar.service';\nimport { CommandNotificationConfig } from '../../components/notification/command-notification/command-notification-config';\nimport { CommandNotificationService } from '../../components/notification/command-notification/command-notification.service';\nimport { NotificationClass } from '../../components/notification/notification-config';\nimport { Localization, ProfileTypeText } from '../../enums';\nimport { Cloud, Edge } from '../../service-proxy';\nimport { ExportFileService } from '../../services/export-file.service';\nimport { TenantService } from '../../services/tenant.service';\nimport { createMessageText, getAddress, lowerCaseFirstLetter, markEntitiesAsChanged, markEntityAsUnchanged, RowOperation } from '../../utils';\nimport { SendEmailFromEntityAction } from '../email-server/email-server.actions';\nimport { FacilityWithGuid } from '../facility/facility-with-guid.interface';\nimport { FacilityState } from '../facility/facility.state';\nimport { ParkerService } from '../parker/parker.service';\nimport {\n  ClearGuestAction, ClearGuestProfilesAction, ClearGuestsListAction, CollapsedGuestsByBatchIdAction,\n  CreateBasicBatchAction, CreateBasicGuestAction, CreateBatchAction, CreateGuestAction, DeleteGuestAction,\n  ExpandGuestsByBatchIdAction, ExportGuestsAction, LoadGuestByIdAction, LoadGuestProfilesAction, LoadGuestsAction,\n  LoadGuestsByBatchIdAction, LoadGuestsByBatchIdCancelledAction, SendEmailToGuest, SendGuestPassesToEmailAction,\n  SetGuestsAction, UpdateBasicGuestAction, UpdateBasicGuestTempAction, UpdateGuestAction, UpdateGuestLocationAction\n} from './guest.actions';\n\nimport GuestEntityParams = Edge.GuestEntityParams;\nimport GuestProfileDto = Edge.GuestProfileDto;\nimport Int32HttpResponseData = Edge.Int32HttpResponseData;\nimport ProblemDetailsHttpResponseData = Edge.ProblemDetailsHttpResponseData;\nimport ProfileType = Edge.ProfileType;\nimport VGuestWithBatchDto = Edge.VGuestWithBatchDto;\nimport VGuestWithBatchDtoEntityWrapperDtoHttpResponseData = Edge.VGuestWithBatchDtoEntityWrapperDtoHttpResponseData;\nimport VGuestWithBatchDtoHttpResponseData = Edge.VGuestWithBatchDtoHttpResponseData;\nimport VGuestWithBatchDtoIEnumerableHttpResponseData = Edge.VGuestWithBatchDtoIEnumerableHttpResponseData;\nimport SendEmailRequestDto = Cloud.SendEmailRequestDto;\nimport TemplateType = Cloud.TemplateType;\n\nexport class VGuestWithBatchTableData extends VGuestWithBatchDto {\n  entities: VGuestWithBatchDto[]\n};\n\nexport interface GuestStateModel {\n  archived: VGuestWithBatchDto[];\n  displayed: VGuestWithBatchDto[];\n  counter: number;\n  guest: VGuestWithBatchDto;\n  profiles: GuestProfileDto[];\n  selected: VGuestWithBatchDto;\n}\n\n@Injectable()\n@State<GuestStateModel>({\n  name: 'guest',\n  defaults: {\n    archived: [],\n    displayed: [],\n    counter: 0,\n    guest: null,\n    profiles: [],\n    selected: null,\n  },\n})\nexport class GuestState {\n  datePipe = new DatePipe('en-US');\n  L = Localization;\n\n  constructor(\n    private store: Store,\n    private guestServiceProxy: Edge.GuestServiceProxy,\n    private translate: TranslateService,\n    private batchServiceProxy: Edge.BatchServiceProxy,\n    private messageBarService: MessageBarService,\n    private commandNotificationService: CommandNotificationService,\n    private translateService: TranslateService,\n    private tenantService: TenantService,\n    private exportFileService: ExportFileService,\n    private parkerService: ParkerService) {\n  }\n\n  @Selector()\n  public static guestCounter(state: GuestStateModel): number {\n    return state.counter;\n  }\n\n  @Selector()\n  public static archivedGuests(state: GuestStateModel): VGuestWithBatchDto[] {\n    return state.archived;\n  }\n\n  @Selector()\n  public static displayedGuests(state: GuestStateModel): VGuestWithBatchDto[] {\n    return state.displayed;\n  }\n\n  @Selector()\n  public static profiles(state: GuestStateModel): GuestProfileDto[] {\n    return state.profiles;\n  }\n\n  @Selector()\n  public static selected(state: GuestStateModel): VGuestWithBatchDto {\n    return state.selected;\n  }\n\n  @Action(LoadGuestByIdAction, { cancelUncompleted: true })\n  onLoadGuestByIdAction(ctx: StateContext<GuestStateModel>, action: LoadGuestByIdAction): Observable<VGuestWithBatchDtoHttpResponseData> {\n    const getGuest$ = this.guestServiceProxy.getGuestById(action.guestId, action.parkId, action.guid);\n    return getGuest$.pipe(tap(guest => {\n      ctx.patchState({\n        selected: guest.data\n      });\n    }));\n  }\n\n  @Action(ClearGuestAction, { cancelUncompleted: true })\n  onClearGuestAction(ctx: StateContext<ClearGuestAction>): void {\n    ctx.patchState({\n      selected: null\n    });\n  }\n\n  @Action(LoadGuestsAction, { cancelUncompleted: true })\n  onLoadGuestsAction(ctx: StateContext<GuestStateModel>, action: LoadGuestsAction): Observable<VGuestWithBatchDtoEntityWrapperDtoHttpResponseData> {\n    const getGuests$ = this.guestServiceProxy.getGuests(action.parkId, action.guid, action.guestsFilterDto);\n    return getGuests$.pipe(tap((guestsWrapper: VGuestWithBatchDtoEntityWrapperDtoHttpResponseData) => {\n      ctx.patchState({\n        archived: guestsWrapper.data.entities,\n        counter: guestsWrapper.data.counter,\n      });\n    }));\n  }\n\n  @Action(SetGuestsAction)\n  onSetGuestsAction(ctx: StateContext<GuestStateModel>, action: SetGuestsAction) {\n    ctx.patchState({\n      displayed: action.guests || [],\n    });\n  }\n\n  @Action(ClearGuestsListAction)\n  onClearGuestListAction(ctx: StateContext<GuestStateModel>) {\n    ctx.patchState({\n      archived: [],\n      displayed: [],\n      counter: 0,\n    });\n  }\n\n  @Action(CreateGuestAction)\n  onCreateGuestAction(ctx: StateContext<GuestStateModel>, action: CreateGuestAction): Observable<VGuestWithBatchDtoHttpResponseData> {\n    const messageBarPayload: MessageBarPayload = {\n      entity: this.translate.instant(Localization.guest),\n      entityName: `${action.guest.firstName} ${action.guest.lastName}`,\n      action: lowerCaseFirstLetter(this.translate.instant(Localization.created)),\n    };\n    this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));\n    return this.guestServiceProxy.createGuest(action.guid, action.guest).pipe(tap({\n      next: (handled: VGuestWithBatchDtoHttpResponseData) => {\n        const displayNewGuestInTable = this.isGuestCreatedFromSelectedFacility(handled.data, action.guid);\n        this.addGuestToStore(ctx, handled.data, displayNewGuestInTable);\n        this.messageBarService.success(\n          displayNewGuestInTable ? Localization.entity_success : Localization.entity_success_not_currently_visible,\n          createMessageText(messageBarPayload)\n        );\n      },\n      error: () => {\n        messageBarPayload.entity = lowerCaseFirstLetter(\n          messageBarPayload.entity\n        );\n        messageBarPayload.action = lowerCaseFirstLetter(\n          this.translate.instant(Localization.create)\n        );\n        this.messageBarService.error(\n          Localization.entity_failed,\n          createMessageText(messageBarPayload)\n        );\n      }\n    }));\n  }\n\n  @Action(CreateBatchAction)\n  onCreateBatchAction(ctx: StateContext<GuestStateModel>, action: CreateBatchAction): Observable<VGuestWithBatchDtoIEnumerableHttpResponseData> {\n    const messageBarPayload: MessageBarPayload = {\n      entity: this.translate.instant(Localization.guest_group),\n      entityName: action.batchCommand.name,\n      action: lowerCaseFirstLetter(this.translate.instant(Localization.created)),\n    };\n    this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));\n    return this.batchServiceProxy.createBatch(action.facilityWithGuid.guid, action.batchCommand).pipe(tap({\n      next: (newGuests: VGuestWithBatchDtoIEnumerableHttpResponseData) => {\n        const displayNewGuestInTable = this.isGuestCreatedFromSelectedFacility(newGuests.data[0], action.facilityWithGuid.guid);\n        this.messageBarService.success(\n          displayNewGuestInTable ? Localization.entity_success : Localization.entity_success_not_currently_visible,\n          createMessageText(messageBarPayload)\n        );\n\n        if (displayNewGuestInTable) {\n          const newBatch = this.convertGuestsToTableData(newGuests.data);\n          markEntitiesAsChanged([newBatch], RowOperation.Insert);\n          markEntitiesAsChanged(newBatch.entities, RowOperation.Insert);\n          const displayedGuests = ctx.getState().displayed;\n          displayedGuests.unshift(...newBatch.entities);\n          displayedGuests.unshift(newBatch);\n          ctx.patchState({\n            displayed: [...displayedGuests],\n            counter: ctx.getState().counter + 1,\n          });\n        }\n      },\n      error: (e: ProblemDetailsHttpResponseData) => {\n        action.errorMessage = e.data.detail;\n      }\n    }));\n  }\n\n  @Action(CreateBasicBatchAction)\n  onCreateBasicBatchAction(ctx: StateContext<GuestStateModel>, action: CreateBasicBatchAction): Observable<VGuestWithBatchDtoIEnumerableHttpResponseData> {\n    const messageBarPayload: MessageBarPayload = {\n      entity: this.translate.instant(Localization.guest_group),\n      entityName: action.batchCommand.name,\n      action: lowerCaseFirstLetter(this.translate.instant(Localization.created)),\n    };\n    this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));\n    return this.batchServiceProxy.createBasicBatch(action.facilityWithGuid.guid, action.batchCommand).pipe(tap({\n      next: (newGuests: VGuestWithBatchDtoIEnumerableHttpResponseData) => {\n        const displayNewGuestInTable = this.isGuestCreatedFromSelectedFacility(newGuests.data[0], action.facilityWithGuid.guid);\n        this.messageBarService.success(\n          displayNewGuestInTable ? Localization.entity_success : Localization.entity_success_not_currently_visible,\n          createMessageText(messageBarPayload)\n        );\n\n        if (displayNewGuestInTable) {\n          const newBatch = this.convertGuestsToTableData(newGuests.data);\n          markEntitiesAsChanged([newBatch], RowOperation.Insert);\n          markEntitiesAsChanged(newBatch.entities, RowOperation.Insert);\n          const displayedGuests = ctx.getState().displayed;\n          displayedGuests.unshift(...newBatch.entities);\n          displayedGuests.unshift(newBatch);\n          ctx.patchState({\n            displayed: [...displayedGuests],\n            counter: ctx.getState().counter + 1,\n          });\n        }\n      },\n      error: (e: ProblemDetailsHttpResponseData) => {\n        action.errorMessage = e.data.detail;\n      }\n    }));\n  }\n\n  @Action(UpdateGuestAction)\n  onUpdateGuestAction(ctx: StateContext<GuestStateModel>, action: UpdateGuestAction): Observable<VGuestWithBatchDtoHttpResponseData> {\n    const messageBarPayload: MessageBarPayload = {\n      entity: this.translate.instant(Localization.guest),\n      entityName: `${action.guest.firstName} ${action.guest.lastName}`,\n      action: this.translate.instant(Localization.updated),\n    };\n    this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));\n    return this.guestServiceProxy.updateGuest(action.guid, action.guest).pipe(tap({\n      next: (handled: VGuestWithBatchDtoHttpResponseData) => {\n        this.updateGuestInStore(ctx, handled.data, action.guid);\n        this.messageBarService.success(\n          Localization.entity_success,\n          createMessageText(messageBarPayload)\n        );\n      },\n      error: () => {\n        messageBarPayload.entity = lowerCaseFirstLetter(\n          messageBarPayload.entity\n        );\n        messageBarPayload.action = lowerCaseFirstLetter(\n          this.translate.instant(Localization.update)\n        );\n        this.messageBarService.error(\n          Localization.entity_failed,\n          createMessageText(messageBarPayload)\n        );\n      }\n    }));\n  }\n\n  @Action(UpdateGuestLocationAction)\n  onUpdateGuestLocationAction(ctx: StateContext<GuestStateModel>, action: UpdateGuestLocationAction): Observable<VGuestWithBatchDtoHttpResponseData> {\n    debugger;\n    const config: CommandNotificationConfig = {\n      messages: [{ value: action.updateGuestLocationCommand.name, class: NotificationClass.body }],\n      command: this.translateService.instant(Localization.update_location)\n    };\n\n    const guest$ = this.guestServiceProxy.updateGuestLocation(action.guid, action.updateGuestLocationCommand);\n    return guest$.pipe(this.commandNotificationService.display(config));\n  }\n\n  @Action(DeleteGuestAction)\n  onDeleteGuestAction(ctx: StateContext<GuestStateModel>, action: DeleteGuestAction): Observable<any> {\n    const interpolatedGuestName = action.guest.name.trim() === Localization.card_holder ?\n      this.translateService.instant(Localization.card_holder) : action.guest.name;\n    const messageBarPayload: MessageBarPayload = {\n      entity: this.translate.instant(Localization.guest),\n      entityName: interpolatedGuestName,\n      action: this.translate.instant(Localization.deleted),\n    };\n    this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));\n    return this.guestServiceProxy.deleteGuest(action.guest.guestID, action.guest.parkID, action.guid).pipe(tap(() => {\n      this.messageBarService.success(\n        Localization.entity_success,\n        createMessageText(messageBarPayload)\n      );\n      (action.guest as VGuestWithBatchDto).deleted = 1;\n      this.deleteGuestFromStore(ctx, action.guest, action.guid);\n    }, () => {\n      messageBarPayload.entity = lowerCaseFirstLetter(\n        messageBarPayload.entity\n      );\n      messageBarPayload.action = lowerCaseFirstLetter(\n        this.translate.instant(Localization.delete)\n      );\n      this.messageBarService.error(\n        Localization.entity_failed,\n        createMessageText(messageBarPayload)\n      );\n    }));\n  }\n\n  @Action(CreateBasicGuestAction)\n  onCreateBasicGuestAction(ctx: StateContext<GuestStateModel>, action: CreateBasicGuestAction): Observable<VGuestWithBatchDtoHttpResponseData> {\n    const messageBarPayload: MessageBarPayload = {\n      entity: this.translate.instant(Localization.guest),\n      entityName: `${action.guest.firstName} ${action.guest.lastName}`,\n      action: lowerCaseFirstLetter(this.translate.instant(Localization.created)),\n    };\n    this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));\n    return this.guestServiceProxy.createBasicGuest(action.guid, action.guest).pipe(tap({\n      next: (handled: VGuestWithBatchDtoHttpResponseData) => {\n        const displayNewGuestInTable = this.isGuestCreatedFromSelectedFacility(handled.data, action.guid);\n        this.addGuestToStore(ctx, handled.data, displayNewGuestInTable);\n        this.messageBarService.success(\n          displayNewGuestInTable ? Localization.entity_success : Localization.entity_success_not_currently_visible,\n          createMessageText(messageBarPayload)\n        );\n      },\n      error: () => {\n        messageBarPayload.entity = lowerCaseFirstLetter(\n          messageBarPayload.entity\n        );\n        messageBarPayload.action = lowerCaseFirstLetter(\n          this.translate.instant(Localization.create)\n        );\n        this.messageBarService.error(\n          Localization.entity_failed,\n          createMessageText(messageBarPayload)\n        );\n      }\n    }));\n  }\n\n  @Action(UpdateBasicGuestAction)\n  onUpdateBasicGuestAction(ctx: StateContext<GuestStateModel>, action: UpdateBasicGuestAction): Observable<VGuestWithBatchDtoHttpResponseData> {\n    const messageBarPayload: MessageBarPayload = {\n      entity: this.translate.instant(Localization.guest),\n      entityName: `${action.guest.firstName} ${action.guest.lastName}`,\n      action: this.translate.instant(Localization.updated),\n    };\n    this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));\n    return this.guestServiceProxy.updateBasicGuest(action.guid, action.guest).pipe(tap({\n      next: (handled: VGuestWithBatchDtoHttpResponseData) => this.onUpdateBasicGuestNext(ctx, action, handled, messageBarPayload),\n      error: () => this.onUpdateBasicGuestError(messageBarPayload)\n    }));\n  }\n\n  @Action(UpdateBasicGuestTempAction)\n  onUpdateBasicGuestTempAction(ctx: StateContext<GuestStateModel>, action: UpdateBasicGuestAction): Observable<VGuestWithBatchDtoHttpResponseData> {\n    const messageBarPayload: MessageBarPayload = {\n      entity: this.translate.instant(Localization.guest),\n      entityName: `${action.guest.firstName} ${action.guest.lastName}`,\n      action: this.translate.instant(Localization.updated),\n    };\n    this.messageBarService.info(Localization.entity_in_progress, createMessageText(messageBarPayload));\n    return this.guestServiceProxy.updateBasicGuestTemp(action.guid, action.guest).pipe(tap({\n      next: (handled: VGuestWithBatchDtoHttpResponseData) => this.onUpdateBasicGuestNext(ctx, action, handled, messageBarPayload),\n      error: () => this.onUpdateBasicGuestError(messageBarPayload)\n    }));\n  }\n\n  @Action(SendEmailToGuest)\n  onSendEmailToGuestAction(ctx: StateContext<GuestStateModel>, action: SendEmailToGuest): Observable<Int32HttpResponseData> {\n    return this.guestServiceProxy.sendGuestEmail(action.guid, action.sendEmailCommand).pipe(tap({\n      next: () => this.messageBarService.success(Localization.email_sent_successfully),\n      error: () => this.messageBarService.error(Localization.email_sending_failed),\n    }));\n  }\n\n  @Action(LoadGuestsByBatchIdAction, { cancelUncompleted: true })\n  onLoadGuestsByBatchId(ctx: StateContext<GuestStateModel>, action: LoadGuestsByBatchIdAction): Observable<VGuestWithBatchDtoIEnumerableHttpResponseData> {\n    const results$ = this.guestServiceProxy.getGuestsByBatchID(action.parkId, action.batchID, action.guid, action.guestsFilterDto);\n    return results$.pipe(tap((guests: VGuestWithBatchDtoIEnumerableHttpResponseData) => {\n      this.addGuestsByBatchIdToStore(ctx, action.batchID, guests.data);\n    }));\n  }\n\n  @Action(LoadGuestsByBatchIdCancelledAction, { cancelUncompleted: false })\n  onLoadGuestsByBatchIdCancelledAction(ctx: StateContext<GuestStateModel>, action: LoadGuestsByBatchIdCancelledAction) {\n    const displayedGuestsBatches = ctx.getState().displayed;\n    const guestBatchIndex = displayedGuestsBatches.findIndex(guest => guest instanceof VGuestWithBatchDto && guest.batchID === action.batchId);\n\n    if (guestBatchIndex !== -1) {\n      const guestBatch = markEntityAsUnchanged(displayedGuestsBatches[guestBatchIndex]);\n\n      displayedGuestsBatches[guestBatchIndex] = Object.assign(new VGuestWithBatchDto(), guestBatch);\n\n      ctx.patchState({\n        displayed: [...displayedGuestsBatches]\n      });\n    }\n  }\n\n  @Action(ExpandGuestsByBatchIdAction)\n  onExpandGuestsByBatchIdAction(ctx: StateContext<GuestStateModel>, action: ExpandGuestsByBatchIdAction): void {\n    this.addGuestsByBatchIdToStore(ctx, action.batchID, action.guests);\n  }\n\n  @Action(CollapsedGuestsByBatchIdAction)\n  onCollapsedGuestsByBatchIdAction(ctx: StateContext<GuestStateModel>, action: CollapsedGuestsByBatchIdAction): void {\n    let displayedGusetBatches = ctx.getState().displayed;\n    const guestBatchIndex = displayedGusetBatches.findIndex(gb => gb.batchID === action.batchID);\n    if (guestBatchIndex !== -1) {\n      displayedGusetBatches = displayedGusetBatches.filter(entity => entity.batchID !== action.batchID || !entity.guestID);\n      ctx.patchState({\n        displayed: [...displayedGusetBatches],\n      });\n    }\n  }\n\n  @Action(LoadGuestProfilesAction, { cancelUncompleted: true })\n  onLoadGuestProfilesAction(ctx: StateContext<GuestStateModel>, action: LoadGuestProfilesAction) {\n    const guestProfiles$ = this.guestServiceProxy.getProfiles(action.parkId, action.searchParamsDto?.maxResults,\n      action.searchParamsDto?.searchTerm, action.searchParamsDto?.orderBy.column,\n      action.searchParamsDto?.orderBy.orderDirection, action.guid);\n    return guestProfiles$.pipe(tap(profiles => {\n      ctx.patchState({\n        profiles: profiles.data,\n      });\n    }));\n  }\n\n  @Action(ClearGuestProfilesAction)\n  onClearGuestProfilesAction(ctx: StateContext<GuestStateModel>) {\n    ctx.patchState({\n      profiles: [],\n    });\n  }\n\n  @Action(SendGuestPassesToEmailAction)\n  async onSendGuestPassesToEmail(ctx: StateContext<GuestStateModel>, action: SendGuestPassesToEmailAction) {\n    const data: any = {\n      modalTitle: this.translate.instant(Localization.send_stickers_to_email),\n      sendEmail: false,\n      sendEmailReqeust: await this.populateSendEmailRequest(action)  // only version >= 8.1 support this feature\n    };\n    data.sendEmailReqeust.to = action.email;\n    ctx.dispatch(new SendEmailFromEntityAction(data.sendEmailReqeust));\n  }\n\n  @Action(ExportGuestsAction, { cancelUncompleted: true })\n  onExportGuestsAction(ctx: StateContext<GuestStateModel>, action: ExportGuestsAction): Observable<VGuestWithBatchDtoEntityWrapperDtoHttpResponseData> {\n    const getGuests$ = this.guestServiceProxy.getGuests(action.parkId, action.guid, action.guestsFilterDto);\n    return getGuests$.pipe(tap({\n      next: (guestsWrapper: VGuestWithBatchDtoEntityWrapperDtoHttpResponseData) => {\n        const tableRows: any[][] = [];\n        const guestWithBatchDtoList: VGuestWithBatchDto[] = guestsWrapper.data.entities;\n        guestWithBatchDtoList.forEach((guest) => {\n          tableRows.push([guest.name,\n          this.translate.instant(ProfileTypeText[ProfileType[guest.mType]]),\n          guest.mobile,\n          guest.carPlate,\n          this.exportFileService.getDateFieldValue(action.fileType, guest, 'validFromDate'),\n          this.exportFileService.getDateFieldValue(action.fileType, guest, 'validToDate'),\n          guest.companyName,\n          guest.subCompanyName,\n          this.parkerService.getHistoryItemAction(guest.location, null),\n          this.exportFileService.getDateFieldValue(action.fileType, guest, 'producedDate')])\n        });\n        this.exportFileService.export(action.fileType, tableRows, action.columnsHeader, Localization.guests);\n      },\n      error: () => {\n        this.messageBarService.error(this.translateService.instant(this.L.failed_export_file));\n      }\n    }));\n  }\n\n  toDateString = (value: Moment) => this.datePipe.transform(value.toDate(), this.tenantService.secondaryDateTimeFormat) || '-';\n\n  private addGuestsByBatchIdToStore(ctx: StateContext<GuestStateModel>, batchID: number, guests: VGuestWithBatchDto[]) {\n    const displayedGusetBatches = ctx.getState().displayed;\n    const guestBatchIndex = displayedGusetBatches.findIndex(gb => gb.batchID === batchID);\n    if (guestBatchIndex !== -1) {\n      displayedGusetBatches[guestBatchIndex].entities = guests;\n      displayedGusetBatches.splice(guestBatchIndex + 1, 0, ...guests);\n\n      ctx.patchState({\n        displayed: [...displayedGusetBatches],\n      });\n    }\n  }\n\n  private convertGuestsToTableData(guests: VGuestWithBatchDto[]): VGuestWithBatchTableData {\n    const batch: VGuestWithBatchTableData = guests.find(g => g.batchID > 0 && g.guestID === null) as any;\n    batch.isRowExpandable = true;\n    batch.entities = guests.filter(g => g.batchID !== null && g.guestID !== null);\n    return batch;\n  }\n\n  private addGuestToStore(ctx: StateContext<GuestStateModel>, guest: VGuestWithBatchDto, displayNewGuestInTable: boolean) {\n    if (displayNewGuestInTable) {\n      const displayedGuests = ctx.getState().displayed;\n      markEntitiesAsChanged([guest], RowOperation.Insert);\n      displayedGuests.unshift(guest);\n      ctx.patchState({\n        displayed: [...displayedGuests],\n        counter: ctx.getState().counter + 1,\n      });\n    }\n  }\n\n  private isGuestCreatedFromSelectedFacility(guest: VGuestWithBatchDto, guid: string) {\n    const selectedParkID = this.store.selectSnapshot(FacilityState.parkId);\n    const selectedGuid = this.store.selectSnapshot(FacilityState.guid);\n    return selectedParkID === guest.parkID && selectedGuid === guid;\n  }\n\n  private getParantAndChildIndex(ctx: StateContext<GuestStateModel>, guestDto: VGuestWithBatchDto): { parent: number, child: number } {\n    const displayedGuests = ctx.getState().displayed;\n    // if I am children find my parent, after that find me\n    const parent = displayedGuests.findIndex(guest => guest.batchID === guestDto.batchID && guest.guestID === null);\n    const child = (displayedGuests[parent].entities || []).findIndex(guest => guest.guestID === guestDto.guestID);\n    return { parent, child };\n  }\n\n  private updateGuestInStore(ctx: StateContext<GuestStateModel>, guest: VGuestWithBatchDto, guid: string) {\n    const displayedGuests = ctx.getState().displayed;\n    const guestIndex = this.getGuestIndex(displayedGuests, guest.guestID);\n\n    if (guestIndex !== -1) {\n      displayedGuests[guestIndex] = guest;\n      markEntitiesAsChanged([guest], RowOperation.Update);\n    }\n\n    if (this.isGuestChild(guest)) {\n      const { child, parent } = this.getParantAndChildIndex(ctx, guest);\n      if (parent !== -1) {\n        if (child !== -1) {\n          displayedGuests[parent].entities[child] = guest;\n        }\n        markEntitiesAsChanged([displayedGuests[parent]]);\n      }\n    }\n\n    ctx.patchState({\n      displayed: [...displayedGuests],\n    });\n  }\n\n  private deleteGuestFromStore(ctx: StateContext<GuestStateModel>, guest: VGuestWithBatchDto, guid: string) {\n    let counter = ctx.getState().counter;\n\n    const displayedGuests = ctx.getState().displayed;\n    const guestIndex = this.getGuestIndex(displayedGuests, guest.guestID);\n\n    if (guestIndex !== -1) {\n      displayedGuests.splice(guestIndex, 1);\n      markEntitiesAsChanged([guest], RowOperation.Delete);\n    }\n\n    if (this.isGuestChild(guest)) {\n      const { child, parent } = this.getParantAndChildIndex(ctx, guest);\n      if (parent !== -1) {\n        if (child !== -1) {\n          displayedGuests[parent].entities.splice(child, 1);\n        }\n        markEntitiesAsChanged([displayedGuests[parent]]);\n      }\n    } else {\n      counter--;\n    }\n\n    ctx.patchState({\n      displayed: [...displayedGuests],\n      counter: counter,\n    });\n  }\n\n  private async populateSendEmailRequest(action: SendGuestPassesToEmailAction) {\n    let pdfPagesParametersList: { [key: string]: any; }[] = [];\n    let guestEmailTemplate = '';\n    if (action.guest.entities && action.guest.entities.length > 0) {\n      pdfPagesParametersList = [];\n      action.guest.entities.forEach(guest => {\n        const paramList = this.getParameters(guest, action.facility);\n        pdfPagesParametersList.push(paramList);\n      });\n      guestEmailTemplate = action.guest.batchName;\n\n    } else {\n      pdfPagesParametersList.push(this.getParameters(action.guest, action.facility));\n      guestEmailTemplate = action.guest.name;\n    }\n\n    const sendEmailRequest = new SendEmailRequestDto({\n      entity: new GuestEntityParams({\n        qrPlainText: action.guest.qrPlainText,\n        id: action.guest.guestID || action.guest.batchID,\n        qrCode: action.guest.qrCode\n      }),\n      to: action.email,\n      templateType: TemplateType.Guest,\n      pdfPagesParametersList,\n      pdfPagesParameters: null, // backwards compatibility version 8.2\n      parameters: {\n        guestEmailTemplate,\n      }\n    });\n    return sendEmailRequest;\n  }\n\n  private getParameters(guest: VGuestWithBatchDto, facility: FacilityWithGuid): { [key: string]: any; } {\n    const parameters = {\n      validFromDateTime: this.toDateString(guest.validFromDate),\n      validToDateTime: this.toDateString(guest.validToDate),\n      companyName: guest.companyName,\n      subCompanyName: guest.subCompanyName,\n      parkName: facility?.data?.name,\n      producedDateTime: this.toDateString(guest.producedDate),\n      id: guest.guestID,\n      firstName: guest.firstName,\n      lastName: guest.lastName,\n      plateId: guest.carPlate,\n      name: guest.name,\n      card: guest.credit,\n      address: getAddress(guest.city, guest.street),\n      qrCode: guest.qrCode,\n      guid: facility.guid,\n      parkId: facility.data.id,\n      qrPlainText: guest.qrPlainText\n    };\n\n    return parameters;\n  }\n\n  private isGuestChild = (guest: VGuestWithBatchDto) => guest.guestID !== null && guest.batchID > 0;\n\n  private getGuestIndex(displayedGuests: VGuestWithBatchDto[], guestId: number): number {\n    return displayedGuests.findIndex(guest => guest.guestID === guestId);\n  }\n\n  private onUpdateBasicGuestNext(ctx: StateContext<GuestStateModel>, action: UpdateBasicGuestAction, handled: VGuestWithBatchDtoHttpResponseData, messageBarPayload: MessageBarPayload) {\n    this.updateGuestInStore(ctx, handled.data, action.guid);\n    this.messageBarService.success(\n      Localization.entity_success,\n      createMessageText(messageBarPayload)\n    );\n  }\n\n  private onUpdateBasicGuestError(messageBarPayload: MessageBarPayload) {\n    messageBarPayload.entity = lowerCaseFirstLetter(\n      messageBarPayload.entity\n    );\n    messageBarPayload.action = lowerCaseFirstLetter(\n      this.translate.instant(Localization.update)\n    );\n    this.messageBarService.error(\n      Localization.entity_failed,\n      createMessageText(messageBarPayload)\n    );\n  }\n}\n"]}