/**
* Simple exception factory for creating Intercom standardised exceptions
*
* @param RequestInterface $request The Request
* @param Response $response The response
* @return BadResponseException
*/
public static function factory(RequestInterface $request, Response $response)
{
$response_json = $response->json();
$intercom_unavailable_error = NULL;
if (!static::isValidIntercomError($response_json)) {
if ($response->isServerError()) {
$label = 'Server error response';
$class = __NAMESPACE__ . '\\ServerErrorResponseException';
$intercom_unavailable_error = 'Service Unavailable: Back-end server is at capacity';
} else {
$label = 'Unsuccessful response';
$class = __CLASS__;
}
} elseif ($response->isClientError()) {
$label = 'Client error response';
$class = __NAMESPACE__ . '\\ClientErrorResponseException';
} elseif ($response->isServerError()) {
$label = 'Server error response';
$class = __NAMESPACE__ . '\\ServerErrorResponseException';
} else {
$label = 'Unsuccessful response';
$class = __CLASS__;
}
$message = $label . PHP_EOL . implode(PHP_EOL, array('[status code] ' . $response->getStatusCode(), '[reason phrase] ' . $response->getReasonPhrase(), '[url] ' . $request->getUrl()));
$e = new $class($message);
$e->setResponse($response);
$e->setRequest($request);
// Sets the errors if the error response is the standard Intercom error type
if (static::isValidIntercomError($response_json)) {
$e->setErrors($response_json['errors']);
} elseif ($intercom_unavailable_error != NULL) {
$e->setErrors(array('code' => 'service_unavailable', "message" => $intercom_unavailable_error));
}
return $e;
}
/**
* Simple exception factory for creating Intercom standardised exceptions
*
* @param RequestInterface $request The Request
* @param Response $response The response
* @return BadResponseException
*/
public static function factory(RequestInterface $request, Response $response)
{
if (!static::isValidIntercomError($response->json())) {
$label = 'Unsuccessful response';
$class = __CLASS__;
} elseif ($response->isClientError()) {
$label = 'Client error response';
$class = __NAMESPACE__ . '\\ClientErrorResponseException';
} elseif ($response->isServerError()) {
$label = 'Server error response';
$class = __NAMESPACE__ . '\\ServerErrorResponseException';
} else {
$label = 'Unsuccessful response';
$class = __CLASS__;
}
$message = $label . PHP_EOL . implode(PHP_EOL, array('[status code] ' . $response->getStatusCode(), '[reason phrase] ' . $response->getReasonPhrase(), '[url] ' . $request->getUrl()));
$e = new $class($message);
$e->setResponse($response);
$e->setRequest($request);
// Sets the errors if the error response is the standard Intercom error type
if (static::isValidIntercomError($response->json())) {
$e->setErrors($response->json()['errors']);
}
return $e;
}
/**
* @param array $query
*
* @return array
*/
public function genderize(array $query)
{
$queryString = '?' . http_build_query($query);
$request = $this->get($queryString);
$this->setLastResponse($request->send());
return $this->lastResponse->json();
}
/**
* Get the response of the query.
* Will be the json decoded data if success, else the error message.
*
* @return array|string
*/
public function getResponse()
{
if (false === $this->response->isSuccessful()) {
return $this->response->getMessage();
}
return $this->response->json();
}
/**
* Get response as an array.
*
* @return array
*/
private function getResponseAsArray()
{
$this->result = $this->response->json();
if ($this->responseHasErrors()) {
return false;
}
return $this->result;
}
/**
* @param string $what
* @return null
*/
protected function extractFromResponse($what)
{
$data = $this->guzzleResponse->json();
if ($data && is_array($data)) {
if (array_key_exists($what, $data)) {
return $data[$what];
}
}
return null;
}
public function __construct(\Guzzle\Http\Message\Response $response, $type)
{
$this->_response = $response;
// if json returned - parse and fill structure
$contentType = $this->_response->getContentType();
if (strpos($contentType, ';')) {
list($contentType, ) = explode(';', $contentType);
}
if ($contentType == 'application/json') {
$this->_structure = new $type($this->_response->json());
} else {
throw new \Exception('Structure parser for content type "' . $this->_response->getContentType() . '" not implemented');
}
}
/**
* Parses response into an array
*
* @param Response $response
* @return array
*/
protected function parseResponseIntoArray($response)
{
if (strpos($response->getContentType(), 'json') === false) {
parse_str($response->getBody(true), $array);
return $array;
}
return $response->json();
}
/**
* {@inheritdoc}
*/
public function json()
{
try {
$result = $this->response->json();
} catch (\Exception $exception) {
throw GuzzleRestException::createFromException($exception);
}
return $result;
}
/**
* Format the raw API response into an array of Models.
*
* @param Guzzle\Http\Message\Response $response api response
* @param string $model the name of the class to instantiate
*
* @return array
*/
public function formatResponse(Response $response, $model)
{
$body = $response->json();
$collection = [];
foreach ($body['data'] as $item) {
$collection[] = new $model($this, $item);
}
// foreach body[data]
return $collection;
}
public function decodeResponse(Response $response)
{
$jsonResponse = $response->json();
if (isset($jsonResponse["result"]) && ($result = $jsonResponse["result"]) !== "success") {
throw new RpcErrorException($result);
}
if (!isset($jsonResponse["arguments"])) {
throw new RpcNoResultException();
}
return $jsonResponse["arguments"];
}
public function decodeResponse(Response $response)
{
$json = $response->json();
if (isset($json["error"])) {
throw new RpcErrorException($json["error"]);
}
if (!isset($json["result"])) {
throw new RpcNoResultException();
}
return $json["result"];
}
/**
* Executing service description defined operations returns the result
* @group unit
*/
public function testMagicOperationsReturnResult()
{
$responseData = array("this" => "that");
Phockito::when($this->mockResponse->getStatusCode())->return(200);
Phockito::when($this->mockResponse->json())->return($this->testDescription);
Phockito::when($this->mockRequest->send())->return($this->mockResponse);
Phockito::when($this->client)->get(anything())->return($this->mockRequest);
Phockito::when($this->client)->callParent(anything(), anything())->return($responseData);
$result = $this->client->SomeOperation(array());
$this->assertEquals($result, $responseData);
}
public function testSuccess()
{
$body = file_get_contents(dirname(dirname(__FILE__)) . '/Mock/TokenPurchaseSuccess.txt');
$httpResponse = new Response(200, array('Content-Type' => 'application/json'), $body);
$response = new TokenPurchaseResponse($this->getMockRequest(), $httpResponse->json());
$this->assertTrue($response->isSuccessful());
$this->assertFalse($response->isRedirect());
$this->assertNull($response->getCode());
$this->assertNull($response->getMessage());
$this->assertSame('205182114555', $response->getTransactionReference());
}
/**
* @param \Guzzle\Http\Message\Response $response
*/
public function __construct(\Guzzle\Http\Message\Response $response)
{
if ($response->isSuccessful()) {
$this->response = $response->json();
foreach ($this->response as $key => $value) {
$this->response[$key] = $value;
}
} else {
// TODO: Error handling
}
}
/**
* Get response as an array, returns false if no result.
*
* @param bool|array
*/
private function getResponseAsArray()
{
$this->result = $this->response->json();
if (isset($this->result['isLastPage'])) {
$this->lastPage = $this->result['isLastPage'];
}
if ($this->responseHasErrors()) {
return false;
}
return $this->result;
}
/**
* Parse the received response into a usable format
*
* @return [type] [description]
*/
private function parse()
{
$data = $this->httpResponse->json();
foreach ($data['messages'] as $message) {
$msg = new Message($message);
$this->messages[] = $msg;
if ($message['type'] === 'error' || $message['type'] === 'non-document-error') {
$this->errors[] = $msg;
} else {
if (isset($message['subType']) && $message['type'] === 'info' && $message['subType'] === 'warning') {
$this->warnings[] = $msg;
}
}
}
}
public static function factory(RequestInterface $request, Response $response)
{
$response_json = $response->json();
$generic_error = null;
$cls = null;
$is_lc_error = static::isLCApiError($response_json);
$err_code = null;
$err_message = null;
$err_domain = null;
$err_exception = null;
$err_trace = null;
$validation_failures = array();
if ($is_lc_error) {
$err_code = isset($response_json['error']['code']) ? $response_json['error']['code'] : null;
$err_message = isset($response_json['error']['message']) ? $response_json['error']['message'] : null;
$err_domain = isset($response_json['error']['domain']) ? $response_json['error']['domain'] : null;
$err_exception = isset($response_json['error']['exception']) ? $response_json['error']['exception'] : null;
$err_trace = isset($response_json['error']['trace']) ? $response_json['error']['trace'] : null;
// parse validation failures
$failures = isset($response_json['error']['validation_failures']) ? $response_json['error']['validation_failures'] : null;
if ($failures) {
foreach ($failures as $failure) {
$validation_failures[] = new ValidationFailure(isset($failure['name']) ? $failure['name'] : null, isset($failure['message']) ? $failure['message'] : null, isset($failure['extra_data']) ? $failure['extra_data'] : null);
unset($failure);
}
}
} else {
$err_message = 'Server communication error';
}
if ($is_lc_error) {
$cls = __NAMESPACE__ . '\\ClientErrorResponseException';
} elseif ($response->isClientError()) {
$cls = __NAMESPACE__ . '\\ServerErrorResponseException';
} else {
$cls = __CLASS__;
}
/** @var Payin7APIException $e */
$e = new $cls($err_message);
$e->setResponse($response);
$e->setRequest($request);
$e->setServerErrorCode($err_code);
$e->setServerErrorMessage($err_message);
$e->setServerErrorDomain($err_domain);
$e->setServerErrorException($err_exception);
$e->setServerErrorTrace($err_trace);
$e->setServerValidationFailures($validation_failures);
return $e;
}
/**
* Create Exception object from response
*
* @param \Guzzle\Http\Message\Response $response
* @return WebPayException
*/
public static function exceptionFromResponse(\Guzzle\Http\Message\Response $response)
{
$status = $response->getStatusCode();
$data = $response->json();
$errorInfo = isset($data['error']) ? $data['error'] : null;
switch ($status) {
case 400:
case 404:
return new InvalidRequestException($status, $errorInfo);
case 401:
return new AuthenticationException($status, $errorInfo);
case 402:
return new CardException($status, $errorInfo);
default:
return new APIException($status, $errorInfo);
}
}
/**
* @covers Guzzle\Http\Message\Response::json
* @expectedException \Guzzle\Common\Exception\RuntimeException
* @expectedExceptionMessage Unable to parse response body into JSON: 4
*/
public function testThrowsExceptionWhenFailsToParseJsonResponse()
{
$response = new Response(200, array(), '{"foo": "');
$response->json();
}
/**
* Log response.
*
* @param Response $response API response.
*
* @return void
*/
protected function logResponse(Response $response)
{
try {
$body = $response->json();
if (isset($body['error'])) {
if (isset($body['message'])) {
$this->logger->error($body['message']);
}
} else {
if (isset($body['message'])) {
$this->logger->info(sprintf('Accepted %s', $body['message']));
}
if (isset($body['url'])) {
$this->logger->info(sprintf('You can see the build on %s', $body['url']));
}
}
} catch (\Guzzle\Common\Exception\RuntimeException $e) {
// the response body is not in JSON format
$body = $response->getBody(true);
if ($body) {
$this->logger->error($body);
}
}
}
private function processResponse(Response $response)
{
if (!$response->isSuccessful()) {
throw new ApiServerException($response->getMessage(), $response->getStatusCode());
}
if (self::FORMAT_ARRAY === $this->outputFormat) {
return $response->json();
}
return $response->getBody(true);
}
/**
* Construct from http response
* @internal
*/
protected final function __construct(Response $response)
{
$this->raw = $response->json();
}
/**
* Log response.
*
* @param Response $response API response.
* @return void
*
* @codeCoverageIgnore
*/
protected function logResponse(Response $response)
{
$body = $response->json();
if (isset($body['error'])) {
if (isset($body['message'])) {
$this->logger->error($body['message']);
}
} else {
if (isset($body['message'])) {
$this->logger->info(sprintf('Accepted %s', $body['message']));
}
if (isset($body['url'])) {
$this->logger->info(sprintf('You can see the build on %s', $body['url']));
}
}
}
/**
* @param Response
*/
private function fetchRepos(Response $orgResponse)
{
foreach ($orgResponse->json() as $repo) {
if (!$repo['permissions']['admin']) {
$this->addNonImportableProject($repo['full_name'], 'no admin rights on the project');
continue;
}
$this->cacheProjectInfo($repo);
$this->addImportableProject($repo['full_name']);
}
}
function it_gets_rates(Client $client, Response $response)
{
$response->json()->shouldBeCalled()->willReturn(['currencyName' => 'HKD', 'deliverTime' => null]);
$regions = $this->getRates('A000812000', 'A440300000', 2, 200000)->shouldReturn(['currencyName' => 'HKD', 'deliverTime' => null]);
}
/**
* @param array $entites
* @return array
*/
private function createEntityListFromResponse(\Guzzle\Http\Message\Response $response)
{
$connections = array();
foreach ($response->json() as $entityId => $connectionMetadata) {
if (static::MAX_CONNECTIONS_TO_TEST && count($connections) > static::MAX_CONNECTIONS_TO_TEST) {
break;
}
$connections[] = array($entityId);
}
return $connections;
}
/**
* {@inheritdoc}
*/
protected function createToken(Response $response)
{
$authData = $response->json();
$this->raiseException($authData);
return new AccessToken($authData['access_token'], null, array(), $authData['expires_in']);
}
public function parseResult(Response $response)
{
try {
$json = $response->json();
if (array_key_exists('d', $json)) {
if (array_key_exists('results', $json['d'])) {
if (count($json['d']['results']) == 1) {
return $json['d']['results'][0];
}
return $json['d']['results'];
}
return $json['d'];
}
return $json;
} catch (\RuntimeException $e) {
throw new ApiException($e->getMessage());
}
}
/**
* @param Response $rawResponse
*
* @return mixed
*/
protected function parseResponse($rawResponse)
{
$formattedResponse = $rawResponse->json();
return $formattedResponse;
}
