TomHart\Restful\Traits\HasLinksTrait

Complexity

Total Complexity

24

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
	append()	0	1	?
	getRouteKey()	0	1	?
A	initializeHasLinksTrait()	0	4	1
A	getLinksAttribute()	0	10	2
A	buildLinks()	0	17	3
B	buildRelationshipLinks()	0	43	7
B	buildLink()	0	55	9
A	getRouteName()	0	8	2

<?php
/**
 * Created by PhpStorm.
 * User: tom
 * Date: 28/03/19
 * Time: 12:47
 */

namespace TomHart\Restful\Traits;

use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Routing\Router;
use Illuminate\Support\Str;
use ReflectionException;
use ReflectionMethod;
use TomHart\Restful\Concerns\HasLinks;

trait HasLinksTrait
{

    /**
     * Append attributes to query when building a query.
     *
     * @param string[]|string $attributes
     * @return $this
     */
    abstract public function append($attributes);

    /**
     * Get the value of the model's route key.
     *
     * @return mixed
     */
    abstract public function getRouteKey();

    /**
     * Add the links attribute to the model.
     */
    public function initializeHasLinksTrait(): void
    {
        $this->append('_links');
    }

    /**
     * Get the links for this model.
     * @return mixed[]
     * @throws ReflectionException
     */
    public function getLinksAttribute(): array
    {
        $links = $this->buildLinks();
        $relationships = $this->buildRelationshipLinks();
        if (!empty($relationships)) {
            $links['relationships'] = $relationships;
        }

        return $links;
    }

    /**
     * Returns the _links for the REST responses.
     *
     * @return mixed[]
     */
    public function buildLinks(): array
    {
        $routes = ['create', 'store', 'show', 'update', 'destroy'];
        $links = [];

        $router = app(Router::class);

        foreach ($routes as $routePart) {
            $link = $this->buildLink($this, $routePart, $router);

            if ($link) {
                $links[$routePart] = $link;
            }
        }

        return $links;
    }


    /**
     * Builds the links to create the relationship resources.
     *
     * @return mixed[]
     * @throws ReflectionException
     */
    public function buildRelationshipLinks(): array
    {
        $methods = get_class_methods($this);

        $links = [];
        $router = app(Router::class);

        foreach ($methods as $method) {
            $method2 = new ReflectionMethod($this, $method);
            $return = (string)$method2->getReturnType();

            if (empty($return)) {
                continue;
            }

            $isRelationship = is_subclass_of($return, Relation::class);

            if (!$isRelationship) {
                continue;
            }

            /** @var Relation $relationship */
            $relationship = $this->$method();

            $targetClass = $relationship->getRelated();

            if (!($targetClass instanceof HasLinks)) {
                continue;
            }

            $createLink = $this->buildLink($targetClass, 'create', $router);
            $storeLink = $this->buildLink($targetClass, 'store', $router);

            if ($createLink || $storeLink) {
                $links[$method] = [
                    'create' => $createLink,
                    'store' => $storeLink
                ];
            }
        }

        return $links;
    }


    /**
     * Builds a link if possible
     *
     * @param HasLinks $model
     * @param string $routePart
     * @param Router $router
     * @return mixed[]|bool
     */
    private function buildLink(HasLinks $model, string $routePart, Router $router)
    {
        $routeStub = $model->getRouteName();

        if ($routeStub === null) {
            return false;
        }

        if (!property_exists($this, 'primaryKey')) {
            return false;
        }

        // Make the route name, and check if it exists.
        $routeName = "$routeStub.$routePart";

        if (!$router->has($routeName)) {
            return false;
        }

        // Get any params needed to build the URL.
        $params = [];
        switch ($routePart) {
            case 'destroy':
            case 'update':
            case 'show':
                $params = [$this->getRouteKey() => $this->primaryKey];
                break;
        }

        // Get the route.
        $route = $router->getRoutes()->getByName($routeName);

        if (!$route) {
            return false;
        }

        // Get the methods applicable to the route, ignoring HEAD and PATCH.
        $methods = collect($route->methods());
        $methods = $methods->filter(static function ($item) {
            return !in_array($item, ['HEAD', 'PATCH']);
        })->map(static function ($str) {
            return strtolower($str);
        });

        // If there's only 1, return just that, otherwise, return an array.
        if ($methods->count() === 1) {
            $methods = $methods->first();
        }

        // Add!
        return [
            'method' => $methods,
            'href' => route($routeName, $params, false)
        ];
    }

    /**
     * Return the name for the resource route this model
     * @return string|null
     */
    public function getRouteName(): ?string
    {
        $name = $this->getRouteKey();
        if (!$name) {
            return null;
        }
        return Str::kebab(Str::studly($name));
    }
}