Event::updateMajorInfo() - Code Metrics - Inspection of "Merge pull request #252 from cultuurnet/feature/II..." - cultuurnet/udb3-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3bba11...039fa3 )

by Kristof

created 2016-12-08 20:21 UTC

Event::updateMajorInfo() A

↳ Parent: Event

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	9
rs	9.6666
cc	1
eloc	7
nc	1
nop	5

<?php

namespace CultuurNet\UDB3\Event;

use CultuurNet\UDB3\BookingInfo;
use CultuurNet\UDB3\CalendarInterface;
use CultuurNet\UDB3\Cdb\EventItemFactory;
use CultuurNet\UDB3\Cdb\UpdateableWithCdbXmlInterface;
use CultuurNet\UDB3\ContactPoint;
use CultuurNet\UDB3\Event\Events\BookingInfoUpdated;
use CultuurNet\UDB3\Event\Events\ContactPointUpdated;
use CultuurNet\UDB3\Event\Events\DescriptionTranslated;
use CultuurNet\UDB3\Event\Events\DescriptionUpdated;
use CultuurNet\UDB3\Event\Events\EventCdbXMLInterface;
use CultuurNet\UDB3\Event\Events\EventCreated;
use CultuurNet\UDB3\Event\Events\EventDeleted;
use CultuurNet\UDB3\Event\Events\EventImportedFromUDB2;
use CultuurNet\UDB3\Event\Events\EventUpdatedFromUDB2;
use CultuurNet\UDB3\Event\Events\ImageAdded;
use CultuurNet\UDB3\Event\Events\ImageRemoved;
use CultuurNet\UDB3\Event\Events\ImageUpdated;
use CultuurNet\UDB3\Event\Events\LabelAdded;
use CultuurNet\UDB3\Event\Events\LabelRemoved;
use CultuurNet\UDB3\Event\Events\MainImageSelected;
use CultuurNet\UDB3\Event\Events\MajorInfoUpdated;
use CultuurNet\UDB3\Event\Events\Moderation\Approved;
use CultuurNet\UDB3\Event\Events\Moderation\FlaggedAsDuplicate;
use CultuurNet\UDB3\Event\Events\Moderation\FlaggedAsInappropriate;
use CultuurNet\UDB3\Event\Events\Moderation\Published;
use CultuurNet\UDB3\Event\Events\Moderation\Rejected;
use CultuurNet\UDB3\Event\Events\OrganizerDeleted;
use CultuurNet\UDB3\Event\Events\OrganizerUpdated;
use CultuurNet\UDB3\Event\Events\PriceInfoUpdated;
use CultuurNet\UDB3\Event\Events\TitleTranslated;
use CultuurNet\UDB3\Event\Events\TypicalAgeRangeDeleted;
use CultuurNet\UDB3\Event\Events\TypicalAgeRangeUpdated;
use CultuurNet\UDB3\Label;
use CultuurNet\UDB3\LabelCollection;
use CultuurNet\UDB3\Language;
use CultuurNet\UDB3\Location\Location;
use CultuurNet\UDB3\Media\Image;
use CultuurNet\UDB3\Offer\Commands\Image\AbstractUpdateImage;
use CultuurNet\UDB3\Offer\Offer;
use CultuurNet\UDB3\Offer\WorkflowStatus;
use CultuurNet\UDB3\PriceInfo\PriceInfo;
use CultuurNet\UDB3\Theme;
use CultuurNet\UDB3\Title;
use ValueObjects\Identity\UUID;
use ValueObjects\String\String as StringLiteral;

class Event extends Offer implements UpdateableWithCdbXmlInterface
{
    protected $eventId;

    const MAIN_LANGUAGE_CODE = 'nl';

    public function __construct()
    {
        parent::__construct();
    }

    /**
     * Factory method to create a new event.
     *
     * @param Title $title
     * @param EventType $eventType
     * @param Location $location
     * @param CalendarInterface $calendar
     * @param Theme|null $theme
     * @param \DateTimeImmutable|null $publicationDate
     *
     * @return Event
     */
    public static function create(
        $eventId,
        Title $title,
        EventType $eventType,
        Location $location,
        CalendarInterface $calendar,
        Theme $theme = null,
        \DateTimeImmutable $publicationDate = null
    ) {
        if (!is_string($eventId)) {
            throw new \InvalidArgumentException(
                'Expected eventId to be a string, received ' . gettype($eventId)
            );
        }

        $event = new self();

        $event->apply(
            new EventCreated(
                $eventId,
                $title,
                $eventType,
                $location,
                $calendar,
                $theme,
                $publicationDate
            )
        );

        return $event;
    }

    /**
     * @param string $eventId
     * @param string $cdbXml
     * @param string $cdbXmlNamespaceUri
     * @return Event
     */
    public static function importFromUDB2(
        $eventId,
        $cdbXml,
        $cdbXmlNamespaceUri
    ) {
        $event = new self();
        $event->apply(
            new EventImportedFromUDB2(
                $eventId,
                $cdbXml,
                $cdbXmlNamespaceUri
            )
        );

        return $event;
    }

    /**
     * {@inheritdoc}
     */
    public function getAggregateRootId()
    {
        return $this->eventId;
    }

    /**
     * @return UUID[]
     */
    public function getMediaObjects()
    {
        return $this->mediaObjects;
    }

    protected function applyEventCreated(EventCreated $eventCreated)
    {
        $this->eventId = $eventCreated->getEventId();
        $this->workflowStatus = WorkflowStatus::DRAFT();
    }

    protected function applyEventImportedFromUDB2(
        EventImportedFromUDB2 $eventImported
    ) {
        $this->eventId = $eventImported->getEventId();
        $this->setUDB2Data($eventImported);
    }

    /**
     * @param EventUpdatedFromUDB2 $eventUpdated
     */
    protected function applyEventUpdatedFromUDB2(
        EventUpdatedFromUDB2 $eventUpdated
    ) {
        $this->setUDB2Data($eventUpdated);
    }

    /**
     * @param EventCdbXMLInterface $eventCdbXML
     */
    protected function setUDB2Data(
        EventCdbXMLInterface $eventCdbXML
    ) {
        $udb2Event = EventItemFactory::createEventFromCdbXml(
            $eventCdbXML->getCdbXmlNamespaceUri(),
            $eventCdbXML->getCdbXml()
        );

        $this->importWorkflowStatus($udb2Event);
        $this->labels = LabelCollection::fromKeywords($udb2Event->getKeywords(true));
    }

    /**
     * Update the major info.
     *
     * @param Title $title
     * @param EventType $eventType
     * @param Location $location
     * @param CalendarInterface $calendar
     * @param type $theme
     */
    public function updateMajorInfo(
        Title $title,
        EventType $eventType,
        Location $location,
        CalendarInterface $calendar,
        $theme = null
    ) {
        $this->apply(new MajorInfoUpdated($this->eventId, $title, $eventType, $location, $calendar, $theme));
    }

    /**
     * @inheritdoc
     */
    public function updateWithCdbXml($cdbXml, $cdbXmlNamespaceUri)
    {
        $this->apply(
            new EventUpdatedFromUDB2(
                $this->eventId,
                $cdbXml,
                $cdbXmlNamespaceUri
            )
        );
    }

    /**
     * @param Label $label
     * @return LabelAdded
     */
    protected function createLabelAddedEvent(Label $label)
    {
        return new LabelAdded($this->eventId, $label);
    }

    /**
     * @param Label $label
     * @return LabelRemoved
     */
    protected function createLabelRemovedEvent(Label $label)
    {
        return new LabelRemoved($this->eventId, $label);
    }

    /**
     * @param Image $image
     * @return ImageAdded
     */
    protected function createImageAddedEvent(Image $image)
    {
        return new ImageAdded($this->eventId, $image);
    }

    /**
     * @param Image $image
     * @return ImageRemoved
     */
    protected function createImageRemovedEvent(Image $image)
    {
        return new ImageRemoved($this->eventId, $image);
    }

    /**
     * @param AbstractUpdateImage $updateImageCommand
     * @return ImageUpdated
     */
    protected function createImageUpdatedEvent(
        AbstractUpdateImage $updateImageCommand
    ) {
        return new ImageUpdated(
            $this->eventId,
            $updateImageCommand->getMediaObjectId(),
            $updateImageCommand->getDescription(),
            $updateImageCommand->getCopyrightHolder()
        );
    }

    /**
     * @param Image $image
     * @return MainImageSelected
     */
    protected function createMainImageSelectedEvent(Image $image)
    {
        return new MainImageSelected($this->eventId, $image);
    }

    /**
     * @param Language $language
     * @param StringLiteral $title
     * @return TitleTranslated
     */
    protected function createTitleTranslatedEvent(Language $language, StringLiteral $title)
    {
        return new TitleTranslated($this->eventId, $language, $title);
    }

    /**
     * @param Language $language
     * @param StringLiteral $description
     * @return DescriptionTranslated
     */
    protected function createDescriptionTranslatedEvent(Language $language, StringLiteral $description)
    {
        return new DescriptionTranslated($this->eventId, $language, $description);
    }

    /**
     * @param string $description
     * @return DescriptionUpdated
     */
    protected function createDescriptionUpdatedEvent($description)
    {
        return new DescriptionUpdated($this->eventId, $description);
    }

    /**
     * @param string $typicalAgeRange
     * @return TypicalAgeRangeUpdated
     */
    protected function createTypicalAgeRangeUpdatedEvent($typicalAgeRange)
    {
        return new TypicalAgeRangeUpdated($this->eventId, $typicalAgeRange);
    }

    /**
     * @return TypicalAgeRangeDeleted
     */
    protected function createTypicalAgeRangeDeletedEvent()
    {
        return new TypicalAgeRangeDeleted($this->eventId);
    }

    /**
     * @param string $organizerId
     * @return OrganizerUpdated
     */
    protected function createOrganizerUpdatedEvent($organizerId)
    {
        return new OrganizerUpdated($this->eventId, $organizerId);
    }

    /**
     * @param string $organizerId
     * @return OrganizerDeleted
     */
    protected function createOrganizerDeletedEvent($organizerId)
    {
        return new OrganizerDeleted($this->eventId, $organizerId);
    }

    /**
     * @param ContactPoint $contactPoint
     * @return ContactPointUpdated
     */
    protected function createContactPointUpdatedEvent(ContactPoint $contactPoint)
    {
        return new ContactPointUpdated($this->eventId, $contactPoint);
    }

    /**
     * @param BookingInfo $bookingInfo
     * @return BookingInfoUpdated
     */
    protected function createBookingInfoUpdatedEvent(BookingInfo $bookingInfo)
    {
        return new BookingInfoUpdated($this->eventId, $bookingInfo);
    }

    /**
     * @param PriceInfo $priceInfo
     * @return PriceInfoUpdated
     */
    protected function createPriceInfoUpdatedEvent(PriceInfo $priceInfo)
    {
        return new PriceInfoUpdated($this->eventId, $priceInfo);
    }

    /**
     * @return EventDeleted
     */
    protected function createOfferDeletedEvent()
    {
        return new EventDeleted($this->eventId);
    }

    /**
     * @inheritdoc
     */
    protected function createPublishedEvent(\DateTimeInterface $publicationDate)
    {
        return new Published($this->eventId, $publicationDate);
    }

    /**
     * @inheritdoc
     */
    protected function createApprovedEvent()
    {
        return new Approved($this->eventId);
    }

    /**
     * @inheritdoc
     */
    protected function createRejectedEvent(StringLiteral $reason)
    {
        return new Rejected($this->eventId, $reason);
    }

    /**
     * @inheritDoc
     */
    protected function createFlaggedAsDuplicate()
    {
        return new FlaggedAsDuplicate($this->eventId);
    }

    /**
     * @inheritDoc
     */
    protected function createFlaggedAsInappropriate()
    {
        return new FlaggedAsInappropriate($this->eventId);
    }
}


1			<?php
2
3			namespace CultuurNet\UDB3\Event;
4
5			use CultuurNet\UDB3\BookingInfo;
6			use CultuurNet\UDB3\CalendarInterface;
7			use CultuurNet\UDB3\Cdb\EventItemFactory;
8			use CultuurNet\UDB3\Cdb\UpdateableWithCdbXmlInterface;
9			use CultuurNet\UDB3\ContactPoint;
10			use CultuurNet\UDB3\Event\Events\BookingInfoUpdated;
11			use CultuurNet\UDB3\Event\Events\ContactPointUpdated;
12			use CultuurNet\UDB3\Event\Events\DescriptionTranslated;
13			use CultuurNet\UDB3\Event\Events\DescriptionUpdated;
14			use CultuurNet\UDB3\Event\Events\EventCdbXMLInterface;
15			use CultuurNet\UDB3\Event\Events\EventCreated;
16			use CultuurNet\UDB3\Event\Events\EventDeleted;
17			use CultuurNet\UDB3\Event\Events\EventImportedFromUDB2;
18			use CultuurNet\UDB3\Event\Events\EventUpdatedFromUDB2;
19			use CultuurNet\UDB3\Event\Events\ImageAdded;
20			use CultuurNet\UDB3\Event\Events\ImageRemoved;
21			use CultuurNet\UDB3\Event\Events\ImageUpdated;
22			use CultuurNet\UDB3\Event\Events\LabelAdded;
23			use CultuurNet\UDB3\Event\Events\LabelRemoved;
24			use CultuurNet\UDB3\Event\Events\MainImageSelected;
25			use CultuurNet\UDB3\Event\Events\MajorInfoUpdated;
26			use CultuurNet\UDB3\Event\Events\Moderation\Approved;
27			use CultuurNet\UDB3\Event\Events\Moderation\FlaggedAsDuplicate;
28			use CultuurNet\UDB3\Event\Events\Moderation\FlaggedAsInappropriate;
29			use CultuurNet\UDB3\Event\Events\Moderation\Published;
30			use CultuurNet\UDB3\Event\Events\Moderation\Rejected;
31			use CultuurNet\UDB3\Event\Events\OrganizerDeleted;
32			use CultuurNet\UDB3\Event\Events\OrganizerUpdated;
33			use CultuurNet\UDB3\Event\Events\PriceInfoUpdated;
34			use CultuurNet\UDB3\Event\Events\TitleTranslated;
35			use CultuurNet\UDB3\Event\Events\TypicalAgeRangeDeleted;
36			use CultuurNet\UDB3\Event\Events\TypicalAgeRangeUpdated;
37			use CultuurNet\UDB3\Label;
38			use CultuurNet\UDB3\LabelCollection;
39			use CultuurNet\UDB3\Language;
40			use CultuurNet\UDB3\Location\Location;
41			use CultuurNet\UDB3\Media\Image;
42			use CultuurNet\UDB3\Offer\Commands\Image\AbstractUpdateImage;
43			use CultuurNet\UDB3\Offer\Offer;
44			use CultuurNet\UDB3\Offer\WorkflowStatus;
45			use CultuurNet\UDB3\PriceInfo\PriceInfo;
46			use CultuurNet\UDB3\Theme;
47			use CultuurNet\UDB3\Title;
48			use ValueObjects\Identity\UUID;
49			use ValueObjects\String\String as StringLiteral;
50
51			class Event extends Offer implements UpdateableWithCdbXmlInterface
52			{
53			protected $eventId;
54
55			const MAIN_LANGUAGE_CODE = 'nl';
56
57			public function __construct()
58			{
59			parent::__construct();
60			}
61
62			/**
63			* Factory method to create a new event.
64			*
65			* @param Title $title
66			* @param EventType $eventType
67			* @param Location $location
68			* @param CalendarInterface $calendar
69			* @param Theme\|null $theme
70			* @param \DateTimeImmutable\|null $publicationDate
71			*
72			* @return Event
73			*/
74			public static function create(
75			$eventId,
76			Title $title,
77			EventType $eventType,
78			Location $location,
79			CalendarInterface $calendar,
80			Theme $theme = null,
81			\DateTimeImmutable $publicationDate = null
82			) {
83			if (!is_string($eventId)) {
84			throw new \InvalidArgumentException(
85			'Expected eventId to be a string, received ' . gettype($eventId)
86			);
87			}
88
89			$event = new self();
90
91			$event->apply(
92			new EventCreated(
93			$eventId,
94			$title,
95			$eventType,
96			$location,
97			$calendar,
98			$theme,
99			$publicationDate
100			)
101			);
102
103			return $event;
104			}
105
106			/**
107			* @param string $eventId
108			* @param string $cdbXml
109			* @param string $cdbXmlNamespaceUri
110			* @return Event
111			*/
112			public static function importFromUDB2(
113			$eventId,
114			$cdbXml,
115			$cdbXmlNamespaceUri
116			) {
117			$event = new self();
118			$event->apply(
119			new EventImportedFromUDB2(
120			$eventId,
121			$cdbXml,
122			$cdbXmlNamespaceUri
123			)
124			);
125
126			return $event;
127			}
128
129			/**
130			* {@inheritdoc}
131			*/
132			public function getAggregateRootId()
133			{
134			return $this->eventId;
135			}
136
137			/**
138			* @return UUID[]
139			*/
140			public function getMediaObjects()
141			{
142			return $this->mediaObjects;
143			}
144
145			protected function applyEventCreated(EventCreated $eventCreated)
146			{
147			$this->eventId = $eventCreated->getEventId();
148			$this->workflowStatus = WorkflowStatus::DRAFT();
149			}
150
151			protected function applyEventImportedFromUDB2(
152			EventImportedFromUDB2 $eventImported
153			) {
154			$this->eventId = $eventImported->getEventId();
155			$this->setUDB2Data($eventImported);
156			}
157
158			/**
159			* @param EventUpdatedFromUDB2 $eventUpdated
160			*/
161			protected function applyEventUpdatedFromUDB2(
162			EventUpdatedFromUDB2 $eventUpdated
163			) {
164			$this->setUDB2Data($eventUpdated);
165			}
166
167			/**
168			* @param EventCdbXMLInterface $eventCdbXML
169			*/
170			protected function setUDB2Data(
171			EventCdbXMLInterface $eventCdbXML
172			) {
173			$udb2Event = EventItemFactory::createEventFromCdbXml(
174			$eventCdbXML->getCdbXmlNamespaceUri(),
175			$eventCdbXML->getCdbXml()
176			);
177
178			$this->importWorkflowStatus($udb2Event);
179			$this->labels = LabelCollection::fromKeywords($udb2Event->getKeywords(true));
180			}
181
182			/**
183			* Update the major info.
184			*
185			* @param Title $title
186			* @param EventType $eventType
187			* @param Location $location
188			* @param CalendarInterface $calendar
189			* @param type $theme
190			*/
191			public function updateMajorInfo(
192			Title $title,
193			EventType $eventType,
194			Location $location,
195			CalendarInterface $calendar,
196			$theme = null
197			) {
198			$this->apply(new MajorInfoUpdated($this->eventId, $title, $eventType, $location, $calendar, $theme));
199			}
200
201			/**
202			* @inheritdoc
203			*/
204			public function updateWithCdbXml($cdbXml, $cdbXmlNamespaceUri)
205			{
206			$this->apply(
207			new EventUpdatedFromUDB2(
208			$this->eventId,
209			$cdbXml,
210			$cdbXmlNamespaceUri
211			)
212			);
213			}
214
215			/**
216			* @param Label $label
217			* @return LabelAdded
218			*/
219			protected function createLabelAddedEvent(Label $label)
220			{
221			return new LabelAdded($this->eventId, $label);
222			}
223
224			/**
225			* @param Label $label
226			* @return LabelRemoved
227			*/
228			protected function createLabelRemovedEvent(Label $label)
229			{
230			return new LabelRemoved($this->eventId, $label);
231			}
232
233			/**
234			* @param Image $image
235			* @return ImageAdded
236			*/
237			protected function createImageAddedEvent(Image $image)
238			{
239			return new ImageAdded($this->eventId, $image);
240			}
241
242			/**
243			* @param Image $image
244			* @return ImageRemoved
245			*/
246			protected function createImageRemovedEvent(Image $image)
247			{
248			return new ImageRemoved($this->eventId, $image);
249			}
250
251			/**
252			* @param AbstractUpdateImage $updateImageCommand
253			* @return ImageUpdated
254			*/
255			protected function createImageUpdatedEvent(
256			AbstractUpdateImage $updateImageCommand
257			) {
258			return new ImageUpdated(
259			$this->eventId,
260			$updateImageCommand->getMediaObjectId(),
261			$updateImageCommand->getDescription(),
262			$updateImageCommand->getCopyrightHolder()
263			);
264			}
265
266			/**
267			* @param Image $image
268			* @return MainImageSelected
269			*/
270			protected function createMainImageSelectedEvent(Image $image)
271			{
272			return new MainImageSelected($this->eventId, $image);
273			}
274
275			/**
276			* @param Language $language
277			* @param StringLiteral $title
278			* @return TitleTranslated
279			*/
280			protected function createTitleTranslatedEvent(Language $language, StringLiteral $title)
281			{
282			return new TitleTranslated($this->eventId, $language, $title);
283			}
284
285			/**
286			* @param Language $language
287			* @param StringLiteral $description
288			* @return DescriptionTranslated
289			*/
290			protected function createDescriptionTranslatedEvent(Language $language, StringLiteral $description)
291			{
292			return new DescriptionTranslated($this->eventId, $language, $description);
293			}
294
295			/**
296			* @param string $description
297			* @return DescriptionUpdated
298			*/
299			protected function createDescriptionUpdatedEvent($description)
300			{
301			return new DescriptionUpdated($this->eventId, $description);
302			}
303
304			/**
305			* @param string $typicalAgeRange
306			* @return TypicalAgeRangeUpdated
307			*/
308			protected function createTypicalAgeRangeUpdatedEvent($typicalAgeRange)
309			{
310			return new TypicalAgeRangeUpdated($this->eventId, $typicalAgeRange);
311			}
312
313			/**
314			* @return TypicalAgeRangeDeleted
315			*/
316			protected function createTypicalAgeRangeDeletedEvent()
317			{
318			return new TypicalAgeRangeDeleted($this->eventId);
319			}
320
321			/**
322			* @param string $organizerId
323			* @return OrganizerUpdated
324			*/
325			protected function createOrganizerUpdatedEvent($organizerId)
326			{
327			return new OrganizerUpdated($this->eventId, $organizerId);
328			}
329
330			/**
331			* @param string $organizerId
332			* @return OrganizerDeleted
333			*/
334			protected function createOrganizerDeletedEvent($organizerId)
335			{
336			return new OrganizerDeleted($this->eventId, $organizerId);
337			}
338
339			/**
340			* @param ContactPoint $contactPoint
341			* @return ContactPointUpdated
342			*/
343			protected function createContactPointUpdatedEvent(ContactPoint $contactPoint)
344			{
345			return new ContactPointUpdated($this->eventId, $contactPoint);
346			}
347
348			/**
349			* @param BookingInfo $bookingInfo
350			* @return BookingInfoUpdated
351			*/
352			protected function createBookingInfoUpdatedEvent(BookingInfo $bookingInfo)
353			{
354			return new BookingInfoUpdated($this->eventId, $bookingInfo);
355			}
356
357			/**
358			* @param PriceInfo $priceInfo
359			* @return PriceInfoUpdated
360			*/
361			protected function createPriceInfoUpdatedEvent(PriceInfo $priceInfo)
362			{
363			return new PriceInfoUpdated($this->eventId, $priceInfo);
364			}
365
366			/**
367			* @return EventDeleted
368			*/
369			protected function createOfferDeletedEvent()
370			{
371			return new EventDeleted($this->eventId);
372			}
373
374			/**
375			* @inheritdoc
376			*/
377			protected function createPublishedEvent(\DateTimeInterface $publicationDate)
378			{
379			return new Published($this->eventId, $publicationDate);
380			}
381
382			/**
383			* @inheritdoc
384			*/
385			protected function createApprovedEvent()
386			{
387			return new Approved($this->eventId);
388			}
389
390			/**
391			* @inheritdoc
392			*/
393			protected function createRejectedEvent(StringLiteral $reason)
394			{
395			return new Rejected($this->eventId, $reason);
396			}
397
398			/**
399			* @inheritDoc
400			*/
401			protected function createFlaggedAsDuplicate()
402			{
403			return new FlaggedAsDuplicate($this->eventId);
404			}
405
406			/**
407			* @inheritDoc
408			*/
409			protected function createFlaggedAsInappropriate()
410			{
411			return new FlaggedAsInappropriate($this->eventId);
412			}
413			}
414

cultuurnet / udb3-php

Push — master ( 3bba11...039fa3 )

Event::updateMajorInfo() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like