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);
     }
 }
Exemple #2
0
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;
 }
Exemple #12
0
 /**
  * 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();
 }