@smartico/public-api 0.0.3 → 0.0.5

package/src/MiniGames/SAWUtils.ts

@@ -0,0 +1,31 @@
+import { SAWBuyInType } from "./SAWBuyInType";
+import { SAWTemplate } from "./SAWTemplate";
+
+
+class SAWUtils {
+
+    public static canPlay = (t: SAWTemplate, pointsBalance: number): boolean => {
+        if (t === null || t === undefined) {
+            return false;
+        }
+    
+        switch (t.saw_buyin_type_id) {
+            case SAWBuyInType.Free: {
+                return true;
+            }
+            case SAWBuyInType.Spins: {
+                return t.spin_count !== null && t.spin_count > 0
+            }
+            case SAWBuyInType.Points: {
+                return t.buyin_cost_points <= pointsBalance;
+            }
+            default: {
+                console.error("MiniGamesUtils.canPlay: Unknwon SAW buyin type " + t.saw_buyin_type_id);
+                return false;
+            }
+        }
+    }
+    
+}
+
+export { SAWUtils }

package/src/MiniGames/index.ts

@@ -0,0 +1,35 @@
+import { SAWUtils } from "./SAWUtils";
+import { SAWAcknowledgeType } from "./SAWAcknowledgeType";
+import { SAWAskForUsername } from "./SAWAskForUsername";
+import { SAWBuyInType, SAWBuyInTypeName } from "./SAWBuyInType";
+import { SAWDoSpinRequest } from "./SAWDoSpinRequest";
+import { SAWDoSpinResponse } from "./SAWDoSpinResponse";
+import { SAWGameType, SAWGameTypeName } from "./SAWGameType";
+import { SAWGetTemplatesRequest } from "./SAWGetTemplatesRequest";
+import { SAWGetTemplatesResponse } from "./SAWGetTemplatesResponse";
+import { SAWPrize } from "./SAWPrize";
+import { SAWPrizeType } from "./SAWPrizeType";
+import { SAWPrizeUI } from "./SAWPrizeUI";
+import { SAWSpinErrorCode } from "./SAWSpinErrorCode";
+import { SAWTemplate } from "./SAWTemplate";
+import { SAWTemplateUI } from "./SAWTemplateUI";
+import { SAWWinSoundType, SAWWinSoundFiles } from "./SAWWinSoundType";
+
+export {
+    SAWUtils,
+    SAWAcknowledgeType,
+    SAWBuyInType, SAWBuyInTypeName,
+    SAWDoSpinRequest,
+    SAWDoSpinResponse,
+    SAWGameType, SAWGameTypeName,
+    SAWGetTemplatesRequest,
+    SAWGetTemplatesResponse,
+    SAWPrize,
+    SAWPrizeType,
+    SAWPrizeUI,
+    SAWTemplate,
+    SAWTemplateUI,
+    SAWWinSoundType, SAWWinSoundFiles,
+    SAWAskForUsername,
+    SAWSpinErrorCode
+}

package/src/OCache.ts

@@ -0,0 +1,54 @@
+import NodeCache from 'node-cache';
+
+export enum ECacheContext {
+    Translations,
+    LabelInfo
+}
+
+const WITH_REF_CACHE = [
+    ECacheContext.Translations
+];
+
+export class OCache {
+
+    private static cache: { [key: string] : NodeCache } = {}
+
+    public static get<T>(oKey: any, cacheContext: ECacheContext): T | undefined {
+
+        const key = cacheContext.toString() + '_' + JSON.stringify(oKey);
+
+        if (this.cache[cacheContext] === undefined) {
+            this.cache[cacheContext] = new NodeCache( { useClones: !WITH_REF_CACHE.includes(cacheContext) } );
+        }
+
+        return this.cache[cacheContext].get(key);
+    }
+
+    public static set(oKey: any, o: any, cacheContext: ECacheContext, ttlSeconds: number = 60) {
+
+        const key = cacheContext.toString() + '_' + JSON.stringify(oKey);
+
+        this.cache[cacheContext].set(key, o, ttlSeconds);
+    }
+
+    public static async use<T>(oKey: any, cacheContext: ECacheContext, f: () => Promise<T>, ttlSeconds: number = 60) {
+        if (ttlSeconds <= 0) {
+            return await f();
+        } else {
+            let o: T = OCache.get(oKey, cacheContext);
+
+            if (o === undefined) {
+                o = await f();
+                OCache.set(oKey, o, cacheContext, ttlSeconds);
+            }
+    
+            return o;
+        }
+    }
+
+    public static async clear(cacheContext: ECacheContext) {
+        if (this.cache[cacheContext]) {
+            this.cache[cacheContext].flushAll();
+        }
+    }
+}

package/src/SmarticoAPI.ts

@@ -0,0 +1,296 @@
+import * as superagent from 'superagent';
+import { ClassId } from "./Base/ClassId";
+import { ProtocolRequest } from './Base/ProtocolRequest';
+import { ProtocolResponse } from './Base/ProtocolResponse';
+import { SAWGetTemplatesResponse } from './MiniGames/SAWGetTemplatesResponse';
+import { SAWGetTemplatesRequest } from './MiniGames/SAWGetTemplatesRequest';
+import { SAWTemplate } from './MiniGames/SAWTemplate';
+import { IntUtils } from './IntUtils';
+import { ILogger } from './ILogger';
+import { SAWBuyInType, SAWBuyInTypeName, SAWDoSpinRequest, SAWDoSpinResponse, SAWGameType, SAWGameTypeName, SAWSpinErrorCode, SAWUtils } from './MiniGames';
+import { ECacheContext, OCache } from './OCache';
+import { GetTranslationsRequest, GetTranslationsResponse, ResponseIdentify, TranslationArea } from './Core';
+import { GetLabelInfoResponse } from './Core/GetLabelInfoResponse';
+import { GetLabelInfoRequest } from './Core/GetLabelInfoRequest';
+
+const PUBLIC_API_URL = 'https://papi{ENV_ID}.smartico.ai/services/public';
+const AVATAR_DOMAIN = 'https://img{ENV_ID}.smr.vc';
+
+interface IOptions {
+    logger?: ILogger;
+    logCIDs?: ClassId[];
+    logHTTPTiming?: boolean;
+}
+
+
+class SmarticoAPI {
+
+    private publicUrl: string;
+    private avatarDomain: string;
+
+
+    private logger: ILogger;
+    private logCIDs: ClassId[];
+    private logHTTPTiming: boolean;
+
+    public constructor(private label_api_key: string, private brand_api_key: string, options: IOptions = {}) {
+
+        this.logger = options.logger || (console as any);
+
+        if (this.logger.always === undefined) {
+            this.logger.always = this.logger.info;
+        }
+
+        this.logCIDs = options.logCIDs || [];
+        this.logHTTPTiming = options.logHTTPTiming || false;
+
+        let ENV_ID = this.label_api_key.length === 38 ? label_api_key.substring(37, 38) : '';
+        
+        if (ENV_ID === '1' || ENV_ID === '2') {
+            ENV_ID = ''
+        }
+        label_api_key = label_api_key.substring(0, 36);
+
+        this.publicUrl = PUBLIC_API_URL.replace('{ENV_ID}', ENV_ID);    
+        this.avatarDomain = AVATAR_DOMAIN.replace('{ENV_ID}', ENV_ID);    
+    }    
+
+    private async send<T>(message: any, expectCID?: ClassId): Promise<T> {
+
+
+        if (this.logCIDs.includes(message.cid)) {
+            this.logger.info('REQ', message)
+        }
+
+
+        let result: any;
+        
+        try {
+            const timeStart = new Date().getTime();
+            const res = await superagent.post(this.publicUrl).send(message);
+            // const res = await superagent.post('http://channel01.int.smartico.ai:81/services/public').send(message);
+            const timeEnd = new Date().getTime();
+
+            if (this.logHTTPTiming) {
+                this.logger.always('HTTP time, ms:' + (timeEnd - timeStart))
+            }
+            
+            result = JSON.parse(res.text);
+        } catch (e) {
+            this.logger.error(`Failed to make request to smartico channel. ${e.message}`, { url: this.publicUrl, request: message, error: e.message });
+            throw(new Error(`Failed to make request to smartico channel. ${e.message}`));
+        }
+
+        if (this.logCIDs.includes(message.cid)) {
+            this.logger.info('RES', result)
+        }
+
+        if (expectCID) {
+            if (Array.isArray(result)) { 
+                for (const str of result as string[]) {
+                    const obj: ProtocolResponse = JSON.parse(str);
+                    if (this.logCIDs.includes(obj.cid)) {
+                        this.logger.info('RES', result)
+                    }
+                    if (obj.cid === expectCID) {
+                        return obj as any;
+                    }
+                }
+                this.logger.error(`Cant find proper response in array, expected CID ${expectCID}`, { request: message, response: result });
+            } else {
+                return result;
+            }    
+        } else {
+            if (Array.isArray(result)) { 
+                if (result.length === 1) {
+                    const obj = JSON.parse(result[0]);
+                    if (this.logCIDs.includes(obj.cid)) {
+                        this.logger.info('RES', result)
+                    }                    
+                    return obj;
+                } else {
+                    this.logger.error('Expected one response, but got array', { request: message, response: result });
+                }
+            }
+            return result;
+        }
+    }
+
+    private buildMessage<TRequest,TResponse>(user_ext_id: string, cid: ClassId, payload: Partial<TRequest> = {}): TResponse {
+
+        const message: ProtocolRequest = {
+            api_key: this.label_api_key,
+            brand_key: this.brand_api_key,
+            ext_user_id: user_ext_id,
+            cid,
+            uuid: IntUtils.uuid(),
+            ts: new Date().getTime(),
+            ...payload
+        };
+
+        if (message.ext_user_id === undefined || message.ext_user_id === null) {
+            delete message.ext_user_id;
+        }
+
+        return message as any
+    }
+
+    public async coreReportCustomEvent(user_ext_id: string, eventType: string, payload: any = {}): Promise<any> {
+        const eventMessage = this.buildMessage<any, any>(user_ext_id, ClassId.EVENT, {
+            eventType,
+            payload
+        });
+
+        const eventResponse = await this.send<any>(eventMessage, ClassId.EVENT_RESPONSE);
+        return eventResponse;
+    }
+
+    public async coreGetTranslations(user_ext_id: string, lang_code: string, areas: TranslationArea[], cacheSec: number = 60): Promise<GetTranslationsResponse> {
+
+        const response = await OCache.use<GetTranslationsResponse>(`${lang_code}-${this.label_api_key}-${this.brand_api_key}`, ECacheContext.Translations, async () => {
+
+            const tsBaseRQ = this.buildMessage<GetTranslationsRequest, GetTranslationsResponse>(user_ext_id, ClassId.GET_TRANSLATIONS_REQUEST, {
+                lang_code: "EN",
+                hash_code: 0,
+                areas
+            });
+
+            const trBase = await this.send<GetTranslationsResponse>(tsBaseRQ);
+
+            if (lang_code !== "EN") {
+                const trUserRQ = this.buildMessage<GetTranslationsRequest, GetTranslationsResponse>(user_ext_id, ClassId.GET_TRANSLATIONS_REQUEST, {
+                    lang_code,
+                    hash_code: 0,
+                    areas
+                });  
+
+                const trUser = await this.send<GetTranslationsResponse>(trUserRQ);
+                
+                Object.keys(trUser.translations).forEach( k => {
+                    trBase.translations[k] = trUser.translations[k];
+                })
+            }
+
+            return trBase;
+
+        }, cacheSec );
+
+        return response;
+    }    
+
+    public async coreIdentifyLabel(user_ext_id: string, cacheSec: number = 60): Promise<GetLabelInfoResponse> {
+        
+        return OCache.use<GetLabelInfoResponse>(`${this.label_api_key} - ${this.brand_api_key}`, ECacheContext.LabelInfo, async () => {
+
+            const message = this.buildMessage<GetLabelInfoResponse, GetLabelInfoRequest>(user_ext_id, ClassId.GET_LABEL_INFO);
+
+            return this.send<GetLabelInfoResponse>(message, ClassId.GET_LABEL_INFO_RESPONSE)
+            
+        }, cacheSec);
+        
+    }    
+
+    public async coreIdentifyUser(user_ext_id: string): Promise<ResponseIdentify> {
+
+        const message = this.buildMessage<any, ResponseIdentify>(user_ext_id, ClassId.IDENTIFY, {
+            request_id: IntUtils.uuid() // AA: do we need request_id?
+        });
+
+        const r = await this.send<ResponseIdentify>(message, ClassId.IDENTIFY_RESPONSE);
+
+        if (!(r.avatar_id && r.avatar_id.startsWith('http'))) {
+            r.avatar_id = AVATAR_DOMAIN + '/avatar/' + r.avatar_id
+        }
+
+        return r;
+    }            
+
+    public async coreChangeUsername(user_ext_id: string, public_username_custom: string): Promise<{ public_username_custom: string }> {
+        
+        const message = this.buildMessage<any, any>(user_ext_id, ClassId.CHANGE_USERNAME, {
+            public_username_custom
+        });
+        
+        return this.send(message, ClassId.CHANGE_USERNAME_RESPONSE);
+    }
+
+
+    public async sawGetTemplates(user_ext_id: string): Promise<SAWGetTemplatesResponse> {
+
+        const message = this.buildMessage<SAWGetTemplatesResponse, SAWGetTemplatesRequest>(user_ext_id, ClassId.SAW_GET_SPINS_REQUEST);
+
+        const response = await this.send<SAWGetTemplatesResponse>(message);
+
+        if (response && response.templates) {
+            response.templates.forEach(t => {
+    
+                if (t.jackpot_current) {
+                    t.saw_template_ui_definition.name = IntUtils.replaceAll(t.saw_template_ui_definition.name, '{{jackpot}}', t.jackpot_current);
+                    t.saw_template_ui_definition.description = IntUtils.replaceAll(t.saw_template_ui_definition.description, '{{jackpot}}', t.jackpot_current);
+                    t.saw_template_ui_definition.promo_text = IntUtils.replaceAll(t.saw_template_ui_definition.promo_text, '{{jackpot}}', t.jackpot_current);
+                    t.prizes.forEach(p => {
+                        p.saw_prize_ui_definition.name = IntUtils.replaceAll(p.saw_prize_ui_definition.name, '{{jackpot}}', t.jackpot_current);
+                        p.saw_prize_ui_definition.aknowledge_message = IntUtils.replaceAll(p.saw_prize_ui_definition.aknowledge_message, '{{jackpot}}', t.jackpot_current);
+                    })
+                }
+            });   
+        }
+
+        return response;
+
+    }
+
+    public async sawFormatTemplatesForWidget(templates: SAWTemplate[], pointsBalance: number): Promise<any[]> {
+
+        return templates.filter( r => r.saw_template_id >= 1).map( r => (
+            {
+                id: r.saw_template_id,
+                name: r.saw_template_ui_definition.name,
+                // description: r.saw_template_ui_definition.description,
+                game_type: SAWGameTypeName[r.saw_game_type_id] || 'unknown',
+                buyin_type: SAWBuyInTypeName[r.saw_buyin_type_id] || 'unknown',
+                jackpot: r.jackpot_current,
+                spin_count: r.spin_count,
+                buyin_cost_points: r.buyin_cost_points,
+                can_play: SAWUtils.canPlay(r, pointsBalance), 
+                icon: 
+                    r.saw_skin_ui_definition?.skin_folder
+                    ? r.saw_skin_ui_definition?.skin_folder + '/ico.png'
+                    : `https://libs.smartico.ai/gf/images/saw/${r.saw_skin_key}/ico.png`
+            }
+        ));
+
+    }
+
+    public async sawSpinRequest(user_ext_id: string, saw_template_id: number, round_id: number): Promise<SAWDoSpinResponse> {
+
+        const message = this.buildMessage<SAWDoSpinRequest, SAWDoSpinResponse>(user_ext_id, ClassId.SAW_DO_SPIN_REQUEST, {
+            saw_template_id,
+            request_id: IntUtils.uuid()
+        });
+
+        const spinAttemptResponse = await this.send<SAWDoSpinResponse>(message, ClassId.SAW_DO_SPIN_RESPONSE);
+
+        // to simulate fail
+        // response.errCode = SAWSpinErrorCode.SAW_NO_SPINS;
+
+        const status: string = {
+            [SAWSpinErrorCode.SAW_OK]: 'OK',
+            [SAWSpinErrorCode.SAW_NO_SPINS]: 'NO SPINS AVAILABLE',
+            [SAWSpinErrorCode.SAW_PRIZE_POOL_EMPTY]: 'PRIZE POOL IS EMPTY',
+            [SAWSpinErrorCode.SAW_NOT_ENOUGH_POINTS]: 'NOT ENOUGH POINTS',
+            [SAWSpinErrorCode.SAW_FAILED_MAX_SPINS_REACHED]: 'MAX SPIN ATTEMPTS REACHED',
+        }[spinAttemptResponse.errCode] || 'OTHER';
+
+        await this.coreReportCustomEvent(user_ext_id, 'minigame_attempt', {
+            saw_template_id,
+            status,
+            round_id,
+        });
+
+        return spinAttemptResponse;
+    }        
+
+}
+
+export { SmarticoAPI }

package/src/index.ts

@@ -1,2 +1,12 @@
-export { Util } from './util/Util';
-export * from './service'
+import { ClassId } from './Base/ClassId'
+import { ILogger } from './ILogger';
+import { SmarticoAPI } from './SmarticoAPI'
+
+export * from './MiniGames';
+export * from './Core';
+
+export {
+    SmarticoAPI,
+    ClassId,
+    ILogger
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "compilerOptions": {
+        "module": "ESNext",
+        "esModuleInterop": true,
+        "target": "ESNext",
+        "noImplicitAny": false,
+        "moduleResolution": "node",
+        "sourceMap": true,
+        "outDir": "dist",
+        "baseUrl": ".",
+        "allowJs": true
+    },
+    "include": [
+        "src/**/*"
+    ]
+  }
+  

package/src/service/index.ts

@@ -1,12 +0,0 @@
-import { ErrorCodes } from './types/ErrorCodes';
-import { GBaseRequest } from './types/GRequest';
-import { GResponseBase, GResponse } from './types/GResponse';
-
-export {
-
-    ErrorCodes,
-    GBaseRequest,
-    GResponseBase,
-    GResponse,
-
-}

package/src/service/types/GRequest.ts

@@ -1,18 +0,0 @@
-
-interface GBaseRequest {
-    customer_id: string;
-    ext_user_id: string; // int in the smartico system
-    int_user_id: number; // int in the retention games
-    smartico_ext_user_id: string; // string in the smartico system, that is referencing to user identification in the partner system
-    ext_game_id: number;
-    lang: string;
-    hash: string;
-    zoom?: number;
-    label_api_key?: string;
-    brand_key?: string;
-    bridgeId?: string;
-    height?: 'auto' | string;
-    theme?: string;
-}
-
-export { GBaseRequest }

package/src/service/types/Game/GameAttemptType.ts

@@ -1,8 +0,0 @@
-enum GameAttemptType {
-    Free = 1,
-    Points = 2,
-    Attempts = 3,
-}
-
-
-export { GameAttemptType }

package/src/service/types/Game/GameExternalStatus.ts

@@ -1,7 +0,0 @@
-enum GameExternalStatus {
-    Draft = 1,
-    Active = 2,
-    Archived = 3
-}
-
-export { GameExternalStatus }

package/src/service/types/Game/GameUtil.ts

@@ -1,30 +0,0 @@
-import { GameInfo } from "./GameInfo";
-import { GamePickRound, GamePickRoundBase } from "./GamePick";
-import { Util } from "../../../util/Util";
-
-
-class GameUtil {
-
-    public static getRoundName(round: GamePickRoundBase, gameInfo: GameInfo): string {
-        if (gameInfo.sawTemplate.jackpot_current) {
-            const t = gameInfo.sawTemplate;
-            const jackpotValue = t.jackpot_current + (t.saw_template_ui_definition?.jackpot_symbol ? ' ' + t.saw_template_ui_definition?.jackpot_symbol : '');
-            return Util.replaceAll(round.round_name, "{{jackpot}}", jackpotValue);
-        } else {
-            return round.round_name;
-        }
-    }
-
-    public static getRoundDescription(round: GamePickRound, gameInfo: GameInfo): string {
-        if (gameInfo.sawTemplate.jackpot_current) {
-            const t = gameInfo.sawTemplate;
-            const jackpotValue = t.jackpot_current + (t.saw_template_ui_definition?.jackpot_symbol ? ' ' + t.saw_template_ui_definition?.jackpot_symbol : '');
-            return Util.replaceAll(round.round_description, "{{jackpot}}", jackpotValue);
-        } else {
-            return round.round_description;
-        }
-    }    
-}
-
-
-export { GameUtil }