knock requests : rename KnockRequestsActionTarget to KnockRequestAction

ganfra · ganfra · commit f4f669cbbbcd · 2024-12-19T20:08:14.000+01:00
diff --git a/features/knockrequests/impl/src/main/kotlin/io/element/android/features/knockrequests/impl/list/KnockRequestsListPresenter.kt b/features/knockrequests/impl/src/main/kotlin/io/element/android/features/knockrequests/impl/list/KnockRequestsListPresenter.kt
@@ -30,7 +30,7 @@ class KnockRequestsListPresenter @Inject constructor(
     @Composable
     override fun present(): KnockRequestsListState {
         val asyncAction = remember { mutableStateOf<AsyncAction<Unit>>(AsyncAction.Uninitialized) }
-        var actionTarget by remember { mutableStateOf<KnockRequestsActionTarget>(KnockRequestsActionTarget.None) }
+        var currentAction by remember { mutableStateOf<KnockRequestsAction>(KnockRequestsAction.None) }
 
         val permissions by knockRequestsService.permissionsFlow.collectAsState()
         val knockRequests by knockRequestsService.knockRequestsFlow.collectAsState()
@@ -40,72 +40,72 @@ class KnockRequestsListPresenter @Inject constructor(
         fun handleEvents(event: KnockRequestsListEvents) {
             when (event) {
                 KnockRequestsListEvents.AcceptAll -> {
-                    actionTarget = KnockRequestsActionTarget.AcceptAll
+                    currentAction = KnockRequestsAction.AcceptAll
                 }
                 is KnockRequestsListEvents.Accept -> {
-                    actionTarget = KnockRequestsActionTarget.Accept(event.knockRequest)
+                    currentAction = KnockRequestsAction.Accept(event.knockRequest)
                 }
                 is KnockRequestsListEvents.Decline -> {
-                    actionTarget = KnockRequestsActionTarget.Decline(event.knockRequest)
+                    currentAction = KnockRequestsAction.Decline(event.knockRequest)
                 }
                 is KnockRequestsListEvents.DeclineAndBan -> {
-                    actionTarget = KnockRequestsActionTarget.DeclineAndBan(event.knockRequest)
+                    currentAction = KnockRequestsAction.DeclineAndBan(event.knockRequest)
                 }
                 KnockRequestsListEvents.ResetCurrentAction -> {
                     asyncAction.value = AsyncAction.Uninitialized
-                    actionTarget = KnockRequestsActionTarget.None
+                    currentAction = KnockRequestsAction.None
                 }
                 KnockRequestsListEvents.RetryCurrentAction -> {
-                    coroutineScope.executeAction(actionTarget, asyncAction, isActionConfirmed = true)
+                    coroutineScope.executeAction(currentAction, asyncAction, isActionConfirmed = true)
                 }
                 KnockRequestsListEvents.ConfirmCurrentAction -> {
-                    coroutineScope.executeAction(actionTarget, asyncAction, isActionConfirmed = true)
+                    coroutineScope.executeAction(currentAction, asyncAction, isActionConfirmed = true)
                 }
             }
         }
-        LaunchedEffect(actionTarget) {
-            executeAction(actionTarget, asyncAction, isActionConfirmed = false)
+        LaunchedEffect(currentAction) {
+            executeAction(currentAction, asyncAction, isActionConfirmed = false)
         }
 
         return KnockRequestsListState(
             knockRequests = knockRequests,
-            actionTarget = actionTarget,
+            currentAction = currentAction,
             permissions = permissions,
             asyncAction = asyncAction.value,
             eventSink = ::handleEvents
         )
     }
 
     private fun CoroutineScope.executeAction(
-        actionTarget: KnockRequestsActionTarget,
+        currentAction: KnockRequestsAction,
         asyncAction: MutableState<AsyncAction<Unit>>,
         isActionConfirmed: Boolean,
     ) = launch {
-        when (actionTarget) {
-            is KnockRequestsActionTarget.Accept -> {
+        when (currentAction) {
+            is KnockRequestsAction.Accept -> {
                 runUpdatingState(asyncAction) {
-                    knockRequestsService.acceptKnockRequest(actionTarget.knockRequest)
+                    knockRequestsService.acceptKnockRequest(currentAction.knockRequest)
                 }
             }
-            is KnockRequestsActionTarget.Decline -> {
+            is KnockRequestsAction.Decline -> {
                 if (isActionConfirmed) {
                     runUpdatingState(asyncAction) {
-                        knockRequestsService.declineKnockRequest(actionTarget.knockRequest)
+                        knockRequestsService.declineKnockRequest(currentAction.knockRequest)
                     }
                 } else {
                     asyncAction.value = AsyncAction.ConfirmingNoParams
                 }
             }
-            is KnockRequestsActionTarget.DeclineAndBan -> {
+            is KnockRequestsAction.DeclineAndBan -> {
                 if (isActionConfirmed) {
                     runUpdatingState(asyncAction) {
-                        knockRequestsService.declineAndBanKnockRequest(actionTarget.knockRequest)
+                        knockRequestsService.declineAndBanKnockRequest(currentAction.knockRequest)
                     }
                 } else {
                     asyncAction.value = AsyncAction.ConfirmingNoParams
                 }
             }
-            is KnockRequestsActionTarget.AcceptAll -> {
+            is KnockRequestsAction.AcceptAll -> {
                 if (isActionConfirmed) {
                     runUpdatingState(asyncAction) {
                         knockRequestsService.acceptAllKnockRequests()
@@ -114,7 +114,7 @@ class KnockRequestsListPresenter @Inject constructor(
                     asyncAction.value = AsyncAction.ConfirmingNoParams
                 }
             }
-            KnockRequestsActionTarget.None -> Unit
+            KnockRequestsAction.None -> Unit
         }
     }
 }
diff --git a/features/knockrequests/impl/src/main/kotlin/io/element/android/features/knockrequests/impl/list/KnockRequestsListState.kt b/features/knockrequests/impl/src/main/kotlin/io/element/android/features/knockrequests/impl/list/KnockRequestsListState.kt
@@ -16,7 +16,7 @@ import kotlinx.collections.immutable.ImmutableList
 
 data class KnockRequestsListState(
     val knockRequests: AsyncData<ImmutableList<KnockRequestPresentable>>,
-    val actionTarget: KnockRequestsActionTarget,
+    val currentAction: KnockRequestsAction,
     val asyncAction: AsyncAction<Unit>,
     val permissions: KnockRequestPermissions,
     val eventSink: (KnockRequestsListEvents) -> Unit,
@@ -25,10 +25,10 @@ data class KnockRequestsListState(
 }
 
 @Immutable
-sealed interface KnockRequestsActionTarget {
-    data object None : KnockRequestsActionTarget
-    data class Accept(val knockRequest: KnockRequestPresentable) : KnockRequestsActionTarget
-    data class Decline(val knockRequest: KnockRequestPresentable) : KnockRequestsActionTarget
-    data class DeclineAndBan(val knockRequest: KnockRequestPresentable) : KnockRequestsActionTarget
-    data object AcceptAll : KnockRequestsActionTarget
+sealed interface KnockRequestsAction {
+    data object None : KnockRequestsAction
+    data class Accept(val knockRequest: KnockRequestPresentable) : KnockRequestsAction
+    data class Decline(val knockRequest: KnockRequestPresentable) : KnockRequestsAction
+    data class DeclineAndBan(val knockRequest: KnockRequestPresentable) : KnockRequestsAction
+    data object AcceptAll : KnockRequestsAction
 }
diff --git a/features/knockrequests/impl/src/main/kotlin/io/element/android/features/knockrequests/impl/list/KnockRequestsListStateProvider.kt b/features/knockrequests/impl/src/main/kotlin/io/element/android/features/knockrequests/impl/list/KnockRequestsListStateProvider.kt
@@ -65,7 +65,7 @@ open class KnockRequestsListStateProvider : PreviewParameterProvider<KnockReques
                         aKnockRequestPresentable()
                     )
                 ),
-                actionTarget = KnockRequestsActionTarget.AcceptAll,
+                currentAction = KnockRequestsAction.AcceptAll,
                 asyncAction = AsyncAction.ConfirmingNoParams,
             ),
             aKnockRequestsListState(
@@ -74,7 +74,7 @@ open class KnockRequestsListStateProvider : PreviewParameterProvider<KnockReques
                         aKnockRequestPresentable()
                     )
                 ),
-                actionTarget = KnockRequestsActionTarget.AcceptAll,
+                currentAction = KnockRequestsAction.AcceptAll,
                 asyncAction = AsyncAction.Loading,
             ),
             aKnockRequestsListState(
@@ -88,7 +88,7 @@ open class KnockRequestsListStateProvider : PreviewParameterProvider<KnockReques
                     canDecline = true,
                     canBan = true,
                 ),
-                actionTarget = KnockRequestsActionTarget.AcceptAll,
+                currentAction = KnockRequestsAction.AcceptAll,
                 asyncAction = AsyncAction.Failure(Throwable("Failed to accept all")),
             ),
             aKnockRequestsListState(
@@ -132,7 +132,7 @@ open class KnockRequestsListStateProvider : PreviewParameterProvider<KnockReques
 
 fun aKnockRequestsListState(
     knockRequests: AsyncData<ImmutableList<KnockRequestPresentable>> = AsyncData.Success(persistentListOf()),
-    actionTarget: KnockRequestsActionTarget = KnockRequestsActionTarget.None,
+    currentAction: KnockRequestsAction = KnockRequestsAction.None,
     asyncAction: AsyncAction<Unit> = AsyncAction.Uninitialized,
     permissions: KnockRequestPermissions = KnockRequestPermissions(
         canAccept = true,
@@ -142,7 +142,7 @@ fun aKnockRequestsListState(
     eventSink: (KnockRequestsListEvents) -> Unit = {},
 ) = KnockRequestsListState(
     knockRequests = knockRequests,
-    actionTarget = actionTarget,
+    currentAction = currentAction,
     asyncAction = asyncAction,
     permissions = permissions,
     eventSink = eventSink,
diff --git a/features/knockrequests/impl/src/main/kotlin/io/element/android/features/knockrequests/impl/list/KnockRequestsListView.kt b/features/knockrequests/impl/src/main/kotlin/io/element/android/features/knockrequests/impl/list/KnockRequestsListView.kt
@@ -153,7 +153,7 @@ private fun KnockRequestsListContent(
             else -> Unit
         }
         KnockRequestsActionsView(
-            actionTarget = state.actionTarget,
+            currentAction = state.currentAction,
             asyncAction = state.asyncAction,
             onConfirm = {
                 state.eventSink(KnockRequestsListEvents.ConfirmCurrentAction)
@@ -181,7 +181,7 @@ private fun KnockRequestsListContent(
 
 @Composable
 private fun KnockRequestsActionsView(
-    actionTarget: KnockRequestsActionTarget,
+    currentAction: KnockRequestsAction,
     asyncAction: AsyncAction<Unit>,
     onConfirm: () -> Unit,
     onDismiss: () -> Unit,
@@ -195,20 +195,20 @@ private fun KnockRequestsActionsView(
             onErrorDismiss = onDismiss,
             confirmationDialog = {
                 KnockRequestActionConfirmation(
-                    actionTarget = actionTarget,
+                    currentAction = currentAction,
                     onSubmit = onConfirm,
                     onDismiss = onDismiss,
                 )
             },
             progressDialog = {
-                KnockRequestActionProgress(target = actionTarget)
+                KnockRequestActionProgress(target = currentAction)
             },
             errorMessage = {
-                when (actionTarget) {
-                    is KnockRequestsActionTarget.Accept -> stringResource(R.string.screen_knock_requests_list_accept_failed_alert_description)
-                    is KnockRequestsActionTarget.Decline -> stringResource(R.string.screen_knock_requests_list_decline_failed_alert_description)
-                    is KnockRequestsActionTarget.DeclineAndBan -> stringResource(R.string.screen_knock_requests_list_decline_failed_alert_description)
-                    KnockRequestsActionTarget.AcceptAll -> stringResource(R.string.screen_knock_requests_list_accept_all_failed_alert_description)
+                when (currentAction) {
+                    is KnockRequestsAction.Accept -> stringResource(R.string.screen_knock_requests_list_accept_failed_alert_description)
+                    is KnockRequestsAction.Decline -> stringResource(R.string.screen_knock_requests_list_decline_failed_alert_description)
+                    is KnockRequestsAction.DeclineAndBan -> stringResource(R.string.screen_knock_requests_list_decline_failed_alert_description)
+                    KnockRequestsAction.AcceptAll -> stringResource(R.string.screen_knock_requests_list_accept_all_failed_alert_description)
                     else -> ""
                 }
             },
@@ -219,25 +219,25 @@ private fun KnockRequestsActionsView(
 
 @Composable
 private fun KnockRequestActionConfirmation(
-    actionTarget: KnockRequestsActionTarget,
+    currentAction: KnockRequestsAction,
     onSubmit: () -> Unit,
     onDismiss: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
-    val (title, content, submitText) = when (actionTarget) {
-        KnockRequestsActionTarget.AcceptAll -> Triple(
+    val (title, content, submitText) = when (currentAction) {
+        KnockRequestsAction.AcceptAll -> Triple(
             stringResource(R.string.screen_knock_requests_list_accept_all_alert_title),
             stringResource(R.string.screen_knock_requests_list_accept_all_alert_description),
             stringResource(R.string.screen_knock_requests_list_accept_all_alert_confirm_button_title),
         )
-        is KnockRequestsActionTarget.Decline -> Triple(
+        is KnockRequestsAction.Decline -> Triple(
             stringResource(R.string.screen_knock_requests_list_decline_alert_title),
-            stringResource(R.string.screen_knock_requests_list_decline_alert_description, actionTarget.knockRequest.getBestName()),
+            stringResource(R.string.screen_knock_requests_list_decline_alert_description, currentAction.knockRequest.getBestName()),
             stringResource(R.string.screen_knock_requests_list_decline_alert_confirm_button_title),
         )
-        is KnockRequestsActionTarget.DeclineAndBan -> Triple(
+        is KnockRequestsAction.DeclineAndBan -> Triple(
             stringResource(R.string.screen_knock_requests_list_ban_alert_title),
-            stringResource(R.string.screen_knock_requests_list_ban_alert_description, actionTarget.knockRequest.getBestName()),
+            stringResource(R.string.screen_knock_requests_list_ban_alert_description, currentAction.knockRequest.getBestName()),
             stringResource(R.string.screen_knock_requests_list_ban_alert_confirm_button_title),
         )
         else -> return
@@ -254,14 +254,14 @@ private fun KnockRequestActionConfirmation(
 
 @Composable
 private fun KnockRequestActionProgress(
-    target: KnockRequestsActionTarget,
+    target: KnockRequestsAction,
     modifier: Modifier = Modifier,
 ) {
     val progressText = when (target) {
-        is KnockRequestsActionTarget.Accept -> stringResource(R.string.screen_knock_requests_list_accept_loading_title)
-        is KnockRequestsActionTarget.Decline -> stringResource(R.string.screen_knock_requests_list_decline_loading_title)
-        is KnockRequestsActionTarget.DeclineAndBan -> stringResource(R.string.screen_knock_requests_list_ban_loading_title)
-        KnockRequestsActionTarget.AcceptAll -> stringResource(R.string.screen_knock_requests_list_accept_all_loading_title)
+        is KnockRequestsAction.Accept -> stringResource(R.string.screen_knock_requests_list_accept_loading_title)
+        is KnockRequestsAction.Decline -> stringResource(R.string.screen_knock_requests_list_decline_loading_title)
+        is KnockRequestsAction.DeclineAndBan -> stringResource(R.string.screen_knock_requests_list_ban_loading_title)
+        KnockRequestsAction.AcceptAll -> stringResource(R.string.screen_knock_requests_list_accept_all_loading_title)
         else -> return
     }
     ProgressDialog(
diff --git a/features/knockrequests/impl/src/test/kotlin/io/element/android/features/knockrequests/impl/list/KnockRequestsListPresenterTest.kt b/features/knockrequests/impl/src/test/kotlin/io/element/android/features/knockrequests/impl/list/KnockRequestsListPresenterTest.kt
diff --git a/features/knockrequests/impl/src/test/kotlin/io/element/android/features/knockrequests/impl/list/KnockRequestsListViewTest.kt b/features/knockrequests/impl/src/test/kotlin/io/element/android/features/knockrequests/impl/list/KnockRequestsListViewTest.kt

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ class KnockRequestsListPresenter @Inject constructor(`
`30`	`30`	`@Composable`
`31`	`31`	`override fun present(): KnockRequestsListState {`
`32`	`32`	`val asyncAction = remember { mutableStateOf<AsyncAction<Unit>>(AsyncAction.Uninitialized) }`
`33`		`- var actionTarget by remember { mutableStateOf<KnockRequestsActionTarget>(KnockRequestsActionTarget.None) }`
	`33`	`+ var currentAction by remember { mutableStateOf<KnockRequestsAction>(KnockRequestsAction.None) }`
`34`	`34`
`35`	`35`	`val permissions by knockRequestsService.permissionsFlow.collectAsState()`
`36`	`36`	`val knockRequests by knockRequestsService.knockRequestsFlow.collectAsState()`
`@@ -40,72 +40,72 @@ class KnockRequestsListPresenter @Inject constructor(`
`40`	`40`	`fun handleEvents(event: KnockRequestsListEvents) {`
`41`	`41`	`when (event) {`
`42`	`42`	`KnockRequestsListEvents.AcceptAll -> {`
`43`		`- actionTarget = KnockRequestsActionTarget.AcceptAll`
	`43`	`+ currentAction = KnockRequestsAction.AcceptAll`
`44`	`44`	`}`
`45`	`45`	`is KnockRequestsListEvents.Accept -> {`
`46`		`- actionTarget = KnockRequestsActionTarget.Accept(event.knockRequest)`
	`46`	`+ currentAction = KnockRequestsAction.Accept(event.knockRequest)`
`47`	`47`	`}`
`48`	`48`	`is KnockRequestsListEvents.Decline -> {`
`49`		`- actionTarget = KnockRequestsActionTarget.Decline(event.knockRequest)`
	`49`	`+ currentAction = KnockRequestsAction.Decline(event.knockRequest)`
`50`	`50`	`}`
`51`	`51`	`is KnockRequestsListEvents.DeclineAndBan -> {`
`52`		`- actionTarget = KnockRequestsActionTarget.DeclineAndBan(event.knockRequest)`
	`52`	`+ currentAction = KnockRequestsAction.DeclineAndBan(event.knockRequest)`
`53`	`53`	`}`
`54`	`54`	`KnockRequestsListEvents.ResetCurrentAction -> {`
`55`	`55`	`asyncAction.value = AsyncAction.Uninitialized`
`56`		`- actionTarget = KnockRequestsActionTarget.None`
	`56`	`+ currentAction = KnockRequestsAction.None`
`57`	`57`	`}`
`58`	`58`	`KnockRequestsListEvents.RetryCurrentAction -> {`
`59`		`- coroutineScope.executeAction(actionTarget, asyncAction, isActionConfirmed = true)`
	`59`	`+ coroutineScope.executeAction(currentAction, asyncAction, isActionConfirmed = true)`
`60`	`60`	`}`
`61`	`61`	`KnockRequestsListEvents.ConfirmCurrentAction -> {`
`62`		`- coroutineScope.executeAction(actionTarget, asyncAction, isActionConfirmed = true)`
	`62`	`+ coroutineScope.executeAction(currentAction, asyncAction, isActionConfirmed = true)`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`	`}`
`66`		`- LaunchedEffect(actionTarget) {`
`67`		`- executeAction(actionTarget, asyncAction, isActionConfirmed = false)`
	`66`	`+ LaunchedEffect(currentAction) {`
	`67`	`+ executeAction(currentAction, asyncAction, isActionConfirmed = false)`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`return KnockRequestsListState(`
`71`	`71`	`knockRequests = knockRequests,`
`72`		`- actionTarget = actionTarget,`
	`72`	`+ currentAction = currentAction,`
`73`	`73`	`permissions = permissions,`
`74`	`74`	`asyncAction = asyncAction.value,`
`75`	`75`	`eventSink = ::handleEvents`
`76`	`76`	`)`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`private fun CoroutineScope.executeAction(`
`80`		`- actionTarget: KnockRequestsActionTarget,`
	`80`	`+ currentAction: KnockRequestsAction,`
`81`	`81`	`asyncAction: MutableState<AsyncAction<Unit>>,`
`82`	`82`	`isActionConfirmed: Boolean,`
`83`	`83`	`) = launch {`
`84`		`- when (actionTarget) {`
`85`		`- is KnockRequestsActionTarget.Accept -> {`
	`84`	`+ when (currentAction) {`
	`85`	`+ is KnockRequestsAction.Accept -> {`
`86`	`86`	`runUpdatingState(asyncAction) {`
`87`		`- knockRequestsService.acceptKnockRequest(actionTarget.knockRequest)`
	`87`	`+ knockRequestsService.acceptKnockRequest(currentAction.knockRequest)`
`88`	`88`	`}`
`89`	`89`	`}`
`90`		`- is KnockRequestsActionTarget.Decline -> {`
	`90`	`+ is KnockRequestsAction.Decline -> {`
`91`	`91`	`if (isActionConfirmed) {`
`92`	`92`	`runUpdatingState(asyncAction) {`
`93`		`- knockRequestsService.declineKnockRequest(actionTarget.knockRequest)`
	`93`	`+ knockRequestsService.declineKnockRequest(currentAction.knockRequest)`
`94`	`94`	`}`
`95`	`95`	`} else {`
`96`	`96`	`asyncAction.value = AsyncAction.ConfirmingNoParams`
`97`	`97`	`}`
`98`	`98`	`}`
`99`		`- is KnockRequestsActionTarget.DeclineAndBan -> {`
	`99`	`+ is KnockRequestsAction.DeclineAndBan -> {`
`100`	`100`	`if (isActionConfirmed) {`
`101`	`101`	`runUpdatingState(asyncAction) {`
`102`		`- knockRequestsService.declineAndBanKnockRequest(actionTarget.knockRequest)`
	`102`	`+ knockRequestsService.declineAndBanKnockRequest(currentAction.knockRequest)`
`103`	`103`	`}`
`104`	`104`	`} else {`
`105`	`105`	`asyncAction.value = AsyncAction.ConfirmingNoParams`
`106`	`106`	`}`
`107`	`107`	`}`
`108`		`- is KnockRequestsActionTarget.AcceptAll -> {`
	`108`	`+ is KnockRequestsAction.AcceptAll -> {`
`109`	`109`	`if (isActionConfirmed) {`
`110`	`110`	`runUpdatingState(asyncAction) {`
`111`	`111`	`knockRequestsService.acceptAllKnockRequests()`
`@@ -114,7 +114,7 @@ class KnockRequestsListPresenter @Inject constructor(`
`114`	`114`	`asyncAction.value = AsyncAction.ConfirmingNoParams`
`115`	`115`	`}`
`116`	`116`	`}`
`117`		`- KnockRequestsActionTarget.None -> Unit`
	`117`	`+ KnockRequestsAction.None -> Unit`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`	`}`