[PM-22450] Bump Collection.RevisionDate on edits and access changes (#7380)

* Fix UpdateCollectionCommand to set RevisionDate using TimeProvider and update corresponding tests. Adjust tests to verify correct RevisionDate assignment during collection updates.

* Enhance BulkAddCollectionAccessCommand to include revision date in access updates. Update ICollectionRepository and its implementations to accept revision date parameter. Modify stored procedure to update collection revision dates accordingly. Add tests to verify correct behavior of access creation and revision date updates.

* Update GroupRepository and stored procedures to bump RevisionDate for affected collections during group creation and updates. Enhance integration tests to verify that collection revision dates are correctly updated when groups are created or modified.

* Implement revision date updates for affected collections in OrganizationUserRepository and related stored procedures. Add integration tests to ensure revision dates are correctly bumped during organization user creation and updates.

* Update database migration script

* Update migration script summary

* Refactor OrganizationUserReplaceTests to create collection first

* Refactor stored procedures to use Common Table Expressions (CTEs) for updating RevisionDate of affected collections. This change improves readability and maintainability by consolidating the logic for identifying affected collections in Group_UpdateWithCollections and OrganizationUser_UpdateWithCollections procedures.

* Enhance OrganizationUser_CreateManyWithCollectionsAndGroups stored procedure to accept RevisionDate parameter for updating affected collections. Update OrganizationUserRepository to utilize the provided RevisionDate when available, ensuring accurate revision date management during organization user operations.

* Refactor OrganizationUser_CreateManyWithCollectionsGroups and migration script to utilize temporary table for CollectionUser data insertion. This change improves performance and maintains consistency in updating RevisionDate for affected collections.

* Refactor OrganizationUserRepository to consistently use RevisionDate from created OrganizationUsers when updating affected collections. This change enhances the accuracy of revision date management across the repository.

* Refactor tests to ensure consistent handling of RevisionDate across Group and Collection repositories. Update assertions to compare RevisionDate directly, improving accuracy in revision date management during tests.

* Restore BOM in Group_UpdateWithCollections and OrganizationUser_UpdateWithCollections

* Refactor GroupRepository and OrganizationUserRepository to improve handling of RevisionDate. Updated collection filtering logic to use HashSet for efficiency and ensured that affected collections are filtered by OrganizationId, enhancing accuracy in revision date management.

* Bump migration script date

* Remove internal set from RevisionDate on Group and OrganizationUser

The Dapper repositories use a System.Text.Json serialize/deserialize
round-trip to build *WithCollections objects. System.Text.Json silently
skips properties with non-public setters, so RevisionDate was reverting
to DateTime.UtcNow instead of preserving the value set in C#.

* Refactor OrganizationUser_CreateManyWithCollectionsGroups and migration script to improve the logic for updating RevisionDate. The update now uses INNER JOINs to ensure accurate filtering of collections based on OrganizationId and CollectionUser data, enhancing the precision of revision date management.

* Fix sprocs styling

* Added early return to OrganizationUserRepository.CreateManyAsync if the supplied parameter is empty

Author: r-tome

src/Core/AdminConsole/Entities/Group.cs

@@ -16,7 +16,7 @@ public class Group : ITableObject<Guid>, IExternal
     [MaxLength(300)]
     public string? ExternalId { get; set; }
     public DateTime CreationDate { get; internal set; } = DateTime.UtcNow;
-    public DateTime RevisionDate { get; internal set; } = DateTime.UtcNow;
+    public DateTime RevisionDate { get; set; } = DateTime.UtcNow;
 
     public void SetNewId()
     {

src/Core/AdminConsole/Entities/OrganizationUser.cs

@@ -65,7 +65,7 @@ public class OrganizationUser : ITableObject<Guid>, IExternal, IOrganizationUser
     /// <summary>
     /// The last date the OrganizationUser entry was updated.
     /// </summary>
-    public DateTime RevisionDate { get; internal set; } = DateTime.UtcNow;
+    public DateTime RevisionDate { get; set; } = DateTime.UtcNow;
     /// <summary>
     /// A json blob representing the <see cref="Bit.Core.Models.Data.Permissions"/> of the OrganizationUser if they
     /// are a Custom user role (i.e. the <see cref="OrganizationUserType"/> is Custom). MAY be NULL if they are not

src/Core/OrganizationFeatures/OrganizationCollections/BulkAddCollectionAccessCommand.cs

@@ -15,17 +15,20 @@ public class BulkAddCollectionAccessCommand : IBulkAddCollectionAccessCommand
     private readonly IOrganizationUserRepository _organizationUserRepository;
     private readonly IGroupRepository _groupRepository;
     private readonly IEventService _eventService;
+    private readonly TimeProvider _timeProvider;
 
     public BulkAddCollectionAccessCommand(
         ICollectionRepository collectionRepository,
         IOrganizationUserRepository organizationUserRepository,
         IGroupRepository groupRepository,
-        IEventService eventService)
+        IEventService eventService,
+        TimeProvider timeProvider)
     {
         _collectionRepository = collectionRepository;
         _organizationUserRepository = organizationUserRepository;
         _groupRepository = groupRepository;
         _eventService = eventService;
+        _timeProvider = timeProvider;
     }
 
     public async Task AddAccessAsync(ICollection<Collection> collections,
@@ -34,15 +37,18 @@ public async Task AddAccessAsync(ICollection<Collection> collections,
     {
         await ValidateRequestAsync(collections, users, groups);
 
+        var revisionDate = _timeProvider.GetUtcNow().UtcDateTime;
+
         await _collectionRepository.CreateOrUpdateAccessForManyAsync(
             collections.First().OrganizationId,
             collections.Select(c => c.Id),
             users,
-            groups
+            groups,
+            revisionDate
         );
 
         await _eventService.LogCollectionEventsAsync(collections.Select(c =>
-            (c, EventType.Collection_Updated, (DateTime?)DateTime.UtcNow)));
+            (c, EventType.Collection_Updated, (DateTime?)revisionDate)));
     }
 
     private async Task ValidateRequestAsync(ICollection<Collection> collections, ICollection<CollectionAccessSelection> usersAccess, ICollection<CollectionAccessSelection> groupsAccess)

src/Core/OrganizationFeatures/OrganizationCollections/UpdateCollectionCommand.cs

@@ -16,15 +16,18 @@ public class UpdateCollectionCommand : IUpdateCollectionCommand
     private readonly IEventService _eventService;
     private readonly IOrganizationRepository _organizationRepository;
     private readonly ICollectionRepository _collectionRepository;
+    private readonly TimeProvider _timeProvider;
 
     public UpdateCollectionCommand(
         IEventService eventService,
         IOrganizationRepository organizationRepository,
-        ICollectionRepository collectionRepository)
+        ICollectionRepository collectionRepository,
+        TimeProvider timeProvider)
     {
         _eventService = eventService;
         _organizationRepository = organizationRepository;
         _collectionRepository = collectionRepository;
+        _timeProvider = timeProvider;
     }
 
     public async Task<Collection> UpdateAsync(Collection collection, IEnumerable<CollectionAccessSelection> groups = null,
@@ -75,6 +78,7 @@ public async Task<Collection> UpdateAsync(Collection collection, IEnumerable<Col
             }
         }
 
+        collection.RevisionDate = _timeProvider.GetUtcNow().UtcDateTime;
         await _collectionRepository.ReplaceAsync(collection, org.UseGroups ? groupsList : null, usersList);
         await _eventService.LogCollectionEventAsync(collection, Enums.EventType.Collection_Updated);
 

src/Core/Repositories/ICollectionRepository.cs

@@ -60,8 +60,18 @@ public interface ICollectionRepository : IRepository<Collection, Guid>
     Task UpdateUsersAsync(Guid id, IEnumerable<CollectionAccessSelection> users);
     Task<ICollection<CollectionAccessSelection>> GetManyUsersByIdAsync(Guid id);
     Task DeleteManyAsync(IEnumerable<Guid> collectionIds);
+
+    /// <summary>
+    /// Creates or updates the access for many collections.
+    /// </summary>
+    /// <param name="organizationId">The Organization ID.</param>
+    /// <param name="collectionIds">The Collection IDs to create or update access for.</param>
+    /// <param name="users">The users to grant access to.</param>
+    /// <param name="groups">The groups to grant access to.</param>
+    /// <param name="revisionDate">The revision date to use for the collections.</param>
     Task CreateOrUpdateAccessForManyAsync(Guid organizationId, IEnumerable<Guid> collectionIds,
-        IEnumerable<CollectionAccessSelection> users, IEnumerable<CollectionAccessSelection> groups);
+        IEnumerable<CollectionAccessSelection> users, IEnumerable<CollectionAccessSelection> groups,
+        DateTime revisionDate);
 
     /// <summary>
     /// Creates default user collections for the specified organization users.

src/Infrastructure.Dapper/AdminConsole/Repositories/OrganizationUserRepository.cs

@@ -652,6 +652,10 @@ public async Task CreateManyAsync(IEnumerable<CreateOrganizationUser> organizati
         await using var connection = new SqlConnection(_marsConnectionString);
 
         var organizationUsersList = organizationUserCollection.ToList();
+        if (organizationUsersList.Count == 0)
+        {
+            return;
+        }
 
         await connection.ExecuteAsync(
             $"[{Schema}].[OrganizationUser_CreateManyWithCollectionsAndGroups]",
@@ -672,7 +676,9 @@ await connection.ExecuteAsync(
                     {
                         GroupId = group,
                         OrganizationUserId = user.OrganizationUser.Id
-                    }))
+                    })),
+                // Use the same RevisionDate as the created OrganizationUsers
+                RevisionDate = organizationUsersList.First().OrganizationUser.RevisionDate
             },
             commandType: CommandType.StoredProcedure);
     }

src/Infrastructure.Dapper/Repositories/CollectionRepository.cs

@@ -301,7 +301,8 @@ await connection.ExecuteAsync("[dbo].[Collection_DeleteByIds]",
     }
 
     public async Task CreateOrUpdateAccessForManyAsync(Guid organizationId, IEnumerable<Guid> collectionIds,
-        IEnumerable<CollectionAccessSelection> users, IEnumerable<CollectionAccessSelection> groups)
+        IEnumerable<CollectionAccessSelection> users, IEnumerable<CollectionAccessSelection> groups,
+        DateTime revisionDate)
     {
         using (var connection = new SqlConnection(ConnectionString))
         {
@@ -310,7 +311,14 @@ public async Task CreateOrUpdateAccessForManyAsync(Guid organizationId, IEnumera
 
             var results = await connection.ExecuteAsync(
                 $"[{Schema}].[Collection_CreateOrUpdateAccessForMany]",
-                new { OrganizationId = organizationId, CollectionIds = collectionIds.ToGuidIdArrayTVP(), Users = usersArray, Groups = groupsArray },
+                new
+                {
+                    OrganizationId = organizationId,
+                    CollectionIds = collectionIds.ToGuidIdArrayTVP(),
+                    Users = usersArray,
+                    Groups = groupsArray,
+                    RevisionDate = revisionDate
+                },
                 commandType: CommandType.StoredProcedure);
         }
     }

src/Infrastructure.EntityFramework/AdminConsole/Repositories/GroupRepository.cs

@@ -38,6 +38,12 @@ from c in dbContext.Collections
                 Manage = y.Manage,
             });
             await dbContext.CollectionGroups.AddRangeAsync(collectionGroups);
+            // Bump RevisionDate on all affected collections
+            var filteredCollectionIds = filteredCollections.Select(fc => fc.Id).ToHashSet();
+            foreach (var c in availableCollections.Where(a => filteredCollectionIds.Contains(a.Id)))
+            {
+                c.RevisionDate = grp.RevisionDate;
+            }
             await dbContext.SaveChangesAsync();
         }
     }
@@ -227,6 +233,20 @@ public async Task ReplaceAsync(AdminConsoleEntities.Group group, IEnumerable<Col
             dbContext.CollectionGroups.RemoveRange(
                 existingCollectionGroups.Where(cg => !requestedCollectionIds.Contains(cg.CollectionId)));
 
+            // Bump the revision date on all affected collections
+            var allAffectedCollectionIds = existingCollectionGroups.Select(cg => cg.CollectionId)
+                .Union(requestedCollections.Select(rc => rc.Id))
+                .Distinct()
+                .ToList();
+            var affectedCollections = await dbContext.Collections
+                .Where(c => c.OrganizationId == group.OrganizationId
+                    && allAffectedCollectionIds.Contains(c.Id))
+                .ToListAsync();
+            foreach (var c in affectedCollections)
+            {
+                c.RevisionDate = group.RevisionDate;
+            }
+
             await dbContext.UserBumpAccountRevisionDateByOrganizationIdAsync(group.OrganizationId);
             await dbContext.SaveChangesAsync();
         }

src/Infrastructure.EntityFramework/AdminConsole/Repositories/OrganizationUserRepository.cs

@@ -46,6 +46,12 @@ from c in dbContext.Collections
                 Manage = y.Manage
             });
             await dbContext.CollectionUsers.AddRangeAsync(collectionUsers);
+            // Bump RevisionDate on all affected collections
+            var filteredCollectionIds = filteredCollections.Select(fc => fc.Id).ToHashSet();
+            foreach (var c in availableCollections.Where(a => filteredCollectionIds.Contains(a.Id)))
+            {
+                c.RevisionDate = organizationUser.RevisionDate;
+            }
             await dbContext.SaveChangesAsync();
         }
 
@@ -651,6 +657,21 @@ join c in dbContext.Collections on cu.CollectionId equals c.Id
             // Remove all existing ones that are no longer requested
             var requestedCollectionIds = requestedCollections.Select(c => c.Id).ToList();
             dbContext.CollectionUsers.RemoveRange(existingCollectionUsers.Where(cu => !requestedCollectionIds.Contains(cu.CollectionId)));
+
+            // Bump the revision date on all affected collections
+            var allAffectedCollectionIds = existingCollectionUsers.Select(cu => cu.CollectionId)
+                .Union(requestedCollections.Select(rc => rc.Id))
+                .Distinct()
+                .ToList();
+            var affectedCollections = await dbContext.Collections
+                .Where(c => c.OrganizationId == obj.OrganizationId
+                    && allAffectedCollectionIds.Contains(c.Id))
+                .ToListAsync();
+            foreach (var c in affectedCollections)
+            {
+                c.RevisionDate = obj.RevisionDate;
+            }
+
             await dbContext.SaveChangesAsync();
         }
     }
@@ -923,6 +944,11 @@ on ou.UserId equals u.Id
 
     public async Task CreateManyAsync(IEnumerable<CreateOrganizationUser> organizationUserCollection)
     {
+        if (!organizationUserCollection.Any())
+        {
+            return;
+        }
+
         using var scope = ServiceScopeFactory.CreateScope();
 
         await using var dbContext = GetDatabaseContext(scope);
@@ -942,6 +968,27 @@ public async Task CreateManyAsync(IEnumerable<CreateOrganizationUser> organizati
             OrganizationUserId = user.OrganizationUser.Id
         }));
 
+        // Bump RevisionDate on all affected collections
+        var affectedCollectionIds = organizationUserCollection
+            .SelectMany(x => x.Collections)
+            .Select(c => c.Id)
+            .Distinct()
+            .ToList();
+        if (affectedCollectionIds.Count > 0)
+        {
+            var organizationId = organizationUserCollection.First().OrganizationUser.OrganizationId;
+            var affectedCollections = await dbContext.Collections
+                .Where(c => c.OrganizationId == organizationId
+                    && affectedCollectionIds.Contains(c.Id))
+                .ToListAsync();
+            // Use the same RevisionDate as the created OrganizationUsers
+            var revisionDate = organizationUserCollection.First().OrganizationUser.RevisionDate;
+            foreach (var c in affectedCollections)
+            {
+                c.RevisionDate = revisionDate;
+            }
+        }
+
         await dbContext.SaveChangesAsync();
     }
 

src/Infrastructure.EntityFramework/Repositories/CollectionRepository.cs

@@ -630,7 +630,8 @@ public async Task DeleteManyAsync(IEnumerable<Guid> collectionIds)
     }
 
     public async Task CreateOrUpdateAccessForManyAsync(Guid organizationId, IEnumerable<Guid> collectionIds,
-        IEnumerable<CollectionAccessSelection> users, IEnumerable<CollectionAccessSelection> groups)
+        IEnumerable<CollectionAccessSelection> users, IEnumerable<CollectionAccessSelection> groups,
+        DateTime revisionDate)
     {
         using (var scope = ServiceScopeFactory.CreateScope())
         {
@@ -715,6 +716,16 @@ public async Task CreateOrUpdateAccessForManyAsync(Guid organizationId, IEnumera
             }
             // Need to save the new collection users/groups before running the bump revision code
             await dbContext.SaveChangesAsync();
+
+            // Bump the revision date on all affected collections
+            var collections = await dbContext.Collections
+                .Where(c => collectionIdsList.Contains(c.Id))
+                .ToListAsync();
+            foreach (var c in collections)
+            {
+                c.RevisionDate = revisionDate;
+            }
+
             await dbContext.UserBumpAccountRevisionDateByCollectionIdsAsync(collectionIdsList, organizationId);
             await dbContext.SaveChangesAsync();
         }