prepared API example of AFarCloud

connector-model/src/main/java/io/connector/model/afarcloud/Observation.java

@@ -0,0 +1,113 @@
+package io.connector.model.afarcloud;
+
+public class Observation {
+
+    private String time;
+    private Integer altitude;
+    private Double latitude;
+    private Double longitude;
+    private String geohash;
+    private Double value;
+    private String entityName;
+    private String sequenceNumber;
+    private String service;
+    private String provider;
+    private String type;
+    private String uom;
+
+    public String getTime() {
+        return time;
+    }
+
+    public void setTime(String time) {
+        this.time = time;
+    }
+
+    public Integer getAltitude() {
+        return altitude;
+    }
+
+    public void setAltitude(Integer altitude) {
+        this.altitude = altitude;
+    }
+
+    public Double getLatitude() {
+        return latitude;
+    }
+
+    public void setLatitude(Double latitude) {
+        this.latitude = latitude;
+    }
+
+    public Double getLongitude() {
+        return longitude;
+    }
+
+    public void setLongitude(Double longitude) {
+        this.longitude = longitude;
+    }
+
+    public String getGeohash() {
+        return geohash;
+    }
+
+    public void setGeohash(String geohash) {
+        this.geohash = geohash;
+    }
+
+    public Double getValue() {
+        return value;
+    }
+
+    public void setValue(Double value) {
+        this.value = value;
+    }
+
+    public String getEntityName() {
+        return entityName;
+    }
+
+    public void setEntityName(String entityName) {
+        this.entityName = entityName;
+    }
+
+    public String getSequenceNumber() {
+        return sequenceNumber;
+    }
+
+    public void setSequenceNumber(String sequenceNumber) {
+        this.sequenceNumber = sequenceNumber;
+    }
+
+    public String getService() {
+        return service;
+    }
+
+    public void setService(String service) {
+        this.service = service;
+    }
+
+    public String getProvider() {
+        return provider;
+    }
+
+    public void setProvider(String provider) {
+        this.provider = provider;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public String getUom() {
+        return uom;
+    }
+
+    public void setUom(String uom) {
+        this.uom = uom;
+    }
+}

connector-model/src/main/java/io/connector/model/afarcloud/ResourceMeasurement.java

@@ -0,0 +1,25 @@
+package io.connector.model.afarcloud;
+
+import java.util.List;
+
+public class ResourceMeasurement {
+
+    private String resource;
+    private List<SensorTelemetry> measurements;
+
+    public String getResource() {
+        return resource;
+    }
+
+    public void setResource(String resource) {
+        this.resource = resource;
+    }
+
+    public List<SensorTelemetry> getMeasurements() {
+        return measurements;
+    }
+
+    public void setMeasurements(List<SensorTelemetry> measurements) {
+        this.measurements = measurements;
+    }
+}

connector-model/src/main/java/io/connector/model/afarcloud/ResponseModel.java

@@ -0,0 +1,55 @@
+package io.connector.model.afarcloud;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ResponseModel<T> {
+
+    private String query;
+    private Map<String, String> params;
+    private int numResults;
+    private List<T> results;
+
+    public ResponseModel() {
+        this.params = new HashMap<>();
+        this.results = new ArrayList<>();
+    }
+
+    public String getQuery() {
+        return query;
+    }
+
+    public void setQuery(String query) {
+        this.query = query;
+    }
+
+    public Map<String, String> getParams() {
+        return params;
+    }
+
+    public void setParams(Map<String, String> params) {
+        this.params = params;
+    }
+
+    public void addParam(String name, String value) {
+        this.params.put(name, value);
+    }
+
+    public int getNumResults() {
+        return numResults;
+    }
+
+    public void setNumResults(int numResults) {
+        this.numResults = numResults;
+    }
+
+    public List<T> getResults() {
+        return results;
+    }
+
+    public void setResults(List<T> results) {
+        this.results = results;
+    }
+}

connector-model/src/main/java/io/connector/model/afarcloud/SensorTelemetry.java

@@ -0,0 +1,33 @@
+package io.connector.model.afarcloud;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SensorTelemetry {
+
+    private String measurement;
+    private List<Observation> observations;
+
+    public String getMeasurement() {
+        return measurement;
+    }
+
+    public void setMeasurement(String measurement) {
+        this.measurement = measurement;
+    }
+
+    public List<Observation> getObservations() {
+        return observations;
+    }
+
+    public void addObservation(Observation observation) {
+        if (this.observations == null) {
+            this.observations = new ArrayList<>();
+        }
+        this.observations.add(observation);
+    }
+
+    public void setObservations(List<Observation> observations) {
+        this.observations = observations;
+    }
+}

connector-module-ogc-sensorthings/src/main/java/io/connector/module/ogc/sensorthings/SensorThingsModule.java

@@ -1,8 +1,9 @@
 package io.connector.module.ogc.sensorthings;
 
-import io.connector.core.ModuleDescriptor;
 import io.connector.core.AbstractModule;
+import io.connector.core.ModuleDescriptor;
 import io.connector.core.ModuleInfo;
+import io.connector.module.ogc.sensorthings.gateway.AFarCloudGateway;
 import io.connector.module.ogc.sensorthings.gateway.SensorThingsGateway;
 
 public class SensorThingsModule extends AbstractModule {
@@ -17,6 +18,7 @@ public class SensorThingsModule extends AbstractModule {
     @Override
     public void run() {
         registerGateway(new SensorThingsGateway("OGCSensorThings", client));
+        registerGateway(new AFarCloudGateway("AFarCloud", client));
     }
 
     @Override

connector-module-ogc-sensorthings/src/main/java/io/connector/module/ogc/sensorthings/gateway/AFarCloudGateway.java

@@ -0,0 +1,246 @@
+package io.connector.module.ogc.sensorthings.gateway;
+
+import io.connector.core.AbstractGateway;
+import io.connector.model.afarcloud.Observation;
+import io.connector.model.afarcloud.ResourceMeasurement;
+import io.connector.model.afarcloud.ResponseModel;
+import io.connector.model.afarcloud.SensorTelemetry;
+import io.connector.module.ogc.sensorthings.SensorThingsClient;
+import io.vertx.core.MultiMap;
+import io.vertx.core.http.HttpServerRequest;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+
+import static cz.senslog.common.http.HttpContentType.APPLICATION_JSON;
+import static cz.senslog.common.http.HttpHeader.CONTENT_TYPE;
+import static io.connector.core.AddressPath.Creator.create;
+import static io.vertx.core.json.Json.encode;
+import static java.lang.Double.parseDouble;
+import static java.lang.Integer.parseInt;
+import static java.lang.String.format;
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
+import static java.util.Comparator.comparing;
+
+public class AFarCloudGateway extends AbstractGateway {
+
+    private final SensorThingsClient client;
+
+    public AFarCloudGateway(String id, SensorThingsClient client) {
+        super(id);
+        this.client = client;
+    }
+
+    private static String getRequiredParam(MultiMap params, String paramName) {
+        String param = getParam(params, paramName);
+        if (param == null) {
+            throw new IllegalArgumentException(format("Parameter '%s' is required.", paramName));
+        }
+        return param;
+    }
+
+    private static String getParam(MultiMap params, String paramName) {
+        return params.contains(paramName) ? params.get(paramName) : null;
+    }
+
+    private static String getParam(MultiMap params, String paramName, String defValue) {
+        return params.contains(paramName) ? params.get(paramName) : defValue;
+    }
+
+    private static List<String> getSplittedParam(MultiMap params, String paramName, String splitter) {
+        String param = getParam(params, paramName);
+        return param != null ? asList(param.split(splitter)) : emptyList();
+    }
+
+    @Override
+    protected void run() {
+
+        // Query sensor telemetry
+        router().get(create("getSensorTelemetry/latest")).handler(ctx -> {
+
+            HttpServerRequest req = ctx.request();
+            MultiMap params = req.params();
+
+            final int limit = parseInt(getRequiredParam(params, "limit"));
+            final List<String> entityNames = getSplittedParam(params, "entityNames", ",");
+            final List<String> devices = getSplittedParam(params, "devices", ",");
+            final List<String> services = getSplittedParam(params, "services", ",");
+            final List<String> types = getSplittedParam(params, "types", ",");
+            final List<String> providers = getSplittedParam(params, "providers", ",");
+            final List<String> measurements = getSplittedParam(params, "measurements", ",");
+            final Integer minAltitude = params.contains("altitude") ? parseInt(params.get("altitude")) : null; // TODO
+            final String order = getParam(params, "order", "DESC").toUpperCase();
+
+            ResponseModel<SensorTelemetry> responseModel = new ResponseModel<>();
+
+            for (Map.Entry<String, String> entry : params.entries()) {
+                responseModel.addParam(entry.getKey(), entry.getValue());
+            }
+            responseModel.setQuery(req.path()+"&"+req.query());
+
+            // GET all telemetries
+            List<SensorTelemetry> telemetries = new ArrayList<>(limit);
+            for (int i = 0; i < limit; i++) {
+                SensorTelemetry telemetry = new SensorTelemetry();
+                telemetry.setMeasurement("wind_speed");
+
+                Observation observation = new Observation();
+                observation.setTime("2020-04-19T14:17:00Z");
+                observation.setAltitude(282);
+                observation.setLatitude(50.0393219);
+                observation.setLongitude(14.6106731);
+                observation.setGeohash("u2fksmrhjmeq");
+                observation.setValue(0.55);
+                observation.setEntityName("1305167562287832");
+                observation.setSequenceNumber("123");
+                observation.setService("environmentalObservations");
+                observation.setProvider("LESP");
+                observation.setType("air_sensor");
+                observation.setUom("http://qudt.org/vocab/unit/M-PER-SEC");
+                telemetry.addObservation(observation);
+
+                telemetries.add(telemetry);
+            }
+            responseModel.setNumResults(telemetries.size());
+
+            Comparator<SensorTelemetry> comparator = comparing(SensorTelemetry::getMeasurement);
+            if (order.equals("DESC")) {
+                comparator = comparator.reversed();
+            }
+            telemetries.sort(comparator);
+
+            responseModel.setResults(telemetries);
+            ctx.response().putHeader(CONTENT_TYPE, APPLICATION_JSON).end(encode(responseModel));
+        });
+
+        router().get(create("getObservationsBySensor/latest")).handler(ctx -> {
+
+            HttpServerRequest req = ctx.request();
+            MultiMap params = req.params();
+
+            final int limit = parseInt(getRequiredParam(params, "limit"));
+            final List<String> entityNames = getSplittedParam(params, "entityNames", ",");
+            final List<String> devices = getSplittedParam(params, "devices", ",");
+            final List<String> services = getSplittedParam(params, "services", ",");
+            final List<String> types = getSplittedParam(params, "types", ",");
+            final List<String> providers = getSplittedParam(params, "providers", ",");
+            final List<String> measurements = getSplittedParam(params, "measurements", ",");
+            final String order = getParam(params, "order", "DESC").toUpperCase();
+            final Integer minAltitude = params.contains("altitude") ? parseInt(params.get("altitude")) : null; // TODO
+            final Double centrLong = params.contains("centr_long") ? parseDouble(params.get("centr_long")) : null; // TODO
+            final Double centrLat = params.contains("centr_lat") ? parseDouble(params.get("centr_lat")) : null; // TODO
+            final Integer radius = params.contains("radius") ? parseInt(params.get("radius")) : null; // TODO
+
+            ResponseModel<ResourceMeasurement> responseModel = new ResponseModel<>();
+
+            for (Map.Entry<String, String> entry : params.entries()) {
+                responseModel.addParam(entry.getKey(), entry.getValue());
+            }
+            responseModel.setQuery(req.path()+"&"+req.query());
+
+            ResourceMeasurement measurement = new ResourceMeasurement();
+            measurement.setResource("10002376");
+            responseModel.setResults(singletonList(measurement));
+
+            SensorTelemetry telemetry = new SensorTelemetry();
+            telemetry.setMeasurement("wind_speed");
+            measurement.setMeasurements(singletonList(telemetry));
+
+            for (int i = 0; i < limit; i++) {
+                Observation observation = new Observation();
+                observation.setTime("2020-04-19T14:17:00Z");
+                observation.setAltitude(282);
+                observation.setLatitude(50.0393219);
+                observation.setLongitude(14.6106731);
+                observation.setGeohash("u2fksmrhjmeq");
+                observation.setValue(0.55);
+                observation.setEntityName("1305167562287832");
+                observation.setSequenceNumber("123");
+                observation.setService("environmentalObservations");
+                observation.setProvider("LESP");
+                observation.setType("air_sensor");
+                observation.setUom("http://qudt.org/vocab/unit/M-PER-SEC");
+                telemetry.addObservation(observation);
+            }
+
+            int counter = 0;
+            for (ResourceMeasurement result : responseModel.getResults()) {
+
+                Comparator<SensorTelemetry> comparator = comparing(SensorTelemetry::getMeasurement);
+                if (order.equals("DESC")) {
+                    comparator = comparator.reversed();
+                }
+                result.getMeasurements().sort(comparator);
+
+                for (SensorTelemetry resultMeasurement : result.getMeasurements()) {
+                    counter += resultMeasurement.getObservations().size();
+                }
+            }
+            responseModel.setNumResults(counter);
+
+            ctx.response().putHeader(CONTENT_TYPE, APPLICATION_JSON).end(encode(responseModel));
+        });
+
+        // Query sensor telemetry interval
+        router().get(create("getSensorTelemetry/historic")).handler(ctx -> {
+
+            HttpServerRequest req = ctx.request();
+            MultiMap params = req.params();
+
+            final int limit = 100;
+            final String startTime = getRequiredParam(params, "start_time");
+            final String endTime = getParam(params, "end_time");
+
+            ctx.response().putHeader(CONTENT_TYPE, APPLICATION_JSON).end(encode(null));
+        });
+
+        router().get(create("getObservationsBySensor/historic")).handler(ctx -> {
+
+            HttpServerRequest req = ctx.request();
+            MultiMap params = req.params();
+
+            final int limit = 100;
+            final String startTime = getRequiredParam(params, "start_time");
+            final String endTime = getParam(params, "end_time");
+
+            ctx.response().putHeader(CONTENT_TYPE, APPLICATION_JSON).end(encode(null));
+        });
+
+        // Query region telemetry
+        router().get(create("getRegionTelemetry/latest")).handler(ctx -> {
+
+        });
+
+        // Query region telemetry interval
+        router().get(create("getRegionTelemetry/historic")).handler(ctx -> {
+
+        });
+
+        // Query collar telemetry
+        router().get(create("getCollarTelemetry/latest")).handler(ctx -> {
+
+        });
+
+        router().get(create("getObservationsByCollar/latest")).handler(ctx -> {
+
+        });
+
+        router().get(create("getObservationsByCollar/historic")).handler(ctx -> {
+
+        });
+
+        // Query collar telemetry interval
+        router().get(create("getCollarTelemetry/historic")).handler(ctx -> {
+
+        });
+
+        // Schema-measurement
+        router().get(create("getMeasurements")).handler(ctx -> {
+
+        });
+    }
+}