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