@almatar/smart-booking-dashboard 0.0.1 → 0.0.2-alpha.3

package/esm2022/lib/components/hotel-cancel/services/almatar-hotel-auto-cancellation-endpoints.service.mjs

@@ -0,0 +1,457 @@
+import { Injectable, inject, signal, computed } from '@angular/core';
+import { map, catchError, throwError } from 'rxjs';
+import { ApiService } from '../../../shared/services/api.service';
+import { SBD_CONFIG } from '../../../config/dashboard.config';
+import { ActivatedRoute } from '@angular/router';
+import { environments } from '../../../shared/environments/environment';
+import { HotelManageBookingService } from '../../shared/services/hotel-manage-booking/hotel-manage-booking.service';
+import { AlmatarHotelAutoCancellationEndpointsEnum } from '../enums/almatar-hotel-auto-cancellation-endpoints.enum';
+import { resolveMyTripsViewedEntrySourceFromQueryParams } from '../../../shared/services/webengage-tracking.service';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+export class AlmatarHotelAutoCancellationEndpointsService {
+    constructor() {
+        this.api = inject(ApiService);
+        this.apiBase = inject(SBD_CONFIG).apiBase;
+        this.route = inject(ActivatedRoute);
+        this.hotelManageBookingService = inject(HotelManageBookingService);
+        this._almatarBookingId = signal('');
+        this._confirmationNumber = signal('');
+        this._isNusukFlow = signal(environments.isTenant || false);
+        this._selectedPackageIds = signal([]);
+        this.almatarBookingId = computed(() => this._almatarBookingId());
+        this.confirmationNumber = computed(() => this._confirmationNumber());
+        this.isNusukFlow = computed(() => this._isNusukFlow());
+        this.initializeBookingData();
+    }
+    initializeBookingData() {
+        this.hotelManageBookingService.selectedHotelBooking
+            .pipe(takeUntilDestroyed())
+            .subscribe((selectedHotelBooking) => {
+            // console.log('Selected Hotel Booking:', selectedHotelBooking);
+            if (selectedHotelBooking) {
+                this._almatarBookingId.set(selectedHotelBooking.bookingId || '');
+                this._confirmationNumber.set(selectedHotelBooking.bookingId || '');
+            }
+        });
+    }
+    /**
+     * Full URL of an endpoint from the enum. The enum paths start with `/api/`, which is the default `apiBase`; a host
+     * that serves the API somewhere else (Helix: its own API origin) sets `apiBase`, so that part is swapped for it.
+     */
+    resolveEndpoint(path) {
+        return `${this.apiBase.replace(/\/+$/, '')}/${path.replace(/^\/?api\//, '')}`;
+    }
+    getRefundDetails(packageIds = []) {
+        const endpoint = this.resolveEndpoint(AlmatarHotelAutoCancellationEndpointsEnum.getRefundDetails);
+        const payload = {
+            bookingId: `${this.hotelManageBookingService.selectedHotelBooking.value?.bookingId ||
+                ''}`,
+            product: 'hotels',
+            packageIds: [...new Set(packageIds)] // Ensure unique package IDs
+        };
+        // return of({
+        //   data: {
+        //     bookingId: 144368,
+        //     currency: 'SAR',
+        //     status: 'Partially refunded',
+        //     message: 'Refund details calculated successfully',
+        //     flags: {
+        //       refundable: true,
+        //       partial: false,
+        //       goldenGift: false
+        //     },
+        //     selection: {
+        //       packageIds: ['f03838bd-ea8d-4fe5-bfc8-dd31c9bdee95']
+        //     },
+        //     totals: {
+        //       paid: 6866,
+        //       beforeCoupon: 6865.61,
+        //       roomsBooked: 4,
+        //       coupon: 0,
+        //       gifts: 0,
+        //       serviceFee: 0,
+        //       wallet: 0,
+        //       card: 0,
+        //       tabby: 0,
+        //       tamara: 220,
+        //       mokafa: 0,
+        //       qitaf: 0,
+        //       wala: 0,
+        //       hassad: 0,
+        //       anb: 0,
+        //       ygg: 0
+        //     },
+        //     previous: [
+        //       {
+        //         packageId: '5eb33d59-2607-4057-9d26-4f7be745f67f',
+        //         roomName: 'Standard Room',
+        //         cancelledAt: '2026-09-02T13:42:54.848Z',
+        //         amount: 2990.79,
+        //         fee: 0,
+        //         refunded: 2990.79
+        //       }
+        //     ],
+        //     current: {
+        //       rooms: [
+        //         {
+        //           packageId: 'f03838bd-ea8d-4fe5-bfc8-dd31c9bdee95',
+        //           roomId: '0229e622-a89a-469d-adb8-8615deb971ca',
+        //           roomName: 'Scene Room Twin',
+        //           basis: 'Room only RO',
+        //           pax: {
+        //             adults: 2,
+        //             children: 0,
+        //             total: 2
+        //           },
+        //           nights: 4,
+        //           amount: 1887.61,
+        //           fee: 0,
+        //           serviceFee: 50,
+        //           refund: 1887.61,
+        //           refundable: true,
+        //           route: 'AUTO'
+        //         },
+        //         {
+        //           packageId: 'f03838bd-ea8d-4fe5-bfc8-dd31c9bdee95',
+        //           roomId: 'b8aed26e-d91a-4234-ae37-94b2c6232dbd',
+        //           roomName: 'Scene Room Twin',
+        //           basis: 'Room only RO',
+        //           pax: {
+        //             adults: 2,
+        //             children: 0,
+        //             total: 2
+        //           },
+        //           nights: 4,
+        //           amount: 1887.6,
+        //           fee: 0,
+        //           serviceFee: 50,
+        //           refund: 1887.6,
+        //           refundable: true,
+        //           route: 'AUTO'
+        //         }
+        //       ],
+        //       amount: 3775.21,
+        //       fee: 0,
+        //       surcharge: 0,
+        //       refund: 3775.21
+        //     },
+        //     payout: {
+        //       alreadyRefunded: 2990.79,
+        //       current: 1600,
+        //       afterThis: 6766,
+        //       feesTotal: 0,
+        //       wallet: 0,
+        //       card: 0,
+        //       tabby: 0,
+        //       tamara: 200,
+        //       amwal: 0,
+        //       mis: 0,
+        //       bnplManual: 0,
+        //       loyaltyToWallet: 600,
+        //       note: null
+        //     },
+        //     summaries: [
+        //       {
+        //         code: 'CARD',
+        //         label: 'Card',
+        //         paid: 6866,
+        //         refund: 3775.21,
+        //         refundable: true,
+        //         gateway: 'CH'
+        //       },
+        //       {
+        //         code: 'SERVICE_FEE',
+        //         label: 'Service Fee',
+        //         paid: 100,
+        //         refund: 0,
+        //         refundable: false
+        //       }
+        //     ],
+        //     gifts: []
+        //   },
+        //   status: 200,
+        //   errors: null
+        // });
+        return this.api
+            .post({
+            endpoint,
+            ...payload
+        })
+            .pipe(catchError((error) => this.handleError(error, 'Failed to get refund details')));
+    }
+    mapApiResponseToRooms(data) {
+        return this.getAllRooms(data);
+    }
+    mapApiResponseToRefundSummary(data) {
+        return {
+            totalPaid: data.totals?.paid || 0,
+            totalRefund: data.current?.refund || data.current?.refund || 0,
+            totalFees: data.current?.fee || 0,
+            rooms: this.getAllRooms(data),
+            packages: this.getAllPackages(data),
+            summaries: data.summaries,
+            payout: data.payout,
+            totals: data.totals,
+            // Additional breakdown fields
+            coupon: data.totals?.coupon || 0,
+            giftsTotal: data.totals?.gifts || 0,
+            giftsDetails: data.gifts || [],
+            serviceFee: data.totals?.serviceFee || 0,
+            surcharge: data.current?.surcharge || 0,
+            goldenGift: data.flags?.goldenGift || false,
+            previousRooms: data.previous || []
+        };
+    }
+    getAllPackages(data) {
+        const packages = [];
+        const packageMap = new Map();
+        // Process previous (cancelled) rooms - group by packageId
+        if (data.previous?.length) {
+            data.previous.forEach((room) => {
+                const existingPkg = packageMap.get(room.packageId);
+                if (existingPkg) {
+                    existingPkg.rooms.push({
+                        roomId: room.roomId || room.packageId,
+                        roomName: room.roomName,
+                        basis: room.basis,
+                        nights: room.nights
+                    });
+                    existingPkg.amount += room.amount || 0;
+                    existingPkg.fee += room.fee || 0;
+                    existingPkg.refund += room.refunded || 0;
+                }
+                else {
+                    packageMap.set(room.packageId, {
+                        packageId: room.packageId,
+                        packageName: room.roomName,
+                        rooms: [
+                            {
+                                roomId: room.roomId || room.packageId,
+                                roomName: room.roomName,
+                                basis: room.basis,
+                                nights: room.nights
+                            }
+                        ],
+                        amount: room.amount || 0,
+                        fee: room.fee || 0,
+                        serviceFee: 0,
+                        refund: room.refunded || 0,
+                        refundable: false,
+                        cancelledBefore: true,
+                        cancellationDate: room.cancelledAt
+                    });
+                }
+            });
+        }
+        // Process current rooms - group by packageId
+        if (data.current?.rooms?.length) {
+            data.current.rooms.forEach((room) => {
+                const existingPkg = packageMap.get(room.packageId);
+                if (existingPkg && !existingPkg.cancelledBefore) {
+                    existingPkg.rooms.push({
+                        roomId: room.roomId || room.packageId,
+                        roomName: room.roomName,
+                        basis: room.basis,
+                        nights: room.nights,
+                        pax: room.pax,
+                        adults: room.pax?.adults,
+                        children: room.pax?.children
+                    });
+                    existingPkg.amount += room.amount || 0;
+                    existingPkg.fee += room.fee || 0;
+                    existingPkg.serviceFee += room.serviceFee || 0;
+                    existingPkg.refund += room.refund || 0;
+                }
+                else {
+                    packageMap.set(room.packageId, {
+                        packageId: room.packageId,
+                        packageName: room.roomName,
+                        rooms: [
+                            {
+                                roomId: room.roomId || room.packageId,
+                                roomName: room.roomName,
+                                basis: room.basis,
+                                nights: room.nights,
+                                pax: room.pax,
+                                adults: room.pax?.adults,
+                                children: room.pax?.children
+                            }
+                        ],
+                        amount: room.amount || 0,
+                        fee: room.fee || 0,
+                        serviceFee: room.serviceFee || 0,
+                        refund: room.refund || 0,
+                        refundable: room.refundable,
+                        route: room.route,
+                        cancelledBefore: false,
+                        cancellationDate: new Date().toISOString()
+                    });
+                }
+            });
+        }
+        packageMap.forEach((pkg) => packages.push(pkg));
+        return packages;
+    }
+    getAllRooms(data) {
+        const allRooms = [];
+        if (data.previous?.length) {
+            data.previous.forEach((room) => {
+                allRooms.push({
+                    packageId: room.packageId,
+                    roomId: room?.roomId,
+                    roomName: room.roomName,
+                    isRefundable: false,
+                    isSelected: false,
+                    cancelledBefore: true,
+                    roomAmount: room.amount,
+                    cancellationFee: room.fee,
+                    refundAmount: room.refunded,
+                    currentCancellation: false,
+                    cancellationDate: room.cancelledAt,
+                    nights: room.nights ?? 1
+                });
+            });
+        }
+        if (data.current?.rooms?.length) {
+            data.current.rooms.forEach((room) => {
+                allRooms.push({
+                    packageId: room.packageId,
+                    roomId: room?.roomId,
+                    roomName: room.roomName,
+                    isRefundable: room.refundable,
+                    isSelected: false,
+                    roomAmount: room.amount,
+                    cancellationFee: room.fee,
+                    cancelledBefore: false,
+                    refundAmount: room.refund,
+                    route: room.route,
+                    currentCancellation: true,
+                    cancellationDate: `${new Date()}`,
+                    nights: room.nights ?? 1
+                });
+            });
+        }
+        return allRooms;
+    }
+    processAutoCancellation(packageIds, refundOption = 'originalPaymentMethod') {
+        const endpoint = this.resolveEndpoint(AlmatarHotelAutoCancellationEndpointsEnum.processAutoCancellation);
+        const uniquePackageIds = [...new Set(packageIds)]; // Ensure unique package IDs
+        const payload = {
+            bookingId: `${this.hotelManageBookingService.selectedHotelBooking.value?.bookingId ||
+                ''}`,
+            product: 'hotels',
+            packageIds: uniquePackageIds,
+            preferredPaymentMethod: refundOption
+        };
+        this._selectedPackageIds.set(uniquePackageIds);
+        // return of({
+        //   data: {
+        //     error: '1',
+        //     message:
+        //       'Cancel requested — supplier cancellation failed; ticket created',
+        //     bookingId: 144368,
+        //     preferredPaymentMethod: 'wallet',
+        //     cancel: {
+        //       status: 'failed',
+        //       packageIds: ['f03838bd-ea8d-4fe5-bfc8-dd31c9bdee95'],
+        //     },
+        //     refund: {
+        //       status: 'skipped',
+        //       bookingStatus: 'Cancelled',
+        //       amount: 1050,
+        //       currency: 'SAR',
+        //       breakdown: {
+        //         wallet: 750,
+        //         mokafa: 200,
+        //         qitaf: 100,
+        //         card: 0,
+        //         tabby: 0,
+        //         tamara: 0,
+        //       },
+        //     },
+        //   },
+        //   status: 200,
+        //   errors: null,
+        // });
+        return this.api
+            .post({
+            endpoint,
+            ...payload
+        })
+            .pipe(map((response) => {
+            this._selectedPackageIds.set([]);
+            return response;
+        }), catchError((error) => this.handleError(error, 'Failed to process cancellation')));
+    }
+    processNonRefundableCancellation(packageId, attachmentUrl, language = 'en') {
+        const endpoint = this.resolveEndpoint(AlmatarHotelAutoCancellationEndpointsEnum.processAutoCancellation);
+        const payload = {
+            bookingId: `${this.hotelManageBookingService.selectedHotelBooking.value?.bookingId ||
+                ''}`,
+            product: 'hotels',
+            packageIds: [packageId],
+            preferredPaymentMethod: 'originalPaymentMethod',
+            processedMode: 'auto',
+            language,
+            attachmentUrl
+        };
+        return this.api
+            .post({
+            endpoint,
+            ...payload
+        })
+            .pipe(catchError((error) => this.handleError(error, 'Failed to process non-refundable cancellation')));
+    }
+    calculateLocalRefundSummary(rooms) {
+        const selectedRooms = rooms.filter((room) => room.isSelected);
+        const totalPaid = rooms.reduce((sum, room) => sum + room.roomAmount, 0);
+        const totalRefund = selectedRooms.reduce((sum, room) => sum + room.refundAmount, 0);
+        return {
+            totalPaid,
+            totalRefund,
+            rooms: selectedRooms.map((room) => ({
+                ...room,
+                currentCancellation: true,
+                cancellationDate: new Date().toISOString()
+            }))
+        };
+    }
+    getSelectedPackageIds() {
+        return this._selectedPackageIds();
+    }
+    clearSelectedPackageIds() {
+        this._selectedPackageIds.set([]);
+    }
+    getEntrySourceDeviceBrand() {
+        return {
+            entrySource: this.getEntrySource(),
+            device: this.getDevice()
+        };
+    }
+    getEntrySource() {
+        return resolveMyTripsViewedEntrySourceFromQueryParams(this.route.snapshot.queryParams);
+    }
+    getDevice() {
+        let device = 'web';
+        if (this.route.snapshot.queryParams['mobileAuth']) {
+            device = this.route.snapshot.queryParams['device'] || 'mobile';
+        }
+        localStorage.setItem('deviceType', device);
+        return device;
+    }
+    handleError(error, message) {
+        // console.log(message, error);
+        const errorMessage = error?.error?.message || error?.message || message;
+        return throwError(() => new Error(errorMessage));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AlmatarHotelAutoCancellationEndpointsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AlmatarHotelAutoCancellationEndpointsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AlmatarHotelAutoCancellationEndpointsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"almatar-hotel-auto-cancellation-endpoints.service.js","sourceRoot":"","sources":["../../../../../../../projects/smart-booking-dashboard/src/lib/components/hotel-cancel/services/almatar-hotel-auto-cancellation-endpoints.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject, signal, computed } from '@angular/core';\nimport { Observable, map, catchError, throwError, of } from 'rxjs';\nimport { ApiService } from '../../../shared/services/api.service';\nimport { SBD_CONFIG } from '../../../config/dashboard.config';\nimport { ActivatedRoute } from '@angular/router';\nimport { environments } from '../../../shared/environments/environment';\nimport { HotelManageBookingService } from '../../shared/services/hotel-manage-booking/hotel-manage-booking.service';\nimport { AlmatarHotelAutoCancellationEndpointsEnum } from '../enums/almatar-hotel-auto-cancellation-endpoints.enum';\nimport {\n  IAlmatarHotelAutoCancellationRoom,\n  IAlmatarHotelAutoCancellationRefundSummary,\n  IAlmatarHotelAutoCancellationRefundPackage,\n  IRefundDetailsApiResponse,\n  IRefundDetailsData\n} from '../interfaces/i-almatar-hotel-auto-cancellation.interface';\nimport { resolveMyTripsViewedEntrySourceFromQueryParams } from '../../../shared/services/webengage-tracking.service';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\nexport interface IRefundDetailsRequest {\n  bookingId: string;\n  product: 'hotels';\n  packageIds: string[];\n}\n\nexport interface IProcessCancellationRequest {\n  bookingId: string;\n  product: 'hotels';\n  packageIds: string[];\n  preferredPaymentMethod?: string;\n}\n\nexport interface IProcessNonRefundableCancellationRequest {\n  bookingId: string;\n  product: 'hotels';\n  packageIds: string[];\n  preferredPaymentMethod: string;\n  processedMode: 'auto';\n  language: string;\n  attachmentUrl: string;\n}\n\nexport interface IAutoCancellationProcessResponse {\n  status: number;\n  data: {\n    error: string;\n    message: string;\n    bookingId: number;\n    preferredPaymentMethod: string;\n    isWhatsApp?: boolean;\n    cancel: {\n      status: string;\n      packageIds: string[];\n    };\n    refund: {\n      status: string;\n      bookingStatus: string;\n      amount: number;\n      currency: string;\n      breakdown: {\n        wallet: number;\n        mokafa: number;\n        qitaf: number;\n        card: number;\n        tabby: number;\n        tamara: number;\n      };\n    };\n  };\n  errors: any;\n}\n\ninterface IEntrySourceDeviceBrand {\n  entrySource: string;\n  device: string;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AlmatarHotelAutoCancellationEndpointsService {\n  private readonly api = inject(ApiService);\n  private readonly apiBase = inject(SBD_CONFIG).apiBase;\n  private readonly route = inject(ActivatedRoute);\n  private readonly hotelManageBookingService = inject(\n    HotelManageBookingService\n  );\n\n  private readonly _almatarBookingId = signal<string>('');\n  private readonly _confirmationNumber = signal<string>('');\n  private readonly _isNusukFlow = signal<boolean>(\n    environments.isTenant || false\n  );\n\n  private readonly _selectedPackageIds = signal<string[]>([]);\n\n  readonly almatarBookingId = computed(() => this._almatarBookingId());\n  readonly confirmationNumber = computed(() => this._confirmationNumber());\n  readonly isNusukFlow = computed(() => this._isNusukFlow());\n\n  constructor() {\n    this.initializeBookingData();\n  }\n\n  private initializeBookingData(): void {\n    this.hotelManageBookingService.selectedHotelBooking\n      .pipe(takeUntilDestroyed())\n      .subscribe((selectedHotelBooking: any) => {\n        // console.log('Selected Hotel Booking:', selectedHotelBooking);\n        if (selectedHotelBooking) {\n          this._almatarBookingId.set(selectedHotelBooking.bookingId || '');\n          this._confirmationNumber.set(selectedHotelBooking.bookingId || '');\n        }\n      });\n  }\n\n  /**\n   * Full URL of an endpoint from the enum. The enum paths start with `/api/`, which is the default `apiBase`; a host\n   * that serves the API somewhere else (Helix: its own API origin) sets `apiBase`, so that part is swapped for it.\n   */\n  resolveEndpoint(path: string): string {\n    return `${this.apiBase.replace(/\\/+$/, '')}/${path.replace(/^\\/?api\\//, '')}`;\n  }\n\n  getRefundDetails(\n    packageIds: string[] = []\n  ): Observable<IRefundDetailsApiResponse> {\n    const endpoint = this.resolveEndpoint(\n      AlmatarHotelAutoCancellationEndpointsEnum.getRefundDetails\n    );\n\n    const payload: IRefundDetailsRequest = {\n      bookingId: `${\n        this.hotelManageBookingService.selectedHotelBooking.value?.bookingId ||\n        ''\n      }`,\n      product: 'hotels',\n      packageIds: [...new Set(packageIds)] // Ensure unique package IDs\n    };\n\n    // return of({\n    //   data: {\n    //     bookingId: 144368,\n    //     currency: 'SAR',\n    //     status: 'Partially refunded',\n    //     message: 'Refund details calculated successfully',\n    //     flags: {\n    //       refundable: true,\n    //       partial: false,\n    //       goldenGift: false\n    //     },\n    //     selection: {\n    //       packageIds: ['f03838bd-ea8d-4fe5-bfc8-dd31c9bdee95']\n    //     },\n    //     totals: {\n    //       paid: 6866,\n    //       beforeCoupon: 6865.61,\n    //       roomsBooked: 4,\n    //       coupon: 0,\n    //       gifts: 0,\n    //       serviceFee: 0,\n    //       wallet: 0,\n    //       card: 0,\n    //       tabby: 0,\n    //       tamara: 220,\n    //       mokafa: 0,\n    //       qitaf: 0,\n    //       wala: 0,\n    //       hassad: 0,\n    //       anb: 0,\n    //       ygg: 0\n    //     },\n    //     previous: [\n    //       {\n    //         packageId: '5eb33d59-2607-4057-9d26-4f7be745f67f',\n    //         roomName: 'Standard Room',\n    //         cancelledAt: '2026-09-02T13:42:54.848Z',\n    //         amount: 2990.79,\n    //         fee: 0,\n    //         refunded: 2990.79\n    //       }\n    //     ],\n    //     current: {\n    //       rooms: [\n    //         {\n    //           packageId: 'f03838bd-ea8d-4fe5-bfc8-dd31c9bdee95',\n    //           roomId: '0229e622-a89a-469d-adb8-8615deb971ca',\n    //           roomName: 'Scene Room Twin',\n    //           basis: 'Room only RO',\n    //           pax: {\n    //             adults: 2,\n    //             children: 0,\n    //             total: 2\n    //           },\n    //           nights: 4,\n    //           amount: 1887.61,\n    //           fee: 0,\n    //           serviceFee: 50,\n    //           refund: 1887.61,\n    //           refundable: true,\n    //           route: 'AUTO'\n    //         },\n    //         {\n    //           packageId: 'f03838bd-ea8d-4fe5-bfc8-dd31c9bdee95',\n    //           roomId: 'b8aed26e-d91a-4234-ae37-94b2c6232dbd',\n    //           roomName: 'Scene Room Twin',\n    //           basis: 'Room only RO',\n    //           pax: {\n    //             adults: 2,\n    //             children: 0,\n    //             total: 2\n    //           },\n    //           nights: 4,\n    //           amount: 1887.6,\n    //           fee: 0,\n    //           serviceFee: 50,\n    //           refund: 1887.6,\n    //           refundable: true,\n    //           route: 'AUTO'\n    //         }\n    //       ],\n    //       amount: 3775.21,\n    //       fee: 0,\n    //       surcharge: 0,\n    //       refund: 3775.21\n    //     },\n    //     payout: {\n    //       alreadyRefunded: 2990.79,\n    //       current: 1600,\n    //       afterThis: 6766,\n    //       feesTotal: 0,\n    //       wallet: 0,\n    //       card: 0,\n    //       tabby: 0,\n    //       tamara: 200,\n    //       amwal: 0,\n    //       mis: 0,\n    //       bnplManual: 0,\n    //       loyaltyToWallet: 600,\n    //       note: null\n    //     },\n    //     summaries: [\n    //       {\n    //         code: 'CARD',\n    //         label: 'Card',\n    //         paid: 6866,\n    //         refund: 3775.21,\n    //         refundable: true,\n    //         gateway: 'CH'\n    //       },\n    //       {\n    //         code: 'SERVICE_FEE',\n    //         label: 'Service Fee',\n    //         paid: 100,\n    //         refund: 0,\n    //         refundable: false\n    //       }\n    //     ],\n    //     gifts: []\n    //   },\n    //   status: 200,\n    //   errors: null\n    // });\n\n    return this.api\n      .post<IRefundDetailsApiResponse>({\n        endpoint,\n        ...payload\n      })\n      .pipe(\n        catchError((error) =>\n          this.handleError(error, 'Failed to get refund details')\n        )\n      );\n  }\n\n  mapApiResponseToRooms(\n    data: IRefundDetailsData\n  ): IAlmatarHotelAutoCancellationRoom[] {\n    return this.getAllRooms(data);\n  }\n\n  mapApiResponseToRefundSummary(\n    data: IRefundDetailsData\n  ): IAlmatarHotelAutoCancellationRefundSummary {\n    return {\n      totalPaid: data.totals?.paid || 0,\n      totalRefund: data.current?.refund || data.current?.refund || 0,\n      totalFees: data.current?.fee || 0,\n      rooms: this.getAllRooms(data),\n      packages: this.getAllPackages(data),\n      summaries: data.summaries,\n      payout: data.payout,\n      totals: data.totals,\n      // Additional breakdown fields\n      coupon: data.totals?.coupon || 0,\n      giftsTotal: data.totals?.gifts || 0,\n      giftsDetails: data.gifts || [],\n      serviceFee: data.totals?.serviceFee || 0,\n      surcharge: data.current?.surcharge || 0,\n      goldenGift: data.flags?.goldenGift || false,\n      previousRooms: data.previous || []\n    };\n  }\n\n  getAllPackages(\n    data: IRefundDetailsData\n  ): IAlmatarHotelAutoCancellationRefundPackage[] {\n    const packages: IAlmatarHotelAutoCancellationRefundPackage[] = [];\n    const packageMap = new Map<\n      string,\n      IAlmatarHotelAutoCancellationRefundPackage\n    >();\n\n    // Process previous (cancelled) rooms - group by packageId\n    if (data.previous?.length) {\n      data.previous.forEach((room: any) => {\n        const existingPkg = packageMap.get(room.packageId);\n        if (existingPkg) {\n          existingPkg.rooms.push({\n            roomId: room.roomId || room.packageId,\n            roomName: room.roomName,\n            basis: room.basis,\n            nights: room.nights\n          });\n          existingPkg.amount += room.amount || 0;\n          existingPkg.fee += room.fee || 0;\n          existingPkg.refund += room.refunded || 0;\n        } else {\n          packageMap.set(room.packageId, {\n            packageId: room.packageId,\n            packageName: room.roomName,\n            rooms: [\n              {\n                roomId: room.roomId || room.packageId,\n                roomName: room.roomName,\n                basis: room.basis,\n                nights: room.nights\n              }\n            ],\n            amount: room.amount || 0,\n            fee: room.fee || 0,\n            serviceFee: 0,\n            refund: room.refunded || 0,\n            refundable: false,\n            cancelledBefore: true,\n            cancellationDate: room.cancelledAt\n          });\n        }\n      });\n    }\n\n    // Process current rooms - group by packageId\n    if (data.current?.rooms?.length) {\n      data.current.rooms.forEach((room: any) => {\n        const existingPkg = packageMap.get(room.packageId);\n        if (existingPkg && !existingPkg.cancelledBefore) {\n          existingPkg.rooms.push({\n            roomId: room.roomId || room.packageId,\n            roomName: room.roomName,\n            basis: room.basis,\n            nights: room.nights,\n            pax: room.pax,\n            adults: room.pax?.adults,\n            children: room.pax?.children\n          });\n          existingPkg.amount += room.amount || 0;\n          existingPkg.fee += room.fee || 0;\n          existingPkg.serviceFee += room.serviceFee || 0;\n          existingPkg.refund += room.refund || 0;\n        } else {\n          packageMap.set(room.packageId, {\n            packageId: room.packageId,\n            packageName: room.roomName,\n            rooms: [\n              {\n                roomId: room.roomId || room.packageId,\n                roomName: room.roomName,\n                basis: room.basis,\n                nights: room.nights,\n                pax: room.pax,\n                adults: room.pax?.adults,\n                children: room.pax?.children\n              }\n            ],\n            amount: room.amount || 0,\n            fee: room.fee || 0,\n            serviceFee: room.serviceFee || 0,\n            refund: room.refund || 0,\n            refundable: room.refundable,\n            route: room.route,\n            cancelledBefore: false,\n            cancellationDate: new Date().toISOString()\n          });\n        }\n      });\n    }\n\n    packageMap.forEach((pkg) => packages.push(pkg));\n    return packages;\n  }\n\n  getAllRooms(data: IRefundDetailsData): IAlmatarHotelAutoCancellationRoom[] {\n    const allRooms: IAlmatarHotelAutoCancellationRoom[] = [];\n\n    if (data.previous?.length) {\n      data.previous.forEach((room) => {\n        allRooms.push({\n          packageId: room.packageId,\n          roomId: room?.roomId,\n          roomName: room.roomName,\n          isRefundable: false,\n          isSelected: false,\n          cancelledBefore: true,\n          roomAmount: room.amount,\n          cancellationFee: room.fee,\n          refundAmount: room.refunded,\n          currentCancellation: false,\n          cancellationDate: room.cancelledAt,\n          nights: room.nights ?? 1\n        });\n      });\n    }\n\n    if (data.current?.rooms?.length) {\n      data.current.rooms.forEach((room) => {\n        allRooms.push({\n          packageId: room.packageId,\n          roomId: room?.roomId,\n          roomName: room.roomName,\n          isRefundable: room.refundable,\n          isSelected: false,\n          roomAmount: room.amount,\n          cancellationFee: room.fee,\n          cancelledBefore: false,\n          refundAmount: room.refund,\n          route: room.route,\n          currentCancellation: true,\n          cancellationDate: `${new Date()}`,\n          nights: room.nights ?? 1\n        });\n      });\n    }\n\n    return allRooms;\n  }\n\n  processAutoCancellation(\n    packageIds: string[],\n    refundOption = 'originalPaymentMethod'\n  ): Observable<IAutoCancellationProcessResponse> {\n    const endpoint = this.resolveEndpoint(\n      AlmatarHotelAutoCancellationEndpointsEnum.processAutoCancellation\n    );\n\n    const uniquePackageIds = [...new Set(packageIds)]; // Ensure unique package IDs\n    const payload: IProcessCancellationRequest = {\n      bookingId: `${\n        this.hotelManageBookingService.selectedHotelBooking.value?.bookingId ||\n        ''\n      }`,\n      product: 'hotels',\n      packageIds: uniquePackageIds,\n      preferredPaymentMethod: refundOption\n    };\n\n    this._selectedPackageIds.set(uniquePackageIds);\n\n    // return of({\n    //   data: {\n    //     error: '1',\n    //     message:\n    //       'Cancel requested — supplier cancellation failed; ticket created',\n    //     bookingId: 144368,\n    //     preferredPaymentMethod: 'wallet',\n    //     cancel: {\n    //       status: 'failed',\n    //       packageIds: ['f03838bd-ea8d-4fe5-bfc8-dd31c9bdee95'],\n    //     },\n    //     refund: {\n    //       status: 'skipped',\n    //       bookingStatus: 'Cancelled',\n    //       amount: 1050,\n    //       currency: 'SAR',\n    //       breakdown: {\n    //         wallet: 750,\n    //         mokafa: 200,\n    //         qitaf: 100,\n    //         card: 0,\n    //         tabby: 0,\n    //         tamara: 0,\n    //       },\n    //     },\n    //   },\n    //   status: 200,\n    //   errors: null,\n    // });\n\n    return this.api\n      .post<IAutoCancellationProcessResponse>({\n        endpoint,\n        ...payload\n      })\n      .pipe(\n        map((response) => {\n          this._selectedPackageIds.set([]);\n          return response;\n        }),\n        catchError((error) =>\n          this.handleError(error, 'Failed to process cancellation')\n        )\n      );\n  }\n\n  processNonRefundableCancellation(\n    packageId: string,\n    attachmentUrl: string,\n    language = 'en'\n  ): Observable<IAutoCancellationProcessResponse> {\n    const endpoint = this.resolveEndpoint(\n      AlmatarHotelAutoCancellationEndpointsEnum.processAutoCancellation\n    );\n\n    const payload: IProcessNonRefundableCancellationRequest = {\n      bookingId: `${\n        this.hotelManageBookingService.selectedHotelBooking.value?.bookingId ||\n        ''\n      }`,\n      product: 'hotels',\n      packageIds: [packageId],\n      preferredPaymentMethod: 'originalPaymentMethod',\n      processedMode: 'auto',\n      language,\n      attachmentUrl\n    };\n\n    return this.api\n      .post<IAutoCancellationProcessResponse>({\n        endpoint,\n        ...payload\n      })\n      .pipe(\n        catchError((error) =>\n          this.handleError(\n            error,\n            'Failed to process non-refundable cancellation'\n          )\n        )\n      );\n  }\n\n  calculateLocalRefundSummary(\n    rooms: IAlmatarHotelAutoCancellationRoom[]\n  ): IAlmatarHotelAutoCancellationRefundSummary {\n    const selectedRooms = rooms.filter((room) => room.isSelected);\n    const totalPaid = rooms.reduce((sum, room) => sum + room.roomAmount, 0);\n    const totalRefund = selectedRooms.reduce(\n      (sum, room) => sum + room.refundAmount,\n      0\n    );\n\n    return {\n      totalPaid,\n      totalRefund,\n      rooms: selectedRooms.map((room) => ({\n        ...room,\n        currentCancellation: true,\n        cancellationDate: new Date().toISOString()\n      }))\n    };\n  }\n\n  getSelectedPackageIds(): string[] {\n    return this._selectedPackageIds();\n  }\n\n  clearSelectedPackageIds(): void {\n    this._selectedPackageIds.set([]);\n  }\n\n  private getEntrySourceDeviceBrand(): IEntrySourceDeviceBrand {\n    return {\n      entrySource: this.getEntrySource(),\n      device: this.getDevice()\n    };\n  }\n\n  private getEntrySource(): string {\n    return resolveMyTripsViewedEntrySourceFromQueryParams(\n      this.route.snapshot.queryParams as Record<string, unknown>\n    );\n  }\n\n  private getDevice(): string {\n    let device = 'web';\n    if (this.route.snapshot.queryParams['mobileAuth']) {\n      device = this.route.snapshot.queryParams['device'] || 'mobile';\n    }\n    localStorage.setItem('deviceType', device);\n    return device;\n  }\n\n  private handleError(error: any, message: string): Observable<never> {\n    // console.log(message, error);\n    const errorMessage =\n      error?.error?.message || error?.message || message;\n    return throwError(() => new Error(errorMessage));\n  }\n}\n"]}

package/esm2022/lib/components/hotel-cancel/services/almatar-hotel-auto-cancellation.service.mjs

@@ -0,0 +1,55 @@
+import { Injectable, signal, computed } from '@angular/core';
+import { AlmatarHotelAutoCancellationStepEnum } from '../enums/almatar-hotel-auto-cancellation-step.enum';
+import * as i0 from "@angular/core";
+export class AlmatarHotelAutoCancellationService {
+    constructor() {
+        this.currentStep = signal(AlmatarHotelAutoCancellationStepEnum.selectRooms);
+        this.selectedRooms = signal([]);
+        this.hotelInfo = signal(null);
+        this.refundSummary = signal(null);
+        this.selectedRoomsCount = computed(() => this.selectedRooms().filter((room) => room.isSelected).length);
+        this.hasSelectedRooms = computed(() => this.selectedRoomsCount() > 0);
+        this.totalRefundAmount = computed(() => {
+            const summary = this.refundSummary();
+            return summary?.totalRefund ?? 0;
+        });
+    }
+    setCurrentStep(step) {
+        this.currentStep.set(step);
+    }
+    setSelectedRooms(rooms) {
+        this.selectedRooms.set(rooms);
+    }
+    setHotelInfo(info) {
+        this.hotelInfo.set(info);
+    }
+    setRefundSummary(summary) {
+        this.refundSummary.set(summary);
+    }
+    toggleRoomSelection(packageId) {
+        this.selectedRooms.update((rooms) => rooms.map((room) => room.packageId === packageId
+            ? { ...room, isSelected: !room.isSelected }
+            : room));
+    }
+    calculateRefundSummary(rooms, totalPaid) {
+        const selected = rooms.filter((room) => room.isSelected);
+        const totalRefund = selected.reduce((sum, room) => sum + room.refundAmount, 0);
+        return {
+            totalPaid,
+            totalRefund,
+            rooms: selected,
+        };
+    }
+    reset() {
+        this.currentStep.set(AlmatarHotelAutoCancellationStepEnum.selectRooms);
+        this.selectedRooms.set([]);
+        this.hotelInfo.set(null);
+        this.refundSummary.set(null);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AlmatarHotelAutoCancellationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AlmatarHotelAutoCancellationService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AlmatarHotelAutoCancellationService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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