/**
* @param RequestException $ex
* @return AccessDeniedException|EntityNotFoundException|EntityValidationException|RequiredFieldMissingException|UnauthorizedClientException|CaravanaHttpException
*/
public static function parseRequestException(RequestException $ex)
{
$code = $ex->getCode();
$body = json_decode($ex->getResponse()->getBody()->getContents(), true);
if (CaravanaExceptionFactory::isEntityValidationException($code, $body)) {
return new EntityValidationException(AU::get($body['Entity']), AU::get($body['field']), AU::get($body['reason']), AU::get($body['providedValue']), $ex->getPrevious());
} else {
if (CaravanaExceptionFactory::isRequiredFieldMissingException($code, $body)) {
return new RequiredFieldMissingException(AU::get($body['Entity']), AU::get($body['field']), $ex->getPrevious());
} else {
if (CaravanaExceptionFactory::isUnauthorizedClientException($code, $body)) {
return new UnauthorizedClientException($ex->getMessage(), $ex->getPrevious());
} else {
if (CaravanaExceptionFactory::isAccessDeniedException($code, $body)) {
return new AccessDeniedException($ex->getMessage(), $ex->getPrevious());
} else {
if (CaravanaExceptionFactory::isEntityNotFoundException($code, $body)) {
return new EntityNotFoundException(AU::get($body['Entity']), AU::get($body['field']), AU::get($body['providedValue']), $ex->getPrevious());
}
}
}
}
}
// Give up and default it to CaravanaException
return new CaravanaHttpException($ex->getMessage(), $ex->getCode(), null, $ex->getPrevious());
}
public function __construct(RequestException $e, $message = '')
{
$prefix = $message ?: "Bad response from the WIU API";
if ($e->getCode()) {
$prefix .= " (HTTP status {$e->getCode()})";
}
$response = $e->getResponse();
$body = $response->json();
$message = isset($body['message']) ? $body['message'] : $response->getReasonPhrase();
parent::__construct("{$prefix}: {$message}", $e->getCode(), null);
}
/**
* @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);
}
/**
* throwRequestException
*
* @param \GuzzleHttp\Exception\RequestException $e
* @param string $className
* @throws Exceptions\RequestException
*/
protected function throwRequestException($e, $className)
{
$response = $e->getResponse();
$rawBody = (string) $response->getBody();
$body = json_decode((string) $rawBody);
$body = $body === null ? $rawBody : $body;
$exception = new $className($e->getMessage(), $e->getCode());
$exception->setBody($body);
throw $exception;
}
/**
* @param GuzzleHttpRequestException $exception
* @return Client\ClientException
*/
private static function createClientException(GuzzleHttpRequestException $exception)
{
$exceptionArray = array(400 => 'BadRequest', 401 => 'Unauthorized', 403 => 'Forbidden', 404 => 'NotFound', 405 => 'MethodNotAllowed', 406 => 'NotAcceptable');
foreach ($exceptionArray as $item => $value) {
if ($item === $exception->getCode()) {
$exceptionName = __NAMESPACE__ . '\\Client\\' . $value . 'Exception';
return new $exceptionName($exception);
}
}
return new RequestException($exception);
}
public function __construct(RequestException $e)
{
$message = $e->getMessage();
if ($e instanceof ClientException) {
$response = $e->getResponse();
$responseBody = $response->getBody()->getContents();
$this->errorDetails = $responseBody;
$message .= ' [details] ' . $this->errorDetails;
} elseif ($e instanceof ServerException) {
$message .= ' [details] Zendesk may be experiencing internal issues or undergoing scheduled maintenance.';
} elseif (!$e->hasResponse()) {
$request = $e->getRequest();
// Unsuccessful response, log what we can
$message .= ' [url] ' . $request->getUri();
$message .= ' [http method] ' . $request->getMethod();
}
parent::__construct($message, $e->getCode());
}
/**
* Handles a Request Exception.
*
* @param RequestException $e The request exception.
*
* @return void
*/
protected function onRequestException(RequestException $e)
{
$request = $e->getRequest();
$response = $e->getResponse();
if (!$response) {
throw new RuntimeException($e->getMessage(), $e->getCode());
}
$statusCode = $response->getStatusCode();
$isClientError = $response->isClientError();
$isServerError = $response->isServerError();
if ($isClientError || $isServerError) {
$content = $response->getContent();
$error = $response->getError();
$description = $response->getErrorDescription();
if (400 === $statusCode) {
throw new BadRequestException($description, $error, $statusCode, $response, $request);
}
if (401 === $statusCode) {
$otp = (string) $response->getHeader('X-Bitreserve-OTP');
if ('required' === $otp) {
$description = 'Two factor authentication is enabled on this account';
throw new TwoFactorAuthenticationRequiredException($description, $error, $statusCode, $response, $request);
}
throw new AuthenticationRequiredException($description, $error, $statusCode, $response, $request);
}
if (404 === $statusCode) {
$description = sprintf('Object or route not found: %s', $request->getPath());
throw new NotFoundException($description, 'not_found', $statusCode, $response, $request);
}
if (429 === $statusCode) {
$rateLimit = $response->getApiRateLimit();
$description = sprintf('You have reached Uphold API limit. API limit is: %s. Your remaining requests will be reset at %s.', $rateLimit['limit'], date('Y-m-d H:i:s', $rateLimit['reset']));
throw new ApiLimitExceedException($description, $error, $statusCode, $response, $request);
}
throw new RuntimeException($description, $error, $statusCode, $response, $request);
}
}
/**
* Prepares an array of important exception parts based on composition of a
* given exception.
*
* @param RequestException $requestException
*
* @return array
*/
private function getRequestExceptionParts(RequestException $requestException)
{
$response = $requestException->getResponse();
$parts = [];
$parts['reason'] = $response ? $response->getReasonPhrase() : $requestException->getMessage();
$parts['code'] = $response ? $response->getStatusCode() : $requestException->getCode();
$parts['body'] = $response ? $response->getBody() : null;
return $parts;
}
private function standardizeExceptionResponse(RequestException $e)
{
$response = new stdClass();
$response->status = $e->getCode();
$response->description = $e->getMessage();
return $response;
}
/**
* @param RequestException $exception
* @throws RequestFailedException
*/
public static function handleGuzzleRequestException(RequestException $exception)
{
$message = sprintf('Request failed due: "%s".', $exception->getMessage());
throw new RequestFailedException($message, $exception->getCode(), $exception);
}
private function handleException(RequestException $exception)
{
if ($exception->getCode() === self::STREAM_DOES_NOT_EXIST) {
throw new StreamDoesNotExist($exception->getMessage());
}
if ($exception->getCode() === self::REQUEST_BODY_INVALID && empty(json_decode($exception->getRequest()->getBody()))) {
throw new CannotWriteStreamWithoutEvents($exception->getMessage());
}
throw new EventStoreConnectionFailed($exception->getMessage());
}
/**
* @param \GuzzleHttp\Exception\RequestException $previous
*
* @return \Riak\Client\Core\Transport\RiakTransportException
*/
public static function httpRequestException(RequestException $previous)
{
return new self($previous->getMessage(), $previous->getCode(), $previous);
}