@mtgame/core 0.2.26 → 2.0.0

package/esm2020/api/tournament-round-api.mjs

@@ -0,0 +1,57 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { TournamentRound } from '../models/tournament-round';
+import { map } from 'rxjs/operators';
+import { TournamentRoundTeam } from '../models/tournament-round-team';
+import { Playoff } from '../models/playoff';
+import { TournamentGroup } from '../models/tournament-group';
+import { applyGamesFilters } from './tournament-api';
+import { Game } from '../models/game';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+export class TournamentRoundApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    async getById(tournamentRoundId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_round/${tournamentRoundId}/`).pipe(map(data => new TournamentRound(data))).toPromise();
+    }
+    async getTeams(tournamentRoundId, filters) {
+        let params = new HttpParams();
+        if (filters) {
+            if (filters.divisionId) {
+                params = params.set('division_id', filters.divisionId);
+            }
+            if (filters.groupId) {
+                params = params.set('group_id', filters.groupId);
+            }
+        }
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_round/${tournamentRoundId}/teams/`, { params }).pipe(map(data => data.map(item => new TournamentRoundTeam(item)))).toPromise();
+    }
+    async getPlayoffs(tournamentRoundId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_round/${tournamentRoundId}/playoffs/`).pipe(map(data => data.map(item => new Playoff(data)))).toPromise();
+    }
+    async getGroups(tournamentRoundId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_round/${tournamentRoundId}/groups/`).pipe(map(data => data.map(item => new TournamentGroup(item)))).toPromise();
+    }
+    async getGames(roundId, page, size, filters) {
+        let params = new HttpParams().set('page', page.toString());
+        if (size) {
+            params = params.set('size', size.toString());
+        }
+        params = applyGamesFilters(filters, params);
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_round/${roundId}/games/`, { params, observe: 'response' }).pipe(map(result => ({
+            total: +result.headers.get('X-Page-Count'),
+            data: result.body.map(item => new Game(item))
+        }))).toPromise();
+    }
+}
+TournamentRoundApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TournamentRoundApi, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+TournamentRoundApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TournamentRoundApi, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TournamentRoundApi, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tournament-round-api.js","sourceRoot":"","sources":["../../../../projects/core/src/api/tournament-round-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient, HttpParams } from '@angular/common/http';\nimport { ConfigService } from '../services/config.service';\nimport { TournamentRound } from '../models/tournament-round';\nimport { map } from 'rxjs/operators';\nimport { TournamentRoundTeam } from '../models/tournament-round-team';\nimport { Playoff } from '../models/playoff';\nimport { TournamentGroup } from '../models/tournament-group';\nimport { applyGamesFilters, TournamentGamesFilters } from './tournament-api';\nimport { PaginatedResponse } from './paginated-response.interface';\nimport { Game } from '../models/game';\n\nexport interface TournamentRoundTeamsFilters {\n  groupId?: number;\n  divisionId?: number;\n}\n\n@Injectable({providedIn: 'root'})\nexport class TournamentRoundApi {\n  constructor(\n    private httpClient: HttpClient,\n    private configService: ConfigService,\n  ) {\n  }\n\n  async getById(tournamentRoundId: number): Promise<TournamentRound> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_round/${tournamentRoundId}/`).pipe(\n      map(data => new TournamentRound(data)),\n    ).toPromise();\n  }\n\n  async getTeams(tournamentRoundId: number, filters?: TournamentRoundTeamsFilters): Promise<TournamentRoundTeam[]> {\n    let params = new HttpParams();\n    if (filters) {\n      if (filters.divisionId) {\n        params = params.set('division_id', filters.divisionId);\n      }\n      if (filters.groupId) {\n        params = params.set('group_id', filters.groupId);\n      }\n    }\n    return this.httpClient.get<object[]>(\n      `${this.configService.get('apiUrl')}/api/v1/tournament_round/${tournamentRoundId}/teams/`,\n      {params}\n    ).pipe(\n      map(data => data.map(item => new TournamentRoundTeam(item))),\n    ).toPromise();\n  }\n\n  async getPlayoffs(tournamentRoundId: number): Promise<Playoff[]> {\n    return this.httpClient.get<object[]>(\n      `${this.configService.get('apiUrl')}/api/v1/tournament_round/${tournamentRoundId}/playoffs/`\n    ).pipe(\n      map(data => data.map(item => new Playoff(data))),\n    ).toPromise();\n  }\n\n  async getGroups(tournamentRoundId: number): Promise<TournamentGroup[]> {\n    return this.httpClient.get<object[]>(\n      `${this.configService.get('apiUrl')}/api/v1/tournament_round/${tournamentRoundId}/groups/`\n    ).pipe(\n      map(data => data.map(item => new TournamentGroup(item))),\n    ).toPromise();\n  }\n\n  async getGames(roundId: 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    params = applyGamesFilters(filters, params);\n    return this.httpClient.get<object[]>(\n      `${this.configService.get('apiUrl')}/api/v1/tournament_round/${roundId}/games/`,\n      {params, observe: 'response'}\n    ).pipe(\n      map(result => ({\n        total: +result.headers.get('X-Page-Count'),\n        data: result.body.map(item => new Game(item))\n      }))\n    ).toPromise();\n  }}\n"]}

package/esm2020/api/tournament-season-api.mjs

@@ -0,0 +1,92 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { TournamentSeason } from '../models/tournament-season';
+import { map } from 'rxjs/operators';
+import { Game } from '../models/game';
+import { Tournament } from '../models/tournament';
+import { applyGamesFilters } from './tournament-api';
+import { TournamentEvent, TournamentEventTypes } from '../models/tournament-event';
+import { applyGameMediaFilters } from './media-api';
+import { TournamentTeam } from '../models/tournament-team';
+import { GameTimelineStages } from '../models/game-timeline-stages';
+import { Playoff } from '../models/playoff';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+export class TournamentSeasonApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    async getByAlias(leagueId, alias) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/tournament_seasons/${alias}/`).pipe(map(result => new TournamentSeason(result))).toPromise();
+    }
+    async getTournaments(seasonId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_season/${seasonId}/tournaments/`).pipe(map(result => result.map(item => new Tournament(item)))).toPromise();
+    }
+    async getGames(seasonId, page, size, filters) {
+        let params = new HttpParams().set('page', page.toString());
+        if (size) {
+            params = params.set('size', size.toString());
+        }
+        params = applyGamesFilters(filters, params);
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_season/${seasonId}/games/`, { params, observe: 'response' }).pipe(map(result => ({
+            total: +result.headers.get('X-Page-Count'),
+            data: result.body.map(item => new Game(item)),
+        }))).toPromise();
+    }
+    async getEvents(seasonId, page, size, filters) {
+        let 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);
+            }
+            if (filters.tournamentTour) {
+                params = params.set('tournament_tour', filters.tournamentTour.toString());
+            }
+        }
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_season/${seasonId}/events/`, { params, observe: 'response' })
+            .pipe(map(result => ({
+            total: +result.headers.get('X-Page-Count'),
+            data: result.body.map(item => new TournamentEvent(item)),
+        })))
+            .toPromise();
+    }
+    async getGameMedia(seasonId, page, size, filters) {
+        let params = new HttpParams().set('page', page.toString()).set('size', size.toString());
+        params = applyGameMediaFilters(filters, params);
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_season/${seasonId}/game_media/`, { observe: 'response', params })
+            .pipe(map(response => {
+            return {
+                total: +response.headers.get('X-Page-Count'),
+                data: response.body.map(item => new Game(item)),
+            };
+        })).toPromise();
+    }
+    async getTeams(seasonId, short) {
+        let params = new HttpParams();
+        if (short) {
+            params = params.set('short', '1');
+        }
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_season/${seasonId}/teams/`, { params }).pipe(map(result => result.map(item => new TournamentTeam(item)))).toPromise();
+    }
+    async getPlayoffs(seasonId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_season/${seasonId}/playoffs/`).pipe(map(result => result.map(item => new Playoff(item)))).toPromise();
+    }
+    async getGamesStages(seasonId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_season/${seasonId}/games_stages/`)
+            .pipe(map(data => new GameTimelineStages(data)))
+            .toPromise();
+    }
+}
+TournamentSeasonApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TournamentSeasonApi, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+TournamentSeasonApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TournamentSeasonApi, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TournamentSeasonApi, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tournament-season-api.js","sourceRoot":"","sources":["../../../../projects/core/src/api/tournament-season-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient, HttpParams } from '@angular/common/http';\nimport { TournamentSeason } from '../models/tournament-season';\nimport { ConfigService } from '../services/config.service';\nimport { map } from 'rxjs/operators';\nimport { Game, GameStatuses } from '../models/game';\nimport { Tournament } from '../models/tournament';\nimport { applyGamesFilters, TournamentEventsListFilter, TournamentGamesFilters } from './tournament-api';\nimport { PaginatedResponse } from './paginated-response.interface';\nimport { TournamentEvent, TournamentEventTypes } from '../models/tournament-event';\nimport { applyGameMediaFilters, GameMediaFilters } from './media-api';\nimport { TournamentTeam } from '../models/tournament-team';\nimport { GameTimelineStages } from '../models/game-timeline-stages';\nimport { Playoff } from '../models/playoff';\n\n@Injectable({providedIn: 'root'})\nexport class TournamentSeasonApi {\n  constructor(\n    private httpClient: HttpClient,\n    private configService: ConfigService,\n  ) {\n  }\n\n  async getByAlias(leagueId: number, alias: string): Promise<TournamentSeason> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/tournament_seasons/${alias}/`).pipe(\n      map(result => new TournamentSeason(result))\n    ).toPromise();\n  }\n\n  async getTournaments(seasonId: number): Promise<Tournament[]> {\n    return this.httpClient.get<object[]>(\n      `${this.configService.get('apiUrl')}/api/v1/tournament_season/${seasonId}/tournaments/`\n    ).pipe(\n      map(result => result.map(item => new Tournament(item)))\n    ).toPromise();\n  }\n\n  async getGames(seasonId: 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    params = applyGamesFilters(filters, params);\n    return this.httpClient.get<object[]>(\n      `${this.configService.get('apiUrl')}/api/v1/tournament_season/${seasonId}/games/`,\n      {params, observe: 'response'}\n    ).pipe(\n      map(result => ({\n        total: +result.headers.get('X-Page-Count'),\n        data: result.body.map(item => new Game(item)),\n      }))\n    ).toPromise();\n  }\n\n  async getEvents(\n    seasonId: number, page: number, size: number,\n    filters?: TournamentEventsListFilter\n  ): 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      if (filters.tournamentTour) {\n        params = params.set('tournament_tour', filters.tournamentTour.toString());\n      }\n    }\n    return this.httpClient.get<object[]>(\n      `${this.configService.get('apiUrl')}/api/v1/tournament_season/${seasonId}/events/`,\n      {params, observe: 'response'}\n    )\n      .pipe(map(result => ({\n        total: +result.headers.get('X-Page-Count'),\n        data: result.body.map(item => new TournamentEvent(item)),\n      })))\n      .toPromise();\n  }\n\n  async getGameMedia(seasonId: number, page: number, size: number, filters: GameMediaFilters): Promise<PaginatedResponse<Game[]>> {\n    let params = new HttpParams().set('page', page.toString()).set('size', size.toString());\n    params = applyGameMediaFilters(filters, params);\n\n    return this.httpClient.get<object[]>(\n      `${this.configService.get('apiUrl')}/api/v1/tournament_season/${seasonId}/game_media/`,\n      {observe: 'response', params})\n      .pipe(\n        map(response => {\n          return {\n            total: +response.headers.get('X-Page-Count'),\n            data: response.body.map(item => new Game(item)),\n          };\n        })\n      ).toPromise();\n  }\n\n  async getTeams(seasonId: number, short?: boolean): Promise<TournamentTeam[]> {\n    let params = new HttpParams();\n    if (short) {\n      params = params.set('short', '1');\n    }\n    return this.httpClient.get<object[]>(\n      `${this.configService.get('apiUrl')}/api/v1/tournament_season/${seasonId}/teams/`,\n      {params}\n    ).pipe(\n      map(result => result.map(item => new TournamentTeam(item)))\n    ).toPromise();\n  }\n\n  async getPlayoffs(seasonId: number): Promise<Playoff[]> {\n    return this.httpClient.get<object[]>(\n      `${this.configService.get('apiUrl')}/api/v1/tournament_season/${seasonId}/playoffs/`\n    ).pipe(\n      map(result => result.map(item => new Playoff(item)))\n    ).toPromise();\n  }\n\n  async getGamesStages(seasonId: number): Promise<GameTimelineStages> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_season/${seasonId}/games_stages/`)\n      .pipe(map(data => new GameTimelineStages(data)))\n      .toPromise();\n  }\n}\n"]}

package/esm2020/api/tournament-stage-api.mjs

@@ -0,0 +1,48 @@
+import { Injectable } from '@angular/core';
+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 { TeamAchievement } from '../models/team-achievement';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+export class TournamentStageApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    async getById(id) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_stage/${id}/`)
+            .pipe(map(result => new TournamentStage(result)))
+            .toPromise();
+    }
+    async getGroups(stageId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_stage/${stageId}/groups/`)
+            .pipe(map(result => result.map(item => new TournamentGroup(item))))
+            .toPromise();
+    }
+    async getTeamsAchievements(stageId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_stage/${stageId}/achievements/`)
+            .pipe(map(result => result.map(item => new TeamAchievement(item))))
+            .toPromise();
+    }
+    async getPlayoffs(stageId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_stage/${stageId}/playoff/`)
+            .pipe(map(result => result.map(item => new Playoff(item))))
+            .toPromise();
+    }
+    async getTeams(stageId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_stage/${stageId}/teams/`)
+            .pipe(map(result => result.map(item => new TournamentStageTeam(item))))
+            .toPromise();
+    }
+}
+TournamentStageApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TournamentStageApi, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+TournamentStageApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TournamentStageApi, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TournamentStageApi, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/api/user-api.mjs

@@ -0,0 +1,219 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { User } from '../models/user';
+import { File } from '../models/file';
+import { map } from 'rxjs/operators';
+import { UserProfile } from '../models/user-profile';
+import { BasketballProfile } from '../models/basketball-profile';
+import { VolleyballProfile } from '../models/volleyball-profile';
+import { Team } from '../models/team';
+import { TeamInvite } from '../models/team-invite';
+import { BasketballStatistic } from '../models/basketball-statistic';
+import { VolleyballStatistic } from '../models/volleyball-statistic';
+import { Game } from '../models/game';
+import { GameInvite } from '../models/game-invite';
+import { TeamEvent } from '../models/team-event';
+import { UserAccess } from '../models/user-access';
+import { UserPermission } from '../models/user-permission';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+export class UserApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    async getCurrentUser() {
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/current/`)
+            .pipe(map(data => new User(data)))
+            .toPromise();
+    }
+    async getUserById(userId) {
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/`)
+            .pipe(map(data => new User(data)))
+            .toPromise();
+    }
+    async getAccess(userId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/user/${userId || 'current'}/access/`)
+            .pipe(map(data => new UserAccess(data)))
+            .toPromise();
+    }
+    async updateUser(userId, data) {
+        return this.httpClient
+            .patch(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/`, data.json())
+            .pipe(map(result => new User(result)))
+            .toPromise();
+    }
+    async updateUserPhoto(file, filename) {
+        const formData = new FormData();
+        formData.append('file', file, filename);
+        return this.httpClient
+            .post(`${this.configService.get('apiUrl')}/api/v1/user/current/photo/`, formData)
+            .pipe(map(data => new File(data)))
+            .toPromise();
+    }
+    async changePassword(userId, oldPassword, password, passwordConfirm) {
+        const payload = {
+            old_password: oldPassword,
+            password,
+            password_confirm: passwordConfirm
+        };
+        return this.httpClient
+            .post(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/change_password/`, payload)
+            .toPromise();
+    }
+    async changeEmail(userId, email, password) {
+        const payload = { email, password };
+        return this.httpClient
+            .post(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/change_email/`, payload)
+            .toPromise();
+    }
+    async changeEmailConfirm(userId, email, password, token) {
+        const payload = { email, password, token };
+        return this.httpClient
+            .post(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/change_email_confirm/`, payload)
+            .toPromise();
+    }
+    async getUserProfile(userId) {
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/profile/`)
+            .pipe(map(data => new UserProfile(data)))
+            .toPromise();
+    }
+    async getBasketballProfile(userId) {
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/basketball_profile/`)
+            .pipe(map(data => new BasketballProfile(data)))
+            .toPromise();
+    }
+    async getVolleyballProfile(userId) {
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/volleyball_profile/`)
+            .pipe(map(data => new VolleyballProfile(data)))
+            .toPromise();
+    }
+    async updateUserProfile(userProfile) {
+        return this.httpClient
+            .patch(`${this.configService.get('apiUrl')}/api/v1/user/${userProfile.userId}/profile/`, userProfile.json())
+            .pipe(map(data => new UserProfile(data)))
+            .toPromise();
+    }
+    async updateUserBasketballProfile(basketballProfile) {
+        return this.httpClient
+            .patch(`${this.configService.get('apiUrl')}/api/v1/user/${basketballProfile.userId}/basketball_profile/`, basketballProfile.json())
+            .pipe(map(data => new BasketballProfile(data)))
+            .toPromise();
+    }
+    async updateUserVolleyballProfile(volleyballProfile) {
+        return this.httpClient
+            .patch(`${this.configService.get('apiUrl')}/api/v1/user/${volleyballProfile.userId}/volleyball_profile/`, volleyballProfile.json())
+            .pipe(map(data => new VolleyballProfile(data)))
+            .toPromise();
+    }
+    async getUserPermissions(userId) {
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId || 'current'}/permission/`)
+            .pipe(map(data => new UserPermission(data)))
+            .toPromise();
+    }
+    async updateUserPermission(data) {
+        return this.httpClient
+            .patch(`${this.configService.get('apiUrl')}/api/v1/user/current/permission/`, data.json())
+            .pipe(map(result => new UserPermission(result)))
+            .toPromise();
+    }
+    async getTeams(userId) {
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/teams/`)
+            .pipe(map(data => data.map(item => new Team(item))))
+            .toPromise();
+    }
+    async getInvites() {
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/current/invites/`)
+            .pipe(map(data => data.map(item => new TeamInvite(item))))
+            .toPromise();
+    }
+    async acceptInvite(inviteId) {
+        return this.httpClient
+            .post(`${this.configService.get('apiUrl')}/api/v1/user/current/invites/${inviteId}/accept/`, {})
+            .pipe(map(data => new TeamInvite(data)))
+            .toPromise();
+    }
+    async declineInvite(inviteId) {
+        return this.httpClient
+            .post(`${this.configService.get('apiUrl')}/api/v1/user/current/invites/${inviteId}/decline/`, {})
+            .pipe(map(data => new TeamInvite(data)))
+            .toPromise();
+    }
+    async getStatistics(userId) {
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/statistics/`)
+            .pipe(map(data => new BasketballStatistic(data)))
+            .toPromise();
+    }
+    async getStreetballStatistics(userId) {
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/streetball_statistics/`)
+            .pipe(map(data => new BasketballStatistic(data)))
+            .toPromise();
+    }
+    async getVolleyballStatistic(userId) {
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/volleyball_statistics/`)
+            .pipe(map(data => new VolleyballStatistic(data)))
+            .toPromise();
+    }
+    async getGames(userId) {
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/games/`)
+            .pipe(map(data => data.map(item => new Game(item))))
+            .toPromise();
+    }
+    async getGameInvites() {
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/current/game_invites/`)
+            .pipe(map(data => data.map(item => new GameInvite(item))))
+            .toPromise();
+    }
+    async acceptGameInvite(inviteId) {
+        return this.httpClient
+            .post(`${this.configService.get('apiUrl')}/api/v1/user/current/game_invites/${inviteId}/accept/`, {})
+            .pipe(map(data => new GameInvite(data)))
+            .toPromise();
+    }
+    async declineGameInvite(inviteId) {
+        return this.httpClient
+            .post(`${this.configService.get('apiUrl')}/api/v1/user/current/game_invites/${inviteId}/decline/`, {})
+            .pipe(map(data => new GameInvite(data)))
+            .toPromise();
+    }
+    async searchUsers(query) {
+        const params = (new HttpParams()).set('search', query);
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/`, { params })
+            .pipe(map(data => data.map(item => new User(item))))
+            .toPromise();
+    }
+    async setWizardShowed(wizard) {
+        return this.httpClient
+            .put(`${this.configService.get('apiUrl')}/api/v1/user/current/wizards/`, { wizard })
+            .pipe(map(data => new User(data)))
+            .toPromise();
+    }
+    async getTeamEvents(userId) {
+        return this.httpClient
+            .get(`${this.configService.get('apiUrl')}/api/v1/user/current/team_events/`)
+            .pipe(map(data => data.map(item => new TeamEvent(item))))
+            .toPromise();
+    }
+}
+UserApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: UserApi, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+UserApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: UserApi, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: UserApi, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-api.js","sourceRoot":"","sources":["../../../../projects/core/src/api/user-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient, HttpParams } from '@angular/common/http';\nimport { User } from '../models/user';\nimport { File } from '../models/file';\nimport { map } from 'rxjs/operators';\nimport { UserProfile } from '../models/user-profile';\nimport { BasketballProfile } from '../models/basketball-profile';\nimport { VolleyballProfile } from '../models/volleyball-profile';\nimport { Team } from '../models/team';\nimport { TeamInvite } from '../models/team-invite';\nimport { BasketballStatistic } from '../models/basketball-statistic';\nimport { VolleyballStatistic } from '../models/volleyball-statistic';\nimport { Game } from '../models/game';\nimport { GameInvite } from '../models/game-invite';\nimport { TeamEvent } from '../models/team-event';\nimport { UserAccess } from '../models/user-access';\nimport { UserPermission } from '../models/user-permission';\nimport { ConfigService } from '../services/config.service';\n\n@Injectable({providedIn: 'root'})\nexport class UserApi {\n  constructor(\n    private httpClient: HttpClient,\n    private configService: ConfigService,\n  ) {}\n\n  async getCurrentUser(): Promise<User> {\n    return this.httpClient\n      .get(`${this.configService.get('apiUrl')}/api/v1/user/current/`)\n      .pipe(map(data => new User(data)))\n      .toPromise();\n  }\n\n  async getUserById(userId: number): Promise<User> {\n    return this.httpClient\n      .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/`)\n      .pipe(map(data => new User(data)))\n      .toPromise();\n  }\n\n  async getAccess(userId?: number): Promise<UserAccess> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/user/${userId || 'current'}/access/`)\n      .pipe(map(data => new UserAccess(data)))\n      .toPromise();\n  }\n\n  async updateUser(userId: number, data: User): Promise<User> {\n    return this.httpClient\n      .patch(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/`, data.json())\n      .pipe(map(result => new User(result)))\n      .toPromise();\n  }\n\n  async updateUserPhoto(file: any, filename?: string): Promise<File> {\n    const formData = new FormData();\n    formData.append('file', file, filename);\n    return this.httpClient\n      .post(`${this.configService.get('apiUrl')}/api/v1/user/current/photo/`, formData)\n      .pipe(map(data => new File(data)))\n      .toPromise();\n  }\n\n  async changePassword(userId: number, oldPassword: string, password: string, passwordConfirm: string): Promise<any> {\n    const payload = {\n      old_password: oldPassword,\n      password,\n      password_confirm: passwordConfirm\n    };\n    return this.httpClient\n      .post(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/change_password/`, payload)\n      .toPromise();\n  }\n\n  async changeEmail(userId: number, email: string, password: string): Promise<any> {\n    const payload = {email, password};\n    return this.httpClient\n      .post(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/change_email/`, payload)\n      .toPromise();\n  }\n\n  async changeEmailConfirm(userId, email: string, password: string, token: number): Promise<any> {\n    const payload = {email, password, token};\n    return this.httpClient\n      .post(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/change_email_confirm/`, payload)\n      .toPromise();\n  }\n\n  async getUserProfile(userId: number): Promise<UserProfile> {\n    return this.httpClient\n      .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/profile/`)\n      .pipe(map(data => new UserProfile(data)))\n      .toPromise();\n  }\n\n  async getBasketballProfile(userId: number): Promise<BasketballProfile> {\n    return this.httpClient\n      .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/basketball_profile/`)\n      .pipe(map(data => new BasketballProfile(data)))\n      .toPromise();\n  }\n\n  async getVolleyballProfile(userId: number): Promise<VolleyballProfile> {\n    return this.httpClient\n      .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/volleyball_profile/`)\n      .pipe(map(data => new VolleyballProfile(data)))\n      .toPromise();\n  }\n\n  async updateUserProfile(userProfile: UserProfile): Promise<UserProfile> {\n    return this.httpClient\n      .patch(`${this.configService.get('apiUrl')}/api/v1/user/${userProfile.userId}/profile/`, userProfile.json())\n      .pipe(map(data => new UserProfile(data)))\n      .toPromise();\n  }\n\n  async updateUserBasketballProfile(basketballProfile: BasketballProfile): Promise<BasketballProfile> {\n    return this.httpClient\n      .patch(`${this.configService.get('apiUrl')}/api/v1/user/${basketballProfile.userId}/basketball_profile/`, basketballProfile.json())\n      .pipe(map(data => new BasketballProfile(data)))\n      .toPromise();\n  }\n\n  async updateUserVolleyballProfile(volleyballProfile: VolleyballProfile): Promise<VolleyballProfile> {\n    return this.httpClient\n      .patch(`${this.configService.get('apiUrl')}/api/v1/user/${volleyballProfile.userId}/volleyball_profile/`, volleyballProfile.json())\n      .pipe(map(data => new VolleyballProfile(data)))\n      .toPromise();\n  }\n\n  async getUserPermissions(userId?: number): Promise<UserPermission> {\n    return this.httpClient\n      .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId || 'current'}/permission/`)\n      .pipe(map(data => new UserPermission(data)))\n      .toPromise();\n  }\n\n  async updateUserPermission(data: UserPermission): Promise<UserPermission> {\n    return this.httpClient\n      .patch(`${this.configService.get('apiUrl')}/api/v1/user/current/permission/`, data.json())\n      .pipe(map(result => new UserPermission(result)))\n      .toPromise();\n  }\n\n  async getTeams(userId: number): Promise<Team[]> {\n    return this.httpClient\n      .get<object[]>(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/teams/`)\n      .pipe(map(data => data.map(item => new Team(item))))\n      .toPromise();\n  }\n\n  async getInvites(): Promise<TeamInvite[]> {\n    return this.httpClient\n      .get<object[]>(`${this.configService.get('apiUrl')}/api/v1/user/current/invites/`)\n      .pipe(map(data => data.map(item => new TeamInvite(item))))\n      .toPromise();\n  }\n\n  async acceptInvite(inviteId: number): Promise<TeamInvite> {\n    return this.httpClient\n      .post(`${this.configService.get('apiUrl')}/api/v1/user/current/invites/${inviteId}/accept/`, {})\n      .pipe(map(data => new TeamInvite(data)))\n      .toPromise();\n  }\n\n  async declineInvite(inviteId: number): Promise<TeamInvite> {\n    return this.httpClient\n      .post(`${this.configService.get('apiUrl')}/api/v1/user/current/invites/${inviteId}/decline/`, {})\n      .pipe(map(data => new TeamInvite(data)))\n      .toPromise();\n  }\n\n  async getStatistics(userId: number): Promise<BasketballStatistic> {\n    return this.httpClient\n      .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/statistics/`)\n      .pipe(map(data => new BasketballStatistic(data)))\n      .toPromise();\n  }\n\n  async getStreetballStatistics(userId: number): Promise<BasketballStatistic> {\n    return this.httpClient\n      .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/streetball_statistics/`)\n      .pipe(map(data => new BasketballStatistic(data)))\n      .toPromise();\n  }\n\n  async getVolleyballStatistic(userId: number): Promise<VolleyballStatistic> {\n    return this.httpClient\n      .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/volleyball_statistics/`)\n      .pipe(map(data => new VolleyballStatistic(data)))\n      .toPromise();\n  }\n\n  async getGames(userId: number): Promise<Game[]> {\n    return this.httpClient\n      .get<object[]>(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/games/`)\n      .pipe(map(data => data.map(item => new Game(item))))\n      .toPromise();\n  }\n\n  async getGameInvites(): Promise<GameInvite[]> {\n    return this.httpClient\n      .get<object[]>(`${this.configService.get('apiUrl')}/api/v1/user/current/game_invites/`)\n      .pipe(map(data => data.map(item => new GameInvite(item))))\n      .toPromise();\n  }\n\n  async acceptGameInvite(inviteId: number): Promise<GameInvite> {\n    return this.httpClient\n      .post(`${this.configService.get('apiUrl')}/api/v1/user/current/game_invites/${inviteId}/accept/`, {})\n      .pipe(map(data => new GameInvite(data)))\n      .toPromise();\n  }\n\n  async declineGameInvite(inviteId: number): Promise<GameInvite> {\n    return this.httpClient\n      .post(`${this.configService.get('apiUrl')}/api/v1/user/current/game_invites/${inviteId}/decline/`, {})\n      .pipe(map(data => new GameInvite(data)))\n      .toPromise();\n  }\n\n  async searchUsers(query: string): Promise<User[]> {\n    const params = (new HttpParams()).set('search', query);\n    return this.httpClient\n      .get<object[]>(`${this.configService.get('apiUrl')}/api/v1/user/`, {params})\n      .pipe(map(data => data.map(item => new User(item))))\n      .toPromise();\n  }\n\n  async setWizardShowed(wizard: string): Promise<User> {\n    return this.httpClient\n      .put(`${this.configService.get('apiUrl')}/api/v1/user/current/wizards/`, {wizard})\n      .pipe(map(data => new User(data)))\n      .toPromise();\n  }\n\n  async getTeamEvents(userId: number): Promise<TeamEvent[]> {\n    return this.httpClient\n      .get<object[]>(`${this.configService.get('apiUrl')}/api/v1/user/current/team_events/`)\n      .pipe(map(data => data.map(item => new TeamEvent(item))))\n      .toPromise();\n  }\n}\n"]}

package/esm2020/api/volleyball-game-api.mjs

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { Game } from '../models/game';
+import { map } from 'rxjs/operators';
+import { VolleyballGameTeamStatistic } from '../models/volleyball-game-team-statistic';
+import { VolleyballGameStatistic } from '../models/volleyball-game-statistic';
+import { VolleyballGameLog } from '../models/volleyball-game-log';
+import { GameBaseApi } from './game-base-api';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+export class VolleyballGameApi extends GameBaseApi {
+    constructor(httpClient, configService) {
+        super(httpClient, configService);
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    async getById(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_volleyball_game/${gameId}/`).pipe(map(result => new Game(result))).toPromise();
+    }
+    async getTeamStatistic(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_volleyball_game/${gameId}/team_statistic/`).pipe(map(result => new VolleyballGameTeamStatistic(result))).toPromise();
+    }
+    async getUserStatistic(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_volleyball_game/${gameId}/user_statistic/`).pipe(map(result => result.map(item => new VolleyballGameStatistic(item)))).toPromise();
+    }
+    async getLogs(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_volleyball_game/${gameId}/logs/`).pipe(map(result => result.map(item => new VolleyballGameLog(item)))).toPromise();
+    }
+    async downloadProtocolLight(gameId, format) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_volleyball_game/${gameId}/game_protocol_light/`, {
+            params: new HttpParams().set('file_type', format),
+            responseType: 'blob'
+        }).toPromise();
+    }
+    async downloadProtocol(gameId, format) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_volleyball_game/${gameId}/game_protocol/`, {
+            params: new HttpParams().set('file_type', format),
+            responseType: 'blob'
+        }).toPromise();
+    }
+}
+VolleyballGameApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: VolleyballGameApi, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+VolleyballGameApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: VolleyballGameApi, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: VolleyballGameApi, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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