SoliDry\Extension\BaseRelationsTrait

Complexity

Total Complexity

29

Size/Duplication

Total Lines	278
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	deleteRelations()	0	43	4
A	presetRelations()	0	15	2
A	updateRelations()	0	6	1
A	setRelationships()	0	14	5
A	clearPivotBeforeSave()	0	9	2
A	savePivot()	0	6	1
A	saveModel()	0	20	2
A	createRelations()	0	6	1
A	related()	0	17	3
A	saveRelationship()	0	26	6
A	relations()	0	10	2

<?php

namespace SoliDry\Extension;

use Illuminate\Http\Request;
use Illuminate\Http\Response;
use League\Fractal\Resource\Collection;
use SoliDry\Blocks\FileManager;
use SoliDry\Helpers\Classes;
use SoliDry\Helpers\ConfigHelper;
use SoliDry\Helpers\Errors;
use SoliDry\Helpers\Json;
use SoliDry\Helpers\MigrationsHelper;
use SoliDry\Types\DirsInterface;
use SoliDry\Types\ModelsInterface;
use SoliDry\Types\PhpInterface;
use SoliDry\Types\ApiInterface;
use SoliDry\Helpers\ConfigHelper as conf;

/**
 * Trait BaseRelationsTrait
 * @package SoliDry\Extension
 */
trait BaseRelationsTrait
{
    use BaseModelTrait;

    /**
     * GET the relationships of this particular Entity
     *
     * @param Request $request
     * @param int|string $id
     * @param string $relation
     * @return Response
     */
    public function relations(Request $request, $id, string $relation) : Response
    {
        $model = $this->getEntity($id);
        if (empty($model)) {
            return $this->getResponse((new Json())->getErrors((new Errors())->getModelNotFound($this->entity, $id)),

It seems like getResponse() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                JSONApiInterface::HTTP_RESPONSE_CODE_NOT_FOUND);
        }

        $resource = Json::getRelations($model->$relation, $relation);
        return $this->getResponse(Json::prepareSerializedRelations($request, $resource));
    }

    /**
     * GET the fully represented relationships of this particular Entity
     *
     * @param Request $request
     * @param int|string $id
     * @param string $relation
     * @return Response
     */
    public function related(Request $request, $id, string $relation) : Response
    {
        $data = ($request->input(ModelsInterface::PARAM_DATA) === null) ? ModelsInterface::DEFAULT_DATA
            : Json::decode(urldecode($request->input(ModelsInterface::PARAM_DATA)));

        $model = $this->getEntity($id);
        if (empty($model)) {
            return $this->getResponse((new Json())->getErrors((new Errors())->getModelNotFound($this->entity, $id)),
                JSONApiInterface::HTTP_RESPONSE_CODE_NOT_FOUND);
        }

        $relEntity = ucfirst($relation);
        $formRequestEntity  = $this->getFormRequestEntity(conf::getModuleName(), $relEntity);

It seems like getFormRequestEntity() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $relFormRequest = new $formRequestEntity();

        $resource = Json::getResource($relFormRequest, $model->$relation, $this->entity, true);
        return $this->getResponse(Json::prepareSerializedData($resource, $data));
    }

    /**
     * POST relationships for specific entity id
     *
     * @param Request $request
     * @param int|string $id
     * @param string $relation
     * @return Response
     */
    public function createRelations(Request $request, $id, string $relation) : Response
    {
        $model    = $this->presetRelations($request, $id, $relation);
        $resource = Json::getResource($this->formRequest, $model, $this->entity);

        return $this->getResponse(Json::prepareSerializedData($resource), JSONApiInterface::HTTP_RESPONSE_CODE_CREATED);
    }

    /**
     * PATCH relationships for specific entity id
     *
     * @param Request $request
     * @param int|string $id
     * @param string $relation
     * @return Response
     */
    public function updateRelations(Request $request, $id, string $relation) : Response
    {
        $model    = $this->presetRelations($request, $id, $relation);
        $resource = Json::getResource($this->formRequest, $model, $this->entity);

        return $this->getResponse(Json::prepareSerializedData($resource));
    }

    /**
     * @param Request $request
     * @param int|string $id
     * @param string $relation
     * @return mixed
     */
    private function presetRelations(Request $request, $id, string $relation)
    {
        $json = Json::decode($request->getContent());
        $this->setRelationships($json, $id, true);

        // set include for relations
        $_GET['include'] = $relation;
        $model           = $this->getEntity($id);

        if (empty($model)) {
            return $this->getResponse((new Json())->getErrors((new Errors())->getModelNotFound($this->entity, $id)),
                JSONApiInterface::HTTP_RESPONSE_CODE_NOT_FOUND);
        }

        return $model;
    }

    /**
     * DELETE relationships for specific entity id
     *
     * @param Request $request JSON API formatted string
     * @param int|string $id int id of an entity
     * @param string $relation
     * @return Response
     */
    public function deleteRelations(Request $request, $id, string $relation) : Response
    {
        $json        = Json::decode($request->getContent());
        $jsonApiRels = Json::getData($json);
        if (empty($jsonApiRels) === false) {
            $lowEntity = strtolower($this->entity);
            foreach ($jsonApiRels as $index => $val) {
                $rId = $val[ApiInterface::RAML_ID];
                // if pivot file exists then save
                $ucEntity = ucfirst($relation);
                $file     = DirsInterface::MODULES_DIR . PhpInterface::SLASH
                    . ConfigHelper::getModuleName() . PhpInterface::SLASH .
                    DirsInterface::ENTITIES_DIR . PhpInterface::SLASH .
                    $this->entity . $ucEntity . PhpInterface::PHP_EXT;
                if (file_exists(PhpInterface::SYSTEM_UPDIR . $file)) { // ManyToMany rel
                    $pivotEntity = Classes::getModelEntity($this->entity . $ucEntity);
                    // clean up old links
                    $this->getModelEntities(
                        $pivotEntity,
                        [
                            [
                                $lowEntity . PhpInterface::UNDERSCORE . ApiInterface::RAML_ID => $id,
                                $relation . PhpInterface::UNDERSCORE . ApiInterface::RAML_ID  => $rId,
                            ],
                        ]
                    )->delete();
                } else { // OneToOne/Many - note this is always updates one row related to entity e.g.:
                    // find article by id and update tag_id or topic_id
                    $entity = Classes::getModelEntity($this->entity);

                    /** @var \Illuminate\Database\Eloquent\Builder $model */
                    $model = $this->getModelEntities(
                        $entity, [
                            ApiInterface::RAML_ID, $id,
                        ]
                    );

                    $model->update([$relation . PhpInterface::UNDERSCORE . ApiInterface::RAML_ID => 0]);
                }
            }
        }

        return $this->getResponse(Json::prepareSerializedData(new Collection()), JSONApiInterface::HTTP_RESPONSE_CODE_NO_CONTENT);
    }

    /**
     * @param array $json
     * @param int|string $eId
     * @param bool $isRemovable
     */
    protected function setRelationships(array $json, $eId, bool $isRemovable = false) : void
    {
        $jsonApiRels = Json::getRelationships($json);
        if (empty($jsonApiRels) === false) {
            foreach ($jsonApiRels as $entity => $value) {
                if (empty($value[ApiInterface::RAML_DATA][ApiInterface::RAML_ID]) === false) {
                    // if there is only one relationship
                    $rId = $value[ApiInterface::RAML_DATA][ApiInterface::RAML_ID];
                    $this->saveRelationship($entity, $eId, $rId, $isRemovable);
                } else {
                    // if there is an array of relationships
                    foreach ($value[ApiInterface::RAML_DATA] as $index => $val) {
                        $rId = $val[ApiInterface::RAML_ID];
                        $this->saveRelationship($entity, $eId, $rId, $isRemovable);
                    }
                }
            }
        }
    }

    /**
     * @param      $entity
     * @param int|string $eId
     * @param int|string $rId
     * @param bool $isRemovable
     */
    private function saveRelationship($entity, $eId, $rId, bool $isRemovable = false) : void
    {
        $ucEntity  = Classes::getClassName($entity);
        $lowEntity = MigrationsHelper::getTableName($this->entity);
        // if pivot file exists then save
        $filePivot          = FileManager::getPivotFile($this->entity, $ucEntity);
        $filePivotInverse   = FileManager::getPivotFile($ucEntity, $this->entity);
        $pivotExists        = file_exists(PhpInterface::SYSTEM_UPDIR . $filePivot);
        $pivotInverseExists = file_exists(PhpInterface::SYSTEM_UPDIR . $filePivotInverse);
        if ($pivotExists === true || $pivotInverseExists === true) { // ManyToMany rel
            $pivotEntity = null;

            if ($pivotExists) {
                $pivotEntity = Classes::getModelEntity($this->entity . $ucEntity);
            } else {
                if ($pivotInverseExists) {
                    $pivotEntity = Classes::getModelEntity($ucEntity . $this->entity);
                }
            }

            if ($isRemovable === true) {
                $this->clearPivotBeforeSave($pivotEntity, $lowEntity, $eId);

It seems like $pivotEntity can also be of type null; however, parameter $pivotEntity of SoliDry\Extension\BaseRelationsTrait::clearPivotBeforeSave() does only seem to accept string, maybe add an additional type check?

            }
            $this->savePivot($pivotEntity, $lowEntity, $entity, $eId, $rId);

It seems like $pivotEntity can also be of type null; however, parameter $pivotEntity of SoliDry\Extension\BaseRelationsTrait::savePivot() does only seem to accept string, maybe add an additional type check?

        } else { // OneToOne
            $this->saveModel($ucEntity, $lowEntity, $eId, $rId);
        }
    }

    /**
     * @param string $pivotEntity
     * @param string $lowEntity
     * @param int|string $eId
     */
    private function clearPivotBeforeSave(string $pivotEntity, string $lowEntity, $eId) : void
    {
        if ($this->relsRemoved === false) {
            // clean up old links
            $this->getModelEntities(
                $pivotEntity,
                [$lowEntity . PhpInterface::UNDERSCORE . ApiInterface::RAML_ID, $eId]
            )->delete();
            $this->relsRemoved = true;

The property relsRemoved does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }
    }

    /**
     * @param string $pivotEntity
     * @param string $lowEntity
     * @param string $entity
     * @param int|string $eId
     * @param int|string $rId
     */
    private function savePivot(string $pivotEntity, string $lowEntity, string $entity, $eId, $rId) : void
    {
        $pivot                                                                  = new $pivotEntity();
        $pivot->{$entity . PhpInterface::UNDERSCORE . ApiInterface::RAML_ID}    = $rId;
        $pivot->{$lowEntity . PhpInterface::UNDERSCORE . ApiInterface::RAML_ID} = $eId;
        $pivot->save();
    }

    /**
     * Saves model with related id from linked table full duplex
     * @param string $ucEntity
     * @param string $lowEntity
     * @param int|string $eId
     * @param int|string $rId
     */
    private function saveModel(string $ucEntity, string $lowEntity, $eId, $rId) : void
    {
        $relEntity = Classes::getModelEntity($ucEntity);
        $model     = $this->getModelEntity($relEntity, $rId);

        // swap table and field trying to find rels with inverse
        if (!property_exists($model, $lowEntity . PhpInterface::UNDERSCORE . ApiInterface::RAML_ID)) {
            $ucTmp     = $ucEntity;
            $ucEntity  = ucfirst($lowEntity);
            $relEntity = Classes::getModelEntity($ucEntity);
            $model     = $this->getModelEntity($relEntity, $eId);
            $lowEntity = strtolower($ucTmp);

            $model->{$lowEntity . PhpInterface::UNDERSCORE . ApiInterface::RAML_ID} = $rId;
            $model->save();
            return;
        }

        $model->{$lowEntity . PhpInterface::UNDERSCORE . ApiInterface::RAML_ID} = $eId;
        $model->save();
    }
}