Skip to main content

Code Examples

Ready-to-use code examples for common integration scenarios.

Complete Player Profile​

Fetch all player data in one flow:

async function getCompletePlayerProfile(wpprId, apiKey) {
  const baseUrl = 'https://developers.wecourts.com/api/v1/players';
  const headers = { Authorization: `Bearer ${apiKey}` };

  try {
    const [player, rating, matches, stats] = await Promise.all([
      fetch(`${baseUrl}/${wpprId}`, { headers }).then((r) => r.json()),
      fetch(`${baseUrl}/${wpprId}/rating`, { headers }).then((r) => r.json()),
      fetch(`${baseUrl}/${wpprId}/matches`, { headers }).then((r) => r.json()),
      fetch(`${baseUrl}/${wpprId}/stats`, { headers }).then((r) => r.json()),
    ]);

    return { player, rating, matches, stats };
  } catch (error) {
    console.error('Failed to fetch player profile:', error);
    throw error;
  }
}

// Usage
const profile = await getCompletePlayerProfile('12345', process.env.WPPR_API_KEY);
console.log(`Player: ${profile.player.name}`);
console.log(`Rating: ${profile.rating.rating}`);
console.log(`Matches: ${profile.matches.length}`);

React Hook​

Custom React hook for player data:

import { useState, useEffect } from 'react';

interface Player {
  id: string;
  wppr_id: string;
  name: string;
  country: string;
  rank: number;
}

function usePlayer(wpprId: string) {
  const [player, setPlayer] = useState<Player | null>(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<Error | null>(null);

  useEffect(() => {
    const apiKey = process.env.REACT_APP_WPPR_API_KEY;

    fetch(`https://developers.wecourts.com/api/v1/players/${wpprId}`, {
      headers: { 'Authorization': `Bearer ${apiKey}` }
    })
      .then(res => {
        if (!res.ok) throw new Error(`HTTP ${res.status}`);
        return res.json();
      })
      .then(data => {
        setPlayer(data);
        setLoading(false);
      })
      .catch(err => {
        setError(err);
        setLoading(false);
      });
  }, [wpprId]);

  return { player, loading, error };
}

// Usage in component
function PlayerCard({ wpprId }: { wpprId: string }) {
  const { player, loading, error } = usePlayer(wpprId);

  if (loading) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;
  if (!player) return <div>Player not found</div>;

  return (
    <div>
      <h2>{player.name}</h2>
      <p>Rank: {player.rank}</p>
      <p>Country: {player.country}</p>
    </div>
  );
}

Python Class​

Object-oriented Python client:

import requests
from typing import Dict, List, Optional

class WPPRClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = 'https://developers.wecourts.com/api/v1'
        self.headers = {'Authorization': f'Bearer {api_key}'}

    def _request(self, endpoint: str) -> Dict:
        response = requests.get(
            f'{self.base_url}{endpoint}',
            headers=self.headers,
            timeout=10
        )
        response.raise_for_status()
        return response.json()

    def get_player(self, wppr_id: str) -> Dict:
        return self._request(f'/players/{wppr_id}')

    def get_player_rating(self, wppr_id: str) -> Dict:
        return self._request(f'/players/{wppr_id}/rating')

    def get_player_matches(self, wppr_id: str) -> List[Dict]:
        return self._request(f'/players/{wppr_id}/matches')

    def get_player_stats(self, wppr_id: str) -> Dict:
        return self._request(f'/players/{wppr_id}/stats')

# Usage
client = WPPRClient(api_key='your_api_key')
player = client.get_player('12345')
print(f"Player: {player['name']}, Rank: {player['rank']}")

Error Handling​

Robust error handling example:

class WPPRAPIError extends Error {
  constructor(message, statusCode, response) {
    super(message);
    this.statusCode = statusCode;
    this.response = response;
  }
}

async function safeApiCall(url, options) {
  try {
    const response = await fetch(url, options);

    if (!response.ok) {
      const error = await response.json();
      throw new WPPRAPIError(error.message || 'API request failed', response.status, error);
    }

    return await response.json();
  } catch (error) {
    if (error instanceof WPPRAPIError) {
      throw error;
    }

    // Network or parsing error
    throw new WPPRAPIError('Network error or invalid response', 0, {
      originalError: error.message,
    });
  }
}

// Usage with error handling
try {
  const player = await safeApiCall('https://developers.wecourts.com/api/v1/players/12345', {
    headers: { Authorization: `Bearer ${apiKey}` },
  });
  console.log('Player:', player);
} catch (error) {
  if (error.statusCode === 401) {
    console.error('Invalid API key');
  } else if (error.statusCode === 404) {
    console.error('Player not found');
  } else {
    console.error('API Error:', error.message);
  }
}

Next Steps​