@vendure/admin-ui 1.7.4 → 1.8.0

package/package/esm2015/order/components/order-detail/order-detail.component.js

@@ -0,0 +1,550 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+import { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';
+import { BaseDetailComponent, DataService, EditNoteDialogComponent, ModalService, NotificationService, ServerConfigService, SortOrder, } from '@vendure/admin-ui/core';
+import { assertNever, summate } from '@vendure/common/lib/shared-utils';
+import { EMPTY, of, Subject } from 'rxjs';
+import { map, mapTo, startWith, switchMap, take } from 'rxjs/operators';
+import { OrderTransitionService } from '../../providers/order-transition.service';
+import { AddManualPaymentDialogComponent } from '../add-manual-payment-dialog/add-manual-payment-dialog.component';
+import { CancelOrderDialogComponent } from '../cancel-order-dialog/cancel-order-dialog.component';
+import { FulfillOrderDialogComponent } from '../fulfill-order-dialog/fulfill-order-dialog.component';
+import { OrderProcessGraphDialogComponent } from '../order-process-graph-dialog/order-process-graph-dialog.component';
+import { RefundOrderDialogComponent } from '../refund-order-dialog/refund-order-dialog.component';
+import { SettleRefundDialogComponent } from '../settle-refund-dialog/settle-refund-dialog.component';
+export class OrderDetailComponent extends BaseDetailComponent {
+    constructor(router, route, serverConfigService, changeDetector, dataService, notificationService, modalService, orderTransitionService) {
+        super(route, router, serverConfigService, dataService);
+        this.changeDetector = changeDetector;
+        this.dataService = dataService;
+        this.notificationService = notificationService;
+        this.modalService = modalService;
+        this.orderTransitionService = orderTransitionService;
+        this.detailForm = new FormGroup({});
+        this.fetchHistory = new Subject();
+        this.defaultStates = [
+            'AddingItems',
+            'ArrangingPayment',
+            'PaymentAuthorized',
+            'PaymentSettled',
+            'PartiallyShipped',
+            'Shipped',
+            'PartiallyDelivered',
+            'Delivered',
+            'Cancelled',
+            'Modifying',
+            'ArrangingAdditionalPayment',
+        ];
+    }
+    ngOnInit() {
+        this.init();
+        this.entity$.pipe(take(1)).subscribe(order => {
+            if (order.state === 'Modifying') {
+                this.router.navigate(['./', 'modify'], { relativeTo: this.route });
+            }
+        });
+        this.customFields = this.getCustomFieldConfig('Order');
+        this.orderLineCustomFields = this.getCustomFieldConfig('OrderLine');
+        this.history$ = this.fetchHistory.pipe(startWith(null), switchMap(() => {
+            return this.dataService.order
+                .getOrderHistory(this.id, {
+                sort: {
+                    createdAt: SortOrder.DESC,
+                },
+            })
+                .mapStream(data => { var _a; return (_a = data.order) === null || _a === void 0 ? void 0 : _a.history.items; });
+        }));
+        this.nextStates$ = this.entity$.pipe(map(order => {
+            const isInCustomState = !this.defaultStates.includes(order.state);
+            return isInCustomState
+                ? order.nextStates
+                : order.nextStates.filter(s => !this.defaultStates.includes(s));
+        }));
+    }
+    ngOnDestroy() {
+        this.destroy();
+    }
+    openStateDiagram() {
+        this.entity$
+            .pipe(take(1), switchMap(order => this.modalService.fromComponent(OrderProcessGraphDialogComponent, {
+            closable: true,
+            locals: {
+                activeState: order.state,
+            },
+        })))
+            .subscribe();
+    }
+    transitionToState(state) {
+        this.dataService.order.transitionToState(this.id, state).subscribe(({ transitionOrderToState }) => {
+            switch (transitionOrderToState === null || transitionOrderToState === void 0 ? void 0 : transitionOrderToState.__typename) {
+                case 'Order':
+                    this.notificationService.success(_('order.transitioned-to-state-success'), { state });
+                    this.fetchHistory.next();
+                    break;
+                case 'OrderStateTransitionError':
+                    this.notificationService.error(transitionOrderToState.transitionError);
+            }
+        });
+    }
+    manuallyTransitionToState(order) {
+        this.orderTransitionService
+            .manuallyTransitionToState({
+            orderId: order.id,
+            nextStates: order.nextStates,
+            cancellable: true,
+            message: _('order.manually-transition-to-state-message'),
+            retry: 0,
+        })
+            .subscribe();
+    }
+    transitionToModifying() {
+        this.dataService.order
+            .transitionToState(this.id, 'Modifying')
+            .subscribe(({ transitionOrderToState }) => {
+            switch (transitionOrderToState === null || transitionOrderToState === void 0 ? void 0 : transitionOrderToState.__typename) {
+                case 'Order':
+                    this.router.navigate(['./modify'], { relativeTo: this.route });
+                    break;
+                case 'OrderStateTransitionError':
+                    this.notificationService.error(transitionOrderToState.transitionError);
+            }
+        });
+    }
+    updateCustomFields(customFieldsValue) {
+        this.dataService.order
+            .updateOrderCustomFields({
+            id: this.id,
+            customFields: customFieldsValue,
+        })
+            .subscribe(() => {
+            this.notificationService.success(_('common.notify-update-success'), { entity: 'Order' });
+        });
+    }
+    getOrderAddressLines(orderAddress) {
+        if (!orderAddress) {
+            return [];
+        }
+        return Object.values(orderAddress)
+            .filter(val => val !== 'OrderAddress')
+            .filter(line => !!line);
+    }
+    settlePayment(payment) {
+        this.dataService.order.settlePayment(payment.id).subscribe(({ settlePayment }) => {
+            switch (settlePayment.__typename) {
+                case 'Payment':
+                    if (settlePayment.state === 'Settled') {
+                        this.notificationService.success(_('order.settle-payment-success'));
+                    }
+                    else {
+                        this.notificationService.error(_('order.settle-payment-error'));
+                    }
+                    this.dataService.order.getOrder(this.id).single$.subscribe();
+                    this.fetchHistory.next();
+                    break;
+                case 'OrderStateTransitionError':
+                case 'PaymentStateTransitionError':
+                case 'SettlePaymentError':
+                    this.notificationService.error(settlePayment.message);
+            }
+        });
+    }
+    transitionPaymentState({ payment, state }) {
+        if (state === 'Cancelled') {
+            this.dataService.order.cancelPayment(payment.id).subscribe(({ cancelPayment }) => {
+                switch (cancelPayment.__typename) {
+                    case 'Payment':
+                        this.notificationService.success(_('order.transitioned-payment-to-state-success'), {
+                            state,
+                        });
+                        this.dataService.order.getOrder(this.id).single$.subscribe();
+                        this.fetchHistory.next();
+                        break;
+                    case 'PaymentStateTransitionError':
+                        this.notificationService.error(cancelPayment.transitionError);
+                        break;
+                    case 'CancelPaymentError':
+                        this.notificationService.error(cancelPayment.paymentErrorMessage);
+                        break;
+                }
+            });
+        }
+        else {
+            this.dataService.order
+                .transitionPaymentToState(payment.id, state)
+                .subscribe(({ transitionPaymentToState }) => {
+                switch (transitionPaymentToState.__typename) {
+                    case 'Payment':
+                        this.notificationService.success(_('order.transitioned-payment-to-state-success'), {
+                            state,
+                        });
+                        this.dataService.order.getOrder(this.id).single$.subscribe();
+                        this.fetchHistory.next();
+                        break;
+                    case 'PaymentStateTransitionError':
+                        this.notificationService.error(transitionPaymentToState.message);
+                        break;
+                }
+            });
+        }
+    }
+    canAddFulfillment(order) {
+        var _a;
+        const allFulfillmentSummaryRows = ((_a = order.fulfillments) !== null && _a !== void 0 ? _a : []).reduce((all, fulfillment) => [...all, ...fulfillment.summary], []);
+        let allItemsFulfilled = true;
+        for (const line of order.lines) {
+            const totalFulfilledCount = allFulfillmentSummaryRows
+                .filter(row => row.orderLine.id === line.id)
+                .reduce((sum, row) => sum + row.quantity, 0);
+            if (totalFulfilledCount < line.quantity) {
+                allItemsFulfilled = false;
+            }
+        }
+        return (!allItemsFulfilled &&
+            !this.hasUnsettledModifications(order) &&
+            this.outstandingPaymentAmount(order) === 0 &&
+            (order.nextStates.includes('Shipped') ||
+                order.nextStates.includes('PartiallyShipped') ||
+                order.nextStates.includes('Delivered')));
+    }
+    hasUnsettledModifications(order) {
+        return 0 < order.modifications.filter(m => !m.isSettled).length;
+    }
+    getOutstandingModificationAmount(order) {
+        return summate(order.modifications.filter(m => !m.isSettled), 'priceChange');
+    }
+    outstandingPaymentAmount(order) {
+        var _a, _b, _c;
+        const paymentIsValid = (p) => p.state !== 'Cancelled' && p.state !== 'Declined' && p.state !== 'Error';
+        let amountCovered = 0;
+        for (const payment of (_b = (_a = order.payments) === null || _a === void 0 ? void 0 : _a.filter(paymentIsValid)) !== null && _b !== void 0 ? _b : []) {
+            const refunds = (_c = payment.refunds.filter(r => r.state !== 'Failed')) !== null && _c !== void 0 ? _c : [];
+            const refundsTotal = summate(refunds, 'total');
+            amountCovered += payment.amount - refundsTotal;
+        }
+        return order.totalWithTax - amountCovered;
+    }
+    addManualPayment(order) {
+        const priorState = order.state;
+        this.modalService
+            .fromComponent(AddManualPaymentDialogComponent, {
+            closable: true,
+            locals: {
+                outstandingAmount: this.outstandingPaymentAmount(order),
+                currencyCode: order.currencyCode,
+            },
+        })
+            .pipe(switchMap(result => {
+            if (result) {
+                return this.dataService.order.addManualPaymentToOrder({
+                    orderId: this.id,
+                    transactionId: result.transactionId,
+                    method: result.method,
+                    metadata: result.metadata || {},
+                });
+            }
+            else {
+                return EMPTY;
+            }
+        }), switchMap(({ addManualPaymentToOrder }) => {
+            switch (addManualPaymentToOrder.__typename) {
+                case 'Order':
+                    this.notificationService.success(_('order.add-payment-to-order-success'));
+                    if (priorState === 'ArrangingAdditionalPayment') {
+                        return this.orderTransitionService.transitionToPreModifyingState(order.id, order.nextStates);
+                    }
+                    else {
+                        return this.dataService.order
+                            .transitionToState(this.id, 'PaymentSettled')
+                            .pipe(mapTo('PaymentSettled'));
+                    }
+                case 'ManualPaymentStateError':
+                    this.notificationService.error(addManualPaymentToOrder.message);
+                    return EMPTY;
+                default:
+                    return EMPTY;
+            }
+        }))
+            .subscribe(result => {
+            if (result) {
+                this.refetchOrder({ result });
+            }
+        });
+    }
+    fulfillOrder() {
+        this.entity$
+            .pipe(take(1), switchMap(order => {
+            return this.modalService.fromComponent(FulfillOrderDialogComponent, {
+                size: 'xl',
+                locals: {
+                    order,
+                },
+            });
+        }), switchMap(input => {
+            if (input) {
+                return this.dataService.order.createFulfillment(input);
+            }
+            else {
+                return of(undefined);
+            }
+        }), switchMap(result => this.refetchOrder(result).pipe(mapTo(result))))
+            .subscribe(result => {
+            if (result) {
+                const { addFulfillmentToOrder } = result;
+                switch (addFulfillmentToOrder.__typename) {
+                    case 'Fulfillment':
+                        this.notificationService.success(_('order.create-fulfillment-success'));
+                        break;
+                    case 'EmptyOrderLineSelectionError':
+                    case 'InsufficientStockOnHandError':
+                    case 'ItemsAlreadyFulfilledError':
+                    case 'InvalidFulfillmentHandlerError':
+                        this.notificationService.error(addFulfillmentToOrder.message);
+                        break;
+                    case 'FulfillmentStateTransitionError':
+                        this.notificationService.error(addFulfillmentToOrder.transitionError);
+                        break;
+                    case 'CreateFulfillmentError':
+                        this.notificationService.error(addFulfillmentToOrder.fulfillmentHandlerError);
+                        break;
+                    case undefined:
+                        this.notificationService.error(JSON.stringify(addFulfillmentToOrder));
+                        break;
+                    default:
+                        assertNever(addFulfillmentToOrder);
+                }
+            }
+        });
+    }
+    transitionFulfillment(id, state) {
+        this.dataService.order
+            .transitionFulfillmentToState(id, state)
+            .pipe(switchMap(result => this.refetchOrder(result)))
+            .subscribe(() => {
+            this.notificationService.success(_('order.successfully-updated-fulfillment'));
+        });
+    }
+    cancelOrRefund(order) {
+        const isRefundable = this.orderHasSettledPayments(order);
+        if (order.state === 'PaymentAuthorized' || order.active === true || !isRefundable) {
+            this.cancelOrder(order);
+        }
+        else {
+            this.refundOrder(order);
+        }
+    }
+    settleRefund(refund) {
+        this.modalService
+            .fromComponent(SettleRefundDialogComponent, {
+            size: 'md',
+            locals: {
+                refund,
+            },
+        })
+            .pipe(switchMap(transactionId => {
+            if (transactionId) {
+                return this.dataService.order.settleRefund({
+                    transactionId,
+                    id: refund.id,
+                }, this.id);
+            }
+            else {
+                return of(undefined);
+            }
+        }))
+            .subscribe(result => {
+            if (result) {
+                this.notificationService.success(_('order.settle-refund-success'));
+            }
+        });
+    }
+    addNote(event) {
+        const { note, isPublic } = event;
+        this.dataService.order
+            .addNoteToOrder({
+            id: this.id,
+            note,
+            isPublic,
+        })
+            .pipe(switchMap(result => this.refetchOrder(result)))
+            .subscribe(result => {
+            this.notificationService.success(_('common.notify-create-success'), {
+                entity: 'Note',
+            });
+        });
+    }
+    updateNote(entry) {
+        this.modalService
+            .fromComponent(EditNoteDialogComponent, {
+            closable: true,
+            locals: {
+                displayPrivacyControls: true,
+                note: entry.data.note,
+                noteIsPrivate: !entry.isPublic,
+            },
+        })
+            .pipe(switchMap(result => {
+            if (result) {
+                return this.dataService.order.updateOrderNote({
+                    noteId: entry.id,
+                    isPublic: !result.isPrivate,
+                    note: result.note,
+                });
+            }
+            else {
+                return EMPTY;
+            }
+        }))
+            .subscribe(result => {
+            this.fetchHistory.next();
+            this.notificationService.success(_('common.notify-update-success'), {
+                entity: 'Note',
+            });
+        });
+    }
+    deleteNote(entry) {
+        return this.modalService
+            .dialog({
+            title: _('common.confirm-delete-note'),
+            body: entry.data.note,
+            buttons: [
+                { type: 'secondary', label: _('common.cancel') },
+                { type: 'danger', label: _('common.delete'), returnValue: true },
+            ],
+        })
+            .pipe(switchMap(res => (res ? this.dataService.order.deleteOrderNote(entry.id) : EMPTY)))
+            .subscribe(() => {
+            this.fetchHistory.next();
+            this.notificationService.success(_('common.notify-delete-success'), {
+                entity: 'Note',
+            });
+        });
+    }
+    orderHasSettledPayments(order) {
+        var _a;
+        return !!((_a = order.payments) === null || _a === void 0 ? void 0 : _a.find(p => p.state === 'Settled'));
+    }
+    cancelOrder(order) {
+        this.modalService
+            .fromComponent(CancelOrderDialogComponent, {
+            size: 'xl',
+            locals: {
+                order,
+            },
+        })
+            .pipe(switchMap(input => {
+            if (input) {
+                return this.dataService.order.cancelOrder(input);
+            }
+            else {
+                return of(undefined);
+            }
+        }), switchMap(result => this.refetchOrder(result)))
+            .subscribe(result => {
+            if (result) {
+                this.notificationService.success(_('order.cancelled-order-success'));
+            }
+        });
+    }
+    refundOrder(order) {
+        this.modalService
+            .fromComponent(RefundOrderDialogComponent, {
+            size: 'xl',
+            locals: {
+                order,
+            },
+        })
+            .pipe(switchMap(input => {
+            var _a;
+            if (!input) {
+                return of(undefined);
+            }
+            if ((_a = input.cancel.lines) === null || _a === void 0 ? void 0 : _a.length) {
+                return this.dataService.order.cancelOrder(input.cancel).pipe(map(res => {
+                    const result = res.cancelOrder;
+                    switch (result.__typename) {
+                        case 'Order':
+                            this.refetchOrder(result).subscribe();
+                            this.notificationService.success(_('order.cancelled-order-success'));
+                            return input;
+                        case 'CancelActiveOrderError':
+                        case 'QuantityTooGreatError':
+                        case 'MultipleOrderError':
+                        case 'OrderStateTransitionError':
+                        case 'EmptyOrderLineSelectionError':
+                            this.notificationService.error(result.message);
+                            return undefined;
+                    }
+                }));
+            }
+            else {
+                return [input];
+            }
+        }), switchMap(input => {
+            if (!input) {
+                return of(undefined);
+            }
+            if (input.refund.lines.length) {
+                return this.dataService.order
+                    .refundOrder(input.refund)
+                    .pipe(map(res => res.refundOrder));
+            }
+            else {
+                return [undefined];
+            }
+        }))
+            .subscribe(result => {
+            if (result) {
+                switch (result.__typename) {
+                    case 'Refund':
+                        this.refetchOrder(result).subscribe();
+                        if (result.state === 'Failed') {
+                            this.notificationService.error(_('order.refund-order-failed'));
+                        }
+                        else {
+                            this.notificationService.success(_('order.refund-order-success'));
+                        }
+                        break;
+                    case 'AlreadyRefundedError':
+                    case 'NothingToRefundError':
+                    case 'PaymentOrderMismatchError':
+                    case 'RefundOrderStateError':
+                    case 'RefundStateTransitionError':
+                        this.notificationService.error(result.message);
+                        break;
+                }
+            }
+        });
+    }
+    refetchOrder(result) {
+        this.fetchHistory.next();
+        if (result) {
+            return this.dataService.order.getOrder(this.id).single$;
+        }
+        else {
+            return of(undefined);
+        }
+    }
+    setFormValues(entity) {
+        // empty
+    }
+}
+OrderDetailComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-order-detail',
+                template: "<vdr-action-bar *ngIf=\"entity$ | async as order\">\r\n    <vdr-ab-left>\r\n        <div class=\"flex clr-align-items-center\">\r\n            <vdr-entity-info [entity]=\"entity$ | async\"></vdr-entity-info>\r\n            <vdr-order-state-label [state]=\"order.state\">\r\n                <button\r\n                    class=\"icon-button\"\r\n                    (click)=\"openStateDiagram()\"\r\n                    [title]=\"'order.order-state-diagram' | translate\"\r\n                >\r\n                    <clr-icon shape=\"list\"></clr-icon>\r\n                </button>\r\n            </vdr-order-state-label>\r\n        </div>\r\n    </vdr-ab-left>\r\n\r\n    <vdr-ab-right>\r\n        <vdr-action-bar-items locationId=\"order-detail\"></vdr-action-bar-items>\r\n        <button\r\n            class=\"btn btn-primary\"\r\n            *ngIf=\"\r\n                (order.state === 'ArrangingPayment' || order.state === 'ArrangingAdditionalPayment') &&\r\n                (hasUnsettledModifications(order) || 0 < outstandingPaymentAmount(order))\r\n            \"\r\n            (click)=\"addManualPayment(order)\"\r\n        >\r\n            {{ 'order.add-payment-to-order' | translate }}\r\n            ({{ outstandingPaymentAmount(order) | localeCurrency: order.currencyCode }})\r\n        </button>\r\n        <button\r\n            class=\"btn btn-primary\"\r\n            *ngIf=\"\r\n                order.active === false &&\r\n                order.state !== 'ArrangingAdditionalPayment' &&\r\n                order.state !== 'ArrangingPayment' &&\r\n                0 < outstandingPaymentAmount(order)\r\n            \"\r\n            (click)=\"transitionToState('ArrangingAdditionalPayment')\"\r\n        >\r\n            {{ 'order.arrange-additional-payment' | translate }}\r\n        </button>\r\n        <button class=\"btn btn-primary\" (click)=\"fulfillOrder()\" [disabled]=\"!canAddFulfillment(order)\">\r\n            {{ 'order.fulfill-order' | translate }}\r\n        </button>\r\n        <vdr-dropdown>\r\n            <button class=\"icon-button\" vdrDropdownTrigger>\r\n                <clr-icon shape=\"ellipsis-vertical\"></clr-icon>\r\n            </button>\r\n            <vdr-dropdown-menu vdrPosition=\"bottom-right\">\r\n                <ng-container *ngIf=\"order.nextStates.includes('Modifying')\">\r\n                    <button type=\"button\" class=\"btn\" vdrDropdownItem (click)=\"transitionToModifying()\">\r\n                        <clr-icon shape=\"pencil\"></clr-icon>\r\n                        {{ 'order.modify-order' | translate }}\r\n                    </button>\r\n                    <div class=\"dropdown-divider\"></div>\r\n                </ng-container>\r\n                <button\r\n                    type=\"button\"\r\n                    class=\"btn\"\r\n                    vdrDropdownItem\r\n                    *ngIf=\"order.nextStates.includes('Cancelled')\"\r\n                    (click)=\"cancelOrRefund(order)\"\r\n                >\r\n                    <clr-icon shape=\"error-standard\" class=\"is-error\"></clr-icon>\r\n                    <ng-container *ngIf=\"orderHasSettledPayments(order); else cancelOnly\">\r\n                        {{ 'order.refund-and-cancel-order' | translate }}\r\n                    </ng-container>\r\n                    <ng-template #cancelOnly>\r\n                        {{ 'order.cancel-order' | translate }}\r\n                    </ng-template>\r\n                </button>\r\n\r\n                <ng-container *ngIf=\"(nextStates$ | async)?.length\">\r\n                    <div class=\"dropdown-divider\"></div>\r\n                    <button\r\n                        *ngFor=\"let nextState of nextStates$ | async\"\r\n                        type=\"button\"\r\n                        class=\"btn\"\r\n                        vdrDropdownItem\r\n                        (click)=\"transitionToState(nextState)\"\r\n                    >\r\n                        <clr-icon shape=\"step-forward-2\"></clr-icon>\r\n                        {{\r\n                            'order.transition-to-state'\r\n                                | translate: { state: (nextState | stateI18nToken | translate) }\r\n                        }}\r\n                    </button>\r\n                </ng-container>\r\n                <div class=\"dropdown-divider\"></div>\r\n                <button type=\"button\" class=\"btn\" vdrDropdownItem (click)=\"manuallyTransitionToState(order)\">\r\n                    <clr-icon shape=\"step-forward-2\" class=\"is-warning\"></clr-icon>\r\n                    {{ 'order.manually-transition-to-state' | translate }}\r\n                </button>\r\n            </vdr-dropdown-menu>\r\n        </vdr-dropdown>\r\n    </vdr-ab-right>\r\n</vdr-action-bar>\r\n\r\n<div *ngIf=\"entity$ | async as order\">\r\n    <div class=\"clr-row\">\r\n        <div class=\"clr-col-lg-8\">\r\n            <vdr-order-table\r\n                [order]=\"order\"\r\n                [orderLineCustomFields]=\"orderLineCustomFields\"\r\n            ></vdr-order-table>\r\n            <h4>{{ 'order.tax-summary' | translate }}</h4>\r\n            <table class=\"table\">\r\n                <thead>\r\n                    <tr>\r\n                        <th>{{ 'common.description' | translate }}</th>\r\n                        <th>{{ 'order.tax-rate' | translate }}</th>\r\n                        <th>{{ 'order.tax-base' | translate }}</th>\r\n                        <th>{{ 'order.tax-total' | translate }}</th>\r\n                    </tr>\r\n                </thead>\r\n                <tbody>\r\n                    <tr *ngFor=\"let row of order.taxSummary\">\r\n                        <td>{{ row.description }}</td>\r\n                        <td>{{ row.taxRate / 100 | percent }}</td>\r\n                        <td>{{ row.taxBase | localeCurrency: order.currencyCode }}</td>\r\n                        <td>{{ row.taxTotal | localeCurrency: order.currencyCode }}</td>\r\n                    </tr>\r\n                </tbody>\r\n            </table>\r\n\r\n            <vdr-custom-detail-component-host\r\n                locationId=\"order-detail\"\r\n                [entity$]=\"entity$\"\r\n                [detailForm]=\"detailForm\"\r\n            ></vdr-custom-detail-component-host>\r\n\r\n            <vdr-order-history\r\n                [order]=\"order\"\r\n                [history]=\"history$ | async\"\r\n                (addNote)=\"addNote($event)\"\r\n                (updateNote)=\"updateNote($event)\"\r\n                (deleteNote)=\"deleteNote($event)\"\r\n            ></vdr-order-history>\r\n        </div>\r\n        <div class=\"clr-col-lg-4 order-cards\">\r\n            <vdr-order-custom-fields-card\r\n                [customFieldsConfig]=\"customFields\"\r\n                [customFieldValues]=\"order.customFields\"\r\n                (updateClick)=\"updateCustomFields($event)\"\r\n            ></vdr-order-custom-fields-card>\r\n            <div class=\"card\">\r\n                <div class=\"card-header\">\r\n                    {{ 'order.customer' | translate }}\r\n                </div>\r\n                <div class=\"card-block\">\r\n                    <div class=\"card-text\">\r\n                        <vdr-customer-label [customer]=\"order.customer\"></vdr-customer-label>\r\n                        <h6 *ngIf=\"getOrderAddressLines(order.shippingAddress).length\">\r\n                            {{ 'order.shipping-address' | translate }}\r\n                        </h6>\r\n                        <vdr-formatted-address [address]=\"order.shippingAddress\"></vdr-formatted-address>\r\n                        <h6 *ngIf=\"getOrderAddressLines(order.billingAddress).length\">\r\n                            {{ 'order.billing-address' | translate }}\r\n                        </h6>\r\n                        <vdr-formatted-address [address]=\"order.billingAddress\"></vdr-formatted-address>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n            <ng-container *ngIf=\"order.payments && order.payments.length\">\r\n                <vdr-order-payment-card\r\n                    *ngFor=\"let payment of order.payments\"\r\n                    [currencyCode]=\"order.currencyCode\"\r\n                    [payment]=\"payment\"\r\n                    (settlePayment)=\"settlePayment($event)\"\r\n                    (transitionPaymentState)=\"transitionPaymentState($event)\"\r\n                    (settleRefund)=\"settleRefund($event)\"\r\n                ></vdr-order-payment-card>\r\n            </ng-container>\r\n            <ng-container *ngFor=\"let fulfillment of order.fulfillments\">\r\n                <vdr-fulfillment-card\r\n                    [fulfillment]=\"fulfillment\"\r\n                    [order]=\"order\"\r\n                    (transitionState)=\"transitionFulfillment(fulfillment.id, $event)\"\r\n                ></vdr-fulfillment-card>\r\n            </ng-container>\r\n        </div>\r\n    </div>\r\n</div>\r\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [".shipping-address{list-style-type:none;line-height:1.3em}.order-cards h6{margin-top:6px;color:var(--color-text-200)}\n"]
+            },] }
+];
+OrderDetailComponent.ctorParameters = () => [
+    { type: Router },
+    { type: ActivatedRoute },
+    { type: ServerConfigService },
+    { type: ChangeDetectorRef },
+    { type: DataService },
+    { type: NotificationService },
+    { type: ModalService },
+    { type: OrderTransitionService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"order-detail.component.js","sourceRoot":"","sources":["../../../../../src/lib/order/src/components/order-detail/order-detail.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, OnDestroy, OnInit } from '@angular/core';\r\nimport { FormGroup } from '@angular/forms';\r\nimport { ActivatedRoute, Router } from '@angular/router';\r\nimport { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';\r\nimport {\r\n    BaseDetailComponent,\r\n    CancelOrder,\r\n    CustomFieldConfig,\r\n    DataService,\r\n    EditNoteDialogComponent,\r\n    FulfillmentFragment,\r\n    FulfillmentLineSummary,\r\n    GetOrderHistory,\r\n    GetOrderQuery,\r\n    HistoryEntry,\r\n    HistoryEntryType,\r\n    ModalService,\r\n    NotificationService,\r\n    Order,\r\n    OrderDetail,\r\n    OrderDetailFragment,\r\n    OrderLineFragment,\r\n    Refund,\r\n    RefundOrder,\r\n    ServerConfigService,\r\n    SortOrder,\r\n} from '@vendure/admin-ui/core';\r\nimport { pick } from '@vendure/common/lib/pick';\r\nimport { assertNever, summate } from '@vendure/common/lib/shared-utils';\r\nimport { EMPTY, merge, Observable, of, Subject } from 'rxjs';\r\nimport { map, mapTo, startWith, switchMap, take } from 'rxjs/operators';\r\n\r\nimport { OrderTransitionService } from '../../providers/order-transition.service';\r\nimport { AddManualPaymentDialogComponent } from '../add-manual-payment-dialog/add-manual-payment-dialog.component';\r\nimport { CancelOrderDialogComponent } from '../cancel-order-dialog/cancel-order-dialog.component';\r\nimport { FulfillOrderDialogComponent } from '../fulfill-order-dialog/fulfill-order-dialog.component';\r\nimport { OrderProcessGraphDialogComponent } from '../order-process-graph-dialog/order-process-graph-dialog.component';\r\nimport { RefundOrderDialogComponent } from '../refund-order-dialog/refund-order-dialog.component';\r\nimport { SettleRefundDialogComponent } from '../settle-refund-dialog/settle-refund-dialog.component';\r\n\r\n@Component({\r\n    selector: 'vdr-order-detail',\r\n    templateUrl: './order-detail.component.html',\r\n    styleUrls: ['./order-detail.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class OrderDetailComponent\r\n    extends BaseDetailComponent<OrderDetail.Fragment>\r\n    implements OnInit, OnDestroy\r\n{\r\n    detailForm = new FormGroup({});\r\n    history$: Observable<GetOrderHistory.Items[] | undefined>;\r\n    nextStates$: Observable<string[]>;\r\n    fetchHistory = new Subject<void>();\r\n    customFields: CustomFieldConfig[];\r\n    orderLineCustomFields: CustomFieldConfig[];\r\n    private readonly defaultStates = [\r\n        'AddingItems',\r\n        'ArrangingPayment',\r\n        'PaymentAuthorized',\r\n        'PaymentSettled',\r\n        'PartiallyShipped',\r\n        'Shipped',\r\n        'PartiallyDelivered',\r\n        'Delivered',\r\n        'Cancelled',\r\n        'Modifying',\r\n        'ArrangingAdditionalPayment',\r\n    ];\r\n\r\n    constructor(\r\n        router: Router,\r\n        route: ActivatedRoute,\r\n        serverConfigService: ServerConfigService,\r\n        private changeDetector: ChangeDetectorRef,\r\n        protected dataService: DataService,\r\n        private notificationService: NotificationService,\r\n        private modalService: ModalService,\r\n        private orderTransitionService: OrderTransitionService,\r\n    ) {\r\n        super(route, router, serverConfigService, dataService);\r\n    }\r\n\r\n    ngOnInit() {\r\n        this.init();\r\n        this.entity$.pipe(take(1)).subscribe(order => {\r\n            if (order.state === 'Modifying') {\r\n                this.router.navigate(['./', 'modify'], { relativeTo: this.route });\r\n            }\r\n        });\r\n        this.customFields = this.getCustomFieldConfig('Order');\r\n        this.orderLineCustomFields = this.getCustomFieldConfig('OrderLine');\r\n        this.history$ = this.fetchHistory.pipe(\r\n            startWith(null),\r\n            switchMap(() => {\r\n                return this.dataService.order\r\n                    .getOrderHistory(this.id, {\r\n                        sort: {\r\n                            createdAt: SortOrder.DESC,\r\n                        },\r\n                    })\r\n                    .mapStream(data => data.order?.history.items);\r\n            }),\r\n        );\r\n        this.nextStates$ = this.entity$.pipe(\r\n            map(order => {\r\n                const isInCustomState = !this.defaultStates.includes(order.state);\r\n                return isInCustomState\r\n                    ? order.nextStates\r\n                    : order.nextStates.filter(s => !this.defaultStates.includes(s));\r\n            }),\r\n        );\r\n    }\r\n\r\n    ngOnDestroy() {\r\n        this.destroy();\r\n    }\r\n\r\n    openStateDiagram() {\r\n        this.entity$\r\n            .pipe(\r\n                take(1),\r\n                switchMap(order =>\r\n                    this.modalService.fromComponent(OrderProcessGraphDialogComponent, {\r\n                        closable: true,\r\n                        locals: {\r\n                            activeState: order.state,\r\n                        },\r\n                    }),\r\n                ),\r\n            )\r\n            .subscribe();\r\n    }\r\n\r\n    transitionToState(state: string) {\r\n        this.dataService.order.transitionToState(this.id, state).subscribe(({ transitionOrderToState }) => {\r\n            switch (transitionOrderToState?.__typename) {\r\n                case 'Order':\r\n                    this.notificationService.success(_('order.transitioned-to-state-success'), { state });\r\n                    this.fetchHistory.next();\r\n                    break;\r\n                case 'OrderStateTransitionError':\r\n                    this.notificationService.error(transitionOrderToState.transitionError);\r\n            }\r\n        });\r\n    }\r\n\r\n    manuallyTransitionToState(order: OrderDetailFragment) {\r\n        this.orderTransitionService\r\n            .manuallyTransitionToState({\r\n                orderId: order.id,\r\n                nextStates: order.nextStates,\r\n                cancellable: true,\r\n                message: _('order.manually-transition-to-state-message'),\r\n                retry: 0,\r\n            })\r\n            .subscribe();\r\n    }\r\n\r\n    transitionToModifying() {\r\n        this.dataService.order\r\n            .transitionToState(this.id, 'Modifying')\r\n            .subscribe(({ transitionOrderToState }) => {\r\n                switch (transitionOrderToState?.__typename) {\r\n                    case 'Order':\r\n                        this.router.navigate(['./modify'], { relativeTo: this.route });\r\n                        break;\r\n                    case 'OrderStateTransitionError':\r\n                        this.notificationService.error(transitionOrderToState.transitionError);\r\n                }\r\n            });\r\n    }\r\n\r\n    updateCustomFields(customFieldsValue: any) {\r\n        this.dataService.order\r\n            .updateOrderCustomFields({\r\n                id: this.id,\r\n                customFields: customFieldsValue,\r\n            })\r\n            .subscribe(() => {\r\n                this.notificationService.success(_('common.notify-update-success'), { entity: 'Order' });\r\n            });\r\n    }\r\n\r\n    getOrderAddressLines(orderAddress?: { [key: string]: string }): string[] {\r\n        if (!orderAddress) {\r\n            return [];\r\n        }\r\n        return Object.values(orderAddress)\r\n            .filter(val => val !== 'OrderAddress')\r\n            .filter(line => !!line);\r\n    }\r\n\r\n    settlePayment(payment: OrderDetail.Payments) {\r\n        this.dataService.order.settlePayment(payment.id).subscribe(({ settlePayment }) => {\r\n            switch (settlePayment.__typename) {\r\n                case 'Payment':\r\n                    if (settlePayment.state === 'Settled') {\r\n                        this.notificationService.success(_('order.settle-payment-success'));\r\n                    } else {\r\n                        this.notificationService.error(_('order.settle-payment-error'));\r\n                    }\r\n                    this.dataService.order.getOrder(this.id).single$.subscribe();\r\n                    this.fetchHistory.next();\r\n                    break;\r\n                case 'OrderStateTransitionError':\r\n                case 'PaymentStateTransitionError':\r\n                case 'SettlePaymentError':\r\n                    this.notificationService.error(settlePayment.message);\r\n            }\r\n        });\r\n    }\r\n\r\n    transitionPaymentState({ payment, state }: { payment: OrderDetail.Payments; state: string }) {\r\n        if (state === 'Cancelled') {\r\n            this.dataService.order.cancelPayment(payment.id).subscribe(({ cancelPayment }) => {\r\n                switch (cancelPayment.__typename) {\r\n                    case 'Payment':\r\n                        this.notificationService.success(_('order.transitioned-payment-to-state-success'), {\r\n                            state,\r\n                        });\r\n                        this.dataService.order.getOrder(this.id).single$.subscribe();\r\n                        this.fetchHistory.next();\r\n                        break;\r\n                    case 'PaymentStateTransitionError':\r\n                        this.notificationService.error(cancelPayment.transitionError);\r\n                        break;\r\n                    case 'CancelPaymentError':\r\n                        this.notificationService.error(cancelPayment.paymentErrorMessage);\r\n                        break;\r\n                }\r\n            });\r\n        } else {\r\n            this.dataService.order\r\n                .transitionPaymentToState(payment.id, state)\r\n                .subscribe(({ transitionPaymentToState }) => {\r\n                    switch (transitionPaymentToState.__typename) {\r\n                        case 'Payment':\r\n                            this.notificationService.success(\r\n                                _('order.transitioned-payment-to-state-success'),\r\n                                {\r\n                                    state,\r\n                                },\r\n                            );\r\n                            this.dataService.order.getOrder(this.id).single$.subscribe();\r\n                            this.fetchHistory.next();\r\n                            break;\r\n                        case 'PaymentStateTransitionError':\r\n                            this.notificationService.error(transitionPaymentToState.message);\r\n                            break;\r\n                    }\r\n                });\r\n        }\r\n    }\r\n\r\n    canAddFulfillment(order: OrderDetail.Fragment): boolean {\r\n        const allFulfillmentSummaryRows: FulfillmentFragment['summary'] = (order.fulfillments ?? []).reduce(\r\n            (all, fulfillment) => [...all, ...fulfillment.summary],\r\n            [] as FulfillmentFragment['summary'],\r\n        );\r\n        let allItemsFulfilled = true;\r\n        for (const line of order.lines) {\r\n            const totalFulfilledCount = allFulfillmentSummaryRows\r\n                .filter(row => row.orderLine.id === line.id)\r\n                .reduce((sum, row) => sum + row.quantity, 0);\r\n            if (totalFulfilledCount < line.quantity) {\r\n                allItemsFulfilled = false;\r\n            }\r\n        }\r\n        return (\r\n            !allItemsFulfilled &&\r\n            !this.hasUnsettledModifications(order) &&\r\n            this.outstandingPaymentAmount(order) === 0 &&\r\n            (order.nextStates.includes('Shipped') ||\r\n                order.nextStates.includes('PartiallyShipped') ||\r\n                order.nextStates.includes('Delivered'))\r\n        );\r\n    }\r\n\r\n    hasUnsettledModifications(order: OrderDetailFragment): boolean {\r\n        return 0 < order.modifications.filter(m => !m.isSettled).length;\r\n    }\r\n\r\n    getOutstandingModificationAmount(order: OrderDetailFragment): number {\r\n        return summate(\r\n            order.modifications.filter(m => !m.isSettled),\r\n            'priceChange',\r\n        );\r\n    }\r\n\r\n    outstandingPaymentAmount(order: OrderDetailFragment): number {\r\n        const paymentIsValid = (p: OrderDetail.Payments): boolean =>\r\n            p.state !== 'Cancelled' && p.state !== 'Declined' && p.state !== 'Error';\r\n\r\n        let amountCovered = 0;\r\n        for (const payment of order.payments?.filter(paymentIsValid) ?? []) {\r\n            const refunds = payment.refunds.filter(r => r.state !== 'Failed') ?? [];\r\n            const refundsTotal = summate(refunds as Array<Required<Refund>>, 'total');\r\n            amountCovered += payment.amount - refundsTotal;\r\n        }\r\n        return order.totalWithTax - amountCovered;\r\n    }\r\n\r\n    addManualPayment(order: OrderDetailFragment) {\r\n        const priorState = order.state;\r\n        this.modalService\r\n            .fromComponent(AddManualPaymentDialogComponent, {\r\n                closable: true,\r\n                locals: {\r\n                    outstandingAmount: this.outstandingPaymentAmount(order),\r\n                    currencyCode: order.currencyCode,\r\n                },\r\n            })\r\n            .pipe(\r\n                switchMap(result => {\r\n                    if (result) {\r\n                        return this.dataService.order.addManualPaymentToOrder({\r\n                            orderId: this.id,\r\n                            transactionId: result.transactionId,\r\n                            method: result.method,\r\n                            metadata: result.metadata || {},\r\n                        });\r\n                    } else {\r\n                        return EMPTY;\r\n                    }\r\n                }),\r\n                switchMap(({ addManualPaymentToOrder }) => {\r\n                    switch (addManualPaymentToOrder.__typename) {\r\n                        case 'Order':\r\n                            this.notificationService.success(_('order.add-payment-to-order-success'));\r\n                            if (priorState === 'ArrangingAdditionalPayment') {\r\n                                return this.orderTransitionService.transitionToPreModifyingState(\r\n                                    order.id,\r\n                                    order.nextStates,\r\n                                );\r\n                            } else {\r\n                                return this.dataService.order\r\n                                    .transitionToState(this.id, 'PaymentSettled')\r\n                                    .pipe(mapTo('PaymentSettled'));\r\n                            }\r\n                        case 'ManualPaymentStateError':\r\n                            this.notificationService.error(addManualPaymentToOrder.message);\r\n                            return EMPTY;\r\n                        default:\r\n                            return EMPTY;\r\n                    }\r\n                }),\r\n            )\r\n            .subscribe(result => {\r\n                if (result) {\r\n                    this.refetchOrder({ result });\r\n                }\r\n            });\r\n    }\r\n\r\n    fulfillOrder() {\r\n        this.entity$\r\n            .pipe(\r\n                take(1),\r\n                switchMap(order => {\r\n                    return this.modalService.fromComponent(FulfillOrderDialogComponent, {\r\n                        size: 'xl',\r\n                        locals: {\r\n                            order,\r\n                        },\r\n                    });\r\n                }),\r\n                switchMap(input => {\r\n                    if (input) {\r\n                        return this.dataService.order.createFulfillment(input);\r\n                    } else {\r\n                        return of(undefined);\r\n                    }\r\n                }),\r\n                switchMap(result => this.refetchOrder(result).pipe(mapTo(result))),\r\n            )\r\n            .subscribe(result => {\r\n                if (result) {\r\n                    const { addFulfillmentToOrder } = result;\r\n                    switch (addFulfillmentToOrder.__typename) {\r\n                        case 'Fulfillment':\r\n                            this.notificationService.success(_('order.create-fulfillment-success'));\r\n                            break;\r\n                        case 'EmptyOrderLineSelectionError':\r\n                        case 'InsufficientStockOnHandError':\r\n                        case 'ItemsAlreadyFulfilledError':\r\n                        case 'InvalidFulfillmentHandlerError':\r\n                            this.notificationService.error(addFulfillmentToOrder.message);\r\n                            break;\r\n                        case 'FulfillmentStateTransitionError':\r\n                            this.notificationService.error(addFulfillmentToOrder.transitionError);\r\n                            break;\r\n                        case 'CreateFulfillmentError':\r\n                            this.notificationService.error(addFulfillmentToOrder.fulfillmentHandlerError);\r\n                            break;\r\n                        case undefined:\r\n                            this.notificationService.error(JSON.stringify(addFulfillmentToOrder));\r\n                            break;\r\n                        default:\r\n                            assertNever(addFulfillmentToOrder);\r\n                    }\r\n                }\r\n            });\r\n    }\r\n\r\n    transitionFulfillment(id: string, state: string) {\r\n        this.dataService.order\r\n            .transitionFulfillmentToState(id, state)\r\n            .pipe(switchMap(result => this.refetchOrder(result)))\r\n            .subscribe(() => {\r\n                this.notificationService.success(_('order.successfully-updated-fulfillment'));\r\n            });\r\n    }\r\n\r\n    cancelOrRefund(order: OrderDetail.Fragment) {\r\n        const isRefundable = this.orderHasSettledPayments(order);\r\n        if (order.state === 'PaymentAuthorized' || order.active === true || !isRefundable) {\r\n            this.cancelOrder(order);\r\n        } else {\r\n            this.refundOrder(order);\r\n        }\r\n    }\r\n\r\n    settleRefund(refund: OrderDetail.Refunds) {\r\n        this.modalService\r\n            .fromComponent(SettleRefundDialogComponent, {\r\n                size: 'md',\r\n                locals: {\r\n                    refund,\r\n                },\r\n            })\r\n            .pipe(\r\n                switchMap(transactionId => {\r\n                    if (transactionId) {\r\n                        return this.dataService.order.settleRefund(\r\n                            {\r\n                                transactionId,\r\n                                id: refund.id,\r\n                            },\r\n                            this.id,\r\n                        );\r\n                    } else {\r\n                        return of(undefined);\r\n                    }\r\n                }),\r\n                // switchMap(result => this.refetchOrder(result)),\r\n            )\r\n            .subscribe(result => {\r\n                if (result) {\r\n                    this.notificationService.success(_('order.settle-refund-success'));\r\n                }\r\n            });\r\n    }\r\n\r\n    addNote(event: { note: string; isPublic: boolean }) {\r\n        const { note, isPublic } = event;\r\n        this.dataService.order\r\n            .addNoteToOrder({\r\n                id: this.id,\r\n                note,\r\n                isPublic,\r\n            })\r\n            .pipe(switchMap(result => this.refetchOrder(result)))\r\n            .subscribe(result => {\r\n                this.notificationService.success(_('common.notify-create-success'), {\r\n                    entity: 'Note',\r\n                });\r\n            });\r\n    }\r\n\r\n    updateNote(entry: HistoryEntry) {\r\n        this.modalService\r\n            .fromComponent(EditNoteDialogComponent, {\r\n                closable: true,\r\n                locals: {\r\n                    displayPrivacyControls: true,\r\n                    note: entry.data.note,\r\n                    noteIsPrivate: !entry.isPublic,\r\n                },\r\n            })\r\n            .pipe(\r\n                switchMap(result => {\r\n                    if (result) {\r\n                        return this.dataService.order.updateOrderNote({\r\n                            noteId: entry.id,\r\n                            isPublic: !result.isPrivate,\r\n                            note: result.note,\r\n                        });\r\n                    } else {\r\n                        return EMPTY;\r\n                    }\r\n                }),\r\n            )\r\n            .subscribe(result => {\r\n                this.fetchHistory.next();\r\n                this.notificationService.success(_('common.notify-update-success'), {\r\n                    entity: 'Note',\r\n                });\r\n            });\r\n    }\r\n\r\n    deleteNote(entry: HistoryEntry) {\r\n        return this.modalService\r\n            .dialog({\r\n                title: _('common.confirm-delete-note'),\r\n                body: entry.data.note,\r\n                buttons: [\r\n                    { type: 'secondary', label: _('common.cancel') },\r\n                    { type: 'danger', label: _('common.delete'), returnValue: true },\r\n                ],\r\n            })\r\n            .pipe(switchMap(res => (res ? this.dataService.order.deleteOrderNote(entry.id) : EMPTY)))\r\n            .subscribe(() => {\r\n                this.fetchHistory.next();\r\n                this.notificationService.success(_('common.notify-delete-success'), {\r\n                    entity: 'Note',\r\n                });\r\n            });\r\n    }\r\n\r\n    orderHasSettledPayments(order: OrderDetail.Fragment): boolean {\r\n        return !!order.payments?.find(p => p.state === 'Settled');\r\n    }\r\n\r\n    private cancelOrder(order: OrderDetail.Fragment) {\r\n        this.modalService\r\n            .fromComponent(CancelOrderDialogComponent, {\r\n                size: 'xl',\r\n                locals: {\r\n                    order,\r\n                },\r\n            })\r\n            .pipe(\r\n                switchMap(input => {\r\n                    if (input) {\r\n                        return this.dataService.order.cancelOrder(input);\r\n                    } else {\r\n                        return of(undefined);\r\n                    }\r\n                }),\r\n                switchMap(result => this.refetchOrder(result)),\r\n            )\r\n            .subscribe(result => {\r\n                if (result) {\r\n                    this.notificationService.success(_('order.cancelled-order-success'));\r\n                }\r\n            });\r\n    }\r\n\r\n    private refundOrder(order: OrderDetail.Fragment) {\r\n        this.modalService\r\n            .fromComponent(RefundOrderDialogComponent, {\r\n                size: 'xl',\r\n                locals: {\r\n                    order,\r\n                },\r\n            })\r\n            .pipe(\r\n                switchMap(input => {\r\n                    if (!input) {\r\n                        return of(undefined);\r\n                    }\r\n\r\n                    if (input.cancel.lines?.length) {\r\n                        return this.dataService.order.cancelOrder(input.cancel).pipe(\r\n                            map(res => {\r\n                                const result = res.cancelOrder;\r\n                                switch (result.__typename) {\r\n                                    case 'Order':\r\n                                        this.refetchOrder(result).subscribe();\r\n                                        this.notificationService.success(_('order.cancelled-order-success'));\r\n                                        return input;\r\n                                    case 'CancelActiveOrderError':\r\n                                    case 'QuantityTooGreatError':\r\n                                    case 'MultipleOrderError':\r\n                                    case 'OrderStateTransitionError':\r\n                                    case 'EmptyOrderLineSelectionError':\r\n                                        this.notificationService.error(result.message);\r\n                                        return undefined;\r\n                                }\r\n                            }),\r\n                        );\r\n                    } else {\r\n                        return [input];\r\n                    }\r\n                }),\r\n                switchMap(input => {\r\n                    if (!input) {\r\n                        return of(undefined);\r\n                    }\r\n                    if (input.refund.lines.length) {\r\n                        return this.dataService.order\r\n                            .refundOrder(input.refund)\r\n                            .pipe(map(res => res.refundOrder));\r\n                    } else {\r\n                        return [undefined];\r\n                    }\r\n                }),\r\n            )\r\n            .subscribe(result => {\r\n                if (result) {\r\n                    switch (result.__typename) {\r\n                        case 'Refund':\r\n                            this.refetchOrder(result).subscribe();\r\n                            if (result.state === 'Failed') {\r\n                                this.notificationService.error(_('order.refund-order-failed'));\r\n                            } else {\r\n                                this.notificationService.success(_('order.refund-order-success'));\r\n                            }\r\n                            break;\r\n                        case 'AlreadyRefundedError':\r\n                        case 'NothingToRefundError':\r\n                        case 'PaymentOrderMismatchError':\r\n                        case 'RefundOrderStateError':\r\n                        case 'RefundStateTransitionError':\r\n                            this.notificationService.error(result.message);\r\n                            break;\r\n                    }\r\n                }\r\n            });\r\n    }\r\n\r\n    private refetchOrder(result: object | undefined): Observable<GetOrderQuery | undefined> {\r\n        this.fetchHistory.next();\r\n        if (result) {\r\n            return this.dataService.order.getOrder(this.id).single$;\r\n        } else {\r\n            return of(undefined);\r\n        }\r\n    }\r\n\r\n    protected setFormValues(entity: Order.Fragment): void {\r\n        // empty\r\n    }\r\n}\r\n"]}