NOSQLQuery::composeFilter() - Code Metrics - psfs/nosql - Measure and Improve Code Quality continuously with Scrutinizer

NOSQLQuery::composeFilter() C
last analyzed 2021-02-28 16:53 UTC

↳ Parent: NOSQLQuery

Complexity

Conditions	12
Paths	22

Size

Total Lines	58
Code Lines	46

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
eloc	46
c	2
b	0
f	0
dl	0
loc	58
rs	6.9666
cc	12
nc	22
nop	2

How to fix Long Method Complexity

<?php
namespace NOSQL\Models;

use MongoDB\BSON\ObjectId;
use MongoDB\Collection;
use MongoDB\Database;
use NOSQL\Services\Base\NOSQLBase;
use NOSQL\Dto\Model\ResultsetDto;
use NOSQL\Models\base\NOSQLParserTrait;
use PSFS\base\config\Config;
use PSFS\base\exception\ApiException;
use PSFS\base\types\Api;

final class NOSQLQuery {
    const NOSQL_COLLATION_FIELD = '__collation';
    const NOSQL_IN_OPERATOR = '$in';
    const NOSQL_NOT_NULL_OPERATOR = '$ne';
    const NOSQL_EQUAL_OPERATOR = '$eq';

    /**
     * @param $pk
     * @param Database|null $con
     * @return mixed
     * @throws ApiException
     */
    public static function findPk($modelName, $pk, Database $con = null) {
        $model = new $modelName();
        $con = NOSQLParserTrait::initConnection($model, $con);
        $collection = $con->selectCollection($model->getSchema()->name);
        $result = $collection->findOne(['_id' => new ObjectId($pk)]);
        if(null !== $result) {
            $model->feed($result->getArrayCopy());
        } else {
            throw new ApiException(t('Document not found'), 404);
        }
        return $model;
    }

    /**
     * @param string $modelName
     * @param array $criteria
     * @param Database|null $con
     * @return ResultsetDto
     * @throws \NOSQL\Exceptions\NOSQLValidationException
     * @throws \PSFS\base\exception\GeneratorException
     */
    public static function find($modelName, array $criteria, Database $con = null) {
        /** @var NOSQLActiveRecord $model */
        $model = new $modelName();
        $con = NOSQLParserTrait::initConnection($model, $con);
        $collection = $con->selectCollection($model->getSchema()->name);
        $resultSet = new ResultsetDto(false);
        // TODO create Query model for it
        [$filters, $nosqlOptions] = self::parseCriteria($criteria, $model, $collection);

        $resultSet->count = $collection->countDocuments($filters, $nosqlOptions);

        $nosqlOptions["limit"] = (integer)(array_key_exists(Api::API_LIMIT_FIELD, $criteria) ? $criteria[Api::API_LIMIT_FIELD] : Config::getParam('pagination.limit', 50));
        $page = (integer)(array_key_exists(Api::API_PAGE_FIELD, $criteria) ? $criteria[Api::API_PAGE_FIELD] : 1);
        $nosqlOptions["skip"] = ($page === 1) ? 0 : ($page - 1) * $nosqlOptions["limit"];

        if ((array_key_exists(Api::API_ORDER_FIELD, $criteria)) && (is_array($criteria[Api::API_ORDER_FIELD]))) {
            $nosqlOptions["sort"] = [];
            foreach ($criteria[Api::API_ORDER_FIELD] as $field => $direction) {
                $nosqlOptions["sort"][$field] = (abs($direction) === 1)  ? $direction : 1;
            }
        }

        $results = $collection->find($filters, $nosqlOptions);
        /** @var  $result */
        $items = $results->toArray();
        foreach($items as $item) {
            $model->feed($item->getArrayCopy(), true);
            $resultSet->items[] = $model->getDtoCopy(true);
        }
        return $resultSet;
    }

    /**
     * @param array $criteria
     * @param NOSQLActiveRecord $model
     * @return array
     */
    private static function parseCriteria(array $criteria, NOSQLActiveRecord $model, Collection $collection)
    {
        $filters = [];
        if (array_key_exists(Api::API_COMBO_FIELD, $criteria)) {
            $filters['$text'] = ['$search' => $criteria[Api::API_COMBO_FIELD]];
        }

        foreach ($model->getSchema()->properties as $property) {
            if (array_key_exists($property->name, $criteria)) {
                $filterValue = self::composeFilter($criteria, $property);
                $filters[$property->name] = $filterValue;
            }
        }

        // Check index collation
        $options = [];
        $indexes = $collection->listIndexes();
        foreach($indexes as $index) {
            $indexInfo = $index->__debugInfo();
            if (empty(array_diff(array_keys($index["key"]), array_keys($filters)))) {
                if (array_key_exists("collation", $indexInfo)) {
                    $collation = $indexInfo["collation"];
                    $options["collation"] = ["locale" => $collation["locale"], "strength" => $collation["strength"]];
                    break;
                }
            }
        }

        if (array_key_exists("collation", $options)) {
            foreach($filters as $key=>$filter) {
                if (is_string($criteria[$key])) {
                    $filters[$key] = $criteria[$key];
                }
            }
        }
        return [$filters, $options];
    }

    /**
     * @param array $criteria
     * @param \NOSQL\Dto\PropertyDto $property
     * @return array|bool|float|int|mixed
     */
    private static function composeFilter(array $criteria, \NOSQL\Dto\PropertyDto $property)
    {
        $filterValue = $criteria[$property->name];
        $matchOperator = is_array($filterValue) ? $filterValue[0] : self::NOSQL_EQUAL_OPERATOR;
        if (is_array($filterValue)) {
            if(in_array($matchOperator, [
                self::NOSQL_NOT_NULL_OPERATOR,
                self::NOSQL_IN_OPERATOR,
            ], true)) {
                $operator = array_shift($filterValue);
                $value = array_shift($filterValue);
                $filterValue = [
                    $operator => $value,
                ];
            } else {
                // Default case for back compatibility
                $filterValue = [
                    self::NOSQL_IN_OPERATOR => $filterValue,
                ];
            }
        } elseif(in_array($filterValue, [
            self::NOSQL_NOT_NULL_OPERATOR,
        ], true)) {
            $filterValue = [
                $filterValue => null,
            ];
        } elseif (in_array($property->type, [
            NOSQLBase::NOSQL_TYPE_BOOLEAN,
            NOSQLBase::NOSQL_TYPE_INTEGER,
            NOSQLBase::NOSQL_TYPE_DOUBLE,
            NOSQLBase::NOSQL_TYPE_LONG], true)) {
            if ($property->type === NOSQLBase::NOSQL_TYPE_BOOLEAN) {
                switch ($filterValue) {
                    case '1':
                    case 1:
                    case 'true':
                    case true:
                        $filterValue = true;
                        break;
                    default:
                        $filterValue = false;
                        break;
                }
            } elseif (NOSQLBase::NOSQL_TYPE_INTEGER === $property->type) {
                $filterValue = (integer)$filterValue;
            } else {
                $filterValue = (float)$filterValue;
            }
            $filterValue = [
                self::NOSQL_EQUAL_OPERATOR => $filterValue,
            ];
        } else {
            $filterValue = [
                '$regex' => $filterValue,
                '$options' => 'i'
            ];
        }
        return $filterValue;
    }
}


1			<?php
2			namespace NOSQL\Models;
3
4			use MongoDB\BSON\ObjectId;
5			use MongoDB\Collection;
6			use MongoDB\Database;
7			use NOSQL\Services\Base\NOSQLBase;
8			use NOSQL\Dto\Model\ResultsetDto;
9			use NOSQL\Models\base\NOSQLParserTrait;
10			use PSFS\base\config\Config;
11			use PSFS\base\exception\ApiException;
12			use PSFS\base\types\Api;
13
14			final class NOSQLQuery {
15			const NOSQL_COLLATION_FIELD = '__collation';
16			const NOSQL_IN_OPERATOR = '$in';
17			const NOSQL_NOT_NULL_OPERATOR = '$ne';
18			const NOSQL_EQUAL_OPERATOR = '$eq';
19
20			/**
21			* @param $pk
22			* @param Database\|null $con
23			* @return mixed
24			* @throws ApiException
25			*/
26			public static function findPk($modelName, $pk, Database $con = null) {
27			$model = new $modelName();
28			$con = NOSQLParserTrait::initConnection($model, $con);
29			$collection = $con->selectCollection($model->getSchema()->name);
30			$result = $collection->findOne(['_id' => new ObjectId($pk)]);
31			if(null !== $result) {
32			$model->feed($result->getArrayCopy());
33			} else {
34			throw new ApiException(t('Document not found'), 404);
35			}
36			return $model;
37			}
38
39			/**
40			* @param string $modelName
41			* @param array $criteria
42			* @param Database\|null $con
43			* @return ResultsetDto
44			* @throws \NOSQL\Exceptions\NOSQLValidationException
45			* @throws \PSFS\base\exception\GeneratorException
46			*/
47			public static function find($modelName, array $criteria, Database $con = null) {
48			/** @var NOSQLActiveRecord $model */
49			$model = new $modelName();
50			$con = NOSQLParserTrait::initConnection($model, $con);
51			$collection = $con->selectCollection($model->getSchema()->name);
52			$resultSet = new ResultsetDto(false);
53			// TODO create Query model for it
54			[$filters, $nosqlOptions] = self::parseCriteria($criteria, $model, $collection);
55
56			$resultSet->count = $collection->countDocuments($filters, $nosqlOptions);
57
58			$nosqlOptions["limit"] = (integer)(array_key_exists(Api::API_LIMIT_FIELD, $criteria) ? $criteria[Api::API_LIMIT_FIELD] : Config::getParam('pagination.limit', 50));
59			$page = (integer)(array_key_exists(Api::API_PAGE_FIELD, $criteria) ? $criteria[Api::API_PAGE_FIELD] : 1);
60			$nosqlOptions["skip"] = ($page === 1) ? 0 : ($page - 1) * $nosqlOptions["limit"];
61
62			if ((array_key_exists(Api::API_ORDER_FIELD, $criteria)) && (is_array($criteria[Api::API_ORDER_FIELD]))) {
63			$nosqlOptions["sort"] = [];
64			foreach ($criteria[Api::API_ORDER_FIELD] as $field => $direction) {
65			$nosqlOptions["sort"][$field] = (abs($direction) === 1) ? $direction : 1;
66			}
67			}
68
69			$results = $collection->find($filters, $nosqlOptions);
70			/** @var $result */
71			$items = $results->toArray();
72			foreach($items as $item) {
73			$model->feed($item->getArrayCopy(), true);
74			$resultSet->items[] = $model->getDtoCopy(true);
75			}
76			return $resultSet;
77			}
78
79			/**
80			* @param array $criteria
81			* @param NOSQLActiveRecord $model
82			* @return array
83			*/
84			private static function parseCriteria(array $criteria, NOSQLActiveRecord $model, Collection $collection)
85			{
86			$filters = [];
87			if (array_key_exists(Api::API_COMBO_FIELD, $criteria)) {
88			$filters['$text'] = ['$search' => $criteria[Api::API_COMBO_FIELD]];
89			}
90
91			foreach ($model->getSchema()->properties as $property) {
92			if (array_key_exists($property->name, $criteria)) {
93			$filterValue = self::composeFilter($criteria, $property);
94			$filters[$property->name] = $filterValue;
95			}
96			}
97
98			// Check index collation
99			$options = [];
100			$indexes = $collection->listIndexes();
101			foreach($indexes as $index) {
102			$indexInfo = $index->__debugInfo();
103			if (empty(array_diff(array_keys($index["key"]), array_keys($filters)))) {
104			if (array_key_exists("collation", $indexInfo)) {
105			$collation = $indexInfo["collation"];
106			$options["collation"] = ["locale" => $collation["locale"], "strength" => $collation["strength"]];
107			break;
108			}
109			}
110			}
111
112			if (array_key_exists("collation", $options)) {
113			foreach($filters as $key=>$filter) {
114			if (is_string($criteria[$key])) {
115			$filters[$key] = $criteria[$key];
116			}
117			}
118			}
119			return [$filters, $options];
120			}
121
122			/**
123			* @param array $criteria
124			* @param \NOSQL\Dto\PropertyDto $property
125			* @return array\|bool\|float\|int\|mixed
126			*/
127			private static function composeFilter(array $criteria, \NOSQL\Dto\PropertyDto $property)
128			{
129			$filterValue = $criteria[$property->name];
130			$matchOperator = is_array($filterValue) ? $filterValue[0] : self::NOSQL_EQUAL_OPERATOR;
131			if (is_array($filterValue)) {
132			if(in_array($matchOperator, [
133			self::NOSQL_NOT_NULL_OPERATOR,
134			self::NOSQL_IN_OPERATOR,
135			], true)) {
136			$operator = array_shift($filterValue);
137			$value = array_shift($filterValue);
138			$filterValue = [
139			$operator => $value,
140			];
141			} else {
142			// Default case for back compatibility
143			$filterValue = [
144			self::NOSQL_IN_OPERATOR => $filterValue,
145			];
146			}
147			} elseif(in_array($filterValue, [
148			self::NOSQL_NOT_NULL_OPERATOR,
149			], true)) {
150			$filterValue = [
151			$filterValue => null,
152			];
153			} elseif (in_array($property->type, [
154			NOSQLBase::NOSQL_TYPE_BOOLEAN,
155			NOSQLBase::NOSQL_TYPE_INTEGER,
156			NOSQLBase::NOSQL_TYPE_DOUBLE,
157			NOSQLBase::NOSQL_TYPE_LONG], true)) {
158			if ($property->type === NOSQLBase::NOSQL_TYPE_BOOLEAN) {
159			switch ($filterValue) {
160			case '1':
161			case 1:
162			case 'true':
163			case true:
164			$filterValue = true;
165			break;
166			default:
167			$filterValue = false;
168			break;
169			}
170			} elseif (NOSQLBase::NOSQL_TYPE_INTEGER === $property->type) {
171			$filterValue = (integer)$filterValue;
172			} else {
173			$filterValue = (float)$filterValue;
174			}
175			$filterValue = [
176			self::NOSQL_EQUAL_OPERATOR => $filterValue,
177			];
178			} else {
179			$filterValue = [
180			'$regex' => $filterValue,
181			'$options' => 'i'
182			];
183			}
184			return $filterValue;
185			}
186			}
187

psfs / nosql

NOSQLQuery::composeFilter() C last analyzed 2021-02-28 16:53 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

NOSQLQuery::composeFilter() C
last analyzed 2021-02-28 16:53 UTC