Victorlap\Approvable\Approvable

Complexity

Total Complexity

26

Size/Duplication

Total Lines	197
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

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

<?php

namespace Victorlap\Approvable;

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

trait Approvable
{

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

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

    /** @var bool */
    protected $withoutApproval = false;

    /**
     * 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(): void
    {
        static::saving(function ($model) {
            return $model->preSave();
        });
    }

    public function approvals(): MorphMany
    {
        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): bool
    {
        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(): Collection
    {
        return $this->approvals()
            ->where('approved', null)
            ->groupBy('key')
            ->pluck('key');
    }

    /**
     * Disable the approval process for this model instance.
     *
     * @param bool $withoutApproval Deprecated, see withoApproval()
     *                              Will be removed in 2.0.0
     *
     * @return self
     */
    public function withoutApproval(bool $withoutApproval = true): self
    {
        $this->withoutApproval = $withoutApproval;

        return $this;
    }

    /**
     * Enable the approval process for this model instance
     *
     * @return self
     */
    public function withApproval(): self
    {
        $this->withoutApproval = false;

        return $this;
    }

    /**
     * Invoked before a model is saved. Return false to abort the operation.
     *
     * @return bool
     */
    protected function preSave(): bool
    {
        if ($this->withoutApproval) {
            return true;
        }

        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(): array
    {
        $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;
    }

    /**
     * Return whether an attribute of this model should be approvable.
     *
     * @param string $key
     * @return bool
     */
    private function isApprovable(string $key): bool
    {
        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);
    }

    /**
     * Get the user id that should be stored as the requester for the approval.
     *
     * @return int|null
     */
    protected function getSystemUserId(): ?int
    {
        return Auth::id() ?? null;
    }

    /**
     * Check if the approval process needs to happen for the currently logged in user.
     *
     * @return bool
     */
    protected function currentUserCanApprove(): bool
    {
        return Auth::check() && 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.

    }
}