OpeningHours::forWeekCombined() - Code Metrics - Inspection of "Return combined OpeningHoursForDay" - spatie/opening-hours - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#57)

by Deniss

created 2018-02-24 08:47 UTC

OpeningHours::forWeekCombined() B

↳ Parent: OpeningHours

Complexity

Conditions	5
Paths	8

Size

Total Lines	23
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	23
rs	8.5906
c	0
b	0
f	0
cc	5
eloc	13
nc	8
nop	0

<?php

namespace Spatie\OpeningHours;

use DateTime;
use DateTimeZone;
use DateTimeInterface;
use Spatie\OpeningHours\Helpers\Arr;
use Spatie\OpeningHours\Exceptions\Exception;
use Spatie\OpeningHours\Exceptions\InvalidDate;
use Spatie\OpeningHours\Exceptions\InvalidDayName;

class OpeningHours
{
    /** @var \Spatie\OpeningHours\Day[] */
    protected $openingHours = [];

    /** @var array */
    protected $exceptions = [];

    /** @var DateTimeZone|null */
    protected $timezone = null;

    public function __construct($timezone = null)
    {
        $this->timezone = $timezone ? new DateTimeZone($timezone) : null;

        $this->openingHours = Day::mapDays(function () {
            return new OpeningHoursForDay();
        });
    }

    /**
     * @param array $data
     *
     * @return static
     */
    public static function create(array $data)
    {
        return (new static())->fill($data);
    }

    /**
     * @param array $data
     *
     * @return bool
     */
    public static function isValid(array $data): bool
    {
        try {
            static::create($data);

            return true;
        } catch (Exception $exception) {
            return false;
        }
    }

    public function fill(array $data)
    {
        list($openingHours, $exceptions) = $this->parseOpeningHoursAndExceptions($data);

        foreach ($openingHours as $day => $openingHoursForThisDay) {
            $this->setOpeningHoursFromStrings($day, $openingHoursForThisDay);
        }

        $this->setExceptionsFromStrings($exceptions);

        return $this;
    }

    public function forWeek(): array
    {
        return $this->openingHours;
    }

    public function forWeekCombined(): array
    {
        $equalDays = [];
        $allOpeningHours = $this->openingHours;
        $uniqueOpeningHours = array_unique($allOpeningHours);
        $nonUniqueOpeningHours = $allOpeningHours;

        foreach ($uniqueOpeningHours as $day => $value) {
            $equalDays[$day] = ['days' => [$day], 'opening_hours' => $value];
            unset($nonUniqueOpeningHours[$day]);
        }

        foreach ($uniqueOpeningHours as $uniqueDay => $uniqueValue) {
            /** @var OpeningHoursForDay $nonUniqueValue */
            foreach ($nonUniqueOpeningHours as $nonUniqueDay => $nonUniqueValue) {
                if ((string) $uniqueValue === (string) $nonUniqueValue) {
                    $equalDays[$uniqueDay]['days'][] = $nonUniqueDay;
                }
            }
        }

        return $equalDays;
    }

    public function forDay(string $day): OpeningHoursForDay
    {
        $day = $this->normalizeDayName($day);

        return $this->openingHours[$day];
    }

    public function forDate(DateTimeInterface $date): OpeningHoursForDay
    {
        $date = $this->applyTimezone($date);

        return $this->exceptions[$date->format('Y-m-d')] ?? ($this->exceptions[$date->format('m-d')] ?? $this->forDay(Day::onDateTime($date)));
    }

    public function exceptions(): array
    {
        return $this->exceptions;
    }

    public function isOpenOn(string $day): bool
    {
        return count($this->forDay($day)) > 0;
    }

    public function isClosedOn(string $day): bool
    {
        return ! $this->isOpenOn($day);
    }

    public function isOpenAt(DateTimeInterface $dateTime): bool
    {
        $dateTime = $this->applyTimezone($dateTime);

        $openingHoursForDay = $this->forDate($dateTime);

        return $openingHoursForDay->isOpenAt(Time::fromDateTime($dateTime));
    }

    public function isClosedAt(DateTimeInterface $dateTime): bool
    {
        return ! $this->isOpenAt($dateTime);
    }

    public function isOpen(): bool
    {
        return $this->isOpenAt(new DateTime());
    }

    public function isClosed(): bool
    {
        return $this->isClosedAt(new DateTime());
    }

    public function nextOpen(DateTimeInterface $dateTime): DateTime
    {
        $openingHoursForDay = $this->forDate($dateTime);
        $nextOpen = $openingHoursForDay->nextOpen(Time::fromDateTime($dateTime));

        while ($nextOpen == false) {
            $dateTime
                ->modify('+1 day')
                ->setTime(0, 0, 0);

            $openingHoursForDay = $this->forDate($dateTime);

            $nextOpen = $openingHoursForDay->nextOpen(Time::fromDateTime($dateTime));
        }

        $nextDateTime = $nextOpen->toDateTime();
        $dateTime->setTime($nextDateTime->format('G'), $nextDateTime->format('i'), 0);

        return $dateTime;
    }

    public function regularClosingDays(): array
    {
        return array_keys($this->filter(function (OpeningHoursForDay $openingHoursForDay) {
            return $openingHoursForDay->isEmpty();
        }));
    }

    public function regularClosingDaysISO(): array
    {
        return Arr::map($this->regularClosingDays(), [Day::class, 'toISO']);
    }

    public function exceptionalClosingDates(): array
    {
        $dates = array_keys($this->filterExceptions(function (OpeningHoursForDay $openingHoursForDay, $date) {

            return $openingHoursForDay->isEmpty();
        }));

        return Arr::map($dates, function ($date) {
            return DateTime::createFromFormat('Y-m-d', $date);
        });
    }

    public function setTimezone($timezone)
    {
        $this->timezone = new DateTimeZone($timezone);
    }

    protected function parseOpeningHoursAndExceptions(array $data): array
    {
        $exceptions = Arr::pull($data, 'exceptions', []);
        $openingHours = [];

        foreach ($data as $day => $openingHoursData) {
            $openingHours[$this->normalizeDayName($day)] = $openingHoursData;
        }

        return [$openingHours, $exceptions];
    }

    protected function setOpeningHoursFromStrings(string $day, array $openingHours)
    {
        $day = $this->normalizeDayName($day);

        $this->openingHours[$day] = OpeningHoursForDay::fromStrings($openingHours);
    }

    protected function setExceptionsFromStrings(array $exceptions)
    {
        $this->exceptions = Arr::map($exceptions, function (array $openingHours, string $date) {
            $recurring = DateTime::createFromFormat('m-d', $date);

            if ($recurring === false || $recurring->format('m-d') !== $date) {
                $dateTime = DateTime::createFromFormat('Y-m-d', $date);

                if ($dateTime === false || $dateTime->format('Y-m-d') !== $date) {
                    throw InvalidDate::invalidDate($date);
                }
            }

            return OpeningHoursForDay::fromStrings($openingHours);
        });
    }

    protected function normalizeDayName(string $day)
    {
        $day = strtolower($day);

        if (! Day::isValid($day)) {
            throw new InvalidDayName();
        }

        return $day;
    }

    protected function applyTimezone(DateTimeInterface $date)
    {
        if ($this->timezone) {
            $date = $date->setTimezone($this->timezone);
        }

        return $date;
    }

    public function filter(callable $callback): array
    {
        return Arr::filter($this->openingHours, $callback);
    }

    public function map(callable $callback): array
    {
        return Arr::map($this->openingHours, $callback);
    }

    public function flatMap(callable $callback): array
    {
        return Arr::flatMap($this->openingHours, $callback);
    }

    public function filterExceptions(callable $callback): array
    {
        return Arr::filter($this->exceptions, $callback);
    }

    public function mapExceptions(callable $callback): array
    {
        return Arr::map($this->exceptions, $callback);
    }

    public function flatMapExceptions(callable $callback): array
    {
        return Arr::flatMap($this->exceptions, $callback);
    }

    public function asStructuredData(): array
    {
        $regularHours = $this->flatMap(function (OpeningHoursForDay $openingHoursForDay, string $day) {

            return $openingHoursForDay->map(function (TimeRange $timeRange) use ($day) {
                return [
                    '@type' => 'OpeningHoursSpecification',
                    'dayOfWeek' => ucfirst($day),
                    'opens' => (string) $timeRange->start(),
                    'closes' => (string) $timeRange->end(),
                ];
            });
        });

        $exceptions = $this->flatMapExceptions(function (OpeningHoursForDay $openingHoursForDay, string $date) {
            if ($openingHoursForDay->isEmpty()) {
                return [[
                    '@type' => 'OpeningHoursSpecification',
                    'opens' => '00:00',
                    'closes' => '00:00',
                    'validFrom' => $date,
                    'validThrough' => $date,
                ]];
            }

            return $openingHoursForDay->map(function (TimeRange $timeRange) use ($date) {

                return [
                    '@type' => 'OpeningHoursSpecification',
                    'opens' => $timeRange->start(),
                    'closes' => $timeRange->end(),
                    'validFrom' => $date,
                    'validThrough' => $date,
                ];
            });
        });

        return array_merge($regularHours, $exceptions);
    }
}


1		<?php
2
3		namespace Spatie\OpeningHours;
4
5		use DateTime;
6		use DateTimeZone;
7		use DateTimeInterface;
8		use Spatie\OpeningHours\Helpers\Arr;
9		use Spatie\OpeningHours\Exceptions\Exception;
10		use Spatie\OpeningHours\Exceptions\InvalidDate;
11		use Spatie\OpeningHours\Exceptions\InvalidDayName;
12
13		class OpeningHours
14		{
15		/** @var \Spatie\OpeningHours\Day[] */
16		protected $openingHours = [];
17
18		/** @var array */
19		protected $exceptions = [];
20
21		/** @var DateTimeZone\|null */
22		protected $timezone = null;
23
24		public function __construct($timezone = null)
25		{
26		$this->timezone = $timezone ? new DateTimeZone($timezone) : null;
27
28		$this->openingHours = Day::mapDays(function () {
29		return new OpeningHoursForDay();
30		});
31		}
32
33		/**
34		* @param array $data
35		*
36		* @return static
37		*/
38		public static function create(array $data)
39		{
40		return (new static())->fill($data);
41		}
42
43		/**
44		* @param array $data
45		*
46		* @return bool
47		*/
48		public static function isValid(array $data): bool
49		{
50		try {
51		static::create($data);
52
53		return true;
54		} catch (Exception $exception) {
55		return false;
56		}
57		}
58
59		public function fill(array $data)
60		{
61		list($openingHours, $exceptions) = $this->parseOpeningHoursAndExceptions($data);
62
63		foreach ($openingHours as $day => $openingHoursForThisDay) {
64		$this->setOpeningHoursFromStrings($day, $openingHoursForThisDay);
65		}
66
67		$this->setExceptionsFromStrings($exceptions);
68
69		return $this;
70		}
71
72		public function forWeek(): array
73		{
74		return $this->openingHours;
75		}
76
77		public function forWeekCombined(): array
78		{
79		$equalDays = [];
80		$allOpeningHours = $this->openingHours;
81		$uniqueOpeningHours = array_unique($allOpeningHours);
82		$nonUniqueOpeningHours = $allOpeningHours;
83
84		foreach ($uniqueOpeningHours as $day => $value) {
85		$equalDays[$day] = ['days' => [$day], 'opening_hours' => $value];
86		unset($nonUniqueOpeningHours[$day]);
87		}
88
89		foreach ($uniqueOpeningHours as $uniqueDay => $uniqueValue) {
90		/** @var OpeningHoursForDay $nonUniqueValue */
91		foreach ($nonUniqueOpeningHours as $nonUniqueDay => $nonUniqueValue) {
92		if ((string) $uniqueValue === (string) $nonUniqueValue) {
93		$equalDays[$uniqueDay]['days'][] = $nonUniqueDay;
94		}
95		}
96		}
97
98		return $equalDays;
99		}
100
101		public function forDay(string $day): OpeningHoursForDay
102		{
103		$day = $this->normalizeDayName($day);
104
105		return $this->openingHours[$day];
106		}
107
108		public function forDate(DateTimeInterface $date): OpeningHoursForDay
109		{
110		$date = $this->applyTimezone($date);
111
112		return $this->exceptions[$date->format('Y-m-d')] ?? ($this->exceptions[$date->format('m-d')] ?? $this->forDay(Day::onDateTime($date)));
113		}
114
115		public function exceptions(): array
116		{
117		return $this->exceptions;
118		}
119
120		public function isOpenOn(string $day): bool
121		{
122		return count($this->forDay($day)) > 0;
123		}
124
125		public function isClosedOn(string $day): bool
126		{
127		return ! $this->isOpenOn($day);
128		}
129
130		public function isOpenAt(DateTimeInterface $dateTime): bool
131		{
132		$dateTime = $this->applyTimezone($dateTime);
133
134		$openingHoursForDay = $this->forDate($dateTime);
135
136		return $openingHoursForDay->isOpenAt(Time::fromDateTime($dateTime));
137		}
138
139		public function isClosedAt(DateTimeInterface $dateTime): bool
140		{
141		return ! $this->isOpenAt($dateTime);
142		}
143
144		public function isOpen(): bool
145		{
146		return $this->isOpenAt(new DateTime());
147		}
148
149		public function isClosed(): bool
150		{
151		return $this->isClosedAt(new DateTime());
152		}
153
154		public function nextOpen(DateTimeInterface $dateTime): DateTime
155		{
156		$openingHoursForDay = $this->forDate($dateTime);
157		$nextOpen = $openingHoursForDay->nextOpen(Time::fromDateTime($dateTime));
158
159		while ($nextOpen == false) {
160		$dateTime
161		->modify('+1 day')
162		->setTime(0, 0, 0);
163
164		$openingHoursForDay = $this->forDate($dateTime);
165
166		$nextOpen = $openingHoursForDay->nextOpen(Time::fromDateTime($dateTime));
167		}
168
169		$nextDateTime = $nextOpen->toDateTime();
170		$dateTime->setTime($nextDateTime->format('G'), $nextDateTime->format('i'), 0);
171
172		return $dateTime;
173		}
174
175		public function regularClosingDays(): array
176		{
177		return array_keys($this->filter(function (OpeningHoursForDay $openingHoursForDay) {
178		return $openingHoursForDay->isEmpty();
179		}));
180		}
181
182		public function regularClosingDaysISO(): array
183		{
184		return Arr::map($this->regularClosingDays(), [Day::class, 'toISO']);
185		}
186
187		public function exceptionalClosingDates(): array
188		{
189		$dates = array_keys($this->filterExceptions(function (OpeningHoursForDay $openingHoursForDay, $date) {
		0 ignored issues – show Unused Code introduced 2017-06-01 13:07 UTC by Report Bug Copy Issue Report The parameter `$date` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
190		return $openingHoursForDay->isEmpty();
191		}));
192
193		return Arr::map($dates, function ($date) {
194		return DateTime::createFromFormat('Y-m-d', $date);
195		});
196		}
197
198		public function setTimezone($timezone)
199		{
200		$this->timezone = new DateTimeZone($timezone);
201		}
202
203		protected function parseOpeningHoursAndExceptions(array $data): array
204		{
205		$exceptions = Arr::pull($data, 'exceptions', []);
206		$openingHours = [];
207
208		foreach ($data as $day => $openingHoursData) {
209		$openingHours[$this->normalizeDayName($day)] = $openingHoursData;
210		}
211
212		return [$openingHours, $exceptions];
213		}
214
215		protected function setOpeningHoursFromStrings(string $day, array $openingHours)
216		{
217		$day = $this->normalizeDayName($day);
218
219		$this->openingHours[$day] = OpeningHoursForDay::fromStrings($openingHours);
220		}
221
222		protected function setExceptionsFromStrings(array $exceptions)
223		{
224		$this->exceptions = Arr::map($exceptions, function (array $openingHours, string $date) {
225		$recurring = DateTime::createFromFormat('m-d', $date);
226
227		if ($recurring === false \|\| $recurring->format('m-d') !== $date) {
228		$dateTime = DateTime::createFromFormat('Y-m-d', $date);
229
230		if ($dateTime === false \|\| $dateTime->format('Y-m-d') !== $date) {
231		throw InvalidDate::invalidDate($date);
232		}
233		}
234
235		return OpeningHoursForDay::fromStrings($openingHours);
236		});
237		}
238
239		protected function normalizeDayName(string $day)
240		{
241		$day = strtolower($day);
242
243		if (! Day::isValid($day)) {
244		throw new InvalidDayName();
245		}
246
247		return $day;
248		}
249
250		protected function applyTimezone(DateTimeInterface $date)
251		{
252		if ($this->timezone) {
253		$date = $date->setTimezone($this->timezone);
254		}
255
256		return $date;
257		}
258
259		public function filter(callable $callback): array
260		{
261		return Arr::filter($this->openingHours, $callback);
262		}
263
264		public function map(callable $callback): array
265		{
266		return Arr::map($this->openingHours, $callback);
267		}
268
269		public function flatMap(callable $callback): array
270		{
271		return Arr::flatMap($this->openingHours, $callback);
272		}
273
274		public function filterExceptions(callable $callback): array
275		{
276		return Arr::filter($this->exceptions, $callback);
277		}
278
279		public function mapExceptions(callable $callback): array
280		{
281		return Arr::map($this->exceptions, $callback);
282		}
283
284		public function flatMapExceptions(callable $callback): array
285		{
286		return Arr::flatMap($this->exceptions, $callback);
287		}
288
289		public function asStructuredData(): array
290		{
291	View Code Duplication	$regularHours = $this->flatMap(function (OpeningHoursForDay $openingHoursForDay, string $day) {
		0 ignored issues – show Duplication introduced 2017-01-03 10:41 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
292		return $openingHoursForDay->map(function (TimeRange $timeRange) use ($day) {
293		return [
294		'@type' => 'OpeningHoursSpecification',
295		'dayOfWeek' => ucfirst($day),
296		'opens' => (string) $timeRange->start(),
297		'closes' => (string) $timeRange->end(),
298		];
299		});
300		});
301
302		$exceptions = $this->flatMapExceptions(function (OpeningHoursForDay $openingHoursForDay, string $date) {
303		if ($openingHoursForDay->isEmpty()) {
304		return [[
305		'@type' => 'OpeningHoursSpecification',
306		'opens' => '00:00',
307		'closes' => '00:00',
308		'validFrom' => $date,
309		'validThrough' => $date,
310		]];
311		}
312
313	View Code Duplication	return $openingHoursForDay->map(function (TimeRange $timeRange) use ($date) {
		0 ignored issues – show Duplication introduced 2017-01-03 10:41 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
314		return [
315		'@type' => 'OpeningHoursSpecification',
316		'opens' => $timeRange->start(),
317		'closes' => $timeRange->end(),
318		'validFrom' => $date,
319		'validThrough' => $date,
320		];
321		});
322		});
323
324		return array_merge($regularHours, $exceptions);
325		}
326		}
327

spatie / opening-hours

GitHub Access Token became invalid

Pull Request — master (#57)

OpeningHours::forWeekCombined() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like