@mtgame/core 0.0.36 → 0.0.38

package/api/basketball-game-api.d.ts

@@ -15,4 +15,5 @@ export declare class BasketballGameApi {
     getUserStatistic(gameId: number): Promise<BasketballGameStatistic[]>;
     getLogs(gameId: number): Promise<BasketballGameLog[]>;
     downloadProtocol(gameId: number, fileType: 'xlsx' | 'pdf'): Promise<any>;
+    downloadFibaProtocol(gameId: number, fileType: 'xlsx' | 'pdf'): Promise<any>;
 }

package/api/league-api.d.ts

@@ -2,9 +2,11 @@ import { HttpClient } from '@angular/common/http';
 import { League } from '../models/league';
 import { Tournament } from '../models/tournament';
 import { ConfigService } from '../services/config.service';
-import { TournamentEventsListFilter } from './tournament-api';
+import { TournamentEventsListFilter, TournamentGamesFilters } from './tournament-api';
 import { PaginatedResponse } from './paginated-response.interface';
 import { TournamentEvent } from '../models/tournament-event';
+import { TournamentSeason } from '../models/tournament-season';
+import { Game } from '../models/game';
 export declare class LeagueApi {
     private httpClient;
     private configService;
@@ -13,4 +15,6 @@ export declare class LeagueApi {
     getByDomain(domain: string): Promise<League>;
     getTournaments(leagueId: number): Promise<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/api/media-api.d.ts

@@ -11,6 +11,9 @@ export interface GameMediaFilters {
     playoffId?: number;
     status?: GameStatuses;
 }
+export interface MediaFilters {
+    mediaType?: 'photo' | 'video';
+}
 export declare class MediaApi {
     private httpClient;
     private configService;
@@ -18,6 +21,7 @@ export declare class MediaApi {
     getMedia(mediaId: number): Promise<MediaItem>;
     getTournamentGameMedia(tournamentId: number, page: number, size: number, filters?: GameMediaFilters): Promise<PaginatedResponse<Game[]>>;
     getLeagueGameMedia(leagueId: number, page: number, size: number, filters?: GameMediaFilters): Promise<PaginatedResponse<Game[]>>;
+    getLeagueMedia(leagueId: number, page: number, size: number, filters?: MediaFilters): Promise<PaginatedResponse<MediaItem[]>>;
     getGameMediaById(gameId: number): Promise<Game>;
     getGameMedia(gameId: number): Promise<MediaItem[]>;
     createZip(mediaIds: number[]): Promise<any>;

package/api/public-api.d.ts

@@ -14,6 +14,7 @@ export * from './team-api';
 export * from './team-event-api';
 export { TournamentApi, TournamentGamesFilters, TournamentEventsListFilter, StatisticGroupByTypes, StatisticFilters } from './tournament-api';
 export { TournamentJoinApi } from './tournament-join-api';
+export * from './tournament-season-api';
 export { TournamentStageApi } from './tournament-stage-api';
 export * from './user-api';
 export { VolleyballGameApi } from './volleyball-game-api';

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

@@ -0,0 +1,21 @@
+import { HttpClient } from '@angular/common/http';
+import { TournamentSeason } from '../models/tournament-season';
+import { ConfigService } from '../services/config.service';
+import { Game } from '../models/game';
+import { Tournament } from '../models/tournament';
+import { TournamentEventsListFilter, TournamentGamesFilters } from './tournament-api';
+import { PaginatedResponse } from './paginated-response.interface';
+import { TournamentEvent } from '../models/tournament-event';
+import { GameMediaFilters } from './media-api';
+import { TournamentTeam } from '../models/tournament-team';
+export declare class TournamentSeasonApi {
+    private httpClient;
+    private configService;
+    constructor(httpClient: HttpClient, configService: ConfigService);
+    getByAlias(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[]>;
+}

package/bundles/mtgame-core.umd.js

@@ -1092,6 +1092,39 @@
         return League;
     }(BaseModel));
 
+    var TournamentSeason = /** @class */ (function (_super) {
+        __extends(TournamentSeason, _super);
+        function TournamentSeason() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        TournamentSeason.toFront = function (data) { };
+        TournamentSeason.toBack = function (data) { };
+        __decorate([
+            ToFrontHook
+        ], TournamentSeason, "toFront", null);
+        __decorate([
+            ToBackHook
+        ], TournamentSeason, "toBack", null);
+        TournamentSeason = __decorate([
+            ModelInstance({
+                mappingFields: {
+                    id: 'id',
+                    name: 'name',
+                    alias: 'alias',
+                    logo: 'logo',
+                    cover: 'cover',
+                    preview_image: 'previewImage',
+                },
+                relation: {
+                    logo: File,
+                    cover: File,
+                    previewImage: File
+                }
+            })
+        ], TournamentSeason);
+        return TournamentSeason;
+    }(BaseModel));
+
 
     (function (TournamentTypes) {
         TournamentTypes["group"] = "group";
@@ -1269,7 +1302,8 @@
                     teams_count: 'teamsCount',
                     closest_game_datetime: 'closestGameDatetime',
                     status: 'status',
-                    team_winner: 'teamWinner'
+                    team_winner: 'teamWinner',
+                    season: 'season',
                 },
                 relation: {
                     logo: File,
@@ -1282,7 +1316,8 @@
                     date: DateTimeField,
                     league: League,
                     status: enumField(exports.TournamentStatuses),
-                    teamWinner: TournamentTeamWinner
+                    teamWinner: TournamentTeamWinner,
+                    season: TournamentSeason,
                 }
             })
         ], Tournament);
@@ -1595,6 +1630,7 @@
                     tournament_court: 'tournamentCourt',
                     media_count: 'mediaCount',
                     media: 'media',
+                    tournament: 'tournament',
                 },
                 relation: {
                     status: enumField(exports.GameStatuses),
@@ -1607,6 +1643,7 @@
                     hockeyGameConfig: HockeyGameConfig,
                     tournamentCourt: LeagueCourt,
                     media: listField(MediaItem),
+                    tournament: Tournament,
                 }
             })
         ], Game);
@@ -2397,6 +2434,14 @@
                 });
             });
         };
+        BasketballGameApi.prototype.downloadFibaProtocol = function (gameId, fileType) {
+            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_basketball_game/" + gameId + "/game_protocol_fiba/?file_type=" + fileType, { responseType: 'blob' })
+                            .toPromise()];
+                });
+            });
+        };
         BasketballGameApi.ctorParameters = function () { return [
             { type: http.HttpClient },
             { type: ConfigService }
@@ -2633,6 +2678,7 @@
                     is_goalie: 'isGoalie',
                     penalty_type: 'penaltyType',
                     penalized_game_user_id: 'penalizedGameUserId',
+                    mutual_penalty: 'mutualPenalty',
                 },
                 relation: {
                     datetime: DateTimeField,
@@ -3127,6 +3173,43 @@
                 });
             });
         };
+        LeagueApi.prototype.getTournamentSeasons = 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 + "/tournament_seasons/").pipe(operators.map(function (result) { return TournamentSeason.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        LeagueApi.prototype.getGames = function (leagueId, page, size, filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('page', page.toString());
+                    if (size) {
+                        params = params.set('size', size.toString());
+                    }
+                    if (filters.tournamentStageId) {
+                        params = params.set('tournament_stage_id', filters.tournamentStageId.toString());
+                    }
+                    if (filters.tournamentTour) {
+                        params = params.set('tournament_tour', filters.tournamentTour.toString());
+                    }
+                    if (filters.playoffStage) {
+                        params = params.set('playoff_stage', filters.playoffStage.toString());
+                    }
+                    if (filters.teamId) {
+                        params = params.set('team_id', filters.teamId.toString());
+                    }
+                    if (filters.status) {
+                        params = params.set('status', exports.GameStatuses[filters.status]);
+                    }
+                    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)
+                        }); })).toPromise()];
+                });
+            });
+        };
         LeagueApi.ctorParameters = function () { return [
             { type: http.HttpClient },
             { type: ConfigService }
@@ -3276,6 +3359,23 @@
                 });
             });
         };
+        MediaApi.prototype.getLeagueMedia = function (leagueId, page, size, filters) {
+            if (filters === void 0) { filters = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('page', page.toString()).set('size', size.toString());
+                    if (filters.mediaType) {
+                        params = params.set('media_type', filters.mediaType);
+                    }
+                    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'),
+                            data: MediaItem.toFront(response.body)
+                        }); })).toPromise()];
+                });
+            });
+        };
         MediaApi.prototype.getGameMediaById = function (gameId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
@@ -5484,6 +5584,131 @@
         return TournamentJoinApi;
     }());
 
+    var TournamentSeasonApi = /** @class */ (function () {
+        function TournamentSeasonApi(httpClient, configService) {
+            this.httpClient = httpClient;
+            this.configService = configService;
+        }
+        TournamentSeasonApi.prototype.getByAlias = function (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()];
+                });
+            });
+        };
+        TournamentSeasonApi.prototype.getTournaments = 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 + "/tournaments/").pipe(operators.map(function (result) { return Tournament.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        TournamentSeasonApi.prototype.getGames = function (seasonId, page, size, filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('page', page.toString());
+                    if (size) {
+                        params = params.set('size', size.toString());
+                    }
+                    if (filters.tournamentStageId) {
+                        params = params.set('tournament_stage_id', filters.tournamentStageId.toString());
+                    }
+                    if (filters.tournamentTour) {
+                        params = params.set('tournament_tour', filters.tournamentTour.toString());
+                    }
+                    if (filters.playoffStage) {
+                        params = params.set('playoff_stage', filters.playoffStage.toString());
+                    }
+                    if (filters.teamId) {
+                        params = params.set('team_id', filters.teamId.toString());
+                    }
+                    if (filters.status) {
+                        params = params.set('status', exports.GameStatuses[filters.status]);
+                    }
+                    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)
+                        }); })).toPromise()];
+                });
+            });
+        };
+        TournamentSeasonApi.prototype.getEvents = function (seasonId, page, size, filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('page', page.toString())
+                        .set('size', size.toString());
+                    if (filters) {
+                        if (filters.event) {
+                            params = params.set('event', exports.TournamentEventTypes[filters.event]);
+                        }
+                        if (filters.search) {
+                            params = params.set('search', filters.search);
+                        }
+                    }
+                    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 ({
+                            total: +result.headers.get('X-Page-Count'),
+                            data: TournamentEvent.toFront(result.body)
+                        }); }))
+                            .toPromise()];
+                });
+            });
+        };
+        TournamentSeasonApi.prototype.getGameMedia = function (seasonId, page, size, filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new http.HttpParams().set('page', page.toString()).set('size', size.toString());
+                    if (filters) {
+                        if (filters.tournamentTour) {
+                            params = params.set('tournament_tour', filters.tournamentTour.toString());
+                        }
+                        if (filters.teamId) {
+                            params = params.set('team_id', filters.teamId.toString());
+                        }
+                        if (filters.tournamentStageId) {
+                            params = params.set('tournament_stage_id', filters.tournamentStageId.toString());
+                        }
+                        if (filters.playoffId) {
+                            params = params.set('playoff_id', filters.playoffId.toString());
+                        }
+                        if (filters.playoffStage) {
+                            params = params.set('playoff_stage', filters.playoffStage.toString());
+                        }
+                        if (filters.status) {
+                            params = params.set('status', exports.GameStatuses[filters.status]);
+                        }
+                    }
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament_season/" + seasonId + "/game_media/", { observe: 'response', params: params })
+                            .pipe(operators.map(function (response) {
+                            return {
+                                total: +response.headers.get('X-Page-Count'),
+                                data: Game.toFront(response.body)
+                            };
+                        })).toPromise()];
+                });
+            });
+        };
+        TournamentSeasonApi.prototype.getTeams = 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 + "/teams/").pipe(operators.map(function (result) { return TournamentTeam.toFront(result); })).toPromise()];
+                });
+            });
+        };
+        TournamentSeasonApi.ctorParameters = function () { return [
+            { type: http.HttpClient },
+            { type: ConfigService }
+        ]; };
+        TournamentSeasonApi.ɵprov = core.ɵɵdefineInjectable({ factory: function TournamentSeasonApi_Factory() { return new TournamentSeasonApi(core.ɵɵinject(http.HttpClient), core.ɵɵinject(ConfigService)); }, token: TournamentSeasonApi, providedIn: "root" });
+        TournamentSeasonApi = __decorate([
+            core.Injectable({ providedIn: 'root' })
+        ], TournamentSeasonApi);
+        return TournamentSeasonApi;
+    }());
+
     var TournamentStageApi = /** @class */ (function () {
         function TournamentStageApi(httpClient, configService) {
             this.httpClient = httpClient;
@@ -6857,6 +7082,8 @@
     exports.TournamentJoinData = TournamentJoinData;
     exports.TournamentJoinTeam = TournamentJoinTeam;
     exports.TournamentNews = TournamentNews;
+    exports.TournamentSeason = TournamentSeason;
+    exports.TournamentSeasonApi = TournamentSeasonApi;
     exports.TournamentSettings = TournamentSettings;
     exports.TournamentStage = TournamentStage;
     exports.TournamentStageApi = TournamentStageApi;