@deenruv/admin-ui 1.0.0

package/esm2022/core/data/providers/settings-data.service.mjs

@@ -0,0 +1,246 @@
+import { pick } from '@deenruv/common/lib/pick';
+import { JobState, } from '../../common/generated-types';
+import { ADD_MEMBERS_TO_ZONE, CANCEL_JOB, CREATE_CHANNEL, CREATE_COUNTRY, CREATE_PAYMENT_METHOD, CREATE_SELLER, CREATE_TAX_CATEGORY, CREATE_TAX_RATE, CREATE_ZONE, DELETE_CHANNEL, DELETE_CHANNELS, DELETE_COUNTRIES, DELETE_COUNTRY, DELETE_PAYMENT_METHOD, DELETE_PAYMENT_METHODS, DELETE_SELLER, DELETE_SELLERS, DELETE_TAX_CATEGORIES, DELETE_TAX_CATEGORY, DELETE_TAX_RATE, DELETE_TAX_RATES, DELETE_ZONE, DELETE_ZONES, GET_ACTIVE_CHANNEL, GET_AVAILABLE_COUNTRIES, GET_CHANNELS, GET_GLOBAL_SETTINGS, GET_JOB_INFO, GET_JOB_QUEUE_LIST, GET_JOBS_BY_ID, GET_JOBS_LIST, GET_PAYMENT_METHOD_OPERATIONS, GET_SELLERS, GET_TAX_CATEGORIES, GET_TAX_RATE_LIST_SIMPLE, GET_ZONE, REMOVE_MEMBERS_FROM_ZONE, UPDATE_CHANNEL, UPDATE_COUNTRY, UPDATE_GLOBAL_SETTINGS, UPDATE_PAYMENT_METHOD, UPDATE_SELLER, UPDATE_TAX_CATEGORY, UPDATE_TAX_RATE, UPDATE_ZONE, } from '../definitions/settings-definitions';
+export class SettingsDataService {
+    constructor(baseDataService) {
+        this.baseDataService = baseDataService;
+    }
+    getAvailableCountries() {
+        return this.baseDataService.query(GET_AVAILABLE_COUNTRIES);
+    }
+    createCountry(input) {
+        return this.baseDataService.mutate(CREATE_COUNTRY, {
+            input: pick(input, ['code', 'enabled', 'translations', 'customFields']),
+        });
+    }
+    updateCountry(input) {
+        return this.baseDataService.mutate(UPDATE_COUNTRY, {
+            input: pick(input, ['id', 'code', 'enabled', 'translations', 'customFields']),
+        });
+    }
+    deleteCountry(id) {
+        return this.baseDataService.mutate(DELETE_COUNTRY, {
+            id,
+        });
+    }
+    deleteCountries(ids) {
+        return this.baseDataService.mutate(DELETE_COUNTRIES, {
+            ids,
+        });
+    }
+    getZone(id) {
+        return this.baseDataService.query(GET_ZONE, {
+            id,
+        });
+    }
+    createZone(input) {
+        return this.baseDataService.mutate(CREATE_ZONE, {
+            input,
+        });
+    }
+    updateZone(input) {
+        return this.baseDataService.mutate(UPDATE_ZONE, {
+            input,
+        });
+    }
+    deleteZone(id) {
+        return this.baseDataService.mutate(DELETE_ZONE, {
+            id,
+        });
+    }
+    deleteZones(ids) {
+        return this.baseDataService.mutate(DELETE_ZONES, {
+            ids,
+        });
+    }
+    addMembersToZone(zoneId, memberIds) {
+        return this.baseDataService.mutate(ADD_MEMBERS_TO_ZONE, {
+            zoneId,
+            memberIds,
+        });
+    }
+    removeMembersFromZone(zoneId, memberIds) {
+        return this.baseDataService.mutate(REMOVE_MEMBERS_FROM_ZONE, {
+            zoneId,
+            memberIds,
+        });
+    }
+    getTaxCategories(options = {}) {
+        return this.baseDataService.query(GET_TAX_CATEGORIES, {
+            options,
+        });
+    }
+    createTaxCategory(input) {
+        return this.baseDataService.mutate(CREATE_TAX_CATEGORY, {
+            input,
+        });
+    }
+    updateTaxCategory(input) {
+        return this.baseDataService.mutate(UPDATE_TAX_CATEGORY, {
+            input,
+        });
+    }
+    deleteTaxCategory(id) {
+        return this.baseDataService.mutate(DELETE_TAX_CATEGORY, {
+            id,
+        });
+    }
+    deleteTaxCategories(ids) {
+        return this.baseDataService.mutate(DELETE_TAX_CATEGORIES, {
+            ids,
+        });
+    }
+    getTaxRatesSimple(take = 10, skip = 0, fetchPolicy) {
+        return this.baseDataService.query(GET_TAX_RATE_LIST_SIMPLE, {
+            options: {
+                take,
+                skip,
+            },
+        }, fetchPolicy);
+    }
+    createTaxRate(input) {
+        return this.baseDataService.mutate(CREATE_TAX_RATE, {
+            input,
+        });
+    }
+    updateTaxRate(input) {
+        return this.baseDataService.mutate(UPDATE_TAX_RATE, {
+            input,
+        });
+    }
+    deleteTaxRate(id) {
+        return this.baseDataService.mutate(DELETE_TAX_RATE, {
+            id,
+        });
+    }
+    deleteTaxRates(ids) {
+        return this.baseDataService.mutate(DELETE_TAX_RATES, {
+            ids,
+        });
+    }
+    getChannels(options = {}) {
+        return this.baseDataService.query(GET_CHANNELS, { options });
+    }
+    getSellerList(options) {
+        return this.baseDataService.query(GET_SELLERS, { options });
+    }
+    createSeller(input) {
+        return this.baseDataService.mutate(CREATE_SELLER, {
+            input,
+        });
+    }
+    updateSeller(input) {
+        return this.baseDataService.mutate(UPDATE_SELLER, {
+            input,
+        });
+    }
+    deleteSeller(id) {
+        return this.baseDataService.mutate(DELETE_SELLER, {
+            id,
+        });
+    }
+    deleteSellers(ids) {
+        return this.baseDataService.mutate(DELETE_SELLERS, {
+            ids,
+        });
+    }
+    getActiveChannel(fetchPolicy) {
+        return this.baseDataService.query(GET_ACTIVE_CHANNEL, {}, fetchPolicy);
+    }
+    createChannel(input) {
+        return this.baseDataService.mutate(CREATE_CHANNEL, {
+            input,
+        });
+    }
+    updateChannel(input) {
+        return this.baseDataService.mutate(UPDATE_CHANNEL, {
+            input,
+        });
+    }
+    deleteChannel(id) {
+        return this.baseDataService.mutate(DELETE_CHANNEL, {
+            id,
+        });
+    }
+    deleteChannels(ids) {
+        return this.baseDataService.mutate(DELETE_CHANNELS, {
+            ids,
+        });
+    }
+    createPaymentMethod(input) {
+        return this.baseDataService.mutate(CREATE_PAYMENT_METHOD, {
+            input: pick(input, ['code', 'checker', 'handler', 'enabled', 'translations', 'customFields']),
+        });
+    }
+    updatePaymentMethod(input) {
+        return this.baseDataService.mutate(UPDATE_PAYMENT_METHOD, {
+            input: pick(input, [
+                'id',
+                'code',
+                'checker',
+                'handler',
+                'enabled',
+                'translations',
+                'customFields',
+            ]),
+        });
+    }
+    deletePaymentMethod(id, force) {
+        return this.baseDataService.mutate(DELETE_PAYMENT_METHOD, {
+            id,
+            force,
+        });
+    }
+    deletePaymentMethods(ids, force) {
+        return this.baseDataService.mutate(DELETE_PAYMENT_METHODS, {
+            ids,
+            force,
+        });
+    }
+    getPaymentMethodOperations() {
+        return this.baseDataService.query(GET_PAYMENT_METHOD_OPERATIONS);
+    }
+    getGlobalSettings(fetchPolicy) {
+        return this.baseDataService.query(GET_GLOBAL_SETTINGS, undefined, fetchPolicy);
+    }
+    updateGlobalSettings(input) {
+        return this.baseDataService.mutate(UPDATE_GLOBAL_SETTINGS, {
+            input,
+        });
+    }
+    getJob(id) {
+        return this.baseDataService.query(GET_JOB_INFO, {
+            id,
+        });
+    }
+    pollJobs(ids) {
+        return this.baseDataService.query(GET_JOBS_BY_ID, {
+            ids,
+        });
+    }
+    getAllJobs(options) {
+        return this.baseDataService.query(GET_JOBS_LIST, {
+            options,
+        }, 'cache-first');
+    }
+    getJobQueues() {
+        return this.baseDataService.query(GET_JOB_QUEUE_LIST);
+    }
+    getRunningJobs() {
+        return this.baseDataService.query(GET_JOBS_LIST, {
+            options: {
+                filter: {
+                    state: {
+                        eq: JobState.RUNNING,
+                    },
+                },
+            },
+        });
+    }
+    cancelJob(id) {
+        return this.baseDataService.mutate(CANCEL_JOB, {
+            id,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"settings-data.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/providers/settings-data.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { FetchPolicy, WatchQueryFetchPolicy } from '@apollo/client/core';\nimport { pick } from '@deenruv/common/lib/pick';\n\nimport * as Codegen from '../../common/generated-types';\nimport {\n    ChannelListOptions,\n    JobListOptions,\n    JobState,\n    SellerListOptions,\n    TaxCategoryListOptions,\n} from '../../common/generated-types';\nimport {\n    ADD_MEMBERS_TO_ZONE,\n    CANCEL_JOB,\n    CREATE_CHANNEL,\n    CREATE_COUNTRY,\n    CREATE_PAYMENT_METHOD,\n    CREATE_SELLER,\n    CREATE_TAX_CATEGORY,\n    CREATE_TAX_RATE,\n    CREATE_ZONE,\n    DELETE_CHANNEL,\n    DELETE_CHANNELS,\n    DELETE_COUNTRIES,\n    DELETE_COUNTRY,\n    DELETE_PAYMENT_METHOD,\n    DELETE_PAYMENT_METHODS,\n    DELETE_SELLER,\n    DELETE_SELLERS,\n    DELETE_TAX_CATEGORIES,\n    DELETE_TAX_CATEGORY,\n    DELETE_TAX_RATE,\n    DELETE_TAX_RATES,\n    DELETE_ZONE,\n    DELETE_ZONES,\n    GET_ACTIVE_CHANNEL,\n    GET_AVAILABLE_COUNTRIES,\n    GET_CHANNELS,\n    GET_GLOBAL_SETTINGS,\n    GET_JOB_INFO,\n    GET_JOB_QUEUE_LIST,\n    GET_JOBS_BY_ID,\n    GET_JOBS_LIST,\n    GET_PAYMENT_METHOD_OPERATIONS,\n    GET_SELLERS,\n    GET_TAX_CATEGORIES,\n    GET_TAX_RATE_LIST_SIMPLE,\n    GET_ZONE,\n    REMOVE_MEMBERS_FROM_ZONE,\n    UPDATE_CHANNEL,\n    UPDATE_COUNTRY,\n    UPDATE_GLOBAL_SETTINGS,\n    UPDATE_PAYMENT_METHOD,\n    UPDATE_SELLER,\n    UPDATE_TAX_CATEGORY,\n    UPDATE_TAX_RATE,\n    UPDATE_ZONE,\n} from '../definitions/settings-definitions';\n\nimport { BaseDataService } from './base-data.service';\n\nexport class SettingsDataService {\n    constructor(private baseDataService: BaseDataService) {}\n\n    getAvailableCountries() {\n        return this.baseDataService.query<Codegen.GetAvailableCountriesQuery>(GET_AVAILABLE_COUNTRIES);\n    }\n\n    createCountry(input: Codegen.CreateCountryInput) {\n        return this.baseDataService.mutate<\n            Codegen.CreateCountryMutation,\n            Codegen.CreateCountryMutationVariables\n        >(CREATE_COUNTRY, {\n            input: pick(input, ['code', 'enabled', 'translations', 'customFields']),\n        });\n    }\n\n    updateCountry(input: Codegen.UpdateCountryInput) {\n        return this.baseDataService.mutate<\n            Codegen.UpdateCountryMutation,\n            Codegen.UpdateCountryMutationVariables\n        >(UPDATE_COUNTRY, {\n            input: pick(input, ['id', 'code', 'enabled', 'translations', 'customFields']),\n        });\n    }\n\n    deleteCountry(id: string) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteCountryMutation,\n            Codegen.DeleteCountryMutationVariables\n        >(DELETE_COUNTRY, {\n            id,\n        });\n    }\n\n    deleteCountries(ids: string[]) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteCountriesMutation,\n            Codegen.DeleteCountriesMutationVariables\n        >(DELETE_COUNTRIES, {\n            ids,\n        });\n    }\n\n    getZone(id: string) {\n        return this.baseDataService.query<Codegen.GetZoneQuery, Codegen.GetZoneQueryVariables>(GET_ZONE, {\n            id,\n        });\n    }\n\n    createZone(input: Codegen.CreateZoneInput) {\n        return this.baseDataService.mutate<Codegen.CreateZoneMutation, Codegen.CreateZoneMutationVariables>(\n            CREATE_ZONE,\n            {\n                input,\n            },\n        );\n    }\n\n    updateZone(input: Codegen.UpdateZoneInput) {\n        return this.baseDataService.mutate<Codegen.UpdateZoneMutation, Codegen.UpdateZoneMutationVariables>(\n            UPDATE_ZONE,\n            {\n                input,\n            },\n        );\n    }\n\n    deleteZone(id: string) {\n        return this.baseDataService.mutate<Codegen.DeleteZoneMutation, Codegen.DeleteZoneMutationVariables>(\n            DELETE_ZONE,\n            {\n                id,\n            },\n        );\n    }\n\n    deleteZones(ids: string[]) {\n        return this.baseDataService.mutate<Codegen.DeleteZonesMutation, Codegen.DeleteZonesMutationVariables>(\n            DELETE_ZONES,\n            {\n                ids,\n            },\n        );\n    }\n\n    addMembersToZone(zoneId: string, memberIds: string[]) {\n        return this.baseDataService.mutate<\n            Codegen.AddMembersToZoneMutation,\n            Codegen.AddMembersToZoneMutationVariables\n        >(ADD_MEMBERS_TO_ZONE, {\n            zoneId,\n            memberIds,\n        });\n    }\n\n    removeMembersFromZone(zoneId: string, memberIds: string[]) {\n        return this.baseDataService.mutate<\n            Codegen.RemoveMembersFromZoneMutation,\n            Codegen.RemoveMembersFromZoneMutationVariables\n        >(REMOVE_MEMBERS_FROM_ZONE, {\n            zoneId,\n            memberIds,\n        });\n    }\n\n    getTaxCategories(options: TaxCategoryListOptions = {}) {\n        return this.baseDataService.query<\n            Codegen.GetTaxCategoriesQuery,\n            Codegen.GetTaxCategoriesQueryVariables\n        >(GET_TAX_CATEGORIES, {\n            options,\n        });\n    }\n\n    createTaxCategory(input: Codegen.CreateTaxCategoryInput) {\n        return this.baseDataService.mutate<\n            Codegen.CreateTaxCategoryMutation,\n            Codegen.CreateTaxCategoryMutationVariables\n        >(CREATE_TAX_CATEGORY, {\n            input,\n        });\n    }\n\n    updateTaxCategory(input: Codegen.UpdateTaxCategoryInput) {\n        return this.baseDataService.mutate<\n            Codegen.UpdateTaxCategoryMutation,\n            Codegen.UpdateTaxCategoryMutationVariables\n        >(UPDATE_TAX_CATEGORY, {\n            input,\n        });\n    }\n\n    deleteTaxCategory(id: string) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteTaxCategoryMutation,\n            Codegen.DeleteTaxCategoryMutationVariables\n        >(DELETE_TAX_CATEGORY, {\n            id,\n        });\n    }\n\n    deleteTaxCategories(ids: string[]) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteTaxCategoriesMutation,\n            Codegen.DeleteTaxCategoriesMutationVariables\n        >(DELETE_TAX_CATEGORIES, {\n            ids,\n        });\n    }\n\n    getTaxRatesSimple(take = 10, skip = 0, fetchPolicy?: FetchPolicy) {\n        return this.baseDataService.query<\n            Codegen.GetTaxRateListSimpleQuery,\n            Codegen.GetTaxRateListSimpleQueryVariables\n        >(\n            GET_TAX_RATE_LIST_SIMPLE,\n            {\n                options: {\n                    take,\n                    skip,\n                },\n            },\n            fetchPolicy,\n        );\n    }\n\n    createTaxRate(input: Codegen.CreateTaxRateInput) {\n        return this.baseDataService.mutate<\n            Codegen.CreateTaxRateMutation,\n            Codegen.CreateTaxRateMutationVariables\n        >(CREATE_TAX_RATE, {\n            input,\n        });\n    }\n\n    updateTaxRate(input: Codegen.UpdateTaxRateInput) {\n        return this.baseDataService.mutate<\n            Codegen.UpdateTaxRateMutation,\n            Codegen.UpdateTaxRateMutationVariables\n        >(UPDATE_TAX_RATE, {\n            input,\n        });\n    }\n\n    deleteTaxRate(id: string) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteTaxRateMutation,\n            Codegen.DeleteTaxRateMutationVariables\n        >(DELETE_TAX_RATE, {\n            id,\n        });\n    }\n\n    deleteTaxRates(ids: string[]) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteTaxRatesMutation,\n            Codegen.DeleteTaxRatesMutationVariables\n        >(DELETE_TAX_RATES, {\n            ids,\n        });\n    }\n\n    getChannels(options: ChannelListOptions = {}) {\n        return this.baseDataService.query<Codegen.GetChannelsQuery, Codegen.GetChannelsQueryVariables>(\n            GET_CHANNELS,\n            { options },\n        );\n    }\n\n    getSellerList(options?: SellerListOptions) {\n        return this.baseDataService.query<Codegen.GetSellersQuery, Codegen.GetSellersQueryVariables>(\n            GET_SELLERS,\n            { options },\n        );\n    }\n\n    createSeller(input: Codegen.CreateSellerInput) {\n        return this.baseDataService.mutate<\n            Codegen.CreateSellerMutation,\n            Codegen.CreateSellerMutationVariables\n        >(CREATE_SELLER, {\n            input,\n        });\n    }\n\n    updateSeller(input: Codegen.UpdateSellerInput) {\n        return this.baseDataService.mutate<\n            Codegen.UpdateSellerMutation,\n            Codegen.UpdateSellerMutationVariables\n        >(UPDATE_SELLER, {\n            input,\n        });\n    }\n\n    deleteSeller(id: string) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteSellerMutation,\n            Codegen.DeleteSellerMutationVariables\n        >(DELETE_SELLER, {\n            id,\n        });\n    }\n\n    deleteSellers(ids: string[]) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteSellersMutation,\n            Codegen.DeleteSellersMutationVariables\n        >(DELETE_SELLERS, {\n            ids,\n        });\n    }\n\n    getActiveChannel(fetchPolicy?: FetchPolicy) {\n        return this.baseDataService.query<\n            Codegen.GetActiveChannelQuery,\n            Codegen.GetActiveChannelQueryVariables\n        >(GET_ACTIVE_CHANNEL, {}, fetchPolicy);\n    }\n\n    createChannel(input: Codegen.CreateChannelInput) {\n        return this.baseDataService.mutate<\n            Codegen.CreateChannelMutation,\n            Codegen.CreateChannelMutationVariables\n        >(CREATE_CHANNEL, {\n            input,\n        });\n    }\n\n    updateChannel(input: Codegen.UpdateChannelInput) {\n        return this.baseDataService.mutate<\n            Codegen.UpdateChannelMutation,\n            Codegen.UpdateChannelMutationVariables\n        >(UPDATE_CHANNEL, {\n            input,\n        });\n    }\n\n    deleteChannel(id: string) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteChannelMutation,\n            Codegen.DeleteChannelMutationVariables\n        >(DELETE_CHANNEL, {\n            id,\n        });\n    }\n\n    deleteChannels(ids: string[]) {\n        return this.baseDataService.mutate<\n            Codegen.DeleteChannelsMutation,\n            Codegen.DeleteChannelsMutationVariables\n        >(DELETE_CHANNELS, {\n            ids,\n        });\n    }\n\n    createPaymentMethod(input: Codegen.CreatePaymentMethodInput) {\n        return this.baseDataService.mutate<\n            Codegen.CreatePaymentMethodMutation,\n            Codegen.CreatePaymentMethodMutationVariables\n        >(CREATE_PAYMENT_METHOD, {\n            input: pick(input, ['code', 'checker', 'handler', 'enabled', 'translations', 'customFields']),\n        });\n    }\n\n    updatePaymentMethod(input: Codegen.UpdatePaymentMethodInput) {\n        return this.baseDataService.mutate<\n            Codegen.UpdatePaymentMethodMutation,\n            Codegen.UpdatePaymentMethodMutationVariables\n        >(UPDATE_PAYMENT_METHOD, {\n            input: pick(input, [\n                'id',\n                'code',\n                'checker',\n                'handler',\n                'enabled',\n                'translations',\n                'customFields',\n            ]),\n        });\n    }\n\n    deletePaymentMethod(id: string, force: boolean) {\n        return this.baseDataService.mutate<\n            Codegen.DeletePaymentMethodMutation,\n            Codegen.DeletePaymentMethodMutationVariables\n        >(DELETE_PAYMENT_METHOD, {\n            id,\n            force,\n        });\n    }\n\n    deletePaymentMethods(ids: string[], force: boolean) {\n        return this.baseDataService.mutate<\n            Codegen.DeletePaymentMethodsMutation,\n            Codegen.DeletePaymentMethodsMutationVariables\n        >(DELETE_PAYMENT_METHODS, {\n            ids,\n            force,\n        });\n    }\n\n    getPaymentMethodOperations() {\n        return this.baseDataService.query<Codegen.GetPaymentMethodOperationsQuery>(\n            GET_PAYMENT_METHOD_OPERATIONS,\n        );\n    }\n\n    getGlobalSettings(fetchPolicy?: WatchQueryFetchPolicy) {\n        return this.baseDataService.query<Codegen.GetGlobalSettingsQuery>(\n            GET_GLOBAL_SETTINGS,\n            undefined,\n            fetchPolicy,\n        );\n    }\n\n    updateGlobalSettings(input: Codegen.UpdateGlobalSettingsInput) {\n        return this.baseDataService.mutate<\n            Codegen.UpdateGlobalSettingsMutation,\n            Codegen.UpdateGlobalSettingsMutationVariables\n        >(UPDATE_GLOBAL_SETTINGS, {\n            input,\n        });\n    }\n\n    getJob(id: string) {\n        return this.baseDataService.query<Codegen.GetJobInfoQuery, Codegen.GetJobInfoQueryVariables>(\n            GET_JOB_INFO,\n            {\n                id,\n            },\n        );\n    }\n\n    pollJobs(ids: string[]) {\n        return this.baseDataService.query<Codegen.GetJobsByIdQuery, Codegen.GetJobsByIdQueryVariables>(\n            GET_JOBS_BY_ID,\n            {\n                ids,\n            },\n        );\n    }\n\n    getAllJobs(options?: JobListOptions) {\n        return this.baseDataService.query<Codegen.GetAllJobsQuery, Codegen.GetAllJobsQueryVariables>(\n            GET_JOBS_LIST,\n            {\n                options,\n            },\n            'cache-first',\n        );\n    }\n\n    getJobQueues() {\n        return this.baseDataService.query<Codegen.GetJobQueueListQuery>(GET_JOB_QUEUE_LIST);\n    }\n\n    getRunningJobs() {\n        return this.baseDataService.query<Codegen.GetAllJobsQuery, Codegen.GetAllJobsQueryVariables>(\n            GET_JOBS_LIST,\n            {\n                options: {\n                    filter: {\n                        state: {\n                            eq: JobState.RUNNING,\n                        },\n                    },\n                },\n            },\n        );\n    }\n\n    cancelJob(id: string) {\n        return this.baseDataService.mutate<Codegen.CancelJobMutation, Codegen.CancelJobMutationVariables>(\n            CANCEL_JOB,\n            {\n                id,\n            },\n        );\n    }\n}\n"]}

package/esm2022/core/data/providers/shipping-method-data.service.mjs

@@ -0,0 +1,58 @@
+import { pick } from '@deenruv/common/lib/pick';
+import { CREATE_SHIPPING_METHOD, DELETE_SHIPPING_METHOD, DELETE_SHIPPING_METHODS, GET_SHIPPING_METHOD_OPERATIONS, TEST_ELIGIBLE_SHIPPING_METHODS, TEST_SHIPPING_METHOD, UPDATE_SHIPPING_METHOD, } from '../definitions/shipping-definitions';
+export class ShippingMethodDataService {
+    constructor(baseDataService) {
+        this.baseDataService = baseDataService;
+    }
+    getShippingMethodOperations() {
+        return this.baseDataService.query(GET_SHIPPING_METHOD_OPERATIONS);
+    }
+    createShippingMethod(input) {
+        const variables = {
+            input: pick(input, [
+                'code',
+                'checker',
+                'calculator',
+                'fulfillmentHandler',
+                'customFields',
+                'translations',
+            ]),
+        };
+        return this.baseDataService.mutate(CREATE_SHIPPING_METHOD, variables);
+    }
+    updateShippingMethod(input) {
+        const variables = {
+            input: pick(input, [
+                'id',
+                'code',
+                'checker',
+                'calculator',
+                'fulfillmentHandler',
+                'customFields',
+                'translations',
+            ]),
+        };
+        return this.baseDataService.mutate(UPDATE_SHIPPING_METHOD, variables);
+    }
+    deleteShippingMethod(id) {
+        return this.baseDataService.mutate(DELETE_SHIPPING_METHOD, {
+            id,
+        });
+    }
+    deleteShippingMethods(ids) {
+        return this.baseDataService.mutate(DELETE_SHIPPING_METHODS, {
+            ids,
+        });
+    }
+    testShippingMethod(input) {
+        return this.baseDataService.query(TEST_SHIPPING_METHOD, {
+            input,
+        });
+    }
+    testEligibleShippingMethods(input) {
+        return this.baseDataService.query(TEST_ELIGIBLE_SHIPPING_METHODS, {
+            input,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/data/query-result.mjs

@@ -0,0 +1,77 @@
+import { NetworkStatus } from '@apollo/client/core';
+import { notNullOrUndefined } from '@deenruv/common/lib/shared-utils';
+import { merge, Subject } from 'rxjs';
+import { distinctUntilChanged, filter, finalize, map, skip, take, takeUntil, tap } from 'rxjs/operators';
+import { GET_USER_STATUS } from './definitions/client-definitions';
+/**
+ * @description
+ * This class wraps the Apollo Angular QueryRef object and exposes some getters
+ * for convenience.
+ *
+ * @docsCategory services
+ * @docsPage DataService
+ */
+export class QueryResult {
+    constructor(queryRef, apollo) {
+        this.queryRef = queryRef;
+        this.apollo = apollo;
+        this.completed$ = new Subject();
+        this.valueChanges = queryRef.valueChanges;
+    }
+    /**
+     * @description
+     * Re-fetch this query whenever the active Channel changes.
+     */
+    refetchOnChannelChange() {
+        const userStatus$ = this.apollo.watchQuery({
+            query: GET_USER_STATUS,
+        }).valueChanges;
+        const activeChannelId$ = userStatus$.pipe(map(data => data.data.userStatus.activeChannelId), filter(notNullOrUndefined), distinctUntilChanged(), skip(1), takeUntil(this.completed$));
+        const loggedOut$ = userStatus$.pipe(map(data => data.data.userStatus.isLoggedIn), distinctUntilChanged(), skip(1), filter(isLoggedIn => !isLoggedIn), takeUntil(this.completed$));
+        this.valueChanges = merge(activeChannelId$, this.queryRef.valueChanges).pipe(tap(val => {
+            if (typeof val === 'string') {
+                new Promise(resolve => setTimeout(resolve, 50)).then(() => this.queryRef.refetch());
+            }
+        }), filter(val => typeof val !== 'string'), takeUntil(loggedOut$), takeUntil(this.completed$));
+        this.queryRef.valueChanges = this.valueChanges;
+        return this;
+    }
+    /**
+     * @description
+     * Returns an Observable which emits a single result and then completes.
+     */
+    get single$() {
+        return this.valueChanges.pipe(filter(result => result.networkStatus === NetworkStatus.ready), take(1), map(result => result.data), finalize(() => {
+            this.completed$.next();
+            this.completed$.complete();
+        }));
+    }
+    /**
+     * @description
+     * Returns an Observable which emits until unsubscribed.
+     */
+    get stream$() {
+        return this.valueChanges.pipe(filter(result => result.networkStatus === NetworkStatus.ready), map(result => result.data), finalize(() => {
+            this.completed$.next();
+            this.completed$.complete();
+        }));
+    }
+    get ref() {
+        return this.queryRef;
+    }
+    /**
+     * @description
+     * Returns a single-result Observable after applying the map function.
+     */
+    mapSingle(mapFn) {
+        return this.single$.pipe(map(mapFn));
+    }
+    /**
+     * @description
+     * Returns a multiple-result Observable after applying the map function.
+     */
+    mapStream(mapFn) {
+        return this.stream$.pipe(map(mapFn));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-result.js","sourceRoot":"","sources":["../../../../src/lib/core/src/data/query-result.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApolloQueryResult, NetworkStatus } from '@apollo/client/core';\nimport { notNullOrUndefined } from '@deenruv/common/lib/shared-utils';\nimport { Apollo, QueryRef } from 'apollo-angular';\nimport { merge, Observable, Subject } from 'rxjs';\nimport { distinctUntilChanged, filter, finalize, map, skip, take, takeUntil, tap } from 'rxjs/operators';\n\nimport { GetUserStatusQuery } from '../common/generated-types';\n\nimport { GET_USER_STATUS } from './definitions/client-definitions';\n\n/**\n * @description\n * This class wraps the Apollo Angular QueryRef object and exposes some getters\n * for convenience.\n *\n * @docsCategory services\n * @docsPage DataService\n */\nexport class QueryResult<T, V extends Record<string, any> = Record<string, any>> {\n    constructor(\n        private queryRef: QueryRef<T, V>,\n        private apollo: Apollo,\n    ) {\n        this.valueChanges = queryRef.valueChanges;\n    }\n\n    completed$ = new Subject<void>();\n    private valueChanges: Observable<ApolloQueryResult<T>>;\n\n    /**\n     * @description\n     * Re-fetch this query whenever the active Channel changes.\n     */\n    refetchOnChannelChange(): QueryResult<T, V> {\n        const userStatus$ = this.apollo.watchQuery<GetUserStatusQuery>({\n            query: GET_USER_STATUS,\n        }).valueChanges;\n        const activeChannelId$ = userStatus$.pipe(\n            map(data => data.data.userStatus.activeChannelId),\n            filter(notNullOrUndefined),\n            distinctUntilChanged(),\n            skip(1),\n            takeUntil(this.completed$),\n        );\n        const loggedOut$ = userStatus$.pipe(\n            map(data => data.data.userStatus.isLoggedIn),\n            distinctUntilChanged(),\n            skip(1),\n            filter(isLoggedIn => !isLoggedIn),\n            takeUntil(this.completed$),\n        );\n\n        this.valueChanges = merge(activeChannelId$, this.queryRef.valueChanges).pipe(\n            tap(val => {\n                if (typeof val === 'string') {\n                    new Promise(resolve => setTimeout(resolve, 50)).then(() => this.queryRef.refetch());\n                }\n            }),\n            filter<any>(val => typeof val !== 'string'),\n            takeUntil(loggedOut$),\n            takeUntil(this.completed$),\n        );\n        this.queryRef.valueChanges = this.valueChanges;\n        return this;\n    }\n\n    /**\n     * @description\n     * Returns an Observable which emits a single result and then completes.\n     */\n    get single$(): Observable<T> {\n        return this.valueChanges.pipe(\n            filter(result => result.networkStatus === NetworkStatus.ready),\n            take(1),\n            map(result => result.data),\n            finalize(() => {\n                this.completed$.next();\n                this.completed$.complete();\n            }),\n        );\n    }\n\n    /**\n     * @description\n     * Returns an Observable which emits until unsubscribed.\n     */\n    get stream$(): Observable<T> {\n        return this.valueChanges.pipe(\n            filter(result => result.networkStatus === NetworkStatus.ready),\n            map(result => result.data),\n            finalize(() => {\n                this.completed$.next();\n                this.completed$.complete();\n            }),\n        );\n    }\n\n    get ref(): QueryRef<T, V> {\n        return this.queryRef;\n    }\n\n    /**\n     * @description\n     * Returns a single-result Observable after applying the map function.\n     */\n    mapSingle<R>(mapFn: (item: T) => R): Observable<R> {\n        return this.single$.pipe(map(mapFn));\n    }\n\n    /**\n     * @description\n     * Returns a multiple-result Observable after applying the map function.\n     */\n    mapStream<R>(mapFn: (item: T) => R): Observable<R> {\n        return this.stream$.pipe(map(mapFn));\n    }\n}\n"]}

package/esm2022/core/data/server-config.mjs

@@ -0,0 +1,78 @@
+import { Injectable } from '@angular/core';
+import { lastValueFrom } from 'rxjs';
+import { GET_GLOBAL_SETTINGS, GET_SERVER_CONFIG } from './definitions/settings-definitions';
+import { BaseDataService } from './providers/base-data.service';
+import * as i0 from "@angular/core";
+export function initializeServerConfigService(serverConfigService) {
+    return serverConfigService.init();
+}
+/**
+ * A service which fetches the config from the server upon initialization, and then provides that config
+ * to the components which require it.
+ */
+export class ServerConfigService {
+    get baseDataService() {
+        return this.injector.get(BaseDataService);
+    }
+    constructor(injector) {
+        this.injector = injector;
+        this._serverConfig = {};
+        this.customFieldsMap = new Map();
+    }
+    /**
+     * Fetches the ServerConfig. Should be run as part of the app bootstrap process by attaching
+     * to the Angular APP_INITIALIZER token.
+     */
+    init() {
+        return () => this.getServerConfig();
+    }
+    /**
+     * Fetch the ServerConfig. Should be run on app init (in case user is already logged in) and on successful login.
+     */
+    getServerConfig() {
+        return lastValueFrom(this.baseDataService.query(GET_SERVER_CONFIG).single$).then(result => {
+            this._serverConfig = result.globalSettings.serverConfig;
+            for (const entityCustomFields of this._serverConfig.entityCustomFields) {
+                this.customFieldsMap.set(entityCustomFields.entityName, entityCustomFields.customFields);
+            }
+        }, err => {
+            // Let the error fall through to be caught by the http interceptor.
+        });
+    }
+    getAvailableLanguages() {
+        return this.baseDataService
+            .query(GET_GLOBAL_SETTINGS, {}, 'cache-first')
+            .mapSingle(res => res.globalSettings.availableLanguages);
+    }
+    /**
+     * When any of the GlobalSettings are modified, this method should be called to update the Apollo cache.
+     */
+    refreshGlobalSettings() {
+        return this.baseDataService.query(GET_GLOBAL_SETTINGS, {}, 'network-only')
+            .single$;
+    }
+    /**
+     * Retrieves the custom field configs for the given entity type.
+     */
+    getCustomFieldsFor(type) {
+        return this.customFieldsMap.get(type) || [];
+    }
+    getOrderProcessStates() {
+        return this.serverConfig.orderProcess;
+    }
+    getPermittedAssetTypes() {
+        return this.serverConfig.permittedAssetTypes;
+    }
+    getPermissionDefinitions() {
+        return this.serverConfig.permissions;
+    }
+    get serverConfig() {
+        return this._serverConfig;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ServerConfigService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ServerConfigService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ServerConfigService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmVyLWNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvY29yZS9zcmMvZGF0YS9zZXJ2ZXItY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQVksTUFBTSxlQUFlLENBQUM7QUFDckQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQVdyQyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUM1RixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sK0JBQStCLENBQUM7O0FBRWhFLE1BQU0sVUFBVSw2QkFBNkIsQ0FBQyxtQkFBd0M7SUFDbEYsT0FBTyxtQkFBbUIsQ0FBQyxJQUFJLEVBQUUsQ0FBQztBQUN0QyxDQUFDO0FBRUQ7OztHQUdHO0FBRUgsTUFBTSxPQUFPLG1CQUFtQjtJQUc1QixJQUFZLGVBQWU7UUFDdkIsT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBa0IsZUFBZSxDQUFDLENBQUM7SUFDL0QsQ0FBQztJQUVELFlBQW9CLFFBQWtCO1FBQWxCLGFBQVEsR0FBUixRQUFRLENBQVU7UUFOOUIsa0JBQWEsR0FBMkQsRUFBUyxDQUFDO1FBQzFGLG9CQUFlLEdBQXFDLElBQUksR0FBRyxFQUFFLENBQUM7SUFLckIsQ0FBQztJQUUxQzs7O09BR0c7SUFDSCxJQUFJO1FBQ0EsT0FBTyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7SUFDeEMsQ0FBQztJQUVEOztPQUVHO0lBQ0gsZUFBZTtRQUNYLE9BQU8sYUFBYSxDQUNoQixJQUFJLENBQUMsZUFBZSxDQUFDLEtBQUssQ0FBdUIsaUJBQWlCLENBQUMsQ0FBQyxPQUFPLENBQzlFLENBQUMsSUFBSSxDQUNGLE1BQU0sQ0FBQyxFQUFFO1lBQ0wsSUFBSSxDQUFDLGFBQWEsR0FBRyxNQUFNLENBQUMsY0FBYyxDQUFDLFlBQVksQ0FBQztZQUN4RCxLQUFLLE1BQU0sa0JBQWtCLElBQUksSUFBSSxDQUFDLGFBQWEsQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO2dCQUNyRSxJQUFJLENBQUMsZUFBZSxDQUFDLEdBQUcsQ0FBQyxrQkFBa0IsQ0FBQyxVQUFVLEVBQUUsa0JBQWtCLENBQUMsWUFBWSxDQUFDLENBQUM7WUFDN0YsQ0FBQztRQUNMLENBQUMsRUFDRCxHQUFHLENBQUMsRUFBRTtZQUNGLG1FQUFtRTtRQUN2RSxDQUFDLENBQ0osQ0FBQztJQUNOLENBQUM7SUFFRCxxQkFBcUI7UUFDakIsT0FBTyxJQUFJLENBQUMsZUFBZTthQUN0QixLQUFLLENBQXlCLG1CQUFtQixFQUFFLEVBQUUsRUFBRSxhQUFhLENBQUM7YUFDckUsU0FBUyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLGNBQWMsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO0lBQ2pFLENBQUM7SUFFRDs7T0FFRztJQUNILHFCQUFxQjtRQUNqQixPQUFPLElBQUksQ0FBQyxlQUFlLENBQUMsS0FBSyxDQUF5QixtQkFBbUIsRUFBRSxFQUFFLEVBQUUsY0FBYyxDQUFDO2FBQzdGLE9BQU8sQ0FBQztJQUNqQixDQUFDO0lBRUQ7O09BRUc7SUFDSCxrQkFBa0IsQ0FBQyxJQUF3RDtRQUN2RSxPQUFPLElBQUksQ0FBQyxlQUFlLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNoRCxDQUFDO0lBRUQscUJBQXFCO1FBQ2pCLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxZQUFZLENBQUM7SUFDMUMsQ0FBQztJQUVELHNCQUFzQjtRQUNsQixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsbUJBQW1CLENBQUM7SUFDakQsQ0FBQztJQUVELHdCQUF3QjtRQUNwQixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsV0FBVyxDQUFDO0lBQ3pDLENBQUM7SUFFRCxJQUFJLFlBQVk7UUFDWixPQUFPLElBQUksQ0FBQyxhQUFhLENBQUM7SUFDOUIsQ0FBQzsrR0F2RVEsbUJBQW1CO21IQUFuQixtQkFBbUI7OzRGQUFuQixtQkFBbUI7a0JBRC9CLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlLCBJbmplY3RvciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgbGFzdFZhbHVlRnJvbSB9IGZyb20gJ3J4anMnO1xuXG5pbXBvcnQge1xuICAgIEN1c3RvbUZpZWxkQ29uZmlnLFxuICAgIEN1c3RvbUZpZWxkcyxcbiAgICBHZXRHbG9iYWxTZXR0aW5nc1F1ZXJ5LFxuICAgIEdldFNlcnZlckNvbmZpZ1F1ZXJ5LFxuICAgIE9yZGVyUHJvY2Vzc1N0YXRlLFxuICAgIFBlcm1pc3Npb25EZWZpbml0aW9uLFxufSBmcm9tICcuLi9jb21tb24vZ2VuZXJhdGVkLXR5cGVzJztcblxuaW1wb3J0IHsgR0VUX0dMT0JBTF9TRVRUSU5HUywgR0VUX1NFUlZFUl9DT05GSUcgfSBmcm9tICcuL2RlZmluaXRpb25zL3NldHRpbmdzLWRlZmluaXRpb25zJztcbmltcG9ydCB7IEJhc2VEYXRhU2VydmljZSB9IGZyb20gJy4vcHJvdmlkZXJzL2Jhc2UtZGF0YS5zZXJ2aWNlJztcblxuZXhwb3J0IGZ1bmN0aW9uIGluaXRpYWxpemVTZXJ2ZXJDb25maWdTZXJ2aWNlKHNlcnZlckNvbmZpZ1NlcnZpY2U6IFNlcnZlckNvbmZpZ1NlcnZpY2UpOiAoKSA9PiBQcm9taXNlPGFueT4ge1xuICAgIHJldHVybiBzZXJ2ZXJDb25maWdTZXJ2aWNlLmluaXQoKTtcbn1cblxuLyoqXG4gKiBBIHNlcnZpY2Ugd2hpY2ggZmV0Y2hlcyB0aGUgY29uZmlnIGZyb20gdGhlIHNlcnZlciB1cG9uIGluaXRpYWxpemF0aW9uLCBhbmQgdGhlbiBwcm92aWRlcyB0aGF0IGNvbmZpZ1xuICogdG8gdGhlIGNvbXBvbmVudHMgd2hpY2ggcmVxdWlyZSBpdC5cbiAqL1xuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFNlcnZlckNvbmZpZ1NlcnZpY2Uge1xuICAgIHByaXZhdGUgX3NlcnZlckNvbmZpZzogR2V0U2VydmVyQ29uZmlnUXVlcnlbJ2dsb2JhbFNldHRpbmdzJ11bJ3NlcnZlckNvbmZpZyddID0ge30gYXMgYW55O1xuICAgIGN1c3RvbUZpZWxkc01hcDogTWFwPHN0cmluZywgQ3VzdG9tRmllbGRDb25maWdbXT4gPSBuZXcgTWFwKCk7XG4gICAgcHJpdmF0ZSBnZXQgYmFzZURhdGFTZXJ2aWNlKCkge1xuICAgICAgICByZXR1cm4gdGhpcy5pbmplY3Rvci5nZXQ8QmFzZURhdGFTZXJ2aWNlPihCYXNlRGF0YVNlcnZpY2UpO1xuICAgIH1cblxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgaW5qZWN0b3I6IEluamVjdG9yKSB7fVxuXG4gICAgLyoqXG4gICAgICogRmV0Y2hlcyB0aGUgU2VydmVyQ29uZmlnLiBTaG91bGQgYmUgcnVuIGFzIHBhcnQgb2YgdGhlIGFwcCBib290c3RyYXAgcHJvY2VzcyBieSBhdHRhY2hpbmdcbiAgICAgKiB0byB0aGUgQW5ndWxhciBBUFBfSU5JVElBTElaRVIgdG9rZW4uXG4gICAgICovXG4gICAgaW5pdCgpOiAoKSA9PiBQcm9taXNlPGFueT4ge1xuICAgICAgICByZXR1cm4gKCkgPT4gdGhpcy5nZXRTZXJ2ZXJDb25maWcoKTtcbiAgICB9XG5cbiAgICAvKipcbiAgICAgKiBGZXRjaCB0aGUgU2VydmVyQ29uZmlnLiBTaG91bGQgYmUgcnVuIG9uIGFwcCBpbml0IChpbiBjYXNlIHVzZXIgaXMgYWxyZWFkeSBsb2dnZWQgaW4pIGFuZCBvbiBzdWNjZXNzZnVsIGxvZ2luLlxuICAgICAqL1xuICAgIGdldFNlcnZlckNvbmZpZygpIHtcbiAgICAgICAgcmV0dXJuIGxhc3RWYWx1ZUZyb20oXG4gICAgICAgICAgICB0aGlzLmJhc2VEYXRhU2VydmljZS5xdWVyeTxHZXRTZXJ2ZXJDb25maWdRdWVyeT4oR0VUX1NFUlZFUl9DT05GSUcpLnNpbmdsZSQsXG4gICAgICAgICkudGhlbihcbiAgICAgICAgICAgIHJlc3VsdCA9PiB7XG4gICAgICAgICAgICAgICAgdGhpcy5fc2VydmVyQ29uZmlnID0gcmVzdWx0Lmdsb2JhbFNldHRpbmdzLnNlcnZlckNvbmZpZztcbiAgICAgICAgICAgICAgICBmb3IgKGNvbnN0IGVudGl0eUN1c3RvbUZpZWxkcyBvZiB0aGlzLl9zZXJ2ZXJDb25maWcuZW50aXR5Q3VzdG9tRmllbGRzKSB7XG4gICAgICAgICAgICAgICAgICAgIHRoaXMuY3VzdG9tRmllbGRzTWFwLnNldChlbnRpdHlDdXN0b21GaWVsZHMuZW50aXR5TmFtZSwgZW50aXR5Q3VzdG9tRmllbGRzLmN1c3RvbUZpZWxkcyk7XG4gICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgfSxcbiAgICAgICAgICAgIGVyciA9PiB7XG4gICAgICAgICAgICAgICAgLy8gTGV0IHRoZSBlcnJvciBmYWxsIHRocm91Z2ggdG8gYmUgY2F1Z2h0IGJ5IHRoZSBodHRwIGludGVyY2VwdG9yLlxuICAgICAgICAgICAgfSxcbiAgICAgICAgKTtcbiAgICB9XG5cbiAgICBnZXRBdmFpbGFibGVMYW5ndWFnZXMoKSB7XG4gICAgICAgIHJldHVybiB0aGlzLmJhc2VEYXRhU2VydmljZVxuICAgICAgICAgICAgLnF1ZXJ5PEdldEdsb2JhbFNldHRpbmdzUXVlcnk+KEdFVF9HTE9CQUxfU0VUVElOR1MsIHt9LCAnY2FjaGUtZmlyc3QnKVxuICAgICAgICAgICAgLm1hcFNpbmdsZShyZXMgPT4gcmVzLmdsb2JhbFNldHRpbmdzLmF2YWlsYWJsZUxhbmd1YWdlcyk7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogV2hlbiBhbnkgb2YgdGhlIEdsb2JhbFNldHRpbmdzIGFyZSBtb2RpZmllZCwgdGhpcyBtZXRob2Qgc2hvdWxkIGJlIGNhbGxlZCB0byB1cGRhdGUgdGhlIEFwb2xsbyBjYWNoZS5cbiAgICAgKi9cbiAgICByZWZyZXNoR2xvYmFsU2V0dGluZ3MoKSB7XG4gICAgICAgIHJldHVybiB0aGlzLmJhc2VEYXRhU2VydmljZS5xdWVyeTxHZXRHbG9iYWxTZXR0aW5nc1F1ZXJ5PihHRVRfR0xPQkFMX1NFVFRJTkdTLCB7fSwgJ25ldHdvcmstb25seScpXG4gICAgICAgICAgICAuc2luZ2xlJDtcbiAgICB9XG5cbiAgICAvKipcbiAgICAgKiBSZXRyaWV2ZXMgdGhlIGN1c3RvbSBmaWVsZCBjb25maWdzIGZvciB0aGUgZ2l2ZW4gZW50aXR5IHR5cGUuXG4gICAgICovXG4gICAgZ2V0Q3VzdG9tRmllbGRzRm9yKHR5cGU6IEV4Y2x1ZGU8a2V5b2YgQ3VzdG9tRmllbGRzLCAnX190eXBlbmFtZSc+IHwgc3RyaW5nKTogQ3VzdG9tRmllbGRDb25maWdbXSB7XG4gICAgICAgIHJldHVybiB0aGlzLmN1c3RvbUZpZWxkc01hcC5nZXQodHlwZSkgfHwgW107XG4gICAgfVxuXG4gICAgZ2V0T3JkZXJQcm9jZXNzU3RhdGVzKCk6IE9yZGVyUHJvY2Vzc1N0YXRlW10ge1xuICAgICAgICByZXR1cm4gdGhpcy5zZXJ2ZXJDb25maWcub3JkZXJQcm9jZXNzO1xuICAgIH1cblxuICAgIGdldFBlcm1pdHRlZEFzc2V0VHlwZXMoKTogc3RyaW5nW10ge1xuICAgICAgICByZXR1cm4gdGhpcy5zZXJ2ZXJDb25maWcucGVybWl0dGVkQXNzZXRUeXBlcztcbiAgICB9XG5cbiAgICBnZXRQZXJtaXNzaW9uRGVmaW5pdGlvbnMoKTogUGVybWlzc2lvbkRlZmluaXRpb25bXSB7XG4gICAgICAgIHJldHVybiB0aGlzLnNlcnZlckNvbmZpZy5wZXJtaXNzaW9ucztcbiAgICB9XG5cbiAgICBnZXQgc2VydmVyQ29uZmlnKCk6IEdldFNlcnZlckNvbmZpZ1F1ZXJ5WydnbG9iYWxTZXR0aW5ncyddWydzZXJ2ZXJDb25maWcnXSB7XG4gICAgICAgIHJldHVybiB0aGlzLl9zZXJ2ZXJDb25maWc7XG4gICAgfVxufVxuIl19