Commercetools\Core\Request\AbstractUpdateRequest

Complexity

Total Complexity

22

Size/Duplication

Total Lines	192
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

93.33%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getActions()	0	4	1
A	setActions()	0	13	4
A	addAction()	0	10	2
A	addActionAsArray()	0	7	1
B	checkActionLimit()	0	23	5
A	getId()	0	4	1
A	setId()	0	6	1
A	getVersion()	0	4	1
A	setVersion()	0	6	1
A	getPath()	0	4	1
A	httpRequest()	0	5	1
A	buildResponse()	0	4	1
A	hasActions()	0	4	1

<?php
/**
 * @author @jayS-de <jens.schulze@commercetools.de>
 * @created: 26.01.15, 17:22
 */

namespace Commercetools\Core\Request;

use Psr\Http\Message\ResponseInterface;
use Commercetools\Core\Client\HttpMethod;
use Commercetools\Core\Client\JsonEndpoint;
use Commercetools\Core\Client\JsonRequest;
use Commercetools\Core\Error\Message;
use Commercetools\Core\Model\Common\Context;
use Commercetools\Core\Model\Common\ContextAwareInterface;
use Commercetools\Core\Response\ResourceResponse;
use Commercetools\Core\Error\UpdateActionLimitException;

/**
 * @package Commercetools\Core\Request
 */
abstract class AbstractUpdateRequest extends AbstractApiRequest
{
    use ExpandTrait;

    const ACTION = 'action';
    const ACTIONS = 'actions';
    const VERSION = 'version';
    const ACTION_MAX_LIMIT = 500;
    const ACTION_WARNING_TRESHOLD = 400;

    /**
     * @var string
     */
    protected $id;

    /**
     * @var int
     */
    protected $version;

    /**
     * @var AbstractAction[]
     */
    protected $actions = [];

    protected $overLimit = false;

    /**
     * @param JsonEndpoint $endpoint
     * @param string $id
     * @param int $version
     * @param array $actions
     * @param Context $context
     */
    public function __construct($endpoint, $id, $version, array $actions = [], Context $context = null)
    {
        parent::__construct($endpoint, $context);
        $this->setId($id)->setVersion($version)->setActions($actions);
    }

    /**
     * @return AbstractAction[]
     */
    public function getActions()
    {
        return $this->actions;
    }

    /**
     * @return bool
     */
    public function hasActions()
    {
        return (0 !== count($this->actions));
    }

    /**
     * @param AbstractAction[] $actions
     * @return $this
     */
    public function setActions(array $actions)
    {
        $this->actions = [];
        foreach ($actions as $action) {
            if ($action instanceof AbstractAction) {
                $this->addAction($action);
            } elseif (is_array($action)) {
                $this->addActionAsArray($action);
            }
        }

        return $this;
    }

    /**
     * @param AbstractAction $action
     * @return $this
     */
    public function addAction(AbstractAction $action)
    {
        $this->actions[] = $action;
        if ($action instanceof ContextAwareInterface) {
            $action->setContextIfNull($this->getContextCallback());
        }
        $this->checkActionLimit();

        return $this;
    }

    /**
     * @param array $action
     * @return $this
     */
    public function addActionAsArray(array $action)
    {
        $this->actions[] = $action;
        $this->checkActionLimit();

        return $this;
    }

    protected function checkActionLimit()
    {
        if (count($this->actions) > static::ACTION_MAX_LIMIT) {
            $message = sprintf(
                Message::UPDATE_ACTION_LIMIT,
                $this->getPath(),
                static::ACTION_WARNING_TRESHOLD
            );
            throw new UpdateActionLimitException($message);
        }
        if (!$this->overLimit && count($this->actions) > static::ACTION_WARNING_TRESHOLD) {
            $this->overLimit = true;
            $logger = $this->getContext()->getLogger();
            if (!is_null($logger)) {
                $message = sprintf(
                    Message::UPDATE_ACTION_LIMIT_WARNING,
                    $this->getPath(),
                    static::ACTION_WARNING_TRESHOLD
                );
                $logger->warning($message);
            }
        }
    }

    /**
     * @return string
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * @param string $id
     * @return $this
     */
    public function setId($id)
    {
        $this->id = $id;

        return $this;
    }

    /**
     * @return int
     */
    public function getVersion()
    {
        return $this->version;
    }

    /**
     * @param int $version
     * @return $this
     */
    public function setVersion($version)
    {
        $this->version = $version;

        return $this;
    }

    /**
     * @return string
     * @internal
     */
    protected function getPath()
    {
        return (string)$this->getEndpoint() . '/' . $this->getId()  . $this->getParamString();
    }

    /**
     * @return JsonRequest
     * @internal
     */
    public function httpRequest()
    {
        $payload = [static::VERSION => $this->getVersion(), static::ACTIONS => $this->getActions()];
        return new JsonRequest(HttpMethod::POST, $this->getPath(), $payload);
    }

    /**
     * @param ResponseInterface $response
     * @return ResourceResponse
     * @internal
     */
    public function buildResponse(ResponseInterface $response)
    {
        return new ResourceResponse($response, $this, $this->getContext());
    }
}