@smartico/public-api 0.0.379 → 0.0.380

package/src/WSAPI/WSAPIJackpots.ts

@@ -0,0 +1,212 @@
+import { ECacheContext, OCache } from '../OCache';
+import {
+	JackpotDetails,
+	JackpotPot,
+	JackpotWinnerHistory,
+	JackpotsOptinResponse,
+	JackpotsOptoutResponse,
+} from '../Jackpots';
+import { IntUtils } from '../IntUtils';
+import { TGetJackpotEligibleGamesResponse } from '../Jackpots/GetJackpotEligibleGamesResponse';
+import {
+	JACKPOT_TEMPLATE_CACHE_SEC,
+	JACKPOT_POT_CACHE_SEC,
+	JACKPOT_WINNERS_CACHE_SEC,
+	JACKPOT_ELIGIBLE_GAMES_CACHE_SEC,
+	onUpdateContextKey,
+} from './WSAPIBase';
+import { WSAPIClans } from './WSAPIClans';
+
+/** @group Jackpots */
+export class WSAPIJackpots extends WSAPIClans {
+
+	/** @hidden */
+	protected jackpotGetSignature: string = '';
+	protected async jackpotClearCache() {
+		OCache.clear(ECacheContext.WSAPI, onUpdateContextKey.Jackpots);
+		OCache.clear(ECacheContext.WSAPI, onUpdateContextKey.Pots);
+		OCache.clear(ECacheContext.WSAPI, onUpdateContextKey.JackpotWinners);
+	}
+
+	/** Returns list of Jackpots that are active in the system and matching to the filter definition.
+	 * If filter is not provided, all active jackpots will be returned.
+	 * Filter can be used to get jackpots related to specific game or specific jackpot template.
+	 * You can call this method every second in order to get up to date information about current value of the jackpot(s) and present them to the end-users
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.jackpotGet({ related_game_id: 'wooko-slot' }).then((result) => {
+	 *      console.log(result);
+	 * });
+	 * ```
+	 *
+	 * **Example in the Visitor mode**:
+	 * ```
+	 * _smartico.vapi('EN').jackpotGet({ related_game_id: 'wooko-slot' }).then((result) => {
+	 *      console.log(result);
+	 * });
+	 * ```
+	 */
+	public async jackpotGet(filter?: { related_game_id?: string; jp_template_id?: number }): Promise<JackpotDetails[]> {
+		const signature: string = `${filter?.jp_template_id}:${filter?.related_game_id}`;
+
+		if (signature !== this.jackpotGetSignature) {
+			this.jackpotGetSignature = signature;
+			this.jackpotClearCache();
+		}
+
+		let jackpots: JackpotDetails[] = [];
+		let pots: JackpotPot[] = [];
+
+		jackpots = await OCache.use<JackpotDetails[]>(
+			onUpdateContextKey.Jackpots,
+			ECacheContext.WSAPI,
+			async () => {
+				const _jackpots = await this.api.jackpotGet(this.userExtId, filter);
+				const _pots = _jackpots.items.map((jp) => jp.pot);
+
+				_jackpots.items.forEach((jp) => {
+					jp.jp_public_meta.custom_data = IntUtils.JsonOrText(jp.jp_public_meta.custom_data);
+				});
+
+				OCache.set(onUpdateContextKey.Pots, _pots, ECacheContext.WSAPI, JACKPOT_POT_CACHE_SEC);
+				return _jackpots.items;
+			},
+			JACKPOT_TEMPLATE_CACHE_SEC,
+		);
+
+		if (jackpots.length > 0) {
+			pots = await OCache.use<JackpotPot[]>(
+				onUpdateContextKey.Pots,
+				ECacheContext.WSAPI,
+				async () => {
+					const jp_template_ids = jackpots.map((jp) => jp.jp_template_id);
+					return (await this.api.potGet(this.userExtId, { jp_template_ids })).items;
+				},
+				JACKPOT_POT_CACHE_SEC,
+			);
+		}
+
+		return jackpots.map((jp) => {
+			let _jp: JackpotDetails = {
+				...jp,
+				pot: pots.find((p) => p.jp_template_id === jp.jp_template_id),
+			};
+			return _jp;
+		});
+	}
+
+	/**
+	 * Opt-in currently logged in user to the jackpot with the specified jp_template_id.
+	 * You may call jackpotGet method after doing optin to see that user is opted in to the jackpot.
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.jackpotOptIn({ jp_template_id: 123 }).then((result) => {
+	 *      console.log('Opted in to the jackpot');
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 *
+	 */
+	public async jackpotOptIn(filter: { jp_template_id: number }): Promise<JackpotsOptinResponse> {
+		if (!filter.jp_template_id) {
+			throw new Error('jp_template_id is required in jackpotOptIn');
+		}
+
+		const result = await this.api.jackpotOptIn(this.userExtId, filter);
+
+		return result;
+	}
+
+	/**
+	 * Opt-out currently logged in user from the jackpot with the specified jp_template_id.
+	 * You may call jackpotGet method after doing optout to see that user is not opted in to the jackpot.
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.jackpotOptOut({ jp_template_id: 123 }).then((result) => {
+	 *      console.log('Opted out from the jackpot');
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 *
+	 */
+	public async jackpotOptOut(filter: { jp_template_id: number }): Promise<JackpotsOptoutResponse> {
+		if (!filter.jp_template_id) {
+			throw new Error('jp_template_id is required in jackpotOptOut');
+		}
+
+		const result = await this.api.jackpotOptOut(this.userExtId, filter);
+
+		return result;
+	}
+
+	/**
+	 * Returns jackpot winners for the given `jp_template_id` (paginated on the server).
+	 * Default page size on the wire is 20; use `limit`, `offset`, and repeated calls to load more.
+	 * The full protocol response also includes `has_more`; this method returns only the `winners` array.
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getJackpotWinners({
+	 *      jp_template_id: 123,
+	 * }).then((result) => {
+	 *      console.log(result);
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 *
+	 * @param params - Jackpot winners parameters
+	 * @param params.jp_template_id - Jackpot template id (required; throws if missing)
+	 * @param params.limit - Page size (server default 20 when omitted)
+	 * @param params.offset - Offset into the winner list
+	 */
+
+	public async getJackpotWinners({
+		limit,
+		offset,
+		jp_template_id,
+	}: {
+		limit?: number;
+		offset?: number;
+		jp_template_id?: number;
+	}): Promise<JackpotWinnerHistory[]> {
+		return OCache.use(
+			onUpdateContextKey.JackpotWinners + jp_template_id,
+			ECacheContext.WSAPI,
+			() => this.api.getJackpotWinnersT(this.userExtId, limit, offset, jp_template_id),
+			JACKPOT_WINNERS_CACHE_SEC,
+		);
+	}
+
+	/**
+	 * Returns the eligible games for the jackpot with the specified jp_template_id.
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getJackpotEligibleGames({ jp_template_id: 123 }).then((result) => {
+	 *      console.log(result);
+	 * });
+	 * ```
+	 * 
+	 * **Visitor mode: not supported**
+	 * 
+	 */
+
+	public async getJackpotEligibleGames({ jp_template_id, onUpdate } : { jp_template_id: number, onUpdate?: () => void }): Promise<TGetJackpotEligibleGamesResponse> {
+		if (onUpdate) {
+			this.onUpdateCallback.set(onUpdateContextKey.JackpotEligibleGames, onUpdate);
+		}
+
+		return OCache.use(
+			onUpdateContextKey.JackpotEligibleGames + jp_template_id,
+			ECacheContext.WSAPI,
+			() => this.api.getJackpotEligibleGamesT(this.userExtId, { jp_template_id }),
+			JACKPOT_ELIGIBLE_GAMES_CACHE_SEC,
+		);
+	}
+}

package/src/WSAPI/WSAPILeaderBoard.ts

@@ -0,0 +1,40 @@
+import { ECacheContext, OCache } from '../OCache';
+import {
+	LeaderBoardDetailsT,
+} from './WSAPITypes';
+import { LeaderBoardPeriodType } from '../Leaderboard';
+import {
+	CACHE_DATA_SEC,
+	onUpdateContextKey,
+} from './WSAPIBase';
+import { WSAPIGamePick } from './WSAPIGamePick';
+
+/** @group LeaderBoard */
+export class WSAPILeaderBoard extends WSAPIGamePick {
+	/**
+	 * Returns the leaderboard for the current type (default is Daily). If getPreviousPeriod is passed as true, a leaderboard for the previous period for the current type will be returned.
+	 * For example, if the type is Weekly and getPreviousPeriod is true, a leaderboard for the previous week will be returned.
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getLeaderBoard(1).then((result) => {
+	 *     console.log(result);
+	 * });
+	 * ```
+	 *
+	 * **Example in the Visitor mode**:
+	 * ```
+	 * _smartico.vapi('EN').getLeaderBoard(1).then((result) => {
+	 *    console.log(result);
+	 * });
+	 * ```
+	 */
+	public async getLeaderBoard(periodType: LeaderBoardPeriodType, getPreviousPeriod?: boolean): Promise<LeaderBoardDetailsT> {
+		return OCache.use(
+			onUpdateContextKey.LeaderBoards,
+			ECacheContext.WSAPI,
+			() => this.api.leaderboardsGetT(this.userExtId, periodType, getPreviousPeriod),
+			CACHE_DATA_SEC,
+		);
+	}
+}

package/src/WSAPI/WSAPIMiniGames.ts

@@ -0,0 +1,181 @@
+import { SAWSpinsCountPush } from '../MiniGames';
+import { ECacheContext, OCache } from '../OCache';
+import {
+	TMiniGamePlayResult,
+	TMiniGameTemplate,
+	TMiniGamePlayBatchResult,
+	TSawHistory,
+} from './WSAPITypes';
+import {
+	CACHE_DATA_SEC,
+	onUpdateContextKey,
+} from './WSAPIBase';
+import { WSAPIRaffles } from './WSAPIRaffles';
+
+/** @group MiniGames */
+export class WSAPIMiniGames extends WSAPIRaffles {
+	/**
+	 * Returns the list of mini-games configured for the current user (not filtered by spin availability or Widget visibility).
+	 * The returned list of mini-games is cached for 30 seconds. But you can pass the onUpdate callback as a parameter. Note that each time you call getMiniGames with a new onUpdate callback, the old one will be overwritten by the new one.
+	 * The onUpdate callback will be called on available spin count change, if mini-game has increasing jackpot per spin or won prize is spin/jackpot and if max count of the available user spins equals one, also if the spins were issued to the user manually in the BO. Updated templates will be passed to onUpdate callback.
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getMiniGames().then((result) => {
+	 *      console.log(result);
+	 * });
+	 * ```
+	 *
+	 * **Example in the Visitor mode**:
+	 * ```
+	 * _smartico.vapi('EN').getMiniGames().then((result) => {
+	 *      console.log(result);
+	 * });
+	 * ```
+	 *
+	 */
+	public async getMiniGames({ onUpdate }: { onUpdate?: (data: TMiniGameTemplate[]) => void } = {}): Promise<
+		TMiniGameTemplate[]
+	> {
+		if (onUpdate) {
+			this.onUpdateCallback.set(onUpdateContextKey.Saw, onUpdate);
+		}
+
+		return OCache.use(onUpdateContextKey.Saw, ECacheContext.WSAPI, () => this.api.sawGetTemplatesT(this.userExtId), CACHE_DATA_SEC);
+	}
+
+	/**
+	 * Returns the list of mini-games based on the provided parameters. "Limit" and "offset" indicate the range of items to be fetched.
+	 * The maximum number of items per request is limited to 20.
+	 * You can leave this params empty and by default it will return list of mini-games ranging from 0 to 20.
+	 * The returned list of mini-games history is cached for 30 seconds.
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.getMiniGamesHistory().then((result) => {
+	 *      console.log(result);
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+
+	public async getMiniGamesHistory({
+		limit,
+		offset,
+		saw_template_id,
+	}: {
+		limit?: number;
+		offset?: number;
+		saw_template_id?: number;
+	}): Promise<TSawHistory[]> {
+		return OCache.use(
+			onUpdateContextKey.SAWHistory,
+			ECacheContext.WSAPI,
+			() => this.api.getSawWinningHistoryT(this.userExtId, limit, offset, saw_template_id),
+			CACHE_DATA_SEC,
+		);
+	}
+
+	/**
+	 * Plays the specified by template_id mini-game on behalf of user and returns prize_id or err_code
+	 * After playMiniGame is called, you can call getMiniGames to get the list of mini-games.The returned list of mini-games is cached for 30 seconds. But you can pass the onUpdate callback as a parameter. Note that each time you call playMiniGame with a new onUpdate callback, the old one will be overwritten by the new one.
+	 * The onUpdate callback will be called on available spin count change, if mini-game has increasing jackpot per spin or won prize is spin/jackpot and if max count of the available user spins equals one, also if the spins were issued to the user manually in the BO. Updated templates will be passed to onUpdate callback.
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.playMiniGame(55).then((result) => {
+	 *      console.log(result);
+	 * });
+	 * ```
+	 *
+	 * **Visitor mode: not supported**
+	 */
+	public async playMiniGame(
+		template_id: number,
+		{ onUpdate }: { onUpdate?: (data: TMiniGameTemplate[]) => void } = {},
+	): Promise<TMiniGamePlayResult> {
+		if (onUpdate) {
+			this.onUpdateCallback.set(onUpdateContextKey.Saw, onUpdate);
+		}
+
+		const r = await this.api.sawSpinRequest(this.userExtId, template_id);
+		this.api.doAcknowledgeRequest(this.userExtId, r.request_id);
+
+		const o: TMiniGamePlayResult = {
+			err_code: r.errCode,
+			err_message: r.errMsg,
+			prize_id: r.saw_prize_id,
+		};
+
+		return o;
+	}
+
+	/**
+	 * Sends the acknowledge request with specific client_request_id from minigame history in order to claim prize
+	 * **Example**:
+	 * ```
+	 * _smartico.api.miniGameWinAcknowledgeRequest('2a189322-31bb-4119-b943-bx7868ff8dc3').then((result) => {
+	 *      console.log(result);
+	 * });
+	 * ```
+	 */
+	public async miniGameWinAcknowledgeRequest(request_id: string) {
+		return this.api.doAcknowledgeRequest(this.userExtId, request_id);
+	}
+
+	/**
+	 * Plays the specified by template_id mini-game on behalf of user spin_count times and returns array of the prizes
+	 * After playMiniGameBatch is called, you can call getMiniGames to get the list of mini-games. The returned list of mini-games is cached for 30 seconds. But you can pass the onUpdate callback as a parameter. Note that each time you call playMiniGameBatch with a new onUpdate callback, the old one will be overwritten by the new one.
+	 * The onUpdate callback will be called on available spin count change, if mini-game has increasing jackpot per spin or won prize is spin/jackpot and if max count of the available user spins equals one, also if the spins were issued to the user manually in the BO. Updated templates will be passed to onUpdate callback.
+	 *
+	 * **Example**:
+	 * ```
+	 * _smartico.api.playMiniGameBatch(55, 10).then((result) => {
+	 *      console.log(result);
+	 * });
+	 * ```
+	 * **Visitor mode: not supported**
+	 */
+	public async playMiniGameBatch(
+		template_id: number,
+		spin_count: number,
+		{ onUpdate }: { onUpdate?: (data: TMiniGameTemplate[]) => void } = {},
+	): Promise<TMiniGamePlayBatchResult[]> {
+		if (onUpdate) {
+			this.onUpdateCallback.set(onUpdateContextKey.Saw, onUpdate);
+		}
+
+		const response = await this.api.sawSpinBatchRequest(this.userExtId, template_id, spin_count);
+
+		const request_ids = response.results.map((result) => result.request_id);
+		this.api.doAcknowledgeBatchRequest(this.userExtId, request_ids);
+
+		const o: TMiniGamePlayBatchResult[] = response.results.map((result) => ({
+			errCode: result.errCode,
+			errMessage: result.errMsg,
+			saw_prize_id: result.saw_prize_id,
+			jackpot_amount: result.jackpot_amount,
+			first_spin_in_period: result.first_spin_in_period,
+		}));
+
+		return o;
+	}
+
+	protected async updateOnSpin(data: SAWSpinsCountPush) {
+		const templates: TMiniGameTemplate[] = await OCache.use(
+			onUpdateContextKey.Saw,
+			ECacheContext.WSAPI,
+			() => this.api.sawGetTemplatesT(this.userExtId),
+			CACHE_DATA_SEC,
+		);
+		const index = templates.findIndex((t) => t.id === data.saw_template_id);
+		templates[index].spin_count = data.spin_count;
+		this.updateEntity(onUpdateContextKey.Saw, templates);
+	}
+
+	protected async reloadMiniGameTemplate() {
+		const updatedTemplates = await this.api.sawGetTemplatesT(this.userExtId);
+		this.updateEntity(onUpdateContextKey.Saw, updatedTemplates);
+	}
+}