Drobotik\Eav\EntityGnome

Complexity

Total Complexity

29

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Test Coverage

Coverage

64.71%

Importance

Changes	1
Bugs	0	Features	1

11 Methods

Rating	Name	Duplication	Size	Complexity
A	checkAttrSetExist()	0	6	2
A	save()	0	20	3
A	beforeSave()	0	31	4
A	find()	0	26	3
A	validate()	0	20	4
A	getEntity()	0	3	1
A	toArray()	0	9	2
A	checkDomainExists()	0	7	2
A	checkEntityExists()	0	6	2
A	delete()	0	33	5
A	__construct()	0	3	1

<?php
/**
 * This file is part of the eav package.
 *
 * @author    Aleksandr Drobotik <drobotiksbox@gmail.com>
 * @copyright 2023 Aleksandr Drobotik
 * @license   https://opensource.org/license/mit  The MIT License
 */
declare(strict_types=1);

namespace Drobotik\Eav;

use Drobotik\Eav\Exception\EntityException;
use Drobotik\Eav\Model\AttributeSetModel;
use Drobotik\Eav\Model\EntityModel;
use Drobotik\Eav\Result\Result;
use Drobotik\Eav\Trait\SingletonsTrait;
use Throwable;

class EntityGnome
{
    use SingletonsTrait;

    private Entity $entity;

    public function __construct(Entity $entity)
    {
        $this->entity = $entity;
    }

    public function getEntity(): Entity
    {
        return $this->entity;
    }

    public function beforeSave(): int
    {
        $entity = $this->getEntity();
        $set = $entity->getAttributeSet();
        if (!$entity->hasKey()) {
            if (!$entity->hasDomainKey()) {
                EntityException::undefinedDomainKey();
            }
            if (!$set->hasKey()) {
                EntityException::undefinedAttributeSetKey();
            }
            $domainKey = $entity->getDomainKey();
            $this->checkDomainExists($domainKey);
            $setKey = $set->getKey();
            $this->checkAttrSetExist($setKey);
            $model = $this->makeEntityModel();
            $model->setDomainKey($domainKey);
            $model->setAttrSetKey($setKey);
            $model->save();
            $entity->setKey($model->getKey());

            return 1;
        }
        $key = $entity->getKey();
        $record = $this->checkEntityExists($key);
        $this->checkDomainExists($record->getDomainKey());
        $this->checkAttrSetExist($record->getAttrSetKey());
        $set->setKey($record->getAttrSetKey());
        $entity->setDomainKey($record->getDomainKey());

        return 2;
    }

    public function find(): Result
    {
        $result = new Result();

        $entity = $this->getEntity();

        if (!$entity->hasKey()) {
            return $result->empty();
        }
        $key = $entity->getKey();

        $model = $this->makeEntityModel();
        $record = $model->find($key);

        if (is_null($record)) {
            return $result->notFound();
        }

        $entity->setDomainKey($record->getDomainKey());

It seems like $record->getDomainKey() can also be of type Illuminate\Database\Eloquent\Relations\HasManyThrough and Illuminate\Database\Eloquent\Relations\HasOneThrough; however, parameter $key of Drobotik\Eav\Entity::setDomainKey() does only seem to accept integer, maybe add an additional type check?

        $set = $entity->getAttributeSet();
        $set->setKey($record->getAttrSetKey());

It seems like $record->getAttrSetKey() can also be of type Illuminate\Database\Eloquent\Relations\HasManyThrough and Illuminate\Database\Eloquent\Relations\HasOneThrough; however, parameter $key of Drobotik\Eav\AttributeSet::setKey() does only seem to accept integer, maybe add an additional type check?

        $set->fetchContainers();

        $result->found();

        return $result;
    }

    public function save(): Result
    {
        $entity = $this->getEntity();
        $result = new Result();
        $operationType = $this->beforeSave();
        $set = $entity->getAttributeSet();
        $set->fetchContainers();
        $valueResults = [];
        foreach ($set->getContainers() as $container) {
            $attribute = $container->getAttribute();
            $valueResults[$attribute->getName()] = $container->getStrategy()->save();
        }
        1 == $operationType
            ? $result->created()
            : $result->updated();
        $result->setData($valueResults);
        $bag = $entity->getBag();
        $bag->clear();

        return $result;
    }

    public function delete()
    {
        $entity = $this->getEntity();
        $set = $entity->getAttributeSet();

        if (!$entity->hasKey()) {
            EntityException::undefinedEntityKey();
        }
        if (!$set->hasKey()) {
            EntityException::undefinedAttributeSetKey();
        }

        $result = new Result();
        $set->fetchContainers();
        $deleteResults = [];
        foreach ($set->getContainers() as $container) {
            $attribute = $container->getAttribute();
            $deleteResults[$attribute->getName()] = $container->getStrategy()->delete();
        }
        $recordResult = $this->makeEntityModel()->findAndDelete($entity->getKey());
        if (!$recordResult) {
            return $result->notDeleted();
        }

        $entity->setKey(0);
        $entity->setDomainKey(0);
        $set->setKey(0);
        $set->resetContainers();

        $result->deleted();
        $result->setData($deleteResults);

        return $result;
    }

    public function validate(): Result
    {
        $result = new Result();
        $result->validationPassed();
        $entity = $this->getEntity();
        $set = $entity->getAttributeSet();
        $set->fetchContainers();
        $errors = [];
        foreach ($set->getContainers() as $container) {
            $validationResult = $container->getValueValidator()->validateField();
            if (!is_null($validationResult)) {
                $errors[$container->getAttribute()->getName()] = $validationResult;
            }
        }
        if (count($errors) > 0) {
            $result->validationFails();
            $result->setData($errors);
        }

        return $result;
    }

    public function toArray(): array
    {
        $result = [];
        $entity = $this->getEntity();
        foreach ($entity->getAttributeSet()->getContainers() as $container) {
            $result[$container->getAttribute()->getName()] = $container->getValueManager()->getValue();
        }

        return $result;
    }

    private function checkEntityExists(int $key): EntityModel
    {
        try {
            return $this->makeEntityModel()->findOrFail($key);

The expression return $this->makeEntityModel()->findOrFail($key) could return the type Illuminate\Database\Eloquent\PendingHasThroughRelationship which is incompatible with the type-hinted return Drobotik\Eav\Model\EntityModel. Consider adding an additional type-check to rule them out.

        } catch (Throwable) {
            EntityException::entityNotFound();

In this branch, the function will implicitly return null which is incompatible with the type-hinted return Drobotik\Eav\Model\EntityModel. Consider adding a return statement or allowing null as return value.

        }
    }

    /**
     * @throws EntityException
     */
    private function checkDomainExists(int $key): void
    {
        $domain = $this->makeDomainModel();
        $domain->setKey($key);

        if ($domain->findMe() === false)
            EntityException::domainNotFound();
    }

    private function checkAttrSetExist(int $key): AttributeSetModel
    {
        try {
            return $this->makeAttributeSetModel()->findOrFail($key);

The expression return $this->makeAttributeSetModel()->findOrFail($key) could return the type Illuminate\Database\Eloquent\PendingHasThroughRelationship which is incompatible with the type-hinted return Drobotik\Eav\Model\AttributeSetModel. Consider adding an additional type-check to rule them out.

        } catch (Throwable) {
            EntityException::attrSetNotFound();

In this branch, the function will implicitly return null which is incompatible with the type-hinted return Drobotik\Eav\Model\AttributeSetModel. Consider adding a return statement or allowing null as return value.

        }
    }
}