EventRepository::findDemanded() - Code Metrics - Inspection of "[BUGFIX] Removed range settings for start- and end..." - derhansen/sf_event_mgt - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — development ( b2c13c...294738 )

by Torben

created 2017-12-01 18:51 UTC

EventRepository::findDemanded() B

↳ Parent: EventRepository

Complexity

Conditions	2
Paths	2

Size

Total Lines	24
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	17
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	24
ccs	17
cts	17
cp	1
rs	8.9713
c	1
b	0
f	0
cc	2
eloc	19
nc	2
nop	1
crap	2

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

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

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

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

derhansen / sf_event_mgt

Push — development ( b2c13c...294738 )

EventRepository::findDemanded() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like