@mtgame/core 0.2.26 → 2.0.0

package/esm2020/api/file-api.mjs

@@ -0,0 +1,41 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { File } from '../models/file';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+export class FileApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    async upload(fileData, filename, width, height) {
+        let params = new HttpParams();
+        if (width && height) {
+            params = params.set('width', width.toString()).set('height', height.toString());
+        }
+        const formData = new FormData();
+        formData.append('file', fileData, filename);
+        return this.httpClient
+            .post(`${this.configService.get('apiUrl')}/api/v1/file/`, formData, { params })
+            .pipe(map(data => new File(data)))
+            .toPromise();
+    }
+    async createZipArchive(files) {
+        const formData = new FormData();
+        for (const file of files) {
+            formData.append('files', file.file, file.filename);
+        }
+        return this.httpClient
+            .post(`${this.configService.get('apiUrl')}/api/v1/file/zip_archive/`, formData, { responseType: 'blob' })
+            .toPromise();
+    }
+}
+FileApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: FileApi, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+FileApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: FileApi, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: FileApi, 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/football-game-api.mjs

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { Game } from '../models/game';
+import { FootballGameLog } from '../models/football-game-log';
+import { FootballGameStatistic } from '../models/football-game-statistic';
+import { FootballGameTeamStatistic } from '../models/football-game-team-statistic';
+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 FootballGameApi 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_football_game/${gameId}/`).pipe(map(result => new Game(result))).toPromise();
+    }
+    async getTeamStatistic(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_football_game/${gameId}/team_statistic/`).pipe(map(result => new FootballGameTeamStatistic(result))).toPromise();
+    }
+    async getUserStatistic(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_football_game/${gameId}/user_statistic/`).pipe(map(result => result.map(item => new FootballGameStatistic(item)))).toPromise();
+    }
+    async getLogs(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_football_game/${gameId}/logs/`).pipe(map(result => result.map(item => new FootballGameLog(result)))).toPromise();
+    }
+    async downloadProtocol(gameId, format) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_football_game/${gameId}/game_protocol/`, {
+            params: new HttpParams().set('file_type', format),
+            responseType: 'blob'
+        }).toPromise();
+    }
+    async downloadApplication(gameId, format, type) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_football_game/${gameId}/game_application_file/`, {
+            params: new HttpParams().set('file_type', format).set('application_type', type),
+            responseType: 'blob'
+        }).toPromise();
+    }
+}
+FootballGameApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: FootballGameApi, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+FootballGameApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: FootballGameApi, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: FootballGameApi, 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/game-base-api.mjs

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { GameUser } from '../models/game-user';
+import { map } from 'rxjs/operators';
+import { GameUserLimitations } from '../models/game-user-limitation';
+import { GameUserDisqualification } from '../models/game-user-disqualification';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+export class GameBaseApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    async getUsers(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_game/${gameId}/users/`).pipe(map(result => result.map(item => new GameUser(item)))).toPromise();
+    }
+    async getMvp(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_game/${gameId}/mvp/`).pipe(map(result => result.map(item => new GameUser(item)))).toPromise();
+    }
+    async getUsersLimitation(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_game/${gameId}/users_limitation/`).pipe(map(result => result.map(item => new GameUserLimitations(item)))).toPromise();
+    }
+    async getUsersDisqualification(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_game/${gameId}/users_disqualification/`).pipe(map(result => result.map(item => new GameUserDisqualification(item)))).toPromise();
+    }
+    async downloadApplication(gameId, format, type) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_game/${gameId}/game_application/`, {
+            params: new HttpParams().set('file_type', format).set('application_type', type),
+            responseType: 'blob'
+        }).toPromise();
+    }
+}
+GameBaseApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: GameBaseApi, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+GameBaseApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: GameBaseApi, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: GameBaseApi, 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/handball-game-api.mjs

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { Game } from '../models/game';
+import { HandballGameLog } from '../models/handball-game-log';
+import { HandballGameStatistic } from '../models/handball-game-statistic';
+import { HandballGameTeamStatistic } from '../models/handball-game-team-statistic';
+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 HandballGameApi 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_handball_game/${gameId}/`).pipe(map(result => new Game(result))).toPromise();
+    }
+    async getTeamStatistic(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_handball_game/${gameId}/team_statistic/`).pipe(map(result => new HandballGameTeamStatistic(result))).toPromise();
+    }
+    async getUserStatistic(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_handball_game/${gameId}/user_statistic/`).pipe(map(result => result.map(item => new HandballGameStatistic(item)))).toPromise();
+    }
+    async getLogs(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_handball_game/${gameId}/logs/`).pipe(map(result => result.map(item => new HandballGameLog(item)))).toPromise();
+    }
+    async downloadProtocol(gameId, format) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_handball_game/${gameId}/game_protocol/`, {
+            params: new HttpParams().set('file_type', format),
+            responseType: 'blob'
+        }).toPromise();
+    }
+    async downloadApplication(gameId, format, type) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_handball_game/${gameId}/game_application_file/`, {
+            params: new HttpParams().set('file_type', format).set('application_type', type),
+            responseType: 'blob'
+        }).toPromise();
+    }
+}
+HandballGameApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: HandballGameApi, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+HandballGameApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: HandballGameApi, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: HandballGameApi, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZGJhbGwtZ2FtZS1hcGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlL3NyYy9hcGkvaGFuZGJhbGwtZ2FtZS1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQWMsVUFBVSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDOUQsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3JDLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUV0QyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDOUQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFDMUUsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDbkYsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlCQUFpQixDQUFDOzs7O0FBRzlDLE1BQU0sT0FBTyxlQUFnQixTQUFRLFdBQVc7SUFDOUMsWUFDWSxVQUFzQixFQUN0QixhQUE0QjtRQUV0QyxLQUFLLENBQUMsVUFBVSxFQUFFLGFBQWEsQ0FBQyxDQUFDO1FBSHZCLGVBQVUsR0FBVixVQUFVLENBQVk7UUFDdEIsa0JBQWEsR0FBYixhQUFhLENBQWU7SUFHeEMsQ0FBQztJQUVELEtBQUssQ0FBQyxPQUFPLENBQUMsTUFBYztRQUMxQixPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLG9DQUFvQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FDL0csR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsSUFBSSxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FDaEMsQ0FBQyxTQUFTLEVBQUUsQ0FBQztJQUNoQixDQUFDO0lBRUQsS0FBSyxDQUFDLGdCQUFnQixDQUFDLE1BQWM7UUFDbkMsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxvQ0FBb0MsTUFBTSxrQkFBa0IsQ0FBQyxDQUFDLElBQUksQ0FDOUgsR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsSUFBSSx5QkFBeUIsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUNyRCxDQUFDLFNBQVMsRUFBRSxDQUFDO0lBQ2hCLENBQUM7SUFFRCxLQUFLLENBQUMsZ0JBQWdCLENBQUMsTUFBYztRQUNuQyxPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUN4QixHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxvQ0FBb0MsTUFBTSxrQkFBa0IsQ0FDaEcsQ0FBQyxJQUFJLENBQ0osR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLElBQUkscUJBQXFCLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUNuRSxDQUFDLFNBQVMsRUFBRSxDQUFDO0lBQ2hCLENBQUM7SUFFRCxLQUFLLENBQUMsT0FBTyxDQUFDLE1BQWM7UUFDMUIsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBVyxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxvQ0FBb0MsTUFBTSxRQUFRLENBQUMsQ0FBQyxJQUFJLENBQzlILEdBQUcsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLGVBQWUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQzdELENBQUMsU0FBUyxFQUFFLENBQUM7SUFDaEIsQ0FBQztJQUVELEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxNQUFjLEVBQUUsTUFBK0I7UUFDcEUsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxvQ0FBb0MsTUFBTSxpQkFBaUIsRUFBRTtZQUN6SCxNQUFNLEVBQUUsSUFBSSxVQUFVLEVBQUUsQ0FBQyxHQUFHLENBQUMsV0FBVyxFQUFFLE1BQU0sQ0FBQztZQUNqRCxZQUFZLEVBQUUsTUFBTTtTQUNyQixDQUFDLENBQUMsU0FBUyxFQUFFLENBQUM7SUFDakIsQ0FBQztJQUVELEtBQUssQ0FBQyxtQkFBbUIsQ0FBQyxNQUFjLEVBQUUsTUFBK0IsRUFBRSxJQUFxQztRQUM5RyxPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLG9DQUFvQyxNQUFNLHlCQUF5QixFQUFFO1lBQ2pJLE1BQU0sRUFBRSxJQUFJLFVBQVUsRUFBRSxDQUFDLEdBQUcsQ0FBQyxXQUFXLEVBQUUsTUFBTSxDQUFDLENBQUMsR0FBRyxDQUFDLGtCQUFrQixFQUFFLElBQUksQ0FBQztZQUMvRSxZQUFZLEVBQUUsTUFBTTtTQUNyQixDQUFDLENBQUMsU0FBUyxFQUFFLENBQUM7SUFDakIsQ0FBQzs7NkdBOUNVLGVBQWU7aUhBQWYsZUFBZSxjQURILE1BQU07NEZBQ2xCLGVBQWU7a0JBRDNCLFVBQVU7bUJBQUMsRUFBQyxVQUFVLEVBQUUsTUFBTSxFQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgSHR0cENsaWVudCwgSHR0cFBhcmFtcyB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IG1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcbmltcG9ydCB7IEdhbWUgfSBmcm9tICcuLi9tb2RlbHMvZ2FtZSc7XG5pbXBvcnQgeyBDb25maWdTZXJ2aWNlIH0gZnJvbSAnLi4vc2VydmljZXMvY29uZmlnLnNlcnZpY2UnO1xuaW1wb3J0IHsgSGFuZGJhbGxHYW1lTG9nIH0gZnJvbSAnLi4vbW9kZWxzL2hhbmRiYWxsLWdhbWUtbG9nJztcbmltcG9ydCB7IEhhbmRiYWxsR2FtZVN0YXRpc3RpYyB9IGZyb20gJy4uL21vZGVscy9oYW5kYmFsbC1nYW1lLXN0YXRpc3RpYyc7XG5pbXBvcnQgeyBIYW5kYmFsbEdhbWVUZWFtU3RhdGlzdGljIH0gZnJvbSAnLi4vbW9kZWxzL2hhbmRiYWxsLWdhbWUtdGVhbS1zdGF0aXN0aWMnO1xuaW1wb3J0IHsgR2FtZUJhc2VBcGkgfSBmcm9tICcuL2dhbWUtYmFzZS1hcGknO1xuXG5ASW5qZWN0YWJsZSh7cHJvdmlkZWRJbjogJ3Jvb3QnfSlcbmV4cG9ydCBjbGFzcyBIYW5kYmFsbEdhbWVBcGkgZXh0ZW5kcyBHYW1lQmFzZUFwaSB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIHByb3RlY3RlZCBodHRwQ2xpZW50OiBIdHRwQ2xpZW50LFxuICAgIHByb3RlY3RlZCBjb25maWdTZXJ2aWNlOiBDb25maWdTZXJ2aWNlXG4gICkge1xuICAgIHN1cGVyKGh0dHBDbGllbnQsIGNvbmZpZ1NlcnZpY2UpO1xuICB9XG5cbiAgYXN5bmMgZ2V0QnlJZChnYW1lSWQ6IG51bWJlcik6IFByb21pc2U8R2FtZT4ge1xuICAgIHJldHVybiB0aGlzLmh0dHBDbGllbnQuZ2V0KGAke3RoaXMuY29uZmlnU2VydmljZS5nZXQoJ2FwaVVybCcpfS9hcGkvdjEvdG91cm5hbWVudF9oYW5kYmFsbF9nYW1lLyR7Z2FtZUlkfS9gKS5waXBlKFxuICAgICAgbWFwKHJlc3VsdCA9PiBuZXcgR2FtZShyZXN1bHQpKVxuICAgICkudG9Qcm9taXNlKCk7XG4gIH1cblxuICBhc3luYyBnZXRUZWFtU3RhdGlzdGljKGdhbWVJZDogbnVtYmVyKTogUHJvbWlzZTxIYW5kYmFsbEdhbWVUZWFtU3RhdGlzdGljPiB7XG4gICAgcmV0dXJuIHRoaXMuaHR0cENsaWVudC5nZXQoYCR7dGhpcy5jb25maWdTZXJ2aWNlLmdldCgnYXBpVXJsJyl9L2FwaS92MS90b3VybmFtZW50X2hhbmRiYWxsX2dhbWUvJHtnYW1lSWR9L3RlYW1fc3RhdGlzdGljL2ApLnBpcGUoXG4gICAgICBtYXAocmVzdWx0ID0+IG5ldyBIYW5kYmFsbEdhbWVUZWFtU3RhdGlzdGljKHJlc3VsdCkpXG4gICAgKS50b1Byb21pc2UoKTtcbiAgfVxuXG4gIGFzeW5jIGdldFVzZXJTdGF0aXN0aWMoZ2FtZUlkOiBudW1iZXIpOiBQcm9taXNlPEhhbmRiYWxsR2FtZVN0YXRpc3RpY1tdPiB7XG4gICAgcmV0dXJuIHRoaXMuaHR0cENsaWVudC5nZXQ8b2JqZWN0W10+KFxuICAgICAgYCR7dGhpcy5jb25maWdTZXJ2aWNlLmdldCgnYXBpVXJsJyl9L2FwaS92MS90b3VybmFtZW50X2hhbmRiYWxsX2dhbWUvJHtnYW1lSWR9L3VzZXJfc3RhdGlzdGljL2BcbiAgICApLnBpcGUoXG4gICAgICBtYXAocmVzdWx0ID0+IHJlc3VsdC5tYXAoaXRlbSA9PiBuZXcgSGFuZGJhbGxHYW1lU3RhdGlzdGljKGl0ZW0pKSksXG4gICAgKS50b1Byb21pc2UoKTtcbiAgfVxuXG4gIGFzeW5jIGdldExvZ3MoZ2FtZUlkOiBudW1iZXIpOiBQcm9taXNlPEhhbmRiYWxsR2FtZUxvZ1tdPiB7XG4gICAgcmV0dXJuIHRoaXMuaHR0cENsaWVudC5nZXQ8b2JqZWN0W10+KGAke3RoaXMuY29uZmlnU2VydmljZS5nZXQoJ2FwaVVybCcpfS9hcGkvdjEvdG91cm5hbWVudF9oYW5kYmFsbF9nYW1lLyR7Z2FtZUlkfS9sb2dzL2ApLnBpcGUoXG4gICAgICBtYXAocmVzdWx0ID0+IHJlc3VsdC5tYXAoaXRlbSA9PiBuZXcgSGFuZGJhbGxHYW1lTG9nKGl0ZW0pKSksXG4gICAgKS50b1Byb21pc2UoKTtcbiAgfVxuXG4gIGFzeW5jIGRvd25sb2FkUHJvdG9jb2woZ2FtZUlkOiBudW1iZXIsIGZvcm1hdDogJ3BkZicgfCAneGxzeCcgfCAnaHRtbCcpOiBQcm9taXNlPGFueT4ge1xuICAgIHJldHVybiB0aGlzLmh0dHBDbGllbnQuZ2V0KGAke3RoaXMuY29uZmlnU2VydmljZS5nZXQoJ2FwaVVybCcpfS9hcGkvdjEvdG91cm5hbWVudF9oYW5kYmFsbF9nYW1lLyR7Z2FtZUlkfS9nYW1lX3Byb3RvY29sL2AsIHtcbiAgICAgIHBhcmFtczogbmV3IEh0dHBQYXJhbXMoKS5zZXQoJ2ZpbGVfdHlwZScsIGZvcm1hdCksXG4gICAgICByZXNwb25zZVR5cGU6ICdibG9iJ1xuICAgIH0pLnRvUHJvbWlzZSgpO1xuICB9XG5cbiAgYXN5bmMgZG93bmxvYWRBcHBsaWNhdGlvbihnYW1lSWQ6IG51bWJlciwgZm9ybWF0OiAncGRmJyB8ICd4bHN4JyB8ICdodG1sJywgdHlwZTogJ2dhbWVfdXNlcicgfCAndG91cm5hbWVudF91c2VyJyk6IFByb21pc2U8YW55PiB7XG4gICAgcmV0dXJuIHRoaXMuaHR0cENsaWVudC5nZXQoYCR7dGhpcy5jb25maWdTZXJ2aWNlLmdldCgnYXBpVXJsJyl9L2FwaS92MS90b3VybmFtZW50X2hhbmRiYWxsX2dhbWUvJHtnYW1lSWR9L2dhbWVfYXBwbGljYXRpb25fZmlsZS9gLCB7XG4gICAgICBwYXJhbXM6IG5ldyBIdHRwUGFyYW1zKCkuc2V0KCdmaWxlX3R5cGUnLCBmb3JtYXQpLnNldCgnYXBwbGljYXRpb25fdHlwZScsIHR5cGUpLFxuICAgICAgcmVzcG9uc2VUeXBlOiAnYmxvYidcbiAgICB9KS50b1Byb21pc2UoKTtcbiAgfVxufVxuIl19

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

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { Game } from '../models/game';
+import { HockeyGameLog } from '../models/hockey-game-log';
+import { HockeyGameStatistic } from '../models/hockey-game-statistic';
+import { HockeyGameTeamStatistic } from '../models/hockey-game-team-statistic';
+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 HockeyGameApi 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_hockey_game/${gameId}/`).pipe(map(result => new Game(result))).toPromise();
+    }
+    async getTeamStatistic(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_hockey_game/${gameId}/team_statistic/`).pipe(map(result => new HockeyGameTeamStatistic(result))).toPromise();
+    }
+    async getUserStatistic(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_hockey_game/${gameId}/user_statistic/`).pipe(map(result => result.map(item => new HockeyGameStatistic(item)))).toPromise();
+    }
+    async getLogs(gameId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_hockey_game/${gameId}/logs/`).pipe(map(result => result.map(item => new HockeyGameLog(item)))).toPromise();
+    }
+    async downloadProtocol(gameId, format) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_hockey_game/${gameId}/game_protocol/`, {
+            params: new HttpParams().set('file_type', format),
+            responseType: 'blob'
+        }).toPromise();
+    }
+    async downloadApplication(gameId, format, type) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament_hockey_game/${gameId}/game_application_file/`, {
+            params: new HttpParams().set('file_type', format).set('application_type', type),
+            responseType: 'blob'
+        }).toPromise();
+    }
+}
+HockeyGameApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: HockeyGameApi, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+HockeyGameApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: HockeyGameApi, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: HockeyGameApi, 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/league-api.mjs

@@ -0,0 +1,119 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { League } from '../models/league';
+import { map } from 'rxjs/operators';
+import { Tournament, TournamentStatuses } from '../models/tournament';
+import { applyGamesFilters } from './tournament-api';
+import { TournamentEvent, TournamentEventTypes } from '../models/tournament-event';
+import { TournamentSeason } from '../models/tournament-season';
+import { Game } from '../models/game';
+import { LeaguePartner } from '../models/league-partner';
+import { LeagueCourt } from '../models/league-court';
+import { LeagueBanner } from '../models/league-banner';
+import { LeagueDocument } from '../models/league-document';
+import { TeamsAndUsers } from '../models/teams-and-users';
+import { SeasonTournament } from '../models/season-tournament';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+export class LeagueApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    async getByAlias(alias) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${alias}/`).pipe(map(result => new League(result))).toPromise();
+    }
+    async getByDomain(domain) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/by_domain/${domain}/`).pipe(map(result => new League(result))).toPromise();
+    }
+    async getSeasonTournaments(leagueId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/season_tournaments/`).pipe(map(response => response.map(item => new SeasonTournament(item)))).toPromise();
+    }
+    async getTournaments(leagueId, filters) {
+        let params = new HttpParams();
+        if (filters) {
+            if (filters.statuses) {
+                params = params.set('statuses', filters.statuses.map(s => TournamentStatuses[s]).join(','));
+            }
+        }
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/tournaments/`, { params }).pipe(map(result => result.map(item => new Tournament(item)))).toPromise();
+    }
+    async getEvents(leagueId, 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/league/${leagueId}/events/`, { params, observe: 'response' }).pipe(map(result => ({
+            total: +result.headers.get('X-Page-Count'),
+            data: result.body.map(item => new TournamentEvent(item)),
+        }))).toPromise();
+    }
+    async getTournamentSeasons(leagueId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/tournament_seasons/`).pipe(map(result => result.map(item => new TournamentSeason(item)))).toPromise();
+    }
+    async getGames(leagueId, 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/league/${leagueId}/games/`, { params, observe: 'response' }).pipe(map(result => ({
+            total: +result.headers.get('X-Page-Count'),
+            data: result.body.map(item => new Game(item)),
+        }))).toPromise();
+    }
+    async getSeasons(leagueId, page = 1, size = 20, notClosed, include) {
+        const params = new HttpParams()
+            .set('page', page.toString())
+            .set('size', size.toString())
+            .set('not_closed', notClosed ? '1' : '')
+            .set('include', include ? include.join(',') : '');
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/tournament_seasons/`, {
+            params,
+            observe: 'response'
+        })
+            .pipe(map(result => ({
+            total: +result.headers.get('X-Page-Count'),
+            data: result.body.map(item => new TournamentSeason(item)),
+        })))
+            .toPromise();
+    }
+    async getPartners(leagueId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/partners/`).pipe(map(result => result.map(item => new LeaguePartner(item)))).toPromise();
+    }
+    async getBanners(leagueId, location) {
+        const params = location ? new HttpParams().set('location', location) : new HttpParams();
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/banners/`, { params }).pipe(map(result => result.map(item => new LeagueBanner(item)))).toPromise();
+    }
+    async getCourts(leagueId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/courts/`).pipe(map(result => result.map(item => new LeagueCourt(item)))).toPromise();
+    }
+    async getGraphicSettings(leagueId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/graphic_settings/`)
+            .toPromise();
+    }
+    async getDocuments(leagueId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/documents/`).pipe(map(result => result.map(item => new LeagueDocument(item)))).toPromise();
+    }
+    async searchTeamsAndUsers(leagueId, query) {
+        const params = (new HttpParams()).set('query', query);
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/team_and_user_search/`, { params }).pipe(map(result => new TeamsAndUsers(result))).toPromise();
+    }
+}
+LeagueApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LeagueApi, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+LeagueApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LeagueApi, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LeagueApi, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"league-api.js","sourceRoot":"","sources":["../../../../projects/core/src/api/league-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient, HttpParams } from '@angular/common/http';\nimport { League } from '../models/league';\nimport { map } from 'rxjs/operators';\nimport { Tournament, TournamentStatuses } from '../models/tournament';\nimport { ConfigService } from '../services/config.service';\nimport { applyGamesFilters, TournamentEventsListFilter, TournamentGamesFilters } from './tournament-api';\nimport { PaginatedResponse } from './paginated-response.interface';\nimport { TournamentEvent, TournamentEventTypes } from '../models/tournament-event';\nimport { TournamentSeason } from '../models/tournament-season';\nimport { Game } from '../models/game';\nimport { LeaguePartner } from '../models/league-partner';\nimport { LeagueCourt } from '../models/league-court';\nimport { BannerLocation, LeagueBanner } from '../models/league-banner';\nimport { LeagueDocument } from '../models/league-document';\nimport { TeamsAndUsers } from '../models/teams-and-users';\nimport { SeasonTournament } from '../models/season-tournament';\n\nexport interface TournamentListFilters {\n  statuses: TournamentStatuses[];\n}\n\n@Injectable({providedIn: 'root'})\nexport class LeagueApi {\n  constructor(\n    private httpClient: HttpClient,\n    private configService: ConfigService\n  ) {\n  }\n\n  async getByAlias(alias: string): Promise<League> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${alias}/`).pipe(\n      map(result => new League(result))\n    ).toPromise();\n  }\n\n  async getByDomain(domain: string): Promise<League> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/by_domain/${domain}/`).pipe(\n      map(result => new League(result))\n    ).toPromise();\n  }\n\n  async getSeasonTournaments(leagueId: number): Promise<SeasonTournament[]> {\n    return this.httpClient.get<object[]>(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/season_tournaments/`).pipe(\n      map(response => response.map(item => new SeasonTournament(item))),\n    ).toPromise();\n  }\n\n  async getTournaments(leagueId: number, filters?: TournamentListFilters): Promise<Tournament[]> {\n    let params = new HttpParams();\n    if (filters) {\n      if (filters.statuses) {\n        params = params.set('statuses', filters.statuses.map(s => TournamentStatuses[s]).join(','));\n      }\n    }\n    return this.httpClient.get<object[]>(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/tournaments/`, {params}).pipe(\n      map(result => result.map(item => new Tournament(item))),\n    ).toPromise();\n  }\n\n  async getEvents(\n    leagueId: 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[]>(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/events/`, {params, observe: 'response'}).pipe(\n      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 getTournamentSeasons(leagueId: number): Promise<TournamentSeason[]> {\n    return this.httpClient.get<object[]>(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/tournament_seasons/`).pipe(\n      map(result => result.map(item => new TournamentSeason(item))),\n    ).toPromise();\n  }\n\n  async getGames(leagueId: 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[]>(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/games/`, {params, observe: 'response'}).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 getSeasons(\n    leagueId: number, page = 1, size = 20,\n    notClosed?: boolean, include?: string[]\n  ): Promise<PaginatedResponse<TournamentSeason[]>> {\n    const params = new HttpParams()\n      .set('page', page.toString())\n      .set('size', size.toString())\n      .set('not_closed', notClosed ? '1' : '')\n      .set('include', include ? include.join(',') : '');\n    return this.httpClient.get<object[]>(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/tournament_seasons/`, {\n      params,\n      observe: 'response'\n    })\n      .pipe(map(result => ({\n        total: +result.headers.get('X-Page-Count'),\n        data: result.body.map(item => new TournamentSeason(item)),\n      })))\n      .toPromise();\n  }\n\n  async getPartners(leagueId: number): Promise<LeaguePartner[]> {\n    return this.httpClient.get<object[]>(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/partners/`).pipe(\n      map(result => result.map(item => new LeaguePartner(item))),\n    ).toPromise();\n  }\n\n  async getBanners(leagueId: number, location?: BannerLocation): Promise<LeagueBanner[]> {\n    const params = location ? new HttpParams().set('location', location) : new HttpParams();\n\n    return this.httpClient.get<object[]>(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/banners/`, {params}).pipe(\n      map(result => result.map(item => new LeagueBanner(item))),\n    ).toPromise();\n  }\n\n  async getCourts(leagueId: number): Promise<LeagueCourt[]> {\n    return this.httpClient.get<object[]>(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/courts/`).pipe(\n      map(result => result.map(item => new LeagueCourt(item))),\n    ).toPromise();\n  }\n\n  async getGraphicSettings(leagueId: number): Promise<any> {\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/graphic_settings/`)\n      .toPromise();\n  }\n\n  async getDocuments(leagueId: number): Promise<LeagueDocument[]> {\n    return this.httpClient.get<object[]>(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/documents/`).pipe(\n      map(result => result.map(item => new LeagueDocument(item))),\n    ).toPromise();\n  }\n\n  async searchTeamsAndUsers(leagueId: number, query: string): Promise<TeamsAndUsers> {\n    const params = (new HttpParams()).set('query', query);\n\n    return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/team_and_user_search/`, {params}\n    ).pipe(\n      map(result => new TeamsAndUsers(result))\n    ).toPromise();\n  }\n}\n"]}

package/esm2020/api/league-news-api.mjs

@@ -0,0 +1,57 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { LeagueNews, LeagueNewsType } from '../models/league-news';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+export class LeagueNewsApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    async getLeagueNewsList(leagueId, page, size, type = LeagueNewsType.text, seasonId) {
+        let params = new HttpParams().set('page', page.toString())
+            .set('size', size.toString())
+            .set('type', LeagueNewsType[type]);
+        if (seasonId) {
+            params = params.set('season', seasonId.toString());
+        }
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/news/`, { params, observe: 'response' })
+            .pipe(map(response => ({
+            total: +response.headers.get('X-Page-Count'),
+            data: response.body.map(item => new LeagueNews(item)),
+        })))
+            .toPromise();
+    }
+    async getMainLeagueNews(leagueId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/news/?is_main=true`)
+            .pipe(map(response => response && response.length > 0 ? new LeagueNews(response[0]) : null))
+            .toPromise();
+    }
+    async getMainLeagueNewsList(leagueId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league/${leagueId}/news/?is_main=true`)
+            .pipe(map(response => response.map(item => new LeagueNews(item))))
+            .toPromise();
+    }
+    async getNewsById(newsId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league_news/${newsId}/`)
+            .pipe(map(response => new LeagueNews(response)))
+            .toPromise();
+    }
+    async getTournamentNewsList(tournamentId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/tournament/${tournamentId}/news/`, { observe: 'response' })
+            .pipe(map(response => ({
+            total: +response.headers.get('X-Page-Count'),
+            data: response.body.map(item => new LeagueNews(item)),
+        })))
+            .toPromise();
+    }
+}
+LeagueNewsApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LeagueNewsApi, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+LeagueNewsApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LeagueNewsApi, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LeagueNewsApi, 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/league-player-api.mjs

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { LeaguePlayer } from '../models/league-player';
+import { map } from 'rxjs/operators';
+import { TournamentTeamUser } from '../models/tournament-team-user';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/config.service";
+export class LeaguePlayerApi {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    getById(leaguePlayerId) {
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league_player/${leaguePlayerId}/`).pipe(map(item => new LeaguePlayer(item))).toPromise();
+    }
+    getTournamentUsers(leaguePlayerId, seasonId) {
+        let params = new HttpParams();
+        if (seasonId) {
+            params = params.set('season_id', seasonId.toString());
+        }
+        return this.httpClient.get(`${this.configService.get('apiUrl')}/api/v1/league_player/${leaguePlayerId}/tournament_users/`, { params }).pipe(map(response => response.map(item => new TournamentTeamUser(item)))).toPromise();
+    }
+}
+LeaguePlayerApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LeaguePlayerApi, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+LeaguePlayerApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LeaguePlayerApi, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LeaguePlayerApi, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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