plaier-mcp-server
Version:
MCP Server for Plaier Football API - Advanced football analytics and predictions
344 lines • 12.4 kB
JavaScript
/**
* Plaier API Client with authentication and error handling
*/
import axios from 'axios';
export class PlaierApiClient {
config;
client;
constructor(config) {
this.config = config;
this.client = axios.create({
baseURL: config.baseUrl,
timeout: config.timeout,
headers: {
'key': config.authToken,
'Accept': 'application/json',
'Accept-Encoding': 'gzip'
}
});
// Add response interceptor for error handling
this.client.interceptors.response.use((response) => response, (error) => {
if (error.response) {
const status = error.response.status;
const statusText = error.response.statusText;
if (status === 404) {
throw new Error(`Resource not found: ${error.response.data || statusText}`);
}
else if (status === 401) {
throw new Error('Authentication failed: Invalid API key');
}
else if (status === 403) {
throw new Error('Access forbidden: Insufficient permissions');
}
else if (status === 429) {
throw new Error('Rate limit exceeded: Too many requests');
}
else {
throw new Error(`API Error ${status}: ${statusText}`);
}
}
else if (error.request) {
throw new Error('Network error: No response received from API');
}
else {
throw new Error(`Request error: ${error.message}`);
}
});
}
/**
* Make a GET request to the API
*/
async get(endpoint, params) {
const response = await this.client.get(endpoint, { params });
return response.data;
}
/**
* Get data in JSON format (default)
*/
async getJson(endpoint, params) {
return this.get(endpoint, { ...params, format: 'json' });
}
/**
* Get data in CSV format
*/
async getCsv(endpoint, params) {
return this.get(endpoint, { ...params, format: 'csv' });
}
/**
* Get data in Excel format
*/
async getExcel(endpoint, params) {
const response = await this.client.get(endpoint, {
params: { ...params, format: 'xlsx' },
responseType: 'arraybuffer'
});
return Buffer.from(response.data);
}
/**
* Get binary data (PNG/PDF reports)
*/
async getBinary(endpoint, params) {
const response = await this.client.get(endpoint, {
params,
responseType: 'arraybuffer'
});
return Buffer.from(response.data);
}
// ==================== TEAM ENDPOINTS ====================
/**
* Get teams - can get all teams, specific team, or teams by tournament
*/
async getTeams(params) {
return this.getJson('/teams', params);
}
/**
* Search for a team by name
*/
async searchTeam(teamName, showDetails = false) {
return this.getJson('/teams/search', {
team_name: teamName,
show_details: showDetails
});
}
/**
* Get team performance in tournament
*/
async getTeamPerformance(params) {
return this.getJson('/teams/performance-in-tournament', params);
}
/**
* Get team improvement suggestions
*/
async getTeamImprovement(params) {
return this.getJson('/teams/team-improvement', params);
}
/**
* Get most important players for a team
*/
async getMostImportantPlayers(params) {
return this.getJson('/teams/most-important-players', params);
}
// ==================== PLAYER ENDPOINTS ====================
/**
* Get players - can get all players, specific player, or players by team/tournament
*/
async getPlayers(params) {
return this.getJson('/players', params);
}
/**
* Search for a player by name with optional filters
*/
async searchPlayer(params) {
const queryParams = {
player_name: params.player_name,
show_details: params.show_details || false
};
if (params.team_name) {
queryParams['team_name'] = params.team_name;
}
return this.getJson('/players/search', queryParams);
}
/**
* Get player rankings with advanced filtering
*/
async getPlayerRanking(params) {
const queryParams = {};
if (params?.tournament_ids)
queryParams.tournament_ids = params.tournament_ids.join(',');
if (params?.team_ids)
queryParams.team_ids = params.team_ids.join(',');
if (params?.nationality_ids)
queryParams.nationality_ids = params.nationality_ids.join(',');
if (params?.position_ids)
queryParams.position_ids = params.position_ids.join(',');
if (params?.position_group_ids)
queryParams.position_group_ids = params.position_group_ids.join(',');
// Add other parameters
if (params) {
Object.keys(params).forEach(key => {
if (!['tournament_ids', 'team_ids', 'nationality_ids', 'position_ids', 'position_group_ids'].includes(key)) {
const value = params[key];
if (value !== undefined) {
queryParams[key] = value;
}
}
});
}
return this.getJson('/players/player-ranking', queryParams);
}
// ==================== MATCH ENDPOINTS ====================
/**
* Get match prediction between two teams
*/
async getMatchPrediction(params) {
const queryParams = {
home_team_id: params.home_team_id,
away_team_id: params.away_team_id
};
if (params.home_team_lineup && params.home_team_lineup.length > 0) {
queryParams.home_team_lineup = params.home_team_lineup.join(',');
}
if (params.away_team_lineup && params.away_team_lineup.length > 0) {
queryParams.away_team_lineup = params.away_team_lineup.join(',');
}
if (params.prediction_type !== undefined) {
queryParams.prediction_type = params.prediction_type;
}
if (params.ignore_home_advantage !== undefined) {
queryParams.ignore_home_advantage = params.ignore_home_advantage;
}
return this.getJson('/matches/match-prediction', queryParams);
}
/**
* Get best lineups for a match
*/
async getBestLineups(params) {
const queryParams = {
team_id: params.team_id,
opponent_team_id: params.opponent_team_id,
home_match: params.home_match
};
if (params.formation !== undefined)
queryParams.formation = params.formation;
if (params.skip_player_ids !== undefined)
queryParams.skip_player_ids = params.skip_player_ids;
if (params.skip_players && params.skip_players.length > 0)
queryParams.skip_players = params.skip_players.join(',');
if (params.limit !== undefined)
queryParams.limit = params.limit;
return this.getJson('/matches/best-lineups', queryParams);
}
/**
* Get best formations for a match
*/
async getBestFormations(params) {
const queryParams = {
team_id: params.team_id,
opponent_team_id: params.opponent_team_id,
home_match: params.home_match
};
if (params.skip_players && params.skip_players.length > 0)
queryParams.skip_players = params.skip_players.join(',');
if (params.dark_mode !== undefined)
queryParams.dark_mode = params.dark_mode;
if (params.format !== undefined)
queryParams.format = params.format;
if (params.orientation !== undefined)
queryParams.orientation = params.orientation;
return this.getJson('/matches/best-formations', queryParams);
}
/**
* Get best lineup count for players
*/
async getBestLineupCount(params) {
const queryParams = {
team_id: params.team_id,
opponent_team_id: params.opponent_team_id,
home_match: params.home_match,
format: 'json' // Ensure we always get JSON format
};
if (params.formation !== undefined)
queryParams.formation = params.formation;
if (params.all_players !== undefined)
queryParams.all_players = params.all_players;
if (params.skip_players && params.skip_players.length > 0)
queryParams.skip_players = params.skip_players.join(',');
if (params.skip_player_ids !== undefined)
queryParams.skip_player_ids = params.skip_player_ids;
if (params.dark_mode !== undefined)
queryParams.dark_mode = params.dark_mode;
if (params.orientation !== undefined)
queryParams.orientation = params.orientation;
if (params.limit !== undefined)
queryParams.limit = params.limit;
return await this.getJson('/matches/best-lineup-count', queryParams);
}
/**
* Run a match simulation
*/
async simulateMatch(params) {
const queryParams = {
home_team_id: params.home_team_id,
away_team_id: params.away_team_id
};
if (params.home_team_lineup && params.home_team_lineup.length > 0) {
queryParams.home_team_lineup = params.home_team_lineup.join(',');
}
if (params.away_team_lineup && params.away_team_lineup.length > 0) {
queryParams.away_team_lineup = params.away_team_lineup.join(',');
}
if (params.simulations !== undefined)
queryParams.simulations = params.simulations;
if (params.detail_level !== undefined)
queryParams.detail_level = params.detail_level;
return this.getJson('/matches/simulate', queryParams);
}
// ==================== TOURNAMENT ENDPOINTS ====================
/**
* Get all tournaments
*/
async getTournaments() {
return this.getJson('/tournaments');
}
/**
* Search for a tournament by name
*/
async searchTournament(tournamentName) {
return this.get('/tournaments/search', { tournament_name: tournamentName });
}
/**
* Get tournament fixtures
*/
async getTournamentFixtures(tournamentId) {
return this.getJson('/tournaments/tournament-fixtures', { tournament_id: tournamentId });
}
/**
* Get tournament prediction (end of season table)
*/
async getTournamentPrediction(tournamentId) {
return this.getJson('/tournaments/tournament-prediction', { tournament_id: tournamentId });
}
/**
* Get tournament probabilities matrix
*/
async getTournamentProbabilities(tournamentId) {
return this.getJson('/tournaments/tournament-probabilities', { tournament_id: tournamentId });
}
// ==================== TRANSFER ENDPOINTS ====================
/**
* Get transfer impact analysis
*/
async getTransferImpact(params) {
const queryParams = {
player_id: params.player_id
};
if (params.team_ids && params.team_ids.length > 0) {
queryParams.team_ids = params.team_ids;
}
else if (params.tournament_id !== undefined) {
queryParams.tournament_id = params.tournament_id;
}
console.error({ queryParams });
return this.getJson('/transfers/transfer-impact', queryParams);
}
// ==================== REFERENCE DATA ENDPOINTS ====================
/**
* Get all positions
*/
async getPositions() {
return this.getJson('/positions/positions');
}
/**
* Get all position groups
*/
async getPositionGroups() {
return this.getJson('/positions/position-groups');
}
/**
* Get all nationalities
*/
async getNationalities() {
return this.getJson('/nationalities/nationalities');
}
}
//# sourceMappingURL=client.js.map