@mtgame/core 0.1.92 → 0.1.93

package/api/tournament-api.d.ts

@@ -19,6 +19,7 @@ import { LeagueUserPermissions } from '../models/league-user';
 import { HandballStatistic } from '../models/handball-statistic';
 import { RugbyStatistic } from '../models/rugby-statistic';
 import { TournamentGroup } from '../models/tournament-group';
+import { TeamAchievement } from '../models/team-achievement';
 export interface TournamentGamesFilters {
     tournamentIds?: number[];
     tournamentSeasonId?: number;
@@ -101,6 +102,7 @@ export declare class TournamentApi {
     getGroups(tournamentId: number): Promise<TournamentGroup[]>;
     getTeams(tournamentId: number, groupId?: number): Promise<TournamentTeam[]>;
     getStageTeams(tournamentId: number): Promise<TournamentStageTeam[]>;
+    getTeamsAchievements(tournamentId: number): Promise<TeamAchievement[]>;
     getTeamById(tournamentTeamId: number): Promise<TournamentTeam>;
     getUserById(userId: number): Promise<TournamentTeamUser>;
     getUserGames(tournamentUserId: number): Promise<Game[]>;

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

@@ -4,12 +4,14 @@ import { TournamentGroup } from '../models/tournament-group';
 import { Playoff } from '../models/playoff';
 import { TournamentStageTeam } from '../models/tournament-stage-team';
 import { ConfigService } from '../services/config.service';
+import { TeamAchievement } from '../models/team-achievement';
 export declare class TournamentStageApi {
     private httpClient;
     private configService;
     constructor(httpClient: HttpClient, configService: ConfigService);
     getById(id: number): Promise<TournamentStage>;
     getGroups(stageId: number): Promise<TournamentGroup[]>;
+    getTeamsAchievements(stageId: number): Promise<TeamAchievement[]>;
     getPlayoffs(stageId: number): Promise<Playoff[]>;
     getTeams(stageId: number): Promise<TournamentStageTeam[]>;
 }

package/bundles/mtgame-core.umd.js

@@ -5945,6 +5945,74 @@
         })
     ], exports.RugbyStatistic);
 
+    exports.AchievementTypes = void 0;
+    (function (AchievementTypes) {
+        AchievementTypes[AchievementTypes["by_game"] = 1] = "by_game";
+        AchievementTypes[AchievementTypes["by_stage"] = 2] = "by_stage";
+    })(exports.AchievementTypes || (exports.AchievementTypes = {}));
+    exports.Achievement = /** @class */ (function (_super) {
+        __extends(Achievement, _super);
+        function Achievement() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Achievement.toFront = function (data) { };
+        Achievement.toBack = function (data) { };
+        return Achievement;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], exports.Achievement, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], exports.Achievement, "toBack", null);
+    exports.Achievement = __decorate([
+        ModelInstance({
+            mappingFields: {
+                id: 'id',
+                name: 'name',
+                alias: 'type',
+                value: 'value',
+                type: 'type',
+            },
+            relation: {
+                type: enumField(exports.AchievementTypes),
+            }
+        })
+    ], exports.Achievement);
+
+    exports.TeamAchievement = /** @class */ (function (_super) {
+        __extends(TeamAchievement, _super);
+        function TeamAchievement() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        TeamAchievement.toFront = function (data) { };
+        TeamAchievement.toBack = function (data) { };
+        return TeamAchievement;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], exports.TeamAchievement, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], exports.TeamAchievement, "toBack", null);
+    exports.TeamAchievement = __decorate([
+        ModelInstance({
+            mappingFields: {
+                id: 'id',
+                achievement: 'achievement',
+                tournament_stage: 'tournamentStage',
+                team_id: 'teamId',
+                game: 'game',
+                mt_points: 'mtPoints',
+            },
+            relation: {
+                achievement: exports.Achievement,
+                tournamentStage: exports.TournamentStage,
+                game: exports.Game
+            }
+        })
+    ], exports.TeamAchievement);
+
     var TournamentApi = /** @class */ (function () {
         function TournamentApi(httpClient, configService) {
             this.httpClient = httpClient;
@@ -6098,6 +6166,15 @@
                 });
             });
         };
+        TournamentApi.prototype.getTeamsAchievements = function (tournamentId) {
+            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/" + tournamentId + "/achievements/")
+                            .pipe(operators.map(function (result) { return exports.TeamAchievement.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
         TournamentApi.prototype.getTeamById = function (tournamentTeamId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
@@ -8920,6 +8997,15 @@
                 });
             });
         };
+        TournamentStageApi.prototype.getTeamsAchievements = function (stageId) {
+            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_stage/" + stageId + "/achievements/")
+                            .pipe(operators.map(function (result) { return exports.TeamAchievement.toFront(result); }))
+                            .toPromise()];
+                });
+            });
+        };
         TournamentStageApi.prototype.getPlayoffs = function (stageId) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {