Управление учетными записями из кадровых приказов 1C при помощи OpenIDM

    import groovyx.net.http.RESTClient
    import groovyx.net.http.StringHashMap
    import org.apache.http.HttpHost
    import org.apache.http.auth.AuthScope
    import org.apache.http.auth.UsernamePasswordCredentials
    import org.apache.http.client.ClientProtocolException
    import org.apache.http.client.CredentialsProvider
    import org.apache.http.client.HttpClient
    import org.apache.http.client.config.RequestConfig
    import org.apache.http.client.protocol.HttpClientContext
    import org.apache.http.conn.routing.HttpRoute
    import org.apache.http.impl.auth.BasicScheme
    import org.apache.http.impl.client.BasicAuthCache
    import org.apache.http.impl.client.BasicCookieStore
    import org.apache.http.impl.client.BasicCredentialsProvider
    import org.apache.http.impl.client.HttpClientBuilder
    import org.apache.http.impl.conn.PoolingHttpClientConnectionManager
    import org.forgerock.openicf.connectors.scriptedrest.ScriptedRESTConfiguration
    import org.forgerock.openicf.connectors.scriptedrest.ScriptedRESTConfiguration.AuthMethod
    import org.identityconnectors.common.security.GuardedString
    
    // must import groovyx.net.http.HTTPBuilder.RequestConfigDelegate
    import groovyx.net.http.HTTPBuilder.RequestConfigDelegate
    
    /**
     * A customizer script defines the custom closures to interact with the default implementation and customize it.
     */
    customize {
        init { HttpClientBuilder builder ->
    
            //SETUP: org.apache.http
            def c = delegate as ScriptedRESTConfiguration
    
            def httpHost = new HttpHost(c.serviceAddress?.host, c.serviceAddress?.port, c.serviceAddress?.scheme);
    
            PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
            // Increase max total connection to 200
            cm.setMaxTotal(200);
            // Increase default max connection per route to 20
            cm.setDefaultMaxPerRoute(20);
            // Increase max connections for httpHost to 50
            cm.setMaxPerRoute(new HttpRoute(httpHost), 50);
    
            builder.setConnectionManager(cm)
    
            // configure timeout on the entire client
            RequestConfig requestConfig = RequestConfig.custom().build();
            builder.setDefaultRequestConfig(requestConfig)
    
            if (c.proxyAddress != null) {
                builder.setProxy(new HttpHost(c.proxyAddress?.host, c.proxyAddress?.port, c.proxyAddress?.scheme));
            }
    
            switch (ScriptedRESTConfiguration.AuthMethod.valueOf(c.defaultAuthMethod)) {
                case ScriptedRESTConfiguration.AuthMethod.BASIC_PREEMPTIVE:
                case ScriptedRESTConfiguration.AuthMethod.BASIC:
                    // It's part of the http client spec to request the resource anonymously
                    // first and respond to the 401 with the Authorization header.
                    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    
                    c.password.access(
                            {
                                credentialsProvider.setCredentials(new AuthScope(httpHost.getHostName(), httpHost.getPort()),
                                        new UsernamePasswordCredentials(c.username, new String(it)));
                            } as GuardedString.Accessor
                    );
    
                    builder.setDefaultCredentialsProvider(credentialsProvider);
                    break;
                case ScriptedRESTConfiguration.AuthMethod.NONE:
                    break;
                default:
                    throw new IllegalArgumentException();
            }
    
            c.propertyBag.put(HttpClientContext.COOKIE_STORE, new BasicCookieStore());
        }
    
        /**
         * This Closure can customize the httpClient and the returning object is injected into the Script Binding.
         */
        decorate { HttpClient httpClient ->
    
            //SETUP: groovyx.net.http
    
            def c = delegate as ScriptedRESTConfiguration
    
            def authCache = null
            if (AuthMethod.valueOf(c.defaultAuthMethod).equals(AuthMethod.BASIC_PREEMPTIVE)){
                authCache = new BasicAuthCache();
                authCache.put(new HttpHost(c.serviceAddress?.host, c.serviceAddress?.port, c.serviceAddress?.scheme), new BasicScheme());
    
            }
    
            def cookieStore = c.propertyBag.get(HttpClientContext.COOKIE_STORE)
    
            RESTClient restClient = new InnerRESTClient(c.serviceAddress, c.defaultContentType, authCache, cookieStore)
    
            Map<Object, Object> defaultRequestHeaders = new StringHashMap<Object>();
            if (null != c.defaultRequestHeaders) {
                c.defaultRequestHeaders.each {
                    if (null != it) {                
                        def kv = it.split('=')
                        assert kv.size() == 2
                        defaultRequestHeaders.put(kv[0], kv[1])
                    }
                }
            }
    
            restClient.setClient(httpClient);
            restClient.setHeaders(defaultRequestHeaders)
    
            // Return with the decorated instance
            return restClient
        }
    
    }
    
    RequestConfigDelegate blank = null;
    
    class InnerRESTClient extends RESTClient {
    
        def authCache = null;
        def cookieStore = null;
    
        InnerRESTClient(Object defaultURI, Object defaultContentType, authCache, cookieStore) throws URISyntaxException {
            super(defaultURI, defaultContentType)
            this.authCache = authCache
            this.cookieStore = cookieStore
        }
    
        @Override
        protected Object doRequest(
                final RequestConfigDelegate delegate) throws ClientProtocolException, IOException {
    
            // Add AuthCache to the execution context
            if (null != authCache) {
                //do Preemptive Auth
                delegate.getContext().setAttribute(HttpClientContext.AUTH_CACHE, authCache);
            }
            // Add AuthCache to the execution context
            if (null != cookieStore) {
                //do Preemptive Auth
                delegate.getContext().setAttribute(HttpClientContext.COOKIE_STORE, cookieStore);
            }
            return super.doRequest(delegate)
        }
    }

    
    import groovyx.net.http.RESTClient
    import org.apache.http.client.HttpClient
    import org.forgerock.openicf.connectors.scriptedrest.ScriptedRESTConfiguration
    import org.forgerock.openicf.misc.scriptedcommon.OperationType
    import org.identityconnectors.common.logging.Log
    import org.identityconnectors.framework.common.objects.Attribute
    import org.identityconnectors.framework.common.objects.AttributeUtil
    import org.identityconnectors.framework.common.objects.Name
    import org.identityconnectors.framework.common.objects.ObjectClass
    import org.identityconnectors.framework.common.objects.OperationOptions
    import org.identityconnectors.framework.common.objects.SearchResult
    import org.identityconnectors.framework.common.objects.Uid
    import org.identityconnectors.framework.common.objects.filter.Filter
    
    import static groovyx.net.http.Method.GET
    
    // imports used for CREST based REST APIs
    import org.forgerock.openicf.misc.crest.CRESTFilterVisitor
    import org.forgerock.openicf.misc.crest.VisitorParameter
    
    def operation = operation as OperationType
    def configuration = configuration as ScriptedRESTConfiguration
    def httpClient = connection as HttpClient
    def connection = customizedConnection as RESTClient
    def filter = filter as Filter
    def log = log as Log
    def objectClass = objectClass as ObjectClass
    def options = options as OperationOptions
    def resultHandler = handler
    
    log.info("Entering " + operation + " Script")
    
    def queryFilter = 'true'
    if (filter != null) {
        queryFilter = filter.accept(CRESTFilterVisitor.VISITOR, [
                translateName: { String name ->
                    if (AttributeUtil.namesEqual(name, Uid.NAME)) {
                        return "uid"
                    } else if (AttributeUtil.namesEqual(name, "name")) {
                        return "name"
                    } else if (AttributeUtil.namesEqual(name, "surname")) {
                        return "surname"
                    } else if (AttributeUtil.namesEqual(name, "patronymic")) {
                        return "patronymic"
                    } else {
                        throw new IllegalArgumentException("Unknown field name: ${name}");
                    }
                },
                convertValue : { Attribute value ->
                    if (AttributeUtil.namesEqual(value.name, "position")) {
                        return value.value
                    } else {
                        return AttributeUtil.getStringValue(value)
                    }
                }] as VisitorParameter).toString();
    }
    switch (objectClass) {
        case ObjectClass.ACCOUNT:
            def searchResult = connection.request(GET) { req ->
                uri.path = '/api/users'
                uri.query = [
                        _queryFilter: queryFilter
                ]
    
                response.success = { resp, json ->
                    json.each() { value ->
                        resultHandler {
                            uid value.uid
                            id value.uid
                            attribute 'surname', value?.surname
                            attribute 'name', value?.name
                            attribute 'patronymic', value?.patronymic
                            attribute 'position', value?.position
                        }
                    }
                    json
                }
            }
    
            return new SearchResult()
    
        case ObjectClass.GROUP:
            throw new IllegalArgumentException("Group sync is not supported");
    }
    

    
    import groovyx.net.http.RESTClient
    import org.apache.http.client.HttpClient
    import org.forgerock.openicf.connectors.scriptedrest.ScriptedRESTConfiguration
    import org.forgerock.openicf.misc.scriptedcommon.OperationType
    import org.identityconnectors.common.logging.Log
    import org.identityconnectors.framework.common.objects.ObjectClass
    import org.identityconnectors.framework.common.objects.SyncToken
    
    import static groovyx.net.http.Method.GET
    
    def operation = operation as OperationType
    def configuration = configuration as ScriptedRESTConfiguration
    def httpClient = connection as HttpClient
    def connection = customizedConnection as RESTClient
    def log = log as Log
    def objectClass = objectClass as ObjectClass
    
    log.info("Entering " + operation + " Script");
    
    if (OperationType.GET_LATEST_SYNC_TOKEN.equals(operation)) {
    
        return connection.request(GET) { req ->
            uri.path = '/api/orders'
            uri.query = [
                    getLatest: 'true',
            ]
    
            response.success = { resp, json ->
                def lastToken = 0l
                json.each() { it ->
                    lastToken = it.date
                }
                return new SyncToken(lastToken)
            }
    
            response.failure = { resp, json ->
                throw new ConnectException(json.message)
            }
        }
    
    } else if (OperationType.SYNC.equals(operation)) {
        def token = token as Object
        log.info("Entering SYNC");
        switch (objectClass) {
            case ObjectClass.ACCOUNT:
                return connection.request(GET) { req ->
                    uri.path = '/api/orders'
                    uri.query = [
                            date: "${token}",
                    ]
    
                    response.success = { resp, json ->
                        def lastToken = 0l
                        json.each() { changeLogEntry ->
                            lastToken = changeLogEntry.date
    
                            def user = {
                                uid changeLogEntry.user.uid
                                id changeLogEntry.user.uid
                                attribute 'name', changeLogEntry.user.name
                                attribute 'surname', changeLogEntry.user.surname
                                attribute 'patronymic', changeLogEntry.user.patronymic
                                attribute 'position', changeLogEntry.newPosition?.name
                            }
    
                            handler({
                                syncToken lastToken
                                if ("hire".equals(changeLogEntry.type)) {
                                    CREATE()
                                    object user
                                } else if ("transfer".equals(changeLogEntry.type)) {
                                    CREATE_OR_UPDATE()
                                    object user
                                } else if ("fire".equals(changeLogEntry.type)) {
                                    DELETE()
                                    object {
                                        uid changeLogEntry.user.uid
                                        id changeLogEntry.user.uid
                                        delegate.objectClass(objectClass)
                                    }
                                    return
                                } else {
                                    CREATE_OR_UPDATE()
                                    object user
                                }
                            })
                        }
                        return new SyncToken(lastToken)
                    }
    
                    response.failure = { resp, json ->
                        throw new ConnectException(json.message)
                    }
                }
                break;
    
            case ObjectClass.GROUP:
                throw new IllegalArgumentException("Group sync is not supported");
                break;
        }
    
    } else { // action not implemented
        log.error("Sync script: action '" + operation + "' is not implemented in this script");
    }