/** * 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); }
/** * 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; }
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()); }
/** * 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); }