OpenStack\Common\Api\Operation

Complexity

Total Complexity

16

Size/Duplication

Total Lines	130
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes	10
Bugs	1	Features	4

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	getPath()	0	4	1
A	getMethod()	0	4	1
A	hasParam()	0	4	1
A	getParam()	0	4	2
A	getJsonKey()	0	4	1
A	toParamArray()	0	10	2
A	validate()	0	14	4
A	checkDisallowedKeys()	0	8	2

<?php

namespace OpenStack\Common\Api;

use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Utils;

/**
 * This class represents an OpenStack API operation. It encapsulates most aspects of the REST operation: its HTTP
 * method, the URL path, its top-level JSON key, and all of its {@see Parameter} objects.
 *
 * An operation not only represents a remote operation, but it also provides the mechanism for executing it
 * over HTTP. To do this, it uses a {@see ClientInterface} that allows a {@see GuzzleHttp\Message\Request}
 * to be created from the user values provided. Once this request is assembled, it is then sent to the
 * remote API and the response is returned to whoever first invoked the Operation class.
 *
 * @package OpenStack\Common\Api
 */
class Operation
{
    /** @var string The HTTP method */
    private $method;

    /** @var string The URL path */
    private $path;

    /** @var string The top-level JSON key */
    private $jsonKey;

    /** @var []Parameter The parameters of this operation */
    private $params;

    /**
     * @param array $definition The data definition (in array form) that will populate this
     *                          operation. Usually this is retrieved from an {@see ApiInterface}
     *                          object method.
     */
    public function __construct(array $definition)
    {
        $this->method = $definition['method'];
        $this->path = $definition['path'];

        if (isset($definition['jsonKey'])) {
            $this->jsonKey = $definition['jsonKey'];
        }

        $this->params = self::toParamArray($definition['params']);
    }

    /**
     * @return string
     */
    public function getPath()
    {
        return $this->path;
    }

    /**
     * @return string
     */
    public function getMethod()
    {
        return $this->method;
    }

    /**
     * Indicates whether this operation supports a parameter.
     *
     * @param $key The name of a parameter
     *
     * @return bool
     */
    public function hasParam($key)
    {
        return isset($this->params[$key]);
    }

    /**
     * @param $name
     *
     * @return Parameter
     */
    public function getParam($name)
    {
        return isset($this->params[$name]) ? $this->params[$name] : null;
    }

    /**
     * @return string
     */
    public function getJsonKey()
    {
        return $this->jsonKey;
    }

    /**
     * A convenience method that will take a generic array of data and convert it into an array of
     * {@see Parameter} objects.
     *
     * @param array $data A generic data array
     *
     * @return array
     */
    public static function toParamArray(array $data)
    {
        $params = [];

        foreach ($data as $name => $param) {
            $params[$name] = new Parameter($param + ['name' => $name]);
        }

        return $params;
    }

    /**
     * This method will validate all of the user-provided values and throw an exception if any
     * failures are detected. This is useful for basic sanity-checking before a request is
     * serialized and sent to the API.
     *
     * @param array $userValues The user-defined values
     *
     * @return bool       TRUE if validation passes
     * @throws \Exception If validate fails
     */
    public function validate(array $userValues)
    {
        $this->checkDisallowedKeys($userValues);

        foreach ($this->params as $paramName => $param) {
            if (array_key_exists($paramName, $userValues)) {
                $param->validate($userValues[$paramName]);
            } elseif ($param->isRequired()) {
                throw new \Exception(sprintf('"%s" is a required option, but it was not provided', $paramName));
            }
        }

        return true;
    }

    private function checkDisallowedKeys(array $userValues)
    {
        if (!empty($disallowedKeys = array_keys(array_diff_key($userValues, $this->params)))) {
            throw new \Exception(sprintf(
                'The following keys are not supported: %s', implode($disallowedKeys, ', ')
            ));
        }
    }
}