EntityGnome::checkDomainExists() - Code Metrics - Inspection of "coverage fixes" - kuperwood/eav - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 3f1e0c...bf7a69 )

by Aleksandr

created 2023-07-06 11:23 UTC

EntityGnome::checkDomainExists() A

↳ Parent: EntityGnome

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	2
eloc	3
nc	2
nop	1
dl	0
loc	6
ccs	4
cts	4
cp	1
crap	2
rs	10
c	1
b	0
f	1

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

namespace Drobotik\Eav;

use Drobotik\Eav\Enum\_ENTITY;
use Drobotik\Eav\Exception\EntityException;
use Drobotik\Eav\Result\Result;
use Drobotik\Eav\Trait\SingletonsTrait;

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();
            $key = $model->create([
                _ENTITY::DOMAIN_ID->column() => $domainKey,
                _ENTITY::ATTR_SET_ID->column() => $setKey
            ]);
            $entity->setKey($key);

            return 1;
        }
        $key = $entity->getKey();
        $record = $this->checkEntityExists($key);
        $domainKey = (int) $record[_ENTITY::DOMAIN_ID->column()];
        $setKey = (int) $record[_ENTITY::ATTR_SET_ID->column()];

        $this->checkDomainExists($domainKey);
        $this->checkAttrSetExist($setKey);
        $set->setKey($setKey);
        $entity->setDomainKey($domainKey);

        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->findByKey($key);

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

        $entity->setDomainKey($record[_ENTITY::DOMAIN_ID->column()]);
        $set = $entity->getAttributeSet();
        $set->setKey($record[_ENTITY::ATTR_SET_ID->column()]);
        $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();
        }
        $entityModel = $this->makeEntityModel();
        $recordResult = $entityModel->deleteByKey($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;
    }

    /**
     * @throws EntityException
     */
    private function checkEntityExists(int $key): array
    {
        $entity = $this->makeEntityModel();

        $result = $entity->findByKey($key);
        if ($result === false)
            EntityException::entityNotFound();

        return $result;
    }

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

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

    private function checkAttrSetExist(int $key): void
    {
        $model = $this->makeAttributeSetModel();

        if($model->findByKey($key) === false) {
            EntityException::attrSetNotFound();
        }
    }
}


1		<?php
2		/**
3		* This file is part of the eav package.
4		*
5		* @author Aleksandr Drobotik <[email protected]>
6		* @copyright 2023 Aleksandr Drobotik
7		* @license https://opensource.org/license/mit The MIT License
8		*/
9		declare(strict_types=1);
10
11		namespace Drobotik\Eav;
12
13		use Drobotik\Eav\Enum\_ENTITY;
14		use Drobotik\Eav\Exception\EntityException;
15		use Drobotik\Eav\Result\Result;
16		use Drobotik\Eav\Trait\SingletonsTrait;
17
18		class EntityGnome
19		{
20		use SingletonsTrait;
21
22		private Entity $entity;
23
24	1	public function __construct(Entity $entity)
25		{
26	1	$this->entity = $entity;
27		}
28
29	1	public function getEntity(): Entity
30		{
31	1	return $this->entity;
32		}
33
34	10	public function beforeSave(): int
35		{
36	10	$entity = $this->getEntity();
37	10	$set = $entity->getAttributeSet();
38	10	if (!$entity->hasKey()) {
39	6	if (!$entity->hasDomainKey()) {
40	1	EntityException::undefinedDomainKey();
41		}
42	5	if (!$set->hasKey()) {
43	1	EntityException::undefinedAttributeSetKey();
44		}
45	4	$domainKey = $entity->getDomainKey();
46	4	$this->checkDomainExists($domainKey);
47	3	$setKey = $set->getKey();
48	3	$this->checkAttrSetExist($setKey);
49	2	$model = $this->makeEntityModel();
50	2	$key = $model->create([
51	2	_ENTITY::DOMAIN_ID->column() => $domainKey,
52	2	_ENTITY::ATTR_SET_ID->column() => $setKey
53	2	]);
54	2	$entity->setKey($key);
55
56	2	return 1;
57		}
58	4	$key = $entity->getKey();
59	4	$record = $this->checkEntityExists($key);
60	3	$domainKey = (int) $record[_ENTITY::DOMAIN_ID->column()];
61	3	$setKey = (int) $record[_ENTITY::ATTR_SET_ID->column()];
62
63	3	$this->checkDomainExists($domainKey);
64	2	$this->checkAttrSetExist($setKey);
65	1	$set->setKey($setKey);
66	1	$entity->setDomainKey($domainKey);
67
68	1	return 2;
69		}
70
71	3	public function find(): Result
72		{
73	3	$result = new Result();
74
75	3	$entity = $this->getEntity();
76
77	3	if (!$entity->hasKey()) {
78	1	return $result->empty();
79		}
80	2	$key = $entity->getKey();
81
82	2	$model = $this->makeEntityModel();
83	2	$record = $model->findByKey($key);
84
85	2	if ($record === false) {
86	1	return $result->notFound();
87		}
88
89	1	$entity->setDomainKey($record[_ENTITY::DOMAIN_ID->column()]);
90	1	$set = $entity->getAttributeSet();
91	1	$set->setKey($record[_ENTITY::ATTR_SET_ID->column()]);
92	1	$set->fetchContainers();
93
94	1	$result->found();
95
96	1	return $result;
97		}
98
99	14	public function save(): Result
100		{
101	14	$entity = $this->getEntity();
102	14	$result = new Result();
103	14	$operationType = $this->beforeSave();
104	7	$set = $entity->getAttributeSet();
105	7	$set->fetchContainers();
106	7	$valueResults = [];
107	7	foreach ($set->getContainers() as $container) {
108	2	$attribute = $container->getAttribute();
109	2	$valueResults[$attribute->getName()] = $container->getStrategy()->save();
110		}
111	7	1 == $operationType
112	3	? $result->created()
113	4	: $result->updated();
114	7	$result->setData($valueResults);
115	7	$bag = $entity->getBag();
116	7	$bag->clear();
117
118	7	return $result;
119		}
120
121	4	public function delete()
122		{
123	4	$entity = $this->getEntity();
124	4	$set = $entity->getAttributeSet();
125
126	4	if (!$entity->hasKey()) {
127	1	EntityException::undefinedEntityKey();
128		}
129	3	if (!$set->hasKey()) {
130	1	EntityException::undefinedAttributeSetKey();
131		}
132
133	2	$result = new Result();
134	2	$set->fetchContainers();
135	2	$deleteResults = [];
136	2	foreach ($set->getContainers() as $container) {
137	1	$attribute = $container->getAttribute();
138	1	$deleteResults[$attribute->getName()] = $container->getStrategy()->delete();
139		}
140	2	$entityModel = $this->makeEntityModel();
141	2	$recordResult = $entityModel->deleteByKey($entity->getKey());
142	2	if (!$recordResult) {
143	1	return $result->notDeleted();
144		}
145
146	1	$entity->setKey(0);
147	1	$entity->setDomainKey(0);
148	1	$set->setKey(0);
149	1	$set->resetContainers();
150
151	1	$result->deleted();
152	1	$result->setData($deleteResults);
153
154	1	return $result;
155		}
156
157	2	public function validate(): Result
158		{
159	2	$result = new Result();
160	2	$result->validationPassed();
161	2	$entity = $this->getEntity();
162	2	$set = $entity->getAttributeSet();
163	2	$set->fetchContainers();
164	2	$errors = [];
165	2	foreach ($set->getContainers() as $container) {
166	2	$validationResult = $container->getValueValidator()->validateField();
167	2	if (!is_null($validationResult)) {
168	1	$errors[$container->getAttribute()->getName()] = $validationResult;
169		}
170		}
171	2	if (count($errors) > 0) {
172	1	$result->validationFails();
173	1	$result->setData($errors);
174		}
175
176	2	return $result;
177		}
178
179	1	public function toArray(): array
180		{
181	1	$result = [];
182	1	$entity = $this->getEntity();
183	1	foreach ($entity->getAttributeSet()->getContainers() as $container) {
184	1	$result[$container->getAttribute()->getName()] = $container->getValueManager()->getValue();
185		}
186
187	1	return $result;
188		}
189
190		/**
191		* @throws EntityException
192		*/
193		private function checkEntityExists(int $key): array
194		{
195		$entity = $this->makeEntityModel();
196
197		$result = $entity->findByKey($key);
198		if ($result === false)
199		EntityException::entityNotFound();
200
201		return $result;
202		}
203
204		/**
205		* @throws EntityException
206		*/
207	1	private function checkDomainExists(int $key): void
208		{
209	1	$domain = $this->makeDomainModel();
210
211	1	if ($domain->findByKey($key) === false)
212	1	EntityException::domainNotFound();
213		}
214
215	1	private function checkAttrSetExist(int $key): void
216		{
217	1	$model = $this->makeAttributeSetModel();
218
219	1	if($model->findByKey($key) === false) {
220	1	EntityException::attrSetNotFound();
221		}
222		}
223		}
224

kuperwood / eav

Push — master ( 3f1e0c...bf7a69 )

EntityGnome::checkDomainExists() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like