private static final boolean ssl = true;

private static final String URL = "/getOrder";

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 getOrderRequest getOrder;

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, List<String> type, int interval ) {

this.getOrder = new getOrderRequest(user, token, security, tinterface, type, interval);

}

}

public static class hftResponse{

public getAuthorizationChallengeResponse getAuthorizationChallengeResponse;

public getAuthorizationTokenResponse getAuthorizationTokenResponse;

public getOrderResponse getOrderResponse;

}

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 getOrderRequest {

public String user;

public String token;

public List<String> security;

public List<String> tinterface;

public List<String> type;

public int interval;

public getOrderRequest( String user, String token, List<String> security, List<String> tinterface, List<String> type, int interval ) {

this.user = user;

this.token = token;

this.security = security;

this.tinterface = tinterface;

this.type = type;

this.interval = interval;

}

}

public static class getOrderResponse {

public int result;

public String message;

public List<orderTick> order;

public orderHeartbeat heartbeat;

public String timestamp;

}

public static class orderTick {

public int tempid;

public String orderid;

public String fixid;

public String account;

public String tinterface;

public String security;

public int pips;

public int quantity;

public String side;

public String type;

public double limitprice;

public int maxshowquantity;

public String timeinforce;

public int seconds;

public int milliseconds;

public String expiration;

public double finishedprice;

public int finishedquantity;

public String commcurrency;

public double commission;

public double priceatstart;

public int userparam;

public String status;

public String reason;

}

public static class orderHeartbeat {

public List<String> security;

public List<String> tinterface;

}

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 continuous responses from server (streaming)

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

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.getOrderResponse != null){

if (response.getOrderResponse.timestamp != null){

System.out.println("Response timestamp: " + response.getOrderResponse.timestamp + " Contents:");

}

if (response.getOrderResponse.order!= null){

for (orderTick tick : response.getOrderResponse.order){

System.out.println("TempId: " + tick.tempid + " OrderId: " + tick.orderid + " Security: " + tick.security + " Account: " + tick.account + " Quantity: " + tick.quantity + " Type: " + tick.type + " Side: " + tick.side + " Status: " + tick.status);

}

}

if (response.getOrderResponse.heartbeat!= null){

System.out.println("Heartbeat!");

}

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

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

}

}

}

}

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

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

return entity != null ? EntityUtils.toString(entity) : 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 order request

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

hftrequest = new hftRequest(user, token, Arrays.asList("EUR/USD", "GBP/JPY", "GBP/USD"), null, null, interval);

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_stream + 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 orderStreaming() {

super();

}