protected function handleParsing(CommandInterface $command, Response $response, $contentType)
{
$operation = $command->getOperation();
$type = $operation->getResponseType();
$model = null;
if ($type == OperationInterface::TYPE_MODEL) {
$model = $operation->getServiceDescription()->getModel($operation->getResponseClass());
} elseif ($type == OperationInterface::TYPE_CLASS) {
$responseClassInterface = __NAMESPACE__ . '\\ResponseClassInterface';
$className = $operation->getResponseClass();
if (!class_exists($className)) {
throw new ResponseClassException("{$className} does not exist");
} elseif (!method_exists($className, 'fromCommand')) {
throw new ResponseClassException("{$className} must implement {$responseClassInterface}");
}
return $className::fromCommand($command);
}
if (!$model) {
// Return basic processing if the responseType is not model or the model cannot be found
return parent::handleParsing($command, $response, $contentType);
} elseif ($command[AbstractCommand::RESPONSE_PROCESSING] != AbstractCommand::TYPE_MODEL) {
// Returns a model with no visiting if the command response processing is not model
return new Model(parent::handleParsing($command, $response, $contentType), $model);
} else {
return new Model($this->visitResult($model, $command, $response), $model);
}
}
public function after(CommandInterface $command, RequestInterface $request)
{
$xml = null;
if (isset($this->data[$command])) {
$xml = $this->finishDocument($this->data[$command]);
unset($this->data[$command]);
} else {
$operation = $command->getOperation();
if ($operation->getData('xmlAllowEmpty')) {
$xmlWriter = $this->createRootElement($operation);
$xml = $this->finishDocument($xmlWriter);
}
}
if ($xml) {
if ($this->contentType && !$request->hasHeader('Content-Type')) {
$request->setHeader('Content-Type', $this->contentType);
}
$request->setBody($xml);
}
}
/**
* Parse a class object
*
* @param CommandInterface $command Command to parse into an object
*
* @return mixed
* @throws ResponseClassException
*/
protected function parseClass(CommandInterface $command)
{
$className = $command->getOperation()->getResponseClass();
if (!class_exists($className)) {
throw new ResponseClassException("{$className} does not exist");
}
if (!method_exists($className, 'fromCommand')) {
throw new ResponseClassException("{$className} must implement the fromCommand() method");
}
return $className::fromCommand($command);
}
protected function parseClass(CommandInterface $command)
{
$event = new CreateResponseClassEvent(array('command' => $command));
$command->getClient()->getEventDispatcher()->dispatch('command.parse_response', $event);
if ($result = $event->getResult()) {
return $result;
}
$className = $command->getOperation()->getResponseClass();
if (!method_exists($className, 'fromCommand')) {
throw new ResponseClassException("{$className} must exist and implement a static fromCommand() method");
}
return $className::fromCommand($command);
}
/**
* {@inheritdoc}
*/
public function prepare(CommandInterface $command)
{
$operation = $command->getOperation();
$client = $command->getClient();
$uri = $operation->getUri();
if (!$uri) {
$url = $client->getBaseUrl();
} else {
// Get the path values and use the client config settings
$variables = $client->getConfig()->getAll();
foreach ($operation->getParams() as $name => $arg) {
if ($arg->getLocation() == 'uri' && $command->hasKey($name)) {
$variables[$name] = $command->get($name);
if (!is_array($variables[$name])) {
$variables[$name] = (string) $variables[$name];
}
}
}
// Merge the client's base URL with an expanded URI template
$url = (string) Url::factory($client->getBaseUrl())->combine(ParserRegistry::getInstance()->getParser('uri_template')->expand($uri, $variables));
}
// Inject path and base_url values into the URL
$request = $client->createRequest($operation->getHttpMethod(), $url);
// Add arguments to the request using the location attribute
foreach ($operation->getParams() as $name => $arg) {
/** @var $arg \Guzzle\Service\Description\Parameter */
$location = $arg->getLocation();
// Visit with the associated visitor
if (isset($this->visitors[$location])) {
// Ensure that a value has been set for this parameter
$value = $command->get($name);
if ($value !== null) {
// Apply the parameter value with the location visitor
$this->visitors[$location]->visit($command, $request, $arg, $value);
}
}
}
// Call the after method on each visitor
foreach ($this->visitors as $visitor) {
$visitor->after($command, $request);
}
return $request;
}
protected function getClassName(CommandInterface $command)
{
$iteratorName = $this->inflector->camel($command->getName()) . 'Iterator';
$iteratorSpecified = $command->getOperation()->getData('iteratorClass');
// @TODO fix this near duplication
if (!is_null($iteratorSpecified)) {
foreach ($this->namespaces as $namespace) {
$potentialClassName = $namespace . '\\' . $iteratorSpecified;
if (class_exists($potentialClassName)) {
return $potentialClassName;
}
}
}
foreach ($this->namespaces as $namespace) {
$potentialClassName = $namespace . '\\' . $iteratorName;
if (class_exists($potentialClassName)) {
return $potentialClassName;
}
}
return false;
}
protected function createRequest(CommandInterface $command)
{
$operation = $command->getOperation();
$client = $command->getClient();
$options = $command[AbstractCommand::REQUEST_OPTIONS] ?: array();
if (!($uri = $operation->getUri())) {
return $client->createRequest($operation->getHttpMethod(), $client->getBaseUrl(), null, null, $options);
}
$variables = array();
foreach ($operation->getParams() as $name => $arg) {
if ($arg->getLocation() == 'uri') {
if (isset($command[$name])) {
$variables[$name] = $arg->filter($command[$name]);
if (!is_array($variables[$name])) {
$variables[$name] = (string) $variables[$name];
}
}
}
}
return $client->createRequest($operation->getHttpMethod(), array($uri, $variables), null, null, $options);
}
public function after(CommandInterface $command, RequestInterface $request)
{
$xml = null;
// If data was found that needs to be serialized, then do so
if (isset($this->data[$command])) {
$xml = $this->data[$command]->asXML();
unset($this->data[$command]);
} else {
// Check if XML should always be sent for the command
$operation = $command->getOperation();
if ($operation->getData('xmlAllowEmpty')) {
$xml = $this->createRootElement($operation)->asXML();
}
}
if ($xml) {
$request->setBody($xml);
// Don't overwrite the Content-Type if one is set
if ($this->contentType && !$request->hasHeader('Content-Type')) {
$request->setHeader('Content-Type', $this->contentType);
}
}
}
/**
* Create a request for the command and operation
*
* @param CommandInterface $command Command to create a request for
*
* @return RequestInterface
*/
protected function createRequest(CommandInterface $command)
{
$operation = $command->getOperation();
$client = $command->getClient();
$options = $command[AbstractCommand::REQUEST_OPTIONS] ?: array();
// If the command does not specify a template, then assume the base URL of the client
if (!($uri = $operation->getUri())) {
return $client->createRequest($operation->getHttpMethod(), $client->getBaseUrl(), null, null, $options);
}
// Get the path values and use the client config settings
$variables = array();
foreach ($operation->getParams() as $name => $arg) {
if ($arg->getLocation() == 'uri') {
if (isset($command[$name])) {
$variables[$name] = $arg->filter($command[$name]);
if (!is_array($variables[$name])) {
$variables[$name] = (string) $variables[$name];
}
}
}
}
return $client->createRequest($operation->getHttpMethod(), array($uri, $variables), null, null, $options);
}
/**
* Create a request for the command and operation
*
* @param CommandInterface $command Command to create a request for
*
* @return RequestInterface
*/
protected function createRequest(CommandInterface $command)
{
$operation = $command->getOperation();
$client = $command->getClient();
// If the command does not specify a template, then assume the base URL of the client
if (!($uri = $operation->getUri())) {
return $client->createRequest($operation->getHttpMethod(), $client->getBaseUrl());
}
// Get the path values and use the client config settings
$variables = array();
foreach ($operation->getParams() as $name => $arg) {
if ($arg->getLocation() == 'uri') {
if ($command->hasKey($name)) {
$variables[$name] = $arg->filter($command->get($name));
if (!is_array($variables[$name])) {
$variables[$name] = (string) $variables[$name];
}
}
}
}
// Merge the client's base URL with an expanded URI template
return $client->createRequest($operation->getHttpMethod(), (string) Url::factory($client->getBaseUrl())->combine(ParserRegistry::getInstance()->getParser('uri_template')->expand($uri, $variables)));
}
/**
* Deserialize the response.
*
* @param CommandInterface $command Command.
* @param Response $response Response.
* @param string $contentType Content type.
*
* @return mixed|null Deserialized response, or `null`.
*/
protected function deserialize(CommandInterface $command, Response $response, $contentType)
{
if ($this->serializer) {
if (false !== stripos($contentType, 'json')) {
$serializerContentType = 'json';
} elseif (false !== stripos($contentType, 'xml')) {
$serializerContentType = 'xml';
} else {
$serializerContentType = null;
}
if (null !== $serializerContentType && OperationInterface::TYPE_CLASS === $command->getOperation()->getResponseType()) {
$context = DeserializationContext::create();
$operation = $command->getOperation();
if (null !== ($groups = $operation->getData('jms_serializer.groups'))) {
$context->setGroups($groups);
}
if (null !== ($version = $operation->getData('jms_serializer.version'))) {
$context->setVersion($version);
}
if (true === $operation->getData('jms_serializer.max_depth_checks')) {
$context->enableMaxDepthChecks();
}
return $this->serializer->deserialize($response->getBody(), $command->getOperation()->getResponseClass(), $serializerContentType, $context);
}
}
return null;
}
/**
* Determines whether a command's response type is a model
*
* @param \Guzzle\Service\Command\AbstractCommand $command
*
* @return boolean
*/
public function responseTypeIsModel(CommandInterface $command)
{
if (!$command instanceof AbstractCommand) {
return false;
}
$operation = $command->getOperation();
$processing = $command->get(AbstractCommand::RESPONSE_PROCESSING);
$description = $operation->getServiceDescription();
return $operation->getResponseType() == OperationInterface::TYPE_MODEL && $description->hasModel($operation->getResponseClass()) && $processing == AbstractCommand::TYPE_MODEL;
}
/**
* This is a good extension point if you need something fancier
*
* @param GuzzleCommandInterface $command
*
* @return string
*/
protected function getClassName(GuzzleCommandInterface $command)
{
return $command->getOperation()->getResponseClass();
}
