Web Services Before/After Operation Rule

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import connector.common.JsonUtil;
import connector.common.Util;
import sailpoint.connector.webservices.EndPoint;
import sailpoint.connector.webservices.WebServicesClient;
import sailpoint.object.Application;
import sailpoint.object.ProvisioningPlan;
import sailpoint.object.ProvisioningPlan.AccountRequest;

    Map body = requestEndPoint.getBody();
    String jsonBody = (String) body.get("jsonBody");
    log.info("Rule - Modify Body: running");

    try {

        Map jsonMap = JsonUtil.toMap(jsonBody);
        if (jsonMap != null) {
            Object roleEntry = jsonMap.get("webSiteAndRole");
            String role = "";
            if (roleEntry != null && roleEntry instanceof ArrayList) {
                ArrayList rolesArray = (ArrayList) roleEntry;
                if (rolesArray.size() > 0) {
                    role = (String) rolesArray.get(0);
                }
            } else if (roleEntry != null) {
                role = (String) roleEntry;
            }

            jsonMap.remove("webSiteAndRole");
            jsonMap.put("webSiteAndRole", role);

            log.info("Rule - Modify Body: setting webSiteAndRole = " + role);
            String webID = "";
            if (provisioningPlan != null) {
                log.info("Rule - Modify Body: plan is not null");
                for (AccountRequest accReq : Util.iterate(provisioningPlan.getAccountRequests())) {
                    log.info("Rule - Modify Body: iterating over account requests");
                    for (ProvisioningPlan.AttributeRequest attReq : Util.iterate(accReq.getAttributeRequests())) {
                        log.info("Rule - Modify Body: iterating over attribute requests");
                        String attrName = attReq.getName();
                        String value = null;
                        if (attrName != null && "webId".equalsIgnoreCase(attrName)) {
                            webID = (String) attReq.getValue();
                            log.info("Rule - Modify Body: setting webID = " + webID);
                    }
                }
            }
        } else {
            log.info("Rule - Modify Body: plan is null");
        }

        if (!"".equals(webID)) {
            jsonMap.put("webID", webID);
        }

// Add in any other missing fields
        if (!jsonMap.containsKey("webLogonEmail")) {
            jsonMap.put("webLogonEmail", "");
        }

        if (!jsonMap.containsKey("taxID")) {
            jsonMap.put("taxID", "");
        }

        if (!jsonMap.containsKey("taxIdType")) {
            jsonMap.put("taxIdType", "");
        }

        if (!jsonMap.containsKey("actorLogonId")) {
            jsonMap.put("actorLogonId", "");
        }

        String finalBody = JsonUtil.render(jsonMap);
        body.put("jsonBody", finalBody);
        requestEndPoint.setBody(body);
    }
} catch (Exception ex) {
    log.error("Rule - Modify Body: " + ex);
}

return requestEndPoint;

import connector.common.JsonUtil;
import sailpoint.connector.webservices.WebServicesClient;
    try {
        WebServicesClient client = new WebServicesClient();
        String url = "http://hostname:portnumber/RestFormDataWS/beforeRuleMock";
        Map args = new HashMap();
        args.put(WebServicesClient.ARG_URL, url);
        client.configure(args);
        Map header = new HashMap();
        // Information can be fetched from requestEndpoint and updated in the header and body
        header.put("Authorization","XXXX XXXX");
        header.put("Content-Type","application/json");

        List<String> allowedStatuses = new ArrayList();
        allowedStatuses.add("2**");

        Map payload = new HashMap();
        payload.put("jsonBody","{\"user\":{\"userId\":\"RinkuSharma\",\"firstName\":\"Rinku\",\"lastName\":\"Sharma\",\"title\":\"manager\"}}");

        String response = client.executePost(url, payload, header, allowedStatuses);
        // if response contains token it can be updated in the requestEndpoint header or body
        // the requestEndpoint will be used for execution of the particular operation configured
        log.info("response: " + response);
    } catch (Exception e) {
        log.error(e.getMessage(), e);
    }

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;

<![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);

]]