GoetasWebservices\SoapServices\SoapClient\ClientFactory

Complexity

Total Complexity

19

Size/Duplication

Total Lines	118
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

95.24%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	setHeaderHandler()	0	4	1
A	setHttpClient()	0	4	1
A	setSerializer()	0	4	1
A	setMetadataReader()	0	4	1
A	getSoapService()	0	6	1
A	getClient()	0	10	4
A	getService()	0	10	4
A	getPort()	0	10	4
A	setMessageFactory()	0	4	1

<?php
namespace GoetasWebservices\SoapServices\SoapClient;

use GoetasWebservices\SoapServices\SoapClient\Arguments\Headers\Handler\HeaderHandler;
use GoetasWebservices\SoapServices\SoapClient\Metadata\Loader\MetadataLoaderInterface;
use GoetasWebservices\XML\WSDLReader\Exception\PortNotFoundException;
use GoetasWebservices\XML\WSDLReader\Exception\ServiceNotFoundException;
use Http\Client\HttpClient;
use Http\Discovery\HttpClientDiscovery;
use Http\Discovery\MessageFactoryDiscovery;
use Http\Message\MessageFactory;
use JMS\Serializer\SerializerInterface;

class ClientFactory
{
    /**
     * @var SerializerInterface
     */
    protected $serializer;
    /**
     * @var MessageFactory
     */
    protected $messageFactory;

    /**
     * @var HttpClient
     */
    protected $httpClient;

    /**
     * @var MetadataLoaderInterface
     */
    private $reader;

    /**
     * @var HeaderHandler
     */
    private $headerHandler;

    public function __construct(MetadataLoaderInterface $reader, SerializerInterface $serializer)
    {
        $this->setMetadataReader($reader);
        $this->setSerializer($serializer);
    }

    public function setHeaderHandler(HeaderHandler $headerHandler)
    {
        $this->headerHandler = $headerHandler;
    }

    public function setHttpClient(HttpClient $client)
    {
        $this->httpClient = $client;
    }

    /**
     * @param MessageFactory $messageFactory
     */
    public function setMessageFactory(MessageFactory $messageFactory)
    {
        $this->messageFactory = $messageFactory;
    }

    public function setSerializer(SerializerInterface $serializer)
    {
        $this->serializer = $serializer;
    }

    public function setMetadataReader(MetadataLoaderInterface $reader)
    {
        $this->reader = $reader;
    }

    private function getSoapService($wsdl, $portName = null, $serviceName = null)
    {
        $servicesMetadata = $this->reader->load($wsdl);
        $service = $this->getService($serviceName, $servicesMetadata);
        return $this->getPort($portName, $service);
    }

    /**
     * @param string $wsdl
     * @param null|string $portName
     * @param null|string $serviceName
     * @return Client
     */
    public function getClient($wsdl, $portName = null, $serviceName = null)
    {
        $service = $this->getSoapService($wsdl, $portName, $serviceName);

        $this->httpClient = $this->httpClient ?: HttpClientDiscovery::find();
        $this->messageFactory = $this->messageFactory ?: MessageFactoryDiscovery::find();
        $headerHandler = $this->headerHandler ?: new HeaderHandler();

        return new Client($service, $this->serializer, $this->messageFactory, $this->httpClient, $headerHandler);

$this->serializer of type object<JMS\Serializer\SerializerInterface> is not a sub-type of object<JMS\Serializer\Serializer>. It seems like you assume a concrete implementation of the interface JMS\Serializer\SerializerInterface to be always present.

    }

    /**
     * @param $serviceName
     * @param array $services
     * @return array
     * @throws ServiceNotFoundException
     */
    private function getService($serviceName, array $services)
    {
        if ($serviceName && isset($services[$serviceName])) {
            return $services[$serviceName];
        } elseif ($serviceName) {
            throw new ServiceNotFoundException("The service named $serviceName can not be found");
        } else {
            return reset($services);
        }
    }

    /**
     * @param string $portName
     * @param array $service
     * @return array
     * @throws PortNotFoundException
     */
    private function getPort($portName, array $service)
    {
        if ($portName && isset($service[$portName])) {
            return $service[$portName];
        } elseif ($portName) {
            throw new PortNotFoundException("The port named $portName can not be found");
        } else {
            return reset($service);
        }
    }
}