Toggle visibility of deleted units in AccountSelector (#1837)

* testing with new functionality

* use local state for saving showDeleted state

* add feature toggle and tests

* rabbit qa

* fix components buttons

---------

Co-authored-by: Vedeler <acn-avede@ai-dev.no>

Author: allinox

backend/src/Altinn.AccessManagement.UI/Altinn.AccessManagement.UI.Core/ClientInterfaces/IProfileClient.cs

@@ -19,6 +19,13 @@ public interface IProfileClient
         /// <returns>users profile settings</returns>
         Task<UserProfile> GetUserProfile(Guid uuid);
 
+        /// <summary>
+        /// Updates the current user's profile settings in altinn profile
+        /// </summary>
+        /// <param name="settingsChange">the settings to be changed. Can be the full object or a partial one</param>
+        /// <returns>users profile settings</returns>
+        Task<ProfileSettingPreference> PatchCurrentUserProfileSetting(ProfileSettingPreference settingsChange);
+
         /// <summary>
         /// Gets the organization's notification addresses from altinn profile
         /// </summary>

backend/src/Altinn.AccessManagement.UI/Altinn.AccessManagement.UI.Core/Configuration/FeatureFlags.cs

@@ -61,6 +61,11 @@ public class FeatureFlags
         /// </summary>
         public bool DisplayRequestsPage { get; set; }
 
+        /// <summary>
+        /// Whether to display the deleted account toggle feature
+        /// </summary>
+        public bool DisplayDeletedAccountToggle { get; set; }
+
         /// <summary>
         /// Whether to display the PRIV delegation feature
         /// </summary>

backend/src/Altinn.AccessManagement.UI/Altinn.AccessManagement.UI.Core/Extensions/HttpClientExtension.cs

@@ -49,6 +49,28 @@ public static Task<HttpResponseMessage> PutAsync(this HttpClient httpClient, str
             return httpClient.SendAsync(request, CancellationToken.None);
         }
 
+        /// <summary>
+        /// Extension that add authorization header to request.
+        /// </summary>
+        /// <param name="httpClient">The HttpClient.</param>
+        /// <param name="authorizationToken">the authorization token (jwt).</param>
+        /// <param name="requestUri">The request Uri.</param>
+        /// <param name="content">The http content.</param>
+        /// <param name="platformAccessToken">The platformAccess tokens.</param>
+        /// <returns>A HttpResponseMessage.</returns>
+        public static Task<HttpResponseMessage> PatchAsync(this HttpClient httpClient, string authorizationToken, string requestUri, HttpContent content, string platformAccessToken = null)
+        {
+            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Patch, requestUri);
+            request.Headers.Add("Authorization", "Bearer " + authorizationToken);
+            request.Content = content;
+            if (!string.IsNullOrEmpty(platformAccessToken))
+            {
+                request.Headers.Add("PlatformAccessToken", platformAccessToken);
+            }
+
+            return httpClient.SendAsync(request, CancellationToken.None);
+        }
+
         /// <summary>
         /// Extension that add authorization header to request.
         /// </summary>

backend/src/Altinn.AccessManagement.UI/Altinn.AccessManagement.UI.Core/Models/Profile/ProfileSettingPreference.cs

@@ -1,7 +1,9 @@
-namespace Altinn.AccessManagement.UI.Core.Models.Profile
+#nullable enable
+namespace Altinn.AccessManagement.UI.Core.Models.Profile
 {
     /// <summary>
-    /// Class describing a users profile setting preferences.
+    /// Class describing a users profile setting preferences. This is lifted from the Profile API, but modified to have nullable properties
+    /// to allow for partial updates.
     /// </summary>
     public class ProfileSettingPreference
     {
@@ -12,7 +14,7 @@ public class ProfileSettingPreference
             "Design",
             "S2376:Write-only properties should not be used",
             Justification = "Write-only alias used to support incoming JSON 'languageType' while avoiding duplicate serialization output. Value is stored in Language.")]
-        public string LanguageType
+        public string? LanguageType
         {
             set
             {
@@ -23,21 +25,21 @@ public string LanguageType
         /// <summary>
         /// Gets or sets the user's language preference in Altinn.
         /// </summary>
-        public string Language { get; set; }
+        public string? Language { get; set; }
 
         /// <summary>
         /// Gets or sets the user's preselected party.
         /// </summary>
         /// <remarks>
         /// This is being phased out in favor of PreselectedPartyUuid.
         /// </remarks>
-        public int PreSelectedPartyId { get; set; }
+        public int? PreSelectedPartyId { get; set; }
 
         /// <summary>
         /// Gets or sets a value indicating whether the users want
         /// to be asked for the party on every form submission.
         /// </summary>
-        public bool DoNotPromptForParty { get; set; }
+        public bool? DoNotPromptForParty { get; set; }
 
         /// <summary>
         /// The UUID of the preselected party. Optional.
@@ -47,7 +49,7 @@ public string LanguageType
         /// <summary>
         /// Indicates whether client units should be shown.
         /// </summary>
-        public bool ShowClientUnits { get; set; }
+        public bool? ShowClientUnits { get; set; }
 
         /// <summary>
         /// Indicates whether sub-entities should be shown.
@@ -57,6 +59,8 @@ public string LanguageType
         /// <summary>
         /// Indicates whether deleted entities should be shown.
         /// </summary>
-        public bool ShouldShowDeletedEntities { get; set; }
+        public bool? ShouldShowDeletedEntities { get; set; }
     }
 }
+
+#nullable restore

backend/src/Altinn.AccessManagement.UI/Altinn.AccessManagement.UI.Core/Services/Interfaces/IUserService.cs

@@ -1,5 +1,6 @@
 using Altinn.AccessManagement.UI.Core.Models;
 using Altinn.AccessManagement.UI.Core.Models.AccessManagement;
+using Altinn.AccessManagement.UI.Core.Models.Profile;
 using Altinn.AccessManagement.UI.Core.Models.User;
 
 namespace Altinn.AccessManagement.UI.Core.Services.Interfaces
@@ -16,6 +17,13 @@ public interface IUserService
         /// <returns>users preferred settings</returns>
         Task<UserProfileFE> GetUserProfile(int userId);
 
+        /// <summary>
+        /// Updates the current user's profile settings in altinn profile
+        /// </summary>
+        /// <param name="shouldShowDeletedEntities">The new value of the field in the profile settings</param>
+        /// <returns>users new profile preferences</returns>
+        Task<ProfileSettingPreference> SetShowDeletedProfileSetting(bool shouldShowDeletedEntities);
+
         /// <summary>
         /// Get the reportees for the user 
         /// </summary>

backend/src/Altinn.AccessManagement.UI/Altinn.AccessManagement.UI.Core/Services/UserService.cs

@@ -48,6 +48,16 @@ public async Task<UserProfileFE> GetUserProfile(int userId)
             return userProfile == null ? null : new UserProfileFE(userProfile);
         }
 
+        /// <inheritdoc/>
+        public async Task<ProfileSettingPreference> SetShowDeletedProfileSetting(bool shouldShowDeletedEntities)
+        {
+            ProfileSettingPreference change = new ProfileSettingPreference
+            {
+                ShouldShowDeletedEntities = shouldShowDeletedEntities
+            };
+            return await _profileClient.PatchCurrentUserProfileSetting(change); 
+        }
+
         /// <inheritdoc/>        
         public async Task<AuthorizedParty> GetPartyFromReporteeListIfExists(int partyId)
         {

backend/src/Altinn.AccessManagement.UI/Altinn.AccessManagement.UI.Integration/Clients/ProfileClient.cs

@@ -1,4 +1,5 @@
-using System.Text;
+using System;
+using System.Text;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using Altinn.AccessManagement.UI.Core.ClientInterfaces;
@@ -86,6 +87,30 @@ public async Task<UserProfile> GetUserProfile(Guid uuid)
             return userProfile;
         }
 
+        /// <inheritdoc/>
+        public async Task<ProfileSettingPreference> PatchCurrentUserProfileSetting(ProfileSettingPreference settingsChange)
+        {
+            try
+            {
+                string endpointUrl = $"users/current/profilesettings";
+                string token = AltinnCore.Authentication.Utils.JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _platformSettings.JwtCookieName);
+                var accessToken = await _accessTokenProvider.GetAccessToken();
+
+                StringContent requestBody = new StringContent(JsonSerializer.Serialize(settingsChange, _serializerOptions), Encoding.UTF8, "application/json");
+
+                HttpResponseMessage response = await _client.PatchAsync(token, endpointUrl, requestBody, accessToken);
+
+                var resString = await response.Content.ReadAsStringAsync();
+                ProfileSettingPreference newSetting = await ClientUtils.DeserializeIfSuccessfullStatusCode<ProfileSettingPreference>(response);
+                return newSetting;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "AccessManagement.UI // ProfileClient // PatchCurrentUserProfileSetting // Exception");
+                throw;
+            }
+        }
+
         /// <inheritdoc/>
         public async Task<List<NotificationAddressResponse>> GetOrgNotificationAddresses(string orgNumber)
         {

backend/src/Altinn.AccessManagement.UI/Altinn.AccessManagement.UI.Mocks/Mocks/ProfileClientMock.cs

@@ -62,6 +62,68 @@ public Task<UserProfile> GetUserProfile(Guid uuid)
             return Task.FromResult<UserProfile>(null);
         }
 
+        /// <inheritdoc />
+        public async Task<ProfileSettingPreference> PatchCurrentUserProfileSetting(ProfileSettingPreference settingsChange)
+        {
+            // Check authentication context for special test scenarios
+            var httpContext = _httpContextAccessor?.HttpContext;
+            if (httpContext?.User?.Identity?.IsAuthenticated == true)
+            {
+                var userId = AuthenticationHelper.GetUserId(_httpContextAccessor.HttpContext);
+                // Special test scenario for 500 - internal server error
+                if (userId == 500)
+                {
+                    throw new HttpRequestException("Internal server error");
+                }
+            }
+
+            // static userId for testing
+            var userUuid = new Guid("167536b5-f8ed-4c5a-8f48-0279507e53ae");
+
+            string path = GetDataPathForProfiles();
+            if (File.Exists(path))
+            {
+                string content = File.ReadAllText(path);
+                List<UserProfile> allProfiles = (List<UserProfile>)JsonSerializer.Deserialize(content, typeof(List<UserProfile>), new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
+
+                var userProfile = allProfiles.FirstOrDefault(p => p.UserUuid == userUuid);
+                if (userProfile?.ProfileSettingPreference != null)
+                {
+                    // Create a copy of the existing ProfileSettingPreference
+                    var result = new ProfileSettingPreference
+                    {
+                        Language = userProfile.ProfileSettingPreference.Language,
+                        PreSelectedPartyId = userProfile.ProfileSettingPreference.PreSelectedPartyId,
+                        DoNotPromptForParty = userProfile.ProfileSettingPreference.DoNotPromptForParty,
+                        PreselectedPartyUuid = userProfile.ProfileSettingPreference.PreselectedPartyUuid,
+                        ShowClientUnits = userProfile.ProfileSettingPreference.ShowClientUnits,
+                        ShouldShowSubEntities = userProfile.ProfileSettingPreference.ShouldShowSubEntities,
+                        ShouldShowDeletedEntities = userProfile.ProfileSettingPreference.ShouldShowDeletedEntities
+                    };
+
+                    // Apply changes (overwrite existing values)
+                    if (settingsChange.Language != null)
+                        result.Language = settingsChange.Language;
+                    if (settingsChange.PreSelectedPartyId.HasValue)
+                        result.PreSelectedPartyId = settingsChange.PreSelectedPartyId;
+                    if (settingsChange.DoNotPromptForParty.HasValue)
+                        result.DoNotPromptForParty = settingsChange.DoNotPromptForParty;
+                    if (settingsChange.PreselectedPartyUuid.HasValue)
+                        result.PreselectedPartyUuid = settingsChange.PreselectedPartyUuid;
+                    if (settingsChange.ShowClientUnits.HasValue)
+                        result.ShowClientUnits = settingsChange.ShowClientUnits;
+                    result.ShouldShowSubEntities = settingsChange.ShouldShowSubEntities; // ShouldShowSubEntities is not nullable, so always apply
+                    if (settingsChange.ShouldShowDeletedEntities.HasValue)
+                        result.ShouldShowDeletedEntities = settingsChange.ShouldShowDeletedEntities;
+
+                    return await Task.FromResult(result);
+                }
+            }
+
+            // Return the settingsChange as-is if no existing profile found
+            return await Task.FromResult(settingsChange);
+        }
+
         /// <inheritdoc/>
         public async Task<List<NotificationAddressResponse>> GetOrgNotificationAddresses(string orgNumber)
         {

backend/src/Altinn.AccessManagement.UI/Altinn.AccessManagement.UI.Tests/Controllers/UserControllerTest.cs

@@ -876,5 +876,109 @@ public void IsHovedadmin_NoHasRequestedPermissionItem_ReturnsFalse()
             var ok = Assert.IsType<OkObjectResult>(result.Result);
             Assert.False((bool)ok.Value);
         }
+
+        /// <summary>
+        /// Test case: UpdateShouldShowDeletedPreference successfully updates preference to true
+        /// Expected: Returns OK with updated ProfileSettingPreference
+        /// </summary>
+        [Fact]
+        public async Task UpdateShouldShowDeletedPreference_SetToTrue_ReturnsUpdatedPreference()
+        {
+            // Arrange
+            const int userId = 20004938;
+            var token = PrincipalUtil.GetToken(userId, 1234, 2);
+            _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
+            bool shouldShowDeleted = true;
+
+            // Act
+            var response = await _client.PutAsJsonAsync("accessmanagement/api/v1/user/profile/settingspreferences/showdeleted", shouldShowDeleted);
+            var actualResponse = await response.Content.ReadFromJsonAsync<ProfileSettingPreference>();
+
+            // Assert
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.NotNull(actualResponse);
+            Assert.True(actualResponse.ShouldShowDeletedEntities);
+        }
+
+        /// <summary>
+        /// Test case: UpdateShouldShowDeletedPreference successfully updates preference to false
+        /// Expected: Returns OK with updated ProfileSettingPreference
+        /// </summary>
+        [Fact]
+        public async Task UpdateShouldShowDeletedPreference_SetToFalse_ReturnsUpdatedPreference()
+        {
+            // Arrange
+            const int userId = 20004938;
+            var token = PrincipalUtil.GetToken(userId, 1234, 2);
+            _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
+            bool shouldShowDeleted = false;
+
+            // Act
+            var response = await _client.PutAsJsonAsync("accessmanagement/api/v1/user/profile/settingspreferences/showdeleted", shouldShowDeleted);
+            var actualResponse = await response.Content.ReadFromJsonAsync<ProfileSettingPreference>();
+
+            // Assert
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.NotNull(actualResponse);
+            Assert.False(actualResponse.ShouldShowDeletedEntities);
+        }
+
+        /// <summary>
+        /// Test case: UpdateShouldShowDeletedPreference returns BadRequest when model state is invalid
+        /// Expected: Returns BadRequest
+        /// </summary>
+        [Fact]
+        public async Task UpdateShouldShowDeletedPreference_InvalidModelState_ReturnsBadRequest()
+        {
+            // Arrange
+            const int userId = 20004938;
+            var token = PrincipalUtil.GetToken(userId, 1234, 2);
+            _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
+
+            // Act - Send invalid JSON to trigger model state error
+            var content = new StringContent("invalid-json", System.Text.Encoding.UTF8, "application/json");
+            var response = await _client.PutAsync("accessmanagement/api/v1/user/profile/settingspreferences/showdeleted", content);
+
+            // Assert
+            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        }
+
+        /// <summary>
+        /// Test case: UpdateShouldShowDeletedPreference returns InternalServerError when service throws exception
+        /// Expected: Returns 500 Internal Server Error
+        /// </summary>
+        [Fact]
+        public async Task UpdateShouldShowDeletedPreference_ServiceThrowsException_Returns500()
+        {
+            // Arrange
+            const int userId = 500;
+            var token = PrincipalUtil.GetToken(userId, 1234, 2);
+            _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
+            bool shouldShowDeleted = true;
+
+            // Act
+            var response = await _client.PutAsJsonAsync("accessmanagement/api/v1/user/profile/settingspreferences/showdeleted", shouldShowDeleted);
+
+            // Assert
+            Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
+        }
+
+        /// <summary>
+        /// Test case: UpdateShouldShowDeletedPreference requires authentication
+        /// Expected: Returns Unauthorized when no token is provided
+        /// </summary>
+        [Fact]
+        public async Task UpdateShouldShowDeletedPreference_NoAuthentication_ReturnsUnauthorized()
+        {
+            // Arrange
+            _client.DefaultRequestHeaders.Authorization = null;
+            bool shouldShowDeleted = true;
+
+            // Act
+            var response = await _client.PutAsJsonAsync("accessmanagement/api/v1/user/profile/settingspreferences/showdeleted", shouldShowDeleted);
+
+            // Assert
+            Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
+        }
     }
 }