Merge pull request #322 from niscy-eudiw/main

Attestation Revocation Implementation

Author: stzouvaras

assembly-logic/src/main/java/eu/europa/ec/assemblylogic/Application.kt

@@ -17,9 +17,13 @@
 package eu.europa.ec.assemblylogic
 
 import android.app.Application
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.PeriodicWorkRequest
+import androidx.work.WorkManager
 import eu.europa.ec.analyticslogic.controller.AnalyticsController
 import eu.europa.ec.assemblylogic.di.setupKoin
 import eu.europa.ec.businesslogic.config.ConfigLogic
+import eu.europa.ec.corelogic.worker.RevocationWorkManager
 import eu.europa.ec.eudi.rqesui.infrastructure.EudiRQESUi
 import org.koin.android.ext.android.inject
 import org.koin.core.KoinApplication
@@ -33,6 +37,7 @@ class Application : Application() {
         super.onCreate()
         initializeKoin().initializeRqes()
         initializeReporting()
+        initializeRevocationWorkManager()
     }
 
     private fun KoinApplication.initializeRqes() {
@@ -50,4 +55,18 @@ class Application : Application() {
     private fun initializeReporting() {
         analyticsController.initialize(this)
     }
+
+    private fun initializeRevocationWorkManager() {
+
+        val periodicWorkRequest = PeriodicWorkRequest.Builder(
+            workerClass = RevocationWorkManager::class.java,
+            repeatInterval = configLogic.revocationInterval,
+        ).build()
+
+        WorkManager.getInstance(this).enqueueUniquePeriodicWork(
+            RevocationWorkManager.REVOCATION_WORK_NAME,
+            ExistingPeriodicWorkPolicy.KEEP,
+            periodicWorkRequest
+        )
+    }
 }

build-logic/convention/src/main/kotlin/AndroidLibraryConventionPlugin.kt

@@ -74,6 +74,7 @@ class AndroidLibraryConventionPlugin : Plugin<Project> {
                 apply("org.jetbrains.kotlin.android")
                 apply("kotlinx-serialization")
                 apply("com.google.android.libraries.mapsplatform.secrets-gradle-plugin")
+                apply("kotlin-parcelize")
             }
 
             extensions.configure<LibraryExtension> {
@@ -146,6 +147,7 @@ class AndroidLibraryConventionPlugin : Plugin<Project> {
                 add("implementation", libs.findLibrary("kotlinx-coroutines-android").get())
                 add("implementation", libs.findLibrary("kotlinx-coroutines-guava").get())
                 add("implementation", libs.findLibrary("kotlinx.serialization.json").get())
+                add("implementation", libs.findLibrary("androidx-work-ktx").get())
             }
             afterEvaluate {
                 if (!config.module.isLogicModule && !config.module.isFeatureCommon) {

business-logic/src/main/java/eu/europa/ec/businesslogic/config/ConfigLogic.kt

@@ -18,6 +18,7 @@ package eu.europa.ec.businesslogic.config
 
 import eu.europa.ec.businesslogic.BuildConfig
 import eu.europa.ec.eudi.rqesui.infrastructure.config.EudiRQESUiConfig
+import java.time.Duration
 
 interface ConfigLogic {
 
@@ -58,6 +59,15 @@ interface ConfigLogic {
      *   changelog is maintained for development builds.
      */
     val changelogUrl: String?
+
+
+    /**
+     * The interval at which revocations are checked.
+     *
+     * This property defines the time interval between checks for revoked tokens or credentials.
+     * It is currently set to 15 minutes.
+     */
+    val revocationInterval: Duration get() = Duration.ofMinutes(15)
 }
 
 enum class AppFlavor {

business-logic/src/main/java/eu/europa/ec/businesslogic/extension/IntentExtensions.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 European Commission
+ *
+ * Licensed under the EUPL, Version 1.2 or - as soon they will be approved by the European
+ * Commission - subsequent versions of the EUPL (the "Licence"); You may not use this work
+ * except in compliance with the Licence.
+ *
+ * You may obtain a copy of the Licence at:
+ * https://joinup.ec.europa.eu/software/page/eupl
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the Licence is distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF
+ * ANY KIND, either express or implied. See the Licence for the specific language
+ * governing permissions and limitations under the Licence.
+ */
+
+package eu.europa.ec.businesslogic.extension
+
+import android.content.Intent
+import android.os.Build
+import android.os.Parcelable
+import androidx.annotation.CheckResult
+
+@CheckResult
+inline fun <reified T : Parcelable> Intent?.getParcelableArrayListExtra(
+    action: String
+): List<T>? {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        this?.getParcelableArrayListExtra(
+            action,
+            T::class.java
+        )
+    } else {
+        @Suppress("DEPRECATION")
+        this?.getParcelableArrayListExtra(action)
+    }?.filterNotNull()
+}

common-feature/src/main/java/eu/europa/ec/commonfeature/model/DocumentDetailsUi.kt

@@ -21,7 +21,7 @@ import eu.europa.ec.eudi.wallet.document.DocumentId
 import eu.europa.ec.uilogic.component.wrap.ExpandableListItem
 
 enum class DocumentUiIssuanceState {
-    Issued, Pending, Failed, Expired
+    Issued, Pending, Failed, Expired, Revoked
 }
 
 data class DocumentDetailsUi(

common-feature/src/main/java/eu/europa/ec/commonfeature/ui/request/RequestViewModel.kt

@@ -63,12 +63,12 @@ sealed class Event : ViewEvent {
 sealed class Effect : ViewSideEffect {
     sealed class Navigation : Effect() {
         data class SwitchScreen(
-            val screenRoute: String
+            val screenRoute: String,
         ) : Navigation()
 
         data object Pop : Navigation()
         data class PopTo(
-            val screenRoute: String
+            val screenRoute: String,
         ) : Navigation()
     }
 
@@ -99,7 +99,7 @@ abstract class RequestViewModel : MviViewModel<Event, State, Effect>() {
 
     open fun updateData(
         updatedItems: List<RequestDocumentItemUi>,
-        allowShare: Boolean? = null
+        allowShare: Boolean? = null,
     ) {
         val hasAtLeastOneFieldSelected = hasAtLeastOneFieldSelected(
             requestDocuments = updatedItems
@@ -265,7 +265,7 @@ abstract class RequestViewModel : MviViewModel<Event, State, Effect>() {
     }
 
     private fun hasAtLeastOneFieldSelected(
-        requestDocuments: List<RequestDocumentItemUi>
+        requestDocuments: List<RequestDocumentItemUi>,
     ): Boolean {
         val hasAtLeastOneFieldSelected: Boolean = requestDocuments.any { requestDocument ->
             requestDocument.headerUi.nestedItems.hasAnySingleSelected()

common-feature/src/main/java/eu/europa/ec/commonfeature/ui/request/transformer/RequestTransformer.kt

@@ -22,6 +22,7 @@ import eu.europa.ec.commonfeature.ui.request.model.DomainDocumentFormat
 import eu.europa.ec.commonfeature.ui.request.model.RequestDocumentItemUi
 import eu.europa.ec.commonfeature.util.docNamespace
 import eu.europa.ec.commonfeature.util.transformPathsToDomainClaims
+import eu.europa.ec.corelogic.extension.toClaimPaths
 import eu.europa.ec.corelogic.model.ClaimPath
 import eu.europa.ec.eudi.iso18013.transfer.response.DisclosedDocument
 import eu.europa.ec.eudi.iso18013.transfer.response.DisclosedDocuments
@@ -48,16 +49,27 @@ object RequestTransformer {
         val resultList = mutableListOf<DocumentPayloadDomain>()
 
         requestDocuments.forEach { requestDocument ->
+
             val storageDocument =
                 storageDocuments.first { it.id == requestDocument.documentId }
 
+            val claimsPaths = storageDocument.data.claims.flatMap { claim ->
+                claim.toClaimPaths()
+            }
+
             val requestedItemsPaths = requestDocument.requestedItems.keys
                 .map {
                     it.toClaimPath()
                 }
 
+            val filteredPaths = claimsPaths.filter { available ->
+                requestedItemsPaths.any { requested ->
+                    available.joined.startsWith(requested.joined)
+                }
+            }
+
             val domainClaims = transformPathsToDomainClaims(
-                paths = requestedItemsPaths,
+                paths = filteredPaths,
                 claims = storageDocument.data.claims,
                 metadata = storageDocument.metadata,
                 resourceProvider = resourceProvider,

common-feature/src/main/java/eu/europa/ec/commonfeature/util/DocumentHelper.kt

@@ -105,7 +105,6 @@ fun getReadableNameFromIdentifier(
         )
 }
 
-@OptIn(ExperimentalUuidApi::class)
 fun createKeyValue(
     item: Any,
     groupKey: String,
@@ -115,24 +114,75 @@ fun createKeyValue(
     metadata: DocumentMetaData?,
     allItems: MutableList<DomainClaim>,
 ) {
+
+    @OptIn(ExperimentalUuidApi::class)
+    fun addFlatOrGroupedChildren(
+        allItems: MutableList<DomainClaim>,
+        children: List<DomainClaim>,
+        groupKey: String,
+        metadata: DocumentMetaData?,
+        locale: Locale,
+        predicate: () -> Boolean
+    ) {
+
+        val groupIsAlreadyPresent = children
+            .filterIsInstance<DomainClaim.Group>()
+            .any { it.key == groupKey }
+
+        if (predicate() && !groupIsAlreadyPresent) {
+            allItems.add(
+                DomainClaim.Group(
+                    key = groupKey,
+                    displayTitle = getReadableNameFromIdentifier(
+                        metadata = metadata,
+                        userLocale = locale,
+                        identifier = groupKey
+                    ),
+                    path = ClaimPath(listOf(Uuid.random().toString())),
+                    items = children
+                )
+            )
+        } else {
+            allItems.addAll(children)
+        }
+    }
+
     when (item) {
 
         is Map<*, *> -> {
+
+            val children: MutableList<DomainClaim> = mutableListOf()
+            val childKeys: MutableList<String> = mutableListOf()
+
             item.forEach { (key, value) ->
                 safeLet(key as? String, value) { key, value ->
+
                     val newGroupKey = if (value is Collection<*>) key else groupKey
                     val newChildKey = if (value is Collection<*>) "" else key
+
+                    childKeys.add(newChildKey)
+
                     createKeyValue(
                         item = value,
                         groupKey = newGroupKey,
                         childKey = newChildKey,
                         disclosurePath = disclosurePath,
                         resourceProvider = resourceProvider,
                         metadata = metadata,
-                        allItems = allItems
+                        allItems = children
                     )
                 }
             }
+
+            addFlatOrGroupedChildren(
+                allItems = allItems,
+                children = children,
+                groupKey = groupKey,
+                metadata = metadata,
+                locale = resourceProvider.getLocale()
+            ) {
+                !childKeys.any { it.isEmpty() }
+            }
         }
 
         is Collection<*> -> {
@@ -152,21 +202,14 @@ fun createKeyValue(
                 }
             }
 
-            if (childKey.isEmpty()) {
-                allItems.add(
-                    DomainClaim.Group(
-                        key = groupKey,
-                        displayTitle = getReadableNameFromIdentifier(
-                            metadata = metadata,
-                            userLocale = resourceProvider.getLocale(),
-                            identifier = groupKey
-                        ),
-                        path = ClaimPath(listOf(Uuid.random().toString())),
-                        items = children
-                    )
-                )
-            } else {
-                allItems.addAll(children)
+            addFlatOrGroupedChildren(
+                allItems = allItems,
+                children = children,
+                groupKey = groupKey,
+                metadata = metadata,
+                locale = resourceProvider.getLocale()
+            ) {
+                childKey.isEmpty()
             }
         }
 

core-logic/build.gradle.kts

@@ -34,6 +34,7 @@ moduleConfig {
 dependencies {
     implementation(project(LibraryModule.ResourcesLogic.path))
     implementation(project(LibraryModule.BusinessLogic.path))
+    implementation(project(LibraryModule.StorageLogic.path))
     implementation(project(LibraryModule.AuthenticationLogic.path))
 
     implementation(libs.androidx.biometric)

core-logic/src/main/java/eu/europa/ec/corelogic/controller/WalletCoreDocumentsController.kt

@@ -29,6 +29,7 @@ import eu.europa.ec.corelogic.model.FormatType
 import eu.europa.ec.corelogic.model.ScopedDocument
 import eu.europa.ec.corelogic.model.toDocumentIdentifier
 import eu.europa.ec.eudi.openid4vci.MsoMdocCredential
+import eu.europa.ec.eudi.statium.Status
 import eu.europa.ec.eudi.wallet.EudiWallet
 import eu.europa.ec.eudi.wallet.document.DeferredDocument
 import eu.europa.ec.eudi.wallet.document.Document
@@ -45,6 +46,7 @@ import eu.europa.ec.eudi.wallet.issue.openid4vci.OfferResult
 import eu.europa.ec.eudi.wallet.issue.openid4vci.OpenId4VciManager
 import eu.europa.ec.resourceslogic.R
 import eu.europa.ec.resourceslogic.provider.ResourceProvider
+import eu.europa.ec.storagelogic.controller.RevokedDocumentsStorageController
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.channels.ProducerScope
@@ -171,12 +173,19 @@ interface WalletCoreDocumentsController {
     suspend fun getScopedDocuments(locale: Locale): FetchScopedDocumentsPartialState
 
     fun getAllDocumentCategories(): DocumentCategories
+
+    suspend fun getRevokedDocumentIds(): List<String>
+
+    suspend fun isDocumentRevoked(id: String): Boolean
+
+    suspend fun resolveDocumentStatus(document: IssuedDocument): Result<Status>
 }
 
 class WalletCoreDocumentsControllerImpl(
     private val resourceProvider: ResourceProvider,
     private val eudiWallet: EudiWallet,
     private val walletCoreConfig: WalletCoreConfig,
+    private val revokedDocumentsStorageController: RevokedDocumentsStorageController,
     private val dispatcher: CoroutineDispatcher = Dispatchers.IO
 ) : WalletCoreDocumentsController {
 
@@ -329,7 +338,10 @@ class WalletCoreDocumentsControllerImpl(
     override fun deleteDocument(documentId: String): Flow<DeleteDocumentPartialState> = flow {
         eudiWallet.deleteDocumentById(documentId = documentId)
             .kotlinResult
-            .onSuccess { emit(DeleteDocumentPartialState.Success) }
+            .onSuccess {
+                revokedDocumentsStorageController.delete(documentId)
+                emit(DeleteDocumentPartialState.Success)
+            }
             .onFailure {
                 emit(
                     DeleteDocumentPartialState.Failure(
@@ -346,10 +358,12 @@ class WalletCoreDocumentsControllerImpl(
 
     override fun deleteAllDocuments(mainPidDocumentId: String): Flow<DeleteAllDocumentsPartialState> =
         flow {
+
             val allDocuments = getAllDocuments()
             val mainPidDocument = getMainPidDocument()
 
             mainPidDocument?.let {
+
                 val restOfDocuments = allDocuments.minusElement(it)
 
                 var restOfAllDocsDeleted = true
@@ -510,6 +524,15 @@ class WalletCoreDocumentsControllerImpl(
         return walletCoreConfig.documentCategories
     }
 
+    override suspend fun getRevokedDocumentIds(): List<String> =
+        revokedDocumentsStorageController.retrieveAll().map { it.identifier }
+
+    override suspend fun isDocumentRevoked(id: String): Boolean =
+        revokedDocumentsStorageController.retrieve(id) != null
+
+    override suspend fun resolveDocumentStatus(document: IssuedDocument): Result<Status> =
+        eudiWallet.resolveStatus(document)
+
     private fun issueDocumentWithOpenId4VCI(configId: String): Flow<IssueDocumentsPartialState> =
         callbackFlow {