@akinon/next 1.0.0

package/data/client/address.ts

@@ -0,0 +1,107 @@
+import { buildClientRequestUrl } from '../../utils';
+import { api } from './api';
+import { address, misc } from '../urls';
+import { Address, City, Country, District, Township } from '../../types';
+
+interface GetResponse<T> {
+  count: number;
+  next: null;
+  previous: null;
+  results: T[];
+}
+
+const addressApi = api.injectEndpoints({
+  endpoints: (builder) => ({
+    getAddresses: builder.query<GetResponse<Address>, void>({
+      query: () => buildClientRequestUrl(address.getAddresses),
+      providesTags: ['Addresses']
+    }),
+    getCountries: builder.query<GetResponse<Country>, void>({
+      query: () => buildClientRequestUrl(address.countries)
+    }),
+    getCities: builder.query<GetResponse<City>, string>({
+      query: (country) => buildClientRequestUrl(address.getCities(country))
+    }),
+    getTownships: builder.query<GetResponse<Township>, string>({
+      query: (city) => buildClientRequestUrl(address.getTownships(city))
+    }),
+    getDistricts: builder.query<GetResponse<District>, string>({
+      query: (township) => buildClientRequestUrl(address.getDistricts(township))
+    }),
+    getRetailStore: builder.query<GetResponse<any>, void>({
+      query: () => buildClientRequestUrl(address.getRetailStore)
+    }),
+    getRetailStoreCities: builder.query<GetResponse<any>, string>({
+      query: (country) => buildClientRequestUrl(address.getRetailStoreCities(country))
+    }),
+    getRetailStoreTownships: builder.query<GetResponse<any>, string>({
+      query: (city) => buildClientRequestUrl(address.getRetailStoreTownships(city))
+    }),
+    addAddress: builder.mutation<Address, Partial<Address>>({
+      query: (body) => ({
+        url: buildClientRequestUrl(address.base, {
+          contentType: 'application/json'
+        }),
+        method: 'POST',
+        body: {
+          ...body,
+          type: body.is_corporate === 'true' ? 'corporate' : 'personal'
+        }
+      }),
+      invalidatesTags: ['Addresses', 'Checkout'] // TODO: Invalidate one of these tags when necessary (e.g. Address page invalidates Addresses tag, Checkout page invalidates Checkout tag)
+    }),
+    editAddress: builder.mutation<Address, Partial<Address>>({
+      query: ({ pk, ...body }) => ({
+        url: buildClientRequestUrl(address.editAddress(pk), {
+          contentType: 'application/json'
+        }),
+        method: 'PATCH',
+        body: {
+          ...body,
+          user: body.user?.pk,
+          type: body.is_corporate === 'true' ? 'corporate' : 'personal'
+        }
+      }),
+      invalidatesTags: ['Addresses', 'Checkout'] // TODO: Invalidate one of these tags when necessary (e.g. Address page invalidates Addresses tag, Checkout page invalidates Checkout tag)
+    }),
+    removeAddress: builder.mutation<void, number>({
+      query: (id) => ({
+        url: buildClientRequestUrl(address.removeAddress(id)),
+        method: 'DELETE'
+      }),
+      invalidatesTags: ['Addresses', 'Checkout'] // TODO: Invalidate one of these tags when necessary (e.g. Address page invalidates Addresses tag, Checkout page invalidates Checkout tag)
+    }),
+    setDefaultAddress: builder.mutation<Address, Partial<Address>>({
+      query: ({ pk, primary }) => ({
+        url: buildClientRequestUrl(address.setDefaultAddress(pk), {
+          contentType: 'application/json'
+        }),
+        method: 'PATCH',
+        body: { primary }
+      }),
+      invalidatesTags: ['Addresses']
+    }),
+    getStores: builder.query<GetResponse<Address>, void>({
+      query: () => ({
+        url: buildClientRequestUrl(misc.stores)
+      })
+    })
+  }),
+  overrideExisting: true
+});
+
+export const {
+  useGetAddressesQuery,
+  useGetCountriesQuery,
+  useGetCitiesQuery,
+  useGetTownshipsQuery,
+  useGetDistrictsQuery,
+  useGetRetailStoreQuery,
+  useGetRetailStoreCitiesQuery,
+  useGetRetailStoreTownshipsQuery,
+  useAddAddressMutation,
+  useEditAddressMutation,
+  useRemoveAddressMutation,
+  useSetDefaultAddressMutation,
+  useGetStoresQuery
+} = addressApi;

package/data/client/api.ts

@@ -0,0 +1,42 @@
+import { createApi, fetchBaseQuery, retry } from '@reduxjs/toolkit/query/react';
+import settings from 'settings';
+import { getCookie } from '../../utils';
+
+export const api = createApi({
+  reducerPath: 'api',
+  baseQuery: retry(fetchBaseQuery({
+    prepareHeaders: async (headers) => {
+      const csrfCookie = getCookie('csrftoken');
+      const activeLocale = getCookie('pz-locale');
+      const localeApiValue = settings.localization.locales.find(
+        (locale) => locale.value === activeLocale
+      )?.apiValue;
+      const activeCurrency = getCookie('pz-currency');
+
+      headers.set('Accept-Language', `${localeApiValue}`);
+      headers.set('x-currency', `${activeCurrency}`);
+
+      if (csrfCookie) {
+        headers.set('x-csrftoken', `${csrfCookie}`);
+      }
+
+      return headers;
+    },
+    credentials: 'include'
+  }), {
+    maxRetries: 3
+  }),
+  tagTypes: [
+    'Basket',
+    'Product',
+    'Checkout',
+    'Favorite',
+    'Addresses',
+    'Profile'
+  ],
+  endpoints: () => ({}) // it must be a function to be able to use `injectEndpoints`
+});
+
+export const {
+  util: { invalidateTags }
+} = api;

package/data/client/basket.ts

@@ -0,0 +1,85 @@
+import { api } from './api';
+import { Basket } from '../../types';
+import { buildClientRequestUrl } from '../../utils';
+import { basket } from '../urls';
+
+export type UpdateQuantityResponse = {
+  basket: Basket;
+  osessionid: string;
+};
+
+export type UpdateQuantityRequest = {
+  product: number;
+  quantity: number;
+  attributes: any;
+};
+
+export const basketApi = api.injectEndpoints({
+  endpoints: (build) => ({
+    getBasket: build.query<Basket, void>({
+      query: () =>
+        buildClientRequestUrl(basket.getBasket, {
+          contentType: 'application/json'
+        }),
+      transformResponse: (response: { basket: Basket }) => response.basket,
+      providesTags: ['Basket']
+    }),
+    updateQuantity: build.mutation<
+      UpdateQuantityResponse,
+      UpdateQuantityRequest
+    >({
+      query: (body) => ({
+        url: buildClientRequestUrl(basket.getBasket, {
+          contentType: 'application/json'
+        }),
+        method: 'PUT',
+        body
+      })
+    }),
+    clearBasket: build.mutation<Basket, void>({
+      query: (body) => ({
+        url: buildClientRequestUrl(basket.getBasket, {
+          useTrailingSlash: false,
+          contentType: 'application/json'
+        }),
+        method: 'DELETE',
+        body
+      }),
+      transformResponse: (response: { basket: Basket }) => response.basket,
+      invalidatesTags: ['Basket']
+    }),
+    applyVoucherCode: build.mutation<Basket, { voucher_code: string }>({
+      query: (body) => ({
+        url: buildClientRequestUrl(basket.getBasket, {
+          useTrailingSlash: false,
+          contentType: 'application/json'
+        }),
+        method: 'PATCH',
+        body
+      }),
+      transformResponse: (response: { basket: Basket }) => response.basket
+    }),
+    removeVoucherCode: build.mutation<Basket, void>({
+      query: () => ({
+        url: buildClientRequestUrl(basket.getBasket, {
+          useTrailingSlash: false,
+          contentType: 'application/json'
+        }),
+        method: 'PATCH',
+        body: {
+          remove_voucher_code: true
+        }
+      }),
+      transformResponse: (response: { basket: Basket }) => response.basket
+    })
+  }),
+  overrideExisting: true
+});
+
+export const {
+  useGetBasketQuery,
+  useUpdateQuantityMutation,
+  useClearBasketMutation,
+  useApplyVoucherCodeMutation,
+  useRemoveVoucherCodeMutation
+} = basketApi;

package/data/client/checkout.ts

@@ -0,0 +1,477 @@
+import {
+  setBankAccounts,
+  setInstallmentOptions,
+  setPaymentStepBusy,
+  setSelectedBankAccountPk,
+  setShippingStepBusy
+} from '../../redux/reducers/checkout';
+import {
+  CheckoutContext,
+  GuestLoginFormParams,
+  Order,
+  PreOrder
+} from '../../types';
+import { buildClientRequestUrl } from '../../utils';
+import { api } from './api';
+import { checkout } from '../urls';
+import { store } from 'redux/store';
+
+interface CheckoutResponse {
+  pre_order?: PreOrder;
+  errors: {
+    non_field_errors: string;
+  };
+  context_list?: CheckoutContext[];
+  template_name?: string;
+  redirect_url?: string;
+}
+
+interface SetAddressesParams {
+  shippingAddressPk: number;
+  billingAddressPk: number;
+}
+
+interface SetRetailStoreParams {
+  retailStorePk: number;
+  billingAddressPk: number;
+}
+
+interface CompleteCreditCardParams {
+  card_holder: string;
+  card_cvv: string;
+  card_number: string;
+  card_month: string;
+  card_year: string;
+}
+
+interface GetContractResponse {
+  result: string;
+}
+
+interface ApplePaySelectParams {
+  agreement: boolean;
+  validationURL: string;
+}
+
+interface ApplePayQueryParams {
+  agreement: boolean;
+  paymentToken: string;
+}
+
+export interface PayOnDeliveryParams {
+  agreement: string;
+  paymentType: string;
+}
+
+export const checkoutApi = api.injectEndpoints({
+  endpoints: (build) => ({
+    fetchCheckout: build.query<CheckoutResponse, void>({
+      query: () => ({
+        url: buildClientRequestUrl(checkout.fetchCheckout, {})
+      }),
+      providesTags: ['Checkout']
+    }),
+    fetchCheckoutResult: build.query<{ order: Order }, string>({
+      query: (token: string) =>
+        buildClientRequestUrl(checkout.fetchCheckoutResult(token))
+    }),
+    get3dRedirectForm: build.query<{ result: string }, void>({
+      query: () =>
+        buildClientRequestUrl(checkout.get3dRedirectForm, {
+          responseType: 'text'
+        })
+    }),
+    getContract: build.query<GetContractResponse, string>({
+      query: (slug: string) =>
+        buildClientRequestUrl(checkout.getContract(slug), {
+          responseType: 'text'
+        })
+    }),
+    completeCreditCardPayment: build.mutation<
+      CheckoutResponse,
+      CompleteCreditCardParams
+    >({
+      query: ({
+        card_holder,
+        card_cvv,
+        card_number,
+        card_month,
+        card_year
+      }) => ({
+        url: buildClientRequestUrl(checkout.completeCreditCardPayment, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          agreement: '1',
+          use_three_d: '1',
+          card_cvv,
+          card_holder,
+          card_month,
+          card_number,
+          card_year
+        }
+      }),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setPaymentStepBusy(true));
+        await queryFulfilled;
+        dispatch(setPaymentStepBusy(false));
+      },
+      invalidatesTags: ['Basket']
+    }),
+    completeFundsTransfer: build.mutation<CheckoutResponse, void>({
+      query: () => ({
+        url: buildClientRequestUrl(checkout.completeFundsTransfer, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          agreement: '1'
+        }
+      }),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setPaymentStepBusy(true));
+        await queryFulfilled;
+        dispatch(setPaymentStepBusy(false));
+      },
+      invalidatesTags: ['Basket']
+    }),
+    guestLogin: build.mutation<CheckoutResponse, GuestLoginFormParams>({
+      query: ({ user_email, phone_number }) => ({
+        url: buildClientRequestUrl(checkout.guestLogin, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          user_email,
+          phone_number
+        }
+      }),
+      invalidatesTags: ['Checkout']
+    }),
+    setDeliveryOption: build.mutation<CheckoutResponse, number>({
+      query: (pk: number) => ({
+        url: buildClientRequestUrl(checkout.setDeliveryOption, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          delivery_option: String(pk)
+        }
+      }),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setShippingStepBusy(true));
+        await queryFulfilled;
+        dispatch(setShippingStepBusy(false));
+      }
+    }),
+    setAddresses: build.mutation<CheckoutResponse, SetAddressesParams>({
+      query: ({ shippingAddressPk, billingAddressPk }) => ({
+        url: buildClientRequestUrl(checkout.setAddresses, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          shipping_address: String(shippingAddressPk),
+          billing_address: String(billingAddressPk)
+        }
+      }),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setShippingStepBusy(true));
+        await queryFulfilled;
+        dispatch(setShippingStepBusy(false));
+      }
+    }),
+    setShippingOption: build.mutation<CheckoutResponse, number>({
+      query: (pk: number) => ({
+        url: buildClientRequestUrl(checkout.setShippingOption, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          shipping_option: String(pk)
+        }
+      }),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setShippingStepBusy(true));
+        await queryFulfilled;
+        dispatch(setShippingStepBusy(false));
+      }
+    }),
+    setRetailStore: build.mutation<CheckoutResponse, SetRetailStoreParams>({
+      query: ({ retailStorePk, billingAddressPk }) => ({
+        url: buildClientRequestUrl(
+          '/orders/checkout?page=RetailStoreSelectionPage',
+          {
+            useFormData: true
+          }
+        ),
+        method: 'POST',
+        body: {
+          retail_store: Number(retailStorePk),
+          billing_address: Number(billingAddressPk)
+        }
+      })
+    }),
+    setPaymentOption: build.mutation<CheckoutResponse, number>({
+      query: (pk: number) => ({
+        url: buildClientRequestUrl(checkout.setPaymentOption, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          payment_option: String(pk)
+        }
+      }),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setPaymentStepBusy(true));
+        dispatch(setInstallmentOptions([]));
+        dispatch(setBankAccounts([]));
+        await queryFulfilled;
+        dispatch(setPaymentStepBusy(false));
+      }
+    }),
+    setBinNumber: build.mutation<CheckoutResponse, string>({
+      query: (binNumber: string) => {
+        const paymentOption =
+          store.getState().checkout?.preOrder?.payment_option;
+        const binNumberUrl =
+          paymentOption?.payment_type === 'masterpass'
+            ? checkout.setMasterpassBinNumber
+            : checkout.setBinNumber;
+
+        return {
+          url: buildClientRequestUrl(binNumberUrl, {
+            useFormData: true
+          }),
+          method: 'POST',
+          body: {
+            bin_number: binNumber
+          }
+        };
+      },
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setPaymentStepBusy(true));
+        await queryFulfilled;
+        dispatch(setPaymentStepBusy(false));
+      }
+    }),
+    setInstallmentOption: build.mutation<CheckoutResponse, number>({
+      query: (pk: number) => {
+        const paymentOption =
+          store.getState().checkout?.preOrder?.payment_option;
+        const installmentOption =
+          paymentOption?.payment_type === 'masterpass'
+            ? checkout.setMasterPassInstallmentOption
+            : checkout.setInstallmentOption;
+        return {
+          url: buildClientRequestUrl(installmentOption, {
+            useFormData: true
+          }),
+          method: 'POST',
+          body: {
+            installment: String(pk)
+          }
+        };
+      },
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setPaymentStepBusy(true));
+        await queryFulfilled;
+        dispatch(setPaymentStepBusy(false));
+      }
+    }),
+    setFundsTransferOption: build.mutation<CheckoutResponse, number>({
+      query: (pk: number) => ({
+        url: buildClientRequestUrl(checkout.setFundsTransferOption, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          bank_account: String(pk)
+        }
+      }),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setPaymentStepBusy(true));
+        await queryFulfilled;
+        dispatch(setPaymentStepBusy(false));
+        dispatch(setSelectedBankAccountPk(arg));
+      }
+    }),
+    completeRedirectionPayment: build.mutation<CheckoutResponse, void>({
+      query: () => ({
+        url: buildClientRequestUrl(checkout.completeRedirectionPayment, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          agreement: true
+        }
+      }),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setPaymentStepBusy(true));
+        await queryFulfilled;
+        dispatch(setPaymentStepBusy(false));
+      }
+    }),
+    applePaymentSelect: build.mutation<CheckoutResponse, ApplePaySelectParams>({
+      query: ({ agreement, validationURL }) => ({
+        url: buildClientRequestUrl(checkout.confirmationPaymentSelect, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          agreement,
+          validationURL
+        }
+      }),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setPaymentStepBusy(true));
+        await queryFulfilled;
+        dispatch(setPaymentStepBusy(false));
+      }
+    }),
+    appleQuery: build.mutation<CheckoutResponse, ApplePayQueryParams>({
+      query: ({ agreement, paymentToken }) => ({
+        url: buildClientRequestUrl(checkout.confirmationQuery, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          agreement,
+          payment_token: paymentToken
+        }
+      }),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setPaymentStepBusy(true));
+        await queryFulfilled;
+        dispatch(setPaymentStepBusy(false));
+      }
+    }),
+    completeConfirmation: build.mutation<CheckoutResponse, void>({
+      query: () => ({
+        url: buildClientRequestUrl(checkout.confirmationComplete, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          agreement: true
+        }
+      }),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setPaymentStepBusy(true));
+        await queryFulfilled;
+        dispatch(setPaymentStepBusy(false));
+      }
+    }),
+    setCompletePayOnDelivery: build.mutation<
+      CheckoutResponse,
+      PayOnDeliveryParams
+    >({
+      query: ({ paymentType }) => ({
+        url: buildClientRequestUrl(
+          `${checkout.fetchCheckout}?page=PayOnDeliveryPage`,
+          { useFormData: true }
+        ),
+        method: 'POST',
+        body: {
+          agreement: '1',
+          paymentType
+        }
+      }),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setPaymentStepBusy(true));
+        await queryFulfilled;
+        dispatch(setPaymentStepBusy(false));
+      }
+    }),
+    setPayOnDeliveryChoice: build.mutation<CheckoutResponse, string>({
+      query: (body) => ({
+        url: buildClientRequestUrl(
+          `${checkout.fetchCheckout}?page=PayOnDeliveryPaymentChoicePage`,
+          { useFormData: true }
+        ),
+        method: 'POST',
+        body: {
+          payment_choice: body
+        }
+      }),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setPaymentStepBusy(true));
+        await queryFulfilled;
+        dispatch(setPaymentStepBusy(false));
+      }
+    }),
+    completeLoyaltyPayment: build.mutation<CheckoutResponse, void>({
+      query: () => ({
+        url: buildClientRequestUrl(checkout.completeLoyaltyPayment, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          agreement: true
+        }
+      }),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        dispatch(setPaymentStepBusy(true));
+        await queryFulfilled;
+        dispatch(setPaymentStepBusy(false));
+      }
+    }),
+    getCheckoutLoyaltyBalance: build.query<CheckoutResponse, void>({
+      query: () => ({
+        url: buildClientRequestUrl(checkout.loyaltyMoneyUsage)
+      })
+    }),
+    payWithLoyaltyBalance: build.mutation<any, string>({
+      query: (amount) => ({
+        url: buildClientRequestUrl(checkout.loyaltyMoneyUsage, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          loyalty_amount_to_use: amount
+        }
+      })
+    }),
+    setOrderNote: build.mutation<CheckoutResponse, string>({
+      query: (notes) => ({
+        url: buildClientRequestUrl(checkout.setOrderNote, {
+          useFormData: true
+        }),
+        method: 'POST',
+        body: {
+          notes
+        }
+      })
+    })
+  }),
+  overrideExisting: false
+});
+
+export const {
+  useFetchCheckoutQuery,
+  useFetchCheckoutResultQuery,
+  useGet3dRedirectFormQuery,
+  useGetContractQuery,
+  useCompleteCreditCardPaymentMutation,
+  useCompleteFundsTransferMutation,
+  useGuestLoginMutation,
+  useSetDeliveryOptionMutation,
+  useSetAddressesMutation,
+  useSetShippingOptionMutation,
+  useSetPaymentOptionMutation,
+  useSetBinNumberMutation,
+  useSetInstallmentOptionMutation,
+  useSetFundsTransferOptionMutation,
+  useSetRetailStoreMutation,
+  useCompleteRedirectionPaymentMutation,
+  useApplePaymentSelectMutation,
+  useAppleQueryMutation,
+  useCompleteConfirmationMutation,
+  useSetCompletePayOnDeliveryMutation,
+  useSetPayOnDeliveryChoiceMutation,
+  useCompleteLoyaltyPaymentMutation,
+  useGetCheckoutLoyaltyBalanceQuery,
+  usePayWithLoyaltyBalanceMutation,
+  useSetOrderNoteMutation
+} = checkoutApi;