Exchange::perform() - Code Metrics - Hackathonners/swap - Measure and Improve Code Quality continuously with Scrutinizer

Exchange::perform() A
last analyzed 2019-09-08 19:16 UTC

↳ Parent: Exchange

Complexity

Conditions	1
Paths	1

Size

Total Lines	15
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	8
nc	1
nop	0
dl	0
loc	15
rs	10
c	0
b	0
f	0

<?php

namespace App\Judite\Models;

use Illuminate\Support\Collection;
use Illuminate\Database\Eloquent\Model;
use App\Judite\Contracts\Registry\ExchangeRegistry;
use App\Exceptions\EnrollmentCannotBeExchangedException;
use App\Exceptions\ExchangeEnrollmentsOnDifferentCoursesException;

class Exchange extends Model
{
    /**
     * The relations to eager load on every query.
     *
     * @var array
     */
    protected $with = ['fromEnrollment', 'toEnrollment'];

    /**
     * The exchanges registry.
     *
     * @var \App\Judite\Contracts\Registry\ExchangeRegistry
     */
    private $registry;

    /**
     * Performed exchange indicator.
     *
     * @var bool
     */
    private $performed = false;

    /**
     * Create a new Exchange model instance.
     *
     * @param array $attributes
     */
    public function __construct(array $attributes = [])
    {
        parent::__construct($attributes);
        $this->registry = resolve(ExchangeRegistry::class);
    }

    /**
     * Scope a query to filter exchanges by owner.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param \App\Judite\Models\Student            $student
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeOwnedBy($query, Student $student)
    {
        $studentEnrollmentsQuery = $student->enrollments()
            ->select((new Enrollment())->getKeyName())
            ->getBaseQuery();

        return $query->whereIn('from_enrollment_id', $studentEnrollmentsQuery);

    }

    /**
     * Set the enrollments of this exchange.
     *
     * @param \App\Judite\Models\Enrollment $from
     * @param \App\Judite\Models\Enrollment $to
     *
     * @throws \App\Exceptions\EnrollmentCannotBeExchangedException
     * @throws \App\Exceptions\ExchangeEnrollmentsOnDifferentCoursesException
     *
     * @return $this
     */
    public function setExchangeEnrollments(Enrollment $from, Enrollment $to) : self
    {
        if (! $from->availableForExchange() || is_null($to->shift)) {
            throw new EnrollmentCannotBeExchangedException();
        }

        if (! $from->course->is($to->course)) {
            throw new ExchangeEnrollmentsOnDifferentCoursesException();
        }

        $this->fromEnrollment()->associate($from);
        $this->toEnrollment()->associate($to);

        return $this;
    }

    /**
     * Check if an inverse exchange exists.
     *
     * @param \App\Judite\Models\Enrollment $from
     * @param \App\Judite\Models\Enrollment $to
     *
     * @return \App\Judite\Models\Exchange|null
     */
    public static function findMatchingExchange(Enrollment $from, Enrollment $to): ?self
    {
        $inverseMatch = [
            'from_enrollment_id' => $to->id,
            'to_enrollment_id' => $from->id,
        ];

        return self::where($inverseMatch)->first();
    }

    /**
     * Scope a query to only filter exchanges which source enrollment is in a set of values.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param mixed                                 $values
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeWhereFromEnrollmentIn($query, $values)
    {
        return $query->whereIn('from_enrollment_id', $values);

    }

    /**
     * Scope a query to only filter exchanges which target enrollment is in a set of values.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param mixed                                 $values
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeWhereToEnrollmentIn($query, $values)
    {
        return $query->whereIn('to_enrollment_id', $values);

    }

    /**
     * Perform the exchange and update the associated enrollments.
     *
     * @return $this
     */
    public function perform(): self
    {
        $fromEnrollmentCopy = clone $this->fromEnrollment;
        $toEnrollmentCopy = clone $this->toEnrollment;

        $this->fromEnrollment->exchange($this->toEnrollment);

        $exchangedEnrollments = collect([$this->fromEnrollment, $this->toEnrollment]);
        $this->deleteExchangesOfEnrollments($exchangedEnrollments);

        $this->registry->record($fromEnrollmentCopy, $toEnrollmentCopy);

        $this->performed = true;

        return $this;
    }

    /**
     * Check whether this exchange is performed.
     *
     * @return bool
     */
    public function isPerformed(): bool
    {
        return $this->performed;
    }

    /**
     * Get the source enrollment of this exchange.
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function fromEnrollment()
    {
        return $this->belongsTo(Enrollment::class, 'from_enrollment_id');
    }

    /**
     * Get the target enrollment of this exchange.
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function toEnrollment()
    {
        return $this->belongsTo(Enrollment::class, 'to_enrollment_id');
    }

    /**
     * Get the course of this exchange.
     *
     * @return \App\Judite\Models\Course
     */
    public function course(): Course
    {
        return $this->fromEnrollment->course;
    }

    /**
     * Get the source shift of this exchange.
     *
     * @return \App\Judite\Models\Shift
     */
    public function fromShift(): Shift
    {
        return $this->fromEnrollment->shift;
    }

    /**
     * Get the target shift of this exchange.
     *
     * @return \App\Judite\Models\Shift
     */
    public function toShift(): Shift
    {
        return $this->toEnrollment->shift;
    }

    /**
     * Get the source student of this exchange.
     *
     * @return \App\Judite\Models\Student
     */
    public function fromStudent(): Student
    {
        return $this->fromEnrollment->student;
    }

    /**
     * Get the target student of this exchange.
     *
     * @return \App\Judite\Models\Student
     */
    public function toStudent(): Student
    {
        return $this->toEnrollment->student;
    }

    /**
     * Get the target student of this exchange.
     *
     * @param \App\Judite\Models\Student $student
     *
     * @return bool
     */
    public function isOwnedBy(Student $student): bool
    {
        return $this->fromStudent()->is($student);
    }

    /**
     * Deletes all exchanges involving the given enrollments.
     *
     * @param \Illuminate\Support\Collection $enrollments
     */
    private function deleteExchangesOfEnrollments(Collection $enrollments)
    {
        $enrollmentIds = $enrollments->pluck('id');

        self::whereIn('from_enrollment_id', $enrollmentIds)
            ->orWhereIn('to_enrollment_id', $enrollmentIds)
            ->delete();
    }
}


1			<?php
2
3			namespace App\Judite\Models;
4
5			use Illuminate\Support\Collection;
6			use Illuminate\Database\Eloquent\Model;
7			use App\Judite\Contracts\Registry\ExchangeRegistry;
8			use App\Exceptions\EnrollmentCannotBeExchangedException;
9			use App\Exceptions\ExchangeEnrollmentsOnDifferentCoursesException;
10
11			class Exchange extends Model
12			{
13			/**
14			* The relations to eager load on every query.
15			*
16			* @var array
17			*/
18			protected $with = ['fromEnrollment', 'toEnrollment'];
19
20			/**
21			* The exchanges registry.
22			*
23			* @var \App\Judite\Contracts\Registry\ExchangeRegistry
24			*/
25			private $registry;
26
27			/**
28			* Performed exchange indicator.
29			*
30			* @var bool
31			*/
32			private $performed = false;
33
34			/**
35			* Create a new Exchange model instance.
36			*
37			* @param array $attributes
38			*/
39			public function __construct(array $attributes = [])
40			{
41			parent::__construct($attributes);
42			$this->registry = resolve(ExchangeRegistry::class);
43			}
44
45			/**
46			* Scope a query to filter exchanges by owner.
47			*
48			* @param \Illuminate\Database\Eloquent\Builder $query
49			* @param \App\Judite\Models\Student $student
50			*
51			* @return \Illuminate\Database\Eloquent\Builder
52			*/
53			public function scopeOwnedBy($query, Student $student)
54			{
55			$studentEnrollmentsQuery = $student->enrollments()
56			->select((new Enrollment())->getKeyName())
57			->getBaseQuery();
58
59			return $query->whereIn('from_enrollment_id', $studentEnrollmentsQuery);
			0 ignored issues – show Bug Best Practice introduced 2018-02-02 09:56 UTC by Report Bug Copy Issue Report The expression `return $query->whereIn('...tudentEnrollmentsQuery)` also could return the type `Illuminate\Database\Query\Builder` which is incompatible with the documented return type `Illuminate\Database\Eloquent\Builder`. Loading history...
60			}
61
62			/**
63			* Set the enrollments of this exchange.
64			*
65			* @param \App\Judite\Models\Enrollment $from
66			* @param \App\Judite\Models\Enrollment $to
67			*
68			* @throws \App\Exceptions\EnrollmentCannotBeExchangedException
69			* @throws \App\Exceptions\ExchangeEnrollmentsOnDifferentCoursesException
70			*
71			* @return $this
72			*/
73			public function setExchangeEnrollments(Enrollment $from, Enrollment $to) : self
74			{
75			if (! $from->availableForExchange() \|\| is_null($to->shift)) {
76			throw new EnrollmentCannotBeExchangedException();
77			}
78
79			if (! $from->course->is($to->course)) {
80			throw new ExchangeEnrollmentsOnDifferentCoursesException();
81			}
82
83			$this->fromEnrollment()->associate($from);
84			$this->toEnrollment()->associate($to);
85
86			return $this;
87			}
88
89			/**
90			* Check if an inverse exchange exists.
91			*
92			* @param \App\Judite\Models\Enrollment $from
93			* @param \App\Judite\Models\Enrollment $to
94			*
95			* @return \App\Judite\Models\Exchange\|null
96			*/
97			public static function findMatchingExchange(Enrollment $from, Enrollment $to): ?self
98			{
99			$inverseMatch = [
100			'from_enrollment_id' => $to->id,
101			'to_enrollment_id' => $from->id,
102			];
103
104			return self::where($inverseMatch)->first();
105			}
106
107			/**
108			* Scope a query to only filter exchanges which source enrollment is in a set of values.
109			*
110			* @param \Illuminate\Database\Eloquent\Builder $query
111			* @param mixed $values
112			*
113			* @return \Illuminate\Database\Eloquent\Builder
114			*/
115			public function scopeWhereFromEnrollmentIn($query, $values)
116			{
117			return $query->whereIn('from_enrollment_id', $values);
			0 ignored issues – show Bug Best Practice introduced 2018-02-02 09:56 UTC by Report Bug Copy Issue Report The expression `return $query->whereIn('...nrollment_id', $values)` also could return the type `Illuminate\Database\Query\Builder` which is incompatible with the documented return type `Illuminate\Database\Eloquent\Builder`. Loading history...
118			}
119
120			/**
121			* Scope a query to only filter exchanges which target enrollment is in a set of values.
122			*
123			* @param \Illuminate\Database\Eloquent\Builder $query
124			* @param mixed $values
125			*
126			* @return \Illuminate\Database\Eloquent\Builder
127			*/
128			public function scopeWhereToEnrollmentIn($query, $values)
129			{
130			return $query->whereIn('to_enrollment_id', $values);
			0 ignored issues – show Bug Best Practice introduced 2018-02-02 09:56 UTC by Report Bug Copy Issue Report The expression `return $query->whereIn('...nrollment_id', $values)` also could return the type `Illuminate\Database\Query\Builder` which is incompatible with the documented return type `Illuminate\Database\Eloquent\Builder`. Loading history...
131			}
132
133			/**
134			* Perform the exchange and update the associated enrollments.
135			*
136			* @return $this
137			*/
138			public function perform(): self
139			{
140			$fromEnrollmentCopy = clone $this->fromEnrollment;
141			$toEnrollmentCopy = clone $this->toEnrollment;
142
143			$this->fromEnrollment->exchange($this->toEnrollment);
144
145			$exchangedEnrollments = collect([$this->fromEnrollment, $this->toEnrollment]);
146			$this->deleteExchangesOfEnrollments($exchangedEnrollments);
147
148			$this->registry->record($fromEnrollmentCopy, $toEnrollmentCopy);
149
150			$this->performed = true;
151
152			return $this;
153			}
154
155			/**
156			* Check whether this exchange is performed.
157			*
158			* @return bool
159			*/
160			public function isPerformed(): bool
161			{
162			return $this->performed;
163			}
164
165			/**
166			* Get the source enrollment of this exchange.
167			*
168			* @return \Illuminate\Database\Eloquent\Relations\BelongsTo
169			*/
170			public function fromEnrollment()
171			{
172			return $this->belongsTo(Enrollment::class, 'from_enrollment_id');
173			}
174
175			/**
176			* Get the target enrollment of this exchange.
177			*
178			* @return \Illuminate\Database\Eloquent\Relations\BelongsTo
179			*/
180			public function toEnrollment()
181			{
182			return $this->belongsTo(Enrollment::class, 'to_enrollment_id');
183			}
184
185			/**
186			* Get the course of this exchange.
187			*
188			* @return \App\Judite\Models\Course
189			*/
190			public function course(): Course
191			{
192			return $this->fromEnrollment->course;
193			}
194
195			/**
196			* Get the source shift of this exchange.
197			*
198			* @return \App\Judite\Models\Shift
199			*/
200			public function fromShift(): Shift
201			{
202			return $this->fromEnrollment->shift;
203			}
204
205			/**
206			* Get the target shift of this exchange.
207			*
208			* @return \App\Judite\Models\Shift
209			*/
210			public function toShift(): Shift
211			{
212			return $this->toEnrollment->shift;
213			}
214
215			/**
216			* Get the source student of this exchange.
217			*
218			* @return \App\Judite\Models\Student
219			*/
220			public function fromStudent(): Student
221			{
222			return $this->fromEnrollment->student;
223			}
224
225			/**
226			* Get the target student of this exchange.
227			*
228			* @return \App\Judite\Models\Student
229			*/
230			public function toStudent(): Student
231			{
232			return $this->toEnrollment->student;
233			}
234
235			/**
236			* Get the target student of this exchange.
237			*
238			* @param \App\Judite\Models\Student $student
239			*
240			* @return bool
241			*/
242			public function isOwnedBy(Student $student): bool
243			{
244			return $this->fromStudent()->is($student);
245			}
246
247			/**
248			* Deletes all exchanges involving the given enrollments.
249			*
250			* @param \Illuminate\Support\Collection $enrollments
251			*/
252			private function deleteExchangesOfEnrollments(Collection $enrollments)
253			{
254			$enrollmentIds = $enrollments->pluck('id');
255
256			self::whereIn('from_enrollment_id', $enrollmentIds)
257			->orWhereIn('to_enrollment_id', $enrollmentIds)
258			->delete();
259			}
260			}
261

Hackathonners / swap

Exchange::perform() A last analyzed 2019-09-08 19:16 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Exchange::perform() A
last analyzed 2019-09-08 19:16 UTC