RegistrationRepository::initializeObject() - Code Metrics - Inspection of "[FEATURE] Added waitlist notification filter to ba..." - derhansen/sf_event_mgt - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — 6.x ( 798bcf...2c9878 )

by Torben

created 2024-03-10 13:40 UTC

RegistrationRepository::initializeObject() A

↳ Parent: RegistrationRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

/*
 * 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.
 */

namespace DERHANSEN\SfEventMgt\Domain\Repository;

use DERHANSEN\SfEventMgt\Domain\Model\Dto\CustomNotification;
use DERHANSEN\SfEventMgt\Domain\Model\Dto\UserRegistrationDemand;
use DERHANSEN\SfEventMgt\Domain\Model\Event;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Persistence\Generic\Typo3QuerySettings;
use TYPO3\CMS\Extbase\Persistence\QueryInterface;
use TYPO3\CMS\Extbase\Persistence\QueryResultInterface;
use TYPO3\CMS\Extbase\Persistence\Repository;

/**
 * The repository for registrations
 */
class RegistrationRepository extends Repository
{
    /**
     * Disable the use of storage records, because the StoragePage can be set
     * in the plugin
     */
    public function initializeObject(): void
    {
        $this->defaultQuerySettings = GeneralUtility::makeInstance(Typo3QuerySettings::class);
        $this->defaultQuerySettings->setRespectStoragePage(false);
    }

    /**
     * Returns all registrations for the given event with the given constraints
     * Constraints are combined with a logical AND
     *
     * @return array|QueryResultInterface
     */
    public function findNotificationRegistrations(
        Event $event,
        CustomNotification $customNotification,
        array $findConstraints = []
    ) {
        $constraints = [];
        $query = $this->createQuery();
        $constraints[] = $query->equals('event', $event);
        $constraints[] = $query->equals('ignoreNotifications', false);

        switch ($customNotification->getRecipients()) {
            case CustomNotification::RECIPIENTS_CONFIRMED:
                $constraints[] = $query->equals('confirmed', true);
                $constraints[] = $query->equals('waitlist', false);
                break;
            case CustomNotification::RECIPIENTS_UNCONFIRMED:
                $constraints[] = $query->equals('confirmed', false);
                $constraints[] = $query->equals('waitlist', false);
                break;
            case CustomNotification::RECIPIENTS_WAITLIST_CONFIRMED:
                $constraints[] = $query->equals('confirmed', true);
                $constraints[] = $query->equals('waitlist', true);
                break;
            case CustomNotification::RECIPIENTS_WAITLIST_UNCONFIRMED:
                $constraints[] = $query->equals('confirmed', false);
                $constraints[] = $query->equals('waitlist', true);
                break;
            default:
        }

        if (!is_array($findConstraints) || count($findConstraints) === 0) {

            return $query->matching($query->logicalAnd($constraints))->execute();
        }

        foreach ($findConstraints as $findConstraint => $value) {
            $condition = key($value);
            switch ($condition) {
                case 'equals':
                    $constraints[] = $query->equals($findConstraint, $value[$condition]);
                    break;
                case 'lessThan':
                    $constraints[] = $query->lessThan($findConstraint, $value[$condition]);
                    break;
                case 'lessThanOrEqual':
                    $constraints[] = $query->lessThanOrEqual($findConstraint, $value[$condition]);
                    break;
                case 'greaterThan':
                    $constraints[] = $query->greaterThan($findConstraint, $value[$condition]);
                    break;
                case 'greaterThanOrEqual':
                    $constraints[] = $query->greaterThanOrEqual($findConstraint, $value[$condition]);
                    break;
                default:
                    throw new \InvalidArgumentException('An error occured - Unknown condition: ' . $condition);
            }
        }

        return $query->matching($query->logicalAnd($constraints))->execute();
    }

    /**
     * Returns registrations for the given UserRegistrationDemand demand
     *
     * @return array|QueryResultInterface
     */
    public function findRegistrationsByUserRegistrationDemand(UserRegistrationDemand $demand)
    {
        if (!$demand->getUser()) {
            return [];
        }
        $constraints = [];
        $query = $this->createQuery();
        $this->setStoragePageConstraint($query, $demand, $constraints);
        $this->setDisplayModeConstraint($query, $demand, $constraints);
        $this->setUserConstraint($query, $demand, $constraints);
        $this->setOrderingsFromDemand($query, $demand);

        return $query->matching($query->logicalAnd($constraints))->execute();
    }

    /**
     * Returns all registrations for the given event and where the waitlist flag is as given
     *
     * @return array|QueryResultInterface
     */
    public function findByEventAndWaitlist(Event $event, bool $waitlist = false)
    {
        $constraints = [];
        $query = $this->createQuery();
        $constraints[] = $query->equals('event', $event->getUid());
        $constraints[] = $query->equals('waitlist', $waitlist);

        return $query->matching($query->logicalAnd($constraints))->execute();
    }

    /**
     * Returns all potential move up registrations for the given event ordered by "registration_date"
     *
     * @return array|QueryResultInterface
     */
    public function findWaitlistMoveUpRegistrations(Event $event)
    {
        $constraints = [];
        $query = $this->createQuery();
        $constraints[] = $query->equals('event', $event->getUid());
        $constraints[] = $query->equals('waitlist', true);
        $constraints[] = $query->equals('confirmed', true);
        $constraints[] = $query->greaterThan('registrationDate', 0);
        $query->setOrderings(['registration_date' => QueryInterface::ORDER_ASCENDING]);

        return $query->matching($query->logicalAnd($constraints))->execute();
    }

    /**
     * Sets the displayMode constraint to the given constraints array
     */
    protected function setDisplayModeConstraint(
        QueryInterface $query,
        UserRegistrationDemand $demand,
        array &$constraints
    ): void {
        switch ($demand->getDisplayMode()) {
            case 'future':
                $constraints[] = $query->greaterThan('event.startdate', $demand->getCurrentDateTime());
                break;
            case 'current_future':
                $constraints[] = $query->logicalOr([
                    $query->greaterThan('event.startdate', $demand->getCurrentDateTime()),
                    $query->logicalAnd([
                        $query->greaterThanOrEqual('event.enddate', $demand->getCurrentDateTime()),
                        $query->lessThanOrEqual('event.startdate', $demand->getCurrentDateTime()),
                    ]),
                ]);
                break;
            case 'past':
                $constraints[] = $query->lessThanOrEqual('event.enddate', $demand->getCurrentDateTime());
                break;
        }
    }

    /**
     * Sets the storagePage constraint to the given constraints array
     */
    protected function setStoragePageConstraint(
        QueryInterface $query,
        UserRegistrationDemand $demand,
        array &$constraints
    ): void {
        if ($demand->getStoragePage() !== '') {
            $pidList = GeneralUtility::intExplode(',', $demand->getStoragePage(), true);
            $constraints[] = $query->in('pid', $pidList);
        }
    }

    /**
     * Sets the user constraint to the given constraints array
     *
     * @param QueryInterface $query Query
     * @param UserRegistrationDemand $demand
     * @param array $constraints Constraints
     */
    protected function setUserConstraint(
        QueryInterface $query,
        UserRegistrationDemand $demand,
        array &$constraints
    ): void {
        if ($demand->getUser()) {
            $constraints[] = $query->equals('feUser', $demand->getUser());
        }
    }

    /**
     * Sets the ordering to the given query for the given demand
     */
    protected function setOrderingsFromDemand(QueryInterface $query, UserRegistrationDemand $demand): void
    {
        $orderings = [];
        if ($demand->getOrderField() !== '' && $demand->getOrderDirection() !== '') {
            $orderings[$demand->getOrderField()] = ((strtolower($demand->getOrderDirection()) === 'desc') ?
                QueryInterface::ORDER_DESCENDING :
                QueryInterface::ORDER_ASCENDING);
            $query->setOrderings($orderings);
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Extension "sf_event_mgt" for TYPO3 CMS.
7			*
8			* For the full copyright and license information, please read the
9			* LICENSE.txt file that was distributed with this source code.
10			*/
11
12			namespace DERHANSEN\SfEventMgt\Domain\Repository;
13
14			use DERHANSEN\SfEventMgt\Domain\Model\Dto\CustomNotification;
15			use DERHANSEN\SfEventMgt\Domain\Model\Dto\UserRegistrationDemand;
16			use DERHANSEN\SfEventMgt\Domain\Model\Event;
17			use TYPO3\CMS\Core\Utility\GeneralUtility;
18			use TYPO3\CMS\Extbase\Persistence\Generic\Typo3QuerySettings;
19			use TYPO3\CMS\Extbase\Persistence\QueryInterface;
20			use TYPO3\CMS\Extbase\Persistence\QueryResultInterface;
21			use TYPO3\CMS\Extbase\Persistence\Repository;
22
23			/**
24			* The repository for registrations
25			*/
26			class RegistrationRepository extends Repository
27			{
28			/**
29			* Disable the use of storage records, because the StoragePage can be set
30			* in the plugin
31			*/
32			public function initializeObject(): void
33			{
34			$this->defaultQuerySettings = GeneralUtility::makeInstance(Typo3QuerySettings::class);
35			$this->defaultQuerySettings->setRespectStoragePage(false);
36			}
37
38			/**
39			* Returns all registrations for the given event with the given constraints
40			* Constraints are combined with a logical AND
41			*
42			* @return array\|QueryResultInterface
43			*/
44			public function findNotificationRegistrations(
45			Event $event,
46			CustomNotification $customNotification,
47			array $findConstraints = []
48			) {
49			$constraints = [];
50			$query = $this->createQuery();
51			$constraints[] = $query->equals('event', $event);
52			$constraints[] = $query->equals('ignoreNotifications', false);
53
54			switch ($customNotification->getRecipients()) {
55			case CustomNotification::RECIPIENTS_CONFIRMED:
56			$constraints[] = $query->equals('confirmed', true);
57			$constraints[] = $query->equals('waitlist', false);
58			break;
59			case CustomNotification::RECIPIENTS_UNCONFIRMED:
60			$constraints[] = $query->equals('confirmed', false);
61			$constraints[] = $query->equals('waitlist', false);
62			break;
63			case CustomNotification::RECIPIENTS_WAITLIST_CONFIRMED:
64			$constraints[] = $query->equals('confirmed', true);
65			$constraints[] = $query->equals('waitlist', true);
66			break;
67			case CustomNotification::RECIPIENTS_WAITLIST_UNCONFIRMED:
68			$constraints[] = $query->equals('confirmed', false);
69			$constraints[] = $query->equals('waitlist', true);
70			break;
71			default:
72			}
73
74			if (!is_array($findConstraints) \|\| count($findConstraints) === 0) {
			0 ignored issues – show introduced 2021-04-04 10:16 UTC by Report Bug Copy Issue Report The condition `is_array($findConstraints)` is always `true`. Loading history...
75			return $query->matching($query->logicalAnd($constraints))->execute();
76			}
77
78			foreach ($findConstraints as $findConstraint => $value) {
79			$condition = key($value);
80			switch ($condition) {
81			case 'equals':
82			$constraints[] = $query->equals($findConstraint, $value[$condition]);
83			break;
84			case 'lessThan':
85			$constraints[] = $query->lessThan($findConstraint, $value[$condition]);
86			break;
87			case 'lessThanOrEqual':
88			$constraints[] = $query->lessThanOrEqual($findConstraint, $value[$condition]);
89			break;
90			case 'greaterThan':
91			$constraints[] = $query->greaterThan($findConstraint, $value[$condition]);
92			break;
93			case 'greaterThanOrEqual':
94			$constraints[] = $query->greaterThanOrEqual($findConstraint, $value[$condition]);
95			break;
96			default:
97			throw new \InvalidArgumentException('An error occured - Unknown condition: ' . $condition);
98			}
99			}
100
101			return $query->matching($query->logicalAnd($constraints))->execute();
102			}
103
104			/**
105			* Returns registrations for the given UserRegistrationDemand demand
106			*
107			* @return array\|QueryResultInterface
108			*/
109			public function findRegistrationsByUserRegistrationDemand(UserRegistrationDemand $demand)
110			{
111			if (!$demand->getUser()) {
112			return [];
113			}
114			$constraints = [];
115			$query = $this->createQuery();
116			$this->setStoragePageConstraint($query, $demand, $constraints);
117			$this->setDisplayModeConstraint($query, $demand, $constraints);
118			$this->setUserConstraint($query, $demand, $constraints);
119			$this->setOrderingsFromDemand($query, $demand);
120
121			return $query->matching($query->logicalAnd($constraints))->execute();
122			}
123
124			/**
125			* Returns all registrations for the given event and where the waitlist flag is as given
126			*
127			* @return array\|QueryResultInterface
128			*/
129			public function findByEventAndWaitlist(Event $event, bool $waitlist = false)
130			{
131			$constraints = [];
132			$query = $this->createQuery();
133			$constraints[] = $query->equals('event', $event->getUid());
134			$constraints[] = $query->equals('waitlist', $waitlist);
135
136			return $query->matching($query->logicalAnd($constraints))->execute();
137			}
138
139			/**
140			* Returns all potential move up registrations for the given event ordered by "registration_date"
141			*
142			* @return array\|QueryResultInterface
143			*/
144			public function findWaitlistMoveUpRegistrations(Event $event)
145			{
146			$constraints = [];
147			$query = $this->createQuery();
148			$constraints[] = $query->equals('event', $event->getUid());
149			$constraints[] = $query->equals('waitlist', true);
150			$constraints[] = $query->equals('confirmed', true);
151			$constraints[] = $query->greaterThan('registrationDate', 0);
152			$query->setOrderings(['registration_date' => QueryInterface::ORDER_ASCENDING]);
153
154			return $query->matching($query->logicalAnd($constraints))->execute();
155			}
156
157			/**
158			* Sets the displayMode constraint to the given constraints array
159			*/
160			protected function setDisplayModeConstraint(
161			QueryInterface $query,
162			UserRegistrationDemand $demand,
163			array &$constraints
164			): void {
165			switch ($demand->getDisplayMode()) {
166			case 'future':
167			$constraints[] = $query->greaterThan('event.startdate', $demand->getCurrentDateTime());
168			break;
169			case 'current_future':
170			$constraints[] = $query->logicalOr([
171			$query->greaterThan('event.startdate', $demand->getCurrentDateTime()),
172			$query->logicalAnd([
173			$query->greaterThanOrEqual('event.enddate', $demand->getCurrentDateTime()),
174			$query->lessThanOrEqual('event.startdate', $demand->getCurrentDateTime()),
175			]),
176			]);
177			break;
178			case 'past':
179			$constraints[] = $query->lessThanOrEqual('event.enddate', $demand->getCurrentDateTime());
180			break;
181			}
182			}
183
184			/**
185			* Sets the storagePage constraint to the given constraints array
186			*/
187			protected function setStoragePageConstraint(
188			QueryInterface $query,
189			UserRegistrationDemand $demand,
190			array &$constraints
191			): void {
192			if ($demand->getStoragePage() !== '') {
193			$pidList = GeneralUtility::intExplode(',', $demand->getStoragePage(), true);
194			$constraints[] = $query->in('pid', $pidList);
195			}
196			}
197
198			/**
199			* Sets the user constraint to the given constraints array
200			*
201			* @param QueryInterface $query Query
202			* @param UserRegistrationDemand $demand
203			* @param array $constraints Constraints
204			*/
205			protected function setUserConstraint(
206			QueryInterface $query,
207			UserRegistrationDemand $demand,
208			array &$constraints
209			): void {
210			if ($demand->getUser()) {
211			$constraints[] = $query->equals('feUser', $demand->getUser());
212			}
213			}
214
215			/**
216			* Sets the ordering to the given query for the given demand
217			*/
218			protected function setOrderingsFromDemand(QueryInterface $query, UserRegistrationDemand $demand): void
219			{
220			$orderings = [];
221			if ($demand->getOrderField() !== '' && $demand->getOrderDirection() !== '') {
222			$orderings[$demand->getOrderField()] = ((strtolower($demand->getOrderDirection()) === 'desc') ?
223			QueryInterface::ORDER_DESCENDING :
224			QueryInterface::ORDER_ASCENDING);
225			$query->setOrderings($orderings);
226			}
227			}
228			}
229

derhansen / sf_event_mgt

Push — 6.x ( 798bcf...2c9878 )

RegistrationRepository::initializeObject() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like