@smartico/public-api 0.0.50 → 0.0.52

package/src/SmarticoAPI.ts

@@ -11,13 +11,13 @@ import { CoreUtils, GetTranslationsRequest, GetTranslationsResponse, ResponseIde
 import { GetLabelInfoResponse } from './Core/GetLabelInfoResponse';
 import { GetLabelInfoRequest } from './Core/GetLabelInfoRequest';
 import { GetInboxMessagesRequest, GetInboxMessagesResponse } from './Inbox';
-import { GetStoreItemsResponse } from './Store';
+import { GetStoreItemsResponse, StoreItemTransform } from './Store';
 import { AchievementType, GetAchievementMapRequest, GetAchievementMapResponse, UserAchievementTransform } from './Missions';
-import { GetTournamentInfoRequest, GetTournamentInfoResponse, GetTournamentsRequest, GetTournamentsResponse } from './Tournaments';
+import { GetTournamentInfoRequest, GetTournamentInfoResponse, GetTournamentsRequest, GetTournamentsResponse, TournamentItemsTransform, tournamentInfoItemTransform } from './Tournaments';
 import { GetLeaderBoardsRequest, GetLeaderBoardsResponse, LeaderBoardDetails, LeaderBoardPeriodType } from "./Leaderboard";
 import { GetLevelMapResponse, GetLevelMapResponseTransform } from "./Level";
 import { WSAPI } from "./WSAPI/WSAPI";
-import { TLevel, TMissionOrBadge } from "./WSAPI/WSAPITypes";
+import { TLevel, TMissionOrBadge, 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';
@@ -333,6 +333,10 @@ class SmarticoAPI {
 
     }
 
+    public async storeGetItemsT(user_ext_id: string): Promise<TStoreItem[]> {
+        return StoreItemTransform((await this.storeGetItems(user_ext_id)).items);
+    }    
+
     public async missionsGetItems(user_ext_id: string): Promise<GetAchievementMapResponse> {
 
         const message = this.buildMessage<GetAchievementMapRequest, GetAchievementMapResponse>(user_ext_id, ClassId.GET_ACHIEVEMENT_MAP_REQUEST);
@@ -343,7 +347,7 @@ class SmarticoAPI {
         return response;
     }
 
-    public async missionsGetItemsT(user_ext_id?: string): Promise<TMissionOrBadge[]> {
+    public async missionsGetItemsT(user_ext_id: string): Promise<TMissionOrBadge[]> {
         return UserAchievementTransform((await this.missionsGetItems(user_ext_id)).achievements);
     }
 
@@ -357,7 +361,7 @@ class SmarticoAPI {
         return response;
     }    
 
-    public async badgetsGetItemsT(user_ext_id?: string): Promise<TMissionOrBadge[]> {
+    public async badgetsGetItemsT(user_ext_id: string): Promise<TMissionOrBadge[]> {
         return UserAchievementTransform((await this.badgetsGetItems(user_ext_id)).achievements);
     }    
 
@@ -369,6 +373,10 @@ class SmarticoAPI {
 
     }
 
+    public async tournamentsGetLobbyT(user_ext_id: string): Promise<TTournament[]> {
+        return TournamentItemsTransform((await this.tournamentsGetLobby(user_ext_id)).tournaments);
+    }
+
     public async tournamentsGetInfo(user_ext_id: string, tournamentInstanceId: number): Promise<GetTournamentInfoResponse> {
 
         const message = this.buildMessage<GetTournamentInfoRequest, GetTournamentInfoResponse>(user_ext_id, ClassId.GET_TOURNAMENT_INFO_REQUEST, 
@@ -392,6 +400,10 @@ class SmarticoAPI {
 
     }
 
+    public async tournamentsGetInfoT(user_ext_id: string, tournamentInstanceId: number): Promise<TTournamentDetailed> {
+        return tournamentInfoItemTransform((await this.tournamentsGetInfo(user_ext_id, tournamentInstanceId)));
+    }    
+
     public async leaderboardGet(user_ext_id: string, period_type_id?: LeaderBoardPeriodType, prevPeriod: boolean = false): Promise<LeaderBoardDetails> {
 
         const message = this.buildMessage<GetLeaderBoardsRequest, GetLeaderBoardsResponse>(user_ext_id, ClassId.GET_LEADERS_BOARD_REQUEST, 
@@ -425,12 +437,12 @@ class SmarticoAPI {
 
     }
 
-    public async levelsGet(user_ext_id?: string): Promise<GetLevelMapResponse> {
+    public async levelsGet(user_ext_id: string): Promise<GetLevelMapResponse> {
         const message = this.buildMessage<any, GetLevelMapResponse>(user_ext_id, ClassId.GET_LEVEL_MAP_REQUEST);
         return await this.send<GetLevelMapResponse>(message, ClassId.GET_LEVEL_MAP_RESPONSE);
     }
 
-    public async levelsGetT(user_ext_id?: string): Promise<TLevel[]> {
+    public async levelsGetT(user_ext_id: string): Promise<TLevel[]> {
         return GetLevelMapResponseTransform(await this.levelsGet(user_ext_id));
     }
 

package/src/Store/StoreItem.ts

@@ -1,3 +1,4 @@
+import { TStoreItem } from "../WSAPI/WSAPITypes";
 import { StoreItemPublicMeta } from "./StoreItemPublicMeta";
 import { StoreItemType } from "./StoreItemType";
 
@@ -8,3 +9,31 @@ export interface StoreItem {
     categoryIds?: number[];
     canBuy?: boolean;
 }
+
+
+export const StoreItemTransform = (items: StoreItem[]): TStoreItem[] => {    
+    return items.filter( r => r.id >= 1).map( r => {
+        const x: TStoreItem = 
+        {
+            id: r.id,
+            name: r.itemPublicMeta.name,
+            price: r.itemPublicMeta.price as any as number, // AA: strange why it's string
+            image: r.itemPublicMeta.image_url,
+            description: r.itemPublicMeta.description,
+            ribbon: r.itemPublicMeta.custom_label_tag || r.itemPublicMeta.label_tag,
+            limit_message: r.itemPublicMeta.limit_message,
+            priority: r.itemPublicMeta.priority,
+            related_item_ids: r.itemPublicMeta.related_items,
+
+            type: {
+                [StoreItemType.Bonus]: 'bonus',
+                [StoreItemType.Manual]: 'manual'
+            }[r.itemTypeId] as 'bonus' | 'manual',
+
+            can_buy: r.canBuy,
+            category_ids: r.categoryIds ?? []
+        }
+        return x;
+    });
+
+}

package/src/Tournaments/GetTournamentInfoResponse.ts

@@ -1,7 +1,8 @@
-import {Tournament} from "./Tournament";
+import {Tournament, TournamentItemsTransform} from "./Tournament";
 import {TournamentPlayer} from "./TournamentPlayer";
 import { ProtocolResponse } from "../Base/ProtocolResponse";
 import { TournamentPrize } from "./TournamentPrize";
+import { TTournamentDetailed } from "../WSAPI/WSAPITypes";
 
 export interface GetTournamentInfoResponse extends ProtocolResponse {
 
@@ -22,4 +23,28 @@ export interface GetTournamentInfoResponse extends ProtocolResponse {
 }
 
 
+export const tournamentInfoItemTransform = (t: GetTournamentInfoResponse): TTournamentDetailed => {
+    const response: TTournamentDetailed = {
+        ...TournamentItemsTransform([t.tournamentInfo.tournamentLobbyInfo])[0],
+        players: t.tournamentInfo.players.map( p => ({
+            public_username: p.userAltName,
+            avatar_url: p.avatar_url,
+            position: p.position,
+            scores: p.scores,
+            is_me: p.isMe,
+        })),
+    };
+
+    if (t.userPosition) {
+        response.me = {
+            public_username: t.userPosition.userAltName,
+            avatar_url: t.userPosition.avatar_url,
+            position: t.userPosition.position,
+            scores: t.userPosition.scores,
+        }
+    }
+
+    return response;
+}
+
 

package/src/Tournaments/GetTournamentsResponse.ts

@@ -1,8 +1,17 @@
 import { ProtocolResponse } from "../Base/ProtocolResponse";
 import {Tournament} from "./Tournament";
+import { TournamentRegistrationStatus } from "./TournamentRegistrationStatus";
+import { TournamentRegistrationType } from "./TournamentRegistrationType";
+import { TournamentUtils } from "./TournamentUtils";
 
 export interface GetTournamentsResponse extends ProtocolResponse {
 
     /** array of the tournaments */
     tournaments?: Tournament[];
 }
+
+
+
+
+
+

package/src/Tournaments/Tournament.ts

@@ -1,8 +1,11 @@
-import {TournamentRegistrationType} from "./TournamentRegistrationType";
+import {TournamentRegistrationType, TournamentRegistrationTypeGetName} from "./TournamentRegistrationType";
 import {TournamentInstanceStatus} from "./TournamentInstanceStatus";
-import { TournamentRegistrationStatus } from "./TournamentRegistrationStatus";
+import { TournamentRegistrationStatus, TournamentRegistrationStatusName } from "./TournamentRegistrationStatus";
 import { TournamentType } from "./TournamentType";
 import { TournamentPublicMeta } from "./TournamentPublicMeta";
+import { TTournament } from "../WSAPI/WSAPITypes";
+import { TournamentUtils } from ".";
+import { IntUtils } from "../IntUtils";
 
 export interface Tournament {
 
@@ -22,6 +25,10 @@ export interface Tournament {
     startTime?: string;
     /** The time when tournament is going to finish */
     endTime?: string;
+    /** The time when tournament is going to start, epoch */
+    startTimeTs?: number;
+    /** The time when tournament is going to finish, epoch */
+    endTimeTs?: number;    
     /** Number of users registered in the tournament */
     registrationCount?: number;
     /** Not in use */
@@ -45,3 +52,49 @@ export interface Tournament {
 }
 
 
+export const TournamentItemsTransform = (items: Tournament[]): TTournament[] => {    
+
+    return items.filter( r => r.tournamentId >= 1).map( r => {
+
+        const x: TTournament =         {
+            instance_id: r.tournamentInstanceId,
+            tournament_id: r.tournamentId,
+            name: r.publicMeta.name,
+            description: r.publicMeta.description,
+            segment_dont_match_message: r.publicMeta.segment_dont_match_message,
+            image1: r.publicMeta.image_url,
+            image2: r.publicMeta.image_url2,
+            prize_pool_short: r.publicMeta.prize_pool_short,
+            custom_price_text: r.publicMeta.custom_price_text,
+            custom_section_id: r.publicMeta.custom_section_id,
+            custom_data: IntUtils.JsonOrText(r.publicMeta.custom_data),
+            is_featured: r.publicMeta.featured,
+            ribbon: r.publicMeta.label_tag,
+
+            start_time: r.startTimeTs,
+            end_time: r.endTimeTs,
+            registration_count: r.registrationCount,
+            is_user_registered: r.isUserRegistered,
+            players_min_count: r.playersMinCount,
+            players_max_count: r.playersMaxCount,
+            registration_status: TournamentRegistrationStatusName(r.tournamentRegistrationStatus),
+
+            registration_type: TournamentRegistrationTypeGetName(r.registrationType),
+            registration_cost_points: r.buyInAmount,
+            duration_ms: r.durationMs,
+
+            is_active: TournamentUtils.isActive(r),
+            is_can_register: TournamentUtils.isCanRegister(r),
+            is_cancelled: TournamentUtils.isCancelled(r),
+            is_finished: TournamentUtils.isFinished(r),
+            is_in_progress: TournamentUtils.isInProgress(r),
+            is_upcoming: TournamentUtils.isUpcoming(r),
+
+        }
+
+        return x;
+    });
+
+
+}
+

package/src/Tournaments/TournamentRegistrationStatus.ts

@@ -1,3 +1,4 @@
+/** @hidden */
 export enum TournamentRegistrationStatus {
 
     NOT_REGISTERED = 0,
@@ -9,3 +10,18 @@ export enum TournamentRegistrationStatus {
     QUALIFIED_PENDING_REGISTRATION = 6
 }
 
+export type TournamentRegistrationStatusName = 'NOT_REGISTERED' | 'REGISTERED' | 'FINISHED' | 'PENDING' | 'CANCELLED' | 'REGISTERED_PENDING_QUALIFICATION' | 'QUALIFIED_PENDING_REGISTRATION';
+
+/** @hidden */
+export const TournamentRegistrationStatusName = (type: TournamentRegistrationStatus): TournamentRegistrationStatusName => {
+    return ({
+        [TournamentRegistrationStatus.CANCELLED]: 'CANCELLED',
+        [TournamentRegistrationStatus.FINISHED]: 'FINISHED',
+        [TournamentRegistrationStatus.NOT_REGISTERED]: 'NOT_REGISTERED',
+        [TournamentRegistrationStatus.PENDING]: 'PENDING',
+        [TournamentRegistrationStatus.QUALIFIED_PENDING_REGISTRATION]: 'QUALIFIED_PENDING_REGISTRATION',
+        [TournamentRegistrationStatus.REGISTERED]: 'REGISTERED',
+        [TournamentRegistrationStatus.REGISTERED_PENDING_QUALIFICATION]: 'REGISTERED_PENDING_QUALIFICATION',
+    }[type] || 'UNKNOWN') as TournamentRegistrationStatusName;
+}    
+

package/src/Tournaments/TournamentRegistrationType.ts

@@ -1,3 +1,4 @@
+/** @hidden */
 export enum TournamentRegistrationType {
 
     AUTO = 1,
@@ -7,3 +8,16 @@ export enum TournamentRegistrationType {
     REQUIRES_QUALIFICATION = 5
     // BUY_IN_CASH = 5???,
 }
+
+export type TournamentRegistrationTypeName = 'AUTO' | 'OPT_IN' | 'BUY_IN_POINTS' | 'MANUAL_APPROVAL' | 'REQUIRES_QUALIFICATION' | 'UNKNOWN';
+
+/** @hidden */
+export const TournamentRegistrationTypeGetName = (type: TournamentRegistrationType): TournamentRegistrationTypeName => {
+    return ({
+        [TournamentRegistrationType.AUTO]: 'AUTO',
+        [TournamentRegistrationType.BUY_IN_POINTS]: 'BUY_IN_POINTS',
+        [TournamentRegistrationType.MANUAL_APPROVAL]: 'MANUAL_APPROVAL',
+        [TournamentRegistrationType.OPT_IN]: 'OPT_IN',
+        [TournamentRegistrationType.REQUIRES_QUALIFICATION]: 'REQUIRES_QUALIFICATION',
+    }[type] || 'UNKNOWN') as any as TournamentRegistrationTypeName;
+}

package/src/WSAPI/WSAPI.ts

@@ -1,7 +1,7 @@
 import { CoreUtils } from "../Core";
 import { SmarticoAPI } from "../SmarticoAPI";
 
-import { TLevel, TMissionOrBadge, TUserProfile } from "./WSAPITypes";
+import { TLevel, TMissionOrBadge, TStoreItem, TTournament, TTournamentDetailed, TUserProfile } from "./WSAPITypes";
 
 /** @group General API */
 export class WSAPI {
@@ -33,8 +33,22 @@ export class WSAPI {
 
     /** Returns all the badges available the current user */
     public async getBadges(): Promise<TMissionOrBadge[]> {
-        return this.api.missionsGetItemsT(null);
-    }    
+        return this.api.badgetsGetItemsT(null);
+    }
+
+    /** Returns all the store items available the current user */
+    public async getStoreItems(): Promise<TStoreItem[]> {
+        return this.api.storeGetItemsT(null);
+    }
+
+    /** Returns all the active instances of tournaments */
+    public async getTournamentsList(): Promise<TTournament[]> {
+        return this.api.tournamentsGetLobbyT(null);
+    }
 
+    /** Returns details information of specific tournament instance, the response will includ tournamnet info and the leaderboard of players */
+    public async getTournamentInstanceInfo(tournamentInstanceId: number): Promise<TTournamentDetailed> {
+        return this.api.tournamentsGetInfoT(null, tournamentInstanceId);
+    }
 
 }

package/src/WSAPI/WSAPITypes.ts

@@ -1,3 +1,6 @@
+import { TournamentRegistrationStatus, TournamentRegistrationStatusName, TournamentRegistrationType, TournamentRegistrationTypeName } from "../Tournaments";
+
+type TRibbon = 'sale' | 'hot' | 'new' | 'vip' | string
 
 /**
  * TUser interface describes the information of the user
@@ -68,6 +71,150 @@ export interface TLevel {
     required_level_counter_2: number,
 }
 
+/** 
+ * TTournament interface describes the general information of the tournament item
+ */
+
+export interface TTournament {
+    /** ID of tournament instance. Generated every time when tournament based on specific template is scheduled for run */
+    instance_id: number;
+    /** ID of tournament template */
+    tournament_id: number;
+    /** Name of the tournament, translated to the user language */
+    name: string;
+    /** Description of the tournament, translated to the user language */
+    description: string;
+    /* 1st image URL representing the tournament */
+    image1: string;
+    /* 2nd image URL representing the tournament */
+    image2: string;
+    /* The message indicating the prize pool of the tournament */
+    prize_pool_short: string;
+    /* The message indicating the price to register in the tournament */
+    custom_price_text: string;
+
+    /** The message that should be shown to the user when the user cannot register in tournament with error code TOURNAMENT_USER_DONT_MATCH_CONDITIONS  */
+    segment_dont_match_message: string;
+    /** 
+     * The ID of the custom section where the tournament is assigned
+     * The list of custom sections can be retrieved using _smartico.api.getCustomSections() method (TODO-API)
+    */
+    custom_section_id: number;
+    /** The custom data of the tournament defined by operator. Can be a JSON object, string or number */
+    custom_data: any;
+
+    /** The indicator if the tournament is 'Featured' */
+    is_featured: boolean;
+
+    /** The ribbon of the tournament item. Can be 'sale', 'hot', 'new', 'vip' or URL to the image in case of custom ribbon */
+    ribbon: TRibbon;
+
+    /** The time when tournament is going to start, epoch with milliseconds */
+    start_time: number;
+    /** The time when tournament is going to finish, epoch with milliseconds */
+    end_time: number;
+    /** Type of registration in the tournament */
+    registration_type: TournamentRegistrationTypeName,
+    /** Number of users registered in the tournament */
+    registration_count: number;
+    /** flag indicating if current user is registered in the tournament */
+    is_user_registered: boolean;
+    /** Minimum number of participant for this tournament. If tournament doesnt have enough registrations, it will not start */
+    players_min_count: number;
+    /** Maximum number of participant for this tournament. When reached, new users won't be able to register */
+    players_max_count: number;
+    /** Status of registration in the tournament for current user */
+    registration_status: TournamentRegistrationStatusName,
+    /** Tournament duration in millisecnnds */
+    duration_ms: number;
+
+    /** Cost of registration in the tournament in gamification points */
+    registration_cost_points: number;
+
+    /** Indicator if tournament instance is active, means in one of the statues -  PUBLISHED, REGISTED, STARTED */
+    is_active: boolean;
+    
+    /** Indicator if user can register in this tournament instance, e.g tournament is active, max users is not reached, user is not registered yet */
+    is_can_register: boolean;
+    /** Indicator if tournament instance is cancelled (status CANCELLED) */
+    is_cancelled: boolean;
+    /** Indicator if tournament instance is finished (status FINISHED, CANCELLED OR FINIALIZING) */
+    is_finished: boolean;
+    /** Indicator if tournament instance is running (status STARTED) */
+    is_in_progress: boolean;
+    /** Indicator if tournament instance is upcoming (status PUBLISHED or REGISTER) */
+    is_upcoming: boolean;
+}
+
+/** 
+ * TTournamentDetailed interface describes the information of the tournament item and includes list of participants, their scores and position in the tournament leaderboard
+ */
+export interface TTournamentDetailed extends TTournament {
+    
+    /** The list of the tournament participants */
+    players?: {
+        /** The username of the participant */
+        public_username: string;
+        /** The URL to the avatar of the participant */
+        avatar_url: string;
+        /** The position of the participant in the tournament */
+        position: number;
+        /** The scores of the participant in the tournament */
+        scores: number;
+        /** The indicator if the participant is current user */
+        is_me: boolean;
+    }[],
+    /** The information about current user in the tournament if he is registered in the tournamnet */
+    me?: {
+        /** The username of the current user */
+        public_username: string;
+        /** The URL to the avatar of the current user */
+        avatar_url: string;
+        /** The position of the current user in the tournament */
+        position: number;
+        /** The scores of the current user in the tournament */
+        scores: number;
+    }
+
+};
+
+
+/** 
+ * TStoreItem interface describes the information of the store item defined in the system
+ */
+export interface TStoreItem {
+    /** ID of the store item  */
+    id: number;
+    /** Name of the store item, translated to the user language */
+    name: string;
+    /** Description of the store item, translated to the user language */
+    description: string;
+    /** URL of the image of the store item */
+    image: string;    
+    /** Type of the store item. Can be 'bonus' or 'manual'. Manual, means it's tangible item, e.g. iPhone */
+    type: 'bonus' | 'manual';
+    /** The price of the store item in the gamification points */
+    price: number;
+    /** The ribbon of the store item. Can be 'sale', 'hot', 'new', 'vip' or URL to the image in case of custom ribbon */
+    ribbon: TRibbon;
+    /** 
+     *  The message that should be shown to the user if he is not eligible to buy it. this message can be used to explain the reason why user cannot buy the item, e.g. 'You should be VIP to buy this item' and can be used in case can_buy property is false.
+        The message is translated to the user language.
+        **Note**: when user is trying to buy the item, the response from server can return custom error messages that can be shown to the user as well
+    */
+    limit_message: string;
+    /** The priority of the store item. Can be used to sort the items in the store */
+    priority: number;
+    /** The list of IDs of the related items. Can be used to show the related items in the store */
+    related_item_ids: number[];    
+    /** The indicator if the user can buy the item
+     *  This indicator is taking into account the segment conditions for the store item, the price of item towards users balance, 
+    */
+    can_buy: boolean;
+    /** The list of IDs of the categories where the store item is assigned, information about categories can be retrievend with getStoreCategories method */
+    category_ids: number[];
+}
+
 /** 
  * TMissionOrBadge interface describes the information of mission or badge defined in the system
  */

package/tsconfig.json

@@ -15,7 +15,11 @@
     ],
     "typedocOptions": {
         "name": "Smartico API documentation",
-        "entryPoints": ["src/WSAPI/WSAPI.ts", "src/WSAPI/WSAPITypes.ts"],
+        "entryPoints": [
+            "src/WSAPI/WSAPI.ts", "src/WSAPI/WSAPITypes.ts", 
+            "src/Tournaments/TournamentRegistrationStatus.ts",
+            "src/Tournaments/TournamentRegistrationType.ts"
+        ],
         "out": "docs",
         "plugin": ["typedoc-plugin-markdown", "typedoc-plugin-merge-modules"],
         "entryDocument": "README.md",