Formatter::hasOperators() - Code Metrics - Inspection of "Support for Embed models" - as3io/modlr-persister-mongodb - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#8)

by Jacob

created 2016-04-19 14:25 UTC

Formatter::hasOperators() B

↳ Parent: Formatter

Complexity

Conditions	6
Paths	7

Size

Total Lines	18
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	1	Features	1

Metric	Value
c	2
b	1
f	1
dl	0
loc	18
rs	8.8571
cc	6
eloc	9
nc	7
nop	1

<?php

namespace As3\Modlr\Persister\MongoDb;

use \Closure;
use \MongoId;
use As3\Modlr\Metadata\AttributeMetadata;
use As3\Modlr\Metadata\EmbeddedPropMetadata;
use As3\Modlr\Metadata\EntityMetadata;
use As3\Modlr\Metadata\RelationshipMetadata;
use As3\Modlr\Models\Embed;
use As3\Modlr\Models\Model;
use As3\Modlr\Persister\PersisterException;
use As3\Modlr\Store\Store;

/**
 * Handles persistence formatting operations for MongoDB.
 * - Formats query criteria to proper keys and values.
 * - Formats attribute, relationship, and embed values for insertion to the db.
 * - Formats identifier values for insertion to the db.
 *
 * @author Jacob Bare <[email protected]>
 */
final class Formatter
{
    /**
     * Query operators.
     * Organized into handling groups.
     *
     * @var array
     */
    private $ops = [
        'root'      => ['$and', '$or', '$nor'],
        'single'    => ['$eq', '$gt', '$gte', '$lt', '$lte', '$ne'],
        'multiple'  => ['$in', '$nin', '$all'],
        'recursive' => ['$not', '$elemMatch'],
        'ignore'    => ['$exists', '$type', '$mod', '$size', '$regex', '$text', '$where'],
    ];

    /**
     * Formats a set of query criteria for a Model.
     * Ensures the id and type fields are properly applied.
     * Ensures that values are properly converted to their database equivalents: e.g dates, mongo ids, etc.
     *
     * @param   EntityMetadata  $metadata
     * @param   Store           $store
     * @param   array           $criteria
     * @return  array
     */
    public function formatQuery(EntityMetadata $metadata, Store $store, array $criteria)
    {
        $formatted = [];
        foreach ($criteria as $key => $value) {

            if ($this->isOpType('root', $key) && is_array($value)) {
                foreach ($value as $subKey => $subValue) {
                    $formatted[$key][$subKey] = $this->formatQuery($metadata, $store, $subValue);
                }
                continue;
            }

            if ($this->isOperator($key) && is_array($value)) {
                $formatted[$key] = $this->formatQuery($metadata, $store, $value);
                continue;
            }

            list($key, $value) = $this->formatQueryElement($key, $value, $metadata, $store);
            $formatted[$key] = $value;
        }
        return $formatted;
    }

    /**
     * Prepares and formats an attribute value for proper insertion into the database.
     *
     * @param   AttributeMetadata   $attrMeta
     * @param   mixed               $value
     * @return  mixed
     */
    public function getAttributeDbValue(AttributeMetadata $attrMeta, $value)
    {
        // Handle data type conversion, if needed.
        if ('date' === $attrMeta->dataType && $value instanceof \DateTime) {
            return new \MongoDate($value->getTimestamp(), $value->format('u'));
        }
        if ('array' === $attrMeta->dataType && empty($value)) {
            return;
        }
        if ('object' === $attrMeta->dataType) {
            $array = (array) $value;
            return empty($array) ? null : $value;
        }
        return $value;
    }

    /**
     * Prepares and formats a has-many embed for proper insertion into the database.
     *
     * @param   EmbeddedPropMetadata    $embeddedPropMeta
     * @param   array                   $embed
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return  mixed
     */
    public function getEmbedManyDbValue(EmbeddedPropMetadata $embeddedPropMeta, array $embeds = null)
    {
        if (null === $embeds) {
            return;
        }
        $created = [];
        foreach ($embeds as $embed) {
            $created[] = $this->createEmbed($embeddedPropMeta, $embed);
        }
        return empty($created) ? null : $created;
    }

    /**
     * Prepares and formats a has-one embed for proper insertion into the database.
     *
     * @param   EmbeddedPropMetadata    $embeddedPropMeta
     * @param   Embed|null              $embed
     * @return  mixed
     */
    public function getEmbedOneDbValue(EmbeddedPropMetadata $embeddedPropMeta, Embed $embed = null)
    {
        if (null === $embed) {
            return;
        }
        return $this->createEmbed($embeddedPropMeta, $embed);
    }

    /**
     * Prepares and formats a has-one relationship model for proper insertion into the database.
     *
     * @param   RelationshipMetadata    $relMeta
     * @param   Model|null              $model
     * @return  mixed
     */
    public function getHasOneDbValue(RelationshipMetadata $relMeta, Model $model = null)
    {
        if (null === $model || true === $relMeta->isInverse) {
            return;
        }
        return $this->createReference($relMeta, $model);
    }

    /**
     * Prepares and formats a has-many relationship model set for proper insertion into the database.
     *
     * @param   RelationshipMetadata    $relMeta
     * @param   Model[]|null            $models
     * @return  mixed
     */
    public function getHasManyDbValue(RelationshipMetadata $relMeta, array $models = null)
    {
        if (null === $models || true === $relMeta->isInverse) {
            return null;
        }
        $references = [];
        foreach ($models as $model) {
            $references[] = $this->createReference($relMeta, $model);
        }
        return empty($references) ? null : $references;
    }

    /**
     * {@inheritDoc}
     */
    public function getIdentifierDbValue($identifier, $strategy = null)
    {
        if (false === $this->isIdStrategySupported($strategy)) {
            throw PersisterException::nyi('ID conversion currently only supports an object strategy, or none at all.');
        }
        if ($identifier instanceof MongoId) {
            return $identifier;
        }
        return new MongoId($identifier);
    }

    /**
     * Gets all possible identifier field keys (internal and persistence layer).
     *
     * @return  array
     */
    public function getIdentifierFields()
    {
        return [Persister::IDENTIFIER_KEY, EntityMetadata::ID_KEY];
    }

    /**
     * Gets all possible model type keys (internal and persistence layer).
     *
     * @return  array
     */
    public function getTypeFields()
    {
        return [Persister::POLYMORPHIC_KEY, EntityMetadata::TYPE_KEY];
    }

    /**
     * Determines if a field key is an identifier.
     * Uses both the internal and persistence identifier keys.
     *
     * @param   string  $key
     * @return  bool
     */
    public function isIdentifierField($key)
    {
        return in_array($key, $this->getIdentifierFields());
    }

    /**
     * Determines if the provided id strategy is supported.
     *
     * @param   string|null     $strategy
     * @return  bool
     */
    public function isIdStrategySupported($strategy)
    {
        return (null === $strategy || 'object' === $strategy);
    }

    /**
     * Determines if a field key is a model type field.
     * Uses both the internal and persistence model type keys.
     *
     * @param   string  $key
     * @return  bool
     */
    public function isTypeField($key)
    {
        return in_array($key, $this->getTypeFields());
    }

    /**
     * Creates an embed for storage of an embed model in the database
     *
     * @param   EmbeddedPropMetadata    $embeddedPropMeta
     * @param   Embed                   $embed
     * @return  array|null
     */
    private function createEmbed(EmbeddedPropMetadata $embeddedPropMeta, Embed $embed)
    {
        $embedMeta = $embeddedPropMeta->embedMeta;

        $obj = [];
        foreach ($embedMeta->getAttributes() as $key => $attrMeta) {
            $value = $this->getAttributeDbValue($attrMeta, $embed->get($key));
            if (null === $value) {
                continue;
            }
            $obj[$key] = $value;
        }
        foreach ($embedMeta->getEmbeds() as $key => $propMeta) {
            $value = (true === $propMeta->isOne()) ? $this->getEmbedOneDbValue($propMeta, $embed->get($key)) : $this->getEmbedManyDbValue($propMeta, $embed->get($key));
            if (null === $value) {
                continue;
            }
            $obj[$key] = $value;
        }
        return $obj;
    }

    /**
     * Creates a reference for storage of a related model in the database
     *
     * @param   RelationshipMetadata    $relMeta
     * @param   Model                   $model
     * @return  mixed
     */
    private function createReference(RelationshipMetadata $relMeta, Model $model)
    {
        $reference = [];
        $identifier = $this->getIdentifierDbValue($model->getId());
        if (true === $relMeta->isPolymorphic()) {
            $reference[Persister::IDENTIFIER_KEY] = $identifier;
            $reference[Persister::TYPE_KEY] = $model->getType();
            return $reference;
        }
        return $identifier;
    }

    /**
     * Formats a query element and ensures the correct key and value are set.
     * Returns a tuple of the formatted key and value.
     *
     * @param   string          $key
     * @param   mixed           $value
     * @param   EntityMetadata  $metadata
     * @param   Store           $store
     * @return  array
     */
    private function formatQueryElement($key, $value, EntityMetadata $metadata, Store $store)
    {
        // Handle root fields: id or model type.
        if (null !== $result = $this->formatQueryElementRoot($key, $value, $metadata)) {
            return $result;
        }

        // Handle attributes.
        if (null !== $result = $this->formatQueryElementAttr($key, $value, $metadata, $store)) {
            return $result;
        }

        // Handle relationships.
        if (null !== $result = $this->formatQueryElementRel($key, $value, $metadata, $store)) {
            return $result;
        }

        // Handle dot notated fields.
        if (null !== $result = $this->formatQueryElementDotted($key, $value, $metadata, $store)) {
            return $result;
        }

        // Pass remaining elements unconverted.
        return [$key, $value];
    }

    /**
     * Formats an attribute query element.
     * Returns a tuple of the formatted key and value, or null if the key is not an attribute field.
     *
     * @param   string          $key
     * @param   mixed           $value
     * @param   EntityMetadata  $metadata
     * @param   Store           $store
     * @return  array|null
     */
    private function formatQueryElementAttr($key, $value, EntityMetadata $metadata, Store $store)
    {
        if (null === $attrMeta = $metadata->getAttribute($key)) {
            return;
        }

        $converter = $this->getQueryAttrConverter($store, $attrMeta);

        if (is_array($value)) {

            if (true === $this->hasOperators($value)) {
                return [$key, $this->formatQueryExpression($value, $converter)];
            }

            if (in_array($attrMeta->dataType, ['array', 'object'])) {
                return [$key, $value];
            }
            return [$key, $this->formatQueryExpression(['$in' => $value], $converter)];
        }
        return [$key, $converter($value)];
    }

    /**
     * Formats a dot-notated field.
     * Returns a tuple of the formatted key and value, or null if the key is not a dot-notated field, or cannot be handled.
     *
     * @param   string          $key
     * @param   mixed           $value
     * @param   EntityMetadata  $metadata
     * @param   Store           $store
     * @return  array|null
     */
    private function formatQueryElementDotted($key, $value, EntityMetadata $metadata, Store $store)
    {
        if (false === stripos($key, '.')) {
            return;
        }

        $parts = explode('.', $key);
        $root = array_shift($parts);
        if (false === $metadata->hasRelationship($root)) {
            // Nothing to format. Allow the dotted field to pass normally.
            return [$key, $value];
        }
        $hasIndex = is_numeric($parts[0]);

        if (true === $hasIndex) {
            $subKey = isset($parts[1]) ? $parts[1] : 'id';
        } else {
            $subKey = $parts[0];
        }

        if ($this->isIdentifierField($subKey)) {

            // Handle like a regular relationship
            list($key, $value) = $this->formatQueryElementRel($root, $value, $metadata, $store);
            $key = (true === $hasIndex) ? sprintf('%s.%s', $key, $parts[0]) : $key;
            return [$key, $value];
        }

        if ($this->isTypeField($subKey)) {

            // Handle as a model type field.
            list($key, $value) = $this->formatQueryElementRoot($subKey, $value, $metadata);
            $key = (true === $hasIndex) ? sprintf('%s.%s.%s', $root, $parts[0], $key) : sprintf('%s.%s', $root, $key);
            return [$key, $value];
        }
        return [$key, $value];
    }

    /**
     * Formats a relationship query element.
     * Returns a tuple of the formatted key and value, or null if the key is not a relationship field.
     *
     * @param   string          $key
     * @param   mixed           $value
     * @param   EntityMetadata  $metadata
     * @param   Store           $store
     * @return  array|null
     */
    private function formatQueryElementRel($key, $value, EntityMetadata $metadata, Store $store)
    {
        if (null === $relMeta = $metadata->getRelationship($key)) {
            return;
        }

        $converter = $this->getQueryRelConverter($store, $relMeta);

        if (true === $relMeta->isPolymorphic()) {
            $key = sprintf('%s.%s', $key, Persister::IDENTIFIER_KEY);
        }

        if (is_array($value)) {

            $value = (true === $this->hasOperators($value)) ? $value : ['$in' => $value];
            return [$key, $this->formatQueryExpression($value, $converter)];
        }
        return [$key, $converter($value)];
    }


    /**
     * Formats a root query element: either id or model type.
     * Returns a tuple of the formatted key and value, or null if the key is not a root field.
     *
     * @param   string          $key
     * @param   mixed           $value
     * @param   EntityMetadata  $metadata
     * @return  array|null
     */
    private function formatQueryElementRoot($key, $value, EntityMetadata $metadata)
    {
        if (true === $this->isIdentifierField($key)) {
            $dbKey = Persister::IDENTIFIER_KEY;
        } elseif (true === $this->isTypeField($key)) {
            $dbKey = Persister::POLYMORPHIC_KEY;
        } else {
            return;
        }

        $converter = $this->getQueryRootConverter($metadata, $dbKey);
        if (is_array($value)) {

            $value = (true === $this->hasOperators($value)) ? $value : ['$in' => $value];
            return [$dbKey, $this->formatQueryExpression($value, $converter)];
        }
        return [$dbKey, $converter($value)];
    }

    /**
     * Formats a query expression.
     *
     * @param   array   $expression
     * @param   Closure $converter
     * @return  array
     */
    private function formatQueryExpression(array $expression, Closure $converter)
    {
        foreach ($expression as $key => $value) {

            if (true === $this->isOpType('ignore', $key)) {
                continue;
            }

            if (true === $this->isOpType('single', $key)) {
                $expression[$key] = $converter($value);
                continue;
            }

            if (true === $this->isOpType('multiple', $key)) {
                $value = (array) $value;
                foreach ($value as $subKey => $subValue) {
                    $expression[$key][$subKey] = $converter($subValue);
                }
                continue;
            }

            if (true === $this->isOpType('recursive', $key)) {
                $value = (array) $value;
                $expression[$key] = $this->formatQueryExpression($value, $converter);
                continue;
            }

            $expression[$key] = $converter($value);
        }
        return $expression;
    }

    /**
     * Gets the converter for handling attribute values in queries.
     *
     * @param   Store               $store
     * @param   AttributeMetadata   $attrMeta
     * @return  Closure
     */
    private function getQueryAttrConverter(Store $store, AttributeMetadata $attrMeta)
    {
        return function ($value) use ($store, $attrMeta) {
            if (in_array($attrMeta->dataType, ['object', 'array'])) {
                // Leave the value as is.
                return $value;
            }
            $value = $store->convertAttributeValue($attrMeta->dataType, $value);
            return $this->getAttributeDbValue($attrMeta, $value);
        };

    }

    /**
     * Gets the converter for handling relationship values in queries.
     *
     * @param   Store                   $store
     * @param   RelationshipMetadata    $relMeta
     * @return  Closure
     */
    private function getQueryRelConverter(Store $store, RelationshipMetadata $relMeta)
    {
        $related = $store->getMetadataForType($relMeta->getEntityType());
        return $this->getQueryRootConverter($related, Persister::IDENTIFIER_KEY);
    }

    /**
     * Gets the converter for handling root field values in queries (id or model type).
     *
     * @param   EntityMetadata  $metadata
     * @param   string          $key
     * @return  Closure
     */
    private function getQueryRootConverter(EntityMetadata $metadata, $key)
    {
        return function($value) use ($metadata, $key) {
            if ($key === Persister::POLYMORPHIC_KEY) {
                return $value;
            }
            $strategy = ($metadata->persistence instanceof StorageMetadata) ? $metadata->persistence->idStrategy : null;
            return $this->getIdentifierDbValue($value, $strategy);
        };
    }

    /**
     * Determines whether a query value has additional query operators.
     *
     * @param   mixed   $value
     * @return  bool
     */
    private function hasOperators($value)
    {

        if (!is_array($value) && !is_object($value)) {
            return false;
        }

        if (is_object($value)) {
            $value = get_object_vars($value);
        }

        foreach ($value as $key => $subValue) {
            if (true === $this->isOperator($key)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Determines if a key is a query operator.
     *
     * @param   string  $key
     * @return  bool
     */
    private function isOperator($key)
    {
        return isset($key[0]) && '$' === $key[0];
    }

    /**
     * Determines if a key is of a certain operator handling type.
     *
     * @param   string  $type
     * @param   string  $key
     * @return  bool
     */
    private function isOpType($type, $key)
    {
        if (!isset($this->ops[$type])) {
            return false;
        }
        return in_array($key, $this->ops[$type]);
    }
}


1		<?php
2
3		namespace As3\Modlr\Persister\MongoDb;
4
5		use \Closure;
6		use \MongoId;
7		use As3\Modlr\Metadata\AttributeMetadata;
8		use As3\Modlr\Metadata\EmbeddedPropMetadata;
9		use As3\Modlr\Metadata\EntityMetadata;
10		use As3\Modlr\Metadata\RelationshipMetadata;
11		use As3\Modlr\Models\Embed;
12		use As3\Modlr\Models\Model;
13		use As3\Modlr\Persister\PersisterException;
14		use As3\Modlr\Store\Store;
15
16		/**
17		* Handles persistence formatting operations for MongoDB.
18		* - Formats query criteria to proper keys and values.
19		* - Formats attribute, relationship, and embed values for insertion to the db.
20		* - Formats identifier values for insertion to the db.
21		*
22		* @author Jacob Bare <[email protected]>
23		*/
24		final class Formatter
25		{
26		/**
27		* Query operators.
28		* Organized into handling groups.
29		*
30		* @var array
31		*/
32		private $ops = [
33		'root' => ['$and', '$or', '$nor'],
34		'single' => ['$eq', '$gt', '$gte', '$lt', '$lte', '$ne'],
35		'multiple' => ['$in', '$nin', '$all'],
36		'recursive' => ['$not', '$elemMatch'],
37		'ignore' => ['$exists', '$type', '$mod', '$size', '$regex', '$text', '$where'],
38		];
39
40		/**
41		* Formats a set of query criteria for a Model.
42		* Ensures the id and type fields are properly applied.
43		* Ensures that values are properly converted to their database equivalents: e.g dates, mongo ids, etc.
44		*
45		* @param EntityMetadata $metadata
46		* @param Store $store
47		* @param array $criteria
48		* @return array
49		*/
50		public function formatQuery(EntityMetadata $metadata, Store $store, array $criteria)
51		{
52		$formatted = [];
53		foreach ($criteria as $key => $value) {
54
55		if ($this->isOpType('root', $key) && is_array($value)) {
56		foreach ($value as $subKey => $subValue) {
57		$formatted[$key][$subKey] = $this->formatQuery($metadata, $store, $subValue);
58		}
59		continue;
60		}
61
62		if ($this->isOperator($key) && is_array($value)) {
63		$formatted[$key] = $this->formatQuery($metadata, $store, $value);
64		continue;
65		}
66
67		list($key, $value) = $this->formatQueryElement($key, $value, $metadata, $store);
68		$formatted[$key] = $value;
69		}
70		return $formatted;
71		}
72
73		/**
74		* Prepares and formats an attribute value for proper insertion into the database.
75		*
76		* @param AttributeMetadata $attrMeta
77		* @param mixed $value
78		* @return mixed
79		*/
80		public function getAttributeDbValue(AttributeMetadata $attrMeta, $value)
81		{
82		// Handle data type conversion, if needed.
83		if ('date' === $attrMeta->dataType && $value instanceof \DateTime) {
84		return new \MongoDate($value->getTimestamp(), $value->format('u'));
85		}
86		if ('array' === $attrMeta->dataType && empty($value)) {
87		return;
88		}
89		if ('object' === $attrMeta->dataType) {
90		$array = (array) $value;
91		return empty($array) ? null : $value;
92		}
93		return $value;
94		}
95
96		/**
97		* Prepares and formats a has-many embed for proper insertion into the database.
98		*
99		* @param EmbeddedPropMetadata $embeddedPropMeta
100		* @param array $embed
		0 ignored issues – show Documentation introduced 2016-04-19 14:29 UTC by Report Bug Copy Issue Report There is no parameter named `$embed`. Did you maybe mean `$embeds`? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. It has, however, found a similar but not annotated parameter which might be a good fit. Consider the following example. The parameter `$ireland` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $ireland */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was changed, but the annotation was not. Loading history...
101		* @return mixed
102		*/
103		public function getEmbedManyDbValue(EmbeddedPropMetadata $embeddedPropMeta, array $embeds = null)
104		{
105		if (null === $embeds) {
106		return;
107		}
108		$created = [];
109		foreach ($embeds as $embed) {
110		$created[] = $this->createEmbed($embeddedPropMeta, $embed);
111		}
112		return empty($created) ? null : $created;
113		}
114
115		/**
116		* Prepares and formats a has-one embed for proper insertion into the database.
117		*
118		* @param EmbeddedPropMetadata $embeddedPropMeta
119		* @param Embed\|null $embed
120		* @return mixed
121		*/
122		public function getEmbedOneDbValue(EmbeddedPropMetadata $embeddedPropMeta, Embed $embed = null)
123		{
124		if (null === $embed) {
125		return;
126		}
127		return $this->createEmbed($embeddedPropMeta, $embed);
128		}
129
130		/**
131		* Prepares and formats a has-one relationship model for proper insertion into the database.
132		*
133		* @param RelationshipMetadata $relMeta
134		* @param Model\|null $model
135		* @return mixed
136		*/
137		public function getHasOneDbValue(RelationshipMetadata $relMeta, Model $model = null)
138		{
139		if (null === $model \|\| true === $relMeta->isInverse) {
140		return;
141		}
142		return $this->createReference($relMeta, $model);
143		}
144
145		/**
146		* Prepares and formats a has-many relationship model set for proper insertion into the database.
147		*
148		* @param RelationshipMetadata $relMeta
149		* @param Model[]\|null $models
150		* @return mixed
151		*/
152		public function getHasManyDbValue(RelationshipMetadata $relMeta, array $models = null)
153		{
154		if (null === $models \|\| true === $relMeta->isInverse) {
155		return null;
156		}
157		$references = [];
158		foreach ($models as $model) {
159		$references[] = $this->createReference($relMeta, $model);
160		}
161		return empty($references) ? null : $references;
162		}
163
164		/**
165		* {@inheritDoc}
166		*/
167		public function getIdentifierDbValue($identifier, $strategy = null)
168		{
169		if (false === $this->isIdStrategySupported($strategy)) {
170		throw PersisterException::nyi('ID conversion currently only supports an object strategy, or none at all.');
171		}
172		if ($identifier instanceof MongoId) {
173		return $identifier;
174		}
175		return new MongoId($identifier);
176		}
177
178		/**
179		* Gets all possible identifier field keys (internal and persistence layer).
180		*
181		* @return array
182		*/
183		public function getIdentifierFields()
184		{
185		return [Persister::IDENTIFIER_KEY, EntityMetadata::ID_KEY];
186		}
187
188		/**
189		* Gets all possible model type keys (internal and persistence layer).
190		*
191		* @return array
192		*/
193		public function getTypeFields()
194		{
195		return [Persister::POLYMORPHIC_KEY, EntityMetadata::TYPE_KEY];
196		}
197
198		/**
199		* Determines if a field key is an identifier.
200		* Uses both the internal and persistence identifier keys.
201		*
202		* @param string $key
203		* @return bool
204		*/
205		public function isIdentifierField($key)
206		{
207		return in_array($key, $this->getIdentifierFields());
208		}
209
210		/**
211		* Determines if the provided id strategy is supported.
212		*
213		* @param string\|null $strategy
214		* @return bool
215		*/
216		public function isIdStrategySupported($strategy)
217		{
218		return (null === $strategy \|\| 'object' === $strategy);
219		}
220
221		/**
222		* Determines if a field key is a model type field.
223		* Uses both the internal and persistence model type keys.
224		*
225		* @param string $key
226		* @return bool
227		*/
228		public function isTypeField($key)
229		{
230		return in_array($key, $this->getTypeFields());
231		}
232
233		/**
234		* Creates an embed for storage of an embed model in the database
235		*
236		* @param EmbeddedPropMetadata $embeddedPropMeta
237		* @param Embed $embed
238		* @return array\|null
239		*/
240		private function createEmbed(EmbeddedPropMetadata $embeddedPropMeta, Embed $embed)
241		{
242		$embedMeta = $embeddedPropMeta->embedMeta;
243
244		$obj = [];
245		foreach ($embedMeta->getAttributes() as $key => $attrMeta) {
246		$value = $this->getAttributeDbValue($attrMeta, $embed->get($key));
247		if (null === $value) {
248		continue;
249		}
250		$obj[$key] = $value;
251		}
252		foreach ($embedMeta->getEmbeds() as $key => $propMeta) {
253		$value = (true === $propMeta->isOne()) ? $this->getEmbedOneDbValue($propMeta, $embed->get($key)) : $this->getEmbedManyDbValue($propMeta, $embed->get($key));
254		if (null === $value) {
255		continue;
256		}
257		$obj[$key] = $value;
258		}
259		return $obj;
260		}
261
262		/**
263		* Creates a reference for storage of a related model in the database
264		*
265		* @param RelationshipMetadata $relMeta
266		* @param Model $model
267		* @return mixed
268		*/
269		private function createReference(RelationshipMetadata $relMeta, Model $model)
270		{
271		$reference = [];
272		$identifier = $this->getIdentifierDbValue($model->getId());
273		if (true === $relMeta->isPolymorphic()) {
274		$reference[Persister::IDENTIFIER_KEY] = $identifier;
275		$reference[Persister::TYPE_KEY] = $model->getType();
276		return $reference;
277		}
278		return $identifier;
279		}
280
281		/**
282		* Formats a query element and ensures the correct key and value are set.
283		* Returns a tuple of the formatted key and value.
284		*
285		* @param string $key
286		* @param mixed $value
287		* @param EntityMetadata $metadata
288		* @param Store $store
289		* @return array
290		*/
291		private function formatQueryElement($key, $value, EntityMetadata $metadata, Store $store)
292		{
293		// Handle root fields: id or model type.
294		if (null !== $result = $this->formatQueryElementRoot($key, $value, $metadata)) {
295		return $result;
296		}
297
298		// Handle attributes.
299		if (null !== $result = $this->formatQueryElementAttr($key, $value, $metadata, $store)) {
300		return $result;
301		}
302
303		// Handle relationships.
304		if (null !== $result = $this->formatQueryElementRel($key, $value, $metadata, $store)) {
305		return $result;
306		}
307
308		// Handle dot notated fields.
309		if (null !== $result = $this->formatQueryElementDotted($key, $value, $metadata, $store)) {
310		return $result;
311		}
312
313		// Pass remaining elements unconverted.
314		return [$key, $value];
315		}
316
317		/**
318		* Formats an attribute query element.
319		* Returns a tuple of the formatted key and value, or null if the key is not an attribute field.
320		*
321		* @param string $key
322		* @param mixed $value
323		* @param EntityMetadata $metadata
324		* @param Store $store
325		* @return array\|null
326		*/
327		private function formatQueryElementAttr($key, $value, EntityMetadata $metadata, Store $store)
328		{
329		if (null === $attrMeta = $metadata->getAttribute($key)) {
330		return;
331		}
332
333		$converter = $this->getQueryAttrConverter($store, $attrMeta);
334
335		if (is_array($value)) {
336
337		if (true === $this->hasOperators($value)) {
338		return [$key, $this->formatQueryExpression($value, $converter)];
339		}
340
341		if (in_array($attrMeta->dataType, ['array', 'object'])) {
342		return [$key, $value];
343		}
344		return [$key, $this->formatQueryExpression(['$in' => $value], $converter)];
345		}
346		return [$key, $converter($value)];
347		}
348
349		/**
350		* Formats a dot-notated field.
351		* Returns a tuple of the formatted key and value, or null if the key is not a dot-notated field, or cannot be handled.
352		*
353		* @param string $key
354		* @param mixed $value
355		* @param EntityMetadata $metadata
356		* @param Store $store
357		* @return array\|null
358		*/
359		private function formatQueryElementDotted($key, $value, EntityMetadata $metadata, Store $store)
360		{
361		if (false === stripos($key, '.')) {
362		return;
363		}
364
365		$parts = explode('.', $key);
366		$root = array_shift($parts);
367		if (false === $metadata->hasRelationship($root)) {
368		// Nothing to format. Allow the dotted field to pass normally.
369		return [$key, $value];
370		}
371		$hasIndex = is_numeric($parts[0]);
372
373		if (true === $hasIndex) {
374		$subKey = isset($parts[1]) ? $parts[1] : 'id';
375		} else {
376		$subKey = $parts[0];
377		}
378
379	View Code Duplication	if ($this->isIdentifierField($subKey)) {
		0 ignored issues – show Duplication introduced 2016-03-18 21:59 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
380		// Handle like a regular relationship
381		list($key, $value) = $this->formatQueryElementRel($root, $value, $metadata, $store);
382		$key = (true === $hasIndex) ? sprintf('%s.%s', $key, $parts[0]) : $key;
383		return [$key, $value];
384		}
385
386	View Code Duplication	if ($this->isTypeField($subKey)) {
		0 ignored issues – show Duplication introduced 2016-03-18 21:59 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
387		// Handle as a model type field.
388		list($key, $value) = $this->formatQueryElementRoot($subKey, $value, $metadata);
389		$key = (true === $hasIndex) ? sprintf('%s.%s.%s', $root, $parts[0], $key) : sprintf('%s.%s', $root, $key);
390		return [$key, $value];
391		}
392		return [$key, $value];
393		}
394
395		/**
396		* Formats a relationship query element.
397		* Returns a tuple of the formatted key and value, or null if the key is not a relationship field.
398		*
399		* @param string $key
400		* @param mixed $value
401		* @param EntityMetadata $metadata
402		* @param Store $store
403		* @return array\|null
404		*/
405		private function formatQueryElementRel($key, $value, EntityMetadata $metadata, Store $store)
406		{
407		if (null === $relMeta = $metadata->getRelationship($key)) {
408		return;
409		}
410
411		$converter = $this->getQueryRelConverter($store, $relMeta);
412
413		if (true === $relMeta->isPolymorphic()) {
414		$key = sprintf('%s.%s', $key, Persister::IDENTIFIER_KEY);
415		}
416
417	View Code Duplication	if (is_array($value)) {
		0 ignored issues – show Duplication introduced 2016-04-19 14:29 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
418		$value = (true === $this->hasOperators($value)) ? $value : ['$in' => $value];
419		return [$key, $this->formatQueryExpression($value, $converter)];
420		}
421		return [$key, $converter($value)];
422		}
423
424
425		/**
426		* Formats a root query element: either id or model type.
427		* Returns a tuple of the formatted key and value, or null if the key is not a root field.
428		*
429		* @param string $key
430		* @param mixed $value
431		* @param EntityMetadata $metadata
432		* @return array\|null
433		*/
434		private function formatQueryElementRoot($key, $value, EntityMetadata $metadata)
435		{
436		if (true === $this->isIdentifierField($key)) {
437		$dbKey = Persister::IDENTIFIER_KEY;
438		} elseif (true === $this->isTypeField($key)) {
439		$dbKey = Persister::POLYMORPHIC_KEY;
440		} else {
441		return;
442		}
443
444		$converter = $this->getQueryRootConverter($metadata, $dbKey);
445	View Code Duplication	if (is_array($value)) {
		0 ignored issues – show Duplication introduced 2016-04-19 14:29 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
446		$value = (true === $this->hasOperators($value)) ? $value : ['$in' => $value];
447		return [$dbKey, $this->formatQueryExpression($value, $converter)];
448		}
449		return [$dbKey, $converter($value)];
450		}
451
452		/**
453		* Formats a query expression.
454		*
455		* @param array $expression
456		* @param Closure $converter
457		* @return array
458		*/
459		private function formatQueryExpression(array $expression, Closure $converter)
460		{
461		foreach ($expression as $key => $value) {
462
463		if (true === $this->isOpType('ignore', $key)) {
464		continue;
465		}
466
467		if (true === $this->isOpType('single', $key)) {
468		$expression[$key] = $converter($value);
469		continue;
470		}
471
472		if (true === $this->isOpType('multiple', $key)) {
473		$value = (array) $value;
474		foreach ($value as $subKey => $subValue) {
475		$expression[$key][$subKey] = $converter($subValue);
476		}
477		continue;
478		}
479
480		if (true === $this->isOpType('recursive', $key)) {
481		$value = (array) $value;
482		$expression[$key] = $this->formatQueryExpression($value, $converter);
483		continue;
484		}
485
486		$expression[$key] = $converter($value);
487		}
488		return $expression;
489		}
490
491		/**
492		* Gets the converter for handling attribute values in queries.
493		*
494		* @param Store $store
495		* @param AttributeMetadata $attrMeta
496		* @return Closure
497		*/
498		private function getQueryAttrConverter(Store $store, AttributeMetadata $attrMeta)
499		{
500		return function ($value) use ($store, $attrMeta) {
501		if (in_array($attrMeta->dataType, ['object', 'array'])) {
502		// Leave the value as is.
503		return $value;
504		}
505		$value = $store->convertAttributeValue($attrMeta->dataType, $value);
506		return $this->getAttributeDbValue($attrMeta, $value);
507		};
508
509		}
510
511		/**
512		* Gets the converter for handling relationship values in queries.
513		*
514		* @param Store $store
515		* @param RelationshipMetadata $relMeta
516		* @return Closure
517		*/
518		private function getQueryRelConverter(Store $store, RelationshipMetadata $relMeta)
519		{
520		$related = $store->getMetadataForType($relMeta->getEntityType());
521		return $this->getQueryRootConverter($related, Persister::IDENTIFIER_KEY);
522		}
523
524		/**
525		* Gets the converter for handling root field values in queries (id or model type).
526		*
527		* @param EntityMetadata $metadata
528		* @param string $key
529		* @return Closure
530		*/
531		private function getQueryRootConverter(EntityMetadata $metadata, $key)
532		{
533		return function($value) use ($metadata, $key) {
534		if ($key === Persister::POLYMORPHIC_KEY) {
535		return $value;
536		}
537		$strategy = ($metadata->persistence instanceof StorageMetadata) ? $metadata->persistence->idStrategy : null;
538		return $this->getIdentifierDbValue($value, $strategy);
539		};
540		}
541
542		/**
543		* Determines whether a query value has additional query operators.
544		*
545		* @param mixed $value
546		* @return bool
547		*/
548		private function hasOperators($value)
549		{
550
551		if (!is_array($value) && !is_object($value)) {
552		return false;
553		}
554
555		if (is_object($value)) {
556		$value = get_object_vars($value);
557		}
558
559		foreach ($value as $key => $subValue) {
560		if (true === $this->isOperator($key)) {
561		return true;
562		}
563		}
564		return false;
565		}
566
567		/**
568		* Determines if a key is a query operator.
569		*
570		* @param string $key
571		* @return bool
572		*/
573		private function isOperator($key)
574		{
575		return isset($key[0]) && '$' === $key[0];
576		}
577
578		/**
579		* Determines if a key is of a certain operator handling type.
580		*
581		* @param string $type
582		* @param string $key
583		* @return bool
584		*/
585		private function isOpType($type, $key)
586		{
587		if (!isset($this->ops[$type])) {
588		return false;
589		}
590		return in_array($key, $this->ops[$type]);
591		}
592		}
593

as3io / modlr-persister-mongodb

Pull Request — master (#8)

Formatter::hasOperators() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like