@mtgame/core 1.0.33 → 1.0.35

package/api/league-api.d.ts

@@ -14,8 +14,17 @@ import { LeagueDocument } from '../models/league-document';
 import { TeamsAndUsers } from '../models/teams-and-users';
 import { SeasonTournament } from '../models/season-tournament';
 import { LeaguePlayerField } from '../models/league-player-field';
+export declare enum TournamentFilterStatusEnum {
+    open = 1,
+    recruitment = 2,
+    in_progress = 3,
+    closed = 4
+}
 export interface TournamentListFilters {
-    statuses: TournamentStatuses[];
+    statuses?: TournamentStatuses[];
+    tournamentStatus?: TournamentFilterStatusEnum;
+    seasonId?: number;
+    seasonTournamentId?: number;
 }
 export declare class LeagueApi {
     private httpClient;
@@ -25,6 +34,7 @@ export declare class LeagueApi {
     getByDomain(domain: string): Promise<League>;
     getSeasonTournaments(leagueId: number): Promise<SeasonTournament[]>;
     getTournaments(leagueId: number, filters?: TournamentListFilters): Promise<Tournament[]>;
+    getTournamentsPaginated(leagueId: number, page: number, size: number, filters?: TournamentListFilters): Promise<PaginatedResponse<Tournament[]>>;
     getEvents(leagueId: number, page: number, size: number, filters?: TournamentEventsListFilter): Promise<PaginatedResponse<TournamentEvent[]>>;
     getTournamentSeasons(leagueId: number): Promise<TournamentSeason[]>;
     getGames(leagueId: number, page: number, size: number, filters: TournamentGamesFilters): Promise<PaginatedResponse<Game[]>>;

package/bundles/mtgame-core.umd.js

@@ -9001,6 +9001,13 @@
         })
     ], SeasonTournament);
 
+    exports.TournamentFilterStatusEnum = void 0;
+    (function (TournamentFilterStatusEnum) {
+        TournamentFilterStatusEnum[TournamentFilterStatusEnum["open"] = 1] = "open";
+        TournamentFilterStatusEnum[TournamentFilterStatusEnum["recruitment"] = 2] = "recruitment";
+        TournamentFilterStatusEnum[TournamentFilterStatusEnum["in_progress"] = 3] = "in_progress";
+        TournamentFilterStatusEnum[TournamentFilterStatusEnum["closed"] = 4] = "closed";
+    })(exports.TournamentFilterStatusEnum || (exports.TournamentFilterStatusEnum = {}));
     var LeagueApi = /** @class */ (function () {
         function LeagueApi(httpClient, configService) {
             this.httpClient = httpClient;
@@ -9033,14 +9040,27 @@
                 return __generator(this, function (_a) {
                     params = new i1.HttpParams();
                     if (filters) {
-                        if (filters.statuses) {
-                            params = params.set('statuses', filters.statuses.map(function (s) { return exports.TournamentStatuses[s]; }).join(','));
-                        }
+                        params = applyTournamentListFilters(params, filters);
                     }
                     return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/tournaments/", { params: params }).pipe(operators.map(function (result) { return exports.Tournament.toFront(result); })).toPromise()];
                 });
             });
         };
+        LeagueApi.prototype.getTournamentsPaginated = function (leagueId, page, size, filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new i1.HttpParams().set('page', page).set('size', size);
+                    if (filters) {
+                        params = applyTournamentListFilters(params, filters);
+                    }
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/tournaments/", { params: params, observe: 'response' }).pipe(operators.map(function (response) { return ({
+                            total: +response.headers.get('X-Page-Count'),
+                            data: exports.Tournament.toFront(response.body)
+                        }); })).toPromise()];
+                });
+            });
+        };
         LeagueApi.prototype.getEvents = function (leagueId, page, size, filters) {
             return __awaiter(this, void 0, void 0, function () {
                 var params;
@@ -9175,6 +9195,21 @@
         { type: i1.HttpClient },
         { type: ConfigService }
     ]; };
+    function applyTournamentListFilters(params, filters) {
+        if (filters.statuses) {
+            params = params.set('statuses', filters.statuses.map(function (s) { return exports.TournamentStatuses[s]; }).join(','));
+        }
+        if (filters.tournamentStatus) {
+            params = params.set('tournament_status', exports.TournamentFilterStatusEnum[filters.tournamentStatus]);
+        }
+        if (filters.seasonId) {
+            params = params.set('season_id', filters.seasonId);
+        }
+        if (filters.seasonTournamentId) {
+            params = params.set('season_tournament_id', filters.seasonTournamentId);
+        }
+        return params;
+    }
 
     var LeagueNewsApi = /** @class */ (function () {
         function LeagueNewsApi(httpClient, configService) {