@smartico/public-api 0.0.351 → 0.0.353

package/src/GamePick/GPTypes.ts

@@ -0,0 +1,277 @@
+import { SAWGPMarketType } from '../Quiz/MarketsType';
+import { QuizAnswersValueType } from '../Quiz/MarketsAnswers';
+
+export enum GamePickMarketType {
+	Goals = 1,
+	Winner = 2,
+}
+
+export enum GamePickResolutionType {
+	None = 0,
+	Lost = 2,
+	PartialWin = 3,
+	FullWin = 4,
+}
+
+export enum GPRoundStatus {
+	Other = -1,
+	NoEventsDefined = 1,
+	NoMoreBetsAllowed = 2,
+	AllEventsResolved_ButNotRound = 3,
+	RoundResolved = 4,
+}
+
+export enum GamePickScoreType {
+	ExactScore = 1,
+	PointsDifference = 2,
+}
+
+export enum GamePickSportType {
+	Golf = 9,
+	Cycling = 17,
+	Specials = 18,
+	TouringCarRacing = 188,
+	StockCarRacing = 191,
+	IndyRacing = 129,
+	Biathlon = 44,
+	Speedway = 131,
+	Motorsport = 11,
+	AlpineSkiing = 43,
+	SkiJumping = 48,
+	Lacrosse = 39,
+	CrossCountry = 46,
+	NordicCombined = 47,
+	Chess = 33,
+	Athletics = 36,
+	ESportOverwatch = 121,
+	MMA = 117,
+	Futsal = 29,
+	IceHockey = 4,
+	Kabaddi = 138,
+	BeachVolley = 34,
+	Formula1 = 40,
+	ESporteBasketball = 153,
+	MotorcycleRacing = 190,
+	Bowls = 32,
+	Boxing = 10,
+	Floorball = 7,
+	GaelicHurling = 136,
+	Bandy = 15,
+	Handball = 6,
+	Waterpolo = 26,
+	Rugby = 12,
+	ESporteSoccer = 137,
+	FieldHockey = 24,
+	Pesapallo = 61,
+	Snooker = 19,
+	Badminton = 31,
+	Cricket = 21,
+	BeachSoccer = 60,
+	Baseball = 3,
+	StarCraft = 112,
+	ESportCounterStrike = 109,
+	ESportArenaofValor = 158,
+	Curling = 28,
+	Squash = 37,
+	Darts = 22,
+	TableTennis = 20,
+	Basketball3x3 = 155,
+	AussieRules = 13,
+	GaelicFootball = 135,
+	CallOfDuty = 118,
+	Soccer = 1,
+	Tennis = 5,
+	ESportDota = 111,
+	Basketball = 2,
+	ESportLeagueofLegends = 110,
+	AmericanFootball = 16,
+	Volleyball = 23,
+	Netball = 35,
+	ESportRocketLeague = 128,
+	Schwingen = 56,
+}
+
+export enum GameRoundOrderType {
+	HowAdded = 1,
+	HowAddedReversed = 2,
+	EventDateAscending = 3,
+	EventDateDescending = 4,
+}
+
+export const AllRoundsGameBoardID = -1;
+
+export interface QuizEventMeta {
+	answers?: {
+		value: string;
+		text: string;
+		_translations: {
+			[key: string]: {
+				text: string;
+			};
+		};
+	}[];
+	question_image?: string;
+	result?: QuizAnswersValueType;
+	custom_question: string;
+}
+
+export interface GamePickEventMeta extends QuizEventMeta {
+	event_name?: string;
+	team1_name: string;
+	team1_image: string;
+	team2_name: string;
+	team2_image: string;
+	team1_result?: number;
+	team2_result?: number;
+	sport_type_id?: number;
+	is_canceled?: boolean;
+	auto_resolve_enabled?: boolean;
+	auto_resolve_date?: string;
+	team1_auto_result?: number;
+	team2_auto_result?: number;
+	auto_result?: string;
+	_translations: {
+		[key: string]: {
+			team1_name: string;
+			team2_name: string;
+			event_name: string;
+			custom_question: string;
+		};
+	};
+}
+
+export interface GamePickEvent {
+	gp_event_id: number;
+	event_resolution_date: number;
+	match_date: number;
+	market_type_id: SAWGPMarketType;
+	event_meta: GamePickEventMeta;
+	user_placed_bet: boolean;
+	team1_user_selection?: number | { from: number; to: number };
+	team2_user_selection?: number | { from: number; to: number };
+	user_selection?: QuizAnswersValueType;
+	resolution_type_id: GamePickResolutionType;
+	resolution_score?: number;
+	is_open_for_bets?: boolean;
+	odds_details?: { odd_value: { [key: string]: number } };
+	question_image?: string;
+}
+
+export interface GamePickRoundBase {
+	round_id: number;
+	round_row_id: number;
+	round_name: string;
+	round_description: string;
+	final_screen_cta_button_title: string;
+	final_screen_message: string;
+	final_screen_image_desktop: string;
+	final_screen_image_mobile: string;
+	promo_image: string;
+	promo_text: string;
+	open_date: number;
+	last_bet_date: number;
+	resolution_date: number;
+	score_full_win: number;
+	score_part_win: number;
+	score_lost: number;
+	is_active_now: boolean;
+	is_resolved: boolean;
+	round_status_id: GPRoundStatus;
+	events_total: number;
+	events_resolved: number;
+	score_type_id: GamePickScoreType;
+	order_events: GameRoundOrderType;
+	board_users_count: number;
+	hide_users_predictions: boolean;
+	public_meta: {
+		round_name: string;
+		round_description: string;
+		promo_image: string;
+		promo_text: string;
+		hide_resolved_round: boolean;
+		final_screen_image_desktop: string;
+		final_screen_image_mobile: string;
+		final_screen_message: string;
+		final_screen_cta_button_title: string;
+		final_screen_cta_dp: string;
+		allow_edit_answers?: boolean;
+		_translations: {
+			[key: string]: {
+				round_name: string;
+				round_description: string;
+				promo_image: string;
+				promo_text: string;
+				final_screen_image_desktop: string;
+				final_screen_image_mobile: string;
+				final_screen_message: string;
+				final_screen_cta_button_title: string;
+			};
+		};
+	};
+	next_round_open_date: number;
+	show_users_preference: boolean;
+}
+
+export interface GamePickRound extends GamePickRoundBase {
+	events: GamePickEvent[];
+	user_score: number;
+	user_placed_bet: boolean;
+	has_open_for_bet_events?: boolean;
+	has_not_submitted_changes?: boolean;
+}
+
+export interface GamePickRoundBoard extends GamePickRoundBase {
+	my_user: GamePickBoardUser;
+	users: GamePickBoardUser[];
+}
+
+export interface GamePickBoardUser {
+	ext_user_id: string;
+	int_user_id: number;
+	public_username: string;
+	avatar_url: string;
+	gp_position: number;
+	resolution_score: number;
+	full_wins_count: number;
+	part_wins_count: number;
+	lost_count: number;
+}
+
+export interface GamePickUserInfo {
+	ext_user_id: string;
+	int_user_id: number;
+	public_username: string;
+	avatar_url: string;
+	gp_position?: number;
+	full_wins_count?: number;
+	part_wins_count?: number;
+	resolution_score?: number;
+	last_wallet_sync_time?: Date;
+	ach_points_balance?: number;
+	ach_gems_balance?: number;
+	ach_diamonds_balance?: number;
+	pubic_username_set?: boolean;
+}
+
+export interface GamePickGameInfo {
+	sawTemplate: any;
+	allRounds: GamePickRoundBase[];
+	labelInfo: any;
+}
+
+export interface GamesApiResponse<T> {
+	errCode: number;
+	errMessage?: string;
+	data?: T;
+}
+
+export interface GamePickRequestParams {
+	saw_template_id: number;
+	ext_user_id: string;
+	smartico_ext_user_id: string;
+	lang?: string;
+}
+
+export interface GamePickRoundRequestParams extends GamePickRequestParams {
+	round_id: number;
+}

package/src/GamePick/index.ts

@@ -0,0 +1 @@
+export * from './GPTypes';

package/src/Raffle/GetRafflesResponse.ts

@@ -108,6 +108,7 @@ export const raffleTransform = (items: Raffle[]): TRaffle[] => {
 			max_tickets_count: item.max_tickets_count,
 			current_tickets_count: item.current_tickets_count,
 			draws: drawTransform(item.draws),
+			ticket_cap_visualization: item.public_meta.ticket_cap_visualization,
 		};
 	});
 };

package/src/Raffle/Raffle.ts

@@ -1,5 +1,13 @@
 import { RaffleDraw } from "./RaffleDraw";
 
+export enum RaffleTicketCapVisualization {
+	/** Show nothing */
+	Empty = 0,
+	/** Show ticket counter */
+	Counter = 1,
+	/** Show message when ticket cap is reached */
+	Message = 2,
+}
 
 interface RafflePublicMeta {
     /** Name of the raffle */
@@ -20,6 +28,12 @@ interface RafflePublicMeta {
 	 * Read more here - <https://help.smartico.ai/welcome/products/general-concepts/custom-fields-attributes>
      */
 	custom_data: string;
+
+    /**
+     * - Value 1 (Counter): Shows a real-time "Tickets Remaining" display available during the whole Raffle activity.
+     * - Value 2 (Message): Will show a specific message that triggers only when the cap is reached and inform users that tickets will be no longer be issued.
+     */
+    ticket_cap_visualization?: RaffleTicketCapVisualization;
 }
 
 

package/src/SmarticoAPI.ts

@@ -133,24 +133,35 @@ import { GetJackpotWinnersResponse, GetJackpotWinnersResponseTransform, JackpotW
 import { GetJackpotWinnersRequest } from './Jackpots/GetJackpotWinnersRequest';
 import { GetJackpotEligibleGamesRequest } from './Jackpots/GetJackpotEligibleGamesRequest';
 import { GetJackpotEligibleGamesResponse, GetJackpotEligibleGamesResponseTransform, JackpotEligibleGame, TGetJackpotEligibleGamesResponse } from './Jackpots/GetJackpotEligibleGamesResponse';
+import {
+	GamesApiResponse,
+	GamePickRound,
+	GamePickRoundBoard,
+	GamePickUserInfo,
+	GamePickGameInfo,
+} from './GamePick';
 
 const PUBLIC_API_URL = 'https://papi{ENV_ID}.smartico.ai/services/public';
 const C_SOCKET_PROD = 'wss://api{ENV_ID}.smartico.ai/websocket/services';
+const GAMES_API_URL = 'https://r-games-api.smr.vc';
 const AVATAR_DOMAIN = 'https://img{ENV_ID}.smr.vc';
 const DEFAULT_LANG_EN = 'EN';
 
 interface Tracker {
 	label_api_key: string;
 	userPublicProps: any;
+	params: { brand_key?: string };
 	on: (callBackKey: ClassId, func: (data: any) => void) => void;
 	getLabelSetting: (key: PublicLabelSettings) => any;
 	triggerExternalCallBack: (callBackKey: string, payload: any) => void;
+	getExtUserId: () => string;
 }
 interface IOptions {
 	logger?: ILogger;
 	logCIDs?: ClassId[];
 	logHTTPTiming?: boolean;
 	tracker?: Tracker;
+	brand_api_key?: string;
 }
 
 type MessageSender = (message: any, publicApuUrl?: string, expectCID?: ClassId) => Promise<any>;
@@ -160,7 +171,10 @@ class SmarticoAPI {
 	private wsUrl: string;
 	private inboxCdnUrl: string;
 	private partnerUrl: string;
+	private gamesApiUrl: string;
+	private baseRgApiParams: Record<string, string>;
 	public avatarDomain: string;
+	private envId: number;
 
 	private logger: ILogger;
 	private logCIDs: ClassId[];
@@ -186,6 +200,13 @@ class SmarticoAPI {
 		this.publicUrl = SmarticoAPI.getPublicUrl(label_api_key);
 		this.wsUrl = SmarticoAPI.getPublicWsUrl(label_api_key);
 
+		this.baseRgApiParams = {
+			env_id: String(SmarticoAPI.getEnvId(label_api_key)),
+			label_api_key: label_api_key,
+			brand_key: options.brand_api_key || this.tracker.params.brand_key,
+			hash: IntUtils.uuid(),
+		}
+
 		this.avatarDomain = SmarticoAPI.getAvatarUrl(label_api_key || options.tracker?.label_api_key);
 
 		this.label_api_key = SmarticoAPI.getCleanLabelApiKey(label_api_key);
@@ -200,7 +221,7 @@ class SmarticoAPI {
 		return ENV_ID;
 	}
 
-	public static replaceSmrDomainsWithCloudfront<T>(value: string | {[key: string]: any}): T {
+	public static replaceSmrDomainsWithCloudfront<T>(value: string | { [key: string]: any }): T {
 		if (!value) {
 			return value as T;
 		}
@@ -255,7 +276,6 @@ class SmarticoAPI {
 	}
 
 	public static getAvatarUrl(label_api_key: string): string {
-		const envId = SmarticoAPI.getEnvDnsSuffix(label_api_key);
 		const avatarUrl = AVATAR_DOMAIN.replace('{ENV_ID}', SmarticoAPI.getEnvDnsSuffix(label_api_key));
 		return SmarticoAPI.replaceSmrDomainsWithCloudfront(avatarUrl);
 	}
@@ -477,7 +497,7 @@ class SmarticoAPI {
 			activityType,
 		});
 
-		this.send(message).catch(() => {});
+		this.send(message).catch(() => { });
 	}
 
 	/**
@@ -495,7 +515,7 @@ class SmarticoAPI {
 			...(action && { action }),
 		});
 
-		this.send(message).catch(() => {});
+		this.send(message).catch(() => { });
 	}
 
 	public async jackpotGet(
@@ -538,7 +558,7 @@ class SmarticoAPI {
 		return await this.send<JackpotsOptoutResponse>(message, ClassId.JP_OPTOUT_RESPONSE);
 	}
 
-	public async getJackpotWinners(user_ext_id: string, limit: number = 20, offset: number = 0, jp_template_id: number ): Promise<GetJackpotWinnersResponse> {
+	public async getJackpotWinners(user_ext_id: string, limit: number = 20, offset: number = 0, jp_template_id: number): Promise<GetJackpotWinnersResponse> {
 		const message = this.buildMessage<GetJackpotWinnersRequest, GetJackpotWinnersResponse>(
 			user_ext_id,
 			ClassId.JP_GET_WINNERS_REQUEST,
@@ -551,11 +571,11 @@ class SmarticoAPI {
 		return await this.send<GetJackpotWinnersResponse>(message, ClassId.JP_GET_WINNERS_RESPONSE);
 	}
 
-	public async getJackpotWinnersT(user_ext_id: string, limit: number = 20, offset: number = 0, jp_template_id: number ): Promise<JackpotWinnerHistory[]> {
+	public async getJackpotWinnersT(user_ext_id: string, limit: number = 20, offset: number = 0, jp_template_id: number): Promise<JackpotWinnerHistory[]> {
 		return GetJackpotWinnersResponseTransform((await this.getJackpotWinners(user_ext_id, limit, offset, jp_template_id)).winners);
 	}
 
-	public async getJackpotEligibleGames(user_ext_id: string, { jp_template_id } : { jp_template_id: number }): Promise<GetJackpotEligibleGamesResponse> {
+	public async getJackpotEligibleGames(user_ext_id: string, { jp_template_id }: { jp_template_id: number }): Promise<GetJackpotEligibleGamesResponse> {
 		const message = this.buildMessage<GetJackpotEligibleGamesRequest, GetJackpotEligibleGamesResponse>(
 			user_ext_id,
 			ClassId.JP_GET_ELIGIBLE_GAMES_REQUEST,
@@ -565,7 +585,7 @@ class SmarticoAPI {
 		return await this.send<GetJackpotEligibleGamesResponse>(message, ClassId.JP_GET_ELIGIBLE_GAMES_RESPONSE);;
 	}
 
-	public async getJackpotEligibleGamesT(user_ext_id: string, { jp_template_id } : { jp_template_id: number }): Promise<TGetJackpotEligibleGamesResponse> {
+	public async getJackpotEligibleGamesT(user_ext_id: string, { jp_template_id }: { jp_template_id: number }): Promise<TGetJackpotEligibleGamesResponse> {
 		return GetJackpotEligibleGamesResponseTransform(await this.getJackpotEligibleGames(user_ext_id, { jp_template_id }));
 	}
 
@@ -729,7 +749,7 @@ class SmarticoAPI {
 	public async getSawWinningHistoryT(user_ext_id: string, limit?: number, offset?: number, saw_template_id?: number): Promise<SAWPrizesHistory[]> {
 		return SAWHistoryTransform((await this.getSawWinningHistory(user_ext_id, limit, offset, saw_template_id)).prizes);
 	}
-	
+
 	public async missionOptIn(user_ext_id: string, mission_id: number) {
 		if (!mission_id) {
 			throw new Error('Missing mission id');
@@ -932,7 +952,7 @@ class SmarticoAPI {
 			ClassId.GET_BONUSES_RESPONSE,
 			force_language,
 		);
-		
+
 		const responseClone = { ...response };
 
 		return responseClone;
@@ -949,7 +969,7 @@ class SmarticoAPI {
 			ClassId.CLAIM_BONUS_RESPONSE,
 
 		);
-		
+
 		const responseClone = { ...response };
 
 		return responseClone;
@@ -1266,19 +1286,144 @@ class SmarticoAPI {
 		return await this.send<MarkInboxMessageDeletedResponse>(message, ClassId.MARK_INBOX_DELETED_RESPONSE);
 	}
 
+	private buildGamesApiParams(): Record<string, string> {
+		const params: Record<string, string> = Object.assign({}, this.baseRgApiParams, {
+			ext_user_id: this.tracker.userPublicProps?.user_id,
+			smartico_ext_user_id: this.tracker.getExtUserId(),
+			lang: this.tracker.userPublicProps?.core_user_language,
+		});
+
+		return params;
+	}
+
+	private async sendGamesApi<T>({ method, params, usePost = false }: { method: string, params: Record<string, any>, usePost?: boolean }): Promise<GamesApiResponse<T>> {
+		const baseParams = this.buildGamesApiParams();
+		const queryString = Object.entries(baseParams).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join('&');
+		let url = `${GAMES_API_URL}/${method}?${queryString}`;
+
+		let fetchOptions: RequestInit = {
+			method: 'GET',
+			headers: { 'Accept': 'application/json' },
+		};
+
+		if (usePost && params) {
+			fetchOptions = {
+				method: 'POST',
+				headers: {
+					'Accept': 'application/json',
+					'Content-Type': 'application/json',
+				},
+				body: JSON.stringify(params),
+			};
+		} else if (params) {
+			const extraQuery = Object.entries(params)
+				.map(([k, v]) => `${k}=${encodeURIComponent(JSON.stringify(v))}`)
+				.join('&');
+			url += `&${extraQuery}`;
+		}
+
+		try {
+			const response = await fetch(url, fetchOptions);
+
+			const data = await response.json();
+			return SmarticoAPI.replaceSmrDomainsWithCloudfront<GamesApiResponse<T>>(data);
+		} catch (e) {
+			this.logger.error(`Failed to call games API: ${method}`, { url, error: e.message });
+			throw new Error(`Failed to call games API: ${method}. ${e.message}`);
+		}
+	}
+
+	public async gpGetActiveRounds(saw_template_id: number): Promise<GamesApiResponse<GamePickRound[]>> {
+		const params = {
+			ext_game_id: saw_template_id,
+		};
+
+		return this.sendGamesApi<GamePickRound[]>({ method: 'active-rounds', params });
+	}
+
+	public async gpGetActiveRound(saw_template_id: number, round_id?: number): Promise<GamesApiResponse<GamePickRound>> {
+		const params = {
+			ext_game_id: saw_template_id,
+			round_id: round_id,
+		};	
+		
+		return this.sendGamesApi<GamePickRound>({ method: 'active-round', params });
+	}
+
+	public async gpGetGamesHistory(saw_template_id: number): Promise<GamesApiResponse<GamePickRound[]>> {
+		const params = {
+			ext_game_id: saw_template_id,
+		};
+
+		return this.sendGamesApi<GamePickRound[]>({ method: 'games-history', params });
+	}
+
+	public async gpGetGameBoard(saw_template_id: number, round_id: number): Promise<GamesApiResponse<GamePickRoundBoard>> {
+		const params = {
+			ext_game_id: saw_template_id,
+			round_id: round_id,
+		};
+
+		return this.sendGamesApi<GamePickRoundBoard>({ method: 'game-board', params });
+	}
+
+	public async gpSubmitSelection(saw_template_id: number, round: any, isQuiz: boolean): Promise<GamesApiResponse<GamePickRound>> {
+		const method = isQuiz ? 'submit-selection-quiz' : 'submit-selection';
+		const params = {
+			ext_game_id: saw_template_id,
+			round: round,
+		};
+
+		return this.sendGamesApi<GamePickRound>({ method, params, usePost: true });
+	}
+
+	public async gpGetUserInfo(saw_template_id: number): Promise<GamesApiResponse<GamePickUserInfo>> {
+		const params = {
+			ext_game_id: saw_template_id,
+		};
+
+		return this.sendGamesApi<GamePickUserInfo>({ method: 'user-info', params });
+	}
+
+	public async gpGetGameInfo(saw_template_id: number): Promise<GamesApiResponse<GamePickGameInfo>> {
+		const params = {
+			ext_game_id: saw_template_id,
+		};
+
+		return this.sendGamesApi<GamePickGameInfo>({ method: 'game-info', params });
+	}
+
+	public async gpGetTranslations(saw_template_id: number): Promise<GamesApiResponse<any>> {
+		const params = {
+			ext_game_id: saw_template_id,
+		};
+
+		return this.sendGamesApi<any>({ method: 'translations', params });
+	}
+
+	public async gpGetRoundInfoForUser(saw_template_id: number, round_id: number, int_user_id: number): Promise<GamesApiResponse<GamePickRound>> {
+		const params = {
+			ext_game_id: saw_template_id,
+			round_id: round_id,
+			int_user_id: int_user_id,
+		};
+
+		return this.sendGamesApi<GamePickRound>({ method: 'game-round-info-for-user', params });
+	}
+
 	public getWSCalls(): WSAPI {
 		return new WSAPI(this);
 	}
 
 	public async getRelatedItemsForGame(user_ext_id: string, related_game_id: string,): Promise<GetRelatedAchTourResponse> {
-		const message = this.buildMessage< GetRelatedAchTourRequest, GetRelatedAchTourResponse>(
+		const message = this.buildMessage<GetRelatedAchTourRequest, GetRelatedAchTourResponse>(
 			user_ext_id,
 			ClassId.GET_RELATED_ACH_N_TOURNAMENTS_REQUEST,
 			{
 				related_game_id: related_game_id
 			}
 		);
-		
+
 		return await this.send<GetRelatedAchTourResponse>(message, ClassId.GET_RELATED_ACH_N_TOURNAMENTS_RESPONSE);
 	}
 

package/src/Tournaments/Tournament.ts

@@ -68,6 +68,8 @@ export interface Tournament {
 	minScoreToWin?: number;
 	/** When enabled, users who don't meet the minimum qualifying score will be hidden from the Leaderboard. */
 	hideLeaderboardsMinScores?: boolean;
+	/** Total scores across all participants in the tournament */
+	totalScores?: number;
 }
 
 export const TournamentItemsTransform = (items: Tournament[]): TTournament[] => {
@@ -112,8 +114,9 @@ export const TournamentItemsTransform = (items: Tournament[]): TTournament[] =>
 				is_in_progress: TournamentUtils.isInProgress(r),
 				is_upcoming: TournamentUtils.isUpcoming(r),
 
-				min_scores_win: r.minScoreToWin,
-				hide_leaderboard_min_scores: r.hideLeaderboardsMinScores,
+			min_scores_win: r.minScoreToWin,
+			hide_leaderboard_min_scores: r.hideLeaderboardsMinScores,
+			total_scores: r.totalScores,
 			};
 
 			if (r.prizeStructure) {