com.instamojo.wrapper.api.ApiContext Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of instamojo-java Show documentation
Instamojo Payments Java Wrapper
The newest version!
package com.instamojo.wrapper.api;

import com.google.gson.Gson;
import com.instamojo.wrapper.exception.ConnectionException;
import com.instamojo.wrapper.exception.HTTPException;
import com.instamojo.wrapper.exception.InvalidClientException;
import com.instamojo.wrapper.model.AccessToken;
import com.instamojo.wrapper.util.Constants;
import com.instamojo.wrapper.util.HttpUtils;
import org.apache.http.util.TextUtils;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * The Class ApiContext.
 */
public class ApiContext {

    private static final Logger LOGGER = Logger.getLogger(ApiContext.class.getName());

    public enum Mode {
        TEST, LIVE
    }

    private volatile static ApiContext instance;

    /*
     * The access token related info
     */
    private AccessToken accessToken;

    /*
     * The token creation time
     */
    private long tokenCreationTime;

    /*
     * Instamojo client id
     */
    private String clientId;

    /*
     * The client secret
     */
    private String clientSecret;

    private String username;

    private String password;

    private Mode mode;

    private ApiContext(String clientId, String clientSecret, Mode mode) {
        this(clientId, clientSecret, null, null, mode);
    }

    private ApiContext(String clientId, String clientSecret, String username, String password, Mode mode) {
        this.clientId = clientId;
        this.clientSecret = clientSecret;
        this.mode = mode;
        this.username = username;
        this.password = password;
    }

    /**
     * Create a context
     *
     * @param clientId     the client id
     * @param clientSecret the client secret
     * @param mode         TEST or LIVE
     * @return the api
     */
    public static ApiContext create(String clientId, String clientSecret, Mode mode) {
        if (instance == null) {
            synchronized (ApiContext.class) {
                if (instance == null) {
                    instance = new ApiContext(clientId, clientSecret, mode);
                }
            }
        }

        return instance;
    }

    /**
     * Create a context
     *
     * @param clientId     the client id
     * @param clientSecret the client secret
     * @param username     user's username
     * @param password     user's password
     * @param mode         TEST or LIVE
     * @return the api
     */
    public static ApiContext create(String clientId, String clientSecret, String username, String password, Mode mode) {
        if (instance == null) {
            synchronized (ApiContext.class) {
                if (instance == null) {
                    instance = new ApiContext(clientId, clientSecret, username, password, mode);
                }
            }
        }

        return instance;
    }

    private boolean isTokenExpired() {
        long durationInSeconds = TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - tokenCreationTime);
        return durationInSeconds >= (accessToken.getExpiresIn() - 300);
    }

    private void loadOrRefreshAccessToken() throws ConnectionException, HTTPException {
        if (accessToken == null) {
            fetchAccessToken();

        } else if (isTokenExpired()) {
            refreshAccessToken();
        }
    }

    /*
     * Fetch a new access token.
     */
    private synchronized void fetchAccessToken() throws ConnectionException, HTTPException {
        if (accessToken != null) {
            return;
        }

        Map params = new HashMap<>();
        params.put(Constants.PARAM_CLIENT_ID, clientId);
        params.put(Constants.PARAM_CLIENT_SECRET, clientSecret);

        if (isUserAuthFlow()) {
            params.put(Constants.PARAM_GRANT_TYPE, Constants.PARAM_PASSWORD);
            params.put(Constants.PARAM_USERNAME, username);
            params.put(Constants.PARAM_PASSWORD, password);

        } else {
            params.put(Constants.PARAM_GRANT_TYPE, Constants.GRAND_TYPE_CLIENT_CREDENTIALS);
        }

        loadAccessToken(params);
    }

    /*
     * Refresh an expired access token
     */
    private synchronized void refreshAccessToken() throws ConnectionException, HTTPException {
        if (!isTokenExpired()) {
            return;
        }

        Map params = new HashMap<>();
        params.put(Constants.PARAM_CLIENT_ID, clientId);
        params.put(Constants.PARAM_CLIENT_SECRET, clientSecret);

        if (isUserAuthFlow() && accessToken.getRefreshToken() != null) {
            // For user based authentication, refresh the token
            params.put(Constants.PARAM_GRANT_TYPE, Constants.GRAND_TYPE_REFRESH_TOKEN);
            params.put(Constants.PARAM_REFRESH_TOKEN, accessToken.getRefreshToken());

        } else {
            // For app based authentication, reload the token
            params.put(Constants.PARAM_GRANT_TYPE, Constants.GRAND_TYPE_CLIENT_CREDENTIALS);
        }

        loadAccessToken(params);
    }

    private void loadAccessToken(Map params) throws ConnectionException, HTTPException {
        try {
            String response = HttpUtils.post(getAuthEndpoint(), null, params);

            AccessToken accessTokenResponse = new Gson().fromJson(response,
                    AccessToken.class);

            if (TextUtils.isEmpty(accessTokenResponse.getToken())) {
                throw new InvalidClientException(
                        "Could not get the access token due to " + accessTokenResponse.getError());
            }

            this.accessToken = accessTokenResponse;
            this.tokenCreationTime = System.nanoTime();

        } catch (IOException e) {
            LOGGER.log(Level.SEVERE, e.toString(), e);
            throw new ConnectionException(e.toString(), e);
        }
    }

    /**
     * Clears the current cached Instance
     */
    public static void ClearInstance() {
        if (instance != null) {
            synchronized (ApiContext.class) {
                instance = null;
            }
        }
    }

    /*
     * Gets the authorization.
     */
    public String getAuthorization() throws ConnectionException, HTTPException {
        loadOrRefreshAccessToken();
        return accessToken.getTokenType() + " " + accessToken.getToken();
    }

    /*
     * Gets the api path.
     */
    public String getApiPath(String path) {
        String apiPath = getApiEndpoint() + path;

        if (!apiPath.endsWith("/")) {
            apiPath += Character.toString('/');
        }
        return apiPath;
    }

    private String getApiEndpoint() {
        if (mode == Mode.TEST) {
            return Constants.INSTAMOJO_TEST_API_ENDPOINT;
        }

        return Constants.INSTAMOJO_LIVE_API_ENDPOINT;
    }

    private String getAuthEndpoint() {
        if (mode == Mode.TEST) {
            return Constants.INSTAMOJO_TEST_AUTH_ENDPOINT;
        }

        return Constants.INSTAMOJO_LIVE_AUTH_ENDPOINT;
    }

    private boolean isUserAuthFlow() {
        return (username != null && password != null);
    }
}