@smartico/public-api 0.0.107 → 0.0.108

package/src/SmarticoAPI.ts

@@ -7,17 +7,17 @@ import { IntUtils } from './IntUtils';
 import { ILogger } from './ILogger';
 import { SAWDoAknowledgeRequest, SAWDoAknowledgeResponse, SAWDoSpinRequest, SAWDoSpinResponse, SAWSpinErrorCode, SAWTemplatesTransform } from './MiniGames';
 import { ECacheContext, OCache } from './OCache';
-import { CoreUtils, GetTranslationsRequest, GetTranslationsResponse, ResponseIdentify, TranslationArea } from './Core';
+import { CoreUtils, GetTranslationsRequest, GetTranslationsResponse, PublicLabelSettings, ResponseIdentify, TranslationArea } from './Core';
 import { GetLabelInfoResponse } from './Core/GetLabelInfoResponse';
 import { GetLabelInfoRequest } from './Core/GetLabelInfoRequest';
-import { GetInboxMessagesRequest, GetInboxMessagesResponse } from './Inbox';
+import { GetInboxMessagesRequest, GetInboxMessagesResponse, InboxMessageBody, InboxMessageBodyTransform, InboxMessagesTransform, MarkInboxMessageDeletedRequest, MarkInboxMessageDeletedResponse, MarkInboxMessageReadRequest, MarkInboxMessageReadResponse, MarkInboxMessageStarredRequest, MarkInboxMessageStarredResponse } from './Inbox';
 import { BuyStoreItemRequest, BuyStoreItemResponse, GetCategoriesStoreResponse, GetStoreItemsResponse, StoreCategoryTransform, StoreItemTransform } from './Store';
 import { AchievementOptinRequest, AchievementOptinResponse, AchievementType, GetAchievementMapRequest, GetAchievementMapResponse, UserAchievementTransform } from './Missions';
 import { GetTournamentInfoRequest, GetTournamentInfoResponse, GetTournamentsRequest, GetTournamentsResponse, TournamentItemsTransform, TournamentRegisterRequest, TournamentRegisterResponse, tournamentInfoItemTransform } from './Tournaments';
 import { GetLeaderBoardsRequest, GetLeaderBoardsResponse, LeaderBoardDetails, LeaderBoardPeriodType } from "./Leaderboard";
 import { GetLevelMapResponse, GetLevelMapResponseTransform } from "./Level";
 import { WSAPI } from "./WSAPI/WSAPI";
-import { TLevel, TMiniGameTemplate, TMissionOrBadge, TStoreCategory, TStoreItem, TTournament, TTournamentDetailed } from "./WSAPI/WSAPITypes";
+import { TInboxMessage, TInboxMessageBody, TLevel, TMiniGameTemplate, TMissionOrBadge, TStoreCategory, TStoreItem, TTournament, TTournamentDetailed } from "./WSAPI/WSAPITypes";
 
 const PUBLIC_API_URL = 'https://papi{ENV_ID}.smartico.ai/services/public';
 const C_SOCKET_PROD = 'wss://api{ENV_ID}.smartico.ai/websocket/services';
@@ -28,6 +28,7 @@ interface Tracker {
     label_api_key: string;
     userPublicProps: any;
     on: (callBackKey: ClassId, func: (data: any) => void) => void;
+    getLabelSetting: (key: PublicLabelSettings) => any;
 }
 interface IOptions {
     logger?: ILogger;
@@ -43,6 +44,7 @@ class SmarticoAPI {
 
     private publicUrl: string;
     private wsUrl: string;
+    private inboxCdnUrl: string;
     private partnerUrl: string;
     public avatarDomain: string;
 
@@ -525,6 +527,95 @@ class SmarticoAPI {
         return await this.coreGetTranslations(user_ext_id, lang_code, areas, 30);
     }
 
+    public async getInboxMessages(user_ext_id: string, limit: number = 20, offset: number = 0, starred_only: boolean): Promise<GetInboxMessagesResponse> {
+        const message = this.buildMessage<GetInboxMessagesRequest, GetInboxMessagesResponse>(user_ext_id, ClassId.GET_INBOX_MESSAGES_REQUEST, {
+            limit,
+            offset,
+            starred_only
+        });
+        return await this.send<GetInboxMessagesResponse>(message, ClassId.GET_INBOX_MESSAGES_RESPONSE);
+    }
+
+    public async getInboxMessagesT(user_ext_id: string, from: number = 0, to: number = 20, favoriteOnly: boolean = false): Promise<TInboxMessage[]> {
+        const limit = (to - from) > 20 ? 20 : to - from;
+        const offset = from;
+
+        return InboxMessagesTransform((await this.getInboxMessages(user_ext_id, limit, offset, favoriteOnly)).log);
+    }
+
+    public async getInboxMessageBody(messageGuid: string): Promise<InboxMessageBody> {
+
+        const getMessageBody = async (messageGuid: string): Promise<InboxMessageBody>=> {
+            const inboxCdnUrl = this.tracker.getLabelSetting(PublicLabelSettings.INBOX_PUBLIC_CDN);
+
+            try {
+                const url = `${inboxCdnUrl}${messageGuid}.json`;
+        
+                const response = await fetch(url, {
+                    method: 'GET',
+                    headers: {
+                        'Accept': 'application/json',
+                        'Content-Type': 'application/json',
+                        'Access-Control-Allow-Origin': '*'
+                    }
+                });
+                const data = await response.json();
+                return data || {};
+            } catch (error) {
+                this.logger.error('Error fetching inbox message body:', error);
+                return null;
+            }
+        };
+
+        return await getMessageBody(messageGuid)
+    }
+
+    public async getInboxMessageBodyT(messageGuid: string): Promise<TInboxMessageBody> {
+        const message = await this.getInboxMessageBody(messageGuid);
+        return InboxMessageBodyTransform(message);
+    }
+
+    public async markInboxMessageRead(user_ext_id: string, messageGuid: string): Promise<MarkInboxMessageReadResponse> {
+        const message = this.buildMessage<MarkInboxMessageReadRequest, MarkInboxMessageReadResponse>(user_ext_id, ClassId.MARK_INBOX_READ_REQUEST, {
+            engagement_uid: messageGuid
+        });
+
+        return await this.send<MarkInboxMessageReadResponse>(message, ClassId.MARK_INBOX_READ_RESPONSE);
+    }
+
+    public async markAllInboxMessageRead(user_ext_id: string): Promise<MarkInboxMessageReadResponse> {
+        const message = this.buildMessage<MarkInboxMessageReadRequest, MarkInboxMessageReadResponse>(user_ext_id, ClassId.MARK_INBOX_READ_REQUEST, {
+            all_read: true
+        });
+
+        return await this.send<MarkInboxMessageReadResponse>(message, ClassId.MARK_INBOX_READ_RESPONSE);
+    }
+
+    public async markUnmarkInboxMessageAsFavorite(user_ext_id: string, messageGuid: string, mark: boolean): Promise<MarkInboxMessageStarredResponse> {
+        const message = this.buildMessage<MarkInboxMessageStarredRequest, MarkInboxMessageStarredResponse>(user_ext_id, ClassId.MARK_INBOX_STARRED_REQUEST, {
+            engagement_uid: messageGuid,
+            is_starred: mark
+        });
+
+        return await this.send<MarkInboxMessageStarredResponse>(message, ClassId.MARK_INBOX_STARRED_RESPONSE);
+    }
+
+    public async deleteInboxMessage(user_ext_id: string, messageGuid: string): Promise<MarkInboxMessageDeletedResponse> {
+        const message = this.buildMessage<MarkInboxMessageDeletedRequest, MarkInboxMessageDeletedResponse>(user_ext_id, ClassId.MARK_INBOX_DELETED_REQUEST, {
+            engagement_uid: messageGuid,
+        });
+
+        return await this.send<MarkInboxMessageDeletedResponse>(message, ClassId.MARK_INBOX_DELETED_RESPONSE);
+    }
+
+    public async deleteAllInboxMessages(user_ext_id: string): Promise<MarkInboxMessageDeletedResponse> {
+        const message = this.buildMessage<MarkInboxMessageDeletedRequest, MarkInboxMessageDeletedResponse>(user_ext_id, ClassId.MARK_INBOX_DELETED_REQUEST, {
+            all_deleted: true
+        });
+
+        return await this.send<MarkInboxMessageDeletedResponse>(message, ClassId.MARK_INBOX_DELETED_RESPONSE);
+    }
+
     
     public getWSCalls(): WSAPI {
         return new WSAPI(this);

package/src/WSAPI/WSAPI.ts

@@ -3,7 +3,7 @@ import { CoreUtils } from "../Core";
 import { MiniGamePrizeTypeName, SAWDoSpinResponse, SAWSpinErrorCode, SAWSpinsCountPush } from "../MiniGames";
 import { ECacheContext, OCache } from "../OCache";
 import { SmarticoAPI } from "../SmarticoAPI";
-import { TBuyStoreItemResult, TGetTranslations, TLevel, TMiniGamePlayResult, TMiniGamePrize, TMiniGameTemplate, TMissionOptInResult, TMissionOrBadge, TStoreItem, TTournament, TTournamentDetailed, TTournamentRegistrationResult, TUserProfile } from "./WSAPITypes";
+import { InboxMarkMessageAction, TBuyStoreItemResult, TGetTranslations, TInboxMessage, TInboxMessageBody, TLevel, TMiniGamePlayResult, TMiniGameTemplate, TMissionOptInResult, TMissionOrBadge, TStoreItem, TTournament, TTournamentDetailed, TTournamentRegistrationResult, TUserProfile } from "./WSAPITypes";
  
 /** @hidden */
 const CACHE_DATA_SEC = 30;
@@ -12,6 +12,7 @@ enum onUpdateContextKey {
     Saw = 'saw',
     Missions = 'missions',
     TournamentList = 'tournamentList',
+    InboxMessages = 'inboxMessages',
 }
 
 
@@ -28,6 +29,7 @@ export class WSAPI {
         on(ClassId.SAW_DO_SPIN_RESPONSE, (data: SAWDoSpinResponse) => on(ClassId.SAW_AKNOWLEDGE_RESPONSE, () => this.updateOnPrizeWin(data)));
         on(ClassId.MISSION_OPTIN_RESPONSE, () => this.updateMissionsOnOptIn());
         on(ClassId.TOURNAMENT_REGISTER_RESPONSE, () => this.updateTournamentsOnRegistration());
+        on(ClassId.CLIENT_ENGAGEMENT_EVENT_NEW, () => this.updateInboxMessages());
     }
 
     /** Returns information about current user */
@@ -142,7 +144,7 @@ export class WSAPI {
         return OCache.use(onUpdateContextKey.TournamentList, ECacheContext.WSAPI, () => this.api.tournamentsGetLobbyT(null), CACHE_DATA_SEC);
     }
 
-    /** Returns details information of specific tournament instance, the response will includ tournamnet info and the leaderboard of players */
+    /** Returns details information of specific tournament instance, the response will include tournament info and the leaderboard of players */
     public async getTournamentInstanceInfo(tournamentInstanceId: number): Promise<TTournamentDetailed> {
         return this.api.tournamentsGetInfoT(null, tournamentInstanceId);
     }
@@ -159,6 +161,79 @@ export class WSAPI {
         return o;
     }
 
+    /** Returns inbox messages based on the provided parameters. "From" and "to" indicate the range of messages to be fetched. 
+    * The maximum number of messages per request is limited to 20. An indicator "onlyFavorite" can be passed to get only messages marked as favorites. 
+    * You can leave this params empty and by default it will return list of messages ranging from 0 to 20.
+    * This functions return list of messages without the body of the message. 
+    * To get the body of the message you need to call getInboxMessageBody function and pass the message guid contained in each message of this request.
+    * All other action like mark as read, favorite, delete, etc. can be done using this message GUID.
+    * The "onUpdate" callback will be triggered when the user receives a new message. It will provide an updated list of messages, ranging from 0 to 20, to the onUpdate callback function. */
+    /**
+    * @param params
+    */
+    public async getInboxMessages({ from, to, onlyFavorite, onUpdate }: { from?: number, to?: number, onlyFavorite?: boolean, onUpdate?: (data: TInboxMessage[]) => void } = {}): Promise<TInboxMessage[]> { 
+        if (onUpdate) {
+            this.onUpdateCallback.set(onUpdateContextKey.InboxMessages, onUpdate);
+        }
+
+        return await this.api.getInboxMessagesT(null, from, to, onlyFavorite);
+    }
+
+    /** Returns the message body of the specified message guid. */
+    public async getInboxMessageBody(messageGuid: string): Promise<TInboxMessageBody> {
+        return await this.api.getInboxMessageBodyT(messageGuid);
+    }
+
+    /** Requests to mark inbox message with specified guid as read */
+    public async markInboxMessageAsRead(messageGuid: string): Promise<InboxMarkMessageAction> {
+        const r = await this.api.markInboxMessageRead(null, messageGuid);
+
+        return {
+            err_code: r.errCode,
+            err_message: r.errMsg,
+        }
+    }
+
+    /** Requests to mark all inbox messages as read */
+    public async markAllInboxMessagesAsRead(): Promise<InboxMarkMessageAction> {
+        const r = await this.api.markAllInboxMessageRead(null);
+
+        return {
+            err_code: r.errCode,
+            err_message: r.errMsg,
+        }
+    }
+
+    /** Requests to mark inbox message with specified guid as favorite. Pass mark true to add message to favorite and false to remove. */
+    public async markUnmarkInboxMessageAsFavorite(messageGuid: string, mark: boolean): Promise<InboxMarkMessageAction> {
+        const r = await this.api.markUnmarkInboxMessageAsFavorite(null, messageGuid, mark);
+
+        return {
+            err_code: r.errCode,
+            err_message: r.errMsg,
+        }
+    }
+
+    /** Requests to delete inbox message */
+    public async deleteInboxMessage(messageGuid: string): Promise<InboxMarkMessageAction> {
+        const r = await this.api.deleteInboxMessage(null, messageGuid);
+
+        return {
+            err_code: r.errCode,
+            err_message: r.errMsg,
+        }
+    }
+
+    /** Requests to delete all inbox messages */
+    public async deleteAllInboxMessages(): Promise<InboxMarkMessageAction> {
+        const r = await this.api.deleteAllInboxMessages(null);
+
+        return {
+            err_code: r.errCode,
+            err_message: r.errMsg,
+        }
+    }
+
     /** Requests translations for the given language. Returns the object including translation key/translation value pairs. All possible translation keys defined in the back office. */
     public async getTranslations(lang_code: string): Promise<TGetTranslations> {
         const r = await this.api.getTranslationsT(null, lang_code, []);
@@ -208,6 +283,11 @@ export class WSAPI {
         this.updateEntity(onUpdateContextKey.TournamentList, payload)
     }
 
+    private async updateInboxMessages() {
+        const payload = await this.api.getInboxMessagesT(null);
+        this.updateEntity(onUpdateContextKey.InboxMessages, payload)
+    }
+
     private async updateEntity(contextKey: onUpdateContextKey, payload: any) {
         OCache.set(contextKey, payload, ECacheContext.WSAPI);
 

package/src/WSAPI/WSAPITypes.ts

@@ -406,7 +406,7 @@ export interface TMissionOrBadge {
     progress: number;
     /** 
      * The action that should be performed when user clicks on the mission or badge
-     * Can be URL or deep link, e.g. 'dp:deposit'. The most safe to execute CTA is to pass it to _smartico.do(cta_action);
+     * Can be URL or deep link, e.g. 'dp:deposit'. The most safe to execute CTA is to pass it to _smartico.dp(cta_action);
      * The 'dp' function will handle the CTA and will execute it in the most safe way
      */
     cta_action: string,
@@ -491,4 +491,45 @@ export interface TBuyStoreItemResult {
 
 export interface TGetTranslations {
     translations: {[key: string]: string};
+}
+
+export interface TInboxMessage {
+    /** Uniq identifier of the message. It is needed to request the message body, mark the message as read/deleted/favorite. */
+    message_guid: string;
+    /** Date when the message was sent */
+    sent_date: string;
+    /** Indicator if a message is read */
+    read: boolean;
+    /** Indicator if a message is added to favorites */
+    favorite: boolean;
+}
+
+export interface TInboxMessageBody {
+    /** Message title */
+    title: string
+    /** Short preview body of the message */
+    preview_body: string,
+    /** Message icon */
+    icon: string,
+    /** The action that should be performed when user clicks on the message.
+     * Can be URL or deep link, e.g. 'dp:deposit'. The most safe to execute CTA is to pass it to _smartico.dp(cta_action);
+     * The 'dp' function will handle the CTA and will execute it in the most safe way. 
+     * If the message has a rich html body - the action will always be 'dp:inbox' which will open the inbox widget when triggered. */
+    action: string,
+    /** Rich HTML body of the message. */
+    html_body?: string,
+    /** Optional additional buttons to show in the message, available only if message has rich HTML body. Max count - 2. */
+    buttons?: {
+        /** The action that should be performed when user clicks on the button. The logic is the same as for message actions */
+        action: string,
+        /** Button text */
+        text: string
+    }[];
+}
+
+export interface InboxMarkMessageAction {
+    /** An error code representing the result of marking a message as deleted, favorite or read. Successful marking action if err_code is 0 */
+    err_code: number;
+    /** Optional error message */
+    err_message: string;
 }