Spatie\Activitylog\Traits\DetectsChanges

Complexity

Total Complexity

17

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	attributesToBeLogged()	0	8	2
A	bootDetectsChanges()	0	12	2
C	attributeValuesToBeLogged()	0	22	7
A	logChanges()	0	12	2
A	getRelatedModelAttributeValue()	0	12	2
A	shouldLogDirtyOnly()	0	8	2

<?php

namespace Spatie\Activitylog\Traits;

use Illuminate\Database\Eloquent\Model;
use Spatie\Activitylog\Exceptions\CouldNotLogChanges;

trait DetectsChanges
{
	protected $oldAttributes = [];

    protected static function bootDetectsChanges()
    {
        if (static::eventsToBeRecorded()->contains('updated')) {
            static::updating(function (Model $model) {
                //temporary hold the original attributes on the model
                //as we'll need these in the updating event
                $oldValues = $model->replicate()->setRawAttributes($model->getOriginal());

                $model->oldAttributes = static::logChanges($oldValues);
            });
        }
    }

    public function attributesToBeLogged(): array
    {
        if (! isset(static::$logAttributes)) {
            return [];
        }

        return static::$logAttributes;
    }

    public function shouldLogDirtyOnly(): bool
    {
        if (! isset(static::$logDirtyOnly)) {
            return false;
        }

        return static::$logDirtyOnly;
    }

    public function attributeValuesToBeLogged(string $processingEvent): array
    {
        if (! count($this->attributesToBeLogged())) {
            return [];
        }

        $properties['attributes'] = static::logChanges($this->exists ? $this->fresh() : $this);

The property exists does not exist. Did you maybe forget to declare it?

It seems like fresh() must be provided by classes using this trait. How about adding it as abstract method to this trait?

$properties was never initialized. Although not strictly required by PHP, it is generally a good practice to add $properties = array(); before regardless.

        if (static::eventsToBeRecorded()->contains('updated') && $processingEvent == 'updated') {
            $nullProperties = array_fill_keys(array_keys($properties['attributes']), null);

            $properties['old'] = array_merge($nullProperties, $this->oldAttributes);
        }

        // Only dirty fields
        if (isset($properties['old']) && $this->shouldLogDirtyOnly()) {
            $properties['attributes'] = collect($properties['attributes'])->diff($properties['old'])->all();
            $properties['old'] = collect($properties['old'])->only(array_keys($properties['attributes']))->all();
        }

        return $properties;
    }

    public static function logChanges(Model $model): array
    {
        return collect($model->attributesToBeLogged())->mapWithKeys(
			function ($attribute) use ($model) {
				if (str_contains($attribute, '.')) {
					return self::getRelatedModelAttributeValue($model, $attribute);
                }

				return collect($model)->only($attribute);
			}
		)->toArray();
    }

    protected static function getRelatedModelAttributeValue(Model $model, string $attribute): array
    {
        if (substr_count($attribute, '.') > 1) {
            throw CouldNotLogChanges::invalidAttribute($attribute);
        }

        list($relatedModelName, $relatedAttribute) = explode('.', $attribute);

        $relatedModel = $model->$relatedModelName ?? $model->$relatedModelName();

        return ["{$relatedModelName}.{$relatedAttribute}" => $relatedModel->$relatedAttribute];
    }
}