net.authorize.util.HttpCallTask Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of anet-java-sdk Show documentation
Authorize.Net SDK includes standard payments, recurring billing, and customer profiles.
There is a newer version: 3.0.0
package net.authorize.util;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.concurrent.Callable;

import javax.xml.bind.JAXBException;
import javax.xml.bind.UnmarshalException;

import net.authorize.Environment;
import net.authorize.api.contract.v1.ANetApiRequest;
import net.authorize.api.contract.v1.ANetApiResponse;
import net.authorize.api.contract.v1.MessageTypeEnum;
import net.authorize.api.contract.v1.MessagesType;
import net.authorize.api.contract.v1.MessagesType.Message;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
//import net.authorize.api.controller.base.ErrorResponse;

/**
 * Callable task to make http calls in future 
 * @author ramittal
 *
 */
public class HttpCallTask implements Callable {
	private static Log logger = LogFactory.getLog(HttpCallTask.class);

	Environment env = null;
	ANetApiRequest request = null;
	@SuppressWarnings("rawtypes")
	Class classType = null;
	
	//private static ANetApiResponse errorResponse = null;
	private Message errorMessage = null;

	/**
	 * Creates task to be called in future for making http call
	 * @param env  Env to point to 
	 * @param request  Http request to send 
	 * @param classType  Expected response type if successful
	 */
    public  HttpCallTask(Environment env, ANetApiRequest request, Class classType) {
    	this.env = env;
    	this.request = request;
    	this.classType = classType;
		this.errorMessage = new Message();
    }

	@SuppressWarnings("unchecked")
    /**
     * Makes a http call, using the proxy if requested, and returns apiresponse
     * with error code set appropriately
     * @return ANetApiResponse  successful or failed response 
     */
	public ANetApiResponse call() throws Exception {
		ANetApiResponse response = null;
		StringBuilder buffer = new StringBuilder();
		
		DefaultHttpClient httpCaller = null;
		
        try {
            HttpPost httppost = HttpUtility.createPostRequest(this.env, this.request);
            httpCaller = new DefaultHttpClient();
			HttpClient.setProxyIfRequested(httpCaller);
            HttpResponse httpResponse = httpCaller.execute(httppost);

			if ( null != httpResponse) { 
				if ( null != httpResponse.getStatusLine()) { 
					if ( 200 == httpResponse.getStatusLine().getStatusCode()) {
				
						HttpEntity entity = httpResponse.getEntity();
						// get the raw data being received
						InputStream instream = entity.getContent();
						buffer.append(HttpUtility.convertStreamToString(instream));
					}
				}
			}
			LogHelper.debug(logger, "Raw Response: '%s'", buffer.toString());
			// handle HTTP errors
			if (0 == buffer.length()) {
				response = createErrorResponse(httpResponse, null);
			} else { // i.e. if ( StringUtils.isNotEmpty(buffer.toString())) 
				Object localResponse = null;
				
				try {
					localResponse = XmlUtility.create(buffer.toString(), this.classType);
				} catch(UnmarshalException ume) {
					try {
						//try deserializing to error message
						localResponse = XmlUtility.create(buffer.toString(), net.authorize.api.contract.v1.ErrorResponse.class);
					} catch(JAXBException jabex) {
						response = createErrorResponse(httpResponse, jabex);
					}
				} catch(JAXBException jabex) {
					response = createErrorResponse(httpResponse, jabex);
				}
				
				//ObjectFactory factory = new ObjectFactory();
				//JAXBElement error = factory.createErrorResponse();
			    
				//check if error
				if ( null == localResponse) {
					try {
						response = XmlUtility.create(buffer.toString(), ANetApiResponse.class);
					} catch(JAXBException jabex) {
						response = createErrorResponse(httpResponse, jabex);
					}
				} else {
					if (localResponse instanceof ANetApiResponse)
					{
						response = (ANetApiResponse) localResponse;
					} else {
						LogHelper.warn( logger, "Unknown ResponseType: '%s'", localResponse);
					}
				}
			}
        } catch (ClientProtocolException cpe) {
			response = createErrorResponse(null, cpe);
        } catch (IOException ioe) {
			response = createErrorResponse(null, ioe);
        } finally {
        	if ( null != httpCaller) {
        		httpCaller.getConnectionManager().shutdown();
        	}
        }

        return response;
	}

	private ANetApiResponse createErrorResponse(HttpResponse httpResponse, Exception exception) {
		ANetApiResponse response = new ANetApiResponse();

		MessagesType aMessage = new MessagesType();
		aMessage.setResultCode(MessageTypeEnum.ERROR);
		response.setMessages(aMessage);

		List messages = response.getMessages().getMessage();
		//clear all messages
		messages.clear();
		
		setErrorResponse(messages, httpResponse);
		setErrorResponse(messages, exception);
		
		return response;
	}

	private void setErrorResponse(List messages, HttpResponse httpResponse) {
		if ( null != httpResponse) {
			messages.add(errorMessage);
			String code = "Error";
			String text = "Unknown Error";
			if (null != httpResponse.getStatusLine())
			{
				LogHelper.warn( logger, "Error deserializing response to '%s'", this.classType);

				code = String.format("%d", httpResponse.getStatusLine().getStatusCode());
				if (null != httpResponse.getStatusLine().getReasonPhrase()) { text = httpResponse.getStatusLine().getReasonPhrase();}
			}
			setErrorMessageValues(code, text);
		}
	}

	private void setErrorResponse(List messages, Exception exception) {
		if ( null != exception) {
			messages.add(errorMessage);
			String code = "Error";
			String text = "Unknown Error";
			LogHelper.error( logger, "Http request execute failed: '%s'", exception.getMessage());
			code = exception.getClass().getCanonicalName();
			//code = exception.getClass().getTypeName();// requires java1.8
			text = exception.getMessage();
			
			setErrorMessageValues(code, text);
		}
	}

	private void setErrorMessageValues(String code, String text) {
		errorMessage.setCode(code);
		errorMessage.setText(text);
		LogHelper.warn(logger, "Adding ErrorMessage: Code: '%s', Text: '%s'", code, text);
	}
}