@mtgame/core 0.0.38 → 0.0.39

package/api/league-api.d.ts

@@ -17,4 +17,5 @@ export declare class LeagueApi {
     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[]>>;
+    getSeasons(leagueId: number, notClosed?: boolean): Promise<TournamentSeason[]>;
 }

package/api/league-news-api.d.ts

@@ -6,8 +6,9 @@ export declare class LeagueNewsApi {
     private httpClient;
     private configService;
     constructor(httpClient: HttpClient, configService: ConfigService);
-    getLeagueNewsList(leagueId: number): Promise<PaginatedResponse<LeagueNews[]>>;
+    getLeagueNewsList(leagueId: number, page: number, size: number): Promise<PaginatedResponse<LeagueNews[]>>;
     getMainLeagueNews(leagueId: number): Promise<LeagueNews>;
+    getMainLeagueNewsList(leagueId: number): Promise<LeagueNews[]>;
     getNewsById(newsId: number): Promise<LeagueNews>;
     getTournamentNewsList(tournamentId: number): Promise<PaginatedResponse<LeagueNews[]>>;
 }

package/api/media-api.d.ts

@@ -12,7 +12,8 @@ export interface GameMediaFilters {
     status?: GameStatuses;
 }
 export interface MediaFilters {
-    mediaType?: 'photo' | 'video';
+    mediaType?: 'photo' | 'video' | 'live_video';
+    sort?: string;
 }
 export declare class MediaApi {
     private httpClient;

package/api/tournament-api.d.ts

@@ -22,10 +22,12 @@ export interface TournamentGamesFilters {
     playoffStage?: number;
     playoffId?: number;
     status?: GameStatuses;
+    statuses?: GameStatuses[];
 }
 export declare type StatisticGroupByTypes = 'team' | 'user' | 'team_user' | 'tournament_team' | 'tournament_team_user' | 'month' | 'win_loses';
 export interface StatisticFilters {
     tournament_id?: number;
+    tournament_season_id?: number;
     tournament_team_id?: number;
     tournament_team_user_id?: number;
     team_id?: number;
@@ -43,12 +45,13 @@ export interface StatisticFilters {
 export interface TournamentEventsListFilter {
     event?: TournamentEventTypes;
     search?: string;
+    tournamentTour?: number;
 }
 export declare class TournamentApi {
     private httpClient;
     private configService;
     constructor(httpClient: HttpClient, configService: ConfigService);
-    getByAlias(alias: string): Promise<Tournament>;
+    getByAlias(leagueId: number, alias: string): Promise<Tournament>;
     getNews(tournamentId: number): Promise<TournamentNews[]>;
     getEvents(tournamentId: number, page: number, size: number, filters?: TournamentEventsListFilter): Promise<PaginatedResponse<TournamentEvent[]>>;
     getTournamentStages(tournamentId: number): Promise<TournamentStage[]>;

package/api/tournament-season-api.d.ts

@@ -8,14 +8,16 @@ import { PaginatedResponse } from './paginated-response.interface';
 import { TournamentEvent } from '../models/tournament-event';
 import { GameMediaFilters } from './media-api';
 import { TournamentTeam } from '../models/tournament-team';
+import { GameTimelineStages } from '../models/game-timeline-stages';
 export declare class TournamentSeasonApi {
     private httpClient;
     private configService;
     constructor(httpClient: HttpClient, configService: ConfigService);
-    getByAlias(alias: string): Promise<TournamentSeason>;
+    getByAlias(leagueId: number, alias: string): Promise<TournamentSeason>;
     getTournaments(seasonId: number): Promise<Tournament[]>;
     getGames(seasonId: number, page: number, size: number, filters: TournamentGamesFilters): Promise<PaginatedResponse<Game[]>>;
     getEvents(seasonId: number, page: number, size: number, filters?: TournamentEventsListFilter): Promise<PaginatedResponse<TournamentEvent[]>>;
     getGameMedia(seasonId: number, page: number, size: number, filters: GameMediaFilters): Promise<PaginatedResponse<Game[]>>;
     getTeams(seasonId: number): Promise<TournamentTeam[]>;
+    getGamesStages(seasonId: number): Promise<GameTimelineStages>;
 }

package/bundles/mtgame-core.umd.js

@@ -1092,6 +1092,12 @@
         return League;
     }(BaseModel));
 
+
+    (function (TournamentSeasonStatuses) {
+        TournamentSeasonStatuses[TournamentSeasonStatuses["open"] = 0] = "open";
+        TournamentSeasonStatuses[TournamentSeasonStatuses["in_progress"] = 1] = "in_progress";
+        TournamentSeasonStatuses[TournamentSeasonStatuses["closed"] = 2] = "closed";
+    })(exports.TournamentSeasonStatuses || (exports.TournamentSeasonStatuses = {}));
     var TournamentSeason = /** @class */ (function (_super) {
         __extends(TournamentSeason, _super);
         function TournamentSeason() {
@@ -1114,11 +1120,13 @@
                     logo: 'logo',
                     cover: 'cover',
                     preview_image: 'previewImage',
+                    status: 'status',
                 },
                 relation: {
                     logo: File,
                     cover: File,
-                    previewImage: File
+                    previewImage: File,
+                    status: enumField(exports.TournamentSeasonStatuses),
                 }
             })
         ], TournamentSeason);
@@ -1303,6 +1311,8 @@
                     closest_game_datetime: 'closestGameDatetime',
                     status: 'status',
                     team_winner: 'teamWinner',
+                    team_second: 'teamSecond',
+                    team_third: 'teamThird',
                     season: 'season',
                 },
                 relation: {
@@ -1317,6 +1327,8 @@
                     league: League,
                     status: enumField(exports.TournamentStatuses),
                     teamWinner: TournamentTeamWinner,
+                    teamSecond: TournamentTeamWinner,
+                    teamThird: TournamentTeamWinner,
                     season: TournamentSeason,
                 }
             })
@@ -1746,6 +1758,7 @@
                     tournament: 'tournament',
                     team: 'team',
                     group: 'group',
+                    final_standing: 'finalStanding',
                     games_count: 'gamesCount',
                     won_games_count: 'wonGamesCount',
                     draw_games_count: 'drawGamesCount',
@@ -3165,6 +3178,9 @@
                         if (filters.search) {
                             params = params.set('search', filters.search);
                         }
+                        if (filters.tournamentTour) {
+                            params = params.set('tournament_tour', filters.tournamentTour.toString());
+                        }
                     }
                     return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/events/", { params: params, observe: 'response' }).pipe(operators.map(function (result) { return ({
                             total: +result.headers.get('X-Page-Count'),
@@ -3182,7 +3198,7 @@
         };
         LeagueApi.prototype.getGames = function (leagueId, page, size, filters) {
             return __awaiter(this, void 0, void 0, function () {
-                var params;
+                var params, statuses;
                 return __generator(this, function (_a) {
                     params = new http.HttpParams().set('page', page.toString());
                     if (size) {
@@ -3203,6 +3219,10 @@
                     if (filters.status) {
                         params = params.set('status', exports.GameStatuses[filters.status]);
                     }
+                    if (filters.statuses) {
+                        statuses = filters.statuses.map(function (i) { return exports.GameStatuses[i]; });
+                        params = params.set('statuses', statuses.join(','));
+                    }
                     return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/games/", { params: params, observe: 'response' }).pipe(operators.map(function (result) { return ({
                             total: +result.headers.get('X-Page-Count'),
                             data: Game.toFront(result.body)
@@ -3210,6 +3230,17 @@
                 });
             });
         };
+        LeagueApi.prototype.getSeasons = function (leagueId, notClosed) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('not_closed', notClosed ? '1' : '');
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/tournament_seasons/", { params: params })
+                            .pipe(operators.map(function (result) { return TournamentSeason.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
         LeagueApi.ctorParameters = function () { return [
             { type: http.HttpClient },
             { type: ConfigService }
@@ -3226,10 +3257,13 @@
             this.httpClient = httpClient;
             this.configService = configService;
         }
-        LeagueNewsApi.prototype.getLeagueNewsList = function (leagueId) {
+        LeagueNewsApi.prototype.getLeagueNewsList = function (leagueId, page, size) {
             return __awaiter(this, void 0, void 0, function () {
+                var params;
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/news/", { observe: 'response' })
+                    params = new http.HttpParams().set('page', page.toString())
+                        .set('size', size.toString());
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/news/", { params: params, observe: 'response' })
                             .pipe(operators.map(function (response) { return ({
                             total: +response.headers.get('X-Page-Count'),
                             data: LeagueNews.toFront(response.body)
@@ -3247,6 +3281,15 @@
                 });
             });
         };
+        LeagueNewsApi.prototype.getMainLeagueNewsList = function (leagueId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/news/?is_main=true")
+                            .pipe(operators.map(function (response) { return LeagueNews.toFront(response); }))
+                            .toPromise()];
+                });
+            });
+        };
         LeagueNewsApi.prototype.getNewsById = function (newsId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
@@ -3368,6 +3411,9 @@
                     if (filters.mediaType) {
                         params = params.set('media_type', filters.mediaType);
                     }
+                    if (filters.sort) {
+                        params = params.set('sort', filters.sort);
+                    }
                     return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/media/", { params: params, observe: 'response' })
                             .pipe(operators.map(function (response) { return ({
                             total: +response.headers.get('X-Page-Count'),
@@ -5207,10 +5253,10 @@
             this.httpClient = httpClient;
             this.configService = configService;
         }
-        TournamentApi.prototype.getByAlias = function (alias) {
+        TournamentApi.prototype.getByAlias = function (leagueId, alias) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + alias + "/")
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/tournaments/" + alias + "/")
                             .pipe(operators.map(function (result) { return Tournament.toFront(result); }))
                             .toPromise()];
                 });
@@ -5238,6 +5284,9 @@
                         if (filters.search) {
                             params = params.set('search', filters.search);
                         }
+                        if (filters.tournamentTour) {
+                            params = params.set('tournament_tour', filters.tournamentTour.toString());
+                        }
                     }
                     return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/events/", { params: params, observe: 'response' })
                             .pipe(operators.map(function (result) { return ({
@@ -5281,7 +5330,7 @@
         TournamentApi.prototype.getGames = function (tournamentId, page, size, filters) {
             if (filters === void 0) { filters = {}; }
             return __awaiter(this, void 0, void 0, function () {
-                var params;
+                var params, statuses;
                 return __generator(this, function (_a) {
                     params = new http.HttpParams().set('page', page.toString());
                     if (size) {
@@ -5302,6 +5351,10 @@
                     if (filters.status) {
                         params = params.set('status', exports.GameStatuses[filters.status]);
                     }
+                    if (filters.statuses) {
+                        statuses = filters.statuses.map(function (i) { return exports.GameStatuses[i]; });
+                        params = params.set('statuses', statuses.join(','));
+                    }
                     return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/games/", { params: params, observe: 'response' })
                             .pipe(operators.map(function (result) { return ({
                             total: +result.headers.get('X-Page-Count'),
@@ -5589,10 +5642,10 @@
             this.httpClient = httpClient;
             this.configService = configService;
         }
-        TournamentSeasonApi.prototype.getByAlias = function (alias) {
+        TournamentSeasonApi.prototype.getByAlias = function (leagueId, alias) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_season/" + alias + "/").pipe(operators.map(function (result) { return TournamentSeason.toFront(result); })).toPromise()];
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/league/" + leagueId + "/tournament_seasons/" + alias + "/").pipe(operators.map(function (result) { return TournamentSeason.toFront(result); })).toPromise()];
                 });
             });
         };
@@ -5605,7 +5658,7 @@
         };
         TournamentSeasonApi.prototype.getGames = function (seasonId, page, size, filters) {
             return __awaiter(this, void 0, void 0, function () {
-                var params;
+                var params, statuses;
                 return __generator(this, function (_a) {
                     params = new http.HttpParams().set('page', page.toString());
                     if (size) {
@@ -5626,6 +5679,10 @@
                     if (filters.status) {
                         params = params.set('status', exports.GameStatuses[filters.status]);
                     }
+                    if (filters.statuses) {
+                        statuses = filters.statuses.map(function (i) { return exports.GameStatuses[i]; });
+                        params = params.set('statuses', statuses.join(','));
+                    }
                     return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_season/" + seasonId + "/games/", { params: params, observe: 'response' }).pipe(operators.map(function (result) { return ({
                             total: +result.headers.get('X-Page-Count'),
                             data: Game.toFront(result.body)
@@ -5646,6 +5703,9 @@
                         if (filters.search) {
                             params = params.set('search', filters.search);
                         }
+                        if (filters.tournamentTour) {
+                            params = params.set('tournament_tour', filters.tournamentTour.toString());
+                        }
                     }
                     return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_season/" + seasonId + "/events/", { params: params, observe: 'response' })
                             .pipe(operators.map(function (result) { return ({
@@ -5698,6 +5758,15 @@
                 });
             });
         };
+        TournamentSeasonApi.prototype.getGamesStages = function (seasonId) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_season/" + seasonId + "/games_stages/")
+                            .pipe(operators.map(function (data) { return GameTimelineStages.toFront(data); }))
+                            .toPromise()];
+                });
+            });
+        };
         TournamentSeasonApi.ctorParameters = function () { return [
             { type: http.HttpClient },
             { type: ConfigService }