REST Connector

// The user to create. The Groovy binding "ACCOUNT" contains the IDM object attributes mapped to the user's attributes
def user = [
        uid: ACCOUNT.uid,
        givenName: ACCOUNT.givenName,
        surname: ACCOUNT.surname,
        email: ACCOUNT.email,
        birthDate: ACCOUNT.birthDate
]

// The remote application expects the user's attributes to be located under the root "data" JSON key
REST.post('/') { json([data : user]) }

// Add the user to groups
ACCOUNT.groups?.each {
    REST.post('/' + user.uid + '/~groups/' + it)
}

// By convention the user's unique id must be returned upon the user creation
ACCOUNT.uid

  <connectorProperty>
      <name>filePath</name>
      <value>/csv/test.csv</value>
  </connectorProperty>

    /**
     * Force the subject of an authentication request, overriding global settings of the REST Connector's authentication
     * configuration.
     * <p>
     * This is namely useful to access Google's delegate APIs, where requests must be performed on behalf of a subject.
     *
     * @param subject set in the authentication request sent to the remote REST application
     */
    RestConnectorRequestBuilder authSubject(String subject);

REST.get('https://gmail.googleapis.com/gmail/v1/users/' + ACCOUNT.email + '/settings/delegates/{delegateEmail}') { authSubject(ACCOUNT.email) }

/**
 * Enable to keep track of the paged search state between consecutive search iterations.
 */
class PageRequest {

    /**
     * The page index, starting with 0, incremented by 1 at each search iteration.
     */
    private final int index;

    /**
     * An offset indicating how many elements have been retrieved so far, it is an accumulation of the search iterations.
     */
    private final int offset;

    /**
     * An alternative to {@link #index}: an opaque token returned by the REST application enabling the application to
     * keep state information between consecutive paged searches. It must be sent back to the application when searching
     * the next page.
     */
    private final Object pagingToken;
}

/**
 * The result of a paged search.
 */
class PageResponse {
    /**
     * Return the page content, indicating that the search is complete.
     *
     * @param content a page of remote objects
     * @return the page result
     */
    public static PageResult complete(List<?> content);

    /**
     * Return the page content, indicating that the search is not complete; there are some entries left.
     *
     * @param content a page of remote objects
     * @return the page result
     */
    public static PageResult partial(List<?> content);

    /**
     * Return the page content, indicating that the search is not complete; there are some entries left.
     *
     * @param content a page of remote objects
     * @param pagingToken an opaque token returned by the application to keep track of the search progress,
     *                    to be sent in the next page request
     * @return the page result
     * @see PageRequest#getPagingToken()
     */
    public static PageResult partial(List content, Object pagingToken);
    }
}

def pagingToken = PAGE.pagingToken as String 

def response as Response 

if (pagingToken) { 
    response = <send search request with paging token> 
} else { 
    // Very first page request 
    response = <send search request without paging token> 
} 

def accounts = <extract entries from response> 
def newPagingToken = <extract token from response> 

if (newPagingToken) { 
    // The search is not over, there are some entries left 
    return PageResult.partial(accounts, newPagingToken) 
} else { 
    return PageResult.complete(accounts) 
}

REST.get(ACCOUNT_ID) {
    onStatusCode 404, { throw new RestConnectorException('Cannot find account with id: ' + ACCOUNT_ID) }
}

REST.get(ACCOUNT_ID) {
    onStatusCode 404, { throw new RestConnectorException('Cannot find account with id: ' + ACCOUNT_ID, "ui.errors.connectors.rest.accountNotFound.msg")
                                .putI18nArg('account_id', ACCOUNT_ID) 
                      }
}

// The Groovy binding "ACCOUNT_ID" contains the id of the Person to fetch
REST.get(ACCOUNT_ID) {
    onStatusCode 404, {/* do something about the error */ }
}.json

// The Groovy binding "SEARCH_PARAMS" contains the search criteria provided by Synchronzation's (service) SimpleLookupStrategyDefault
// A single person is searched
def accountId = SEARCH_PARAMS.uid as String
LOG.debug('About to search single account with id {}', accountId)
REST.get(accountId).json

// In this example the pagination token expected by the remote application is a Map structured as {"index": index} where index is an int
// For another application it could be a simple string holding some kind of "state cookie"
def pagingToken = PAGE.pagingToken as Map<String, Integer>
def index = pagingToken?.index ?: 0

List accounts = REST.get('?index=' + index + '&size=5').json as List

if (accounts.size() == 5) {
    // Generate the next paging token
    return PageResult.partial(accounts, ["index": index+1])
} else {
    // Search complete
    return PageResult.complete(accounts)
}

def index = PAGE.index ?: 0
def size = PAGE.size ?: 5

List accounts = REST.get('?index=' + index + '&size=' + size).json as List

if (accounts.size() == size) {
    return PageResult.partial(accounts)
} else {
    return PageResult.complete(accounts)
}

// The Person to create. The Groovy binding "OBJECT" contains the Person's attributes computed by Synchronzation service
def person = [
        uid: OBJECT.uid,
        givenName: OBJECT.givenName,
        surname: OBJECT.surname,
        birthDate: OBJECT.birthDate,
        address:OBJECT.address
]

// The remote application expects the Person's attributes to be located under the root "data" key
REST.post('/') { json([data : person]) }

// Add the person to groups
OBJECT.groups?.each {
    REST.post('/' + person.uid + '/~groups/' + it)
}

// By convention the Person's id must be returned upon the Person creation
OBJECT.uid

import com.memority.citadel.shared.api.im.operation.AttributeOperation
import com.memority.citadel.shared.api.im.operation.AttributePatch
import com.memority.domino.shared.api.AttributeDelta
import com.memority.toolkit.rest.client.groovy.api.Response

/*
    OBJECT_ID -> CORRELATION_KEY (email)
    OBJECT    -> Values from application.xml mapping
    PATCH     -> Modified attributes only
  */

LOG.debug('Provisioning - UPDATE - CORRELATION_KEY {}', OBJECT_ID)

List<Map> attributes = new ArrayList()

def updateUser = [
        "objectId"  : OBJECT_ID,
        "attributes": attributes
]


((Map<String, AttributeDelta>) PATCH).each {
    String attribute, AttributeDelta attributeDelta ->

        /*
        * Complete the attrDelta.operation and check its value
        * In if condition you will check if the operation is a DELETE
          */

        // -> Should be like this
        if (attrDelta.multiValuedState == AttributeDelta.MultiValuedState.MoNO){
          attributes.add([
                  "operation": attributeDelta.operation == AttributeOperation.DELETE ? "REMOVE" : "SET",
                  "id"       : attribute,
                  "values"   : attributeDelta.operation == AttributeOperation.DELETE ? [] : [attributeDelta.value]
          ])
        }else if (attrDelta.multiValuedState == AttributeDelta.MultiValuedState.MULTI) {
                  if (attrName == "group" && attrDelta.valuesToAdd()) {
                        (attrDelta.valuesToAdd() as List<String>).each { String value ->
                            def groupAdd = [
                                    "roleId"   : value,
                                    "groupMode": ["group"]
                            ]
                            def responsePatchGroup = REST.patch('api/v1/user/' + OBJECT_ID + '/role/') {
                                  header("Authorization: Bearer", bearerValue)
                                  header("Cookie", cookie)
                                  json(groupAdd)
                              }
                  }
        }                              
}

if (updateUser.attributes) {

    //Send PATCH Request
    def response = REST.patch('identity-internal-ws-update') { json(updateUser) } as Response

    if (response.statusCode != 200) {
        LOG.error('Provisioning - UPDATE - CORRELATION_KEY {} - Request Body {}', OBJECT_ID, toJson(updateUser))
        LOG.error('Provisioning - UPDATE - CORRELATION_KEY {} - Response Code {}', OBJECT_ID, response.statusCode)
        LOG.error('Provisioning - UPDATE - CORRELATION_KEY {} - Response Body {}', OBJECT_ID, toJson(response.json))
        LOG.audit('Provisioning - UPDATE - CORRELATION_KEY {} - Request Body {}', OBJECT_ID, toJson(updateUser))
        LOG.audit('Provisioning - UPDATE - CORRELATION_KEY {} - Response Code {}', OBJECT_ID, response.statusCode)
        LOG.audit('Provisioning - UPDATE - CORRELATION_KEY {} - Response Body {}', OBJECT_ID, toJson(response.json))
        throw new RestConnectorException("Provisioning - UPDATE - CORRELATION_KEY - ERROR")

    } else {
        LOG.debug('Provisioning - UPDATE - CORRELATION_KEY {} - Request Body {}', OBJECT_ID, toJson(updateUser))
        LOG.debug('Provisioning - UPDATE - CORRELATION_KEY {} - Response Code {}', OBJECT_ID, response.statusCode)
        LOG.debug('Provisioning - UPDATE - CORRELATION_KEY {} - Response Body {}', OBJECT_ID, toJson(response.json))
    }
}
                        

import com.memority.citadel.shared.api.im.ApiObject

// Remove the person from its groups. The Groovy binding "OBJECT_ID" contains the id of the Person to delete
OBJECT.groups?.each {
    REST.delete('/' + OBJECT_ID + '/~groups/' + it)
}

// Only to test the PARSER feature: retrieve the person to delete
def person = PARSER.parse(REST.get(OBJECT_ID).json) as ApiObject
LOG.info("Retrieved person to delete: {}", person.value("lastName"))

// Delete the person
REST.delete(OBJECT_ID)