Poll Processor

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
Before continuing we would again like to remind you of the relevant icons that are visible down the left hand navigation strip of the Unifi Integration Designer.
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:
Field
Description
Value
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:
Field
Description
Value
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:
1
// Configure the new Poll Request record
2
(function(poll_request, poller, params) {
3
​
4
    var gdt = new GlideDateTime();
5
    gdt.addSeconds(-1800);
6
​
7
    var connection = poller.getIntegration().getActiveConnection();
8
    var user = connection.getBasicAuthUser();
9
    var time = connection.getData('last_update_time', (gdt + ''));
10
​
11
    var fields = 'sys_id,number,correlation_id,short_description,description,state,close_code,close_notes,sys_updated_on,sys_updated_by';
12
​
13
    var query = [
14
        'correlation_idISNOTEMPTY',
15
        'sys_updated_by!=' + user,
16
        'sys_updated_on>' + time
17
    ];
18
​
19
    var uri_query = query.map(function(c) {
20
        return encodeURIComponent(c);
21
    }).join('%5E');
22
​
23
    poll_request.endpoint_url += '/table/incident?sysparm_query=' + uri_query +
24
        '&sysparm_fields=' + encodeURIComponent(fields) + '&sysparm_limit=10';
25
​
26
})(poll_request, poller, params);
Copied!
Setup script: The parameters for which data to return are contained in the endpoint url.
fields: The table API will return all the data by default, so we choose to deliberately limit what is returned to the fields listed in this variable.
query: Instead of querying all the records on the remote instance, we deliberately limit the records to those where the correlation id is not empty (i.e. it's bonded), that haven't been updated by the Authentication user (our system) and that were updated since either since the last update time (if one exists), or in the last 30 minutes.
Endpoint URL: The value used in the poll_request.endpoint_url was initially generated using the ServiceNow REST API Explorer, substituting variables in for the uri query and fields. This value is appended to the existing endpoint url in the active connection before being added to the Poll Request.
Note: We have included the /table/incident element of the endpoint url because we used the truncated url in the Connection when following the Outbound Incident Guide.  If you have used the full url there, then this element can be excluded here.
(We have also chosen to limit the number of records returned to 10.)
params: The params object is passed through to the subsequent scripts (and on to further Pollers, if required).
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:
Field
Description
Value
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:
1
// Process the request e.g. by executing a web service and returning the response
2
(function(poll_request, poller, connection, params) {
3
​
4
    var rm = new sn_ws.RESTMessageV2();
5
    rm.setEndpoint(poll_request.endpoint_url);
6
    rm.setHttpMethod('GET');
7
    rm.setRequestHeader('Accept', 'application/json');
8
    rm.setRequestHeader('Content-type', 'application/json');
9
    rm.setBasicAuth(connection.getBasicAuthUser(), connection.getBasicAuthPassword());
10
​
11
    // rm.setRequestBody(JSON.stringify(body));
12
    var resp = rm.execute();
13
​
14
    answer = resp.getBody() + '';
15
​
16
})(poll_request, poller, connection, params);
Copied!
Request script: This script uses the ServiceNow RESTMessageV2() web service to make a REST call to the endpoint url created in the Setup script. It returns the body of the request as the answer which it passes to the Response script
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:
Field
Description
Value
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:
1
// Process the response returned by the request script
2
// The 'answer' variable from the request script is passed in here as the 'response' parameter 
3
(function (poll_request, poller, response, params) {
4
​
5
    var body = JSON.parse(response);
6
​
7
    // Nothing to do if no results were returned
8
    if ( body.result.length == 0 ) {
9
        poll_request.response_status = 'No Incidents returned\n\n' + JSON.stringify(body,null,2);
10
        return;
11
    }
12
​
13
    // Sample result
14
/*
15
{
16
  "result": [
17
    {
18
      "sys_id": "0ecc4865db734010c3ebde82ca961960",
19
      "number": "INC0010107",
20
      "correlation_id": "INC0010345",
21
      "short_description": "Demo two - Fixing request",
22
      "description": "A long description",
23
      "state":"2",
24
      "sys_updated_on": "2020-04-02 14:00:00",
25
      "sys_updated_by": "a.user"
26
    },
27
    {
28
      ... next Incident
29
    }
30
  ]
31
}    
32
*/
33
​
34
    // Establish the environment
35
    var integration = poller.getIntegration();
36
    var config = integration.getConfig();
37
    var conn   = integration.getActiveConnection();
38
    var cvars  = conn.getVariables();
39
​
40
    var poll_helper = new x_snd_eb.PollHelper(poll_request);
41
    var info = [];
42
​
43
    // Use Unifi code to find the Bond for an Incident
44
    function get_bond(inc) {
45
        var bond = new x_snd_eb.Bond(config);
46
        bond.locateReference(integration,inc.correlation_id,inc.sys_id);
47
        if ( !bond.isValidRecord() ) { return null; }
48
        return bond; 
49
    }
50
​
51
    // Work out the message type to send to Unifi based upon the change of state
52
    function get_message_name(curr,prev) {
53
​
54
        // Default message type is an update
55
        var message_name = 'UpdateIncidentInbound';
56
​
57
        // Use the default type if we have no previous state
58
        if ( !prev || !prev.state ) { 
59
            return message_name; 
60
        }
61
​
62
        // Use the default type if there is no change in state
63
        if ( curr.state == prev.state ) { 
64
            return message_name; 
65
        }
66
​
67
        // We know the state has changed, check if it is Resolved (6)
68
        if ( curr.state == '6' ) {
69
            message_name = 'ResolveIncidentInbound';
70
        }
71
​
72
        return message_name;
73
    }
74
​
75
    function process_incident(inc) {
76
​
77
        // Log the incident number and time
78
        var inc_time = inc.sys_updated_on;
79
        info.push('Incident : ' + inc.number + ' (' + inc_time + ')');
80
​
81
        // Find the bond on which the previous data is stored
82
        var bond = get_bond(inc);
83
​
84
        // If no bond was found, ignore this incident
85
        if ( !bond ) {
86
            info.push('- Bond not found - Incident ignored');
87
            return;
88
        }
89
​
90
        // Get the data stored for the incident by a previous poll
91
        var previous_inc = bond.getDataObject('previous_inc',{ state : '2' });
92
​
93
        // Work out the message type to send into Unifi 
94
        var message_name = get_message_name(inc,previous_inc);
95
        info.push('- Message name: ' + message_name);
96
​
97
        // Set up the payload object for passing into Unifi
98
        var payload = {
99
            message : {
100
                name: message_name,
101
                source_reference: inc.sys_id,
102
            },
103
            detail : {
104
                short_description : inc.short_description,
105
                description : inc.description,
106
                state : inc.state,
107
                close_code : inc.close_code,
108
                close_notes : inc.close_notes
109
            }
110
        };
111
​
112
        // Submit the message into Unifi
113
        poll_helper.processInbound({
114
            payload : JSON.stringify(payload)
115
        });
116
​
117
        // Save the current incident as the previous incident for the next poll
118
        bond.setDataObject('previous_inc',inc);
119
​
120
        // Update last update time (if later)
121
        var conn_time = conn.getData('last_update_time');
122
        if ( inc_time > conn_time ) {
123
            conn.setData('last_update_time',inc_time);
124
        }
125
​
126
    }
127
​
128
    // Process each result
129
    body.result.forEach(function(inc){
130
        process_incident(inc);
131
    });
132
​
133
    poll_request.response_status = info.join('\n') + '\n\n' + JSON.stringify(body,null,2);
134
​
135
})(poll_request, poller, response, params);
Copied!
Response script: This script parses the response into a body object to contain the result, (returning if it doesn't contain anything).
It then sets up some objects to help us; these include the essential PollHelper() function (which we initialise from the poll_request) along with two other functions: get_bond() to find the Bond for an Incident & get_message_name() to work out the message type to send to Unifi based upon the change of state.
After that it loops through each of the returned tickets. For each ticket, it logs the incident number & time, finds the bond & returns any previous data stored on the bond, decides which Message to use, sets up a payload object and submits it to Unifi by calling the processInbound() method. It then saves the current incident as the previous incident for the next poll & checks whether the ticket was updated later than the last update time; if so, it sets and stores the last update time as that 'sys_updated_on' value (this 'last_update_time' is what the Setup script checks against when defining what the Poll will do).
After looping through all the records (processing each result), the results are logged to the Response status field of the Poll Request.
Essential code: the following lines of code must be included in the response script to enable Unifi
1
var poll_helper = new x_snd_eb.PollHelper(poll_request);
Copied!
1
poll_helper.processInbound({
2
            payload : JSON.stringify(payload)
3
        });
Copied!
processInbound(): Having the 'poll_helper.processInbound()' function inside the loop means that an update message will be generated for each updated ticket.
Payload object: We have chosen to structure the payload object (var payload) as we have. There is no obligation to keep the same structure. Yours can be defined to suit your requirements.
Message name: Unifi needs to know the message name in order to know how to process the inbound request. We can either set it in the payload (as we have), or declare a variable that sets it which is passed into the processInbound() function along with the payload. (Unifi will always check processInbound() first. If no Message name is set here it will use the 'Identify message script' on the Integration).
Your Response Script form should look like this:
Save the Poll Processor.
Now let's move on and configure the Poller.
Polling
Poller
Last modified 7mo ago
Export as PDF
Copy link
Contents