Freshcells\SoapClientBundle\SoapClient\SoapClient

Complexity

Total Complexity

46

Size/Duplication

Total Lines	299
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

82.35%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	37	6
A	getOptions()	0	4	1
A	__call()	0	14	3
A	__soapCall()	0	19	3
C	__doRequest()	0	62	14
A	preCall()	0	4	1
A	postCall()	0	12	1
A	faultCall()	0	7	1
B	resolveLocation()	0	11	7
A	setMockRequests()	0	4	1
A	setMockResponses()	0	4	1
A	setDispatcher()	0	8	2
A	handleFault()	0	11	2
A	dispatch()	0	15	3

<?php

namespace Freshcells\SoapClientBundle\SoapClient;

use Freshcells\SoapClientBundle\Event\Event;
use Freshcells\SoapClientBundle\Event\Events;
use Freshcells\SoapClientBundle\Event\FaultEvent;
use Freshcells\SoapClientBundle\Event\RequestEvent;
use Freshcells\SoapClientBundle\Event\ResponseEvent;
use Ramsey\Uuid\Uuid;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\EventDispatcher\LegacyEventDispatcherProxy;

/**
 * Class SoapClient
 */
class SoapClient extends \SoapClient implements SoapClientInterface
{
    /**
     * @var array
     */
    protected $options;
    /**
     * @var EventDispatcherInterface
     */
    protected $dispatcher;
    /**
     * @var array
     */
    private $mockRequests = [];
    /**
     * @var array
     */
    private $mockResponses = [];

    /**
     * SoapClient constructor.
     * @param null $wsdl
     * @param array|null $options
     */
    public function __construct($wsdl = null, array $options = [])
    {

        if (isset($options['mock_requests'])) {
            $this->setMockRequests($options['mock_requests']);
            unset($options['mock_requests']);
        }
        if (isset($options['mock_responses'])) {
            $this->setMockResponses($options['mock_responses']);
            unset($options['mock_responses']);
        }

        $defaults = array(
            'compression'        => (SOAP_COMPRESSION_ACCEPT | SOAP_COMPRESSION_GZIP),
            'cache_wsdl'         => WSDL_CACHE_BOTH,
            'connection_timeout' => 60,
            'exceptions'         => true,
            'features'           => SOAP_SINGLE_ELEMENT_ARRAYS,
            'soap_version'       => SOAP_1_2,
            'trace'              => true,
            'user_agent'         => 'freshcells/soap-client-bundle',
        );

        $options = array_merge($defaults, $options);

        if (!is_null($wsdl)) {
            // if option 'location' not set explicit use WSDL URL as service location
            // this was added for some obscure reason
            // dont use for local wsdl
            if (!isset($options['location']) && substr($wsdl, 0, 4) === "http") {
                $options['location'] = $this->resolveLocation($wsdl);
            }
        }

        $this->SoapClient($wsdl, $options);
        $this->options = $options;
    }

    public function getOptions(): array
    {
        return $this->options;
    }

    public function __call($function_name, $arguments)
    {
        try {
            $response = parent::__call($function_name, $arguments);
            //works only with 'exceptions' => false, we always throw
            if (is_soap_fault($response)) {
                throw $response;
            }
        } catch (\Exception $e) {
            $this->handleFault($function_name, $arguments, $e);
        }

        return $response;
    }

    public function __soapCall(
        $function_name,
        $arguments,
        $options = null,
        $input_headers = null,
        &$output_headers = null
    ) {
        try {
            $response = parent::__soapCall($function_name, $arguments, $options, $input_headers, $output_headers);
            //works only with 'exceptions' => false, we always throw
            if (is_soap_fault($response)) {
                throw $response;
            }
        } catch (\Exception $e) {
            $this->handleFault($function_name, $arguments, $e);
        }

        return $response;
    }

    /**
     * @param string $request
     * @param string $location
     * @param string $action
     * @param int $version
     * @param null $one_way
     * @return bool|string
     */
    public function __doRequest($request, $location, $action, $version, $one_way = null)
    {
        $id = Uuid::uuid1();

        foreach ($this->mockRequests as $key => $mockRequest) {
            if (is_string($key)) {
                if (strrpos($action, $key) !== false) {
                    $request = file_get_contents($mockRequest);
                    break;
                }
            } else {
                if (is_callable($mockRequest)) {
                    if ($requestFilePath = $mockRequest($request, $location, $action, $version, $one_way)) {
                        $request = file_get_contents($requestFilePath);
                        break;
                    }
                }
            }
        }

        $this->preCall($id->toString(), (string)$action, $request);

        foreach ($this->mockResponses as $key => $mockResponse) {
            if (is_string($key)) {
                if (strrpos($action, $key) !== false) {
                    $response = file_get_contents($mockResponse);

                    $this->postCall($id->toString(), $action, $response);

                    return $response;
                }
            } else {
                if (is_callable($mockResponse)) {
                    if ($responseFilePath = $mockResponse($request, $location, $action, $version, $one_way)) {
                        $response = file_get_contents($responseFilePath);

                        $this->postCall($id->toString(), $action, $response);

                        return $response;
                    }
                }
            }
        }

        /* workaround for working timeout */
        $socketTimeout = false;
        if (isset($this->options['connection_timeout'])
            && (int)$this->options['connection_timeout'] > (int)ini_get('default_socket_timeout')
        ) {
            $socketTimeout = ini_set('default_socket_timeout', $this->options['connection_timeout']);
        }

        $response = parent::__doRequest($request, $location, $action, $version, $one_way);

        $this->postCall($id->toString(), (string)$action, $response);

        if ($socketTimeout !== false) {
            ini_set('default_socket_timeout', $socketTimeout);
        }

        return $response;
    }

    /**
     * Triggered before a request is executed
     *
     * @param string $id
     * @param string $resource
     * @param string $requestContent
     */
    protected function preCall(string $id, string $resource, string $requestContent = null)
    {
        $this->dispatch(new RequestEvent($id, $resource, $requestContent), Events::REQUEST);
    }

    /**
     * @param string $id
     * @param string $resource
     * @param string $response
     */
    protected function postCall(string $id, string $resource, string $response = null)
    {
        $responseEvent = new ResponseEvent(
            $id,
            $resource,
            $this->__getLastRequest(),
            $this->__getLastRequestHeaders(),
            $response,
            $this->__getLastResponseHeaders()
        );
        $this->dispatch($responseEvent, Events::RESPONSE);
    }

    /**
     * @param string $id
     * @param string $resource
     * @param string $requestContent
     * @param \Exception $exception
     */
    protected function faultCall(string $id, string $resource, string $requestContent, \Exception $exception)
    {
        $this->dispatch(
            new FaultEvent($id, $exception, new RequestEvent($id, $resource, $requestContent)),
            Events::FAULT
        );
    }

    /**
     * @param string $wsdl
     * @return string
     */
    protected function resolveLocation($wsdl)
    {
        $wsdlUrl = parse_url($wsdl);

        return ((isset($wsdlUrl['scheme'])) ? $wsdlUrl['scheme'].'://' : '')
            .((isset($wsdlUrl['user'])) ? $wsdlUrl['user']
                .((isset($wsdlUrl['pass'])) ? ':'.$wsdlUrl['pass'] : '').'@' : '')
            .((isset($wsdlUrl['host'])) ? $wsdlUrl['host'] : '')
            .((isset($wsdlUrl['port'])) ? ':'.$wsdlUrl['port'] : '')
            .((isset($wsdlUrl['path'])) ? $wsdlUrl['path'] : '');
    }

    /**
     * @param array $mockRequests
     */
    public function setMockRequests(array $mockRequests)
    {
        $this->mockRequests = $mockRequests;
    }

    /**
     * @param array $mockResponses
     */
    public function setMockResponses(array $mockResponses)
    {
        $this->mockResponses = $mockResponses;
    }

    /**
     * @param EventDispatcherInterface $dispatcher
     * @required
     */
    public function setDispatcher(EventDispatcherInterface $dispatcher)
    {
        if (class_exists(LegacyEventDispatcherProxy::class)) {
            $this->dispatcher = LegacyEventDispatcherProxy::decorate($dispatcher);
        } else {
            $this->dispatcher = $dispatcher;
        }
    }

    /**
     * @param $function_name
     * @param $arguments
     * @param $e
     */
    protected function handleFault($function_name, $arguments, $e): void
    {
        $request = $this->__getLastRequest();
        if ($request === null) { //only dispatch this when no request was fired
            $request = implode(' ', $arguments);
            $id      = Uuid::uuid1();
            $this->faultCall($id->toString(), $function_name, $request, $e);
        }

        throw $e;
    }

    /**
     * @param Event $event
     * @param string $eventName
     */
    private function dispatch(Event $event, $eventName)
    {
        if (null === $this->dispatcher) {
            return;
        }

        // LegacyEventDispatcherProxy exists in Symfony >= 4.3
        if (class_exists(LegacyEventDispatcherProxy::class)) {
            // New Symfony 4.3 EventDispatcher signature
            $this->dispatcher->dispatch($event, $eventName);

$event is of type object<Freshcells\SoapClientBundle\Event\Event>, but the function expects a object<Symfony\Contracts\EventDispatcher\object>.

        } else {
            // Old EventDispatcher signature
            $this->dispatcher->dispatch($eventName, $event);

$eventName is of type string, but the function expects a object<Symfony\Contracts\EventDispatcher\object>.

$event is of type object<Freshcells\SoapClientBundle\Event\Event>, but the function expects a null|string.

        }
    }
}