StoredEvent::getEventClassAttribute() - Code Metrics - Inspection of "Merge pull request #178 from spatie/event-map" - spatie/laravel-event-projector - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2c0599...af6fa8 )

by Freek

created 2019-07-18 07:54 UTC

StoredEvent::getEventClassAttribute() A

↳ Parent: StoredEvent

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Spatie\EventProjector\Models;

use Exception;
use Carbon\Carbon;
use Illuminate\Support\Arr;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Builder;
use Spatie\EventProjector\ShouldBeStored;
use Spatie\EventProjector\Facades\Projectionist;
use Spatie\SchemalessAttributes\SchemalessAttributes;
use Spatie\EventProjector\Exceptions\InvalidStoredEvent;
use Spatie\EventProjector\EventSerializers\EventSerializer;

class StoredEvent extends Model
{
    public $guarded = [];

    public $timestamps = false;

    public $casts = [
        'event_properties' => 'array',
        'meta_data' => 'array',
    ];

    public static function createForEvent(ShouldBeStored $event, string $uuid = null): StoredEvent
    {
        $storedEvent = new static();
        $storedEvent->aggregate_uuid = $uuid;
        $storedEvent->event_class = static::getEventClass(get_class($event));
        $storedEvent->attributes['event_properties'] = app(EventSerializer::class)->serialize(clone $event);
        $storedEvent->meta_data = [];
        $storedEvent->created_at = Carbon::now();

        $storedEvent->save();

        return $storedEvent;
    }

    public function getEventClassAttribute(string $value): string
    {
        return static::getActualClassForEvent($value);
    }

    public function getEventAttribute(): ShouldBeStored
    {
        try {
            $event = app(EventSerializer::class)->deserialize(
                $this->event_class,
                $this->getOriginal('event_properties')
            );
        } catch (Exception $exception) {
            throw InvalidStoredEvent::couldNotUnserializeEvent($this, $exception);
        }

        return $event;
    }

    public function scopeStartingFrom(Builder $query, int $storedEventId): void
    {
        $query->where('id', '>=', $storedEventId);
    }

    public function scopeUuid(Builder $query, string $uuid): void
    {
        $query->where('aggregate_uuid', $uuid);
    }

    public function getMetaDataAttribute(): SchemalessAttributes
    {
        return SchemalessAttributes::createForModel($this, 'meta_data');
    }

    public function scopeWithMetaDataAttributes(): Builder
    {
        return SchemalessAttributes::scopeWithSchemalessAttributes('meta_data');
    }

    public static function storeMany(array $events, string $uuid = null): void
    {
        collect($events)
            ->map(function (ShouldBeStored $domainEvent) use ($uuid) {
                $storedEvent = static::createForEvent($domainEvent, $uuid);

                return [$domainEvent, $storedEvent];
            })
            ->eachSpread(function (ShouldBeStored $event, StoredEvent $storedEvent) {
                Projectionist::handleWithSyncProjectors($storedEvent);

                if (method_exists($event, 'tags')) {
                    $tags = $event->tags();

                }

                $storedEventJob = call_user_func(
                    [config('event-projector.stored_event_job'), 'createForEvent'],
                    $storedEvent,
                    $tags ?? []
                );

                dispatch($storedEventJob->onQueue($event->queue ?? config('event-projector.queue')));
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            });
    }

    public static function store(ShouldBeStored $event, string $uuid = null): void
    {
        static::storeMany([$event], $uuid);
    }

    protected static function getEventClass(string $class): string
    {
        $map = config('event-projector.event_class_map', []);

        if (! empty($map) && in_array($class, $map)) {
            return array_search($class, $map, true);
        }

        return $class;
    }

    protected static function getActualClassForEvent(string $class): string
    {
        return Arr::get(config('event-projector.event_class_map', []), $class, $class);
    }
}


1			<?php
2
3			namespace Spatie\EventProjector\Models;
4
5			use Exception;
6			use Carbon\Carbon;
7			use Illuminate\Support\Arr;
8			use Illuminate\Database\Eloquent\Model;
9			use Illuminate\Database\Eloquent\Builder;
10			use Spatie\EventProjector\ShouldBeStored;
11			use Spatie\EventProjector\Facades\Projectionist;
12			use Spatie\SchemalessAttributes\SchemalessAttributes;
13			use Spatie\EventProjector\Exceptions\InvalidStoredEvent;
14			use Spatie\EventProjector\EventSerializers\EventSerializer;
15
16			class StoredEvent extends Model
17			{
18			public $guarded = [];
19
20			public $timestamps = false;
21
22			public $casts = [
23			'event_properties' => 'array',
24			'meta_data' => 'array',
25			];
26
27			public static function createForEvent(ShouldBeStored $event, string $uuid = null): StoredEvent
28			{
29			$storedEvent = new static();
30			$storedEvent->aggregate_uuid = $uuid;
31			$storedEvent->event_class = static::getEventClass(get_class($event));
32			$storedEvent->attributes['event_properties'] = app(EventSerializer::class)->serialize(clone $event);
33			$storedEvent->meta_data = [];
34			$storedEvent->created_at = Carbon::now();
35
36			$storedEvent->save();
37
38			return $storedEvent;
39			}
40
41			public function getEventClassAttribute(string $value): string
42			{
43			return static::getActualClassForEvent($value);
44			}
45
46			public function getEventAttribute(): ShouldBeStored
47			{
48			try {
49			$event = app(EventSerializer::class)->deserialize(
50			$this->event_class,
51			$this->getOriginal('event_properties')
52			);
53			} catch (Exception $exception) {
54			throw InvalidStoredEvent::couldNotUnserializeEvent($this, $exception);
55			}
56
57			return $event;
58			}
59
60			public function scopeStartingFrom(Builder $query, int $storedEventId): void
61			{
62			$query->where('id', '>=', $storedEventId);
63			}
64
65			public function scopeUuid(Builder $query, string $uuid): void
66			{
67			$query->where('aggregate_uuid', $uuid);
68			}
69
70			public function getMetaDataAttribute(): SchemalessAttributes
71			{
72			return SchemalessAttributes::createForModel($this, 'meta_data');
73			}
74
75			public function scopeWithMetaDataAttributes(): Builder
76			{
77			return SchemalessAttributes::scopeWithSchemalessAttributes('meta_data');
78			}
79
80			public static function storeMany(array $events, string $uuid = null): void
81			{
82			collect($events)
83			->map(function (ShouldBeStored $domainEvent) use ($uuid) {
84			$storedEvent = static::createForEvent($domainEvent, $uuid);
85
86			return [$domainEvent, $storedEvent];
87			})
88			->eachSpread(function (ShouldBeStored $event, StoredEvent $storedEvent) {
89			Projectionist::handleWithSyncProjectors($storedEvent);
90
91			if (method_exists($event, 'tags')) {
92			$tags = $event->tags();
			0 ignored issues – show Bug introduced 2019-04-08 16:03 UTC by Report Bug Copy Issue Report The method `tags()` does not seem to exist on `object<Spatie\EventProjector\ShouldBeStored>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
93			}
94
95			$storedEventJob = call_user_func(
96			[config('event-projector.stored_event_job'), 'createForEvent'],
97			$storedEvent,
98			$tags ?? []
99			);
100
101			dispatch($storedEventJob->onQueue($event->queue ?? config('event-projector.queue')));
			0 ignored issues – show Bug introduced 2019-04-21 19:23 UTC by Report Bug Copy Issue Report Accessing `queue` on the interface `Spatie\EventProjector\ShouldBeStored` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
102			});
103			}
104
105			public static function store(ShouldBeStored $event, string $uuid = null): void
106			{
107			static::storeMany([$event], $uuid);
108			}
109
110			protected static function getEventClass(string $class): string
111			{
112			$map = config('event-projector.event_class_map', []);
113
114			if (! empty($map) && in_array($class, $map)) {
115			return array_search($class, $map, true);
116			}
117
118			return $class;
119			}
120
121			protected static function getActualClassForEvent(string $class): string
122			{
123			return Arr::get(config('event-projector.event_class_map', []), $class, $class);
124			}
125			}
126

spatie / laravel-event-projector

Push — master ( 2c0599...af6fa8 )

StoredEvent::getEventClassAttribute() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like