@vendure/admin-ui 1.5.0 → 2.0.0-next.2

package/esm2020/core/data/providers/facet-data.service.mjs

@@ -0,0 +1,60 @@
+import { pick } from '@vendure/common/lib/pick';
+import { CREATE_FACET, CREATE_FACET_VALUES, DELETE_FACET, DELETE_FACET_VALUES, GET_FACET_LIST, GET_FACET_WITH_VALUES, UPDATE_FACET, UPDATE_FACET_VALUES, } from '../definitions/facet-definitions';
+export class FacetDataService {
+    constructor(baseDataService) {
+        this.baseDataService = baseDataService;
+    }
+    getFacets(take = 10, skip = 0) {
+        return this.baseDataService.query(GET_FACET_LIST, {
+            options: {
+                take,
+                skip,
+            },
+        });
+    }
+    getAllFacets() {
+        return this.baseDataService.query(GET_FACET_LIST, {});
+    }
+    getFacet(id) {
+        return this.baseDataService.query(GET_FACET_WITH_VALUES, {
+            id,
+        });
+    }
+    createFacet(facet) {
+        const input = {
+            input: pick(facet, ['code', 'isPrivate', 'translations', 'values', 'customFields']),
+        };
+        return this.baseDataService.mutate(CREATE_FACET, input);
+    }
+    updateFacet(facet) {
+        const input = {
+            input: pick(facet, ['id', 'code', 'isPrivate', 'translations', 'customFields']),
+        };
+        return this.baseDataService.mutate(UPDATE_FACET, input);
+    }
+    deleteFacet(id, force) {
+        return this.baseDataService.mutate(DELETE_FACET, {
+            id,
+            force,
+        });
+    }
+    createFacetValues(facetValues) {
+        const input = {
+            input: facetValues.map(pick(['facetId', 'code', 'translations', 'customFields'])),
+        };
+        return this.baseDataService.mutate(CREATE_FACET_VALUES, input);
+    }
+    updateFacetValues(facetValues) {
+        const input = {
+            input: facetValues.map(pick(['id', 'code', 'translations', 'customFields'])),
+        };
+        return this.baseDataService.mutate(UPDATE_FACET_VALUES, input);
+    }
+    deleteFacetValues(ids, force) {
+        return this.baseDataService.mutate(DELETE_FACET_VALUES, {
+            ids,
+            force,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/data/providers/fetch-adapter.mjs

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import { lastValueFrom } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * An adapter that allows the Angular HttpClient to be used as a replacement for the global `fetch` function.
+ * This is used to supply a custom fetch function to the apollo-upload-client whilst also allowing the
+ * use of Angular's http infrastructure such as interceptors.
+ */
+export class FetchAdapter {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.fetch = (input, init) => {
+            const url = typeof input === 'string' ? input : input.url;
+            const method = typeof input === 'string' ? (init.method ? init.method : 'GET') : input.method;
+            return lastValueFrom(this.httpClient.request(method, url, {
+                body: init.body,
+                headers: init.headers,
+                observe: 'response',
+                responseType: 'json',
+                withCredentials: true,
+            })).then(result => {
+                return new Response(JSON.stringify(result.body), {
+                    status: result.status,
+                    statusText: result.statusText,
+                });
+            });
+        };
+    }
+}
+FetchAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: FetchAdapter, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+FetchAdapter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: FetchAdapter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: FetchAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/data/providers/interceptor.mjs

@@ -0,0 +1,136 @@
+import { HttpErrorResponse, HttpResponse, } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';
+import { DEFAULT_AUTH_TOKEN_HEADER_KEY } from '@vendure/common/lib/shared-constants';
+import { switchMap, tap } from 'rxjs/operators';
+import { getAppConfig } from '../../app.config';
+import { NotificationService } from '../../providers/notification/notification.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../providers/data.service";
+import * as i2 from "../../providers/auth/auth.service";
+import * as i3 from "@angular/router";
+import * as i4 from "../../providers/local-storage/local-storage.service";
+export const AUTH_REDIRECT_PARAM = 'redirectTo';
+/**
+ * The default interceptor examines all HTTP requests & responses and automatically updates the requesting state
+ * and shows error notifications.
+ */
+export class DefaultInterceptor {
+    constructor(dataService, injector, authService, router, localStorageService) {
+        this.dataService = dataService;
+        this.injector = injector;
+        this.authService = authService;
+        this.router = router;
+        this.localStorageService = localStorageService;
+        this.tokenMethod = 'cookie';
+        this.tokenMethod = getAppConfig().tokenMethod;
+        this.authTokenHeaderKey = getAppConfig().authTokenHeaderKey || DEFAULT_AUTH_TOKEN_HEADER_KEY;
+    }
+    intercept(req, next) {
+        this.dataService.client.startRequest().subscribe();
+        return this.dataService.client.uiState().single$.pipe(switchMap(({ uiState }) => {
+            const request = req.clone({
+                setParams: {
+                    languageCode: uiState?.contentLanguage ?? '',
+                },
+            });
+            return next.handle(request);
+        }), tap(event => {
+            if (event instanceof HttpResponse) {
+                this.checkForAuthToken(event);
+                this.notifyOnError(event);
+                this.dataService.client.completeRequest().subscribe();
+            }
+        }, err => {
+            if (err instanceof HttpErrorResponse) {
+                this.notifyOnError(err);
+                this.dataService.client.completeRequest().subscribe();
+            }
+            else {
+                this.displayErrorNotification(err.message);
+            }
+        }));
+    }
+    notifyOnError(response) {
+        if (response instanceof HttpErrorResponse) {
+            if (response.status === 0) {
+                const { apiHost, apiPort } = getAppConfig();
+                this.displayErrorNotification(_(`error.could-not-connect-to-server`), {
+                    url: `${apiHost}:${apiPort}`,
+                });
+            }
+            else if (response.status === 503 && response.url?.endsWith('/health')) {
+                this.displayErrorNotification(_(`error.health-check-failed`));
+            }
+            else {
+                this.displayErrorNotification(this.extractErrorFromHttpResponse(response));
+            }
+        }
+        else {
+            // GraphQL errors still return 200 OK responses, but have the actual error message
+            // inside the body of the response.
+            const graqhQLErrors = response.body.errors;
+            if (graqhQLErrors && Array.isArray(graqhQLErrors)) {
+                const firstCode = graqhQLErrors[0]?.extensions?.code;
+                if (firstCode === 'FORBIDDEN') {
+                    this.authService.logOut().subscribe(() => {
+                        if (!window.location.pathname.includes('login')) {
+                            const path = graqhQLErrors[0].path.join(' > ');
+                            this.displayErrorNotification(_(`error.403-forbidden`), { path });
+                        }
+                        this.router.navigate(['/login'], {
+                            queryParams: {
+                                [AUTH_REDIRECT_PARAM]: btoa(this.router.url),
+                            },
+                        });
+                    });
+                }
+                else if (firstCode === 'CHANNEL_NOT_FOUND') {
+                    const message = graqhQLErrors.map(err => err.message).join('\n');
+                    this.displayErrorNotification(message);
+                    this.localStorageService.remove('activeChannelToken');
+                }
+                else {
+                    const message = graqhQLErrors.map(err => err.message).join('\n');
+                    this.displayErrorNotification(message);
+                }
+            }
+        }
+    }
+    extractErrorFromHttpResponse(response) {
+        const errors = response.error.errors;
+        if (Array.isArray(errors)) {
+            return errors.map(e => e.message).join('\n');
+        }
+        else {
+            return response.message;
+        }
+    }
+    /**
+     * We need to lazily inject the NotificationService since it depends on the I18nService which
+     * eventually depends on the HttpClient (used to load messages from json files). If we were to
+     * directly inject NotificationService into the constructor, we get a cyclic dependency.
+     */
+    displayErrorNotification(message, vars) {
+        const notificationService = this.injector.get(NotificationService);
+        notificationService.error(message, vars);
+    }
+    /**
+     * If the server is configured to use the "bearer" tokenMethod, each response should be checked
+     * for the existence of an auth token.
+     */
+    checkForAuthToken(response) {
+        if (this.tokenMethod === 'bearer') {
+            const authToken = response.headers.get(this.authTokenHeaderKey);
+            if (authToken) {
+                this.localStorageService.set('authToken', authToken);
+            }
+        }
+    }
+}
+DefaultInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DefaultInterceptor, deps: [{ token: i1.DataService }, { token: i0.Injector }, { token: i2.AuthService }, { token: i3.Router }, { token: i4.LocalStorageService }], target: i0.ɵɵFactoryTarget.Injectable });
+DefaultInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DefaultInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DefaultInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DataService }, { type: i0.Injector }, { type: i2.AuthService }, { type: i3.Router }, { type: i4.LocalStorageService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/providers/interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    HttpErrorResponse,\n    HttpEvent,\n    HttpHandler,\n    HttpInterceptor,\n    HttpRequest,\n    HttpResponse,\n} from '@angular/common/http';\nimport { Injectable, Injector } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';\nimport { DEFAULT_AUTH_TOKEN_HEADER_KEY } from '@vendure/common/lib/shared-constants';\nimport { AdminUiConfig } from '@vendure/common/lib/shared-types';\nimport { Observable } from 'rxjs';\nimport { switchMap, tap } from 'rxjs/operators';\n\nimport { getAppConfig } from '../../app.config';\nimport { AuthService } from '../../providers/auth/auth.service';\nimport { LocalStorageService } from '../../providers/local-storage/local-storage.service';\nimport { NotificationService } from '../../providers/notification/notification.service';\nimport { DataService } from '../providers/data.service';\n\nexport const AUTH_REDIRECT_PARAM = 'redirectTo';\n\n/**\n * The default interceptor examines all HTTP requests & responses and automatically updates the requesting state\n * and shows error notifications.\n */\n@Injectable()\nexport class DefaultInterceptor implements HttpInterceptor {\n    private readonly tokenMethod: AdminUiConfig['tokenMethod'] = 'cookie';\n    private readonly authTokenHeaderKey: string;\n\n    constructor(\n        private dataService: DataService,\n        private injector: Injector,\n        private authService: AuthService,\n        private router: Router,\n        private localStorageService: LocalStorageService,\n    ) {\n        this.tokenMethod = getAppConfig().tokenMethod;\n        this.authTokenHeaderKey = getAppConfig().authTokenHeaderKey || DEFAULT_AUTH_TOKEN_HEADER_KEY;\n    }\n\n    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n        this.dataService.client.startRequest().subscribe();\n        return this.dataService.client.uiState().single$.pipe(\n            switchMap(({ uiState }) => {\n                const request = req.clone({\n                    setParams: {\n                        languageCode: uiState?.contentLanguage ?? '',\n                    },\n                });\n                return next.handle(request);\n            }),\n            tap(\n                event => {\n                    if (event instanceof HttpResponse) {\n                        this.checkForAuthToken(event);\n                        this.notifyOnError(event);\n                        this.dataService.client.completeRequest().subscribe();\n                    }\n                },\n                err => {\n                    if (err instanceof HttpErrorResponse) {\n                        this.notifyOnError(err);\n                        this.dataService.client.completeRequest().subscribe();\n                    } else {\n                        this.displayErrorNotification(err.message);\n                    }\n                },\n            ),\n        );\n    }\n\n    private notifyOnError(response: HttpResponse<any> | HttpErrorResponse) {\n        if (response instanceof HttpErrorResponse) {\n            if (response.status === 0) {\n                const { apiHost, apiPort } = getAppConfig();\n                this.displayErrorNotification(_(`error.could-not-connect-to-server`), {\n                    url: `${apiHost}:${apiPort}`,\n                });\n            } else if (response.status === 503 && response.url?.endsWith('/health')) {\n                this.displayErrorNotification(_(`error.health-check-failed`));\n            } else {\n                this.displayErrorNotification(this.extractErrorFromHttpResponse(response));\n            }\n        } else {\n            // GraphQL errors still return 200 OK responses, but have the actual error message\n            // inside the body of the response.\n            const graqhQLErrors = response.body.errors;\n            if (graqhQLErrors && Array.isArray(graqhQLErrors)) {\n                const firstCode: string = graqhQLErrors[0]?.extensions?.code;\n                if (firstCode === 'FORBIDDEN') {\n                    this.authService.logOut().subscribe(() => {\n                        if (!window.location.pathname.includes('login')) {\n                            const path = graqhQLErrors[0].path.join(' > ');\n                            this.displayErrorNotification(_(`error.403-forbidden`), { path });\n                        }\n                        this.router.navigate(['/login'], {\n                            queryParams: {\n                                [AUTH_REDIRECT_PARAM]: btoa(this.router.url),\n                            },\n                        });\n                    });\n                } else if (firstCode === 'CHANNEL_NOT_FOUND') {\n                    const message = graqhQLErrors.map(err => err.message).join('\\n');\n                    this.displayErrorNotification(message);\n                    this.localStorageService.remove('activeChannelToken');\n                } else {\n                    const message = graqhQLErrors.map(err => err.message).join('\\n');\n                    this.displayErrorNotification(message);\n                }\n            }\n        }\n    }\n\n    private extractErrorFromHttpResponse(response: HttpErrorResponse): string {\n        const errors = response.error.errors;\n        if (Array.isArray(errors)) {\n            return errors.map(e => e.message).join('\\n');\n        } else {\n            return response.message;\n        }\n    }\n\n    /**\n     * We need to lazily inject the NotificationService since it depends on the I18nService which\n     * eventually depends on the HttpClient (used to load messages from json files). If we were to\n     * directly inject NotificationService into the constructor, we get a cyclic dependency.\n     */\n    private displayErrorNotification(message: string, vars?: Record<string, any>): void {\n        const notificationService = this.injector.get<NotificationService>(NotificationService);\n        notificationService.error(message, vars);\n    }\n\n    /**\n     * If the server is configured to use the \"bearer\" tokenMethod, each response should be checked\n     * for the existence of an auth token.\n     */\n    private checkForAuthToken(response: HttpResponse<any>) {\n        if (this.tokenMethod === 'bearer') {\n            const authToken = response.headers.get(this.authTokenHeaderKey);\n            if (authToken) {\n                this.localStorageService.set('authToken', authToken);\n            }\n        }\n    }\n}\n"]}

package/esm2020/core/data/providers/order-data.service.mjs

@@ -0,0 +1,100 @@
+import { ADD_MANUAL_PAYMENT_TO_ORDER, ADD_NOTE_TO_ORDER, CANCEL_ORDER, CREATE_FULFILLMENT, DELETE_ORDER_NOTE, GET_ORDER, GET_ORDERS_LIST, GET_ORDER_HISTORY, GET_ORDER_SUMMARY, MODIFY_ORDER, REFUND_ORDER, SETTLE_PAYMENT, SETTLE_REFUND, TRANSITION_FULFILLMENT_TO_STATE, TRANSITION_ORDER_TO_STATE, TRANSITION_PAYMENT_TO_STATE, UPDATE_ORDER_CUSTOM_FIELDS, UPDATE_ORDER_NOTE, } from '../definitions/order-definitions';
+export class OrderDataService {
+    constructor(baseDataService) {
+        this.baseDataService = baseDataService;
+    }
+    getOrders(options = { take: 10 }) {
+        return this.baseDataService.query(GET_ORDERS_LIST, {
+            options,
+        });
+    }
+    getOrder(id) {
+        return this.baseDataService.query(GET_ORDER, {
+            id,
+        });
+    }
+    getOrderHistory(id, options) {
+        return this.baseDataService.query(GET_ORDER_HISTORY, {
+            id,
+            options,
+        });
+    }
+    settlePayment(id) {
+        return this.baseDataService.mutate(SETTLE_PAYMENT, {
+            id,
+        });
+    }
+    transitionPaymentToState(id, state) {
+        return this.baseDataService.mutate(TRANSITION_PAYMENT_TO_STATE, {
+            id,
+            state,
+        });
+    }
+    createFulfillment(input) {
+        return this.baseDataService.mutate(CREATE_FULFILLMENT, {
+            input,
+        });
+    }
+    transitionFulfillmentToState(id, state) {
+        return this.baseDataService.mutate(TRANSITION_FULFILLMENT_TO_STATE, {
+            id,
+            state,
+        });
+    }
+    cancelOrder(input) {
+        return this.baseDataService.mutate(CANCEL_ORDER, {
+            input,
+        });
+    }
+    refundOrder(input) {
+        return this.baseDataService.mutate(REFUND_ORDER, {
+            input,
+        });
+    }
+    settleRefund(input, orderId) {
+        return this.baseDataService.mutate(SETTLE_REFUND, {
+            input,
+        });
+    }
+    addNoteToOrder(input) {
+        return this.baseDataService.mutate(ADD_NOTE_TO_ORDER, {
+            input,
+        });
+    }
+    updateOrderNote(input) {
+        return this.baseDataService.mutate(UPDATE_ORDER_NOTE, {
+            input,
+        });
+    }
+    deleteOrderNote(id) {
+        return this.baseDataService.mutate(DELETE_ORDER_NOTE, {
+            id,
+        });
+    }
+    transitionToState(id, state) {
+        return this.baseDataService.mutate(TRANSITION_ORDER_TO_STATE, {
+            id,
+            state,
+        });
+    }
+    updateOrderCustomFields(input) {
+        return this.baseDataService.mutate(UPDATE_ORDER_CUSTOM_FIELDS, {
+            input,
+        });
+    }
+    getOrderSummary(start, end) {
+        return this.baseDataService.query(GET_ORDER_SUMMARY, {
+            start: start.toISOString(),
+            end: end.toISOString(),
+        });
+    }
+    modifyOrder(input) {
+        return this.baseDataService.mutate(MODIFY_ORDER, {
+            input,
+        });
+    }
+    addManualPaymentToOrder(input) {
+        return this.baseDataService.mutate(ADD_MANUAL_PAYMENT_TO_ORDER, { input });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"order-data.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/providers/order-data.service.ts"],"names":[],"mappings":"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","sourcesContent":["import * as Codegen from '../../common/generated-types';\r\nimport {\r\n    ADD_MANUAL_PAYMENT_TO_ORDER,\r\n    ADD_NOTE_TO_ORDER,\r\n    CANCEL_ORDER,\r\n    CREATE_FULFILLMENT,\r\n    DELETE_ORDER_NOTE,\r\n    GET_ORDER,\r\n    GET_ORDERS_LIST,\r\n    GET_ORDER_HISTORY,\r\n    GET_ORDER_SUMMARY,\r\n    MODIFY_ORDER,\r\n    REFUND_ORDER,\r\n    SETTLE_PAYMENT,\r\n    SETTLE_REFUND,\r\n    TRANSITION_FULFILLMENT_TO_STATE,\r\n    TRANSITION_ORDER_TO_STATE,\r\n    TRANSITION_PAYMENT_TO_STATE,\r\n    UPDATE_ORDER_CUSTOM_FIELDS,\r\n    UPDATE_ORDER_NOTE,\r\n} from '../definitions/order-definitions';\r\n\r\nimport { BaseDataService } from './base-data.service';\r\n\r\nexport class OrderDataService {\r\n    constructor(private baseDataService: BaseDataService) {}\r\n\r\n    getOrders(options: Codegen.OrderListOptions = { take: 10 }) {\r\n        return this.baseDataService.query<Codegen.GetOrderListQuery, Codegen.GetOrderListQueryVariables>(\r\n            GET_ORDERS_LIST,\r\n            {\r\n                options,\r\n            },\r\n        );\r\n    }\r\n\r\n    getOrder(id: string) {\r\n        return this.baseDataService.query<Codegen.GetOrderQuery, Codegen.GetOrderQueryVariables>(GET_ORDER, {\r\n            id,\r\n        });\r\n    }\r\n\r\n    getOrderHistory(id: string, options?: Codegen.HistoryEntryListOptions) {\r\n        return this.baseDataService.query<\r\n            Codegen.GetOrderHistoryQuery,\r\n            Codegen.GetOrderHistoryQueryVariables\r\n        >(GET_ORDER_HISTORY, {\r\n            id,\r\n            options,\r\n        });\r\n    }\r\n\r\n    settlePayment(id: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.SettlePaymentMutation,\r\n            Codegen.SettlePaymentMutationVariables\r\n        >(SETTLE_PAYMENT, {\r\n            id,\r\n        });\r\n    }\r\n\r\n    transitionPaymentToState(id: string, state: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.TransitionPaymentToStateMutation,\r\n            Codegen.TransitionPaymentToStateMutationVariables\r\n        >(TRANSITION_PAYMENT_TO_STATE, {\r\n            id,\r\n            state,\r\n        });\r\n    }\r\n\r\n    createFulfillment(input: Codegen.FulfillOrderInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.CreateFulfillmentMutation,\r\n            Codegen.CreateFulfillmentMutationVariables\r\n        >(CREATE_FULFILLMENT, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    transitionFulfillmentToState(id: string, state: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.TransitionFulfillmentToStateMutation,\r\n            Codegen.TransitionFulfillmentToStateMutationVariables\r\n        >(TRANSITION_FULFILLMENT_TO_STATE, {\r\n            id,\r\n            state,\r\n        });\r\n    }\r\n\r\n    cancelOrder(input: Codegen.CancelOrderInput) {\r\n        return this.baseDataService.mutate<Codegen.CancelOrderMutation, Codegen.CancelOrderMutationVariables>(\r\n            CANCEL_ORDER,\r\n            {\r\n                input,\r\n            },\r\n        );\r\n    }\r\n\r\n    refundOrder(input: Codegen.RefundOrderInput) {\r\n        return this.baseDataService.mutate<Codegen.RefundOrderMutation, Codegen.RefundOrderMutationVariables>(\r\n            REFUND_ORDER,\r\n            {\r\n                input,\r\n            },\r\n        );\r\n    }\r\n\r\n    settleRefund(input: Codegen.SettleRefundInput, orderId: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.SettleRefundMutation,\r\n            Codegen.SettleRefundMutationVariables\r\n        >(SETTLE_REFUND, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    addNoteToOrder(input: Codegen.AddNoteToOrderInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.AddNoteToOrderMutation,\r\n            Codegen.AddNoteToOrderMutationVariables\r\n        >(ADD_NOTE_TO_ORDER, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    updateOrderNote(input: Codegen.UpdateOrderNoteInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.UpdateOrderNoteMutation,\r\n            Codegen.UpdateOrderNoteMutationVariables\r\n        >(UPDATE_ORDER_NOTE, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    deleteOrderNote(id: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.DeleteOrderNoteMutation,\r\n            Codegen.DeleteOrderNoteMutationVariables\r\n        >(DELETE_ORDER_NOTE, {\r\n            id,\r\n        });\r\n    }\r\n\r\n    transitionToState(id: string, state: string) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.TransitionOrderToStateMutation,\r\n            Codegen.TransitionOrderToStateMutationVariables\r\n        >(TRANSITION_ORDER_TO_STATE, {\r\n            id,\r\n            state,\r\n        });\r\n    }\r\n\r\n    updateOrderCustomFields(input: Codegen.UpdateOrderInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.UpdateOrderCustomFieldsMutation,\r\n            Codegen.UpdateOrderCustomFieldsMutationVariables\r\n        >(UPDATE_ORDER_CUSTOM_FIELDS, {\r\n            input,\r\n        });\r\n    }\r\n\r\n    getOrderSummary(start: Date, end: Date) {\r\n        return this.baseDataService.query<\r\n            Codegen.GetOrderSummaryQuery,\r\n            Codegen.GetOrderSummaryQueryVariables\r\n        >(GET_ORDER_SUMMARY, {\r\n            start: start.toISOString(),\r\n            end: end.toISOString(),\r\n        });\r\n    }\r\n\r\n    modifyOrder(input: Codegen.ModifyOrderInput) {\r\n        return this.baseDataService.mutate<Codegen.ModifyOrderMutation, Codegen.ModifyOrderMutationVariables>(\r\n            MODIFY_ORDER,\r\n            {\r\n                input,\r\n            },\r\n        );\r\n    }\r\n\r\n    addManualPaymentToOrder(input: Codegen.ManualPaymentInput) {\r\n        return this.baseDataService.mutate<\r\n            Codegen.AddManualPaymentMutation,\r\n            Codegen.AddManualPaymentMutationVariables\r\n        >(ADD_MANUAL_PAYMENT_TO_ORDER, { input });\r\n    }\r\n}\r\n"]}