Event - Code Metrics - Inspection of "III-1737 Make it possible to copy an event." - cultuurnet/udb3-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#264)

by Kristof

created 2017-01-10 08:07 UTC

Event D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	451
Duplicated Lines	5.54 %

Coupling/Cohesion

Components	1
Dependencies	38

Importance

Changes

Metric	Value
wmc	43
lcom	1
cbo	38
dl	25
loc	451
rs	4.0512
c	0
b	0
f	0

41 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	create()	25	25	1
A	copyEvent()	0	17	1
A	importFromUDB2()	0	16	1
A	updateImagesFromUDB2()	0	4	1
A	importImagesFromUDB2()	0	4	1
A	getAggregateRootId()	0	4	1
A	getMediaObjects()	0	4	1
A	applyEventCreated()	0	5	1
A	applyEventCopied()	0	5	1
A	applyEventImportedFromUDB2()	0	6	1
A	applyEventUpdatedFromUDB2()	0	5	1
A	setUDB2Data()	0	11	1
A	updateMajorInfo()	0	9	1
A	updateAudience()	0	10	3
A	applyAudienceUpdated()	0	4	1
A	createImagesImportedFromUDB2()	0	4	1
A	createImagesUpdatedFromUDB2()	0	4	1
A	updateWithCdbXml()	0	10	1
A	createLabelAddedEvent()	0	4	1
A	createLabelRemovedEvent()	0	4	1
A	createImageAddedEvent()	0	4	1
A	createImageRemovedEvent()	0	4	1
A	createImageUpdatedEvent()	0	10	1
A	createMainImageSelectedEvent()	0	4	1
A	createTitleTranslatedEvent()	0	4	1
A	createDescriptionTranslatedEvent()	0	4	1
A	createDescriptionUpdatedEvent()	0	4	1
A	createTypicalAgeRangeUpdatedEvent()	0	4	1
A	createTypicalAgeRangeDeletedEvent()	0	4	1
A	createOrganizerUpdatedEvent()	0	4	1
A	createOrganizerDeletedEvent()	0	4	1
A	createContactPointUpdatedEvent()	0	4	1
A	createBookingInfoUpdatedEvent()	0	4	1
A	createPriceInfoUpdatedEvent()	0	4	1
A	createOfferDeletedEvent()	0	4	1
A	createPublishedEvent()	0	4	1
A	createApprovedEvent()	0	4	1
A	createRejectedEvent()	0	4	1
A	createFlaggedAsDuplicate()	0	4	1
A	createFlaggedAsInappropriate()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Event often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Event, and based on these observations, apply Extract Interface, too.

<?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\AudienceUpdated;
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\EventCopied;
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\Image\ImagesImportedFromUDB2;
use CultuurNet\UDB3\Event\Events\Image\ImagesUpdatedFromUDB2;
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\Event\ValueObjects\Audience;
use CultuurNet\UDB3\Label;
use CultuurNet\UDB3\LabelCollection;
use CultuurNet\UDB3\Language;
use CultuurNet\UDB3\Location\Location;
use CultuurNet\UDB3\Media\ImageCollection;
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;

    /**
     * @var Audience
     */
    private $audience;

    const MAIN_LANGUAGE_CODE = 'nl';

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

    /**
     * Factory method to create a new event.
     *
     * @param $eventId
     * @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
    ) {
        $event = new self();

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

        return $event;
    }

    /**
     * @param string $eventId
     * @param string $originalEventId
     * @param CalendarInterface $calendar
     * @return Event
     */
    public static function copyEvent(
        $eventId,
        $originalEventId,
        CalendarInterface $calendar
    ) {
        $event = new self();

        $event->apply(
            new EventCopied(
                $eventId,
                $originalEventId,
                $calendar
            )
        );

        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;
    }

    /**
     * @param ImageCollection $images
     */
    public function updateImagesFromUDB2(ImageCollection $images)
    {
        $this->apply(new ImagesUpdatedFromUDB2($this->eventId, $images));
    }

    /**
     * @param ImageCollection $images
     */
    public function importImagesFromUDB2(ImageCollection $images)
    {
        $this->apply(new ImagesImportedFromUDB2($this->eventId, $images));
    }

    /**
     * {@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();
    }

    /**
     * @param EventCopied $eventCopied
     */
    protected function applyEventCopied(EventCopied $eventCopied)
    {
        $this->eventId = $eventCopied->getItemId();
        $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 Theme|null $theme
     */
    public function updateMajorInfo(
        Title $title,
        EventType $eventType,
        Location $location,
        CalendarInterface $calendar,
        Theme $theme = null
    ) {
        $this->apply(new MajorInfoUpdated($this->eventId, $title, $eventType, $location, $calendar, $theme));
    }

    /**
     * @param Audience $audience
     */
    public function updateAudience(
        Audience $audience
    ) {
        if (is_null($this->audience) || !$this->audience->equals($audience)) {
            $this->apply(new AudienceUpdated(
                $this->eventId,
                $audience
            ));
        }
    }

    /**
     * @param AudienceUpdated $audienceUpdated
     */
    public function applyAudienceUpdated(AudienceUpdated $audienceUpdated)
    {
        $this->audience= $audienceUpdated->getAudience();
    }

    /**
     * @inheritDoc
     * @return ImagesImportedFromUDB2
     */
    protected function createImagesImportedFromUDB2(ImageCollection $images)
    {
        return new ImagesImportedFromUDB2($this->eventId, $images);
    }

    /**
     * @inheritDoc
     * @return ImagesUpdatedFromUDB2
     */
    protected function createImagesUpdatedFromUDB2(ImageCollection $images)
    {
        return new ImagesUpdatedFromUDB2($this->eventId, $images);
    }

    /**
     * @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\AudienceUpdated;
11		use CultuurNet\UDB3\Event\Events\BookingInfoUpdated;
12		use CultuurNet\UDB3\Event\Events\ContactPointUpdated;
13		use CultuurNet\UDB3\Event\Events\DescriptionTranslated;
14		use CultuurNet\UDB3\Event\Events\DescriptionUpdated;
15		use CultuurNet\UDB3\Event\Events\EventCdbXMLInterface;
16		use CultuurNet\UDB3\Event\Events\EventCopied;
17		use CultuurNet\UDB3\Event\Events\EventCreated;
18		use CultuurNet\UDB3\Event\Events\EventDeleted;
19		use CultuurNet\UDB3\Event\Events\EventImportedFromUDB2;
20		use CultuurNet\UDB3\Event\Events\EventUpdatedFromUDB2;
21		use CultuurNet\UDB3\Event\Events\ImageAdded;
22		use CultuurNet\UDB3\Event\Events\ImageRemoved;
23		use CultuurNet\UDB3\Event\Events\Image\ImagesImportedFromUDB2;
24		use CultuurNet\UDB3\Event\Events\Image\ImagesUpdatedFromUDB2;
25		use CultuurNet\UDB3\Event\Events\ImageUpdated;
26		use CultuurNet\UDB3\Event\Events\LabelAdded;
27		use CultuurNet\UDB3\Event\Events\LabelRemoved;
28		use CultuurNet\UDB3\Event\Events\MainImageSelected;
29		use CultuurNet\UDB3\Event\Events\MajorInfoUpdated;
30		use CultuurNet\UDB3\Event\Events\Moderation\Approved;
31		use CultuurNet\UDB3\Event\Events\Moderation\FlaggedAsDuplicate;
32		use CultuurNet\UDB3\Event\Events\Moderation\FlaggedAsInappropriate;
33		use CultuurNet\UDB3\Event\Events\Moderation\Published;
34		use CultuurNet\UDB3\Event\Events\Moderation\Rejected;
35		use CultuurNet\UDB3\Event\Events\OrganizerDeleted;
36		use CultuurNet\UDB3\Event\Events\OrganizerUpdated;
37		use CultuurNet\UDB3\Event\Events\PriceInfoUpdated;
38		use CultuurNet\UDB3\Event\Events\TitleTranslated;
39		use CultuurNet\UDB3\Event\Events\TypicalAgeRangeDeleted;
40		use CultuurNet\UDB3\Event\Events\TypicalAgeRangeUpdated;
41		use CultuurNet\UDB3\Event\ValueObjects\Audience;
42		use CultuurNet\UDB3\Label;
43		use CultuurNet\UDB3\LabelCollection;
44		use CultuurNet\UDB3\Language;
45		use CultuurNet\UDB3\Location\Location;
46		use CultuurNet\UDB3\Media\ImageCollection;
47		use CultuurNet\UDB3\Media\Image;
48		use CultuurNet\UDB3\Offer\Commands\Image\AbstractUpdateImage;
49		use CultuurNet\UDB3\Offer\Offer;
50		use CultuurNet\UDB3\Offer\WorkflowStatus;
51		use CultuurNet\UDB3\PriceInfo\PriceInfo;
52		use CultuurNet\UDB3\Theme;
53		use CultuurNet\UDB3\Title;
54		use ValueObjects\Identity\UUID;
55		use ValueObjects\String\String as StringLiteral;
56
57		class Event extends Offer implements UpdateableWithCdbXmlInterface
58		{
59		protected $eventId;
60
61		/**
62		* @var Audience
63		*/
64		private $audience;
65
66		const MAIN_LANGUAGE_CODE = 'nl';
67
68		public function __construct()
69		{
70		parent::__construct();
71		}
72
73		/**
74		* Factory method to create a new event.
75		*
76		* @param $eventId
77		* @param Title $title
78		* @param EventType $eventType
79		* @param Location $location
80		* @param CalendarInterface $calendar
81		* @param Theme\|null $theme
82		* @param \DateTimeImmutable\|null $publicationDate
83		* @return Event
84		*/
85	View Code Duplication	public static function create(
		0 ignored issues – show Duplication introduced 2017-01-06 08:49 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...
86		$eventId,
87		Title $title,
88		EventType $eventType,
89		Location $location,
90		CalendarInterface $calendar,
91		Theme $theme = null,
92		\DateTimeImmutable $publicationDate = null
93		) {
94		$event = new self();
95
96		$event->apply(
97		new EventCreated(
98		$eventId,
99		$title,
100		$eventType,
101		$location,
102		$calendar,
103		$theme,
104		$publicationDate
105		)
106		);
107
108		return $event;
109		}
110
111		/**
112		* @param string $eventId
113		* @param string $originalEventId
114		* @param CalendarInterface $calendar
115		* @return Event
116		*/
117		public static function copyEvent(
118		$eventId,
119		$originalEventId,
120		CalendarInterface $calendar
121		) {
122		$event = new self();
123
124		$event->apply(
125		new EventCopied(
126		$eventId,
127		$originalEventId,
128		$calendar
129		)
130		);
131
132		return $event;
133		}
134
135		/**
136		* @param string $eventId
137		* @param string $cdbXml
138		* @param string $cdbXmlNamespaceUri
139		* @return Event
140		*/
141		public static function importFromUDB2(
142		$eventId,
143		$cdbXml,
144		$cdbXmlNamespaceUri
145		) {
146		$event = new self();
147		$event->apply(
148		new EventImportedFromUDB2(
149		$eventId,
150		$cdbXml,
151		$cdbXmlNamespaceUri
152		)
153		);
154
155		return $event;
156		}
157
158		/**
159		* @param ImageCollection $images
160		*/
161		public function updateImagesFromUDB2(ImageCollection $images)
162		{
163		$this->apply(new ImagesUpdatedFromUDB2($this->eventId, $images));
164		}
165
166		/**
167		* @param ImageCollection $images
168		*/
169		public function importImagesFromUDB2(ImageCollection $images)
170		{
171		$this->apply(new ImagesImportedFromUDB2($this->eventId, $images));
172		}
173
174		/**
175		* {@inheritdoc}
176		*/
177		public function getAggregateRootId()
178		{
179		return $this->eventId;
180		}
181
182		/**
183		* @return UUID[]
184		*/
185		public function getMediaObjects()
186		{
187		return $this->mediaObjects;
188		}
189
190		protected function applyEventCreated(EventCreated $eventCreated)
191		{
192		$this->eventId = $eventCreated->getEventId();
193		$this->workflowStatus = WorkflowStatus::DRAFT();
194		}
195
196		/**
197		* @param EventCopied $eventCopied
198		*/
199		protected function applyEventCopied(EventCopied $eventCopied)
200		{
201		$this->eventId = $eventCopied->getItemId();
202		$this->workflowStatus = WorkflowStatus::DRAFT();
203		}
204
205		protected function applyEventImportedFromUDB2(
206		EventImportedFromUDB2 $eventImported
207		) {
208		$this->eventId = $eventImported->getEventId();
209		$this->setUDB2Data($eventImported);
210		}
211
212		/**
213		* @param EventUpdatedFromUDB2 $eventUpdated
214		*/
215		protected function applyEventUpdatedFromUDB2(
216		EventUpdatedFromUDB2 $eventUpdated
217		) {
218		$this->setUDB2Data($eventUpdated);
219		}
220
221		/**
222		* @param EventCdbXMLInterface $eventCdbXML
223		*/
224		protected function setUDB2Data(
225		EventCdbXMLInterface $eventCdbXML
226		) {
227		$udb2Event = EventItemFactory::createEventFromCdbXml(
228		$eventCdbXML->getCdbXmlNamespaceUri(),
229		$eventCdbXML->getCdbXml()
230		);
231
232		$this->importWorkflowStatus($udb2Event);
233		$this->labels = LabelCollection::fromKeywords($udb2Event->getKeywords(true));
234		}
235
236		/**
237		* Update the major info.
238		*
239		* @param Title $title
240		* @param EventType $eventType
241		* @param Location $location
242		* @param CalendarInterface $calendar
243		* @param Theme\|null $theme
244		*/
245		public function updateMajorInfo(
246		Title $title,
247		EventType $eventType,
248		Location $location,
249		CalendarInterface $calendar,
250		Theme $theme = null
251		) {
252		$this->apply(new MajorInfoUpdated($this->eventId, $title, $eventType, $location, $calendar, $theme));
253		}
254
255		/**
256		* @param Audience $audience
257		*/
258		public function updateAudience(
259		Audience $audience
260		) {
261		if (is_null($this->audience) \|\| !$this->audience->equals($audience)) {
262		$this->apply(new AudienceUpdated(
263		$this->eventId,
264		$audience
265		));
266		}
267		}
268
269		/**
270		* @param AudienceUpdated $audienceUpdated
271		*/
272		public function applyAudienceUpdated(AudienceUpdated $audienceUpdated)
273		{
274		$this->audience= $audienceUpdated->getAudience();
275		}
276
277		/**
278		* @inheritDoc
279		* @return ImagesImportedFromUDB2
280		*/
281		protected function createImagesImportedFromUDB2(ImageCollection $images)
282		{
283		return new ImagesImportedFromUDB2($this->eventId, $images);
284		}
285
286		/**
287		* @inheritDoc
288		* @return ImagesUpdatedFromUDB2
289		*/
290		protected function createImagesUpdatedFromUDB2(ImageCollection $images)
291		{
292		return new ImagesUpdatedFromUDB2($this->eventId, $images);
293		}
294
295		/**
296		* @inheritdoc
297		*/
298		public function updateWithCdbXml($cdbXml, $cdbXmlNamespaceUri)
299		{
300		$this->apply(
301		new EventUpdatedFromUDB2(
302		$this->eventId,
303		$cdbXml,
304		$cdbXmlNamespaceUri
305		)
306		);
307		}
308
309		/**
310		* @param Label $label
311		* @return LabelAdded
312		*/
313		protected function createLabelAddedEvent(Label $label)
314		{
315		return new LabelAdded($this->eventId, $label);
316		}
317
318		/**
319		* @param Label $label
320		* @return LabelRemoved
321		*/
322		protected function createLabelRemovedEvent(Label $label)
323		{
324		return new LabelRemoved($this->eventId, $label);
325		}
326
327		/**
328		* @param Image $image
329		* @return ImageAdded
330		*/
331		protected function createImageAddedEvent(Image $image)
332		{
333		return new ImageAdded($this->eventId, $image);
334		}
335
336		/**
337		* @param Image $image
338		* @return ImageRemoved
339		*/
340		protected function createImageRemovedEvent(Image $image)
341		{
342		return new ImageRemoved($this->eventId, $image);
343		}
344
345		/**
346		* @param AbstractUpdateImage $updateImageCommand
347		* @return ImageUpdated
348		*/
349		protected function createImageUpdatedEvent(
350		AbstractUpdateImage $updateImageCommand
351		) {
352		return new ImageUpdated(
353		$this->eventId,
354		$updateImageCommand->getMediaObjectId(),
355		$updateImageCommand->getDescription(),
356		$updateImageCommand->getCopyrightHolder()
357		);
358		}
359
360		/**
361		* @param Image $image
362		* @return MainImageSelected
363		*/
364		protected function createMainImageSelectedEvent(Image $image)
365		{
366		return new MainImageSelected($this->eventId, $image);
367		}
368
369		/**
370		* @param Language $language
371		* @param StringLiteral $title
372		* @return TitleTranslated
373		*/
374		protected function createTitleTranslatedEvent(Language $language, StringLiteral $title)
375		{
376		return new TitleTranslated($this->eventId, $language, $title);
377		}
378
379		/**
380		* @param Language $language
381		* @param StringLiteral $description
382		* @return DescriptionTranslated
383		*/
384		protected function createDescriptionTranslatedEvent(Language $language, StringLiteral $description)
385		{
386		return new DescriptionTranslated($this->eventId, $language, $description);
387		}
388
389		/**
390		* @param string $description
391		* @return DescriptionUpdated
392		*/
393		protected function createDescriptionUpdatedEvent($description)
394		{
395		return new DescriptionUpdated($this->eventId, $description);
396		}
397
398		/**
399		* @param string $typicalAgeRange
400		* @return TypicalAgeRangeUpdated
401		*/
402		protected function createTypicalAgeRangeUpdatedEvent($typicalAgeRange)
403		{
404		return new TypicalAgeRangeUpdated($this->eventId, $typicalAgeRange);
405		}
406
407		/**
408		* @return TypicalAgeRangeDeleted
409		*/
410		protected function createTypicalAgeRangeDeletedEvent()
411		{
412		return new TypicalAgeRangeDeleted($this->eventId);
413		}
414
415		/**
416		* @param string $organizerId
417		* @return OrganizerUpdated
418		*/
419		protected function createOrganizerUpdatedEvent($organizerId)
420		{
421		return new OrganizerUpdated($this->eventId, $organizerId);
422		}
423
424		/**
425		* @param string $organizerId
426		* @return OrganizerDeleted
427		*/
428		protected function createOrganizerDeletedEvent($organizerId)
429		{
430		return new OrganizerDeleted($this->eventId, $organizerId);
431		}
432
433		/**
434		* @param ContactPoint $contactPoint
435		* @return ContactPointUpdated
436		*/
437		protected function createContactPointUpdatedEvent(ContactPoint $contactPoint)
438		{
439		return new ContactPointUpdated($this->eventId, $contactPoint);
440		}
441
442		/**
443		* @param BookingInfo $bookingInfo
444		* @return BookingInfoUpdated
445		*/
446		protected function createBookingInfoUpdatedEvent(BookingInfo $bookingInfo)
447		{
448		return new BookingInfoUpdated($this->eventId, $bookingInfo);
449		}
450
451		/**
452		* @param PriceInfo $priceInfo
453		* @return PriceInfoUpdated
454		*/
455		protected function createPriceInfoUpdatedEvent(PriceInfo $priceInfo)
456		{
457		return new PriceInfoUpdated($this->eventId, $priceInfo);
458		}
459
460		/**
461		* @return EventDeleted
462		*/
463		protected function createOfferDeletedEvent()
464		{
465		return new EventDeleted($this->eventId);
466		}
467
468		/**
469		* @inheritdoc
470		*/
471		protected function createPublishedEvent(\DateTimeInterface $publicationDate)
472		{
473		return new Published($this->eventId, $publicationDate);
474		}
475
476		/**
477		* @inheritdoc
478		*/
479		protected function createApprovedEvent()
480		{
481		return new Approved($this->eventId);
482		}
483
484		/**
485		* @inheritdoc
486		*/
487		protected function createRejectedEvent(StringLiteral $reason)
488		{
489		return new Rejected($this->eventId, $reason);
490		}
491
492		/**
493		* @inheritDoc
494		*/
495		protected function createFlaggedAsDuplicate()
496		{
497		return new FlaggedAsDuplicate($this->eventId);
498		}
499
500		/**
501		* @inheritDoc
502		*/
503		protected function createFlaggedAsInappropriate()
504		{
505		return new FlaggedAsInappropriate($this->eventId);
506		}
507		}
508

cultuurnet / udb3-php