PHP Parameter::getAdditionalProperties方法代码示例

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);
}

 /**
  * Custom handling for objects
  *
  * @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 resolveObject(Parameter $param, array $value, $prefix, array &$query)
 {
     // Maps are implemented using additional properties
     $hasAdditionalProperties = $param->getAdditionalProperties() instanceof Parameter;
     $additionalPropertyCount = 0;
     foreach ($value as $name => $v) {
         if ($subParam = $param->getProperty($name)) {
             // if the parameter was found by name as a regular property
             $key = $prefix . '.' . $subParam->getWireName();
             $this->customResolver($v, $subParam, $query, $key);
         } elseif ($hasAdditionalProperties) {
             // Handle map cases like &Attribute.1.Name=<name>&Attribute.1.Value=<value>
             $additionalPropertyCount++;
             $data = $param->getData();
             $keyName = isset($data['keyName']) ? $data['keyName'] : 'key';
             $valueName = isset($data['valueName']) ? $data['valueName'] : 'value';
             $query["{$prefix}.{$additionalPropertyCount}.{$keyName}"] = $name;
             $newPrefix = "{$prefix}.{$additionalPropertyCount}.{$valueName}";
             if (is_array($v)) {
                 $this->customResolver($v, $param->getAdditionalProperties(), $query, $newPrefix);
             } else {
                 $query[$newPrefix] = $param->filter($v);
             }
         }
     }
 }

 protected function visitResult(Parameter $model, CommandInterface $command, Response $response)
 {
     $foundVisitors = $result = $knownProps = array();
     $props = $model->getProperties();
     foreach ($props as $schema) {
         if ($location = $schema->getLocation()) {
             if (!isset($foundVisitors[$location])) {
                 $foundVisitors[$location] = $this->factory->getResponseVisitor($location);
                 $foundVisitors[$location]->before($command, $result);
             }
         }
     }
     if (($additional = $model->getAdditionalProperties()) instanceof Parameter) {
         $this->visitAdditionalProperties($model, $command, $response, $additional, $result, $foundVisitors);
     }
     foreach ($props as $schema) {
         $knownProps[$schema->getName()] = 1;
         if ($location = $schema->getLocation()) {
             $foundVisitors[$location]->visit($command, $response, $schema, $result);
         }
     }
     if ($additional === false) {
         $result = array_intersect_key($result, $knownProps);
     }
     foreach ($foundVisitors as $visitor) {
         $visitor->after($command);
     }
     return $result;
 }

 /**
  * {@inheritdoc}
  */
 public function visit(CommandInterface $command, Response $response, Parameter $param, &$value, $context = null)
 {
     if ($param->getType() == 'object' && $param->getAdditionalProperties() instanceof Parameter) {
         $this->processPrefixedHeaders($response, $param, $value);
     } else {
         $value[$param->getName()] = (string) $response->getHeader($param->getWireName());
     }
 }

 /**
  * {@inheritdoc}
  */
 public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, $value)
 {
     if ($param->getType() == 'object' && $param->getAdditionalProperties() instanceof Parameter) {
         $this->addPrefixedHeaders($request, $param, $value);
     } else {
         $request->setHeader($param->getWireName(), $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);
}

 /**
  * 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 processObject(Parameter $param, &$value)
 {
     if (!isset($value[0]) && ($properties = $param->getProperties())) {
         $knownProperties = array();
         foreach ($properties as $property) {
             $name = $property->getName();
             $sentAs = $property->getWireName();
             $knownProperties[$name] = 1;
             if ($property->getData('xmlAttribute')) {
                 $this->processXmlAttribute($property, $value);
             } elseif (isset($value[$sentAs])) {
                 $this->recursiveProcess($property, $value[$sentAs]);
                 if ($name != $sentAs) {
                     $value[$name] = $value[$sentAs];
                     unset($value[$sentAs]);
                 }
             }
         }
         if ($param->getAdditionalProperties() === false) {
             $value = array_intersect_key($value, $knownProperties);
         }
     }
 }

 /**
  * 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) {
//.........这里部分代码省略.........

 /**
  * 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)
 {
     $foundVisitors = $result = array();
     $props = $model->getProperties();
     foreach ($props as $schema) {
         if ($location = $schema->getLocation()) {
             // Trigger the before method on the first found visitor of this type
             if (!isset($foundVisitors[$location])) {
                 $foundVisitors[$location] = $this->factory->getResponseVisitor($location);
                 $foundVisitors[$location]->before($command, $result);
             }
         }
     }
     // Visit additional properties when it is an actual schema
     if (($additional = $model->getAdditionalProperties()) instanceof Parameter) {
         $this->visitAdditionalProperties($model, $command, $response, $additional, $result, $foundVisitors);
     }
     // Apply the parameter value with the location visitor
     foreach ($props as $schema) {
         if ($location = $schema->getLocation()) {
             $foundVisitors[$location]->visit($command, $response, $schema, $result);
         }
     }
     // Call the after() method of each found visitor
     foreach ($foundVisitors as $visitor) {
         $visitor->after($command);
     }
     return $result;
 }

 /**
  * Process an object
  *
  * @param Parameter $param API parameter being parsed
  * @param mixed     $value Value to process
  */
 protected function processObject(Parameter $param, &$value)
 {
     // Ensure that the array is associative and not numerically indexed
     if (!isset($value[0]) && ($properties = $param->getProperties())) {
         $knownProperties = array();
         foreach ($properties as $property) {
             $name = $property->getName();
             $sentAs = $property->getWireName();
             $knownProperties[$name] = 1;
             if ($property->getData('xmlAttribute')) {
                 $this->processXmlAttribute($property, $value);
             } elseif (isset($value[$sentAs])) {
                 $this->recursiveProcess($property, $value[$sentAs]);
                 if ($name != $sentAs) {
                     $value[$name] = $value[$sentAs];
                     unset($value[$sentAs]);
                 }
             }
         }
         // Remove any unknown and potentially unsafe properties
         if ($param->getAdditionalProperties() === false) {
             $value = array_intersect_key($value, $knownProperties);
         }
     }
 }

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

protected function recursiveProcess(Parameter $param, &$value, $path = '', $depth = 0)
{

 $value = $param->getValue($value);

$required = $param->getRequired();

 if ((null === $value && !$required) || $param->getStatic()) {
return true;
}

$type = $param->getType();

 $valueIsArray = is_array($value);

 if ($name = $param->getName()) {
$path .= "[{$name}]";
}

if ($type == 'object') {


 if ($param->getInstanceOf()) {
$instance = $param->getInstanceOf();
if (!($value instanceof $instance)) {
$this->errors[] = "{$path} must be an instance of {$instance}";
return false;
}
}


 $traverse = $temporaryValue = false;


 if (!$valueIsArray && $value instanceof ToArrayInterface) {
$value = $value->toArray();
}

if ($valueIsArray) {

 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) {

 $value = array();
$temporaryValue = $valueIsArray = $traverse = true;
}

if ($traverse) {

if ($properties = $param->getProperties()) {

 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);

 if (null !== $current) {
$value[$name] = $current;
}
}
}
}

$additional = $param->getAdditionalProperties();
if ($additional !== true) {

 $keys = array_keys($value);

 $diff = array_diff($keys, array_keys($properties));
if (!empty($diff)) {

 if ($additional instanceOf Parameter) {
foreach ($diff as $key) {
$this->recursiveProcess($additional, $value[$key], "{$path}[{$key}]", $depth);
}
} else {

 $keys = array_keys($value);
$this->errors[] = sprintf('%s[%s] is not an allowed property', $path, reset($keys));
}
}
}


 
 
 if ($temporaryValue && empty($value)) {
$value = null;
$valueIsArray = false;
}
}

} elseif ($type == 'array' && $valueIsArray && $param->getItems()) {
//.........这里部分代码省略.........

 public function testAddsAdditionalProperties()
 {
     $p = new Parameter(array('type' => 'object', 'additionalProperties' => array('type' => 'string')));
     $this->assertInstanceOf('Guzzle\\Service\\Description\\Parameter', $p->getAdditionalProperties());
     $this->assertNull($p->getAdditionalProperties()->getAdditionalProperties());
     $p = new Parameter(array('type' => 'object'));
     $this->assertTrue($p->getAdditionalProperties());
 }

 /**
  * 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)
 {
     $foundVisitors = $result = array();
     $props = $model->getProperties();
     foreach ($props as $schema) {
         if ($location = $schema->getLocation()) {
             // Trigger the before method on the first found visitor of this type
             if (!isset($foundVisitors[$location])) {
                 $foundVisitors[$location] = $this->factory->getResponseVisitor($location);
                 $foundVisitors[$location]->before($command, $result);
             }
         }
     }
     // Visit additional properties when it is an actual schema
     if ($additional = $model->getAdditionalProperties()) {
         if ($additional instanceof Parameter) {
             // 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);
                 }
             }
         }
     }
     // Apply the parameter value with the location visitor
     foreach ($props as $schema) {
         if ($location = $schema->getLocation()) {
             $foundVisitors[$location]->visit($command, $response, $schema, $result);
         }
     }
     // Call the after() method of each found visitor
     foreach ($foundVisitors as $visitor) {
         $visitor->after($command);
     }
     return $result;
 }