UDDI
[ class tree: UDDI ] [ index: UDDI ] [ all elements ]

Source for file UDDI.php

Documentation is available at UDDI.php

  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4 foldmethod=marker: */
  3. // +----------------------------------------------------------------------+
  4. // | UDDI: A PHP class library implementing the Universal Description,    |
  5. // | Discovery and Integration API for locating and publishing Web        |
  6. // | Services listings in a UBR (UDDI Business Registry)                  |
  7. // +----------------------------------------------------------------------+
  8. // | This library is free software; you can redistribute it and/or        |
  9. // | modify it under the terms of the GNU Lesser General Public           |
  10. // | License as published by the Free Software Foundation; either         |
  11. // | version 2.1 of the License, or (at your option) any later version.   |
  12. // |                                                                      |
  13. // | This library is distributed in the hope that it will be useful,      |
  14. // | but WITHOUT ANY WARRANTY; without even the implied warranty of       |
  15. // | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU    |
  16. // | General Public License for more details.                             |
  17. // |                                                                      |
  18. // | You should have received a copy of the GNU General Public License    |
  19. // | along with this library; if not, write to the Free Software          |
  20. // | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, |
  21. // | USA, or visit http://www.gnu.org/copyleft/lesser.html                |
  22. // +----------------------------------------------------------------------+
  23. // | Authors: Jon Stephens & Lee Reynolds (authors of non-PEAR version)   |
  24. // |          Maintainers and PEARifiers:                                 |
  25. // |          Christian Wenz <chw@hauser-wenz.de>                         |
  26. // |          Tobias Hauser <th@hauser-wenz.de>                           |
  27. // +----------------------------------------------------------------------+
  28. //
  29. //    $Id$
  30. /* Original Credits:
  31.  
  32.   phpUDDI
  33.   A PHP class library implementing the Universal Description,
  34.   Discovery and Integration API for locating and publishing Web
  35.   Services listings in a UBR (UDDI Business Registry).
  36.  
  37.   Copyright (C) 2002-2004 Lee Reynolds and Jon Stephens
  38.  
  39.   This program is free software; you can redistribute it and/or
  40.   modify it under the terms of the GNU General Public License
  41.   as published by the Free Software Foundation; either version 2
  42.   of the License, or (at your option) any later version.
  43.  
  44.   This program is distributed in the hope that it will be useful,
  45.   but WITHOUT ANY WARRANTY; without even the implied warranty of
  46.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  47.   GNU General Public License for more details.
  48.  
  49.   You should have received a copy of the GNU General Public License
  50.   along with this program; if not, write to the Free Software
  51.   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
  52.   or point your web browser to http://www.gnu.org/licenses/lgpl.html.
  53.  
  54.   Conceived and developed in conjunction with the
  55.   authors' work for the book "PHP Web Services" from Wrox Press
  56.   Ltd. (ISBN-1861008074)
  57.  
  58.   Original developers:
  59.   Lee Reynolds lee@annasart.com
  60.   Jon Stephens jon@hiveminds.info
  61.  
  62.   Useful Links:
  63.  
  64.   Wrox Press "Programmer To Programmer" Discussion Groups
  65.   Pro PHP: http://p2p.wrox.com/list.asp?list=pro_php
  66.   Pro XML: http://p2p.wrox.com/list.asp?list=xml
  67.  
  68.   HiveMinds Group
  69.   http://www.hiveminds.info/
  70.   http://forums.hiveminds.info/
  71.  
  72.   Version History:
  73.  
  74.   0.1   -- 15 November 2002 -- Basic Proof of concept
  75.   0.2   -- 20 November 2002 -- Base class redefinition to
  76.                 include public and private methods
  77.   0.3   -- 25 November 2002 -- All UDDI 2.0 Inquiry APIs implemented
  78.   0.3.1 -- 14 March 2004    -- small bugfixes (Christian); license change to LPGL (Lee, Jon)
  79.  
  80.   Objective for 1.0 release is complete implementation of the UDDI 2.0 API
  81.   (http://www.uddi.org/pubs/ProgrammersAPI-V2.04-Published-20020719.pdf).
  82.  
  83.   Objective for 1.5 release is backwards compatibility with UDDI 1.0.
  84.  
  85.   Objective for 2.0 release is complete implementation of the UDDI 3.0 API
  86.   (http://www.uddi.org/pubs/uddi-v3.00-published-20020719.pdf).
  87.  
  88. */
  89.  
  90. require_once 'PEAR.php';
  91.  
  92. /**
  93.  * PEAR::UDDI
  94.  * class that implements the UDDI API
  95.  * @link http://www.uddi.org/
  96.  *
  97.  *  pearified version of phpUDDI by Stephens & Reynolds
  98.  * 
  99.  * 
  100.  * @category Web Services
  101.  * @package  UDDI
  102.  * @version  0.2.4
  103.  * @author   Christian Wenz <chw@hauser-wenz.de>
  104.  * @author   Tobias Hauser <th@hauser-wenz.de>
  105.  * @todo     fully implement UDDI 2.0 (and later 1.0, 3.0)
  106.  * @todo     more helper functions (for analyzing the data returned by querying a UBR)
  107.  
  108.  
  109. Name:
  110.   UDDI.php - UDDI Registry access library (PEARified version)
  111.  
  112. Synopsis:
  113.   require_once 'UDDI/UDDI.php';
  114.  
  115. Currently, PEAR::UDDI supports one function call in one UDDI API.
  116.  
  117. Variables supported:
  118.   $UDDI::_api
  119.   currently 2 values are supported, and they represent 2 of the 6 published APIs by UDDI.org.
  120.   'Inquiry' which represents the search and _query API
  121.   'Publish' which represents the publishing API
  122.  
  123.   Usage:
  124.   <code>
  125.     $UDDI::_api = 'Inquiry'; // (default)
  126.     $UDDI::_api = 'Publish';
  127.   </code>
  128.  
  129.   $UDDI::_uddiversion
  130.   This is the API version of the UPI spec you want to use
  131.   Values are either 1, 2, or 3.
  132.  
  133.   Usage:
  134.   <code>
  135.     $UDDI::_uddiversion = 2;
  136.   </code>
  137.  
  138.   Default:
  139.     currently, the version default is '1';
  140.  
  141.   Note: As stated above, we are aiming for a 1.0 release of this library which implements
  142.   the UDDI 2.0 Programming API; we cannot guarantee at this time that any of the API functions
  143.   as implemented here will work correctly (or at all) unless you set the version to 2 as shown
  144.   under 'Usage' immediately above or by setting the version when you call the UDDI class constructor:
  145.  
  146.   <code>
  147.   $my_uddi = new UDDI('SAP', 2);
  148.   </code>
  149.  
  150.   At a later date we will make this class compatible with UDDI Versions 1.0 and 3.0.
  151.  
  152.   $UDDI::_regarray
  153.   We currently support the one remaining test registry: 'SAP'.
  154.   We also support 2 API interfaces. These are, as noted above, 'Inquiry' and 'Publish'.
  155.  
  156.   To add live registry entries, or your own test registry, you must append a multiple index array element
  157.   to $UDDI::_regarray.  The form for this follows:
  158.   <code>
  159.     array('registry name' =>
  160.     array('Inquiry' =>
  161.       array('url' => 'url_for_inquiry',
  162.         'port' => 80),
  163.         'Publish' =>
  164.       array('url' => 'url_for_publish',
  165.         'port' => 443)));
  166.   </code>
  167.   Internally this is accessed as 
  168.   <code>URL = $_regarray['registry_name']['Inquiry']['url']</code>
  169.   , and
  170.   <code>port = $_regarray['registry_name']['Inquiry']['port']</code>
  171.  
  172.   PLEASE NOTE: You're adding elements to this array, instead of overwriting old ones.
  173.  
  174.   Usage:
  175.   <code>
  176.     $UDDI::_regarray = array('private' =>
  177.               array('Inquiry' =>
  178.               array('url' =>'url_for_inquiry',
  179.                   'port' => 80),
  180.                   'Publish' =>
  181.                       array('url' => 'url_for_publishing',
  182.                           'port' => 443)));
  183.   </code>
  184.  
  185.   $UDDI::_xmlns
  186.   You can modify the XML namespace by reassigning a value to this
  187.  
  188.   Usage:
  189.   <code>
  190.     $UDDI::_xmlns = 'new_ns_definition';
  191.   </code>
  192.  
  193.   Default:
  194.      'urn:uddi-org:api'
  195.  
  196.   $UDDI::_debug
  197.   Turns on debugging by echoing HTTP headers and UDDI queries.
  198.  
  199.   Usage:
  200.   <code>
  201.     $UDDI::_debug = true;
  202.   </code>
  203.  
  204.   Default:
  205.     false
  206.  
  207.   $UDDI::_transmit
  208.   Turns on _posting of UDDI message to UBR.
  209.  
  210.   Usage:
  211.   <code>
  212.     $UDDI::_transmit = false;
  213.   </code>
  214.  
  215.   Default:
  216.     true;
  217.  
  218.  
  219. EXAMPLE:
  220.  
  221. This queries SAP's UDDI Registry for the first 50 businesses whose names include
  222. the word "Acme", matches sorted first in ascending order by name, then in descending
  223. order by date last updated. The raw XML that's returned is escaped and echoed to the page.
  224.  
  225. <code>
  226. $my_uddi = new UDDI('SAP', 1);
  227. $result = htmlspecialchars($my_uddi->find_business(array('name' => '%Acme%', 'maxRows' => 50, 'findQualifiers' => 'sortByNameAsc,sortByDateAsc')));
  228. echo "<pre>$result</pre>";
  229. </code>
  230.  
  231. */
  232.  
  233.  
  234. // {{{ constants
  235. /**
  236.  * version of corresponding phpUDDI version
  237.  * still included so that moving from phpUDDI to PEAR::UDDI is easier
  238.  */
  239.  
  240. define('UDDI_PHP_LIB_VERSION''0.3.1p')//suffix p = PEAR :-)
  241.  
  242. // }}}
  243. // {{{ UDDI
  244.  
  245. /**
  246.  * UDDI
  247.  *
  248.  * class that implements the UDDI API
  249.  * 
  250.  * @package  UDDI
  251.  * @author   Christian Wenz <chw@hauser-wenz.de>
  252.  * @author   Tobias Hauser <th@hauser-wenz.de>
  253. */
  254. class UDDI extends PEAR
  255. {
  256.     // {{{ properties
  257.  
  258.     /**
  259.      * version of package
  260.      * @var string $_version 
  261.      */
  262.     var $_version '0.2.4';
  263.  
  264.     /**
  265.      * ('headers'), the body ('body'), or both ('all', default)
  266.      * @var string $_returnMode 
  267.      */
  268.     var $_returnMode 'all';
  269.  
  270.     /**
  271.      * list of known registries
  272.      * @var array $regarray 
  273.      */
  274.     var $_regarray =
  275.         array(
  276.             'SAP' =>
  277.                 array(
  278.                     'Inquiry'  =>
  279.                         array(
  280.                             'url'  => 'uddi.sap.com/uddi/api/inquiry/',
  281.                             'port' => 80),
  282.                     'Publish' =>
  283.                         array('url' => 'https://uddi.sap.com/uddi/api/publish/',
  284.                             'port' => 443))/*,
  285.             'IBM' =>
  286.                 array(
  287.                     'Inquiry'  =>
  288.                         array(
  289.                             'url'  => 'www-3.ibm.com/services/uddi/testregistry/inquiryapi',
  290.                             'port' => 80),
  291.                     'Publish' =>
  292.                         array('url' => 'https://www-3.ibm.com/services/uddi/testregistry/protect/publishapi',
  293.                             'port' => 443)),
  294.             'Microsoft' =>
  295.                 array(
  296.                     'Inquiry' =>
  297.                         array(
  298.                             'url' => 'test.uddi.microsoft.com/inquire',
  299.                             'port' => 80),
  300.                     'Publish' =>
  301.                         array(
  302.                             'url' => 'https://test.uddi.microsoft.com/publish',
  303.                             'port' => 443))*/);
  304.  
  305.     /**
  306.      * which API to use (Inquiry/Publish)
  307.      * @var string $_api 
  308.      */
  309.     var $_api 'Inquiry';
  310.  
  311.     /**
  312.      * used XML namespace
  313.      * @var string $_xmlns 
  314.      */
  315.     var $_xmlns 'urn:uddi-org:api';
  316.  
  317.     /**
  318.      * used UDDI version
  319.      * @var string $_uddiversion 
  320.      */
  321.     var $_uddiversion  = 1;
  322.  
  323.     /**
  324.      * used XML generic version
  325.      * @var string $_generic 
  326.      */
  327.     var $_generic;
  328.  
  329.     /**
  330.      * debug mode
  331.      * @var boolean $_debug 
  332.      */
  333.     var $_debug    = false;
  334.  
  335.     /**
  336.      * Turns on _posting of UDDI message to UBR
  337.      * @var boolean $_transmit 
  338.      */
  339.     var $_transmit = true;
  340.  
  341.     /**
  342.      * Host to use
  343.      * @var string $_host 
  344.      */
  345.     var $_host;
  346.  
  347.     /**
  348.      * URL to use
  349.      * @var string $_url 
  350.      */
  351.     var $_url;
  352.  
  353.     // }}}
  354.     // {{{ constructor
  355.  
  356.     /**
  357.      * constructor
  358.      *
  359.      * @access   public
  360.      * @param    string   $registry    name of registry to use (defaults to SAP)
  361.      * @param    integer  $version     UDDI version to use
  362.      */
  363.     function UDDI($registry 'SAP'$version = 1)
  364.     {
  365.         $this->splitUrl($registry$version);
  366.     }
  367.  
  368.     // }}}
  369.     // {{{ splitUrl()
  370.  
  371.     /**
  372.      * retrieves information from URL and sets params
  373.      *
  374.      * @access   public
  375.      * @param    string   $registry    name of registry to use
  376.      * @param    integer  $version     UDDI version to use
  377.      */
  378.     function splitUrl($registry$version)
  379.     {
  380.         $this->_registry $registry;
  381.         $reg $this->_regarray[$this->_registry][$this->_api]['url'];
  382.         $reg str_replace('http://'''$reg);
  383.         $pos strpos($reg'/');
  384.         if ($pos === false{
  385.             return PEAR::raiseError("Invalid registry (POS = $pos, URL = '$reg')\n");
  386.         }
  387.         $this->_host substr($reg0$pos);
  388.         $this->_url substr($reg$posstrlen($reg- 1);
  389.  
  390.         if ($version > 1{
  391.             $this->_xmlns .= "_v$version";
  392.         }
  393.  
  394.         $this->_generic = "$version.0";
  395.     }
  396.  
  397.     // }}}
  398.     // {{{ post()
  399.  
  400.     /**
  401.      * assembles HTTP headers and posts these and the UDDI message to the UBR
  402.      *
  403.      * @access   public
  404.      * @param    string  $message    the UDDI message to send
  405.      * @return   string  $data       data returned from the UBR
  406.      */
  407.     function post($message)
  408.     {
  409.         $msg_length strlen($message);
  410.         $php_version phpversion();
  411.         $date str_replace('+0000''GMT'gmdate('r'time()));
  412.  
  413.         $header '';
  414.         $header .= "POST $this->_url HTTP/1.0\r\n";
  415.         $header .= "Date: $date\r\n";
  416.         $header .= "Content-Type: text/xml; charset=UTF-8\r\n";
  417.         $header .= "User-agent: PEAR::UDDI/$this->_version php/$php_version\r\n";
  418.         $header .= "Host: $this->_host\r\n";
  419.         $header .= "SOAPAction: \"\"\r\n";
  420.         $header .= "Content-Length: $msg_length\r\n\r\n";
  421.  
  422.         //  echoes HTTP header and UDDI message to page if true
  423.         if ($this->_debug{
  424.             echo '<pre>' htmlspecialchars(str_replace('><'">\n<"$header $message)) '</pre>';
  425.         }
  426.  
  427.         //  sends header and message to UBR if true
  428.         if ($this->_transmit{
  429.             $port $this->_regarray[$this->_registry][$this->_api]['port'];
  430.             $fp fsockopen($this->_host$port$errno$errstr5);
  431.             if ($fp === false{
  432.                 return PEAR::raiseError("Couldn't connect to server at $this->_host:$port.<br />Error #$errno$errstr.");
  433.             };
  434.  
  435.             $result fputs($fp$header);
  436.             if ($result === false{
  437.                   return PEAR::raiseError('Couldn\'t send HTTP headers.');
  438.             }
  439.             $result fputs($fp"$message\n\n");
  440.             if ($result === false{
  441.                 return PEAR::raiseError('Couldn\'t send UDDI message.');
  442.             }
  443.  
  444.             $response '';
  445.             while (!feof($fp)) {
  446.                 $data fgets($fp1024);
  447.                 if ($data !== false{
  448.                     $response .= $data;
  449.                 else {
  450.                     return PEAR::raiseError('No response from server.');
  451.                 }
  452.             }
  453.             $result fclose($fp);
  454.             if ($result === false{
  455.                 return PEAR::raiseError('Warning: Couldn\'t close HTTP connection.');
  456.             }
  457.  
  458.             $response str_replace('><'">\n<"$response);
  459.             return $response;
  460.         }
  461.     }
  462.  
  463.     // }}}
  464.     // {{{ query()
  465.  
  466.     /**
  467.      * sends and UDDI query to the registry server
  468.      *
  469.      * @access   public
  470.      * @param    string  $method     the UDDI message to send
  471.      * @param    array   $params     parameters for the query
  472.      * @return   string  $data       response from the registry server
  473.      */
  474.     function query($method$params)
  475.     {
  476.         $message $this->assemble($method$params);
  477.         $data $this->post($message);
  478.         
  479.         switch ($this->_returnMode{
  480.             case 'headers'
  481.                 $pos strpos($data"\r\n\r\n");
  482.                 if ($pos !== false{
  483.                     $data substr($data0$pos);
  484.                 }
  485.                 // if no blank line is found, 
  486.                 // assume that only headers were returned
  487.                 return $data;
  488.                 break; 
  489.             case 'body'
  490.                 $pos strpos($data"\r\n\r\n");
  491.                 if ($pos !== false{
  492.                     $data substr($data$pos + 4);
  493.                     return $data;
  494.                 else {
  495.                     return '';
  496.                 }
  497.                 break; 
  498.             case 'all'
  499.                 return $data;
  500.                 break; 
  501.             default: 
  502.                 return PEAR::raiseError('Unknown return mode.');
  503.                 break;                 
  504.         }
  505.     }
  506.  
  507.     // }}}
  508.     // {{{ assemble()
  509.  
  510.     /**
  511.      * generate XML creating the UDDI query
  512.      *
  513.      * @access   public
  514.      * @param    string  $method     the UDDI message to send
  515.      * @param    array   $params     parameters for the query
  516.      * @return   string  $data       the desired XML query code
  517.      */
  518.     function assemble($method$params)
  519.     {
  520.         $head '<?xml version="1.0" encoding="utf-8"?>';
  521.         $head .= '<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/">';
  522.         $head .= '<Body>';
  523.  
  524.         $end = "</$method></Body></Envelope>";
  525.  
  526.         $attrib '';
  527.         $element '';
  528.  
  529.         if (isset($params['discoveryURLs']&& ($params['discoveryURLs'!= '')) {
  530.             $element .= '<discoveryURLs>' $params['discoveryURLs''</discoveryURLs>';
  531.         }
  532.  
  533.         if (isset($params['bindingKey']&& ($params['bindingKey'!= '')) {
  534.             $element .= '<bindingKey>' $params['bindingKey''</bindingKey>';
  535.         }
  536.  
  537.         if (isset($params['businessKey']&& ($params['businessKey'!= '')) {
  538.             $element .= '<businessKey>' $params['businessKey''</businessKey>';
  539.         }
  540.  
  541.         if (isset($params['serviceKey']&& ($params['serviceKey'!= '')) {
  542.     
  543.             if ($method == 'find_binding'{
  544.                 $attrib .= ' serviceKey="' $params['serviceKey''"';
  545.             }
  546.             if ($method == 'get_serviceDetail'{
  547.                 $element .= '<serviceKey>' $params['serviceKey''</serviceKey>';
  548.             }
  549.         }
  550.  
  551.         if (isset($params['tModelKey']&& ($params['tModelKey'!= '')) {
  552.           if (is_array($params['tModelKey'])) {
  553.             foreach ($params['tModelKey'as $uuid{
  554.               $element .= '<tModelKey>uuid:' $uuid '</tModelKey>';
  555.             }
  556.           else {
  557.             $element .= '<tModelKey>uuid:' $params['tModelKey''</tModelKey>';
  558.           }
  559.         }
  560.  
  561.         if (isset($params['findQualifiers']&& ($params['findQualifiers'!= '')) {
  562.             $element .= '<findQualifiers>';
  563.             $findQualifiers explode(','$params['findQualifiers']);
  564.             for ($i = 0; $i count($findQualifiers)$i++{
  565.                 $element .= '<findQualifier>' $findQualifiers[$i'</findQualifier>';
  566.             }
  567.             $element .= '</findQualifiers>';
  568.         }
  569.  
  570.         if (isset($params['tModelBag']&& ($params['tModelBag'!= '')) {
  571.             $tModelKey explode(','$params['tModelBag']);
  572.             $element .= '<tModelBag>';
  573.             for ($i = 0; $i count($tModelKey)$i++{
  574.                 $element .= '<tModelKey>uuid:' $tModelKey[$i'</tModelKey>';
  575.                 $element .= '</tModelBag>';
  576.             }
  577.         }
  578.  
  579.         if (isset($params['name']&& ($params['name'!= '')) {
  580.             $lang '';
  581.             if (isset($params['lang']&& ($params['lang'!= '')) {
  582.                 $lang = "xml:lang=\"$lang\"";
  583.             }
  584.             $element .= '<name ' $lang '>' $params['name''</name>';
  585.         }
  586.  
  587.         if (isset($params['identifierBag']&& ($params['identifierBag'!= '')) {
  588.             $element .= '<identifierBag>';
  589.             $keyedReference explode(','$params['identifierBag']);
  590.             for ($i = 0; $i count($keyedReference)$i++{
  591.                 $element .= '<keyedReference>' $keyedReference[$i'</keyedReference>';
  592.             }
  593.             $element .= '</identifierBag>';
  594.         }
  595.  
  596.         if (isset($params['categoryBag']&& ($params['categoryBag'!= '')) {
  597.             $element .= '<categoryBag>';
  598.             $keyedReference explode(','$params['identifierBag']);
  599.             for ($i = 0; $i<count($keyedReference)$i++{
  600.                 $element .= '<keyedReference>' $keyedReference[$i'</keyedReference>';
  601.             }
  602.             $element .= '</categoryBag>';
  603.         }
  604.  
  605.         if (isset($params['maxRows']&& ($params['maxRows'!= '')) {
  606.             $attrib .= ' maxRows="' $params['maxRows''"';
  607.         }
  608.  
  609.         $head .= "<$method $attrib xmlns=\"$this->_xmlns\" generic=\"$this->_generic\">";
  610.  
  611.         $message $head;
  612.         $message .= $element;
  613.         $message .= $end;
  614.  
  615.         return $message;
  616.     }
  617.  
  618.     // }}}
  619.     // {{{ find_binding()
  620.  
  621.     /**
  622.      * Sends find_binding inquiry to UBR (searchs for bindings within a businessService element)
  623.      *
  624.      * @access   public
  625.      * @param    array   $params     parameters for the query
  626.      * @return   string  $data       response from the registry server
  627.      */
  628.     function find_binding($params)
  629.     {
  630.         $data $this->query('find_binding'$params);
  631.         return $data;
  632.     }
  633.  
  634.     // }}}
  635.     // {{{ find_business()
  636.  
  637.     /**
  638.      * Sends find_business inquiry to UBR (searchs businessEntity elements)
  639.      *
  640.      * @access   public
  641.      * @param    array   $params     parameters for the query
  642.      * @return   string  $data       response from the registry server
  643.      */
  644.     function find_business($params)
  645.     {
  646.         $data $this->query('find_business'$params);
  647.         return $data;
  648.     }
  649.  
  650.     // }}}
  651.     // {{{ find_relatedBusinesses()
  652.  
  653.     /**
  654.      * Sends find_relatedBusinesses inquiry to UBR (searchs for related businessEntity elements for a given businessKey)
  655.      *
  656.      * @access   public
  657.      * @param    array   $params     parameters for the query
  658.      * @return   string  $data       response from the registry server
  659.      */
  660.     function find_relatedBusinesses($params)
  661.     {
  662.         $data $this->query('find_relatedBusinesses'$params);
  663.         return $data;
  664.     }
  665.  
  666.     // }}}
  667.     // {{{ find_service()
  668.  
  669.     /**
  670.      * Sends find_service inquiry to UBR (searchs for businessService elements)
  671.      *
  672.      * @access   public
  673.      * @param    array   $params     parameters for the query
  674.      * @return   string  $data       response from the registry server
  675.      */
  676.     function find_service($params)
  677.     {
  678.         $data $this->query('find_service'$params);
  679.         return $data;
  680.     }
  681.  
  682.     // }}}
  683.     // {{{ find_tModel()
  684.  
  685.     /**
  686.      * Sends find_tModel inquiry to UBR (searchs for tModel elements)
  687.      *
  688.      * @access   public
  689.      * @param    array   $params     parameters for the query
  690.      * @return   string  $data       response from the registry server
  691.      */
  692.     function find_tModel($params)
  693.     {
  694.         $data $this->query('find_tModel'$params);
  695.         return $data;
  696.     }
  697.  
  698.     // }}}
  699.     // {{{ get_bindingDetail()
  700.  
  701.     /**
  702.      * Sends get_bindingDetail inquiry to UBR (returns bindingDetail elements for one or more bindingKey elements)
  703.      *
  704.      * @access   public
  705.      * @param    array   $params     parameters for the query
  706.      * @return   string  $data       response from the registry server
  707.      */
  708.     function get_bindingDetail($params)
  709.     {
  710.         $data $this->query('get_bindingDetail'$params);
  711.         return $data;
  712.     }
  713.  
  714.     // }}}
  715.     // {{{ get_businessDetail()
  716.  
  717.     /**
  718.      * Sends get_businessDetail inquiry to UBR (returns information about one or more businessEntity elements)
  719.      *
  720.      * @access   public
  721.      * @param    array   $params     parameters for the query
  722.      * @return   string  $data       response from the registry server
  723.      */
  724.     function get_businessDetail($params)
  725.     {
  726.         $data $this->query('get_businessDetail'$params);
  727.         return $data;
  728.     }
  729.  
  730.     // }}}
  731.     // {{{ get_businessDetailExt()
  732.  
  733.     /**
  734.      * Sends get_businessDetailExt inquiry to UBR (returns extended information about one or more businessEntity elements)
  735.      *
  736.      * @access   public
  737.      * @param    array   $params     parameters for the query
  738.      * @return   string  $data       response from the registry server
  739.      */
  740.     function get_businessDetailExt($params)
  741.     {
  742.         $data $this->query('get_businessDetailExt'$params);
  743.         return $data;
  744.     }
  745.  
  746.     // }}}
  747.     // {{{ get_serviceDetail()
  748.  
  749.     /**
  750.      * Sends get_serviceDetail inquiry to UBR (returns information about one or more businessService elements)
  751.      *
  752.      * @access   public
  753.      * @param    array   $params     parameters for the query
  754.      * @return   string  $data       response from the registry server
  755.      */
  756.     function get_serviceDetail($params)
  757.     {
  758.         $data $this->query('get_serviceDetail'$params);
  759.         return $data;
  760.     }
  761.  
  762.     // }}}
  763.     // {{{ get_tModelDetail()
  764.  
  765.     /**
  766.      * Sends get_tModelDetail inquiry to UBR (returns information about one or more tModel elements)
  767.      *
  768.      * @access   public
  769.      * @param    array   $params     parameters for the query
  770.      * @return   string  $data       response from the registry server
  771.      */
  772.     function get_tModelDetail($params)
  773.     {
  774.         $data $this->query('get_tModelDetail'$params);
  775.         return $data;
  776.     }
  777.  
  778.     // }}}
  779.  
  780. }
  781.  
  782. // }}}
  783.  
  784. ?>

Documentation generated on Mon, 11 Mar 2019 15:05:06 -0400 by phpDocumentor 1.4.4. PEAR Logo Copyright © PHP Group 2004.