Mikemirten\Component\JsonApi\Mapper\Handler\RelationshipHandler

Complexity

Total Complexity

11

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

88.24%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	toResource()	0	13	3
A	fromResource()	0	4	1
A	createSingleIdentifierRelationship()	0	11	1
A	createIdentifierCollectionRelationship()	0	16	2
A	resolveIdentifier()	0	10	2
A	resolveType()	0	8	2

<?php
declare(strict_types = 1);

namespace Mikemirten\Component\JsonApi\Mapper\Handler;

use Mikemirten\Component\JsonApi\Document\IdentifierCollectionRelationship;
use Mikemirten\Component\JsonApi\Document\ResourceIdentifierObject;
use Mikemirten\Component\JsonApi\Document\ResourceObject;
use Mikemirten\Component\JsonApi\Document\SingleIdentifierRelationship;
use Mikemirten\Component\JsonApi\Mapper\Definition\Relationship as RelationshipDefinition;
use Mikemirten\Component\JsonApi\Mapper\MappingContext;

/**
 * Handler of relationships
 *
 * @package Mikemirten\Component\JsonApi\Mapper\Handler
 */
class RelationshipHandler implements HandlerInterface
{
    /**
     * {@inheritdoc}
     */
    public function toResource($object, ResourceObject $resource, MappingContext $context)
    {
        $definitions = $context->getDefinition()->getRelationships();

        foreach ($definitions as $definition)
        {
            $relationship = $definition->isCollection()
                ? $this->createIdentifierCollectionRelationship($object, $definition, $context)
                : $this->createSingleIdentifierRelationship($object, $definition, $context);

            $resource->setRelationship($definition->getName(), $relationship);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function fromResource($object, ResourceObject $resource, MappingContext $context)
    {
        // Do nothing
    }

    /**
     * Create relationship contains a single resource-identifier
     *
     * @param  mixed                  $object
     * @param  RelationshipDefinition $definition
     * @return SingleIdentifierRelationship
     */
    protected function createSingleIdentifierRelationship($object, RelationshipDefinition $definition, MappingContext $context): SingleIdentifierRelationship
    {
        $relatedObject = $object->{$definition->getGetter()}();

        $identifier   = $this->resolveIdentifier($relatedObject, $definition, $context);
        $resourceType = $this->resolveType($relatedObject, $definition, $context);

        $resource = new ResourceIdentifierObject($identifier, $resourceType);

        return new SingleIdentifierRelationship($resource);
    }

    /**
     * Create relationship contains a collection of resource-identifiers
     *
     * @param  mixed                  $object
     * @param  RelationshipDefinition $definition
     * @return IdentifierCollectionRelationship
     */
    protected function createIdentifierCollectionRelationship($object, RelationshipDefinition $definition, MappingContext $context): IdentifierCollectionRelationship
    {
        $relationship = new IdentifierCollectionRelationship();
        $collection   = $object->{$definition->getGetter()}();

        foreach ($collection as $relatedObject)
        {
            $identifier   = $this->resolveIdentifier($relatedObject, $definition, $context);
            $resourceType = $this->resolveType($relatedObject, $definition, $context);
            $resource     = new ResourceIdentifierObject($identifier, $resourceType);

            $relationship->addIdentifier($resource);
        }

        return $relationship;
    }

    /**
     * Resolve ID of resource
     *
     * @param  mixed                  $object
     * @param  RelationshipDefinition $definition
     * @param  MappingContext         $context
     * @return string
     */
    protected function resolveIdentifier($object, RelationshipDefinition $definition, MappingContext $context): string
    {
        if ($definition->hasIdentifierGetter()) {
            $method = $definition->getIdentifierGetter();

            return (string) $object->$method();
        }

        return $context->getIdentifierHandler()->getIdentifier($object, $context);
    }

    /**
     * Resolve type of resource
     *
     * @param  mixed                  $object
     * @param  RelationshipDefinition $definition
     * @param  MappingContext         $context
     * @return string
     */
    protected function resolveType($object, RelationshipDefinition $definition, MappingContext $context): string
    {
        if ($definition->hasResourceType()) {
            return $definition->getResourceType();
        }

        return $context->getTypeHandler()->getType($object, $context);
    }
}