added migrated 2.x add-ons

Signed-off-by: Kai Kreuzer <kai@openhab.org>

bundles/org.openhab.binding.deconz/src/test/java/org/openhab/binding/deconz/DeconzTest.java

@@ -0,0 +1,107 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.deconz;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.times;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+
+import org.apache.commons.io.IOUtils;
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.openhab.binding.deconz.internal.Util;
+import org.openhab.binding.deconz.internal.discovery.ThingDiscoveryService;
+import org.openhab.binding.deconz.internal.dto.BridgeFullState;
+import org.openhab.binding.deconz.internal.handler.DeconzBridgeHandler;
+import org.openhab.binding.deconz.internal.types.LightType;
+import org.openhab.binding.deconz.internal.types.LightTypeDeserializer;
+import org.openhab.binding.deconz.internal.types.ThermostatMode;
+import org.openhab.binding.deconz.internal.types.ThermostatModeGsonTypeAdapter;
+import org.openhab.core.config.discovery.DiscoveryListener;
+import org.openhab.core.library.types.DateTimeType;
+import org.openhab.core.thing.Bridge;
+import org.openhab.core.thing.ThingUID;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+/**
+ * This class provides tests for deconz binding
+ *
+ * @author Jan N. Klug - Initial contribution
+ */
+@NonNullByDefault
+public class DeconzTest {
+    private @NonNullByDefault({}) Gson gson;
+
+    @Mock
+    private @NonNullByDefault({}) DiscoveryListener discoveryListener;
+
+    @Mock
+    private @NonNullByDefault({}) DeconzBridgeHandler bridgeHandler;
+
+    @Mock
+    private @NonNullByDefault({}) Bridge bridge;
+
+    @Before
+    public void initialize() {
+        initMocks(this);
+
+        Mockito.doAnswer(answer -> bridge).when(bridgeHandler).getThing();
+        Mockito.doAnswer(answer -> new ThingUID("deconz", "mybridge")).when(bridge).getUID();
+
+        GsonBuilder gsonBuilder = new GsonBuilder();
+        gsonBuilder.registerTypeAdapter(LightType.class, new LightTypeDeserializer());
+        gsonBuilder.registerTypeAdapter(ThermostatMode.class, new ThermostatModeGsonTypeAdapter());
+        gson = gsonBuilder.create();
+    }
+
+    @Test
+    public void discoveryTest() throws IOException {
+        BridgeFullState bridgeFullState = getObjectFromJson("discovery.json", BridgeFullState.class, gson);
+        Assert.assertNotNull(bridgeFullState);
+        Assert.assertEquals(6, bridgeFullState.lights.size());
+        Assert.assertEquals(9, bridgeFullState.sensors.size());
+
+        ThingDiscoveryService discoveryService = new ThingDiscoveryService();
+        discoveryService.setThingHandler(bridgeHandler);
+        discoveryService.addDiscoveryListener(discoveryListener);
+
+        discoveryService.stateRequestFinished(bridgeFullState);
+        Mockito.verify(discoveryListener, times(15)).thingDiscovered(any(), any());
+    }
+
+    public static <T> T getObjectFromJson(String filename, Class<T> clazz, Gson gson) throws IOException {
+        String json = IOUtils.toString(DeconzTest.class.getResourceAsStream(filename), StandardCharsets.UTF_8.name());
+        return gson.fromJson(json, clazz);
+    }
+
+    @Test
+    public void dateTimeConversionTest() {
+        DateTimeType dateTime = Util.convertTimestampToDateTime("2020-08-22T11:09Z");
+        Assert.assertEquals(new DateTimeType(ZonedDateTime.parse("2020-08-22T11:09:00Z")), dateTime);
+
+        dateTime = Util.convertTimestampToDateTime("2020-08-22T11:09:47");
+        Assert.assertEquals(
+                new DateTimeType(ZonedDateTime.parse("2020-08-22T11:09:47Z")).toZone(ZoneId.systemDefault()), dateTime);
+    }
+}

bundles/org.openhab.binding.deconz/src/test/java/org/openhab/binding/deconz/LightsTest.java

@@ -0,0 +1,189 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.deconz;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.MockitoAnnotations.initMocks;
+import static org.openhab.binding.deconz.internal.BindingConstants.*;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.openhab.binding.deconz.internal.StateDescriptionProvider;
+import org.openhab.binding.deconz.internal.dto.LightMessage;
+import org.openhab.binding.deconz.internal.handler.LightThingHandler;
+import org.openhab.binding.deconz.internal.types.LightType;
+import org.openhab.binding.deconz.internal.types.LightTypeDeserializer;
+import org.openhab.binding.deconz.internal.types.ThermostatMode;
+import org.openhab.binding.deconz.internal.types.ThermostatModeGsonTypeAdapter;
+import org.openhab.core.library.types.DecimalType;
+import org.openhab.core.library.types.PercentType;
+import org.openhab.core.thing.Bridge;
+import org.openhab.core.thing.ChannelUID;
+import org.openhab.core.thing.Thing;
+import org.openhab.core.thing.ThingUID;
+import org.openhab.core.thing.binding.ThingHandlerCallback;
+import org.openhab.core.thing.binding.builder.ChannelBuilder;
+import org.openhab.core.thing.binding.builder.ThingBuilder;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+/**
+ * This class provides tests for deconz lights
+ *
+ * @author Jan N. Klug - Initial contribution
+ */
+@NonNullByDefault
+public class LightsTest {
+    private @NonNullByDefault({}) Gson gson;
+
+    @Mock
+    private @NonNullByDefault({}) ThingHandlerCallback thingHandlerCallback;
+
+    @Mock
+    private @NonNullByDefault({}) StateDescriptionProvider stateDescriptionProvider;
+
+    @Before
+    public void initialize() {
+        initMocks(this);
+
+        GsonBuilder gsonBuilder = new GsonBuilder();
+        gsonBuilder.registerTypeAdapter(LightType.class, new LightTypeDeserializer());
+        gsonBuilder.registerTypeAdapter(ThermostatMode.class, new ThermostatModeGsonTypeAdapter());
+        gson = gsonBuilder.create();
+    }
+
+    @Test
+    public void colorTemperatureLightUpdateTest() throws IOException {
+        LightMessage lightMessage = DeconzTest.getObjectFromJson("colortemperature.json", LightMessage.class, gson);
+        Assert.assertNotNull(lightMessage);
+
+        ThingUID thingUID = new ThingUID("deconz", "light");
+        ChannelUID channelUID_bri = new ChannelUID(thingUID, CHANNEL_BRIGHTNESS);
+        ChannelUID channelUID_ct = new ChannelUID(thingUID, CHANNEL_COLOR_TEMPERATURE);
+
+        Thing light = ThingBuilder.create(THING_TYPE_COLOR_TEMPERATURE_LIGHT, thingUID)
+                .withChannel(ChannelBuilder.create(channelUID_bri, "Dimmer").build())
+                .withChannel(ChannelBuilder.create(channelUID_ct, "Number").build()).build();
+        LightThingHandler lightThingHandler = new LightThingHandler(light, gson, stateDescriptionProvider);
+        lightThingHandler.setCallback(thingHandlerCallback);
+
+        lightThingHandler.messageReceived("", lightMessage);
+        Mockito.verify(thingHandlerCallback).stateUpdated(eq(channelUID_bri), eq(new PercentType("21")));
+        Mockito.verify(thingHandlerCallback).stateUpdated(eq(channelUID_ct), eq(new DecimalType("2500")));
+    }
+
+    @Test
+    public void colorTemperatureLightStateDescriptionProviderTest() {
+        ThingUID thingUID = new ThingUID("deconz", "light");
+        ChannelUID channelUID_bri = new ChannelUID(thingUID, CHANNEL_BRIGHTNESS);
+        ChannelUID channelUID_ct = new ChannelUID(thingUID, CHANNEL_COLOR_TEMPERATURE);
+
+        Map<String, String> properties = new HashMap<>();
+        properties.put(PROPERTY_CT_MAX, "500");
+        properties.put(PROPERTY_CT_MIN, "200");
+
+        Thing light = ThingBuilder.create(THING_TYPE_COLOR_TEMPERATURE_LIGHT, thingUID).withProperties(properties)
+                .withChannel(ChannelBuilder.create(channelUID_bri, "Dimmer").build())
+                .withChannel(ChannelBuilder.create(channelUID_ct, "Number").build()).build();
+        LightThingHandler lightThingHandler = new LightThingHandler(light, gson, stateDescriptionProvider) {
+            // avoid warning when initializing
+            @Override
+            public @Nullable Bridge getBridge() {
+                return null;
+            }
+        };
+
+        lightThingHandler.initialize();
+
+        Mockito.verify(stateDescriptionProvider).setDescription(eq(channelUID_ct), any());
+    }
+
+    @Test
+    public void dimmableLightUpdateTest() throws IOException {
+        LightMessage lightMessage = DeconzTest.getObjectFromJson("dimmable.json", LightMessage.class, gson);
+        Assert.assertNotNull(lightMessage);
+
+        ThingUID thingUID = new ThingUID("deconz", "light");
+        ChannelUID channelUID_bri = new ChannelUID(thingUID, CHANNEL_BRIGHTNESS);
+
+        Thing light = ThingBuilder.create(THING_TYPE_DIMMABLE_LIGHT, thingUID)
+                .withChannel(ChannelBuilder.create(channelUID_bri, "Dimmer").build()).build();
+        LightThingHandler lightThingHandler = new LightThingHandler(light, gson, stateDescriptionProvider);
+        lightThingHandler.setCallback(thingHandlerCallback);
+
+        lightThingHandler.messageReceived("", lightMessage);
+        Mockito.verify(thingHandlerCallback).stateUpdated(eq(channelUID_bri), eq(new PercentType("38")));
+    }
+
+    @Test
+    public void dimmableLightOverrangeUpdateTest() throws IOException {
+        LightMessage lightMessage = DeconzTest.getObjectFromJson("dimmable_overrange.json", LightMessage.class, gson);
+        Assert.assertNotNull(lightMessage);
+
+        ThingUID thingUID = new ThingUID("deconz", "light");
+        ChannelUID channelUID_bri = new ChannelUID(thingUID, CHANNEL_BRIGHTNESS);
+
+        Thing light = ThingBuilder.create(THING_TYPE_DIMMABLE_LIGHT, thingUID)
+                .withChannel(ChannelBuilder.create(channelUID_bri, "Dimmer").build()).build();
+        LightThingHandler lightThingHandler = new LightThingHandler(light, gson, stateDescriptionProvider);
+        lightThingHandler.setCallback(thingHandlerCallback);
+
+        lightThingHandler.messageReceived("", lightMessage);
+        Mockito.verify(thingHandlerCallback).stateUpdated(eq(channelUID_bri), eq(new PercentType("100")));
+    }
+
+    @Test
+    public void dimmableLightUnderrangeUpdateTest() throws IOException {
+        LightMessage lightMessage = DeconzTest.getObjectFromJson("dimmable_underrange.json", LightMessage.class, gson);
+        Assert.assertNotNull(lightMessage);
+
+        ThingUID thingUID = new ThingUID("deconz", "light");
+        ChannelUID channelUID_bri = new ChannelUID(thingUID, CHANNEL_BRIGHTNESS);
+
+        Thing light = ThingBuilder.create(THING_TYPE_DIMMABLE_LIGHT, thingUID)
+                .withChannel(ChannelBuilder.create(channelUID_bri, "Dimmer").build()).build();
+        LightThingHandler lightThingHandler = new LightThingHandler(light, gson, stateDescriptionProvider);
+        lightThingHandler.setCallback(thingHandlerCallback);
+
+        lightThingHandler.messageReceived("", lightMessage);
+        Mockito.verify(thingHandlerCallback).stateUpdated(eq(channelUID_bri), eq(new PercentType("0")));
+    }
+
+    @Test
+    public void windowCoveringUpdateTest() throws IOException {
+        LightMessage lightMessage = DeconzTest.getObjectFromJson("windowcovering.json", LightMessage.class, gson);
+        Assert.assertNotNull(lightMessage);
+
+        ThingUID thingUID = new ThingUID("deconz", "light");
+        ChannelUID channelUID_pos = new ChannelUID(thingUID, CHANNEL_POSITION);
+
+        Thing light = ThingBuilder.create(THING_TYPE_WINDOW_COVERING, thingUID)
+                .withChannel(ChannelBuilder.create(channelUID_pos, "Rollershutter").build()).build();
+        LightThingHandler lightThingHandler = new LightThingHandler(light, gson, stateDescriptionProvider);
+        lightThingHandler.setCallback(thingHandlerCallback);
+
+        lightThingHandler.messageReceived("", lightMessage);
+        Mockito.verify(thingHandlerCallback).stateUpdated(eq(channelUID_pos), eq(new PercentType("41")));
+    }
+}

bundles/org.openhab.binding.deconz/src/test/java/org/openhab/binding/deconz/SensorsTest.java

@@ -0,0 +1,116 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.deconz;
+
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.MockitoAnnotations.initMocks;
+import static org.openhab.binding.deconz.internal.BindingConstants.*;
+
+import java.io.IOException;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.openhab.binding.deconz.internal.dto.SensorMessage;
+import org.openhab.binding.deconz.internal.handler.SensorThermostatThingHandler;
+import org.openhab.binding.deconz.internal.handler.SensorThingHandler;
+import org.openhab.binding.deconz.internal.types.LightType;
+import org.openhab.binding.deconz.internal.types.LightTypeDeserializer;
+import org.openhab.binding.deconz.internal.types.ThermostatMode;
+import org.openhab.binding.deconz.internal.types.ThermostatModeGsonTypeAdapter;
+import org.openhab.core.library.types.OnOffType;
+import org.openhab.core.library.types.QuantityType;
+import org.openhab.core.library.types.StringType;
+import org.openhab.core.library.unit.SIUnits;
+import org.openhab.core.library.unit.SmartHomeUnits;
+import org.openhab.core.thing.ChannelUID;
+import org.openhab.core.thing.Thing;
+import org.openhab.core.thing.ThingUID;
+import org.openhab.core.thing.binding.ThingHandlerCallback;
+import org.openhab.core.thing.binding.builder.ChannelBuilder;
+import org.openhab.core.thing.binding.builder.ThingBuilder;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+/**
+ * This class provides tests for deconz sensors
+ *
+ * @author Jan N. Klug - Initial contribution
+ * @author Lukas Agethen - Added Thermostat
+ */
+@NonNullByDefault
+public class SensorsTest {
+    private @NonNullByDefault({}) Gson gson;
+
+    @Mock
+    private @NonNullByDefault({}) ThingHandlerCallback thingHandlerCallback;
+
+    @Before
+    public void initialize() {
+        initMocks(this);
+
+        GsonBuilder gsonBuilder = new GsonBuilder();
+        gsonBuilder.registerTypeAdapter(LightType.class, new LightTypeDeserializer());
+        gsonBuilder.registerTypeAdapter(ThermostatMode.class, new ThermostatModeGsonTypeAdapter());
+        gson = gsonBuilder.create();
+    }
+
+    @Test
+    public void carbonmonoxideSensorUpdateTest() throws IOException {
+        SensorMessage sensorMessage = DeconzTest.getObjectFromJson("carbonmonoxide.json", SensorMessage.class, gson);
+        Assert.assertNotNull(sensorMessage);
+
+        ThingUID thingUID = new ThingUID("deconz", "sensor");
+        ChannelUID channelUID = new ChannelUID(thingUID, "carbonmonoxide");
+        Thing sensor = ThingBuilder.create(THING_TYPE_CARBONMONOXIDE_SENSOR, thingUID)
+                .withChannel(ChannelBuilder.create(channelUID, "Switch").build()).build();
+        SensorThingHandler sensorThingHandler = new SensorThingHandler(sensor, gson);
+        sensorThingHandler.setCallback(thingHandlerCallback);
+
+        sensorThingHandler.messageReceived("", sensorMessage);
+        Mockito.verify(thingHandlerCallback).stateUpdated(eq(channelUID), eq(OnOffType.ON));
+    }
+
+    @Test
+    public void thermostatSensorUpdateTest() throws IOException {
+        SensorMessage sensorMessage = DeconzTest.getObjectFromJson("thermostat.json", SensorMessage.class, gson);
+        Assert.assertNotNull(sensorMessage);
+
+        ThingUID thingUID = new ThingUID("deconz", "sensor");
+        ChannelUID channelValveUID = new ChannelUID(thingUID, "valve");
+        ChannelUID channelHeatSetPointUID = new ChannelUID(thingUID, "heatsetpoint");
+        ChannelUID channelModeUID = new ChannelUID(thingUID, "mode");
+        ChannelUID channelTemperatureUID = new ChannelUID(thingUID, "temperature");
+        Thing sensor = ThingBuilder.create(THING_TYPE_THERMOSTAT, thingUID)
+                .withChannel(ChannelBuilder.create(channelValveUID, "Number").build())
+                .withChannel(ChannelBuilder.create(channelHeatSetPointUID, "Number").build())
+                .withChannel(ChannelBuilder.create(channelModeUID, "String").build())
+                .withChannel(ChannelBuilder.create(channelTemperatureUID, "Number").build()).build();
+        SensorThermostatThingHandler sensorThingHandler = new SensorThermostatThingHandler(sensor, gson);
+        sensorThingHandler.setCallback(thingHandlerCallback);
+
+        sensorThingHandler.messageReceived("", sensorMessage);
+        Mockito.verify(thingHandlerCallback).stateUpdated(eq(channelValveUID),
+                eq(new QuantityType<>(100.0, SmartHomeUnits.PERCENT)));
+        Mockito.verify(thingHandlerCallback).stateUpdated(eq(channelHeatSetPointUID),
+                eq(new QuantityType<>(25, SIUnits.CELSIUS)));
+        Mockito.verify(thingHandlerCallback).stateUpdated(eq(channelModeUID),
+                eq(new StringType(ThermostatMode.AUTO.name())));
+        Mockito.verify(thingHandlerCallback).stateUpdated(eq(channelTemperatureUID),
+                eq(new QuantityType<>(16.5, SIUnits.CELSIUS)));
+    }
+}

bundles/org.openhab.binding.deconz/src/test/resources/org/openhab/binding/deconz/carbonmonoxide.json

@@ -0,0 +1,21 @@
+{
+  "config": {
+    "battery": 100,
+    "on": true,
+    "reachable": true
+  },
+  "ep": 1,
+  "etag": "1902d2cdb9d256624398f9ec3d35481d",
+  "manufacturername": "Heiman",
+  "modelid": "COSensor-N",
+  "name": "CO Sensor",
+  "state": {
+    "carbonmonoxide": true,
+    "lastupdated": "none",
+    "lowbattery": null,
+    "tampered": null
+  },
+  "swversion": "2018.4.22",
+  "type": "ZHACarbonMonoxide",
+  "uniqueid": "00:28:9f:00:03:eb:80:2a-01-0500"
+}

bundles/org.openhab.binding.deconz/src/test/resources/org/openhab/binding/deconz/colortemperature.json

@@ -0,0 +1,15 @@
+{
+  "e": "changed",
+  "id": "3",
+  "r": "lights",
+  "state": {
+    "alert": null,
+    "bri": 51,
+    "colormode": "ct",
+    "ct": 400,
+    "on": true,
+    "reachable": true
+  },
+  "t": "event",
+  "uniqueid": "00:0b:57:ff:fe:eb:2f:84-01"
+}

bundles/org.openhab.binding.deconz/src/test/resources/org/openhab/binding/deconz/dimmable.json

@@ -0,0 +1,13 @@
+{
+  "e": "changed",
+  "id": "4",
+  "r": "lights",
+  "state": {
+    "alert": null,
+    "bri": 96,
+    "on": true,
+    "reachable": true
+  },
+  "t": "event",
+  "uniqueid": "00:0b:57:ff:fe:c5:34:c4-01"
+}

bundles/org.openhab.binding.deconz/src/test/resources/org/openhab/binding/deconz/dimmable_overrange.json

@@ -0,0 +1,13 @@
+{
+  "e": "changed",
+  "id": "4",
+  "r": "lights",
+  "state": {
+    "alert": null,
+    "bri": 270,
+    "on": true,
+    "reachable": true
+  },
+  "t": "event",
+  "uniqueid": "00:0b:57:ff:fe:c5:34:c4-01"
+}

bundles/org.openhab.binding.deconz/src/test/resources/org/openhab/binding/deconz/dimmable_underrange.json

@@ -0,0 +1,13 @@
+{
+  "e": "changed",
+  "id": "4",
+  "r": "lights",
+  "state": {
+    "alert": null,
+    "bri": -1,
+    "on": true,
+    "reachable": true
+  },
+  "t": "event",
+  "uniqueid": "00:0b:57:ff:fe:c5:34:c4-01"
+}

bundles/org.openhab.binding.deconz/src/test/resources/org/openhab/binding/deconz/thermostat.json

@@ -0,0 +1,27 @@
+{
+    "config": {
+        "battery": 85,
+        "displayflipped": null,
+        "heatsetpoint": 2500,
+        "locked": null,
+        "mode": "auto",
+        "offset": 0,
+        "on": true,
+        "reachable": true
+    },
+    "ep": 1,
+    "etag": "717549a99371f3ea1a5f0b40f1537094",
+    "lastseen": "2020-05-31T20:24:55.819",
+    "manufacturername": "Eurotronic",
+    "modelid": "SPZB0001",
+    "name": "Test Thermostat",
+    "state": {
+        "lastupdated": "2020-05-31T20:24:55.819",
+        "on": true,
+        "temperature": 1650,
+        "valve": 255
+    },
+    "swversion": "20191014",
+    "type": "ZHAThermostat",
+    "uniqueid": "00:15:8d:00:01:ff:8a:00-01-0201"
+}

bundles/org.openhab.binding.deconz/src/test/resources/org/openhab/binding/deconz/windowcovering.json

@@ -0,0 +1,13 @@
+{
+  "e": "changed",
+  "id": "6",
+  "r": "lights",
+  "state": {
+    "alert": null,
+    "bri": 102,
+    "on": true,
+    "reachable": true
+  },
+  "t": "event",
+  "uniqueid": "68:0a:e2:ff:fe:6e:95:af-01"
+}