Audit\Traits\Loggable

Complexity

Total Complexity

23

Size/Duplication

Total Lines	195
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	changes()	0	4	1
A	bootLoggable()	0	17	1
A	shouldLogChange()	0	5	3
A	showTrashedVersion()	0	8	3
A	lookupRequestedChange()	0	20	4
B	builderMatchesChange()	0	29	6
A	replaceAttributesWithChange()	0	11	3
A	attributesAtChange()	0	9	1
A	previousChanges()	0	8	1

<?php

namespace Audit\Traits;

// Deps
use App;
use Facilitador\Models\Admin;
use Audit\Models\Change;
use MediaManager\Models\Image;
use Facilitador;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\SoftDeletingScope;
use Muleta\Traits\Models\SerializeWithImages;
use Muleta\Traits\Models\CanSerializeTransform;

/**
 * Enable logging changes to models
 */
trait Loggable
{
    /**
     * The name of the scope that is applied to make trashed versions to be
     * viewable
     *
     * @var string
     */
    static public $LOGGABLE_SCOPE = 'view trashed versions';

    /**
     * Previous (to the change referenced in the request query) changes made
     * to this model
     *
     * @var Collection
     */
    private $previous_changes;

    /**
     * Get the polymorphic relationship to Changes
     *
     * @return Illuminate\Database\Eloquent\Relations\Relation
     */
    public function changes()
    {
        return $this->morphMany(Change::class, 'loggable', 'model', 'key');

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

    }

     /**
      * Boot events
      *
      * @return void
      */
    public static function bootLoggable()
    {
        // Add scope that will fetch trashed versions of models when the
        // Change::QUERY_KEY is present.
        static::addGlobalScope(
            static::$LOGGABLE_SCOPE, function (Builder $builder) {
                static::showTrashedVersion($builder);
            }
        );

        // Substitute attribute values from changes on load
        static::retrieved(
            function ($model) {
                $model->replaceAttributesWithChange();
            }
        );
    }

    /**
     * Should this model log it's changes.  Defaults to true if the change
     * happened while handling an admin request or via the console but not
     * during a non-http unit test.
     *
     * @param  string $action Like "deleted", "updated", etc
     * @return boolean
     */
    public function shouldLogChange($action)

The parameter $action is not used and could be removed.

    {
        return Facilitador::handling()
            || (App::runningInConsole() && request()->path() == '/');
    }

    /**
     * Show trashed models for matching change
     *
     * @param  Builder $builder
     * @return void
     */
    private static function showTrashedVersion(Builder $builder)
    {
        if (($change = static::lookupRequestedChange())
            && static::builderMatchesChange($change, $builder)
        ) {
            $builder->withoutGlobalScope(SoftDeletingScope::class);
        }
    }

    /**
     * Get a Change record mentioned in the query, if appropriate
     *
     * @return Change|void
     */
    private static function lookupRequestedChange()
    {
        // Only run if the query param is present
        if (!$change_id = request(Change::QUERY_KEY)) {
            return;
        }

        // Don't execute for classes that result in recusirve queries when the
        // Change model gets built below
        $class = get_called_class();
        if (in_array($class, [Change::class, Admin::class, Image::class])) {
            return;
        }

        // Check whether the referenced Change is for this class
        $change = Change::find($change_id);
        if ($class == $change->model) {
            return $change;
        }
    }

    /**
     * Does the Change referenced in the GET query match the conditions already
     * applied in the query builder?
     *
     * @param  Change  $change
     * @param  Builder $builder
     * @return boolean
     */
    private static function builderMatchesChange(Change $change, Builder $builder)
    {
        $class = $change->model;

The property model does not exist on object<Audit\Models\Change>. Since you implemented __set, maybe consider adding a @property annotation.

        $route_key_name = (new $class)->getRouteKeyName();
        return collect($builder->getQuery()->wheres)
            ->contains(
                function ($where) use ($change, $route_key_name) {

                    // If the builder is keyed to a simple "id" in the route, return
                    // whether the Change matches it.
                    if ($route_key_name == 'id') {
                        return $where['column'] == $route_key_name
                        && $where['operator'] == '='
                        && $where['value'] == $change->key;

The property key does not exist on object<Audit\Models\Change>. Since you implemented __get, maybe consider adding a @property annotation.

                        // Otherwise compare against model logged by the change. The
                        // scope needs to be removed to prevent recursion.
                    } else {
                        $value = $change->changedModel()
                            ->withoutGlobalScope(static::$LOGGABLE_SCOPE)
                            ->first()
                            ->$route_key_name;
                        return $where['column'] == $route_key_name
                        && $where['operator'] == '='
                        && $where['value'] == $value;
                    }
                }
            );
    }

    /**
     * Replace all the attributes with those from the specified Change specified
     * in the reqeust query.
     *
     * @return void
     */
    private function replaceAttributesWithChange()

This method is not used, and could be removed.

    {
        if (($change = static::lookupRequestedChange())
            && $change->key == $this->getKey()

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

The property key does not exist on object<Audit\Models\Change>. Since you implemented __get, maybe consider adding a @property annotation.

        ) {
            $this->attributes = array_merge(

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

                $this->attributes,
                $this->attributesAtChange($change)
            );
        }
    }

    /**
     * Get the attributes of the model at a given Change
     *
     * @param  Change $change
     * @return array
     */
    private function attributesAtChange(Change $change)
    {
        return $this->previousChanges($change)
            ->reduce(
                function ($attributes, $change) {
                    return array_merge($attributes, $change->changed);
                }, []
            );
    }

    /**
     * Get the list of pervious changes of this model, storing it to reduce
     * future lookups
     *
     * @param  Change $change
     * @return Collection
     */
    private function previousChanges(Change $change)
    {
        return $this->changes()
            ->where('changes.id', '<=', $change->id)

The property id does not exist on object<Audit\Models\Change>. Since you implemented __get, maybe consider adding a @property annotation.

            ->orderBy('changes.id', 'asc')
            ->get();

    }

}