Sirius\Orm\Entity\GenericEntity

Complexity

Total Complexity

32

Size/Duplication

Total Lines	158
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	2
A	__unset()	0	3	1
A	__set()	0	3	1
A	__isset()	0	3	1
A	castAttribute()	0	17	3
A	__get()	0	3	1
A	getChanges()	0	12	5
A	getPersistenceState()	0	6	2
A	set()	0	17	4
A	getArrayCopy()	0	9	4
A	preventChangesIfDeleted()	0	4	2
A	setPersistenceState()	0	6	2
A	get()	0	9	2
A	maybeLazyLoad()	0	11	2

<?php
declare(strict_types=1);

namespace Sirius\Orm\Entity;

use Sirius\Orm\CastingManager;
use Sirius\Orm\Helpers\Str;

class GenericEntity implements EntityInterface
{
    protected $state = StateEnum::CHANGED;

    protected $primaryKey = 'id';

    protected $attributes = [];

    protected $lazyLoaders = [];

    protected $changed = [];

    protected $casts = [];

    /**
     * @var CastingManager
     */
    protected $castingManager;

    public function __construct(array $attributes, CastingManager $castingManager = null)
    {
        $this->castingManager = $castingManager;
        foreach ($attributes as $attr => $value) {
            $this->set($attr, $value);
        }
    }

    public function __get($name)
    {
        return $this->get($name);
    }

    public function __set($name, $value)
    {
        return $this->set($name, $value);
    }

    public function __isset($name)
    {
        return isset($this->attributes[$name]);
    }

    public function __unset($name)
    {
        return $this->set($name, null);
    }

    protected function castAttribute($name, $value)
    {
        $method = Str::methodName($name . ' attribute', 'cast');
        if (method_exists($this, $method)) {
            return $this->$method($value);
        }

        if (!$this->castingManager) {
            return $value;
        }

        /**
         * @todo implement additional attributes
         */
        $type = $this->casts[$name] ?? $name;

        return $this->castingManager->cast($type, $value);
    }

    protected function set($attribute, $value = null)
    {
        $this->preventChangesIfDeleted();

        if ($value instanceof LazyLoader) {
            $this->lazyLoaders[$attribute] = $value;
            return $this;
        }

        $value = $this->castAttribute($attribute, $value);
        if (! isset($this->attributes[$attribute]) || $value != $this->attributes[$attribute]) {
            $this->changed[$attribute] = true;
            $this->state               = StateEnum::CHANGED;
        }
        $this->attributes[$attribute] = $value;

        return $this;
    }

    protected function get($attribute)
    {
        if (! $attribute) {
            return null;
        }

        $this->maybeLazyLoad($attribute);

        return $this->attributes[$attribute] ?? null;
    }

    public function getPersistenceState()
    {
        if (! empty($this->changed)) {
        }

        return $this->state;
    }

    public function setPersistenceState($state)
    {
        if ($state == StateEnum::SYNCHRONIZED) {
            $this->changed = [];
        }
        $this->state = $state;
    }

    public function getArrayCopy()
    {
        $copy = $this->attributes;
        foreach ($copy as $k => $v) {
            if (is_object($v) && method_exists($v, 'getArrayCopy')) {
                $copy[$k] = $v->getArrayCopy();
            }
        }
        return $copy;
    }

    public function getChanges()
    {
        $changes = $this->changed;
        foreach ($this->attributes as $name => $value) {
            if (is_object($value) && method_exists($value, 'getChanges')) {
                if (! empty($value->getChanges())) {
                    $changes[$name] = true;
                }
            }
        }

        return $changes;
    }

    protected function preventChangesIfDeleted()
    {
        if ($this->state == StateEnum::DELETED) {
            throw new \BadMethodCallException('Entity was deleted, no further changes are allowed');
        }
    }

    /**
     * @param $attribute
     */
    protected function maybeLazyLoad($attribute): void
    {
        if (isset($this->lazyLoaders[$attribute])) {
            // preserve state
            $state = $this->state;
            /** @var LazyLoader $lazyLoader */
            $lazyLoader = $this->lazyLoaders[$attribute];
            $lazyLoader->load();
            unset($this->changed[$attribute]);
            unset($this->lazyLoaders[$attribute]);
            $this->state = $state;
        }
    }
}