Mangopixel\Adjuster\CanBeAdjusted

Complexity

Total Complexity

22

Size/Duplication

Total Lines	185
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	bootCanBeAdjusted()	0	8	3
A	adjust()	0	15	3
A	adjustment()	0	8	2
A	applyAdjustments()	0	16	4
A	isAdjusted()	0	4	1
A	hasSaveProtection()	0	4	1
A	mergeAndFilterChanges()	0	8	1
A	isValidChange()	0	8	3
A	castChanges()	0	14	4
	fill()	0	1	?
	isFillable()	0	1	?
	morphOne()	0	1	?
	hasOne()	0	1	?

<?php

namespace Mangopixel\Adjuster;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Support\Collection;
use Mangopixel\Adjuster\Contracts\Adjustable;
use Mangopixel\Adjuster\Exceptions\ModelAdjustedException;

/**
 * This trait is where most of the package logic lives. This trait satisfies the
 * entire Adjustable contract and you should only use the trait on classes that
 * extend Illuminate\Database\Eloquent\Model.
 *
 * @package Laravel Adjuster
 * @author  Alexander Tømmerås <flugged@gmail.com>
 * @license The MIT License
 */
trait CanBeAdjusted
{
    /**
     * A boolean to keep track of wether the model has been adjusted or not.
     *
     * @var bool
     */
    protected $adjusted = false;

    /**
     * The booting method of the model trait. This method will be called once the model
     * has been booted, and registers an event listener that listens for save calls
     * to block if save protection is enabled.
     *
     * @return void
     * @throws ModelAdjustedException
     */
    protected static function bootCanBeAdjusted()
    {
        static::saving( function ( Adjustable $model ) {
            if ( $model->isAdjusted() && $model->hasSaveProtection() ) {
                throw new ModelAdjustedException();
            }
        } );
    }

    /**
     * Adjusts the model by updating an existing record in the adjustments table or adds
     * a new one if no previous adjustments are set. All changes will be merged with
     * old changes and old changes can be unset using null.
     *
     * @param  array $changes
     * @param  array $attributes
     * @return Model|null
     */
    public function adjust( array $changes, array $attributes = [ ] )
    {
        $adjustment = $this->adjustment()->exists() ? $this->adjustment : app( 'adjuster.model' );
        $changes = $this->mergeAndFilterChanges( $changes, $adjustment );

        if ( $changes->isEmpty() ) {
            $adjustment->delete();
        } else {
            $adjustment->fill( $attributes );
            $adjustment->{config( 'adjuster.changes_column' )} = $this->castChanges( $changes, $adjustment );
            $this->adjustment()->save( $adjustment );

            return $adjustment;
        }
    }

    /**
     * Get the adjustment associated with the adjustable model.
     *
     * @return Relation
     */
    public function adjustment():Relation
    {
        if ( config( 'adjuster.polymorphic' ) ) {
            return $this->morphOne( config( 'adjuster.adjustment_model' ), config( 'adjuster.adjustable_column' ) );
        } else {
            return $this->hasOne( config( 'adjuster.adjustment_model' ), config( 'adjuster.adjustable_column' ) );
        }
    }

    /**
     * Fill the model instance with the adjusted values, replacing the original values.
     *
     * @return $this
     */
    public function applyAdjustments():Model
    {
        $changes = $this->adjustment->{config( 'adjuster.changes_column' )} ?? null;

        if ( $changes instanceof Collection ) {
            $changes = $changes->toArray();
        } elseif ( is_string( $changes ) ) {
            $changes = json_decode( $changes, true );
        } elseif ( is_null( $changes ) ) {
            return $this;
        }

        $this->adjusted = true;

        return $this->fill( $changes );
    }

    /**
     * Checks if the given model has applied the adjustments.
     *
     * @return bool
     */
    public function isAdjusted():bool
    {
        return $this->adjusted;
    }

    /**
     * Checks if save protection is enabled. Save protection protects you from persisting
     * the model after applying the adjustments.
     *
     * @return bool
     */
    public function hasSaveProtection():bool
    {
        return $this->saveProtection ?? config( 'adjuster.save_protection' );
    }

    /**
     * We will fetch any existing changes from the adjustment and then filter them down
     * based on certain criterias. Then we will return the changes converted to the
     * correct data type depending on set casts on the Adjustment model.
     *
     * @param  array $changes
     * @param  Model $adjustment
     * @return Collection
     */
    protected function mergeAndFilterChanges( array $changes, Model $adjustment ):Collection
    {
        $existingChanges = collect( $adjustment->{config( 'adjuster.changes_column' )} );

        return $existingChanges->merge( $changes )->filter( function ( $value, $attribute ) {
            return $this->isValidChange( $attribute, $value );
        } );
    }

    /**
     * Checks if a given attribute value pair is valid. The value should not be null and
     * not be equal the original value, and the attribute should actually be fillable.
     *
     * @param  string $attribute
     * @param  mixed  $value
     * @return bool
     */
    protected function isValidChange( string $attribute, $value ):bool
    {
        if ( is_null( $value ) || $value === $this->$attribute ) {
            return false;
        }

        return $this->isFillable( $attribute );
    }

    /**
     * Cast the changes collection to the appropiate type.
     *
     * @param  Collection $changes
     * @param  Model      $adjustment
     * @return mixed
     */
    protected function castChanges( Collection $changes, Model $adjustment )
    {
        $cast = $adjustment->hasCast( config( 'adjuster.changes_column' ) );

        switch ( $cast ) {
            case 'collection':
                return $changes;
            case 'array':
            case 'json':
                return $changes->toArray();
            default:
                return $changes->toJson();
        }
    }

    /**
     * Fill the model with an array of attributes.
     */
    abstract public function fill( array $attributes );

    /**
     * Determine if the given attribute may be mass assigned.
     */
    abstract public function isFillable( $key );

    /**
     * Define a polymorphic one-to-one relationship.
     */
    abstract public function morphOne( $related, $name, $type = null, $id = null, $localKey = null );

    /**
     * Define a one-to-one relationship.
     */
    abstract public function hasOne( $related, $foreignKey = null, $localKey = null );
}