KleijnWeb\SwaggerBundle\Document\OperationObject

Complexity

Total Complexity

16

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	18	3
A	createFromOperationDefinition()	0	14	1
A	getRequestSchema()	0	4	1
A	getPath()	0	4	1
A	getMethod()	0	4	1
A	getDefinition()	0	4	1
C	assembleRequestSchema()	0	27	8

<?php
/*
 * This file is part of the KleijnWeb\SwaggerBundle package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace KleijnWeb\SwaggerBundle\Document;

/**
 * @author John Kleijn <john@kleijnweb.nl>
 */
class OperationObject
{
    /**
     * @var SwaggerDocument
     */
    private $document;

    /**
     * @var object
     */
    private $definition;

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

    /**
     * @var string
     */
    private $method;

    /**
     * @param SwaggerDocument $document
     * @param string          $path
     * @param string          $method
     */
    public function __construct(SwaggerDocument $document, $path, $method)
    {
        $paths = $document->getPathDefinitions();

        if (!property_exists($paths, $path)) {
            throw new \InvalidArgumentException("Path '$path' not in Swagger document");
        }
        $method = strtolower($method);
        if (!property_exists($paths->$path, $method)) {
            throw new \InvalidArgumentException("Method '$method' not supported for path '$path'");
        }

        $this->document = $document;
        $this->path = $path;
        $this->method = $method;
        $this->definition = $paths->$path->$method;
        $this->definition->{'x-request-schema'} = $this->assembleRequestSchema();
    }

    /**
     * @param object $definition
     * @param string $path
     * @param string $method
     *
     * @return static
     */
    public static function createFromOperationDefinition($definition, $path = '/', $method = 'GET')
    {
        $method = strtolower($method);
        $documentDefinition = (object)[
            'paths' => (object)[
                $path => (object)[
                    $method => $definition
                ]
            ]
        ];
        $document = new SwaggerDocument('', $documentDefinition);

        return new static($document, $path, $method);
    }

    /**
     * @return object
     */
    public function getRequestSchema()
    {
        return $this->definition->{'x-request-schema'};
    }

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

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

    /**
     * @return object
     */
    public function getDefinition()
    {
        return $this->definition;
    }

    /**
     * @return object
     */
    private function assembleRequestSchema()
    {
        if (!isset($this->definition->parameters)) {
            return new \stdClass;
        }
        $schema = new \stdClass;
        $schema->type = 'object';
        $schema->required = [];
        $schema->properties = new \stdClass;

        foreach ($this->definition->parameters as $paramDefinition) {
            if (isset($paramDefinition->required) && $paramDefinition->required) {
                $schema->required[] = $paramDefinition->name;
            }
            if ($paramDefinition->in === 'body') {
                $schema->properties->{$paramDefinition->name} = property_exists($paramDefinition, 'schema')
                    ? $paramDefinition->schema
                    : (object)['type' => 'object'];
                continue;
            }

            $type = property_exists($paramDefinition, 'type') ? $paramDefinition->type : 'string';
            $schema->properties->{$paramDefinition->name} = (object)['type' => $type];
        }

        return $schema;
    }
}