VCL
[ class tree: VCL ] [ index: VCL ] [ all elements ]
Packages:
VCL

Source for file webservices.inc.php

Documentation is available at webservices.inc.php

  1. <?php
  2. /**
  3. *  This file is part of the VCL for PHP project
  4. *
  5. *  Copyright (c) 2004-2007 qadram software <support@qadram.com>
  6. *
  7. *  Checkout AUTHORS file for more information on the developers
  8. *
  9. *  This library is free software; you can redistribute it and/or
  10. *  modify it under the terms of the GNU Lesser General Public
  11. *  License as published by the Free Software Foundation; either
  12. *  version 2.1 of the License, or (at your option) any later version.
  13. *
  14. *  This library is distributed in the hope that it will be useful,
  15. *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17. *  Lesser General Public License for more details.
  18. *
  19. *  You should have received a copy of the GNU Lesser General Public
  20. *  License along with this library; if not, write to the Free Software
  21. *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  22. *  USA
  23. *
  24. */
  25.  
  26. require_once("vcl/vcl.inc.php");
  27. use_unit("classes.inc.php");
  28. use_unit("nusoap/nusoap.php");
  29.  
  30. class Service extends Component
  31. {
  32.         private $_server = null;
  33.  
  34.         protected $_active = false;
  35.  
  36.         /**
  37.         * Specifies if the webservice is active or not, if it's true, the component will fire the events
  38.         * to get the functions to register and any complex type required and will publish the WSDL and process
  39.         * service requests
  40.         */
  41.         function getActive() { return $this->_active; }
  42.         function setActive($value) { $this->_active = $value; }
  43.         function defaultActive() { return false; }
  44.  
  45.         protected $_servicename = "VCL";
  46.  
  47.         /**
  48.         * Specifies the Name of the service you want to create
  49.         */
  50.         function getServiceName() { return $this->_servicename; }
  51.         function setServiceName($value) { $this->_servicename = $value; }
  52.         function defaultServiceName() { return "VCL"; }
  53.  
  54.         protected $_namespace = "http://localhost";
  55.  
  56.         /**
  57.         * Specifies the Name Space for the WSDL
  58.         */
  59.         function getNameSpace() { return $this->_namespace; }
  60.         function setNameSpace($value) { $this->_namespace = $value; }
  61.         function defaultNameSpace() { return false; }
  62.  
  63.         protected $_schematargetnamespace = "http://localhost/xsd";
  64.  
  65.         /**
  66.         * Specifies the Target Name Space for the WSDL
  67.         */
  68.         function getSchemaTargetNamespace() { return $this->_schematargetnamespace; }
  69.         function setSchemaTargetNamespace($value) { $this->_schematargetnamespace = $value; }
  70.         function defaultSchemaTargetNamespace() { return ""; }
  71.  
  72.  
  73.         protected $_onregisterservices = null;
  74.  
  75.         /**
  76.         * Fired when the service needs to register the functions to be published by the service, see also register method
  77.         */
  78.         function getOnRegisterServices() { return $this->_onregisterservices; }
  79.         function setOnRegisterServices($value) { $this->_onregisterservices = $value; }
  80.         function defaultOnRegisterServices() { return null; }
  81.  
  82.         protected $_onaddcomplextypes = null;
  83.  
  84.         /**
  85.         * Fired when the service needs to register complex types, see also addComplexType
  86.         */
  87.         function getOnAddComplexTypes() { return $this->_onaddcomplextypes; }
  88.         function setOnAddComplexTypes($value) { $this->_onaddcomplextypes = $value; }
  89.         function defaultOnAddComplexTypes() { return null; }
  90.  
  91.         function init()
  92.         {
  93.                 if (($this->ControlState & csDesigning) != csDesigning)
  94.                 {
  95.                         if ($this->_active)
  96.                         {
  97.                                 //If the webservice is active, create the nusoap object
  98.                                 $this->_server = new soap_server();
  99.                                 $this->_server->configureWSDL($this->_servicename, $this->_namespace);
  100.                                 $this->_server->wsdl->schemaTargetNamespace = $this->_schematargetnamespace;
  101.  
  102.                                 //Call events
  103.                                 $this->callEvent('onaddcomplextypes', array());
  104.                                 $this->callEvent('onregisterservices', array());
  105.  
  106.                                 global $HTTP_RAW_POST_DATA;
  107.  
  108.                                 $HTTP_RAW_POST_DATA = isset($HTTP_RAW_POST_DATA) ? $HTTP_RAW_POST_DATA: '';
  109.  
  110.                                 $this->_server->service($HTTP_RAW_POST_DATA);
  111.  
  112.                                 global $log;
  113.  
  114.                                 if(isset($log) and $log != '')
  115.                                 {
  116.                                         harness('nusoap_r2_base_server', $this->_server->headers['User-Agent'], $this->_server->methodname, $this->_server->request, $this->_server->response, $this->_server->result);
  117.                                 }
  118.                         }
  119.                 }
  120.         }
  121.  
  122.         function __construct($aowner = null)
  123.         {
  124.                 //Calls inherited constructor
  125.                 parent::__construct($aowner);
  126.         }
  127.  
  128.         /**
  129.         * register a service function with the server
  130.         *
  131.         * @param    string $name the name of the PHP function, class.method or class..method
  132.         * @param    array $in assoc array of input values: key = param name, value = param type
  133.         * @param    array $out assoc array of output values: key = param name, value = param type
  134.         * @param        mixed $namespace the element namespace for the method or false
  135.         * @param        mixed $soapaction the soapaction for the method or false
  136.         * @param        mixed $style optional (rpc|document) or false Note: when 'document' is specified, parameter and return wrappers are created for you automatically
  137.         * @param        mixed $use optional (encoded|literal) or false
  138.         * @param        string $documentation optional Description to include in WSDL
  139.         * @param        string $encodingStyle optional (usually 'http://schemas.xmlsoap.org/soap/encoding/' for encoded)
  140.         * @access   public
  141.         */
  142.         function register($name,$in=array(),$out=array(),$namespace=false,$soapaction=false,$style=false,$use=false,$documentation='',$encodingStyle='')
  143.         {
  144.                 if ($namespace==false) $namespace=$this->_namespace;
  145.  
  146.                 $this->_server->register($name,$in,$out,$namespace,$soapaction,$style,$use,$documentation,$encodingStyle);
  147.         }
  148.  
  149.         /**
  150.         * adds a complex type to the schema
  151.         *
  152.         * example: array
  153.         *
  154.         * addType(
  155.         *       'ArrayOfstring',
  156.         *       'complexType',
  157.         *       'array',
  158.         *       '',
  159.         *       'SOAP-ENC:Array',
  160.         *       array('ref'=>'SOAP-ENC:arrayType','wsdl:arrayType'=>'string[]'),
  161.         *       'xsd:string'
  162.         * );
  163.         *
  164.         * example: PHP associative array ( SOAP Struct )
  165.         *
  166.         * addType(
  167.         *       'SOAPStruct',
  168.         *       'complexType',
  169.         *       'struct',
  170.         *       'all',
  171.         *       array('myVar'=> array('name'=>'myVar','type'=>'string')
  172.         * );
  173.         *
  174.         * @param name 
  175.         * @param typeClass (complexType|simpleType|attribute)
  176.         * @param phpType: currently supported are array and struct (php assoc array)
  177.         * @param compositor (all|sequence|choice)
  178.         * @param restrictionBase namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array)
  179.         * @param elements = array ( name = array(name=>'',type=>'') )
  180.         * @param attrs = array(
  181.         *        array(
  182.         *                'ref' => "http://schemas.xmlsoap.org/soap/encoding/:arrayType",
  183.         *                "http://schemas.xmlsoap.org/wsdl/:arrayType" => "string[]"
  184.         *        )
  185.         *  )
  186.         * @param arrayType: namespace:name (http://www.w3.org/2001/XMLSchema:string)
  187.         * @access public
  188.         * @see getTypeDef
  189.         */
  190.         function addComplexType($name,$typeClass='complexType',$phpType='array',$compositor='',$restrictionBase='',$elements=array(),$attrs=array(),$arrayType='')
  191.         {
  192.                 $this->_server->wsdl->addComplexType($name,$typeClass, $phpType,$compositor,$restrictionBase,$elements,$attrs,$arrayType);
  193.         }
  194.  
  195. }
  196.  
  197. ?>
Documentation generated on Tue, 27 Mar 2007 13:36:02 +0200 by phpDocumentor 1.3.1