@open-tender/cloud 0.0.1

package/dist/esm/slices/customer/addresses.js

@@ -0,0 +1,129 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from '../types';
+import { MISSING_CUSTOMER } from '@open-tender/types';
+import { checkAuth, selectToken } from './account';
+import { showNotification } from '../notifications';
+import { makeFormErrors } from '@open-tender/utils';
+const initialState = {
+    entities: [],
+    lookup: {},
+    loading: 'idle',
+    error: null
+};
+export var CustomerAddressesActionType;
+(function (CustomerAddressesActionType) {
+    CustomerAddressesActionType["FetchCustomerAddresses"] = "customer/fetchCustomerAddresses";
+    CustomerAddressesActionType["UpdateCustomerAddresses"] = "customer/updateCustomerAddresses";
+    CustomerAddressesActionType["RemoveCustomerAddress"] = "customer/removeCustomerAddress";
+})(CustomerAddressesActionType || (CustomerAddressesActionType = {}));
+export const fetchCustomerAddresses = createAsyncThunk(CustomerAddressesActionType.FetchCustomerAddresses, (limit, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const addresses = yield api.getCustomerAddresses(token, limit);
+        return addresses;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const updateCustomerAddress = createAsyncThunk(CustomerAddressesActionType.UpdateCustomerAddresses, (data, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        yield api.putCustomerAddress(token, data.addressId, data.data);
+        const limit = getState().customer.addresses.entities.length;
+        const { data: addresses } = yield api.getCustomerAddresses(token, limit);
+        dispatch(showNotification('Address updated!'));
+        if (data.callback)
+            data.callback();
+        return addresses;
+    }
+    catch (err) {
+        const errors = makeFormErrors(err);
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(errors));
+    }
+}));
+export const removeCustomerAddress = createAsyncThunk(CustomerAddressesActionType.RemoveCustomerAddress, (data, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        yield api.deleteCustomerAddress(token, data.addressId);
+        const limit = getState().customer.addresses.entities.length;
+        const { data: addresses } = yield api.getCustomerAddresses(token, limit);
+        dispatch(showNotification('Address removed!'));
+        if (data.callback)
+            data.callback();
+        return addresses;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerAddressesSlice = createSlice({
+    name: ReducerType.CustomerAddresses,
+    initialState,
+    reducers: {
+        resetCustomerAddresses: () => initialState,
+        setCustomerAddresses: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        },
+        resetCustomerAddressesError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerAddresses.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerAddresses.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerAddresses.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(updateCustomerAddress.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(updateCustomerAddress.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateCustomerAddress.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(removeCustomerAddress.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(removeCustomerAddress.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(removeCustomerAddress.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerAddresses, setCustomerAddresses } = customerAddressesSlice.actions;
+export const selectCustomerAddresses = (state) => state.customer.addresses;
+export const customerAddressesReducer = customerAddressesSlice.reducer;

package/dist/esm/slices/customer/allergens.d.ts

@@ -0,0 +1,25 @@
+import { AppState } from '../../app';
+import { Allergens, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerAllergensState {
+    entities: Allergens;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerAllergensActionType {
+    FetchCustomerAllergens = "customer/fetchCustomerAllergens",
+    UpdateCustomerAllergens = "customer/updateCustomerAllergens"
+}
+export declare const fetchCustomerAllergens: import("@reduxjs/toolkit").AsyncThunk<Allergens, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const updateCustomerAllergens: import("@reduxjs/toolkit").AsyncThunk<Allergens, Allergens, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerAllergens: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerAllergens: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCustomerAllergens: (state: AppState) => CustomerAllergensState;
+export declare const customerAllergensReducer: import("redux").Reducer<CustomerAllergensState, import("redux").AnyAction>;

package/dist/esm/slices/customer/allergens.js

@@ -0,0 +1,89 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from '../types';
+import { MISSING_CUSTOMER } from '@open-tender/types';
+import { checkAuth, selectToken } from './account';
+import { setSelectedAllergens } from '../allergens';
+import { showNotification } from '../notifications';
+const initialState = {
+    entities: [],
+    lookup: {},
+    loading: 'idle',
+    error: null
+};
+export var CustomerAllergensActionType;
+(function (CustomerAllergensActionType) {
+    CustomerAllergensActionType["FetchCustomerAllergens"] = "customer/fetchCustomerAllergens";
+    CustomerAllergensActionType["UpdateCustomerAllergens"] = "customer/updateCustomerAllergens";
+})(CustomerAllergensActionType || (CustomerAllergensActionType = {}));
+export const fetchCustomerAllergens = createAsyncThunk(CustomerAllergensActionType.FetchCustomerAllergens, (_, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const allergens = yield api.getCustomerAllergens(token);
+        return allergens;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const updateCustomerAllergens = createAsyncThunk(CustomerAllergensActionType.UpdateCustomerAllergens, (data, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const allergens = yield api.putCustomerAllergens(token, data);
+        dispatch(setSelectedAllergens(allergens || []));
+        dispatch(showNotification('Allergens updated!'));
+        return allergens;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerAllergensSlice = createSlice({
+    name: ReducerType.CustomerAllergens,
+    initialState,
+    reducers: {
+        resetCustomerAllergens: () => initialState,
+        setCustomerAllergens: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerAllergens.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerAllergens.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerAllergens.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(updateCustomerAllergens.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(updateCustomerAllergens.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateCustomerAllergens.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerAllergens, setCustomerAllergens } = customerAllergensSlice.actions;
+export const selectCustomerAllergens = (state) => state.customer.allergens;
+export const customerAllergensReducer = customerAllergensSlice.reducer;

package/dist/esm/slices/customer/communicationPreferences.d.ts

@@ -0,0 +1,44 @@
+import { AppState } from '../../app';
+import { CustomerNotificationPrefs, NotificationArea, NotificationChannel, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerCommunicationPrefsState {
+    entities: CustomerNotificationPrefs;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerCommunicationPrefsActionType {
+    FetchCustomerCommunicationPreferences = "customer/fetchCustomerCommunicationPreferences",
+    AddCustomerCommunicationPreference = "customer/addCustomerCommunicationPreference",
+    RemoveCustomerCommunicationPreference = "customer/removeCustomerCommunicationPreference",
+    SetCustomerCommunicationDefaultPreferences = "customer/setCustomerCommunicationDefaultPreferences"
+}
+export declare const fetchCustomerCommunicationPreferences: import("@reduxjs/toolkit").AsyncThunk<CustomerNotificationPrefs, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const addCustomerCommunicationPreference: import("@reduxjs/toolkit").AsyncThunk<CustomerNotificationPrefs, {
+    area: NotificationArea;
+    channel: NotificationChannel;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const removeCustomerCommunicationPreference: import("@reduxjs/toolkit").AsyncThunk<CustomerNotificationPrefs, {
+    prefId: number;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const setCustomerCommunicationDefaultPreferences: import("@reduxjs/toolkit").AsyncThunk<CustomerNotificationPrefs, {
+    prefs: CustomerNotificationPrefs;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerCommunicationPreferences: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerCommunicationPreferencesError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerCommunicationPreferences: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const customerCommunicationPrefsReducer: import("redux").Reducer<CustomerCommunicationPrefsState, import("redux").AnyAction>;

package/dist/esm/slices/customer/communicationPreferences.js

@@ -0,0 +1,161 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from '../types';
+import { MISSING_CUSTOMER } from '@open-tender/types';
+import { checkAuth, selectToken } from './account';
+import { showNotification } from '../notifications';
+import { makeFormErrors } from '@open-tender/utils';
+const initialState = {
+    entities: [],
+    lookup: {},
+    loading: 'idle',
+    error: null
+};
+export var CustomerCommunicationPrefsActionType;
+(function (CustomerCommunicationPrefsActionType) {
+    CustomerCommunicationPrefsActionType["FetchCustomerCommunicationPreferences"] = "customer/fetchCustomerCommunicationPreferences";
+    CustomerCommunicationPrefsActionType["AddCustomerCommunicationPreference"] = "customer/addCustomerCommunicationPreference";
+    CustomerCommunicationPrefsActionType["RemoveCustomerCommunicationPreference"] = "customer/removeCustomerCommunicationPreference";
+    CustomerCommunicationPrefsActionType["SetCustomerCommunicationDefaultPreferences"] = "customer/setCustomerCommunicationDefaultPreferences";
+})(CustomerCommunicationPrefsActionType || (CustomerCommunicationPrefsActionType = {}));
+export const fetchCustomerCommunicationPreferences = createAsyncThunk(CustomerCommunicationPrefsActionType.FetchCustomerCommunicationPreferences, (_, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const { data: communicationPreferences } = yield api.getCustomerCommunicationPreferences(token);
+        return communicationPreferences;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const addCustomerCommunicationPreference = createAsyncThunk(CustomerCommunicationPrefsActionType.AddCustomerCommunicationPreference, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const data = {
+            notification_area: requestData.area,
+            notification_channel: requestData.channel
+        };
+        yield api.postCustomerCommunicationPreference(token, data);
+        const { data: communicationPreferences } = yield api.getCustomerCommunicationPreferences(token);
+        dispatch(showNotification('Preference added!'));
+        if (requestData.callback)
+            requestData.callback();
+        return communicationPreferences;
+    }
+    catch (err) {
+        const error = err;
+        const errors = makeFormErrors(error);
+        return checkAuth(error, dispatch, () => rejectWithValue(errors));
+    }
+}));
+export const removeCustomerCommunicationPreference = createAsyncThunk(CustomerCommunicationPrefsActionType.RemoveCustomerCommunicationPreference, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        yield api.deleteCustomerCommunicationPreference(token, requestData.prefId);
+        const { data: communicationPreferences } = yield api.getCustomerCommunicationPreferences(token);
+        dispatch(showNotification('Preference removed!'));
+        if (requestData.callback)
+            requestData.callback();
+        return communicationPreferences;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const setCustomerCommunicationDefaultPreferences = createAsyncThunk(CustomerCommunicationPrefsActionType.SetCustomerCommunicationDefaultPreferences, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        yield api.putCustomerCommunicationPreference(token, requestData.prefs);
+        const { data: communicationPreferences } = yield api.getCustomerCommunicationPreferences(token);
+        if (requestData.callback)
+            requestData.callback();
+        return communicationPreferences;
+    }
+    catch (err) {
+        const error = err;
+        const errors = makeFormErrors(error);
+        return checkAuth(error, dispatch, () => rejectWithValue(errors));
+    }
+}));
+const customerCommunicationPrefsSlice = createSlice({
+    name: ReducerType.CommunicationPrefs,
+    initialState,
+    reducers: {
+        resetCustomerCommunicationPreferences: () => initialState,
+        resetCustomerCommunicationPreferencesError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerCommunicationPreferences: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerCommunicationPreferences.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerCommunicationPreferences.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerCommunicationPreferences.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(addCustomerCommunicationPreference.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(addCustomerCommunicationPreference.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(addCustomerCommunicationPreference.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(removeCustomerCommunicationPreference.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(removeCustomerCommunicationPreference.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(removeCustomerCommunicationPreference.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(setCustomerCommunicationDefaultPreferences.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(setCustomerCommunicationDefaultPreferences.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(setCustomerCommunicationDefaultPreferences.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerCommunicationPreferences, resetCustomerCommunicationPreferencesError, setCustomerCommunicationPreferences } = customerCommunicationPrefsSlice.actions;
+export const customerCommunicationPrefsReducer = customerCommunicationPrefsSlice.reducer;

package/dist/esm/slices/customer/creditCards.d.ts

@@ -0,0 +1,46 @@
+import { AppState } from '../../app';
+import { CreditCard, CreditCards, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerCreditCardsState {
+    entities: CreditCards;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerCreditCardsActionType {
+    FetchCustomerCreditCards = "customer/fetchCustomerCreditCards",
+    UpdateCustomerCreditCard = "customer/updateCustomerCreditCard",
+    RemoveCustomerCreditCard = "customer/removeCustomerCreditCard",
+    AddCustomerCreditCard = "customer/addCustomerCreditCard"
+}
+export declare const fetchCustomerCreditCards: import("@reduxjs/toolkit").AsyncThunk<CreditCards, boolean, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const updateCustomerCreditCard: import("@reduxjs/toolkit").AsyncThunk<CreditCards, {
+    cardId: number;
+    data: CreditCard;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const removeCustomerCreditCard: import("@reduxjs/toolkit").AsyncThunk<CreditCards, {
+    cardId: number;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const addCustomerCreditCard: import("@reduxjs/toolkit").AsyncThunk<CreditCards, {
+    data: CreditCard;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerCreditCards: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerCreditCardsError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerCreditCards: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCustomerCreditCards: (state: AppState) => CustomerCreditCardsState;
+export declare const selectCustomerCreditCardsForPayment: (state: AppState) => CreditCard[];
+export declare const customerCreditCardsReducer: import("redux").Reducer<CustomerCreditCardsState, import("redux").AnyAction>;

package/dist/esm/slices/customer/creditCards.js

@@ -0,0 +1,166 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from '../types';
+import { MISSING_CUSTOMER } from '@open-tender/types';
+import { checkAuth, selectToken } from './account';
+import { showNotification } from '../notifications';
+import { makeFormErrors } from '@open-tender/utils';
+const initialState = {
+    entities: [],
+    lookup: {},
+    loading: 'idle',
+    error: null
+};
+export var CustomerCreditCardsActionType;
+(function (CustomerCreditCardsActionType) {
+    CustomerCreditCardsActionType["FetchCustomerCreditCards"] = "customer/fetchCustomerCreditCards";
+    CustomerCreditCardsActionType["UpdateCustomerCreditCard"] = "customer/updateCustomerCreditCard";
+    CustomerCreditCardsActionType["RemoveCustomerCreditCard"] = "customer/removeCustomerCreditCard";
+    CustomerCreditCardsActionType["AddCustomerCreditCard"] = "customer/addCustomerCreditCard";
+})(CustomerCreditCardsActionType || (CustomerCreditCardsActionType = {}));
+export const fetchCustomerCreditCards = createAsyncThunk(CustomerCreditCardsActionType.FetchCustomerCreditCards, (includeLinked, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const creditCards = yield api.getCustomerCreditCards(token, includeLinked);
+        return creditCards;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const updateCustomerCreditCard = createAsyncThunk(CustomerCreditCardsActionType.UpdateCustomerCreditCard, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        yield api.putCustomerCreditCard(token, requestData.cardId, requestData.data);
+        const includeLinked = true;
+        const creditCards = yield api.getCustomerCreditCards(token, includeLinked);
+        dispatch(showNotification('Credit card updated!'));
+        if (requestData.callback)
+            requestData.callback();
+        return creditCards;
+    }
+    catch (err) {
+        const error = err;
+        const errors = makeFormErrors(error);
+        return checkAuth(error, dispatch, () => rejectWithValue(errors));
+    }
+}));
+export const removeCustomerCreditCard = createAsyncThunk(CustomerCreditCardsActionType.RemoveCustomerCreditCard, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        yield api.deleteCustomerCreditCard(token, requestData.cardId);
+        const includeLinked = true;
+        const creditCards = yield api.getCustomerCreditCards(token, includeLinked);
+        dispatch(showNotification('Credit card removed!'));
+        if (requestData.callback)
+            requestData.callback();
+        return creditCards;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const addCustomerCreditCard = createAsyncThunk(CustomerCreditCardsActionType.AddCustomerCreditCard, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        yield api.postCustomerCreditCard(token, requestData.data);
+        const includeLinked = true;
+        const creditCards = yield api.getCustomerCreditCards(token, includeLinked);
+        dispatch(showNotification('Credit card added!'));
+        if (requestData.callback)
+            requestData.callback();
+        return creditCards;
+    }
+    catch (err) {
+        const error = err;
+        const errors = makeFormErrors(error);
+        return checkAuth(error, dispatch, () => rejectWithValue(errors));
+    }
+}));
+const customerCreditCardsSlice = createSlice({
+    name: ReducerType.CreditCards,
+    initialState,
+    reducers: {
+        resetCustomerCreditCards: () => initialState,
+        resetCustomerCreditCardsError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerCreditCards: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerCreditCards.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerCreditCards.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerCreditCards.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(updateCustomerCreditCard.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(updateCustomerCreditCard.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateCustomerCreditCard.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(removeCustomerCreditCard.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(removeCustomerCreditCard.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(removeCustomerCreditCard.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(addCustomerCreditCard.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(addCustomerCreditCard.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(addCustomerCreditCard.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerCreditCards, resetCustomerCreditCardsError, setCustomerCreditCards } = customerCreditCardsSlice.actions;
+export const selectCustomerCreditCards = (state) => state.customer.creditCards;
+export const selectCustomerCreditCardsForPayment = (state) => {
+    const creditCards = state.customer.creditCards.entities;
+    return creditCards.filter(i => i.has_profile);
+};
+export const customerCreditCardsReducer = customerCreditCardsSlice.reducer;