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,108 @@
+package org.radarbase.dexcom.converter
+
+import com.fasterxml.jackson.databind.JsonNode
+import org.radarbase.dexcom.user.User
+import org.radarcns.connector.dexcom.DexcomAlert
+import org.radarcns.connector.dexcom.DexcomAlertName
+import org.radarcns.connector.dexcom.DexcomAlertState
+import org.radarcns.connector.dexcom.DexcomDisplayDevice
+import org.radarcns.connector.dexcom.DexcomTransmitterGeneration
+import org.radarcns.connector.dexcom.DexcomTransmitterGenerationVariant
+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()
+            time = systemTimeInstant.epochSecond.toDouble()
+            displayTime = textOrNull("displayTime")
+            alertName = parseAlertName(textOrNull("alertName"))
+            alertState = parseAlertState(textOrNull("alertState"))
+            displayDevice = parseDisplayDevice(textOrNull("displayDevice"))
+            transmitterGeneration = parseTransmitterGeneration(textOrNull("transmitterGeneration"))
+            transmitterGenerationVariant =
+                parseTransmitterGenerationVariant(textOrNull("transmitterGenerationVariant"))
+            transmitterId = textOrNull("transmitterId").orEmpty()
+            displayApp = textOrNull("displayApp")
+            timeReceived = System.currentTimeMillis() / 1000.0
+        }.build()
+
+    private fun parseAlertName(value: String?): DexcomAlertName? =
+        when (value) {
+            null -> null
+            else -> when (value.lowercase()) {
+                "high" -> DexcomAlertName.HIGH
+                "low" -> DexcomAlertName.LOW
+                "rise" -> DexcomAlertName.RISE
+                "fall" -> DexcomAlertName.FALL
+                "outofrange" -> DexcomAlertName.OUT_OF_RANGE
+                "urgentlow" -> DexcomAlertName.URGENT_LOW
+                "urgentlowsoon" -> DexcomAlertName.URGENT_LOW_SOON
+                "noreadings" -> DexcomAlertName.NO_READINGS
+                else -> DexcomAlertName.UNKNOWN
+            }
+        }
+
+    private fun parseAlertState(value: String?): DexcomAlertState? =
+        when (value) {
+            null -> null
+            else -> when (value.lowercase()) {
+                "inactive" -> DexcomAlertState.INACTIVE
+                "activesnoozed" -> DexcomAlertState.ACTIVE_SNOOZED
+                "activealarming" -> DexcomAlertState.ACTIVE_ALARMING
+                else -> DexcomAlertState.UNKNOWN
+            }
+        }
+
+    private fun parseTransmitterGeneration(value: String?): DexcomTransmitterGeneration =
+        when (value?.lowercase()) {
+            "g6" -> DexcomTransmitterGeneration.G6
+            "g6+" -> DexcomTransmitterGeneration.G6_PLUS
+            "g6pro" -> DexcomTransmitterGeneration.G6_PRO
+            "g7" -> DexcomTransmitterGeneration.G7
+            else -> DexcomTransmitterGeneration.UNKNOWN
+        }
+
+    private fun parseTransmitterGenerationVariant(value: String?): DexcomTransmitterGenerationVariant =
+        when (value?.lowercase()) {
+            "d1+" -> DexcomTransmitterGenerationVariant.D1_PLUS
+            "g6" -> DexcomTransmitterGenerationVariant.G6
+            "g7" -> DexcomTransmitterGenerationVariant.G7
+            "g715day" -> DexcomTransmitterGenerationVariant.G7_15_DAY
+            else -> DexcomTransmitterGenerationVariant.UNKNOWN
+        }
+
+    private fun parseDisplayDevice(value: String?): DexcomDisplayDevice? =
+        when (value?.lowercase()) {
+            null -> null
+            "receiver" -> DexcomDisplayDevice.RECEIVER
+            "ios" -> DexcomDisplayDevice.IOS
+            "android" -> DexcomDisplayDevice.ANDROID
+            else -> DexcomDisplayDevice.UNKNOWN
+        }
+
+    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,85 @@
+package org.radarbase.dexcom.converter
+
+import com.fasterxml.jackson.databind.JsonNode
+import org.radarbase.dexcom.user.User
+import org.radarcns.connector.dexcom.DexcomCalibration
+import org.radarcns.connector.dexcom.DexcomDisplayDevice
+import org.radarcns.connector.dexcom.DexcomTransmitterGeneration
+import org.radarcns.connector.dexcom.DexcomTransmitterGenerationVariant
+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()
+            time = systemTimeInstant.epochSecond.toDouble()
+            displayTime = textOrNull("displayTime")
+            unit = textOrNull("unit")
+            value = intOrNull("value")
+            displayDevice = parseDisplayDevice(textOrNull("displayDevice"))
+            transmitterId = textOrNull("transmitterId").orEmpty()
+            transmitterTicks = longOrNull("transmitterTicks")
+            transmitterGeneration = parseTransmitterGeneration(textOrNull("transmitterGeneration"))
+            transmitterGenerationVariant =
+                parseTransmitterGenerationVariant(textOrNull("transmitterGenerationVariant"))
+            timeReceived = System.currentTimeMillis() / 1000.0
+        }.build()
+
+    private fun parseTransmitterGeneration(value: String?): DexcomTransmitterGeneration =
+        when (value?.lowercase()) {
+            "g6" -> DexcomTransmitterGeneration.G6
+            "g6+" -> DexcomTransmitterGeneration.G6_PLUS
+            "g6pro" -> DexcomTransmitterGeneration.G6_PRO
+            "g7" -> DexcomTransmitterGeneration.G7
+            else -> DexcomTransmitterGeneration.UNKNOWN
+        }
+
+    private fun parseTransmitterGenerationVariant(value: String?): DexcomTransmitterGenerationVariant =
+        when (value?.lowercase()) {
+            "d1+" -> DexcomTransmitterGenerationVariant.D1_PLUS
+            "g6" -> DexcomTransmitterGenerationVariant.G6
+            "g7" -> DexcomTransmitterGenerationVariant.G7
+            "g715day" -> DexcomTransmitterGenerationVariant.G7_15_DAY
+            else -> DexcomTransmitterGenerationVariant.UNKNOWN
+        }
+
+    private fun parseDisplayDevice(value: String?): DexcomDisplayDevice? =
+        when (value?.lowercase()) {
+            null -> null
+            "receiver" -> DexcomDisplayDevice.RECEIVER
+            "ios" -> DexcomDisplayDevice.IOS
+            "android" -> DexcomDisplayDevice.ANDROID
+            else -> DexcomDisplayDevice.UNKNOWN
+        }
+
+    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,78 @@
+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.DexcomDataRangeWindow
+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 }?.toWindow()
+            egvs = get("egvs")?.takeIf { !it.isNull }?.toWindow()
+            events = get("events")?.takeIf { !it.isNull }?.toWindow()
+            timeReceived = System.currentTimeMillis() / 1000.0
+        }.build()
+
+    private fun JsonNode.toWindow(): DexcomDataRangeWindow =
+        DexcomDataRangeWindow.newBuilder().apply {
+            start = get("start")?.takeIf { !it.isNull }?.toMoment() ?: emptyMoment()
+            end = get("end")?.takeIf { !it.isNull }?.toMoment() ?: emptyMoment()
+        }.build()
+
+    private fun JsonNode.toMoment(): DexcomDataRangeMoment =
+        DexcomDataRangeMoment.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()
+}