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

package/src_old/url.ts

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,64 @@
+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]
+}