Iris\SaleWrapper\Base

Complexity

Total Complexity

15

Size/Duplication

Total Lines	133
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	4

Test Coverage

Coverage

42.5%

Importance

Changes	7
Bugs	2	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getOrderService()	0	4	1
A	getPartnerApiClient()	0	4	1
A	getVentureApiClient()	0	4	1
A	getManager()	0	4	1
A	canCall()	0	7	2
A	call()	0	11	1
A	mappingArguments()	0	11	2
A	validateArgument()	0	6	2
A	getOrderMapping()	0	5	2
A	setOrderMapping()	0	5	1

<?php

namespace Iris\SaleWrapper;

abstract class Base
{
    /**
     * @var \Iris\Manager
     */
    private $manager;

    /**
     * @var \Iris\Mapping\Order
     */
    private $orderMapping;

    /**
     * @param \Iris\Manager $manager
     */
    public function __construct(\Iris\Manager $manager)
    {
        $this->manager = $manager;
    }

    /**
     * @return \Iris\Interfaces\Order
     */
    public function getOrderService()
    {
        return $this->getManager()->getService(\Iris\Factory::ORDER);
    }

    /**
     * @return \Iris\Api\PartnerClient
     */
    public function getPartnerApiClient()
    {
        return $this->getManager()->getPartnerApiClient();
    }

    /**
     * @return \Iris\Api\VentureClient
     */
    public function getVentureApiClient()
    {
        return $this->getManager()->getVentureApiClient();
    }

    /**
     * @return \Iris\Manager
     */
    public function getManager()
    {
        return $this->manager;
    }

    /**
     * Check if method exists in current context.
     * @param string $methodName
     * @return bool
     */
    protected function canCall($methodName)
    {
        if (!method_exists($this, $methodName)) {
            throw new \Iris\Exceptions\MethodNotAllowed($methodName, $this->getName());

The method getName() does not seem to exist on object<Iris\SaleWrapper\Base>.

        }
        return true;
    }

    /**
     * @param string $methodName
     * @param array  $data
     * @return array
     */
    final public function call($methodName, array $data = array())
    {
        $this->canCall($methodName);

        $ref = new \ReflectionObject($this);
        $method = $ref->getMethod($methodName);

        $args = $this->mappingArguments($method, $data);

        return $method->invokeArgs($this, $args);
    }

    /**
     * @param \ReflectionMethod $method
     * @param array            $data
     * @return array
     * @throws \Iris\Exceptions\ParameterNotFound
     */
    final protected function mappingArguments(\ReflectionMethod $method, array $data)
    {
        $parameters = $method->getParameters();
        $args = [];
        foreach ($parameters as $parameter) {
            $parameterName = mb_strtolower(preg_replace('/([A-Z])/', '_\1', $parameter->name));
            $this->validateArgument($parameterName, $method, $data);
            $args[$parameter->name] = $data[$parameterName];
        }
        return $args;
    }

    /**
     * @param $parameterName
     * @param \ReflectionMethod $method
     * @param $data
     * @return void
     * @throws \Iris\Exceptions\ParameterNotFound
     */
    final protected function validateArgument($parameterName, \ReflectionMethod $method, $data)
    {
        if (!isset($data[$parameterName])) {
            throw new \Iris\Exceptions\ParameterNotFound($parameterName, $method->name);
        }
    }

    /**
     * @return \Iris\Mapping\Order
     */
    public function getOrderMapping()
    {
        $this->orderMapping || $this->setOrderMapping(\Iris\Mapping\Order::getInstance());
        return $this->orderMapping;
    }

    /**
     * @param \Iris\Mapping\Order $map
     * @return \Iris\SaleWrapper\Venture
     */
    public function setOrderMapping(\Iris\Mapping\Order $map)
    {
        $this->orderMapping = $map;
        return $this;
    }
}