@mtgame/core 0.0.1

package/esm5/api/org-notification-api.js

@@ -0,0 +1,21 @@
+import { __decorate, __extends } from "tslib";
+import { Injectable } from '@angular/core';
+import { NotificationBaseApi } from './notification-base-api';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+var OrgNotificationApi = /** @class */ (function (_super) {
+    __extends(OrgNotificationApi, _super);
+    function OrgNotificationApi() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.apiUrl = '/org/api/v1';
+        return _this;
+    }
+    OrgNotificationApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function OrgNotificationApi_Factory() { return new OrgNotificationApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.ConfigService)); }, token: OrgNotificationApi, providedIn: "root" });
+    OrgNotificationApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], OrgNotificationApi);
+    return OrgNotificationApi;
+}(NotificationBaseApi));
+export { OrgNotificationApi };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JnLW5vdGlmaWNhdGlvbi1hcGkuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbXRnYW1lL2NvcmUvIiwic291cmNlcyI6WyJhcGkvb3JnLW5vdGlmaWNhdGlvbi1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7Ozs7QUFHOUQ7SUFBd0Msc0NBQW1CO0lBQTNEO1FBQUEscUVBRUM7UUFEVyxZQUFNLEdBQUcsYUFBYSxDQUFDOztLQUNsQzs7SUFGWSxrQkFBa0I7UUFEOUIsVUFBVSxDQUFDLEVBQUMsVUFBVSxFQUFFLE1BQU0sRUFBQyxDQUFDO09BQ3BCLGtCQUFrQixDQUU5Qjs2QkFORDtDQU1DLEFBRkQsQ0FBd0MsbUJBQW1CLEdBRTFEO1NBRlksa0JBQWtCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTm90aWZpY2F0aW9uQmFzZUFwaSB9IGZyb20gJy4vbm90aWZpY2F0aW9uLWJhc2UtYXBpJztcblxuQEluamVjdGFibGUoe3Byb3ZpZGVkSW46ICdyb290J30pXG5leHBvcnQgY2xhc3MgT3JnTm90aWZpY2F0aW9uQXBpIGV4dGVuZHMgTm90aWZpY2F0aW9uQmFzZUFwaSB7XG4gIHByb3RlY3RlZCBhcGlVcmwgPSAnL29yZy9hcGkvdjEnO1xufVxuIl19

package/esm5/api/paginated-response.interface.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFnaW5hdGVkLXJlc3BvbnNlLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BtdGdhbWUvY29yZS8iLCJzb3VyY2VzIjpbImFwaS9wYWdpbmF0ZWQtcmVzcG9uc2UuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFBhZ2luYXRlZFJlc3BvbnNlPFQ+IHtcbiAgdG90YWw6IG51bWJlcjtcbiAgZGF0YTogVDtcbn1cbiJdfQ==

package/esm5/api/public-api.js

@@ -0,0 +1,12 @@
+export { BasketballGameApi } from './basketball-game-api';
+export { LeagueApi } from './league-api';
+export { MediaApi } from './media-api';
+export * from './notification-api';
+export * from './notification-base-api';
+export * from './org-notification-api';
+export { ReferenceApi } from './reference-api';
+export { TournamentApi } from './tournament-api';
+export { TournamentJoinApi } from './tournament-join-api';
+export { TournamentStageApi } from './tournament-stage-api';
+export { VolleyballGameApi } from './volleyball-game-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BtdGdhbWUvY29yZS8iLCJzb3VyY2VzIjpbImFwaS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQzFELE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFDekMsT0FBTyxFQUFFLFFBQVEsRUFBb0IsTUFBTSxhQUFhLENBQUM7QUFDekQsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsd0JBQXdCLENBQUM7QUFFdkMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFDTCxhQUFhLEVBQ2QsTUFBTSxrQkFBa0IsQ0FBQztBQUMxQixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUMxRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUM1RCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IEJhc2tldGJhbGxHYW1lQXBpIH0gZnJvbSAnLi9iYXNrZXRiYWxsLWdhbWUtYXBpJztcbmV4cG9ydCB7IExlYWd1ZUFwaSB9IGZyb20gJy4vbGVhZ3VlLWFwaSc7XG5leHBvcnQgeyBNZWRpYUFwaSwgR2FtZU1lZGlhRmlsdGVycyB9IGZyb20gJy4vbWVkaWEtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vbm90aWZpY2F0aW9uLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL25vdGlmaWNhdGlvbi1iYXNlLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL29yZy1ub3RpZmljYXRpb24tYXBpJztcbmV4cG9ydCB7IFBhZ2luYXRlZFJlc3BvbnNlIH0gZnJvbSAnLi9wYWdpbmF0ZWQtcmVzcG9uc2UuaW50ZXJmYWNlJztcbmV4cG9ydCB7IFJlZmVyZW5jZUFwaSB9IGZyb20gJy4vcmVmZXJlbmNlLWFwaSc7XG5leHBvcnQge1xuICBUb3VybmFtZW50QXBpLCBUb3VybmFtZW50R2FtZXNGaWx0ZXJzLCBUb3VybmFtZW50RXZlbnRzTGlzdEZpbHRlciwgU3RhdGlzdGljR3JvdXBCeVR5cGVzLCBTdGF0aXN0aWNGaWx0ZXJzXG59IGZyb20gJy4vdG91cm5hbWVudC1hcGknO1xuZXhwb3J0IHsgVG91cm5hbWVudEpvaW5BcGkgfSBmcm9tICcuL3RvdXJuYW1lbnQtam9pbi1hcGknO1xuZXhwb3J0IHsgVG91cm5hbWVudFN0YWdlQXBpIH0gZnJvbSAnLi90b3VybmFtZW50LXN0YWdlLWFwaSc7XG5leHBvcnQgeyBWb2xsZXliYWxsR2FtZUFwaSB9IGZyb20gJy4vdm9sbGV5YmFsbC1nYW1lLWFwaSc7XG4iXX0=

package/esm5/api/reference-api.js

@@ -0,0 +1,45 @@
+import { __awaiter, __decorate, __generator } from "tslib";
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { ConfigService } from '../services/config.service';
+import { City } from '../models/city';
+import { Sport } from '../models/sport';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+var ReferenceApi = /** @class */ (function () {
+    function ReferenceApi(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    ReferenceApi.prototype.getCities = function () {
+        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/reference/cities/")
+                        .pipe(map(function (data) { return City.toFront(data); })).toPromise()];
+            });
+        });
+    };
+    ReferenceApi.prototype.getSports = function () {
+        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/sport/")
+                        .pipe(map(function (data) { return Sport.toFront(data); })).toPromise()];
+            });
+        });
+    };
+    ReferenceApi.ctorParameters = function () { return [
+        { type: HttpClient },
+        { type: ConfigService }
+    ]; };
+    ReferenceApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function ReferenceApi_Factory() { return new ReferenceApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.ConfigService)); }, token: ReferenceApi, providedIn: "root" });
+    ReferenceApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], ReferenceApi);
+    return ReferenceApi;
+}());
+export { ReferenceApi };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/api/tournament-api.js

@@ -0,0 +1,245 @@
+import { __awaiter, __decorate, __generator, __values } from "tslib";
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Tournament } from '../models/tournament';
+import { map } from 'rxjs/operators';
+import { TournamentNews } from '../models/tournament-news';
+import { Game, GameStatuses } from '../models/game';
+import { GameTimelineStages } from '../models/game-timeline-stages';
+import { TournamentTeam } from '../models/tournament-team';
+import { TournamentStage } from '../models/tournament-stage';
+import { Playoff } from '../models/playoff';
+import { BasketballStatistic } from '../models/basketball-statistic';
+import { VolleyballStatistic } from '../models/volleyball-statistic';
+import { TournamentTeamUser } from '../models/tournament-team-user';
+import { TournamentStageTeam } from '../models/tournament-stage-team';
+import { TournamentEvent, TournamentEventTypes } from '../models/tournament-event';
+import { ConfigService } from '../services/config.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+var TournamentApi = /** @class */ (function () {
+    function TournamentApi(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    TournamentApi.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/" + alias + "/")
+                        .pipe(map(function (result) { return Tournament.toFront(result); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentApi.prototype.getNews = 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 + "/news/")
+                        .pipe(map(function (result) { return TournamentNews.toFront(result); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentApi.prototype.getEvents = function (tournamentId, page, size, filters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_a) {
+                params = new HttpParams().set('page', page.toString())
+                    .set('size', size.toString());
+                if (filters) {
+                    if (filters.event) {
+                        params = params.set('event', 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/" + tournamentId + "/events/", { params: params, observe: 'response' })
+                        .pipe(map(function (result) { return ({
+                        total: +result.headers.get('X-Page-Count'),
+                        data: TournamentEvent.toFront(result.body)
+                    }); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentApi.prototype.getTournamentStages = 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 + "/stages/").pipe(map(function (data) { return TournamentStage.toFront(data); })).toPromise()];
+            });
+        });
+    };
+    TournamentApi.prototype.getPlayoff = 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 + "/playoff/").pipe(map(function (result) { return Playoff.toFront(result); })).toPromise()];
+            });
+        });
+    };
+    TournamentApi.prototype.getPlayoffGames = function (playoffId) {
+        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_playoff/" + playoffId + "/games/").pipe(map(function (result) { return Game.toFront(result); })).toPromise()];
+            });
+        });
+    };
+    TournamentApi.prototype.getGamesStages = 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 + "/games_stages/")
+                        .pipe(map(function (data) { return GameTimelineStages.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentApi.prototype.getGames = function (tournamentId, 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 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', GameStatuses[filters.status]);
+                }
+                return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/games/", { params: params, observe: 'response' })
+                        .pipe(map(function (result) { return ({
+                        total: +result.headers.get('X-Page-Count'),
+                        data: Game.toFront(result.body)
+                    }); })).toPromise()];
+            });
+        });
+    };
+    TournamentApi.prototype.getTeams = 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 + "/teams/")
+                        .pipe(map(function (result) { return TournamentTeam.toFront(result); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentApi.prototype.getStageTeams = 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 + "/stage_teams/")
+                        .pipe(map(function (result) { return TournamentStageTeam.toFront(result); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentApi.prototype.getTeamById = function (tournamentTeamId) {
+        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_team/" + tournamentTeamId + "/")
+                        .pipe(map(function (result) { return TournamentTeam.toFront(result); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentApi.prototype.getUserById = function (userId) {
+        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_team_user/" + userId + "/")
+                        .pipe(map(function (result) { return TournamentTeamUser.toFront(result); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentApi.prototype.getUserGames = function (tournamentUserId) {
+        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_team_user/" + tournamentUserId + "/games/")
+                        .pipe(map(function (result) { return Game.toFront(result); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentApi.prototype.getBasketballStatistic = function (filters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var params, _a, _b, key;
+            var e_1, _c;
+            return __generator(this, function (_d) {
+                params = new HttpParams();
+                if (filters) {
+                    try {
+                        for (_a = __values(Object.keys(filters)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                            key = _b.value;
+                            if (filters[key]) {
+                                params = params.set(key, filters[key]);
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    if (filters.per_game !== undefined) {
+                        params = params.set('per_game', filters.per_game ? '1' : '0');
+                    }
+                }
+                return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/basketball_statistic/", { params: params }).pipe(map(function (result) { return BasketballStatistic.toFront(result); })).toPromise()];
+            });
+        });
+    };
+    TournamentApi.prototype.getVolleyballStatistic = function (filters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var params, _a, _b, key;
+            var e_2, _c;
+            return __generator(this, function (_d) {
+                params = new HttpParams();
+                if (filters) {
+                    try {
+                        for (_a = __values(Object.keys(filters)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                            key = _b.value;
+                            if (filters[key]) {
+                                params = params.set(key, filters[key]);
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                    if (filters.per_game !== undefined) {
+                        params = params.set('per_game', filters.per_game ? '1' : '0');
+                    }
+                }
+                return [2 /*return*/, this.httpClient.get(this.configService.get('apiUrl') + "/api/v1/volleyball_statistic/", { params: params }).pipe(map(function (result) { return VolleyballStatistic.toFront(result); })).toPromise()];
+            });
+        });
+    };
+    TournamentApi.ctorParameters = function () { return [
+        { type: HttpClient },
+        { type: ConfigService }
+    ]; };
+    TournamentApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function TournamentApi_Factory() { return new TournamentApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.ConfigService)); }, token: TournamentApi, providedIn: "root" });
+    TournamentApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], TournamentApi);
+    return TournamentApi;
+}());
+export { TournamentApi };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tournament-api.js","sourceRoot":"ng://@mtgame/core/","sources":["api/tournament-api.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACnF,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;;;;AAoC3D;IACE,uBACU,UAAsB,EACtB,aAA4B;QAD5B,eAAU,GAAV,UAAU,CAAY;QACtB,kBAAa,GAAb,aAAa,CAAe;IAEtC,CAAC;IAEK,kCAAU,GAAhB,UAAiB,KAAa;;;gBAC5B,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,2BAAsB,KAAK,MAAG,CAAC;yBAC1F,IAAI,CAAC,GAAG,CAAC,UAAA,MAAM,IAAI,OAAA,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,EAA1B,CAA0B,CAAC,CAAC;yBAC/C,SAAS,EAAE,EAAC;;;KAChB;IAEK,+BAAO,GAAb,UAAc,YAAoB;;;gBAChC,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,2BAAsB,YAAY,WAAQ,CAAC;yBACtG,IAAI,CAAC,GAAG,CAAC,UAAA,MAAM,IAAI,OAAA,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC,EAA9B,CAA8B,CAAC,CAAC;yBACnD,SAAS,EAAE,EAAC;;;KAChB;IAEK,iCAAS,GAAf,UAAgB,YAAoB,EAAE,IAAY,EAAE,IAAY,EAAE,OAAoC;;;;gBAChG,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC;qBACvD,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAChC,IAAI,OAAO,EAAE;oBACX,IAAI,OAAO,CAAC,KAAK,EAAE;wBACjB,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;qBACnE;oBACD,IAAI,OAAO,CAAC,MAAM,EAAE;wBAClB,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;qBAC/C;iBACF;gBACD,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,2BAAsB,YAAY,aAAU,EAAE,EAAC,MAAM,QAAA,EAAE,OAAO,EAAE,UAAU,EAAC,CAAC;yBACvI,IAAI,CAAC,GAAG,CAAC,UAAA,MAAM,IAAI,OAAA,CAAC;wBACnB,KAAK,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;wBAC1C,IAAI,EAAE,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC;qBAC3C,CAAC,EAHkB,CAGlB,CAAC,CAAC;yBACH,SAAS,EAAE,EAAC;;;KAChB;IAEK,2CAAmB,GAAzB,UAA0B,YAAoB;;;gBAC5C,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,2BAAsB,YAAY,aAAU,CAAC,CAAC,IAAI,CAC9G,GAAG,CAAC,UAAA,IAAI,IAAI,OAAA,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,EAA7B,CAA6B,CAAC,CAC3C,CAAC,SAAS,EAAE,EAAC;;;KACf;IAEK,kCAAU,GAAhB,UAAiB,YAAoB;;;gBACnC,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,2BAAsB,YAAY,cAAW,CAAC,CAAC,IAAI,CAC/G,GAAG,CAAC,UAAA,MAAM,IAAI,OAAA,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAvB,CAAuB,CAAC,CACvC,CAAC,SAAS,EAAE,EAAC;;;KACf;IAEK,uCAAe,GAArB,UAAsB,SAAiB;;;gBACrC,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,mCAA8B,SAAS,YAAS,CAAC,CAAC,IAAI,CAClH,GAAG,CAAC,UAAA,MAAM,IAAI,OAAA,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAApB,CAAoB,CAAC,CACpC,CAAC,SAAS,EAAE,EAAC;;;KACf;IAEK,sCAAc,GAApB,UAAqB,YAAoB;;;gBACvC,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,2BAAsB,YAAY,mBAAgB,CAAC;yBAC9G,IAAI,CAAC,GAAG,CAAC,UAAA,IAAI,IAAI,OAAA,kBAAkB,CAAC,OAAO,CAAC,IAAI,CAAC,EAAhC,CAAgC,CAAC,CAAC;yBACnD,SAAS,EAAE,EAAC;;;KAChB;IAEK,gCAAQ,GAAd,UAAe,YAAoB,EAAE,IAAY,EAAE,IAAY,EAAE,OAAoC;QAApC,wBAAA,EAAA,YAAoC;;;;gBAC/F,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC3D,IAAI,IAAI,EAAE;oBACR,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;iBAC9C;gBACD,IAAI,OAAO,CAAC,iBAAiB,EAAE;oBAC7B,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,qBAAqB,EAAE,OAAO,CAAC,iBAAiB,CAAC,QAAQ,EAAE,CAAC,CAAC;iBAClF;gBACD,IAAI,OAAO,CAAC,cAAc,EAAE;oBAC1B,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,iBAAiB,EAAE,OAAO,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAC,CAAC;iBAC3E;gBACD,IAAI,OAAO,CAAC,YAAY,EAAE;oBACxB,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,eAAe,EAAE,OAAO,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;iBACvE;gBACD,IAAI,OAAO,CAAC,MAAM,EAAE;oBAClB,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;iBAC3D;gBACD,IAAI,OAAO,CAAC,MAAM,EAAE;oBAClB,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;iBAC7D;gBACD,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,2BAAsB,YAAY,YAAS,EAAE,EAAC,MAAM,QAAA,EAAE,OAAO,EAAE,UAAU,EAAC,CAAC;yBACtI,IAAI,CAAC,GAAG,CAAC,UAAA,MAAM,IAAI,OAAA,CAAC;wBACnB,KAAK,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;wBAC1C,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC;qBAChC,CAAC,EAHkB,CAGlB,CAAC,CAAC,CAAC,SAAS,EAAE,EAAC;;;KACpB;IAEK,gCAAQ,GAAd,UAAe,YAAoB;;;gBACjC,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,2BAAsB,YAAY,YAAS,CAAC;yBACvG,IAAI,CAAC,GAAG,CAAC,UAAA,MAAM,IAAI,OAAA,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC,EAA9B,CAA8B,CAAC,CAAC;yBACnD,SAAS,EAAE,EAAC;;;KAChB;IAEK,qCAAa,GAAnB,UAAoB,YAAoB;;;gBACtC,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,2BAAsB,YAAY,kBAAe,CAAC;yBAC7G,IAAI,CAAC,GAAG,CAAC,UAAA,MAAM,IAAI,OAAA,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,EAAnC,CAAmC,CAAC,CAAC;yBACxD,SAAS,EAAE,EAAC;;;KAChB;IAEK,mCAAW,GAAjB,UAAkB,gBAAwB;;;gBACxC,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,gCAA2B,gBAAgB,MAAG,CAAC;yBAC1G,IAAI,CAAC,GAAG,CAAC,UAAA,MAAM,IAAI,OAAA,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC,EAA9B,CAA8B,CAAC,CAAC;yBACnD,SAAS,EAAE,EAAC;;;KAChB;IAEK,mCAAW,GAAjB,UAAkB,MAAc;;;gBAC9B,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,qCAAgC,MAAM,MAAG,CAAC;yBACrG,IAAI,CAAC,GAAG,CAAC,UAAA,MAAM,IAAI,OAAA,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,EAAlC,CAAkC,CAAC,CAAC;yBACvD,SAAS,EAAE,EAAC;;;KAChB;IAEK,oCAAY,GAAlB,UAAmB,gBAAwB;;;gBACzC,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,qCAAgC,gBAAgB,YAAS,CAAC;yBACrH,IAAI,CAAC,GAAG,CAAC,UAAA,MAAM,IAAI,OAAA,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAApB,CAAoB,CAAC,CAAC;yBACzC,SAAS,EAAE,EAAC;;;KAChB;IAEK,8CAAsB,GAA5B,UAA6B,OAA0B;;;;;gBACjD,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;gBAC9B,IAAI,OAAO,EAAE;;wBACX,KAAkB,KAAA,SAAA,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA,4CAAE;4BAA7B,GAAG;4BACZ,IAAI,OAAO,CAAC,GAAG,CAAC,EAAE;gCAChB,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;6BACxC;yBACF;;;;;;;;;oBAED,IAAI,OAAO,CAAC,QAAQ,KAAK,SAAS,EAAE;wBAClC,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;qBAC/D;iBACF;gBAED,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,kCAA+B,EAAE,EAAC,MAAM,QAAA,EAAC,CAAC,CAAC,IAAI,CAC3G,GAAG,CAAC,UAAA,MAAM,IAAI,OAAA,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,EAAnC,CAAmC,CAAC,CACnD,CAAC,SAAS,EAAE,EAAC;;;KACf;IAEK,8CAAsB,GAA5B,UAA6B,OAA0B;;;;;gBACjD,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;gBAC9B,IAAI,OAAO,EAAE;;wBACX,KAAkB,KAAA,SAAA,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA,4CAAE;4BAA7B,GAAG;4BACZ,IAAI,OAAO,CAAC,GAAG,CAAC,EAAE;gCAChB,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;6BACxC;yBACF;;;;;;;;;oBAED,IAAI,OAAO,CAAC,QAAQ,KAAK,SAAS,EAAE;wBAClC,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;qBAC/D;iBACF;gBAED,sBAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,kCAA+B,EAAE,EAAC,MAAM,QAAA,EAAC,CAAC,CAAC,IAAI,CAC3G,GAAG,CAAC,UAAA,MAAM,IAAI,OAAA,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,EAAnC,CAAmC,CAAC,CACnD,CAAC,SAAS,EAAE,EAAC;;;KACf;;gBAzJqB,UAAU;gBACP,aAAa;;;IAH3B,aAAa;QADzB,UAAU,CAAC,EAAC,UAAU,EAAE,MAAM,EAAC,CAAC;OACpB,aAAa,CA4JzB;wBAhND;CAgNC,AA5JD,IA4JC;SA5JY,aAAa","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient, HttpParams } from '@angular/common/http';\nimport { Tournament } from '../models/tournament';\nimport { map } from 'rxjs/operators';\nimport { TournamentNews } from '../models/tournament-news';\nimport { Game, GameStatuses } from '../models/game';\nimport { GameTimelineStages } from '../models/game-timeline-stages';\nimport { TournamentTeam } from '../models/tournament-team';\nimport { TournamentStage } from '../models/tournament-stage';\nimport { Playoff } from '../models/playoff';\nimport { PaginatedResponse } from './paginated-response.interface';\nimport { BasketballStatistic } from '../models/basketball-statistic';\nimport { VolleyballStatistic } from '../models/volleyball-statistic';\nimport { TournamentTeamUser } from '../models/tournament-team-user';\nimport { TournamentStageTeam } from '../models/tournament-stage-team';\nimport { TournamentEvent, TournamentEventTypes } from '../models/tournament-event';\nimport { ConfigService } from '../services/config.service';\n\nexport interface TournamentGamesFilters {\n  tournamentStageId?: number;\n  tournamentTour?: number;\n  teamId?: number;\n  playoffStage?: number;\n  playoffId?: number;\n  status?: GameStatuses;\n}\n\nexport type StatisticGroupByTypes = 'team' | 'user' | 'team_user' | 'tournament_team' | 'tournament_team_user' | 'month' | 'win_loses';\n\nexport interface StatisticFilters {\n  tournament_id?: number;\n  tournament_team_id?: number;\n  tournament_team_user_id?: number;\n  team_id?: number;\n  team_user_id?: number;\n  user_id?: number;\n  tournament_stage_id?: number;\n  tournament_tour?: number;\n  playoff_stage?: number;\n  playoff_id?: number;\n  date_from?: string;\n  date_to?: string;\n  per_game?: boolean;\n  group_by: StatisticGroupByTypes;\n}\n\nexport interface TournamentEventsListFilter {\n  event?: TournamentEventTypes;\n  search?: string;\n}\n\n@Injectable({providedIn: 'root'})\nexport class TournamentApi {\n  constructor(\n    private httpClient: HttpClient,\n    private configService: ConfigService,\n  ) {\n  }\n\n  async getByAlias(alias: string): Promise<Tournament> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${alias}/`)\n      .pipe(map(result => Tournament.toFront(result)))\n      .toPromise();\n  }\n\n  async getNews(tournamentId: number): Promise<TournamentNews[]> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/news/`)\n      .pipe(map(result => TournamentNews.toFront(result)))\n      .toPromise();\n  }\n\n  async getEvents(tournamentId: number, page: number, size: number, filters?: TournamentEventsListFilter): Promise<PaginatedResponse<TournamentEvent[]>> {\n    let params = new HttpParams().set('page', page.toString())\n      .set('size', size.toString());\n    if (filters) {\n      if (filters.event) {\n        params = params.set('event', TournamentEventTypes[filters.event]);\n      }\n      if (filters.search) {\n        params = params.set('search', filters.search);\n      }\n    }\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/events/`, {params, observe: 'response'})\n      .pipe(map(result => ({\n        total: +result.headers.get('X-Page-Count'),\n        data: TournamentEvent.toFront(result.body)\n      })))\n      .toPromise();\n  }\n\n  async getTournamentStages(tournamentId: number): Promise<TournamentStage[]> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/stages/`).pipe(\n      map(data => TournamentStage.toFront(data))\n    ).toPromise();\n  }\n\n  async getPlayoff(tournamentId: number): Promise<Playoff[]> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/playoff/`).pipe(\n      map(result => Playoff.toFront(result))\n    ).toPromise();\n  }\n\n  async getPlayoffGames(playoffId: number): Promise<Game[]> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_playoff/${playoffId}/games/`).pipe(\n      map(result => Game.toFront(result))\n    ).toPromise();\n  }\n\n  async getGamesStages(tournamentId: number): Promise<GameTimelineStages> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/games_stages/`)\n      .pipe(map(data => GameTimelineStages.toFront(data)))\n      .toPromise();\n  }\n\n  async getGames(tournamentId: number, page: number, size: number, filters: TournamentGamesFilters = {}): Promise<PaginatedResponse<Game[]>> {\n    let params = new HttpParams().set('page', page.toString());\n    if (size) {\n      params = params.set('size', size.toString());\n    }\n    if (filters.tournamentStageId) {\n      params = params.set('tournament_stage_id', filters.tournamentStageId.toString());\n    }\n    if (filters.tournamentTour) {\n      params = params.set('tournament_tour', filters.tournamentTour.toString());\n    }\n    if (filters.playoffStage) {\n      params = params.set('playoff_stage', filters.playoffStage.toString());\n    }\n    if (filters.teamId) {\n      params = params.set('team_id', filters.teamId.toString());\n    }\n    if (filters.status) {\n      params = params.set('status', GameStatuses[filters.status]);\n    }\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/games/`, {params, observe: 'response'})\n      .pipe(map(result => ({\n        total: +result.headers.get('X-Page-Count'),\n        data: Game.toFront(result.body)\n      }))).toPromise();\n  }\n\n  async getTeams(tournamentId: number): Promise<TournamentTeam[]> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/teams/`)\n      .pipe(map(result => TournamentTeam.toFront(result)))\n      .toPromise();\n  }\n\n  async getStageTeams(tournamentId: number): Promise<TournamentStageTeam[]> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/stage_teams/`)\n      .pipe(map(result => TournamentStageTeam.toFront(result)))\n      .toPromise();\n  }\n\n  async getTeamById(tournamentTeamId: number): Promise<TournamentTeam> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_team/${tournamentTeamId}/`)\n      .pipe(map(result => TournamentTeam.toFront(result)))\n      .toPromise();\n  }\n\n  async getUserById(userId: number): Promise<TournamentTeamUser> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_team_user/${userId}/`)\n      .pipe(map(result => TournamentTeamUser.toFront(result)))\n      .toPromise();\n  }\n\n  async getUserGames(tournamentUserId: number): Promise<Game[]> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_team_user/${tournamentUserId}/games/`)\n      .pipe(map(result => Game.toFront(result)))\n      .toPromise();\n  }\n\n  async getBasketballStatistic(filters?: StatisticFilters): Promise<BasketballStatistic[]> {\n    let params = new HttpParams();\n    if (filters) {\n      for (const key of Object.keys(filters)) {\n        if (filters[key]) {\n          params = params.set(key, filters[key]);\n        }\n      }\n\n      if (filters.per_game !== undefined) {\n        params = params.set('per_game', filters.per_game ? '1' : '0');\n      }\n    }\n\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/basketball_statistic/`, {params}).pipe(\n      map(result => BasketballStatistic.toFront(result))\n    ).toPromise();\n  }\n\n  async getVolleyballStatistic(filters?: StatisticFilters): Promise<VolleyballStatistic[]> {\n    let params = new HttpParams();\n    if (filters) {\n      for (const key of Object.keys(filters)) {\n        if (filters[key]) {\n          params = params.set(key, filters[key]);\n        }\n      }\n\n      if (filters.per_game !== undefined) {\n        params = params.set('per_game', filters.per_game ? '1' : '0');\n      }\n    }\n\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/volleyball_statistic/`, {params}).pipe(\n      map(result => VolleyballStatistic.toFront(result))\n    ).toPromise();\n  }\n}\n"]}

package/esm5/api/tournament-join-api.js

@@ -0,0 +1,59 @@
+import { __awaiter, __decorate, __generator } from "tslib";
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { TournamentJoinTeam } from '../models/tournament-join-team';
+import { map } from 'rxjs/operators';
+import { TeamUser } from '../models/team-user';
+import { TournamentTeamUserInvite } from '../models/tournament-team-user-invite';
+import { TournamentInvite } from '../models/tournament-invite';
+import { ConfigService } from '../services/config.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+var TournamentJoinApi = /** @class */ (function () {
+    function TournamentJoinApi(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    TournamentJoinApi.prototype.getTeamsForJoin = 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 + "/teams_for_join/").pipe(map(function (response) { return TournamentJoinTeam.toFront(response); })).toPromise()];
+            });
+        });
+    };
+    TournamentJoinApi.prototype.getTeamUsers = function (teamId) {
+        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/team/" + teamId + "/users/")
+                        .pipe(map(function (data) { return TeamUser.toFront(data); })).toPromise()];
+            });
+        });
+    };
+    TournamentJoinApi.prototype.joinTournament = function (tournamentId, teamId, invites) {
+        return __awaiter(this, void 0, void 0, function () {
+            var body;
+            return __generator(this, function (_a) {
+                body = {
+                    team: { id: teamId },
+                    user_invites: TournamentTeamUserInvite.toBack(invites)
+                };
+                return [2 /*return*/, this.httpClient.post(this.configService.get('apiUrl') + "/api/v1/tournament/" + tournamentId + "/join/", body)
+                        .pipe(map(function (data) { return TournamentInvite.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentJoinApi.ctorParameters = function () { return [
+        { type: HttpClient },
+        { type: ConfigService }
+    ]; };
+    TournamentJoinApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function TournamentJoinApi_Factory() { return new TournamentJoinApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.ConfigService)); }, token: TournamentJoinApi, providedIn: "root" });
+    TournamentJoinApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], TournamentJoinApi);
+    return TournamentJoinApi;
+}());
+export { TournamentJoinApi };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG91cm5hbWVudC1qb2luLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BtdGdhbWUvY29yZS8iLCJzb3VyY2VzIjpbImFwaS90b3VybmFtZW50LWpvaW4tYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUNsRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRSxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDckMsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQy9DLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBQ2pGLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQy9ELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQzs7OztBQUczRDtJQUNFLDJCQUNVLFVBQXNCLEVBQ3RCLGFBQTRCO1FBRDVCLGVBQVUsR0FBVixVQUFVLENBQVk7UUFDdEIsa0JBQWEsR0FBYixhQUFhLENBQWU7SUFFdEMsQ0FBQztJQUVLLDJDQUFlLEdBQXJCLFVBQXNCLFlBQW9COzs7Z0JBQ3hDLHNCQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFJLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQywyQkFBc0IsWUFBWSxxQkFBa0IsQ0FBQyxDQUFDLElBQUksQ0FDdEgsR0FBRyxDQUFDLFVBQUEsUUFBUSxJQUFJLE9BQUEsa0JBQWtCLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxFQUFwQyxDQUFvQyxDQUFDLENBQ3RELENBQUMsU0FBUyxFQUFFLEVBQUM7OztLQUNmO0lBRUssd0NBQVksR0FBbEIsVUFBbUIsTUFBYzs7O2dCQUMvQixzQkFBTyxJQUFJLENBQUMsVUFBVTt5QkFDbkIsR0FBRyxDQUFJLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxxQkFBZ0IsTUFBTSxZQUFTLENBQUM7eUJBQ3ZFLElBQUksQ0FDSCxHQUFHLENBQUMsVUFBQSxJQUFJLElBQUksT0FBQSxRQUFRLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUF0QixDQUFzQixDQUFDLENBQ3BDLENBQUMsU0FBUyxFQUFFLEVBQUM7OztLQUNqQjtJQUVLLDBDQUFjLEdBQXBCLFVBQXFCLFlBQW9CLEVBQUUsTUFBYyxFQUFFLE9BQW1DOzs7O2dCQUN0RixJQUFJLEdBQUc7b0JBQ1gsSUFBSSxFQUFFLEVBQUMsRUFBRSxFQUFFLE1BQU0sRUFBQztvQkFDbEIsWUFBWSxFQUFFLHdCQUF3QixDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUM7aUJBQ3ZELENBQUM7Z0JBQ0Ysc0JBQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUksSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLDJCQUFzQixZQUFZLFdBQVEsRUFBRSxJQUFJLENBQUM7eUJBQzdHLElBQUksQ0FBQyxHQUFHLENBQUMsVUFBQSxJQUFJLElBQUksT0FBQSxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEVBQTlCLENBQThCLENBQUMsQ0FBQzt5QkFDakQsU0FBUyxFQUFFLEVBQUM7OztLQUNoQjs7Z0JBM0JxQixVQUFVO2dCQUNQLGFBQWE7OztJQUgzQixpQkFBaUI7UUFEN0IsVUFBVSxDQUFDLEVBQUMsVUFBVSxFQUFFLE1BQU0sRUFBQyxDQUFDO09BQ3BCLGlCQUFpQixDQThCN0I7NEJBeENEO0NBd0NDLEFBOUJELElBOEJDO1NBOUJZLGlCQUFpQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEh0dHBDbGllbnQgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5pbXBvcnQgeyBUb3VybmFtZW50Sm9pblRlYW0gfSBmcm9tICcuLi9tb2RlbHMvdG91cm5hbWVudC1qb2luLXRlYW0nO1xuaW1wb3J0IHsgbWFwIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuaW1wb3J0IHsgVGVhbVVzZXIgfSBmcm9tICcuLi9tb2RlbHMvdGVhbS11c2VyJztcbmltcG9ydCB7IFRvdXJuYW1lbnRUZWFtVXNlckludml0ZSB9IGZyb20gJy4uL21vZGVscy90b3VybmFtZW50LXRlYW0tdXNlci1pbnZpdGUnO1xuaW1wb3J0IHsgVG91cm5hbWVudEludml0ZSB9IGZyb20gJy4uL21vZGVscy90b3VybmFtZW50LWludml0ZSc7XG5pbXBvcnQgeyBDb25maWdTZXJ2aWNlIH0gZnJvbSAnLi4vc2VydmljZXMvY29uZmlnLnNlcnZpY2UnO1xuXG5ASW5qZWN0YWJsZSh7cHJvdmlkZWRJbjogJ3Jvb3QnfSlcbmV4cG9ydCBjbGFzcyBUb3VybmFtZW50Sm9pbkFwaSB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgaHR0cENsaWVudDogSHR0cENsaWVudCxcbiAgICBwcml2YXRlIGNvbmZpZ1NlcnZpY2U6IENvbmZpZ1NlcnZpY2UsXG4gICkge1xuICB9XG5cbiAgYXN5bmMgZ2V0VGVhbXNGb3JKb2luKHRvdXJuYW1lbnRJZDogbnVtYmVyKTogUHJvbWlzZTxUb3VybmFtZW50Sm9pblRlYW1bXT4ge1xuICAgIHJldHVybiB0aGlzLmh0dHBDbGllbnQuZ2V0KGAke3RoaXMuY29uZmlnU2VydmljZS5nZXQoJ2FwaVVybCcpfS9hcGkvdjEvdG91cm5hbWVudC8ke3RvdXJuYW1lbnRJZH0vdGVhbXNfZm9yX2pvaW4vYCkucGlwZShcbiAgICAgIG1hcChyZXNwb25zZSA9PiBUb3VybmFtZW50Sm9pblRlYW0udG9Gcm9udChyZXNwb25zZSkpXG4gICAgKS50b1Byb21pc2UoKTtcbiAgfVxuXG4gIGFzeW5jIGdldFRlYW1Vc2Vycyh0ZWFtSWQ6IG51bWJlcik6IFByb21pc2U8VGVhbVVzZXJbXT4ge1xuICAgIHJldHVybiB0aGlzLmh0dHBDbGllbnRcbiAgICAgIC5nZXQoYCR7dGhpcy5jb25maWdTZXJ2aWNlLmdldCgnYXBpVXJsJyl9L2FwaS92MS90ZWFtLyR7dGVhbUlkfS91c2Vycy9gKVxuICAgICAgLnBpcGUoXG4gICAgICAgIG1hcChkYXRhID0+IFRlYW1Vc2VyLnRvRnJvbnQoZGF0YSkpXG4gICAgICApLnRvUHJvbWlzZSgpO1xuICB9XG5cbiAgYXN5bmMgam9pblRvdXJuYW1lbnQodG91cm5hbWVudElkOiBudW1iZXIsIHRlYW1JZDogbnVtYmVyLCBpbnZpdGVzOiBUb3VybmFtZW50VGVhbVVzZXJJbnZpdGVbXSk6IFByb21pc2U8VG91cm5hbWVudEludml0ZT4ge1xuICAgIGNvbnN0IGJvZHkgPSB7XG4gICAgICB0ZWFtOiB7aWQ6IHRlYW1JZH0sXG4gICAgICB1c2VyX2ludml0ZXM6IFRvdXJuYW1lbnRUZWFtVXNlckludml0ZS50b0JhY2soaW52aXRlcylcbiAgICB9O1xuICAgIHJldHVybiB0aGlzLmh0dHBDbGllbnQucG9zdChgJHt0aGlzLmNvbmZpZ1NlcnZpY2UuZ2V0KCdhcGlVcmwnKX0vYXBpL3YxL3RvdXJuYW1lbnQvJHt0b3VybmFtZW50SWR9L2pvaW4vYCwgYm9keSlcbiAgICAgIC5waXBlKG1hcChkYXRhID0+IFRvdXJuYW1lbnRJbnZpdGUudG9Gcm9udChkYXRhKSkpXG4gICAgICAudG9Qcm9taXNlKCk7XG4gIH1cbn1cbiJdfQ==

package/esm5/api/tournament-stage-api.js

@@ -0,0 +1,65 @@
+import { __awaiter, __decorate, __generator } from "tslib";
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { TournamentStage } from '../models/tournament-stage';
+import { map } from 'rxjs/operators';
+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 * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+var TournamentStageApi = /** @class */ (function () {
+    function TournamentStageApi(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    TournamentStageApi.prototype.getById = function (id) {
+        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/" + id + "/")
+                        .pipe(map(function (result) { return TournamentStage.toFront(result); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentStageApi.prototype.getGroups = 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 + "/groups/")
+                        .pipe(map(function (result) { return TournamentGroup.toFront(result); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentStageApi.prototype.getPlayoffs = 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 + "/playoff/")
+                        .pipe(map(function (result) { return Playoff.toFront(result); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentStageApi.prototype.getTeams = 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 + "/teams/")
+                        .pipe(map(function (result) { return TournamentStageTeam.toFront(result); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TournamentStageApi.ctorParameters = function () { return [
+        { type: HttpClient },
+        { type: ConfigService }
+    ]; };
+    TournamentStageApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function TournamentStageApi_Factory() { return new TournamentStageApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.ConfigService)); }, token: TournamentStageApi, providedIn: "root" });
+    TournamentStageApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], TournamentStageApi);
+    return TournamentStageApi;
+}());
+export { TournamentStageApi };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/api/volleyball-game-api.js

@@ -0,0 +1,65 @@
+import { __awaiter, __decorate, __generator } from "tslib";
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Game } from '../models/game';
+import { map } from 'rxjs/operators';
+import { GameUser } from '../models/game-user';
+import { VolleyballGameTeamStatistic } from '../models/volleyball-game-team-statistic';
+import { VolleyballGameStatistic } from '../models/volleyball-game-statistic';
+import { VolleyballGameLog } from '../models/volleyball-game-log';
+import { ConfigService } from '../services/config.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+var VolleyballGameApi = /** @class */ (function () {
+    function VolleyballGameApi(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    VolleyballGameApi.prototype.getById = function (gameId) {
+        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_volleyball_game/" + gameId + "/").pipe(map(function (result) { return Game.toFront(result); })).toPromise()];
+            });
+        });
+    };
+    VolleyballGameApi.prototype.getUsers = function (gameId) {
+        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_game/" + gameId + "/users/").pipe(map(function (result) { return GameUser.toFront(result); })).toPromise()];
+            });
+        });
+    };
+    VolleyballGameApi.prototype.getTeamStatistic = function (gameId) {
+        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_volleyball_game/" + gameId + "/team_statistic/").pipe(map(function (result) { return VolleyballGameTeamStatistic.toFront(result); })).toPromise()];
+            });
+        });
+    };
+    VolleyballGameApi.prototype.getUserStatistic = function (gameId) {
+        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_volleyball_game/" + gameId + "/user_statistic/").pipe(map(function (result) { return VolleyballGameStatistic.toFront(result); })).toPromise()];
+            });
+        });
+    };
+    VolleyballGameApi.prototype.getLogs = function (gameId) {
+        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_volleyball_game/" + gameId + "/logs/").pipe(map(function (result) { return VolleyballGameLog.toFront(result); })).toPromise()];
+            });
+        });
+    };
+    VolleyballGameApi.ctorParameters = function () { return [
+        { type: HttpClient },
+        { type: ConfigService }
+    ]; };
+    VolleyballGameApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function VolleyballGameApi_Factory() { return new VolleyballGameApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.ConfigService)); }, token: VolleyballGameApi, providedIn: "root" });
+    VolleyballGameApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], VolleyballGameApi);
+    return VolleyballGameApi;
+}());
+export { VolleyballGameApi };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidm9sbGV5YmFsbC1nYW1lLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BtdGdhbWUvY29yZS8iLCJzb3VyY2VzIjpbImFwaS92b2xsZXliYWxsLWdhbWUtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUNsRCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDdEMsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3JDLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSwwQ0FBMEMsQ0FBQztBQUN2RixPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUM5RSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUNsRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7Ozs7QUFHM0Q7SUFDRSwyQkFDVSxVQUFzQixFQUN0QixhQUE0QjtRQUQ1QixlQUFVLEdBQVYsVUFBVSxDQUFZO1FBQ3RCLGtCQUFhLEdBQWIsYUFBYSxDQUFlO0lBRXRDLENBQUM7SUFFSyxtQ0FBTyxHQUFiLFVBQWMsTUFBYzs7O2dCQUMxQixzQkFBTyxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBSSxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsMkNBQXNDLE1BQU0sTUFBRyxDQUFDLENBQUMsSUFBSSxDQUNqSCxHQUFHLENBQUMsVUFBQSxNQUFNLElBQUksT0FBQSxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUFwQixDQUFvQixDQUFDLENBQ3BDLENBQUMsU0FBUyxFQUFFLEVBQUM7OztLQUNmO0lBRUssb0NBQVEsR0FBZCxVQUFlLE1BQWM7OztnQkFDM0Isc0JBQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUksSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLGdDQUEyQixNQUFNLFlBQVMsQ0FBQyxDQUFDLElBQUksQ0FDNUcsR0FBRyxDQUFDLFVBQUEsTUFBTSxJQUFJLE9BQUEsUUFBUSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsRUFBeEIsQ0FBd0IsQ0FBQyxDQUN4QyxDQUFDLFNBQVMsRUFBRSxFQUFDOzs7S0FDZjtJQUVLLDRDQUFnQixHQUF0QixVQUF1QixNQUFjOzs7Z0JBQ25DLHNCQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFJLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQywyQ0FBc0MsTUFBTSxxQkFBa0IsQ0FBQyxDQUFDLElBQUksQ0FDaEksR0FBRyxDQUFDLFVBQUEsTUFBTSxJQUFJLE9BQUEsMkJBQTJCLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUEzQyxDQUEyQyxDQUFDLENBQzNELENBQUMsU0FBUyxFQUFFLEVBQUM7OztLQUNmO0lBRUssNENBQWdCLEdBQXRCLFVBQXVCLE1BQWM7OztnQkFDbkMsc0JBQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUksSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLDJDQUFzQyxNQUFNLHFCQUFrQixDQUFDLENBQUMsSUFBSSxDQUNoSSxHQUFHLENBQUMsVUFBQSxNQUFNLElBQUksT0FBQSx1QkFBdUIsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLEVBQXZDLENBQXVDLENBQUMsQ0FDdkQsQ0FBQyxTQUFTLEVBQUUsRUFBQzs7O0tBQ2Y7SUFFSyxtQ0FBTyxHQUFiLFVBQWMsTUFBYzs7O2dCQUMxQixzQkFBTyxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBSSxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsMkNBQXNDLE1BQU0sV0FBUSxDQUFDLENBQUMsSUFBSSxDQUN0SCxHQUFHLENBQUMsVUFBQSxNQUFNLElBQUksT0FBQSxpQkFBaUIsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLEVBQWpDLENBQWlDLENBQUMsQ0FDakQsQ0FBQyxTQUFTLEVBQUUsRUFBQzs7O0tBQ2Y7O2dCQWpDcUIsVUFBVTtnQkFDUCxhQUFhOzs7SUFIM0IsaUJBQWlCO1FBRDdCLFVBQVUsQ0FBQyxFQUFDLFVBQVUsRUFBRSxNQUFNLEVBQUMsQ0FBQztPQUNwQixpQkFBaUIsQ0FvQzdCOzRCQS9DRDtDQStDQyxBQXBDRCxJQW9DQztTQXBDWSxpQkFBaUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBIdHRwQ2xpZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuaW1wb3J0IHsgR2FtZSB9IGZyb20gJy4uL21vZGVscy9nYW1lJztcbmltcG9ydCB7IG1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcbmltcG9ydCB7IEdhbWVVc2VyIH0gZnJvbSAnLi4vbW9kZWxzL2dhbWUtdXNlcic7XG5pbXBvcnQgeyBWb2xsZXliYWxsR2FtZVRlYW1TdGF0aXN0aWMgfSBmcm9tICcuLi9tb2RlbHMvdm9sbGV5YmFsbC1nYW1lLXRlYW0tc3RhdGlzdGljJztcbmltcG9ydCB7IFZvbGxleWJhbGxHYW1lU3RhdGlzdGljIH0gZnJvbSAnLi4vbW9kZWxzL3ZvbGxleWJhbGwtZ2FtZS1zdGF0aXN0aWMnO1xuaW1wb3J0IHsgVm9sbGV5YmFsbEdhbWVMb2cgfSBmcm9tICcuLi9tb2RlbHMvdm9sbGV5YmFsbC1nYW1lLWxvZyc7XG5pbXBvcnQgeyBDb25maWdTZXJ2aWNlIH0gZnJvbSAnLi4vc2VydmljZXMvY29uZmlnLnNlcnZpY2UnO1xuXG5ASW5qZWN0YWJsZSh7cHJvdmlkZWRJbjogJ3Jvb3QnfSlcbmV4cG9ydCBjbGFzcyBWb2xsZXliYWxsR2FtZUFwaSB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgaHR0cENsaWVudDogSHR0cENsaWVudCxcbiAgICBwcml2YXRlIGNvbmZpZ1NlcnZpY2U6IENvbmZpZ1NlcnZpY2UsXG4gICkge1xuICB9XG5cbiAgYXN5bmMgZ2V0QnlJZChnYW1lSWQ6IG51bWJlcik6IFByb21pc2U8R2FtZT4ge1xuICAgIHJldHVybiB0aGlzLmh0dHBDbGllbnQuZ2V0KGAke3RoaXMuY29uZmlnU2VydmljZS5nZXQoJ2FwaVVybCcpfS9hcGkvdjEvdG91cm5hbWVudF92b2xsZXliYWxsX2dhbWUvJHtnYW1lSWR9L2ApLnBpcGUoXG4gICAgICBtYXAocmVzdWx0ID0+IEdhbWUudG9Gcm9udChyZXN1bHQpKVxuICAgICkudG9Qcm9taXNlKCk7XG4gIH1cblxuICBhc3luYyBnZXRVc2VycyhnYW1lSWQ6IG51bWJlcik6IFByb21pc2U8R2FtZVVzZXJbXT4ge1xuICAgIHJldHVybiB0aGlzLmh0dHBDbGllbnQuZ2V0KGAke3RoaXMuY29uZmlnU2VydmljZS5nZXQoJ2FwaVVybCcpfS9hcGkvdjEvdG91cm5hbWVudF9nYW1lLyR7Z2FtZUlkfS91c2Vycy9gKS5waXBlKFxuICAgICAgbWFwKHJlc3VsdCA9PiBHYW1lVXNlci50b0Zyb250KHJlc3VsdCkpXG4gICAgKS50b1Byb21pc2UoKTtcbiAgfVxuXG4gIGFzeW5jIGdldFRlYW1TdGF0aXN0aWMoZ2FtZUlkOiBudW1iZXIpOiBQcm9taXNlPFZvbGxleWJhbGxHYW1lVGVhbVN0YXRpc3RpYz4ge1xuICAgIHJldHVybiB0aGlzLmh0dHBDbGllbnQuZ2V0KGAke3RoaXMuY29uZmlnU2VydmljZS5nZXQoJ2FwaVVybCcpfS9hcGkvdjEvdG91cm5hbWVudF92b2xsZXliYWxsX2dhbWUvJHtnYW1lSWR9L3RlYW1fc3RhdGlzdGljL2ApLnBpcGUoXG4gICAgICBtYXAocmVzdWx0ID0+IFZvbGxleWJhbGxHYW1lVGVhbVN0YXRpc3RpYy50b0Zyb250KHJlc3VsdCkpXG4gICAgKS50b1Byb21pc2UoKTtcbiAgfVxuXG4gIGFzeW5jIGdldFVzZXJTdGF0aXN0aWMoZ2FtZUlkOiBudW1iZXIpOiBQcm9taXNlPFZvbGxleWJhbGxHYW1lU3RhdGlzdGljW10+IHtcbiAgICByZXR1cm4gdGhpcy5odHRwQ2xpZW50LmdldChgJHt0aGlzLmNvbmZpZ1NlcnZpY2UuZ2V0KCdhcGlVcmwnKX0vYXBpL3YxL3RvdXJuYW1lbnRfdm9sbGV5YmFsbF9nYW1lLyR7Z2FtZUlkfS91c2VyX3N0YXRpc3RpYy9gKS5waXBlKFxuICAgICAgbWFwKHJlc3VsdCA9PiBWb2xsZXliYWxsR2FtZVN0YXRpc3RpYy50b0Zyb250KHJlc3VsdCkpXG4gICAgKS50b1Byb21pc2UoKTtcbiAgfVxuXG4gIGFzeW5jIGdldExvZ3MoZ2FtZUlkOiBudW1iZXIpOiBQcm9taXNlPFZvbGxleWJhbGxHYW1lTG9nW10+IHtcbiAgICByZXR1cm4gdGhpcy5odHRwQ2xpZW50LmdldChgJHt0aGlzLmNvbmZpZ1NlcnZpY2UuZ2V0KCdhcGlVcmwnKX0vYXBpL3YxL3RvdXJuYW1lbnRfdm9sbGV5YmFsbF9nYW1lLyR7Z2FtZUlkfS9sb2dzL2ApLnBpcGUoXG4gICAgICBtYXAocmVzdWx0ID0+IFZvbGxleWJhbGxHYW1lTG9nLnRvRnJvbnQocmVzdWx0KSlcbiAgICApLnRvUHJvbWlzZSgpO1xuICB9XG59XG4iXX0=