@mtgame/core 0.0.3 → 0.0.5

package/esm5/api/team-event-api.js

@@ -0,0 +1,96 @@
+import { __awaiter, __decorate, __generator } from "tslib";
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { TeamEvent } from '../models/team-event';
+import { TeamEventInvite } from '../models/team-event-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 TeamEventApi = /** @class */ (function () {
+    function TeamEventApi(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    TeamEventApi.prototype.getTeamEvent = function (teamEventId) {
+        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_event/" + teamEventId + "/")
+                        .pipe(map(function (data) { return TeamEvent.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TeamEventApi.prototype.updateTeamEvent = function (teamEvent) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .patch(this.configService.get('apiUrl') + "/api/v1/team_event/" + teamEvent.id + "/", TeamEvent.toBack(teamEvent))
+                        .pipe(map(function (data) { return TeamEvent.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TeamEventApi.prototype.deleteTeamEvent = function (teamEventId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .delete(this.configService.get('apiUrl') + "/api/v1/team_event/" + teamEventId + "/")
+                        .toPromise()];
+            });
+        });
+    };
+    TeamEventApi.prototype.getTeamEventInvites = function (teamEventId) {
+        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_event/" + teamEventId + "/invites/")
+                        .pipe(map(function (data) { return TeamEventInvite.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TeamEventApi.prototype.createTeamEventInvite = function (teamEventId, teamUserId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .post(this.configService.get('apiUrl') + "/api/v1/team_event/" + teamEventId + "/invites/", { team_user_id: teamUserId })
+                        .pipe(map(function (data) { return TeamEventInvite.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TeamEventApi.prototype.acceptTeamEventInvite = function (teamEventInvite) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .post(this.configService.get('apiUrl') + "/api/v1/team_event_invite/" + teamEventInvite.id + "/accept/", {})
+                        .pipe(map(function (data) { return TeamEventInvite.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TeamEventApi.prototype.declineTeamEventInvite = function (teamEventInvite) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .post(this.configService.get('apiUrl') + "/api/v1/team_event_invite/" + teamEventInvite.id + "/decline/", {})
+                        .pipe(map(function (data) { return TeamEventInvite.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    TeamEventApi.ctorParameters = function () { return [
+        { type: HttpClient },
+        { type: ConfigService }
+    ]; };
+    TeamEventApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function TeamEventApi_Factory() { return new TeamEventApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.ConfigService)); }, token: TeamEventApi, providedIn: "root" });
+    TeamEventApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], TeamEventApi);
+    return TeamEventApi;
+}());
+export { TeamEventApi };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/api/user-api.js

@@ -0,0 +1,350 @@
+import { __awaiter, __decorate, __generator } from "tslib";
+import { Injectable } from '@angular/core';
+import { HttpClient, 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 { 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 UserApi = /** @class */ (function () {
+    function UserApi(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    UserApi.prototype.getCurrentUser = 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/user/current/")
+                        .pipe(map(function (data) { return User.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.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/user/" + userId + "/")
+                        .pipe(map(function (data) { return User.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.getAccess = 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/user/" + (userId || 'current') + "/access/")
+                        .pipe(map(function (data) { return UserAccess.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.updateUser = function (userId, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .patch(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/", User.toBack(data))
+                        .pipe(map(function (result) { return User.toFront(result); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.updateUserPhoto = function (file, filename) {
+        return __awaiter(this, void 0, void 0, function () {
+            var formData;
+            return __generator(this, function (_a) {
+                formData = new FormData();
+                formData.append('file', file, filename);
+                return [2 /*return*/, this.httpClient
+                        .post(this.configService.get('apiUrl') + "/api/v1/user/current/photo/", formData)
+                        .pipe(map(function (data) { return File.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.changePassword = function (userId, oldPassword, password, passwordConfirm) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload;
+            return __generator(this, function (_a) {
+                payload = {
+                    old_password: oldPassword,
+                    password: password,
+                    password_confirm: passwordConfirm
+                };
+                return [2 /*return*/, this.httpClient
+                        .post(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/change_password/", payload)
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.changeEmail = function (userId, email, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload;
+            return __generator(this, function (_a) {
+                payload = { email: email, password: password };
+                return [2 /*return*/, this.httpClient
+                        .post(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/change_email/", payload)
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.changeEmailConfirm = function (userId, email, password, token) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload;
+            return __generator(this, function (_a) {
+                payload = { email: email, password: password, token: token };
+                return [2 /*return*/, this.httpClient
+                        .post(this.configService.get('apiUrl') + "/api/v1/user/" + userId + "/change_email_confirm/", payload)
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.getUserProfile = 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/user/" + userId + "/profile/")
+                        .pipe(map(function (data) { return UserProfile.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.getBasketballProfile = 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/user/" + userId + "/basketball_profile/")
+                        .pipe(map(function (data) { return BasketballProfile.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.getVolleyballProfile = 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/user/" + userId + "/volleyball_profile/")
+                        .pipe(map(function (data) { return VolleyballProfile.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.updateUserProfile = function (userProfile) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .patch(this.configService.get('apiUrl') + "/api/v1/user/" + userProfile.userId + "/profile/", UserProfile.toBack(userProfile))
+                        .pipe(map(function (data) { return UserProfile.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.updateUserBasketballProfile = function (basketballProfile) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .patch(this.configService.get('apiUrl') + "/api/v1/user/" + basketballProfile.userId + "/basketball_profile/", BasketballProfile.toBack(basketballProfile))
+                        .pipe(map(function (data) { return BasketballProfile.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.updateUserVolleyballProfile = function (volleyballProfile) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .patch(this.configService.get('apiUrl') + "/api/v1/user/" + volleyballProfile.userId + "/volleyball_profile/", VolleyballProfile.toBack(volleyballProfile))
+                        .pipe(map(function (data) { return VolleyballProfile.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.getUserPermissions = 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/user/" + (userId || 'current') + "/permission/")
+                        .pipe(map(function (data) { return UserPermission.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.updateUserPermission = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .patch(this.configService.get('apiUrl') + "/api/v1/user/current/permission/", UserPermission.toBack(data))
+                        .pipe(map(function (result) { return UserPermission.toFront(result); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.getTeams = 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/user/" + userId + "/teams/")
+                        .pipe(map(function (data) { return Team.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.getInvites = 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/user/current/invites/")
+                        .pipe(map(function (data) { return TeamInvite.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.acceptInvite = function (inviteId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .post(this.configService.get('apiUrl') + "/api/v1/user/current/invites/" + inviteId + "/accept/", {})
+                        .pipe(map(function (data) { return TeamInvite.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.declineInvite = function (inviteId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .post(this.configService.get('apiUrl') + "/api/v1/user/current/invites/" + inviteId + "/decline/", {})
+                        .pipe(map(function (data) { return TeamInvite.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.getStatistics = 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/user/" + userId + "/statistics/")
+                        .pipe(map(function (data) { return BasketballStatistic.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.getStreetballStatistics = 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/user/" + userId + "/streetball_statistics/")
+                        .pipe(map(function (data) { return BasketballStatistic.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.getVolleyballStatistic = 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/user/" + userId + "/volleyball_statistics/")
+                        .pipe(map(function (data) { return VolleyballStatistic.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.getGames = 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/user/" + userId + "/games/")
+                        .pipe(map(function (data) { return Game.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.getGameInvites = 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/user/current/game_invites/")
+                        .pipe(map(function (data) { return GameInvite.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.acceptGameInvite = function (inviteId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .post(this.configService.get('apiUrl') + "/api/v1/user/current/game_invites/" + inviteId + "/accept/", {})
+                        .pipe(map(function (data) { return GameInvite.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.declineGameInvite = function (inviteId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .post(this.configService.get('apiUrl') + "/api/v1/user/current/game_invites/" + inviteId + "/decline/", {})
+                        .pipe(map(function (data) { return GameInvite.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.searchUsers = function (query) {
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_a) {
+                params = (new HttpParams()).set('search', query);
+                return [2 /*return*/, this.httpClient
+                        .get(this.configService.get('apiUrl') + "/api/v1/user/", { params: params })
+                        .pipe(map(function (data) { return User.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.setWizardShowed = function (wizard) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.httpClient
+                        .put(this.configService.get('apiUrl') + "/api/v1/user/current/wizards/", { wizard: wizard })
+                        .pipe(map(function (data) { return User.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.prototype.getTeamEvents = 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/user/current/team_events/")
+                        .pipe(map(function (data) { return TeamEvent.toFront(data); }))
+                        .toPromise()];
+            });
+        });
+    };
+    UserApi.ctorParameters = function () { return [
+        { type: HttpClient },
+        { type: ConfigService }
+    ]; };
+    UserApi.ɵprov = i0.ɵɵdefineInjectable({ factory: function UserApi_Factory() { return new UserApi(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.ConfigService)); }, token: UserApi, providedIn: "root" });
+    UserApi = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], UserApi);
+    return UserApi;
+}());
+export { UserApi };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-api.js","sourceRoot":"ng://@mtgame/core/","sources":["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 => User.toFront(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 => User.toFront(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 => UserAccess.toFront(data)))\n      .toPromise();\n  }\n\n  async updateUser(userId: number, data: any): Promise<User> {\n    return this.httpClient\n      .patch(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/`, User.toBack(data))\n      .pipe(map(result => User.toFront(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 => File.toFront(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 => UserProfile.toFront(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 => BasketballProfile.toFront(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 => VolleyballProfile.toFront(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.toBack(userProfile))\n      .pipe(map(data => UserProfile.toFront(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.toBack(basketballProfile))\n      .pipe(map(data => BasketballProfile.toFront(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.toBack(volleyballProfile))\n      .pipe(map(data => VolleyballProfile.toFront(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 => UserPermission.toFront(data)))\n      .toPromise();\n  }\n\n  async updateUserPermission(data: any): Promise<UserPermission> {\n    return this.httpClient\n      .patch(`${this.configService.get('apiUrl')}/api/v1/user/current/permission/`, UserPermission.toBack(data))\n      .pipe(map(result => UserPermission.toFront(result)))\n      .toPromise();\n  }\n\n  async getTeams(userId: number): Promise<Team[]> {\n    return this.httpClient\n      .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/teams/`)\n      .pipe(map(data => Team.toFront(data)))\n      .toPromise();\n  }\n\n  async getInvites(): Promise<TeamInvite[]> {\n    return this.httpClient\n      .get(`${this.configService.get('apiUrl')}/api/v1/user/current/invites/`)\n      .pipe(map(data => TeamInvite.toFront(data)))\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 => TeamInvite.toFront(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 => TeamInvite.toFront(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 => BasketballStatistic.toFront(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 => BasketballStatistic.toFront(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 => VolleyballStatistic.toFront(data)))\n      .toPromise();\n  }\n\n  async getGames(userId: number): Promise<Game[]> {\n    return this.httpClient\n      .get(`${this.configService.get('apiUrl')}/api/v1/user/${userId}/games/`)\n      .pipe(map(data => Game.toFront(data)))\n      .toPromise();\n  }\n\n  async getGameInvites(): Promise<GameInvite[]> {\n    return this.httpClient\n      .get(`${this.configService.get('apiUrl')}/api/v1/user/current/game_invites/`)\n      .pipe(map(data => GameInvite.toFront(data)))\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 => GameInvite.toFront(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 => GameInvite.toFront(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(`${this.configService.get('apiUrl')}/api/v1/user/`, {params})\n      .pipe(map(data => User.toFront(data)))\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 => User.toFront(data)))\n      .toPromise();\n  }\n\n  async getTeamEvents(userId: number): Promise<TeamEvent[]> {\n    return this.httpClient\n      .get(`${this.configService.get('apiUrl')}/api/v1/user/current/team_events/`)\n      .pipe(map(data => TeamEvent.toFront(data)))\n      .toPromise();\n  }\n}\n"]}

package/esm5/models/basketball-game-config.js

@@ -1,6 +1,6 @@
 import { __decorate, __extends } from "tslib";
 import { ModelInstance, BaseModel, ToFrontHook, ToBackHook, enumField } from './util';
-import { BasketballStatisticTypes } from './tournament';
+import { BasketballStatisticTypes, GameTimeTypes } from './tournament';
 export var OvertimeTypes;
 (function (OvertimeTypes) {
     OvertimeTypes[OvertimeTypes["to_score_total"] = 1] = "to_score_total";
@@ -34,14 +34,17 @@ var BasketballGameConfig = /** @class */ (function (_super) {
                 overtime_timeout_count: 'overtimeTimeoutCount',
                 timeout_time: 'timeoutTime',
                 statistic_type: 'statisticType',
+                shot_clock_enabled: 'shotClockEnabled',
+                game_time_type: 'gameTimeType',
             },
             relation: {
                 overtimeType: enumField(OvertimeTypes),
-                statisticType: enumField(BasketballStatisticTypes)
+                statisticType: enumField(BasketballStatisticTypes),
+                gameTimeType: enumField(GameTimeTypes),
             }
         })
     ], BasketballGameConfig);
     return BasketballGameConfig;
 }(BaseModel));
 export { BasketballGameConfig };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/models/feedback.js

@@ -0,0 +1,35 @@
+import { __decorate } from "tslib";
+import { ModelInstance, ToBackHook, ToFrontHook } from './util';
+import { File } from './file';
+var Feedback = /** @class */ (function () {
+    function Feedback() {
+    }
+    Feedback.toFront = function (data) {
+        return null;
+    };
+    Feedback.toBack = function (value) {
+        return null;
+    };
+    __decorate([
+        ToFrontHook
+    ], Feedback, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], Feedback, "toBack", null);
+    Feedback = __decorate([
+        ModelInstance({
+            mappingFields: {
+                id: 'id',
+                theme: 'theme',
+                message: 'message',
+                files: 'files',
+            },
+            relation: {
+                files: File
+            }
+        })
+    ], Feedback);
+    return Feedback;
+}());
+export { Feedback };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVlZGJhY2suanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbXRnYW1lL2NvcmUvIiwic291cmNlcyI6WyJtb2RlbHMvZmVlZGJhY2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUNoRSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBYTlCO0lBQUE7SUFlQSxDQUFDO0lBUlEsZ0JBQU8sR0FBZCxVQUFlLElBQVM7UUFDdEIsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBR00sZUFBTSxHQUFiLFVBQWMsS0FBVTtRQUN0QixPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFQRDtRQURDLFdBQVc7aUNBR1g7SUFHRDtRQURDLFVBQVU7Z0NBR1Y7SUFkVSxRQUFRO1FBWHBCLGFBQWEsQ0FBQztZQUNiLGFBQWEsRUFBRTtnQkFDYixFQUFFLEVBQUUsSUFBSTtnQkFDUixLQUFLLEVBQUUsT0FBTztnQkFDZCxPQUFPLEVBQUUsU0FBUztnQkFDbEIsS0FBSyxFQUFFLE9BQU87YUFDZjtZQUNELFFBQVEsRUFBRTtnQkFDUixLQUFLLEVBQUUsSUFBSTthQUNaO1NBQ0YsQ0FBQztPQUNXLFFBQVEsQ0FlcEI7SUFBRCxlQUFDO0NBQUEsQUFmRCxJQWVDO1NBZlksUUFBUSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1vZGVsSW5zdGFuY2UsIFRvQmFja0hvb2ssIFRvRnJvbnRIb29rIH0gZnJvbSAnLi91dGlsJztcbmltcG9ydCB7IEZpbGUgfSBmcm9tICcuL2ZpbGUnO1xuXG5ATW9kZWxJbnN0YW5jZSh7XG4gIG1hcHBpbmdGaWVsZHM6IHtcbiAgICBpZDogJ2lkJyxcbiAgICB0aGVtZTogJ3RoZW1lJyxcbiAgICBtZXNzYWdlOiAnbWVzc2FnZScsXG4gICAgZmlsZXM6ICdmaWxlcycsXG4gIH0sXG4gIHJlbGF0aW9uOiB7XG4gICAgZmlsZXM6IEZpbGVcbiAgfVxufSlcbmV4cG9ydCBjbGFzcyBGZWVkYmFjayB7XG4gIGlkOiBudW1iZXI7XG4gIHRoZW1lOiBzdHJpbmc7XG4gIG1lc3NhZ2U6IHN0cmluZztcbiAgZmlsZXM6IEZpbGVbXTtcblxuICBAVG9Gcm9udEhvb2tcbiAgc3RhdGljIHRvRnJvbnQoZGF0YTogYW55KTogYW55IHtcbiAgICByZXR1cm4gbnVsbDtcbiAgfVxuXG4gIEBUb0JhY2tIb29rXG4gIHN0YXRpYyB0b0JhY2sodmFsdWU6IGFueSk6IGFueSB7XG4gICAgcmV0dXJuIG51bGw7XG4gIH1cbn1cbiJdfQ==

package/esm5/models/league-news.js

@@ -0,0 +1,44 @@
+import { __decorate, __extends } from "tslib";
+import { ModelInstance, BaseModel, ToFrontHook, ToBackHook, listField, DateTimeField } from './util';
+import { File } from './file';
+import { Tournament } from './tournament';
+var LeagueNews = /** @class */ (function (_super) {
+    __extends(LeagueNews, _super);
+    function LeagueNews() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    LeagueNews.toFront = function (data) {
+        return undefined;
+    };
+    LeagueNews.toBack = function (data) { };
+    __decorate([
+        ToFrontHook
+    ], LeagueNews, "toFront", null);
+    __decorate([
+        ToBackHook
+    ], LeagueNews, "toBack", null);
+    LeagueNews = __decorate([
+        ModelInstance({
+            mappingFields: {
+                id: 'id',
+                title: 'title',
+                datetime: 'datetime',
+                preview_text: 'previewText',
+                detail_text: 'detailText',
+                picture: 'picture',
+                cover: 'cover',
+                is_main: 'isMain',
+                tournaments: 'tournaments',
+            },
+            relation: {
+                datetime: DateTimeField,
+                picture: File,
+                cover: File,
+                tournaments: listField(Tournament)
+            }
+        })
+    ], LeagueNews);
+    return LeagueNews;
+}(BaseModel));
+export { LeagueNews };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVhZ3VlLW5ld3MuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbXRnYW1lL2NvcmUvIiwic291cmNlcyI6WyJtb2RlbHMvbGVhZ3VlLW5ld3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxVQUFVLEVBQUUsU0FBUyxFQUFFLGFBQWEsRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUNyRyxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBQzlCLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFxQjFDO0lBQWdDLDhCQUFTO0lBQXpDOztJQWtCQSxDQUFDO0lBTlEsa0JBQU8sR0FBZCxVQUFlLElBQVM7UUFDdEIsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztJQUdNLGlCQUFNLEdBQWIsVUFBYyxJQUFTLElBQVEsQ0FBQztJQUxoQztRQURDLFdBQVc7bUNBR1g7SUFHRDtRQURDLFVBQVU7a0NBQ3FCO0lBakJyQixVQUFVO1FBbkJ0QixhQUFhLENBQUM7WUFDYixhQUFhLEVBQUU7Z0JBQ2IsRUFBRSxFQUFFLElBQUk7Z0JBQ1IsS0FBSyxFQUFFLE9BQU87Z0JBQ2QsUUFBUSxFQUFFLFVBQVU7Z0JBQ3BCLFlBQVksRUFBRSxhQUFhO2dCQUMzQixXQUFXLEVBQUUsWUFBWTtnQkFDekIsT0FBTyxFQUFFLFNBQVM7Z0JBQ2xCLEtBQUssRUFBRSxPQUFPO2dCQUNkLE9BQU8sRUFBRSxRQUFRO2dCQUNqQixXQUFXLEVBQUUsYUFBYTthQUMzQjtZQUNELFFBQVEsRUFBRTtnQkFDUixRQUFRLEVBQUUsYUFBYTtnQkFDdkIsT0FBTyxFQUFFLElBQUk7Z0JBQ2IsS0FBSyxFQUFFLElBQUk7Z0JBQ1gsV0FBVyxFQUFFLFNBQVMsQ0FBQyxVQUFVLENBQUM7YUFDbkM7U0FDRixDQUFDO09BQ1csVUFBVSxDQWtCdEI7SUFBRCxpQkFBQztDQUFBLEFBbEJELENBQWdDLFNBQVMsR0FrQnhDO1NBbEJZLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNb2RlbEluc3RhbmNlLCBCYXNlTW9kZWwsIFRvRnJvbnRIb29rLCBUb0JhY2tIb29rLCBsaXN0RmllbGQsIERhdGVUaW1lRmllbGQgfSBmcm9tICcuL3V0aWwnO1xuaW1wb3J0IHsgRmlsZSB9IGZyb20gJy4vZmlsZSc7XG5pbXBvcnQgeyBUb3VybmFtZW50IH0gZnJvbSAnLi90b3VybmFtZW50JztcblxuQE1vZGVsSW5zdGFuY2Uoe1xuICBtYXBwaW5nRmllbGRzOiB7XG4gICAgaWQ6ICdpZCcsXG4gICAgdGl0bGU6ICd0aXRsZScsXG4gICAgZGF0ZXRpbWU6ICdkYXRldGltZScsXG4gICAgcHJldmlld190ZXh0OiAncHJldmlld1RleHQnLFxuICAgIGRldGFpbF90ZXh0OiAnZGV0YWlsVGV4dCcsXG4gICAgcGljdHVyZTogJ3BpY3R1cmUnLFxuICAgIGNvdmVyOiAnY292ZXInLFxuICAgIGlzX21haW46ICdpc01haW4nLFxuICAgIHRvdXJuYW1lbnRzOiAndG91cm5hbWVudHMnLFxuICB9LFxuICByZWxhdGlvbjoge1xuICAgIGRhdGV0aW1lOiBEYXRlVGltZUZpZWxkLFxuICAgIHBpY3R1cmU6IEZpbGUsXG4gICAgY292ZXI6IEZpbGUsXG4gICAgdG91cm5hbWVudHM6IGxpc3RGaWVsZChUb3VybmFtZW50KVxuICB9XG59KVxuZXhwb3J0IGNsYXNzIExlYWd1ZU5ld3MgZXh0ZW5kcyBCYXNlTW9kZWwge1xuICBpZDogbnVtYmVyO1xuICB0aXRsZTogc3RyaW5nO1xuICBkYXRldGltZTogRGF0ZTtcbiAgcHJldmlld1RleHQ6IHN0cmluZztcbiAgZGV0YWlsVGV4dDogc3RyaW5nO1xuICBwaWN0dXJlOiBGaWxlO1xuICBjb3ZlcjogRmlsZTtcbiAgaXNNYWluOiBib29sZWFuO1xuICB0b3VybmFtZW50czogVG91cm5hbWVudFtdO1xuXG4gIEBUb0Zyb250SG9va1xuICBzdGF0aWMgdG9Gcm9udChkYXRhOiBhbnkpOiBhbnkge1xuICAgIHJldHVybiB1bmRlZmluZWQ7XG4gIH1cblxuICBAVG9CYWNrSG9va1xuICBzdGF0aWMgdG9CYWNrKGRhdGE6IGFueSk6IGFueSB7fVxufVxuIl19