HasItemStocks::take() - Code Metrics - ronmrcdo/laravel-inventory - Measure and Improve Code Quality continuously with Scrutinizer

HasItemStocks::take() A
last analyzed 2020-02-23 12:18 UTC

↳ Parent: HasItemStocks
Complexity

Conditions	3
Paths	2
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	2
c	1
b	0
f	0
dl	0
loc	4
rs	10
cc	3
nc	2
nop	3
<?php

namespace Ronmrcdo\Inventory\Traits;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\DB;
use Ronmrcdo\Inventory\Exceptions\NotEnoughStockException;
use Ronmrcdo\Inventory\Exceptions\InvalidMovementException;

trait HasItemStocks
{
	/**
     * Stores the quantity before an update.
     *
     * @var int|float|string
     */
    private $beforeQuantity = 0;

    /**
     * Stores the reason for updating / creating a stock.
     *
     * @var string
     */
    public $reason = '';

    /**
     * Stores the cost for updating a stock.
     *
     * @var int|float|string
     */
	public $cost = 0;
	
	protected static function bootHasItemStocks()
	{
		static::creating(function (Model $model) {

            /*
             * Check if a reason has been set, if not
             * let's retrieve the default first entry reason
             */
            if (!$model->reason) {
                $model->reason = 'First Item Record; Stock Increase';
            }
		});
		
		static::created(function (Model $model) {
            $model->postCreate();
		});
		
		static::updating(function (Model $model) {
            /*
             * Retrieve the original quantity before it was updated,
             * so we can create generate an update with it
             */
            $model->beforeQuantity = $model->getOriginal('quantity');

            /*
             * Check if a reason has been set, if not let's retrieve the default change reason
             */
            if (!$model->reason) {
                $model->reason = 'Stock Adjustment';
            }
		});
		
		static::updated(function (Model $model) {
            $model->postUpdate();
        });
	}

	/**
     * Generates a stock movement on the creation of a stock.
     */
    public function postCreate()
    {
        if (!$this->getLastMovement()) {
            $this->generateStockMovement(0, $this->quantity, $this->reason, $this->cost);
        }
	}
	
	/**
     * Generates a stock movement after a stock is updated.
     */
    public function postUpdate()
    {
        $this->generateStockMovement($this->beforeQuantity, $this->quantity, $this->reason, $this->cost);
	}
	
	/**
     * Performs a quantity update. Automatically determining
     * depending on the quantity entered if stock is being taken
     * or added.
     *
     * @param int|float|string $quantity
     * @param string           $reason
     * @param int|float|string $cost
     *
     * @throws InvalidQuantityException
     *
     * @return $this
     */
    public function updateQuantity($quantity, $reason = '', $cost = 0)
    {
        if ($this->isValidQuantity($quantity)) {
        if ($this->/** @scrutinizer ignore-call */ isValidQuantity($quantity)) {
            return $this->processUpdateQuantityOperation($quantity, $reason, $cost);

        }
    }

    /**
     * Removes the specified quantity from the current stock.
     *
     * @param int|float|string $quantity
     * @param string           $reason
     * @param int|float|string $cost
     *
     * @return $this|bool
     */
    public function remove($quantity, $reason = '', $cost = 0)
    {
        return $this->take($quantity, $reason, $cost);
    }

    /**
     * Processes a 'take' operation on the current stock.
     *
     * @param int|float|string $quantity
     * @param string           $reason
     * @param int|float|string $cost
     *
     * @throws InvalidQuantityException
     * @throws NotEnoughStockException
     *
     * @return $this|bool
     */
    public function take($quantity, $reason = '', $cost = 0)
    {
        if ($this->isValidQuantity($quantity) && $this->hasEnoughStock($quantity)) {
            return $this->processTakeOperation($quantity, $reason, $cost);
        }
    }

    /**
     * Alias for put function.
     *
     * @param int|float|string $quantity
     * @param string           $reason
     * @param int|float|string $cost
     *
     * @return $this
     */
    public function add($quantity, $reason = '', $cost = 0)
    {
        return $this->put($quantity, $reason, $cost);

    }

    /**
     * Processes a 'put' operation on the current stock.
     *
     * @param int|float|string $quantity
     * @param string           $reason
     * @param int|float|string $cost
     *
     * @throws InvalidQuantityException
     *
     * @return $this
     */
    public function put($quantity, $reason = '', $cost = 0)
    {
        if ($this->isValidQuantity($quantity)) {
            return $this->processPutOperation($quantity, $reason, $cost);

        }
    }

    /**
     * Moves a stock to the specified location.
     *
     * @param $location
     *
     * @return bool
     */
    public function moveTo($location)
    {
        $location = $this->getLocation($location);
        $location = $this->getLocation($location);

        return $this->processMoveOperation($location);
    }

    /**
     * Rolls back the last movement, or the movement specified. If recursive is set to true,
     * it will rollback all movements leading up to the movement specified.
     *
     * @param mixed $movement
     * @param bool  $recursive
     *
     * @return $this|bool
     */
    public function rollback($movement = null, $recursive = false)
    {
        if ($movement) {
            return $this->rollbackMovement($movement, $recursive);
        } else {
            $movement = $this->getLastMovement();

            if ($movement) {
                return $this->processRollbackOperation($movement, $recursive);
            }
        }

        return false;
    }

    /**
     * Rolls back a specific movement.
     *
     * @param mixed $movement
     * @param bool  $recursive
     *
     * @throws InvalidMovementException
     *
     * @return $this|bool
     */
    public function rollbackMovement($movement, $recursive = false)
    {
        $movement = $this->getMovement($movement);

        return $this->processRollbackOperation($movement, $recursive);
    }

    /**
     * Returns true if there is enough stock for the specified quantity being taken.
     * Throws NotEnoughStockException otherwise.
     *
     * @param int|float|string $quantity
     *
     * @throws NotEnoughStockException
     *
     * @return bool
     */
    public function hasEnoughStock($quantity = 0)
    {
        /*
         * Using double equals for validation of complete value only, not variable type. For example:
         * '20' (string) equals 20 (int)
         */
        if ($this->quantity == $quantity || $this->quantity > $quantity) {
            return true;
        }

        $message = 'Not enough stock. Tried to take '. $quantity.' but only '. $this->quantity .' is available';

        throw new NotEnoughStockException($message);
    }

    /**
     * Returns the last movement on the current stock record.
     *
     * @return mixed
     */
    public function getLastMovement()
    {
        $movement = $this->movements()->orderBy('created_at', 'DESC')->first();
        $movement = $this->/** @scrutinizer ignore-call */ movements()->orderBy('created_at', 'DESC')->first();

        if ($movement) {
            return $movement;
        }

        return false;
    }

    /**
     * Returns a movement depending on the specified argument. If an object is supplied, it is checked if it
     * is an instance of an eloquent model. If a numeric value is entered, it is retrieved by it's ID.
     *
     * @param mixed $movement
     *
     * @throws InvalidMovementException
     *
     * @return mixed
     */
    public function getMovement($movement)
    {
        if ($this->isModel($movement)) {
        if ($this->/** @scrutinizer ignore-call */ isModel($movement)) {
            return $movement;
        } elseif (is_numeric($movement)) {
            return $this->getMovementById($movement);
        } else {
            $message = 'Movement '. $movement .' is invalid';

            throw new InvalidMovementException($message);
        }
    }

    /**
     * Creates and returns a new un-saved stock transaction
     * instance with the current stock ID attached.
     *
     * @param string $name
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function newTransaction($name = '')
    {
        $transaction = $this->transactions()->getRelated();
        $transaction = $this->/** @scrutinizer ignore-call */ transactions()->getRelated();

        /*
         * Set the transaction attributes so they don't
         * need to be set manually
         */
        $transaction->stock_id = $this->getKey();
        $transaction->stock_id = $this->getKey();
        $transaction->name = $name;

        return $transaction;
    }

    /**
     * Retrieves a movement by the specified ID.
     *
     * @param int|string $id
     *
     * @return mixed
     */
    private function getMovementById($id)
    {
        return $this->movements()->find($id);
    }

    /**
     * Processes a quantity update operation.
     *
     * @param int|float|string $quantity
     * @param string           $reason
     * @param int|float|string $cost
     *
     * @return $this
     */
    private function processUpdateQuantityOperation($quantity, $reason = '', $cost = 0)
    {
        if ($quantity > $this->quantity) {
            $putting = $quantity - $this->quantity;

            return $this->put($putting, $reason, $cost);

        } else {
            $taking = $this->quantity - $quantity;

            return $this->take($taking, $reason, $cost);
        }
    }

    /**
     * Processes removing quantity from the current stock.
     *
     * @param int|float|string $taking
     * @param string           $reason
     * @param int|float|string $cost
     *
     * @return $this|bool
     */
    private function processTakeOperation($taking, $reason = '', $cost = 0)
    {
        $left = $this->quantity - $taking;

        /*
         * If the updated total and the beginning total are the same, we'll check if
         * duplicate movements are allowed. We'll return the current record if
         * they aren't.
         */
        if ($left == $this->quantity && !$this->allowDuplicateMovementsEnabled()) {
            return $this;
        }

        $this->quantity = $left;


        $this->setReason($reason);

        $this->setCost($cost);

        DB::beginTransaction();

        try {
            if ($this->save()) {
            if ($this->/** @scrutinizer ignore-call */ save()) {

                $this->fireModelEvent('inventory.stock.taken', [
                       fireModelEvent('inventory.stock.taken', [
                    'stock' => $this,
                ]);

                return $this;
            }
        } catch (\Exception $e) {
            DB::rollBack();
        }

        return false;
    }

    /**
     * Processes adding quantity to current stock.
     *
     * @param int|float|string $putting
     * @param string           $reason
     * @param int|float|string $cost
     *
     * @return $this|bool
     */
    private function processPutOperation($putting, $reason = '', $cost = 0)
    {
        $before = $this->quantity;

        $total = $putting + $before;

        /*
         * If the updated total and the beginning total are the same,
         * we'll check if duplicate movements are allowed
         */
        if ($total == $this->quantity && !$this->allowDuplicateMovementsEnabled()) {
            return $this;
        }

        $this->quantity = $total;


        $this->setReason($reason);

        $this->setCost($cost);

        DB::beginTransaction();

        try {
            if ($this->save()) {
                DB::commit();

                $this->fireModelEvent('inventory.stock.added', [
                    'stock' => $this,
                ]);

                return $this;
            }
        } catch (\Exception $e) {
            DB::rollBack();
        }

        return false;
    }

    /**
     * Processes the stock moving from it's current
     * location, to the specified location.
     *
     * @param mixed $location
     *
     * @return bool
     */
    private function processMoveOperation(Model $location)
    {
        $this->location_id = $location->getKey();


        DB::beginTransaction();

        try {
            if ($this->save()) {
                

                $this->fireModelEvent('inventory.stock.moved', [
                    'stock' => $this,
                ]);
				
				DB::commit();
                return $this;

            }
        } catch (\Exception $e) {
            DB::rollBack();
        }

        return false;
    }

    /**
     * Processes a single rollback operation.
     *
     * @param mixed $movement
     * @param bool  $recursive
     *
     * @return $this|bool
     */
    private function processRollbackOperation(Model $movement, $recursive = false)
    {
        if ($recursive) {
            return $this->processRecursiveRollbackOperation($movement);

        }

        $this->quantity = $movement->before;


        $reason = 'Rolled back to movement ID: '. $movement->getOriginal('id') .' on '. $movement->getOriginal('created_at');
        $reason = 'Rolled back to movement ID: '. /** @scrutinizer ignore-type */ $movement->getOriginal('id') .' on '. $movement->getOriginal('created_at');

        $this->setReason($reason);

        if ($this->rollbackCostEnabled()) {
            $this->setCost($movement->cost);
            $this->setCost(/** @scrutinizer ignore-type */ $movement->cost);

            $this->reverseCost();
        }

        DB::beginTransaction();

        try {
            if ($this->save()) {
                DB::commit();

                $this->fireModelEvent('inventory.stock.rollback', [
                    'stock' => $this,
                ]);

                return $this;
            }
        } catch (\Exception $e) {
            DB::rollBack();
        }

        return false;
    }

    /**
     * Processes a recursive rollback operation.
     *
     * @param mixed $movement
     *
     * @return array
     */
    private function processRecursiveRollbackOperation(Model $movement)
    {
        /*
         * Retrieve movements that were created after
         * the specified movement, and order them descending
         */
        $movements = $this
            ->movements()
            ->where('created_at', '>=', $movement->getOriginal('created_at'))
            ->orderBy('created_at', 'DESC')
            ->get();

        $rollbacks = [];

        if ($movements->count() > 0) {
            foreach ($movements as $movement) {
                $rollbacks = $this->processRollbackOperation($movement);
            }
        }

        return $rollbacks;

    }

    /**
     * Creates a new stock movement record.
     *
     * @param int|float|string $before
     * @param int|float|string $after
     * @param string           $reason
     * @param int|float|string $cost
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    private function generateStockMovement($before, $after, $reason = '', $cost = 0)
    {
        $insert = [
            'stock_id' => $this->getKey(),
            'before' => $before,
            'after' => $after,
            'reason' => $reason,
            'cost' => $cost,
        ];

        return $this->movements()->create($insert);
    }

    /**
     * Sets the cost attribute.
     *
     * @param int|float|string $cost
     */
    private function setCost($cost = 0)
    {
        $this->cost = $cost;
    }

    /**
     * Reverses the cost of a movement.
     */
    private function reverseCost()
    {
        if ($this->isPositive($this->cost)) {
        if ($this->/** @scrutinizer ignore-call */ isPositive($this->cost)) {
            $this->setCost(-abs($this->cost));
        } else {
            $this->setCost(abs($this->cost));
        }
    }

    /**
     * Sets the reason attribute.
     *
     * @param string $reason
     */
    private function setReason($reason = '')
    {
        $this->reason = $reason;
    }

    /**
     * Returns true/false from the configuration file determining
     * whether or not stock movements can have the same before and after
     * quantities.
     *
     * @return bool
     */
    private function allowDuplicateMovementsEnabled()
    {
        return false;
    }

    /**
     * Returns true/false from the configuration file determining
     * whether or not to rollback costs when a rollback occurs on
     * a stock.
     *
     * @return bool
     */
    private function rollbackCostEnabled()
    {
        return true;
    }

}

ronmrcdo / laravel-inventory

HasItemStocks::take() A last analyzed 2020-02-23 12:18 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

HasItemStocks::take() A
last analyzed 2020-02-23 12:18 UTC
