AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\EntityGubbins

Complexity

Total Complexity

33

Size/Duplication

Total Lines	229
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	getOdataResourceType()	0	3	1
A	getStubs()	0	3	1
A	getName()	0	3	1
A	setOdataResourceType()	0	7	2
A	setFields()	0	22	6
A	getKeyFields()	0	3	1
A	setStubs()	0	10	3
A	setClassName()	0	3	1
A	getClassName()	0	3	1
A	getFields()	0	3	1
A	setName()	0	3	1
A	getFieldNames()	0	7	2
A	resolveAssociation()	0	3	2
A	isOK()	0	6	1
A	addAssociation()	0	16	6
A	getAssociations()	0	3	1
A	getAssociationNames()	0	7	2

<?php

declare(strict_types=1);

namespace AlgoWeb\PODataLaravel\Models\ObjectMap\Entities;

use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\Association;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationMonomorphic;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationStubBase;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationStubPolymorphic;
use POData\Common\InvalidOperationException;
use POData\Providers\Metadata\ResourceEntityType;

class EntityGubbins
{
    /**
     * @var string
     */
    private $name;

    /**
     * @var string
     */
    private $className;

    /**
     * @var EntityField[]
     */
    private $keyFields = [];

    /**
     * @var EntityField[] keyed by name
     */
    private $fields = [];

    /**
     * @var AssociationStubBase[]
     */
    private $stubs = [];

    /**
     * @var Association[]
     */
    private $associations = [];
    /**
     * @var ResourceEntityType
     */
    private $odataResourceType;

    /**
     * @return ResourceEntityType
     */
    public function getOdataResourceType(): ?ResourceEntityType
    {
        return $this->odataResourceType;
    }

    /**
     * @param ResourceEntityType $odataType
     */
    public function setOdataResourceType(ResourceEntityType $odataType): void
    {
        if ($odataType->isAbstract()) {
            $msg = 'OData resource entity type must be concrete';
            throw new \InvalidArgumentException($msg);
        }
        $this->odataResourceType = $odataType;
    }

    /**
     * @return string
     */
    public function getName(): ?string
    {
        return $this->name;
    }

    /**
     * @param string $name
     */
    public function setName($name): void
    {
        $this->name = $name;
    }

    /**
     * @return string
     */
    public function getClassName(): ?string
    {
        return $this->className;
    }

    /**
     * @param string $className
     */
    public function setClassName($className): void
    {
        $this->className = $className;
    }

    /**
     * @return EntityField[]
     */
    public function getKeyFields(): array
    {
        return $this->keyFields;
    }

    /**
     * @return EntityField[]
     */
    public function getFields(): array
    {
        return $this->fields;
    }

    /**
     * @param  EntityField[] $fields
     * @throws \Exception
     */
    public function setFields(array $fields): void
    {
        if (0 == count($fields)) {
            $msg = 'Fields array must not be empty for ' . $this->getClassName();
            throw new \Exception($msg);
        }
        $keys = [];
        foreach ($fields as $propName => $field) {
            if (!$field instanceof EntityField) {
                $msg = 'Fields array must only have EntityField objects for ' . $this->getClassName();
                throw new \Exception($msg);
            }
            if ($field->getIsKeyField()) {
                $keys[$propName] = $field;
            }
        }
        if (0 == count($keys)) {
            $msg = 'No key field supplied in fields array for ' . $this->getClassName();
            throw new \Exception($msg);
        }
        $this->fields    = $fields;
        $this->keyFields = $keys;
    }

    /**
     * @return AssociationStubBase[]
     */
    public function getStubs(): array
    {
        return $this->stubs;
    }

    /**
     * @param  AssociationStubBase[] $stubs
     * @throws \Exception
     */
    public function setStubs(array $stubs): void
    {
        foreach ($stubs as $field) {
            if (!$field instanceof AssociationStubBase) {
                $msg = 'Stubs array must only have AssociationStubBase objects';
                throw new \Exception($msg);
            }
            $field->setEntity($this);
        }
        $this->stubs = $stubs;
    }

    /**
     * @param  Association               $association
     * @param  bool                      $isFirst
     * @throws InvalidOperationException
     */
    public function addAssociation(Association $association, $isFirst = true): void
    {
        if ($association instanceof AssociationMonomorphic) {
            $stub = $isFirst ? $association->getFirst() : $association->getLast();
            // $stub is required to be not null, as getFirst and getLast return type hints prohibit returning null
            $exists = in_array($stub, $this->stubs);

            if (!($exists || ($stub instanceof AssociationStubPolymorphic))) {
                throw new \InvalidArgumentException('Association cannot be connected to this entity');
            }
            $propertyName = $stub->getRelationName();
        }
        if (empty($propertyName)) {
            throw new InvalidOperationException('');
        }
        $this->associations[$propertyName] = $association;
    }

    /**
     * @return String[]
     */
    protected function getFieldNames(): array
    {
        $fieldNames = [];
        foreach ($this->fields as $field) {
            $fieldNames[] = $field->getName();
        }
        return $fieldNames;
    }

    /**
     * @return String[]
     */
    protected function getAssociationNames(): array
    {
        $associationNames = [];
        foreach ($this->stubs as $stub) {
            $associationNames[] = $stub->getRelationName();
        }
        return $associationNames;
    }

    /**
     * @return Associations\Association[]
     */
    public function getAssociations(): array
    {
        return $this->associations;
    }

    /**
     * @param string $relName
     * @return Association|null
     */
    public function resolveAssociation($relName): ?Association
    {
        return array_key_exists($relName, $this->associations) ? $this->associations[$relName] : null;
    }

    /**
     * @return bool
     */
    public function isOK(): bool
    {
        $fieldNames       = $this->getFieldNames();
        $associationNames = $this->getAssociationNames();
        $intersection     = array_intersect($fieldNames, $associationNames);
        return 0 === count($intersection);
    }
}