Static WSDL script include example
Summarize
Summary of Static WSDL script include example
This example demonstrates how to create a Static WSDL script include in ServiceNow using theFakeStockValueclass. It shows how to process SOAP XML requests, interpret the SOAP body to invoke appropriate functions, and generate SOAP responses or faults. This is useful for customers building scripted web services that interact via SOAP with static WSDL definitions.
Show less
Key Features
- initialize function: Converts the incoming SOAP XML request string into an XML Document object for easy navigation and manipulation within the script include.
- process function: Extracts the first child element inside the SOAP body to determine which operation to execute. Currently, it supports one operation, TradePriceRequest, but can be extended for multiple functions.
- fakeOutTradePriceRequest function: Implements the WSDL operation by retrieving the authenticated user's username and returns a custom message including the requested stock symbol. This demonstrates how to access user context and craft XML SOAP responses.
- generateSoapFault function: Creates a SOAP fault response XML to handle unsupported operations or errors, allowing graceful error communication back to the SOAP client.
Practical Use for ServiceNow Customers
This scripted web service example enables you to build customized SOAP endpoints that can parse and respond to SOAP requests based on static WSDL definitions. You can tailor the fakeOutTradePriceRequest function or add more operations to implement business logic like querying stock quotes or other backend data. The inclusion of SOAP fault generation ensures robust error handling.
By leveraging this example, customers can:
- Understand how to parse SOAP XML requests within ServiceNow script includes.
- Return dynamic, user-contextual SOAP responses.
- Extend the scripted web service with additional SOAP operations.
- Implement error handling through SOAP faults for unsupported or invalid requests.
This example demonstrates the FakeStockValue script include that implements much of the static WSDL behavior.
var FakeStockValue = Class.create();
FakeStockValue.prototype = {
initialize : function(requestXML) {
//Use some backend XML utilities...you could use string tools if you wish
this.xmlutil = Packages.com.glide.util.XMLUtil;
//converting the string to an XML Document
this.fSoapDoc = new XMLDocument(requestXML);
},
process : function() {
var soapBody = this.fSoapDoc.getNode("/Envelope/Body");
//Our WSDL was formatted to have the only first child element be the function
var funcNode = this.xmlutil.getFirstChildElement(soapBody);
var nodeName = this.xmlutil.getNodeNameNS(funcNode);
//If the function for this SOAP request is TradePriceRequest, perform the necessary actions
if (nodeName == "TradePriceRequest") {
return this.fakeOutTradePriceRequest(funcNode);
}
//Couldn't find any supported functions in this SOAP request
return this.generateSoapFault("un-supported API call: " + nodeName);
},
fakeOutTradePriceRequest : function (funcNode) {
//Create the beginnings of our XML response
var r = new XMLDocument("<GetLastTradePriceOutput xmlns='https://www.service-now.com/vws/FakeStockValue'/>");
//Do the necessary actions here...we're going to get the USER ID of the user
//used to make this SOAP call. Then we will return the
//stock symbol they were asking about
var usersysid = gs.getUserID();
var now_GR = new GlideRecord("sys_user");
gr.get(usersysid);
var username = gr.user_name;
var quoteSymbol = this.xmlutil.getText(funcNode);
//Create a "message" element to store our response message
r.createElement("message", username + ", You were looking for a quote on "+quoteSymbol);
return r.getDocumentElement();
},
generateSoapFault : function (str) {
var f = "<SOAP-ENV:Fault>" +
"<faultcode xsi:type='xsd:string'>SOAP-ENV:FakeStockValue</faultcode>" +
"<faultstring xsi:type='xsd:string'>" + str +
"</faultstring>" +
"</SOAP-ENV:Fault>"
var s = new XMLDocument(f);
return s.getDocumentElement();
}
}
initialize function
The initialize function takes the XML request string and converts it to an XML Document object that you can navigate and manipulate using libraries. Alternatively, you can leave the XML request as a string and navigate it using regular expressions.
process function
The process function is called by the scripted web service. This function grabs the first child element in the XML after the body element. The WSDL uses this child element to determine which function to use. In this WSDL there is only one possible function but most WSDLs provide many functions. If more functions were available, there would be more "if" statements that tested the first child element for the various function names.
fakeOutTradePriceRequest function
The fakeOutTradePriceRequest function is the implementation of the only available function in the WSDL. This function looks up the user that the SOAP request authenticated as and retrieves the user_name then returns it to the SOAP client. The fakeOutTradePriceRequest function could be expanded to perform useful activities, such as looking up a stock symbol and returning the last traded price.
generateSoapFault function
The generateSoapFault function returns a SOAP error that can be called if there are problems.