feat: dexcom connector

dexcom-library/build.gradle

@@ -0,0 +1,49 @@
+
+group = 'org.radarbase'
+version = '0.0.1'
+
+apply plugin: 'maven-publish'
+
+repositories {
+    // Use jcenter for resolving dependencies.
+    // You can declare any Maven/Ivy/file repository here.
+    mavenCentral()
+}
+
+dependencies {
+    // Use the Kotlin JDK 8 standard library.
+    implementation libs.kotlin.stdlib
+
+    implementation libs.okhttp
+
+    implementation libs.radar.schemas.commons
+
+    implementation libs.jackson.annotations
+
+    implementation libs.jackson.databind
+
+    implementation libs.avro
+
+    implementation libs.jackson.datatype.jsr310
+
+    implementation libs.slf4j.api
+
+    // Use the Kotlin test library.
+    testImplementation libs.kotlin.test
+
+    // Use the Kotlin JUnit integration.
+    testImplementation libs.kotlin.test.junit
+}
+
+project.afterEvaluate {
+    publishing {
+        publications {
+            library(MavenPublication) {
+                setGroupId "$group"
+                setArtifactId "dexcom-library"
+                version "$version"
+                from components.java
+            }
+        }
+    }
+}

dexcom-library/src/main/kotlin/org/radarbase/dexcom/converter/DexcomAlertsConverter.kt

@@ -0,0 +1,46 @@
+package org.radarbase.dexcom.converter
+
+import com.fasterxml.jackson.databind.JsonNode
+import org.radarbase.dexcom.user.User
+import org.radarcns.connector.dexcom.DexcomAlert
+import java.time.Instant
+
+class DexcomAlertsConverter(
+    private val topic: String = "connect_dexcom_alert",
+) : DexcomDataConverter {
+    override fun processRecords(
+        root: JsonNode,
+        user: User,
+    ): Sequence<Result<TopicData>> {
+        val array = root.get("records")
+            ?: return emptySequence()
+        return array.asSequence()
+            .mapCatching {
+                val systemTimeInstant = DexcomEGVConverter.parseDexcomTime(it.get("systemTime").asText())
+                TopicData(
+                    key = user.observationKey,
+                    topic = topic,
+                    offset = systemTimeInstant.epochSecond,
+                    value = it.toDexcomAlert(systemTimeInstant),
+                )
+            }
+    }
+
+    private fun JsonNode.toDexcomAlert(systemTimeInstant: Instant): DexcomAlert =
+        DexcomAlert.newBuilder().apply {
+            recordId = get("recordId").asText()
+            systemTime = systemTimeInstant.epochSecond.toDouble()
+            displayTime = textOrNull("displayTime")
+            alertName = get("alertName").asText()
+            alertState = get("alertState").asText()
+            displayDevice = textOrNull("displayDevice")
+            transmitterGeneration = textOrNull("transmitterGeneration")
+            transmitterGenerationVariant = textOrNull("transmitterGenerationVariant")
+            transmitterId = textOrNull("transmitterId")
+            displayApp = textOrNull("displayApp")
+            timeReceived = System.currentTimeMillis() / 1000.0
+        }.build()
+
+    private fun JsonNode.textOrNull(field: String): String? =
+        get(field)?.takeIf { !it.isNull }?.asText()
+}

dexcom-library/src/main/kotlin/org/radarbase/dexcom/converter/DexcomCalibrationsConverter.kt

@@ -0,0 +1,52 @@
+package org.radarbase.dexcom.converter
+
+import com.fasterxml.jackson.databind.JsonNode
+import org.radarbase.dexcom.user.User
+import org.radarcns.connector.dexcom.DexcomCalibration
+import java.time.Instant
+
+class DexcomCalibrationsConverter(
+    private val topic: String = "connect_dexcom_calibration",
+) : DexcomDataConverter {
+    override fun processRecords(
+        root: JsonNode,
+        user: User,
+    ): Sequence<Result<TopicData>> {
+        val array = root.get("records")
+            ?: return emptySequence()
+        return array.asSequence()
+            .mapCatching {
+                val systemTimeInstant = DexcomEGVConverter.parseDexcomTime(it.get("systemTime").asText())
+                TopicData(
+                    key = user.observationKey,
+                    topic = topic,
+                    offset = systemTimeInstant.epochSecond,
+                    value = it.toDexcomCalibration(systemTimeInstant),
+                )
+            }
+    }
+
+    private fun JsonNode.toDexcomCalibration(systemTimeInstant: Instant): DexcomCalibration =
+        DexcomCalibration.newBuilder().apply {
+            recordId = get("recordId").asText()
+            systemTime = systemTimeInstant.epochSecond.toDouble()
+            displayTime = textOrNull("displayTime")
+            unit = textOrNull("unit")
+            value = intOrNull("value")
+            displayDevice = textOrNull("displayDevice")
+            transmitterId = textOrNull("transmitterId")
+            transmitterTicks = longOrNull("transmitterTicks")
+            transmitterGeneration = textOrNull("transmitterGeneration")
+            transmitterGenerationVariant = textOrNull("transmitterGenerationVariant")
+            timeReceived = System.currentTimeMillis() / 1000.0
+        }.build()
+
+    private fun JsonNode.textOrNull(field: String): String? =
+        get(field)?.takeIf { !it.isNull }?.asText()
+
+    private fun JsonNode.intOrNull(field: String): Int? =
+        get(field)?.takeIf { !it.isNull }?.asInt()
+
+    private fun JsonNode.longOrNull(field: String): Long? =
+        get(field)?.takeIf { !it.isNull }?.asLong()
+}

dexcom-library/src/main/kotlin/org/radarbase/dexcom/converter/DexcomDataConverter.kt

@@ -0,0 +1,37 @@
+package org.radarbase.dexcom.converter
+
+import com.fasterxml.jackson.databind.JsonNode
+import okhttp3.Headers
+import org.radarbase.dexcom.request.DexcomRequestGenerator.Companion.JSON_READER
+import org.radarbase.dexcom.request.RestRequest
+import org.radarbase.dexcom.user.User
+import java.time.Instant
+
+interface DexcomDataConverter : RecordConverter {
+    fun processRecords(
+        root: JsonNode,
+        user: User,
+    ): Sequence<Result<TopicData>>
+
+    override fun convert(
+        request: RestRequest,
+        headers: Headers,
+        data: ByteArray,
+    ): List<TopicData> {
+        val node = JSON_READER.readTree(data)
+
+        return processRecords(node, request.user)
+            .mapNotNull { result ->
+                result.fold(
+                    { it },
+                    {
+                        RecordConverter.logger.error("Data conversion failed: ${it.message}")
+                        null
+                    },
+                )
+            }
+            .toList()
+    }
+
+    fun Instant.toEpoch(): Long = toEpochMilli() / 1000
+}

dexcom-library/src/main/kotlin/org/radarbase/dexcom/converter/DexcomDataRangeConverter.kt

@@ -0,0 +1,142 @@
+package org.radarbase.dexcom.converter
+
+import com.fasterxml.jackson.databind.JsonNode
+import org.radarbase.dexcom.user.User
+import org.radarcns.connector.dexcom.DexcomDataRange
+import org.radarcns.connector.dexcom.DexcomDataRangeMoment
+import org.radarcns.connector.dexcom.DexcomDataRangeMomentEnd
+import org.radarcns.connector.dexcom.DexcomDataRangeMomentEgvsEnd
+import org.radarcns.connector.dexcom.DexcomDataRangeMomentEgvsStart
+import org.radarcns.connector.dexcom.DexcomDataRangeMomentEventsEnd
+import org.radarcns.connector.dexcom.DexcomDataRangeMomentEventsStart
+import org.radarcns.connector.dexcom.DexcomDataRangeWindow
+import org.radarcns.connector.dexcom.DexcomDataRangeWindowEgvs
+import org.radarcns.connector.dexcom.DexcomDataRangeWindowEvents
+import java.time.Instant
+
+/**
+ * /dataRange returns a single object (not records[]).
+ */
+class DexcomDataRangeConverter(
+    private val topic: String = "connect_dexcom_data_range",
+) : DexcomDataConverter {
+    override fun processRecords(
+        root: JsonNode,
+        user: User,
+    ): Sequence<Result<TopicData>> {
+        return sequenceOf(root).mapCatching {
+            val value = it.toDexcomDataRange()
+            val offset = it.offsetFromResponse()
+            TopicData(
+                key = user.observationKey,
+                topic = topic,
+                offset = offset,
+                value = value,
+            )
+        }
+    }
+
+    private fun JsonNode.offsetFromResponse(): Long {
+        val candidates = listOfNotNull(
+            get("egvs")?.get("end")?.get("systemTime")?.asText(),
+            get("events")?.get("end")?.get("systemTime")?.asText(),
+            get("calibrations")?.get("end")?.get("systemTime")?.asText(),
+        )
+        return candidates.firstNotNullOfOrNull { text ->
+            runCatching { DexcomEGVConverter.parseDexcomTime(text).epochSecond }.getOrNull()
+        } ?: Instant.now().epochSecond
+    }
+
+    private fun JsonNode.toDexcomDataRange(): DexcomDataRange =
+        DexcomDataRange.newBuilder().apply {
+            calibrations = get("calibrations")?.takeIf { !it.isNull }?.toCalibrationsWindow()
+            egvs = get("egvs")?.takeIf { !it.isNull }?.toEgvsWindow()
+            events = get("events")?.takeIf { !it.isNull }?.toEventsWindow()
+            timeReceived = System.currentTimeMillis() / 1000.0
+        }.build()
+
+    private fun JsonNode.toCalibrationsWindow(): DexcomDataRangeWindow =
+        DexcomDataRangeWindow.newBuilder().apply {
+            start = get("start")?.toMoment() ?: emptyMoment()
+            end = get("end")?.toMomentEnd() ?: emptyMomentEnd()
+        }.build()
+
+    private fun JsonNode.toEgvsWindow(): DexcomDataRangeWindowEgvs =
+        DexcomDataRangeWindowEgvs.newBuilder().apply {
+            start = get("start")?.toEgvsStart() ?: emptyEgvsStart()
+            end = get("end")?.toEgvsEnd() ?: emptyEgvsEnd()
+        }.build()
+
+    private fun JsonNode.toEventsWindow(): DexcomDataRangeWindowEvents =
+        DexcomDataRangeWindowEvents.newBuilder().apply {
+            start = get("start")?.toEventsStart() ?: emptyEventsStart()
+            end = get("end")?.toEventsEnd() ?: emptyEventsEnd()
+        }.build()
+
+    private fun JsonNode.toMoment(): DexcomDataRangeMoment =
+        DexcomDataRangeMoment.newBuilder().apply {
+            systemTime = systemTimeEpochOrNull()
+            displayTime = textOrNull("displayTime")
+        }.build()
+
+    private fun JsonNode.toMomentEnd(): DexcomDataRangeMomentEnd =
+        DexcomDataRangeMomentEnd.newBuilder().apply {
+            systemTime = systemTimeEpochOrNull()
+            displayTime = textOrNull("displayTime")
+        }.build()
+
+    private fun JsonNode.toEgvsStart(): DexcomDataRangeMomentEgvsStart =
+        DexcomDataRangeMomentEgvsStart.newBuilder().apply {
+            systemTime = systemTimeEpochOrNull()
+            displayTime = textOrNull("displayTime")
+        }.build()
+
+    private fun JsonNode.toEgvsEnd(): DexcomDataRangeMomentEgvsEnd =
+        DexcomDataRangeMomentEgvsEnd.newBuilder().apply {
+            systemTime = systemTimeEpochOrNull()
+            displayTime = textOrNull("displayTime")
+        }.build()
+
+    private fun JsonNode.toEventsStart(): DexcomDataRangeMomentEventsStart =
+        DexcomDataRangeMomentEventsStart.newBuilder().apply {
+            systemTime = systemTimeEpochOrNull()
+            displayTime = textOrNull("displayTime")
+        }.build()
+
+    private fun JsonNode.toEventsEnd(): DexcomDataRangeMomentEventsEnd =
+        DexcomDataRangeMomentEventsEnd.newBuilder().apply {
+            systemTime = systemTimeEpochOrNull()
+            displayTime = textOrNull("displayTime")
+        }.build()
+
+    private fun JsonNode.systemTimeEpochOrNull(): Double? =
+        get("systemTime")
+            ?.takeIf { !it.isNull }
+            ?.asText()
+            ?.let { text ->
+                runCatching {
+                    DexcomEGVConverter.parseDexcomTime(text).epochSecond.toDouble()
+                }.getOrNull()
+            }
+
+    private fun JsonNode.textOrNull(field: String): String? =
+        get(field)?.takeIf { !it.isNull }?.asText()
+
+    private fun emptyMoment() =
+        DexcomDataRangeMoment.newBuilder().build()
+
+    private fun emptyMomentEnd() =
+        DexcomDataRangeMomentEnd.newBuilder().build()
+
+    private fun emptyEgvsStart() =
+        DexcomDataRangeMomentEgvsStart.newBuilder().build()
+
+    private fun emptyEgvsEnd() =
+        DexcomDataRangeMomentEgvsEnd.newBuilder().build()
+
+    private fun emptyEventsStart() =
+        DexcomDataRangeMomentEventsStart.newBuilder().build()
+
+    private fun emptyEventsEnd() =
+        DexcomDataRangeMomentEventsEnd.newBuilder().build()
+}