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

package/src_old/preFetch.ts

@@ -1,43 +0,0 @@
-import { DIReader } from './common'
-import { inject } from 'readuz'
-
-type LemonstandConfig = {
-    css: string
-    js: string
-    unreadOfferNotifsCountUrl: string
-}
-
-export type PreFetch = (...parameter: any[]) => void
-
-export const preResolveConfig: DIReader<PreFetch> = inject(
-    (environment) => environment.log,
-    (environment) => environment.setStore,
-    (environment) => environment.createCustomizationUrl,
-    (log, setStore, getCustomizationUrl) => () => {
-        if (typeof fetch !== 'function') {
-            return
-        }
-        const originalCustomUrl = getCustomizationUrl()
-        let resolvedUrl = ''
-        fetch(originalCustomUrl)
-            .then((resp) => {
-                const currentCustomUrl = getCustomizationUrl()
-                if (currentCustomUrl === originalCustomUrl) {
-                    // this is the latest, we keep it
-                    resolvedUrl = resp.url
-                    log('parsed customization url is ' + resolvedUrl)
-                    setStore({
-                        resolvedCustomizationUrl: resolvedUrl,
-                    })
-                    return resp.json()
-                }
-            })
-            .then((config: LemonstandConfig | undefined) => {
-                if (config) {
-                    setStore({
-                        unreadOfferNotifsCountUrl: config.unreadOfferNotifsCountUrl || '',
-                    })
-                }
-            })
-    }
-)

package/src_old/storage.ts

@@ -1,32 +0,0 @@
-import { IDictionary } from './common'
-
-export interface IStorageData {
-    growthFund: {
-        lastPopup: IDictionary<number>
-    }
-}
-
-export type GetStorageData = () => IStorageData
-export const getStorageData: GetStorageData = () => {
-    const restoreData = () => JSON.parse(localStorage.getItem('webshop') as string) as IStorageData
-
-    if (localStorage.getItem('webshop')) {
-        return restoreData()
-    }
-
-    localStorage.setItem(
-        'webshop',
-        JSON.stringify({
-            growthFund: {
-                lastPopup: {},
-            },
-        } as IStorageData)
-    )
-
-    return restoreData()
-}
-
-export type SetStorageData = (data: IStorageData) => void
-export const setStorageData: SetStorageData = (data: IStorageData) => {
-    localStorage.setItem('webshop', JSON.stringify(data))
-}

package/src_old/store.ts

@@ -1,82 +0,0 @@
-import { DIReader, IDictionary } from './common'
-import { inject } from 'readuz'
-import { CountryCode, IGameEvent } from '@goodgamestudios/cxf-events'
-import { ICXF, IGameApi } from './cxf'
-
-export interface IStore {
-    playerId?: string
-    instanceId: string
-    networkId: string
-    gameId: string
-    gameApi: IGameApi
-    language?: string
-    token?: string
-    zoneId?: string
-    xp: number
-    level: number
-    gameEvents: IGameEvent[]
-    countryCode: CountryCode
-    lastPurchaseTab: string
-    legendLevel?: number
-    subscriptionDisabled: boolean
-    isTempServer: boolean
-    customizationSuffix: string
-    resolvedCustomizationUrl?: string
-    sourceId: string
-    unreadOfferNotifsCountUrl: string
-    adStatus?: Record<string, any>
-}
-
-export function defaultStore(cxf: ICXF): IStore {
-    return {
-        playerId: cxf.playerId,
-        instanceId: cxf.instanceId,
-        networkId: cxf.networkId,
-        gameId: cxf.gameId,
-        gameApi: cxf.gameApi,
-        language: cxf.language,
-        token: cxf.token,
-        zoneId: cxf.zoneId,
-        gameEvents: [],
-        xp: 0,
-        level: 0,
-        legendLevel: undefined,
-        countryCode: '',
-        lastPurchaseTab: '',
-        subscriptionDisabled: false,
-        isTempServer: false,
-        customizationSuffix: '',
-        resolvedCustomizationUrl: '',
-        sourceId: 'unknown',
-        unreadOfferNotifsCountUrl: '',
-    }
-}
-
-export type GetStore = () => IStore
-export const getStore: DIReader<GetStore> = inject(
-    (environment) => environment.log,
-    (environment) => environment.store,
-    (log, store) => () => {
-        return store.get() as IStore
-    }
-)
-
-export type SetStore = (data: Partial<IStore>) => void
-export const setStore: DIReader<SetStore> = inject(
-    (environment) => environment.log,
-    (environment) => environment.store,
-    (log, store) => (data) => {
-        const state = store.get() as IStore
-        store.set({
-            ...state,
-            ...data,
-        })
-    }
-)
-
-export function criteriaSelector({ legendLevel, level }: IStore): IDictionary<any> {
-    return {
-        legendLevel,
-        level,
-    }
-}

package/src_old/track.ts

@@ -1,59 +0,0 @@
-import { inject } from 'readuz'
-import { DIReader, IDictionary } from './common'
-import { msToSec } from './utils'
-import { getCxf, getTokenAndLanguage } from './helpers'
-
-export type IRanchWebShopCallProperties = {
-    eventId: number
-    gameId: number
-    playerId: number
-    instanceId: number
-    zoneId: number
-    networkId: number
-    sessionId: string
-    date: number
-    unixtimeMS: number
-    sourceId: string
-}
-
-export type TrackOpenAction = (sid: string) => void
-export const trackOpenAction: DIReader<TrackOpenAction> = inject(
-    (environment) => environment.config,
-    (environment) => environment.trackAction,
-    (environment) => environment.getStore,
-    ({ WEB_SHOP_CALL_TRACK_ID }, trackUserAction, getStore) =>
-        (sid) => {
-            const now = Date.now()
-            const parameters = getTokenAndLanguage(getStore())
-            const { zoneId } = parameters
-            const sessionId = sid
-            const { playerId, gameId, networkId, instanceId, sourceId } = getStore()
-            trackUserAction({
-                eventId: WEB_SHOP_CALL_TRACK_ID,
-                date: msToSec(now),
-                unixtimeMS: now,
-                sessionId,
-                zoneId: zoneId ? Number.parseInt(zoneId, 10) : undefined,
-                playerId: Number.parseInt(playerId as string, 10),
-                gameId: Number.parseInt(gameId, 10),
-                networkId: Number.parseInt(networkId, 10),
-                instanceId: Number.parseInt(instanceId, 10),
-                sourceId,
-            } as IRanchWebShopCallProperties)
-        }
-)
-
-export interface ITrackPayload extends IDictionary<string | number> {
-    eventId: number
-}
-
-export type TrackAction = (payload: ITrackPayload) => void
-export const trackAction: DIReader<TrackAction> = inject(
-    (environment) => environment.config,
-    (environment) => environment.cxfProvider,
-    ({ CXF_TRACK_MSG }, cxfProvider) =>
-        (payload) => {
-            const cxf = getCxf(cxfProvider)
-            cxf.emit(CXF_TRACK_MSG, payload)
-        }
-)

package/src_old/url.ts

@@ -1,95 +0,0 @@
-import { inject } from 'readuz'
-import { DIReader } from './common'
-import { getCxf, createSessionId, formatQueryString, getTokenAndLanguage } from './helpers'
-import { validateForNull } from './utils'
-import { criteriaSelector } from './store'
-import { acronym } from '@goodgamestudios/game-alias'
-
-export interface ICreateCatalogUrlProperties {
-    sid?: string
-    page?: string
-    route?: string
-    config?: Record<string, any>
-}
-
-export type CreateIframeUrl = (properties: ICreateCatalogUrlProperties) => string
-export const createIframeUrl: DIReader<CreateIframeUrl> = inject(
-    (environment) => environment.config,
-    (environment) => environment.log,
-    (environment) => environment.getStore,
-    (environment) => environment.getDomain,
-    (environment) => environment.ggsGetQueryParams,
-    (environment) => environment.ggsGetReferrerValue,
-    (environment) => environment.createCustomizationUrl,
-    (config, log, getStore, getDomain, ggsGetQueryParameters, ggsGetReferrerValue, getCustomizationUrl) =>
-        ({ page, route, sid, config: igsConfig = {} }: ICreateCatalogUrlProperties) => {
-            const store = getStore()
-
-            const { token, zoneId, locale } = getTokenAndLanguage(store)
-            const parameters = {
-                token,
-                zoneId,
-                locale,
-                sid: sid || createSessionId(),
-            }
-
-            if (Object.keys(igsConfig).length > 0) {
-                // @ts-ignore
-                parameters.config = JSON.stringify(igsConfig)
-            }
-
-            validateForNull(parameters)
-
-            const urlParameters = new URLSearchParams(ggsGetQueryParameters())
-            const queryParameters = {
-                ...parameters,
-                'lemonstand.customization.url': store.resolvedCustomizationUrl || getCustomizationUrl(),
-                domain: getDomain(ggsGetReferrerValue()),
-                websiteId: urlParameters.get('w'),
-                criteria: JSON.stringify(criteriaSelector(store)),
-                level: store.level,
-            }
-            // <editor-fold desc="SPIL integration">
-            /* In case of SPIL integration the game can be launched
-               with additional params 'network=xx&usekeybaselogin=false'
-               in this case it needs to pass the network parameter to iframe url  */
-            const network = urlParameters.get('network')
-            if (urlParameters.get('usekeybaselogin') === 'false' && Number(network) > 0) {
-                // @ts-ignore
-                queryParameters.network = network
-            }
-
-            if (store.adStatus?.areBannersAvailable) {
-                // @ts-ignore
-                queryParameters.ads = true
-            }
-            // </editor-fold>
-
-            log('createIframeUrl params', queryParameters)
-            return `${config.BASE_URL}/?${formatQueryString(queryParameters)}${page ? `#${page}` : ''}${
-                route ? `--${route}--${Date.now()}` : ''
-            }`
-        }
-)
-
-export type CreateCustomizationUrl = () => string
-export const createCustomizationUrl: DIReader<CreateCustomizationUrl> = inject(
-    (environment) => environment.config,
-    (environment) => environment.getStore,
-    (environment) => environment.cxfProvider,
-    (config, getStore, cxfProvider) => () => {
-        const store = getStore()
-        const configBase = acronym(store.gameId)
-        const configVariance = store.customizationSuffix ? `-${store.customizationSuffix}` : ''
-        const configBranch = `${configBase}${configVariance}`
-        const cxf = getCxf(cxfProvider)
-
-        if (cxf.env === 'test') {
-            const configVersion = new URLSearchParams(window.location.search).get('configGGS')
-            if (configVersion !== null) {
-                return config.CUSTOMIZATION_URL_TEMPLATE.replace('{0}', configBranch).replace('{1}', configVersion)
-            }
-        }
-        return config.CUSTOMIZATION_URL.replace('{0}', configBranch)
-    }
-)

package/src_old/utils.ts

@@ -1,64 +0,0 @@
-import { AnyVoidFn as AnyVoidFunction, IDictionary, PromiseFn as PromiseFunction } from './common'
-import { ArgumentNullError } from './ArgumentNullError'
-
-const startTimer = (function_: AnyVoidFunction, time: number) => {
-    const id = setTimeout(function_, time)
-    return () => clearTimeout(id)
-}
-
-export const timeout =
-    <A, B>(function_: PromiseFunction<A, B>, time: number): PromiseFunction<A, B> =>
-    (a) => {
-        return new Promise((resolve, reject) => {
-            const stopTimer = startTimer(() => {
-                reject(new Error(`Timeout has exceeded ${time}`))
-            }, time)
-
-            function_(a)
-                .then((value) => {
-                    resolve(value)
-                    stopTimer()
-                })
-                .catch(reject)
-        })
-    }
-
-export const validateForNull = (properties: IDictionary<any>) => {
-    for (const key of Object.keys(properties)) {
-        const value = properties[key]
-        if (value === undefined || value === null || Number.isNaN(value)) {
-            throw new ArgumentNullError(key, value)
-        }
-    }
-}
-
-export function msToSec(value: number): number {
-    return Math.floor(value / 1000)
-}
-
-export function decodePayload<T>(data: string): T {
-    return JSON.parse(atob(data))
-}
-
-export function diffHours(d1: Date, d2: Date): number {
-    const diff = (d1.getTime() - d2.getTime()) / 1000
-    return Math.abs(Math.round(diff / (60 * 60)))
-}
-
-export function timestampToHours(value: number): number {
-    return Math.abs(Math.round(value / 1000 / (60 * 60)))
-}
-
-export const parentDomain = (referrer: string) => {
-    const matches = referrer.match(/^https?:\/\/([^#/?]+)(?:[#/?]|$)/i)
-    if (!matches || !matches[1]) {
-        return
-    }
-
-    const result = matches[1].match(/[^.]+\.[^.]+$/)
-    if (!result) {
-        return
-    }
-
-    return result[0]
-}