public function visit( CommandInterface $command, Response $response, Parameter $param, &$value, $context = null ) { $value[$param->getName()] = $response->getStatusCode(); }
/** * Recursively process a parameter while applying filters * * @param Parameter $param API parameter being validated * @param mixed $value Value to validate and process. The value may change during this process. */ protected function recursiveProcess(Parameter $param, &$value) { if ($value === null) { return; } if (is_array($value)) { $type = $param->getType(); if ($type == 'array') { foreach ($value as &$item) { $this->recursiveProcess($param->getItems(), $item); } } elseif ($type == 'object' && !isset($value[0])) { // On the above line, we ensure that the array is associative and not numerically indexed if ($properties = $param->getProperties()) { foreach ($properties as $property) { $name = $property->getName(); $key = $property->getWireName(); if (isset($value[$key])) { $this->recursiveProcess($property, $value[$key]); if ($key != $name) { $value[$name] = $value[$key]; unset($value[$key]); } } } } } } $value = $param->filter($value); }
/** * {@inheritdoc} */ public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, $value) { if ($value instanceof PostFileInterface) { $request->addPostFile($value); } else { $request->addPostFile($param->getWireName(), $value); } }
public function visit( CommandInterface $command, Response $response, Parameter $param, &$value, $context = null ) { $value[$param->getName()] = $param->filter($response->getBody()); }
/** * Validates an array of tags or aliases (just strings) * * @param array $aliases * @param Parameter $parameter * * @return array * @throws \Guzzle\Service\Exception\ValidationException */ public static function tagsOrAliases(array $aliases, Parameter $parameter) { foreach ($aliases as $alias) { if (!is_string($alias) || strlen($alias) > 128) { throw new ValidationException("Invalid value [{$alias}] in {$parameter->getName()}"); } } return $aliases; }
/** * Validates the structure of a link (from the service description) * * @param \Guzzle\Service\Description\Parameter $structure * * @throws \Desk\Exception\UnexpectedValueException If it's invalid */ public function validateLinkStructure(Parameter $structure) { if (!$structure->getData('operation')) { throw new UnexpectedValueException("Parameter with 'links' location requires 'operation'"); } if (!$structure->getData('pattern')) { throw new UnexpectedValueException("Parameter with 'links' location requires 'pattern'"); } }
/** * {@inheritdoc} */ public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, $value) { $entityBody = EntityBody::factory($value); $request->setBody($entityBody); $this->addExpectHeader($request, $entityBody, $param->getData('expect_header')); // Add the Content-Encoding header if one is set on the EntityBody if ($encoding = $entityBody->getContentEncoding()) { $request->setHeader('Content-Encoding', $encoding); } }
public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, $value) { if (isset($this->data[$command])) { $json = $this->data[$command]; } else { $json = array(); } $json[$param->getWireName()] = $this->prepareValue($value, $param); $this->data[$command] = $json; }
/** * Add a prefixed array of headers to the request * * @param RequestInterface $request Request to update * @param Parameter $param Parameter object * @param array $value Header array to add * * @throws InvalidArgumentException */ protected function addPrefixedHeaders(RequestInterface $request, Parameter $param, $value) { if (!is_array($value)) { throw new InvalidArgumentException('An array of mapped headers expected, but received a single value'); } $prefix = $param->getSentAs(); foreach ($value as $headerName => $headerValue) { $request->setHeader($prefix . $headerName, $headerValue); } }
/** * Processes model data according to a parameter schema * * @param Desk\Relationship\Resource\EmbeddedCommand $command * @param Guzzle\Service\Description\Parameter $schema * @param array $data * * @return array */ public function process(EmbeddedCommand $command, Parameter $schema, array $data) { $result = array(); $visitors = array(); $properties = $schema->getProperties(); foreach ($properties as $property) { $location = $property->getLocation(); if ($location && !isset($visitors[$location])) { // add visitor for this location and trigger before() $visitor = $this->visitors->getResponseVisitor($location); $visitor->before($command, $result); $visitors[$location] = $visitor; } } $response = $command->getResponse(); // Visit additional properties when it is an actual schema $additional = $schema->getAdditionalProperties(); if ($additional instanceof Parameter) { // Only visit when a location is specified $location = $additional->getLocation(); if ($location) { if (!isset($visitors[$location])) { $visitors[$location] = $this->visitors->getResponseVisitor($location); $visitors[$location]->before($command, $result); } // Only traverse if an array was parsed from the before() visitors if (is_array($result)) { // Find each additional property foreach (array_keys($result) as $key) { // Check if the model actually knows this property. If so, then it is not additional if (!$schema->getProperty($key)) { // Set the name to the key so that we can parse it with each visitor $additional->setName($key); $visitors[$location]->visit($command, $response, $additional, $result); } } // Reset the additionalProperties name to null $additional->setName(null); } } } // Apply the parameter value with the location visitor foreach ($properties as $property) { $location = $property->getLocation(); if ($location) { $visitors[$location]->visit($command, $response, $property, $result); } } // Call the after() method of each found visitor foreach ($visitors as $visitor) { $visitor->after($command); } return $result; }
/** * {@inheritdoc} */ public function visit(CommandInterface $command, Response $response, Parameter $param, &$value, $context = null) { // check if there's a link provided for the param's "wire" name $links = $this->get($command, 'links'); if (!empty($links[$param->getWireName()])) { // create a command representing the link $linkCommand = $this->builder->createLinkCommand($command, $param, $links[$param->getWireName()]); // store the created link command in the results array $value[self::ELEMENT][$param->getName()] = $linkCommand; } }
protected function processXmlAttribute(Parameter $property, array &$value) { $sentAs = $property->getWireName(); if (isset($value['@attributes'][$sentAs])) { $value[$property->getName()] = $value['@attributes'][$sentAs]; unset($value['@attributes'][$sentAs]); if (empty($value['@attributes'])) { unset($value['@attributes']); } } }
/** * {@inheritdoc} */ public function visit(CommandInterface $command, Response $response, Parameter $param, &$value, $context = null) { // check if there's embedded resource data for the parameter $resourceData = $this->get($command, $this->getFieldName()); if (!empty($resourceData[$param->getWireName()])) { // create the resource representing the embedded resource data $resource = $this->createResourceFromData($command, $param, $resourceData[$param->getWireName()]); // store the created embedded resource in the results array $value[$this->getOutputFieldName()][$param->getName()] = $resource; } }
protected function processPrefixedHeaders(Response $response, Parameter $param, &$value) { if ($prefix = $param->getSentAs()) { $container = $param->getName(); $len = strlen($prefix); foreach ($response->getHeaders()->toArray() as $key => $header) { if (stripos($key, $prefix) === 0) { $value[$container][substr($key, $len)] = count($header) == 1 ? end($header) : $header; } } } }
/** * Custom handling for arrays * * @param Parameter $param Parameter for the object * @param array $value Value that is set for this parameter * @param string $prefix Prefix for the resulting key * @param array $query Query string array passed by reference */ protected function resolveArray(Parameter $param, array $value, $prefix, array &$query) { $offset = $param->getData('offset') ?: 1; foreach ($value as $index => $v) { $index += $offset; if (is_array($v) && ($items = $param->getItems())) { $this->customResolver($v, $items, $query, $prefix . '.' . $index); } else { $query[$prefix . '.' . $index] = $param->filter($v); } } }
/** * {@inheritdoc} */ public function visit(CommandInterface $command, Response $response, Parameter $param, &$value, $context = null) { // check if there's an embedded resource for the parameter's // "wire" name $resources = $this->get($command, 'embedded'); if (!empty($resources[$param->getWireName()])) { // create a model representing the embedded resource data $embeddedModel = $this->builder->createEmbeddedModel($command, $param, $resources[$param->getWireName()]); // store the created embedded model in the results array $value[self::ELEMENT][$param->getName()] = $embeddedModel; } }
public function testCanAddArrayOfSimpleTypes() { $request = new EntityEnclosingRequest('POST', 'http://foo.com'); $visitor = new XmlVisitor(); $param = new Parameter(array('type' => 'object', 'location' => 'xml', 'name' => 'Out', 'properties' => array('Nodes' => array('required' => true, 'type' => 'array', 'min' => 1, 'items' => array('type' => 'string', 'sentAs' => 'Node'))))); $param->setParent(new Operation(array('data' => array('xmlRoot' => array('name' => 'Test', 'namespaces' => array('https://foo/')))))); $value = array('Nodes' => array('foo', 'baz')); $this->assertTrue($this->validator->validate($param, $value)); $visitor->visit($this->command, $request, $param, $value); $visitor->after($this->command, $request); $this->assertEquals("<?xml version=\"1.0\"?>\n" . "<Test xmlns=\"https://foo/\"><Out><Nodes><Node>foo</Node><Node>baz</Node></Nodes></Out></Test>\n", (string) $request->getBody()); }
/** * Process a prefixed header array * * @param Response $response Response that contains the headers * @param Parameter $param Parameter object * @param array $value Value response array to modify */ protected function processPrefixedHeaders(Response $response, Parameter $param, &$value) { // Grab prefixed headers that should be placed into an array with the prefix stripped if ($prefix = $param->getSentAs()) { $container = $param->getName(); $len = strlen($prefix); // Find all matching headers and place them into the containing element foreach ($response->getHeaders() as $key => $header) { if (stripos($key, $prefix) === 0) { // Account for multi-value headers $value[$container][substr($key, $len)] = count($header) == 1 ? end($header) : $header; } } } }
protected function prepareAdditionalParameters(OperationInterface $operation, CommandInterface $command, RequestInterface $request, Parameter $additional) { if (!($location = $additional->getLocation())) { return; } $visitor = $this->factory->getRequestVisitor($location); $hidden = $command[$command::HIDDEN_PARAMS]; foreach ($command->toArray() as $key => $value) { if ($value !== null && !in_array($key, $hidden) && !$operation->hasParam($key)) { $additional->setName($key); $visitor->visit($command, $request, $additional, $value); } } return $visitor; }
/** * Map nested parameters into the location_key based parameters * * @param array $value Value to map * @param Parameter $param Parameter that holds information about the current key * * @return array Returns the mapped array */ protected function resolveRecursively(array $value, Parameter $param) { foreach ($value as $name => $v) { if ($subParam = $param->getProperty($name)) { $key = $subParam->getWireName(); if (is_array($v)) { $value[$key] = $this->resolveRecursively($v, $subParam); } elseif ($name != $key) { $value[$key] = $param->filter($v); unset($value[$name]); } } } return $value; }
protected function resolveRecursively(array $value, Parameter $param) { foreach ($value as $name => &$v) { switch ($param->getType()) { case 'object': if ($subParam = $param->getProperty($name)) { $key = $subParam->getWireName(); $value[$key] = $this->prepareValue($v, $subParam); if ($name != $key) { unset($value[$name]); } } elseif ($param->getAdditionalProperties() instanceof Parameter) { $v = $this->prepareValue($v, $param->getAdditionalProperties()); } break; case 'array': if ($items = $param->getItems()) { $v = $this->prepareValue($v, $items); } break; } } return $param->filter($value); }
/** * Map nested parameters into the location_key based parameters * * @param array $value Value to map * @param Parameter $param Parameter that holds information about the current key * @param array $query Built up query string values * @param string $prefix String to prepend to sub query values */ protected function customResolver($value, Parameter $param, array &$query, $prefix = '') { if ($param->getType() == 'object') { foreach ($value as $name => $v) { if ($subParam = $param->getProperty($name)) { $key = $prefix . '.' . $subParam->getWireName(); if (is_array($v)) { $this->customResolver($v, $subParam, $query, $key); } else { $query[$key] = $v; } } } } elseif ($param->getType() == 'array') { $offset = $param->getData('offset') ?: 0; foreach ($value as $index => $v) { $index += $offset; if (is_array($v) && ($items = $param->getItems())) { $this->customResolver($v, $items, $query, $prefix . '.' . $index); } else { $query[$prefix . '.' . $index] = $v; } } } else { $query[$prefix] = $value; } }
/** * Custom handling for arrays * * @param Parameter $param Parameter for the object * @param array $value Value that is set for this parameter * @param string $prefix Prefix for the resulting key * @param array $query Query string array passed by reference */ protected function resolveArray(Parameter $param, array $value, $prefix, array &$query) { static $serializeEmpty = array('SetLoadBalancerPoliciesForBackendServer' => 1, 'SetLoadBalancerPoliciesOfListener' => 1, 'UpdateStack' => 1); // For BC, serialize empty lists for specific operations if (!$value) { if (isset($serializeEmpty[$this->fqname])) { $query[$prefix] = ''; } return; } $offset = $param->getData('offset') ?: 1; foreach ($value as $index => $v) { $index += $offset; if (is_array($v) && ($items = $param->getItems())) { $this->customResolver($v, $items, $query, $prefix . '.' . $index); } else { $query[$prefix . '.' . $index] = $param->filter($v); } } }
/** * Perform transformations on the result array * * @param Parameter $model Model that defines the structure * @param CommandInterface $command Command that performed the operation * @param Response $response Response received * * @return array Returns the array of result data */ protected function visitResult(Parameter $model, CommandInterface $command, Response $response) { // Determine what visitors are associated with the model $foundVisitors = $result = array(); foreach ($model->getProperties() as $schema) { if ($location = $schema->getLocation()) { $foundVisitors[$location] = $this->factory->getResponseVisitor($location); $foundVisitors[$location]->before($command, $result); } } foreach ($model->getProperties() as $schema) { /** @var $arg Parameter */ if ($location = $schema->getLocation()) { // Apply the parameter value with the location visitor $foundVisitors[$location]->visit($command, $response, $schema, $result); } } foreach ($foundVisitors as $visitor) { $visitor->after($command); } return $result; }
/** * {@inheritdoc} */ public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, $value) { $filteredValue = $param->filter($value); if (null !== $this->serializer && (is_object($filteredValue) || is_array($filteredValue))) { switch ($param->getSentAs()) { case 'json': $request->setHeader('Content-Type', 'application/json'); $contentType = 'json'; break; case 'yml': case 'yaml': $request->setHeader('Content-Type', 'application/yaml'); $contentType = 'yml'; break; default: $request->setHeader('Content-Type', 'application/xml'); $contentType = 'xml'; break; } $context = SerializationContext::create(); if (null !== ($groups = $param->getData('jms_serializer.groups'))) { $context->setGroups($groups); } if (null !== ($version = $param->getData('jms_serializer.version'))) { $context->setVersion($version); } if (null !== ($nulls = $param->getData('jms_serializer.serialize_nulls'))) { $context->setSerializeNull($nulls); } if (true === $param->getData('jms_serializer.max_depth_checks')) { $context->enableMaxDepthChecks(); } $value = $this->serializer->serialize($filteredValue, $contentType, $context); } parent::visit($command, $request, $param, $value); }
/** * Recursively process a parameter while applying filters * * @param Parameter $param API parameter being validated * @param mixed $value Value to validate and process. The value may change during this process. */ protected function recursiveProcess(Parameter $param, &$value) { if ($value === null) { return; } if (is_array($value)) { $type = $param->getType(); if ($type == 'array') { foreach ($value as &$item) { $this->recursiveProcess($param->getItems(), $item); } } elseif ($type == 'object' && !isset($value[0])) { // On the above line, we ensure that the array is associative and not numerically indexed $knownProperties = array(); if ($properties = $param->getProperties()) { foreach ($properties as $property) { $name = $property->getName(); $key = $property->getWireName(); $knownProperties[$name] = 1; if (isset($value[$key])) { $this->recursiveProcess($property, $value[$key]); if ($key != $name) { $value[$name] = $value[$key]; unset($value[$key]); } } } } // Remove any unknown and potentially unsafe properties if ($param->getAdditionalProperties() === false) { $value = array_intersect_key($value, $knownProperties); } elseif (($additional = $param->getAdditionalProperties()) !== true) { // Validate and filter additional properties foreach ($value as &$v) { $this->recursiveProcess($additional, $v); } } } } $value = $param->filter($value); }
protected function recursiveProcess(Parameter $param, &$value) { if ($value === null) { return; } if (is_array($value)) { $type = $param->getType(); if ($type == 'array') { foreach ($value as &$item) { $this->recursiveProcess($param->getItems(), $item); } } elseif ($type == 'object' && !isset($value[0])) { $knownProperties = array(); if ($properties = $param->getProperties()) { foreach ($properties as $property) { $name = $property->getName(); $key = $property->getWireName(); $knownProperties[$name] = 1; if (isset($value[$key])) { $this->recursiveProcess($property, $value[$key]); if ($key != $name) { $value[$name] = $value[$key]; unset($value[$key]); } } } } if ($param->getAdditionalProperties() === false) { $value = array_intersect_key($value, $knownProperties); } elseif (($additional = $param->getAdditionalProperties()) !== true) { foreach ($value as &$v) { $this->recursiveProcess($additional, $v); } } } } $value = $param->filter($value); }
/** * Add a parameter to the command * * @param Parameter $param Parameter to add * * @return self */ public function addParam(Parameter $param) { $this->parameters[$param->getName()] = $param; $param->setParent($this); return $this; }
public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, $value) { $request->getQuery()->set($param->getWireName(), $this->prepareValue($value, $param)); }
/** * Add an object to the XML */ protected function addXmlObject(\XMLWriter $xmlWriter, Parameter $param, &$value) { $noAttributes = array(); // add values which have attributes foreach ($value as $name => $v) { if ($property = $param->getProperty($name)) { if ($property->getData('xmlAttribute')) { $this->addXml($xmlWriter, $property, $v); } else { $noAttributes[] = array('value' => $v, 'property' => $property); } } } // now add values with no attributes foreach ($noAttributes as $element) { $this->addXml($xmlWriter, $element['property'], $element['value']); } }