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

package/esm2022/lib/components/reissue-dialog/reissue-upgrade.store.mjs

@@ -0,0 +1,305 @@
+import { DestroyRef, Injectable, computed, effect, inject, signal, untracked } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { finalize } from 'rxjs/operators';
+import { SbdReissueService } from '../../services/reissue.service';
+import { formatMoney } from '../../utils/reissue-format';
+import { SbdReissueStore, buildLegRow } from './reissue.store';
+import * as i0 from "@angular/core";
+const extraOf = (o) => o.fareDetails?.totalAdditionalFare ?? o.priceDifference ?? 0;
+const routeOf = (l) => `${l.origin} → ${l.destination}`;
+const currentOf = (l) => {
+    if (!l)
+        return '';
+    const cabin = [l.class, l.fareBrand?.name].filter(Boolean).join(' · ');
+    return cabin ? `Current: ${cabin}` : '';
+};
+/**
+ * Upgrade Class flow: pick the new class -> price it (choose-flight) -> confirm (book-now when nothing to pay,
+ * otherwise a backend-generated payment link). Reads the options the main store already loaded.
+ */
+export class SbdReissueUpgradeStore {
+    constructor() {
+        this.main = inject(SbdReissueStore);
+        this.api = inject(SbdReissueService);
+        this.destroyRef = inject(DestroyRef);
+        this.submitting = signal(false);
+        this.error = signal(null);
+        this.priceChanged = signal(false);
+        /** `book-now` succeeded (nothing to pay): the reissue is being placed with the supplier. */
+        this.booked = signal(false);
+        this.paymentLink = signal(null);
+        this.selected = signal({}); // sectionId -> referenceKey
+        this.unavailableKeys = signal(new Set());
+        /** Legs the agent chose to upgrade (the "select leg" step; a one-way preselects its only leg). */
+        this.legIds = signal([]);
+        /** Options fetched for a partial leg selection; `null` = the options loaded when the dialog opened (all legs) apply. */
+        this.freshOptions = signal(null);
+        this.legsStepSkipped = signal(false);
+        // ── derived ───────────────────────────────────────────────────────────────
+        this.currency = computed(() => this.main.ctx()?.currency ?? '');
+        /** The options to show: for a partial leg selection the fresh response, otherwise the one loaded with the dialog. */
+        this.options = computed(() => this.freshOptions() ?? this.main.upgradeOptions());
+        this.legRows = computed(() => {
+            const chosen = new Set(this.legIds());
+            return this.main
+                .legs()
+                .map((leg, i) => buildLegRow(leg, this.legUpgradable(leg.legId, i), chosen.has(leg.legId), this.main.isLegOnline(leg.legId) ? 'no-options' : 'offline'));
+        });
+        this.anyLegUpgradable = computed(() => this.legRows().some(r => r.available));
+        this.canContinueFromLegs = computed(() => this.legIds().length > 0 && !this.submitting());
+        /** Legs the options on screen were requested for (all of them, or just the selected ones after a partial fetch). */
+        this.optionLegs = computed(() => {
+            const all = this.main.legs();
+            return this.freshOptions() ? all.filter(l => this.legIds().includes(l.legId)) : all;
+        });
+        this.rawSections = computed(() => {
+            const data = this.options();
+            if (!data)
+                return [];
+            if (data.fareOptionScope === 'leg') {
+                return (data.legs ?? []).map(leg => ({
+                    id: String(leg.legIndex),
+                    title: routeOf({ origin: leg.origin ?? leg.existingLeg.origin, destination: leg.destination ?? leg.existingLeg.destination }),
+                    current: currentOf(leg.existingLeg),
+                    options: leg.options ?? [],
+                }));
+            }
+            const originals = data.existingLegs ?? data.originalLegs ?? [];
+            return [
+                {
+                    id: 'booking',
+                    title: originals.map(routeOf).join(' · ') || 'Whole booking',
+                    current: currentOf(originals[0]),
+                    options: data.options ?? [],
+                },
+            ];
+        });
+        this.sections = computed(() => {
+            const selected = this.selected();
+            const unavailable = this.unavailableKeys();
+            const currency = this.currency();
+            return this.rawSections().map(s => ({
+                id: s.id,
+                title: s.title,
+                current: s.current,
+                options: s.options.map(o => {
+                    const extra = extraOf(o);
+                    return {
+                        key: o.referenceKey,
+                        name: o.name,
+                        code: o.code,
+                        extraLabel: extra > 0 ? `+${formatMoney(extra, currency)}` : 'No extra cost',
+                        selected: selected[s.id] === o.referenceKey,
+                        unavailable: unavailable.has(o.referenceKey),
+                    };
+                }),
+            }));
+        });
+        this.picks = computed(() => {
+            const selected = this.selected();
+            return this.rawSections().flatMap(section => {
+                const option = section.options.find(o => o.referenceKey === selected[section.id]);
+                return option ? [{ section, option }] : [];
+            });
+        });
+        this.canContinue = computed(() => this.picks().length > 0 && !this.submitting());
+        /**
+         * Amount to pay: the sum of the picked options' additional fare (same as the web's `getTotalToPay`).
+         * choose-flight's own `price` is deliberately not used — it is not known whether it is the difference or the full fare.
+         */
+        this.total = computed(() => this.picks().reduce((sum, p) => sum + extraOf(p.option), 0));
+        this.totalLabel = computed(() => (this.total() > 0 ? formatMoney(this.total(), this.currency()) : 'Nothing to pay'));
+        this.summary = computed(() => this.picks().map(({ section, option }) => ({
+            title: section.title,
+            from: section.current.replace(/^Current:\s*/, ''),
+            to: option.name,
+            extraLabel: extraOf(option) > 0 ? `+${formatMoney(extraOf(option), this.currency())}` : 'No extra cost',
+        })));
+        this.action = computed(() => {
+            if (this.booked() || this.paymentLink())
+                return 'done';
+            return this.total() > 0 ? 'link' : 'book';
+        });
+        /** Nothing can be changed any more once the upgrade is placed or a link was generated. */
+        this.locked = computed(() => this.booked() || !!this.paymentLink() || this.submitting());
+        // A fresh options response (new dialog visit / retry) starts the flow over.
+        effect(() => {
+            this.main.upgradeOptions();
+            untracked(() => this.reset());
+        }, { allowSignalWrites: true });
+    }
+    // ── leg selection ─────────────────────────────────────────────────────────
+    /** A leg can be upgraded only if it is online AND has upgrade options (per leg for leg scope; booking scope applies to all). */
+    legUpgradable(legId, index) {
+        if (!this.main.isLegOnline(legId))
+            return false;
+        const data = this.main.upgradeOptions();
+        if (!data)
+            return false;
+        if (data.fareOptionScope === 'leg') {
+            return (data.legs?.find(l => l.legIndex === index)?.options?.length ?? 0) > 0;
+        }
+        return (data.options?.length ?? 0) > 0;
+    }
+    // ── actions ───────────────────────────────────────────────────────────────
+    /**
+     * Service picked: go to "select leg", unless there is nothing to choose (one-way with its only leg upgradable),
+     * which goes straight to the options like the web.
+     */
+    start() {
+        if (this.main.loading() || this.main.error())
+            return;
+        this.main.service.set('upgrade_class');
+        this.freshOptions.set(null);
+        this.selected.set({});
+        this.error.set(null);
+        const upgradable = this.legRows().filter(r => r.available);
+        if (this.legRows().length === 1 && upgradable.length === 1) {
+            this.legIds.set([upgradable[0].leg.legId]);
+            this.legsStepSkipped.set(true);
+            this.main.goTo('upgrade');
+            return;
+        }
+        this.legsStepSkipped.set(false);
+        // "Upgrade as a whole" bookings: every upgradable leg is preselected and cannot be unticked.
+        this.legIds.set(this.main.allowSingleLegSelection() ? [] : upgradable.map(r => r.leg.legId));
+        this.main.goTo('upgrade-legs');
+    }
+    toggleLeg(legId) {
+        const row = this.legRows().find(r => r.leg.legId === legId);
+        if (!row?.available || !this.main.allowSingleLegSelection())
+            return;
+        this.error.set(null);
+        this.legIds.update(ids => (ids.includes(legId) ? ids.filter(i => i !== legId) : [...ids, legId]));
+    }
+    /**
+     * Select leg -> options. All legs selected: reuse the options loaded with the dialog. A subset: fetch the options
+     * again for just those legs (the earlier response covers the whole booking, so it would price the wrong legs).
+     */
+    continueFromLegs() {
+        const ctx = this.main.ctx();
+        const chosen = this.main.legs().filter(l => this.legIds().includes(l.legId));
+        if (!ctx || !chosen.length || !this.canContinueFromLegs())
+            return;
+        this.selected.set({});
+        this.unavailableKeys.set(new Set());
+        if (chosen.length === this.main.legs().length) {
+            this.freshOptions.set(null);
+            this.main.goTo('upgrade');
+            return;
+        }
+        this.submitting.set(true);
+        this.error.set(null);
+        this.api
+            .getUpgradeClassOptions(ctx.bookingId, this.main.postBookingId(), { ...ctx, legs: chosen })
+            .pipe(finalize(() => this.submitting.set(false)), takeUntilDestroyed(this.destroyRef))
+            .subscribe({
+            next: data => {
+                if (!this.api.hasUpgradeOptions(data)) {
+                    this.error.set('No upgrade is available for the selected flight(s).');
+                    return;
+                }
+                this.freshOptions.set(data);
+                this.main.goTo('upgrade');
+            },
+            error: () => this.error.set('Could not load the upgrade options for the selected flight(s).'),
+        });
+    }
+    /** Back from the options: to "select leg" when that step was shown, otherwise to the service list. */
+    back() {
+        this.main.goTo(this.legsStepSkipped() ? 'service' : 'upgrade-legs');
+    }
+    select(sectionId, key) {
+        if (this.unavailableKeys().has(key))
+            return;
+        this.error.set(null);
+        this.selected.update(s => ({ ...s, [sectionId]: key }));
+    }
+    /** Options -> confirm: prices the pick(s) with choose-flight (same body the web sends). */
+    continue() {
+        const ctx = this.main.ctx();
+        const picks = this.picks();
+        if (!ctx || !picks.length || !this.canContinue())
+            return;
+        this.submitting.set(true);
+        this.error.set(null);
+        this.api
+            .chooseFlight(ctx.bookingId, this.main.postBookingId(), this.chooseBody(picks))
+            .pipe(finalize(() => this.submitting.set(false)), takeUntilDestroyed(this.destroyRef))
+            .subscribe({
+            next: res => {
+                if (res?.itineraryAvailable === false) {
+                    this.unavailableKeys.update(keys => new Set([...keys, ...picks.map(p => p.option.referenceKey)]));
+                    this.selected.set({});
+                    this.error.set('This option is no longer available. Please choose another one.');
+                    return;
+                }
+                this.priceChanged.set(res?.priceChanged === true);
+                this.main.goTo('confirm');
+            },
+            error: () => this.error.set('Could not price the selected upgrade. Please try again.'),
+        });
+    }
+    /** Confirm step primary action: place the free upgrade, or generate the payment link. */
+    confirm() {
+        const action = this.action();
+        if (action === 'done' || this.submitting())
+            return;
+        const postBookingId = this.main.postBookingId();
+        this.submitting.set(true);
+        this.error.set(null);
+        const request$ = action === 'book'
+            ? this.api.bookNow(postBookingId)
+            : this.api.getPaymentLink(postBookingId, this.total(), this.currency());
+        request$
+            .pipe(finalize(() => this.submitting.set(false)), takeUntilDestroyed(this.destroyRef))
+            .subscribe({
+            next: res => {
+                // The dialog does not follow the result (no confirmation-status): after `book-now`, or once the link is
+                // sent, the agent follows the booking from the dashboard.
+                if (action === 'book')
+                    this.booked.set(true);
+                else
+                    this.paymentLink.set(res);
+            },
+            error: (err) => this.error.set(action === 'book'
+                ? 'Could not place the upgrade. Please try again.'
+                : err instanceof Error && err.message.startsWith('The cart ')
+                    ? err.message
+                    : 'Could not get the payment link. Please try again.'),
+        });
+    }
+    reset() {
+        this.selected.set({});
+        this.unavailableKeys.set(new Set());
+        this.legIds.set([]);
+        this.freshOptions.set(null);
+        this.legsStepSkipped.set(false);
+        this.submitting.set(false);
+        this.error.set(null);
+        this.priceChanged.set(false);
+        this.booked.set(false);
+        this.paymentLink.set(null);
+    }
+    /** Booking scope: one itinerary. Leg scope: each picked leg as onwardLeg / returnLeg (by the real leg direction). */
+    chooseBody(picks) {
+        const scope = this.options()?.fareOptionScope ?? 'booking';
+        if (scope !== 'leg')
+            return { fareOptionScope: 'booking', ItineraryId: picks[0].option.referenceKey };
+        // A partial fetch re-indexes the sections from 0, so resolve the direction from the legs the options were requested for.
+        const legs = this.optionLegs();
+        const toLeg = (p) => (p ? { legId: p.option.referenceKey, providerType: p.option.providerType } : undefined);
+        const isReturn = (p) => legs[Number(p.section.id)]?.direction === 'Return';
+        return {
+            fareOptionScope: 'leg',
+            onwardLeg: toLeg(picks.find(p => !isReturn(p))),
+            returnLeg: toLeg(picks.find(isReturn)),
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SbdReissueUpgradeStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SbdReissueUpgradeStore }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SbdReissueUpgradeStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reissue-upgrade.store.js","sourceRoot":"","sources":["../../../../../../projects/smart-booking-dashboard/src/lib/components/reissue-dialog/reissue-upgrade.store.ts"],"names":[],"mappings":"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","sourcesContent":["import { DestroyRef, Injectable, computed, effect, inject, signal, untracked } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { finalize } from 'rxjs/operators';\n\nimport { SbdReissueService } from '../../services/reissue.service';\nimport {\n  ReissueChooseFlightRequest,\n  ReissuePaymentLink,\n  ReissueUpgradeExistingLeg,\n  ReissueUpgradeOption,\n  ReissueUpgradeOptionsResponse,\n} from '../../models/reissue.types';\nimport { formatMoney } from '../../utils/reissue-format';\nimport { ReissueLegRow, SbdReissueStore, buildLegRow } from './reissue.store';\n\n/** View models for the Upgrade Class steps. */\nexport interface UpgradeOptionRow { key: string; name: string; code: string; extraLabel: string; selected: boolean; unavailable: boolean }\nexport interface UpgradeSectionRow { id: string; title: string; current: string; options: UpgradeOptionRow[] }\nexport interface UpgradeSummaryRow { title: string; from: string; to: string; extraLabel: string }\n/** What the primary button of the confirm step does. */\nexport type UpgradeAction = 'book' | 'link' | 'done';\n\ninterface RawSection { id: string; title: string; current: string; options: ReissueUpgradeOption[] }\ninterface UpgradePick { section: RawSection; option: ReissueUpgradeOption }\n\nconst extraOf = (o: ReissueUpgradeOption): number => o.fareDetails?.totalAdditionalFare ?? o.priceDifference ?? 0;\nconst routeOf = (l: Pick<ReissueUpgradeExistingLeg, 'origin' | 'destination'>): string => `${l.origin} → ${l.destination}`;\nconst currentOf = (l?: ReissueUpgradeExistingLeg): string => {\n  if (!l) return '';\n  const cabin = [l.class, l.fareBrand?.name].filter(Boolean).join(' · ');\n  return cabin ? `Current: ${cabin}` : '';\n};\n\n/**\n * Upgrade Class flow: pick the new class -> price it (choose-flight) -> confirm (book-now when nothing to pay,\n * otherwise a backend-generated payment link). Reads the options the main store already loaded.\n */\n@Injectable()\nexport class SbdReissueUpgradeStore {\n  private main = inject(SbdReissueStore);\n  private api = inject(SbdReissueService);\n  private destroyRef = inject(DestroyRef);\n\n  readonly submitting = signal(false);\n  readonly error = signal<string | null>(null);\n  readonly priceChanged = signal(false);\n  /** `book-now` succeeded (nothing to pay): the reissue is being placed with the supplier. */\n  readonly booked = signal(false);\n  readonly paymentLink = signal<ReissuePaymentLink | null>(null);\n\n  private selected = signal<Readonly<Record<string, string>>>({}); // sectionId -> referenceKey\n  private unavailableKeys = signal<ReadonlySet<string>>(new Set());\n\n  /** Legs the agent chose to upgrade (the \"select leg\" step; a one-way preselects its only leg). */\n  private legIds = signal<readonly string[]>([]);\n  /** Options fetched for a partial leg selection; `null` = the options loaded when the dialog opened (all legs) apply. */\n  private freshOptions = signal<ReissueUpgradeOptionsResponse | null>(null);\n  private legsStepSkipped = signal(false);\n\n  constructor() {\n    // A fresh options response (new dialog visit / retry) starts the flow over.\n    effect(\n      () => {\n        this.main.upgradeOptions();\n        untracked(() => this.reset());\n      },\n      { allowSignalWrites: true },\n    );\n  }\n\n  // ── derived ───────────────────────────────────────────────────────────────\n  readonly currency = computed(() => this.main.ctx()?.currency ?? '');\n\n  /** The options to show: for a partial leg selection the fresh response, otherwise the one loaded with the dialog. */\n  private options = computed(() => this.freshOptions() ?? this.main.upgradeOptions());\n\n  // ── leg selection ─────────────────────────────────────────────────────────\n\n  /** A leg can be upgraded only if it is online AND has upgrade options (per leg for leg scope; booking scope applies to all). */\n  private legUpgradable(legId: string, index: number): boolean {\n    if (!this.main.isLegOnline(legId)) return false;\n    const data = this.main.upgradeOptions();\n    if (!data) return false;\n    if (data.fareOptionScope === 'leg') {\n      return (data.legs?.find(l => l.legIndex === index)?.options?.length ?? 0) > 0;\n    }\n    return (data.options?.length ?? 0) > 0;\n  }\n\n  readonly legRows = computed<ReissueLegRow[]>(() => {\n    const chosen = new Set(this.legIds());\n    return this.main\n      .legs()\n      .map((leg, i) =>\n        buildLegRow(leg, this.legUpgradable(leg.legId, i), chosen.has(leg.legId), this.main.isLegOnline(leg.legId) ? 'no-options' : 'offline'),\n      );\n  });\n  readonly anyLegUpgradable = computed(() => this.legRows().some(r => r.available));\n  readonly canContinueFromLegs = computed(() => this.legIds().length > 0 && !this.submitting());\n\n  /** Legs the options on screen were requested for (all of them, or just the selected ones after a partial fetch). */\n  private optionLegs = computed(() => {\n    const all = this.main.legs();\n    return this.freshOptions() ? all.filter(l => this.legIds().includes(l.legId)) : all;\n  });\n\n  private rawSections = computed<RawSection[]>(() => {\n    const data = this.options();\n    if (!data) return [];\n\n    if (data.fareOptionScope === 'leg') {\n      return (data.legs ?? []).map(leg => ({\n        id: String(leg.legIndex),\n        title: routeOf({ origin: leg.origin ?? leg.existingLeg.origin, destination: leg.destination ?? leg.existingLeg.destination }),\n        current: currentOf(leg.existingLeg),\n        options: leg.options ?? [],\n      }));\n    }\n    const originals = data.existingLegs ?? data.originalLegs ?? [];\n    return [\n      {\n        id: 'booking',\n        title: originals.map(routeOf).join(' · ') || 'Whole booking',\n        current: currentOf(originals[0]),\n        options: data.options ?? [],\n      },\n    ];\n  });\n\n  readonly sections = computed<UpgradeSectionRow[]>(() => {\n    const selected = this.selected();\n    const unavailable = this.unavailableKeys();\n    const currency = this.currency();\n    return this.rawSections().map(s => ({\n      id: s.id,\n      title: s.title,\n      current: s.current,\n      options: s.options.map(o => {\n        const extra = extraOf(o);\n        return {\n          key: o.referenceKey,\n          name: o.name,\n          code: o.code,\n          extraLabel: extra > 0 ? `+${formatMoney(extra, currency)}` : 'No extra cost',\n          selected: selected[s.id] === o.referenceKey,\n          unavailable: unavailable.has(o.referenceKey),\n        };\n      }),\n    }));\n  });\n\n  private picks = computed<UpgradePick[]>(() => {\n    const selected = this.selected();\n    return this.rawSections().flatMap(section => {\n      const option = section.options.find(o => o.referenceKey === selected[section.id]);\n      return option ? [{ section, option }] : [];\n    });\n  });\n\n  readonly canContinue = computed(() => this.picks().length > 0 && !this.submitting());\n\n  /**\n   * Amount to pay: the sum of the picked options' additional fare (same as the web's `getTotalToPay`).\n   * choose-flight's own `price` is deliberately not used — it is not known whether it is the difference or the full fare.\n   */\n  readonly total = computed(() => this.picks().reduce((sum, p) => sum + extraOf(p.option), 0));\n  readonly totalLabel = computed(() => (this.total() > 0 ? formatMoney(this.total(), this.currency()) : 'Nothing to pay'));\n\n  readonly summary = computed<UpgradeSummaryRow[]>(() =>\n    this.picks().map(({ section, option }) => ({\n      title: section.title,\n      from: section.current.replace(/^Current:\\s*/, ''),\n      to: option.name,\n      extraLabel: extraOf(option) > 0 ? `+${formatMoney(extraOf(option), this.currency())}` : 'No extra cost',\n    })),\n  );\n\n  readonly action = computed<UpgradeAction>(() => {\n    if (this.booked() || this.paymentLink()) return 'done';\n    return this.total() > 0 ? 'link' : 'book';\n  });\n\n  /** Nothing can be changed any more once the upgrade is placed or a link was generated. */\n  readonly locked = computed(() => this.booked() || !!this.paymentLink() || this.submitting());\n\n  // ── actions ───────────────────────────────────────────────────────────────\n\n  /**\n   * Service picked: go to \"select leg\", unless there is nothing to choose (one-way with its only leg upgradable),\n   * which goes straight to the options like the web.\n   */\n  start(): void {\n    if (this.main.loading() || this.main.error()) return;\n    this.main.service.set('upgrade_class');\n    this.freshOptions.set(null);\n    this.selected.set({});\n    this.error.set(null);\n\n    const upgradable = this.legRows().filter(r => r.available);\n    if (this.legRows().length === 1 && upgradable.length === 1) {\n      this.legIds.set([upgradable[0].leg.legId]);\n      this.legsStepSkipped.set(true);\n      this.main.goTo('upgrade');\n      return;\n    }\n    this.legsStepSkipped.set(false);\n    // \"Upgrade as a whole\" bookings: every upgradable leg is preselected and cannot be unticked.\n    this.legIds.set(this.main.allowSingleLegSelection() ? [] : upgradable.map(r => r.leg.legId));\n    this.main.goTo('upgrade-legs');\n  }\n\n  toggleLeg(legId: string): void {\n    const row = this.legRows().find(r => r.leg.legId === legId);\n    if (!row?.available || !this.main.allowSingleLegSelection()) return;\n    this.error.set(null);\n    this.legIds.update(ids => (ids.includes(legId) ? ids.filter(i => i !== legId) : [...ids, legId]));\n  }\n\n  /**\n   * Select leg -> options. All legs selected: reuse the options loaded with the dialog. A subset: fetch the options\n   * again for just those legs (the earlier response covers the whole booking, so it would price the wrong legs).\n   */\n  continueFromLegs(): void {\n    const ctx = this.main.ctx();\n    const chosen = this.main.legs().filter(l => this.legIds().includes(l.legId));\n    if (!ctx || !chosen.length || !this.canContinueFromLegs()) return;\n\n    this.selected.set({});\n    this.unavailableKeys.set(new Set());\n    if (chosen.length === this.main.legs().length) {\n      this.freshOptions.set(null);\n      this.main.goTo('upgrade');\n      return;\n    }\n\n    this.submitting.set(true);\n    this.error.set(null);\n    this.api\n      .getUpgradeClassOptions(ctx.bookingId, this.main.postBookingId(), { ...ctx, legs: chosen })\n      .pipe(\n        finalize(() => this.submitting.set(false)),\n        takeUntilDestroyed(this.destroyRef),\n      )\n      .subscribe({\n        next: data => {\n          if (!this.api.hasUpgradeOptions(data)) {\n            this.error.set('No upgrade is available for the selected flight(s).');\n            return;\n          }\n          this.freshOptions.set(data);\n          this.main.goTo('upgrade');\n        },\n        error: () => this.error.set('Could not load the upgrade options for the selected flight(s).'),\n      });\n  }\n\n  /** Back from the options: to \"select leg\" when that step was shown, otherwise to the service list. */\n  back(): void {\n    this.main.goTo(this.legsStepSkipped() ? 'service' : 'upgrade-legs');\n  }\n\n  select(sectionId: string, key: string): void {\n    if (this.unavailableKeys().has(key)) return;\n    this.error.set(null);\n    this.selected.update(s => ({ ...s, [sectionId]: key }));\n  }\n\n  /** Options -> confirm: prices the pick(s) with choose-flight (same body the web sends). */\n  continue(): void {\n    const ctx = this.main.ctx();\n    const picks = this.picks();\n    if (!ctx || !picks.length || !this.canContinue()) return;\n\n    this.submitting.set(true);\n    this.error.set(null);\n    this.api\n      .chooseFlight(ctx.bookingId, this.main.postBookingId(), this.chooseBody(picks))\n      .pipe(\n        finalize(() => this.submitting.set(false)),\n        takeUntilDestroyed(this.destroyRef),\n      )\n      .subscribe({\n        next: res => {\n          if (res?.itineraryAvailable === false) {\n            this.unavailableKeys.update(keys => new Set([...keys, ...picks.map(p => p.option.referenceKey)]));\n            this.selected.set({});\n            this.error.set('This option is no longer available. Please choose another one.');\n            return;\n          }\n          this.priceChanged.set(res?.priceChanged === true);\n          this.main.goTo('confirm');\n        },\n        error: () => this.error.set('Could not price the selected upgrade. Please try again.'),\n      });\n  }\n\n  /** Confirm step primary action: place the free upgrade, or generate the payment link. */\n  confirm(): void {\n    const action = this.action();\n    if (action === 'done' || this.submitting()) return;\n    const postBookingId = this.main.postBookingId();\n\n    this.submitting.set(true);\n    this.error.set(null);\n    const request$ =\n      action === 'book'\n        ? this.api.bookNow(postBookingId)\n        : this.api.getPaymentLink(postBookingId, this.total(), this.currency());\n\n    request$\n      .pipe(\n        finalize(() => this.submitting.set(false)),\n        takeUntilDestroyed(this.destroyRef),\n      )\n      .subscribe({\n        next: res => {\n          // The dialog does not follow the result (no confirmation-status): after `book-now`, or once the link is\n          // sent, the agent follows the booking from the dashboard.\n          if (action === 'book') this.booked.set(true);\n          else this.paymentLink.set(res as ReissuePaymentLink);\n        },\n        error: (err: unknown) =>\n          this.error.set(\n            action === 'book'\n              ? 'Could not place the upgrade. Please try again.'\n              : err instanceof Error && err.message.startsWith('The cart ')\n                ? err.message\n                : 'Could not get the payment link. Please try again.',\n          ),\n      });\n  }\n\n  private reset(): void {\n    this.selected.set({});\n    this.unavailableKeys.set(new Set());\n    this.legIds.set([]);\n    this.freshOptions.set(null);\n    this.legsStepSkipped.set(false);\n    this.submitting.set(false);\n    this.error.set(null);\n    this.priceChanged.set(false);\n    this.booked.set(false);\n    this.paymentLink.set(null);\n  }\n\n  /** Booking scope: one itinerary. Leg scope: each picked leg as onwardLeg / returnLeg (by the real leg direction). */\n  private chooseBody(picks: UpgradePick[]): ReissueChooseFlightRequest {\n    const scope = this.options()?.fareOptionScope ?? 'booking';\n    if (scope !== 'leg') return { fareOptionScope: 'booking', ItineraryId: picks[0].option.referenceKey };\n\n    // A partial fetch re-indexes the sections from 0, so resolve the direction from the legs the options were requested for.\n    const legs = this.optionLegs();\n    const toLeg = (p?: UpgradePick) => (p ? { legId: p.option.referenceKey, providerType: p.option.providerType } : undefined);\n    const isReturn = (p: UpgradePick) => legs[Number(p.section.id)]?.direction === 'Return';\n    return {\n      fareOptionScope: 'leg',\n      onwardLeg: toLeg(picks.find(p => !isReturn(p))),\n      returnLeg: toLeg(picks.find(isReturn)),\n    };\n  }\n}\n"]}