EventRepository::initializeObject() - Code Metrics - Inspection of "[TASK] Add "speaker" to searchDemand" - derhansen/sf_event_mgt - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — development ( 3f7d20...b27959 )

by Torben

created 2018-09-04 13:56 UTC

EventRepository::initializeObject() A

↳ Parent: EventRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	5
rs	10
c	0
b	0
f	0
ccs	0
cts	0
cp	0
cc	1
nc	1
nop	0
crap	2

<?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 <[email protected]>
 */
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() != '') {
            $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->equals('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)
    {
        /* StartDate */
        if ($eventDemand->getSearchDemand() && $eventDemand->getSearchDemand()->getStartDate() !== null) {
            $constraints[] = $query->greaterThanOrEqual('startdate', $eventDemand->getSearchDemand()->getStartDate());
        }

        /* EndDate */
        if ($eventDemand->getSearchDemand() && $eventDemand->getSearchDemand()->getEndDate() !== null) {
            $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);
                }
            }

            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)
                ])
            ]);
        }
    }
}


1		<?php
2		namespace DERHANSEN\SfEventMgt\Domain\Repository;
3
4		/*
5		* This file is part of the Extension "sf_event_mgt" for TYPO3 CMS.
6		*
7		* For the full copyright and license information, please read the
8		* LICENSE.txt file that was distributed with this source code.
9		*/
10
11		use DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand;
12		use DERHANSEN\SfEventMgt\Service\CategoryService;
13		use TYPO3\CMS\Core\Utility\GeneralUtility;
14		use TYPO3\CMS\Core\Utility\MathUtility;
15		use TYPO3\CMS\Extbase\Persistence\Generic\Typo3QuerySettings;
16		use TYPO3\CMS\Extbase\SignalSlot\Dispatcher;
17
18		/**
19		* The repository for Events
20		*
21		* @author Torben Hansen <[email protected]>
22		*/
23		class EventRepository extends \TYPO3\CMS\Extbase\Persistence\Repository
24		{
25		/**
26		* Set default sorting
27		*
28		* @var array
29		*/
30		protected $defaultOrderings = [
31		'startdate' => \TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_ASCENDING,
32		];
33
34		/**
35		* Disable the use of storage records, because the StoragePage can be set
36		* in the plugin
37		*
38		* @return void
39		*/
40		public function initializeObject()
41		{
42		$this->defaultQuerySettings = $this->objectManager->get(Typo3QuerySettings::class);
43		$this->defaultQuerySettings->setRespectStoragePage(false);
44		}
45	31
46		/**
47	31	* Returns the objects of this repository matching the given demand
48	31	*
49	31	* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
50		*
51		* @return array\|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface QueryResultInterface
52		*/
53		public function findDemanded(EventDemand $eventDemand)
54		{
55		$constraints = [];
56		$query = $this->createQuery();
57		$this->setStoragePageConstraint($query, $eventDemand, $constraints);
58	30	$this->setDisplayModeConstraint($query, $eventDemand, $constraints);
59		$this->setCategoryConstraint($query, $eventDemand, $constraints);
60	30	$this->setLocationConstraint($query, $eventDemand, $constraints);
61	30	$this->setLocationCityConstraint($query, $eventDemand, $constraints);
62	30	$this->setLocationCountryConstraint($query, $eventDemand, $constraints);
63	30	$this->setSpeakerConstraint($query, $eventDemand, $constraints);
64	30	$this->setOrganisatorConstraint($query, $eventDemand, $constraints);
65	30	$this->setStartEndDateConstraint($query, $eventDemand, $constraints);
66	30	$this->setSearchConstraint($query, $eventDemand, $constraints);
67	30	$this->setTopEventConstraint($query, $eventDemand, $constraints);
68	30	$this->setYearMonthDayRestriction($query, $eventDemand, $constraints);
69	30
70	30	/** @var Dispatcher $signalSlotDispatcher */
71	30	$signalSlotDispatcher = $this->objectManager->get(Dispatcher::class);
72		$signalSlotDispatcher->dispatch(
73	30	__CLASS__,
74	30	__FUNCTION__ . 'ModifyQueryConstraints',
75	30	[&$constraints, $query, $eventDemand, $this]
76		);
77	30
78	30	$this->setOrderingsFromDemand($query, $eventDemand);
79
80		if (count($constraints) > 0) {
81		$query->matching($query->logicalAnd($constraints));
82		}
83
84		$this->setQueryLimitFromDemand($query, $eventDemand);
85
86		return $query->execute();
87		}
88
89	30	/**
90		* Sets a query limit to the given query for the given demand
91	30	*
92	30	* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
93	1	* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
94	30	*
95	1	* @return void
96	1	*/
97	30	protected function setQueryLimitFromDemand($query, EventDemand $eventDemand)
98		{
99		if ($eventDemand->getQueryLimit() != null &&
100		MathUtility::canBeInterpretedAsInteger($eventDemand->getQueryLimit()) &&
101		(int)$eventDemand->getQueryLimit() > 0
102		) {
103		$query->setLimit((int)$eventDemand->getQueryLimit());
104		}
105		}
106
107	30	/**
108		* Sets the ordering to the given query for the given demand
109	30	*
110	30	* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
111	6	* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
112	6	*
113	3	* @return void
114	6	*/
115	6	protected function setOrderingsFromDemand($query, EventDemand $eventDemand)
116	30	{
117		$orderings = [];
118		$orderFieldAllowed = GeneralUtility::trimExplode(',', $eventDemand->getOrderFieldAllowed(), true);
119		if ($eventDemand->getOrderField() != '' && $eventDemand->getOrderDirection() != '' &&
120		!empty($orderFieldAllowed) && in_array($eventDemand->getOrderField(), $orderFieldAllowed, true)) {
121		$orderings[$eventDemand->getOrderField()] = ((strtolower($eventDemand->getOrderDirection()) == 'desc') ?
122		\TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_DESCENDING :
123		\TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_ASCENDING);
124		$query->setOrderings($orderings);
125		}
126		}
127	30
128		/**
129	30	* Sets the storagePage constraint to the given constraints array
130	30	*
131	30	* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
132	30	* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
133	30	* @param array $constraints Constraints
134		*
135		* @return void
136		*/
137		protected function setStoragePageConstraint($query, $eventDemand, &$constraints)
138		{
139		if ($eventDemand->getStoragePage() != '') {
140		$pidList = GeneralUtility::intExplode(',', $eventDemand->getStoragePage(), true);
141		$constraints[] = $query->in('pid', $pidList);
142		}
143		}
144	30
145		/**
146	30	* Sets the displayMode constraint to the given constraints array
147	30	*
148	1	* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
149	1	* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
150	29	* @param array $constraints Constraints
151	1	*
152	1	* @return void
153	28	*/
154	30	protected function setDisplayModeConstraint($query, $eventDemand, &$constraints)
155	30	{
156		switch ($eventDemand->getDisplayMode()) {
157		case 'future':
158		$constraints[] = $query->greaterThan('startdate', $eventDemand->getCurrentDateTime());
159		break;
160		case 'current_future':
161		$constraints[] = $query->logicalOr([
162		$query->greaterThan('startdate', $eventDemand->getCurrentDateTime()),
163		$query->logicalAnd([
164		$query->greaterThanOrEqual('enddate', $eventDemand->getCurrentDateTime()),
165		$query->lessThanOrEqual('startdate', $eventDemand->getCurrentDateTime())
166	30	])
167		]);
168	30	break;
169	5	case 'past':
170	5	$constraints[] = $query->lessThanOrEqual('enddate', $eventDemand->getCurrentDateTime());
171	1	break;
172	1	default:
173	1	}
174	4	}
175
176	5	/**
177	5	* Sets the category constraint to the given constraints array
178	5	*
179	5	* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
180	5	* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
181	5	* @param array $constraints Constraints
182	5	*
183	30	* @return void
184		*/
185		protected function setCategoryConstraint($query, $eventDemand, &$constraints)
186		{
187		// If no category constraint is set, categories should not be respected in the query
188		if ($eventDemand->getCategoryConjunction() === '') {
189		return;
190		}
191
192		if ($eventDemand->getCategory() != '') {
193		$categoryConstraints = [];
194	30	if ($eventDemand->getIncludeSubcategories()) {
195		$categoryList = CategoryService::getCategoryListWithChilds($eventDemand->getCategory());
196	30	$categories = GeneralUtility::intExplode(',', $categoryList, true);
197	3	} else {
198	3	$categories = GeneralUtility::intExplode(',', $eventDemand->getCategory(), true);
199	30	}
200		foreach ($categories as $category) {
201		$categoryConstraints[] = $query->contains('category', $category);
202		}
203		if (count($categoryConstraints) > 0) {
204		$constraints[] = $this->getCategoryConstraint($query, $eventDemand, $categoryConstraints);
205		}
206		}
207		}
208
209		/**
210	30	* Returns the category constraint depending on the category conjunction configured in eventDemand
211		*
212	30	* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query
213	2	* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand
214	2	* @param array $categoryConstraints
215	30	* @return mixed
216		*/
217		public function getCategoryConstraint($query, $eventDemand, $categoryConstraints)
218		{
219		switch (strtolower($eventDemand->getCategoryConjunction())) {
220		case 'and':
221		$constraint = $query->logicalAnd($categoryConstraints);
222		break;
223		case 'notor':
224		$constraint = $query->logicalNot($query->logicalOr($categoryConstraints));
225		break;
226	30	case 'notand':
227		$constraint = $query->logicalNot($query->logicalAnd($categoryConstraints));
228	30	break;
229	2	case 'or':
230	2	default:
231	30	$constraint = $query->logicalOr($categoryConstraints);
232		}
233
234		return $constraint;
235		}
236
237		/**
238		* Sets the location constraint to the given constraints array
239		*
240		* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
241		* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
242	30	* @param array $constraints Constraints
243		*
244		* @return void
245	30	*/
246	1	protected function setLocationConstraint($query, $eventDemand, &$constraints)
247	1	{
248		if ($eventDemand->getLocation() !== null && $eventDemand->getLocation() != '') {
249		$constraints[] = $query->equals('location', $eventDemand->getLocation());
250	30	}
251	1	}
252	1
253	30	/**
254		* Sets the location.city constraint to the given constraints array
255		*
256		* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
257		* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
258		* @param array $constraints Constraints
259		*
260		* @return void
261		*/
262		protected function setLocationCityConstraint($query, $eventDemand, &$constraints)
263		{
264	30	if ($eventDemand->getLocationCity() !== null && $eventDemand->getLocationCity() != '') {
265		$constraints[] = $query->equals('location.city', $eventDemand->getLocationCity());
266	30	}
267	30	}
268	3
269	30	/**
270	1	* Sets the location.country constraint to the given constraints array
271	1	*
272		* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
273	1	* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
274		* @param array $constraints Constraints
275		*
276		* @return void
277	1	*/
278	1	protected function setLocationCountryConstraint($query, $eventDemand, &$constraints)
279	1	{
280	1	if ($eventDemand->getLocationCountry() !== null && $eventDemand->getLocationCountry() != '') {
281	1	$constraints[] = $query->equals('location.country', $eventDemand->getLocationCountry());
282	1	}
283		}
284	1
285	1	/**
286	1	* Sets the speaker constraint to the given constraints array
287	1	*
288	30	* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
289		* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
290		* @param array $constraints Constraints
291		*
292		* @return void
293		*/
294		protected function setSpeakerConstraint($query, $eventDemand, &$constraints)
295		{
296		if ($eventDemand->getSpeaker() !== null && $eventDemand->getSpeaker() != '') {
297		$constraints[] = $query->equals('speaker', $eventDemand->getSpeaker());
298		}
299	30	}
300
301	30	/**
302	2	* Sets the organisator constraint to the given constraints array
303	2	*
304	30	* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
305		* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
306		* @param array $constraints Constraints
307		*
308		* @return void
309		*/
310		protected function setOrganisatorConstraint($query, $eventDemand, &$constraints)
311		{
312		if ($eventDemand->getOrganisator() !== null && $eventDemand->getOrganisator() != '') {
313		$constraints[] = $query->equals('organisator', $eventDemand->getOrganisator());
314		}
315		}
316
317		/**
318		* Sets the start- and enddate constraint to the given constraints array
319		*
320		* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
321		* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
322		* @param array $constraints Constraints
323		*
324		* @return void
325		*/
326		protected function setStartEndDateConstraint($query, $eventDemand, &$constraints)
327		{
328		/* StartDate */
329		if ($eventDemand->getSearchDemand() && $eventDemand->getSearchDemand()->getStartDate() !== null) {
330		$constraints[] = $query->greaterThanOrEqual('startdate', $eventDemand->getSearchDemand()->getStartDate());
331		}
332
333		/* EndDate */
334		if ($eventDemand->getSearchDemand() && $eventDemand->getSearchDemand()->getEndDate() !== null) {
335		$constraints[] = $query->lessThanOrEqual('enddate', $eventDemand->getSearchDemand()->getEndDate());
336		}
337		}
338
339		/**
340		* Sets the search constraint to the given constraints array
341		*
342		* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
343		* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
344		* @param array $constraints Constraints
345		*
346		* @return void
347		*/
348		protected function setSearchConstraint($query, $eventDemand, &$constraints)
349		{
350		if ($eventDemand->getSearchDemand() &&
351		$eventDemand->getSearchDemand()->getSearch() !== null &&
352		$eventDemand->getSearchDemand()->getSearch() !== ''
353		) {
354		$searchFields = GeneralUtility::trimExplode(',', $eventDemand->getSearchDemand()->getFields(), true);
355		$searchConstraints = [];
356
357		if (count($searchFields) === 0) {
358		throw new \UnexpectedValueException('No search fields defined', 1318497755);
359		}
360
361		$searchSubject = $eventDemand->getSearchDemand()->getSearch();
362		foreach ($searchFields as $field) {
363		if (!empty($searchSubject)) {
364		$searchConstraints[] = $query->like($field, '%' . addcslashes($searchSubject, '_%') . '%', false);
365		}
366		}
367
368		if (count($searchConstraints)) {
369		$constraints[] = $query->logicalOr($searchConstraints);
370		}
371		}
372		}
373
374		/**
375		* Sets the topEvent constraint to the given constraints array
376		*
377		* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query Query
378		* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand EventDemand
379		* @param array $constraints Constraints
380		*
381		* @return void
382		*/
383		protected function setTopEventConstraint($query, $eventDemand, &$constraints)
384		{
385		if ($eventDemand->getTopEventRestriction() > 0) {
386		$constraints[] = $query->equals('topEvent', (bool)($eventDemand->getTopEventRestriction() - 1));
387		}
388		}
389
390		/**
391		* Sets the restriction for year, year/month or year/month/day to the given constraints array
392		*
393		* @param \TYPO3\CMS\Extbase\Persistence\QueryInterface $query
394		* @param \DERHANSEN\SfEventMgt\Domain\Model\Dto\EventDemand $eventDemand
395		* @param array $constraints
396		*
397		* @return void
398		*/
399		protected function setYearMonthDayRestriction($query, $eventDemand, &$constraints)
400		{
401		if ($eventDemand->getYear() > 0) {
402		if ($eventDemand->getMonth() > 0) {
403		if ($eventDemand->getDay() > 0) {
404		$begin = mktime(0, 0, 0, $eventDemand->getMonth(), $eventDemand->getDay(), $eventDemand->getYear());
405		$end = mktime(23, 59, 59, $eventDemand->getMonth(), $eventDemand->getDay(), $eventDemand->getYear());
406		} else {
407		$begin = mktime(0, 0, 0, $eventDemand->getMonth(), 1, $eventDemand->getYear());
408		$end = mktime(23, 59, 59, ($eventDemand->getMonth() + 1), 0, $eventDemand->getYear());
409		}
410		} else {
411		$begin = mktime(0, 0, 0, 1, 1, $eventDemand->getYear());
412		$end = mktime(23, 59, 59, 12, 31, $eventDemand->getYear());
413		}
414		$constraints[] = $query->logicalOr([
415		$query->between('startdate', $begin, $end),
416		$query->between('enddate', $begin, $end),
417		$query->logicalAnd([
418		$query->greaterThanOrEqual('enddate', $begin),
419		$query->lessThanOrEqual('startdate', $begin)
420		])
421		]);
422		}
423		}
424		}
425

derhansen / sf_event_mgt

Push — development ( 3f7d20...b27959 )

EventRepository::initializeObject() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like