@mtgame/core 0.2.68 → 0.2.70

package/api/tournament-api.d.ts

@@ -32,6 +32,7 @@ import { GameWaterpoloPosition } from '../models/waterpolo-profile';
 import { GameBasketballPosition } from '../models/basketball-profile';
 import { GameVolleyballPosition } from '../models/volleyball-profile';
 import { GameRugbyPosition } from '../models/rugby-profile';
+import { WrestballStatistic } from '../models/wrestball-statistic';
 export interface TournamentGamesFilters {
     tournamentIds?: number[];
     tournamentSeasonId?: number;
@@ -165,6 +166,7 @@ export declare class TournamentApi {
     getHandballStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<HandballStatistic[]>>;
     getRugbyStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<RugbyStatistic[]>>;
     getWaterpoloStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<WaterpoloStatistic[]>>;
+    getWrestballStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<WrestballStatistic[]>>;
     getTournamentTeamUsers(tournamentTeamId: number, includes?: string[]): Promise<TournamentTeamUser[]>;
     myPermission(tournamentId: number): Promise<LeagueUserPermissions[]>;
     getTournamentTeamTournaments(tournamentTeamId: number): Promise<Tournament[]>;

package/bundles/mtgame-core.umd.js

@@ -1620,6 +1620,10 @@
         WaterpoloStatisticTypes[WaterpoloStatisticTypes["standard"] = 1] = "standard";
         WaterpoloStatisticTypes[WaterpoloStatisticTypes["light"] = 2] = "light";
     })(exports.WaterpoloStatisticTypes || (exports.WaterpoloStatisticTypes = {}));
+    exports.WrestballStatisticTypes = void 0;
+    (function (WrestballStatisticTypes) {
+        WrestballStatisticTypes[WrestballStatisticTypes["standard"] = 1] = "standard";
+    })(exports.WrestballStatisticTypes || (exports.WrestballStatisticTypes = {}));
     exports.GameTimeTypes = void 0;
     (function (GameTimeTypes) {
         GameTimeTypes[GameTimeTypes["clean"] = 1] = "clean";
@@ -2426,6 +2430,49 @@
         })
     ], exports.WaterpoloGameConfig);
 
+    exports.ɵa = /** @class */ (function (_super) {
+        __extends(WrestballGameConfig, _super);
+        function WrestballGameConfig() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        WrestballGameConfig.toFront = function (data) { };
+        WrestballGameConfig.toBack = function (data) { };
+        return WrestballGameConfig;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], exports.ɵa, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], exports.ɵa, "toBack", null);
+    exports.ɵa = __decorate([
+        ModelInstance({
+            mappingFields: {
+                periods_count: 'periodsCount',
+                period_time: 'periodTime',
+                game_up_to_score: 'gameUpToScore',
+                overtime_type: 'overtimeType',
+                overtime_time: 'overtimeTime',
+                overtime_score: 'overtimeScore',
+                max_game_players: 'maxGamePlayers',
+                timeout_count: 'timeoutCount',
+                overtime_timeout_count: 'overtimeTimeoutCount',
+                timeout_time: 'timeoutTime',
+                statistic_type: 'statisticType',
+                shot_clock_enabled: 'shotClockEnabled',
+                game_time_type: 'gameTimeType',
+                timer_type: 'timerType',
+                wrestler_scrums_count: 'wrestlerScrumsCount'
+            },
+            relation: {
+                overtimeType: enumField(exports.OvertimeTypes),
+                statisticType: enumField(exports.WrestballStatisticTypes),
+                gameTimeType: enumField(exports.GameTimeTypes),
+                timerType: enumField(exports.TimerTypes),
+            }
+        })
+    ], exports.ɵa);
+
     exports.GameStatuses = void 0;
     (function (GameStatuses) {
         GameStatuses[GameStatuses["open"] = 1] = "open";
@@ -2609,6 +2656,22 @@
             enumerable: false,
             configurable: true
         });
+        Object.defineProperty(Game.prototype, "wrestballGameConfig", {
+            get: function () {
+                if (this._wrestballGameConfig && this._wrestballGameConfig.periodsCount) {
+                    return this._wrestballGameConfig;
+                }
+                if (this.gameConfig) {
+                    this._wrestballGameConfig = exports.ɵa.toFront(this.gameConfig);
+                }
+                return this._wrestballGameConfig;
+            },
+            set: function (value) {
+                this._wrestballGameConfig = value;
+            },
+            enumerable: false,
+            configurable: true
+        });
         Object.defineProperty(Game.prototype, "scoreByPeriodList", {
             get: function () {
                 var _this = this;
@@ -2733,6 +2796,7 @@
                 handball_game_config: 'handballGameConfig',
                 rugby_game_config: 'rugbyGameConfig',
                 waterpolo_game_config: 'waterpoloGameConfig',
+                wrestball_game_config: 'wrestballGameConfig',
                 score_by_period: 'scoreByPeriod',
                 playoff_stage: 'playoffStage',
                 playoff_round: 'playoffRound',
@@ -2761,6 +2825,7 @@
                 handballGameConfig: exports.HandballGameConfig,
                 rugbyGameConfig: exports.RugbyGameConfig,
                 waterpoloGameConfig: exports.WaterpoloGameConfig,
+                wrestballGameConfig: exports.ɵa,
                 tournamentPlayoff: exports.Playoff,
                 tournamentCourt: exports.LeagueCourt,
                 media: listField(exports.MediaItem),
@@ -7339,6 +7404,157 @@
         })
     ], exports.TournamentRound);
 
+    var WrestballStatistic = /** @class */ (function (_super) {
+        __extends(WrestballStatistic, _super);
+        function WrestballStatistic() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(WrestballStatistic.prototype, "totalFouls", {
+            get: function () {
+                return Math.floor(10 * ((this.personalFouls || 0))) / 10;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WrestballStatistic.prototype, "gameMinutes", {
+            get: function () {
+                return Math.floor(this.gameTime / 60);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WrestballStatistic.prototype, "tournamentTeamPoints", {
+            get: function () {
+                return this.tournamentTeam && this.tournamentTeam.points;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WrestballStatistic.prototype, "onePointsPercent", {
+            get: function () {
+                if (!this.onePointsMade || !this.onePointAttempts) {
+                    return 0;
+                }
+                return Math.round(1000 * this.onePointsMade / this.onePointAttempts) / 10;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WrestballStatistic.prototype, "twoPointsPercent", {
+            get: function () {
+                if (!this.twoPointsMade || !this.twoPointAttempts) {
+                    return 0;
+                }
+                return Math.round(1000 * this.twoPointsMade / this.twoPointAttempts) / 10;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WrestballStatistic.prototype, "threePointsPercent", {
+            get: function () {
+                if (!this.threePointsMade || !this.threePointAttempts) {
+                    return 0;
+                }
+                return Math.round(1000 * this.threePointsMade / this.threePointAttempts) / 10;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WrestballStatistic.prototype, "freeThrowsPercent", {
+            get: function () {
+                if (!this.freeThrowsMade || !this.freeThrowAttempts) {
+                    return 0;
+                }
+                return Math.round(1000 * this.freeThrowsMade / this.freeThrowAttempts) / 10;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(WrestballStatistic.prototype, "totalRebounds", {
+            get: function () {
+                return Math.floor(10 * ((this.offensiveRebounds || 0) + (this.defensiveRebounds || 0))) / 10;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        WrestballStatistic.toFront = function (data) { };
+        WrestballStatistic.toBack = function (data) { };
+        return WrestballStatistic;
+    }(BaseModel));
+    __decorate([
+        ToFrontHook
+    ], WrestballStatistic, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], WrestballStatistic, "toBack", null);
+    WrestballStatistic = __decorate([
+        ModelInstance({
+            mappingFields: {
+                league_player: 'leaguePlayer',
+                tournament_team_user: 'tournamentTeamUser',
+                team: 'team',
+                team_user: 'teamUser',
+                user: 'user',
+                tournament_team: 'tournamentTeam',
+                month: 'month',
+                win_lose: 'winLose',
+                games_count: 'gamesCount',
+                won_games_count: 'wonGamesCount',
+                team_score_sum: 'teamScoreSum',
+                team_missed_sum: 'teamMissedSum',
+                tournament_points: 'tournamentPoints',
+                points: 'points',
+                two_points_made: 'twoPointsMade',
+                three_points_made: 'threePointsMade',
+                free_throws_made: 'freeThrowsMade',
+                one_points_made: 'onePointsMade',
+                two_point_attempts: 'twoPointAttempts',
+                three_point_attempts: 'threePointAttempts',
+                free_throw_attempts: 'freeThrowAttempts',
+                one_point_attempts: 'onePointAttempts',
+                two_point_percent: 'twoPointPercent',
+                three_point_percent: 'threePointPercent',
+                free_throw_percent: 'freeThrowPercent',
+                one_point_percent: 'onePointPercent',
+                assists: 'assists',
+                blocks: 'blocks',
+                rebounds: 'rebounds',
+                offensive_rebounds: 'offensiveRebounds',
+                defensive_rebounds: 'defensiveRebounds',
+                steals: 'steals',
+                turnovers: 'turnovers',
+                personal_fouls: 'personalFouls',
+                drawn_fouls: 'drawnFouls',
+                wrestler_scrums_won: 'wrestlerScrumsWon',
+                wrestler_scrums_lost: 'wrestlerScrumsLost',
+                wrestler_scrums_tie: 'wrestlerScrumsTie',
+                wrestler_scrum_points: 'wrestlerScrumPoints',
+                scrums_won: 'scrumsWon',
+                scrums_lost: 'scrumsLost',
+                scrums_tie: 'scrumsTie',
+                scrum_points: 'scrumPoints',
+                yellow_cards: 'yellowCards',
+                red_cards: 'redCards',
+                wrestler_scrums: 'wrestlerScrums',
+                wrestler_scrums_won_percent: 'wrestlerScrumsWonPercent',
+                scrums: 'scrums',
+                scrums_won_percent: 'scrumsWonPercent',
+                game_time: 'gameTime',
+                newbie: 'newbie',
+                rank: 'rank',
+            },
+            relation: {
+                leaguePlayer: exports.LeaguePlayer,
+                tournamentTeamUser: exports.TournamentTeamUser,
+                team: exports.Team,
+                teamUser: exports.TeamUser,
+                user: exports.User,
+                tournamentTeam: exports.TournamentTeam,
+                month: DateField
+            }
+        })
+    ], WrestballStatistic);
+
     var TournamentApi = /** @class */ (function () {
         function TournamentApi(httpClient, configService) {
             this.httpClient = httpClient;
@@ -7821,6 +8037,19 @@
                 });
             });
         };
+        TournamentApi.prototype.getWrestballStatistic = function (filters) {
+            return __awaiter(this, void 0, void 0, function () {
+                var params;
+                return __generator(this, function (_a) {
+                    params = new i1.HttpParams();
+                    params = applyStatisticFilters(filters, params);
+                    return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/wrestball_statistic/", { params: params, observe: 'response' }).pipe(operators.map(function (result) { return ({
+                            total: +result.headers.get('X-Page-Count'),
+                            data: WrestballStatistic.toFront(result.body)
+                        }); })).toPromise()];
+                });
+            });
+        };
         TournamentApi.prototype.getTournamentTeamUsers = function (tournamentTeamId, includes) {
             if (includes === void 0) { includes = []; }
             return __awaiter(this, void 0, void 0, function () {