Event::createImagesImportedFromUDB2() - Code Metrics - Inspection of "III-1406 Access option for an event or audience of..." - cultuurnet/udb3-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#261)

by Luc

created 2017-01-02 12:41 UTC

Event::createImagesImportedFromUDB2() A

↳ Parent: Event

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?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\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\AudienceType;
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 AudienceType
     */
    private $audienceType;

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

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

    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 AudienceType $audienceType
     */
    public function updateAudience(
        AudienceType $audienceType
    ) {
        if ($this->audienceType !== $audienceType) {
            $this->apply(new AudienceUpdated(
                $this->eventId,
                $audienceType
            ));
        }
    }

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

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

cultuurnet / udb3-php

Pull Request — master (#261)

Event::createImagesImportedFromUDB2() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like