Example #1
0
 public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, $value)
 {
     $value = $param->filter($value);
     if ($value instanceof PostFileInterface) {
         $request->addPostFile($value);
     } else {
         $request->addPostFile($param->getWireName(), $value);
     }
 }
Example #2
0
 /**
  * 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);
     }
 }
Example #3
0
 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;
 }
Example #4
0
 public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, $value)
 {
     $value = $param->filter($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);
     }
 }
Example #5
0
 /**
  * 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()->toArray() as $key => $header) {
             if (stripos($key, $prefix) === 0) {
                 // Account for multi-value headers
                 $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)
 {
     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);
         }
     }
 }
Example #7
0
 /**
  * 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);
 }
 /**
  * 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) {
         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);
 }
Example #9
0
 /**
  * Add a property to the parameter
  *
  * @param Parameter $property Properties to set
  *
  * @return self
  */
 public function addProperty(Parameter $property)
 {
     $this->properties[$property->getName()] = $property;
     $property->setParent($this);
     $this->propertiesCache = null;
     return $this;
 }
 /**
  * Serialize additional parameters
  *
  * @param OperationInterface $operation  Operation that owns the command
  * @param CommandInterface   $command    Command to prepare
  * @param RequestInterface   $request    Request to serialize
  * @param Parameter          $additional Additional parameters
  *
  * @return null|RequestVisitorInterface
  */
 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) {
         // Ignore values that are null or built-in command options
         if ($value !== null && !in_array($key, $hidden) && !$operation->hasParam($key)) {
             $additional->setName($key);
             $visitor->visit($command, $request, $additional, $value);
         }
     }
     return $visitor;
 }
Example #11
0
 public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, $value)
 {
     $request->setPostField($param->getWireName(), $this->prepareValue($value, $param));
 }
Example #12
0
 /**
  * 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') {
         // Objects are either associative arrays, ToArrayInterface, or some other object
         if ($param->getInstanceOf()) {
             $instance = $param->getInstanceOf();
             if (!$value instanceof $instance) {
                 $this->errors[] = "{$path} must be an instance of {$instance}";
                 return false;
             }
         }
         // 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 = array();
             $temporaryValue = $valueIsArray = $traverse = true;
         }
         if ($traverse) {
             if ($properties = $param->getProperties()) {
                 // if properties were found, the validate each property of the value
                 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 with something
                         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);
 }
Example #13
0
 /**
  * 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']);
     }
 }
Example #14
0
 /**
  * Add a model to the service description
  *
  * @param Parameter $model Model to add
  *
  * @return self
  */
 public function addModel(Parameter $model)
 {
     $this->models[$model->getName()] = $model;
     return $this;
 }
Example #15
0
 protected function visitAdditionalProperties(Parameter $model, CommandInterface $command, Response $response, Parameter $additional, &$result, array &$foundVisitors)
 {
     // Only visit when a location is specified
     if ($location = $additional->getLocation()) {
         if (!isset($foundVisitors[$location])) {
             $foundVisitors[$location] = $this->factory->getResponseVisitor($location);
             $foundVisitors[$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 (!$model->getProperty($key)) {
                     // Set the name to the key so that we can parse it with each visitor
                     $additional->setName($key);
                     $foundVisitors[$location]->visit($command, $response, $additional, $result);
                 }
             }
             // Reset the additionalProperties name to null
             $additional->setName(null);
         }
     }
 }
Example #16
0
 public function visit(CommandInterface $command, Response $response, Parameter $param, &$value, $context = null)
 {
     $value[$param->getName()] = $response->getReasonPhrase();
 }
Example #17
0
 /**
  * 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;
 }
Example #18
0
 public function visit(CommandInterface $command, Response $response, Parameter $param, &$value, $context = null)
 {
     $value[$param->getName()] = $param->filter($response->getBody());
 }