RichanFongdasen\EloquentBlameable\BlameableTrait

Complexity

Total Complexity

12

Size/Duplication

Total Lines	164
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	blameable()	0	7	2
A	bootBlameableTrait()	0	4	1
A	buildBlameableScope()	0	8	2
A	creator()	0	7	1
A	updater()	0	7	1
A	scopeCreatedBy()	0	4	1
A	scopeUpdatedBy()	0	4	1
A	silentUpdate()	0	11	2
A	useSoftDeletes()	0	4	1
	belongsTo()	0	1	?
	getDirty()	0	1	?
	getKeyName()	0	1	?
	getKey()	0	1	?
	newQueryWithoutScopes()	0	1	?

<?php

namespace RichanFongdasen\EloquentBlameable;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;

trait BlameableTrait
{
    /**
     * Get any of override 'blameable attributes'.
     *
     * @return array
     */
    public function blameable()
    {
        if (property_exists($this, 'blameable')) {
            return (array) static::$blameable;
        }
        return [];
    }

    /**
     * Boot the Blameable service by attaching
     * a new observer into the current model object.
     *
     * @return void
     */
    public static function bootBlameableTrait()
    {
        static::observe(app(BlameableObserver::class));
    }

    /**
     * Build blameable query scope.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param mixed                                 $userId
     * @param string                                $key
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    private function buildBlameableScope(Builder $query, $userId, $key)
    {
        if ($userId instanceof Model) {
            $userId = $userId->getKey();
        }

        return $query->where(app(BlameableService::class)->getConfiguration($this, $key), $userId);
    }

    /**
     * Get the user who created the record.
     *
     * @return \Illuminate\Database\Eloquent\Model

Should the return type not be \Illuminate\Database\Eloquent\Relations\BelongsTo?

     */
    public function creator()
    {
        return $this->belongsTo(
            app(BlameableService::class)->getConfiguration($this, 'user'),
            app(BlameableService::class)->getConfiguration($this, 'createdBy')
        );
    }

    /**
     * Get the user who updated the record for the last time.
     *
     * @return \Illuminate\Database\Eloquent\Model

Should the return type not be \Illuminate\Database\Eloquent\Relations\BelongsTo?

     */
    public function updater()
    {
        return $this->belongsTo(
            app(BlameableService::class)->getConfiguration($this, 'user'),
            app(BlameableService::class)->getConfiguration($this, 'updatedBy')
        );
    }

    /**
     * createdBy Query Scope.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param mixed                                 $userId
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeCreatedBy(Builder $query, $userId)
    {
        return $this->buildBlameableScope($query, $userId, 'createdBy');
    }

    /**
     * updatedBy Query Scope.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param mixed                                 $userId
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeUpdatedBy(Builder $query, $userId)
    {
        return $this->buildBlameableScope($query, $userId, 'updatedBy');
    }

    /**
     * Silently update the model without firing any
     * events.
     *
     * @return int
     */
    public function silentUpdate()
    {
        if (!$this->isDirty()) {

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

            return 0;
        }

        return $this->newQueryWithoutScopes()

The method where does only exist in Illuminate\Database\Eloquent\Builder, but not in RichanFongdasen\EloquentBlameable\BlameableTrait.

            ->where($this->getKeyName(), $this->getKey())
            ->getQuery()
            ->update($this->getDirty());
    }

    /**
     * Confirm if the current model uses SoftDeletes.
     *
     * @return boolean
     */
    public function useSoftDeletes()
    {
        return in_array(SoftDeletes::class, class_uses($this));
    }

    /**
     * Define an inverse one-to-one or many relationship.
     *
     * @param string $related
     * @param string $foreignKey

Should the type for parameter $foreignKey not be string|null?

     * @param string $otherKey

Should the type for parameter $otherKey not be string|null?

     * @param string $relation

Should the type for parameter $relation not be string|null?

     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    abstract public function belongsTo($related, $foreignKey = null, $otherKey = null, $relation = null);

    /**
     * Get the attributes that have been changed since last sync.
     *
     * @return array
     */
    abstract public function getDirty();

    /**
     * Get the primary key for the model.
     *
     * @return string
     */
    abstract public function getKeyName();

    /**
     * Get the value of the model's primary key.
     *
     * @return mixed
     */
    abstract public function getKey();

    /**
     * Get a new query builder that doesn't have any global scopes.
     *
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    abstract public function newQueryWithoutScopes();
}