Web Services After Operation Rule

The After Operation Rule is used to calculate attributes after a web service operation call.

It is used by the Web Services connector to update parsed resource objects and save connectorStateMap values. Create List of Objects converts to Resource objects and the connectorStateMap values are updated in the application object permanently. The returned map holds data keys for the resource object list and the connectorStateMap key for updated attributes that must be saved in the application.

Input Objects

Objects	Type	Description
application	`sailpoint.object.Application`	Application whose data file is being processed.
requestEndPoint	`sailpoint.connector.webservices. EndPoint`	Current request information. It contains the header, body, context URL, method type, response attribute map, successful response code.
processedResponseObject	`List<Map<String, Object>>`	This object is List of Map (account/group). The map contains key as identityAttribute of the application schema and value is all the account/group attributes (schema) passed by the connector after parsing the respective API response.
rawResponseObject	String	String object which holds the raw response returned from the target system which can be in JSON or XML form.
restClient	`sailpoint.connector.webservices. WebServicesClient`	A Web Services Client (HTTP Client) object that enables you to call the Web Services API target system.

Return Objects

Examples for After Operation Rules

The following example displays the After Operation Rule used to update accounts, groups, and application attribute values after execution of the endpoint:

Copy

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Iterator;

//We can parse the response(rawResponseObject) to fetch from the respective executed Endpoint operation.
Map updatedMapInfo = new HashMap();
if (processedResponseObject != null){
 
    for (Map iterateMap : processedResponseObject) {
        if (iterateMap != null ) {
            Set keySet = iterateMap.keySet();
            for (String s : keySet) {
                if (s.equals("given_name")) {
            String forStr = (String) iterateMap.get("given_name");
            forStr = "TEST"+ forStr;
                iterateMap.put("given_name", forStr);
        }
            }
        }
    }
updatedMapInfo.put("data", processedResponseObject);
}
Map connectorStateMap = new HashMap();
connectorStateMap.put("refresh_token","refreshTokenGeneratedInAfterRuleScript");
updatedInfoMap.put("connectorStateMap",connectorStateMap);
return updatedMapInfo;

The following example displays the After Operation Rule being used by the Web Services connector to update the resource object:

Copy

<![CDATA[
    import connector.common.JsonUtil;
    import java.util.HashMap;
    import java.util.Map.Entry;
    import java.util.Map;
    import java.util.List;
    import java.util.ArrayList;
    import javax.net.ssl.HttpsURLConnection;
    import java.io.BufferedReader;
    import java.io.PrintStream;
    import java.io.StringWriter;
    import java.text.SimpleDateFormat;
    import sailpoint.tools.GeneralException;

Map updatedMapInfo = new HashMap();
List list = new ArrayList();
ArrayList<String> Roles = new ArrayList<String>();
Map response = (Map) JsonUtil.toMap(rawResponseObject);
int RoleSize = 0;
String newName;
List Finallist = new ArrayList();
List workspace = new ArrayList();

log.error("RULEWS response at start" + response);
if (response.get("data") != null) {

    list = (ArrayList) response.get("data");

    for(int d = 0; d < list.size(); d++ ){

            Map responseMap = (Map) list.get(d);

            if (responseMap.get("attributes") != null) {
                Map newmap = new HashMap();
                Map data = (Map) responseMap.get("attributes");
                newmap.put("firstName", data.get("firstName"));
                newmap.put("lastName",data.get("lastName"));
                newmap.put("displayName",data.get("displayName"));
                newmap.put("userName",data.get("userName"));
                newmap.put("email",data.get("email"));

            if (data.get("workspaceMemberships") != null) {
                ArrayList Workspacedetail = (ArrayList) data.get("workspaceMemberships");
                for (int i = 0; i < Workspacedetail.size(); i++) {
                    Map work = (Map) Workspacedetail.get(i);
                    for (int w = 0; w < work.size(); w++) {
                        if (work.get("workspaceName") != null) {
                            workspace.add(work.get("workspaceName"));
                                Roles = (ArrayList) work.get("workspaceRoles");
                                for (int r = 0; r < Roles.size(); r++) {
                                    if (Roles.get(r) != null) {
                                        newName = Roles.get(r).toString() + " - " + work.get("workspaceName");
                                        if(newName != null) {
                                            Roles.set(r, newName);
                                            newmap.put("workspaceRoles", Roles);
                                        }
                                    }
                                }
                        }
                        break;
                    }
                }
            }

            Finallist.add(newmap);

        }
    }

}
log.error("RULEWS newmap at end" + newmap);
log.error("RULEWS Finallist at end" + Finallist);

log.error("RULEWS processedResponseObject Before is " + processedResponseObject);

updatedMapInfo.put("data", Finallist);
log.error("RULEWS updatedMapInfo is " + updatedMapInfo);

return updatedMapInfo;
log.error("RULEWS processedResponseObject after is " + processedResponseObject);

]]


	You are here: