public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, array $context)
{
$body = $request->getBody();
if (!$body instanceof PostBodyInterface) {
throw new \RuntimeException('Must be a POST body interface');
}
$body->setField($param->getWireName(), $this->prepareValue($command[$param->getName()], $param));
}
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);
}
}
public function visit(GuzzleCommandInterface $command, RequestInterface $request, Parameter $param, array $context)
{
$body = $request->getBody();
if (!$body instanceof PostBodyInterface) {
throw new \RuntimeException('Must be a POST body interface');
}
$value = $param->filter($command[$param->getName()]);
if (!$value instanceof PostFileInterface) {
$value = new PostFile($param->getWireName(), $value);
}
$body->addFile($value);
}
public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, array $context)
{
$name = urlencode($param->formName);
$value = urlencode($command[$param->getName()]);
$content = Stream::factory($param->filter($value));
if ($request->getBody() === null) {
$request->setBody(Stream::factory(""));
}
$queryChar = '&';
if ($request->getBody()->__toString() == '') {
$queryChar = '';
}
$request->getBody()->write($queryChar . $name . "=" . $content);
}
/**
* Recursively process a parameter while applying filters
*
* @param Parameter $param API parameter being validated
* @param mixed $value Value to process.
* @return mixed|null
*/
private function recurse(Parameter $param, $value)
{
if (!is_array($value)) {
return $param->filter($value);
}
$result = [];
$type = $param->getType();
if ($type == 'array') {
$items = $param->getItems();
foreach ($value as $val) {
$result[] = $this->recurse($items, $val);
}
} 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) {
$key = $property->getWireName();
if (array_key_exists($key, $value)) {
$result[$property->getName()] = $this->recurse($property, $value[$key]);
// Remove from the value so that AP can later be handled
unset($value[$key]);
}
}
}
// Only check additional properties if everything wasn't already
// handled
if ($value) {
$additional = $param->getAdditionalProperties();
if ($additional === null || $additional === true) {
// Merge the JSON under the resulting array
$result += $value;
} elseif ($additional instanceof Parameter) {
// Process all child elements according to the given schema
foreach ($value as $prop => $val) {
$result[$prop] = $this->recurse($additional, $val);
}
}
}
}
return $param->filter($result);
}
/**
* Recursively prepare and filter nested values.
*
* @param array $value Value to map
* @param Parameter $param Parameter related to the current key.
*
* @return array Returns the mapped array
*/
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);
}
public function visit(GuzzleCommandInterface $command, ResponseInterface $response, Parameter $param, &$result, array $context = [])
{
$result[$param->getName()] = $param->filter($response->getBody());
}
public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, array $context)
{
$value = $command[$param->getName()];
$request->setBody(Stream::factory($param->filter($value)));
}
private function visitOuterArray(Parameter $model, array &$result, GuzzleCommandInterface $command, ResponseInterface $response, array &$context)
{
// Use 'location' defined on the top of the model
if (!($location = $model->getLocation())) {
return;
}
if (!isset($foundVisitors[$location])) {
$this->triggerBeforeVisitor($location, $model, $result, $command, $response, $context);
}
// Visit each item in the response
$this->responseLocations[$location]->visit($command, $response, $model, $result, $context);
}
/**
* Add an object to the XML
*/
protected function addXmlObject(\XMLWriter $writer, 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($writer, $property, $v);
} else {
$noAttributes[] = array('value' => $v, 'property' => $property);
}
}
}
// now add values with no attributes
foreach ($noAttributes as $element) {
$this->addXml($writer, $element['property'], $element['value']);
}
}
public function visit(GuzzleCommandInterface $command, RequestInterface $request, Parameter $param, array $context)
{
$query = $request->getQuery();
$query[$param->getWireName()] = $this->prepareValue($command[$param->getName()], $param);
}
public function testHasProperties()
{
$data = ['type' => 'object', 'properties' => ['foo' => ['type' => 'string'], 'bar' => ['type' => 'string']]];
$p = new Parameter($data);
$this->assertInstanceOf('GuzzleHttp\\Command\\Guzzle\\Parameter', $p->getProperty('foo'));
$this->assertSame($p->getProperty('foo'), $p->getProperty('foo'));
$this->assertNull($p->getProperty('wefwe'));
$properties = $p->getProperties();
$this->assertInternalType('array', $properties);
foreach ($properties as $prop) {
$this->assertInstanceOf('GuzzleHttp\\Command\\Guzzle\\Parameter', $prop);
}
$this->assertEquals($data, $p->toArray());
}
public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, array $context)
{
$value = $command[$param->getName()];
$request->setHeader($param->getWireName(), $param->filter($value));
}
/**
* Process an object
*
* @param Parameter $param API parameter being parsed
* @param \SimpleXMLElement $node Value to process
* @return array
*/
private function processObject(Parameter $param, \SimpleXMLElement $node)
{
$result = $knownProps = array();
// Handle known properties
if ($properties = $param->getProperties()) {
foreach ($properties as $property) {
$name = $property->getName();
$sentAs = $property->getWireName();
$knownProps[$sentAs] = 1;
if (strpos($sentAs, ':')) {
list($ns, $sentAs) = explode(':', $sentAs);
} else {
$ns = $property->getData('xmlNs');
}
if ($property->getData('xmlAttribute')) {
// Handle XML attributes
$result[$name] = (string) $node->attributes($ns, true)->{$sentAs};
} elseif (count($node->children($ns, true)->{$sentAs})) {
// Found a child node matching wire name
$childNode = $node->children($ns, true)->{$sentAs};
$result[$name] = $this->recursiveProcess($property, $childNode);
}
}
}
// Handle additional, undefined properties
$additional = $param->getAdditionalProperties();
if ($additional instanceof Parameter) {
// Process all child elements according to the given schema
foreach ($node->children($additional->getData('xmlNs'), true) as $childNode) {
/** @var \SimpleXMLElement $childNode */
$sentAs = $childNode->getName();
if (!isset($knownProps[$sentAs])) {
$result[$sentAs] = $this->recursiveProcess($additional, $childNode);
}
}
} elseif ($additional === null || $additional === true) {
// Blindly transform the XML into an array preserving as much data
// as possible. Remove processed, aliased properties.
$array = array_diff_key(static::xmlToArray($node), $knownProps);
// Merge it together with the original result
$result = array_merge($array, $result);
}
return $result;
}
/**
* Recursively validate a parameter
*
* @param Parameter $param API parameter being validated
* @param mixed $value Value to validate and validate. The value may change during this validate.
* @param string $path Current validation path (used for error reporting)
* @param int $depth Current depth in the validation validate
*
* @return bool Returns true if valid, or false if invalid
*/
protected function recursiveProcess(Parameter $param, &$value, $path = '', $depth = 0)
{
// Update the value by adding default or static values
$value = $param->getValue($value);
$required = $param->getRequired();
// if the value is null and the parameter is not required or is static,
// then skip any further recursion
if (null === $value && !$required || $param->getStatic()) {
return true;
}
$type = $param->getType();
// Attempt to limit the number of times is_array is called by tracking
// if the value is an array
$valueIsArray = is_array($value);
// If a name is set then update the path so that validation messages
// are more helpful
if ($name = $param->getName()) {
$path .= "[{$name}]";
}
if ($type == 'object') {
// Determine whether or not this "value" has properties and should
// be traversed
$traverse = $temporaryValue = false;
// Convert the value to an array
if (!$valueIsArray && $value instanceof ToArrayInterface) {
$value = $value->toArray();
}
if ($valueIsArray) {
// Ensure that the array is associative and not numerically indexed
if (isset($value[0])) {
$this->errors[] = "{$path} must be an array of properties. Got a numerically indexed array.";
return false;
}
$traverse = true;
} elseif ($value === null) {
// Attempt to let the contents be built up by default values if
// possible
$value = [];
$temporaryValue = $valueIsArray = $traverse = true;
}
if ($traverse) {
if ($properties = $param->getProperties()) {
// if properties were found, validate each property
foreach ($properties as $property) {
$name = $property->getName();
if (isset($value[$name])) {
$this->recursiveProcess($property, $value[$name], $path, $depth + 1);
} else {
$current = null;
$this->recursiveProcess($property, $current, $path, $depth + 1);
// Only set the value if it was populated
if (null !== $current) {
$value[$name] = $current;
}
}
}
}
$additional = $param->getAdditionalProperties();
if ($additional !== true) {
// If additional properties were found, then validate each
// against the additionalProperties attr.
$keys = array_keys($value);
// Determine the keys that were specified that were not
// listed in the properties of the schema
$diff = array_diff($keys, array_keys($properties));
if (!empty($diff)) {
// Determine which keys are not in the properties
if ($additional instanceof Parameter) {
foreach ($diff as $key) {
$this->recursiveProcess($additional, $value[$key], "{$path}[{$key}]", $depth);
}
} else {
// if additionalProperties is set to false and there
// are additionalProperties in the values, then fail
foreach ($diff as $prop) {
$this->errors[] = sprintf('%s[%s] is not an allowed property', $path, $prop);
}
}
}
}
// A temporary value will be used to traverse elements that
// have no corresponding input value. This allows nested
// required parameters with default values to bubble up into the
// input. Here we check if we used a temp value and nothing
// bubbled up, then we need to remote the value.
if ($temporaryValue && empty($value)) {
$value = null;
$valueIsArray = false;
}
}
} elseif ($type == 'array' && $valueIsArray && $param->getItems()) {
foreach ($value as $i => &$item) {
// Validate each item in an array against the items attribute of the schema
$this->recursiveProcess($param->getItems(), $item, $path . "[{$i}]", $depth + 1);
}
}
// If the value is required and the type is not null, then there is an
// error if the value is not set
if ($required && $value === null && $type != 'null') {
$message = "{$path} is " . ($param->getType() ? 'a required ' . implode(' or ', (array) $param->getType()) : 'required');
if ($param->getDescription()) {
$message .= ': ' . $param->getDescription();
}
$this->errors[] = $message;
return false;
}
// Validate that the type is correct. If the type is string but an
// integer was passed, the class can be instructed to cast the integer
// to a string to pass validation. This is the default behavior.
if ($type && !($type = $this->determineType($type, $value))) {
if ($this->castIntegerToStringType && $param->getType() == 'string' && is_integer($value)) {
$value = (string) $value;
} else {
$this->errors[] = "{$path} must be of type " . implode(' or ', (array) $param->getType());
}
}
// Perform type specific validation for strings, arrays, and integers
if ($type == 'string') {
// Strings can have enums which are a list of predefined values
if (($enum = $param->getEnum()) && !in_array($value, $enum)) {
$this->errors[] = "{$path} must be one of " . implode(' or ', array_map(function ($s) {
return '"' . addslashes($s) . '"';
}, $enum));
}
// Strings can have a regex pattern that the value must match
if (($pattern = $param->getPattern()) && !preg_match($pattern, $value)) {
$this->errors[] = "{$path} must match the following regular expression: {$pattern}";
}
$strLen = null;
if ($min = $param->getMinLength()) {
$strLen = strlen($value);
if ($strLen < $min) {
$this->errors[] = "{$path} length must be greater than or equal to {$min}";
}
}
if ($max = $param->getMaxLength()) {
if (($strLen ?: strlen($value)) > $max) {
$this->errors[] = "{$path} length must be less than or equal to {$max}";
}
}
} elseif ($type == 'array') {
$size = null;
if ($min = $param->getMinItems()) {
$size = count($value);
if ($size < $min) {
$this->errors[] = "{$path} must contain {$min} or more elements";
}
}
if ($max = $param->getMaxItems()) {
if (($size ?: count($value)) > $max) {
$this->errors[] = "{$path} must contain {$max} or fewer elements";
}
}
} elseif ($type == 'integer' || $type == 'number' || $type == 'numeric') {
if (($min = $param->getMinimum()) && $value < $min) {
$this->errors[] = "{$path} must be greater than or equal to {$min}";
}
if (($max = $param->getMaximum()) && $value > $max) {
$this->errors[] = "{$path} must be less than or equal to {$max}";
}
}
return empty($this->errors);
}
public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, array $context)
{
$this->jsonData[$param->getWireName()] = $this->prepareValue($command[$param->getName()], $param);
}
