IBM\Watson\Common\Message\AbstractRequest

Complexity

Total Complexity

15

Size/Duplication

Total Lines	189
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	initialize()	0	12	2
A	getParameters()	0	4	1
A	getData()	0	7	1
A	send()	0	6	1
A	getParameter()	0	4	1
A	getUsername()	0	4	1
A	setUsername()	0	4	1
A	getPassword()	0	4	1
A	setPassword()	0	4	1
A	getResponse()	0	8	2
A	setParameter()	0	10	2

<?php
/**
 * Abstract Request
 */

namespace IBM\Watson\Common\Message;

use GuzzleHttp\ClientInterface;
use IBM\Watson\Common\Exception\RuntimeException;
use IBM\Watson\Common\Helper;
use Omnipay\Common\Message\ResponseInterface;

This use statement conflicts with another class in this namespace, IBM\Watson\Common\Message\ResponseInterface.

use Symfony\Component\HttpFoundation\ParameterBag;
use Symfony\Component\HttpFoundation\Request;

/**
 * Abstract Request
 *
 * This abstract class implements RequestInterface and defines a basic
 * set of functions that all Watson Request are intended to include.
 *
 * @see RequestInterface
 */
abstract class AbstractRequest implements RequestInterface
{
    /**
     * The request parameters
     *
     * @var \Symfony\Component\HttpFoundation\ParameterBag
     */
    protected $parameters;

    /**
     * The request client
     *
     * @var \Guzzle\Http\ClientInterface
     */
    protected $httpClient;

    /**
     * The HTTP request object
     *
     * @var \Symfony\Component\HttpFoundation\Request
     */
    protected $httpRequest;

    /**
     * An associated ResponseInterface
     *
     * @var ResponseInterface
     */
    protected $response;

    /**
     * Create a new Request
     *
     * @param ClientInterface $httpClient A Guzzle client to make API calls with
     * @param Request         $httpRequest A Symfony HTTP requet object
     */
    public function __construct(ClientInterface $httpClient, Request $httpRequest)

You have injected the Request via parameter $httpRequest. This is generally not recommended as there might be multiple instances during a request cycle (f.e. when using sub-requests). Instead, it is recommended to inject the RequestStack and retrieve the current request each time you need it via getCurrentRequest().

    {
        $this->httpClient = $httpClient;

It seems like $httpClient of type object<GuzzleHttp\ClientInterface> is incompatible with the declared type object<Guzzle\Http\ClientInterface> of property $httpClient.

        $this->httpRequest = $httpRequest;
        $this->initialize();
    }

    /**
     * Initialize the request with parameters
     *
     * @param array $parameters Associative array of parameters
     *
     * @return $this
     * @throws RuntimeException
     */
    public function initialize(array $parameters = [])
    {
        if (null !== $this->response) {
            throw new RuntimeException('Request cannot be modified after it has been sent!');
        }

        $this->parameters = new ParameterBag;

        Helper::initialize($this, $parameters);

        return $this;
    }

    /**
     * Get all parameters
     *
     * @return array
     */
    public function getParameters()
    {
        return $this->parameters->all();
    }

    /**
     * Get a parameter
     *
     * @param string $key The parameter key
     * @param mixed $default Default value
     * @return mixed
     */
    public function getParameter($key, $default = null)
    {
        return $this->parameters->get($key, $default);
    }

    /**
     * Get the API username
     *
     * @return string
     */
    public function getUsername()
    {
        return $this->getParameter('username');
    }

    /**
     * Set the API username
     *
     * @param string $value
     *
     * @return $this
     */
    public function setUsername($value)
    {
        return $this->setParameter('username', $value);
    }

    /**
     * Get the API password
     *
     * @return string
     */
    public function getPassword()
    {
        return $this->getParameter('password');
    }

    /**
     * Set the API password
     *
     * @param string $value
     *
     * @return $this
     */
    public function setPassword($value)
    {
        return $this->setParameter('password', $value);
    }

    /**
     * Get request data
     *
     * @return array
     */
    public function getData()
    {
        return [
            'username'  => $this->getUsername(),
            'password'  => $this->getPassword(),
        ];
    }

    /**
     * Get the associated Response
     *
     * @return ResponseInterface
     * @throws RuntimeException
     */
    public function getResponse()
    {
        if (null === $this->response) {
            throw new RuntimeException('You must call send() before accessing the Response!');
        }

        return $this->response;
    }

    /**
     * Send the request
     *
     * @return ResponseInterface
     */
    public function send()
    {
        $data = $this->getData();

        return $this->sendData($data);
    }

    /**
     * Set a parameter on the request
     *
     * @param string $key
     * @param mixed $value
     * @return $this
     * @throws RuntimeException
     */
    protected function setParameter($key, $value)
    {
        if (null !== $this->response) {
            throw new RuntimeException('Request cannot be modified after it has been sent!');
        }

        $this->parameters->set($key, $value);

        return $this;
    }
}