ReservationsFacade::getActiveReservations() - Code Metrics - Inspection of "Issues#17" - vojtasvoboda/oc-reservations-plugin - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#20)

unknown

created 2017-05-10 14:33 UTC

ReservationsFacade::getActiveReservations() A

↳ Parent: ReservationsFacade

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php namespace VojtaSvoboda\Reservations\Facades;

use Auth;
use Carbon\Carbon;
use Config;
use Event;
use Lang;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Support\Facades\DB;
use October\Rain\Exception\ApplicationException;
use October\Rain\Exception\ValidationException;
use VojtaSvoboda\Reservations\Classes\DatesResolver;
use VojtaSvoboda\Reservations\Mailers\ReservationAdminMailer;
use VojtaSvoboda\Reservations\Mailers\ReservationMailer;
use VojtaSvoboda\Reservations\Models\Reservation;
use VojtaSvoboda\Reservations\Models\Settings;
use VojtaSvoboda\Reservations\Models\Status;

/**
 * Public reservations facade.
 *
 * Usage: App::make(ReservationsFacade::class);
 *
 * @package VojtaSvoboda\Reservations\Facades
 */
class ReservationsFacade
{
    /** @var Reservation $reservations */
    private $reservations;

    /** @var Status $statuses */
    private $statuses;

    /** @var DatesResolver $datesResolver */
    private $datesResolver;

    /** @var array $returningUsersCache */
    private $returningUsersCache;

    /** @var ReservationMailer $mailer */
    private $mailer;

    /** @var ReservationAdminMailer $adminMailer */
    private $adminMailer;

    /**
     * ReservationsFacade constructor.
     *
     * @param Reservation $reservations
     * @param Status $statuses
     * @param DatesResolver $resolver
     * @param ReservationMailer $mailer
     * @param ReservationAdminMailer $adminMailer
     */
    public function __construct(
        Reservation $reservations, Status $statuses, DatesResolver $resolver,
        ReservationMailer $mailer, ReservationAdminMailer $adminMailer
    ) {
        $this->reservations = $reservations;
        $this->statuses = $statuses;
        $this->datesResolver = $resolver;
        $this->mailer = $mailer;
        $this->adminMailer = $adminMailer;
    }

    /**
     * Create and store reservation.
     *
     * @param array $data
     *
     * @return Reservation $reservation
     *
     * @throws ApplicationException
     * @throws ValidationException
     */
    public function storeReservation($data)
    {
        // check number of sends
        $this->checkLimits();

        // transform date and time to Carbon
        $data['date'] = $this->transformDateTime($data);

        // place for extending
        Event::fire('vojtasvoboda.reservations.processReservation', [&$data]);

        // create reservation
        $reservation = $this->reservations->create($data);

        // send mails to client and admin
        $this->sendMails($reservation);

        return $reservation;
    }

    /**
     * Send mail to client and admin.
     *
     * @param Reservation $reservation
     */
    public function sendMails($reservation)
    {
        // calculate reservations by same email
        $sameCount = $this->getReservationsCountByMail($reservation->email);

        // send reservation confirmation to customer
        $this->mailer->send($reservation, $sameCount);

        // send reservation confirmation to admin
        $this->adminMailer->send($reservation, $sameCount);
    }

    /**
     * Get all reservations.
     *
     * @return Collection
     */
    public function getReservations()
    {
        return $this->reservations->all();
    }

    /**
     * Get all active (not cancelled) reservations.
     *
     * @return Collection
     */
    public function getActiveReservations()
    {
        return $this->reservations->notCancelled()->get();
    }

    /**
     * Get all reserved time slots.
     *
     * @return array
     */
    public function getReservedDates()
    {
        $reservations = $this->getActiveReservations();

        return $this->datesResolver->getDatesFromReservations($reservations);
    }

    /**
     * Get all reservations by given date interval.
     *
     * @param Carbon $since Date from.
     * @param Carbon $till Date to.
     *
     * @return mixed
     */
    public function getReservationsByInterval(Carbon $since, Carbon $till)
    {
        return $this->reservations->whereBetween('date', [$since, $till])->get();
    }

    /**
     * Get reservations count by one email.
     *
     * @param $email
     *
     * @return int
     */
    public function getReservationsCountByMail($email)
    {
        return $this->reservations->where('email', $email)->notCancelled()->count();
    }

    /**
     * Is user returning or not? You have to set this parameter at Backend Reservations setting.
     *
     * @param $email
     *
     * @return bool
     */
    public function isUserReturning($email)
    {
        // when disabled, user is never returning
        $threshold = Settings::get('returning_mark', 0);
        if ($threshold < 1) {
            return false;
        }

        // load emails count
        if ($this->returningUsersCache === null) {
            $items = $this
                ->reservations
                ->select(DB::raw('email, count(*) as count'))
                ->groupBy('email')
                ->get();
            // refactor to mapWithKeys after upgrade to Laravel 5.3.
            foreach($items as $item) {
                $this->returningUsersCache[$item['email']] = $item['count'];
            }
        }

        $returning = $this->returningUsersCache;
        $actual = isset($returning[$email]) ? $returning[$email] : 0;

        return $threshold > 0 && $actual >= $threshold;
    }

    /**
     * Bulk reservation state change.
     *
     * @param array $ids
     * @param string $ident
     */
    public function bulkStateChange($ids, $ident)
    {
        // get state
        $status = $this->statuses->where('ident', $ident)->first();
        if (!$status) {
            return;
        }

        // go through reservations
        foreach ($ids as $id)
        {
            $reservation = $this->reservations->find($id);
            if (!$reservation) {
                continue;
            }

            $reservation->status = $status;
            $reservation->save();
        }
    }

    /**
     * Bulk reservations delete.
     *
     * @param array $ids
     */
    public function bulkDelete($ids)
    {
        // go through reservations
        foreach ($ids as $id)
        {
            $reservation = $this->reservations->find($id);
            if (!$reservation) {
                continue;
            }

            $reservation->delete();
        }
    }

    /**
     * Transform date and time to DateTime string.
     *
     * @param $data
     *
     * @return Carbon
     *
     * @throws ApplicationException
     */
    public function transformDateTime($data)
    {
        // validate date
        if (empty($data['date'])) {
            throw new ApplicationException(Lang::get('vojtasvoboda.reservations::lang.errors.empty_date'));
        }

        // validate time
        if (empty($data['time'])) {
            throw new ApplicationException(Lang::get('vojtasvoboda.reservations::lang.errors.empty_hour'));
        }

        $format = Settings::get(
            'formats_datetime',
            Config::get('vojtasvoboda.reservations::config.formats.datetime', 'd/m/Y H:i')
        );

        $dateTime = Carbon::createFromFormat($format, trim($data['date'] . ' ' . $data['time']));

        // validate date + time > current
        if ($dateTime->timestamp < Carbon::now()->timestamp) {
            throw new ApplicationException(Lang::get('vojtasvoboda.reservations::lang.errors.past_date'));
        }

        // validate days off
        if (!in_array($dateTime->dayOfWeek, $this->getWorkDays())) {
            throw new ApplicationException(Lang::get('vojtasvoboda.reservations::lang.errors.days_off'));
        }

        // validate out of hours
        $workTime = $this->getWorkTime();
        //convert hour and minutes to minutes
        $timeToMinute = $dateTime->hour * 60 + $dateTime->minute;
        $workTimeFrom = $workTime['from']['hour'] * 60 + $workTime['from']['minute'];
        $workTimeTo   = $workTime['to']['hour'] * 60 + $workTime['to']['minute'];

        if ($timeToMinute < $workTimeFrom || $timeToMinute > $workTimeTo) {
            throw new ApplicationException(Lang::get('vojtasvoboda.reservations::lang.errors.out_of_hours'));
        }

        return $dateTime;
    }

    /**
     * Get work days of week
     *
     * @return array
     */
    public function getWorkDays()
    {
        $daysWorkInput = Settings::get('work_days', ['monday','tuesday','wednesday','thursday','friday']);
        $daysWork = [];

        foreach (['monday','tuesday','wednesday','thursday','friday','saturday','sunday'] as $index => $day) {
            if (in_array($day, $daysWorkInput)) {
                $daysWork[] = $index + 1;
            }
        }

        return $daysWork;
    }

    /**
     * Get work time of day
     *
     * @return array
     */
    public function getWorkTime()
    {
        $workTime = [];

        $work_time_from = explode(':', Settings::get('work_time_from', '10:00'));
        $workTime['from']['hour'] = (int)$work_time_from[0];
        $workTime['from']['minute'] = (isset($work_time_from[1]))?(int)$work_time_from[1]:0;

        $work_time_to = explode(':', Settings::get('work_time_to', '18:00'));
        $workTime['to']['hour'] = (int)$work_time_to[0];
        $workTime['to']['minute'] = (isset($work_time_to[1]))?(int)$work_time_to[1]:0;

        return $workTime;
    }

    /**
     * Returns if given date is available.
     *
     * @param Carbon $date
     * @param int $exceptId Except reservation ID.
     *
     * @return bool
     */
    public function isDateAvailable($date, $exceptId = null)
    {
        // get boundary dates for given reservation date
        $boundaries = $this->datesResolver->getBoundaryDates($date);

        // get all reservations in this date
        $query = $this->reservations->notCancelled()->whereBetween('date', $boundaries);

        // if updating reservation, we should skip existing reservation
        if ($exceptId !== null) {
            $query->where('id', '!=', $exceptId);
        }

        return $query->count() === 0;
    }

    /**
     * Check reservations amount limit per time.
     *
     * @throws ApplicationException
     */
    private function checkLimits()
    {
        if ($this->isCreatedWhileAgo()) {
            throw new ApplicationException(Lang::get('vojtasvoboda.reservations::lang.errors.please_wait'));
        }
    }

    /**
     * Try to find some reservation in less then given limit (default 30 seconds).
     *
     * @return boolean
     */
    public function isCreatedWhileAgo()
    {
        // protection time
        $time = Config::get('vojtasvoboda.reservations::config.protection_time', '-30 seconds');
        $timeLimit = Carbon::parse($time)->toDateTimeString();

        // try to find some message
        $item = $this->reservations->machine()->where('created_at', '>', $timeLimit)->first();

        return $item !== null;
    }
}


1		<?php namespace VojtaSvoboda\Reservations\Facades;
2
3		use Auth;
4		use Carbon\Carbon;
5		use Config;
6		use Event;
7		use Lang;
8		use Illuminate\Database\Eloquent\Collection;
9		use Illuminate\Support\Facades\DB;
10		use October\Rain\Exception\ApplicationException;
11		use October\Rain\Exception\ValidationException;
12		use VojtaSvoboda\Reservations\Classes\DatesResolver;
13		use VojtaSvoboda\Reservations\Mailers\ReservationAdminMailer;
14		use VojtaSvoboda\Reservations\Mailers\ReservationMailer;
15		use VojtaSvoboda\Reservations\Models\Reservation;
16		use VojtaSvoboda\Reservations\Models\Settings;
17		use VojtaSvoboda\Reservations\Models\Status;
18
19		/**
20		* Public reservations facade.
21		*
22		* Usage: App::make(ReservationsFacade::class);
23		*
24		* @package VojtaSvoboda\Reservations\Facades
25		*/
26		class ReservationsFacade
27		{
28		/** @var Reservation $reservations */
29		private $reservations;
30
31		/** @var Status $statuses */
32		private $statuses;
33
34		/** @var DatesResolver $datesResolver */
35		private $datesResolver;
36
37		/** @var array $returningUsersCache */
38		private $returningUsersCache;
39
40		/** @var ReservationMailer $mailer */
41		private $mailer;
42
43		/** @var ReservationAdminMailer $adminMailer */
44		private $adminMailer;
45
46		/**
47		* ReservationsFacade constructor.
48		*
49		* @param Reservation $reservations
50		* @param Status $statuses
51		* @param DatesResolver $resolver
52		* @param ReservationMailer $mailer
53		* @param ReservationAdminMailer $adminMailer
54		*/
55	14	public function __construct(
56		Reservation $reservations, Status $statuses, DatesResolver $resolver,
57		ReservationMailer $mailer, ReservationAdminMailer $adminMailer
58		) {
59	14	$this->reservations = $reservations;
60	14	$this->statuses = $statuses;
61	14	$this->datesResolver = $resolver;
62	14	$this->mailer = $mailer;
63	14	$this->adminMailer = $adminMailer;
64	14	}
65
66		/**
67		* Create and store reservation.
68		*
69		* @param array $data
70		*
71		* @return Reservation $reservation
72		*
73		* @throws ApplicationException
74		* @throws ValidationException
75		*/
76	7	public function storeReservation($data)
77		{
78		// check number of sends
79	7	$this->checkLimits();
80
81		// transform date and time to Carbon
82	7	$data['date'] = $this->transformDateTime($data);
83
84		// place for extending
85	5	Event::fire('vojtasvoboda.reservations.processReservation', [&$data]);
86
87		// create reservation
88	5	$reservation = $this->reservations->create($data);
89
90		// send mails to client and admin
91	5	$this->sendMails($reservation);
92
93	5	return $reservation;
94		}
95
96		/**
97		* Send mail to client and admin.
98		*
99		* @param Reservation $reservation
100		*/
101	5	public function sendMails($reservation)
102		{
103		// calculate reservations by same email
104	5	$sameCount = $this->getReservationsCountByMail($reservation->email);
105
106		// send reservation confirmation to customer
107	5	$this->mailer->send($reservation, $sameCount);
108
109		// send reservation confirmation to admin
110	5	$this->adminMailer->send($reservation, $sameCount);
111	5	}
112
113		/**
114		* Get all reservations.
115		*
116		* @return Collection
117		*/
118		public function getReservations()
119		{
120		return $this->reservations->all();
121		}
122
123		/**
124		* Get all active (not cancelled) reservations.
125		*
126		* @return Collection
127		*/
128		public function getActiveReservations()
129		{
130		return $this->reservations->notCancelled()->get();
131		}
132
133		/**
134		* Get all reserved time slots.
135		*
136		* @return array
137		*/
138		public function getReservedDates()
139		{
140		$reservations = $this->getActiveReservations();
141
142		return $this->datesResolver->getDatesFromReservations($reservations);
143		}
144
145		/**
146		* Get all reservations by given date interval.
147		*
148		* @param Carbon $since Date from.
149		* @param Carbon $till Date to.
150		*
151		* @return mixed
152		*/
153		public function getReservationsByInterval(Carbon $since, Carbon $till)
154		{
155		return $this->reservations->whereBetween('date', [$since, $till])->get();
156		}
157
158		/**
159		* Get reservations count by one email.
160		*
161		* @param $email
162		*
163		* @return int
164		*/
165	5	public function getReservationsCountByMail($email)
166		{
167	5	return $this->reservations->where('email', $email)->notCancelled()->count();
168		}
169
170		/**
171		* Is user returning or not? You have to set this parameter at Backend Reservations setting.
172		*
173		* @param $email
174		*
175		* @return bool
176		*/
177	1	public function isUserReturning($email)
178		{
179		// when disabled, user is never returning
180	1	$threshold = Settings::get('returning_mark', 0);
181	1	if ($threshold < 1) {
182		return false;
183		}
184
185		// load emails count
186	1	if ($this->returningUsersCache === null) {
187		$items = $this
188	1	->reservations
189	1	->select(DB::raw('email, count(*) as count'))
190	1	->groupBy('email')
191	1	->get();
192		// refactor to mapWithKeys after upgrade to Laravel 5.3.
193	1	foreach($items as $item) {
194	1	$this->returningUsersCache[$item['email']] = $item['count'];
195		}
196		}
197
198	1	$returning = $this->returningUsersCache;
199	1	$actual = isset($returning[$email]) ? $returning[$email] : 0;
200
201	1	return $threshold > 0 && $actual >= $threshold;
202		}
203
204		/**
205		* Bulk reservation state change.
206		*
207		* @param array $ids
208		* @param string $ident
209		*/
210		public function bulkStateChange($ids, $ident)
211		{
212		// get state
213		$status = $this->statuses->where('ident', $ident)->first();
214		if (!$status) {
215		return;
216		}
217
218		// go through reservations
219		foreach ($ids as $id)
220		{
221		$reservation = $this->reservations->find($id);
222		if (!$reservation) {
223		continue;
224		}
225
226		$reservation->status = $status;
227		$reservation->save();
228		}
229		}
230
231		/**
232		* Bulk reservations delete.
233		*
234		* @param array $ids
235		*/
236		public function bulkDelete($ids)
237		{
238		// go through reservations
239		foreach ($ids as $id)
240		{
241		$reservation = $this->reservations->find($id);
242		if (!$reservation) {
243		continue;
244		}
245
246		$reservation->delete();
247		}
248		}
249
250		/**
251		* Transform date and time to DateTime string.
252		*
253		* @param $data
254		*
255		* @return Carbon
256		*
257		* @throws ApplicationException
258		*/
259	8	public function transformDateTime($data)
260		{
261		// validate date
262	8	if (empty($data['date'])) {
263	1	throw new ApplicationException(Lang::get('vojtasvoboda.reservations::lang.errors.empty_date'));
264		}
265
266		// validate time
267	7	if (empty($data['time'])) {
268	1	throw new ApplicationException(Lang::get('vojtasvoboda.reservations::lang.errors.empty_hour'));
269		}
270
271	6	$format = Settings::get(
272		'formats_datetime',
273	6	Config::get('vojtasvoboda.reservations::config.formats.datetime', 'd/m/Y H:i')
274		);
275
276		$dateTime = Carbon::createFromFormat($format, trim($data['date'] . ' ' . $data['time']));
277
278		// validate date + time > current
279		if ($dateTime->timestamp < Carbon::now()->timestamp) {
280		throw new ApplicationException(Lang::get('vojtasvoboda.reservations::lang.errors.past_date'));
281		}
282
283		// validate days off
284	11	if (!in_array($dateTime->dayOfWeek, $this->getWorkDays())) {
285		throw new ApplicationException(Lang::get('vojtasvoboda.reservations::lang.errors.days_off'));
286		}
287	11
288		// validate out of hours
289		$workTime = $this->getWorkTime();
290	11	//convert hour and minutes to minutes
291		$timeToMinute = $dateTime->hour * 60 + $dateTime->minute;
292		$workTimeFrom = $workTime['from']['hour'] * 60 + $workTime['from']['minute'];
293	11	$workTimeTo = $workTime['to']['hour'] * 60 + $workTime['to']['minute'];
294
295		if ($timeToMinute < $workTimeFrom \|\| $timeToMinute > $workTimeTo) {
296		throw new ApplicationException(Lang::get('vojtasvoboda.reservations::lang.errors.out_of_hours'));
297	11	}
298
299		return $dateTime;
300		}
301
302		/**
303		* Get work days of week
304		*
305	7	* @return array
306		*/
307	7	public function getWorkDays()
308	1	{
309		$daysWorkInput = Settings::get('work_days', ['monday','tuesday','wednesday','thursday','friday']);
310	7	$daysWork = [];
311
312		foreach (['monday','tuesday','wednesday','thursday','friday','saturday','sunday'] as $index => $day) {
313		if (in_array($day, $daysWorkInput)) {
314		$daysWork[] = $index + 1;
315		}
316		}
317	7
318		return $daysWork;
319		}
320	7
321	7	/**
322		* Get work time of day
323		*
324	7	* @return array
325		*/
326	7	public function getWorkTime()
327		{
328		$workTime = [];
329
330		$work_time_from = explode(':', Settings::get('work_time_from', '10:00'));
331		$workTime['from']['hour'] = (int)$work_time_from[0];
332		$workTime['from']['minute'] = (isset($work_time_from[1]))?(int)$work_time_from[1]:0;
333
334		$work_time_to = explode(':', Settings::get('work_time_to', '18:00'));
335		$workTime['to']['hour'] = (int)$work_time_to[0];
336		$workTime['to']['minute'] = (isset($work_time_to[1]))?(int)$work_time_to[1]:0;
337
338		return $workTime;
339		}
340
341		/**
342		* Returns if given date is available.
343		*
344		* @param Carbon $date
345		* @param int $exceptId Except reservation ID.
346		*
347		* @return bool
348		*/
349		public function isDateAvailable($date, $exceptId = null)
350		{
351		// get boundary dates for given reservation date
352		$boundaries = $this->datesResolver->getBoundaryDates($date);
353
354		// get all reservations in this date
355		$query = $this->reservations->notCancelled()->whereBetween('date', $boundaries);
356
357		// if updating reservation, we should skip existing reservation
358		if ($exceptId !== null) {
359		$query->where('id', '!=', $exceptId);
360		}
361
362		return $query->count() === 0;
363		}
364
365		/**
366		* Check reservations amount limit per time.
367		*
368		* @throws ApplicationException
369		*/
370		private function checkLimits()
371		{
372		if ($this->isCreatedWhileAgo()) {
373		throw new ApplicationException(Lang::get('vojtasvoboda.reservations::lang.errors.please_wait'));
374		}
375		}
376
377		/**
378		* Try to find some reservation in less then given limit (default 30 seconds).
379		*
380		* @return boolean
381		*/
382		public function isCreatedWhileAgo()
383		{
384		// protection time
385		$time = Config::get('vojtasvoboda.reservations::config.protection_time', '-30 seconds');
386		$timeLimit = Carbon::parse($time)->toDateTimeString();
387
388		// try to find some message
389		$item = $this->reservations->machine()->where('created_at', '>', $timeLimit)->first();
390
391		return $item !== null;
392		}
393		}
394

vojtasvoboda / oc-reservations-plugin

Pull Request — master (#20)

ReservationsFacade::getActiveReservations() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like