PHP RequestException::getResponse方法代码示例

 /**
  * Handles a Request Exception.
  *
  * @param RequestException $e The request exception.
  *
  * @return void
  */
 protected function onRequestException(RequestException $e)
 {
     $request = $e->getRequest();
     $response = $e->getResponse();
     $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 Bitreserve 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);
     }
 }

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

 /**
  * Converts a Guzzle exception into an Httplug exception.
  *
  * @param RequestException $exception
  *
  * @return Exception
  */
 private function createException(RequestException $exception)
 {
     if ($exception->hasResponse()) {
         return new HttpException($exception->getMessage(), $exception->getRequest(), $exception->getResponse(), $exception);
     }
     return new NetworkException($exception->getMessage(), $exception->getRequest(), $exception);
 }

 private function handleException(RequestException $exception)
 {
     if ($exception instanceof BadResponseException) {
         return $exception->getResponse();
     }
     throw new Exception($exception->getMessage());
 }

 /**
  * @internal
  * @param RequestException $e
  * @return AccessDeniedException|ApiException|AuthenticationException|ConflictingStateException|
  * MethodNotAllowedException|NotFoundException|RateLimitExceededException|UnsupportedAcceptHeaderException|
  * UnsupportedContentTypeException|ValidationException
  */
 public static function create(RequestException $e)
 {
     if ($response = $e->getResponse()) {
         switch ($response->getStatusCode()) {
             case 400:
                 return new ValidationException($e);
             case 401:
                 return new AuthenticationException($e);
             case 403:
                 return new AccessDeniedException($e);
             case 404:
                 return new NotFoundException($e);
             case 405:
                 return new MethodNotAllowedException($e);
             case 406:
                 return new UnsupportedAcceptHeaderException($e);
             case 409:
                 return new ConflictingStateException($e);
             case 415:
                 return new UnsupportedContentTypeException($e);
             case 429:
                 return new RateLimitExceededException($e);
         }
     }
     return new ApiException($e);
 }

 private function manejar_excepcion_request(RequestException $e)
 {
     $msg = $e->getRequest() . "\n";
     if ($e->hasResponse()) {
         $msg .= $e->getResponse() . "\n";
     }
     throw new toba_error($msg);
 }

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

 protected function handleError(RequestException $e)
 {
     $response = $e->getResponse();
     switch ($response->getStatusCode()) {
         case 404:
             throw new Exceptions\NotFoundException($this->getResponseError($response));
         default:
             throw new Exceptions\MeshException($this->getResponseError($response));
     }
 }

 public function testHasRequestAndResponse()
 {
     $req = new Request('GET', '/');
     $res = new Response(200);
     $e = new RequestException('foo', $req, $res);
     $this->assertSame($req, $e->getRequest());
     $this->assertSame($res, $e->getResponse());
     $this->assertTrue($e->hasResponse());
     $this->assertEquals('foo', $e->getMessage());
 }

 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);
 }

 /**
  * Captch known exceptions
  * @param RequestException $e
  * @throws BolException
  * @throws \Exception
  */
 public function handle(RequestException $e)
 {
     $response = $e->getResponse();
     $statusCode = $response->getStatusCode();
     $this->handleStatusCode($statusCode);
     $body = $response->getBody(true);
     $message = $this->xmlParser->parse($body);
     if (isset($message['ErrorCode'])) {
         throw new BolException($message['ErrorMessage'], $message['ErrorCode']);
     }
     throw new \Exception("Unknown error occurred. Status code: {$response->getStatusCode()}.");
 }

 /**
  * Wraps an API exception in the appropriate domain exception.
  *
  * @param RequestException $e The API exception
  *
  * @return HttpException
  */
 public static function wrap(RequestException $e)
 {
     $response = $e->getResponse();
     if ($errors = self::errors($response)) {
         $class = self::exceptionClass($response, $errors[0]);
         $message = implode(', ', array_map('strval', $errors));
     } else {
         $class = self::exceptionClass($response);
         $message = $e->getMessage();
     }
     return new $class($message, $errors, $e->getRequest(), $response, $e);
 }

 /**
  * @param RequestException $exception
  *
  * @return ApnsException
  */
 private static function factoryException(RequestException $exception)
 {
     $response = $exception->getResponse();
     if (null === $response) {
         return new ApnsException('Unknown network error', 0, $exception);
     }
     try {
         $contents = $response->getBody()->getContents();
     } catch (\Exception $e) {
         return new ApnsException('Unknown network error', 0, $e);
     }
     return ExceptionFactory::factoryException($response->getStatusCode(), $contents, $exception);
 }

 public function __construct(RequestException $e)
 {
     $response = $e->getResponse();
     $message = $response->getReasonPhrase() . " [status code] " . $response->getStatusCode();
     $level = floor($response->getStatusCode() / 100);
     // Check if business-level error message
     // https://developer.zendesk.com/rest_api/docs/core/introduction#requests
     if ($level == '4') {
         $responseBody = $response->getBody()->getContents();
         $this->errorDetails = $responseBody;
         $message .= ' [details] ' . $this->errorDetails;
     } elseif ($level == '5') {
         $message .= ' [details] Zendesk may be experiencing internal issues or undergoing scheduled maintenance.';
     }
     parent::__construct($message, $response->getStatusCode());
 }

 public function __construct(RequestException $e)
 {
     $response = $e->getResponse();
     $message = $response->getReasonPhrase();
     $level = floor($response->getStatusCode() / 100);
     // Check if business-level error message
     // https://developer.zendesk.com/rest_api/docs/core/introduction#requests
     if ($response->getHeaderLine('Content-Type') == 'application/json; charset=UTF-8') {
         $responseBody = json_decode($response->getBody()->getContents());
         $this->errorDetails = $responseBody->details;
         $message = $responseBody->description . "\n" . 'Errors: ' . print_r($this->errorDetails, true);
     } elseif ($level == '5') {
         $message = 'Zendesk may be experiencing internal issues or undergoing scheduled maintenance.';
     }
     parent::__construct($message, $response->getStatusCode());
 }