MetadataProvider::resolveReverseProperty() - Code Metrics - Inspection of "WIP: Complify" - Algo-Web/POData-Laravel - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#184)

by Alex

created 2019-10-01 15:12 UTC

MetadataProvider::resolveReverseProperty() A

↳ Parent: MetadataProvider

Complexity

Conditions	6
Paths	6

Size

Total Lines	24
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	42

Importance

Changes	4
Bugs	1	Features	1

Metric	Value
eloc	15
c	4
b	1
f	1
dl	0
loc	24
ccs	0
cts	0
cp	0
rs	9.2222
cc	6
nc	6
nop	2
crap	42

<?php

namespace AlgoWeb\PODataLaravel\Providers;

use AlgoWeb\PODataLaravel\Models\MetadataGubbinsHolder;
use AlgoWeb\PODataLaravel\Models\MetadataTrait;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationMonomorphic;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationStubRelationType;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationType;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\EntityFieldType;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\EntityGubbins;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Map;
use Illuminate\Contracts\Container\BindingResolutionException;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\App;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Schema as Schema;
use Illuminate\Support\Str;
use POData\Common\InvalidOperationException;
use POData\Providers\Metadata\ResourceStreamInfo;
use POData\Providers\Metadata\SimpleMetadataProvider;
use POData\Providers\Metadata\Type\TypeCode;

class MetadataProvider extends MetadataBaseProvider
{
    protected $multConstraints = ['0..1' => ['1'], '1' => ['0..1', '*'], '*' => ['1', '*']];
    protected static $metaNAMESPACE = 'Data';
    protected static $isBooted = false;
    const POLYMORPHIC = 'polyMorphicPlaceholder';
    const POLYMORPHIC_PLURAL = 'polyMorphicPlaceholders';

    /**
     * @var Map The completed object map set at post Implement;
     */
    private $completedObjectMap;

    /**
     * @return \AlgoWeb\PODataLaravel\Models\ObjectMap\Map
     */
    public function getObjectMap()
    {
        return $this->completedObjectMap;
    }

    protected static $afterExtract;
    protected static $afterUnify;
    protected static $afterVerify;
    protected static $afterImplement;

    public static function setAfterExtract(callable $method)
    {
        self::$afterExtract = $method;
    }

    public static function setAfterUnify(callable $method)
    {
        self::$afterUnify = $method;
    }

    public static function setAfterVerify(callable $method)
    {
        self::$afterVerify = $method;
    }

    public static function setAfterImplement(callable $method)
    {
        self::$afterImplement = $method;
    }


    protected $relationHolder;

    public function __construct($app)
    {
        parent::__construct($app);
        $this->relationHolder = new MetadataGubbinsHolder();
        self::$isBooted = false;
    }

    /**
     * @param array $modelNames
     * @return Map
     * @throws InvalidOperationException
     * @throws \Doctrine\DBAL\DBALException
     * @throws \ReflectionException
     */
    private function extract(array $modelNames)
    {
        /** @var Map $objectMap */
        $objectMap = App::make('objectmap');
        foreach ($modelNames as $modelName) {
            try {
                /** @var MetadataTrait $modelInstance */
                $modelInstance = App::make($modelName);
            } catch (BindingResolutionException $e) {
                // if we can't instantiate modelName for whatever reason, move on
                continue;
            }
            $gubbins = $modelInstance->extractGubbins();
            $isEmpty = 0 === count($gubbins->getFields());
            $inArtisan = $this->isRunningInArtisan();
            if (!($isEmpty && $inArtisan)) {
                $objectMap->addEntity($gubbins);
            }
        }
        $this->handleCustomFunction($objectMap, self::$afterExtract);
        return $objectMap;
    }

    /**
     * @param Map $objectMap
     * @return Map
     * @throws InvalidOperationException
     */
    private function unify(Map $objectMap)
    {
        /** @var MetadataGubbinsHolder $mgh */
        $mgh = $this->getRelationHolder();
        foreach ($objectMap->getEntities() as $entity) {
            $mgh->addEntity($entity);
        }
        $objectMap->setAssociations($mgh->getRelations());

        $this->handleCustomFunction($objectMap, self::$afterUnify);
        return $objectMap;
    }

    private function verify(Map $objectModel)
    {
        $objectModel->isOK();
        $this->handleCustomFunction($objectModel, self::$afterVerify);
    }

    /**
     * @param Map $objectModel
     * @throws InvalidOperationException
     * @throws \ReflectionException
     */
    private function implement(Map $objectModel)
    {
        /** @var SimpleMetadataProvider $meta */
        $meta = App::make('metadata');
        $namespace = $meta->getContainerNamespace().'.';

        $entities = $objectModel->getEntities();
        foreach ($entities as $entity) {
            $baseType = null;
            $className = $entity->getClassName();
            $entityName = $entity->getName();
            $pluralName = Str::plural($entityName);
            $entityType = $meta->addEntityType(new \ReflectionClass($className), $entityName, null, false, $baseType);
            if ($entityType->hasBaseType() !== isset($baseType)) {
                throw new InvalidOperationException('');
            }
            $entity->setOdataResourceType($entityType);
            $this->implementProperties($entity);
            $meta->addResourceSet($pluralName, $entityType);
            $meta->oDataEntityMap[$className] = $meta->oDataEntityMap[$namespace.$entityName];
        }
        $metaCount = count($meta->oDataEntityMap);
        $entityCount = count($entities);
        $expected = 2 * $entityCount;
        if ($metaCount != $expected) {
            $msg = 'Expected ' . $expected . ' items, actually got '.$metaCount;
            throw new InvalidOperationException($msg);
        }

        if (0 === count($objectModel->getAssociations())) {
            return;
        }
        $assoc = $objectModel->getAssociations();
        foreach ($assoc as $association) {
            if (!$association->isOk()) {
                throw new InvalidOperationException('');
            }
            $this->implementAssociationsMonomorphic($objectModel, $association);
        }
        $this->handleCustomFunction($objectModel, self::$afterImplement);
    }

    /**
     * @param Map $objectModel
     * @param AssociationMonomorphic $associationUnderHammer
     * @throws InvalidOperationException
     */
    private function implementAssociationsMonomorphic(Map $objectModel, AssociationMonomorphic $associationUnderHammer)
    {
        /** @var SimpleMetadataProvider $meta */
        $meta = App::make('metadata');
        $first = $associationUnderHammer->getFirst();
        $last = $associationUnderHammer->getLast();
        switch ($associationUnderHammer->getAssociationType()) {
            case AssociationType::NULL_ONE_TO_NULL_ONE():
            case AssociationType::NULL_ONE_TO_ONE():
            case AssociationType::ONE_TO_ONE():
                $meta->addResourceReferenceSinglePropertyBidirectional(
                    $objectModel->getEntities()[$first->getBaseType()]->getOdataResourceType(),
                    $objectModel->getEntities()[$last->getBaseType()]->getOdataResourceType(),
                    $first->getRelationName(),
                    $last->getRelationName()
                );
                break;
            case AssociationType::NULL_ONE_TO_MANY():
            case AssociationType::ONE_TO_MANY():
                if ($first->getMultiplicity()->getValue() == AssociationStubRelationType::MANY) {
                    $oneSide = $last;
                    $manySide = $first;
                } else {
                    $oneSide = $first;
                    $manySide = $last;
                }
                $meta->addResourceReferencePropertyBidirectional(
                    $objectModel->getEntities()[$oneSide->getBaseType()]->getOdataResourceType(),
                    $objectModel->getEntities()[$manySide->getBaseType()]->getOdataResourceType(),
                    $oneSide->getRelationName(),
                    $manySide->getRelationName()
                );
                break;
            case AssociationType::MANY_TO_MANY():
                $meta->addResourceSetReferencePropertyBidirectional(
                    $objectModel->getEntities()[$first->getBaseType()]->getOdataResourceType(),
                    $objectModel->getEntities()[$last->getBaseType()]->getOdataResourceType(),
                    $first->getRelationName(),
                    $last->getRelationName()
                );
        }
    }

    /**
     * @param EntityGubbins $unifiedEntity
     * @throws InvalidOperationException
     */
    private function implementProperties(EntityGubbins $unifiedEntity)
    {
        /** @var SimpleMetadataProvider $meta */
        $meta = App::make('metadata');
        $odataEntity = $unifiedEntity->getOdataResourceType();
        $keyFields = $unifiedEntity->getKeyFields();
        $fields = $unifiedEntity->getFields();
        foreach ($keyFields as $keyField) {
            $meta->addKeyProperty($odataEntity, $keyField->getName(), $keyField->getEdmFieldType());
        }

        foreach ($fields as $field) {
            if (in_array($field, $keyFields)) {
                continue;
            }
            if ($field->getPrimitiveType() == 'blob') {
                $odataEntity->setMediaLinkEntry(true);
                $streamInfo = new ResourceStreamInfo($field->getName());
                $odataEntity->addNamedStream($streamInfo);
                continue;
            }

            $default = $field->getDefaultValue();
            $isFieldBool = TypeCode::BOOLEAN == $field->getEdmFieldType();
            $default = $isFieldBool ? ($default ? 'true' : 'false') : strval($default);

            $meta->addPrimitiveProperty(
                $odataEntity,
                $field->getName(),
                $field->getEdmFieldType(),
                $field->getFieldType()->getValue() == EntityFieldType::PRIMITIVE_BAG()->getValue(),
                $default,
                $field->getIsNullable()
            );
        }
    }

    /**
     * Bootstrap the application services.  Post-boot.
     *
     * @param mixed $reset
     *
     * @return void
     * @throws InvalidOperationException
     * @throws \ReflectionException
     * @throws \Doctrine\DBAL\DBALException
     */
    public function boot($reset = true)
    {
        self::$metaNAMESPACE = env('ODataMetaNamespace', 'Data');
        // If we aren't migrated, there's no DB tables to pull metadata _from_, so bail out early
        try {
            if (!Schema::hasTable(config('database.migrations'))) {
                return;
            }
        } catch (\Exception $e) {
            return;
        }

        if (false !== self::$isBooted) {
            throw new InvalidOperationException('Provider booted twice');
        }
        $isCaching = true === $this->getIsCaching();
        $meta = Cache::get('metadata');
        $objectMap = Cache::get('objectmap');
        $hasCache = null != $meta && null != $objectMap;

        if ($isCaching && $hasCache) {
            App::instance('metadata', $meta);
            App::instance('objectmap', $objectMap);
            self::$isBooted = true;
            return;
        }
        $meta = App::make('metadata');
        if (false !== $reset) {
            $this->reset();
        }

        $modelNames = $this->getCandidateModels();
        $objectModel = $this->extract($modelNames);
        $objectModel = $this->unify($objectModel);
        $this->verify($objectModel);
        $this->implement($objectModel);
        $this->completedObjectMap = $objectModel;
        $key = 'metadata';
        $objKey = 'objectmap';
        $this->handlePostBoot($isCaching, $hasCache, $key, $meta);
        $this->handlePostBoot($isCaching, $hasCache, $objKey, $objectModel);
        self::$isBooted = true;
    }

    /**
     * Register the application services.  Boot-time only.
     *
     * @return void
     */
    public function register()
    {
        $this->app->singleton('metadata', function () {
            return new SimpleMetadataProvider('Data', self::$metaNAMESPACE);
        });
        $this->app->singleton('objectmap', function () {
            return new Map();
        });
    }

    /**
     * @return array
     */
    protected function getCandidateModels()
    {
        $classes = $this->getClassMap();
        $ends = [];
        $startName = $this->getAppNamespace();
        foreach ($classes as $name) {
            if (Str::startsWith($name, $startName)) {
                if (in_array('AlgoWeb\\PODataLaravel\\Models\\MetadataTrait', class_uses($name))) {
                    if (is_subclass_of($name, '\\Illuminate\\Database\\Eloquent\\Model')) {
                        $ends[] = $name;
                    }
                }
            }
        }
        return $ends;
    }

    /**
     * @return MetadataGubbinsHolder
     */
    public function getRelationHolder()
    {
        return $this->relationHolder;
    }

    public function reset()
    {
        self::$isBooted = false;
        self::$afterExtract = null;
        self::$afterUnify = null;
        self::$afterVerify = null;
        self::$afterImplement = null;
    }

    /**
     * Resolve possible reverse relation property names.
     *
     * @param Model $source
     * @param $propName
     * @return null|string
     * @internal param Model $target
     * @throws InvalidOperationException
     */
    public function resolveReverseProperty(Model $source, $propName)
    {
        if (!is_string($propName)) {
            throw new InvalidOperationException('Property name must be string');
        }
        $entity = $this->getObjectMap()->resolveEntity(get_class($source));
        if (null === $entity) {
            $msg = 'Source model not defined';
            throw new \InvalidArgumentException($msg);
        }
        $association = $entity->resolveAssociation($propName);

        if (null === $association) {
            return null;
        }
        $isFirst = $propName === $association->getFirst()->getRelationName();
        if (!$isFirst) {
            return $association->getFirst()->getRelationName();
        }

        if (!$association instanceof AssociationMonomorphic) {
            throw new InvalidOperationException('');
        }
        return $association->getLast()->getRelationName();
    }

    public function isRunningInArtisan()
    {
        return App::runningInConsole() && !App::runningUnitTests();
    }

    /**
     * Encapsulate applying self::$after{FOO} calls
     *
     * @param mixed $parm
     * @param callable|null $func
     */
    private function handleCustomFunction($parm, callable $func = null)
    {
        if (null != $func) {
            $func($parm);
        }
    }
}


1		<?php
2
3		namespace AlgoWeb\PODataLaravel\Providers;
4
5		use AlgoWeb\PODataLaravel\Models\MetadataGubbinsHolder;
6		use AlgoWeb\PODataLaravel\Models\MetadataTrait;
7		use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationMonomorphic;
8		use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationStubRelationType;
9		use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationType;
10		use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\EntityFieldType;
11		use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\EntityGubbins;
12		use AlgoWeb\PODataLaravel\Models\ObjectMap\Map;
13		use Illuminate\Contracts\Container\BindingResolutionException;
14		use Illuminate\Database\Eloquent\Model;
15		use Illuminate\Support\Facades\App;
16		use Illuminate\Support\Facades\Cache;
17		use Illuminate\Support\Facades\Schema as Schema;
18		use Illuminate\Support\Str;
19		use POData\Common\InvalidOperationException;
20	1	use POData\Providers\Metadata\ResourceStreamInfo;
21		use POData\Providers\Metadata\SimpleMetadataProvider;
22	1	use POData\Providers\Metadata\Type\TypeCode;
23
24		class MetadataProvider extends MetadataBaseProvider
25	1	{
26		protected $multConstraints = ['0..1' => ['1'], '1' => ['0..1', ''], '' => ['1', '*']];
27		protected static $metaNAMESPACE = 'Data';
28	1	protected static $isBooted = false;
29	1	const POLYMORPHIC = 'polyMorphicPlaceholder';
30		const POLYMORPHIC_PLURAL = 'polyMorphicPlaceholders';
31
32		/**
33		* @var Map The completed object map set at post Implement;
34		*/
35		private $completedObjectMap;
36
37		/**
38		* @return \AlgoWeb\PODataLaravel\Models\ObjectMap\Map
39		*/
40		public function getObjectMap()
41		{
42		return $this->completedObjectMap;
43		}
44
45		protected static $afterExtract;
46		protected static $afterUnify;
47		protected static $afterVerify;
48		protected static $afterImplement;
49
50		public static function setAfterExtract(callable $method)
51		{
52		self::$afterExtract = $method;
53		}
54
55		public static function setAfterUnify(callable $method)
56		{
57		self::$afterUnify = $method;
58		}
59
60		public static function setAfterVerify(callable $method)
61		{
62		self::$afterVerify = $method;
63		}
64
65		public static function setAfterImplement(callable $method)
66		{
67		self::$afterImplement = $method;
68		}
69
70
71		protected $relationHolder;
72
73		public function __construct($app)
74		{
75		parent::__construct($app);
76		$this->relationHolder = new MetadataGubbinsHolder();
77		self::$isBooted = false;
78		}
79
80		/**
81		* @param array $modelNames
82		* @return Map
83		* @throws InvalidOperationException
84		* @throws \Doctrine\DBAL\DBALException
85		* @throws \ReflectionException
86		*/
87		private function extract(array $modelNames)
88		{
89		/** @var Map $objectMap */
90		$objectMap = App::make('objectmap');
91		foreach ($modelNames as $modelName) {
92		try {
93		/** @var MetadataTrait $modelInstance */
94		$modelInstance = App::make($modelName);
95		} catch (BindingResolutionException $e) {
96		// if we can't instantiate modelName for whatever reason, move on
97		continue;
98		}
99		$gubbins = $modelInstance->extractGubbins();
100		$isEmpty = 0 === count($gubbins->getFields());
101		$inArtisan = $this->isRunningInArtisan();
102		if (!($isEmpty && $inArtisan)) {
103		$objectMap->addEntity($gubbins);
104		}
105		}
106		$this->handleCustomFunction($objectMap, self::$afterExtract);
107		return $objectMap;
108		}
109
110		/**
111		* @param Map $objectMap
112		* @return Map
113		* @throws InvalidOperationException
114		*/
115		private function unify(Map $objectMap)
116		{
117		/** @var MetadataGubbinsHolder $mgh */
118		$mgh = $this->getRelationHolder();
119		foreach ($objectMap->getEntities() as $entity) {
120		$mgh->addEntity($entity);
121		}
122		$objectMap->setAssociations($mgh->getRelations());
123
124		$this->handleCustomFunction($objectMap, self::$afterUnify);
125		return $objectMap;
126		}
127
128		private function verify(Map $objectModel)
129		{
130		$objectModel->isOK();
131		$this->handleCustomFunction($objectModel, self::$afterVerify);
132		}
133
134		/**
135		* @param Map $objectModel
136		* @throws InvalidOperationException
137		* @throws \ReflectionException
138		*/
139		private function implement(Map $objectModel)
140		{
141		/** @var SimpleMetadataProvider $meta */
142		$meta = App::make('metadata');
143		$namespace = $meta->getContainerNamespace().'.';
144
145		$entities = $objectModel->getEntities();
146		foreach ($entities as $entity) {
147		$baseType = null;
148		$className = $entity->getClassName();
149		$entityName = $entity->getName();
150		$pluralName = Str::plural($entityName);
151		$entityType = $meta->addEntityType(new \ReflectionClass($className), $entityName, null, false, $baseType);
152		if ($entityType->hasBaseType() !== isset($baseType)) {
153		throw new InvalidOperationException('');
154		}
155		$entity->setOdataResourceType($entityType);
156		$this->implementProperties($entity);
157		$meta->addResourceSet($pluralName, $entityType);
158		$meta->oDataEntityMap[$className] = $meta->oDataEntityMap[$namespace.$entityName];
159		}
160		$metaCount = count($meta->oDataEntityMap);
161		$entityCount = count($entities);
162		$expected = 2 * $entityCount;
163		if ($metaCount != $expected) {
164		$msg = 'Expected ' . $expected . ' items, actually got '.$metaCount;
165		throw new InvalidOperationException($msg);
166		}
167
168		if (0 === count($objectModel->getAssociations())) {
169		return;
170		}
171		$assoc = $objectModel->getAssociations();
172		foreach ($assoc as $association) {
173		if (!$association->isOk()) {
174		throw new InvalidOperationException('');
175		}
176		$this->implementAssociationsMonomorphic($objectModel, $association);
177		}
178		$this->handleCustomFunction($objectModel, self::$afterImplement);
179		}
180
181		/**
182		* @param Map $objectModel
183		* @param AssociationMonomorphic $associationUnderHammer
184		* @throws InvalidOperationException
185		*/
186		private function implementAssociationsMonomorphic(Map $objectModel, AssociationMonomorphic $associationUnderHammer)
187		{
188		/** @var SimpleMetadataProvider $meta */
189		$meta = App::make('metadata');
190		$first = $associationUnderHammer->getFirst();
191		$last = $associationUnderHammer->getLast();
192		switch ($associationUnderHammer->getAssociationType()) {
193		case AssociationType::NULL_ONE_TO_NULL_ONE():
194		case AssociationType::NULL_ONE_TO_ONE():
195		case AssociationType::ONE_TO_ONE():
196		$meta->addResourceReferenceSinglePropertyBidirectional(
197		$objectModel->getEntities()[$first->getBaseType()]->getOdataResourceType(),
198		$objectModel->getEntities()[$last->getBaseType()]->getOdataResourceType(),
199		$first->getRelationName(),
200		$last->getRelationName()
201		);
202		break;
203		case AssociationType::NULL_ONE_TO_MANY():
204		case AssociationType::ONE_TO_MANY():
205		if ($first->getMultiplicity()->getValue() == AssociationStubRelationType::MANY) {
206		$oneSide = $last;
207		$manySide = $first;
208		} else {
209		$oneSide = $first;
210		$manySide = $last;
211		}
212		$meta->addResourceReferencePropertyBidirectional(
213		$objectModel->getEntities()[$oneSide->getBaseType()]->getOdataResourceType(),
214		$objectModel->getEntities()[$manySide->getBaseType()]->getOdataResourceType(),
215		$oneSide->getRelationName(),
216		$manySide->getRelationName()
217		);
218		break;
219		case AssociationType::MANY_TO_MANY():
220		$meta->addResourceSetReferencePropertyBidirectional(
221		$objectModel->getEntities()[$first->getBaseType()]->getOdataResourceType(),
222		$objectModel->getEntities()[$last->getBaseType()]->getOdataResourceType(),
223		$first->getRelationName(),
224		$last->getRelationName()
225		);
226		}
227		}
228
229		/**
230		* @param EntityGubbins $unifiedEntity
231		* @throws InvalidOperationException
232		*/
233		private function implementProperties(EntityGubbins $unifiedEntity)
234		{
235		/** @var SimpleMetadataProvider $meta */
236		$meta = App::make('metadata');
237		$odataEntity = $unifiedEntity->getOdataResourceType();
238		$keyFields = $unifiedEntity->getKeyFields();
239		$fields = $unifiedEntity->getFields();
240		foreach ($keyFields as $keyField) {
241		$meta->addKeyProperty($odataEntity, $keyField->getName(), $keyField->getEdmFieldType());
242		}
243
244		foreach ($fields as $field) {
245		if (in_array($field, $keyFields)) {
246		continue;
247		}
248		if ($field->getPrimitiveType() == 'blob') {
249		$odataEntity->setMediaLinkEntry(true);
250		$streamInfo = new ResourceStreamInfo($field->getName());
251		$odataEntity->addNamedStream($streamInfo);
252		continue;
253		}
254
255		$default = $field->getDefaultValue();
256		$isFieldBool = TypeCode::BOOLEAN == $field->getEdmFieldType();
257		$default = $isFieldBool ? ($default ? 'true' : 'false') : strval($default);
258
259		$meta->addPrimitiveProperty(
260		$odataEntity,
261		$field->getName(),
262		$field->getEdmFieldType(),
263		$field->getFieldType()->getValue() == EntityFieldType::PRIMITIVE_BAG()->getValue(),
264		$default,
265		$field->getIsNullable()
266		);
267		}
268		}
269
270		/**
271		* Bootstrap the application services. Post-boot.
272		*
273		* @param mixed $reset
274		*
275		* @return void
276		* @throws InvalidOperationException
277		* @throws \ReflectionException
278		* @throws \Doctrine\DBAL\DBALException
279		*/
280		public function boot($reset = true)
281		{
282		self::$metaNAMESPACE = env('ODataMetaNamespace', 'Data');
283		// If we aren't migrated, there's no DB tables to pull metadata _from_, so bail out early
284		try {
285		if (!Schema::hasTable(config('database.migrations'))) {
286		return;
287		}
288		} catch (\Exception $e) {
289		return;
290		}
291
292		if (false !== self::$isBooted) {
293		throw new InvalidOperationException('Provider booted twice');
294		}
295		$isCaching = true === $this->getIsCaching();
296		$meta = Cache::get('metadata');
297		$objectMap = Cache::get('objectmap');
298		$hasCache = null != $meta && null != $objectMap;
299
300		if ($isCaching && $hasCache) {
301		App::instance('metadata', $meta);
302		App::instance('objectmap', $objectMap);
303		self::$isBooted = true;
304		return;
305		}
306		$meta = App::make('metadata');
307		if (false !== $reset) {
308		$this->reset();
309		}
310
311		$modelNames = $this->getCandidateModels();
312		$objectModel = $this->extract($modelNames);
313		$objectModel = $this->unify($objectModel);
314		$this->verify($objectModel);
315		$this->implement($objectModel);
316		$this->completedObjectMap = $objectModel;
317		$key = 'metadata';
318		$objKey = 'objectmap';
319		$this->handlePostBoot($isCaching, $hasCache, $key, $meta);
320		$this->handlePostBoot($isCaching, $hasCache, $objKey, $objectModel);
321		self::$isBooted = true;
322		}
323
324		/**
325		* Register the application services. Boot-time only.
326		*
327		* @return void
328		*/
329		public function register()
330		{
331		$this->app->singleton('metadata', function () {
332		return new SimpleMetadataProvider('Data', self::$metaNAMESPACE);
333		});
334		$this->app->singleton('objectmap', function () {
335		return new Map();
336		});
337		}
338
339		/**
340		* @return array
341		*/
342		protected function getCandidateModels()
343		{
344		$classes = $this->getClassMap();
345		$ends = [];
346		$startName = $this->getAppNamespace();
347		foreach ($classes as $name) {
348		if (Str::startsWith($name, $startName)) {
349		if (in_array('AlgoWeb\\PODataLaravel\\Models\\MetadataTrait', class_uses($name))) {
350		if (is_subclass_of($name, '\\Illuminate\\Database\\Eloquent\\Model')) {
351		$ends[] = $name;
352		}
353		}
354		}
355		}
356		return $ends;
357		}
358
359		/**
360		* @return MetadataGubbinsHolder
361		*/
362		public function getRelationHolder()
363		{
364		return $this->relationHolder;
365		}
366
367		public function reset()
368		{
369		self::$isBooted = false;
370		self::$afterExtract = null;
371		self::$afterUnify = null;
372		self::$afterVerify = null;
373		self::$afterImplement = null;
374		}
375
376		/**
377		* Resolve possible reverse relation property names.
378		*
379		* @param Model $source
380		* @param $propName
381		* @return null\|string
382		* @internal param Model $target
383		* @throws InvalidOperationException
384		*/
385		public function resolveReverseProperty(Model $source, $propName)
386		{
387		if (!is_string($propName)) {
388		throw new InvalidOperationException('Property name must be string');
389		}
390		$entity = $this->getObjectMap()->resolveEntity(get_class($source));
391		if (null === $entity) {
392		$msg = 'Source model not defined';
393		throw new \InvalidArgumentException($msg);
394		}
395		$association = $entity->resolveAssociation($propName);
396
397		if (null === $association) {
398		return null;
399		}
400		$isFirst = $propName === $association->getFirst()->getRelationName();
401		if (!$isFirst) {
402		return $association->getFirst()->getRelationName();
403		}
404
405		if (!$association instanceof AssociationMonomorphic) {
406		throw new InvalidOperationException('');
407		}
408		return $association->getLast()->getRelationName();
409		}
410
411		public function isRunningInArtisan()
412		{
413		return App::runningInConsole() && !App::runningUnitTests();
414		}
415
416		/**
417		* Encapsulate applying self::$after{FOO} calls
418		*
419		* @param mixed $parm
420		* @param callable\|null $func
421		*/
422		private function handleCustomFunction($parm, callable $func = null)
423		{
424		if (null != $func) {
425		$func($parm);
426		}
427		}
428		}
429

Algo-Web / POData-Laravel

Pull Request — master (#184)

MetadataProvider::resolveReverseProperty() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like