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

package/src/containers/tickets/Tickets.tsx

@@ -1,525 +0,0 @@
-import _get from 'lodash/get'
-import _isEmpty from 'lodash/isEmpty'
-import _some from 'lodash/some'
-import React, {
-  forwardRef,
-  useCallback,
-  useEffect,
-  useImperativeHandle,
-  useRef,
-  useState,
-} from 'react'
-import { Alert } from 'react-native'
-
-import {
-  IEventResponse,
-  IFetchAccessTokenResponse,
-  IPromoCodeResponse,
-} from '../../api/types'
-import { SessionHandle, TicketsCore, TicketsCoreHandle } from '../../core'
-import { SessionHandleType } from '../../core/Session/SessionCoreTypes'
-import {
-  IBookTicketsOptions,
-  IGetTicketsPayload,
-  IGroupedTickets,
-} from '../../core/TicketsCore/TicketsCoreTypes'
-import {
-  IAddToCartResponse,
-  IEvent,
-  IOnFetchTicketsSuccess,
-  ISelectedTicket,
-  ITicket,
-} from '../../types'
-import TicketsView from './TicketsView'
-import { IPasswordProtectedEventData, ITicketsProps } from './types'
-import { Logger } from '../../utils/Logger'
-
-const Tickets = forwardRef<SessionHandleType, ITicketsProps>(
-  (
-    {
-      onAddToCartSuccess,
-      onAddToCartError,
-      onFetchTicketsError,
-      styles,
-      texts,
-      isAccessCodeEnabled = false,
-      isPromoEnabled = true,
-      onPressMyOrders,
-      onPressLogout,
-      onFetchTicketsSuccess,
-      onFetchEventError,
-      onLoadingChange,
-      onFetchEventSuccess,
-      onAddToWaitingListError,
-      onAddToWaitingListSuccess,
-      promoCodeCloseIcon,
-      isCheckingCurrentSession,
-      config = {
-        areTicketsGrouped: true,
-        areActivityIndicatorsEnabled: true,
-        areAlertsEnabled: true,
-        areTicketsSortedBySoldOut: true,
-      },
-      referrerId,
-      debugMode,
-    },
-    ref
-  ) => {
-    const logger = new Logger({ level: debugMode ? 'debug' : 'error' })
-    const [isUserLogged, setIsUserLogged] = useState(false)
-    const [isGettingTickets, setIsGettingTickets] = useState(false)
-    const [isGettingEvent, setIsGettingEvent] = useState(false)
-    const [event, setEvent] = useState<IEvent>()
-    const [isBooking, setIsBooking] = useState(false)
-    const [areTicketGroupsShown, setAreTicketGroupsShown] = useState(false)
-    const [tickets, setTickets] = useState<ITicket[]>([])
-    const [groupedTickets, setGroupedTickets] = useState<IGroupedTickets[]>([])
-    const [isWaitingListVisible, setIsWaitingListVisible] = useState(false)
-    const [isAccessCode, setIsAccessCode] = useState(false)
-    const [selectedTicket, setSelectedTicket] = useState<ISelectedTicket>()
-    const [promoCodeResponse, setPromoCodeResponse] = useState<
-      IPromoCodeResponse | undefined
-    >(undefined)
-    const [isFirstCall, setIsFirstCall] = useState(true)
-    const [passwordProtectedEventData, setPasswordProtectedEventData] = useState<
-      IPasswordProtectedEventData | undefined
-    >()
-
-    //#region Refs
-    const eventErrorCodeRef = useRef(0)
-    const ticketsCoreRef = useRef<TicketsCoreHandle>(null)
-    const sessionHandleRef = useRef<SessionHandleType>(null)
-    const isApiErrorRef = useRef<boolean>(false)
-    //#endregion Refs
-
-    const showAlert = (message: string) => {
-      if (config.areAlertsEnabled) {
-        Alert.alert('', message)
-      }
-    }
-
-    const isTicketOnSale = (ticketsForCheck: ITicket[]) =>
-      _some(
-        ticketsForCheck,
-        (item: ITicket) => item.salesStarted && !item.salesEnded && !item.soldOut
-      )
-
-    const areTicketsOnSale = (): boolean => {
-      if (event?.salesEnded) {
-        return false
-      }
-
-      if (
-        config.areTicketsGrouped &&
-        areTicketGroupsShown &&
-        groupedTickets.length === 0
-      ) {
-        return false
-      }
-
-      if (!config.areTicketsGrouped && tickets.length === 0) {
-        return false
-      }
-
-      if (config.areTicketsGrouped) {
-        return _some(groupedTickets, (gTicket) => isTicketOnSale(gTicket.data))
-      } else {
-        return isTicketOnSale(tickets)
-      }
-    }
-
-    //#region Core Api calls
-    const retrieveStoredAccessToken = async () => {
-      if (!ticketsCoreRef.current) {
-        return { eventError: { message: 'Ticket core is not initialized' } }
-      }
-
-      setIsUserLogged(await ticketsCoreRef.current.getIsUserLoggedIn())
-    }
-
-    const getTicketsCore = async (promoCode?: string): Promise<IGetTicketsPayload> => {
-      if (!ticketsCoreRef.current) {
-        return { error: { message: 'Ticket core is not initialized' } }
-      }
-
-      return await ticketsCoreRef.current.getTickets({
-        referredId: referrerId,
-        promoCode,
-        areTicketsSortedBySoldOut: config.areTicketsSortedBySoldOut,
-        areTicketsGrouped: config.areTicketsGrouped,
-      })
-    }
-
-    const unlockPasswordProtectedEventCore = async (
-      password: string
-    ): Promise<IEventResponse> => {
-      if (!ticketsCoreRef.current) {
-        return { eventError: { message: 'Ticket core is not initialized' } }
-      }
-
-      return await ticketsCoreRef.current.unlockPasswordProtectedEvent(password)
-    }
-
-    const getEventCore = async (): Promise<IEventResponse> => {
-      if (!ticketsCoreRef.current) {
-        return { eventError: { message: 'Ticket core is not initialized' } }
-      }
-
-      return await ticketsCoreRef.current.getEvent()
-    }
-
-    const addToCartCore = async (
-      data: IBookTicketsOptions
-    ): Promise<IAddToCartResponse> => {
-      if (!ticketsCoreRef.current) {
-        return { error: { message: 'Ticket core is not initialized' } }
-      }
-
-      return await ticketsCoreRef.current.addToCart(data)
-    }
-    //#endregion Core Api calls
-
-    //#region Fetch Initial Data
-    const fetchInitialData = async () => {
-      try {
-        logger.info('Fetching initial data')
-        await retrieveStoredAccessToken()
-        logger.info('retrieveStoredAccessToken')
-        await getEventData()
-        logger.info('getEventData success')
-      } catch (error) {
-        logger.error('Error while fetching initial data', error)
-      }
-    }
-    //#endregion Fetch Initial Data
-
-    //#region Api Calls
-    const getTickets = async (promoCode: string = '') => {
-      setIsGettingTickets(true)
-      isApiErrorRef.current = false
-      const {
-        error,
-        tickets: responseTickets,
-        promoCodeResult,
-        isInWaitingList,
-        isAccessCodeRequired,
-        areGroupsShown,
-      } = await getTicketsCore(promoCode)
-      logger.info('getTicketsCore response', {
-        error,
-        tickets: responseTickets,
-        promoCodeResult,
-        isInWaitingList,
-        isAccessCodeRequired,
-        areGroupsShown,
-      })
-      setIsGettingTickets(false)
-
-      if (error) {
-        onFetchTicketsError?.(error)
-        isApiErrorRef.current = true
-        return showAlert('Error while getting tickets, please try again')
-      }
-
-      setIsWaitingListVisible(!!isInWaitingList)
-      setIsAccessCode(!!isAccessCodeRequired)
-      setAreTicketGroupsShown(areGroupsShown || false)
-
-      if (responseTickets && !_isEmpty(responseTickets)) {
-        if (config.areTicketsGrouped) {
-          if (areGroupsShown) {
-            setGroupedTickets(responseTickets as IGroupedTickets[])
-          } else {
-            setTickets(responseTickets as ITicket[])
-          }
-        } else {
-          setTickets(responseTickets as ITicket[])
-        }
-
-        if (isFirstCall && promoCodeResult?.isValid) {
-          setPromoCodeResponse(promoCodeResult)
-        } else if (!isFirstCall) {
-          setPromoCodeResponse(promoCodeResult)
-        }
-
-        const onFetchTicketsData: IOnFetchTicketsSuccess = {
-          promoCodeResponse: {
-            success: true,
-            message: promoCodeResponse?.message,
-          },
-          tickets: responseTickets,
-          isInWaitingList,
-          isAccessCodeRequired,
-          areTicketsGroupsShown: areGroupsShown,
-        }
-
-        onFetchTicketsSuccess?.(onFetchTicketsData)
-
-        if (
-          !isFirstCall &&
-          (!promoCodeResult?.isValid || promoCodeResult.isValid === 0)
-        ) {
-          onFetchTicketsSuccess?.({
-            ...onFetchTicketsData,
-            promoCodeResponse: {
-              success: false,
-              message: promoCodeResult?.message,
-            },
-          })
-        }
-      }
-
-      setIsFirstCall(false)
-    }
-
-    const getEventData = async () => {
-      logger.info('Fetching event data: API call')
-      if (isApiErrorRef.current === true) {
-        logger.info('Fetching event data: API call: Skip, error already occurred')
-        return
-      }
-
-      setIsGettingEvent(true)
-      const { eventError, eventData } = await getEventCore()
-      logger.info('Fetching event data: API call: response', {
-        eventError,
-        eventData,
-      })
-      setIsGettingEvent(false)
-
-      if (eventError) {
-        logger.info('Fetching event data: API call: Error', eventError)
-        eventErrorCodeRef.current = eventError.code || 400
-        if (eventError.code === 401) {
-          logger.info('Fetching event data: API call: Error: 401')
-          setPasswordProtectedEventData({
-            isPasswordProtected: true,
-            message: eventError.message,
-          })
-        } else {
-          logger.info('Fetching event data: API call: Error: ' + eventError.message)
-          showAlert(eventError.message)
-        }
-        return onFetchEventError?.(
-          eventError || { message: 'There was an error while fetching event' }
-        )
-      }
-
-      eventErrorCodeRef.current = 0
-
-      if (!eventData) {
-        logger.info('Fetching event data: API call: Error: No event data')
-        return onFetchEventError?.({
-          message: 'There was an error while fetching event',
-        })
-      }
-
-      try {
-        logger.info('Fetching tickets: getTickets()')
-        await getTickets()
-      } catch (error) {
-        logger.info('Fetching tickets: getTickets() Error: ' + error)
-        showAlert(error)
-      }
-
-      onFetchEventSuccess?.(eventData)
-      setEvent(eventData)
-    }
-
-    const performBookTickets = async () => {
-      if (!selectedTicket || !selectedTicket.selectedOption) {
-        onAddToCartError?.({ message: 'Please select a ticket' })
-        return showAlert('Please select a ticket')
-      }
-
-      const ticketQuantity =
-        typeof selectedTicket.selectedOption.value === 'string'
-          ? parseInt(selectedTicket.selectedOption.value, 10)
-          : selectedTicket.selectedOption.value
-
-      const ticketsOptions: IBookTicketsOptions = {
-        quantity: ticketQuantity,
-        optionName: _get(selectedTicket, 'optionName'),
-        ticketId: _get(selectedTicket, 'id'),
-        price: selectedTicket.price,
-      }
-
-      setIsBooking(true)
-      const { data: result, error: addToCartError } = await addToCartCore(ticketsOptions)
-      setIsBooking(false)
-
-      if (result) {
-        return onAddToCartSuccess?.(result)
-      }
-
-      if (addToCartError) {
-        showAlert(addToCartError.message || 'Error while adding tickets to cart')
-        return onAddToCartError?.(addToCartError)
-      }
-    }
-    //#endregion Api Calls
-
-    const onLoadingChangeCallback = useCallback(
-      (loading: boolean) => {
-        if (onLoadingChange) {
-          onLoadingChange(loading)
-        }
-      },
-      [onLoadingChange]
-    )
-
-    //#region UseEffects
-    useEffect(() => {
-      if (isGettingEvent || isGettingTickets || isBooking) {
-        onLoadingChangeCallback(true)
-      } else {
-        onLoadingChangeCallback(false)
-      }
-    }, [isGettingTickets, isGettingEvent, isBooking, onLoadingChangeCallback])
-
-    useEffect(() => {
-      if (!isCheckingCurrentSession && isFirstCall) {
-        fetchInitialData()
-      }
-    }, [isCheckingCurrentSession])
-    //#endregion UseEffects
-
-    //#region Imperative Handler
-    useImperativeHandle(ref, () => ({
-      async refreshAccessToken(refreshToken: string): Promise<IFetchAccessTokenResponse> {
-        if (!sessionHandleRef.current) {
-          return {
-            accessTokenError: {
-              message: 'Session Handle ref is not initialized',
-            },
-          }
-        }
-
-        const { accessTokenError, accessTokenData } =
-          await sessionHandleRef.current!.refreshAccessToken(refreshToken)
-        if (!accessTokenError && accessTokenData?.accessToken) {
-          await fetchInitialData()
-        }
-        return {
-          accessTokenData,
-          accessTokenError,
-        }
-      },
-
-      async reloadData() {
-        await fetchInitialData()
-      },
-    }))
-    //#endregion Imperative Handler
-
-    //#region Handlers
-    const handleOnPressGetTickets = () => {
-      if (eventErrorCodeRef.current !== 0) {
-        showAlert('Event not found')
-        return onAddToCartError?.({
-          code: eventErrorCodeRef.current,
-          message: 'Event not found',
-        })
-      }
-      performBookTickets()
-    }
-
-    const handleOnPressApplyPromoCode = async (code: string) => {
-      await getTickets(code)
-    }
-
-    const handleOnSelectTicketOption = (ticket: ISelectedTicket) => {
-      setSelectedTicket(ticket)
-    }
-
-    const handleOnLogout = async () => {
-      if (!ticketsCoreRef.current) {
-        return { error: { message: 'Ticket core is not initialized' } }
-      }
-
-      await ticketsCoreRef.current.logout()
-      setIsUserLogged(false)
-
-      await getEventData()
-      onPressLogout?.()
-    }
-
-    const handleOnLoadingChange = (loading: boolean) => {
-      onLoadingChangeCallback(loading)
-    }
-
-    const handleOnSubmitEventPassword = async (password: string) => {
-      setPasswordProtectedEventData({
-        ...passwordProtectedEventData,
-        isLoading: true,
-      })
-
-      const { eventData, eventError } = await unlockPasswordProtectedEventCore(password)
-
-      if (eventError) {
-        return setPasswordProtectedEventData({
-          ...passwordProtectedEventData,
-          isLoading: false,
-          apiError: eventError.message,
-        })
-      }
-
-      setPasswordProtectedEventData({
-        ...passwordProtectedEventData,
-        isLoading: false,
-        apiError: '',
-        isPasswordProtected: false,
-        message: '',
-      })
-      eventErrorCodeRef.current = 0
-
-      onFetchEventSuccess?.(eventData!)
-      setEvent(eventData)
-      getTickets()
-    }
-    //#endregion
-
-    //#region RENDER
-    return (
-      <TicketsCore ref={ticketsCoreRef}>
-        <SessionHandle ref={sessionHandleRef}>
-          <TicketsView
-            isGettingTickets={isGettingTickets}
-            tickets={tickets}
-            groupedTickets={groupedTickets}
-            onPressGetTickets={handleOnPressGetTickets}
-            onPressApplyPromoCode={handleOnPressApplyPromoCode}
-            promoCodeValidationMessage={promoCodeResponse?.message}
-            isPromoCodeValid={promoCodeResponse?.isValid}
-            onSelectTicketOption={handleOnSelectTicketOption}
-            selectedTicket={selectedTicket}
-            isBookingTickets={isBooking}
-            styles={styles}
-            isGettingEvent={isGettingEvent}
-            texts={texts}
-            event={event}
-            isWaitingListVisible={isWaitingListVisible}
-            isGetTicketsButtonVisible={areTicketsOnSale()}
-            isAccessCodeEnabled={isAccessCodeEnabled || isAccessCode}
-            isPromoEnabled={isPromoEnabled}
-            isUserLogged={isUserLogged}
-            onPressMyOrders={onPressMyOrders}
-            onPressLogout={handleOnLogout}
-            areLoadingIndicatorsEnabled={config.areActivityIndicatorsEnabled}
-            onAddToWaitingListError={onAddToWaitingListError}
-            onAddToWaitingListSuccess={onAddToWaitingListSuccess}
-            onLoadingChange={handleOnLoadingChange}
-            promoCodeCloseIcon={promoCodeCloseIcon}
-            areTicketsGroupsShown={areTicketGroupsShown}
-            passwordProtectedEventData={passwordProtectedEventData}
-            onPressSubmitEventPassword={handleOnSubmitEventPassword}
-            isCheckingCurrentSession={isCheckingCurrentSession}
-          />
-        </SessionHandle>
-      </TicketsCore>
-    )
-    //#endregion RENDER
-  }
-)
-
-export default Tickets

package/src/containers/tickets/TicketsView.tsx

@@ -1,164 +0,0 @@
-import React from 'react'
-import { FlatList, SectionList, Text, View } from 'react-native'
-
-import {
-  EnterPassword,
-  Loading,
-  LoggedIn,
-  PromoCode,
-  WaitingList,
-} from '../../components'
-import Button from '../../components/button/Button'
-import Separator from '../../components/separator/Separator'
-import TicketGroupListHeader from './components/TicketGroupListHeader'
-import CartListItem from './components/TicketListItem'
-import s from './styles'
-import { ITicketsViewProps } from './types'
-
-const TicketsView = ({
-  isGettingTickets,
-  tickets,
-  groupedTickets,
-  styles,
-  onPressGetTickets,
-  onPressApplyPromoCode,
-  promoCodeValidationMessage,
-  isPromoCodeValid,
-  onSelectTicketOption,
-  selectedTicket,
-  isBookingTickets,
-  texts,
-  isGettingEvent,
-  event,
-  isWaitingListVisible,
-  isGetTicketsButtonVisible,
-  isAccessCodeEnabled,
-  isUserLogged,
-  onPressMyOrders,
-  onPressLogout,
-  areLoadingIndicatorsEnabled,
-  onAddToWaitingListError,
-  onAddToWaitingListSuccess,
-  onLoadingChange,
-  areAlertsEnabled,
-  promoCodeCloseIcon,
-  areTicketsGroupsShown,
-  passwordProtectedEventData,
-  onPressSubmitEventPassword,
-}: ITicketsViewProps) => {
-  const isButtonDisabled = !selectedTicket || selectedTicket.selectedOption?.value === 0
-  const buttonText = texts?.getTicketsButton
-    ? texts.getTicketsButton
-    : isButtonDisabled
-      ? 'Get tickets'
-      : `Get ${selectedTicket?.selectedOption?.value} tickets`
-  const title = texts?.title ? texts.title : 'GET TICKETS'
-
-  return passwordProtectedEventData?.isPasswordProtected ? (
-    <EnterPassword
-      onSubmit={onPressSubmitEventPassword}
-      styles={styles?.enterPassword}
-      texts={texts?.enterPassword}
-      isLoading={passwordProtectedEventData?.isLoading}
-      apiError={passwordProtectedEventData?.apiError}
-    />
-  ) : (
-    <View style={[s.container, styles?.rootContainer]}>
-      <View style={[s.container, styles?.container]}>
-        <View style={s.header}>
-          <Text style={[s.headerText, styles?.title]}>{title}</Text>
-        </View>
-        <PromoCode
-          onPressApply={onPressApplyPromoCode}
-          promoCodeValidationMessage={promoCodeValidationMessage}
-          isPromoCodeValid={isPromoCodeValid}
-          isAccessCodeEnabled={isAccessCodeEnabled}
-          styles={styles?.promoCode}
-          texts={texts?.promoCode}
-          closeButtonIcon={promoCodeCloseIcon}
-        />
-        {areTicketsGroupsShown ? (
-          <SectionList
-            sections={groupedTickets}
-            style={styles?.ticketList?.listContainer}
-            renderItem={({ item, index }) => (
-              <CartListItem
-                onSelectTicketItem={onSelectTicketOption}
-                ticket={item}
-                ticketNumber={index}
-                selectedTicket={selectedTicket}
-                styles={styles?.ticketList?.item}
-                texts={texts?.listItem}
-                {...item}
-              />
-            )}
-            renderSectionHeader={(data) => (
-              <TicketGroupListHeader
-                text={data.section.title}
-                styles={{
-                  container: styles?.ticketList?.sectionHeader?.container,
-                  text: styles?.ticketList?.sectionHeader?.title,
-                }}
-              />
-            )}
-          />
-        ) : (
-          <FlatList
-            data={tickets}
-            style={styles?.ticketList?.listContainer}
-            keyExtractor={(item) => `ticket.${item.id}`}
-            renderItem={({ item, index }) => (
-              <CartListItem
-                onSelectTicketItem={onSelectTicketOption}
-                ticket={item}
-                ticketNumber={index}
-                selectedTicket={selectedTicket}
-                styles={styles?.ticketList?.item}
-                texts={texts?.listItem}
-                {...item}
-              />
-            )}
-            ItemSeparatorComponent={() => <Separator />}
-          />
-        )}
-        {isWaitingListVisible && event?.salesStarted && (
-          <WaitingList
-            styles={styles?.waitingList}
-            texts={texts?.waitingList}
-            onAddToWaitingListSuccess={onAddToWaitingListSuccess}
-            onAddToWaitingListError={onAddToWaitingListError}
-            onLoadingChange={onLoadingChange}
-            areAlertsEnabled={areAlertsEnabled}
-          />
-        )}
-        {isGetTicketsButtonVisible && (
-          <Button
-            text={buttonText}
-            onPress={onPressGetTickets}
-            isUpperCase={true}
-            isLoading={isBookingTickets}
-            isDisabled={isButtonDisabled}
-            styles={
-              isButtonDisabled
-                ? styles?.getTicketsButtonDisabled
-                : styles?.getTicketsButtonActive
-            }
-          />
-        )}
-        {isUserLogged && (
-          <LoggedIn
-            onPressMyOrders={onPressMyOrders}
-            styles={styles?.loggedIn}
-            texts={texts?.loggedInTexts}
-            onPressLogout={onPressLogout}
-          />
-        )}
-        {(isGettingTickets || isGettingEvent) && areLoadingIndicatorsEnabled && (
-          <Loading />
-        )}
-      </View>
-    </View>
-  )
-}
-
-export default TicketsView

package/src/containers/tickets/components/TicketGroupListHeader.tsx

@@ -1,12 +0,0 @@
-import React, { FC } from 'react'
-import { Text, View } from 'react-native'
-
-import { ITicketGroupListHeaderProps } from './types'
-
-const TicketGroupListHeader: FC<ITicketGroupListHeaderProps> = ({ styles, text }) => (
-  <View style={styles?.container}>
-    {!!text && <Text style={styles?.text}>{text}</Text>}
-  </View>
-)
-
-export default TicketGroupListHeader