DERHANSEN\SfEventMgt\Domain\Repository\EventRepository

Complexity

Total Complexity

68

Size/Duplication

Total Lines	414
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

99.17%

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	initializeObject()	0	5	1
A	findDemanded()	0	35	2
A	setQueryLimitFromDemand()	0	9	4
A	setOrderingsFromDemand()	0	12	6
A	setDisplayModeConstraint()	0	21	4
B	setCategoryConstraint()	0	23	6
A	getCategoryConstraint()	0	19	5
A	setLocationConstraint()	0	6	3
A	setLocationCityConstraint()	0	6	3
A	setLocationCountryConstraint()	0	6	3
A	setSpeakerConstraint()	0	6	3
A	setOrganisatorConstraint()	0	6	3
A	setStoragePageConstraint()	0	7	3
B	setStartEndDateConstraint()	0	24	8
B	setSearchConstraint()	0	25	8
A	setTopEventConstraint()	0	6	2
A	setYearMonthDayRestriction()	0	25	4

<?php
namespace DERHANSEN\SfEventMgt\Domain\Repository;

/*
 * This file is part of the Extension "sf_event_mgt" for TYPO3 CMS.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 */

use DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand;
use DERHANSEN\SfEventMgt\Service\CategoryService;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\MathUtility;
use TYPO3\CMS\Extbase\Persistence\Generic\Typo3QuerySettings;
use TYPO3\CMS\Extbase\SignalSlot\Dispatcher;

/**
 * The repository for Events
 *
 * @author Torben Hansen <derhansen@gmail.com>
 */
class EventRepository extends \TYPO3\CMS\Extbase\Persistence\Repository
{
    /**
     * Set default sorting
     *
     * @var array
     */
    protected $defaultOrderings = [
        'startdate' => \TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_ASCENDING,
    ];

    /**
     * Disable the use of storage records, because the StoragePage can be set
     * in the plugin
     *
     * @return void
     */
    public function initializeObject()
    {
        $this->defaultQuerySettings = $this->objectManager->get(Typo3QuerySettings::class);
        $this->defaultQuerySettings->setRespectStoragePage(false);
    }

    /**
     * Returns the objects of this repository matching the given demand
     *
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface QueryResultInterface
     */
    public function findDemanded(EventDemand $eventDemand)
    {
        $constraints = [];
        $query = $this->createQuery();
        $this->setStoragePageConstraint($query, $eventDemand, $constraints);
        $this->setDisplayModeConstraint($query, $eventDemand, $constraints);
        $this->setCategoryConstraint($query, $eventDemand, $constraints);
        $this->setLocationConstraint($query, $eventDemand, $constraints);
        $this->setLocationCityConstraint($query, $eventDemand, $constraints);
        $this->setLocationCountryConstraint($query, $eventDemand, $constraints);
        $this->setSpeakerConstraint($query, $eventDemand, $constraints);
        $this->setOrganisatorConstraint($query, $eventDemand, $constraints);
        $this->setStartEndDateConstraint($query, $eventDemand, $constraints);
        $this->setSearchConstraint($query, $eventDemand, $constraints);
        $this->setTopEventConstraint($query, $eventDemand, $constraints);
        $this->setYearMonthDayRestriction($query, $eventDemand, $constraints);

        /** @var Dispatcher $signalSlotDispatcher */
        $signalSlotDispatcher = $this->objectManager->get(Dispatcher::class);
        $signalSlotDispatcher->dispatch(
            __CLASS__,
            __FUNCTION__ . 'ModifyQueryConstraints',
            [&$constraints, $query, $eventDemand, $this]
        );

        $this->setOrderingsFromDemand($query, $eventDemand);

        if (count($constraints) > 0) {
            $query->matching($query->logicalAnd($constraints));
        }

        $this->setQueryLimitFromDemand($query, $eventDemand);

        return $query->execute();
    }

    /**
     * Sets a query limit to the given query for the given demand
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
     *
     * @return void
     */
    protected function setQueryLimitFromDemand($query, EventDemand $eventDemand)
    {
        if ($eventDemand->getQueryLimit() != null &&
            MathUtility::canBeInterpretedAsInteger($eventDemand->getQueryLimit()) &&
            (int)$eventDemand->getQueryLimit() > 0
        ) {
            $query->setLimit((int)$eventDemand->getQueryLimit());
        }
    }

    /**
     * Sets the ordering to the given query for the given demand
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
     *
     * @return void
     */
    protected function setOrderingsFromDemand($query, EventDemand $eventDemand)
    {
        $orderings = [];
        $orderFieldAllowed = GeneralUtility::trimExplode(',', $eventDemand->getOrderFieldAllowed(), true);
        if ($eventDemand->getOrderField() != '' && $eventDemand->getOrderDirection() != '' &&
            !empty($orderFieldAllowed) && in_array($eventDemand->getOrderField(), $orderFieldAllowed, true)) {
            $orderings[$eventDemand->getOrderField()] = ((strtolower($eventDemand->getOrderDirection()) == 'desc') ?
                \TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_DESCENDING :
                \TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_ASCENDING);
            $query->setOrderings($orderings);
        }
    }

    /**
     * Sets the storagePage constraint to the given constraints array
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
     * @param array $constraints Constraints
     *
     * @return void
     */
    protected function setStoragePageConstraint($query, $eventDemand, &$constraints)
    {
        if ($eventDemand->getStoragePage() && $eventDemand->getStoragePage() !== '') {
            $pidList = GeneralUtility::intExplode(',', $eventDemand->getStoragePage(), true);
            $constraints[] = $query->in('pid', $pidList);
        }
    }

    /**
     * Sets the displayMode constraint to the given constraints array
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
     * @param array $constraints Constraints
     *
     * @return void
     */
    protected function setDisplayModeConstraint($query, $eventDemand, &$constraints)
    {
        switch ($eventDemand->getDisplayMode()) {
            case 'future':
                $constraints[] = $query->greaterThan('startdate', $eventDemand->getCurrentDateTime());
                break;
            case 'current_future':
                $constraints[] = $query->logicalOr([
                    $query->greaterThan('startdate', $eventDemand->getCurrentDateTime()),
                    $query->logicalAnd([
                        $query->greaterThanOrEqual('enddate', $eventDemand->getCurrentDateTime()),
                        $query->lessThanOrEqual('startdate', $eventDemand->getCurrentDateTime())
                    ])
                ]);
                break;
            case 'past':
                $constraints[] = $query->lessThanOrEqual('enddate', $eventDemand->getCurrentDateTime());
                break;
            default:
        }
    }

    /**
     * Sets the category constraint to the given constraints array
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
     * @param array $constraints Constraints
     *
     * @return void
     */
    protected function setCategoryConstraint($query, $eventDemand, &$constraints)
    {
        // If no category constraint is set, categories should not be respected in the query
        if ($eventDemand->getCategoryConjunction() === '') {
            return;
        }

        if ($eventDemand->getCategory() != '') {
            $categoryConstraints = [];
            if ($eventDemand->getIncludeSubcategories()) {
                $categoryList = CategoryService::getCategoryListWithChilds($eventDemand->getCategory());
                $categories = GeneralUtility::intExplode(',', $categoryList, true);
            } else {
                $categories = GeneralUtility::intExplode(',', $eventDemand->getCategory(), true);
            }
            foreach ($categories as $category) {
                $categoryConstraints[] = $query->contains('category', $category);
            }
            if (count($categoryConstraints) > 0) {
                $constraints[] = $this->getCategoryConstraint($query, $eventDemand, $categoryConstraints);
            }
        }
    }

    /**
     * Returns the category constraint depending on the category conjunction configured in eventDemand
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand
     * @param array $categoryConstraints
     * @return mixed
     */
    public function getCategoryConstraint($query, $eventDemand, $categoryConstraints)
    {
        switch (strtolower($eventDemand->getCategoryConjunction())) {
            case 'and':
                $constraint = $query->logicalAnd($categoryConstraints);
                break;
            case 'notor':
                $constraint = $query->logicalNot($query->logicalOr($categoryConstraints));
                break;
            case 'notand':
                $constraint = $query->logicalNot($query->logicalAnd($categoryConstraints));
                break;
            case 'or':
            default:
                $constraint = $query->logicalOr($categoryConstraints);
        }

        return $constraint;
    }

    /**
     * Sets the location constraint to the given constraints array
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
     * @param array $constraints Constraints
     *
     * @return void
     */
    protected function setLocationConstraint($query, $eventDemand, &$constraints)
    {
        if ($eventDemand->getLocation() !== null && $eventDemand->getLocation() != '') {
            $constraints[] = $query->equals('location', $eventDemand->getLocation());
        }
    }

    /**
     * Sets the location.city constraint to the given constraints array
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
     * @param array $constraints Constraints
     *
     * @return void
     */
    protected function setLocationCityConstraint($query, $eventDemand, &$constraints)
    {
        if ($eventDemand->getLocationCity() !== null && $eventDemand->getLocationCity() != '') {
            $constraints[] = $query->equals('location.city', $eventDemand->getLocationCity());
        }
    }

    /**
     * Sets the location.country constraint to the given constraints array
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
     * @param array $constraints Constraints
     *
     * @return void
     */
    protected function setLocationCountryConstraint($query, $eventDemand, &$constraints)
    {
        if ($eventDemand->getLocationCountry() !== null && $eventDemand->getLocationCountry() != '') {
            $constraints[] = $query->equals('location.country', $eventDemand->getLocationCountry());
        }
    }

    /**
     * Sets the speaker constraint to the given constraints array
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
     * @param array $constraints Constraints
     *
     * @return void
     */
    protected function setSpeakerConstraint($query, $eventDemand, &$constraints)
    {
        if ($eventDemand->getSpeaker() !== null && $eventDemand->getSpeaker() != '') {
            $constraints[] = $query->contains('speaker', $eventDemand->getSpeaker());
        }
    }

    /**
     * Sets the organisator constraint to the given constraints array
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
     * @param array $constraints Constraints
     *
     * @return void
     */
    protected function setOrganisatorConstraint($query, $eventDemand, &$constraints)
    {
        if ($eventDemand->getOrganisator() !== null && $eventDemand->getOrganisator() != '') {
            $constraints[] = $query->equals('organisator', $eventDemand->getOrganisator());
        }
    }

    /**
     * Sets the start- and enddate constraint to the given constraints array
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
     * @param array $constraints Constraints
     *
     * @return void
     */
    protected function setStartEndDateConstraint($query, $eventDemand, &$constraints)
    {
        if ($eventDemand->getSearchDemand() && $eventDemand->getSearchDemand()->getStartDate() !== null &&
            $eventDemand->getSearchDemand()->getEndDate() !== null
        ) {
            /* StartDate and EndDate  - Search for events between two given dates */
            $begin = $eventDemand->getSearchDemand()->getStartDate();
            $end = $eventDemand->getSearchDemand()->getEndDate();
            $constraints[] = $query->logicalOr([
                $query->between('startdate', $begin, $end),
                $query->between('enddate', $begin, $end),
                $query->logicalAnd([
                    $query->greaterThanOrEqual('enddate', $begin),
                    $query->lessThanOrEqual('startdate', $begin)
                ])
            ]);
        } elseif ($eventDemand->getSearchDemand() && $eventDemand->getSearchDemand()->getStartDate() !== null) {
            /* StartDate - Search for events beginning at a given date */
            $constraints[] = $query->greaterThanOrEqual('startdate', $eventDemand->getSearchDemand()->getStartDate());
        } elseif ($eventDemand->getSearchDemand() && $eventDemand->getSearchDemand()->getEndDate() !== null) {
            /* EndDate - Search for events ending on a given date */
            $constraints[] = $query->lessThanOrEqual('enddate', $eventDemand->getSearchDemand()->getEndDate());
        }
    }

    /**
     * Sets the search constraint to the given constraints array
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
     * @param array $constraints Constraints
     *
     * @return void
     */
    protected function setSearchConstraint($query, $eventDemand, &$constraints)
    {
        if ($eventDemand->getSearchDemand() &&
            $eventDemand->getSearchDemand()->getSearch() !== null &&
            $eventDemand->getSearchDemand()->getSearch() !== ''
        ) {
            $searchFields = GeneralUtility::trimExplode(',', $eventDemand->getSearchDemand()->getFields(), true);
            $searchConstraints = [];

            if (count($searchFields) === 0) {
                throw new \UnexpectedValueException('No search fields defined', 1318497755);
            }

            $searchSubject = $eventDemand->getSearchDemand()->getSearch();
            foreach ($searchFields as $field) {
                if (!empty($searchSubject)) {
                    $searchConstraints[] = $query->like($field, '%' . addcslashes($searchSubject, '_%') . '%', false);

The call to QueryInterface::like() has too many arguments starting with false.

                }
            }

            if (count($searchConstraints)) {
                $constraints[] = $query->logicalOr($searchConstraints);
            }
        }
    }

    /**
     * Sets the topEvent constraint to the given constraints array
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
     * @param array $constraints Constraints
     *
     * @return void
     */
    protected function setTopEventConstraint($query, $eventDemand, &$constraints)
    {
        if ($eventDemand->getTopEventRestriction() > 0) {
            $constraints[] = $query->equals('topEvent', (bool)($eventDemand->getTopEventRestriction() - 1));
        }
    }

    /**
     * Sets the restriction for year, year/month or year/month/day to the given constraints array
     *
     * @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query
     * @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand
     * @param array $constraints
     *
     * @return void
     */
    protected function setYearMonthDayRestriction($query, $eventDemand, &$constraints)
    {
        if ($eventDemand->getYear() > 0) {
            if ($eventDemand->getMonth() > 0) {
                if ($eventDemand->getDay() > 0) {
                    $begin = mktime(0, 0, 0, $eventDemand->getMonth(), $eventDemand->getDay(), $eventDemand->getYear());
                    $end = mktime(23, 59, 59, $eventDemand->getMonth(), $eventDemand->getDay(), $eventDemand->getYear());
                } else {
                    $begin = mktime(0, 0, 0, $eventDemand->getMonth(), 1, $eventDemand->getYear());
                    $end = mktime(23, 59, 59, ($eventDemand->getMonth() + 1), 0, $eventDemand->getYear());
                }
            } else {
                $begin = mktime(0, 0, 0, 1, 1, $eventDemand->getYear());
                $end = mktime(23, 59, 59, 12, 31, $eventDemand->getYear());
            }
            $constraints[] = $query->logicalOr([
                $query->between('startdate', $begin, $end),
                $query->between('enddate', $begin, $end),
                $query->logicalAnd([
                    $query->greaterThanOrEqual('enddate', $begin),
                    $query->lessThanOrEqual('startdate', $begin)
                ])
            ]);
        }
    }
}