HDNET\Calendarize\Domain\Repository\IndexRepository

Complexity

Total Complexity

75

Size/Duplication

Total Lines	754
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes

0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	setIndexTypes()	0	4	1
A	setOverridePageIds()	0	4	1
A	findList()	0	31	5
A	createQuery()	0	6	1
A	findAllForBackend()	0	28	3
D	findBySearch()	0	94	18
A	findByPast()	0	17	2
B	findByTraversing()	0	35	7
B	findByEventTraversing()	0	39	7
A	findYear()	0	4	1
A	findQuarter()	0	6	1
A	findMonth()	0	7	1
A	findWeek()	0	11	1
A	findDifferentTypesAndLocations()	0	6	1
A	findDay()	0	10	1
A	setDefaultSortingDirection()	0	4	1
A	findByTimeSlot()	0	15	2
A	findByEvent()	0	13	1
A	getStoragePageIds()	0	21	5
A	getDefaultConstraints()	0	25	4
B	addTimeFrameConstraints()	0	27	6
A	addDateTimeFrameConstraints()	0	41	1
A	addDateFrameConstraints()	0	41	1
A	getSorting()	0	18	3

<?php

/**
 * Index repository.
 */
declare(strict_types=1);

namespace HDNET\Calendarize\Domain\Repository;

use Exception;
use function gmmktime;
use HDNET\Calendarize\Domain\Model\Index;
use HDNET\Calendarize\Domain\Model\Request\OptionRequest;
use HDNET\Calendarize\Utility\ConfigurationUtility;
use HDNET\Calendarize\Utility\DateTimeUtility;
use HDNET\Calendarize\Utility\ExtensionConfigurationUtility;
use TYPO3\CMS\Core\Database\ConnectionPool;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Configuration\BackendConfigurationManager;
use TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
use TYPO3\CMS\Extbase\DomainObject\DomainObjectInterface;
use TYPO3\CMS\Extbase\Persistence\QueryInterface;

/**
 * Index repository.
 */
class IndexRepository extends AbstractRepository
{
    /**
     * Default orderings for index records.
     *
     * @var array
     */
    protected $defaultOrderings = [
        'start_date' => QueryInterface::ORDER_ASCENDING,
        'start_time' => QueryInterface::ORDER_ASCENDING,
    ];

    /**
     * Index types for selection.
     *
     * @var array
     */
    protected $indexTypes = [];

    /**
     * Override page ids.
     *
     * @var array
     */
    protected $overridePageIds;

    /**
     * Create query.
     *
     * @return QueryInterface
     */
    public function createQuery()
    {
        $query = parent::createQuery();

        return $query;
    }

    /**
     * Set the index types.
     *
     * @param array $types
     */
    public function setIndexTypes(array $types)
    {
        $this->indexTypes = $types;
    }

    /**
     * Override page IDs.
     *
     * @param array $overridePageIds
     */
    public function setOverridePageIds($overridePageIds)
    {
        $this->overridePageIds = $overridePageIds;
    }

    /**
     * Select indecies for Backend.
     *
     * @param OptionRequest $options
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function findAllForBackend(OptionRequest $options)
    {
        $query = $this->createQuery();
        $query->getQuerySettings()->setIgnoreEnableFields(true);
        $query->getQuerySettings()->setRespectSysLanguage(false);
        $query->getQuerySettings()->setLanguageOverlayMode(false);

        // Notice Selection without any language handling
        unset($GLOBALS['TCA']['tx_calendarize_domain_model_index']['ctrl']['languageField'], $GLOBALS['TCA']['tx_calendarize_domain_model_index']['ctrl']['transOrigPointerField']);

        if ('asc' === $options->getDirection()) {
            $query->setOrderings([
                'start_date' => QueryInterface::ORDER_ASCENDING,
                'start_time' => QueryInterface::ORDER_ASCENDING,
            ]);
        } else {
            $query->setOrderings([
                'start_date' => QueryInterface::ORDER_DESCENDING,
                'start_time' => QueryInterface::ORDER_DESCENDING,
            ]);
        }

        if ((int)$options->getPid() > 0) {
            $query->matching($query->equals('pid', (int)$options->getPid()));
        }

        return $query->execute();
    }

    /**
     * Find List.
     *
     * @param int        $limit
     * @param int|string $listStartTime
     * @param int        $startOffsetHours
     * @param int        $overrideStartDate
     * @param int        $overrideEndDate
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function findList(
        $limit = 0,
        $listStartTime = 0,
        $startOffsetHours = 0,
        $overrideStartDate = 0,
        $overrideEndDate = 0
    ) {
        if ($overrideStartDate > 0) {
            $startTimestamp = $overrideStartDate;
        } else {
            $now = DateTimeUtility::getNow();
            if ('now' !== $listStartTime) {

The strict comparison !== seems to always evaluate to true as the types of 'now' (string) and $listStartTime (integer) can never be identical. Maybe you want to use a loose comparison != instead?

                $now->setTime(0, 0, 0);
            }
            $now->modify($startOffsetHours . ' hours');
            $startTimestamp = $now->getTimestamp();
        }
        $endTimestamp = null;
        if ($overrideEndDate > 0) {
            $endTimestamp = $overrideEndDate;
        }

        $result = $this->findByTimeSlot($startTimestamp, $endTimestamp);
        if ($limit > 0) {
            $query = $result->getQuery();
            $query->setLimit($limit);
            $result = $query->execute();
        }

        return $result;
    }

    /**
     * Find by custom search.
     *
     * @param \DateTime $startDate
     * @param \DateTime $endDate
     * @param array     $customSearch
     * @param int       $limit
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    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'];
    }

    /**
     * Find Past Events.
     *
     * @param int    $limit
     * @param string $sort
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function findByPast(
        $limit,
        $sort
    ) {
        //create Query
        $query = $this->createQuery();
        //Get actual datetime
        $now = DateTimeUtility::getNow();

        $constraints = $this->getDefaultConstraints($query);
        $constraints[] = $query->lessThanOrEqual('startDate', $now->format('Y-m-d'));
        $sort = QueryInterface::ORDER_ASCENDING === $sort ? QueryInterface::ORDER_ASCENDING : QueryInterface::ORDER_DESCENDING;
        $query->setOrderings($this->getSorting($sort));
        $query->setLimit($limit);

        return $this->matchAndExecute($query, $constraints);
    }

    /**
     * Find by traversing information.
     *
     * @param Index      $index
     * @param bool|true  $future
     * @param bool|false $past
     * @param int        $limit
     * @param string     $sort
     * @param bool       $useIndexTime
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function findByTraversing(
        Index $index,
        $future = true,
        $past = false,
        $limit = 100,
        $sort = QueryInterface::ORDER_ASCENDING,
        $useIndexTime = false
    ) {
        if (!$future && !$past) {
            return [];
        }
        $query = $this->createQuery();

        $now = DateTimeUtility::getNow();
        if ($useIndexTime) {
            $now = $index->getStartDate();
        }

        $constraints = [];
        $constraints[] = $query->logicalNot($query->equals('uid', $index->getUid()));
        $constraints[] = $query->equals('foreignTable', $index->getForeignTable());
        $constraints[] = $query->equals('foreignUid', $index->getForeignUid());
        if (!$future) {
            $constraints[] = $query->lessThanOrEqual('startDate', $now->format('Y-m-d'));
        }
        if (!$past) {
            $constraints[] = $query->greaterThanOrEqual('startDate', $now->format('Y-m-d'));
        }

        $query->setLimit($limit);
        $sort = QueryInterface::ORDER_ASCENDING === $sort ? QueryInterface::ORDER_ASCENDING : QueryInterface::ORDER_DESCENDING;
        $query->setOrderings($this->getSorting($sort));

        return $this->matchAndExecute($query, $constraints);
    }

    /**
     * Find by traversing information.
     *
     * @param DomainObjectInterface $event
     * @param bool|true             $future
     * @param bool|false            $past
     * @param int                   $limit
     * @param string                $sort
     *
     * @throws Exception
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function findByEventTraversing(
        DomainObjectInterface $event,
        $future = true,
        $past = false,
        $limit = 100,
        $sort = QueryInterface::ORDER_ASCENDING
    ) {
        if (!$future && !$past) {
            return [];
        }
        $query = $this->createQuery();

        $uniqueRegisterKey = ExtensionConfigurationUtility::getUniqueRegisterKeyForModel($event);

        $this->setIndexTypes([$uniqueRegisterKey]);

        $now = DateTimeUtility::getNow()
            ->getTimestamp();

        $constraints = [];

        $localizedUid = $event->_getProperty('_localizedUid');
        $selectUid = $localizedUid ? $localizedUid : $event->getUid();

        $constraints[] = $query->equals('foreignUid', $selectUid);
        $constraints[] = $query->in('uniqueRegisterKey', $this->indexTypes);
        if (!$future) {
            $constraints[] = $query->lessThanOrEqual('startDate', $now);
        }
        if (!$past) {
            $constraints[] = $query->greaterThanOrEqual('startDate', $now);
        }

        $query->setLimit($limit);
        $sort = QueryInterface::ORDER_ASCENDING === $sort ? QueryInterface::ORDER_ASCENDING : QueryInterface::ORDER_DESCENDING;
        $query->setOrderings($this->getSorting($sort));

        return $this->matchAndExecute($query, $constraints);
    }

    /**
     * find Year.
     *
     * @param int $year
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function findYear(int $year)
    {
        return $this->findByTimeSlot(gmmktime(0, 0, 0, 1, 1, $year), gmmktime(0, 0, 0, 1, 1, $year + 1) - 1);
    }

    /**
     * find quarter.
     *
     * @param int $year
     * @param int $quarter
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function findQuarter(int $year, int $quarter)
    {
        $startMonth = 1 + (3 * ($quarter - 1));

        return $this->findByTimeSlot(gmmktime(0, 0, 0, $startMonth, 1, $year), gmmktime(0, 0, 0, $startMonth + 3, 1, $year) - 1);
    }

    /**
     * find Month.
     *
     * @param int $year
     * @param int $month
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function findMonth(int $year, int $month)
    {
        $startTime = gmmktime(0, 0, 0, $month, 1, $year);
        $endTime = gmmktime(0, 0, 0, $month + 1, 1, $year) - 1;

        return $this->findByTimeSlot($startTime, $endTime);
    }

    /**
     * find Week.
     *
     * @param int $year
     * @param int $week
     * @param int $weekStart See documentation for settings.weekStart
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function findWeek($year, $week, $weekStart = 1)
    {
        $firstDayLocal = DateTimeUtility::convertWeekYear2DayMonthYear($week, $year, $weekStart);
        // Convert local date to utc date
        $firstDay = new \Datetime($firstDayLocal->format('Y-m-d'), DateTimeUtility::getUtcTimeZone());
        $endDate = clone $firstDay;
        $endDate->modify('+1 week');
        $endDate->modify('-1 second');

        return $this->findByTimeSlot($firstDay->getTimestamp(), $endDate->getTimestamp());
    }

    /**
     * Find different types and locations.
     *
     * @return array
     */
    public function findDifferentTypesAndLocations(): array
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('tx_calendarize_domain_model_index');

        return (array)$queryBuilder->select('unique_register_key', 'pid', 'foreign_table')->from('tx_calendarize_domain_model_index')->groupBy('pid', 'foreign_table', 'unique_register_key')->execute()->fetchAll();
    }

    /**
     * find day.
     *
     * @param int $year
     * @param int $month
     * @param int $day
     *
     * @throws Exception
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function findDay(int $year, int $month, int $day)
    {
        $startTime = gmmktime(0, 0, 0, $month, $day, $year);
        $startDate = new \DateTime('@' . $startTime);
        $endDate = clone $startDate;
        $endDate->modify('+1 day');
        $endDate->modify('-1 second');

        return $this->findByTimeSlot($startDate->getTimestamp(), $endDate->getTimestamp());
    }

    /**
     * Set the default sorting direction.
     *
     * @param string $direction
     * @param string $field
     */
    public function setDefaultSortingDirection($direction, $field = '')
    {
        $this->defaultOrderings = $this->getSorting($direction, $field);
    }

    /**
     * Find by time slot.
     *
     * @param int      $startTime
     * @param int|null $endTime   null means open end
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function findByTimeSlot($startTime, $endTime = null)
    {
        $query = $this->createQuery();
        $constraints = $this->getDefaultConstraints($query);
        $this->addTimeFrameConstraints($constraints, $query, $startTime, $endTime);

        $arguments = [
            'constraints' => $constraints,
            'query' => $query,
        ];
        $arguments = $this->callSignal(__CLASS__, __FUNCTION__, $arguments);
        $constraints = $arguments['constraints'] ?: $constraints;

        return $this->matchAndExecute($query, $constraints);
    }

    /**
     * Find all indices by the given Event model.
     *
     * @param DomainObjectInterface $event
     *
     * @throws Exception
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function findByEvent(DomainObjectInterface $event)
    {
        $query = $this->createQuery();

        $uniqueRegisterKey = ExtensionConfigurationUtility::getUniqueRegisterKeyForModel($event);

        $this->setIndexTypes([$uniqueRegisterKey]);
        $constraints = $this->getDefaultConstraints($query);
        $constraints[] = $query->equals('foreignUid', $event->getUid());
        $query->matching($query->logicalAnd($constraints));

        return $query->execute();
    }

    /**
     * storage page selection.
     *
     * @return array
     */
    protected function getStoragePageIds()
    {
        if (null !== $this->overridePageIds) {
            return $this->overridePageIds;
        }

        $configurationManager = $this->objectManager->get(ConfigurationManagerInterface::class);

The method TYPO3\CMS\Extbase\Object\ObjectManagerInterface::get() has been deprecated with message: since TYPO3 10.4, will be removed in version 12.0

        $frameworkConfig = $configurationManager->getConfiguration(ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK);
        $storagePages = isset($frameworkConfig['persistence']['storagePid']) ? GeneralUtility::intExplode(
            ',',
            $frameworkConfig['persistence']['storagePid']
        ) : [];
        if (!empty($storagePages)) {
            return $storagePages;
        }
        if ($frameworkConfig instanceof BackendConfigurationManager) {
            return GeneralUtility::trimExplode(',', $frameworkConfig->getDefaultBackendStoragePid(), true);
        }

        return $storagePages;
    }

    /**
     * Get the default constraint for the queries.
     *
     * @param QueryInterface $query
     *
     * @return array
     */
    protected function getDefaultConstraints(QueryInterface $query)
    {
        $constraints = [];
        if (!empty($this->indexTypes)) {
            $indexTypes = $this->indexTypes;
            $constraints[] = $query->in('uniqueRegisterKey', $indexTypes);
        }

        $storagePages = $this->getStoragePageIds();
        if (!empty($storagePages)) {
            $constraints[] = $query->in('pid', $storagePages);
        }

        $arguments = [
            'indexIds' => [],
            'indexTypes' => $this->indexTypes,
        ];
        $arguments = $this->callSignal(__CLASS__, __FUNCTION__, $arguments);

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

        return $constraints;
    }

    /**
     * Add time frame related queries.
     *
     * @param array          $constraints
     * @param QueryInterface $query
     * @param int            $startTime
     * @param int|null       $endTime
     *
     * @see IndexUtility::isIndexInRange
     */
    protected function addTimeFrameConstraints(&$constraints, QueryInterface $query, $startTime = null, $endTime = null)
    {
        $arguments = [
            'constraints' => &$constraints,
            'query' => $query,
            'startTime' => $startTime,
            'endTime' => $endTime,
        ];
        $arguments = $this->callSignal(__CLASS__, __FUNCTION__, $arguments);

        if (null === $arguments['startTime'] && null === $arguments['endTime']) {
            return;
        }
        if (null === $arguments['startTime']) {
            // Simulate start time
            $arguments['startTime'] = DateTimeUtility::getNow()->getTimestamp() - DateTimeUtility::SECONDS_DECADE;
        } elseif (null === $arguments['endTime']) {
            // Simulate end time
            $arguments['endTime'] = DateTimeUtility::getNow()->getTimestamp() + DateTimeUtility::SECONDS_DECADE;
        }

        if ((bool)ConfigurationUtility::get('respectTimesInTimeFrameConstraints')) {
            $this->addDateTimeFrameConstraints($constraints, $query, $arguments);
        } else {
            $this->addDateFrameConstraints($constraints, $query, $arguments);
        }
    }

    /**
     * Adds time frame constraints which respect the actual index times.
     * Do not call this method directly. Call IndexRepository::addTimeFrameConstraints instead.
     *
     * @param array          $constraints
     * @param QueryInterface $query
     * @param array          $arguments
     *
     * @see IndexRepository::addTimeFrameConstraints
     */
    protected function addDateTimeFrameConstraints(&$constraints, QueryInterface $query, array $arguments)
    {
        $timezone = DateTimeUtility::getUtcTimeZone();

        // store values for start_date and start_time in separate variables
        $startDateTime = new \DateTime('@' . $arguments['startTime'], $timezone);
        $restrictionLowTime = DateTimeUtility::getDaySecondsOfDateTime($startDateTime);
        $restrictionLowDay = DateTimeUtility::resetTime($startDateTime)->format('Y-m-d');

        // store values for end_date and end_time in separate variables
        $endDateTime = new \DateTime('@' . $arguments['endTime'], $timezone);
        $restrictionHighTime = DateTimeUtility::getDaySecondsOfDateTime($endDateTime);
        $restrictionHighDay = DateTimeUtility::resetTime($endDateTime)->format('Y-m-d');

        $constraints[] = $query->logicalAnd([
            // (end_date === restrictionLowDay && end_time >= restrictionLowTime) || end_date > restrictionLowDay || (all_day === true && end_date >= restrictionLowDay)
            $query->logicalOr([
                $query->logicalAnd([
                    $query->equals('endDate', $restrictionLowDay),
                    $query->greaterThanOrEqual('endTime', $restrictionLowTime),
                ]),
                $query->greaterThan('endDate', $restrictionLowDay),
                $query->logicalAnd([
                    $query->equals('allDay', true),
                    $query->greaterThanOrEqual('endDate', $restrictionLowDay),
                ]),
            ]),
            // (start_date === restrictionHighDay && start_time <= restrictionHighTime) || start_date < restrictionHighDay || (all_day === true && start_date <= restrictionHighDay)
            $query->logicalOr([
                $query->logicalAnd([
                    $query->equals('startDate', $restrictionHighDay),
                    $query->lessThanOrEqual('startTime', $restrictionHighTime),
                ]),
                $query->lessThan('startDate', $restrictionHighDay),
                $query->logicalAnd([
                    $query->equals('allDay', true),
                    $query->lessThanOrEqual('startDate', $restrictionHighDay),
                ]),
            ]),
        ]);
    }

    /**
     * Adds time frame constraints which respect only the index dates, not the actual index times.
     * Do not call this method directly. Call IndexRepository::addTimeFrameConstraints instead.
     *
     * @param array          $constraints
     * @param QueryInterface $query
     * @param array          $arguments
     *
     * @see IndexRepository::addTimeFrameConstraints
     */
    protected function addDateFrameConstraints(&$constraints, QueryInterface $query, array $arguments)
    {
        $orConstraint = [];

        // DateTimeUtility::getTimeZone() ?!
        $startDate = (new \DateTime('@' . $arguments['startTime']))->format('Y-m-d');
        $endDate = (new \DateTime('@' . $arguments['endTime']))->format('Y-m-d');

        // before - in
        $beforeIn = [
            $query->lessThan('startDate', $startDate),
            $query->greaterThanOrEqual('endDate', $startDate),
            $query->lessThan('endDate', $endDate),
        ];
        $orConstraint[] = $query->logicalAnd($beforeIn);

        // in - in
        $inIn = [
            $query->greaterThanOrEqual('startDate', $startDate),
            $query->lessThanOrEqual('endDate', $endDate),
        ];
        $orConstraint[] = $query->logicalAnd($inIn);

        // in - after
        $inAfter = [
            $query->greaterThanOrEqual('startDate', $startDate),
            $query->lessThan('startDate', $endDate),
            $query->greaterThanOrEqual('endDate', $endDate),
        ];
        $orConstraint[] = $query->logicalAnd($inAfter);

        // before - after
        $beforeAfter = [
            $query->lessThan('startDate', $startDate),
            $query->greaterThan('endDate', $endDate),
        ];
        $orConstraint[] = $query->logicalAnd($beforeAfter);

        // finish
        $constraints[] = $query->logicalOr($orConstraint);
    }

    /**
     * Get the sorting.
     *
     * @param string $direction
     * @param string $field
     *
     * @return array
     */
    protected function getSorting($direction, $field = '')
    {
        if ('withrangelast' === $field) {
            return [
                'endDate' => $direction,
                'startDate' => $direction,
                'startTime' => $direction,
            ];
        }
        if ('end' !== $field) {
            $field = 'start';
        }

        return [
            $field . 'Date' => $direction,
            $field . 'Time' => $direction,
        ];
    }
}