Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  com.adobe.granite.crypto.CryptoException
 *  com.adobe.granite.crypto.CryptoSupport
 *  javax.jcr.Node
 *  javax.jcr.RepositoryException
 *  javax.jcr.Session
 *  org.apache.felix.scr.annotations.Activate
 *  org.apache.felix.scr.annotations.Component
 *  org.apache.felix.scr.annotations.Deactivate
 *  org.apache.felix.scr.annotations.Property
 *  org.apache.felix.scr.annotations.Reference
 *  org.apache.felix.scr.annotations.Service
 *  org.apache.http.HttpEntity
 *  org.apache.http.HttpException
 *  org.apache.http.NameValuePair
 *  org.apache.http.client.entity.UrlEncodedFormEntity
 *  org.apache.http.client.methods.HttpGet
 *  org.apache.http.client.methods.HttpPost
 *  org.apache.http.client.methods.HttpRequestBase
 *  org.apache.http.client.utils.URIBuilder
 *  org.apache.http.entity.ByteArrayEntity
 *  org.apache.http.entity.ContentType
 *  org.apache.http.message.BasicNameValuePair
 *  org.apache.http.osgi.services.HttpClientBuilderFactory
 *  org.apache.sling.commons.json.JSONArray
 *  org.apache.sling.commons.json.JSONException
 *  org.apache.sling.commons.json.JSONObject
 *  org.apache.sling.commons.osgi.PropertiesUtil
 *  org.osgi.service.component.ComponentContext
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.adobe.cq.aam.client;

import com.adobe.cq.aam.client.AudienceManagerFolderList;
import com.adobe.cq.aam.client.AudienceManagerItemImpl;
import com.adobe.cq.aam.client.JSONOAuthHttpClient;
import com.adobe.cq.aam.client.MemoryCookieStore;
import com.adobe.cq.aam.client.OAuthResponseImpl;
import com.adobe.cq.aam.client.PagedHttpIterator;
import com.adobe.cq.aam.client.TestData;
import com.adobe.cq.aam.client.spi.AudienceManagerAccessDenied;
import com.adobe.cq.aam.client.spi.AudienceManagerClient;
import com.adobe.cq.aam.client.spi.AudienceManagerConfiguration;
import com.adobe.cq.aam.client.spi.AudienceManagerFolder;
import com.adobe.cq.aam.client.spi.AudienceManagerFolders;
import com.adobe.cq.aam.client.spi.AudienceManagerItem;
import com.adobe.cq.aam.client.spi.HCCookieStore;
import com.adobe.cq.aam.client.spi.OAuthResponse;
import com.adobe.cq.aam.client.spi.SegmentService;
import com.adobe.cq.aam.client.spi.SyncResult;
import com.adobe.cq.aam.client.spi.TraitsService;
import com.adobe.granite.crypto.CryptoException;
import com.adobe.granite.crypto.CryptoSupport;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLEncoder;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Property;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.http.HttpEntity;
import org.apache.http.HttpException;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.ContentType;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.osgi.services.HttpClientBuilderFactory;
import org.apache.sling.commons.json.JSONArray;
import org.apache.sling.commons.json.JSONException;
import org.apache.sling.commons.json.JSONObject;
import org.apache.sling.commons.osgi.PropertiesUtil;
import org.osgi.service.component.ComponentContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component(immediate=1, metatype=1)
@Service(value={AudienceManagerClient.class})
public class AudienceManagerClientImpl
implements AudienceManagerClient {
    private static final int DEFAULT_POST_BATCH_SIZE = 10;
    private static final String DEFAULT_DEMDEX_API_ENDPOINT = "https://api.demdex.com/v1";
    private static final String FOLDERS_SEGMENTS_ENDPOINT = "/folders/segments/";
    private static final String FOLDERS_TRAITS_ENDPOINT = "/folders/traits/";
    private static final String DESTINATIONS_ENDPOINT = "/destinations/";
    private static final String BULK_CREATE_ENDPOINT = "/bulk-create";
    private static final String SEGMENTS_ENDPOINT = "/segments/";
    private static final String TRAITS_ENDPOINT = "/traits/";
    private static final String MAPPINGS_PAGE = "/mappings?page=";
    private static final String DEFAULT_DEMDEX_OAUTH_TOKEN_ENDPOINT = "https://api.demdex.com/oauth/token";
    private static final String BULK_DELETE_ENDPOINT = "/bulk-delete/";
    private static final String DEFAULT_DEMDEX_EVENT_ENDPOINT = "https://{0}.demdex.net/event";
    private static final String DEFAULT_CLIENT_ID = "clientid";
    private static final String DEFAULT_CLIENT_SECRET = "clientsecret";
    @Property(value={"https://api.demdex.com/oauth/token"})
    private static final String TOKEN_ENDPOINT = "endpoint.token";
    @Property(value={"https://api.demdex.com/v1"})
    private static final String API_ENDPOINT = "endpoint.api";
    @Property(value={"https://{0}.demdex.net/event"})
    private static final String EVENT_ENDPOINT = "endpoint.event";
    @Property(intValue={10})
    private static final String BATCH_SIZE = "batchsize";
    @Property(value={"clientid"})
    private static final String CLIENT_ID = "clientid";
    @Property(value={"clientsecret"})
    private static final String CLIENT_SECRET = "clientsecret";
    private static final String ERROR_PARTNER_OR_CONTAINERID_INVALID = "partner_invalid";
    private static final String ERROR_CLIENT_NOT_CONFIGURED = "client_not_configured";
    private static final Logger LOGGER = LoggerFactory.getLogger(AudienceManagerClientImpl.class);
    private static final long DAY_IN_MS = 86400000;
    private JSONOAuthHttpClient httpClient;
    private String tokenEndpoint;
    private String clientId;
    private String clientSecret;
    private String apiEndpoint;
    private String eventEndpoint;
    @Reference
    private CryptoSupport cryptoSupport;
    @Reference
    private TraitsService traitsService;
    @Reference
    private SegmentService segmentService;
    @Reference
    private HttpClientBuilderFactory httpClientBuilderFactory;
    private int maxBatchSize;
    private MethodFactory methodFactory;
    private boolean partnerCheckingEnabled;

    public AudienceManagerClientImpl() {
        this.methodFactory = new MethodFactory(){

            @Override
            public HttpPost getPostMethod(String url) {
                return new HttpPost(url);
            }

            @Override
            public HttpGet getGetMethod(String url) {
                return new HttpGet(url);
            }
        };
        this.partnerCheckingEnabled = false;
    }

    @Activate
    public void activate(ComponentContext componentContext) {
        this.httpClient = new JSONOAuthHttpClient(this.httpClientBuilderFactory, new MethodFactory(){

            @Override
            public HttpPost getPostMethod(String url) {
                return AudienceManagerClientImpl.this.methodFactory.getPostMethod(url);
            }

            @Override
            public HttpGet getGetMethod(String url) {
                return AudienceManagerClientImpl.this.methodFactory.getGetMethod(url);
            }
        });
        Dictionary properties = componentContext.getProperties();
        this.apiEndpoint = PropertiesUtil.toString(properties.get("endpoint.api"), (String)"https://api.demdex.com/v1");
        this.eventEndpoint = PropertiesUtil.toString(properties.get("endpoint.event"), (String)"https://{0}.demdex.net/event");
        this.tokenEndpoint = PropertiesUtil.toString(properties.get("endpoint.token"), (String)"https://api.demdex.com/oauth/token");
        this.clientId = PropertiesUtil.toString(properties.get("clientid"), (String)"clientid");
        this.clientSecret = PropertiesUtil.toString(properties.get("clientsecret"), (String)"clientsecret");
        this.maxBatchSize = PropertiesUtil.toInteger(properties.get("batchsize"), (int)10);
    }

    @Deactivate
    public void deactivate(ComponentContext componentContext) {
        this.httpClient = null;
    }

    @Override
    public OAuthResponse authenticate(String username, String password) throws AudienceManagerAccessDenied {
        return this.authenticate(username, password, new HashMap<String, Object>());
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    @Override
    public OAuthResponse authenticate(String username, String password, Map<String, Object> properties) throws AudienceManagerAccessDenied {
        try {
            OAuthResponseImpl oauthResponse;
            block10 : {
                if ("clientid".equals(this.clientId) || "clientsecret".equals(this.clientSecret)) {
                    return new OAuthResponseImpl("client_not_configured");
                }
                HttpPost postMethod = this.methodFactory.getPostMethod(this.tokenEndpoint);
                oauthResponse = new OAuthResponseImpl(this.clientId, this.clientSecret);
                postMethod.addHeader("Content-Type", "application/x-www-form-urlencoded");
                postMethod.addHeader("Authorization", oauthResponse.getBasicAuth());
                postMethod.addHeader("Accept", "application/json");
                ArrayList<BasicNameValuePair> nvps = new ArrayList<BasicNameValuePair>();
                nvps.add(new BasicNameValuePair("grant_type", "password"));
                nvps.add(new BasicNameValuePair("username", username));
                nvps.add(new BasicNameValuePair("password", password));
                postMethod.setEntity((HttpEntity)new UrlEncodedFormEntity(nvps));
                oauthResponse.update(this.httpClient.executeJSONObject((HttpRequestBase)postMethod, 200, JSONObject.class), this.cryptoSupport);
                if (this.partnerCheckingEnabled && properties.containsKey("partner")) {
                    String testDestination = "VerifyPartner_" + System.currentTimeMillis();
                    LOGGER.debug("Create Destination");
                    long destinationId = this.createDestination(testDestination, ".cqclientintegration.adobe.com", "Temporary Partner Validation Distribution, should be deleted automatically, if not feel free to delete", oauthResponse);
                    LOGGER.debug("Created Destination {} ({})", (Object)testDestination, (Object)destinationId);
                    try {
                        String partner = (String)properties.get("partner");
                        String containerID = (String)properties.get("container");
                        LOGGER.debug("Getting DCS response for {} {} ", (Object)partner, (Object)containerID);
                        ArrayList<String[]> signals = new ArrayList<String[]>();
                        signals.add(new String[]{"c_verify", "CQ5Verification"});
                        JSONObject response = this.getDCSResponse(partner, containerID, signals);
                        if (!this.traitsService.containsDestination(response, testDestination, ".cqclientintegration.adobe.com")) {
                            LOGGER.debug("Partner Not associated with credentials ");
                            oauthResponse.setErrorStatus("partner_invalid");
                            break block10;
                        }
                        LOGGER.debug("Partner Was associated with credentials ");
                    }
                    finally {
                        LOGGER.debug("Delete Destingation {}  ", (Object)destinationId);
                        this.deleteDestination(destinationId, oauthResponse);
                        LOGGER.debug("Delete Destingation {} Done ", (Object)destinationId);
                    }
                }
            }
            LOGGER.debug("Done Authentication");
            return oauthResponse;
        }
        catch (IOException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (JSONException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (CryptoException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        return null;
    }

    public OAuthResponse refresh(OAuthResponse response) throws AudienceManagerAccessDenied {
        OAuthResponseImpl oauthResponse = (OAuthResponseImpl)response;
        String refreshToken = oauthResponse.getRefreshToken();
        if (refreshToken == null) {
            throw new IllegalStateException("Unable to refresh as no refresh token was supplied in the original response");
        }
        try {
            LOGGER.debug("Refreshing Oauth Access Token");
            HttpPost postMethod = this.methodFactory.getPostMethod("https://api.demdex.com/oauth/token");
            postMethod.addHeader("Content-Type", "application/x-www-form-urlencoded");
            postMethod.addHeader("Authorization", oauthResponse.getBasicAuth());
            LOGGER.debug("Refresh Token is {} ", (Object)oauthResponse.getRefreshToken());
            postMethod.addHeader("Accept", "application/json");
            ArrayList<BasicNameValuePair> nvps = new ArrayList<BasicNameValuePair>();
            nvps.add(new BasicNameValuePair("grant_type", "refresh_token"));
            nvps.add(new BasicNameValuePair("refresh_token", oauthResponse.getRefreshToken()));
            postMethod.setEntity((HttpEntity)new UrlEncodedFormEntity(nvps));
            LOGGER.debug("Refresh Token is {} ", (Object)oauthResponse.getRefreshToken());
            oauthResponse.update(this.httpClient.executeJSONObject((HttpRequestBase)postMethod, 200, JSONObject.class), this.cryptoSupport);
            return oauthResponse;
        }
        catch (IOException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (JSONException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (CryptoException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (AudienceManagerAccessDenied e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
            throw e;
        }
        return null;
    }

    public void checkAccess(OAuthResponseImpl oAuthResponseImpl) throws CryptoException, RepositoryException, AudienceManagerAccessDenied, IOException {
        HttpGet getMethod = this.httpClient.prepareMethod(oAuthResponseImpl, this.methodFactory.getGetMethod(this.apiEndpoint + "/traits/" + "?search=testing"));
        this.httpClient.executeJSONObject((HttpRequestBase)getMethod, 200, JSONArray.class);
    }

    @Override
    public boolean isValidForUse(AudienceManagerConfiguration config) {
        try {
            OAuthResponseImpl oauth = new OAuthResponseImpl(config.getNode(), this.clientId, this.clientSecret, this.cryptoSupport);
            if (oauth.hasExpired() && oauth.getRefreshToken() == null) {
                LOGGER.debug("Invalid Config: Has expired {} ", (Object)oauth.hasExpired());
                LOGGER.debug("Invalid Config: Access Token {} ", (Object)oauth.getAccessToken());
                LOGGER.debug("Invalid Config: Refresh Token {} ", (Object)oauth.getRefreshToken());
                return false;
            }
            return true;
        }
        catch (Exception e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
            return false;
        }
    }

    @Override
    public AudienceManagerFolders getSegmentFolders(AudienceManagerConfiguration config, boolean autoSave) throws AudienceManagerAccessDenied {
        return this.getFolders(config, this.apiEndpoint + "/folders/segments/" + "?expand=true", autoSave);
    }

    @Override
    public AudienceManagerFolders getTraitFolders(AudienceManagerConfiguration config, boolean autoSave) throws AudienceManagerAccessDenied {
        return this.getFolders(config, this.apiEndpoint + "/folders/traits/" + "?expand=true", autoSave);
    }

    @Override
    public Iterable<AudienceManagerItem> getSegments(final AudienceManagerConfiguration config, final AudienceManagerFolders folders, final boolean autoSave) {
        return new Iterable<AudienceManagerItem>(){

            @Override
            public Iterator<AudienceManagerItem> iterator() {
                String offlineTestSuite = null;
                if (config.isOfflineTest()) {
                    offlineTestSuite = config.getOfflineTestSet();
                }
                return new PagedHttpIterator<AudienceManagerItem>(offlineTestSuite){

                    @Override
                    protected AudienceManagerItem getElement(JSONObject jsonObject) throws JSONException {
                        return new AudienceManagerItemImpl(jsonObject, folders, config.getTemplate());
                    }

                    @Override
                    protected JSONObject getJSONPageObject(int page) throws CryptoException, IOException, RepositoryException, AudienceManagerAccessDenied {
                        try {
                            return AudienceManagerClientImpl.this.httpClient.executeJSONObject(AudienceManagerClientImpl.this.prepareOAuthMethodFromConfig(config.getNode(), (T)((HttpRequestBase)AudienceManagerClientImpl.this.methodFactory.getGetMethod(AudienceManagerClientImpl.this.apiEndpoint + "/segments/" + "?page=" + page)), autoSave), 200, JSONObject.class);
                        }
                        catch (AudienceManagerAccessDenied e) {
                            AudienceManagerClientImpl.this.refreshAccessToken(config.getNode(), autoSave);
                            return AudienceManagerClientImpl.this.httpClient.executeJSONObject(AudienceManagerClientImpl.this.prepareOAuthMethodFromConfig(config.getNode(), (T)((HttpRequestBase)AudienceManagerClientImpl.this.methodFactory.getGetMethod(AudienceManagerClientImpl.this.apiEndpoint + "/segments/" + "?page=" + page)), autoSave), 200, JSONObject.class);
                        }
                    }
                };
            }

        };
    }

    @Override
    public Iterable<AudienceManagerItem> getTraits(final AudienceManagerConfiguration config, final AudienceManagerFolders folders, final boolean autoSave) {
        return new Iterable<AudienceManagerItem>(){

            @Override
            public Iterator<AudienceManagerItem> iterator() {
                String offlineTestSuite = null;
                if (config.isOfflineTest()) {
                    offlineTestSuite = config.getOfflineTestSet();
                }
                return new PagedHttpIterator<AudienceManagerItem>(offlineTestSuite){

                    @Override
                    protected AudienceManagerItem getElement(JSONObject jsonObject) throws JSONException {
                        return new AudienceManagerItemImpl(jsonObject, folders, config.getTemplate());
                    }

                    @Override
                    protected JSONObject getJSONPageObject(int page) throws CryptoException, IOException, RepositoryException, AudienceManagerAccessDenied {
                        try {
                            return AudienceManagerClientImpl.this.httpClient.executeJSONObject(AudienceManagerClientImpl.this.prepareOAuthMethodFromConfig(config.getNode(), (T)((HttpRequestBase)AudienceManagerClientImpl.this.methodFactory.getGetMethod(AudienceManagerClientImpl.this.apiEndpoint + "/traits/" + "?page=" + page)), autoSave), 200, JSONObject.class);
                        }
                        catch (AudienceManagerAccessDenied e) {
                            AudienceManagerClientImpl.this.refreshAccessToken(config.getNode(), autoSave);
                            return AudienceManagerClientImpl.this.httpClient.executeJSONObject(AudienceManagerClientImpl.this.prepareOAuthMethodFromConfig(config.getNode(), (T)((HttpRequestBase)AudienceManagerClientImpl.this.methodFactory.getGetMethod(AudienceManagerClientImpl.this.apiEndpoint + "/traits/" + "?page=" + page)), autoSave), 200, JSONObject.class);
                        }
                    }
                };
            }

        };
    }

    @Override
    public Iterable<AudienceManagerItem> getTraits(AudienceManagerConfiguration config, AudienceManagerFolders folders, String[] ids, String search, boolean autoSave) throws AudienceManagerAccessDenied {
        ArrayList<AudienceManagerItem> audienceManagerItems = new ArrayList<AudienceManagerItem>();
        try {
            Node configNode = config.getNode();
            if (search != null && search.trim().length() > 0) {
                HttpGet getMethod = this.prepareOAuthMethodFromConfig(configNode, (T)this.methodFactory.getGetMethod(this.apiEndpoint + "/traits/" + "?search=" + URLEncoder.encode(search, "UTF-8")), autoSave);
                JSONArray result = this.httpClient.executeJSONObject((HttpRequestBase)getMethod, 200, JSONArray.class);
                for (int i = 0; i < result.length(); ++i) {
                    audienceManagerItems.add(new AudienceManagerItemImpl(result.getJSONObject(i), folders, ""));
                }
            } else {
                for (String traitID : ids) {
                    long safeTraitID = Long.parseLong(traitID);
                    HttpGet getMethod = this.prepareOAuthMethodFromConfig(configNode, (T)this.methodFactory.getGetMethod(this.apiEndpoint + "/traits/" + safeTraitID), autoSave);
                    JSONObject result = this.httpClient.executeJSONObject((HttpRequestBase)getMethod, 200, JSONObject.class);
                    audienceManagerItems.add(new AudienceManagerItemImpl(result, folders, ""));
                }
            }
        }
        catch (RepositoryException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (CryptoException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (JSONException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (IOException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        return audienceManagerItems;
    }

    @Override
    public Iterable<AudienceManagerItem> getSegments(AudienceManagerConfiguration config, String[] traits) throws AudienceManagerAccessDenied {
        try {
            String url = MessageFormat.format(this.eventEndpoint, config.getPartner());
            NameValuePair[] params = this.addTraitParams(this.traitsService.updateTraits(config, traits), this.getDefaultParams(config.getContainerNSID())).toArray((T[])new NameValuePair[0]);
            URIBuilder builder = new URIBuilder();
            URL buildurl = new URL(url);
            builder.setParameters(params).setScheme(buildurl.getProtocol()).setPort(buildurl.getPort()).setHost(buildurl.getHost()).setPath(buildurl.getPath()).setUserInfo(buildurl.getUserInfo());
            URI uri = builder.build();
            HttpGet eventMethod = this.methodFactory.getGetMethod(uri.toASCIIString());
            MemoryCookieStore cookieStore = new MemoryCookieStore();
            return this.traitsService.getSegments(config, this.httpClient.executeJSONObject((HttpRequestBase)eventMethod, 200, JSONObject.class, cookieStore));
        }
        catch (IOException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (HttpException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (URISyntaxException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        return null;
    }

    @Override
    public Iterable<String> getSegmentIds(AudienceManagerConfiguration config, String[] traits) throws AudienceManagerAccessDenied {
        try {
            List<String[]> traitList = this.traitsService.updateTraits(config, traits);
            return this.traitsService.getSegmentIds(config, this.getDCSResponse(config.getPartner(), config.getContainerNSID(), traitList));
        }
        catch (IOException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
            return null;
        }
    }

    private JSONObject getDCSResponse(String partner, String container, List<String[]> traitList) throws IOException, AudienceManagerAccessDenied {
        String url = MessageFormat.format(this.eventEndpoint, partner.toLowerCase());
        NameValuePair[] params = this.addTraitParams(traitList, this.getDefaultParams(container)).toArray((T[])new NameValuePair[0]);
        try {
            URIBuilder builder = new URIBuilder();
            URL buildurl = new URL(url);
            builder.setParameters(params).setScheme(buildurl.getProtocol()).setPort(buildurl.getPort()).setHost(buildurl.getHost()).setPath(buildurl.getPath()).setUserInfo(buildurl.getUserInfo());
            URI uri = builder.build();
            HttpGet eventMethod = this.methodFactory.getGetMethod(uri.toASCIIString());
            MemoryCookieStore cookieStore = new MemoryCookieStore();
            return this.httpClient.executeJSONObject((HttpRequestBase)eventMethod, 200, JSONObject.class, cookieStore);
        }
        catch (HttpException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
            return null;
        }
        catch (URISyntaxException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
            return null;
        }
    }

    @Override
    public void setupDestinations(AudienceManagerConfiguration config, SyncResult syncResult) throws AudienceManagerAccessDenied {
        this.setupDestinations(config, syncResult, "CQIntegrationDestination");
    }

    public void setupDestinations(AudienceManagerConfiguration config, SyncResult syncResult, String destinationName) throws AudienceManagerAccessDenied {
        try {
            long destinationId = this.getOrCreateDestination(config, destinationName);
            this.registerNewSegments(config, destinationId, syncResult);
        }
        catch (JSONException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (RepositoryException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (CryptoException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (IOException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
    }

    private long getOrCreateDestination(AudienceManagerConfiguration config, String destinationName) throws CryptoException, RepositoryException, AudienceManagerAccessDenied, IOException, JSONException {
        Node configNode = config.getNode();
        HttpGet checkDestination = this.prepareOAuthMethodFromConfig(configNode, (T)this.methodFactory.getGetMethod(this.apiEndpoint + "/destinations/"), false);
        JSONArray results = this.httpClient.executeJSONObject((HttpRequestBase)checkDestination, 200, JSONArray.class);
        for (int i = 0; i < results.length(); ++i) {
            JSONObject destination = results.getJSONObject(i);
            if (destination == null || !destination.has("name") || !destinationName.equals(destination.get("name"))) continue;
            return destination.getLong("destinationId");
        }
        return this.createDestination(destinationName, ".cqclientintegration.adobe.com", "Auto Created CQ Integration Cookie Destination: Please do not edit or disable without talking to the team managing the CQ installation connected to this destination.Doing so may break integration.", this.checkOAuthResponse(configNode, new OAuthResponseImpl(configNode, this.clientId, this.clientSecret, this.cryptoSupport), false));
    }

    private long createDestination(String destinationName, String domain, String description, OAuthResponseImpl oauthResponse) throws JSONException, IOException, AudienceManagerAccessDenied {
        JSONObject requestBody = new JSONObject();
        requestBody.put("name", (Object)destinationName);
        if (description != null) {
            requestBody.put("description", (Object)description);
        }
        requestBody.put("destinationType", (Object)"ADS");
        requestBody.put("cookieName", (Object)destinationName);
        requestBody.put("cnameDomain", (Object)domain);
        requestBody.put("maxSize", (Object)"2048");
        requestBody.put("ttl", (Object)"0");
        requestBody.put("domainRestrictions", (Object)"ALL_DOMAINS");
        requestBody.put("formatType", (Object)"SINGLE_KEY");
        requestBody.put("singleKey", (Object)"segs");
        requestBody.put("keySeparator", (Object)"=");
        requestBody.put("valueSeparator", (Object)",");
        HttpPost createDestination = this.prepareJSONPostMethod(oauthResponse, this.methodFactory.getPostMethod(this.apiEndpoint + "/destinations/"), requestBody);
        JSONObject created = this.httpClient.executeJSONObject((HttpRequestBase)createDestination, 201, JSONObject.class);
        LOGGER.debug("Created response is {} ", (Object)created.toString(2));
        if (created != null && created.has("name") && destinationName.equals(created.get("name"))) {
            return created.getLong("destinationId");
        }
        throw new IllegalStateException("Unable to create destination " + destinationName + " on Audience Manager Server");
    }

    private void deleteDestination(long destinationId, OAuthResponseImpl oAuthResponse) throws IOException, AudienceManagerAccessDenied {
        JSONArray batch = new JSONArray();
        batch.put(destinationId);
        this.executeJSONBatch(oAuthResponse, batch, this.methodFactory.getPostMethod(this.apiEndpoint + "/destinations/" + "/bulk-delete/"), 204);
    }

    private JSONObject getDestinationMappings(long destinationId, OAuthResponseImpl oAuthResponse) throws IOException, AudienceManagerAccessDenied, JSONException {
        JSONObject destinations = new JSONObject();
        int total = 1;
        int n = 0;
        for (int page = 0; n < total && page < 500; ++page) {
            HttpGet getMappings = this.prepareOAuthMethod(oAuthResponse, (T)this.methodFactory.getGetMethod(this.apiEndpoint + "/destinations/" + destinationId + "/mappings?page=" + page));
            JSONObject results = this.httpClient.executeJSONObject((HttpRequestBase)getMappings, 200, JSONObject.class);
            LOGGER.debug(results.toString(2));
            if (total == 1) {
                total = results.has("total") ? results.getInt("total") : 0;
            }
            JSONArray list = results.getJSONArray("list");
            for (int i = 0; i < list.length(); ++i) {
                JSONObject dest = list.getJSONObject(i);
                if (dest.has("destinationMappingId")) {
                    destinations.put(dest.getString("destinationMappingId"), (Object)dest);
                }
                ++n;
            }
        }
        return destinations;
    }

    private void registerNewSegments(AudienceManagerConfiguration config, long destinationId, SyncResult syncResult) throws JSONException, CryptoException, RepositoryException, IOException, AudienceManagerAccessDenied {
        Node configNode = config.getNode();
        OAuthResponseImpl oAuthResponseImpl = this.checkOAuthResponse(configNode, new OAuthResponseImpl(configNode, this.clientId, this.clientSecret, this.cryptoSupport), false);
        final JSONObject destinations = this.getDestinationMappings(destinationId, oAuthResponseImpl);
        HashSet<Long> seen = new HashSet<Long>();
        for (String k : new Iterable<String>(){

            @Override
            public Iterator<String> iterator() {
                return destinations.keys();
            }
        }) {
            JSONObject dest = destinations.getJSONObject(k);
            if (!dest.has("traitType") || !"SEGMENT".equals(dest.get("traitType")) || !dest.has("sid")) continue;
            seen.add(dest.getLong("sid"));
        }
        JSONArray batch = new JSONArray();
        ArrayList<Long> seglist = new ArrayList<Long>();
        long startDate = System.currentTimeMillis() - 86400000;
        for (AudienceManagerItem item : syncResult.getNewSegments()) {
            if (seen.contains(item.getItemId())) continue;
            seen.add(item.getItemId());
            seglist.add(item.getItemId());
            JSONObject segment = new JSONObject();
            segment.put("sid", item.getItemId());
            segment.put("traitType", (Object)"SEGMENT");
            segment.put("startDate", startDate);
            segment.put("valueAlias", (Object)String.valueOf(item.getItemId()));
            batch.put((Object)segment);
            if (batch.length() < this.maxBatchSize) continue;
            JSONArray result = new JSONArray();
            try {
                oAuthResponseImpl = this.checkOAuthResponse(configNode, oAuthResponseImpl, false);
                result = this.executeJSONBatch(oAuthResponseImpl, batch, this.methodFactory.getPostMethod(this.apiEndpoint + "/destinations/" + destinationId + "/bulk-create"), 200);
            }
            catch (AudienceManagerAccessDenied e) {
                this.refreshAccessToken(configNode, false);
                oAuthResponseImpl = this.checkOAuthResponse(configNode, new OAuthResponseImpl(configNode, this.clientId, this.clientSecret, this.cryptoSupport), false);
                result = this.executeJSONBatch(oAuthResponseImpl, batch, this.methodFactory.getPostMethod(this.apiEndpoint + "/destinations/" + destinationId + "/bulk-create"), 200);
            }
            if (result.length() != batch.length()) {
                LOGGER.error("None of the following segments were registered {} ", seglist);
                LOGGER.error("Please Log in to the Audience Manager UI and try and add each segment ID in turn. One of the segments is in error, probably as a result of being duplicated in an Audience Manager SQL table. Alternatively delete the Destination called CQIntegrationDestination set the batch size on this component to 1 (OSGi console) and retry.");
            }
            seglist.clear();
            batch = new JSONArray();
        }
        if (batch.length() > 0) {
            try {
                this.executeJSONBatch(oAuthResponseImpl, batch, this.methodFactory.getPostMethod(this.apiEndpoint + "/destinations/" + destinationId + "/bulk-create"), 200);
            }
            catch (AudienceManagerAccessDenied e) {
                this.refreshAccessToken(configNode, false);
                oAuthResponseImpl = this.checkOAuthResponse(configNode, new OAuthResponseImpl(configNode, this.clientId, this.clientSecret, this.cryptoSupport), false);
                this.executeJSONBatch(oAuthResponseImpl, batch, this.methodFactory.getPostMethod(this.apiEndpoint + "/destinations/" + destinationId + "/bulk-create"), 200);
            }
        }
        configNode.getSession().save();
    }

    private OAuthResponseImpl refreshAccessToken(Node configNode, boolean autoSave) throws CryptoException, RepositoryException, AudienceManagerAccessDenied {
        return this.checkOAuthResponse(configNode, new OAuthResponseImpl(configNode, this.clientId, this.clientSecret, this.cryptoSupport), autoSave);
    }

    private HttpPost prepareJSONPostMethod(OAuthResponseImpl oauthResponse, HttpPost postMethod, JSONArray requestBody) throws UnsupportedEncodingException {
        postMethod = this.prepareOAuthMethod(oauthResponse, (T)postMethod);
        postMethod.setHeader("Content-Type", "application/json");
        ByteArrayEntity requestEntity = new ByteArrayEntity(requestBody.toString().getBytes("UTF-8"), ContentType.APPLICATION_JSON);
        postMethod.setEntity((HttpEntity)requestEntity);
        return postMethod;
    }

    private HttpPost prepareJSONPostMethod(OAuthResponseImpl oauthResponse, HttpPost postMethod, JSONObject requestBody) throws UnsupportedEncodingException {
        postMethod = this.prepareOAuthMethod(oauthResponse, (T)postMethod);
        postMethod.setHeader("Content-Type", "application/json");
        ByteArrayEntity requestEntity = new ByteArrayEntity(requestBody.toString().getBytes("UTF-8"), ContentType.APPLICATION_JSON);
        postMethod.setEntity((HttpEntity)requestEntity);
        return postMethod;
    }

    private <T extends HttpRequestBase> T prepareOAuthMethodFromConfig(Node configNode, T method, boolean autoSave) throws CryptoException, RepositoryException, AudienceManagerAccessDenied {
        return this.prepareOAuthMethod(this.checkOAuthResponse(configNode, new OAuthResponseImpl(configNode, this.clientId, this.clientSecret, this.cryptoSupport), autoSave), method);
    }

    private <T extends HttpRequestBase> T prepareOAuthMethod(OAuthResponseImpl oauthResponse, T method) {
        return this.httpClient.prepareMethod(oauthResponse, method);
    }

    private OAuthResponseImpl checkOAuthResponse(Node n, OAuthResponseImpl oAuthResponse, boolean autoSave) throws CryptoException, RepositoryException, AudienceManagerAccessDenied {
        if (oAuthResponse.hasExpired()) {
            if ((oAuthResponse = (OAuthResponseImpl)this.refresh(oAuthResponse)) == null) {
                throw new RuntimeException("OAuth Authentication token has expired and cant be refreshed ");
            }
            oAuthResponse.save(n, this.cryptoSupport);
            if (autoSave) {
                n.getSession().save();
            }
        } else {
            LOGGER.debug("Access Token is valid and current value: {} ", (Object)oAuthResponse.getAccessToken());
        }
        return oAuthResponse;
    }

    private AudienceManagerFolders getFolders(AudienceManagerConfiguration config, String url, boolean autoSave) throws AudienceManagerAccessDenied {
        try {
            if (config.isOfflineTest()) {
                return new AudienceManagerFolderList(new JSONArray(TestData.loadTestData(config.getOfflineTestSet() + "_folders.json")), config.getTemplate());
            }
            try {
                return new AudienceManagerFolderList(this.httpClient.executeJSONObject((HttpRequestBase)this.prepareOAuthMethodFromConfig(config.getNode(), (T)this.methodFactory.getGetMethod(url), autoSave), 200, JSONArray.class), config.getTemplate());
            }
            catch (AudienceManagerAccessDenied e) {
                this.refreshAccessToken(config.getNode(), autoSave);
                return new AudienceManagerFolderList(this.httpClient.executeJSONObject((HttpRequestBase)this.prepareOAuthMethodFromConfig(config.getNode(), (T)this.methodFactory.getGetMethod(url), autoSave), 200, JSONArray.class), config.getTemplate());
            }
        }
        catch (IOException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (JSONException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (RepositoryException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        catch (CryptoException e) {
            LOGGER.error(e.getMessage(), (Throwable)e);
        }
        return new AudienceManagerFolders(){
            private List<AudienceManagerFolder> empty;

            @Override
            public AudienceManagerFolder getFolder(long folderId) {
                return null;
            }

            @Override
            public Iterator<AudienceManagerFolder> iterator() {
                return this.empty.iterator();
            }
        };
    }

    private JSONArray executeJSONBatch(OAuthResponseImpl oAuthResponseImpl, JSONArray batch, HttpPost method, int expectedCode) throws IOException, AudienceManagerAccessDenied {
        HttpPost batchCreate = this.prepareJSONPostMethod(oAuthResponseImpl, method, batch);
        JSONArray result = this.httpClient.executeJSONObject((HttpRequestBase)batchCreate, expectedCode, JSONArray.class);
        if (result.length() < batch.length()) {
            LOGGER.warn("Not all items were accepted {} out of {}", (Object)result.length(), (Object)batch.length());
        } else {
            LOGGER.debug("Accepted {}", (Object)result.length());
        }
        return result;
    }

    private List<NameValuePair> getDefaultParams(String containerNSID) {
        ArrayList<NameValuePair> params = new ArrayList<NameValuePair>();
        params.add((NameValuePair)new BasicNameValuePair("d_rtbd", "json"));
        params.add((NameValuePair)new BasicNameValuePair("d_nsid", containerNSID));
        return params;
    }

    private List<NameValuePair> addTraitParams(List<String[]> moreParams, List<NameValuePair> params) {
        if (moreParams != null) {
            for (String[] param : moreParams) {
                params.add((NameValuePair)new BasicNameValuePair(param[0], param[1]));
            }
        }
        return params;
    }

    protected void bindCryptoSupport(CryptoSupport cryptoSupport) {
        this.cryptoSupport = cryptoSupport;
    }

    protected void unbindCryptoSupport(CryptoSupport cryptoSupport) {
        if (this.cryptoSupport == cryptoSupport) {
            this.cryptoSupport = null;
        }
    }

    protected void bindTraitsService(TraitsService traitsService) {
        this.traitsService = traitsService;
    }

    protected void unbindTraitsService(TraitsService traitsService) {
        if (this.traitsService == traitsService) {
            this.traitsService = null;
        }
    }

    protected void bindSegmentService(SegmentService segmentService) {
        this.segmentService = segmentService;
    }

    protected void unbindSegmentService(SegmentService segmentService) {
        if (this.segmentService == segmentService) {
            this.segmentService = null;
        }
    }

    protected void bindHttpClientBuilderFactory(HttpClientBuilderFactory httpClientBuilderFactory) {
        this.httpClientBuilderFactory = httpClientBuilderFactory;
    }

    protected void unbindHttpClientBuilderFactory(HttpClientBuilderFactory httpClientBuilderFactory) {
        if (this.httpClientBuilderFactory == httpClientBuilderFactory) {
            this.httpClientBuilderFactory = null;
        }
    }

    public static interface MethodFactory {
        public HttpPost getPostMethod(String var1);

        public HttpGet getGetMethod(String var1);
    }

}