HTTP Socket Tutorial

package com.sitewhere.test;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.client.RestTemplate;

/**
 * JUnit test cases for sending sample LoRa payloads over a socket connection.
 * 
 * @author Derek
 */
public class LoRaTests {

	/** URL for accessing SiteWhere */
	private static final String URL = "http://localhost:8484/lora";

	/**
	 * Send a LoRa payload to SiteWhere which is listening for a socket connection.
	 */
	@Test
	public void sendLoRaPayload() throws Exception {
		// Use Spring REST client.

		RestTemplate client = new RestTemplate();

		// Set up JSON payload encoding.

		List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>();
		converters.add(new MappingJackson2HttpMessageConverter());
		client.setMessageConverters(converters);

		// Create payload to mock OSS.

		LoRaPayload lora = createLoRaPayload();

		HttpHeaders headers = new HttpHeaders();
		HttpEntity<LoRaPayload> entity = new HttpEntity<LoRaPayload>(lora, headers);
		ResponseEntity<Void> response = client.exchange(URL, HttpMethod.POST, entity, Void.class);
		response.getStatusCode();
	}

	/**
	 * Create a sample payload.
	 * 
	 * @return
	 */
	protected LoRaPayload createLoRaPayload() {
		LoRaPayload lora = new LoRaPayload();
		lora.setDeveui("hex");
		lora.setDataFrame("AB==");
		lora.setPort(1);
		lora.setTimestamp("2015-02-11 10:33:00.578");
		lora.setFcnt(138);
		lora.setRssi(-111);
		lora.setSnr(-6);
		lora.setSf_used("8");
		lora.setId(278998);
		lora.setLive(true);
		lora.setDecrypted(false);
		return lora;
	}

	public static class LoRaPayload {

		// DevEUI of source node

		private String deveui;

		// Raw (encrypted) payload in base64 format

		private String dataFrame;

		// MAC port the message was receive on

		private int port;

		// Time of reception in GMT

		private String timestamp;

		// Uplink fcnt (needed for decryption)

		private int fcnt;

		// RSSI from gateway

		private int rssi;

		// SNR from gateway

		private int snr;

		// Used spreading factor

		private String sf_used;

		// Unique identifier (64-bit) of payload.

		private long id;

		// Indicate if the message is live, or

		// resent from the temporary storage

		private boolean live;

		// Set true if the DASS decrypted the payload,

		// false if the message is still encrypted.

		private boolean decrypted;

		public String getDeveui() {
			return deveui;
		}

		public void setDeveui(String deveui) {
			this.deveui = deveui;
		}

		public String getDataFrame() {
			return dataFrame;
		}

		public void setDataFrame(String dataFrame) {
			this.dataFrame = dataFrame;
		}

		public int getPort() {
			return port;
		}

		public void setPort(int port) {
			this.port = port;
		}

		public String getTimestamp() {
			return timestamp;
		}

		public void setTimestamp(String timestamp) {
			this.timestamp = timestamp;
		}

		public int getFcnt() {
			return fcnt;
		}

		public void setFcnt(int fcnt) {
			this.fcnt = fcnt;
		}

		public int getRssi() {
			return rssi;
		}

		public void setRssi(int rssi) {
			this.rssi = rssi;
		}

		public int getSnr() {
			return snr;
		}

		public void setSnr(int snr) {
			this.snr = snr;
		}

		public String getSf_used() {
			return sf_used;
		}

		public void setSf_used(String sf_used) {
			this.sf_used = sf_used;
		}

		public long getId() {
			return id;
		}

		public void setId(long id) {
			this.id = id;
		}

		public boolean isLive() {
			return live;
		}

		public void setLive(boolean live) {
			this.live = live;
		}

		public boolean isDecrypted() {
			return decrypted;
		}

		public void setDecrypted(boolean decrypted) {
			this.decrypted = decrypted;
		}
	}
}

import com.fasterxml.jackson.databind.*
import com.sitewhere.rest.model.device.communication.*;
import com.sitewhere.rest.model.device.event.request.*;
import com.sitewhere.spi.device.event.request.*;

// Create String from payload and parse as Jackson JsonNode.

def message = new String(payload);
def mapper = new ObjectMapper()
def json = mapper.readTree(message) 

// Parse Id from JSON.

def jsonId = json.get("id")
if (jsonId == null) {
	throw new RuntimeException("No id value passed.")
}

// Parse RSSI and SNR from JSON.

def jsonRSSI = json.get("rssi")
def jsonSNR = json.get("snr")

// Build a request for adding a new measurements event.

def decoded = new DecodedDeviceRequest<IDeviceMeasurementsCreateRequest>()

// Use 'id' value as device hardware id.

decoded.setHardwareId(jsonId.asText());
  
// Add measurements to event create request if they are present.

def mxs = new DeviceMeasurementsCreateRequest()
if (jsonRSSI != null) {
	logger.info("RSSI: " + jsonRSSI.asInt())
	mxs.addOrReplaceMeasurement("rssi", jsonRSSI.asInt())
}
if (jsonSNR != null) {
	logger.info("SNR: " + jsonSNR.asInt())
	mxs.addOrReplaceMeasurement("snr", jsonSNR.asInt())
}
mxs.setEventDate(new java.util.Date())
decoded.setRequest(mxs)
  
events.add(decoded);