Syntax\SteamApi\Client

Complexity

Total Complexity

32

Size/Duplication

Total Lines	274
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	10

Test Coverage

Coverage

76.15%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	get()	0	4	1
A	getSteamId()	0	4	1
A	setUpClient()	0	31	3
A	setUpXml()	0	17	2
A	getRedirectUrl()	0	12	1
A	buildUrl()	0	12	2
A	__call()	0	28	5
A	getApiKey()	0	13	5
A	setUpService()	0	25	2
A	setApiDetails()	0	5	1
A	getServiceResponse()	0	7	1
A	sendRequest()	0	20	4
A	sortObjects()	0	6	1
A	convertSteamIdTo64()	0	12	2

<?php

namespace Syntax\SteamApi;

use GuzzleHttp\Exception\GuzzleException;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Config;
use stdClass;
use GuzzleHttp\Client as GuzzleClient;
use GuzzleHttp\Psr7\Request;
use Exception;
use GuzzleHttp\Exception\ClientException;
use GuzzleHttp\Exception\ServerException;
use Syntax\SteamApi\Exceptions\ApiArgumentRequired;
use Syntax\SteamApi\Exceptions\ApiCallFailedException;
use Syntax\SteamApi\Exceptions\ClassNotFoundException;
use Syntax\SteamApi\Steam\App;
use Syntax\SteamApi\Steam\Group;
use Syntax\SteamApi\Steam\Item;
use Syntax\SteamApi\Steam\News;
use Syntax\Steamapi\Steam\Package;
use Syntax\SteamApi\Steam\Player;
use Syntax\SteamApi\Steam\User;
use Syntax\SteamApi\Steam\User\Stats;

/**
 * @method News       news()
 * @method Player     player($steamId)
 * @method User       user($steamId)
 * @method Stats      userStats($steamId)
 * @method App        app()
 * @method Package    package()
 * @method Group      group()
 * @method Item       item($appId)
 */
class Client
{
    use SteamId;

    public $validFormats = ['json', 'xml', 'vdf'];

    protected $url = 'http://api.steampowered.com/';

    protected $client;

    protected $interface;

    protected $method;

    protected $version = 'v0002';

    protected $apiKey;

    protected $apiFormat = 'json';

    protected $steamId;

    protected $isService = false;

    public function __construct()
    {
        $apiKey = $this->getApiKey();

        $this->client = new GuzzleClient();
        $this->apiKey = $apiKey;

        // Set up the Ids
        $this->setUpFormatted();
    }

    public function get()
    {
        return $this;
    }

    public function getSteamId()
    {
        return $this->steamId;
    }

    /**
     * @param string $arguments
     *
     * @return string
     *
     * @throws ApiArgumentRequired
     * @throws ApiCallFailedException
     * @throws GuzzleException
     */
    protected function setUpService($arguments = null)
    {
        // Services have a different url syntax
        if ($arguments == null) {

It seems like you are loosely comparing $arguments of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            throw new ApiArgumentRequired;
        }

        $parameters = [
            'key'        => $this->apiKey,
            'format'     => $this->apiFormat,
            'input_json' => $arguments,
        ];

        $steamUrl = $this->buildUrl(true);

        // Build the query string
        $parameters = http_build_query($parameters);

        // Send the request and get the results
        $request  = new Request('GET', $steamUrl . '?' . $parameters);
        $response = $this->sendRequest($request);

        // Pass the results back
        return $response->body;
    }

    protected function setUpClient(array $arguments = [])
    {
        $versionFlag = ! is_null($this->version);
        $steamUrl    = $this->buildUrl($versionFlag);

        $parameters = [
            'key'    => $this->apiKey,
            'format' => $this->apiFormat,
        ];

        if (! empty($arguments)) {
            $parameters = array_merge($arguments, $parameters);
        }

        // Build the query string
        $parameters = http_build_query($parameters);

        $headers = [];
        if (array_key_exists('l', $arguments)) {
            $headers = [
                'Accept-Language' => $arguments['l'],
            ];
        }

        // Send the request and get the results
        $request  = new Request('GET', $steamUrl . '?' . $parameters, $headers);
        $response = $this->sendRequest($request);

        // Pass the results back
        return $response->body;
    }

    protected function setUpXml(array $arguments = [])
    {
        $steamUrl = $this->buildUrl();

        // Build the query string
        $parameters = http_build_query($arguments);

        // Pass the results back
        libxml_use_internal_errors(true);
        $result = simplexml_load_file($steamUrl . '?' . $parameters);

        if (! $result) {
            return null;
        }

        return $result;
    }

    public function getRedirectUrl()
    {
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $this->url);
        curl_setopt($ch, CURLOPT_HEADER, true);
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        curl_exec($ch);
        $this->url = curl_getinfo($ch, CURLINFO_EFFECTIVE_URL);
        curl_close($ch);
    }

    /**
     * @param Request $request
     *
     * @return stdClass
     * @throws ApiCallFailedException
     * @throws GuzzleException
     */
    protected function sendRequest(Request $request)
    {
        // Try to get the result.  Handle the possible exceptions that can arise
        try {
            $response = $this->client->send($request);

            $result       = new stdClass();
            $result->code = $response->getStatusCode();
            $result->body = json_decode($response->getBody(true));

The call to ResponseInterface::getBody() has too many arguments starting with true.

        } catch (ClientException $e) {
            throw new ApiCallFailedException($e->getMessage(), $e->getResponse()->getStatusCode(), $e);
        } catch (ServerException $e) {
            throw new ApiCallFailedException('Api call failed to complete due to a server error.', $e->getResponse()->getStatusCode(), $e);
        } catch (Exception $e) {
            throw new ApiCallFailedException($e->getMessage(), $e->getCode(), $e);
        }

        // If all worked out, return the result
        return $result;
    }

    private function buildUrl($version = false)
    {
        // Set up the basic url
        $url = $this->url . $this->interface . '/' . $this->method . '/';

        // If we have a version, add it
        if ($version) {
            return $url . $this->version . '/';
        }

        return $url;
    }

    public function __call($name, $arguments)
    {
        // Handle a steamId being passed
        if (! empty($arguments) && count($arguments) == 1) {
            $this->steamId = $arguments[0];

            $this->convertSteamIdTo64();
        }

        // Inside the root steam directory
        $class      = ucfirst($name);
        $steamClass = '\Syntax\SteamApi\Steam\\' . $class;

        if (class_exists($steamClass)) {
            return new $steamClass($this->steamId);
        }

        // Inside a nested directory
        $class      = implode('\\', preg_split('/(?=[A-Z])/', $class, -1, PREG_SPLIT_NO_EMPTY));
        $steamClass = '\Syntax\SteamApi\Steam\\' . $class;

        if (class_exists($steamClass)) {
            return new $steamClass($this->steamId);
        }

        // Nothing found
        throw new ClassNotFoundException($name);
    }

    /**
     * @param Collection $objects
     *
     * @return Collection
     */
    protected function sortObjects($objects)
    {
        return $objects->sortBy(function ($object) {
            return $object->name;
        });
    }

    /**
     * @param string $method
     * @param string $version
     */
    protected function setApiDetails($method, $version)
    {
        $this->method  = $method;
        $this->version = $version;
    }

    protected function getServiceResponse($arguments)
    {
        $arguments = json_encode($arguments);

        // Get the client
        return $this->setUpService($arguments)->response;
    }

    /**
     * @return string
     * @throws Exceptions\InvalidApiKeyException
     */
    protected function getApiKey()
    {
        $apiKey = Config::get('steam-api.steamApiKey');

        if ($apiKey == 'YOUR-API-KEY') {
            throw new Exceptions\InvalidApiKeyException();
        }
        if (is_null($apiKey) || $apiKey == '' || $apiKey == []) {
            $apiKey = getenv('apiKey');
        }

        return $apiKey;
    }

    private function convertSteamIdTo64()
    {
        if (is_array($this->steamId)) {
            array_walk($this->steamId, function (&$id) {
                // Convert the id to all types and grab the 64 bit version
                $id = $this->convertToAll($id)->id64;
            });
        } else {
            // Convert the id to all types and grab the 64 bit version
            $this->steamId = $this->convertToAll($this->steamId)->id64;
        }
    }
}