KeyDescriptor::tryParseKeysFromRawKeyPredicate() - Code Metrics - Inspection of "WIP: UriProcessor folder cleanup" - Algo-Web/POData - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#265)

by Alex

created 2020-05-12 07:09 UTC

KeyDescriptor::tryParseKeysFromRawKeyPredicate() C

↳ Parent: KeyDescriptor

Complexity

Conditions	17
Paths	15

Size

Total Lines	96
Code Lines	51

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	17
eloc	51
c	2
b	0
f	0
nc	15
nop	4
dl	0
loc	96
rs	5.2166

How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace POData\UriProcessor\ResourcePathProcessor\SegmentParser;

use InvalidArgumentException;
use POData\Common\InvalidOperationException;
use POData\Common\Messages;
use POData\Common\ODataException;
use POData\ObjectModel\ODataProperty;
use POData\Providers\Metadata\ResourceSet;
use POData\Providers\Metadata\ResourceType;
use POData\Providers\Metadata\Type\Boolean;
use POData\Providers\Metadata\Type\DateTime;
use POData\Providers\Metadata\Type\Decimal;
use POData\Providers\Metadata\Type\Double;
use POData\Providers\Metadata\Type\Guid;
use POData\Providers\Metadata\Type\Int32;
use POData\Providers\Metadata\Type\Int64;
use POData\Providers\Metadata\Type\IType;
use POData\Providers\Metadata\Type\Null1;
use POData\Providers\Metadata\Type\Single;
use POData\Providers\Metadata\Type\StringType;
use POData\UriProcessor\QueryProcessor\ExpressionParser\ExpressionLexer;
use POData\UriProcessor\QueryProcessor\ExpressionParser\ExpressionToken;
use POData\UriProcessor\QueryProcessor\ExpressionParser\ExpressionTokenId;
use ReflectionException;

/**
 * Class KeyDescriptor.
 *
 * A type used to represent Key (identifier) for an entity (resource), This class
 * can parse an Astoria KeyPredicate, KeyPredicate will be in one of the following
 * two formats:
 *  1) KeyValue                                      : If the Entry has a single key
 *                                                     Property the predicate may
 *                                                     include only the value of the
 *                                                     key Property.
 *      e.g. 'ALFKI' in Customers('ALFKI')
 *  2) Property = KeyValue [, Property = KeyValue]*  : If the key is made up of two
 *                                                     or more Properties, then its
 *                                                     value must be stated using
 *                                                     name/value pairs.
 *      e.g. 'ALFKI' in Customers(CustomerID = 'ALFKI'),
 *          "OrderID=10248,ProductID=11" in Order_Details(OrderID=10248,ProductID=11)
 *
 * Entity's identifier is a collection of value for key properties. These values
 * can be named or positional, depending on how they were specified in the URI.
 *  e.g. Named values:
 *         Customers(CustomerID = 'ALFKI'), Order_Details(OrderID=10248,ProductID=11)
 *       Positional values:
 *         Customers('ALFKI'), Order_Details(10248, 11)
 * Note: Currently WCF Data Service does not support multiple 'Positional values' so
 *       Order_Details(10248, 11) is not valid, but this class can parse both types.
 * Note: This type is also used to parse and validate skiptoken value as they are
 *       comma separated positional values.
 */
class KeyDescriptor
{
    /**
     * Holds collection of named key values
     * For e.g. the keypredicate Order_Details(OrderID=10248,ProductID=11) will
     * stored in this array as:
     * Array([OrderID] => Array( [0] => 10248 [1] => Object(Int32)),
     *       [ProductID] => Array( [0] => 11 [1] => Object(Int32)))
     * Note: This is mutually exclusive with $_positionalValues. These values
     * are not validated against entity's ResourceType, validation will happen
     * once validate function is called, $_validatedNamedValues will hold
     * validated values.
     *
     * @var array
     */
    private $namedValues = [];

    /**
     * Holds collection of positional key values
     * For e.g. the keypredicate Order_Details(10248, 11) will
     * stored in this array as:
     * Array([0] => Array( [0] => 10248 [1] => Object(Int32)),
     *       [1] => Array( [0] => 11 [1] => Object(Int32)))
     * Note: This is mutually exclusive with $_namedValues. These values are not
     * validated against entity's ResourceType, validation will happen once validate
     * function is called, $_validatedNamedValues will hold validated values.
     *
     * @var array
     */
    private $positionalValues = [];

    /**
     * Holds collection of positional or named values as named values. The validate
     * function populates this collection.
     *
     * @var array
     */
    private $validatedNamedValues = [];

    /**
     * Creates new instance of KeyDescriptor
     * Note: The arguments $namedValues and $positionalValues are mutually
     * exclusive. Either both or one will be empty array.
     *
     * @param array $namedValues      Collection of named key values
     * @param array $positionalValues Collection of positional key values
     */
    private function __construct(array $namedValues, array $positionalValues)
    {
        $namedCount = count($namedValues);
        $posCount   = count($positionalValues);
        assert(0 == min($namedCount, $posCount), 'At least one of named and positional values arrays must be empty');
        if (0 < $namedCount) {
            $keys = array_keys($namedValues);
            for ($i = 0; $i < $namedCount; $i++) {
                $namedValues[$keys[$i]][0] = urldecode($namedValues[$keys[$i]][0]);
            }
        }
        if (0 < $posCount) {
            for ($i = 0; $i < $posCount; $i++) {
                $positionalValues[$i][0] = urldecode($positionalValues[$i][0]);
            }
        }
        $this->namedValues          = $namedValues;
        $this->positionalValues     = $positionalValues;
        $this->validatedNamedValues = [];
    }

    /**
     * Attempts to parse value(s) of resource key(s) from the given key predicate
     *  and creates instance of KeyDescription representing the same, Once parsing
     *  is done one should call validate function to validate the created
     *  KeyDescription.
     *
     * @param string             $keyPredicate  The predicate to parse
     * @param KeyDescriptor|null $keyDescriptor On return, Description of key after parsing
     *
     * @throws ODataException
     * @return bool           True if the given values were parsed; false if there was a syntax error
     */
    public static function tryParseKeysFromKeyPredicate(
        string $keyPredicate,
        KeyDescriptor &$keyDescriptor = null
    ): bool {
        $isKey     = true;
        $keyString = $keyPredicate;
        return self::parseAndVerifyRawKeyPredicate($keyString, $isKey, $keyDescriptor);
    }

    /**
     * @param  string             $keyString
     * @param  bool               $isKey
     * @param  KeyDescriptor|null $keyDescriptor
     * @throws ODataException
     * @return bool
     */
    protected static function parseAndVerifyRawKeyPredicate(
        string $keyString,
        bool $isKey,
        KeyDescriptor &$keyDescriptor = null
    ): bool {
        $result = self::tryParseKeysFromRawKeyPredicate(
            $keyString,
            $isKey,
            !$isKey,
            $keyDescriptor
        );
        assert($result === isset($keyDescriptor), 'Result must match existence of keyDescriptor');
        return $result;
    }

    /**
     * Attempts to parse value(s) of resource key(s) from the key predicate and
     * creates instance of KeyDescription representing the same, Once parsing is
     * done, one should call validate function to validate the created KeyDescription.
     *
     * @param string        $keyPredicate     The key predicate to parse
     * @param bool          $allowNamedValues Set to true if parser should accept
     *                                        named values(Property = KeyValue),
     *                                        if false then parser will fail on
     *                                        such constructs
     * @param bool          $allowNull        Set to true if parser should accept
     *                                        null values for positional key
     *                                        values, if false then parser will
     *                                        fail on seeing null values
     * @param KeyDescriptor &$keyDescriptor   On return, Description of key after
     *                                        parsing
     *
     * @throws ODataException
     * @return bool           True if the given values were parsed; false if there was a syntax error
     */
    private static function tryParseKeysFromRawKeyPredicate(
        string $keyPredicate,
        bool $allowNamedValues,
        bool $allowNull,
        ?KeyDescriptor &$keyDescriptor
    ): bool {
        $expressionLexer = new ExpressionLexer($keyPredicate);
        $currentToken    = $expressionLexer->getCurrentToken();

        //Check for empty predicate e.g. Customers(  )
        if ($currentToken->getId() == ExpressionTokenId::END()) {
            $keyDescriptor = new self([], []);

            return true;
        }

        $namedValues      = [];
        $positionalValues = [];

        do {
            if (($currentToken->getId() == ExpressionTokenId::IDENTIFIER())
                && $allowNamedValues
            ) {
                //named and positional values are mutually exclusive
                if (!empty($positionalValues)) {
                    return false;
                }

                //expecting keyName=keyValue, verify it
                $identifier = $currentToken->getIdentifier();
                $currentToken = self::getNextLexerToken($expressionLexer);
                if ($currentToken->getId() != ExpressionTokenId::EQUAL()) {
                    return false;
                }

                $currentToken = self::getNextLexerToken($expressionLexer);
                if (!$currentToken->isKeyValueToken()) {
                    return false;
                }

                if (array_key_exists($identifier, $namedValues)) {
                    //Duplication of KeyName not allowed
                    return false;
                }

                //Get type of keyValue and validate keyValue
                $outValue = $outType = null;
                if (!self::getTypeAndValidateKeyValue(
                    $currentToken->Text,
                    $currentToken->getId(),
                    $outValue,
                    $outType
                )
                ) {
                    return false;
                }

                $namedValues[$identifier] = [$outValue, $outType];
            } elseif ($currentToken->isKeyValueToken()
                || ($currentToken->getId() == ExpressionTokenId::NULL_LITERAL() && $allowNull)
            ) {
                //named and positional values are mutually exclusive
                if (!empty($namedValues)) {
                    return false;
                }

                //Get type of keyValue and validate keyValue
                $outValue = $outType = null;
                if (!self::getTypeAndValidateKeyValue(
                    $currentToken->Text,
                    $currentToken->getId(),
                    $outValue,
                    $outType
                )
                ) {
                    return false;
                }

                $positionalValues[] = [$outValue, $outType];
            } else {
                return false;
            }

            $currentToken = self::getNextLexerToken($expressionLexer);
            if ($currentToken->getId() == ExpressionTokenId::COMMA()) {
                $currentToken = self::getNextLexerToken($expressionLexer);
                //end of text and comma, Trailing comma not allowed
                if ($currentToken->getId() == ExpressionTokenId::END()) {
                    return false;
                }
            }
        } while ($currentToken->getId() != ExpressionTokenId::END());

        $keyDescriptor = new self($namedValues, $positionalValues);

        return true;
    }

    /**
     * Get the type of an Astoria URI key value, validate the value against the type. If valid, this function
     * provides the PHP value equivalent to the Astoria URI key value.
     *
     * @param string            $value     The Astoria URI key value
     * @param ExpressionTokenId $tokenId   The tokenId for $value literal
     * @param mixed|null        &$outValue After the invocation, this parameter holds the PHP equivalent to $value,
     *                                     if $value is not valid then this parameter will be null
     * @param IType|null        &$outType  After the invocation, this parameter holds the type of $value, if $value is
     *                                     not a valid key value type then this parameter will be null
     *
     * @return bool True if $value is a valid type, else false
     */
    private static function getTypeAndValidateKeyValue(
        string $value,
        ExpressionTokenId $tokenId,
        &$outValue,
        IType &$outType = null
    ): bool {
        switch ($tokenId) {
            case ExpressionTokenId::BOOLEAN_LITERAL():
                $outType = new Boolean();
                break;
            case ExpressionTokenId::DATETIME_LITERAL():
                $outType = new DateTime();
                break;
            case ExpressionTokenId::GUID_LITERAL():
                $outType = new Guid();
                break;
            case ExpressionTokenId::STRING_LITERAL():
                $outType = new StringType();
                break;
            case ExpressionTokenId::INTEGER_LITERAL():
                $outType = new Int32();
                break;
            case ExpressionTokenId::DECIMAL_LITERAL():
                $outType = new Decimal();
                break;
            case ExpressionTokenId::DOUBLE_LITERAL():
                $outType = new Double();
                break;
            case ExpressionTokenId::INT64_LITERAL():
                $outType = new Int64();
                break;
            case ExpressionTokenId::SINGLE_LITERAL():
                $outType = new Single();
                break;
            case ExpressionTokenId::NULL_LITERAL():
                $outType = new Null1();
                break;
            default:
                $outType = null;

                return false;
        }

        if (!$outType->validate($value, $outValue)) {
            $outType = $outValue = null;

            return false;
        }

        return true;
    }

    /**
     * Attempt to parse comma separated values representing a skiptoken and creates
     * instance of KeyDescriptor representing the same.
     *
     * @param string        $skipToken      The skiptoken value to parse
     * @param KeyDescriptor &$keyDescriptor On return, Description of values
     *                                      after parsing
     *
     * @throws ODataException
     * @return bool           True if the given values were parsed; false if there was a syntax error
     */
    public static function tryParseValuesFromSkipToken(string $skipToken, ?KeyDescriptor &$keyDescriptor): bool
    {
        $isKey     = false;
        $keyString = $skipToken;
        return self::parseAndVerifyRawKeyPredicate($keyString, $isKey, $keyDescriptor);
    }

    /**
     * @param ExpressionLexer $expressionLexer
     * @return \POData\UriProcessor\QueryProcessor\ExpressionParser\ExpressionToken
     * @throws ODataException
     */
    private static function getNextLexerToken(ExpressionLexer $expressionLexer): ExpressionToken
    {
        $expressionLexer->nextToken();
        return $expressionLexer->getCurrentToken();
    }

    /**
     * Gets collection of positional key values.
     *
     * @return array[]
     */
    public function getPositionalValues(): array
    {
        return $this->positionalValues;
    }

    /**
     * Gets collection of positional key values by reference.
     *
     * @return array[]
     */
    public function &getPositionalValuesByRef(): array
    {
        return $this->positionalValues;
    }

    /**
     * Checks whether the key values have name.
     *
     * @return bool
     */
    public function areNamedValues(): bool
    {
        return !empty($this->namedValues);
    }

    /**
     * Gets number of values in the key.
     *
     * @return int
     */
    public function valueCount(): int
    {
        if ($this->isEmpty()) {
            return 0;
        }
        if (!empty($this->namedValues)) {
            return count($this->namedValues);
        }

        return count($this->positionalValues);
    }

    /**
     * Check whether this KeyDescription has any key values.
     *
     * @return bool
     */
    public function isEmpty(): bool
    {
        return empty($this->namedValues) && empty($this->positionalValues);
    }

    /**
     * Validate this KeyDescriptor, If valid, this function populates
     * _validatedNamedValues array with key as keyName and value as an array of
     * key value and key type.
     *
     * @param string       $segmentAsString The segment in the form identifier
     *                                      (keyPredicate) which this descriptor
     *                                      represents
     * @param ResourceType $resourceType    The type of the identifier in the segment
     *
     * @throws ODataException      If validation fails
     * @throws ReflectionException
     */
    public function validate(string $segmentAsString, ResourceType $resourceType): void
    {
        if ($this->isEmpty()) {
            $this->validatedNamedValues = [];
            return;
        }

        $keyProperties      = $resourceType->getKeyProperties();
        $keyPropertiesCount = count($keyProperties);
        if (!empty($this->namedValues)) {
            if (count($this->namedValues) != $keyPropertiesCount) {
                throw ODataException::createSyntaxError(
                    Messages::keyDescriptorKeyCountNotMatching(
                        $segmentAsString,
                        $keyPropertiesCount,
                        count($this->namedValues)
                    )
                );
            }

            foreach ($keyProperties as $keyName => $keyResourceProperty) {
                if (!array_key_exists($keyName, $this->namedValues)) {
                    $keysAsString = null;
                    foreach (array_keys($keyProperties) as $key) {
                        $keysAsString .= $key . ', ';
                    }

                    $keysAsString = rtrim($keysAsString, ' ,');
                    throw ODataException::createSyntaxError(
                        Messages::keyDescriptorMissingKeys(
                            $segmentAsString,
                            $keysAsString
                        )
                    );
                }

                /** @var IType $typeProvided */
                $typeProvided = $this->namedValues[$keyName][1];
                $expectedType = $keyResourceProperty->getInstanceType();
                assert($expectedType instanceof IType, get_class($expectedType));
                if (!$expectedType->isCompatibleWith($typeProvided)) {
                    throw ODataException::createSyntaxError(
                        Messages::keyDescriptorInCompatibleKeyType(
                            $segmentAsString,
                            $keyName,
                            $expectedType->getFullTypeName(),
                            $typeProvided->getFullTypeName()
                        )
                    );
                }

                $this->validatedNamedValues[$keyName] = $this->namedValues[$keyName];
            }
        } else {
            if (count($this->positionalValues) != $keyPropertiesCount) {
                throw ODataException::createSyntaxError(
                    Messages::keyDescriptorKeyCountNotMatching(
                        $segmentAsString,
                        $keyPropertiesCount,
                        count($this->positionalValues)
                    )
                );
            }

            $i = 0;
            foreach ($keyProperties as $keyName => $keyResourceProperty) {
                /** @var IType $typeProvided */
                $typeProvided = $this->positionalValues[$i][1];
                $expectedType = $keyResourceProperty->getInstanceType();
                assert($expectedType instanceof IType, get_class($expectedType));

                if (!$expectedType->isCompatibleWith($typeProvided)) {
                    throw ODataException::createSyntaxError(
                        Messages::keyDescriptorInCompatibleKeyTypeAtPosition(
                            $segmentAsString,
                            $keyResourceProperty->getName(),
                            $i,
                            $expectedType->getFullTypeName(),
                            $typeProvided->getFullTypeName()
                        )
                    );
                }

                $this->validatedNamedValues[$keyName] = $this->positionalValues[$i];
                ++$i;
            }
        }
    }

    /**
     * Generate relative edit url for this key descriptor and supplied resource set.
     *
     * @param ResourceSet $resourceSet
     *
     * @throws ReflectionException
     * @throws InvalidArgumentException
     * @return string
     */
    public function generateRelativeUri(ResourceSet $resourceSet): string
    {
        $resourceType = $resourceSet->getResourceType();
        $keys         = $resourceType->getKeyProperties();

        $namedKeys = $this->getNamedValues();
        $keys = array_intersect_key($keys, $namedKeys);
        if (0 == count($keys) || count($keys) !== count($namedKeys)) {
            $msg = 'Mismatch between supplied key predicates and keys defined on resource set';
            throw new InvalidArgumentException($msg);
        }

        $editUrl = $resourceSet->getName() . '(';
        $comma   = null;
        foreach ($keys as $keyName => $resourceProperty) {
            $keyType = $resourceProperty->getInstanceType();
            assert($keyType instanceof IType, '$keyType not instanceof IType');
            $keyValue = $namedKeys[$keyName][0];
            $keyValue = $keyType->convertToOData($keyValue);

            $editUrl .= $comma . $keyName . '=' . $keyValue;
            $comma = ',';
        }

        $editUrl .= ')';

        return $editUrl;
    }

    /**
     * Gets collection of named key values.
     *
     * @return array[]
     */
    public function getNamedValues(): array
    {
        return $this->namedValues;
    }

    /**
     * Convert validated named values into an array of ODataProperties.
     *
     * return array[]
     * @throws InvalidOperationException
     */
    public function getODataProperties(): array
    {
        $values = $this->getValidatedNamedValues();
        $result = [];

        foreach ($values as $propName => $propDeets) {
            assert(2 == count($propDeets));
            assert($propDeets[1] instanceof IType);
            $property           = new ODataProperty();
            $property->name     = strval($propName);
            $property->value    = $propDeets[1]->convert($propDeets[0]);
            $property->typeName = $propDeets[1]->getFullTypeName();
            $result[$propName]  = $property;
        }

        return $result;
    }

    /**
     * Gets validated named key values, this array will be populated
     * in validate function.
     *
     * @throws InvalidOperationException If this function invoked before invoking validate function
     * @return array[]
     */
    public function getValidatedNamedValues(): array
    {
        if (empty($this->validatedNamedValues)) {
            throw new InvalidOperationException(
                Messages::keyDescriptorValidateNotCalled()
            );
        }

        return $this->validatedNamedValues;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace POData\UriProcessor\ResourcePathProcessor\SegmentParser;
6
7			use InvalidArgumentException;
8			use POData\Common\InvalidOperationException;
9			use POData\Common\Messages;
10			use POData\Common\ODataException;
11			use POData\ObjectModel\ODataProperty;
12			use POData\Providers\Metadata\ResourceSet;
13			use POData\Providers\Metadata\ResourceType;
14			use POData\Providers\Metadata\Type\Boolean;
15			use POData\Providers\Metadata\Type\DateTime;
16			use POData\Providers\Metadata\Type\Decimal;
17			use POData\Providers\Metadata\Type\Double;
18			use POData\Providers\Metadata\Type\Guid;
19			use POData\Providers\Metadata\Type\Int32;
20			use POData\Providers\Metadata\Type\Int64;
21			use POData\Providers\Metadata\Type\IType;
22			use POData\Providers\Metadata\Type\Null1;
23			use POData\Providers\Metadata\Type\Single;
24			use POData\Providers\Metadata\Type\StringType;
25			use POData\UriProcessor\QueryProcessor\ExpressionParser\ExpressionLexer;
26			use POData\UriProcessor\QueryProcessor\ExpressionParser\ExpressionToken;
27			use POData\UriProcessor\QueryProcessor\ExpressionParser\ExpressionTokenId;
28			use ReflectionException;
29
30			/**
31			* Class KeyDescriptor.
32			*
33			* A type used to represent Key (identifier) for an entity (resource), This class
34			* can parse an Astoria KeyPredicate, KeyPredicate will be in one of the following
35			* two formats:
36			* 1) KeyValue : If the Entry has a single key
37			* Property the predicate may
38			* include only the value of the
39			* key Property.
40			* e.g. 'ALFKI' in Customers('ALFKI')
41			* 2) Property = KeyValue [, Property = KeyValue]* : If the key is made up of two
42			* or more Properties, then its
43			* value must be stated using
44			* name/value pairs.
45			* e.g. 'ALFKI' in Customers(CustomerID = 'ALFKI'),
46			* "OrderID=10248,ProductID=11" in Order_Details(OrderID=10248,ProductID=11)
47			*
48			* Entity's identifier is a collection of value for key properties. These values
49			* can be named or positional, depending on how they were specified in the URI.
50			* e.g. Named values:
51			* Customers(CustomerID = 'ALFKI'), Order_Details(OrderID=10248,ProductID=11)
52			* Positional values:
53			* Customers('ALFKI'), Order_Details(10248, 11)
54			* Note: Currently WCF Data Service does not support multiple 'Positional values' so
55			* Order_Details(10248, 11) is not valid, but this class can parse both types.
56			* Note: This type is also used to parse and validate skiptoken value as they are
57			* comma separated positional values.
58			*/
59			class KeyDescriptor
60			{
61			/**
62			* Holds collection of named key values
63			* For e.g. the keypredicate Order_Details(OrderID=10248,ProductID=11) will
64			* stored in this array as:
65			* Array([OrderID] => Array( [0] => 10248 [1] => Object(Int32)),
66			* [ProductID] => Array( [0] => 11 [1] => Object(Int32)))
67			* Note: This is mutually exclusive with $_positionalValues. These values
68			* are not validated against entity's ResourceType, validation will happen
69			* once validate function is called, $_validatedNamedValues will hold
70			* validated values.
71			*
72			* @var array
73			*/
74			private $namedValues = [];
75
76			/**
77			* Holds collection of positional key values
78			* For e.g. the keypredicate Order_Details(10248, 11) will
79			* stored in this array as:
80			* Array([0] => Array( [0] => 10248 [1] => Object(Int32)),
81			* [1] => Array( [0] => 11 [1] => Object(Int32)))
82			* Note: This is mutually exclusive with $_namedValues. These values are not
83			* validated against entity's ResourceType, validation will happen once validate
84			* function is called, $_validatedNamedValues will hold validated values.
85			*
86			* @var array
87			*/
88			private $positionalValues = [];
89
90			/**
91			* Holds collection of positional or named values as named values. The validate
92			* function populates this collection.
93			*
94			* @var array
95			*/
96			private $validatedNamedValues = [];
97
98			/**
99			* Creates new instance of KeyDescriptor
100			* Note: The arguments $namedValues and $positionalValues are mutually
101			* exclusive. Either both or one will be empty array.
102			*
103			* @param array $namedValues Collection of named key values
104			* @param array $positionalValues Collection of positional key values
105			*/
106			private function __construct(array $namedValues, array $positionalValues)
107			{
108			$namedCount = count($namedValues);
109			$posCount = count($positionalValues);
110			assert(0 == min($namedCount, $posCount), 'At least one of named and positional values arrays must be empty');
111			if (0 < $namedCount) {
112			$keys = array_keys($namedValues);
113			for ($i = 0; $i < $namedCount; $i++) {
114			$namedValues[$keys[$i]][0] = urldecode($namedValues[$keys[$i]][0]);
115			}
116			}
117			if (0 < $posCount) {
118			for ($i = 0; $i < $posCount; $i++) {
119			$positionalValues[$i][0] = urldecode($positionalValues[$i][0]);
120			}
121			}
122			$this->namedValues = $namedValues;
123			$this->positionalValues = $positionalValues;
124			$this->validatedNamedValues = [];
125			}
126
127			/**
128			* Attempts to parse value(s) of resource key(s) from the given key predicate
129			* and creates instance of KeyDescription representing the same, Once parsing
130			* is done one should call validate function to validate the created
131			* KeyDescription.
132			*
133			* @param string $keyPredicate The predicate to parse
134			* @param KeyDescriptor\|null $keyDescriptor On return, Description of key after parsing
135			*
136			* @throws ODataException
137			* @return bool True if the given values were parsed; false if there was a syntax error
138			*/
139			public static function tryParseKeysFromKeyPredicate(
140			string $keyPredicate,
141			KeyDescriptor &$keyDescriptor = null
142			): bool {
143			$isKey = true;
144			$keyString = $keyPredicate;
145			return self::parseAndVerifyRawKeyPredicate($keyString, $isKey, $keyDescriptor);
146			}
147
148			/**
149			* @param string $keyString
150			* @param bool $isKey
151			* @param KeyDescriptor\|null $keyDescriptor
152			* @throws ODataException
153			* @return bool
154			*/
155			protected static function parseAndVerifyRawKeyPredicate(
156			string $keyString,
157			bool $isKey,
158			KeyDescriptor &$keyDescriptor = null
159			): bool {
160			$result = self::tryParseKeysFromRawKeyPredicate(
161			$keyString,
162			$isKey,
163			!$isKey,
164			$keyDescriptor
165			);
166			assert($result === isset($keyDescriptor), 'Result must match existence of keyDescriptor');
167			return $result;
168			}
169
170			/**
171			* Attempts to parse value(s) of resource key(s) from the key predicate and
172			* creates instance of KeyDescription representing the same, Once parsing is
173			* done, one should call validate function to validate the created KeyDescription.
174			*
175			* @param string $keyPredicate The key predicate to parse
176			* @param bool $allowNamedValues Set to true if parser should accept
177			* named values(Property = KeyValue),
178			* if false then parser will fail on
179			* such constructs
180			* @param bool $allowNull Set to true if parser should accept
181			* null values for positional key
182			* values, if false then parser will
183			* fail on seeing null values
184			* @param KeyDescriptor &$keyDescriptor On return, Description of key after
185			* parsing
186			*
187			* @throws ODataException
188			* @return bool True if the given values were parsed; false if there was a syntax error
189			*/
190			private static function tryParseKeysFromRawKeyPredicate(
191			string $keyPredicate,
192			bool $allowNamedValues,
193			bool $allowNull,
194			?KeyDescriptor &$keyDescriptor
195			): bool {
196			$expressionLexer = new ExpressionLexer($keyPredicate);
197			$currentToken = $expressionLexer->getCurrentToken();
198
199			//Check for empty predicate e.g. Customers( )
200			if ($currentToken->getId() == ExpressionTokenId::END()) {
201			$keyDescriptor = new self([], []);
202
203			return true;
204			}
205
206			$namedValues = [];
207			$positionalValues = [];
208
209			do {
210			if (($currentToken->getId() == ExpressionTokenId::IDENTIFIER())
211			&& $allowNamedValues
212			) {
213			//named and positional values are mutually exclusive
214			if (!empty($positionalValues)) {
215			return false;
216			}
217
218			//expecting keyName=keyValue, verify it
219			$identifier = $currentToken->getIdentifier();
220			$currentToken = self::getNextLexerToken($expressionLexer);
221			if ($currentToken->getId() != ExpressionTokenId::EQUAL()) {
222			return false;
223			}
224
225			$currentToken = self::getNextLexerToken($expressionLexer);
226			if (!$currentToken->isKeyValueToken()) {
227			return false;
228			}
229
230			if (array_key_exists($identifier, $namedValues)) {
231			//Duplication of KeyName not allowed
232			return false;
233			}
234
235			//Get type of keyValue and validate keyValue
236			$outValue = $outType = null;
237			if (!self::getTypeAndValidateKeyValue(
238			$currentToken->Text,
239			$currentToken->getId(),
240			$outValue,
241			$outType
242			)
243			) {
244			return false;
245			}
246
247			$namedValues[$identifier] = [$outValue, $outType];
248			} elseif ($currentToken->isKeyValueToken()
249			\|\| ($currentToken->getId() == ExpressionTokenId::NULL_LITERAL() && $allowNull)
250			) {
251			//named and positional values are mutually exclusive
252			if (!empty($namedValues)) {
253			return false;
254			}
255
256			//Get type of keyValue and validate keyValue
257			$outValue = $outType = null;
258			if (!self::getTypeAndValidateKeyValue(
259			$currentToken->Text,
260			$currentToken->getId(),
261			$outValue,
262			$outType
263			)
264			) {
265			return false;
266			}
267
268			$positionalValues[] = [$outValue, $outType];
269			} else {
270			return false;
271			}
272
273			$currentToken = self::getNextLexerToken($expressionLexer);
274			if ($currentToken->getId() == ExpressionTokenId::COMMA()) {
275			$currentToken = self::getNextLexerToken($expressionLexer);
276			//end of text and comma, Trailing comma not allowed
277			if ($currentToken->getId() == ExpressionTokenId::END()) {
278			return false;
279			}
280			}
281			} while ($currentToken->getId() != ExpressionTokenId::END());
282
283			$keyDescriptor = new self($namedValues, $positionalValues);
284
285			return true;
286			}
287
288			/**
289			* Get the type of an Astoria URI key value, validate the value against the type. If valid, this function
290			* provides the PHP value equivalent to the Astoria URI key value.
291			*
292			* @param string $value The Astoria URI key value
293			* @param ExpressionTokenId $tokenId The tokenId for $value literal
294			* @param mixed\|null &$outValue After the invocation, this parameter holds the PHP equivalent to $value,
295			* if $value is not valid then this parameter will be null
296			* @param IType\|null &$outType After the invocation, this parameter holds the type of $value, if $value is
297			* not a valid key value type then this parameter will be null
298			*
299			* @return bool True if $value is a valid type, else false
300			*/
301			private static function getTypeAndValidateKeyValue(
302			string $value,
303			ExpressionTokenId $tokenId,
304			&$outValue,
305			IType &$outType = null
306			): bool {
307			switch ($tokenId) {
308			case ExpressionTokenId::BOOLEAN_LITERAL():
309			$outType = new Boolean();
310			break;
311			case ExpressionTokenId::DATETIME_LITERAL():
312			$outType = new DateTime();
313			break;
314			case ExpressionTokenId::GUID_LITERAL():
315			$outType = new Guid();
316			break;
317			case ExpressionTokenId::STRING_LITERAL():
318			$outType = new StringType();
319			break;
320			case ExpressionTokenId::INTEGER_LITERAL():
321			$outType = new Int32();
322			break;
323			case ExpressionTokenId::DECIMAL_LITERAL():
324			$outType = new Decimal();
325			break;
326			case ExpressionTokenId::DOUBLE_LITERAL():
327			$outType = new Double();
328			break;
329			case ExpressionTokenId::INT64_LITERAL():
330			$outType = new Int64();
331			break;
332			case ExpressionTokenId::SINGLE_LITERAL():
333			$outType = new Single();
334			break;
335			case ExpressionTokenId::NULL_LITERAL():
336			$outType = new Null1();
337			break;
338			default:
339			$outType = null;
340
341			return false;
342			}
343
344			if (!$outType->validate($value, $outValue)) {
345			$outType = $outValue = null;
346
347			return false;
348			}
349
350			return true;
351			}
352
353			/**
354			* Attempt to parse comma separated values representing a skiptoken and creates
355			* instance of KeyDescriptor representing the same.
356			*
357			* @param string $skipToken The skiptoken value to parse
358			* @param KeyDescriptor &$keyDescriptor On return, Description of values
359			* after parsing
360			*
361			* @throws ODataException
362			* @return bool True if the given values were parsed; false if there was a syntax error
363			*/
364			public static function tryParseValuesFromSkipToken(string $skipToken, ?KeyDescriptor &$keyDescriptor): bool
365			{
366			$isKey = false;
367			$keyString = $skipToken;
368			return self::parseAndVerifyRawKeyPredicate($keyString, $isKey, $keyDescriptor);
369			}
370
371			/**
372			* @param ExpressionLexer $expressionLexer
373			* @return \POData\UriProcessor\QueryProcessor\ExpressionParser\ExpressionToken
374			* @throws ODataException
375			*/
376			private static function getNextLexerToken(ExpressionLexer $expressionLexer): ExpressionToken
377			{
378			$expressionLexer->nextToken();
379			return $expressionLexer->getCurrentToken();
380			}
381
382			/**
383			* Gets collection of positional key values.
384			*
385			* @return array[]
386			*/
387			public function getPositionalValues(): array
388			{
389			return $this->positionalValues;
390			}
391
392			/**
393			* Gets collection of positional key values by reference.
394			*
395			* @return array[]
396			*/
397			public function &getPositionalValuesByRef(): array
398			{
399			return $this->positionalValues;
400			}
401
402			/**
403			* Checks whether the key values have name.
404			*
405			* @return bool
406			*/
407			public function areNamedValues(): bool
408			{
409			return !empty($this->namedValues);
410			}
411
412			/**
413			* Gets number of values in the key.
414			*
415			* @return int
416			*/
417			public function valueCount(): int
418			{
419			if ($this->isEmpty()) {
420			return 0;
421			}
422			if (!empty($this->namedValues)) {
423			return count($this->namedValues);
424			}
425
426			return count($this->positionalValues);
427			}
428
429			/**
430			* Check whether this KeyDescription has any key values.
431			*
432			* @return bool
433			*/
434			public function isEmpty(): bool
435			{
436			return empty($this->namedValues) && empty($this->positionalValues);
437			}
438
439			/**
440			* Validate this KeyDescriptor, If valid, this function populates
441			* _validatedNamedValues array with key as keyName and value as an array of
442			* key value and key type.
443			*
444			* @param string $segmentAsString The segment in the form identifier
445			* (keyPredicate) which this descriptor
446			* represents
447			* @param ResourceType $resourceType The type of the identifier in the segment
448			*
449			* @throws ODataException If validation fails
450			* @throws ReflectionException
451			*/
452			public function validate(string $segmentAsString, ResourceType $resourceType): void
453			{
454			if ($this->isEmpty()) {
455			$this->validatedNamedValues = [];
456			return;
457			}
458
459			$keyProperties = $resourceType->getKeyProperties();
460			$keyPropertiesCount = count($keyProperties);
461			if (!empty($this->namedValues)) {
462			if (count($this->namedValues) != $keyPropertiesCount) {
463			throw ODataException::createSyntaxError(
464			Messages::keyDescriptorKeyCountNotMatching(
465			$segmentAsString,
466			$keyPropertiesCount,
467			count($this->namedValues)
468			)
469			);
470			}
471
472			foreach ($keyProperties as $keyName => $keyResourceProperty) {
473			if (!array_key_exists($keyName, $this->namedValues)) {
474			$keysAsString = null;
475			foreach (array_keys($keyProperties) as $key) {
476			$keysAsString .= $key . ', ';
477			}
478
479			$keysAsString = rtrim($keysAsString, ' ,');
480			throw ODataException::createSyntaxError(
481			Messages::keyDescriptorMissingKeys(
482			$segmentAsString,
483			$keysAsString
484			)
485			);
486			}
487
488			/** @var IType $typeProvided */
489			$typeProvided = $this->namedValues[$keyName][1];
490			$expectedType = $keyResourceProperty->getInstanceType();
491			assert($expectedType instanceof IType, get_class($expectedType));
492			if (!$expectedType->isCompatibleWith($typeProvided)) {
493			throw ODataException::createSyntaxError(
494			Messages::keyDescriptorInCompatibleKeyType(
495			$segmentAsString,
496			$keyName,
497			$expectedType->getFullTypeName(),
498			$typeProvided->getFullTypeName()
499			)
500			);
501			}
502
503			$this->validatedNamedValues[$keyName] = $this->namedValues[$keyName];
504			}
505			} else {
506			if (count($this->positionalValues) != $keyPropertiesCount) {
507			throw ODataException::createSyntaxError(
508			Messages::keyDescriptorKeyCountNotMatching(
509			$segmentAsString,
510			$keyPropertiesCount,
511			count($this->positionalValues)
512			)
513			);
514			}
515
516			$i = 0;
517			foreach ($keyProperties as $keyName => $keyResourceProperty) {
518			/** @var IType $typeProvided */
519			$typeProvided = $this->positionalValues[$i][1];
520			$expectedType = $keyResourceProperty->getInstanceType();
521			assert($expectedType instanceof IType, get_class($expectedType));
522
523			if (!$expectedType->isCompatibleWith($typeProvided)) {
524			throw ODataException::createSyntaxError(
525			Messages::keyDescriptorInCompatibleKeyTypeAtPosition(
526			$segmentAsString,
527			$keyResourceProperty->getName(),
528			$i,
529			$expectedType->getFullTypeName(),
530			$typeProvided->getFullTypeName()
531			)
532			);
533			}
534
535			$this->validatedNamedValues[$keyName] = $this->positionalValues[$i];
536			++$i;
537			}
538			}
539			}
540
541			/**
542			* Generate relative edit url for this key descriptor and supplied resource set.
543			*
544			* @param ResourceSet $resourceSet
545			*
546			* @throws ReflectionException
547			* @throws InvalidArgumentException
548			* @return string
549			*/
550			public function generateRelativeUri(ResourceSet $resourceSet): string
551			{
552			$resourceType = $resourceSet->getResourceType();
553			$keys = $resourceType->getKeyProperties();
554
555			$namedKeys = $this->getNamedValues();
556			$keys = array_intersect_key($keys, $namedKeys);
557			if (0 == count($keys) \|\| count($keys) !== count($namedKeys)) {
558			$msg = 'Mismatch between supplied key predicates and keys defined on resource set';
559			throw new InvalidArgumentException($msg);
560			}
561
562			$editUrl = $resourceSet->getName() . '(';
563			$comma = null;
564			foreach ($keys as $keyName => $resourceProperty) {
565			$keyType = $resourceProperty->getInstanceType();
566			assert($keyType instanceof IType, '$keyType not instanceof IType');
567			$keyValue = $namedKeys[$keyName][0];
568			$keyValue = $keyType->convertToOData($keyValue);
569
570			$editUrl .= $comma . $keyName . '=' . $keyValue;
571			$comma = ',';
572			}
573
574			$editUrl .= ')';
575
576			return $editUrl;
577			}
578
579			/**
580			* Gets collection of named key values.
581			*
582			* @return array[]
583			*/
584			public function getNamedValues(): array
585			{
586			return $this->namedValues;
587			}
588
589			/**
590			* Convert validated named values into an array of ODataProperties.
591			*
592			* return array[]
593			* @throws InvalidOperationException
594			*/
595			public function getODataProperties(): array
596			{
597			$values = $this->getValidatedNamedValues();
598			$result = [];
599
600			foreach ($values as $propName => $propDeets) {
601			assert(2 == count($propDeets));
602			assert($propDeets[1] instanceof IType);
603			$property = new ODataProperty();
604			$property->name = strval($propName);
605			$property->value = $propDeets[1]->convert($propDeets[0]);
606			$property->typeName = $propDeets[1]->getFullTypeName();
607			$result[$propName] = $property;
608			}
609
610			return $result;
611			}
612
613			/**
614			* Gets validated named key values, this array will be populated
615			* in validate function.
616			*
617			* @throws InvalidOperationException If this function invoked before invoking validate function
618			* @return array[]
619			*/
620			public function getValidatedNamedValues(): array
621			{
622			if (empty($this->validatedNamedValues)) {
623			throw new InvalidOperationException(
624			Messages::keyDescriptorValidateNotCalled()
625			);
626			}
627
628			return $this->validatedNamedValues;
629			}
630			}
631

Algo-Web / POData

Pull Request — master (#265)

KeyDescriptor::tryParseKeysFromRawKeyPredicate() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like