Scriptotek\Sru\Client

Complexity

Total Complexity

22

Size/Duplication

Total Lines	211
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
C	__construct()	0	40	10
A	urlTo()	0	22	3
A	search()	0	7	1
A	all()	0	4	1
A	records()	0	4	1
A	first()	0	5	2
A	explain()	0	11	1
A	request()	0	11	3

<?php namespace Scriptotek\Sru;

use Http\Client\Common\Plugin\AuthenticationPlugin;
use Http\Client\Common\PluginClient;
use Http\Client\Common\Exception\ServerErrorException;
use Http\Factory\Discovery\HttpClient;
use Http\Factory\Discovery\HttpFactory;
use Http\Message\Authentication\BasicAuth;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestFactoryInterface;

/**
 * SRU client
 */
class Client
{
    /** @var ClientInterface */
    protected $httpClient;

    /**
     * @var RequestFactoryInterface
     */
    private $requestFactory;

    /** @var string SRU service base URL */
    protected $url;

    /** @var string Requested schema for the returned records */
    protected $schema;

    /** @var string SRU protocol version */
    protected $version;

    /** @var string Some user agent string to identify our client */
    protected $userAgent;

    /** @var array Custom headers */
    public $headers;

    /**
     * @var string|string[] Proxy configuration details.
     *
     * Either a string 'host:port' or an
     * array('host:port', 'username', 'password').
     */
    protected $proxy;

    /**
     * @var string[] Array containing username and password
     */
    protected $credentials;

    /**
     * Create a new client
     *
     * @param string                  $url             Base URL to the SRU service
     * @param array                   $options         Associative array of options
     * @param ClientInterface         $httpClient
     * @param RequestFactoryInterface $requestFactory
     * @throws \ErrorException
     */
    public function __construct(
        $url,
        $options = null,
        ClientInterface $httpClient = null,
        RequestFactoryInterface $requestFactory = null
    ) {
        $this->url = $url;
        $options = $options ?: array();

        $plugins = [];

        $this->schema = isset($options['schema'])
            ? $options['schema']
            : 'marcxml';

        $this->version = isset($options['version'])
            ? $options['version']
            : '1.1';

        $this->headers = isset($options['headers'])
            ? $options['headers']
            : ['Accept' => 'application/xml'];

        if (isset($options['user-agent'])) {
            // legacy option
            $this->headers['User-Agent'] = $options['user-agent'];
        }

        if (isset($options['credentials'])) {
            $authentication = new BasicAuth($options['credentials'][0], $options['credentials'][1]);
            $plugins[] = new AuthenticationPlugin($authentication);
        }

        if (isset($options['proxy'])) {
            throw new\ErrorException('Not supported');
        }

        $this->httpClient = new PluginClient($httpClient ?: HttpClient::client(), $plugins);
        $this->requestFactory = $requestFactory ?: HttpFactory::requestFactory();
    }

    /**
     * Construct the URL for a CQL query
     *
     * @param string $cql The CQL query
     * @param int $start Start value in result set (optional)
     * @param int $count Number of records to request (optional)
     * @param array $extraParams Extra GET parameters
     * @return string
     */
    public function urlTo($cql, $start = 1, $count = 10, $extraParams = array())
    {
        $qs = array(
            'operation' => 'searchRetrieve',
            'version' => $this->version,
            'recordSchema' => $this->schema,
            'maximumRecords' => $count,
            'query' => $cql
        );

        if ($start != 1) {
            // At least the BIBSYS SRU service, specifying startRecord results in
            // a less clear error message when there's no results
            $qs['startRecord'] = $start;
        }

        foreach ($extraParams as $key => $value) {
            $qs[$key] = $value;
        }

        return $this->url . '?' . http_build_query($qs);
    }

    /**
     * Perform a searchRetrieve request
     *
     * @deprecated
     * @param string $cql
     * @param int $start Start value in result set (optional)
     * @param int $count Number of records to request (optional)
     * @param array $extraParams Extra GET parameters
     * @return SearchRetrieveResponse
     */
    public function search($cql, $start = 1, $count = 10, $extraParams = array())
    {
        $url = $this->urlTo($cql, $start, $count, $extraParams);
        $body = $this->request('GET', $url);

        return new SearchRetrieveResponse($body, $this, $url);
    }

    /**
     * Perform a searchRetrieve request and return an iterator over the records
     *
     * @param string $cql
     * @param int $batchSize Number of records to request per request
     * @param array $extraParams Extra GET parameters
     * @return Records
     */
    public function all($cql, $batchSize = 10, $extraParams = array())
    {
        return new Records($cql, $this, $batchSize, $extraParams);
    }

    /**
     * Alias for `all()`
     * @deprecated
     * @param $cql
     * @param int $batchSize
     * @param array $extraParams
     * @return Records
     */
    public function records($cql, $batchSize = 10, $extraParams = array())
    {
        return $this->all($cql, $batchSize, $extraParams);
    }

    /**
     * Perform a searchRetrieve request and return first record
     *
     * @param string $cql
     * @param array $extraParams Extra GET parameters
     * @return Record
     */
    public function first($cql, $extraParams = array())
    {
        $recs = new Records($cql, $this, 1, $extraParams);
        return $recs->numberOfRecords() ? $recs->current() : null;
    }

    /**
     * Perform an explain request
     *
     * @return ExplainResponse
     */
    public function explain()
    {
        $url = $this->url . '?' . http_build_query(array(
            'operation' => 'explain',
            'version' => $this->version,
        ));

        $body = $this->request('GET', $url);

        return new ExplainResponse($body, $this, $url);
    }

    /**
     * @param string $method
     * @param string $url
     * @return string
     */
    public function request($method, $url)
    {
        $request = $this->requestFactory->createRequest($method, $url, $this->headers);

The call to RequestFactoryInterface::createRequest() has too many arguments starting with $this->headers.

        $response = $this->httpClient->sendRequest($request);

        if ($response->getStatusCode() >= 500 && $response->getStatusCode() < 600) {
            throw new ServerErrorException($response->getReasonPhrase(), $request, $response);
        }

        return (string) $response->getBody();
    }
}