@goodgamestudios/cxf-webshop 6.27.3 → 7.0.0-qa.2

package/src_old/app.ts

@@ -0,0 +1,30 @@
+import { DIReader } from './common'
+import { inject } from 'readuz'
+
+export const app: DIReader<void> = inject(
+    (environment) => environment.postMessageHandlers,
+    (environment) => environment.subscribeToCxf,
+    (environment) => environment.log,
+    (environment) => environment.tryCatch,
+    (environment) => environment.preResolveConfig,
+    (postMessageHandlers, subscribeCxf, log, tryCatch, preResolveConfig) => {
+        log('App has started')
+        window.addEventListener(
+            'message',
+            tryCatch(({ data }: MessageEvent) => {
+                if (data) {
+                    const handler = postMessageHandlers[data.name]
+                    if (handler) {
+                        log('POST MESSAGE', data)
+                        handler(data.payload)
+                    }
+                }
+            })
+        )
+        // eslint-disable-next-line array-callback-return
+        Object.entries(subscribeCxf).map(([_, reducer]) => {
+            reducer()
+        })
+        preResolveConfig()
+    }
+)

package/src_old/combineReaders.ts

@@ -0,0 +1,8 @@
+import { IDictionary } from './common'
+import { Reader } from 'readuz'
+
+export const combineReaders =
+    <E>(readers: IDictionary<Reader<E, any>>) =>
+    (environment: E) => {
+        return Object.fromEntries(Object.entries(readers).map<any>(([key, reader]) => [key, reader(environment)]))
+    }

package/src_old/common.ts

@@ -0,0 +1,35 @@
+import { IEnvironment } from './env'
+import { Reader } from 'readuz'
+
+export interface IDictionary<T> {
+    [key: string]: T
+}
+
+export type AnyVoidFn = (...arguments_: any[]) => void
+
+export type DIReader<TResult> = Reader<IEnvironment, TResult>
+
+export type Fn<A, B> = (a: A) => B
+export type PromiseFn<A, B> = Fn<A, Promise<B>>
+
+type IPushMessageId = string
+
+export type IPushMessageData = {
+    id: IPushMessageId
+    payload: IDictionary<any>
+}
+
+export interface IPushMessage<T> {
+    id: string
+    payload: T
+}
+
+export enum WebshopEvents {
+    CXF_DIALOG_CLOSE = 'cxf.dialog.close',
+    CXF_NATIVE_SUBSCRIPTION_ENABLE = 'cxf.native.subscription.enable',
+    CXF_OPEN_SALES_MSG = 'cxf.webshop.sales.open',
+    CXF_SET_CUSTOMIZATION_SUFFIX = 'cxf.set.customization.surfix',
+    CXF_JOIN_TEMP_SERVER = 'cxf.join.temp.server',
+    LEMONSTAND_CATEGORY_UPDATE = 'lemonstand.category.update',
+    LEMONSTAND_NOTIFICATIONS_CREATED = 'lemonstand.notifs.created',
+}

package/src_old/config.ts

@@ -0,0 +1,42 @@
+import { IDictionary, WebshopEvents } from './common'
+import { CxfEvents } from '@goodgamestudios/cxf-events'
+
+export type GameSpecificConfig = {
+    LEGEND_LEVEL_IS_USED: boolean
+}
+
+const COMMON_CONFIG = {
+    CUSTOMIZATION_URL: process.env.CUSTOMIZATION_URL as string,
+    CUSTOMIZATION_URL_TEMPLATE: process.env.CUSTOMIZATION_URL_TEMPLATE as string,
+    BASE_URL: process.env.BASE_URL as string,
+    CXF_DIALOG_OPEN: 'cxf.dialog.open',
+    CXF_DIALOG_CLOSE: 'cxf.dialog.close',
+    CXF_TRACK_MSG: 'cxf.tracking.message',
+    CXF_BTN_CLICK_MSG: CxfEvents.OpenIGS,
+    CXF_OPEN_SALES_MSG: WebshopEvents.CXF_OPEN_SALES_MSG,
+    WEB_SHOP_CALL_TRACK_ID: 1181,
+    CXF_ERROR: 'cxf.error',
+    CXF_PUSH: 'cxf.push',
+    CXF_AD_STATUS: 'cxf.adBanner.status',
+}
+
+export type Config = typeof COMMON_CONFIG & GameSpecificConfig
+
+const GAME_SPECIFIC_CONFIG: IDictionary<GameSpecificConfig> = {
+    12: {
+        LEGEND_LEVEL_IS_USED: true,
+    },
+    15: {
+        LEGEND_LEVEL_IS_USED: false,
+    },
+    16: {
+        LEGEND_LEVEL_IS_USED: true,
+    },
+}
+
+export const createConfig = (gameId: string): Config => {
+    return {
+        ...COMMON_CONFIG,
+        ...GAME_SPECIFIC_CONFIG[gameId],
+    }
+}

package/src_old/cxf.ts

@@ -0,0 +1,32 @@
+import { DIReader } from './common'
+import { inject } from 'readuz'
+import { CXF as ICXFBase } from '@goodgamestudios/cxf-runtime'
+
+export interface IGameApi {
+    invokeFn(functionName: string, ...arguments_: any[]): Promise<any>
+}
+
+export interface ICXF extends ICXFBase {
+    gameApi: IGameApi
+}
+
+export type GetCxf = () => ICXF
+export const getCxf: DIReader<GetCxf> = inject(
+    (environment) => environment.cxfProvider,
+    (cxfProvider) => () => {
+        const cxf = cxfProvider.get()
+        if (cxf) {
+            return cxf
+        }
+
+        throw new Error('CXF is not loaded')
+    }
+)
+
+export type SetCxf = (cxf: ICXF) => void
+export const setCxf: DIReader<SetCxf> = inject(
+    (environment) => environment.cxfProvider,
+    (cxfProvider) => (value) => {
+        cxfProvider.set(value)
+    }
+)

package/src_old/dialog.ts

@@ -0,0 +1,25 @@
+import { inject } from 'readuz'
+import { DIReader } from './common'
+import { getCxf } from './helpers'
+
+export type RemoveDialog = () => void
+export const removeDialog: DIReader<RemoveDialog> = inject(
+    (environment) => environment.config,
+    (environment) => environment.cxfProvider,
+    ({ CXF_DIALOG_CLOSE }, cxfProvider) =>
+        () => {
+            const cxf = getCxf(cxfProvider)
+            cxf.emit(CXF_DIALOG_CLOSE)
+        }
+)
+
+export type CreateDialog = (url: string) => void
+export const createDialog: DIReader<CreateDialog> = inject(
+    (environment) => environment.config,
+    (environment) => environment.cxfProvider,
+    ({ CXF_DIALOG_OPEN }, cxfProvider) =>
+        (url) => {
+            const cxf = getCxf(cxfProvider)
+            cxf.emit(CXF_DIALOG_OPEN, url)
+        }
+)

package/src_old/env.ts

@@ -0,0 +1,127 @@
+import { just } from 'readuz'
+import { createCxfReducers, CxfReducers, subscribeToGameEvents, SubscribeToGameEvents } from './handlers/reducers'
+import { DIReader } from './common'
+import { Config, createConfig } from './config'
+import { CreateDialog, createDialog, RemoveDialog, removeDialog } from './dialog'
+import { OnOpen, onOpen } from './handlers/eventHandlers'
+import {
+    entityProvider,
+    getDomain,
+    GetDomain,
+    getPing,
+    GetPing,
+    ggsGetQueryParams as ggsGetQueryParameters,
+    GGSGetQueryParams as GGSGetQueryParameters,
+    ggsGetReferrerValue,
+    GGSGetReferrerValue,
+    IProvider,
+    loadCxf,
+    LoadCxf,
+    Log,
+    log,
+    LogError,
+    logError,
+    ThrowCxfError,
+    throwCxfError,
+    TryCatch,
+    tryCatch,
+} from './helpers'
+import { TrackAction, trackAction, TrackOpenAction, trackOpenAction } from './track'
+import { CreateCustomizationUrl, createCustomizationUrl, CreateIframeUrl, createIframeUrl } from './url'
+import { createPushHandlers, PushHandlers } from './handlers/pushHandlers'
+import { createPostMessageHandlers, Handlers } from './handlers/postMessageHandlers'
+import { GetStorageData, getStorageData, setStorageData, SetStorageData } from './storage'
+import { defaultStore, getStore, GetStore, IStore, setStore, SetStore } from './store'
+import { getCxf, GetCxf, ICXF } from './cxf'
+import { IShopMessageBus } from './messages/IShopMessageBus'
+import { ShopMessageBus } from './messages/ShopMessageBus'
+import { preResolveConfig, PreFetch } from './preFetch'
+import { OfferNotificationsFetchResult, fetchUnreadOfferNotificationsCount } from './fetch'
+
+export interface IEnvironment {
+    config: DIReader<Config>
+
+    cxfProvider: DIReader<IProvider<ICXF>>
+    getCxf: DIReader<GetCxf>
+
+    dialogProvider: DIReader<IProvider<HTMLElement>>
+
+    store: DIReader<IProvider<IStore>>
+    getStore: DIReader<GetStore>
+    setStore: DIReader<SetStore>
+    log: DIReader<Log>
+    logError: DIReader<LogError>
+    throwCxfError: DIReader<ThrowCxfError>
+
+    createDialog: DIReader<CreateDialog>
+    removeDialog: DIReader<RemoveDialog>
+
+    createIframeUrl: DIReader<CreateIframeUrl>
+    createCustomizationUrl: DIReader<CreateCustomizationUrl>
+
+    onOpen: DIReader<OnOpen>
+
+    pushHandlers: DIReader<PushHandlers>
+    postMessageHandlers: DIReader<Handlers>
+    subscribeToCxf: DIReader<CxfReducers>
+    trackOpenAction: DIReader<TrackOpenAction>
+    trackAction: DIReader<TrackAction>
+    loadCxf: DIReader<LoadCxf>
+    tryCatch: DIReader<TryCatch>
+
+    getStorageData: DIReader<GetStorageData>
+    setStorageData: DIReader<SetStorageData>
+    getPing: DIReader<GetPing>
+    subscribeToGameEvents: DIReader<SubscribeToGameEvents>
+    getDomain: DIReader<GetDomain>
+    ggsGetQueryParams: DIReader<GGSGetQueryParameters>
+    ggsGetReferrerValue: DIReader<GGSGetReferrerValue>
+    shopMessageBus: DIReader<IShopMessageBus>
+    preResolveConfig: DIReader<PreFetch>
+    fetchUnreadOfferNotificationsCount: DIReader<OfferNotificationsFetchResult>
+}
+
+export const createEnv = (environment: Partial<IEnvironment>): IEnvironment => {
+    return {
+        config: just(createConfig('15')),
+
+        cxfProvider: just(entityProvider()),
+        getCxf,
+        subscribeToGameEvents,
+
+        dialogProvider: just(entityProvider()),
+
+        store: just(entityProvider(defaultStore({} as ICXF))),
+        getStore,
+        setStore,
+        log: just(log),
+        logError: just(logError),
+        throwCxfError,
+
+        createDialog,
+        removeDialog,
+        pushHandlers: createPushHandlers({}),
+        postMessageHandlers: createPostMessageHandlers({}),
+        subscribeToCxf: createCxfReducers({}),
+        onOpen,
+        createIframeUrl,
+        createCustomizationUrl,
+        trackOpenAction,
+        trackAction,
+        loadCxf: just(loadCxf),
+        tryCatch,
+
+        getStorageData: just(getStorageData),
+        setStorageData: just(setStorageData),
+        getPing,
+        getDomain,
+        ggsGetQueryParams: ggsGetQueryParameters,
+        ggsGetReferrerValue,
+
+        shopMessageBus: just(new ShopMessageBus()),
+        preResolveConfig,
+        fetchUnreadOfferNotificationsCount,
+
+        ...environment,
+    }
+}

package/src_old/fetch.ts

@@ -0,0 +1,46 @@
+import { DIReader } from './common'
+import { inject } from 'readuz'
+import { criteriaSelector } from './store'
+
+export type OfferNotificationsFetchResult = () => void
+export const fetchUnreadOfferNotificationsCount: DIReader<OfferNotificationsFetchResult> = inject(
+    (environment) => environment.log,
+    (environment) => environment.logError,
+    (environment) => environment.getStore,
+    (environment) => environment.config,
+    (log, logError, getStore, { LEGEND_LEVEL_IS_USED }) =>
+        async () => {
+            const store = getStore()
+            if (LEGEND_LEVEL_IS_USED && store.legendLevel === undefined) {
+                log('Skip fetchUnreadOfferNotificationsCount due to legendLevel is undefined')
+                return
+            }
+            log('fetchUnreadOfferNotificationsCount')
+            if (store.token && store.unreadOfferNotifsCountUrl) {
+                let unreadCount = 0
+                const headers = {
+                    Authorization: `Bearer ${store.token}`,
+                }
+                const url = store.unreadOfferNotifsCountUrl
+                    .replace('{locale}', store.language || '')
+                    .replace('{zoneId}', store.zoneId || '')
+                    .replace('{criteria}', encodeURIComponent(JSON.stringify(criteriaSelector(store))))
+                try {
+                    log('fetch', url)
+                    const resp = await fetch(url, {
+                        headers,
+                    })
+                    if (resp.ok) {
+                        const data = await resp.json()
+                        unreadCount = Number(data?.notifCount)
+                    }
+                } catch (error) {
+                    logError(`cannot fetch ${url}`, error)
+                }
+                log('setUnseenOffersCounter', unreadCount)
+                store.gameApi.invokeFn('setUnseenOffersCounter', unreadCount).catch((error) => {
+                    logError('setUnseenOffersCounter error:', error)
+                })
+            }
+        }
+)

package/src_old/handlers/eventHandlers.ts

@@ -0,0 +1,43 @@
+import { inject } from 'readuz'
+import { DIReader } from '../common'
+import { createSessionId } from '../helpers'
+
+export interface OpenIGSPayload {
+    page?: string
+    route?: string
+    sourceId?: string
+    config?: Record<string, any>
+}
+
+export type OnOpen = (payload?: OpenIGSPayload) => void
+export const onOpen: DIReader<OnOpen> = inject(
+    (environment) => environment.createIframeUrl,
+    (environment) => environment.createDialog,
+    (environment) => environment.log,
+    (environment) => environment.trackOpenAction,
+    (environment) => environment.getStore,
+    (environment) => environment.setStore,
+    (createIframeUrl, createDialog, log, trackOpenAction, getStore, setStore) =>
+        (payload = {}) => {
+            log('OnOpen payload:', payload)
+            if (payload.sourceId) {
+                setStore({
+                    sourceId: payload.sourceId,
+                })
+            }
+            const store = getStore()
+            const sid = createSessionId()
+            trackOpenAction(sid)
+            const url = createIframeUrl({
+                sid,
+                page: store.lastPurchaseTab,
+                ...payload,
+            })
+            createDialog(url)
+            setTimeout(() => {
+                // remove unread offer notifications counter on the IGS button while opening the IGS
+                // small delay makes UX a bit better due to it happens after IGS initialization is started
+                store.gameApi.invokeFn('setUnseenOffersCounter', 0)
+            }, 1000)
+        }
+)

package/src_old/handlers/postMessageHandlers.ts

@@ -0,0 +1,43 @@
+import { inject } from 'readuz'
+import { DIReader, WebshopEvents, IDictionary } from '../common'
+import { combineReaders } from '../combineReaders'
+import { createSessionId } from '../helpers'
+
+export type OpenSalesPage = () => void
+export const onSalesPageOpen: DIReader<OpenSalesPage> = inject(
+    (environment) => environment.log,
+    (environment) => environment.createDialog,
+    (environment) => environment.createIframeUrl,
+    (log, createDialog, createIframeUrl) => () => {
+        log('OnOpenSalesOffersPage')
+        const sid = createSessionId()
+        const url = createIframeUrl({
+            page: 'sale-offers',
+            sid,
+        })
+        createDialog(url)
+    }
+)
+
+export type LemonstandClose = () => void
+export const onLemonstandClose: DIReader<LemonstandClose> = inject(
+    (environment) => environment.log,
+    (environment) => environment.getStore,
+    (environment) => environment.fetchUnreadOfferNotificationsCount,
+    (log, getStore, fetchUnreadOfferNotificationsCount) => () => {
+        const store = getStore()
+        log('onLemonstandClose', store)
+        fetchUnreadOfferNotificationsCount()
+    }
+)
+
+export type Handler = (...arguments_: any[]) => void
+export type Handlers = IDictionary<Handler>
+
+export function createPostMessageHandlers(handlers: IDictionary<DIReader<Handler>>) {
+    return combineReaders({
+        [WebshopEvents.CXF_OPEN_SALES_MSG]: onSalesPageOpen,
+        [WebshopEvents.CXF_DIALOG_CLOSE]: onLemonstandClose,
+        ...handlers,
+    })
+}

package/src_old/handlers/pushHandlers.ts

@@ -0,0 +1,95 @@
+import { DIReader, WebshopEvents, IDictionary } from '../common'
+import { combineReaders } from '../combineReaders'
+import { inject } from 'readuz'
+
+interface OnRewardProperties {
+    successUrl: string
+    offerId: string
+    sid: string
+    page: string
+    config?: Record<string, any>
+}
+
+export type OnReward = (properties: OnRewardProperties) => void
+export const onReward: DIReader<OnReward> = inject(
+    (environment) => environment.log,
+    (environment) => environment.createDialog,
+    (environment) => environment.createIframeUrl,
+    (environment) => environment.setStore,
+    (environment) => environment.trackOpenAction,
+    (log, createDialog, createIframeUrl, setStore, trackOpenAction) => (payload) => {
+        log('OnReward: offerId', payload.offerId, 'Page', payload.page)
+        const url = createIframeUrl({
+            route: encodeURIComponent(payload.successUrl),
+            ...payload,
+        })
+        setStore({
+            lastPurchaseTab: payload.page,
+            sourceId: 'successfulPayoutReward',
+        })
+        trackOpenAction(payload.sid)
+
+        createDialog(url)
+    }
+)
+
+export interface OnLemonstandCategoryUpdateProperties {
+    target: string
+    action: string
+    data: any
+}
+export type OnLemonstandCategoryUpdate = (properties: OnLemonstandCategoryUpdateProperties) => void
+export const onLemonstandCategoryUpdate: DIReader<OnLemonstandCategoryUpdate> = inject(
+    (environment) => environment.shopMessageBus,
+    (shopMessageBus) =>
+        ({ target, action, data }) => {
+            shopMessageBus.post({
+                eventName: WebshopEvents.LEMONSTAND_CATEGORY_UPDATE,
+                target,
+                data: { action, data },
+            })
+        }
+)
+
+export interface OnLemonstandNotificationsCreatedProperties {
+    notifCount: number
+}
+type OnLemonstandNotificationsCreated = (properties: OnLemonstandNotificationsCreatedProperties) => void
+
+/**
+ * this handler works in case of offer notification activation and deactivation
+ */
+export const onLemonstandNotificationsCreated: DIReader<OnLemonstandNotificationsCreated> = inject(
+    (environment) => environment.log,
+    (environment) => environment.logError,
+    (environment) => environment.getStore,
+    (environment) => environment.fetchUnreadOfferNotificationsCount,
+    (log, logError, getStore, fetchUnreadOfferNotificationsCount) =>
+        ({ notifCount }) => {
+            log('onLemonstandNotificationsCreated -> notifCount:', notifCount)
+            const store = getStore()
+            if (notifCount > 0) {
+                // random delay in range 1-120 sec on LIVE, and 1-15 sec on TEST
+                const randomDelayMs = Math.floor(Math.random() * (Number(store.networkId) < 250 ? 120_000 : 15_000))
+                setTimeout(() => {
+                    fetchUnreadOfferNotificationsCount()
+                }, randomDelayMs)
+            } else {
+                store.gameApi.invokeFn('setUnseenOffersCounter', 0).catch((error) => {
+                    logError('setUnseenOffersCounter error:', error)
+                })
+            }
+        }
+)
+
+export type PushHandler = (...arguments_: any[]) => void
+export type PushHandlers = IDictionary<PushHandler>
+
+export function createPushHandlers(handlers: IDictionary<DIReader<PushHandler>>) {
+    return combineReaders({
+        reward: onReward,
+        [WebshopEvents.LEMONSTAND_CATEGORY_UPDATE]: onLemonstandCategoryUpdate,
+        [WebshopEvents.LEMONSTAND_NOTIFICATIONS_CREATED]: onLemonstandNotificationsCreated,
+        ...handlers,
+    })
+}