MetadataRelationHolder::calculateRoundTripRelationsGenForwardReverse() - Code Metrics - Inspection of "Fix relation calculation" - Algo-Web/POData-Laravel - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#106)

by Alex

created 2017-09-03 04:20 UTC

calculateRoundTripRelationsGenForwardReverse() B

↳ Parent: MetadataRelationHolder

Complexity

Conditions	1
Paths	1

Size

Total Lines	34
Code Lines	28

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	34
rs	8.8571
c	0
b	0
f	0
cc	1
eloc	28
nc	1
nop	6

<?php

namespace AlgoWeb\PODataLaravel\Models;

use Illuminate\Database\Eloquent\Model;

class MetadataRelationHolder
{
    protected $multConstraints = [ '0..1' => ['1'], '1' => ['0..1', '*'], '*' => ['1', '*']];
    protected $relations = [];

    public function __construct()
    {
    }

    /**
     * Add model's relationships to holder
     *
     * @param Model $model
     */
    public function addModel(Model $model)
    {
        if (!in_array('AlgoWeb\\PODataLaravel\\Models\\MetadataTrait', class_uses($model))) {
            $msg = 'Supplied model does not use MetadataTrait';
            throw new \InvalidArgumentException($msg);
        }
        $className = get_class($model);
        if (array_key_exists($className, $this->relations)) {
            $msg = $className.' already added';
            throw new \InvalidArgumentException($msg);
        }
        $this->relations[$className] = $model->getRelationships();
    }

    public function getRelationsByKey($className, $keyName)
    {
        $this->checkClassExists($className);

        $rels = $this->relations[$className];
        if (!array_key_exists($keyName, $rels)) {
            $msg = 'Key ' . $keyName . ' not registered on ' . $className;
            throw new \InvalidArgumentException($msg);
        }

        $result = [];
        $payload = $rels[$keyName];
        $principalType = $className;
        foreach ($payload as $dependentType => $targDeets) {
            if (!array_key_exists($dependentType, $this->relations)) {
                continue;
            }
            // if principal and ostensible dependent type are equal, drop through to specific handler
            // at moment, this is only for morphTo relations - morphedByMany doesn't cause this
            if ($principalType === $dependentType) {
                $morphToLines = $this->getMorphToRelations($principalType, $targDeets, $keyName);
                foreach ($morphToLines as $morph) {
                    if (!in_array($morph, $result)) {
                        $result[] = $morph;
                    }
                }
                continue;
            }

            $foreign = $this->relations[$dependentType];

            foreach ($targDeets as $principalProperty => $rawDeets) {
                $targKey = $rawDeets['local'];
                $principalMult = $rawDeets['multiplicity'];
                $principalProperty = $rawDeets['property'];
                if (!array_key_exists($targKey, $foreign)) {
                    continue;
                }
                $foreignDeets = $foreign[$targKey];
                foreach ($foreignDeets as $foreignType => $raw) {
                    if (!array_key_exists($foreignType, $this->relations)) {
                        continue;
                    }
                    $result = $this->generateRoundTripRelations(
                        $principalType,
                        $keyName,
                        $raw,
                        $principalMult,
                        $principalProperty,
                        $dependentType,
                        $result
                    );
                }
            }
        }
        return $result;
    }

    public function getRelationsByClass($className)
    {
        $this->checkClassExists($className);

        $rels = $this->relations[$className];
        $keys = array_keys($rels);
        $results = [];
        foreach ($keys as $key) {
            $lines = $this->getRelationsByKey($className, $key);
            foreach ($lines as $line) {
                if (!in_array($line, $results)) {
                    $results[] = $line;
                }
            }
        }

        return $results;
    }

    private function getMorphToRelations($principalType, $targDeets, $keyName)
    {
        $result = [];
        $deetKeys = array_keys($targDeets);
        $principalProperty = $deetKeys[0];
        $principalDeets = $targDeets[$principalProperty];
        $principalMult = $principalDeets['multiplicity'];

        foreach ($this->relations as $dependentType => $dependentDeets) {
            foreach ($dependentDeets as $targKey => $rawDeets) {
                foreach ($rawDeets as $targType => $interDeets) {
                    if ($targType != $principalType) {
                        continue;
                    }
                    $raw = $interDeets;
                    $result = $this->generateRoundTripRelations(
                        $principalType,
                        $keyName,
                        $raw,
                        $principalMult,
                        $principalProperty,
                        $dependentType,
                        $result
                    );
                }
            }
        }
        return $result;
    }

    /**
     * @param $principalType
     * @param $principalMult
     * @param $principalProperty
     * @param $dependentType
     * @param $dependentMult
     * @param $dependentProperty
     * @return array[]
     */
    private function calculateRoundTripRelationsGenForwardReverse(
        $principalType,
        $principalMult,
        $principalProperty,
        $dependentType,
        $dependentMult,
        $dependentProperty
    ) {
        assert(
            in_array($dependentMult, $this->multConstraints[$principalMult]),
            'Cannot pair multiplicities ' . $dependentMult . ' and ' . $principalMult
        );
        assert(
            in_array($principalMult, $this->multConstraints[$dependentMult]),
            'Cannot pair multiplicities ' . $principalMult . ' and ' . $dependentMult
        );
        $forward = [
            'principalType' => $principalType,
            'principalMult' => $dependentMult,
            'principalProp' => $principalProperty,
            'dependentType' => $dependentType,
            'dependentMult' => $principalMult,
            'dependentProp' => $dependentProperty
        ];
        $reverse = [
            'principalType' => $dependentType,
            'principalMult' => $principalMult,
            'principalProp' => $dependentProperty,
            'dependentType' => $principalType,
            'dependentMult' => $dependentMult,
            'dependentProp' => $principalProperty
        ];
        return [$forward, $reverse];
    }

    /**
     * @param $className
     */
    protected function checkClassExists($className)
    {
        if (!array_key_exists($className, $this->relations)) {
            $msg = $className . ' does not exist in holder';
            throw new \InvalidArgumentException($msg);
        }
    }

    /**
     * Reset stored relations
     */
    public function reset()
    {
        $this->relations = [];
    }

    /**
     * @param $principalType
     * @param $keyName
     * @param $raw
     * @param $principalMult
     * @param $principalProperty
     * @param $dependentType
     * @param $result
     * @return array
     */
    private function generateRoundTripRelations(
        $principalType,
        $keyName,
        $raw,
        $principalMult,
        $principalProperty,
        $dependentType,
        $result
    ) {
        foreach ($raw as $dependentProperty => $dependentPayload) {
            if ($keyName !== $dependentPayload['local']) {
                continue;
            }
            $dependentMult = $dependentPayload['multiplicity'];
            list($forward, $reverse) = $this->calculateRoundTripRelationsGenForwardReverse(
                $principalType,
                $principalMult,
                $principalProperty,
                $dependentType,
                $dependentMult,
                $dependentProperty
            );
            if (!in_array($forward, $result)) {
                // add forward relation
                $result[] = $forward;
            }
            if (!in_array($reverse, $result)) {
                // add reverse relation
                $result[] = $reverse;
            }
        }
        return $result;
    }
}


1			<?php
2
3			namespace AlgoWeb\PODataLaravel\Models;
4
5			use Illuminate\Database\Eloquent\Model;
6
7			class MetadataRelationHolder
8			{
9			protected $multConstraints = [ '0..1' => ['1'], '1' => ['0..1', ''], '' => ['1', '*']];
10			protected $relations = [];
11
12			public function __construct()
13			{
14			}
15
16			/**
17			* Add model's relationships to holder
18			*
19			* @param Model $model
20			*/
21			public function addModel(Model $model)
22			{
23			if (!in_array('AlgoWeb\\PODataLaravel\\Models\\MetadataTrait', class_uses($model))) {
24			$msg = 'Supplied model does not use MetadataTrait';
25			throw new \InvalidArgumentException($msg);
26			}
27			$className = get_class($model);
28			if (array_key_exists($className, $this->relations)) {
29			$msg = $className.' already added';
30			throw new \InvalidArgumentException($msg);
31			}
32			$this->relations[$className] = $model->getRelationships();
33			}
34
35			public function getRelationsByKey($className, $keyName)
36			{
37			$this->checkClassExists($className);
38
39			$rels = $this->relations[$className];
40			if (!array_key_exists($keyName, $rels)) {
41			$msg = 'Key ' . $keyName . ' not registered on ' . $className;
42			throw new \InvalidArgumentException($msg);
43			}
44
45			$result = [];
46			$payload = $rels[$keyName];
47			$principalType = $className;
48			foreach ($payload as $dependentType => $targDeets) {
49			if (!array_key_exists($dependentType, $this->relations)) {
50			continue;
51			}
52			// if principal and ostensible dependent type are equal, drop through to specific handler
53			// at moment, this is only for morphTo relations - morphedByMany doesn't cause this
54			if ($principalType === $dependentType) {
55			$morphToLines = $this->getMorphToRelations($principalType, $targDeets, $keyName);
56			foreach ($morphToLines as $morph) {
57			if (!in_array($morph, $result)) {
58			$result[] = $morph;
59			}
60			}
61			continue;
62			}
63
64			$foreign = $this->relations[$dependentType];
65
66			foreach ($targDeets as $principalProperty => $rawDeets) {
67			$targKey = $rawDeets['local'];
68			$principalMult = $rawDeets['multiplicity'];
69			$principalProperty = $rawDeets['property'];
70			if (!array_key_exists($targKey, $foreign)) {
71			continue;
72			}
73			$foreignDeets = $foreign[$targKey];
74			foreach ($foreignDeets as $foreignType => $raw) {
75			if (!array_key_exists($foreignType, $this->relations)) {
76			continue;
77			}
78			$result = $this->generateRoundTripRelations(
79			$principalType,
80			$keyName,
81			$raw,
82			$principalMult,
83			$principalProperty,
84			$dependentType,
85			$result
86			);
87			}
88			}
89			}
90			return $result;
91			}
92
93			public function getRelationsByClass($className)
94			{
95			$this->checkClassExists($className);
96
97			$rels = $this->relations[$className];
98			$keys = array_keys($rels);
99			$results = [];
100			foreach ($keys as $key) {
101			$lines = $this->getRelationsByKey($className, $key);
102			foreach ($lines as $line) {
103			if (!in_array($line, $results)) {
104			$results[] = $line;
105			}
106			}
107			}
108
109			return $results;
110			}
111
112			private function getMorphToRelations($principalType, $targDeets, $keyName)
113			{
114			$result = [];
115			$deetKeys = array_keys($targDeets);
116			$principalProperty = $deetKeys[0];
117			$principalDeets = $targDeets[$principalProperty];
118			$principalMult = $principalDeets['multiplicity'];
119
120			foreach ($this->relations as $dependentType => $dependentDeets) {
121			foreach ($dependentDeets as $targKey => $rawDeets) {
122			foreach ($rawDeets as $targType => $interDeets) {
123			if ($targType != $principalType) {
124			continue;
125			}
126			$raw = $interDeets;
127			$result = $this->generateRoundTripRelations(
128			$principalType,
129			$keyName,
130			$raw,
131			$principalMult,
132			$principalProperty,
133			$dependentType,
134			$result
135			);
136			}
137			}
138			}
139			return $result;
140			}
141
142			/**
143			* @param $principalType
144			* @param $principalMult
145			* @param $principalProperty
146			* @param $dependentType
147			* @param $dependentMult
148			* @param $dependentProperty
149			* @return array[]
150			*/
151			private function calculateRoundTripRelationsGenForwardReverse(
152			$principalType,
153			$principalMult,
154			$principalProperty,
155			$dependentType,
156			$dependentMult,
157			$dependentProperty
158			) {
159			assert(
160			in_array($dependentMult, $this->multConstraints[$principalMult]),
161			'Cannot pair multiplicities ' . $dependentMult . ' and ' . $principalMult
162			);
163			assert(
164			in_array($principalMult, $this->multConstraints[$dependentMult]),
165			'Cannot pair multiplicities ' . $principalMult . ' and ' . $dependentMult
166			);
167			$forward = [
168			'principalType' => $principalType,
169			'principalMult' => $dependentMult,
170			'principalProp' => $principalProperty,
171			'dependentType' => $dependentType,
172			'dependentMult' => $principalMult,
173			'dependentProp' => $dependentProperty
174			];
175			$reverse = [
176			'principalType' => $dependentType,
177			'principalMult' => $principalMult,
178			'principalProp' => $dependentProperty,
179			'dependentType' => $principalType,
180			'dependentMult' => $dependentMult,
181			'dependentProp' => $principalProperty
182			];
183			return [$forward, $reverse];
184			}
185
186			/**
187			* @param $className
188			*/
189			protected function checkClassExists($className)
190			{
191			if (!array_key_exists($className, $this->relations)) {
192			$msg = $className . ' does not exist in holder';
193			throw new \InvalidArgumentException($msg);
194			}
195			}
196
197			/**
198			* Reset stored relations
199			*/
200			public function reset()
201			{
202			$this->relations = [];
203			}
204
205			/**
206			* @param $principalType
207			* @param $keyName
208			* @param $raw
209			* @param $principalMult
210			* @param $principalProperty
211			* @param $dependentType
212			* @param $result
213			* @return array
214			*/
215			private function generateRoundTripRelations(
216			$principalType,
217			$keyName,
218			$raw,
219			$principalMult,
220			$principalProperty,
221			$dependentType,
222			$result
223			) {
224			foreach ($raw as $dependentProperty => $dependentPayload) {
225			if ($keyName !== $dependentPayload['local']) {
226			continue;
227			}
228			$dependentMult = $dependentPayload['multiplicity'];
229			list($forward, $reverse) = $this->calculateRoundTripRelationsGenForwardReverse(
230			$principalType,
231			$principalMult,
232			$principalProperty,
233			$dependentType,
234			$dependentMult,
235			$dependentProperty
236			);
237			if (!in_array($forward, $result)) {
238			// add forward relation
239			$result[] = $forward;
240			}
241			if (!in_array($reverse, $result)) {
242			// add reverse relation
243			$result[] = $reverse;
244			}
245			}
246			return $result;
247			}
248			}
249

Algo-Web / POData-Laravel

Pull Request — master (#106)

calculateRoundTripRelationsGenForwardReverse() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like