Partial PersonCertificatesProvider implementation (EXPOSUREAPP-7685) (#3473)

* wip

* wip

* Fix wiring.

* Add setCurrentCwaUser method.

* Adjust tests.

Corona-Warn-App/src/main/java/de/rki/coronawarnapp/covidcertificate/person/core/PersonCertificatesProvider.kt

@@ -2,27 +2,81 @@ package de.rki.coronawarnapp.covidcertificate.person.core
 
 import dagger.Reusable
 import de.rki.coronawarnapp.covidcertificate.common.certificate.CertificatePersonIdentifier
+import de.rki.coronawarnapp.covidcertificate.common.certificate.CwaCovidCertificate
 import de.rki.coronawarnapp.covidcertificate.common.qrcode.QrCodeString
 import de.rki.coronawarnapp.covidcertificate.recovery.core.RecoveryCertificateRepository
 import de.rki.coronawarnapp.covidcertificate.test.core.TestCertificate
 import de.rki.coronawarnapp.covidcertificate.test.core.TestCertificateRepository
 import de.rki.coronawarnapp.covidcertificate.vaccination.core.repository.VaccinationRepository
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.map
 import org.joda.time.Instant
 import org.joda.time.LocalDate
+import timber.log.Timber
 import javax.inject.Inject
 
 // Aggregate the certificates and sort them
 @Reusable
 class PersonCertificatesProvider @Inject constructor(
-    private val recoveryCertificateRepository: RecoveryCertificateRepository,
-    private val testCertificateRepository: TestCertificateRepository,
-    private val vaccinationRepository: VaccinationRepository,
+    vaccinationRepository: VaccinationRepository,
+    testCertificateRepository: TestCertificateRepository,
+    recoveryCertificateRepository: RecoveryCertificateRepository,
 ) {
 
+    val personCertificates: Flow<Set<PersonCertificates>> = combine(
+        vaccinationRepository.vaccinationInfos.map { vaccPersons ->
+            vaccPersons.flatMap { it.vaccinationCertificates }.toSet()
+        },
+        testCertificateRepository.certificates.map { testWrappers ->
+            testWrappers.mapNotNull { it.testCertificate }
+        },
+        recoveryCertificateRepository.certificates.map { recoveryWrappers ->
+            recoveryWrappers.mapNotNull { it.testCertificate }
+        }
+    ) { vaccs, tests, recos ->
+        val mapping = mutableMapOf<CertificatePersonIdentifier, MutableSet<CwaCovidCertificate>>()
+
+        val allCerts: Set<CwaCovidCertificate> = (vaccs + tests + recos)
+        allCerts.forEach {
+            mapping[it.personIdentifier] = (mapping[it.personIdentifier] ?: mutableSetOf()).apply {
+                add(it)
+            }
+        }
+
+        mapping.entries.map { (personIdentifier, certs) ->
+            Timber.tag(TAG).v("PersonCertificates for %s with %d certs.", personIdentifier, certs.size)
+            PersonCertificates(certificates = certs.toPrioritySortOrder())
+        }.toSet()
+//        + testData // TODO remove
+    }
+
+    fun Collection<CwaCovidCertificate>.toPrioritySortOrder(): List<CwaCovidCertificate> {
+        // TODO
+        return this.toList()
+    }
+
+    /**
+     * Set the current cwa user with regards to listed persons in the certificates tab.
+     * After calling this [personCertificates] will emit new values.
+     * Setting it to null deletes it.
+     */
+    suspend fun setCurrentCwaUser(personIdentifier: CertificatePersonIdentifier?) {
+        // TODO
+    }
+
+    // TODO remove
+    private val testData = (0..30).map { PersonCertificates(listOf(testCertificate(it))) }.toSet() +
+        PersonCertificates(listOf(testCertificate(31, true, false))) +
+        PersonCertificates(listOf(testCertificate(32, true, true))) +
+        PersonCertificates(listOf(testCertificate(33)), true)
+
     // TODO remove
-    fun testCertificate(index: Int, isCertificateRetrievalPending: Boolean = false, isUpdating: Boolean = false) =
+    private fun testCertificate(
+        index: Int,
+        isCertificateRetrievalPending: Boolean = false,
+        isUpdating: Boolean = false
+    ) =
         object : TestCertificate {
             override val targetName: String
                 get() = "targetName"
@@ -77,11 +131,7 @@ class PersonCertificatesProvider @Inject constructor(
                 get() = "certificateId"
         }
 
-    // TODO
-    val personCertificates: Flow<Set<PersonCertificates>> = flowOf(
-        (0..30).map { PersonCertificates(listOf(testCertificate(it))) }.toSet() +
-            PersonCertificates(listOf(testCertificate(31, true, false))) +
-            PersonCertificates(listOf(testCertificate(32, true, true))) +
-            PersonCertificates(listOf(testCertificate(33)), true)
-    )
+    companion object {
+        private val TAG = PersonCertificatesProvider::class.simpleName!!
+    }
 }

Corona-Warn-App/src/main/java/de/rki/coronawarnapp/covidcertificate/recovery/core/RecoveryCertificateRepository.kt

@@ -9,7 +9,7 @@ import de.rki.coronawarnapp.util.coroutine.AppScope
 import de.rki.coronawarnapp.util.coroutine.DispatcherProvider
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.flow.flowOf
 import timber.log.Timber
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -22,7 +22,7 @@ class RecoveryCertificateRepository @Inject constructor(
     valueSetsRepository: ValueSetsRepository,
 ) {
 
-    val certificates: Flow<Set<RecoveryCertificateWrapper>> = emptyFlow()
+    val certificates: Flow<Set<RecoveryCertificateWrapper>> = flowOf(emptySet())
 
     suspend fun requestCertificate(qrCode: RecoveryCertificateQRCode): RecoveryCertificateContainer {
         Timber.tag(TAG).d("requestCertificate(qrCode=%s)", qrCode)

Corona-Warn-App/src/test/java/de/rki/coronawarnapp/covidcertificate/person/core/PersonCertificatesProviderTest.kt

+package de.rki.coronawarnapp.covidcertificate.person.core
+
+import de.rki.coronawarnapp.covidcertificate.common.certificate.CertificatePersonIdentifier
+import de.rki.coronawarnapp.covidcertificate.recovery.core.RecoveryCertificate
+import de.rki.coronawarnapp.covidcertificate.recovery.core.RecoveryCertificateRepository
+import de.rki.coronawarnapp.covidcertificate.recovery.core.RecoveryCertificateWrapper
+import de.rki.coronawarnapp.covidcertificate.test.core.TestCertificate
+import de.rki.coronawarnapp.covidcertificate.test.core.TestCertificateRepository
+import de.rki.coronawarnapp.covidcertificate.test.core.TestCertificateWrapper
+import de.rki.coronawarnapp.covidcertificate.vaccination.core.VaccinatedPerson
+import de.rki.coronawarnapp.covidcertificate.vaccination.core.VaccinationCertificate
+import de.rki.coronawarnapp.covidcertificate.vaccination.core.repository.VaccinationRepository
+import io.kotest.matchers.shouldBe
+import io.mockk.MockKAnnotations
+import io.mockk.every
+import io.mockk.impl.annotations.MockK
+import io.mockk.mockk
+import io.mockk.verify
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runBlockingTest
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import testhelpers.BaseTest
+
+class PersonCertificatesProviderTest : BaseTest() {
+    @MockK lateinit var vaccinationRepo: VaccinationRepository
+    @MockK lateinit var testRepo: TestCertificateRepository
+    @MockK lateinit var recoveryRepo: RecoveryCertificateRepository
+
+    private val identifierA = mockk<CertificatePersonIdentifier>()
+
+    private val vaccinatedPersonACertificate1 = mockk<VaccinationCertificate>().apply {
+        every { personIdentifier } returns identifierA
+    }
+    private val vaccinatedPersonA = mockk<VaccinatedPerson>().apply {
+        every { vaccinationCertificates } returns setOf(vaccinatedPersonACertificate1)
+    }
+    private val testWrapperACertificate = mockk<TestCertificate>().apply {
+        every { personIdentifier } returns identifierA
+    }
+    private val testWrapperA = mockk<TestCertificateWrapper>().apply {
+        every { testCertificate } returns testWrapperACertificate
+    }
+    private val recoveryWrapperACertificate = mockk<RecoveryCertificate>().apply {
+        every { personIdentifier } returns identifierA
+    }
+    private val recoveryWrapperA = mockk<RecoveryCertificateWrapper>().apply {
+        every { testCertificate } returns recoveryWrapperACertificate
+    }
+
+    private val vaccinationPersons = MutableStateFlow(setOf(vaccinatedPersonA))
+    private val testWrappers = MutableStateFlow(setOf(testWrapperA))
+    private val recoveryWrappers = MutableStateFlow(setOf(recoveryWrapperA))
+
+    @BeforeEach
+    fun setup() {
+        MockKAnnotations.init(this)
+
+        every { vaccinationRepo.vaccinationInfos } returns vaccinationPersons
+        every { testRepo.certificates } returns testWrappers
+        every { recoveryRepo.certificates } returns recoveryWrappers
+    }
+
+    private fun createInstance() = PersonCertificatesProvider(
+        recoveryCertificateRepository = recoveryRepo,
+        testCertificateRepository = testRepo,
+        vaccinationRepository = vaccinationRepo,
+    )
+
+    @Test
+    fun `empty data`() = runBlockingTest {
+        vaccinationPersons.value = emptySet()
+        testWrappers.value = emptySet()
+        recoveryWrappers.value = emptySet()
+
+        val instance = createInstance()
+
+        instance.personCertificates.first() shouldBe emptyList()
+
+        verify {
+            recoveryRepo.certificates
+            testRepo.certificates
+            vaccinationRepo.vaccinationInfos
+        }
+    }
+
+    @Test
+    fun `data combination`() = runBlockingTest {
+        val instance = createInstance()
+
+        instance.personCertificates.first() shouldBe listOf(
+            PersonCertificates(
+                certificates = listOf(
+                    vaccinatedPersonACertificate1,
+                    testWrapperACertificate,
+                    recoveryWrapperACertificate
+                )
+            )
+        )
+
+        verify {
+            recoveryRepo.certificates
+            testRepo.certificates
+            vaccinationRepo.vaccinationInfos
+        }
+    }
+}