[EC-647] OAVR v2 Feature Branch Merge (#2588)

* [EC-19] Move SSO Identifier to Org SSO endpoint (#2184)

* [EC-19] Move SSO identifier to Org SSO config endpoint

* [EC-19] Add Jira tech debt issue reference

* [EC-542] Update email communications (#2348)

* [EC-73] Add users alongside groups for collection details (#2358)

* [EC-73] feat: add new stored procedures

* [EC-73] feat: add migration

* [EC-73] chore: rename collection group details

* [EC-73] fix: migration

* [EC-73] feat: return users from dapper repo

* [EC-73] feat: EF support for collection users

* [EC-73] feat: implement updating users in EF

* [EC-73] feat: new collections with users in EF

* [EC-73] feat: create with users in dapper

* [EC-73] feat: update with users in dapper

* [EC-73] fix: collection service tests

* [EC-73] fix: lint

* [EC-73] feat: add new data model and rename for clarity

* [EC-73] chore: add future migrations

* [EC-16 / EC-86] Implement Groups Table Endpoints (#2280)

* [EC-16] Update Group endpoints/repositories to include necessary collection info

* [EC-16] Add delete many groups endpoint and command

* [EC-16] Add DeleteGroupCommand unit tests

* [EC-16] Update migration script

* [EC-16] Formatting

* [EC-16] Support modifying users via Post Group endpoint

- Add optional Users property to GroupRequestModel
- Add users parameter to the GroupService.SaveAsync() method
- Use the users argument to update the Group via the GroupRepository if present.

* [EC-16] Add/update Sprocs for bulk group deletion

- Add a new bump account revision date by multiple org ids sproc to be used by the delete many group sproc.
- Update the delete many group sproc to no longer require the organization Id as authorization is a business concern.

* [EC-16] No longer require org Id in delete many GroupRepository

The group repository should not care about which organization a group belongs to when being deleted. That is a business logic concern and is not necessary at the repository level.

* [EC-16] Remove org Id from delete many group command

- Remove the organization Id from the delete many method.
- Require Group entities instead of just group Ids so that group retrieval is completed outside the command.
- No longer return deleted groups as they are now being passed into the command.
- Update unit tests

* [EC-16] Remove org id from bulk delete group endpoint

- Remove the Org Id from the endpoint and make use of the updated delete many command

* [EC-16] Rename delete many groups sproc

* [EC-16] Update migration script

* [EC-16] Fix typo in migration script

* [EC-16] Fix order of operations in Group_DeleteByIds sproc

* [EC-16] Formatting

* [EC-86] Fix DeleteManyAsync parameter name

Co-authored-by: Thomas Rittson <31796059+eliykat@users.noreply.github.com>

* [EC-16] Add missing sproc to sqlproj file

* [EC-16] Improve GroupRepository method performance

Use GroupBy before marrying Groups and Collections to avoid iterating over all collections for every group)

* [EC-16] Use ToListAsync() to be consistent in the repository

* [EC-16] Fix collection grouping in the EF repository

* [EC-16] Adjust DeleteGroup command namespace to be less verbose

* [EC-16] Cleanup DeleteGroupCommandTests

* [EC-16] Formatting

* [EC-16] Ensure a non-null group collection list is provided

* [EC-16] Add bulk GroupEvents method to EventService

- Use the new method in the DeleteGroups command

* [EC-16] Remove bulk delete group Api response

The response is unnecessary and not used by the client

* [EC-16] Log OrganizationUser_UpdateGroups event in GroupService

Events are logged for users during both Group creation (all added users) and modification (only changed users).

* [EC-16] Fix failing unit test

* [EC-16] Rename newUsers variable per feedback

* [EC-16] Assert delete many group log events

Explicitly check for the event type and groups that are logged to the event service.

* [EC-16] Update DeleteManyAsync signature

Use ICollection<> instead of IEnumerable<> to avoid ambiguity of possible multiple enumeration

* [EC-16] Increment migration script name

Co-authored-by: Thomas Rittson <31796059+eliykat@users.noreply.github.com>

* Add missing GO command to EC-73 migration script (#2433)

* [EC-15] Members Grid Api Support (#2485)

* [EC-15] Update OrganizationUser models to support list of collections and groups

* [EC-15] Add sprocs to query GroupUser and CollectionUser entities

* [EC-15] Update the OrganizationUserRepository to optionally fetch groups/collections

* [EC-15] Formatting

* [EC-15] Remove leftover repository method

* [EC-15] Fix table identifier inconsistency in sproc/migration

* Formatting

* [EC-14]: Server changes for Collection rows in Vault (#2360)

* [EC-14] add collection management methods to repo
- delete many, get many by ids, and get many with groups by org

* [EC-14] connection command tests had wrong folder name

* [EC-14] add collection repo methods to interface

* [EC-14] create DeleteCollectionCommand

* [EC-14] add getManyWithDetails collections endpoint

* [EC-14] add GetManyWithGroupsByUserId

* [EC-14] add call to interface

* [EC-14] add GetOrganizationCollectionsWIthGroups
- gets groups with collections
- add tests as well

* [EC-14] add call to interface

* [EC-14] add new coll call to controller
- gets collections with groups

* [EC-14] use new delete collection command

* [EC-14] add CollectionBulkDeleteRequestModel

* [EC-14] remove org from delete collection cmd
- move all permission checks to controller
- add tests to controller
- remove org check from repository method

* [EC-14] add migration and sprocs

* [EC-14] formatting

* [EC-14] revert delete permission check changes

* [EC-14] rename SelectionReadOnly to CollectionAccessSelection

* [EC-14] move GetOrganizationCollectionsWithGroups to controller
- there's no reason to have this logic in the service layer
- we can still test the permission check in the controller
- also renamed repo methods and changed return types

* [EC-14] include users in collection access details

* [EC-14] fix migration names

* [EC-14] bumpAccountRevisionDate when deleting collections

* [EC-14] new line in collection service

* [EC-14] formatting and add .sql to proc file

* [EC-14] more formatting

* [EC-14] formatting

* [EC-14] fix whitespace

* [EC-14] add datetime to event log of single delete

* [EC-14] remove ToList() from enumerables not returned

* [EC-14] fix permissions on "Create new collection"
- a custom user with "Create new collections" should see all collections

* [EC-14] add bulk events for collections

* [EC-14] group collections from db before iterating

* [EC-14] sql formatting and missing GO

* [EC-14] fix tests

* [EC-14] add null handling to repo methods

* [EC-14] fix account revision call

* [EC-14] formatting

* [EC-548] Member Details Group Tab (#2508)

* [EC-548] Update models to support groups

* [EC-548] Include groups in invite and save organization user methods

* [EC-548] Pass groups to service methods in member/user controllers

* [EC-548] Fix failing tests

* [EC-548] Add option to include groups for GET org user query

* Formatting

* [EC-887] Server fix for managers seeing options to edit/delete Collections they aren't assigned to (#2542)

* [EC-887] Add Assigned property to CollectionResponseModel

A new property to determine if a collection is assigned to the acting user; as some users, have the view all collections permission, but cannot see every collection's items

* [EC-887] Update logic for retrieving GET all collection details

- Only need to check the ViewAllCollections permission
- Calculate new Assigned response property based on the assignedOrgCollections list

* Formatting

* [EC-887] Update unit tests

Co-authored-by: Shane Melton <smelton@bitwarden.com>
Co-authored-by: Jacob Fink <jfink@bitwarden.com>
Co-authored-by: Thomas Rittson <31796059+eliykat@users.noreply.github.com>

src/Core/Models/Business/OrganizationUserInvite.cs

@@ -9,7 +9,8 @@ public class OrganizationUserInvite
     public Enums.OrganizationUserType? Type { get; set; }
     public bool AccessAll { get; set; }
     public Permissions Permissions { get; set; }
-    public IEnumerable<SelectionReadOnly> Collections { get; set; }
+    public IEnumerable<CollectionAccessSelection> Collections { get; set; }
+    public IEnumerable<Guid> Groups { get; set; }
 
     public OrganizationUserInvite() { }
 
@@ -19,6 +20,7 @@ public class OrganizationUserInvite
         Type = requestModel.Type;
         AccessAll = requestModel.AccessAll;
         Collections = requestModel.Collections;
+        Groups = requestModel.Groups;
         Permissions = requestModel.Permissions;
     }
 }

src/Core/Models/Data/CollectionAccessDetails.cs

@@ -0,0 +1,8 @@
+namespace Bit.Core.Models.Data;
+
+public class CollectionAccessDetails
+{
+    public IEnumerable<CollectionAccessSelection> Groups { get; set; }
+    public IEnumerable<CollectionAccessSelection> Users { get; set; }
+}
+

src/Core/Models/Data/CollectionAccessSelection.cs

@@ -1,6 +1,6 @@
 namespace Bit.Core.Models.Data;
 
-public class SelectionReadOnly
+public class CollectionAccessSelection
 {
     public Guid Id { get; set; }
     public bool ReadOnly { get; set; }

src/Core/Models/Data/Organizations/OrganizationUsers/OrganizationUserInviteData.cs

@@ -7,6 +7,7 @@ public class OrganizationUserInviteData
     public IEnumerable<string> Emails { get; set; }
     public OrganizationUserType? Type { get; set; }
     public bool AccessAll { get; set; }
-    public IEnumerable<SelectionReadOnly> Collections { get; set; }
+    public IEnumerable<CollectionAccessSelection> Collections { get; set; }
+    public IEnumerable<Guid> Groups { get; set; }
     public Permissions Permissions { get; set; }
 }

src/Core/Models/Data/Organizations/OrganizationUsers/OrganizationUserUserDetails.cs

@@ -23,6 +23,9 @@ public class OrganizationUserUserDetails : IExternal, ITwoFactorProvidersUser
     public string ResetPasswordKey { get; set; }
     public bool UsesKeyConnector { get; set; }
 
+    public ICollection<Guid> Groups { get; set; } = new List<Guid>();
+    public ICollection<CollectionAccessSelection> Collections { get; set; } = new List<CollectionAccessSelection>();
+
     public Dictionary<TwoFactorProviderType, TwoFactorProvider> GetTwoFactorProviders()
     {
         if (string.IsNullOrWhiteSpace(TwoFactorProviders))

src/Core/OrganizationFeatures/Groups/CreateGroupCommand.cs

@@ -13,35 +13,52 @@ public class CreateGroupCommand : ICreateGroupCommand
 {
     private readonly IEventService _eventService;
     private readonly IGroupRepository _groupRepository;
+    private readonly IOrganizationUserRepository _organizationUserRepository;
     private readonly IReferenceEventService _referenceEventService;
 
     public CreateGroupCommand(
         IEventService eventService,
         IGroupRepository groupRepository,
+        IOrganizationUserRepository organizationUserRepository,
         IReferenceEventService referenceEventService)
     {
         _eventService = eventService;
         _groupRepository = groupRepository;
+        _organizationUserRepository = organizationUserRepository;
         _referenceEventService = referenceEventService;
     }
 
     public async Task CreateGroupAsync(Group group, Organization organization,
-        IEnumerable<SelectionReadOnly> collections = null)
+        IEnumerable<CollectionAccessSelection> collections = null,
+        IEnumerable<Guid> users = null)
     {
         Validate(organization);
         await GroupRepositoryCreateGroupAsync(group, organization, collections);
+
+        if (users != null)
+        {
+            await GroupRepositoryUpdateUsersAsync(group, users);
+        }
+
         await _eventService.LogGroupEventAsync(group, Enums.EventType.Group_Created);
     }
 
     public async Task CreateGroupAsync(Group group, Organization organization, EventSystemUser systemUser,
-        IEnumerable<SelectionReadOnly> collections = null)
+        IEnumerable<CollectionAccessSelection> collections = null,
+        IEnumerable<Guid> users = null)
     {
         Validate(organization);
         await GroupRepositoryCreateGroupAsync(group, organization, collections);
+
+        if (users != null)
+        {
+            await GroupRepositoryUpdateUsersAsync(group, users, systemUser);
+        }
+
         await _eventService.LogGroupEventAsync(group, Enums.EventType.Group_Created, systemUser);
     }
 
-    private async Task GroupRepositoryCreateGroupAsync(Group group, Organization organization, IEnumerable<SelectionReadOnly> collections = null)
+    private async Task GroupRepositoryCreateGroupAsync(Group group, Organization organization, IEnumerable<CollectionAccessSelection> collections = null)
     {
         group.CreationDate = group.RevisionDate = DateTime.UtcNow;
 
@@ -57,6 +74,28 @@ public class CreateGroupCommand : ICreateGroupCommand
         await _referenceEventService.RaiseEventAsync(new ReferenceEvent(ReferenceEventType.GroupCreated, organization));
     }
 
+    private async Task GroupRepositoryUpdateUsersAsync(Group group, IEnumerable<Guid> userIds,
+        EventSystemUser? systemUser = null)
+    {
+        var usersToAddToGroup = userIds as Guid[] ?? userIds.ToArray();
+
+        await _groupRepository.UpdateUsersAsync(group.Id, usersToAddToGroup);
+
+        var users = await _organizationUserRepository.GetManyAsync(usersToAddToGroup);
+        var eventDate = DateTime.UtcNow;
+
+        if (systemUser.HasValue)
+        {
+            await _eventService.LogOrganizationUserEventsAsync(users.Select(u =>
+                (u, EventType.OrganizationUser_UpdatedGroups, systemUser.Value, (DateTime?)eventDate)));
+        }
+        else
+        {
+            await _eventService.LogOrganizationUserEventsAsync(users.Select(u =>
+                (u, EventType.OrganizationUser_UpdatedGroups, (DateTime?)eventDate)));
+        }
+    }
+
     private static void Validate(Organization organization)
     {
         if (organization == null)

src/Core/OrganizationFeatures/Groups/DeleteGroupCommand.cs

@@ -9,25 +9,43 @@ namespace Bit.Core.OrganizationFeatures.Groups;
 
 public class DeleteGroupCommand : IDeleteGroupCommand
 {
-    private readonly IEventService _eventService;
     private readonly IGroupRepository _groupRepository;
+    private readonly IEventService _eventService;
 
-    public DeleteGroupCommand(IEventService eventService, IGroupRepository groupRepository)
+    public DeleteGroupCommand(IGroupRepository groupRepository, IEventService eventService)
     {
-        _eventService = eventService;
         _groupRepository = groupRepository;
+        _eventService = eventService;
     }
 
     public async Task DeleteGroupAsync(Guid organizationId, Guid id)
     {
         var group = await GroupRepositoryDeleteGroupAsync(organizationId, id);
-        await _eventService.LogGroupEventAsync(group, Core.Enums.EventType.Group_Deleted);
+        await _eventService.LogGroupEventAsync(group, EventType.Group_Deleted);
     }
 
     public async Task DeleteGroupAsync(Guid organizationId, Guid id, EventSystemUser eventSystemUser)
     {
         var group = await GroupRepositoryDeleteGroupAsync(organizationId, id);
-        await _eventService.LogGroupEventAsync(group, Core.Enums.EventType.Group_Deleted, eventSystemUser);
+        await _eventService.LogGroupEventAsync(group, EventType.Group_Deleted, eventSystemUser);
+    }
+
+    public async Task DeleteAsync(Group group)
+    {
+        await _groupRepository.DeleteAsync(group);
+        await _eventService.LogGroupEventAsync(group, EventType.Group_Deleted);
+    }
+
+    public async Task DeleteManyAsync(ICollection<Group> groups)
+    {
+        await _eventService.LogGroupEventsAsync(
+            groups.Select(g =>
+                (g, EventType.Group_Deleted, (EventSystemUser?)null, (DateTime?)DateTime.UtcNow)
+            ));
+
+        await _groupRepository.DeleteManyAsync(
+            groups.Select(g => g.Id)
+            );
     }
 
     private async Task<Group> GroupRepositoryDeleteGroupAsync(Guid organizationId, Guid id)

src/Core/OrganizationFeatures/Groups/Interfaces/ICreateGroupCommand.cs

@@ -7,8 +7,10 @@ namespace Bit.Core.OrganizationFeatures.Groups.Interfaces;
 public interface ICreateGroupCommand
 {
     Task CreateGroupAsync(Group group, Organization organization,
-        IEnumerable<SelectionReadOnly> collections = null);
+        IEnumerable<CollectionAccessSelection> collections = null,
+        IEnumerable<Guid> users = null);
 
     Task CreateGroupAsync(Group group, Organization organization, EventSystemUser systemUser,
-        IEnumerable<SelectionReadOnly> collections = null);
+        IEnumerable<CollectionAccessSelection> collections = null,
+        IEnumerable<Guid> users = null);
 }

src/Core/OrganizationFeatures/Groups/Interfaces/IDeleteGroupCommand.cs

@@ -1,4 +1,5 @@
-using Bit.Core.Enums;
+using Bit.Core.Entities;
+using Bit.Core.Enums;
 
 namespace Bit.Core.OrganizationFeatures.Groups.Interfaces;
 
@@ -6,4 +7,6 @@ public interface IDeleteGroupCommand
 {
     Task DeleteGroupAsync(Guid organizationId, Guid id);
     Task DeleteGroupAsync(Guid organizationId, Guid id, EventSystemUser eventSystemUser);
+    Task DeleteAsync(Group group);
+    Task DeleteManyAsync(ICollection<Group> groups);
 }

src/Core/OrganizationFeatures/Groups/Interfaces/IUpdateGroupCommand.cs

@@ -7,8 +7,10 @@ namespace Bit.Core.OrganizationFeatures.Groups.Interfaces;
 public interface IUpdateGroupCommand
 {
     Task UpdateGroupAsync(Group group, Organization organization,
-        IEnumerable<SelectionReadOnly> collections = null);
+        IEnumerable<CollectionAccessSelection> collections = null,
+        IEnumerable<Guid> users = null);
 
     Task UpdateGroupAsync(Group group, Organization organization, EventSystemUser systemUser,
-        IEnumerable<SelectionReadOnly> collections = null);
+        IEnumerable<CollectionAccessSelection> collections = null,
+        IEnumerable<Guid> users = null);
 }

src/Core/OrganizationFeatures/Groups/UpdateGroupCommand.cs

@@ -12,32 +12,49 @@ public class UpdateGroupCommand : IUpdateGroupCommand
 {
     private readonly IEventService _eventService;
     private readonly IGroupRepository _groupRepository;
+    private readonly IOrganizationUserRepository _organizationUserRepository;
 
     public UpdateGroupCommand(
         IEventService eventService,
-        IGroupRepository groupRepository)
+        IGroupRepository groupRepository,
+        IOrganizationUserRepository organizationUserRepository)
     {
         _eventService = eventService;
         _groupRepository = groupRepository;
+        _organizationUserRepository = organizationUserRepository;
     }
 
     public async Task UpdateGroupAsync(Group group, Organization organization,
-        IEnumerable<SelectionReadOnly> collections = null)
+        IEnumerable<CollectionAccessSelection> collections = null,
+        IEnumerable<Guid> userIds = null)
     {
         Validate(organization);
         await GroupRepositoryUpdateGroupAsync(group, collections);
+
+        if (userIds != null)
+        {
+            await GroupRepositoryUpdateUsersAsync(group, userIds);
+        }
+
         await _eventService.LogGroupEventAsync(group, Enums.EventType.Group_Updated);
     }
 
     public async Task UpdateGroupAsync(Group group, Organization organization, EventSystemUser systemUser,
-        IEnumerable<SelectionReadOnly> collections = null)
+        IEnumerable<CollectionAccessSelection> collections = null,
+        IEnumerable<Guid> userIds = null)
     {
         Validate(organization);
         await GroupRepositoryUpdateGroupAsync(group, collections);
+
+        if (userIds != null)
+        {
+            await GroupRepositoryUpdateUsersAsync(group, userIds, systemUser);
+        }
+
         await _eventService.LogGroupEventAsync(group, Enums.EventType.Group_Updated, systemUser);
     }
 
-    private async Task GroupRepositoryUpdateGroupAsync(Group group, IEnumerable<SelectionReadOnly> collections = null)
+    private async Task GroupRepositoryUpdateGroupAsync(Group group, IEnumerable<CollectionAccessSelection> collections = null)
     {
         group.RevisionDate = DateTime.UtcNow;
 
@@ -51,6 +68,34 @@ public class UpdateGroupCommand : IUpdateGroupCommand
         }
     }
 
+    private async Task GroupRepositoryUpdateUsersAsync(Group group, IEnumerable<Guid> userIds, EventSystemUser? systemUser = null)
+    {
+        var newUserIds = userIds as Guid[] ?? userIds.ToArray();
+        var originalUserIds = await _groupRepository.GetManyUserIdsByIdAsync(group.Id);
+
+        await _groupRepository.UpdateUsersAsync(group.Id, newUserIds);
+
+        // We only want to create events OrganizationUserEvents for those that were actually modified.
+        // HashSet.SymmetricExceptWith is a convenient method of finding the difference between lists
+        var changedUserIds = new HashSet<Guid>(originalUserIds);
+        changedUserIds.SymmetricExceptWith(newUserIds);
+
+        // Fetch all changed users for logging the event
+        var users = await _organizationUserRepository.GetManyAsync(changedUserIds);
+        var eventDate = DateTime.UtcNow;
+
+        if (systemUser.HasValue)
+        {
+            await _eventService.LogOrganizationUserEventsAsync(users.Select(u =>
+                (u, EventType.OrganizationUser_UpdatedGroups, systemUser.Value, (DateTime?)eventDate)));
+        }
+        else
+        {
+            await _eventService.LogOrganizationUserEventsAsync(users.Select(u =>
+                (u, EventType.OrganizationUser_UpdatedGroups, (DateTime?)eventDate)));
+        }
+    }
+
     private static void Validate(Organization organization)
     {
         if (organization == null)

src/Core/OrganizationFeatures/OrganizationCollections/DeleteCollectionCommand.cs

@@ -0,0 +1,39 @@
+using Bit.Core.Entities;
+using Bit.Core.OrganizationFeatures.OrganizationCollections.Interfaces;
+using Bit.Core.Repositories;
+using Bit.Core.Services;
+
+namespace Bit.Core.OrganizationFeatures.OrganizationCollections;
+
+public class DeleteCollectionCommand : IDeleteCollectionCommand
+{
+    private readonly ICollectionRepository _collectionRepository;
+    private readonly IEventService _eventService;
+
+    public DeleteCollectionCommand(
+        ICollectionRepository collectionRepository,
+        IEventService eventService)
+    {
+        _collectionRepository = collectionRepository;
+        _eventService = eventService;
+    }
+
+    public async Task DeleteAsync(Collection collection)
+    {
+        await _collectionRepository.DeleteAsync(collection);
+        await _eventService.LogCollectionEventAsync(collection, Enums.EventType.Collection_Deleted, DateTime.UtcNow);
+    }
+
+    public async Task DeleteManyAsync(IEnumerable<Guid> collectionIds)
+    {
+        var ids = collectionIds as Guid[] ?? collectionIds.ToArray();
+        var collectionsToDelete = await _collectionRepository.GetManyByManyIdsAsync(ids);
+        await this.DeleteManyAsync(collectionsToDelete);
+    }
+
+    public async Task DeleteManyAsync(IEnumerable<Collection> collections)
+    {
+        await _collectionRepository.DeleteManyAsync(collections.Select(c => c.Id));
+        await _eventService.LogCollectionEventsAsync(collections.Select(c => (c, Enums.EventType.Collection_Deleted, (DateTime?)DateTime.UtcNow)));
+    }
+}

src/Core/OrganizationFeatures/OrganizationCollections/Interfaces/IDeleteCollectionCommand.cs

@@ -0,0 +1,10 @@
+using Bit.Core.Entities;
+
+namespace Bit.Core.OrganizationFeatures.OrganizationCollections.Interfaces;
+
+public interface IDeleteCollectionCommand
+{
+    Task DeleteAsync(Collection collection);
+    Task DeleteManyAsync(IEnumerable<Guid> collectionIds);
+    Task DeleteManyAsync(IEnumerable<Collection> collections);
+}

src/Core/OrganizationFeatures/OrganizationServiceCollectionExtensions.cs

@@ -3,6 +3,8 @@ using Bit.Core.OrganizationFeatures.Groups;
 using Bit.Core.OrganizationFeatures.Groups.Interfaces;
 using Bit.Core.OrganizationFeatures.OrganizationApiKeys;
 using Bit.Core.OrganizationFeatures.OrganizationApiKeys.Interfaces;
+using Bit.Core.OrganizationFeatures.OrganizationCollections;
+using Bit.Core.OrganizationFeatures.OrganizationCollections.Interfaces;
 using Bit.Core.OrganizationFeatures.OrganizationConnections;
 using Bit.Core.OrganizationFeatures.OrganizationConnections.Interfaces;
 using Bit.Core.OrganizationFeatures.OrganizationSponsorships.FamiliesForEnterprise;
@@ -28,13 +30,8 @@ public static class OrganizationServiceCollectionExtensions
         services.AddOrganizationConnectionCommands();
         services.AddOrganizationSponsorshipCommands(globalSettings);
         services.AddOrganizationApiKeyCommandsQueries();
-    }
-
-    private static void AddOrganizationGroupCommands(this IServiceCollection services)
-    {
-        services.AddScoped<ICreateGroupCommand, CreateGroupCommand>();
-        services.AddScoped<IDeleteGroupCommand, DeleteGroupCommand>();
-        services.AddScoped<IUpdateGroupCommand, UpdateGroupCommand>();
+        services.AddOrganizationCollectionCommands();
+        services.AddOrganizationGroupCommands();
     }
 
     private static void AddOrganizationConnectionCommands(this IServiceCollection services)
@@ -76,6 +73,18 @@ public static class OrganizationServiceCollectionExtensions
         services.AddScoped<ICreateOrganizationApiKeyCommand, CreateOrganizationApiKeyCommand>();
     }
 
+    public static void AddOrganizationCollectionCommands(this IServiceCollection services)
+    {
+        services.AddScoped<IDeleteCollectionCommand, DeleteCollectionCommand>();
+    }
+
+    private static void AddOrganizationGroupCommands(this IServiceCollection services)
+    {
+        services.AddScoped<ICreateGroupCommand, CreateGroupCommand>();
+        services.AddScoped<IDeleteGroupCommand, DeleteGroupCommand>();
+        services.AddScoped<IUpdateGroupCommand, UpdateGroupCommand>();
+    }
+
     private static void AddTokenizers(this IServiceCollection services)
     {
         services.AddSingleton<IDataProtectorTokenFactory<OrganizationSponsorshipOfferTokenable>>(serviceProvider =>

src/Core/Repositories/ICollectionRepository.cs

@@ -6,14 +6,18 @@ namespace Bit.Core.Repositories;
 public interface ICollectionRepository : IRepository<Collection, Guid>
 {
     Task<int> GetCountByOrganizationIdAsync(Guid organizationId);
-    Task<Tuple<Collection, ICollection<SelectionReadOnly>>> GetByIdWithGroupsAsync(Guid id);
-    Task<Tuple<CollectionDetails, ICollection<SelectionReadOnly>>> GetByIdWithGroupsAsync(Guid id, Guid userId);
+    Task<Tuple<Collection, CollectionAccessDetails>> GetByIdWithAccessAsync(Guid id);
+    Task<Tuple<CollectionDetails, CollectionAccessDetails>> GetByIdWithAccessAsync(Guid id, Guid userId);
     Task<ICollection<Collection>> GetManyByOrganizationIdAsync(Guid organizationId);
+    Task<ICollection<Tuple<Collection, CollectionAccessDetails>>> GetManyByOrganizationIdWithAccessAsync(Guid organizationId);
+    Task<ICollection<Tuple<Collection, CollectionAccessDetails>>> GetManyByUserIdWithAccessAsync(Guid userId, Guid organizationId);
     Task<CollectionDetails> GetByIdAsync(Guid id, Guid userId);
+    Task<ICollection<Collection>> GetManyByManyIdsAsync(IEnumerable<Guid> collectionIds);
     Task<ICollection<CollectionDetails>> GetManyByUserIdAsync(Guid userId);
-    Task CreateAsync(Collection obj, IEnumerable<SelectionReadOnly> groups);
-    Task ReplaceAsync(Collection obj, IEnumerable<SelectionReadOnly> groups);
+    Task CreateAsync(Collection obj, IEnumerable<CollectionAccessSelection> groups, IEnumerable<CollectionAccessSelection> users);
+    Task ReplaceAsync(Collection obj, IEnumerable<CollectionAccessSelection> groups, IEnumerable<CollectionAccessSelection> users);
     Task DeleteUserAsync(Guid collectionId, Guid organizationUserId);
-    Task UpdateUsersAsync(Guid id, IEnumerable<SelectionReadOnly> users);
-    Task<ICollection<SelectionReadOnly>> GetManyUsersByIdAsync(Guid id);
+    Task UpdateUsersAsync(Guid id, IEnumerable<CollectionAccessSelection> users);
+    Task<ICollection<CollectionAccessSelection>> GetManyUsersByIdAsync(Guid id);
+    Task DeleteManyAsync(IEnumerable<Guid> collectionIds);
 }

src/Core/Repositories/IGroupRepository.cs

@@ -5,13 +5,17 @@ namespace Bit.Core.Repositories;
 
 public interface IGroupRepository : IRepository<Group, Guid>
 {
-    Task<Tuple<Group, ICollection<SelectionReadOnly>>> GetByIdWithCollectionsAsync(Guid id);
+    Task<Tuple<Group, ICollection<CollectionAccessSelection>>> GetByIdWithCollectionsAsync(Guid id);
     Task<ICollection<Group>> GetManyByOrganizationIdAsync(Guid organizationId);
+    Task<ICollection<Tuple<Group, ICollection<CollectionAccessSelection>>>> GetManyWithCollectionsByOrganizationIdAsync(
+        Guid organizationId);
+    Task<ICollection<Group>> GetManyByManyIds(IEnumerable<Guid> groupIds);
     Task<ICollection<Guid>> GetManyIdsByUserIdAsync(Guid organizationUserId);
     Task<ICollection<Guid>> GetManyUserIdsByIdAsync(Guid id);
     Task<ICollection<GroupUser>> GetManyGroupUsersByOrganizationIdAsync(Guid organizationId);
-    Task CreateAsync(Group obj, IEnumerable<SelectionReadOnly> collections);
-    Task ReplaceAsync(Group obj, IEnumerable<SelectionReadOnly> collections);
+    Task CreateAsync(Group obj, IEnumerable<CollectionAccessSelection> collections);
+    Task ReplaceAsync(Group obj, IEnumerable<CollectionAccessSelection> collections);
     Task DeleteUserAsync(Guid groupId, Guid organizationUserId);
     Task UpdateUsersAsync(Guid groupId, IEnumerable<Guid> organizationUserIds);
+    Task DeleteManyAsync(IEnumerable<Guid> groupIds);
 }

src/Core/Repositories/IOrganizationUserRepository.cs

@@ -15,20 +15,20 @@ public interface IOrganizationUserRepository : IRepository<OrganizationUser, Gui
     Task<int> GetCountByOrganizationAsync(Guid organizationId, string email, bool onlyRegisteredUsers);
     Task<ICollection<string>> SelectKnownEmailsAsync(Guid organizationId, IEnumerable<string> emails, bool onlyRegisteredUsers);
     Task<OrganizationUser> GetByOrganizationAsync(Guid organizationId, Guid userId);
-    Task<Tuple<OrganizationUser, ICollection<SelectionReadOnly>>> GetByIdWithCollectionsAsync(Guid id);
+    Task<Tuple<OrganizationUser, ICollection<CollectionAccessSelection>>> GetByIdWithCollectionsAsync(Guid id);
     Task<OrganizationUserUserDetails> GetDetailsByIdAsync(Guid id);
-    Task<Tuple<OrganizationUserUserDetails, ICollection<SelectionReadOnly>>>
+    Task<Tuple<OrganizationUserUserDetails, ICollection<CollectionAccessSelection>>>
         GetDetailsByIdWithCollectionsAsync(Guid id);
-    Task<ICollection<OrganizationUserUserDetails>> GetManyDetailsByOrganizationAsync(Guid organizationId);
+    Task<ICollection<OrganizationUserUserDetails>> GetManyDetailsByOrganizationAsync(Guid organizationId, bool includeGroups = false, bool includeCollections = false);
     Task<ICollection<OrganizationUserOrganizationDetails>> GetManyDetailsByUserAsync(Guid userId,
         OrganizationUserStatusType? status = null);
     Task<OrganizationUserOrganizationDetails> GetDetailsByUserAsync(Guid userId, Guid organizationId,
         OrganizationUserStatusType? status = null);
     Task UpdateGroupsAsync(Guid orgUserId, IEnumerable<Guid> groupIds);
     Task UpsertManyAsync(IEnumerable<OrganizationUser> organizationUsers);
-    Task<Guid> CreateAsync(OrganizationUser obj, IEnumerable<SelectionReadOnly> collections);
+    Task<Guid> CreateAsync(OrganizationUser obj, IEnumerable<CollectionAccessSelection> collections);
     Task<ICollection<Guid>> CreateManyAsync(IEnumerable<OrganizationUser> organizationIdUsers);
-    Task ReplaceAsync(OrganizationUser obj, IEnumerable<SelectionReadOnly> collections);
+    Task ReplaceAsync(OrganizationUser obj, IEnumerable<CollectionAccessSelection> collections);
     Task ReplaceManyAsync(IEnumerable<OrganizationUser> organizationUsers);
     Task<ICollection<OrganizationUser>> GetManyByManyUsersAsync(IEnumerable<Guid> userIds);
     Task<ICollection<OrganizationUser>> GetManyAsync(IEnumerable<Guid> Ids);

src/Core/Services/ICollectionService.cs

@@ -5,8 +5,7 @@ namespace Bit.Core.Services;
 
 public interface ICollectionService
 {
-    Task SaveAsync(Collection collection, IEnumerable<SelectionReadOnly> groups = null, Guid? assignUserId = null);
-    Task DeleteAsync(Collection collection);
+    Task SaveAsync(Collection collection, IEnumerable<CollectionAccessSelection> groups = null, IEnumerable<CollectionAccessSelection> users = null, Guid? assignUserId = null);
     Task DeleteUserAsync(Collection collection, Guid organizationUserId);
     Task<IEnumerable<Collection>> GetOrganizationCollections(Guid organizationId);
 }

src/Core/Services/IEventService.cs

@@ -10,8 +10,10 @@ public interface IEventService
     Task LogCipherEventAsync(Cipher cipher, EventType type, DateTime? date = null);
     Task LogCipherEventsAsync(IEnumerable<Tuple<Cipher, EventType, DateTime?>> events);
     Task LogCollectionEventAsync(Collection collection, EventType type, DateTime? date = null);
+    Task LogCollectionEventsAsync(IEnumerable<(Collection collection, EventType type, DateTime? date)> events);
     Task LogGroupEventAsync(Group group, EventType type, DateTime? date = null);
     Task LogGroupEventAsync(Group group, EventType type, EventSystemUser systemUser, DateTime? date = null);
+    Task LogGroupEventsAsync(IEnumerable<(Group group, EventType type, EventSystemUser? systemUser, DateTime? date)> events);
     Task LogPolicyEventAsync(Policy policy, EventType type, DateTime? date = null);
     Task LogOrganizationUserEventAsync(OrganizationUser organizationUser, EventType type, DateTime? date = null);
     Task LogOrganizationUserEventAsync(OrganizationUser organizationUser, EventType type, EventSystemUser systemUser, DateTime? date = null);

src/Core/Services/IOrganizationService.cs

@@ -34,9 +34,9 @@ public interface IOrganizationService
     Task<List<OrganizationUser>> InviteUsersAsync(Guid organizationId, EventSystemUser systemUser,
         IEnumerable<(OrganizationUserInvite invite, string externalId)> invites);
     Task<OrganizationUser> InviteUserAsync(Guid organizationId, Guid? invitingUserId, string email,
-        OrganizationUserType type, bool accessAll, string externalId, IEnumerable<SelectionReadOnly> collections);
+        OrganizationUserType type, bool accessAll, string externalId, IEnumerable<CollectionAccessSelection> collections, IEnumerable<Guid> groups);
     Task<OrganizationUser> InviteUserAsync(Guid organizationId, EventSystemUser systemUser, string email,
-        OrganizationUserType type, bool accessAll, string externalId, IEnumerable<SelectionReadOnly> collections);
+        OrganizationUserType type, bool accessAll, string externalId, IEnumerable<CollectionAccessSelection> collections, IEnumerable<Guid> groups);
     Task<IEnumerable<Tuple<OrganizationUser, string>>> ResendInvitesAsync(Guid organizationId, Guid? invitingUserId, IEnumerable<Guid> organizationUsersId);
     Task ResendInviteAsync(Guid organizationId, Guid? invitingUserId, Guid organizationUserId);
     Task<OrganizationUser> AcceptUserAsync(Guid organizationUserId, User user, string token,
@@ -46,7 +46,7 @@ public interface IOrganizationService
         Guid confirmingUserId, IUserService userService);
     Task<List<Tuple<OrganizationUser, string>>> ConfirmUsersAsync(Guid organizationId, Dictionary<Guid, string> keys,
         Guid confirmingUserId, IUserService userService);
-    Task SaveUserAsync(OrganizationUser user, Guid? savingUserId, IEnumerable<SelectionReadOnly> collections);
+    Task SaveUserAsync(OrganizationUser user, Guid? savingUserId, IEnumerable<CollectionAccessSelection> collections, IEnumerable<Guid> groups);
     [Obsolete("IDeleteOrganizationUserCommand should be used instead. To be removed by EC-607.")]
     Task DeleteUserAsync(Guid organizationId, Guid organizationUserId, Guid? deletingUserId);
     [Obsolete("IDeleteOrganizationUserCommand should be used instead. To be removed by EC-607.")]

src/Core/Services/Implementations/CollectionService.cs

@@ -39,8 +39,8 @@ public class CollectionService : ICollectionService
         _currentContext = currentContext;
     }
 
-    public async Task SaveAsync(Collection collection, IEnumerable<SelectionReadOnly> groups = null,
-        Guid? assignUserId = null)
+    public async Task SaveAsync(Collection collection, IEnumerable<CollectionAccessSelection> groups = null,
+        IEnumerable<CollectionAccessSelection> users = null, Guid? assignUserId = null)
     {
         var org = await _organizationRepository.GetByIdAsync(collection.OrganizationId);
         if (org == null)
@@ -60,14 +60,7 @@ public class CollectionService : ICollectionService
                 }
             }
 
-            if (groups == null || !org.UseGroups)
-            {
-                await _collectionRepository.CreateAsync(collection);
-            }
-            else
-            {
-                await _collectionRepository.CreateAsync(collection, groups);
-            }
+            await _collectionRepository.CreateAsync(collection, org.UseGroups ? groups : null, users);
 
             // Assign a user to the newly created collection.
             if (assignUserId.HasValue)
@@ -76,8 +69,8 @@ public class CollectionService : ICollectionService
                 if (orgUser != null && orgUser.Status == Enums.OrganizationUserStatusType.Confirmed)
                 {
                     await _collectionRepository.UpdateUsersAsync(collection.Id,
-                        new List<SelectionReadOnly> {
-                            new SelectionReadOnly { Id = orgUser.Id, ReadOnly = false } });
+                        new List<CollectionAccessSelection> {
+                            new CollectionAccessSelection { Id = orgUser.Id, ReadOnly = false } });
                 }
             }
 
@@ -86,25 +79,11 @@ public class CollectionService : ICollectionService
         }
         else
         {
-            if (!org.UseGroups)
-            {
-                await _collectionRepository.ReplaceAsync(collection);
-            }
-            else
-            {
-                await _collectionRepository.ReplaceAsync(collection, groups ?? new List<SelectionReadOnly>());
-            }
-
+            await _collectionRepository.ReplaceAsync(collection, org.UseGroups ? groups : null, users);
             await _eventService.LogCollectionEventAsync(collection, Enums.EventType.Collection_Updated);
         }
     }
 
-    public async Task DeleteAsync(Collection collection)
-    {
-        await _collectionRepository.DeleteAsync(collection);
-        await _eventService.LogCollectionEventAsync(collection, Enums.EventType.Collection_Deleted);
-    }
-
     public async Task DeleteUserAsync(Collection collection, Guid organizationUserId)
     {
         var orgUser = await _organizationUserRepository.GetByIdAsync(organizationUserId);

src/Core/Services/Implementations/EventService.cs

@@ -135,59 +135,67 @@ public class EventService : IEventService
         };
     }
 
-    public async Task LogCollectionEventAsync(Collection collection, EventType type, DateTime? date = null)
+    public async Task LogCollectionEventAsync(Collection collection, EventType type, DateTime? date = null) =>
+        await LogCollectionEventsAsync(new[] { (collection, type, date) });
+
+
+    public async Task LogCollectionEventsAsync(IEnumerable<(Collection collection, EventType type, DateTime? date)> events)
     {
         var orgAbilities = await _applicationCacheService.GetOrganizationAbilitiesAsync();
-        if (!CanUseEvents(orgAbilities, collection.OrganizationId))
+        var eventMessages = new List<IEvent>();
+        foreach (var (collection, type, date) in events)
         {
-            return;
+            if (!CanUseEvents(orgAbilities, collection.OrganizationId))
+            {
+                continue;
+            }
+
+            eventMessages.Add(new EventMessage(_currentContext)
+            {
+                OrganizationId = collection.OrganizationId,
+                CollectionId = collection.Id,
+                Type = type,
+                ActingUserId = _currentContext?.UserId,
+                ProviderId = await GetProviderIdAsync(collection.OrganizationId),
+                Date = date.GetValueOrDefault(DateTime.UtcNow)
+            });
         }
 
-        var e = new EventMessage(_currentContext)
-        {
-            OrganizationId = collection.OrganizationId,
-            CollectionId = collection.Id,
-            Type = type,
-            ActingUserId = _currentContext?.UserId,
-            ProviderId = await GetProviderIdAsync(collection.OrganizationId),
-            Date = date.GetValueOrDefault(DateTime.UtcNow)
-        };
-        await _eventWriteService.CreateAsync(e);
+        await _eventWriteService.CreateManyAsync(eventMessages);
     }
 
-    public async Task LogGroupEventAsync(Group group, EventType type,
-        DateTime? date = null)
-    {
-        await CreateLogGroupEventAsync(group, type, systemUser: null, date);
-    }
+    public async Task LogGroupEventAsync(Group group, EventType type, DateTime? date = null) =>
+        await LogGroupEventsAsync(new[] { (group, type, (EventSystemUser?)null, date) });
 
-    public async Task LogGroupEventAsync(Group group, EventType type, EventSystemUser systemUser,
-        DateTime? date = null)
-    {
-        await CreateLogGroupEventAsync(group, type, systemUser, date);
-    }
+    public async Task LogGroupEventAsync(Group group, EventType type, EventSystemUser systemUser, DateTime? date = null) =>
+        await LogGroupEventsAsync(new[] { (group, type, (EventSystemUser?)systemUser, date) });
 
-    private async Task CreateLogGroupEventAsync(Group group, EventType type, EventSystemUser? systemUser, DateTime? date = null)
+    public async Task LogGroupEventsAsync(IEnumerable<(Group group, EventType type, EventSystemUser? systemUser, DateTime? date)> events)
     {
         var orgAbilities = await _applicationCacheService.GetOrganizationAbilitiesAsync();
-        if (!CanUseEvents(orgAbilities, group.OrganizationId))
+        var eventMessages = new List<IEvent>();
+        foreach (var (group, type, systemUser, date) in events)
         {
-            return;
-        }
+            if (!CanUseEvents(orgAbilities, group.OrganizationId))
+            {
+                continue;
+            }
 
-        var e = new EventMessage(_currentContext)
-        {
-            OrganizationId = group.OrganizationId,
-            GroupId = group.Id,
-            Type = type,
-            ActingUserId = _currentContext?.UserId,
-            ProviderId = await GetProviderIdAsync(@group.OrganizationId),
-            Date = date.GetValueOrDefault(DateTime.UtcNow),
-            SystemUser = systemUser
-        };
-        await _eventWriteService.CreateAsync(e);
+            eventMessages.Add(new EventMessage(_currentContext)
+            {
+                OrganizationId = group.OrganizationId,
+                GroupId = group.Id,
+                Type = type,
+                ActingUserId = _currentContext?.UserId,
+                ProviderId = await GetProviderIdAsync(group.OrganizationId),
+                SystemUser = systemUser,
+                Date = date.GetValueOrDefault(DateTime.UtcNow)
+            });
+        }
+        await _eventWriteService.CreateManyAsync(eventMessages);
     }
 
+
     public async Task LogPolicyEventAsync(Policy policy, EventType type, DateTime? date = null)
     {
         var orgAbilities = await _applicationCacheService.GetOrganizationAbilitiesAsync();

src/Core/Services/Implementations/OrganizationService.cs

@@ -1207,7 +1207,8 @@ public class OrganizationService : IOrganizationService
         }
 
         var orgUsers = new List<OrganizationUser>();
-        var limitedCollectionOrgUsers = new List<(OrganizationUser, IEnumerable<SelectionReadOnly>)>();
+        var limitedCollectionOrgUsers = new List<(OrganizationUser, IEnumerable<CollectionAccessSelection>)>();
+        var orgUserGroups = new List<(OrganizationUser, IEnumerable<Guid>)>();
         var orgUserInvitedCount = 0;
         var exceptions = new List<Exception>();
         var events = new List<(OrganizationUser, EventType, DateTime?)>();
@@ -1252,6 +1253,11 @@ public class OrganizationService : IOrganizationService
                         orgUsers.Add(orgUser);
                     }
 
+                    if (invite.Groups != null && invite.Groups.Any())
+                    {
+                        orgUserGroups.Add((orgUser, invite.Groups));
+                    }
+
                     events.Add((orgUser, EventType.OrganizationUser_Invited, DateTime.UtcNow));
                     orgUserInvitedCount++;
                 }
@@ -1276,6 +1282,11 @@ public class OrganizationService : IOrganizationService
                 await _organizationUserRepository.CreateAsync(orgUser, collections);
             }
 
+            foreach (var (orgUser, groups) in orgUserGroups)
+            {
+                await _organizationUserRepository.UpdateGroupsAsync(orgUser.Id, groups);
+            }
+
             if (!await _currentContext.ManageUsers(organization.Id))
             {
                 throw new BadRequestException("Cannot add seats. Cannot manage organization users.");
@@ -1659,7 +1670,8 @@ public class OrganizationService : IOrganizationService
     }
 
     public async Task SaveUserAsync(OrganizationUser user, Guid? savingUserId,
-        IEnumerable<SelectionReadOnly> collections)
+        IEnumerable<CollectionAccessSelection> collections,
+        IEnumerable<Guid> groups)
     {
         if (user.Id.Equals(default(Guid)))
         {
@@ -1688,9 +1700,15 @@ public class OrganizationService : IOrganizationService
         if (user.AccessAll)
         {
             // We don't need any collections if we're flagged to have all access.
-            collections = new List<SelectionReadOnly>();
+            collections = new List<CollectionAccessSelection>();
         }
         await _organizationUserRepository.ReplaceAsync(user, collections);
+
+        if (groups != null)
+        {
+            await _organizationUserRepository.UpdateGroupsAsync(user.Id, groups);
+        }
+
         await _eventService.LogOrganizationUserEventAsync(user, EventType.OrganizationUser_Updated);
     }
 
@@ -1915,19 +1933,21 @@ public class OrganizationService : IOrganizationService
     }
 
     public async Task<OrganizationUser> InviteUserAsync(Guid organizationId, Guid? invitingUserId, string email,
-        OrganizationUserType type, bool accessAll, string externalId, IEnumerable<SelectionReadOnly> collections)
+        OrganizationUserType type, bool accessAll, string externalId, IEnumerable<CollectionAccessSelection> collections,
+        IEnumerable<Guid> groups)
     {
-        return await SaveUserSendInviteAsync(organizationId, invitingUserId, systemUser: null, email, type, accessAll, externalId, collections);
+        return await SaveUserSendInviteAsync(organizationId, invitingUserId, systemUser: null, email, type, accessAll, externalId, collections, groups);
     }
 
     public async Task<OrganizationUser> InviteUserAsync(Guid organizationId, EventSystemUser systemUser, string email,
-        OrganizationUserType type, bool accessAll, string externalId, IEnumerable<SelectionReadOnly> collections)
+        OrganizationUserType type, bool accessAll, string externalId, IEnumerable<CollectionAccessSelection> collections,
+        IEnumerable<Guid> groups)
     {
-        return await SaveUserSendInviteAsync(organizationId, invitingUserId: null, systemUser, email, type, accessAll, externalId, collections);
+        return await SaveUserSendInviteAsync(organizationId, invitingUserId: null, systemUser, email, type, accessAll, externalId, collections, groups);
     }
 
     private async Task<OrganizationUser> SaveUserSendInviteAsync(Guid organizationId, Guid? invitingUserId, EventSystemUser? systemUser, string email,
-        OrganizationUserType type, bool accessAll, string externalId, IEnumerable<SelectionReadOnly> collections)
+        OrganizationUserType type, bool accessAll, string externalId, IEnumerable<CollectionAccessSelection> collections, IEnumerable<Guid> groups)
     {
         var invite = new OrganizationUserInvite()
         {
@@ -1935,6 +1955,7 @@ public class OrganizationService : IOrganizationService
             Type = type,
             AccessAll = accessAll,
             Collections = collections,
+            Groups = groups
         };
         var results = systemUser.HasValue ? await InviteUsersAsync(organizationId, systemUser.Value,
             new (OrganizationUserInvite, string)[] { (invite, externalId) }) : await InviteUsersAsync(organizationId, invitingUserId,
@@ -2048,7 +2069,7 @@ public class OrganizationService : IOrganizationService
                         Emails = new List<string> { user.Email },
                         Type = OrganizationUserType.User,
                         AccessAll = false,
-                        Collections = new List<SelectionReadOnly>(),
+                        Collections = new List<CollectionAccessSelection>(),
                     };
                     userInvites.Add((invite, user.ExternalId));
                 }

src/Core/Services/NoopImplementations/NoopEventService.cs

@@ -21,6 +21,17 @@ public class NoopEventService : IEventService
         return Task.FromResult(0);
     }
 
+    Task IEventService.LogCollectionEventsAsync(IEnumerable<(Collection collection, EventType type, DateTime? date)> events)
+    {
+        return Task.FromResult(0);
+    }
+
+    public Task LogGroupEventsAsync(
+        IEnumerable<(Group group, EventType type, EventSystemUser? systemUser, DateTime? date)> events)
+    {
+        return Task.FromResult(0);
+    }
+
     public Task LogPolicyEventAsync(Policy policy, EventType type, DateTime? date = null)
     {
         return Task.FromResult(0);
@@ -82,4 +93,5 @@ public class NoopEventService : IEventService
     {
         return Task.FromResult(0);
     }
+
 }