@smartico/public-api 0.0.4 → 0.0.6

package/src/NodeCache.ts

@@ -0,0 +1,45 @@
+
+class NodeCache {
+
+    private static ttlChecker: NodeJS.Timeout;
+
+    private static cache: { [key: string] : any } = {};
+
+    constructor() {
+        if (NodeCache.ttlChecker === undefined) {
+            NodeCache.ttlChecker = setInterval(() => {
+                const now = new Date().getTime();
+                for (const key in NodeCache.cache) {
+                    if (NodeCache.cache.hasOwnProperty(key)) {
+                        const o = NodeCache.cache[key];
+                        if (o.ttl < now) {
+                            delete NodeCache.cache[key];
+                        }
+                    }
+                }
+            }, 1000);
+        }
+    }
+
+    public get(key: string): any {
+        const o = NodeCache.cache[key];
+        if (o !== undefined && o.ttl > new Date().getTime()) {
+            return o.value;
+        }
+    }
+
+    public set(key: string, value: any, ttlSeconds: number = 60) {
+        NodeCache.cache[key] = {
+            value,
+            ttl: new Date().getTime() + ttlSeconds * 1000
+        }
+    }
+
+    public flushAll() {
+        NodeCache.cache = {};
+    }
+
+}
+
+
+export { NodeCache }

package/src/OCache.ts

@@ -0,0 +1,55 @@
+import { NodeCache } from "./NodeCache";
+
+
+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( );
+        }
+
+        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

@@ -7,9 +7,15 @@ import { SAWGetTemplatesRequest } from './MiniGames/SAWGetTemplatesRequest';
 import { SAWTemplate } from './MiniGames/SAWTemplate';
 import { IntUtils } from './IntUtils';
 import { ILogger } from './ILogger';
-import { SAWBuyInType, SAWBuyInTypeName, SAWGameType, SAWGameTypeName } from './MiniGames';
+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';
+import { GetInboxMessagesRequest, GetInboxMessagesResponse } from './Inbox';
 
 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;
@@ -21,6 +27,9 @@ interface IOptions {
 class SmarticoAPI {
 
     private publicUrl: string;
+    private avatarDomain: string;
+
+
     private logger: ILogger;
     private logCIDs: ClassId[];
     private logHTTPTiming: boolean;
@@ -43,7 +52,8 @@ class SmarticoAPI {
         }
         label_api_key = label_api_key.substring(0, 36);
 
-        this.publicUrl = PUBLIC_API_URL.replace('{ENV_ID}', ENV_ID);        
+        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> {
@@ -59,6 +69,7 @@ class SmarticoAPI {
         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) {
@@ -118,10 +129,94 @@ class SmarticoAPI {
             ...payload
         };
 
+        if (message.ext_user_id === undefined || message.ext_user_id === null) {
+            delete message.ext_user_id;
+        }
+
         return message as any
     }
 
-    public async miniGamesGetTemplates(user_ext_id: string): Promise<SAWGetTemplatesResponse> {
+    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.INIT);
+
+            return this.send<GetLabelInfoResponse>(message, ClassId.INIT_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.CLIENT_SET_CUSTOM_USERNAME_REQUEST, {
+            public_username_custom
+        });
+        
+        return this.send(message, ClassId.CLIENT_SET_CUSTOM_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);
 
@@ -146,7 +241,7 @@ class SmarticoAPI {
 
     }
 
-    public miniGamesFormatTemplatesForWidget(templates: SAWTemplate[], pointsBalance: number): any[] {
+    public async sawFormatTemplatesForWidget(templates: SAWTemplate[], pointsBalance: number): Promise<any[]> {
 
         return templates.filter( r => r.saw_template_id >= 1).map( r => (
             {
@@ -158,11 +253,7 @@ class SmarticoAPI {
                 jackpot: r.jackpot_current,
                 spin_count: r.spin_count,
                 buyin_cost_points: r.buyin_cost_points,
-                can_play: (
-                    r.saw_buyin_type_id === SAWBuyInType.Free
-                    || (r.saw_buyin_type_id === SAWBuyInType.Points && r.buyin_cost_points <= pointsBalance)
-                    || (r.saw_buyin_type_id === SAWBuyInType.Spins && r.spin_count > 0)
-                ), 
+                can_play: SAWUtils.canPlay(r, pointsBalance), 
                 icon: 
                     r.saw_skin_ui_definition?.skin_folder
                     ? r.saw_skin_ui_definition?.skin_folder + '/ico.png'
@@ -172,6 +263,48 @@ class SmarticoAPI {
 
     }
 
+    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;
+    }        
+
+    public async inboxGetMessages(user_ext_id: string, limit: number = 10, offset: number = 0): Promise<GetInboxMessagesResponse> {
+
+        const message = this.buildMessage<GetInboxMessagesRequest, GetInboxMessagesResponse>(user_ext_id, ClassId.GET_ACTIVITY_LOG_REQUEST, {
+            limit,
+            offset
+        });
+
+        const response = await this.send<GetInboxMessagesResponse>(message);
+
+        return response;
+
+    }    
+
 }
 
 export { SmarticoAPI }

package/src/index.ts

@@ -2,7 +2,9 @@ import { ClassId } from './Base/ClassId'
 import { ILogger } from './ILogger';
 import { SmarticoAPI } from './SmarticoAPI'
 
+export * from './Core';
 export * from './MiniGames';
+export * from './Inbox';
 
 export {
     SmarticoAPI,