Victorlap\Approvable\Approvable

Complexity

Total Complexity

22

Size/Duplication

Total Lines	164
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

94.83%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	bootApprovable()	0	6	1
A	approvals()	0	4	1
A	isPendingApproval()	0	9	1
A	getPendingApprovalAttributes()	0	7	1
B	preSave()	0	34	5
B	changedApprovableFields()	0	22	6
B	isApprovable()	0	11	5
A	getSystemUserId()	0	4	1
A	currentUserCanApprove()	0	4	1

<?php

namespace Victorlap\Approvable;

use Illuminate\Database\Eloquent\Relations\MorphMany;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;

/**
 * Class Approvable
 * @package Victorlap\Approvable
 */
trait Approvable
{

    /**
     * @var array
     */
    protected $approveOf = array();

    /**
     * @var array
     */
    protected $dontApproveOf = array();

    /**
     * Create the event listeners for the saving event
     * This lets us save approvals whenever a save is made, no matter the
     * http method
     */
    public static function bootApprovable()
    {
        static::saving(function ($model) {
            return $model->preSave();
        });
    }

    /**
     * @return MorphMany
     */
    public function approvals()
    {
        return $this->morphMany(Approval::class, 'approvable');

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

    }

    /**
     * Check if this model has pending changes,
     * If an attribute is provided, check if the attribute has pending changes.
     *
     * @param null $attribute
     * @return bool
     */
    public function isPendingApproval($attribute = null)
    {
        return $this->approvals()
                ->when($attribute !== null, function ($query) use ($attribute) {
                    $query->where('key', $attribute);
                })
                ->where('approved', null)
                ->exists();
    }

    /**
     * List all the attributes, that currently have pending changes.
     *
     * @return \Illuminate\Support\Collection
     */
    public function getPendingApprovalAttributes()
    {
        return $this->approvals()
            ->where('approved', null)
            ->groupBy('key')
            ->pluck('key');
    }

    /**
     * Invoked before a model is saved. Return false to abort the operation.
     *
     * @return bool
     */
    public function preSave()
    {
        if ($this->currentUserCanApprove()) {
            // If the user is able to approve edits, do nothing.
            return true;
        }

        if (!$this->exists) {

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

            // There is currently no way (implemented) to enable this for new models.
            return true;
        }

        $changes_to_record = $this->changedApprovableFields();

        $approvals = array();
        foreach ($changes_to_record as $key => $change) {
            $approvals[] = array(
                'approvable_type' => $this->getMorphClass(),

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

                'approvable_id' => $this->getKey(),

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

                'key' => $key,
                'value' => $change,
                'user_id' => $this->getSystemUserId(),
                'created_at' => new \DateTime(),
                'updated_at' => new \DateTime(),
            );
        }

        if (count($approvals) > 0) {
            $approval = new Approval();
            DB::table($approval->getTable())->insert($approvals);
        }

        return true;
    }

    /**
     * Get all of the changes that have been made, that are also supposed
     * to be approved.
     *
     * @return array fields with new data, that should be recorded
     */
    private function changedApprovableFields()
    {
        $dirty = $this->getDirty();

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

        $changes_to_record = array();

        foreach ($dirty as $key => $value) {
            if ($this->isApprovable($key)) {
                if (!isset($this->original[$key]) || $this->original[$key] != $this->attributes[$key]) {
                    $changes_to_record[$key] = $value;

                    // Reset changes that we want to approve
                    if (!isset($this->original[$key])) {
                        unset($this->attributes[$key]);
                    } else {
                        $this->attributes[$key] = $this->original[$key];

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

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

                    }
                }
            }
        }

        return $changes_to_record;
    }

    /**
     * @param $key
     * @return bool
     */
    private function isApprovable($key)
    {
        if (isset($this->approveOf) && in_array($key, $this->approveOf)) {
            return true;
        }
        if (isset($this->dontApproveOf) && in_array($key, $this->dontApproveOf)) {
            return false;
        }

        return empty($this->approveOf);
    }

    /**
     * @return mixed|null
     */
    protected function getSystemUserId()
    {
        return Auth::id() ?? null;
    }

    /**
     * @return bool
     */
    protected function currentUserCanApprove()
    {
        return Auth::user()->can('approve', $this) ?? false;

It seems like you code against a concrete implementation and not the interface Illuminate\Contracts\Auth\Authenticatable as the method can() does only exist in the following implementations of said interface: Illuminate\Foundation\Auth\User.

    }
}