tf-checkout-react-native 1.0.45 → 2.0.0-beta.0

package/src/api/ApiClient.ts

@@ -1,1539 +0,0 @@
-import Axios, { AxiosError, AxiosResponse, InternalAxiosRequestConfig } from 'axios'
-import axiosRetry from 'axios-retry'
-import _filter from 'lodash/filter'
-import _forEach from 'lodash/forEach'
-import _get from 'lodash/get'
-import _map from 'lodash/map'
-import _mapKeys from 'lodash/mapKeys'
-import _sortBy from 'lodash/sortBy'
-
-import { IWaitingListFields } from '../components/waitingList/types'
-import { IOnCheckoutSuccess } from '../containers/billingInfo/types'
-import { Config } from '../helpers/Config'
-import { getDomainByClientAndEnv } from '../helpers/Domains'
-import {
-  deleteAllData,
-  getData,
-  LocalStorageKeys,
-  storeData,
-} from '../helpers/LocalStorage'
-import { IAccountTicketsResponse, IError, IEvent, IUserProfile } from '../types'
-import { IAddToCartResponse, ITicket, ITicketsResponseData } from '../types/ITicket'
-import Constants from './Constants'
-import { getApiError } from './ErrorHandler'
-import {
-  IAddToCartParams,
-  IAddToWaitingListResponse,
-  IAuthorizeResponse,
-  ICartData,
-  ICartResponse,
-  ICheckoutBody,
-  ICheckoutResponse,
-  IClientRequest,
-  ICloseSessionData,
-  ICloseSessionResponse,
-  ICountriesResponse,
-  IEventResponse,
-  IFetchAccessTokenResponse,
-  IFetchTicketsParams,
-  IFetchTicketsResponse,
-  IFreeRegistrationData,
-  IFreeRegistrationResponse,
-  IMyOrderDetailsData,
-  IMyOrderDetailsItem,
-  IMyOrderDetailsResponse,
-  IMyOrderDetailsTicket,
-  IMyOrdersData,
-  IMyOrdersRequestParams,
-  IMyOrdersResponse,
-  IOrderReview,
-  IOrderReviewResponse,
-  IPostReferralData,
-  IPostReferralResponse,
-  IPromoCodeResponse,
-  IPurchaseConfirmationData,
-  IPurchaseConfirmationResponse,
-  IRegisterNewUserResponse,
-  IRemoveTicketFromResaleData,
-  IRemoveTicketFromResaleResponse,
-  IResaleTicketData,
-  IResaleTicketResponse,
-  IResetPasswordRequestData,
-  IResetPasswordResponse,
-  IRestorePasswordData,
-  IRestorePasswordResponse,
-  IStatesResponse,
-  IUpdateCheckoutResponse,
-  IUserProfileResponse,
-} from './types'
-
-// Type for error response data from API
-interface ErrorResponseData {
-  message?: string | { email?: string; [key: string]: any }
-  error_description?: string
-  status?: number | string
-  [key: string]: any
-}
-
-// Helper function to safely extract message from error response
-const getErrorMessage = (
-  data: ErrorResponseData | undefined,
-  fallback: string
-): string => {
-  if (!data?.message) return fallback
-  return typeof data.message === 'string' ? data.message : fallback
-}
-
-const HEADERS: { [key: string]: any } = {
-  Accept: 'application/vnd.api+json',
-  'Content-Type': 'application/vnd.api+json',
-}
-
-export const Client: IClientRequest = Axios.create({
-  baseURL: Constants.BASE_URL,
-  headers: HEADERS,
-  timeout: Constants.TIMEOUT,
-  data: {},
-}) as IClientRequest
-
-axiosRetry(Client, { retries: 3 })
-
-Client.interceptors.request.use(async (config: InternalAxiosRequestConfig) => {
-  const guestToken = await getData(LocalStorageKeys.AUTH_GUEST_TOKEN)
-  const accessToken = await getData(LocalStorageKeys.ACCESS_TOKEN)
-  const storedTokenType = await getData(LocalStorageKeys.AUTH_TOKEN_TYPE)
-  const tokenType = storedTokenType || 'Bearer'
-
-  if (accessToken) {
-    config.headers['Authorization'] = `${tokenType} ${accessToken}`
-  }
-
-  if (guestToken) {
-    Client.setGuestToken(guestToken)
-    config.headers['Authorization-Guest'] = guestToken
-  }
-
-  if (Config.CLIENT) {
-    config.headers['origin'] = getDomainByClientAndEnv(Config.CLIENT, Config.ENV)
-  }
-
-  return config
-})
-
-Client.interceptors.response.use(
-  (response: AxiosResponse) => {
-    return response
-  },
-  async (error: AxiosError<ErrorResponseData>) => {
-    if (error?.response?.status === 401) {
-      error.code = error.code
-      error.message = error.response.data?.error_description || error.message
-    } else if (error.message) {
-      error.message = error.message
-    }
-
-    return Promise.reject(error)
-  }
-)
-
-Client.setGuestToken = (token: string) =>
-  (Client.defaults.headers.common['Authorization-Guest'] = token)
-
-Client.removeGuestToken = () =>
-  delete Client.defaults.headers.common['Authorization-Guest']
-
-Client.removeAccessToken = () => delete Client.defaults.headers.common.Authorization
-
-Client.setAccessToken = (token: string) =>
-  (Client.defaults.headers.common.Authorization = token)
-
-Client.setBaseUrl = (baseUrl: string) => (Client.defaults.baseURL = baseUrl)
-
-Client.setTimeOut = (timeOut: number) => (Client.defaults.timeout = timeOut)
-
-Client.setDomain = (domain: string) => {
-  Client.defaults.headers.common['origin'] = domain
-}
-
-Client.setContentType = (contentType: string) =>
-  (Client.defaults.headers.common['Content-Type'] = contentType)
-
-export const setCustomHeader = (response: any) => {
-  const guestHeaderResponseValue = _get(response, 'headers.authorization-guest')
-
-  const guestHeaderExistingValue = _get(response, 'config.headers[Authorization-Guest]')
-
-  const guestHeader = guestHeaderResponseValue || guestHeaderExistingValue
-
-  if (guestHeader) {
-    storeData(LocalStorageKeys.AUTH_GUEST_TOKEN, guestHeader)
-    Client.setGuestToken(guestHeader)
-  }
-}
-
-export const setAccessTokenHandler = async (accessToken: string) => {
-  await storeData(LocalStorageKeys.ACCESS_TOKEN, accessToken)
-  Client.setAccessToken(accessToken)
-}
-
-// API Authentication
-export const authorize = async (data: FormData): Promise<IAuthorizeResponse> => {
-  let responseError: IError | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.post(
-      `/v1/oauth/authorize-rn?client_id=${Config.CLIENT_ID}`,
-      data
-    )
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(axiosError?.response?.data, 'Authorization failed'),
-      code: axiosError?.response?.status,
-    }
-  }
-
-  return {
-    error: responseError,
-    code: response?.data?.data?.code,
-  }
-}
-
-export const fetchAccessToken = async (
-  data: FormData
-): Promise<IFetchAccessTokenResponse> => {
-  let responseError: IError | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.post('/v1/oauth/access_token', data)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(axiosError.response?.data, 'Error occurred'),
-      code: axiosError.response?.status,
-    }
-  }
-
-  const accessToken = _get(response, 'data.access_token')
-  if (accessToken) {
-    await storeData(LocalStorageKeys.ACCESS_TOKEN, accessToken)
-  }
-  const refreshToken = _get(response, 'data.refresh_token')
-  if (refreshToken) {
-    await storeData(LocalStorageKeys.REFRESH_TOKEN, refreshToken)
-  }
-  const tokenType = _get(response, 'data.token_type')
-  if (tokenType) {
-    await storeData(LocalStorageKeys.TOKEN_TYPE, tokenType)
-  }
-  const scope = _get(response, 'data.scope')
-  if (scope) {
-    await storeData(LocalStorageKeys.AUTH_SCOPE, scope)
-  }
-
-  return {
-    accessTokenError: responseError,
-    accessTokenData: {
-      accessToken,
-      refreshToken,
-      tokenType,
-      scope,
-    },
-  }
-}
-
-export const fetchUserProfile = async (): Promise<IUserProfileResponse> => {
-  const accessToken = await getData(LocalStorageKeys.ACCESS_TOKEN)
-  if (!accessToken) {
-    return { userProfileError: { message: 'Access token not found' } }
-  }
-
-  let responseError: IError | undefined
-  let userProfile: IUserProfile | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.get('/customer/profile/', {
-      headers: {
-        ...HEADERS,
-        Authorization: `Bearer ${accessToken}`,
-      },
-    })
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(axiosError?.response?.data, 'Error occurred'),
-      code: axiosError.response?.status!,
-    }
-  }
-
-  if (!responseError && response) {
-    userProfile = response.data.data
-  }
-
-  return {
-    userProfileError: responseError,
-    userProfileData: userProfile,
-  }
-}
-
-//#region Register new user
-export const registerNewUser = async (
-  data: FormData
-): Promise<IRegisterNewUserResponse> => {
-  const resultData: IRegisterNewUserResponse = {
-    registerNewUserResponseError: undefined,
-    registerNewUserResponseData: undefined,
-  }
-
-  let res: AxiosResponse<any> | undefined
-
-  try {
-    res = await Client.post('/v1/oauth/register-rn', data, {
-      headers: {
-        'Content-Type': 'multipart/form-data',
-      },
-    })
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    const messageObject = axiosError.response?.data.message
-    let errorMessage = ''
-
-    if (!messageObject) {
-      resultData.registerNewUserResponseError = {
-        message: 'Error registering user',
-      }
-    } else {
-      if (
-        typeof messageObject === 'object' &&
-        'email' in messageObject &&
-        messageObject.email
-      ) {
-        resultData.registerNewUserResponseError = {
-          isAlreadyRegistered: true,
-          message:
-            'It appears this email is already attached to an account. Please log in here to complete your registration.',
-          raw: axiosError.response,
-        }
-      } else {
-        if (typeof messageObject === 'object') {
-          _mapKeys(messageObject, (value) => {
-            _forEach(value, (eachVal) => {
-              errorMessage += `- ${eachVal} \n`
-            })
-          })
-        }
-        resultData.registerNewUserResponseError = {
-          message: errorMessage || 'Error registering user',
-        }
-      }
-    }
-  }
-
-  if (res?.status === 200) {
-    const userProfile = _get(res, 'data.data.attributes.user_profile')
-    const accessToken = _get(res, 'data.data.attributes.access_token')
-    const refreshToken = _get(res, 'data.data.attributes.refresh_token')
-    const scope = _get(res, 'data.data.attributes.scope')
-    const tokenType = _get(res, 'data.data.attributes.token_type')
-
-    if (accessToken) {
-      await storeData(LocalStorageKeys.ACCESS_TOKEN, accessToken)
-      await setAccessTokenHandler(accessToken)
-    }
-
-    if (refreshToken) {
-      await storeData(LocalStorageKeys.REFRESH_TOKEN, refreshToken)
-    }
-
-    if (tokenType) {
-      await storeData(LocalStorageKeys.TOKEN_TYPE, tokenType)
-    }
-
-    if (scope) {
-      await storeData(LocalStorageKeys.AUTH_SCOPE, scope)
-    }
-
-    resultData.registerNewUserResponseData = {
-      accessTokenData: {
-        accessToken: accessToken,
-        refreshToken: refreshToken,
-        tokenType: tokenType,
-        scope: scope,
-      },
-      userProfile: {
-        firstName: _get(userProfile, 'first_name'),
-        lastName: _get(userProfile, 'last_name'),
-        email: _get(userProfile, 'email'),
-      },
-    }
-  }
-
-  return resultData
-}
-//#endregion
-
-//#region Waiting List
-export const addToWaitingList = async (
-  values: IWaitingListFields
-): Promise<IAddToWaitingListResponse> => {
-  if (!Config.EVENT_ID) {
-    return {
-      addToWaitingListError: { message: 'Event ID is not configured!' },
-    }
-  }
-
-  const requestData = { data: { attributes: values } }
-  let responseError: IError | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.post(
-      `/v1/event/${Config.EVENT_ID}/add_to_waiting_list`,
-      requestData
-    )
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(axiosError.response?.data, 'Error occurred'),
-      code: axiosError.response?.status!,
-    }
-  }
-
-  return {
-    addToWaitingListError: responseError,
-    addToWaitingListData: response?.data,
-  }
-}
-//#endregion
-
-//#region MyOrders
-export const fetchMyOrders = async ({
-  page,
-  limit = 20,
-  filter = '',
-  from = '',
-}: IMyOrdersRequestParams): Promise<IMyOrdersResponse> => {
-  const data: IMyOrdersData = {
-    events: [],
-    orders: [],
-    pagination: {
-      page: 0,
-      limit: 0,
-      totalCount: 0,
-      totalPages: 0,
-    },
-  }
-  let responseError: IError | undefined
-  let response: AxiosResponse<any> | undefined
-
-  const withFilterEvent = filter ? `&filter[event]=${filter}` : ''
-  const withBrand = Config.BRAND ? `&filter[brand]=${Config.BRAND}` : ''
-  const withSubBrands = Config.ARE_SUB_BRANDS_INCLUDED
-    ? `&filter[subbrands]=${Config.ARE_SUB_BRANDS_INCLUDED}`
-    : ''
-  const withFrom = from ? `&filter[from]=${from}` : ''
-
-  const endpoint = `/v1/account/orders/?page=${page}&limit=${limit}${withFilterEvent}${withBrand}${withSubBrands}${withFrom}`
-
-  try {
-    response = await Client.get(endpoint)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = getApiError(axiosError, 'Error fetching My Orders')
-  }
-
-  if (response?.data) {
-    const dataAttributes = response.data.data.attributes
-
-    data.events = dataAttributes.purchased_events
-    data.orders = dataAttributes.orders
-    data.pagination.limit = dataAttributes.limit
-    data.pagination.page = dataAttributes.page
-    data.pagination.totalCount = dataAttributes.total_count
-    data.pagination.totalPages = dataAttributes.total_pages
-    data.filter = dataAttributes.filter
-    data.brandFilter = dataAttributes.brand_filter
-    data.subBrands = dataAttributes.sub_brands
-  }
-
-  return {
-    myOrdersError: responseError,
-    myOrdersData: data,
-  }
-}
-//#endregion
-
-//#region OrderDetails
-export const fetchOrderDetails = async (
-  orderId: string
-): Promise<IMyOrderDetailsResponse> => {
-  let responseError: IError | undefined
-  let responseData: IMyOrderDetailsData | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.get(`/v1/account/order/${orderId}`)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(
-        axiosError.response?.data,
-        'Error while fetching order details'
-      ),
-      code: axiosError.response?.status,
-    }
-  }
-
-  if (!responseError && response) {
-    const { attributes } = response.data.data
-    let items: IMyOrderDetailsItem[] | undefined
-
-    if (attributes.items?.ticket_types) {
-      items = _map(attributes.items.ticket_types, (item) => {
-        return {
-          name: item.name,
-          currency: item.currency,
-          price: item.price,
-          discount: item.discount,
-          quantity: item.quantity,
-          total: item.total,
-          isActive: item.active,
-          hash: item.hash,
-        }
-      })
-    }
-
-    const tickets: IMyOrderDetailsTicket[] = _map(attributes.tickets, (item) => {
-      return {
-        hash: item.hash,
-        ticketType: item.ticket_type,
-        holderName: item.holder_name,
-        status: item.status,
-        pdfLink: item.pdf_link,
-        qrData: item.qr_data,
-        isSellable: item.is_sellable,
-        holderEmail: item.holder_email,
-        holderPhone: item.holder_phone,
-        description: item.description,
-        descriptionPlain: item.description_plain,
-        currency: item.currency,
-        eventName: item.event_name,
-        isOnSale: item.is_on_sale,
-        resaleFeeAmount: item.resale_fee_amount,
-        ticketTypeHash: item.ticket_type_hash,
-        isTable: item.is_table,
-      }
-    })
-    responseData = {
-      header: {
-        currency: attributes.currency,
-        date: attributes.date,
-        isReferralDisabled: attributes.disable_referral,
-        eventEndDate: attributes.event_end_date,
-        eventStartDate: attributes.event_start_date,
-        eventId: attributes.event_id,
-        eventName: attributes.event_name,
-        eventSalesEndDate: attributes.event_sales_end_date,
-        eventSalesStartDate: attributes.event_sales_start_date,
-        eventUrl: attributes.event_url,
-        isVenueHidden: attributes.hide_venue,
-        id: attributes.id,
-        image: attributes.image,
-        shareLink: attributes.personal_share_link,
-        salesReferred: attributes.sales_referred,
-        total: attributes.total,
-        hideVenueUntil: attributes.hide_venue_until,
-        timeZone: attributes.timezone,
-        venue: {
-          city: attributes.venue_city,
-          country: attributes.venue_country,
-          googlePlaceId: attributes.venue_google_place_id || undefined,
-          latitude: attributes.venue_latitude || undefined,
-          longitude: attributes.venue_longitude || undefined,
-          name: attributes.venue_name || undefined,
-          postalCode: attributes.venue_postal_code || undefined,
-          state: attributes.venue_state,
-          street: attributes.venue_street || undefined,
-          streetNumber: attributes.venue_street_number || undefined,
-        },
-      },
-      items: items,
-      tickets: tickets,
-    }
-  }
-
-  return {
-    orderDetailsError: responseError,
-    orderDetailsData: responseData,
-  }
-}
-
-//#endregion
-
-//#region Tickets
-// PromoCode higher priority than ReferredId
-export const fetchTickets = async ({
-  promoCode,
-  referredId,
-}: IFetchTicketsParams): Promise<IFetchTicketsResponse> => {
-  if (!Config.EVENT_ID) {
-    return {
-      error: {
-        message: 'Event ID is not configured!',
-      },
-    }
-  }
-
-  const eventId = Config.EVENT_ID.toString()
-  const headers = {
-    'Promotion-Event': eventId,
-    'Promotion-Code': promoCode,
-    'Referrer-Id': referredId,
-  }
-
-  let responseError
-  let response: AxiosResponse<any> | undefined
-
-  if (!referredId) {
-    delete headers['Referrer-Id']
-  }
-
-  if (!promoCode) {
-    //@ts-ignore
-    delete headers['Promotion-Code']
-  }
-
-  if (!promoCode && !referredId) {
-    //@ts-ignore
-    delete headers['Promotion-Event']
-  }
-
-  // If there are promoCode and referredId, then we need to remove the Referrer-Id header
-  if (promoCode && referredId && headers['Referrer-Id']) {
-    delete headers['Referrer-Id']
-  }
-
-  try {
-    response = await Client.get(`v1/event/${eventId}/tickets/`, {
-      //@ts-ignore
-      headers: headers,
-    })
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    if (axiosError.response) {
-      responseError = {
-        code: axiosError.response.status!,
-        message: axiosError.response.data.message,
-      }
-    } else {
-      responseError = {
-        message: axiosError.message,
-      }
-    }
-  }
-
-  if (responseError) {
-    return {
-      error: responseError,
-    }
-  }
-
-  const attributes = _get(response, 'data.data.attributes.tickets')
-  const ticketsAttributes = _filter(attributes, (item) => typeof item === 'object')
-  const promoCodeResult: IPromoCodeResponse = {
-    message: _get(response, 'data.data.attributes.PromoCodeValidationMessage'),
-    isValid: _get(response, 'data.data.attributes.ValidPromoCode'),
-  }
-
-  const tickets = (Object.values(ticketsAttributes) || []) as ITicket[]
-  const guestHeaderValue = _get(response, 'headers.authorization-guest')
-  if (guestHeaderValue) {
-    setCustomHeader(response)
-  }
-
-  return {
-    tickets: _sortBy(tickets, 'sortOrder'),
-    error: responseError,
-    promoCodeResult: promoCodeResult,
-    isInWaitingList: _get(response, 'data.data.attributes.showWaitingList'),
-    isAccessCodeRequired: _get(response, 'data.data.attributes.is_access_code'),
-  }
-}
-//#endregion Tickets
-
-export const addToCart = async (data: IAddToCartParams): Promise<IAddToCartResponse> => {
-  if (!Config.EVENT_ID) {
-    return {
-      error: { message: 'Event ID is not configured!' },
-    }
-  }
-
-  let responseError: IError | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.post(`v1/event/${Config.EVENT_ID}/add-to-cart/`, {
-      data,
-    })
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      code: axiosError.response?.status!,
-      message: getErrorMessage(axiosError.response?.data, 'Error occurred'),
-    }
-  }
-
-  let responseData: ITicketsResponseData | undefined
-  if (!responseError && response) {
-    setCustomHeader(response)
-    const { attributes } = response.data
-
-    responseData = {
-      isBillingRequired: !attributes?.skip_billing_page,
-      isNameRequired: attributes?.names_required ?? false,
-      isAgeRequired: attributes?.age_required ?? false,
-      isPhoneRequired: attributes?.phone_required ?? false,
-      minimumAge: attributes?.age_required ? (attributes?.minimum_age ?? 18) : undefined,
-      isTicketFree: attributes?.free_ticket ?? false,
-      isPhoneHidden: attributes?.hide_phone_field && false,
-    }
-  }
-
-  return { data: responseData, error: responseError }
-}
-
-export const fetchEvent = async (): Promise<IEventResponse> => {
-  if (!Config.EVENT_ID) {
-    return {
-      eventError: {
-        message: 'Event ID is not configured!',
-      },
-    }
-  }
-
-  let responseError: IError | undefined
-  let event: IEvent | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.get(`v1/event/${Config.EVENT_ID}`, {
-      headers: HEADERS,
-    })
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      code:
-        typeof axiosError?.response?.data.status === 'number'
-          ? axiosError.response.data.status
-          : undefined,
-      message:
-        typeof axiosError.response?.data.message === 'string'
-          ? axiosError.response.data.message
-          : undefined,
-    }
-  }
-
-  if (response?.status === 200) {
-    event = response.data.data.attributes
-  }
-
-  if (event?.country) {
-    await storeData(LocalStorageKeys.EVENT_COUNTRY, event.country)
-  }
-
-  return {
-    eventError: responseError,
-    eventData: event,
-  }
-}
-
-export const postReferralVisit = async (
-  referralId: string
-): Promise<IPostReferralResponse> => {
-  if (!Config.EVENT_ID) {
-    return {
-      postReferralError: {
-        message: 'Event ID is not configured!',
-      },
-    }
-  }
-
-  const eventId = Config.EVENT_ID.toString()
-  const referralIdNumber = parseInt(referralId, 10)
-  let responseError: IError | undefined
-  let responseData: IPostReferralData | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.post(`v1/event/${eventId}/referrer/`, {
-      referrer: referralIdNumber,
-    })
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    if (axiosError.response?.data.errors && axiosError.response?.data.errors.length > 0) {
-      responseError = {
-        code: axiosError.response?.data.errors[0].status,
-        message: axiosError.response?.data.errors[0].details,
-      }
-    } else {
-      responseError = {
-        message: getErrorMessage(axiosError.response?.data, 'Error occurred'),
-        code: axiosError.response?.status!,
-      }
-    }
-
-    if (axiosError.response?.status === 422 && responseError.message === undefined) {
-      responseError.message = 'Cannot process request'
-    }
-  }
-
-  if (response?.data && response.data.status === 200) {
-    responseData = {
-      message: response.data.message,
-      status: response.data.status,
-    }
-  }
-
-  return {
-    postReferralData: responseData,
-    postReferralError: responseError,
-  }
-}
-//#region Unlock Password Protected Event
-export const unlockPasswordProtectedEvent = async (
-  password: string
-): Promise<IEventResponse> => {
-  if (!Config.EVENT_ID) {
-    return {
-      eventError: {
-        message: 'Event ID is not configured!',
-      },
-    }
-  }
-
-  const eventId = Config.EVENT_ID.toString()
-  let responseError: IError | undefined
-  let responseData: any | undefined
-  let response: AxiosResponse<any> | undefined
-
-  const body = {
-    attributes: {
-      data: {
-        password: password,
-      },
-    },
-  }
-
-  try {
-    response = await Client.post(`v1/event/${eventId}/authenticate`, body)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(axiosError.response?.data, 'Error while unlocking Event'),
-      code: axiosError?.response?.status,
-    }
-  }
-
-  if (response?.data) {
-    responseData = {
-      message: response.data.message,
-      status: response.data.status,
-    }
-
-    const guestHeaderValue = _get(response, 'headers.authorization-guest')
-    if (guestHeaderValue) {
-      setCustomHeader(response)
-    }
-  }
-
-  return {
-    eventData: responseData,
-    eventError: responseError,
-  }
-}
-//#endregion Unlock Password Protected Event
-
-//#region Billing Information
-export const fetchCountries = async (): Promise<ICountriesResponse> => {
-  let responseError: IError | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.get('/countries/list')
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(axiosError.response?.data, 'Error occurred'),
-      code: axiosError.response?.status!,
-    }
-  }
-
-  if (response?.status === 200) {
-    setCustomHeader(response)
-  }
-
-  return {
-    countriesData: response?.data.data,
-    countriesError: responseError,
-  }
-}
-
-export const fetchStates = async (countryId: string): Promise<IStatesResponse> => {
-  let responseError: IError | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.get(`/countries/${countryId}/states/`)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      code: axiosError.response?.status!,
-      message: getErrorMessage(axiosError.response?.data, 'Error occurred'),
-    }
-  }
-
-  if (response?.status === 200) {
-    setCustomHeader(response)
-  }
-
-  return {
-    statesError: responseError,
-    statesData: response?.data?.data,
-  }
-}
-
-export const fetchCart = async (): Promise<ICartResponse> => {
-  let responseError: IError | undefined
-  let cartData = {} as ICartData
-  let res: AxiosResponse<any> | undefined
-
-  try {
-    res = await Client.get('v1/cart/')
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      code: axiosError.response?.status!,
-      message: getErrorMessage(axiosError.response?.data, 'Error occurred'),
-    }
-  }
-
-  const data = res?.data.data
-  if (data?.attributes) {
-    const attr = data?.attributes
-    const quantityString = _get(attr, 'cart[0].quantity', '1')
-    const tfOptIn = _get(attr, 'ttfOptIn', false)
-    const isMarketingOptedIn = _get(attr, 'optedIn', false)
-    const expiresAt = _get(attr, 'expiresAt', 420)
-    const eventId = _get(attr, 'eventId', null)
-
-    cartData = {
-      quantity: parseInt(quantityString, 10),
-      isMarketingOptedIn:
-        typeof isMarketingOptedIn === 'number'
-          ? isMarketingOptedIn > 0
-          : isMarketingOptedIn,
-      isTfOptInHidden: _get(attr, 'hide_ttf_opt_in', false),
-      isTfOptIn: typeof tfOptIn === 'number' ? tfOptIn > 0 : tfOptIn,
-      expiresAt: expiresAt,
-    }
-
-    return {
-      success: true,
-      cartError: responseError,
-      cartData,
-      eventId: eventId,
-    }
-  } else {
-    responseError = {
-      message: 'Error fetching cart',
-    }
-  }
-
-  return {
-    cartError: responseError,
-    cartData: cartData,
-  }
-}
-
-export const checkoutOrder = async (data: ICheckoutBody): Promise<ICheckoutResponse> => {
-  const accessToken = await getData(LocalStorageKeys.ACCESS_TOKEN)
-
-  if (!accessToken) {
-    return {
-      error: {
-        message: 'Access token not found',
-      },
-    }
-  }
-  let responseError: IError | undefined
-  let res: AxiosResponse<any> | undefined
-
-  try {
-    res = await Client.post(
-      'v1/on-checkout/',
-      { data },
-      {
-        headers: {
-          ...HEADERS,
-          Authorization: `Bearer ${accessToken}`,
-        },
-      }
-    )
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      code: axiosError.response?.status!,
-      message: getErrorMessage(axiosError.response?.data, 'Error occurred'),
-    }
-  }
-
-  if (!res || !res.data) {
-    return { error: responseError }
-  }
-
-  const checkoutResponseData: IOnCheckoutSuccess = {
-    id: res.data.data.attributes.id,
-    hash: res.data.data.attributes.hash,
-    total: res.data.data.attributes.total,
-    status: res.data.data.attributes.status,
-  }
-
-  return {
-    error: responseError,
-    data: checkoutResponseData,
-  }
-}
-//#endregion
-//#region Checkout
-export const fetchEventConditions = async () => {
-  if (!Config.EVENT_ID) {
-    return {
-      error: {
-        message: 'Event ID is not configured!',
-      },
-    }
-  }
-
-  let responseError: IError | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.get(`v1/event/${Config.EVENT_ID}/conditions`)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message:
-        typeof axiosError.response?.data.message === 'string'
-          ? axiosError.response.data.message
-          : 'Error fetching event conditions',
-      code: axiosError.response?.status,
-    }
-  }
-
-  return {
-    error: responseError,
-    data: response?.data?.data?.attributes,
-  }
-}
-
-export const fetchOrderReview = async (hash: string): Promise<IOrderReviewResponse> => {
-  let responseError: IError | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.get(`v1/order/${hash}/review/`)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(axiosError.response?.data, 'Error occurred'),
-      code: axiosError.response?.status!,
-    }
-  }
-
-  let resData: IOrderReview | undefined
-
-  if (!responseError) {
-    const attributes = _get(response, 'data.data.attributes')
-    const { cart, order_details, payment_method, billing_info } = attributes
-
-    if (!payment_method.stripe_client_secret && order_details.total !== '0.00') {
-      responseError = {
-        message: 'Stripe is not configured',
-      }
-    } else {
-      const {
-        tickets: [ticket],
-      } = order_details
-
-      resData = {
-        expiresAt: attributes.expires_at,
-        reviewData: {
-          event: cart[0]?.product_name,
-          price: ticket?.price,
-          ticketType: ticket?.name,
-          total: order_details?.total,
-          numberOfTickets: ticket?.quantity,
-          currency: order_details?.currency,
-        },
-        paymentData: {
-          id: payment_method.id,
-          name: payment_method.name,
-          stripeClientSecret: payment_method.stripe_client_secret,
-          stripeConnectedAccount:
-            payment_method.stripe_connected_account?.length > 0
-              ? payment_method.stripe_connected_account
-              : undefined,
-          stripePublishableKey: payment_method.stripe_publishable_key,
-        },
-        addressData: {
-          city: billing_info.city,
-          line1: billing_info.street_address,
-          state: billing_info.state ? billing_info.state.toString() : '',
-          postalCode: billing_info.zip,
-        },
-        billingData: {
-          firstName: billing_info.first_name,
-          lastName: billing_info.last_name,
-          isActAsBillingInfo: billing_info.as_act_billing_info,
-          city: billing_info.city,
-          company: billing_info.company,
-          country: billing_info.country,
-          email: billing_info.email,
-          isBusiness: billing_info.is_business,
-          phone: billing_info.phone,
-          state: billing_info.state,
-          streetAddress: billing_info.street_address,
-          zipCode: billing_info.zip,
-        },
-        cart: attributes.cart,
-        cartTotalPrice: attributes.cart_total_price,
-        couponCode: attributes.coupon_code,
-        discount: attributes.discount,
-        estimatedTax: attributes.estimated_tax,
-        estimatedTotal: attributes.estimated_total,
-        isSeatMapAllowed: attributes.flagSeatMapAllowed,
-        isShippingRequired: attributes.shipping_required,
-        shippingInfo: attributes.shipping_info,
-        orderDetails: attributes.order_details,
-        isOptedId: attributes.opted_id,
-        isTtfOptedIn: attributes.hide_ttf_opt_in,
-        eventDetails: attributes.event_details,
-        countries: attributes.countries,
-      }
-    }
-  }
-  return {
-    orderReviewError: responseError,
-    orderReviewData: resData,
-  }
-}
-
-// Update checkout with add-ons and pricing
-export const updateCheckout = async (data: any): Promise<IUpdateCheckoutResponse> => {
-  let responseError: IError | undefined
-  let responseData: any | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.post('v1/checkout', {
-      data,
-    })
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(axiosError.response?.data, 'Error updating checkout'),
-      code: axiosError.response?.status,
-    }
-  }
-
-  if (response?.data) {
-    responseData = response.data
-  }
-
-  return {
-    success: !responseError,
-    error: responseError,
-    data: responseData,
-  }
-}
-
-// Get add-ons for event
-export const getAddons = async (eventId: string): Promise<any> => {
-  let responseError: IError | undefined
-  let addonsData: any = {}
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.get(`v1/event/${eventId}/add-ons`)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(axiosError.response?.data, 'Error fetching add-ons'),
-      code: axiosError.response?.status,
-    }
-  }
-
-  if (response?.data?.data?.attributes) {
-    addonsData = response.data.data.attributes
-  }
-
-  return {
-    data: addonsData,
-    error: responseError,
-    success: !responseError,
-  }
-}
-
-// Get payment data and order review
-export const getPaymentData = async (hash: string): Promise<any> => {
-  let responseError: IError | undefined
-  let responseData: any | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.get(`v1/order/${hash}/review`)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(axiosError.response?.data, 'Error fetching payment data'),
-      code: axiosError.response?.status,
-    }
-  }
-
-  if (response?.data) {
-    responseData = response.data
-  }
-
-  return {
-    success: !responseError,
-    error: responseError,
-    data: responseData,
-  }
-}
-
-export const postOnPaymentSuccess = async (orderHash: string) => {
-  let responseError: IError | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.post(`v1/order/${orderHash}/success`)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(
-        axiosError.response?.data,
-        'Error while notifying Payment Success'
-      ),
-      code: axiosError.response?.status,
-    }
-  }
-
-  return {
-    error: responseError,
-    data: response?.data,
-  }
-}
-
-export const postOnFreeRegistration = async (
-  orderHash: string
-): Promise<IFreeRegistrationResponse> => {
-  let responseError: IError | undefined
-  let responseData: IFreeRegistrationData | undefined
-  let res: AxiosResponse<any> | undefined
-
-  try {
-    res = await Client.post(`v1/order/${orderHash}/complete_free_registration`)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(axiosError.response?.data, 'Error occurred'),
-      code: axiosError.response?.status,
-    }
-  }
-
-  if (res?.data) {
-    const orderDetails = res.data.data.attributes.order_details
-    responseData = {
-      id: orderDetails.id,
-      customerId: orderDetails.customer_id,
-      total: orderDetails.total,
-      currency: orderDetails.currency,
-      orderHash: orderDetails.order_hash,
-    }
-  }
-  return {
-    freeRegistrationError: responseError,
-    freeRegistrationData: responseData,
-  }
-}
-//#endregion
-
-//#region Purchase Confirmation
-export const fetchPurchaseConfirmation = async (
-  orderHash: string
-): Promise<IPurchaseConfirmationResponse> => {
-  let responseError: IError | undefined
-  let data: IPurchaseConfirmationData | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.get(`/v1/order/${orderHash}/payment/complete`)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(axiosError.response?.data, 'Error occurred'),
-      code: axiosError.response?.status,
-    }
-  }
-
-  if (response?.data?.data.attributes) {
-    const resData = response.data.data.attributes
-    data = {
-      conversionPixels: resData.conversion_pixels,
-      currency: resData.currency,
-      customConfirmationPageText: resData.custom_confirmation_page_text,
-      customerId: resData.customer_id,
-      isReferralDisabled: resData.disable_referral,
-      eventDate: resData.event_date,
-      eventDescription: resData.event_description,
-      eventType: resData.event_type,
-      message: resData.message,
-      orderTotal: resData.order_total,
-      personalShareLink: resData.personal_share_link,
-      productId: resData.product_id,
-      productName: resData.product_name,
-      productImage: resData.product_image,
-      productPrice: resData.product_price,
-      productUrl: resData.product_url,
-      personalShareSales: resData.personal_share_sales,
-    }
-  }
-
-  return {
-    purchaseConfirmationError: responseError,
-    purchaseConfirmationData: data,
-  }
-}
-//#endregion
-
-//#region Resale Tickets
-export const resaleTicket = async (
-  data: FormData,
-  orderHash: string
-): Promise<IResaleTicketResponse> => {
-  let responseError: IError | undefined
-  let responseData: IResaleTicketData | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.post(`v1/ticket/${orderHash}/sell`, data)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(axiosError.response?.data, 'Error while re-sale ticket'),
-    }
-  }
-
-  if (response?.data && response.data.status) {
-    responseData = {
-      message: response.data.message,
-    }
-  }
-
-  return {
-    resaleTicketData: responseData,
-    resaleTicketError: responseError,
-  }
-}
-
-export const removeTicketFromResale = async (
-  orderHash: string
-): Promise<IRemoveTicketFromResaleResponse> => {
-  let responseError: IError | undefined
-  let responseData: IRemoveTicketFromResaleData | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.delete(`v1/ticket/${orderHash}/sell`)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message:
-        typeof axiosError.response?.data.message === 'string'
-          ? axiosError.response.data.message
-          : 'Error removing ticket from resale',
-    }
-  }
-
-  if (response?.data.message && response.data.status === 200) {
-    responseData = {
-      message: response.data.message,
-    }
-  }
-
-  return {
-    removeTicketFromResaleData: responseData,
-    removeTicketFromResaleError: responseError,
-  }
-}
-//#endregion
-
-//#region Logout
-export const closeSession = async (): Promise<ICloseSessionResponse> => {
-  let responseData: ICloseSessionData | undefined
-  let responseError: IError | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.delete('/auth')
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message:
-        typeof axiosError.response?.data.message === 'string'
-          ? axiosError.response.data.message
-          : 'Error while closing session',
-    }
-  }
-
-  if (response?.data && response.data.status && response.data.status === 200) {
-    responseData = {
-      message: response.data.message || 'Session closed successfully',
-    }
-  }
-
-  await deleteAllData()
-
-  Client.removeGuestToken()
-  Client.removeAccessToken()
-
-  return {
-    closeSessionData: responseData,
-    closeSessionError: responseError,
-  }
-}
-//endregion Logout
-
-//#region Restore Password
-export const requestRestorePassword = async (
-  email: string
-): Promise<IRestorePasswordResponse> => {
-  let responseError: IError | undefined
-  let successData: IRestorePasswordData | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.post(`v1/oauth/restore-password-rn`, {
-      email: email,
-    })
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message: getErrorMessage(
-        axiosError.response?.data,
-        'Error while restoring password'
-      ),
-      code: axiosError.response?.status,
-    }
-  }
-
-  if (!responseError && response?.status === 200) {
-    successData = {
-      message: response.data.message,
-      status: response.data.status,
-    }
-  }
-
-  return {
-    data: successData,
-    error: responseError,
-  }
-}
-//#endregion
-
-//#region Request Password
-export const requestResetPassword = async (
-  data: IResetPasswordRequestData
-): Promise<IResetPasswordResponse> => {
-  let responseError: IError | undefined
-  let responseData: any | undefined
-  let response: AxiosResponse<any> | undefined
-
-  try {
-    response = await Client.post(`/auth/reset-password`, data)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = {
-      message:
-        typeof axiosError.response?.data.message === 'string'
-          ? axiosError.response.data.message
-          : 'Reset password error',
-      code:
-        typeof axiosError.response?.data.status === 'number'
-          ? axiosError.response.data.status
-          : undefined,
-    }
-  }
-
-  if (!responseError && response?.status === 200) {
-    responseData = {
-      message: response.data.message,
-      status: response.status,
-    }
-  }
-
-  return {
-    error: responseError,
-    data: responseData,
-  }
-}
-//#endregion Request Password
-
-//#region Account Tickets
-export const fetchAccountTickets = async ({
-  page = 1,
-  limit = 20,
-  filter = '',
-  from = '',
-}: IMyOrdersRequestParams): Promise<IAccountTicketsResponse> => {
-  let responseError: IError | undefined
-  let response: AxiosResponse<any> | undefined
-
-  const withFilterEvent = filter ? `&filter[event]=${filter}` : ''
-  const withBrand = Config.BRAND ? `&filter[brand]=${Config.BRAND}` : ''
-  const withSubBrands = Config.ARE_SUB_BRANDS_INCLUDED
-    ? `&filter[subbrands]=${Config.ARE_SUB_BRANDS_INCLUDED}`
-    : ''
-  const withFrom = from ? `&filter[from]=${from}` : ''
-
-  const endpoint = `/v1/account/tickets/?page=${page}&limit=${limit}${withFilterEvent}${withBrand}${withSubBrands}${withFrom}`
-
-  try {
-    response = await Client.get(endpoint)
-  } catch (error) {
-    const axiosError = error as AxiosError<ErrorResponseData>
-    responseError = getApiError(axiosError)
-  }
-
-  if (responseError) {
-    return {
-      error: responseError,
-    }
-  }
-
-  if (response?.data) {
-    return {
-      data: response.data.data,
-    }
-  }
-
-  return {
-    error: {
-      message: 'No data was received in Account Tickets.',
-    },
-  }
-}
-//#endregion Account Tickets