Feature/74 bottom sheets and record operations

app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/health/HealthPageTest.kt

@@ -155,9 +155,10 @@ class HealthPageTest {
                         trend = 0f,
                         formattedTrend = "0.0 kg",
                         secondValue = null,
-                        id = entryId
+                        id = entryId,
                     )
-                )
+                ),
+                valueFormatter = { value -> "$value" }
             )
         )
     }

app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/component/BottomSheetEvents.kt

@@ -25,6 +25,8 @@ class BottomSheetEvents @Inject constructor(
         data object DoNewMeasurement : Event
         data object CloseBottomSheet : Event
         data object WeightDescriptionBottomSheet : Event
+        data object BloodPressureDescriptionBottomSheet : Event
+        data object HeartRateDescriptionBottomSheet : Event
         data object AddWeightRecord : Event
         data object AddBloodPressureRecord : Event
         data object AddHeartRateRecord : Event

app/src/main/kotlin/edu/stanford/bdh/engagehf/health/HealthAction.kt

@@ -2,7 +2,6 @@ package edu.stanford.bdh.engagehf.health
 
 sealed interface HealthAction {
     data object DescriptionBottomSheet : HealthAction
-    data object AddRecord : HealthAction
     data class DeleteRecord(val recordId: String) : HealthAction
     data class UpdateTimeRange(val timeRange: TimeRange) : HealthAction
     data class ToggleTimeRangeDropdown(val expanded: Boolean) : HealthAction

app/src/main/kotlin/edu/stanford/bdh/engagehf/health/HealthPage.kt

@@ -1,6 +1,5 @@
 package edu.stanford.bdh.engagehf.health
 
-import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
@@ -11,7 +10,8 @@
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.LazyListScope
 import androidx.compose.foundation.lazy.itemsIndexed
-import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Info
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
@@ -20,8 +20,6 @@
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.shadow
-import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.PreviewParameter
@@ -32,7 +30,6 @@
 import edu.stanford.bdh.engagehf.health.components.HealthChart
 import edu.stanford.bdh.engagehf.health.components.SwipeBox
 import edu.stanford.bdh.engagehf.health.components.TimeRangeDropdown
-import edu.stanford.spezi.core.design.theme.Colors.onPrimary
 import edu.stanford.spezi.core.design.theme.Colors.primary
 import edu.stanford.spezi.core.design.theme.Sizes
 import edu.stanford.spezi.core.design.theme.Spacings
@@ -184,14 +181,9 @@
             onClick = onInfoAction
         ) {
             Icon(
-                painter = painterResource(id = edu.stanford.spezi.core.design.R.drawable.ic_info),
+                imageVector = Icons.Filled.Info,
                 contentDescription = stringResource(R.string.info_icon_content_description),
-                modifier = Modifier
-                    .size(Sizes.Icon.medium)
-                    .background(primary, shape = CircleShape)
-                    .shadow(Spacings.small, CircleShape)
-                    .padding(Spacings.small),
-                tint = onPrimary
+                tint = primary
             )
         }
     }
@@ -217,6 +209,7 @@
             HealthUiState.NoData("No data available"),
             HealthUiState.Success(
                 data = HealthUiData(
+                    valueFormatter = { "Jan 24" },
                     infoRowData = InfoRowData(
                         selectedTimeRange = TimeRange.MONTHLY,
                         formattedValue = "70.0 kg",

app/src/main/kotlin/edu/stanford/bdh/engagehf/health/HealthRepository.kt

@@ -4,25 +4,31 @@
 import androidx.health.connect.client.records.HeartRateRecord
 import androidx.health.connect.client.records.Record
 import androidx.health.connect.client.records.WeightRecord
+import com.google.firebase.firestore.FirebaseFirestore
 import com.google.firebase.firestore.ListenerRegistration
 import com.google.firebase.firestore.Query
 import edu.stanford.bdh.engagehf.observations.ObservationCollection
 import edu.stanford.bdh.engagehf.observations.ObservationCollectionProvider
 import edu.stanford.healthconnectonfhir.ObservationsDocumentMapper
+import edu.stanford.healthconnectonfhir.RecordToObservationMapper
 import edu.stanford.spezi.core.coroutines.di.Dispatching
 import edu.stanford.spezi.core.logging.speziLogger
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.tasks.await
 import kotlinx.coroutines.withContext
 import java.time.ZonedDateTime
 import java.time.format.DateTimeFormatter
 import javax.inject.Inject
 
 class HealthRepository @Inject constructor(
+    private val firestore: FirebaseFirestore,
     private val observationCollectionProvider: ObservationCollectionProvider,
     private val observationsDocumentMapper: ObservationsDocumentMapper,
+    private val observationMapper: ObservationsDocumentMapper,
+    private val recordToObservationMapper: RecordToObservationMapper,
     @Dispatching.IO private val ioDispatcher: CoroutineDispatcher,
 ) {
     private val logger by speziLogger()
@@ -46,8 +52,7 @@
                                 logger.e(error) { "Error listening for latest observation in collection: ${collection.name}" }
                                 trySend(Result.failure(error))
                             } else {
-                                val documents = snapshot?.documents
-                                val records: List<T> = documents?.mapNotNull { document ->
+                                val records: List<T> = snapshot?.documents?.mapNotNull { document ->
                                     observationsDocumentMapper.map(document)
                                 } ?: emptyList()
                                 trySend(Result.success(records))
@@ -73,6 +78,50 @@
     suspend fun observeHeartRateRecords(): Flow<Result<List<HeartRateRecord>>> =
         observe(ObservationCollection.HEART_RATE)
 
+    suspend fun saveRecord(record: Record): Result<Unit> {
+        val observations = recordToObservationMapper.map(record)
+        return withContext(ioDispatcher) {
+            runCatching {
+                val batch = firestore.batch()
+                observations.forEach { observation ->
+                    val collection = ObservationCollection.entries.find { collection ->
+                        observation.code.coding.any { it.code == collection.loinc.code }
+                    }
+                    val data = observationMapper.map(observation = observation)
+                    collection?.let { observationCollectionProvider.getCollection(it).document() }
+                        ?.let { docRef ->
+                            batch.set(docRef, data)
+                        }
+                }
+                batch.commit().await().let { }
+            }
+        }
+    }
+
+    private suspend fun deleteRecord(
+        recordId: String,
+        observationCollection: ObservationCollection,
+    ): Result<Unit> {
+        return withContext(ioDispatcher) {
+            runCatching {
+                observationCollectionProvider.getCollection(observationCollection)
+                    .document(recordId).delete().await().let { }
+            }
+        }
+    }
+
+    suspend fun deleteWeightRecord(recordId: String): Result<Unit> {
+        return deleteRecord(recordId, ObservationCollection.BODY_WEIGHT)
+    }
+
+    suspend fun deleteBloodPressureRecord(recordId: String): Result<Unit> {
+        return deleteRecord(recordId, ObservationCollection.BLOOD_PRESSURE)
+    }
+
+    suspend fun deleteHeartRateRecord(recordId: String): Result<Unit> {
+        return deleteRecord(recordId, ObservationCollection.HEART_RATE)
+    }
+
     companion object {
         const val DEFAULT_MAX_MONTHS = 6L
         const val DATE_TIME_FIELD = "effectiveDateTime"

app/src/main/kotlin/edu/stanford/bdh/engagehf/health/HealthScreen.kt

@@ -140,7 +140,7 @@ private fun BoxScope.AddRecordFloatingIcon(
     tab: HealthTab,
     onAction: (HealthViewModel.Action) -> Unit,
 ) {
-    if (tab != HealthTab.Weight) return
+    if (tab == HealthTab.Symptoms) return
     FloatingActionButton(
         onClick = {
             onAction(HealthViewModel.Action.AddRecord(tab = tab))

app/src/main/kotlin/edu/stanford/bdh/engagehf/health/HealthUiState.kt

@@ -10,6 +10,7 @@ data class HealthUiData(
     val newestData: NewestHealthData? = null,
     val averageData: AverageHealthData? = null,
     val infoRowData: InfoRowData,
+    val valueFormatter: (Float) -> String,
 ) {
     val selectedTimeRange = infoRowData.selectedTimeRange
 }

app/src/main/kotlin/edu/stanford/bdh/engagehf/health/HealthUiStateMapper.kt

@@ -7,8 +7,11 @@
 import androidx.health.connect.client.records.Record
 import androidx.health.connect.client.records.WeightRecord
 import edu.stanford.spezi.core.utils.LocaleProvider
+import edu.stanford.spezi.core.utils.extensions.roundToDecimalPlaces
 import java.time.DayOfWeek
+import java.time.Instant
 import java.time.LocalDate
+import java.time.ZoneId
 import java.time.ZonedDateTime
 import java.time.format.DateTimeFormatter
 import java.time.temporal.TemporalAdjusters
@@ -27,6 +30,11 @@
         selectedTimeRange: TimeRange,
     ): HealthUiState {
         val engageRecords = records.map { EngageRecord.from(it) }
+            .filter {
+                it.zonedDateTime.isAfter(
+                    ZonedDateTime.now().minusMonths(getMaxMonths(selectedTimeRange))
+                )
+            }
         return if (engageRecords.isEmpty()) {
             HealthUiState.NoData(message = "No data available")
         } else {
@@ -67,7 +75,8 @@
             tableData = tableData,
             newestData = newestData,
             averageData = getAverageData(tableData),
-            infoRowData = generateHealthHeaderData(selectedTimeRange, newestData)
+            infoRowData = generateHealthHeaderData(selectedTimeRange, newestData),
+            valueFormatter = { valueFormatter(it, selectedTimeRange) }
         )
     }
 
@@ -100,10 +109,10 @@
 
     private fun mapXValue(selectedTimeRange: TimeRange, zonedDateTime: ZonedDateTime): Float {
         return when (selectedTimeRange) {
-            TimeRange.DAILY -> zonedDateTime.year.toFloat() + (zonedDateTime.dayOfYear - 1) / 365f
+            TimeRange.DAILY -> (zonedDateTime.year.toFloat() + (zonedDateTime.dayOfYear - 1) / 365f) * 10
             TimeRange.WEEKLY -> (zonedDateTime.toEpochSecond() / (7 * 24 * 60 * 60)).toFloat()
             TimeRange.MONTHLY -> zonedDateTime.year.toFloat() + (zonedDateTime.monthValue - 1) / 12f
-        }
+        }.roundToDecimalPlaces(places = 2)
     }
 
     private fun groupRecordsByTimeRange(
@@ -308,16 +317,34 @@
 
     private fun getDefaultLocale() = localeProvider.getDefaultLocale()
 
-    companion object {
-        private const val DAILY_MAX_MONTHS = 1L
-        private const val WEEKLY_MAX_MONTHS = 3L
-        private const val MONTHLY_MAX_MONTHS = 6L
+    private fun valueFormatter(value: Float, timeRange: TimeRange): String {
+        val date = when (timeRange) {
+            TimeRange.DAILY -> {
+                val actualValue = value * 10
+                val year = actualValue.toInt()
+                val dayOfYearFraction = actualValue - year
+                val dayOfYear = (dayOfYearFraction * 365).toInt() + 1
+                ZonedDateTime.of(year, 1, 1, 0, 0, 0, 0, ZoneId.systemDefault())
+                    .plusDays((dayOfYear - 1).toLong())
+            }
 
-        const val EPOCH_SECONDS_DIVISOR = 60.0f
-        const val ADAPTIVE_Y_VALUES_FRACTION = 1.05f
+            TimeRange.WEEKLY -> ZonedDateTime.ofInstant(
+                Instant.ofEpochSecond(
+                    value.toLong() * 7 * 24 * 60 * 60
+                ), ZoneId.systemDefault()
+            )
 
-        private const val MONTH_DAY_TIME_PATTERN = "MMM dd HH:mm"
-        private const val MONTH_YEAR_PATTERN = "MMM yy"
+            TimeRange.MONTHLY -> {
+                val year = value.toInt()
+                val month = ((value - year) * 12).toInt() + 1
+                ZonedDateTime.of(year, month, 1, 0, 0, 0, 0, ZoneId.systemDefault())
+            }
+        }
+        val pattern = when (timeRange) {
+            TimeRange.DAILY, TimeRange.WEEKLY -> "MMM dd"
+            TimeRange.MONTHLY -> "MMM yy"
+        }
+        return date.format(DateTimeFormatter.ofPattern(pattern))
     }
 
     private data class ValueUnit(val value: Double, val unit: String)
@@ -347,4 +374,16 @@
             }
         }
     }
+
+    companion object {
+        private const val DAILY_MAX_MONTHS = 1L
+        private const val WEEKLY_MAX_MONTHS = 3L
+        private const val MONTHLY_MAX_MONTHS = 6L
+
+        const val EPOCH_SECONDS_DIVISOR = 60.0f
+        const val ADAPTIVE_Y_VALUES_FRACTION = 1.05f
+
+        private const val MONTH_DAY_TIME_PATTERN = "MMM dd HH:mm"
+        private const val MONTH_YEAR_PATTERN = "MMM yy"
+    }
 }

app/src/main/kotlin/edu/stanford/bdh/engagehf/health/bloodpressure/BloodPressureViewModel.kt

@@ -3,12 +3,12 @@
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
+import edu.stanford.bdh.engagehf.bluetooth.component.BottomSheetEvents
 import edu.stanford.bdh.engagehf.health.HealthAction
 import edu.stanford.bdh.engagehf.health.HealthRepository
 import edu.stanford.bdh.engagehf.health.HealthUiState
 import edu.stanford.bdh.engagehf.health.HealthUiStateMapper
 import edu.stanford.bdh.engagehf.health.TimeRange
-import edu.stanford.spezi.core.logging.speziLogger
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
@@ -19,9 +19,8 @@
 class BloodPressureViewModel @Inject internal constructor(
     private val uiStateMapper: HealthUiStateMapper,
     private val healthRepository: HealthRepository,
+    private val bottomSheetEvents: BottomSheetEvents,
 ) : ViewModel() {
-    private val logger by speziLogger()
-
     private val _uiState = MutableStateFlow<HealthUiState>(HealthUiState.Loading)
     val uiState = _uiState.asStateFlow()
 
@@ -50,9 +49,16 @@
 
     fun onAction(healthAction: HealthAction) {
         when (healthAction) {
-            HealthAction.AddRecord -> logger.i { "AddRecord" }
-            is HealthAction.DeleteRecord -> logger.i { "DeleteRecord" }
-            HealthAction.DescriptionBottomSheet -> logger.i { "DescriptionBottomSheet" }
+            is HealthAction.DeleteRecord -> {
+                viewModelScope.launch {
+                    healthRepository.deleteBloodPressureRecord(healthAction.recordId)
+                }
+            }
+
+            HealthAction.DescriptionBottomSheet -> {
+                bottomSheetEvents.emit(BottomSheetEvents.Event.BloodPressureDescriptionBottomSheet)
+            }
+
             is HealthAction.ToggleTimeRangeDropdown -> {
                 _uiState.update {
                     uiStateMapper.mapToggleTimeRange(healthAction, it)