HDNET\Calendarize\Domain\Repository\IndexRepository::findBySearch()

Complexity

Conditions	18
Paths	68

Size

Total Lines

94

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function findBySearch(\DateTime $startDate = null, \DateTime $endDate = null, array $customSearch = [], int $limit = 0)
    {
        $arguments = [
            'indexIds' => [],
            'startDate' => $startDate,
            'endDate' => $endDate,
            'customSearch' => $customSearch,
            'indexTypes' => $this->indexTypes,
            'emptyPreResult' => false,
        ];
        $arguments = $this->callSignal(__CLASS__, __FUNCTION__ . 'Pre', $arguments);

        $query = $this->createQuery();
        $constraints = $this->getDefaultConstraints($query);

        if ($limit > 0) {
            $query->setLimit($limit);
        }

        $this->addTimeFrameConstraints(
            $constraints,
            $query,
            $arguments['startDate'] instanceof \DateTime ? DateTimeUtility::getDayStart($arguments['startDate'])->getTimestamp() : null,
            $arguments['endDate'] instanceof \DateTime ? DateTimeUtility::getDayEnd($arguments['endDate'])->getTimestamp() : null
        );

        if ($arguments['indexIds']) {
            $indexIds = [];
            $tabledIndexIds = [];
            foreach ($arguments['indexIds'] as $key => $indexId) {
                if (is_int($key)) {
                    // Plain integers (= deprecated old way, stays in for compatibility)
                    $indexIds[] = $indexId;
                } elseif (is_string($key) && is_array($indexId)) {
                    // Table based values with array of foreign uids
                    $tabledIndexIds[] = [
                        'table' => $key,
                        'indexIds' => $indexId
                    ];
                } elseif (is_string($key) && is_int($indexId)) {
                    // Table based single return value
                    $tabledIndexIds[] = [
                         'table' => $key,
                         'indexIds' => [$indexId]
                    ];
                }
            }
            $foreignIdConstraints = [];
            // Old way, just accept foreignUids as provided, not checking the table.
            // This has a caveat solved with the $tabledIndexIds
            if ( $indexIds ) {

The expression $indexIds of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                $foreignIdConstraints[] = $query->in('foreignUid', $indexIds);
            }
            if ( $tabledIndexIds ) {

The expression $tabledIndexIds of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                // Handle each table individually on the filters
                // allowing for uids to be table specific.
                // If 1,3,5 on table_a are ok and 4,5,7 on table_b are ok,
                // don't show uid 1 from table_b
                foreach ( $tabledIndexIds as $tabledIndexId ) {
                    if ( $tabledIndexId['indexIds'] ) {
                        // This table has used filters and returned some allowed uids.
                        // Providing non-existing values e.g.: -1 will remove everything
                        // unless other elements have found elements with the filters
                        $foreignIdConstraints[] = $query->logicalAnd([
                            $query->equals('foreignTable', $tabledIndexId['table']),
                            $query->in('foreignUid', $tabledIndexId['indexIds'])
                        ]);
                    }
                }
            }
            if ( count($foreignIdConstraints) > 1 ) {
                // Multiple valid tables should be grouped by "OR"
                // so it's either table_a with uids 1,3,4 OR table_b with uids 1,5,7
                $foreignIdConstraint = $query->logicalOr($foreignIdConstraints);
            } else {
                // Single constraint or no constraint should just be simply added
                $foreignIdConstraint = array_shift($foreignIdConstraints);
            }
            // If any foreignUid constraint survived, use it on the query
            if ( $foreignIdConstraint ) {
                $constraints[] = $foreignIdConstraint;
            }
        }
        if ($arguments['emptyPreResult']) {
            $constraints[] = $query->equals('uid', '-1');
        }
        $result = [
            'result' => $this->matchAndExecute($query, $constraints),
        ];

        $result = $this->callSignal(__CLASS__, __FUNCTION__ . 'Post', $result);

        return $result['result'];
    }