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;
}
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;
}
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;
}
/**
* 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);
}
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));
}
public function isUserInSharedData($user)
{
$data = $this->response->xml()->data[0];
foreach ($data as $element) {
if ($element->share_with == $user) {
return True;
}
}
return False;
}
/**
* Run request to Restoration Media
*/
public function send()
{
$request = $this->client->createRequest('GET', $this->getBuiltUrl());
$request->setHeader('User-Agent', 'github.com/caseyw/restorationmedia_php');
$this->response = $this->client->send($request);
/*
* Restoration Media doesn't actually use HTTP Status Codes. I don't know why.
*/
return 'success.' == $this->response->xml() ? true : false;
}
protected function getResponse(GuzzleResponse $response)
{
if (strpos($response->getHeader('Content-Type'), 'json')) {
$returnResponse = new JsonResponse($response->getBody());
} elseif (strpos($response->getHeader('Content-Type'), 'xml')) {
$returnResponse = new XmlResponse($response->xml());
} else {
throw new \Exception('Unknow return type');
}
return $returnResponse;
}
/**
* Execute the command
*
* @param Command $command
* @return bool
*/
public function execute(Command $command)
{
$cookies = CookieJar::fromArray(['TokenKey' => $this->getToken()], $this->hostname);
$client = $this->getClient();
// Get the request method
$method = $command->getMethod();
// get the url
$url = $command->getUrl($this->endpoint);
// create the request object with the cookie
$this->lastRequest = $client->createRequest($method, $url, $command->getPayload(['cookies' => $cookies]));
$this->lastResponse = $client->send($this->lastRequest);
$xml = $this->lastResponse->xml();
return isset($xml->Success) && $xml->Success;
}
public function getArrayOfShareesResponded(ResponseInterface $response, $shareeType)
{
$elements = $response->xml()->data;
$elements = json_decode(json_encode($elements), 1);
if (strpos($shareeType, 'exact ') === 0) {
$elements = $elements['exact'];
$shareeType = substr($shareeType, 6);
}
$sharees = [];
foreach ($elements[$shareeType] as $element) {
$sharees[] = [$element['label'], $element['value']['shareType'], $element['value']['shareWith']];
}
return $sharees;
}
public function parse(Session $rets, ResponseInterface $response)
{
$xml = $response->xml();
$collection = new Collection();
if ($xml->METADATA) {
foreach ($xml->METADATA->{'METADATA-OBJECT'}->Object as $key => $value) {
$metadata = new \PHRETS\Models\Metadata\Object();
$metadata->setSession($rets);
$obj = $this->loadFromXml($metadata, $value, $xml->METADATA->{'METADATA-OBJECT'});
$collection->put($obj->getObjectType(), $obj);
}
}
return $collection;
}
public function parse(Session $rets, ResponseInterface $response, $keyed_by)
{
$xml = $response->xml();
$collection = new Collection();
if ($xml->METADATA) {
foreach ($xml->METADATA->{'METADATA-TABLE'}->Field as $key => $value) {
$metadata = new \PHRETS\Models\Metadata\Table();
$metadata->setSession($rets);
$this->loadFromXml($metadata, $value, $xml->METADATA->{'METADATA-TABLE'});
$method = 'get' . $keyed_by;
$collection->put((string) $metadata->{$method}(), $metadata);
}
}
return $collection;
}
public function parse(Session $rets, ResponseInterface $response)
{
$xml = $response->xml();
$collection = new Collection();
if ($xml->METADATA) {
// some servers don't name this correctly for the version of RETS used, so play nice with either way
if (!empty($xml->METADATA->{'METADATA-LOOKUP_TYPE'}->LookupType)) {
$base = $xml->METADATA->{'METADATA-LOOKUP_TYPE'}->LookupType;
} else {
$base = $xml->METADATA->{'METADATA-LOOKUP_TYPE'}->Lookup;
}
foreach ($base as $key => $value) {
$metadata = new \PHRETS\Models\Metadata\LookupType();
$metadata->setSession($rets);
$collection->push($this->loadFromXml($metadata, $value, $xml->METADATA->{'METADATA-LOOKUP_TYPE'}));
}
}
return $collection;
}
/**
* @param ResponseInterface $response
* @param string $deserialize
*
* @return mixed
*/
protected function parse(ResponseInterface $response, $deserialize)
{
return $this->parser->parse($response->xml(), $deserialize);
}
/**
* @param string $call
* @param ResponseInterface $rawResponse
*
* @return Response
*/
protected function parseResponse($call, ResponseInterface $rawResponse)
{
$response = new Response();
$responseArray = json_decode(json_encode($rawResponse->xml()), true);
$response->setMethod($call);
if (!array_key_exists('message', $responseArray)) {
$response->setCode(999);
$response->setMessage('Invalid response received.');
} else {
$response->setCode(intval($responseArray['message']['code']));
$response->setMessage($responseArray['message']['text']);
}
if ($response->isSuccessful() && array_key_exists('response', $responseArray)) {
$response->setData($responseArray['response']);
}
return $response;
}
/**
* Parse the XML response body and return a \SimpleXMLElement.
*
* @param mixed|\GuzzleHttp\Message\ResponseInterface $body
* @param array $config
* @return mixed
*/
public function xml($body, array $config = [])
{
$xml = $body->xml($config);
return $this->parseXml($xml);
}
/**
* Returns the response in the configured format.
*
* @param ResponseInterface $response
* @param string $format
*
* @return mixed $response
*/
private function responseFormat($response, $format)
{
if ($format == 'json') {
return $response->json();
} elseif ($format == 'xml') {
return $response->xml();
}
return $response;
}
/**
* @return \SimpleXMLElement
*/
public function xml()
{
return $this->response->xml();
}
/**
* @param ResponseInterface $response
* @throws RequestException
*/
private function catchErrors(ResponseInterface $response)
{
$code = $response->getStatusCode();
if ($code != 200) {
throw new RequestException($code);
}
try {
$xml = $response->xml();
} catch (ParseException $e) {
// Simply ignore. This is not a known error structure, so maybe not an error
}
if (isset($xml->err) && $xml->err == 1) {
throw new RequestException(500, $xml->errmsg);
}
}
protected function payload(ResponseInterface $response, StructureShape $member, array &$result)
{
$result += $this->parser->parse($member, $response->xml());
}
private function responseToArray(ResponseInterface $response)
{
$responseType = $response->getHeader('Content-Type');
if (false === strpos($responseType, 'application/json') && false === strpos($responseType, 'application/xml')) {
throw new InvalidResponseFormatException((string) $response->getBody(), $response->getStatusCode());
}
return strpos($responseType, 'application/json') !== false ? $response->json() : $response->xml();
}
/**
* @param RequestInterface $request
* @param ResponseInterface $response
* @return object
*/
protected function parseResponse(RequestInterface $request, ResponseInterface $response)
{
$this->response = $response;
if ($request->getQuery()->get('check_if_alive') == '1') {
$xml = $response->xml();
return (object) array($xml->getName() => (string) $xml);
}
return $response->json();
}
/**
* @param \GuzzleHttp\Message\ResponseInterface $response
* @return mixed
*/
private function getResponseContent($response)
{
switch ($response->getHeader('content-type')) {
case 'application/json':
return $response->json();
case 'text/xml':
case 'application/xml':
return $response->xml();
default:
return $response->getBody();
}
}
/**
* @param Response $response
* @return ErrorResponseException
*/
protected function createErrorResponseException(Response $response)
{
$xml = $response->xml();
if ($xml->errors->Err1) {
$message = (string) $xml->errors->Err1;
} elseif ($xml->ErrString) {
$message = (string) $xml->ErrString;
} else {
$message = 'Failed to execute ' . $xml->Command;
}
$exception = new ErrorResponseException($message);
$exception->setResponse($response);
return $exception;
}
/**
* Parses the xml answer to get ocs response which doesn't match with
* http one in v1 of the api.
* @param ResponseInterface $response
* @return string
*/
public function getOCSResponse($response)
{
return $response->xml()->meta[0]->statuscode;
}
/**
* Parses the xml answer to get the array of subadmins returned.
* @param ResponseInterface $resp
* @return array
*/
public function getArrayOfSubadminsResponded($resp)
{
$listCheckedElements = $resp->xml()->data[0]->element;
$extractedElementsArray = json_decode(json_encode($listCheckedElements), 1);
return $extractedElementsArray;
}
public function before(GuzzleCommandInterface $command, ResponseInterface $response, Parameter $model, &$result, array $context = array())
{
$this->xml = $response->xml();
}
