public function parse(Session $rets, ResponseInterface $response, $parameters) { $xml = $response->xml(); $rs = new Results(); $rs->setSession($rets)->setResource($parameters['SearchType'])->setClass($parameters['Class']); if ($this->getRestrictedIndicator($rets, $xml, $parameters)) { $rs->setRestrictedIndicator($this->getRestrictedIndicator($rets, $xml, $parameters)); } $rs->setHeaders($this->getColumnNames($rets, $xml, $parameters)); $rets->debug(count($rs->getHeaders()) . ' column headers/fields given'); $this->parseRecords($rets, $xml, $parameters, $rs); if ($this->getTotalCount($rets, $xml, $parameters) !== null) { $rs->setTotalResultsCount($this->getTotalCount($rets, $xml, $parameters)); $rets->debug($rs->getTotalResultsCount() . ' total results found'); } $rets->debug($rs->getReturnedResultsCount() . ' results given'); if ($this->foundMaxRows($rets, $xml, $parameters)) { // MAXROWS tag found. the RETS server withheld records. // if the server supports Offset, more requests can be sent to page through results // until this tag isn't found anymore. $rs->setMaxRowsReached(); $rets->debug('Maximum rows returned in response'); } unset($xml); return $rs; }
/** * Decode an HTTP Response. * @static * @throws Google_Service_Exception * @param GuzzleHttp\Message\RequestInterface $response The http response to be decoded. * @param GuzzleHttp\Message\ResponseInterface $response * @return mixed|null */ public static function decodeHttpResponse(ResponseInterface $response, RequestInterface $request = null) { $body = (string) $response->getBody(); $code = $response->getStatusCode(); $result = null; // return raw response when "alt" is "media" $isJson = !($request && 'media' == $request->getQuery()->get('alt')); // set the result to the body if it's not set to anything else if ($isJson) { try { $result = $response->json(); } catch (ParseException $e) { $result = $body; } } else { $result = $body; } // retry strategy if (intVal($code) >= 300) { $errors = null; // Specific check for APIs which don't return error details, such as Blogger. if (isset($result['error']) && isset($result['error']['errors'])) { $errors = $result['error']['errors']; } throw new Google_Service_Exception($body, $code, null, $errors); } return $result; }
/** * {@inheritDoc} */ public function populateFromResponse(ResponseInterface $response) { $entries = $response->json()['access']['serviceCatalog']; foreach ($entries as $entry) { $this->entries[] = $this->model('Entry', $entry); } }
/** * @param ResponseInterface $response */ private function handleResponse(ResponseInterface $response, Request $request) { $context = $this->prepareBaseContext($request); $data = $response->json(); if (isset($data['results'])) { foreach ($data['results'] as $registrationIdIdx => $result) { $context['registrationId'] = $this->registrationIds[$registrationIdIdx]; $context['result'] = var_export($result, true); switch (key($result)) { case 'message_id': if (isset($result['registration_id'])) { $this->callback(EventsEnum::ON_PUSH_SUCCESS_BUT_NEED_NEW_ID, [$context]); } else { $this->callback(EventsEnum::ON_PUSH_SUCCESS, [$context]); } break; case 'error': $currentResult = current($result); switch ($currentResult) { case 'Unavailable': $this->callback(EventsEnum::ON_PUSH_UNAVAILABLE, [$context]); break; case 'InvalidRegistration': $this->callback(EventsEnum::ON_PUSH_INVALID_REGISTRATION, [$context]); break; case 'NotRegistered': $this->callback(EventsEnum::ON_PUSH_NOT_REGISTERED, [$context]); break; } break; } } } return ['success' => $data['success'], 'failure' => $data['failure']]; }
public function parse(Session $rets, ResponseInterface $response) { $xml = $response->xml(); $base = $xml->METADATA->{'METADATA-SYSTEM'}; $metadata = new \PHRETS\Models\Metadata\System(); $metadata->setSession($rets); $configuration = $rets->getConfiguration(); if ($configuration->getRetsVersion()->is1_5()) { if (isset($base->System->SystemID)) { $metadata->setSystemId((string) $base->System->SystemID); } if (isset($base->System->SystemDescription)) { $metadata->setSystemDescription((string) $base->System->SystemDescription); } } else { if (isset($base->SYSTEM->attributes()->SystemID)) { $metadata->setSystemId((string) $base->SYSTEM->attributes()->SystemID); } if (isset($base->SYSTEM->attributes()->SystemDescription)) { $metadata->setSystemDescription((string) $base->SYSTEM->attributes()->SystemDescription); } if (isset($base->SYSTEM->attributes()->TimeZoneOffset)) { $metadata->setTimezoneOffset((string) $base->SYSTEM->attributes()->TimeZoneOffset); } } if (isset($base->SYSTEM->Comments)) { $metadata->setComments((string) $base->SYSTEM->Comments); } if (isset($base->attributes()->Version)) { $metadata->setVersion((string) $xml->METADATA->{'METADATA-SYSTEM'}->attributes()->Version); } return $metadata; }
private function isNotJsonError(HttpResponseInterface $httpResponse) { if ($httpResponse->getStatusCode() == ResponseInterface::HTTP_CODE_NOT_FOUND || $httpResponse->getStatusCode() == ResponseInterface::HTTP_CODE_INTERNAL_SERVER_ERROR || $httpResponse->getStatusCode() == ResponseInterface::HTTP_CODE_METHOD_NOT_ALLOWED) { return true; } return false; }
public function it_handle_unexpected_oboom_response(Client $guzzleClient, ResponseInterface $response) { $url = 'http://example.com'; $response->json()->shouldBeCalled()->willReturn([400]); $guzzleClient->get($url, ['query' => []])->willReturn($response); $this->shouldThrow(new RuntimeException('API error', 400))->during('call', [$url]); }
/** * Creates a response object * @param ResponseInterface $responseInterface * @throws ParseException */ public function __construct(ResponseInterface $responseInterface) { $this->response = $responseInterface->json(); $this->status = isset($this->response['meta']['code']) ? $this->response['meta']['code'] : 500; $this->errorCode = isset($this->response['meta']['error_code']) ? $this->response['meta']['error_code'] : null; $this->responseErrorCodes = new ResponseErrorCodes(); }
function it_should_make_post_request(ResponseInterface $responce) { $responce->getHeader("Content-Type")->willReturn('blablaxmlblabla'); $responce->getBody()->willReturn('<xml></xml>'); $this->client->post(Argument::any(), Argument::any())->willReturn($responce); $responce->xml()->willReturn(new \SimpleXMLElement('<xml></xml>')); $this->post(Argument::type('string'))->shouldBeAnInstanceOf('Bxav\\Component\\ResellerClub\\Model\\XmlResponse'); }
/** * Sets attributes from response xml. * * @param ResponseInterface $response * @param array $attributes */ public function __construct(ResponseInterface $response, array $attributes = null) { $this->response = $response; if (is_null($attributes)) { $attributes = Xml::elementsToArray($response->xml()->xpath('/RESPONSE/FIELDS/*')); } parent::__construct($attributes); }
/** * Set Http response in case of successful request * * @param GuzzleHttp\Message\ResponseInterface $response * @return CurrencyExchange\HttpClient * @throws CurrencyExchange\Exception\ResponseException */ public function setResponse(ResponseInterface $response) { if ($response->getStatusCode() != 200) { throw new ResponseException('Unsuccessful HTTP request: ' . $response->getStatusCode() . ' on ' . $this->getUri()); } $this->_response = $response; return $this; }
/** * @param ResponseInterface $response raw json response * @param bool $throw Should throw API errors as exceptions * * @throws \Exception */ public function __construct(ResponseInterface $response = null, $throw = true) { if ($response !== null) { $this->_executionTime = $response->getHeader('X-Execution-Time'); $this->_callTime = $response->getHeader('X-Call-Time'); $this->readJson((string) $response->getBody(), $throw); } }
public function getCount($content, ResponseInterface $response = null) { $data = $response->json(); if (empty($data)) { return false; } return (int) array_shift($data)['shares']; }
/** * @param RequestInterface|ResponseInterface $message * @return string */ protected function formatHeaders($message) { $headers = []; foreach ($message->getHeaders() as $header => $value) { $headers[] = sprintf('%s: %s', $header, implode("\n : ", $value)); } return implode("\n", $headers); }
private function parseHeaders(ResponseInterface $response, array &$data) { $data['message'] = $response->getStatusCode() . ' ' . $response->getReasonPhrase(); if ($requestId = $response->getHeader('x-amz-request-id')) { $data['request_id'] = $requestId; $data['message'] .= " (Request-ID: {$requestId})"; } }
public function visit(GuzzleCommandInterface $command, ResponseInterface $response, Parameter $param, &$result, array $context = array()) { // Retrieving a single header by name $name = $param->getName(); if ($header = $response->getHeader($param->getWireName())) { $result[$name] = $param->filter($header); } }
function it_should_return_results_as_an_object(ClientInterface $client, ResponseInterface $response) { $params = 'key=' . $this->test_key . '&hero_id=12345&skill=2'; $expectedUrl = $this->test_base_url . 'IDOTA2Match_570/GetMatchDetails/v001/?' . $params; $responseReturn = json_decode('{"result": {"status": 1, "num_results": 0, "total_results": 407, "results_remaining": 307} }'); $response->json(['object' => true])->shouldBeCalled()->willReturn($responseReturn); $client->get($expectedUrl)->shouldBeCalled()->willReturn($response); $this->endpoint('IDOTA2Match_570/GetMatchDetails/v001')->options(['hero_id' => 12345, 'skill' => 2])->get()->shouldReturn($responseReturn); }
public function __invoke(ResponseInterface $response) { \SellerCenter\SDK\Common\AnnotationRegistry::registerAutoloadNamespace(); if (count($response->xml()->xpath('/ErrorResponse'))) { $serializer = SerializerBuilder::create()->build(); return $serializer->deserialize($response->xml()->asXML(), 'SellerCenter\\SDK\\Common\\Api\\Response\\Error\\ErrorResponse', 'xml'); } return; }
function it_should_return_a_service_response_when_verifying_an_ipn_message(Client $httpClient, Message $message, ResponseInterface $response) { $response->getBody()->willReturn('foo'); $httpClient->post(Argument::type('string'), Argument::type('array'))->willReturn($response); $message->getAll()->willReturn(['foo' => 'bar']); $response = $this->verifyIpnMessage($message); $response->shouldHaveType('Mdb\\PayPal\\Ipn\\ServiceResponse'); $response->getBody()->shouldReturn('foo'); }
/** * @param \GuzzleHttp\Message\ResponseInterface $response * @return Language[] */ public function processResponse(\GuzzleHttp\Message\ResponseInterface $response) { $xml = simplexml_load_string($response->getBody()->getContents()); $languages = []; foreach ($xml->string as $language) { $languages[] = new Language($language); } return $languages; }
/** * @param ResponseInterface|Response6Interface $response * * @return string * * @throws CommunicationException */ public static function getRawResponseBody($response) { $statusCode = $response->getStatusCode(); $rawResponse = $response->getBody()->getContents(); if ($statusCode != 200) { throw CommunicationException::createFromHTTPResponse($statusCode, $rawResponse); } return $rawResponse; }
/** * Gets the relevant data from the Guzzle clients. * * @param RequestInterface $request * @param ResponseInterface $response */ public function __construct(RequestInterface $request, ResponseInterface $response) { if ($response instanceof FutureResponse) { $this->httpStatusCode = null; } else { $this->httpStatusCode = $response->getStatusCode(); } $this->requestUrl = $request->getUrl(); }
/** * Returns the Guzzle array of headers as a string. * * @param ResponseInterface $response The Guzzle response. * * @return string */ public function getHeadersAsString(ResponseInterface $response) { $headers = $response->getHeaders(); $rawHeaders = []; foreach ($headers as $name => $values) { $rawHeaders[] = $name . ": " . implode(", ", $values); } return implode("\r\n", $rawHeaders); }
/** * @param RequestInterface $request * @param ResponseInterface $response * @return string */ protected function buildMessage($request, $response) { $resource = $this->getResponseBody(); if (is_null($resource)) { $resource = ''; } $message = sprintf('[url] %s [http method] %s [status code] %s [reason phrase] %s: %s', $request->getUrl(), $request->getMethod(), $response->getStatusCode(), $response->getReasonPhrase(), $resource); return $message; }
/** * @param RequestInterface $originalRequest * @param ResponseInterface|null $response * * @return Span */ public function fromIncomingResponse(RequestInterface $originalRequest, ResponseInterface $response = null) { $span = $originalRequest->getHeader('X-B3-SpanId'); $trace = $originalRequest->getHeader('X-B3-TraceId'); if (empty($span) || empty($trace)) { throw new \InvalidArgumentException('Unable to find the original request properties'); } return new Span(Identifier::fromString($span), $this->getName($originalRequest), Identifier::fromString($trace), [new Annotation(Annotation::CLIENT_RECEIVE, $this->clock->microseconds(), $this->endpointResolver->resolve())], [new BinaryAnnotation('http.status', $response !== null ? $response->getStatusCode() : 0, BinaryAnnotation::TYPE_INTEGER_16)]); }
public function before(CommandInterface $command, ResponseInterface $response, Parameter $model, &$result, array $context = []) { $this->json = $response->json() ?: []; // relocate named arrays, so that they have the same structure as // arrays nested in objects and visit can work on them in the same way if ($model->getType() == 'array' && ($name = $model->getName())) { $this->json = [$name => $this->json]; } }
public function __invoke(CommandInterface $command, ResponseInterface $response) { $output = $this->api->getOperation($command->getName())->getOutput(); $xml = $response->xml(); if ($this->honorResultWrapper && $output['resultWrapper']) { $xml = $xml->{$output['resultWrapper']}; } return new Result($this->xmlParser->parse($output, $xml)); }
/** * Create the response object * * @param ResponseInterface $adapterResponse * @return \Tmdb\HttpClient\Response */ private function createResponse(ResponseInterface $adapterResponse = null) { $response = new Response(); if ($adapterResponse !== null) { $response->setCode($adapterResponse->getStatusCode()); $response->setHeaders(new ParameterBag($adapterResponse->getHeaders())); $response->setBody((string) $adapterResponse->getBody()); } return $response; }
/** * Populates the current resource from a response object. * * @param ResponseInterface $response * * @return $this|ResourceInterface */ public function populateFromResponse(ResponseInterface $response) { if (strpos($response->getHeader('Content-Type'), 'application/json') === 0) { $json = $response->json(); if (!empty($json)) { $this->populateFromArray($this->flatten($json)); } } return $this; }
/** * @param ResponseInterface|Response6Interface $response * * @return string * * @throws CommunicationException */ public static function getRawResponseBody($response) { $statusCode = $response->getStatusCode(); $rawResponse = $response->getBody()->getContents(); if ($statusCode != 200) { throw new CommunicationException("StatusCode: {$statusCode}, Contents: {$rawResponse}", CommunicationException::GENERAL_HTTP_ERROR); } static::checkForErrors($rawResponse); return $rawResponse; }