Cviebrock\EloquentLoggable\LoggableObserver

Complexity

Total Complexity

15

Size/Duplication

Total Lines	198
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	created()	0	6	1
A	updated()	0	13	2
A	deleted()	0	6	1
A	restored()	0	6	1
A	buildDataToLog()	0	13	1
A	generateChangeSet()	0	4	1
B	getLoggableAttributes()	0	43	4
A	getTimestampAttributes()	0	16	3

<?php namespace Cviebrock\EloquentLoggable;

use Cviebrock\EloquentLoggable\Models\Change;
use Illuminate\Contracts\Events\Dispatcher;
use Illuminate\Foundation\Auth\User as Authenticatable;


class LoggableObserver
{

    /**
     * @var mixed
     */
    private $userId;

    /**
     * @var \Illuminate\Contracts\Events\Dispatcher
     */
    private $events;

    /**
     * LoggableObserver constructor.
     *
     * @param \Illuminate\Foundation\Auth\User $user
     * @param \Illuminate\Contracts\Events\Dispatcher $events
     */
    public function __construct(Authenticatable $user, Dispatcher $events)
    {
        $this->userId = $user->getKey();
        $this->events = $events;
    }

    /**
     * Log a created model.
     *
     * @param \Cviebrock\EloquentLoggable\Loggable|\Illuminate\Database\Eloquent\Model $model
     *
     * @return void
     */
    public function created(Loggable $model): void
    {
        $data = $this->buildDataToLog('create', $model);

        Change::create($data);
    }

    /**
     * Log an updated model.
     *
     * @param \Cviebrock\EloquentLoggable\Loggable|\Illuminate\Database\Eloquent\Model $model
     *
     * @return void
     */
    public function updated(Loggable $model): void
    {
        $data = $this->buildDataToLog('update', $model);

        foreach ($this->getLoggableAttributes($model) as $change) {

            $data['attribute'] = $change['attribute'];
            $data['old_value'] = $change['old_value'];
            $data['new_value'] = $change['new_value'];

            Change::create($data);
        }
    }

    /**
     * Log a deleted model.
     *
     * @param \Cviebrock\EloquentLoggable\Loggable|\Illuminate\Database\Eloquent\Model $model
     *
     * @return void
     */
    public function deleted(Loggable $model): void
    {
        $data = $this->buildDataToLog('delete', $model);

        Change::create($data);
    }

    /**
     * Log a restored model.
     *
     * @param \Cviebrock\EloquentLoggable\Loggable|\Illuminate\Database\Eloquent\Model $model
     *
     * @return void
     */
    public function restored(Loggable $model): void
    {
        $data = $this->buildDataToLog('restore', $model);

        Change::create($data);
    }

    /**
     * Build up the array of data to log.
     *
     * @param string $type
     * @param \Cviebrock\EloquentLoggable\Loggable|\Illuminate\Database\Eloquent\Model $model
     *
     * @return array
     */
    protected function buildDataToLog(string $type, Loggable $model): array
    {
        $data = [
            'change_type' => $type,
            'user_id'     => $this->userId,
            'model_type'  => get_class($model),
            'model_id'    => $model->getKey(),

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

        ];

        $data['change_set'] = $this->generateChangeSet($data);

        return $data;
    }

    /**
     * Return a "unique" hash to identify sets of changes.
     *
     * @param array $data
     *
     * @return string
     */
    protected function generateChangeSet(array $data): string
    {
        return substr(md5(serialize($data)), 0, 8) . '.' . microtime(true);
    }

    /**
     * Return an array of old and new values that should be logged.
     *
     * @param \Cviebrock\EloquentLoggable\Loggable|\Illuminate\Database\Eloquent\Model $model
     *
     * @return array
     */
    private function getLoggableAttributes(Loggable $model): array
    {
        // Get the list of all the changed attributes
        $attributes = $model->getDirty();

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

        // The list of timestamp attributes to filter out
        $timestamps = $this->getTimestampAttributes($model);

        // If the model has a defined list of attributes to log,
        // use that and filter the timestamp list accordingly
        if ($only = $model->getLoggableAttributes()) {
            $attributes = array_only($attributes, $only);
            $timestamps = array_diff($timestamps, $only);
        }

        // Finally, filter out any unloggable attributes,
        // and any remaining unloggable timestamp attributes
        if ($except = $model->getUnloggableAttributes()) {
            $attributes = array_except($attributes, array_merge($except, $timestamps));
        }

        // Get a list of attributes to be obfuscated
        $hidden = $model->getHidden();

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

        return array_map(
            function($attribute, $value) use ($model, $hidden) {
                if (in_array($attribute, $hidden, null)) {
                    return [
                        'attribute' => $attribute,
                        'old_value' => '** HIDDEN **',
                        'new_value' => '** HIDDEN **',
                    ];
                }

                return [
                    'attribute' => $attribute,
                    'old_value' => $model->getOriginal($attribute),

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

                    'new_value' => $value,
                ];
            },
            array_keys($attributes), $attributes
        );
    }

    /**
     * Get the timestamp attributes on the model that are normally not logged.
     *
     * @param \Cviebrock\EloquentLoggable\Loggable|\Illuminate\Database\Eloquent\Model $model
     *
     * @return array
     */
    private function getTimestampAttributes(Loggable $model): array
    {
        if (!$model->usesTimestamps()) {

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

            return [];
        }

        $attributes = [
            $model->getCreatedAtColumn(),

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

            $model->getUpdatedAtColumn(),

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

        ];
        if (method_exists($model, 'getDeletedAtColumn')) {
            $attributes[] = $model->getDeletedAtColumn();

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

        }

        return $attributes;
    }

}