Adlogix\ConfluenceClient\Exception\ExceptionWrapper

Complexity

Total Complexity

18

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	wrap()	0	5	1
A	parseException()	0	8	2
A	create401ErrorMessage()	0	7	1
A	getExceptionMessage()	0	4	2
A	getExceptionMessageForRequest()	0	7	2
A	isRequestValid()	0	10	4
B	getExceptionMessageForResponse()	0	21	5

<?php
/*
 * This file is part of the Adlogix package.
 *
 * (c) Allan Segebarth <allan@adlogix.eu>
 * (c) Jean-Jacques Courtens <jjc@adlogix.eu>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Adlogix\ConfluenceClient\Exception;


use GuzzleHttp\Exception\RequestException;
use JMS\Serializer\SerializerInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

/**
 * Class ExceptionWrapper
 * @package Adlogix\ConfluenceClient\Exception
 * @author  Cedric Michaux <cedric@adlogix.eu>
 */
class ExceptionWrapper
{
    const RESPONSE_AUTHENTICATED_FAILED = 'AUTHENTICATED_FAILED';
    const RESPONSE_AUTHENTICATION_DENIED = 'AUTHENTICATION_DENIED';
    const RESPONSE_AUTHORIZATION_FAILED = 'AUTHORIZATION_FAILED';
    const RESPONSE_AUTHORISATION_FAILED = 'AUTHORISATION_FAILED';
    const RESPONSE_OUT = 'OUT';
    /**
     * @var SerializerInterface
     */
    private $serializer;

    /**
     * ExceptionWrapper constructor.
     *
     * @param SerializerInterface $serializer
     */
    private function __construct(SerializerInterface $serializer)
    {
        $this->serializer = $serializer;
    }

    public static function wrap(RequestException $exception, SerializerInterface $serializer)
    {
        $wrapper = new static($serializer);
        return $wrapper->parseException($exception);
    }

    /**
     * @param RequestException $exception
     *
     * @return ApiException
     */
    private function parseException(RequestException $exception)
    {
        if ($exception->getCode() == 401) {
            return new ApiException($this->create401ErrorMessage($exception), $exception->getCode(), $exception);
        }

        return new ApiException($exception->getMessage(), $exception->getCode(), $exception);
    }

    /**
     * @param RequestException $exception
     *
     * @return string
     */
    private function create401ErrorMessage(RequestException $exception)
    {
        $request = $exception->getRequest();
        $response = $exception->getResponse();

        return $this->getExceptionMessage($request, $response);

It seems like $response defined by $exception->getResponse() on line 75 can be null; however, Adlogix\ConfluenceClient\Exception\ExceptionWrapper::getExceptionMessage() does not accept null, maybe add an additional type check?

    }

    /**
     * @param RequestInterface  $request
     * @param ResponseInterface $response
     *
     * @return string
     */
    private function getExceptionMessage(RequestInterface $request, ResponseInterface $response)
    {
        return $this->getExceptionMessageForRequest($request) ?: $this->getExceptionMessageForResponse($response);
    }

    /**
     * @param RequestInterface $request
     *
     * @return null|string
     */
    private function getExceptionMessageForRequest(RequestInterface $request)
    {
        if (!$this->isRequestValid($request)) {
            return 'Authentication Required';
        }
        return null;
    }

    /**
     * @param RequestInterface $request
     *
     * @return bool
     */
    private function isRequestValid(RequestInterface $request)
    {
        $uri = $request->getUri();
        $queryParams = \GuzzleHttp\Psr7\parse_query($uri->getQuery());

        return $request->hasHeader('Authorization')
        || $request->hasHeader('Authentication')
        || array_key_exists('jwt', $queryParams)
        || !empty($queryParams['jwt']);
    }

    /**
     * @param ResponseInterface $response
     *
     * @return string
     */
    private function getExceptionMessageForResponse(ResponseInterface $response)
    {
        switch ($response->getHeader('X-Seraph-LoginReason')) {
            case self::RESPONSE_AUTHENTICATED_FAILED:
                return 'Could not be authenticated';
                break;

break is not strictly necessary here and could be removed.

            case self::RESPONSE_AUTHENTICATION_DENIED:
                return 'Not allowed to login';
                break;

break is not strictly necessary here and could be removed.

            case self::RESPONSE_AUTHORISATION_FAILED:
                return 'Could not be authorised';
                break;

break is not strictly necessary here and could be removed.

            case self::RESPONSE_OUT:
                return 'Logged out';
                break;

break is not strictly necessary here and could be removed.

        }
        return 'Invalid Credentials';
    }
}