PHP RequestException::getCode方法代码示例

 /**
  * @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);
 }