@mtgame/core 0.0.77 → 0.1.1

package/api/league-api.d.ts

@@ -1,6 +1,6 @@
 import { HttpClient } from '@angular/common/http';
 import { League } from '../models/league';
-import { Tournament } from '../models/tournament';
+import { Tournament, TournamentStatuses } from '../models/tournament';
 import { ConfigService } from '../services/config.service';
 import { TournamentEventsListFilter, TournamentGamesFilters } from './tournament-api';
 import { PaginatedResponse } from './paginated-response.interface';
@@ -10,18 +10,22 @@ import { Game } from '../models/game';
 import { LeaguePartner } from '../models/league-partner';
 import { LeagueCourt } from '../models/league-court';
 import { BannerLocation, LeagueBanner } from '../models/league-banner';
+export interface TournamentListFilters {
+    statuses: TournamentStatuses[];
+}
 export declare class LeagueApi {
     private httpClient;
     private configService;
     constructor(httpClient: HttpClient, configService: ConfigService);
     getByAlias(alias: string): Promise<League>;
     getByDomain(domain: string): Promise<League>;
-    getTournaments(leagueId: number): Promise<Tournament[]>;
+    getTournaments(leagueId: number, filters?: TournamentListFilters): Promise<Tournament[]>;
     getEvents(leagueId: number, page: number, size: number, filters?: TournamentEventsListFilter): Promise<PaginatedResponse<TournamentEvent[]>>;
     getTournamentSeasons(leagueId: number): Promise<TournamentSeason[]>;
     getGames(leagueId: number, page: number, size: number, filters: TournamentGamesFilters): Promise<PaginatedResponse<Game[]>>;
-    getSeasons(leagueId: number, notClosed?: boolean): Promise<TournamentSeason[]>;
+    getSeasons(leagueId: number, page?: number, size?: number, notClosed?: boolean, include?: string[]): Promise<PaginatedResponse<TournamentSeason[]>>;
     getPartners(leagueId: number): Promise<LeaguePartner[]>;
     getBanners(leagueId: number, location?: BannerLocation): Promise<LeagueBanner[]>;
     getCourts(leagueId: number): Promise<LeagueCourt[]>;
+    getGraphicSettings(leagueId: number): Promise<any>;
 }

package/api/media-api.d.ts

@@ -1,15 +1,11 @@
-import { HttpClient } from '@angular/common/http';
+import { HttpClient, HttpParams } from '@angular/common/http';
 import { MediaItem } from '../models/media-item';
-import { Game, GameStatuses } from '../models/game';
+import { Game } from '../models/game';
 import { PaginatedResponse } from './paginated-response.interface';
 import { ConfigService } from '../services/config.service';
-export interface GameMediaFilters {
-    tournamentStageId?: number;
-    tournamentTour?: number;
-    teamId?: number;
-    playoffStage?: number;
-    playoffId?: number;
-    status?: GameStatuses;
+import { TournamentGamesFilters } from './tournament-api';
+export interface GameMediaFilters extends TournamentGamesFilters {
+    mediaCount?: number;
 }
 export interface MediaFilters {
     mediaType?: 'photo' | 'video' | 'live_video';
@@ -29,3 +25,4 @@ export declare class MediaApi {
     createZip(mediaIds: number[]): Promise<any>;
     downloadMedia(mediaId: number): Promise<any>;
 }
+export declare function applyGameMediaFilters(filters: GameMediaFilters, params: HttpParams): HttpParams;

package/api/tournament-api.d.ts

@@ -29,6 +29,7 @@ export interface TournamentGamesFilters {
     statuses?: GameStatuses[];
     tournamentCourtId?: number;
     userId?: number;
+    query?: string;
 }
 export declare type StatisticGroupByTypes = 'team' | 'user' | 'team_user' | 'tournament_team' | 'tournament_team_user' | 'month' | 'win_loses';
 export interface StatisticFilters {
@@ -46,8 +47,29 @@ export interface StatisticFilters {
     playoff_id?: number;
     date_from?: string;
     date_to?: string;
+    query?: string;
     per_game?: boolean;
     group_by: StatisticGroupByTypes;
+    order_by?: string;
+    page?: number;
+    size?: number;
+}
+export interface StatisticLeadersFilters {
+    tournament_id?: number;
+    tournament_ids?: number[];
+    tournament_season_id?: number;
+    tournament_team_id?: number;
+    team_id?: number;
+    tournament_stage_id?: number;
+    tournament_tour?: number;
+    playoff_stage?: number;
+    playoff_id?: number;
+    date_from?: string;
+    date_to?: string;
+    per_game?: boolean;
+    group_by: StatisticGroupByTypes;
+    size?: number;
+    fields: string[];
 }
 export interface TournamentEventsListFilter {
     event?: TournamentEventTypes;
@@ -72,14 +94,31 @@ export declare class TournamentApi {
     getTeamById(tournamentTeamId: number): Promise<TournamentTeam>;
     getUserById(userId: number): Promise<TournamentTeamUser>;
     getUserGames(tournamentUserId: number): Promise<Game[]>;
-    getBasketballStatistic(filters?: StatisticFilters): Promise<BasketballStatistic[]>;
-    getVolleyballStatistic(filters?: StatisticFilters): Promise<VolleyballStatistic[]>;
-    getHockeyStatistic(filters?: StatisticFilters): Promise<HockeyStatistic[]>;
-    getFootballStatistic(filters?: StatisticFilters): Promise<FootballStatistic[]>;
-    getHandballStatistic(filters?: StatisticFilters): Promise<HandballStatistic[]>;
+    getBasketballStatisticLeaders(filters: StatisticLeadersFilters): Promise<{
+        [key: string]: BasketballStatistic[];
+    }>;
+    getVolleyballStatisticLeaders(filters: StatisticLeadersFilters): Promise<{
+        [key: string]: VolleyballStatistic[];
+    }>;
+    getHockeyStatisticLeaders(filters: StatisticLeadersFilters): Promise<{
+        [key: string]: HockeyStatistic[];
+    }>;
+    getFootballStatisticLeaders(filters: StatisticLeadersFilters): Promise<{
+        [key: string]: FootballStatistic[];
+    }>;
+    getHandballStatisticLeaders(filters: StatisticLeadersFilters): Promise<{
+        [key: string]: HandballStatistic[];
+    }>;
+    getBasketballStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<BasketballStatistic[]>>;
+    getVolleyballStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<VolleyballStatistic[]>>;
+    getHockeyStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<HockeyStatistic[]>>;
+    getFootballStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<FootballStatistic[]>>;
+    getHandballStatistic(filters?: StatisticFilters): Promise<PaginatedResponse<HandballStatistic[]>>;
     getTournamentTeamUsers(tournamentTeamId: number): Promise<TournamentTeamUser[]>;
     myPermission(tournamentId: number): Promise<LeagueUserPermissions[]>;
     getTournamentTeamTournaments(tournamentTeamId: number): Promise<Tournament[]>;
     getTournamentUserTournaments(tournamentTeamUserId: number): Promise<Tournament[]>;
 }
 export declare function applyGamesFilters(filters: TournamentGamesFilters, params: HttpParams): HttpParams;
+export declare function applyStatisticFilters(filters: StatisticFilters, params: HttpParams): HttpParams;
+export declare function applyStatisticLeadersFilters(filters: StatisticLeadersFilters, params: HttpParams): HttpParams;