@smartico/public-api 0.0.350 → 0.0.352

package/docs/api/enums/RaffleTicketCapVisualization.md

@@ -0,0 +1,21 @@
+# Enumeration: RaffleTicketCapVisualization
+
+### Empty
+
+• **Empty** = ``0``
+
+Don’t show anything
+
+### Counter
+
+• **Counter** = ``1``
+
+Show ticket counter
+
+___
+
+### Message
+
+• **Message** = ``2``
+
+Show message when ticket cap is reached

package/docs/api/interfaces/RafflePublicMeta.md

@@ -57,3 +57,11 @@ ___
 Custom data as string or JSON string that can be used in API to build custom UI
 You can request from Smartico to define fields for your specific case that will be managed from Smartico BackOffice
 Read more here - <https://help.smartico.ai/welcome/products/general-concepts/custom-fields-attributes>
+
+___
+
+### ticket\_cap\_visualization
+
+• **ticket\_cap\_visualization**: [`RaffleTicketCapVisualization`](../enums/RaffleTicketCapVisualization.md)
+
+Ticket cap visualization

package/docs/api/interfaces/TTournament.md

@@ -316,3 +316,11 @@ ___
 • `Optional` **hide\_leaderboard\_min\_scores**: `boolean`
 
 When enabled, users who don’t meet the minimum qualifying score will be hidden from the Leaderboard
+
+___
+
+### total\_scores
+
+• `Optional` **total\_scores**: `number`
+
+Total scores across all participants in the tournament

package/docs/api/interfaces/TTournamentDetailed.md

@@ -431,6 +431,18 @@ When enabled, users who don’t meet the minimum qualifying score will be hidden
 
 ___
 
+### total\_scores
+
+• `Optional` **total\_scores**: `number`
+
+Total scores across all participants in the tournament
+
+#### Inherited from
+
+[TTournament](TTournament.md).[total_scores](TTournament.md#total_scores)
+
+___
+
 ### related\_games
 
 • `Optional` **related\_games**: [`AchRelatedGame`](AchRelatedGame-1.md)[]

package/docs/api/interfaces/Tournament.md

@@ -205,3 +205,11 @@ ___
 • `Optional` **hideLeaderboardsMinScores**: `boolean`
 
 When enabled, users who don't meet the minimum qualifying score will be hidden from the Leaderboard.
+
+___
+
+### totalScores
+
+• `Optional` **totalScores**: `number`
+
+Total scores across all participants in the tournament

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@smartico/public-api",
-	"version": "0.0.350",
+	"version": "0.0.352",
 	"description": "Smartico public API",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/src/ActivityLog/GetActivityLogResponse.ts

@@ -20,6 +20,8 @@ export const ActivityLogTransform = (items: ActivityLogEntry[]): TActivityLog[]
 			source_type_id: item.source_type_id,
 		}
 
+		item.type = item.type ?? UserBalanceType.Points;
+
 		if (item.type === UserBalanceType.Diamonds || item.type === UserBalanceType.Gems) {
 			itemTransformed.type = item.type;
 			itemTransformed.amount = item.amount;

package/src/GamePick/GPTypes.ts

@@ -0,0 +1,273 @@
+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;
+}

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,9 +133,17 @@ 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{ENV_ID}.smr.vc';
 const AVATAR_DOMAIN = 'https://img{ENV_ID}.smr.vc';
 const DEFAULT_LANG_EN = 'EN';
 
@@ -160,7 +168,9 @@ class SmarticoAPI {
 	private wsUrl: string;
 	private inboxCdnUrl: string;
 	private partnerUrl: string;
+	public gamesApiUrl: string;
 	public avatarDomain: string;
+	private envId: number;
 
 	private logger: ILogger;
 	private logCIDs: ClassId[];
@@ -185,6 +195,7 @@ class SmarticoAPI {
 
 		this.publicUrl = SmarticoAPI.getPublicUrl(label_api_key);
 		this.wsUrl = SmarticoAPI.getPublicWsUrl(label_api_key);
+		this.gamesApiUrl = SmarticoAPI.getGamesApiUrl(label_api_key);
 
 		this.avatarDomain = SmarticoAPI.getAvatarUrl(label_api_key || options.tracker?.label_api_key);
 
@@ -254,8 +265,11 @@ class SmarticoAPI {
 		return C_SOCKET_PROD.replace('{ENV_ID}', SmarticoAPI.getEnvDnsSuffix(label_api_key));
 	}
 
+	public static getGamesApiUrl(label_api_key: string): string {
+		return GAMES_API_URL.replace('{ENV_ID}', SmarticoAPI.getEnvDnsSuffix(label_api_key));
+	}
+
 	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);
 	}
@@ -1266,6 +1280,101 @@ class SmarticoAPI {
 		return await this.send<MarkInboxMessageDeletedResponse>(message, ClassId.MARK_INBOX_DELETED_RESPONSE);
 	}
 
+	private buildGamesApiParams(ext_user_id: string, smartico_ext_user_id: string, ext_game_id: number, lang: string): Record<string, string> {
+		const params: Record<string, string> = {
+			ext_user_id,
+			smartico_ext_user_id,
+			ext_game_id: String(ext_game_id),
+			lang,
+			env_id: String(SmarticoAPI.getEnvId(this.label_api_key)),
+			label_api_key: this.label_api_key,
+			hash: '',
+		};
+
+		if (this.brand_api_key) {
+			params.brand_key = this.brand_api_key;
+		}
+
+		return params;
+	}
+
+	private async sendGamesApi<T>(method: string, ext_user_id: string, smartico_ext_user_id: string, ext_game_id: number, lang: string, extraParams?: Record<string, any>, usePost: boolean = false): Promise<GamesApiResponse<T>> {
+		const baseParams = this.buildGamesApiParams(ext_user_id, smartico_ext_user_id, ext_game_id, lang);
+		const queryString = Object.entries(baseParams).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join('&');
+		let url = `${this.gamesApiUrl}/${method}?${queryString}`;
+
+		let fetchOptions: RequestInit = {
+			method: 'GET',
+			headers: { 'Accept': 'application/json' },
+		};
+
+		if (usePost && extraParams) {
+			fetchOptions = {
+				method: 'POST',
+				headers: {
+					'Accept': 'application/json',
+					'Content-Type': 'application/json',
+				},
+				body: JSON.stringify(extraParams),
+			};
+		} else if (extraParams) {
+			const extraQuery = Object.entries(extraParams)
+				.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(ext_user_id: string, smartico_ext_user_id: string, saw_template_id: number, lang: string = DEFAULT_LANG_EN): Promise<GamesApiResponse<GamePickRound[]>> {
+		return this.sendGamesApi<GamePickRound[]>('active-rounds', ext_user_id, smartico_ext_user_id, saw_template_id, lang);
+	}
+
+	public async gpGetActiveRound(ext_user_id: string, smartico_ext_user_id: string, saw_template_id: number, lang: string = DEFAULT_LANG_EN, round_id?: number): Promise<GamesApiResponse<GamePickRound>> {
+		const extraParams: Record<string, any> = {};
+		if (round_id !== undefined) {
+			extraParams.round_id = round_id;
+		}
+		return this.sendGamesApi<GamePickRound>('active-round', ext_user_id, smartico_ext_user_id, saw_template_id, lang, Object.keys(extraParams).length > 0 ? extraParams : undefined);
+	}
+
+	public async gpGetGamesHistory(ext_user_id: string, smartico_ext_user_id: string, saw_template_id: number, lang: string = DEFAULT_LANG_EN): Promise<GamesApiResponse<GamePickRound[]>> {
+		return this.sendGamesApi<GamePickRound[]>('games-history', ext_user_id, smartico_ext_user_id, saw_template_id, lang);
+	}
+
+	public async gpGetGameBoard(ext_user_id: string, smartico_ext_user_id: string, saw_template_id: number, round_id: number, lang: string = DEFAULT_LANG_EN): Promise<GamesApiResponse<GamePickRoundBoard>> {
+		return this.sendGamesApi<GamePickRoundBoard>('game-board', ext_user_id, smartico_ext_user_id, saw_template_id, lang, { round_id });
+	}
+
+	public async gpSubmitSelection(ext_user_id: string, smartico_ext_user_id: string, saw_template_id: number, round: any, isQuiz: boolean, lang: string = DEFAULT_LANG_EN): Promise<GamesApiResponse<GamePickRound>> {
+		const method = isQuiz ? 'submit-selection-quiz' : 'submit-selection';
+		return this.sendGamesApi<GamePickRound>(method, ext_user_id, smartico_ext_user_id, saw_template_id, lang, { round }, true);
+	}
+
+	public async gpGetUserInfo(ext_user_id: string, smartico_ext_user_id: string, saw_template_id: number, lang: string = DEFAULT_LANG_EN): Promise<GamesApiResponse<GamePickUserInfo>> {
+		return this.sendGamesApi<GamePickUserInfo>('user-info', ext_user_id, smartico_ext_user_id, saw_template_id, lang);
+	}
+
+	public async gpGetGameInfo(ext_user_id: string, smartico_ext_user_id: string, saw_template_id: number, lang: string = DEFAULT_LANG_EN): Promise<GamesApiResponse<GamePickGameInfo>> {
+		return this.sendGamesApi<GamePickGameInfo>('game-info', ext_user_id, smartico_ext_user_id, saw_template_id, lang);
+	}
+
+	public async gpGetTranslations(ext_user_id: string, smartico_ext_user_id: string, saw_template_id: number, lang: string = DEFAULT_LANG_EN): Promise<GamesApiResponse<any>> {
+		return this.sendGamesApi<any>('translations', ext_user_id, smartico_ext_user_id, saw_template_id, lang);
+	}
+
+	public async gpGetRoundInfoForUser(ext_user_id: string, smartico_ext_user_id: string, saw_template_id: number, round_id: number, int_user_id: number, lang: string = DEFAULT_LANG_EN): Promise<GamesApiResponse<GamePickRound>> {
+		return this.sendGamesApi<GamePickRound>('game-round-info-for-user', ext_user_id, smartico_ext_user_id, saw_template_id, lang, { round_id, int_user_id });
+	}
+
 	public getWSCalls(): WSAPI {
 		return new WSAPI(this);
 	}

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) {