CalendarFactory::createFromCdbCalendar() - Code Metrics - Inspection of "Fix end dates in JsonLD projection of events with..." - cultuurnet/udb3-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#454)

by Jonas

created 2020-04-01 14:02 UTC

CalendarFactory::createFromCdbCalendar() F

↳ Parent: CalendarFactory

Complexity

Conditions	27
Paths	9600

Size

Total Lines

143

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	143
rs	0
c	0
b	0
f	0
cc	27
nc	9600
nop	1

How to fix Long Method Complexity

<?php

namespace CultuurNet\UDB3;

use Cake\Chronos\Chronos;
use CultureFeed_Cdb_Data_Calendar_Timestamp;
use CultuurNet\UDB3\Calendar\DayOfWeek;
use CultuurNet\UDB3\Calendar\DayOfWeekCollection;
use CultuurNet\UDB3\Calendar\OpeningHour;
use CultuurNet\UDB3\Calendar\OpeningTime;
use CultuurNet\UDB3\Cdb\DateTimeFactory;
use DateTimeInterface;

class CalendarFactory implements CalendarFactoryInterface
{
    /**
     * @inheritdoc
     */
    public function createFromCdbCalendar(\CultureFeed_Cdb_Data_Calendar $cdbCalendar)
    {
        //
        // Get the start day.
        //
        $cdbCalendar->rewind();
        $startDateString = '';
        if ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_PeriodList) {
            /** @var \CultureFeed_Cdb_Data_Calendar_Period $period */
            $period = $cdbCalendar->current();
            $startDateString = $period->getDateFrom() . 'T00:00:00';
        } elseif ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_TimestampList) {
            $firstTimestamp = $cdbCalendar->current();
            $cdbCalendarAsArray = iterator_to_array($cdbCalendar);
            $timestamp = $this->getFirstTimestamp($cdbCalendarAsArray, $firstTimestamp);
            if ($timestamp->getStartTime()) {
                $startDateString = $timestamp->getDate() . 'T' . substr($timestamp->getStartTime(), 0, 5) . ':00';
            } else {
                $startDateString = $timestamp->getDate() . 'T00:00:00';
            }
        }
        $startDate = !empty($startDateString) ? DateTimeFactory::dateTimeFromDateString($startDateString) : null;

        //
        // Get the end day.
        //
        $cdbCalendar->rewind();
        $endDateString = '';
        if ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_PeriodList) {
            /** @var \CultureFeed_Cdb_Data_Calendar_Period $period */
            $period = $cdbCalendar->current();
            $endDateString = $period->getDateTo() . 'T00:00:00';
        } elseif ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_TimestampList) {
            $firstTimestamp = $cdbCalendar->current();
            /** @var \CultureFeed_Cdb_Data_Calendar_Timestamp $timestamp */
            $cdbCalendarAsArray = iterator_to_array($cdbCalendar);
            $timestamp = $this->getLastTimestamp($cdbCalendarAsArray, $firstTimestamp);
            if ($timestamp->getEndTime()) {
                $endDateString = $timestamp->getDate() . 'T' . $timestamp->getEndTime();
            } else {
                $endTime = $timestamp->getStartTime() ? $timestamp->getStartTime() : '00:00:00';
                $endDateString = $timestamp->getDate() . 'T' . $endTime;
            }
        }
        $endDate = !empty($endDateString) ? DateTimeFactory::dateTimeFromDateString($endDateString) : null;

        //
        // Get the time stamps.
        //
        $cdbCalendar->rewind();
        $timestamps = [];
        if ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_TimestampList) {
            $splitPeriods = [];
            while ($cdbCalendar->valid()) {
                /** @var \CultureFeed_Cdb_Data_Calendar_Timestamp $timestamp */
                $timestamp = $cdbCalendar->current();
                $cdbCalendar->next();

                $startTime = $timestamp->getStartTime() ? $timestamp->getStartTime() : '00:00:00';
                $startDateString = $timestamp->getDate() . 'T' . $startTime;

                if ($timestamp->getEndTime()) {
                    $endDateString = $timestamp->getDate() . 'T' . $timestamp->getEndTime();
                } else {
                    $endDateString = $timestamp->getDate() . 'T' . $startTime;
                }

                $timestamp = $this->createTimestamp(
                    $startDateString,
                    $endDateString
                );

                $index = intval($timestamp->getStartDate()->format('s'));
                if ($index > 0) {
                    $splitPeriods[$index][] = $timestamp;
                } else {
                    $timestamps[] = $timestamp;
                }
            }

            $periods = array_map(
                function (array $periodParts) {
                    $firstPart = array_shift($periodParts);
                    $lastPart = array_pop($periodParts);
                    return new Timestamp(
                        Chronos::instance($firstPart->getStartDate())->second(0),
                        $lastPart ? $lastPart->getEndDate() : $firstPart->getEndDate()
                    );
                },
                $splitPeriods
            );

            $timestamps = array_merge($timestamps, $periods);
        }

        //
        // Get the opening hours.
        //
        $cdbCalendar->rewind();
        $openingHours = [];

        $weekSchema = null;
        if ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_PeriodList) {
            $period = $cdbCalendar->current();
            $weekSchema = $period->getWeekScheme();
        } elseif ($cdbCalendar instanceof  \CultureFeed_Cdb_Data_Calendar_Permanent) {
            $weekSchema = $cdbCalendar->getWeekScheme();
        }

        if ($weekSchema) {
            $openingHours = $this->createOpeningHoursFromWeekScheme($weekSchema);
        }

        if (isset($startDate) && isset($endDate)) {
            $calendarTimeSpan = $this->createChronologicalTimestamp($startDate, $endDate);
        }

        //
        // Get the calendar type.
        //
        $calendarType = null;
        if ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_Permanent) {
            $calendarType = CalendarType::PERMANENT();
        } elseif ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_PeriodList) {
            $calendarType = CalendarType::PERIODIC();
        } elseif ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_TimestampList) {
            $calendarType = CalendarType::SINGLE();
            if (count($timestamps) > 1) {
                $calendarType = CalendarType::MULTIPLE();
            }
        }

        //
        // Create the calendar value object.
        //
        return new Calendar(
            $calendarType,
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            isset($calendarTimeSpan) ? $calendarTimeSpan->getStartDate() : null,
            isset($calendarTimeSpan) ? $calendarTimeSpan->getEndDate() : null,
            $timestamps,
            $openingHours
        );
    }

    /**
     * @param \CultureFeed_Cdb_Data_Calendar_Weekscheme|null $weekScheme
     * @return Calendar
     */
    public function createFromWeekScheme(
        \CultureFeed_Cdb_Data_Calendar_Weekscheme $weekScheme = null
    ) {
        $openingHours = [];

        if ($weekScheme) {
            $openingHours = $this->createOpeningHoursFromWeekScheme($weekScheme);
        }

        return new Calendar(
            CalendarType::PERMANENT(),
            null,
            null,
            [],
            $openingHours
        );
    }

    /**
     * @param \CultureFeed_Cdb_Data_Calendar_Weekscheme $weekScheme
     * @return OpeningHour[]
     */
    private function createOpeningHoursFromWeekScheme(
        \CultureFeed_Cdb_Data_Calendar_Weekscheme $weekScheme
    ) {
        $openingHours = [];

        foreach ($weekScheme->getDays() as $day) {
            if ($day->isOpen()) {
                /** @var \CultureFeed_Cdb_Data_Calendar_OpeningTime[] $openingTimes */
                $openingTimes = $day->getOpeningTimes();

                // A day could be marked as open but without any hours.
                // This means all day open but needs to be mapped to 00:00:00.
                if (count($openingTimes) === 0) {
                    $openingTimes[] = new \CultureFeed_Cdb_Data_Calendar_OpeningTime(
                        '00:00:00',
                        '00:00:00'
                    );
                }

                foreach ($openingTimes as $openingTime) {
                    $opens = \DateTime::createFromFormat(
                        'H:i:s',
                        $openingTime->getOpenFrom()
                    );
                    $closes = \DateTime::createFromFormat(
                        'H:i:s',
                        $openingTime->getOpenTill()
                    );

                    $openingHour = new OpeningHour(
                        OpeningTime::fromNativeDateTime($opens),
<?php

function getDate($date)
{
    if ($date !== null) {
        return new DateTime($date);
    }

    return false;
}
                        $closes ? OpeningTime::fromNativeDateTime($closes) : OpeningTime::fromNativeDateTime($opens),
<?php

function getDate($date)
{
    if ($date !== null) {
        return new DateTime($date);
    }

    return false;
}
                        new DayOfWeekCollection(DayOfWeek::fromNative($day->getDayName()))
                    );

                    $openingHours = $this->addToOpeningHours($openingHour, ...$openingHours);
                }
            }
        }

        return $openingHours;
    }

    /**
     * @param OpeningHour $newOpeningHour
     * @param OpeningHour[] ...$openingHours
     * @return OpeningHour[]
     */
    private function addToOpeningHours(
        OpeningHour $newOpeningHour,
        OpeningHour ...$openingHours
    ) {
        foreach ($openingHours as $openingHour) {
            if ($openingHour->hasEqualHours($newOpeningHour)) {

                $openingHour->addDayOfWeekCollection(

                    $newOpeningHour->getDayOfWeekCollection()
                );
                return $openingHours;
            }
        }

        $openingHours[] = $newOpeningHour;
        return $openingHours;
    }

    /**
     * @param string $startDateString
     * @param string $endDateString
     * @return Timestamp
     */
    private function createTimestamp(
        $startDateString,
        $endDateString
    ) {
        $startDate = DateTimeFactory::dateTimeFromDateString($startDateString);
        $endDate = DateTimeFactory::dateTimeFromDateString($endDateString);

        return $this->createChronologicalTimestamp($startDate, $endDate);
    }

    /**
     * End date might be before start date in cdbxml when event takes place
     * between e.g. 9 PM and 3 AM (the next day). To keep the dates chronological we push the end to the next day.
     *
     * If the end dates does not make any sense at all, it is forced to the start date.
     *
     * @param DateTimeInterface $start
     * @param DateTimeInterface $end
     *
     * @return Timestamp
     */
    private function createChronologicalTimestamp(DateTimeInterface $start, DateTimeInterface $end)
    {
        $startDate = Chronos::instance($start);
        $endDate = Chronos::instance($end);

        if ($startDate->isSameDay($endDate) && $endDate->lt($startDate)) {
            $endDate = $endDate->addDay();
        }

        if ($endDate->lt($startDate)) {
            $endDate = $startDate;
        }

        return new Timestamp($startDate, $endDate);
    }

    /**
     * @param CultureFeed_Cdb_Data_Calendar_Timestamp[] $timestampList
     * @param CultureFeed_Cdb_Data_Calendar_Timestamp $default
     * @return CultureFeed_Cdb_Data_Calendar_Timestamp
     */
    private function getLastTimestamp(array $timestampList, CultureFeed_Cdb_Data_Calendar_Timestamp $default)

    {
        $lastTimestamp = $default;
        foreach ($timestampList as $timestamp) {
            $currentEndDate = Chronos::parse($lastTimestamp->getEndDate());
            $endDate = Chronos::parse($timestamp->getEndDate());
            if ($currentEndDate->lt($endDate)) {
                $lastTimestamp = $timestamp;
            }
        }

        return $lastTimestamp;
    }

    /**
     * @param CultureFeed_Cdb_Data_Calendar_Timestamp[] $timestampList
     * @param CultureFeed_Cdb_Data_Calendar_Timestamp $default
     * @return CultureFeed_Cdb_Data_Calendar_Timestamp
     */
    private function getFirstTimestamp(array $timestampList, CultureFeed_Cdb_Data_Calendar_Timestamp $default)

    {
        $firstTimestamp = $default;
        foreach ($timestampList as $timestamp) {
            $currentStartTime = Chronos::parse($firstTimestamp->getDate());
            $startTime = Chronos::parse($timestamp->getDate());
            if ($currentStartTime->gt($startTime)) {
                $firstTimestamp = $timestamp;
            }
        }

        return $firstTimestamp;
    }
}


1		<?php
2
3		namespace CultuurNet\UDB3;
4
5		use Cake\Chronos\Chronos;
6		use CultureFeed_Cdb_Data_Calendar_Timestamp;
7		use CultuurNet\UDB3\Calendar\DayOfWeek;
8		use CultuurNet\UDB3\Calendar\DayOfWeekCollection;
9		use CultuurNet\UDB3\Calendar\OpeningHour;
10		use CultuurNet\UDB3\Calendar\OpeningTime;
11		use CultuurNet\UDB3\Cdb\DateTimeFactory;
12		use DateTimeInterface;
13
14		class CalendarFactory implements CalendarFactoryInterface
15		{
16		/**
17		* @inheritdoc
18		*/
19		public function createFromCdbCalendar(\CultureFeed_Cdb_Data_Calendar $cdbCalendar)
20		{
21		//
22		// Get the start day.
23		//
24		$cdbCalendar->rewind();
25		$startDateString = '';
26		if ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_PeriodList) {
27		/** @var \CultureFeed_Cdb_Data_Calendar_Period $period */
28		$period = $cdbCalendar->current();
29		$startDateString = $period->getDateFrom() . 'T00:00:00';
30		} elseif ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_TimestampList) {
31		$firstTimestamp = $cdbCalendar->current();
32		$cdbCalendarAsArray = iterator_to_array($cdbCalendar);
33		$timestamp = $this->getFirstTimestamp($cdbCalendarAsArray, $firstTimestamp);
34		if ($timestamp->getStartTime()) {
35		$startDateString = $timestamp->getDate() . 'T' . substr($timestamp->getStartTime(), 0, 5) . ':00';
36		} else {
37		$startDateString = $timestamp->getDate() . 'T00:00:00';
38		}
39		}
40		$startDate = !empty($startDateString) ? DateTimeFactory::dateTimeFromDateString($startDateString) : null;
41
42		//
43		// Get the end day.
44		//
45		$cdbCalendar->rewind();
46		$endDateString = '';
47		if ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_PeriodList) {
48		/** @var \CultureFeed_Cdb_Data_Calendar_Period $period */
49		$period = $cdbCalendar->current();
50		$endDateString = $period->getDateTo() . 'T00:00:00';
51		} elseif ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_TimestampList) {
52		$firstTimestamp = $cdbCalendar->current();
53		/** @var \CultureFeed_Cdb_Data_Calendar_Timestamp $timestamp */
54		$cdbCalendarAsArray = iterator_to_array($cdbCalendar);
55		$timestamp = $this->getLastTimestamp($cdbCalendarAsArray, $firstTimestamp);
56		if ($timestamp->getEndTime()) {
57		$endDateString = $timestamp->getDate() . 'T' . $timestamp->getEndTime();
58		} else {
59		$endTime = $timestamp->getStartTime() ? $timestamp->getStartTime() : '00:00:00';
60		$endDateString = $timestamp->getDate() . 'T' . $endTime;
61		}
62		}
63		$endDate = !empty($endDateString) ? DateTimeFactory::dateTimeFromDateString($endDateString) : null;
64
65		//
66		// Get the time stamps.
67		//
68		$cdbCalendar->rewind();
69		$timestamps = [];
70		if ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_TimestampList) {
71		$splitPeriods = [];
72		while ($cdbCalendar->valid()) {
73		/** @var \CultureFeed_Cdb_Data_Calendar_Timestamp $timestamp */
74		$timestamp = $cdbCalendar->current();
75		$cdbCalendar->next();
76
77		$startTime = $timestamp->getStartTime() ? $timestamp->getStartTime() : '00:00:00';
78		$startDateString = $timestamp->getDate() . 'T' . $startTime;
79
80		if ($timestamp->getEndTime()) {
81		$endDateString = $timestamp->getDate() . 'T' . $timestamp->getEndTime();
82		} else {
83		$endDateString = $timestamp->getDate() . 'T' . $startTime;
84		}
85
86		$timestamp = $this->createTimestamp(
87		$startDateString,
88		$endDateString
89		);
90
91		$index = intval($timestamp->getStartDate()->format('s'));
92		if ($index > 0) {
93		$splitPeriods[$index][] = $timestamp;
94		} else {
95		$timestamps[] = $timestamp;
96		}
97		}
98
99		$periods = array_map(
100		function (array $periodParts) {
101		$firstPart = array_shift($periodParts);
102		$lastPart = array_pop($periodParts);
103		return new Timestamp(
104		Chronos::instance($firstPart->getStartDate())->second(0),
105		$lastPart ? $lastPart->getEndDate() : $firstPart->getEndDate()
106		);
107		},
108		$splitPeriods
109		);
110
111		$timestamps = array_merge($timestamps, $periods);
112		}
113
114		//
115		// Get the opening hours.
116		//
117		$cdbCalendar->rewind();
118		$openingHours = [];
119
120		$weekSchema = null;
121		if ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_PeriodList) {
122		$period = $cdbCalendar->current();
123		$weekSchema = $period->getWeekScheme();
124		} elseif ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_Permanent) {
125		$weekSchema = $cdbCalendar->getWeekScheme();
126		}
127
128		if ($weekSchema) {
129		$openingHours = $this->createOpeningHoursFromWeekScheme($weekSchema);
130		}
131
132		if (isset($startDate) && isset($endDate)) {
133		$calendarTimeSpan = $this->createChronologicalTimestamp($startDate, $endDate);
134		}
135
136		//
137		// Get the calendar type.
138		//
139		$calendarType = null;
140		if ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_Permanent) {
141		$calendarType = CalendarType::PERMANENT();
142		} elseif ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_PeriodList) {
143		$calendarType = CalendarType::PERIODIC();
144		} elseif ($cdbCalendar instanceof \CultureFeed_Cdb_Data_Calendar_TimestampList) {
145		$calendarType = CalendarType::SINGLE();
146		if (count($timestamps) > 1) {
147		$calendarType = CalendarType::MULTIPLE();
148		}
149		}
150
151		//
152		// Create the calendar value object.
153		//
154		return new Calendar(
155		$calendarType,
		0 ignored issues – show Bug introduced 2017-05-16 12:11 UTC by Report Bug Copy Issue Report It seems like `$calendarType` defined by `null` on line `139` can be `null`; however, `CultuurNet\UDB3\Calendar::__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
156		isset($calendarTimeSpan) ? $calendarTimeSpan->getStartDate() : null,
157		isset($calendarTimeSpan) ? $calendarTimeSpan->getEndDate() : null,
158		$timestamps,
159		$openingHours
160		);
161		}
162
163		/**
164		* @param \CultureFeed_Cdb_Data_Calendar_Weekscheme\|null $weekScheme
165		* @return Calendar
166		*/
167		public function createFromWeekScheme(
168		\CultureFeed_Cdb_Data_Calendar_Weekscheme $weekScheme = null
169		) {
170		$openingHours = [];
171
172		if ($weekScheme) {
173		$openingHours = $this->createOpeningHoursFromWeekScheme($weekScheme);
174		}
175
176		return new Calendar(
177		CalendarType::PERMANENT(),
178		null,
179		null,
180		[],
181		$openingHours
182		);
183		}
184
185		/**
186		* @param \CultureFeed_Cdb_Data_Calendar_Weekscheme $weekScheme
187		* @return OpeningHour[]
188		*/
189		private function createOpeningHoursFromWeekScheme(
190		\CultureFeed_Cdb_Data_Calendar_Weekscheme $weekScheme
191		) {
192		$openingHours = [];
193
194		foreach ($weekScheme->getDays() as $day) {
195		if ($day->isOpen()) {
196		/** @var \CultureFeed_Cdb_Data_Calendar_OpeningTime[] $openingTimes */
197		$openingTimes = $day->getOpeningTimes();
198
199		// A day could be marked as open but without any hours.
200		// This means all day open but needs to be mapped to 00:00:00.
201		if (count($openingTimes) === 0) {
202		$openingTimes[] = new \CultureFeed_Cdb_Data_Calendar_OpeningTime(
203		'00:00:00',
204		'00:00:00'
205		);
206		}
207
208		foreach ($openingTimes as $openingTime) {
209		$opens = \DateTime::createFromFormat(
210		'H:i:s',
211		$openingTime->getOpenFrom()
212		);
213		$closes = \DateTime::createFromFormat(
214		'H:i:s',
215		$openingTime->getOpenTill()
216		);
217
218		$openingHour = new OpeningHour(
219		OpeningTime::fromNativeDateTime($opens),
		0 ignored issues – show Security Bug introduced 2017-04-26 08:48 UTC by Report Bug Copy Issue Report It seems like `$opens` defined by `\DateTime::createFromFor...ingTime->getOpenFrom())` on line `209` can also be of type `false`; however, `CultuurNet\UDB3\Calendar...e::fromNativeDateTime()` does only seem to accept `object<DateTimeInterface>`, did you maybe forget to handle an error condition? This check looks for type mismatches where the missing type is `false`. This is usually indicative of an error condtion. Consider the follow example <?php function getDate($date) { if ($date !== null) { return new DateTime($date); } return false; } This function either returns a new `DateTime` object or false, if there was an error. This is a typical pattern in PHP programming to show that an error has occurred without raising an exception. The calling code should check for this returned `false` before passing on the value to another function or method that may not be able to handle a `false`. Loading history...
220		$closes ? OpeningTime::fromNativeDateTime($closes) : OpeningTime::fromNativeDateTime($opens),
		0 ignored issues – show Security Bug introduced 2017-04-26 08:48 UTC by Report Bug Copy Issue Report It seems like `$opens` defined by `\DateTime::createFromFor...ingTime->getOpenFrom())` on line `209` can also be of type `false`; however, `CultuurNet\UDB3\Calendar...e::fromNativeDateTime()` does only seem to accept `object<DateTimeInterface>`, did you maybe forget to handle an error condition? This check looks for type mismatches where the missing type is `false`. This is usually indicative of an error condtion. Consider the follow example <?php function getDate($date) { if ($date !== null) { return new DateTime($date); } return false; } This function either returns a new `DateTime` object or false, if there was an error. This is a typical pattern in PHP programming to show that an error has occurred without raising an exception. The calling code should check for this returned `false` before passing on the value to another function or method that may not be able to handle a `false`. Loading history...
221		new DayOfWeekCollection(DayOfWeek::fromNative($day->getDayName()))
222		);
223
224		$openingHours = $this->addToOpeningHours($openingHour, ...$openingHours);
225		}
226		}
227		}
228
229		return $openingHours;
230		}
231
232		/**
233		* @param OpeningHour $newOpeningHour
234		* @param OpeningHour[] ...$openingHours
235		* @return OpeningHour[]
236		*/
237		private function addToOpeningHours(
238		OpeningHour $newOpeningHour,
239		OpeningHour ...$openingHours
240		) {
241		foreach ($openingHours as $openingHour) {
242		if ($openingHour->hasEqualHours($newOpeningHour)) {
		0 ignored issues – show Bug introduced 2017-04-26 08:48 UTC by Report Bug Copy Issue Report The method `hasEqualHours` cannot be called on `$openingHour` (of type `array<integer,object<Cul...\Calendar\OpeningHour>>`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
243		$openingHour->addDayOfWeekCollection(
		0 ignored issues – show Bug introduced 2017-04-26 11:24 UTC by Report Bug Copy Issue Report The method `addDayOfWeekCollection` cannot be called on `$openingHour` (of type `array<integer,object<Cul...\Calendar\OpeningHour>>`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
244		$newOpeningHour->getDayOfWeekCollection()
245		);
246		return $openingHours;
247		}
248		}
249
250		$openingHours[] = $newOpeningHour;
251		return $openingHours;
252		}
253
254		/**
255		* @param string $startDateString
256		* @param string $endDateString
257		* @return Timestamp
258		*/
259		private function createTimestamp(
260		$startDateString,
261		$endDateString
262		) {
263		$startDate = DateTimeFactory::dateTimeFromDateString($startDateString);
264		$endDate = DateTimeFactory::dateTimeFromDateString($endDateString);
265
266		return $this->createChronologicalTimestamp($startDate, $endDate);
267		}
268
269		/**
270		* End date might be before start date in cdbxml when event takes place
271		* between e.g. 9 PM and 3 AM (the next day). To keep the dates chronological we push the end to the next day.
272		*
273		* If the end dates does not make any sense at all, it is forced to the start date.
274		*
275		* @param DateTimeInterface $start
276		* @param DateTimeInterface $end
277		*
278		* @return Timestamp
279		*/
280		private function createChronologicalTimestamp(DateTimeInterface $start, DateTimeInterface $end)
281		{
282		$startDate = Chronos::instance($start);
283		$endDate = Chronos::instance($end);
284
285		if ($startDate->isSameDay($endDate) && $endDate->lt($startDate)) {
286		$endDate = $endDate->addDay();
287		}
288
289		if ($endDate->lt($startDate)) {
290		$endDate = $startDate;
291		}
292
293		return new Timestamp($startDate, $endDate);
294		}
295
296		/**
297		* @param CultureFeed_Cdb_Data_Calendar_Timestamp[] $timestampList
298		* @param CultureFeed_Cdb_Data_Calendar_Timestamp $default
299		* @return CultureFeed_Cdb_Data_Calendar_Timestamp
300		*/
301	View Code Duplication	private function getLastTimestamp(array $timestampList, CultureFeed_Cdb_Data_Calendar_Timestamp $default)
		0 ignored issues – show Duplication introduced 2020-04-01 14:05 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
302		{
303		$lastTimestamp = $default;
304		foreach ($timestampList as $timestamp) {
305		$currentEndDate = Chronos::parse($lastTimestamp->getEndDate());
306		$endDate = Chronos::parse($timestamp->getEndDate());
307		if ($currentEndDate->lt($endDate)) {
308		$lastTimestamp = $timestamp;
309		}
310		}
311
312		return $lastTimestamp;
313		}
314
315		/**
316		* @param CultureFeed_Cdb_Data_Calendar_Timestamp[] $timestampList
317		* @param CultureFeed_Cdb_Data_Calendar_Timestamp $default
318		* @return CultureFeed_Cdb_Data_Calendar_Timestamp
319		*/
320	View Code Duplication	private function getFirstTimestamp(array $timestampList, CultureFeed_Cdb_Data_Calendar_Timestamp $default)
		0 ignored issues – show Duplication introduced 2020-04-01 14:05 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
321		{
322		$firstTimestamp = $default;
323		foreach ($timestampList as $timestamp) {
324		$currentStartTime = Chronos::parse($firstTimestamp->getDate());
325		$startTime = Chronos::parse($timestamp->getDate());
326		if ($currentStartTime->gt($startTime)) {
327		$firstTimestamp = $timestamp;
328		}
329		}
330
331		return $firstTimestamp;
332		}
333		}
334

cultuurnet / udb3-php

Pull Request — master (#454)

CalendarFactory::createFromCdbCalendar() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like