Poll Processor
The Poll Processor contains the logic that will be applied when polling a remote system for data.
The Poll Processor is a configuration record which contains the logic that will be applied when polling a remote system for data. There are three main scripts which are used to setup, execute and process the Poll Requests. The scripts given here are examples of how you might configure your Poll. The details of yours may differ depending on your requirements.
Icons
The icons are:

a) 'Integration' icon: Opens the current integration's Details page.
b) 'Messages' icon: Opens the current integration's Messages page.
c) 'Fields' icon: Opens the current integration's Fields page.
d) 'Field Maps' icon: Opens the current integration's Field Maps page.
e) 'Pollers' icon: Opens the current integration's Pollers page.
f) 'Poll Processors' icon: Opens the current integration's Poll Processors page.
New Poll Processor
In Unifi Integration Designer, navigate to & open < Your Integration > (created following the Outbound Incident Guide & Incident Update Poller Guide).
Click the 'Poll Processors' icon & then New.
The fields to be configured for the New Poll Processor modal are as follows:
Name
The name of the Processor.
<Your Name>
Your New Poll Processor modal should look like this:

Submit and view to further configure the Poll Processor.
Setup Script
The Setup Script is the first script to run (it runs at the point in time the Poll Request is created). It is used to build the environment for the poll and define what it will do. We will use it to setup the URL that will be called.
Navigate to Scripts > Setup Script.
The initial Poll Processor fields to be configured are as follows:
Setup script
The script to setup the Poll Request record.
Update the code in the Setup script field so that it looks like the code below
The code in the Setup script field should look like this:
// Configure the new Poll Request record
(function(poll_request, poller, params) {
var gdt = new GlideDateTime();
gdt.addSeconds(-1800);
var connection = poller.getIntegration().getActiveConnection();
var user = connection.getBasicAuthUser();
var time = connection.getData('last_update_time', (gdt + ''));
var fields = 'sys_id,number,correlation_id,short_description,description,state,close_code,close_notes,sys_updated_on,sys_updated_by';
var query = [
'correlation_idISNOTEMPTY',
'sys_updated_by!=' + user,
'sys_updated_on>' + time
];
var uri_query = query.map(function(c) {
return encodeURIComponent(c);
}).join('%5E');
poll_request.endpoint_url += '/table/incident?sysparm_query=' + uri_query +
'&sysparm_fields=' + encodeURIComponent(fields) + '&sysparm_limit=10';
})(poll_request, poller, params);
Your Setup Script form should look like this:

Navigate to Request Script.
Request Script
The Request Script is used to reach into the remote system and execute the request. We will use the ServiceNow RESTMessageV2() web service to make a REST call to the URL defined in the Setup Script.
The next Poll Processor field to be configured is as follows:
Request script
The script that executes the request.
Update the code in the Request script field so that it looks like the code below
The code in the Request script field should look like this:
// Process the request e.g. by executing a web service and returning the response
(function(poll_request, poller, connection, params) {
var rm = new sn_ws.RESTMessageV2();
rm.setEndpoint(poll_request.endpoint_url);
rm.setHttpMethod('GET');
rm.setRequestHeader('Accept', 'application/json');
rm.setRequestHeader('Content-type', 'application/json');
rm.setBasicAuth(connection.getBasicAuthUser(), connection.getBasicAuthPassword());
// rm.setRequestBody(JSON.stringify(body));
var resp = rm.execute();
answer = resp.getBody() + '';
})(poll_request, poller, connection, params);
Your Request Script form should look like this:

Navigate to Response Script.
Response Script
The Response Script is used to process the information returned from the remote system. We will pass this data to Unifi, telling it which Message to use to process the data.
The last Poll Processor field to be configured is as follows:
Response script
The script that processes the response to the request.
Update the code in the Response script field so that it looks like the code below
The code in the Response script field should look like this:
// Process the response returned by the request script
// The 'answer' variable from the request script is passed in here as the 'response' parameter
(function (poll_request, poller, response, params) {
var body = JSON.parse(response);
// Nothing to do if no results were returned
if ( body.result.length == 0 ) {
poll_request.response_status = 'No Incidents returned\n\n' + JSON.stringify(body,null,2);
return;
}
// Sample result
/*
{
"result": [
{
"sys_id": "0ecc4865db734010c3ebde82ca961960",
"number": "INC0010107",
"correlation_id": "INC0010345",
"short_description": "Demo two - Fixing request",
"description": "A long description",
"state":"2",
"sys_updated_on": "2020-04-02 14:00:00",
"sys_updated_by": "a.user"
},
{
... next Incident
}
]
}
*/
// Establish the environment
var integration = poller.getIntegration();
var config = integration.getConfig();
var conn = integration.getActiveConnection();
var cvars = conn.getVariables();
var poll_helper = new x_snd_eb.PollHelper(poll_request);
var info = [];
// Use Unifi code to find the Bond for an Incident
function get_bond(inc) {
var bond = new x_snd_eb.Bond(config);
bond.locateReference(integration,inc.correlation_id,inc.sys_id);
if ( !bond.isValidRecord() ) { return null; }
return bond;
}
// Work out the message type to send to Unifi based upon the change of state
function get_message_name(curr,prev) {
// Default message type is an update
var message_name = 'UpdateIncidentInbound';
// Use the default type if we have no previous state
if ( !prev || !prev.state ) {
return message_name;
}
// Use the default type if there is no change in state
if ( curr.state == prev.state ) {
return message_name;
}
// We know the state has changed, check if it is Resolved (6)
if ( curr.state == '6' ) {
message_name = 'ResolveIncidentInbound';
}
return message_name;
}
function process_incident(inc) {
// Log the incident number and time
var inc_time = inc.sys_updated_on;
info.push('Incident : ' + inc.number + ' (' + inc_time + ')');
// Find the bond on which the previous data is stored
var bond = get_bond(inc);
// If no bond was found, ignore this incident
if ( !bond ) {
info.push('- Bond not found - Incident ignored');
return;
}
// Get the data stored for the incident by a previous poll
var previous_inc = bond.getDataObject('previous_inc',{ state : '2' });
// Work out the message type to send into Unifi
var message_name = get_message_name(inc,previous_inc);
info.push('- Message name: ' + message_name);
// Set up the payload object for passing into Unifi
var payload = {
message : {
name: message_name,
source_reference: inc.sys_id,
},
detail : {
short_description : inc.short_description,
description : inc.description,
state : inc.state,
close_code : inc.close_code,
close_notes : inc.close_notes
}
};
// Submit the message into Unifi
poll_helper.processInbound({
payload : JSON.stringify(payload)
});
// Save the current incident as the previous incident for the next poll
bond.setDataObject('previous_inc',inc);
// Update last update time (if later)
var conn_time = conn.getData('last_update_time');
if ( inc_time > conn_time ) {
conn.setData('last_update_time',inc_time);
}
}
// Process each result
body.result.forEach(function(inc){
process_incident(inc);
});
poll_request.response_status = info.join('\n') + '\n\n' + JSON.stringify(body,null,2);
})(poll_request, poller, response, params);
Your Response Script form should look like this:

Save the Poll Processor.
Now let's move on and configure the Poller.
Was this helpful?