Suricate\Traits\DBObjectRelations

Complexity

Total Complexity

19

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

Test Coverage

Coverage

59.61%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	isRelationLoaded()	0	3	1
A	loadRelationOneMany()	0	8	2
A	isRelation()	0	3	1
A	setRelations()	0	5	1
A	loadRelationOneOne()	0	6	1
A	loadRelation()	0	13	5
A	loadRelationManyMany()	0	8	1
A	getRelation()	0	16	5
A	markRelationAsLoaded()	0	4	2

<?php
namespace Suricate\Traits;

trait DBObjectRelations
{
    protected $relations                    = [];
    protected $relationValues               = [];
    protected $loadedRelations              = [];

    /**
     * Get relation from its name
     * 
     * @param string $name
     */
    protected function getRelation($name)
    {
        if (isset($this->relationValues[$name]) && $this->isRelationLoaded($name)) {
            return $this->relationValues[$name];
        }

        if (!$this->isRelationLoaded($name)) {
            $this->loadRelation($name);
            $this->markRelationAsLoaded($name);
        }

        if (isset($this->relationValues[$name])) {
            return $this->relationValues[$name];
        }

        return null;
    }

    /**
     * Check if variable is predefined relation
     * @param  string  $name variable name
     * @return boolean
     */
    protected function isRelation($name)
    {
        return isset($this->relations[$name]);
    }
    /**
     * Define object relations
     *
     * @return DBObject
     */
    protected function setRelations()
    {
        $this->relations = [];

        return $this;

The expression return $this returns the type Suricate\Traits\DBObjectRelations which is incompatible with the documented return type Suricate\Traits\DBObject.

    }

    /**
     * Mark a relation as loaded
     * @param  string $name varialbe name
     * @return void
     */
    protected function markRelationAsLoaded($name)
    {
        if ($this->isRelation($name)) {
            $this->loadedRelations[$name] = true;
        }
    }
     /**
     * Check if a relation already have been loaded
     * @param  string  $name Variable name
     * @return boolean
     */
    protected function isRelationLoaded($name)
    {
        return isset($this->loadedRelations[$name]);
    }

    /**
     * Load realation according to relation type
     *
     * @param string $name
     * @return void
     */
    protected function loadRelation($name)
    {
        if ($this->isRelation($name)) {
            switch ($this->relations[$name]['type']) {
                case self::RELATION_ONE_ONE:

The constant Suricate\Traits\DBObjectRelations::RELATION_ONE_ONE was not found. Maybe you did not declare it correctly or list all dependencies?

                    $this->loadRelationOneOne($name);
                    return;
                case self::RELATION_ONE_MANY:

The constant Suricate\Traits\DBObjectRelations::RELATION_ONE_MANY was not found. Maybe you did not declare it correctly or list all dependencies?

                    $this->loadRelationOneMany($name);
                    return;
                case self::RELATION_MANY_MANY:

The constant Suricate\Traits\DBObjectRelations::RELATION_MANY_MANY was not found. Maybe you did not declare it correctly or list all dependencies?

                    $this->loadRelationManyMany($name);
                    return;
            }
        }
    }

    /**
     * Load one to one relationship
     *
     * @param string $name
     * @return void
     */
    private function loadRelationOneOne($name)
    {
        $target = $this->relations[$name]['target'];
        $source = $this->relations[$name]['source'];
        $this->relationValues[$name] = new $target();
        $this->relationValues[$name]->load($this->$source);
    }

    /**
     * Load one to many relationship
     *
     * @param string $name
     * @return void
     */
    private function loadRelationOneMany($name)
    {
        $target         = $this->relations[$name]['target'];
        $parentId       = $this->{$this->relations[$name]['source']};
        $parentIdField  = isset($this->relations[$name]['target_field']) ? $this->relations[$name]['target_field'] : null;
        $validate       = dataGet($this->relations[$name], 'validate', null);
        
        $this->relationValues[$name] = $target::loadForParentId($parentId, $parentIdField, $validate);
    }

    /**
     * Load many to many relationship
     *
     * @param string $name
     * @return void
     */
    private function loadRelationManyMany($name)
    {
        $pivot      = $this->relations[$name]['pivot'];
        $sourceType = $this->relations[$name]['source_type'];
        $target     = dataGet($this->relations[$name], 'target');
        $validate   = dataGet($this->relations[$name], 'validate', null);

        $this->relationValues[$name] = $pivot::loadFor($sourceType, $this->{$this->relations[$name]['source']}, $target, $validate);
    }
}