GoetasWebservices\SoapServices\SoapClient\ClientFactory

Complexity

Total Complexity

25

Size/Duplication

Total Lines	144
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

86%

Importance

Changes	3
Bugs	0	Features	1

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	setHeaderHandler()	0	4	1
A	setUnwrapResponses()	0	4	1
A	setHttpClient()	0	4	1
A	setMessageFactory()	0	4	1
A	setSerializer()	0	4	1
A	setMetadataGenerator()	0	4	1
A	getSoapService()	0	13	3
A	addNamespace()	0	4	1
B	getClient()	0	11	5
A	getService()	0	10	4
A	getPort()	0	10	4

<?php
namespace GoetasWebservices\SoapServices\SoapClient;

use GoetasWebservices\SoapServices\SoapClient\Arguments\Headers\Handler\HeaderHandler;
use GoetasWebservices\SoapServices\SoapCommon\Metadata\PhpMetadataGenerator;
use GoetasWebservices\SoapServices\SoapCommon\Metadata\PhpMetadataGeneratorInterface;
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
{
    protected $namespaces = [];
    protected $metadata = [];
    /**
     * @var SerializerInterface
     */
    protected $serializer;
    /**
     * @var MessageFactory
     */
    protected $messageFactory;

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

    /**
     * @var PhpMetadataGeneratorInterface
     */
    private $generator;

    private $unwrap = false;

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

    public function __construct(array $namespaces, SerializerInterface $serializer)
    {
        $this->setSerializer($serializer);

        foreach ($namespaces as $namespace => $phpNamespace) {
            $this->addNamespace($namespace, $phpNamespace);
        }
    }

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

    public function setUnwrapResponses($unwrap)
    {
        $this->unwrap = !!$unwrap;
    }

    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 setMetadataGenerator(PhpMetadataGeneratorInterface $generator)
    {
        $this->generator = $generator;
    }

    private function getSoapService($wsdl, $portName = null, $serviceName = null)
    {
        $generator = $this->generator ?: new PhpMetadataGenerator();

        foreach ($this->namespaces as $ns => $phpNs) {
            $generator->addNamespace($ns, $phpNs);
        }

        $services = $generator->generateServices($wsdl);
        $service = $this->getService($serviceName, $services);

        return $this->getPort($portName, $service);
    }

    public function addNamespace($uri, $phpNs)
    {
        $this->namespaces[$uri] = $phpNs;
    }

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

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

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

$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);
        }
    }
}