private static final boolean ssl = true;

private static final String URL = "/getHistoricalPrice";

private static String domain;

//private static String url_stream;

private static String url_polling;

private static String url_challenge;

private static String url_token;

private static String user;

private static String password;

private static String authentication_port;

private static String request_port;

private static String ssl_cert;

private static String challenge;

private static String token;

//private static int interval;

public static class hftRequest {

public getAuthorizationChallengeRequest getAuthorizationChallenge;

public getAuthorizationTokenRequest getAuthorizationToken;

public getHistoricalPriceRequest getHistoricalPrice;

public hftRequest( String user) {

this.getAuthorizationChallenge = new getAuthorizationChallengeRequest(user);

}

public hftRequest( String user, String challengeresp ) {

this.getAuthorizationToken = new getAuthorizationTokenRequest(user, challengeresp);

}

public hftRequest( String user, String token, List<String> security, List<String> tinterface, String granularity, String side, int number ) {

this.getHistoricalPrice = new getHistoricalPriceRequest(user, token, security, tinterface, granularity, side, number);

}

}

public static class hftResponse {

public getAuthorizationChallengeResponse getAuthorizationChallengeResponse;

public getAuthorizationTokenResponse getAuthorizationTokenResponse;

public getHistoricalPriceResponse getHistoricalPriceResponse;

}

public static class getAuthorizationChallengeRequest {

public String user;

public getAuthorizationChallengeRequest( String user ) {

this.user = user;

}

}

public static class getAuthorizationChallengeResponse {

public String challenge;

public String timestamp;

}

public static class getAuthorizationTokenRequest {

public String user;

public String challengeresp;

public getAuthorizationTokenRequest( String user, String challengeresp ) {

this.user = user;

this.challengeresp = challengeresp;

}

}

public static class getAuthorizationTokenResponse {

public String token;

public String timestamp;

}

public static class getHistoricalPriceRequest {

public String user;

public String token;

public List<String> security;

public List<String> tinterface;

public String granularity;

public String side;

public int number;

public getHistoricalPriceRequest( String user, String token, List<String> security, List<String> tinterface, String granularity, String side, int number ) {

this.user = user;

this.token = token;

this.security = security;

this.tinterface = tinterface;

this.granularity = granularity;

this.side = side;

this.number = number;

}

}

public static class getHistoricalPriceResponse {

public int result;

public String message;

public List<candleTick> candle;

public String timestamp;

}

public static class candleTick {

public String security;

public String tinterface;

public int timestamp;

public String side;

public double open;

public double high;

public double low;

public double close;

public int ticks;

}

public static void main(String[] args) throws IOException, DecoderException, CertificateException, NoSuchAlgorithmException, KeyStoreException, KeyManagementException {

// get properties from file

getProperties();

final ObjectMapper mapper = new ObjectMapper();

List<Header> headers = new ArrayList<Header>();

headers.add( new BasicHeader(HttpHeaders.CONTENT_TYPE, "application/json") );

headers.add( new BasicHeader(HttpHeaders.ACCEPT, "application/json") );

CloseableHttpClient client=null;

if (ssl){

// get certificate

CertificateFactory cf = CertificateFactory.getInstance("X.509");

URL url = new URL(ssl_cert);

URLConnection connection = url.openConnection();

InputStream in = connection.getInputStream();

Certificate cert = cf.generateCertificate(in);

//System.out.println("Cert:\n===================\n" + cert.getPublicKey().toString() + "\n");

in.close();

TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());

KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());

ks.load(null); // You don't need the KeyStore instance to come from a file.

ks.setCertificateEntry("cert", cert);

tmf.init(ks);

SSLContext sslContext = SSLContext.getInstance("TLS");

sslContext.init(null, tmf.getTrustManagers(), null);

client = HttpClients.custom().setSSLContext(sslContext).setDefaultHeaders(headers).build();

}

else{

client = HttpClients.custom().setDefaultHeaders(headers).build();

}

// Create a custom response handler

ResponseHandler<String> responseHandler = new ResponseHandler<String>() {

@Override

public String handleResponse(final HttpResponse httpresponse) throws ClientProtocolException, IOException {

int status = httpresponse.getStatusLine().getStatusCode();

if (status >= 200 && status < 300) {

HttpEntity entity = httpresponse.getEntity();

// --------------------------------------------------------------

// Wait for response from server (polling)

// --------------------------------------------------------------

try {

InputStreamReader stream = new InputStreamReader(entity.getContent());

BufferedReader bufferedReader = new BufferedReader(stream);

String line = null;

while ((line = bufferedReader.readLine()) != null) {

hftResponse response = mapper.readValue(line, hftResponse.class);

if (response.getAuthorizationChallengeResponse != null){

challenge = response.getAuthorizationChallengeResponse.challenge;

return null;

}

if (response.getAuthorizationTokenResponse != null){

token = response.getAuthorizationTokenResponse.token;

return null;

}

if (response.getHistoricalPriceResponse != null){

if (response.getHistoricalPriceResponse.candle != null){

for (candleTick tick : response.getHistoricalPriceResponse.candle){

System.out.println("Security: " + tick.security + " tinterface: " + tick.tinterface + " TimeStamp: " + tick.timestamp + " Side: " + tick.side + " Open: " + tick.open + " High: " + tick.high + " Low: " + tick.low + " Close: " + tick.close + " Ticks: " + tick.ticks);

}

}

if (response.getHistoricalPriceResponse.message != null){

System.out.println("Message from server: " + response.getHistoricalPriceResponse.message);

}

}

}

}

catch (IOException e) { e.printStackTrace(); }

catch (Exception e) { e.printStackTrace(); }

return null;

} else {

throw new ClientProtocolException("Unexpected response status: " + status);

}

}

};

try {

hftRequest hftrequest;

StringEntity request;

HttpPost httpRequest;

// get challenge

hftrequest = new hftRequest(user);

mapper.setSerializationInclusion(Inclusion.NON_NULL);

mapper.configure(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);

request = new StringEntity(mapper.writeValueAsString(hftrequest));

System.out.println(mapper.writeValueAsString(hftrequest));

httpRequest = new HttpPost(domain + ":" + authentication_port + url_challenge);

httpRequest.setEntity(request);

client.execute(httpRequest, responseHandler);

// create challenge response

byte[] a = Hex.decodeHex(challenge.toCharArray());

byte[] b = password.getBytes();

byte[] c = new byte[a.length + b.length];

System.arraycopy(a, 0, c, 0, a.length);

System.arraycopy(b, 0, c, a.length, b.length);

byte[] d = DigestUtils.sha1(c);

String challengeresp = Hex.encodeHexString(d);

// get token with challenge response

hftrequest = new hftRequest(user, challengeresp);

mapper.setSerializationInclusion(Inclusion.NON_NULL);

mapper.configure(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);

request = new StringEntity(mapper.writeValueAsString(hftrequest));

System.out.println(mapper.writeValueAsString(hftrequest));

httpRequest = new HttpPost(domain + ":" + authentication_port + url_token);

httpRequest.setEntity(request);

client.execute(httpRequest, responseHandler);

// -----------------------------------------

// Prepare and send a getHistoricalPrices request

// -----------------------------------------

hftrequest = new hftRequest(user, token, Arrays.asList("EUR/USD", "GBP/USD"), null, "s1", "ask", 3);

mapper.setSerializationInclusion(Inclusion.NON_NULL);

mapper.configure(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);

request = new StringEntity(mapper.writeValueAsString(hftrequest));

System.out.println(mapper.writeValueAsString(hftrequest));

httpRequest = new HttpPost(domain + ":" + request_port + url_polling + URL);

httpRequest.setEntity(request);

client.execute(httpRequest, responseHandler);

} finally {

client.close();

}

}

public static void getProperties(){

Properties prop = new Properties();

InputStream input = null;

try {

input = new FileInputStream("config.properties");

prop.load(input);

//url_stream = prop.getProperty("url-stream");

url_polling = prop.getProperty("url-polling");

url_challenge = prop.getProperty("url-challenge");

url_token = prop.getProperty("url-token");

user = prop.getProperty("user");

password = prop.getProperty("password");

//interval = Integer.parseInt(prop.getProperty("interval"));

if (ssl){

domain = prop.getProperty("ssl-domain");

authentication_port = prop.getProperty("ssl-authentication-port");

request_port = prop.getProperty("ssl-request-port");

ssl_cert = prop.getProperty("ssl-cert");

}

else{

domain = prop.getProperty("domain");

authentication_port = prop.getProperty("authentication-port");

request_port = prop.getProperty("request-port");

}

}

catch (IOException ex) {

ex.printStackTrace();

}

finally {

if (input != null) {

try {

input.close();

}

catch (IOException e) {

e.printStackTrace();

}

}

}

}

public getHistoricalPrice() {

super();

}