Turahe\Counters\Traits\HasCounter

Complexity

Total Complexity

18

Size/Duplication

Total Lines	156
Duplicated Lines	0 %

Importance

Changes	2
Bugs	1	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	hasCounter()	0	3	1
A	removeCounter()	0	8	2
A	counters()	0	7	1
A	getCounter()	0	12	2
A	addCounter()	0	17	4
A	decrementCounter()	0	11	2
A	resetCounter()	0	11	2
A	getCounterValue()	0	10	2
A	incrementCounter()	0	11	2

<?php
namespace Turahe\Counters\Traits;

use Turahe\Counters\Models\Counter;
use Turahe\Counters\Facades\Counters;

/**
 * Trait HasCounter.
 * @package Turahe\Counters\Traits
 */
trait HasCounter
{
    /**
     * @return mixed
     * The morph relation between any model and counters
     */
    public function counters()
    {
        return $this->morphToMany(

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

            Counter::class,
            'counterable',
            'counterables'
        )->withPivot('value', 'id');
    }

    /**
     * @param $key
     * @return mixed
     * Get counter related to the relation with the given $key
     */
    public function getCounter($key)
    {
        //        dd($this->counters);
        $counter = $this->counters->where('key', $key)->first();

        //connect the counter to the object if it's not exist
        if (! $counter) {
            $this->addCounter($key);
            $counter = $this->counters->where('key', $key)->first();
        }

        return $counter;
    }

    /**
     * @param $key
     * @return bool
     * check if the related model has counter with the given key
     */
    public function hasCounter($key)
    {
        return ! is_null($this->counters()->where('counters.key', $key)->first());
    }

    /**
     * @param $key
     * @return null
     * Get the related model value of the counter for the given $key
     */
    public function getCounterValue($key)
    {
        $counter = $this->getCounter($key);
        $value = null;

        if ($counter) {
            $value = $counter->pivot->value;
        }

        return $value;
    }

    /**
     * @param $key
     * @param null $initialValue

Are you sure the doc-type for parameter $initialValue is correct as it would always require null to be passed?

     * Add a record to counterable table (make relation with the given $key)
     */
    public function addCounter($key, $initialValue = null)
    {
        $counter = Counters::get($key);

        if ($counter) {
            if (! $this->hasCounter($key)) { // not to add the counter twice
                $this->counters()->attach(
                    $counter->id,
                    [
                        'value' => ! is_null($initialValue) ? $initialValue : $counter->initial_value,

The condition is_null($initialValue) is always true.

                    ]
                );
            } else {
                logger("In addCounter: This object already has counter for $key");
            }
        } else {
            logger("In addCounter: Counter Is not found for key $key");
        }
    }

    /**
     * @param $key
     * Remove the relation in counterable table
     */
    public function removeCounter($key)
    {
        $counter = Counters::get($key);

        if ($counter) {
            $this->counters()->detach($counter->id);
        } else {
            logger("In removeCounter: Counter Is not found for key $key");
        }
    }

    /**
     * @param $key
     * @param null $step

Are you sure the doc-type for parameter $step is correct as it would always require null to be passed?

     * @return mixed
     * Increment the counterable in the relation table for the given $key
     */
    public function incrementCounter($key, $step = null)
    {
        $counter = $this->getCounter($key);

        if ($counter) {
            $this->counters()->updateExistingPivot($counter->id, ['value' => $counter->pivot->value + ($step ?? $counter->step)]);
        } else {
            logger("In incrementCounter: Counter Is not found for key $key");
        }

        return $counter;
    }

    /**
     * @param $key
     * @param null $step

Are you sure the doc-type for parameter $step is correct as it would always require null to be passed?

     * @return mixed
     * Decrement the counterable in the relation table for the given $key
     */
    public function decrementCounter($key, $step = null)
    {
        $counter = $this->getCounter($key);

        if ($counter) {
            $this->counters()->updateExistingPivot($counter->id, ['value' => $counter->pivot->value - ($step ?? $counter->step)]);
        } else {
            logger("In decrementCounter: Counter Is not found for key $key");
        }

        return $counter;
    }

    /**
     * @param $key
     * @param null $initalVlaue

Are you sure the doc-type for parameter $initalVlaue is correct as it would always require null to be passed?

     * @return mixed
     * Reset the counterable in the relation table to the initial value for the given $key
     */
    public function resetCounter($key, $initalVlaue = null)
    {
        $counter = $this->getCounter($key);

        if ($counter) {
            $this->counters()->updateExistingPivot($counter->id, ['value' =>$initalVlaue ?? $counter->initial_value]);
        } else {
            logger("In resetCounter: Counter Is not found for key $key");
        }

        return $counter;
    }
}