Mokka\Strategy\StrategyCalculator

Complexity

Total Complexity

11

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getInterval()	0	3	1
A	setInterval()	0	3	1
A	getSymbol()	0	3	1
A	__construct()	0	7	1
A	setMarket()	0	3	1
A	setSymbol()	0	3	1
A	getMarket()	0	3	1
A	run()	0	34	4

<?php

namespace Mokka\Strategy;


use DoctrineTest\InstantiatorTestAsset\AbstractClassAsset;
use Mokka\Action\Action;
use Mokka\Action\ActionInterface;
use Mokka\Action\BuyAction;
use Mokka\Action\IdleAction;
use Mokka\Action\SellAction;
use Mokka\Config\Logger;
use Mokka\Exchange\ExchangeInterface;

class StrategyCalculator
{

    /**
     * @var ExchangeInterface
     */
    private static $exchange;
    /**
     * @var IndicatorInterface
     */
    private static $indicator;


    /**
     * @var
     */
    private $symbol;

    /**
     * @var
     */
    private $interval;

    /**
     * @var
     */
    private $market;
    /**
     * StrategyCalculator constructor.
     * @param ExchangeInterface $exchange
     * @param IndicatorInterface $indicator
     */
    public function __construct(
        ExchangeInterface $exchange,
        IndicatorInterface $indicator
    )
    {
        self::$exchange = $exchange;
        self::$indicator = $indicator;

    }

    public function run(Logger $logger): Action
    {
        //get last action and price from logs
        $lastAction = $logger

Are you sure the assignment to $lastAction is correct as $logger->read()->where('market', '=', $this->getMarket())->where('symbol', '=', $this->getSymbol())->sortDesc('lastUpdate')->limit(1)->first() targeting Flatbase\Query\ReadQuery::first() seems to always return null.

            ->read()
            ->where('market', '=', $this->getMarket())
            ->where('symbol', '=', $this->getSymbol())
            ->sortDesc('lastUpdate')
            ->limit(1)
            ->first();

        $lastAction = new Action($lastAction);

        //calculate in loop by interval
        /** @var ActionInterface $actionType */
        $actionType = self::$indicator->calculate($this->getSymbol(), $lastAction);

        if ($actionType->getType() == ActionInterface::TYPE_BUY) {
            $action = new BuyAction();
        }elseif ($actionType->getType() == ActionInterface::TYPE_SELL) {
            $action = new SellAction();
        }elseif ($actionType->getType() == ActionInterface::TYPE_IDLE) {
            $action = new IdleAction();
        }

        /** @var ActionInterface $action */
        $action->setType($actionType->getType());

The variable $action does not seem to be defined for all execution paths leading up to this point.

        $action->setSymbol($this->getSymbol());

The method setSymbol() does not exist on Mokka\Action\ActionInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Mokka\Action\ActionInterface.

        $action->setMarket($this->getMarket());

The method setMarket() does not exist on Mokka\Action\ActionInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Mokka\Action\ActionInterface.

        $action->setPreviousPrice($lastAction->getActionPrice());
        $action->setActionPrice($actionType->getActionPrice());
        $action->setLastUpdate(time());

The method setLastUpdate() does not exist on Mokka\Action\ActionInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Mokka\Action\ActionInterface.

        return $action;

The expression return $action returns the type Mokka\Action\ActionInterface which is incompatible with the type-hinted return Mokka\Action\Action.

    }

    /**
     * @return mixed
     */
    public function getSymbol()
    {
        return $this->symbol;
    }

    /**
     * @param mixed $symbol
     */
    public function setSymbol($symbol)
    {
        $this->symbol = $symbol;
    }

    /**
     * @return mixed
     */
    public function getInterval()
    {
        return $this->interval;
    }

    /**
     * @param mixed $interval
     */
    public function setInterval($interval)
    {
        $this->interval = $interval;
    }

    /**
     * @return mixed
     */
    public function getMarket()
    {
        return $this->market;
    }

    /**
     * @param mixed $market
     */
    public function setMarket($market)
    {
        $this->market = $market;
    }

}