Calendar::sameAs() - Code Metrics - Inspection of "Merge pull request #480 from cultuurnet/III-3570-e..." - cultuurnet/udb3-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( bd434e...913de5 )

unknown

created 2020-11-24 09:28 UTC

Calendar::sameAs() A

↳ Parent: Calendar

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace CultuurNet\UDB3;

use Broadway\Serializer\SerializableInterface;
use CultuurNet\UDB3\Calendar\OpeningHour;
use CultuurNet\UDB3\Event\ValueObjects\EventStatusType;
use CultuurNet\UDB3\Model\ValueObject\Calendar\Calendar as Udb3ModelCalendar;
use CultuurNet\UDB3\Model\ValueObject\Calendar\CalendarWithDateRange;
use CultuurNet\UDB3\Model\ValueObject\Calendar\CalendarWithOpeningHours;
use CultuurNet\UDB3\Model\ValueObject\Calendar\CalendarWithSubEvents;
use CultuurNet\UDB3\Model\ValueObject\Calendar\DateRange;
use CultuurNet\UDB3\Model\ValueObject\Calendar\OpeningHours\OpeningHour as Udb3ModelOpeningHour;
use DateTime;
use DateTimeInterface;
use DateTimeZone;
use InvalidArgumentException;

final class Calendar implements CalendarInterface, JsonLdSerializableInterface, SerializableInterface
{
    /**
     * @var CalendarType
     */
    protected $type;

    /**
     * @var DateTimeInterface
     */
    protected $startDate;

    /**
     * @var DateTimeInterface
     */
    protected $endDate;

    /**
     * @var Timestamp[]
     */
    protected $timestamps = [];

    /**
     * @var OpeningHour[]
     */
    protected $openingHours = [];

    /**
     * @param CalendarType $type
     * @param DateTimeInterface|null $startDate
     * @param DateTimeInterface|null $endDate
     * @param Timestamp[] $timestamps
     * @param OpeningHour[] $openingHours
     */
    public function __construct(
        CalendarType $type,
        ?DateTimeInterface $startDate = null,
        ?DateTimeInterface $endDate = null,
        array $timestamps = [],
        array $openingHours = []
    ) {
        if (empty($timestamps) && ($type->is(CalendarType::SINGLE()) || $type->is(CalendarType::MULTIPLE()))) {
            throw new \UnexpectedValueException('A single or multiple calendar should have timestamps.');
        }

        if (($startDate === null || $endDate === null) && $type->is(CalendarType::PERIODIC())) {
            throw new \UnexpectedValueException('A period should have a start- and end-date.');
        }

        foreach ($timestamps as $timestamp) {
            if (!is_a($timestamp, Timestamp::class)) {
                throw new \InvalidArgumentException('Timestamps should have type TimeStamp.');
            }
        }

        foreach ($openingHours as $openingHour) {
            if (!is_a($openingHour, OpeningHour::class)) {
                throw new \InvalidArgumentException('OpeningHours should have type OpeningHour.');
            }
        }

        $this->type = $type->toNative();
        $this->startDate = $startDate;
        $this->endDate = $endDate;
        $this->openingHours = $openingHours;

        usort($timestamps, function (Timestamp $timestamp, Timestamp $otherTimestamp) {
            return $timestamp->getStartDate() <=> $otherTimestamp->getStartDate();
        });

        $this->timestamps = $timestamps;

    }

    public function getType(): CalendarType
    {
        return CalendarType::fromNative($this->type);
    }

    public function serialize(): array
    {
        $serializedTimestamps = array_map(
            function (Timestamp $timestamp) {
                return $timestamp->serialize();
            },
            $this->timestamps
        );

        $serializedOpeningHours = array_map(
            function (OpeningHour $openingHour) {
                return $openingHour->serialize();
            },
            $this->openingHours
        );

        $calendar = [
            'type' => $this->type,
        ];

        empty($this->startDate) ?: $calendar['startDate'] = $this->startDate->format(DateTime::ATOM);
        empty($this->endDate) ?: $calendar['endDate'] = $this->endDate->format(DateTime::ATOM);
        empty($serializedTimestamps) ?: $calendar['timestamps'] = $serializedTimestamps;
        empty($serializedOpeningHours) ?: $calendar['openingHours'] = $serializedOpeningHours;

        return $calendar;
    }

    public static function deserialize(array $data): Calendar
    {
        $calendarType = CalendarType::fromNative($data['type']);

        // Backwards compatibility for serialized single or multiple calendar types that are missing timestamps but do
        // have a start and end date.
        $defaultTimeStamps = [];
        if ($calendarType->sameValueAs(CalendarType::SINGLE()) || $calendarType->sameValueAs(CalendarType::MULTIPLE())) {
            $defaultTimeStampStartDate = !empty($data['startDate']) ? self::deserializeDateTime($data['startDate']) : null;
            $defaultTimeStampEndDate = !empty($data['endDate']) ? self::deserializeDateTime($data['endDate']) : $defaultTimeStampStartDate;
            $defaultTimeStamp = $defaultTimeStampStartDate && $defaultTimeStampEndDate ? new Timestamp($defaultTimeStampStartDate, $defaultTimeStampEndDate) : null;
            $defaultTimeStamps = $defaultTimeStamp ? [$defaultTimeStamp] : [];
        }

        return new self(
            $calendarType,
            !empty($data['startDate']) ? self::deserializeDateTime($data['startDate']) : null,
            !empty($data['endDate']) ? self::deserializeDateTime($data['endDate']) : null,
            !empty($data['timestamps']) ? array_map(
                function ($timestamp) {
                    return Timestamp::deserialize($timestamp);
                },
                $data['timestamps']
            ) : $defaultTimeStamps,
            !empty($data['openingHours']) ? array_map(
                function ($openingHour) {
                    return OpeningHour::deserialize($openingHour);
                },
                $data['openingHours']
            ) : []
        );
    }

    /**
     * This deserialization function takes into account old data that might be missing a timezone.
     * It will fall back to creating a DateTime object and assume Brussels.
     * If this still fails an error will be thrown.
     */
    private static function deserializeDateTime(string $dateTimeData): DateTime
    {
        $dateTime = DateTime::createFromFormat(DateTime::ATOM, $dateTimeData);

        if ($dateTime === false) {
            $dateTime = DateTime::createFromFormat('Y-m-d\TH:i:s', $dateTimeData, new DateTimeZone('Europe/Brussels'));

            if (!$dateTime) {
                throw new InvalidArgumentException('Invalid date string provided for timestamp, ISO8601 expected!');
            }
        }

        return $dateTime;
    }

    public function getStartDate(): ?DateTimeInterface
    {
        $timestamps = $this->getTimestamps();

        if (empty($timestamps)) {
            return $this->startDate;
        }

        $startDate = null;
        foreach ($timestamps as $timestamp) {
            if ($startDate === null || $timestamp->getStartDate() < $startDate) {
                $startDate = $timestamp->getStartDate();
            }
        }

        return $startDate;
    }

    public function getEndDate(): ?DateTimeInterface
    {
        $timestamps = $this->getTimestamps();

        if (empty($timestamps)) {
            return $this->endDate;
        }

        $endDate = null;
        foreach ($this->getTimestamps() as $timestamp) {
            if ($endDate === null || $timestamp->getEndDate() > $endDate) {
                $endDate = $timestamp->getEndDate();
            }
        }

        return $endDate;
    }

    /**
     * @return array|OpeningHour[]
     */
    public function getOpeningHours(): array
    {
        return $this->openingHours;
    }

    /**
     * @return array|Timestamp[]
     */
    public function getTimestamps(): array
    {
        return $this->timestamps;
    }

    public function getEventStatusType(): EventStatusType
    {
        $eventStatusTypeCounts = [];
        $eventStatusTypeCounts[EventStatusType::scheduled()->toNative()] = 0;
        $eventStatusTypeCounts[EventStatusType::postponed()->toNative()] = 0;
        $eventStatusTypeCounts[EventStatusType::cancelled()->toNative()] = 0;

        foreach ($this->timestamps as $timestamp) {
            ++$eventStatusTypeCounts[$timestamp->getEventStatus()->getEventStatusType()->toNative()];
        }

        if ($eventStatusTypeCounts[EventStatusType::scheduled()->toNative()] > 0) {
            return EventStatusType::scheduled();
        }

        if ($eventStatusTypeCounts[EventStatusType::postponed()->toNative()] > 0) {
            return EventStatusType::postponed();
        }

        if ($eventStatusTypeCounts[EventStatusType::cancelled()->toNative()] > 0) {
            return EventStatusType::cancelled();
        }

        // This extra return is needed for events with calendar type of permanent or periodic.
        return EventStatusType::scheduled();
    }

    public function toJsonLd(): array
    {
        $jsonLd = [];

        $jsonLd['calendarType'] = $this->getType()->toNative();

        $startDate = $this->getStartDate();
        $endDate = $this->getEndDate();
        if ($startDate !== null) {
            $jsonLd['startDate'] = $startDate->format(DateTime::ATOM);
        }
        if ($endDate !== null) {
            $jsonLd['endDate'] = $endDate->format(DateTime::ATOM);
        }

        $jsonLd['eventStatus'] = $this->getEventStatusType()->toNative();

        $timestamps = $this->getTimestamps();
        if (!empty($timestamps)) {
            $jsonLd['subEvent'] = [];
            foreach ($timestamps as $timestamp) {
                $jsonLd['subEvent'][] = $timestamp->toJsonLd();
            }
        }

        $openingHours = $this->getOpeningHours();
        if (!empty($openingHours)) {
            $jsonLd['openingHours'] = [];
            foreach ($openingHours as $openingHour) {
                $jsonLd['openingHours'][] = $openingHour->serialize();
            }
        }

        return $jsonLd;
    }

    public function sameAs(Calendar $otherCalendar): bool
    {
        return $this->toJsonLd() === $otherCalendar->toJsonLd();
    }

    public static function fromUdb3ModelCalendar(Udb3ModelCalendar $calendar): Calendar
    {
        $type = CalendarType::fromNative($calendar->getType()->toString());

        $startDate = null;
        $endDate = null;
        $timestamps = [];
        $openingHours = [];

        if ($calendar instanceof CalendarWithDateRange) {
            $startDate = $calendar->getStartDate();
            $endDate = $calendar->getEndDate();
        }

        if ($calendar instanceof CalendarWithSubEvents) {
            $timestamps = array_map(
                function (DateRange $dateRange) {
                    return Timestamp::fromUdb3ModelDateRange($dateRange);
                },
                $calendar->getSubEvents()->toArray()
            );
        }

        if ($calendar instanceof CalendarWithOpeningHours) {
            $openingHours = array_map(
                function (Udb3ModelOpeningHour $openingHour) {
                    return OpeningHour::fromUdb3ModelOpeningHour($openingHour);
                },
                $calendar->getOpeningHours()->toArray()
            );
        }

        return new self($type, $startDate, $endDate, $timestamps, $openingHours);
    }
}


1			<?php
2
3			namespace CultuurNet\UDB3;
4
5			use Broadway\Serializer\SerializableInterface;
6			use CultuurNet\UDB3\Calendar\OpeningHour;
7			use CultuurNet\UDB3\Event\ValueObjects\EventStatusType;
8			use CultuurNet\UDB3\Model\ValueObject\Calendar\Calendar as Udb3ModelCalendar;
9			use CultuurNet\UDB3\Model\ValueObject\Calendar\CalendarWithDateRange;
10			use CultuurNet\UDB3\Model\ValueObject\Calendar\CalendarWithOpeningHours;
11			use CultuurNet\UDB3\Model\ValueObject\Calendar\CalendarWithSubEvents;
12			use CultuurNet\UDB3\Model\ValueObject\Calendar\DateRange;
13			use CultuurNet\UDB3\Model\ValueObject\Calendar\OpeningHours\OpeningHour as Udb3ModelOpeningHour;
14			use DateTime;
15			use DateTimeInterface;
16			use DateTimeZone;
17			use InvalidArgumentException;
18
19			final class Calendar implements CalendarInterface, JsonLdSerializableInterface, SerializableInterface
20			{
21			/**
22			* @var CalendarType
23			*/
24			protected $type;
25
26			/**
27			* @var DateTimeInterface
28			*/
29			protected $startDate;
30
31			/**
32			* @var DateTimeInterface
33			*/
34			protected $endDate;
35
36			/**
37			* @var Timestamp[]
38			*/
39			protected $timestamps = [];
40
41			/**
42			* @var OpeningHour[]
43			*/
44			protected $openingHours = [];
45
46			/**
47			* @param CalendarType $type
48			* @param DateTimeInterface\|null $startDate
49			* @param DateTimeInterface\|null $endDate
50			* @param Timestamp[] $timestamps
51			* @param OpeningHour[] $openingHours
52			*/
53			public function __construct(
54			CalendarType $type,
55			?DateTimeInterface $startDate = null,
56			?DateTimeInterface $endDate = null,
57			array $timestamps = [],
58			array $openingHours = []
59			) {
60			if (empty($timestamps) && ($type->is(CalendarType::SINGLE()) \|\| $type->is(CalendarType::MULTIPLE()))) {
61			throw new \UnexpectedValueException('A single or multiple calendar should have timestamps.');
62			}
63
64			if (($startDate === null \|\| $endDate === null) && $type->is(CalendarType::PERIODIC())) {
65			throw new \UnexpectedValueException('A period should have a start- and end-date.');
66			}
67
68			foreach ($timestamps as $timestamp) {
69			if (!is_a($timestamp, Timestamp::class)) {
70			throw new \InvalidArgumentException('Timestamps should have type TimeStamp.');
71			}
72			}
73
74			foreach ($openingHours as $openingHour) {
75			if (!is_a($openingHour, OpeningHour::class)) {
76			throw new \InvalidArgumentException('OpeningHours should have type OpeningHour.');
77			}
78			}
79
80			$this->type = $type->toNative();
81			$this->startDate = $startDate;
82			$this->endDate = $endDate;
83			$this->openingHours = $openingHours;
84
85			usort($timestamps, function (Timestamp $timestamp, Timestamp $otherTimestamp) {
86			return $timestamp->getStartDate() <=> $otherTimestamp->getStartDate();
87			});
88
89			$this->timestamps = $timestamps;
90
91			}
92
93			public function getType(): CalendarType
94			{
95			return CalendarType::fromNative($this->type);
96			}
97
98			public function serialize(): array
99			{
100			$serializedTimestamps = array_map(
101			function (Timestamp $timestamp) {
102			return $timestamp->serialize();
103			},
104			$this->timestamps
105			);
106
107			$serializedOpeningHours = array_map(
108			function (OpeningHour $openingHour) {
109			return $openingHour->serialize();
110			},
111			$this->openingHours
112			);
113
114			$calendar = [
115			'type' => $this->type,
116			];
117
118			empty($this->startDate) ?: $calendar['startDate'] = $this->startDate->format(DateTime::ATOM);
119			empty($this->endDate) ?: $calendar['endDate'] = $this->endDate->format(DateTime::ATOM);
120			empty($serializedTimestamps) ?: $calendar['timestamps'] = $serializedTimestamps;
121			empty($serializedOpeningHours) ?: $calendar['openingHours'] = $serializedOpeningHours;
122
123			return $calendar;
124			}
125
126			public static function deserialize(array $data): Calendar
127			{
128			$calendarType = CalendarType::fromNative($data['type']);
129
130			// Backwards compatibility for serialized single or multiple calendar types that are missing timestamps but do
131			// have a start and end date.
132			$defaultTimeStamps = [];
133			if ($calendarType->sameValueAs(CalendarType::SINGLE()) \|\| $calendarType->sameValueAs(CalendarType::MULTIPLE())) {
134			$defaultTimeStampStartDate = !empty($data['startDate']) ? self::deserializeDateTime($data['startDate']) : null;
135			$defaultTimeStampEndDate = !empty($data['endDate']) ? self::deserializeDateTime($data['endDate']) : $defaultTimeStampStartDate;
136			$defaultTimeStamp = $defaultTimeStampStartDate && $defaultTimeStampEndDate ? new Timestamp($defaultTimeStampStartDate, $defaultTimeStampEndDate) : null;
137			$defaultTimeStamps = $defaultTimeStamp ? [$defaultTimeStamp] : [];
138			}
139
140			return new self(
141			$calendarType,
142			!empty($data['startDate']) ? self::deserializeDateTime($data['startDate']) : null,
143			!empty($data['endDate']) ? self::deserializeDateTime($data['endDate']) : null,
144			!empty($data['timestamps']) ? array_map(
145			function ($timestamp) {
146			return Timestamp::deserialize($timestamp);
147			},
148			$data['timestamps']
149			) : $defaultTimeStamps,
150			!empty($data['openingHours']) ? array_map(
151			function ($openingHour) {
152			return OpeningHour::deserialize($openingHour);
153			},
154			$data['openingHours']
155			) : []
156			);
157			}
158
159			/**
160			* This deserialization function takes into account old data that might be missing a timezone.
161			* It will fall back to creating a DateTime object and assume Brussels.
162			* If this still fails an error will be thrown.
163			*/
164			private static function deserializeDateTime(string $dateTimeData): DateTime
165			{
166			$dateTime = DateTime::createFromFormat(DateTime::ATOM, $dateTimeData);
167
168			if ($dateTime === false) {
169			$dateTime = DateTime::createFromFormat('Y-m-d\TH:i:s', $dateTimeData, new DateTimeZone('Europe/Brussels'));
170
171			if (!$dateTime) {
172			throw new InvalidArgumentException('Invalid date string provided for timestamp, ISO8601 expected!');
173			}
174			}
175
176			return $dateTime;
177			}
178
179			public function getStartDate(): ?DateTimeInterface
180			{
181			$timestamps = $this->getTimestamps();
182
183			if (empty($timestamps)) {
184			return $this->startDate;
185			}
186
187			$startDate = null;
188			foreach ($timestamps as $timestamp) {
189			if ($startDate === null \|\| $timestamp->getStartDate() < $startDate) {
190			$startDate = $timestamp->getStartDate();
191			}
192			}
193
194			return $startDate;
195			}
196
197			public function getEndDate(): ?DateTimeInterface
198			{
199			$timestamps = $this->getTimestamps();
200
201			if (empty($timestamps)) {
202			return $this->endDate;
203			}
204
205			$endDate = null;
206			foreach ($this->getTimestamps() as $timestamp) {
207			if ($endDate === null \|\| $timestamp->getEndDate() > $endDate) {
208			$endDate = $timestamp->getEndDate();
209			}
210			}
211
212			return $endDate;
213			}
214
215			/**
216			* @return array\|OpeningHour[]
217			*/
218			public function getOpeningHours(): array
219			{
220			return $this->openingHours;
221			}
222
223			/**
224			* @return array\|Timestamp[]
225			*/
226			public function getTimestamps(): array
227			{
228			return $this->timestamps;
229			}
230
231			public function getEventStatusType(): EventStatusType
232			{
233			$eventStatusTypeCounts = [];
234			$eventStatusTypeCounts[EventStatusType::scheduled()->toNative()] = 0;
235			$eventStatusTypeCounts[EventStatusType::postponed()->toNative()] = 0;
236			$eventStatusTypeCounts[EventStatusType::cancelled()->toNative()] = 0;
237
238			foreach ($this->timestamps as $timestamp) {
239			++$eventStatusTypeCounts[$timestamp->getEventStatus()->getEventStatusType()->toNative()];
240			}
241
242			if ($eventStatusTypeCounts[EventStatusType::scheduled()->toNative()] > 0) {
243			return EventStatusType::scheduled();
244			}
245
246			if ($eventStatusTypeCounts[EventStatusType::postponed()->toNative()] > 0) {
247			return EventStatusType::postponed();
248			}
249
250			if ($eventStatusTypeCounts[EventStatusType::cancelled()->toNative()] > 0) {
251			return EventStatusType::cancelled();
252			}
253
254			// This extra return is needed for events with calendar type of permanent or periodic.
255			return EventStatusType::scheduled();
256			}
257
258			public function toJsonLd(): array
259			{
260			$jsonLd = [];
261
262			$jsonLd['calendarType'] = $this->getType()->toNative();
263
264			$startDate = $this->getStartDate();
265			$endDate = $this->getEndDate();
266			if ($startDate !== null) {
267			$jsonLd['startDate'] = $startDate->format(DateTime::ATOM);
268			}
269			if ($endDate !== null) {
270			$jsonLd['endDate'] = $endDate->format(DateTime::ATOM);
271			}
272
273			$jsonLd['eventStatus'] = $this->getEventStatusType()->toNative();
274
275			$timestamps = $this->getTimestamps();
276			if (!empty($timestamps)) {
277			$jsonLd['subEvent'] = [];
278			foreach ($timestamps as $timestamp) {
279			$jsonLd['subEvent'][] = $timestamp->toJsonLd();
280			}
281			}
282
283			$openingHours = $this->getOpeningHours();
284			if (!empty($openingHours)) {
285			$jsonLd['openingHours'] = [];
286			foreach ($openingHours as $openingHour) {
287			$jsonLd['openingHours'][] = $openingHour->serialize();
288			}
289			}
290
291			return $jsonLd;
292			}
293
294			public function sameAs(Calendar $otherCalendar): bool
295			{
296			return $this->toJsonLd() === $otherCalendar->toJsonLd();
297			}
298
299			public static function fromUdb3ModelCalendar(Udb3ModelCalendar $calendar): Calendar
300			{
301			$type = CalendarType::fromNative($calendar->getType()->toString());
302
303			$startDate = null;
304			$endDate = null;
305			$timestamps = [];
306			$openingHours = [];
307
308			if ($calendar instanceof CalendarWithDateRange) {
309			$startDate = $calendar->getStartDate();
310			$endDate = $calendar->getEndDate();
311			}
312
313			if ($calendar instanceof CalendarWithSubEvents) {
314			$timestamps = array_map(
315			function (DateRange $dateRange) {
316			return Timestamp::fromUdb3ModelDateRange($dateRange);
317			},
318			$calendar->getSubEvents()->toArray()
319			);
320			}
321
322			if ($calendar instanceof CalendarWithOpeningHours) {
323			$openingHours = array_map(
324			function (Udb3ModelOpeningHour $openingHour) {
325			return OpeningHour::fromUdb3ModelOpeningHour($openingHour);
326			},
327			$calendar->getOpeningHours()->toArray()
328			);
329			}
330
331			return new self($type, $startDate, $endDate, $timestamps, $openingHours);
332			}
333			}
334

cultuurnet / udb3-php

Push — master ( bd434e...913de5 )

Calendar::sameAs() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like