Agavi\Dispatcher\SoapDispatcher::startup()

Complexity

Conditions	13
Paths	144

Size

Total Lines	120
Code Lines	60

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function startup()
    {
        parent::startup();
        
        // user-supplied "wsdl" and "options" parameters
        $wsdl = $this->getParameter('wsdl');
        if (!$wsdl) {
            // no wsdl was specified, that means we generate one from the annotations in routing.xml
            $wsdl = $this->context->getRouting()->getWsdlPath();

It seems like you code against a specific sub-type and not the parent class Agavi\Routing\Routing as the method getWsdlPath() does only exist in the following sub-classes of Agavi\Routing\Routing: Agavi\Routing\SoapRouting. Maybe you want to instanceof check for one of these explicitly?

        }
        $this->setParameter('wsdl', $wsdl);
        
        // get the name of the class to use for the client, defaults to PHP's own "SoapClient"
        $soapClientClass = $this->getParameter('soap_client_class', 'SoapClient');
        $soapClientOptions = $this->getParameter('soap_client_options', array());
        // get the name of the class to use for the server, defaults to PHP's own "SoapServer"
        $soapServerClass = $this->getParameter('soap_server_class', 'SoapServer');
        $soapServerOptions = $this->getParameter('soap_server_options', array());
        // get the name of the class to use for handling soap calls, defaults to Agavi's "AgaviSoapDispatcherCallHandler"
        $soapHandlerClass = $this->getParameter('soap_handler_class', 'AgaviSoapDispatcherCallHandler');
        
        // force client's soap version to be the same as the server's
        if (isset($soapServerOptions['soap_version'])) {
            $soapClientOptions['soap_version'] = $soapServerOptions['soap_version'];
        }
        
        // force client's cache_wsdl setting to be the same as the server's
        if (isset($soapServerOptions['cache_wsdl'])) {
            // and cast it to an int
            $soapServerOptions['cache_wsdl'] = (int)$soapServerOptions['cache_wsdl'];
            $soapClientOptions['cache_wsdl'] = $soapServerOptions['cache_wsdl'];
        }
        
        if (isset($soapServerOptions['features'])) {
            // cast this to an int
            $soapServerOptions['features'] = (int)$soapServerOptions['features'];
        }
        
        // create a client, so we can grab the functions and types defined in the wsdl (not possible from the server, duh)
        $this->soapClient = new $soapClientClass($wsdl, $soapClientOptions);
        
        if ($this->getParameter('auto_classmap')) {
            // we have to create a classmap automatically.
            // to do that, we read the defined types, and set identical values for type and class name.
            $classmap = array();
            
            // with an optional prefix, of course.
            $prefix = $this->getParameter('auto_classmap_prefix', '');
            
            foreach ($this->soapClient->__getTypes() as $definition) {
                if (preg_match('/^struct (\S+) \{$/m', $definition, $matches)) {
                    $classmap[$matches[1]] = $prefix . $matches[1];
                }
            }
            
            if (isset($soapServerOptions['classmap'])) {
                $classmap = array_merge((array) $classmap, $soapServerOptions['classmap']);
            }
            
            $soapServerOptions['classmap'] = $classmap;
        }
        
        // create a server
        $this->soapServer = new $soapServerClass($wsdl, $soapServerOptions);
        
        $newSoapHandlerClass = $soapHandlerClass . 'WithAutoHeaders';
        
        // build the special extension class to the handler that contains methods for each of the headers
        if ($this->getParameter('auto_headers', true)) {
            // the cache filename we'll be using
            $cache = ConfigCache::getCacheName($soapHandlerClass, $this->context->getName());
            
            if (ConfigCache::isModified($wsdl, $cache)) {
                $doc = new \DOMDocument();
                $doc->load($wsdl);
                $xpath = new \DOMXPath($doc);
                $xpath->registerNamespace('soap', 'http://schemas.xmlsoap.org/wsdl/soap/');
                
                $code = array();
                
                $code[] = '<?php';
                $code[] = sprintf('class %s extends %s {', $newSoapHandlerClass, $soapHandlerClass);
                $code[] = '  protected $rd;';
                $code[] = '  public function __construct(Context $context) {';
                $code[] = '    parent::__construct($context);';
                $code[] = '    $this->rd = $this->context->getRequest()->getRequestData();';
                $code[] = '  }';
                
                $headers = array();

                /** @var \DOMElement $header */
                foreach ($xpath->query('//soap:header') as $header) {
                    $name = $header->getAttribute('part');
                    
                    if (in_array($name, $headers)) {
                        continue;
                    }
                    $headers[] = $name;
                    
                    $code[] = sprintf('  public function %s($value) {', $name);
                    $code[] = sprintf('    $this->rd->setHeader(%s, $value);', var_export($name, true));
                    $code[] = '  }';
                }
                
                $code[] = '}';
                $code[] = '?>';
                
                $code = implode("\n", $code);
                
                ConfigCache::writeCacheFile($soapHandlerClass, $cache, $code);
            }
            
            include($cache);
        }
        
        // give it a class that handles method calls
        // that class uses __call
        // the class ctor gets the context as the first argument
        $this->soapServer->setClass($newSoapHandlerClass, $this->context);
    }
    /**