Tubee\Rest\v1\ObjectRelations

Complexity

Total Complexity

9

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

0%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getAll()	0	20	2
A	getOne()	0	15	2
A	post()	0	14	1
A	delete()	0	7	1
A	patch()	0	20	1
A	watchAll()	0	13	1

<?php

declare(strict_types=1);

/**
 * tubee.io
 *
 * @copyright   Copryright (c) 2017-2019 gyselroth GmbH (https://gyselroth.com)
 * @license     GPL-3.0 https://opensource.org/licenses/GPL-3.0
 */

namespace Tubee\Rest\v1;

use Fig\Http\Message\StatusCodeInterface;
use Lcobucci\ContentNegotiation\UnformattedResponse;
use Micro\Auth\Identity;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Rs\Json\Patch;
use Tubee\Acl;
use Tubee\DataObjectRelation\Factory as DataObjectRelationFactory;
use Tubee\ResourceNamespace\Factory as ResourceNamespaceFactory;
use Tubee\Rest\Helper;
use Zend\Diactoros\Response;

class ObjectRelations
{
    /**
     * namespace factory.
     *
     * @var ResourceNamespaceFactory
     */
    protected $namespace_factory;

    /**
     * Dataobject relation factory.
     *
     * @var DataObjectRelationFactory
     */
    protected $relation_factory;

    /**
     * Acl.
     *
     * @var Acl
     */
    protected $acl;

    /**
     * Init.
     */
    public function __construct(ResourceNamespaceFactory $namespace_factory, DataObjectRelationFactory $relation_factory, Acl $acl)
    {
        $this->namespace_factory = $namespace_factory;
        $this->relation_factory = $relation_factory;
        $this->acl = $acl;
    }

    /**
     * Entrypoint.
     */
    public function getAll(ServerRequestInterface $request, Identity $identity, string $namespace, ?string $collection = null, ?string $object = null): ResponseInterface
    {
        $query = array_merge([
            'offset' => 0,
            'limit' => 20,
        ], $request->getQueryParams());

        if ($object !== null) {
            $collection = $this->namespace_factory->getOne($namespace)->getCollection($collection);
            $object = $collection->getObject(['name' => $object]);
            $relatives = $object->getRelations($query['query'], false, (int) $query['offset'], (int) $query['limit'], $query['sort']);

            return Helper::getAll($request, $identity, $this->acl, $relatives);
        }

        $namespace = $this->namespace_factory->getOne($namespace);
        $result = $this->relation_factory->getAll($namespace, $query['query'], (int) $query['offset'], (int) $query['limit'], $query['sort']);

        return Helper::getAll($request, $identity, $this->acl, $result);
    }

    /**
     * Entrypoint.
     */
    public function getOne(ServerRequestInterface $request, Identity $identity, string $namespace, ?string $collection = null, ?string $object = null, ?string $relation = null): ResponseInterface
    {
        if ($object != null) {
            $collection = $this->namespace_factory->getOne($namespace)->getCollection($collection);
            $object = $collection->getObject(['name' => $object], false);
            $relative = $object->getRelation($relation);

            return Helper::getOne($request, $identity, $relative);
        }

        $namespace = $this->namespace_factory->getOne($namespace);
        $relative = $this->relation_factory->getOne($namespace, $relation);

        return Helper::getOne($request, $identity, $relative);
    }

    /**
     * Create object.
     */
    public function post(ServerRequestInterface $request, Identity $identity, string $namespace): ResponseInterface

The parameter $identity is not used and could be removed.

    {
        $body = $request->getParsedBody();
        $query = $request->getQueryParams();

        $namespace = $this->namespace_factory->getOne($namespace);
        $this->relation_factory->add($namespace, $body);

        return new UnformattedResponse(
            (new Response())->withStatus(StatusCodeInterface::STATUS_CREATED),
            $this->relation_factory->getOne($namespace, $body['name'])->decorate($request),
            ['pretty' => isset($query['pretty'])]
        );
    }

    /**
     * Delete.
     */
    public function delete(ServerRequestInterface $request, Identity $identity, string $namespace, string $relation): ResponseInterface

The parameter $request is not used and could be removed.

The parameter $identity is not used and could be removed.

    {
        $collection = $this->namespace_factory->getOne($namespace);

$collection is not used, you could remove the assignment.

        $this->relation_factory->deleteOne($namespace, $relation);

$namespace is of type string, but the function expects a object<Tubee\DataObjectRelation\DataObjectRelationInterface>.

$relation is of type string, but the function expects a boolean.

        return(new Response())->withStatus(StatusCodeInterface::STATUS_NO_CONTENT);
    }

    /**
     * Patch.
     */
    public function patch(ServerRequestInterface $request, Identity $identity, string $namespace, string $relation): ResponseInterface

The parameter $identity is not used and could be removed.

    {
        $body = $request->getParsedBody();
        $query = $request->getQueryParams();
        $namespace = $this->namespace_factory->getOne($namespace);
        $relation = $this->relation_factory->getOne($namespace, $relation);
        $doc = ['data' => $relation->getData()];

        $patch = new Patch(json_encode($doc), json_encode($body));
        $patched = $patch->apply();
        $update = json_decode($patched, true);

        $this->relation_factory->update($relation, $update);

        return new UnformattedResponse(
            (new Response())->withStatus(StatusCodeInterface::STATUS_OK),
            $this->relation_factory->getOne($namespace, $relation->getName())->decorate($request),
            ['pretty' => isset($query['pretty'])]
        );
    }

    /**
     * Watch.
     */
    public function watchAll(ServerRequestInterface $request, Identity $identity, string $namespace): ResponseInterface
    {
        $query = array_merge([
            'offset' => null,
            'limit' => null,
            'existing' => true,
        ], $request->getQueryParams());

        $object = $this->namespace_factory->getOne($namespace);

$object is not used, you could remove the assignment.

        $cursor = $this->relation_factory->watch($namespace, $query['query'], $query['offset'], $query['limit'], $query['sort']);

$namespace is of type string, but the function expects a object<Tubee\ResourceNamespace\ResourceNamespaceInterface>.

It seems like $query['offset'] can also be of type null; however, Tubee\DataObjectRelation\Factory::watch() does only seem to accept boolean, maybe add an additional type check?

        return Helper::watchAll($request, $identity, $this->acl, $cursor);
    }
}