ExternalPatientSearch.java

/**
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
 * License for the specific language governing rights and limitations under
 * the License.
 * 
 * The Original Code is OpenELIS code.
 * 
 * Copyright (C) The Minnesota Department of Health.  All Rights Reserved.
 *
 * Contributor(s): CIRG, University of Washington, Seattle WA.
 */
package us.mn.state.health.lims.common.externalLinks;

import java.io.IOException;
import java.net.ConnectException;
import java.net.SocketTimeoutException;
import java.net.URI;
import java.net.URISyntaxException;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.io.IOUtils;
import org.apache.commons.validator.GenericValidator;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.dom4j.DocumentException;

import us.mn.state.health.lims.common.log.LogEvent;
import us.mn.state.health.lims.common.provider.query.PatientDemographicsSearchResults;

public class ExternalPatientSearch implements Runnable {

	private static final String GET_PARAM_PWD = "pwd";
	private static final String GET_PARAM_NAME = "name";
	private static final String GET_PARAM_NATIONAL_ID = "nationalId";
	private static final String GET_PARAM_ST = "ST";
	private static final String GET_PARAM_SUBJECT = "subjectNumber";
	private static final String GET_PARAM_LAST = "last";
	private static final String GET_PARAM_FIRST = "first";
	private static final String GET_PARAM_GUID = "guid";

	public static final String MALFORMED_REPLY = "Malformed reply";
	public static final String URI_BUILD_FAILURE = "Failed to build URI";

	private boolean finished = false;

	private String firstName;
	private String lastName;
	private String STNumber;
	private String subjectNumber;
	private String nationalId;
	private String guid;
	private String connectionString;
	private String connectionName;
	private String connectionPassword;
	private int timeout = 0;

	protected String resultXML;
	protected List<PatientDemographicsSearchResults> searchResults;
	protected List<String> errors;
	protected int returnStatus = HttpStatus.SC_CREATED;

	synchronized public void setConnectionCredentials(String connectionString, String name, String password,
			int timeout_Mil) {
		if (finished) {
			throw new IllegalStateException("ServiceCredentials set after ExternalPatientSearch thread was started");
		}

		this.connectionString = connectionString;
		connectionName = name;
		connectionPassword = password;
		timeout = timeout_Mil;
	}

	synchronized public void setSearchCriteria(String lastName, String firstName, String STNumber, String subjectNumber, String nationalID, String guid)
			throws IllegalStateException {

		if (finished) {
			throw new IllegalStateException("Search criteria set after ExternalPatientSearch thread was started");
		}

		this.lastName = lastName;
		this.firstName = firstName;
		this.STNumber = STNumber;
		this.subjectNumber = subjectNumber;
		this.nationalId = nationalID;
		this.guid = guid;
	}

	synchronized public List<PatientDemographicsSearchResults> getSearchResults() {

		if (!finished) {
			throw new IllegalStateException("Results requested before ExternalPatientSearch thread was finished");
		}
		
		if (searchResults == null) {
			searchResults = new ArrayList<PatientDemographicsSearchResults>();

			convertXMLToResults();
		}

		return searchResults;
	}

	public int getSearchResultStatus() {
		if (!finished) {
			throw new IllegalStateException("Result status requested ExternalPatientSearch before search was finished");
		}

		return returnStatus;
	}

	public void run() {
		try {
			synchronized (this) {
				if (noSearchTerms()) {
					return;
				}

				if (connectionCredentialsIncomplete()) {
					throw new IllegalStateException("Search requested before connection credentials set.");
				}
				errors = new ArrayList<String>();

				doSearch();
			}
		} finally {
			finished = true;
		}
	}

	private boolean connectionCredentialsIncomplete() {
		return GenericValidator.isBlankOrNull(connectionString) || GenericValidator.isBlankOrNull(connectionName)
				|| GenericValidator.isBlankOrNull(connectionPassword);
	}

	private boolean noSearchTerms() {
		return GenericValidator.isBlankOrNull(firstName) && GenericValidator.isBlankOrNull(lastName)
				&& GenericValidator.isBlankOrNull(nationalId) && GenericValidator.isBlankOrNull(STNumber);
	}

	// protected for unit testing called from synchronized block
	protected void doSearch() {

		HttpClient httpclient = new DefaultHttpClient();
		setTimeout(httpclient);

		HttpGet httpget = new HttpGet(connectionString);
		URI getUri = buildConnectionString(httpget.getURI());
		httpget.setURI(getUri);

		try {
			// Ignore hostname mismatches and allow trust of self-signed certs
			SSLSocketFactory sslsf = new SSLSocketFactory(new TrustSelfSignedStrategy(), SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
			Scheme https = new Scheme("https", 443, sslsf);
			ClientConnectionManager ccm = httpclient.getConnectionManager();
			ccm.getSchemeRegistry().register(https);

			HttpResponse getResponse = httpclient.execute(httpget);
			returnStatus = getResponse.getStatusLine().getStatusCode();
			setPossibleErrors();
			setResults(IOUtils.toString(getResponse.getEntity().getContent(), "UTF-8"));
		} catch (SocketTimeoutException e) {
			errors.add("Response from patient information server took too long.");
			LogEvent.logError("ExternalPatientSearch", "doSearch()", e.toString());
			// System.out.println("Tinny time out" + e);
		} catch (ConnectException e) {
			errors.add("Unable to connect to patient information form service. Service may not be running");
			LogEvent.logError("ExternalPatientSearch", "doSearch()", e.toString());
			// System.out.println("you no talks? " + e);
		} catch (IOException e) {
			errors.add("IO error trying to read input stream.");
			LogEvent.logError("ExternalPatientSearch", "doSearch()", e.toString());
			// System.out.println("all else failed " + e);
		} catch (KeyManagementException e) {
			errors.add("Key management error trying to connect to external search service.");
			LogEvent.logError("ExternalPatientSearch", "doSearch()", e.toString());
		} catch (UnrecoverableKeyException e) {
			errors.add("Unrecoverable key error trying to connect to external search service.");
			LogEvent.logError("ExternalPatientSearch", "doSearch()", e.toString());
		} catch (NoSuchAlgorithmException e) {
			errors.add("No such encyrption algorithm error trying to connect to external search service.");
			LogEvent.logError("ExternalPatientSearch", "doSearch()", e.toString());
		} catch (KeyStoreException e) {
			errors.add("Keystore error trying to connect to external search service.");
			LogEvent.logError("ExternalPatientSearch", "doSearch()", e.toString());
		} catch (RuntimeException e) {
			errors.add("Runtime error trying to retrieve patient information.");
			LogEvent.logError("ExternalPatientSearch", "doSearch()", e.toString());
			httpget.abort();
			throw e;
		} finally {
			httpclient.getConnectionManager().shutdown();
		}
	}
	
	private void convertXMLToResults() {
		if (!GenericValidator.isBlankOrNull(resultXML)) {
			
			ExternalPatientSearchResultsXMLConverter converter = new ExternalPatientSearchResultsXMLConverter();
			
			try {
				searchResults = converter.convertXMLToSearchResults( resultXML );
			} catch (DocumentException e) {
				errors.add(MALFORMED_REPLY);
			}
		}
	}

	
	protected void setResults(String resultsAsXml) {
		resultXML = resultsAsXml;
	}

	private void setPossibleErrors() {
		switch (returnStatus) {
		case HttpStatus.SC_UNAUTHORIZED: {
			errors.add("Access denied to patient information service.");
			break;
		}
		case HttpStatus.SC_INTERNAL_SERVER_ERROR: {
			errors.add("Internal error on patient information service.");
			break;
		}
		case HttpStatus.SC_OK:{
			break; //NO-OP
		}
		default: {
			errors.add("Unknown error trying to connect to patient information service. Resturn status was "
					+ returnStatus);
		}
		}

	}

	private void setTimeout(HttpClient httpclient) {
		// this one causes a timeout if a connection is established but there is 
		// no response within <timeout> seconds
		httpclient.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, timeout);

		// this one causes a timeout if no connection is established within 10 seconds
		httpclient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, timeout);
	}

	private URI buildConnectionString(URI uriStart) {

		URI uriFinal = null;
		try {
			uriFinal = new URIBuilder(uriStart)
				.addParameter(GET_PARAM_FIRST, firstName)
				.addParameter(GET_PARAM_LAST, lastName)
				.addParameter(GET_PARAM_ST, STNumber)
				.addParameter(GET_PARAM_SUBJECT, subjectNumber)
				.addParameter(GET_PARAM_NATIONAL_ID, nationalId)
				.addParameter(GET_PARAM_GUID, guid)
				.addParameter(GET_PARAM_NAME, connectionName)
				.addParameter(GET_PARAM_PWD, connectionPassword)
				.build();
		} catch (URISyntaxException e) {
			errors.add(URI_BUILD_FAILURE);
		}

		return uriFinal;
	}
}