function ws_convert_to_wsdl20($wsdl_out)
{
$wsdl_dom = new DomDocument();
$xslt_wsdl_20_dom = new DOMDocument();
$xslt_11_to_20_dom = new DOMDocument();
$xslt_11_to_20_dom->preserveWhiteSpace = false;
$xslt = new XSLTProcessor();
$xslt_str = file_get_contents(WS_WSDL_Const::WSF_WSDL_WSDL11_2_2_CONVERTORS, TRUE);
if (!$xslt_wsdl_20_dom->loadXML($xslt_str)) {
ws_log_write(__FILE__, __LINE__, WSF_LOG_ERROR, "Error loading the wsdl11towsdl2 convertor script");
echo "Error in generating the WSDL\n";
exit(0);
}
$xslt->importStyleSheet($xslt_wsdl_20_dom);
$wsdl_dom->loadXML($wsdl_out);
$xslt_11_to_20_dom->loadXML($xslt->transformToXML($wsdl_dom));
$doc_ele = $xslt_11_to_20_dom->documentElement;
foreach ($doc_ele->childNodes as $child) {
if ($child->nodeType == XML_COMMENT_NODE) {
$old_child = $doc_ele->removeChild($child);
}
}
return $xslt_11_to_20_dom->saveXML();
}
function wsf_attach_xsd_imports($wsdl_types_node, $wsdl_dom, $schema_node, $relative_url, &$already_added_xsds, $stream_ctx)
{
$schema_childs = $schema_node->childNodes;
/* extracting out relative url details */
$path_parts = pathinfo($relative_url);
$relative_dir = $path_parts["dirname"] . "/";
$import_node_array = array();
foreach ($schema_childs as $schema_child) {
if ($schema_child->nodeType != XML_ELEMENT_NODE) {
continue;
}
if ($schema_child->localName == "import" || $schema_child->localName == "include") {
$import_node = $schema_child;
if ($import_node->attributes && $import_node->attributes->getNamedItem("schemaLocation")) {
$imported_location = $import_node->attributes->getNamedItem("schemaLocation")->value;
if (strncmp($imported_location, "http://", 7) == 0 || strncmp($imported_location, "https://", 8) == 0) {
// then this is a absolute URL and doesn't need to derive again..
} else {
// derive the absolute url from relative url
$tmp_relative_url = $relative_dir . $imported_location;
$imported_location = wsf_normalize_url($tmp_relative_url);
}
if (!array_key_exists($imported_location, $already_added_xsds) || $already_added_xsds[$imported_location] == NULL) {
$already_added_xsds[$imported_location] = TRUE;
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "importing xsd: {$imported_location} from: {$relative_url}");
$imported_dom = new DOMDocument();
$imported_content = file_get_contents($imported_location, 0, $stream_ctx);
if ($imported_dom->loadXML($imported_content)) {
$imported_root = $imported_dom->documentElement;
if ($imported_root && $imported_root->nodeType == XML_ELEMENT_NODE && $imported_root->localName == "schema") {
// do the same thing for the imported_schema
wsf_attach_xsd_imports($wsdl_types_node, $wsdl_dom, $imported_root, $imported_location, $already_added_xsds, $stream_ctx);
// append the schema to the first wsdl
wsf_wsdl_append_node($wsdl_types_node, $imported_root, $wsdl_dom);
// and remove the old node..
$import_node_array[] = $import_node;
}
}
} else {
// still we remove the already imported node
$import_node_array[] = $import_node;
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "xsd: {$imported_location} redeclared to import from: {$relative_url}");
}
}
}
}
foreach ($import_node_array as $import_node) {
$schema_node->removeChild($import_node);
}
}
function wsf_wsdl_process_in_msg($wsdata)
{
require_once 'dynamic_invocation/wsf_wsdl_consts.php';
require_once 'dynamic_invocation/wsf_wsdl_util.php';
require_once 'dynamic_invocation/wsf_wsdl_service.php';
$parameters = $wsdata->WSDL_ParamArray;
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "wsf_wsdl_process_in_msg is called");
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, print_r($parameters, TRUE));
$payload_dom = new DomDocument();
$sig_model_dom = new DomDocument();
$payload_dom->preserveWhiteSpace = FALSE;
$sig_model_dom->preserveWhiteSpace = FALSE;
$service_name = NULL;
$port_name = NULL;
$is_multiple_interfaces = FALSE;
$sig_model_string = NULL;
$payload_string = NULL;
$operation_name = NULL;
$function_name = NULL;
$class_name = NULL;
$class_map = NULL;
$class_args = NULL;
$header_string = NULL;
// this is about the respnse message
$mtom_on = TRUE;
$cid2cont_type = array();
$cid2attachments = array();
if (array_key_exists(WSF_SERVICE_NAME, $parameters)) {
$service_name = $parameters[WSF_SERVICE_NAME];
}
if (array_key_exists(WSF_PORT_NAME, $parameters)) {
$port_name = $parameters[WSF_PORT_NAME];
}
if (array_key_exists(WSF_SIG_MODEL_STRING, $parameters)) {
$sig_model_string = $parameters[WSF_SIG_MODEL_STRING];
}
if (array_key_exists(WSF_PAYLOAD_STRING, $parameters)) {
$payload_string = $parameters[WSF_PAYLOAD_STRING];
}
if (array_key_exists(WSF_OPERATION_NAME, $parameters)) {
$operation_name = $parameters[WSF_OPERATION_NAME];
}
if (array_key_exists(WSF_FUNCTION_NAME, $parameters)) {
$function_name = $parameters[WSF_FUNCTION_NAME];
}
if (array_key_exists(WSF_CLASS_NAME, $parameters)) {
$class_name = $parameters[WSF_CLASS_NAME];
}
if (array_key_exists(WSF_CLASSMAP, $parameters)) {
$class_map = $parameters[WSF_CLASSMAP];
}
if (array_key_exists(WSF_CLASS_ARGS, $parameters)) {
$class_args = $parameters[WSF_CLASS_ARGS];
}
if (array_key_exists(WSF_ATTACHMENTS, $parameters)) {
$cid2attachments = $parameters[WSF_ATTACHMENTS];
}
if (array_key_exists(WSF_CID2CONTENT_TYPE, $parameters)) {
$cid2cont_type = $parameters[WSF_CID2CONTENT_TYPE];
}
if (array_key_exists(WSF_USE_MTOM, $parameters)) {
$mtom_on = $parameters[WSF_USE_MTOM];
}
$header_element = NULL;
if (array_key_exists(WSF_HEADER_STRING, $parameters)) {
$header_string = $parameters[WSF_HEADER_STRING];
if ($header_string && !empty($header_string)) {
$header_dom = new DomDocument();
$header_dom->preserveWhiteSpace = FALSE;
$header_dom->loadXML($header_string);
$header_element = $header_dom->documentElement;
}
}
// payload can be NULL
if (!empty($payload_string)) {
$payload_dom->loadXML($payload_string);
$payload_element = $payload_dom->documentElement;
} else {
$payload_dom = NULL;
$payload_element = NULL;
}
$sig_model_dom->loadXML($sig_model_string);
$endpoint_address = wsf_get_endpoint_address($sig_model_dom);
$operation_node = wsf_find_operation($sig_model_dom, $operation_name, $service_name, $endpoint_address, $port_name, $is_multiple_interfaces);
if (!$operation_node) {
ws_log_write(__FILE__, __LINE__, WSF_LOG_ERROR, "{$operation_name} operaiton not found");
throw new WSFault("Sender", "{$operation_name} operation not found");
}
$return_payload_info = wsf_serivce_invoke_function($operation_node, $function_name, $class_name, $class_args, $payload_element, $header_element, $class_map, $mtom_on, $cid2cont_type, $cid2attachments);
return $return_payload_info;
}
function wsf_set_nil_element($value, $parent_node, $root_node, &$prefix_i, array &$namespace_map)
{
if ($value !== NULL) {
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, $parent_node->localName . " is not nil\n value is: " . print_r($value, TRUE));
return FALSE;
}
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, $parent_node->localName . " is nil\n");
if (array_key_exists(WSF_XSI_NAMESPACE, $namespace_map)) {
$prefix = $namespace_map[WSF_XSI_NAMESPACE];
} else {
$prefix = "xsi";
$root_node->setAttribute("xmlns:" . $prefix, WSF_XSI_NAMESPACE);
$namespace_map[WSF_XSI_NAMESPACE] = $prefix;
}
$attribute_name = $prefix . ":" . "nil";
$attribute_value = "1";
$parent_node->setAttribute($attribute_name, $attribute_value);
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, $parent_node->localName . " is nil");
return TRUE;
}
/**
* service invoke function
*/
function wsf_serivce_invoke_function($operation_node, $function_name, $class_name, $class_args, $soap_body_node, $header_node, $classmap, $mtom_on, $cid2cont_type, $cid2attachments)
{
require_once 'wsf_wsdl_consts.php';
require_once 'wsf_wsdl_util.php';
require_once 'wsf_wsdl_deserialization.php';
$sig_node = NULL;
$binding_details_node = NULL;
if ($operation_node) {
foreach ($operation_node->childNodes as $operation_child) {
if ($operation_child->tagName == WSF_SIGNATURE) {
$sig_node = $operation_child;
}
if ($operation_child->tagName == WSF_BINDINDG_DETAILS) {
$binding_details_node = $operation_child;
}
}
}
$is_doc = TRUE;
//currently we only support doc-lit style parsing..
$is_wrapper = FALSE;
$params_node = NULL;
$is_direct_list = FALSE;
if ($sig_node) {
$params_node = $sig_node->firstChild;
if ($params_node && $params_node->localName == WSF_PARAMS) {
if ($params_node->hasAttributes()) {
/* Wrapper element of the request operation */
$sig_attrs = $params_node->attributes;
if ($sig_attrs->getNamedItem(WSF_WRAPPER_ELEMENT)) {
$ele_name = $sig_attrs->getNamedItem(WSF_WRAPPER_ELEMENT)->value;
}
if ($sig_attrs->getNamedItem(WSF_WRAPPER_ELEMENT_NS)) {
$ele_ns = $sig_attrs->getNamedItem(WSF_WRAPPER_ELEMENT_NS)->value;
}
$is_wrapper = TRUE;
} else {
/* No wrapper element in the request */
$ele_ns = NULL;
$ele_name = NULL;
/* check for the only param target-namespace */
$only_param = $params_node->firstChild;
$sig_attrs = $only_param->attributes;
if ($sig_attrs->getNamedItem(WSF_TARGETNAMESPACE)) {
$ele_ns = $sig_attrs->getNamedItem(WSF_TARGETNAMESPACE)->value;
}
if ($sig_attrs->getNamedItem(WSF_NAME)) {
$ele_name = $sig_attrs->getNamedItem(WSF_NAME)->value;
}
if ($sig_attrs->getNamedItem(WSF_LIST)) {
$is_direct_list = $sig_attrs->getNamedItem(WSF_LIST)->value;
}
}
}
}
if (!$soap_body_node) {
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "soap_body not found");
}
// parsing input headers
$header_params = array();
$output_headers = array();
if ($header_node) {
$header_first_child = $header_node->firstChild;
$output_index = 0;
if ($binding_details_node) {
$binding_details_childs = $binding_details_node->childNodes;
foreach ($binding_details_childs as $binding_details_child) {
if ($binding_details_child->nodeType == XML_ELEMENT_NODE && $binding_details_child->nodeName == WSF_SOAPHEADER && $binding_details_child->attributes->getNamedItem(WSF_HEADER_FOR_ATTRIBUTE)) {
if ($binding_details_child->attributes->getNamedItem(WSF_HEADER_FOR_ATTRIBUTE)->value == WSF_WSDL_INPUT) {
//so this is the next input element..
$sig_attrs = $binding_details_child->attributes;
if ($sig_attrs->getNamedItem(WSF_TYPE)) {
$ele_name = $sig_attrs->getNamedItem(WSF_TYPE)->value;
}
if ($sig_attrs->getNamedItem(WSF_TYPE_NAMESPACE)) {
$ele_ns = $sig_attrs->getNamedItem(WSF_TYPE_NAMESPACE)->value;
}
// for the starting sig we have to go for the header node name we want
//go to the next header
if ($header_first_child) {
$header_child = $header_first_child;
while ($header_child && ($header_child->nodeType == XML_TEXT_NODE || !($header_child->localName == $ele_name && $header_child->namespaceURI == $ele_ns))) {
$header_child = $header_child->nextSibling;
}
}
if ($header_child) {
$header_sig = $binding_details_child->firstChild;
if ($classmap != NULL && !empty($classmap)) {
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "starting to parse header {$ele_name} as a classmap");
$new_param = wsf_parse_payload_for_class_map($header_child, $header_sig, $ele_name, $classmap, $cid2cont_type, $cid2attachments);
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "parsed_pram " . print_r($new_param, TRUE) . " as a classmap");
} else {
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "starting to parse header {$ele_name} as an array");
$new_param = wsf_parse_payload_for_array($header_child, $header_sig, $cid2cont_type, $cid2attachments);
}
$header_params[] = $new_param;
} else {
//if header child doesn't exist better check whether it is an requeired header
if ($sig_attrs && $sig_attrs->getNamedItem(WSF_REQUIRED) && $sig_attrs->getNamedItem(WSF_REQUIRED)->value == "true") {
//throwing faults saying it is required
throw new WSFault("Sender", "Requried header {$ele_name}|{$ele_ns} missing");
}
}
} else {
if ($binding_details_child->attributes->getNamedItem(WSF_HEADER_FOR_ATTRIBUTE)->value == WSF_WSDL_OUTPUT) {
$output_headers[$output_index] = array();
//to retrive later
$header_params[] =& $output_headers[$output_index];
//to feed to the user operation
$output_index++;
}
}
}
}
}
}
//parsing the pyalod
$op_param_values = array();
if ($classmap != NULL && !empty($classmap)) {
if ($soap_body_node) {
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "starting to parse payload as a classmap");
$op_param_values = wsf_parse_payload_for_class_map($soap_body_node, $params_node, $ele_name, $classmap, $cid2cont_type, $cid2attachments);
}
$arg_array = array_merge(array($op_param_values), $header_params);
} else {
if ($soap_body_node) {
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "starting to parse payload as an array");
$op_param_values = wsf_parse_payload_for_array($soap_body_node, $params_node, $cid2cont_type, $cid2attachments);
if (!is_array($op_param_values) || $is_direct_list) {
// this can happens when returning simple types
$op_param_values = array($op_param_values);
}
}
$arg_array = array_merge($op_param_values, $header_params);
}
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, print_r($arg_array, TRUE));
if ($class_name != NULL) {
// First call the constructor
$class = new ReflectionClass($class_name);
if ($class) {
if ($class_args && is_array($class_args)) {
$class_inst = $class->newInstanceArgs($class_args);
} else {
$class_inst = $class->newInstanceArgs(array());
}
// Then the user method
$method = $class->getMethod($function_name);
if ($classmap != NULL && !empty($classmap) || $is_direct_list) {
// for direct lists we follow same api as classmap
$response_value = $method->invokeArgs($class_inst, $arg_array);
} else {
$response_value = $method->invokeArgs($class_inst, $arg_array);
}
} else {
ws_log_write(__FILE__, __LINE__, WSF_LOG_ERROR, "class : {$class_name} doesn't exists");
}
} else {
if ($classmap != NULL && !empty($classmap) || $is_direct_list) {
// for direct lists we follow same api as classmap
$response_value = call_user_func_array($function_name, $arg_array);
} else {
$response_value = call_user_func_array($function_name, $arg_array);
}
}
$attachment_map = array();
$response_payload_string = wsf_wsdl_create_response_payload($response_value, $sig_node, $mtom_on, $attachment_map, $classmap);
$output_header_string = wsf_wsdl_create_response_headers($binding_details_node, $output_headers, $mtom_on, $attachment_map, $classmap);
return array(WSF_RESPONSE_PAYLOAD => $response_payload_string, WSF_OUTPUT_HEADERS => $output_header_string, WSF_ATTACHMENT_MAP => $attachment_map);
}
/**
* Extract the sig node looking at the incomming xml type
* @param array $sig_model as a DomNode
* @param DomNode $parent_node - The parent node to check for the content
* @param $object mixed relevent object instance(passed by reference)
* @param $original_type the type in the first place
* @param $classmap - the type name to class map
*/
function wsf_infer_sig_node_from_xml($sig_node, $parent_node, &$object, $original_type, $classmap)
{
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "Calling infer sig mode from xml");
// first it is to be safte to keep the element type as the original type and the sig node too
$the_element_type = $original_type;
$the_sig_node = $sig_node;
// second we have to find whether there is xsi:type in the xml.
$xml_type = NULL;
$xsi_type_attri_node = $parent_node->getAttributeNodeNS(WSF_XSI_NAMESPACE, "type");
if ($xsi_type_attri_node) {
$xml_type = $xsi_type_attri_node->value;
}
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "xml type {$xml_type}");
if ($xml_type) {
//looks like there is a type declared in the xml, so find possible types..
$inheriting_type_found = FALSE;
$xml_type_local_value = $xml_type;
$pos = strpos($xml_type, ":");
if ($pos !== FALSE) {
$xml_type_local_value = substr($xml_type, $pos + 1);
}
$sig_child_nodes = $sig_node->childNodes;
foreach ($sig_child_nodes as $sig_child_node) {
if ($sig_child_node->localName == WSF_INHERITING_TYPE) {
$sig_child_attris = $sig_child_node->attributes;
$type_name = $type_ns = "";
if ($sig_child_attris->getNamedItem(WSF_XSI_TYPE)) {
$type_name = $sig_child_attris->getNamedItem(WSF_XSI_TYPE)->value;
}
if ($xml_type_local_value == $type_name) {
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "type name {$type_name} found ");
$the_element_type = $type_name;
$the_sig_node = $sig_child_node;
$inheriting_type_found = TRUE;
break;
}
}
}
}
if (is_array($classmap) && array_key_exists($the_element_type, $classmap)) {
$class_name = $classmap[$the_element_type];
}
if (!isset($class_name) || $class_name == NULL) {
$class_name = $the_element_type;
}
try {
$ref_class = new ReflectionClass($class_name);
if ($ref_class->isInstantiable()) {
$object = $ref_class->newInstance();
}
} catch (Exception $e) {
$object = new WSFUnknownSchemaConstruct();
}
return $the_sig_node;
}
/**
* Function that creates types elements(schema) for WSDL1.1 in
* doc-lit style
* @param DomDocument $wsdl_doc DomDocument element of the wsdl document
* @param DomElement $wsdl_root service dom element
* @param array $schemaTypes array of schema types
*/
public function createDocLitType(DomDocument $wsdl_doc, DomElement $wsdl_root, $schemaTypes)
{
$return_array = array();
$types_ele = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SCHEMA_WSDL_NAMESPACE, WS_WSDL_Const::WS_WSDL_TYPES_ATTR_NAME);
$wsdl_root->appendChild($types_ele);
$schema_ele = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_SCHEMA_ATTR_NAME);
$schema_ele->setAttribute(WS_WSDL_Const::WS_WSDL_ELEMENTFORMDEFAULT_ATTR_NAME, WS_WSDL_Const::WS_WSDL_QUALIFIED_ATTR_NAME);
$schema_ele->setAttribute(WS_WSDL_Const::WS_WSDL_DEF_TARGET_NS, $this->ns);
$schema_root = $schema_ele;
$types_ele->appendChild($schema_ele);
/* here the structure of the param is
Array
(
[In] => Array
(
[matrix_add] => Array
(
[type] => MatrixAdd
[array] =>
[object] => object
[min] => 1
[max] => 3
)
)
[Out] => Array
(
[matrix_add_response] => Array
(
[type] => MatrixAddResponse
[array] =>
[object] => object
[min] => 1
[max] => 3
)
)
)
*/
foreach ($schemaTypes as $function_name => $params) {
$return_array[$function_name] = array();
if (array_key_exists(WS_WSDL_Const::WS_WSDL_INPUT_ATTR_NAME, $params)) {
$params_in_out = $params[WS_WSDL_Const::WS_WSDL_INPUT_ATTR_NAME];
if ($this->classmap) {
if ($params_in_out == NULL || !is_array($params_in_out)) {
ws_log_write(__FILE__, __LINE__, WSF_LOG_ERROR, "with classmap provided, you should have the input param for the {$function_name}");
echo "Error in generating the WSDL\n";
exit(0);
}
foreach ($params_in_out as $paramName => $paramValue) {
$xsd_type = $paramValue["type"];
$element_ele = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_ELEMENT_ATTR_NAME);
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_NAME_ATTR_NAME, $paramName);
if ($paramValue["object"] == "object") {
$object_return = $this->createSchemaType($wsdl_doc, $types_ele, $xsd_type);
if ($this->rev_classmap && is_array($this->rev_classmap) && array_key_exists($xsd_type, $this->rev_classmap)) {
$xsd_type = $this->rev_classmap[$xsd_type];
}
$object_prefix = $object_return["prefix"];
$object_namespace = $object_return["namespace"];
$schema_root->setAttribute("xmlns:" . $object_prefix, $object_namespace);
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_TYPE_ATTR_NAME, $object_prefix . ":" . $xsd_type);
$this->delcare_namespace_import($wsdl_doc, $schema_root, $object_namespace);
} else {
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_TYPE_ATTR_NAME, WS_WSDL_Const::WS_WSDL_XSD_ATTR_NAME . $xsd_type);
}
$schema_ele->appendChild($element_ele);
$return_array[$function_name][WS_WSDL_Const::WS_WSDL_INPUT_ATTR_NAME] = WS_WSDL_Const::WS_WSDL_DEFAULT_SCHEMA_ATTR_NAME . ":" . $paramName;
}
} else {
$ct = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_ELEMENT_ATTR_NAME);
foreach ($this->fun_mapping as $key => $value) {
if ($value == $function_name) {
$ct->setAttribute(WS_WSDL_Const::WS_WSDL_NAME_ATTR_NAME, $key);
}
}
$schema_ele->appendChild($ct);
$comtype = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_COMPLXTYPE_ATTR_NAME);
$ct->appendChild($comtype);
$seq = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_SEQUENCE_ATTR_NAME);
$comtype->appendChild($seq);
foreach ($params_in_out as $paramName => $paramValue) {
$xsd_type = $paramValue["type"];
$element_ele = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_ELEMENT_ATTR_NAME);
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_NAME_ATTR_NAME, $paramName);
// listen to the min and max settings
if (array_key_exists("min", $paramValue) && isset($paramValue["min"]) && is_numeric($paramValue["min"]) && $paramValue["min"] != 1) {
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_ATTR_MIN_OCCURS, $paramValue["min"]);
}
if (array_key_exists("max", $paramValue) && $paramValue["max"]) {
// listen to the min and max settings
if (is_numeric($paramValue["max"]) && $paramValue["max"] != 1) {
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_ATTR_MAX_OCCURS, $paramValue["max"]);
} else {
if ($paramValue["max"] == WS_WSDL_Const::WS_WSDL_ATTR_VALUE_UNBOUNDED) {
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_ATTR_MAX_OCCURS, WS_WSDL_Const::WS_WSDL_ATTR_VALUE_UNBOUNDED);
}
}
} else {
if ($paramValue["array"] == "array") {
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_ATTR_MAX_OCCURS, WS_WSDL_Const::WS_WSDL_ATTR_VALUE_UNBOUNDED);
}
}
if ($paramValue["object"] == "object") {
$object_return = $this->createSchemaType($wsdl_doc, $types_ele, $xsd_type);
if ($this->rev_classmap && is_array($this->rev_classmap) && array_key_exists($xsd_type, $this->rev_classmap)) {
$xsd_type = $this->rev_classmap[$xsd_type];
}
$object_prefix = $object_return["prefix"];
$object_namespace = $object_return["namespace"];
$schema_root->setAttribute("xmlns:" . $object_prefix, $object_namespace);
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_TYPE_ATTR_NAME, $object_prefix . ":" . $xsd_type);
$this->delcare_namespace_import($wsdl_doc, $schema_root, $object_namespace);
} else {
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_TYPE_ATTR_NAME, WS_WSDL_Const::WS_WSDL_XSD_ATTR_NAME . $xsd_type);
}
$seq->appendChild($element_ele);
}
$return_array[$function_name][WS_WSDL_Const::WS_WSDL_INPUT_ATTR_NAME] = TRUE;
}
} else {
//just create an empty schema type
if ($this->classmap) {
ws_log_write(__FILE__, __LINE__, WSF_LOG_ERROR, "with classmap provided, you should have the input param for the {$function_name}");
echo "Error in generating the WSDL\n";
exit(0);
}
$ct = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_ELEMENT_ATTR_NAME);
$ct->setAttribute(WS_WSDL_Const::WS_WSDL_NAME_ATTR_NAME, $function_name);
$schema_ele->appendChild($ct);
$comtype = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_COMPLXTYPE_ATTR_NAME);
$ct->appendChild($comtype);
$seq = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_SEQUENCE_ATTR_NAME);
$comtype->appendChild($seq);
}
if (array_key_exists(WS_WSDL_Const::WS_WSDL_OUTPUT_ATTR_NAME, $params)) {
$params_in_out = $params[WS_WSDL_Const::WS_WSDL_OUTPUT_ATTR_NAME];
if ($this->classmap) {
foreach ($params_in_out as $paramName => $paramValue) {
$xsd_type = $paramValue["type"];
$element_ele = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_ELEMENT_ATTR_NAME);
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_NAME_ATTR_NAME, $paramName);
if ($paramValue["object"] == "object") {
$object_return = $this->createSchemaType($wsdl_doc, $types_ele, $xsd_type);
if ($this->rev_classmap && is_array($this->rev_classmap) && array_key_exists($xsd_type, $this->rev_classmap)) {
$xsd_type = $this->rev_classmap[$xsd_type];
}
$object_prefix = $object_return["prefix"];
$object_namespace = $object_return["namespace"];
$schema_root->setAttribute("xmlns:" . $object_prefix, $object_namespace);
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_TYPE_ATTR_NAME, $object_prefix . ":" . $xsd_type);
$this->delcare_namespace_import($wsdl_doc, $schema_root, $object_namespace);
} else {
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_TYPE_ATTR_NAME, WS_WSDL_Const::WS_WSDL_XSD_ATTR_NAME . $xsd_type);
}
$schema_ele->appendChild($element_ele);
$return_array[$function_name][WS_WSDL_Const::WS_WSDL_OUTPUT_ATTR_NAME] = WS_WSDL_Const::WS_WSDL_DEFAULT_SCHEMA_ATTR_NAME . ":" . $paramName;
}
} else {
$ct = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_ELEMENT_ATTR_NAME);
foreach ($this->fun_mapping as $key => $value) {
if ($value == $function_name) {
$ct->setAttribute(WS_WSDL_Const::WS_WSDL_NAME_ATTR_NAME, $key . WS_WSDL_Const::WS_WSDL_RESPONSE_ATTR_NAME);
}
}
$schema_ele->appendChild($ct);
$comtype = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_COMPLXTYPE_ATTR_NAME);
$ct->appendChild($comtype);
$seq = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_SEQUENCE_ATTR_NAME);
$comtype->appendChild($seq);
foreach ($params_in_out as $paramName => $paramValue) {
$xsd_type = $paramValue["type"];
$element_ele = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_ELEMENT_ATTR_NAME);
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_NAME_ATTR_NAME, $paramName);
// listen to the min and max settings
if (array_key_exists("min", $paramValue) && isset($paramValue["min"]) && is_numeric($paramValue["min"]) && $paramValue["min"] != 1) {
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_ATTR_MIN_OCCURS, $paramValue["min"]);
}
if (array_key_exists("max", $paramValue) && $paramValue["max"]) {
// listen to the min and max settings
if (is_numeric($paramValue["max"]) && $paramValue["max"] != 1) {
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_ATTR_MAX_OCCURS, $paramValue["max"]);
} else {
if ($paramValue["max"] == WS_WSDL_Const::WS_WSDL_ATTR_VALUE_UNBOUNDED) {
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_ATTR_MAX_OCCURS, WS_WSDL_Const::WS_WSDL_ATTR_VALUE_UNBOUNDED);
}
}
} else {
if ($paramValue["array"] == "array") {
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_ATTR_MAX_OCCURS, WS_WSDL_Const::WS_WSDL_ATTR_VALUE_UNBOUNDED);
}
}
if ($paramValue["object"] == "object") {
$object_return = $this->createSchemaType($wsdl_doc, $types_ele, $xsd_type);
if ($this->rev_classmap && is_array($this->rev_classmap) && array_key_exists($xsd_type, $this->rev_classmap)) {
$xsd_type = $this->rev_classmap[$xsd_type];
}
$object_prefix = $object_return["prefix"];
$object_namespace = $object_return["namespace"];
$schema_root->setAttribute("xmlns:" . $object_prefix, $object_namespace);
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_TYPE_ATTR_NAME, $object_prefix . ":" . $xsd_type);
$this->delcare_namespace_import($wsdl_doc, $schema_root, $object_namespace);
} else {
$element_ele->setAttribute(WS_WSDL_Const::WS_WSDL_TYPE_ATTR_NAME, WS_WSDL_Const::WS_WSDL_XSD_ATTR_NAME . $xsd_type);
}
$seq->appendChild($element_ele);
}
$return_array[$function_name][WS_WSDL_Const::WS_WSDL_OUTPUT_ATTR_NAME] = TRUE;
}
} else {
//just create an empty schema type
$ct = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_ELEMENT_ATTR_NAME);
$ct->setAttribute(WS_WSDL_Const::WS_WSDL_NAME_ATTR_NAME, $function_name . "Response");
$schema_ele->appendChild($ct);
$comtype = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_COMPLXTYPE_ATTR_NAME);
$ct->appendChild($comtype);
$seq = $wsdl_doc->createElementNS(WS_WSDL_Const::WS_SOAP_XML_SCHEMA_NAMESPACE, WS_WSDL_Const::WS_WSDL_SEQUENCE_ATTR_NAME);
$comtype->appendChild($seq);
}
}
return $return_array;
}
/**
* check if the xsd type and php types are mathched if not a log
*is written
*@param string $keyIndex
*/
function checkValidTypes($keyIndex, $keyXsdIndex)
{
$keyPHPArray = NULL;
if (array_key_exists($keyXsdIndex, $this->xsdMapArry[$this->operationName])) {
$keyPHPArray = $this->xsdMapArry[$this->operationName][$keyXsdIndex];
}
$PHPType = NULL;
if (array_key_exists($keyIndex, $this->phpMapArry)) {
$PHPType = $this->phpMapArry[$keyIndex];
}
require_once 'dynamic_invocation/wsf_wsdl_consts.php';
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "mapping :" . $keyPHPArray . " to " . $PHPType);
if ($keyPHPArray && array_key_exists($keyPHPArray, self::$mappingTable) && $PHPType == self::$mappingTable[$keyPHPArray]) {
return $keyPHPArray;
} else {
error_log("type missmatched", 0);
return $PHPType;
}
}
/**
* Processes and validate response message and assign values to class map.
* @param DomDocument $payload_dom response payload
* @param DomDocument $header_dom response header, can be NULL
* @param DomDocument $operation_sig_dom operation sig model
* @param array $response_parameters array of response parameters
* @return mixed an object, an array or a simple type in line with the
* expected format of the response
*/
function wsf_client_response_and_validate(DomDocument $payload_dom, $header_dom, DomDocument $operation_sig_dom, $response_parameters, $mtom_on = FALSE)
{
require_once 'wsf_wsdl_consts.php';
require_once 'wsf_wsdl_util.php';
require_once 'wsf_wsdl_deserialization.php';
$payload_node = $payload_dom->documentElement;
$operation_sig_node = $operation_sig_dom->documentElement;
$binding_details_node = NULL;
$sig_method = NULL;
//extracting out the sig_method from the operation sig node
if ($operation_sig_node) {
foreach ($operation_sig_node->childNodes as $operation_sig_child) {
if ($operation_sig_child->tagName == WSF_SIGNATURE) {
$sig_method = $operation_sig_child;
}
if ($operation_sig_child->tagName == WSF_BINDINDG_DETAILS) {
$binding_details_node = $operation_sig_child;
}
}
}
$ele_ns = NULL;
$is_wrapper = FALSE;
if ($sig_method) {
$returns_node = $sig_method->firstChild;
while ($returns_node && $returns_node->localName != WSF_RETURNS) {
$returns_node = $returns_node->nextSibling;
}
if ($returns_node) {
if ($returns_node->hasAttributes()) {
/* Wrapper element of the request operation */
$sig_attrs = $returns_node->attributes;
$ele_name = NULL;
$ele_ns = NULL;
if ($sig_attrs->getNamedItem(WSF_WRAPPER_ELEMENT)) {
$ele_name = $sig_attrs->getNamedItem(WSF_WRAPPER_ELEMENT)->value;
}
if ($sig_attrs->getNamedItem(WSF_WRAPPER_ELEMENT_NS)) {
$ele_ns = $sig_attrs->getNamedItem(WSF_WRAPPER_ELEMENT_NS)->value;
}
$is_wrapper = TRUE;
} else {
/* No wrapper element in the request */
$ele_ns = NULL;
$ele_name = NULL;
/* check for the only param target-namespace */
$only_param = $returns_node->firstChild;
$sig_attrs = $only_param->attributes;
if ($sig_attrs->getNamedItem(WSF_TARGETNAMESPACE)) {
$ele_ns = $sig_attrs->getNamedItem(WSF_TARGETNAMESPACE)->value;
}
if ($sig_attrs->getNamedItem(WSF_NAME)) {
$ele_name = $sig_attrs->getNamedItem(WSF_NAME)->value;
}
}
}
}
/** get SOAP body DOM tree to compare with Sig model */
if (!$payload_node) {
error_log("soap_body not found", 0);
}
$classmap = NULL;
$cid2cont_type = array();
$cid2attachments = array();
if (array_key_exists(WSF_CLASSMAP, $response_parameters)) {
$classmap = $response_parameters[WSF_CLASSMAP];
}
if (array_key_exists("attachments", $response_parameters)) {
$cid2attachments = $response_parameters["attachments"];
}
if (array_key_exists("cid2contentType", $response_parameters)) {
$cid2cont_type = $response_parameters["cid2contentType"];
}
$op_param_values = array();
if ($classmap !== NULL) {
$op_param_values = wsf_parse_payload_for_class_map($payload_node, $returns_node, $ele_name, $classmap, $cid2cont_type, $cid2attachments);
} else {
$op_param_values = wsf_parse_payload_for_array($payload_node, $returns_node, $cid2cont_type, $cid2attachments);
}
$header_node = NULL;
if ($header_dom) {
$header_node = $header_dom->documentElement;
}
$header_params = array();
if ($header_node) {
$header_first_child = $header_node->firstChild;
$output_index = 0;
if ($binding_details_node) {
$binding_details_childs = $binding_details_node->childNodes;
foreach ($binding_details_childs as $binding_details_child) {
if ($binding_details_child->nodeType == XML_ELEMENT_NODE && $binding_details_child->nodeName == WSF_SOAPHEADER && $binding_details_child->attributes->getNamedItem(WSF_HEADER_FOR_ATTRIBUTE)) {
if ($binding_details_child->attributes->getNamedItem(WSF_HEADER_FOR_ATTRIBUTE)->value == WSF_WSDL_OUTPUT) {
//so this is the next input element..
$sig_attrs = $binding_details_child->attributes;
if ($sig_attrs->getNamedItem(WSF_TYPE)) {
$ele_name = $sig_attrs->getNamedItem(WSF_TYPE)->value;
}
if ($sig_attrs->getNamedItem(WSF_TYPE_NAMESPACE)) {
$ele_ns = $sig_attrs->getNamedItem(WSF_TYPE_NAMESPACE)->value;
}
//go to the next header
if ($header_first_child) {
$header_child = $header_first_child;
while ($header_child && ($header_child->nodeType == XML_TEXT_NODE || !($header_child->localName == $ele_name && $header_child->namespaceURI == $ele_ns))) {
$header_child = $header_child->nextSibling;
}
}
if ($header_child) {
$header_sig = $binding_details_child->firstChild;
if ($classmap != NULL && !empty($classmap)) {
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "starting to parse header {$ele_name} as a classmap");
$new_param = wsf_parse_payload_for_class_map($header_child, $header_sig, $ele_name, $classmap, $cid2cont_type, $cid2attachments);
} else {
ws_log_write(__FILE__, __LINE__, WSF_LOG_DEBUG, "starting to parse header {$ele_name} as an array");
$new_param = wsf_parse_payload_for_array($header_child, $header_sig, $cid2cont_type, $cid2attachments);
}
$header_params[] = $new_param;
}
}
}
}
}
}
return array(WSF_RESPONSE_PAYLOAD_PARAM => $op_param_values, WSF_RESPONSE_HEADER_PARAM => $header_params);
}
