Revert "Update Patient#isEligibleForReassignment on BP creation" (#…

…4924)

CHANGELOG.md

@@ -51,7 +51,6 @@
 - Bump Jackson Core to v2.17.0
 - Add `isPatientEligibleForReassignment` to `Patient` model 
 - Add function in `PatientRepository` to check if patient is eligible for reassignment
-- Update `isPatientEligibleForReassignment` when BP is saved.
 - Bump eclipse jgit to v6.9.0.202403050737-r
 - Update GH Actions `checkout` to v4
 

app/src/androidTest/java/org/simple/clinic/patient/PatientRepositoryAndroidTest.kt

@@ -4217,56 +4217,4 @@ class PatientRepositoryAndroidTest {
     // then
     assertThat(isPatientEligibleForReassignment).isFalse()
   }
-
-  @Test
-  fun updating_patient_reassignment_status_should_work_correctly() {
-    // given
-    val facilityId = UUID.fromString("77c9ae7d-5be9-49c1-a7b7-495591b13ae2")
-
-    val facility = TestData.facility(
-        uuid = facilityId,
-        name = "PHC RTSL",
-        facilityType = "UHC"
-    )
-
-    val patientId = UUID.fromString("824a15e8-59eb-4425-9a6c-6055a8609911")
-    val patientAddressId = UUID.fromString("962f2012-0ce3-4d0d-85b6-c8c6f3f0b55e")
-
-    val patientProfile = TestData.patientProfile(
-        patientName = "Ramesh Prasad",
-        patientUuid = patientId,
-        patientAddressUuid = patientAddressId,
-        generatePhoneNumber = false,
-        patientPhoneNumber = "1111111111",
-        generateBusinessId = false,
-        patientAddressStreet = "45 Marigold Lane",
-        patientAddressColonyOrVillage = "Carroll Gardens",
-        gender = Gender.Male,
-        generateDateOfBirth = false,
-        patientAgeDetails = PatientAgeDetails(
-            ageValue = 65,
-            ageUpdatedAt = Instant.parse("2018-01-01T00:00:00Z"),
-            dateOfBirth = null
-        ),
-        patientRegisteredFacilityId = facilityId,
-        patientAssignedFacilityId = facilityId,
-        patientStatus = Active,
-        patientCreatedAt = Instant.parse("2017-01-01T00:00:00Z"),
-        patientUpdatedAt = Instant.parse("2018-01-01T00:00:00Z"),
-        patientDeletedAt = null
-    )
-
-    facilityRepository.save(listOf(facility))
-    patientRepository.save(listOf(patientProfile))
-
-    // when
-    patientRepository.updatePatientReassignmentEligibilityStatus(
-        patientUuid = patientId,
-        isEligibleForReassignment = true
-    )
-
-    // then
-    val isPatientEligibleForReassignment = patientRepository.patientImmediate(patientId)?.isEligibleForReassignment ?: false
-    assertThat(isPatientEligibleForReassignment).isTrue()
-  }
 }

app/src/main/java/org/simple/clinic/bp/entry/BloodPressureEntryEffect.kt

@@ -74,7 +74,3 @@ data class UpdateBpEntry(
   val wasDateChanged: Boolean
     get() = userEnteredDate != prefilledDate
 }
-
-data class CheckAndUpdatePatientReassignmentEligibilityStatus(
-    val patientUuid: UUID,
-) : BloodPressureEntryEffect()

app/src/main/java/org/simple/clinic/bp/entry/BloodPressureEntryEffectHandler.kt

@@ -74,7 +74,6 @@ class BloodPressureEntryEffectHandler @AssistedInject constructor(
         .addConsumer(ShowBpEntryScreen::class.java, { showBpEntryScreen(it.date) }, schedulersProvider.ui())
         .addConsumer(ShowDateValidationError::class.java, { showDateValidationError(it.result) }, schedulersProvider.ui())
         .addTransformer(CreateNewBpEntry::class.java, createNewBpEntryTransformer())
-        .addTransformer(CheckAndUpdatePatientReassignmentEligibilityStatus::class.java, checkAndUpdatePatientReassignmentEligibilityStatusTransformer())
         .addAction(SetBpSavedResultAndFinish::class.java, ui::setBpSavedResultAndFinish, schedulersProvider.ui())
         .addTransformer(UpdateBpEntry::class.java, updateBpEntryTransformer())
         .build()
@@ -249,19 +248,4 @@ class BloodPressureEntryEffectHandler @AssistedInject constructor(
   }
 
   private fun getExistingBloodPressureMeasurement(bpUuid: UUID) = bloodPressureRepository.measurementImmediate(bpUuid)
-
-  private fun checkAndUpdatePatientReassignmentEligibilityStatusTransformer()
-      : ObservableTransformer<CheckAndUpdatePatientReassignmentEligibilityStatus, BloodPressureEntryEvent> {
-    return ObservableTransformer { updateStatus ->
-      updateStatus
-          .observeOn(schedulersProvider.io())
-          .map {
-            val isEligibleForReassignment = patientRepository.isPatientEligibleForReassignment(it.patientUuid)
-            patientRepository.updatePatientReassignmentEligibilityStatus(it.patientUuid, isEligibleForReassignment)
-          }
-          .map { PatientReassignmentEligibilityStatusUpdated }
-          .compose(reportAnalyticsEvents)
-          .cast()
-    }
-  }
 }

app/src/main/java/org/simple/clinic/bp/entry/BloodPressureEntryEvent.kt

@@ -59,7 +59,3 @@ data class BloodPressureMeasurementFetched(
 ) : BloodPressureEntryEvent()
 
 data class DatePrefilled(val prefilledDate: LocalDate) : BloodPressureEntryEvent()
-
-object PatientReassignmentEligibilityStatusUpdated : BloodPressureEntryEvent() {
-  override val analyticsName = "Blood Pressure Entry:Patient Reassignment eligibility status updated"
-}

app/src/main/java/org/simple/clinic/bp/entry/BloodPressureEntrySheet.kt

@@ -84,9 +84,9 @@ class BloodPressureEntrySheet : BottomSheetActivity(), BloodPressureEntryUi, Rem
           .putExtra(KEY_OPEN_AS, New(patientUuid))
     }
 
-    fun intentForUpdateBp(context: Context, bloodPressureMeasurementUuid: UUID, patientUuid: UUID): Intent {
+    fun intentForUpdateBp(context: Context, bloodPressureMeasurementUuid: UUID): Intent {
       return Intent(context, BloodPressureEntrySheet::class.java)
-          .putExtra(KEY_OPEN_AS, Update(bloodPressureMeasurementUuid, patientUuid))
+          .putExtra(KEY_OPEN_AS, Update(bloodPressureMeasurementUuid))
     }
 
     fun wasBloodPressureSaved(data: Intent): Boolean {

app/src/main/java/org/simple/clinic/bp/entry/BloodPressureEntryUpdate.kt

@@ -39,9 +39,8 @@ class BloodPressureEntryUpdate(
       is ChangeDateClicked -> changeDateClicked(model)
       is SaveClicked -> onSaveClicked(model)
       is ShowBpClicked -> showBpClicked(model)
-      is BloodPressureSaved -> dispatch(CheckAndUpdatePatientReassignmentEligibilityStatus(model.openAs.patientUuid))
+      is BloodPressureSaved -> next(model.bloodPressureStateChanged(NOT_SAVING_BLOOD_PRESSURE), SetBpSavedResultAndFinish)
       is DatePrefilled -> next(model.datePrefilled(event.prefilledDate))
-      is PatientReassignmentEligibilityStatusUpdated -> next(model.bloodPressureStateChanged(NOT_SAVING_BLOOD_PRESSURE), SetBpSavedResultAndFinish)
     }
   }
 

app/src/main/java/org/simple/clinic/bp/entry/OpenAs.kt

@@ -4,13 +4,11 @@ import android.os.Parcelable
 import kotlinx.parcelize.Parcelize
 import java.util.UUID
 
-sealed interface OpenAs : Parcelable {
-
-  val patientUuid: UUID
+sealed class OpenAs : Parcelable {
 
   @Parcelize
-  data class New(override val patientUuid: UUID) : OpenAs
+  data class New(val patientUuid: UUID) : OpenAs()
 
   @Parcelize
-  data class Update(val bpUuid: UUID, override val patientUuid: UUID) : OpenAs
+  data class Update(val bpUuid: UUID) : OpenAs()
 }

app/src/main/java/org/simple/clinic/bp/history/BloodPressureHistoryScreen.kt

@@ -176,8 +176,8 @@ class BloodPressureHistoryScreen : BaseScreen<
     requireContext().startActivity(intent)
   }
 
-  override fun openBloodPressureUpdateSheet(bpUuid: UUID, patientUuid: UUID) {
-    val intent = BloodPressureEntrySheet.intentForUpdateBp(requireContext(), bpUuid, patientUuid)
+  override fun openBloodPressureUpdateSheet(bpUuid: UUID) {
+    val intent = BloodPressureEntrySheet.intentForUpdateBp(requireContext(), bpUuid)
     requireContext().startActivity(intent)
   }
 

app/src/main/java/org/simple/clinic/bp/history/BloodPressureHistoryScreenUiActions.kt

@@ -5,6 +5,6 @@ import java.util.UUID
 
 interface BloodPressureHistoryScreenUiActions {
   fun openBloodPressureEntrySheet(patientUuid: UUID)
-  fun openBloodPressureUpdateSheet(bpUuid: UUID, patientUuid: UUID)
+  fun openBloodPressureUpdateSheet(bpUuid: UUID)
   fun showBloodPressures(dataSourceFactory: BloodPressureHistoryListItemDataSourceFactory)
 }

app/src/main/java/org/simple/clinic/bp/history/BloodPressureHistoryViewEffectHandler.kt

@@ -10,10 +10,7 @@ class BloodPressureHistoryViewEffectHandler(
   override fun handle(viewEffect: BloodPressureHistoryViewEffect) {
     when (viewEffect) {
       is OpenBloodPressureEntrySheet -> uiActions.openBloodPressureEntrySheet(viewEffect.patientUuid)
-      is OpenBloodPressureUpdateSheet -> uiActions.openBloodPressureUpdateSheet(
-          viewEffect.bloodPressureMeasurement.uuid,
-          viewEffect.bloodPressureMeasurement.patientUuid,
-      )
+      is OpenBloodPressureUpdateSheet -> uiActions.openBloodPressureUpdateSheet(viewEffect.bloodPressureMeasurement.uuid)
       is ShowBloodPressures -> uiActions.showBloodPressures(viewEffect.bloodPressureHistoryDataSourceFactory)
     }.exhaustive()
   }

app/src/main/java/org/simple/clinic/patient/Patient.kt

@@ -295,16 +295,6 @@ data class Patient(
         pendingStatus: SyncStatus
     )
 
-    @Query("""
-      UPDATE Patient
-      SET isEligibleForReassignment = :isEligibleForReassignment
-      WHERE uuid = :patientUuid
-    """)
-    abstract fun updatePatientReassignmentEligibilityStatus(
-        patientUuid: UUID,
-        isEligibleForReassignment: Boolean,
-    )
-
     @Transaction
     @Query("""
       SELECT * FROM Patient

app/src/main/java/org/simple/clinic/patient/PatientRepository.kt

@@ -783,16 +783,6 @@ class PatientRepository @Inject constructor(
     )
   }
 
-  fun updatePatientReassignmentEligibilityStatus(
-      patientUuid: UUID,
-      isEligibleForReassignment: Boolean,
-  ) {
-    database.patientDao().updatePatientReassignmentEligibilityStatus(
-        patientUuid = patientUuid,
-        isEligibleForReassignment = isEligibleForReassignment
-    )
-  }
-
   fun isPatientEligibleForReassignment(patientUuid: UUID): Boolean {
     val patient = database.patientDao().patientImmediate(patientUuid)
 

app/src/main/java/org/simple/clinic/summary/bloodpressures/BloodPressureSummaryViewEffectHandler.kt

@@ -30,7 +30,7 @@ class BloodPressureSummaryViewEffectHandler @AssistedInject constructor(
         .addTransformer(LoadBloodPressuresCount::class.java, loadBloodPressuresCount(schedulersProvider.io()))
         .addTransformer(LoadCurrentFacility::class.java, loadCurrentFacility(schedulersProvider.io()))
         .addConsumer(OpenBloodPressureEntrySheet::class.java, { uiActions.openBloodPressureEntrySheet(it.patientUuid, it.currentFacility) }, schedulersProvider.ui())
-        .addConsumer(OpenBloodPressureUpdateSheet::class.java, { uiActions.openBloodPressureUpdateSheet(it.measurement.uuid, it.measurement.patientUuid) }, schedulersProvider.ui())
+        .addConsumer(OpenBloodPressureUpdateSheet::class.java, { uiActions.openBloodPressureUpdateSheet(it.measurement.uuid) }, schedulersProvider.ui())
         .addConsumer(ShowBloodPressureHistoryScreen::class.java, { uiActions.showBloodPressureHistoryScreen(it.patientUuid) }, schedulersProvider.ui())
         .build()
   }

app/src/main/java/org/simple/clinic/summary/bloodpressures/BloodPressureSummaryViewUiActions.kt

@@ -5,6 +5,6 @@ import java.util.UUID
 
 interface BloodPressureSummaryViewUiActions {
   fun openBloodPressureEntrySheet(patientUuid: UUID, currentFacility: Facility)
-  fun openBloodPressureUpdateSheet(bpUuid: UUID, patientUuid: UUID)
+  fun openBloodPressureUpdateSheet(bpUuid: UUID)
   fun showBloodPressureHistoryScreen(patientUuid: UUID)
 }

app/src/main/java/org/simple/clinic/summary/bloodpressures/view/BloodPressureSummaryView.kt

@@ -223,8 +223,8 @@ class BloodPressureSummaryView(
     ))
   }
 
-  override fun openBloodPressureUpdateSheet(bpUuid: UUID, patientUuid: UUID) {
-    val intent = BloodPressureEntrySheet.intentForUpdateBp(context, bpUuid, patientUuid)
+  override fun openBloodPressureUpdateSheet(bpUuid: UUID) {
+    val intent = BloodPressureEntrySheet.intentForUpdateBp(context, bpUuid)
     activity.startActivity(intent)
   }
 

app/src/test/java/org/simple/clinic/bp/entry/BloodPressureEntryEffectHandlerTest.kt

@@ -1,14 +1,13 @@
 package org.simple.clinic.bp.entry
 
-import org.junit.After
-import org.junit.Test
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.verify
-import org.mockito.kotlin.verifyNoInteractions
-import org.simple.clinic.mobius.EffectHandlerTestCase
-import org.simple.clinic.util.scheduler.TestSchedulersProvider
+import org.junit.After
+import org.junit.Test
 import org.simple.sharedTestCode.TestData
+import org.simple.clinic.mobius.EffectHandlerTestCase
 import org.simple.sharedTestCode.util.TestUserClock
+import org.simple.clinic.util.scheduler.TestSchedulersProvider
 import java.time.LocalDate
 import java.time.ZoneOffset.UTC
 import java.util.UUID
@@ -25,8 +24,6 @@ class BloodPressureEntryEffectHandlerTest {
       currentFacilityUuid = facility.uuid
   )
 
-  private val patientUuid = UUID.fromString("b02d2c99-0572-4318-9e4b-127f14ea5316")
-
   private val effectHandler = BloodPressureEntryEffectHandler(
       ui = ui,
       patientRepository = mock(),
@@ -58,14 +55,4 @@ class BloodPressureEntryEffectHandlerTest {
     verify(ui).showBpDate(entryDate)
     testCase.assertOutgoingEvents(DatePrefilled(entryDate))
   }
-
-  @Test
-  fun `when patient update reassignment eligibility status effect is received then status should be updated`() {
-    //when
-    testCase.dispatch(CheckAndUpdatePatientReassignmentEligibilityStatus(patientUuid))
-
-    //then
-    testCase.assertOutgoingEvents(PatientReassignmentEligibilityStatusUpdated)
-    verifyNoInteractions(ui)
-  }
 }