[AC-2810] Remove unused FlexibleCollections feature flag from CollectionCipher Repository (#4284)

Remove FlexibleCollections feature flag logic for repository methods:
* GetManyByUserIdAsync
* GetManyByUserIdCipherIdAsync
* UpdateCollectionsAsync
* UpdateCollectionsForCiphersAsync

This feature flag was never turned on and we will update the sprocs
directly as required.

src/Api/Vault/Controllers/CiphersController.cs

@@ -117,7 +117,7 @@ public class CiphersController : Controller
             throw new NotFoundException();
         }
 
-        var collectionCiphers = await _collectionCipherRepository.GetManyByUserIdCipherIdAsync(userId, id, UseFlexibleCollections);
+        var collectionCiphers = await _collectionCipherRepository.GetManyByUserIdCipherIdAsync(userId, id);
         return new CipherDetailsResponseModel(cipher, _globalSettings, collectionCiphers);
     }
 
@@ -131,7 +131,7 @@ public class CiphersController : Controller
         Dictionary<Guid, IGrouping<Guid, CollectionCipher>> collectionCiphersGroupDict = null;
         if (hasOrgs)
         {
-            var collectionCiphers = await _collectionCipherRepository.GetManyByUserIdAsync(userId, UseFlexibleCollections);
+            var collectionCiphers = await _collectionCipherRepository.GetManyByUserIdAsync(userId);
             collectionCiphersGroupDict = collectionCiphers.GroupBy(c => c.CipherId).ToDictionary(s => s.Key);
         }
 
@@ -202,7 +202,7 @@ public class CiphersController : Controller
         ValidateClientVersionForItemLevelEncryptionSupport(cipher);
         ValidateClientVersionForFido2CredentialSupport(cipher);
 
-        var collectionIds = (await _collectionCipherRepository.GetManyByUserIdCipherIdAsync(userId, id, UseFlexibleCollections)).Select(c => c.CollectionId).ToList();
+        var collectionIds = (await _collectionCipherRepository.GetManyByUserIdCipherIdAsync(userId, id)).Select(c => c.CollectionId).ToList();
         var modelOrgId = string.IsNullOrWhiteSpace(model.OrganizationId) ?
             (Guid?)null : new Guid(model.OrganizationId);
         if (cipher.OrganizationId != modelOrgId)
@@ -233,7 +233,7 @@ public class CiphersController : Controller
             throw new NotFoundException();
         }
 
-        var collectionIds = (await _collectionCipherRepository.GetManyByUserIdCipherIdAsync(userId, id, UseFlexibleCollections)).Select(c => c.CollectionId).ToList();
+        var collectionIds = (await _collectionCipherRepository.GetManyByUserIdCipherIdAsync(userId, id)).Select(c => c.CollectionId).ToList();
         // object cannot be a descendant of CipherDetails, so let's clone it.
         var cipherClone = model.ToCipher(cipher).Clone();
         await _cipherService.SaveAsync(cipherClone, userId, model.LastKnownRevisionDate, collectionIds, true, false);
@@ -618,7 +618,7 @@ public class CiphersController : Controller
             model.CollectionIds.Select(c => new Guid(c)), userId, false);
 
         var updatedCipher = await GetByIdAsync(id, userId);
-        var collectionCiphers = await _collectionCipherRepository.GetManyByUserIdCipherIdAsync(userId, id, UseFlexibleCollections);
+        var collectionCiphers = await _collectionCipherRepository.GetManyByUserIdCipherIdAsync(userId, id);
 
         return new CipherDetailsResponseModel(updatedCipher, _globalSettings, collectionCiphers);
     }
@@ -639,7 +639,7 @@ public class CiphersController : Controller
             model.CollectionIds.Select(c => new Guid(c)), userId, false);
 
         var updatedCipher = await GetByIdAsync(id, userId);
-        var collectionCiphers = await _collectionCipherRepository.GetManyByUserIdCipherIdAsync(userId, id, UseFlexibleCollections);
+        var collectionCiphers = await _collectionCipherRepository.GetManyByUserIdCipherIdAsync(userId, id);
         // If a user removes the last Can Manage access of a cipher, the "updatedCipher" will return null
         // We will be returning an "Unavailable" property so the client knows the user can no longer access this
         var response = new OptionalCipherDetailsResponseModel()

src/Api/Vault/Controllers/SyncController.cs

@@ -91,7 +91,7 @@ public class SyncController : Controller
         if (hasEnabledOrgs)
         {
             collections = await _collectionRepository.GetManyByUserIdAsync(user.Id, UseFlexibleCollections);
-            var collectionCiphers = await _collectionCipherRepository.GetManyByUserIdAsync(user.Id, UseFlexibleCollections);
+            var collectionCiphers = await _collectionCipherRepository.GetManyByUserIdAsync(user.Id);
             collectionCiphersGroupDict = collectionCiphers.GroupBy(c => c.CipherId).ToDictionary(s => s.Key);
         }
 

src/Core/Repositories/ICollectionCipherRepository.cs

@@ -4,13 +4,13 @@ namespace Bit.Core.Repositories;
 
 public interface ICollectionCipherRepository
 {
-    Task<ICollection<CollectionCipher>> GetManyByUserIdAsync(Guid userId, bool useFlexibleCollections);
+    Task<ICollection<CollectionCipher>> GetManyByUserIdAsync(Guid userId);
     Task<ICollection<CollectionCipher>> GetManyByOrganizationIdAsync(Guid organizationId);
-    Task<ICollection<CollectionCipher>> GetManyByUserIdCipherIdAsync(Guid userId, Guid cipherId, bool useFlexibleCollections);
-    Task UpdateCollectionsAsync(Guid cipherId, Guid userId, IEnumerable<Guid> collectionIds, bool useFlexibleCollections);
+    Task<ICollection<CollectionCipher>> GetManyByUserIdCipherIdAsync(Guid userId, Guid cipherId);
+    Task UpdateCollectionsAsync(Guid cipherId, Guid userId, IEnumerable<Guid> collectionIds);
     Task UpdateCollectionsForAdminAsync(Guid cipherId, Guid organizationId, IEnumerable<Guid> collectionIds);
     Task UpdateCollectionsForCiphersAsync(IEnumerable<Guid> cipherIds, Guid userId, Guid organizationId,
-        IEnumerable<Guid> collectionIds, bool useFlexibleCollections);
+        IEnumerable<Guid> collectionIds);
 
     /// <summary>
     /// Add the specified collections to the specified ciphers. If a cipher already belongs to a requested collection,

src/Core/Vault/Services/Implementations/CipherService.cs

@@ -585,11 +585,11 @@ public class CipherService : ICipherService
                     originalCipher.SetAttachments(originalAttachments);
                 }
 
-                var currentCollectionsForCipher = await _collectionCipherRepository.GetManyByUserIdCipherIdAsync(sharingUserId, originalCipher.Id, UseFlexibleCollections);
+                var currentCollectionsForCipher = await _collectionCipherRepository.GetManyByUserIdCipherIdAsync(sharingUserId, originalCipher.Id);
                 var currentCollectionIdsForCipher = currentCollectionsForCipher.Select(c => c.CollectionId).ToList();
                 currentCollectionIdsForCipher.RemoveAll(id => collectionIds.Contains(id));
 
-                await _collectionCipherRepository.UpdateCollectionsAsync(originalCipher.Id, sharingUserId, currentCollectionIdsForCipher, UseFlexibleCollections);
+                await _collectionCipherRepository.UpdateCollectionsAsync(originalCipher.Id, sharingUserId, currentCollectionIdsForCipher);
                 await _cipherRepository.ReplaceAsync(originalCipher);
             }
 
@@ -634,7 +634,7 @@ public class CipherService : ICipherService
 
         await _cipherRepository.UpdateCiphersAsync(sharingUserId, cipherInfos.Select(c => c.cipher));
         await _collectionCipherRepository.UpdateCollectionsForCiphersAsync(cipherIds, sharingUserId,
-            organizationId, collectionIds, UseFlexibleCollections);
+            organizationId, collectionIds);
 
         var events = cipherInfos.Select(c =>
             new Tuple<Cipher, EventType, DateTime?>(c.cipher, EventType.Cipher_Shared, null));
@@ -675,7 +675,7 @@ public class CipherService : ICipherService
             {
                 throw new BadRequestException("You do not have permissions to edit this.");
             }
-            await _collectionCipherRepository.UpdateCollectionsAsync(cipher.Id, savingUserId, collectionIds, UseFlexibleCollections);
+            await _collectionCipherRepository.UpdateCollectionsAsync(cipher.Id, savingUserId, collectionIds);
         }
 
         await _eventService.LogCipherEventAsync(cipher, Bit.Core.Enums.EventType.Cipher_UpdatedCollections);

src/Infrastructure.Dapper/Repositories/CollectionCipherRepository.cs

@@ -17,16 +17,12 @@ public class CollectionCipherRepository : BaseRepository, ICollectionCipherRepos
         : base(connectionString, readOnlyConnectionString)
     { }
 
-    public async Task<ICollection<CollectionCipher>> GetManyByUserIdAsync(Guid userId, bool useFlexibleCollections)
+    public async Task<ICollection<CollectionCipher>> GetManyByUserIdAsync(Guid userId)
     {
-        var sprocName = useFlexibleCollections
-            ? "[dbo].[CollectionCipher_ReadByUserId_V2]"
-            : "[dbo].[CollectionCipher_ReadByUserId]";
-
         using (var connection = new SqlConnection(ConnectionString))
         {
             var results = await connection.QueryAsync<CollectionCipher>(
-                sprocName,
+                "[dbo].[CollectionCipher_ReadByUserId]",
                 new { UserId = userId },
                 commandType: CommandType.StoredProcedure);
 
@@ -47,16 +43,12 @@ public class CollectionCipherRepository : BaseRepository, ICollectionCipherRepos
         }
     }
 
-    public async Task<ICollection<CollectionCipher>> GetManyByUserIdCipherIdAsync(Guid userId, Guid cipherId, bool useFlexibleCollections)
+    public async Task<ICollection<CollectionCipher>> GetManyByUserIdCipherIdAsync(Guid userId, Guid cipherId)
     {
-        var sprocName = useFlexibleCollections
-            ? "[dbo].[CollectionCipher_ReadByUserIdCipherId_V2]"
-            : "[dbo].[CollectionCipher_ReadByUserIdCipherId]";
-
         using (var connection = new SqlConnection(ConnectionString))
         {
             var results = await connection.QueryAsync<CollectionCipher>(
-                sprocName,
+                "[dbo].[CollectionCipher_ReadByUserIdCipherId]",
                 new { UserId = userId, CipherId = cipherId },
                 commandType: CommandType.StoredProcedure);
 
@@ -64,16 +56,12 @@ public class CollectionCipherRepository : BaseRepository, ICollectionCipherRepos
         }
     }
 
-    public async Task UpdateCollectionsAsync(Guid cipherId, Guid userId, IEnumerable<Guid> collectionIds, bool useFlexibleCollections)
+    public async Task UpdateCollectionsAsync(Guid cipherId, Guid userId, IEnumerable<Guid> collectionIds)
     {
-        var sprocName = useFlexibleCollections
-            ? "[dbo].[CollectionCipher_UpdateCollections_V2]"
-            : "[dbo].[CollectionCipher_UpdateCollections]";
-
         using (var connection = new SqlConnection(ConnectionString))
         {
             var results = await connection.ExecuteAsync(
-                sprocName,
+                "[dbo].[CollectionCipher_UpdateCollections]",
                 new { CipherId = cipherId, UserId = userId, CollectionIds = collectionIds.ToGuidIdArrayTVP() },
                 commandType: CommandType.StoredProcedure);
         }
@@ -91,16 +79,12 @@ public class CollectionCipherRepository : BaseRepository, ICollectionCipherRepos
     }
 
     public async Task UpdateCollectionsForCiphersAsync(IEnumerable<Guid> cipherIds, Guid userId,
-        Guid organizationId, IEnumerable<Guid> collectionIds, bool useFlexibleCollections)
+        Guid organizationId, IEnumerable<Guid> collectionIds)
     {
-        var sprocName = useFlexibleCollections
-            ? "[dbo].[CollectionCipher_UpdateCollectionsForCiphers_V2]"
-            : "[dbo].[CollectionCipher_UpdateCollectionsForCiphers]";
-
         using (var connection = new SqlConnection(ConnectionString))
         {
             var results = await connection.ExecuteAsync(
-                sprocName,
+                "[dbo].[CollectionCipher_UpdateCollectionsForCiphers]",
                 new
                 {
                     CipherIds = cipherIds.ToGuidIdArrayTVP(),

src/Infrastructure.EntityFramework/Repositories/CollectionCipherRepository.cs

@@ -46,31 +46,31 @@ public class CollectionCipherRepository : BaseEntityFrameworkRepository, ICollec
         }
     }
 
-    public async Task<ICollection<CollectionCipher>> GetManyByUserIdAsync(Guid userId, bool useFlexibleCollections)
+    public async Task<ICollection<CollectionCipher>> GetManyByUserIdAsync(Guid userId)
     {
         using (var scope = ServiceScopeFactory.CreateScope())
         {
             var dbContext = GetDatabaseContext(scope);
-            var data = await new CollectionCipherReadByUserIdQuery(userId, useFlexibleCollections)
+            var data = await new CollectionCipherReadByUserIdQuery(userId)
                 .Run(dbContext)
                 .ToArrayAsync();
             return data;
         }
     }
 
-    public async Task<ICollection<CollectionCipher>> GetManyByUserIdCipherIdAsync(Guid userId, Guid cipherId, bool useFlexibleCollections)
+    public async Task<ICollection<CollectionCipher>> GetManyByUserIdCipherIdAsync(Guid userId, Guid cipherId)
     {
         using (var scope = ServiceScopeFactory.CreateScope())
         {
             var dbContext = GetDatabaseContext(scope);
-            var data = await new CollectionCipherReadByUserIdCipherIdQuery(userId, cipherId, useFlexibleCollections)
+            var data = await new CollectionCipherReadByUserIdCipherIdQuery(userId, cipherId)
                 .Run(dbContext)
                 .ToArrayAsync();
             return data;
         }
     }
 
-    public async Task UpdateCollectionsAsync(Guid cipherId, Guid userId, IEnumerable<Guid> collectionIds, bool useFlexibleCollections)
+    public async Task UpdateCollectionsAsync(Guid cipherId, Guid userId, IEnumerable<Guid> collectionIds)
     {
         using (var scope = ServiceScopeFactory.CreateScope())
         {
@@ -82,39 +82,35 @@ public class CollectionCipherRepository : BaseEntityFrameworkRepository, ICollec
                 .FirstAsync();
 
             List<Guid> availableCollections;
-            if (useFlexibleCollections)
-            {
-                var availableCollectionsQuery = new CollectionsReadByOrganizationIdUserIdQuery(organizationId, userId);
-                availableCollections = await availableCollectionsQuery
-                    .Run(dbContext)
-                    .Select(c => c.Id).ToListAsync();
-            }
-            else
-            {
-                availableCollections = await (from c in dbContext.Collections
-                                              join o in dbContext.Organizations on c.OrganizationId equals o.Id
-                                              join ou in dbContext.OrganizationUsers
-                                                 on new { OrganizationId = o.Id, UserId = (Guid?)userId } equals
-                                                 new { ou.OrganizationId, ou.UserId }
-                                              join cu in dbContext.CollectionUsers
-                                                 on new { ou.AccessAll, CollectionId = c.Id, OrganizationUserId = ou.Id } equals
-                                                 new { AccessAll = false, cu.CollectionId, cu.OrganizationUserId } into cu_g
-                                              from cu in cu_g.DefaultIfEmpty()
-                                              join gu in dbContext.GroupUsers
-                                                 on new { CollectionId = (Guid?)cu.CollectionId, ou.AccessAll, OrganizationUserId = ou.Id } equals
-                                                 new { CollectionId = (Guid?)null, AccessAll = false, gu.OrganizationUserId } into gu_g
-                                              from gu in gu_g.DefaultIfEmpty()
-                                              join g in dbContext.Groups on gu.GroupId equals g.Id into g_g
-                                              from g in g_g.DefaultIfEmpty()
-                                              join cg in dbContext.CollectionGroups
-                                                 on new { g.AccessAll, CollectionId = c.Id, gu.GroupId } equals
-                                                 new { AccessAll = false, cg.CollectionId, cg.GroupId } into cg_g
-                                              from cg in cg_g.DefaultIfEmpty()
-                                              where o.Id == organizationId && o.Enabled && ou.Status == OrganizationUserStatusType.Confirmed
-                                                 && (ou.AccessAll || !cu.ReadOnly || g.AccessAll || !cg.ReadOnly)
-                                              select c.Id).ToListAsync();
 
-            }
+            // TODO AC-1375: use the query below to remove AccessAll from this method
+            // var availableCollectionsQuery = new CollectionsReadByOrganizationIdUserIdQuery(organizationId, userId);
+            // availableCollections = await availableCollectionsQuery
+            //     .Run(dbContext)
+            //     .Select(c => c.Id).ToListAsync();
+
+            availableCollections = await (from c in dbContext.Collections
+                                          join o in dbContext.Organizations on c.OrganizationId equals o.Id
+                                          join ou in dbContext.OrganizationUsers
+                                             on new { OrganizationId = o.Id, UserId = (Guid?)userId } equals
+                                             new { ou.OrganizationId, ou.UserId }
+                                          join cu in dbContext.CollectionUsers
+                                             on new { ou.AccessAll, CollectionId = c.Id, OrganizationUserId = ou.Id } equals
+                                             new { AccessAll = false, cu.CollectionId, cu.OrganizationUserId } into cu_g
+                                          from cu in cu_g.DefaultIfEmpty()
+                                          join gu in dbContext.GroupUsers
+                                             on new { CollectionId = (Guid?)cu.CollectionId, ou.AccessAll, OrganizationUserId = ou.Id } equals
+                                             new { CollectionId = (Guid?)null, AccessAll = false, gu.OrganizationUserId } into gu_g
+                                          from gu in gu_g.DefaultIfEmpty()
+                                          join g in dbContext.Groups on gu.GroupId equals g.Id into g_g
+                                          from g in g_g.DefaultIfEmpty()
+                                          join cg in dbContext.CollectionGroups
+                                             on new { g.AccessAll, CollectionId = c.Id, gu.GroupId } equals
+                                             new { AccessAll = false, cg.CollectionId, cg.GroupId } into cg_g
+                                          from cg in cg_g.DefaultIfEmpty()
+                                          where o.Id == organizationId && o.Enabled && ou.Status == OrganizationUserStatusType.Confirmed
+                                             && (ou.AccessAll || !cu.ReadOnly || g.AccessAll || !cg.ReadOnly)
+                                          select c.Id).ToListAsync();
 
             var collectionCiphers = await (from cc in dbContext.CollectionCiphers
                                            where cc.CipherId == cipherId
@@ -188,47 +184,43 @@ public class CollectionCipherRepository : BaseEntityFrameworkRepository, ICollec
         }
     }
 
-    public async Task UpdateCollectionsForCiphersAsync(IEnumerable<Guid> cipherIds, Guid userId, Guid organizationId, IEnumerable<Guid> collectionIds, bool useFlexibleCollections)
+    public async Task UpdateCollectionsForCiphersAsync(IEnumerable<Guid> cipherIds, Guid userId, Guid organizationId, IEnumerable<Guid> collectionIds)
     {
         using (var scope = ServiceScopeFactory.CreateScope())
         {
             var dbContext = GetDatabaseContext(scope);
 
             IQueryable<Models.Collection> availableCollections;
-            if (useFlexibleCollections)
-            {
-                var availableCollectionsQuery = new CollectionsReadByOrganizationIdUserIdQuery(organizationId, userId);
-                availableCollections = availableCollectionsQuery
-                    .Run(dbContext);
-            }
-            else
-            {
-                availableCollections = from c in dbContext.Collections
-                                       join o in dbContext.Organizations
-                                           on c.OrganizationId equals o.Id
-                                       join ou in dbContext.OrganizationUsers
-                                           on o.Id equals ou.OrganizationId
-                                       where ou.UserId == userId
-                                       join cu in dbContext.CollectionUsers
-                                           on ou.Id equals cu.OrganizationUserId into cu_g
-                                       from cu in cu_g.DefaultIfEmpty()
-                                       where !ou.AccessAll && cu.CollectionId == c.Id
-                                       join gu in dbContext.GroupUsers
-                                           on ou.Id equals gu.OrganizationUserId into gu_g
-                                       from gu in gu_g.DefaultIfEmpty()
-                                       where cu.CollectionId == null && !ou.AccessAll
-                                       join g in dbContext.Groups
-                                           on gu.GroupId equals g.Id into g_g
-                                       from g in g_g.DefaultIfEmpty()
-                                       join cg in dbContext.CollectionGroups
-                                           on gu.GroupId equals cg.GroupId into cg_g
-                                       from cg in cg_g.DefaultIfEmpty()
-                                       where !g.AccessAll && cg.CollectionId == c.Id &&
-                                       (o.Id == organizationId && o.Enabled && ou.Status == OrganizationUserStatusType.Confirmed &&
-                                       (ou.AccessAll || !cu.ReadOnly || g.AccessAll || !cg.ReadOnly))
-                                       select c;
 
-            }
+            // TODO AC-1375: use the query below to remove AccessAll from this method
+            // var availableCollectionsQuery = new CollectionsReadByOrganizationIdUserIdQuery(organizationId, userId);
+            // availableCollections = availableCollectionsQuery
+            //     .Run(dbContext);
+
+            availableCollections = from c in dbContext.Collections
+                                   join o in dbContext.Organizations
+                                       on c.OrganizationId equals o.Id
+                                   join ou in dbContext.OrganizationUsers
+                                       on o.Id equals ou.OrganizationId
+                                   where ou.UserId == userId
+                                   join cu in dbContext.CollectionUsers
+                                       on ou.Id equals cu.OrganizationUserId into cu_g
+                                   from cu in cu_g.DefaultIfEmpty()
+                                   where !ou.AccessAll && cu.CollectionId == c.Id
+                                   join gu in dbContext.GroupUsers
+                                       on ou.Id equals gu.OrganizationUserId into gu_g
+                                   from gu in gu_g.DefaultIfEmpty()
+                                   where cu.CollectionId == null && !ou.AccessAll
+                                   join g in dbContext.Groups
+                                       on gu.GroupId equals g.Id into g_g
+                                   from g in g_g.DefaultIfEmpty()
+                                   join cg in dbContext.CollectionGroups
+                                       on gu.GroupId equals cg.GroupId into cg_g
+                                   from cg in cg_g.DefaultIfEmpty()
+                                   where !g.AccessAll && cg.CollectionId == c.Id &&
+                                   (o.Id == organizationId && o.Enabled && ou.Status == OrganizationUserStatusType.Confirmed &&
+                                   (ou.AccessAll || !cu.ReadOnly || g.AccessAll || !cg.ReadOnly))
+                                   select c;
 
             if (await availableCollections.CountAsync() < 1)
             {

src/Infrastructure.EntityFramework/Repositories/Queries/CollectionCipherReadByUserIdCipherIdQuery.cs

@@ -6,7 +6,7 @@ public class CollectionCipherReadByUserIdCipherIdQuery : CollectionCipherReadByU
 {
     private readonly Guid _cipherId;
 
-    public CollectionCipherReadByUserIdCipherIdQuery(Guid userId, Guid cipherId, bool useFlexibleCollections) : base(userId, useFlexibleCollections)
+    public CollectionCipherReadByUserIdCipherIdQuery(Guid userId, Guid cipherId) : base(userId)
     {
         _cipherId = cipherId;
     }

src/Infrastructure.EntityFramework/Repositories/Queries/CollectionCipherReadByUserIdQuery.cs

@@ -6,19 +6,15 @@ namespace Bit.Infrastructure.EntityFramework.Repositories.Queries;
 public class CollectionCipherReadByUserIdQuery : IQuery<CollectionCipher>
 {
     private readonly Guid _userId;
-    private readonly bool _useFlexibleCollections;
 
-    public CollectionCipherReadByUserIdQuery(Guid userId, bool useFlexibleCollections)
+    public CollectionCipherReadByUserIdQuery(Guid userId)
     {
         _userId = userId;
-        _useFlexibleCollections = useFlexibleCollections;
     }
 
     public virtual IQueryable<CollectionCipher> Run(DatabaseContext dbContext)
     {
-        return _useFlexibleCollections
-            ? Run_VNext(dbContext)
-            : Run_VCurrent(dbContext);
+        return Run_VCurrent(dbContext);
     }
 
     private IQueryable<CollectionCipher> Run_VNext(DatabaseContext dbContext)

test/Api.Test/Vault/Controllers/CiphersControllerTests.cs

@@ -74,7 +74,7 @@ public class CiphersControllerTests
         var cipherDetails = CreateCipherDetailsMock(id, userId);
         sutProvider.GetDependency<ICipherRepository>().GetByIdAsync(id, userId).ReturnsForAnyArgs(cipherDetails);
 
-        sutProvider.GetDependency<ICollectionCipherRepository>().GetManyByUserIdCipherIdAsync(userId, id, Arg.Any<bool>()).Returns((ICollection<CollectionCipher>)new List<CollectionCipher>());
+        sutProvider.GetDependency<ICollectionCipherRepository>().GetManyByUserIdCipherIdAsync(userId, id).Returns((ICollection<CollectionCipher>)new List<CollectionCipher>());
         var cipherService = sutProvider.GetDependency<ICipherService>();
 
         await sutProvider.Sut.PutCollections_vNext(id, model);
@@ -89,7 +89,7 @@ public class CiphersControllerTests
         var cipherDetails = CreateCipherDetailsMock(id, userId);
         sutProvider.GetDependency<ICipherRepository>().GetByIdAsync(id, userId).ReturnsForAnyArgs(cipherDetails);
 
-        sutProvider.GetDependency<ICollectionCipherRepository>().GetManyByUserIdCipherIdAsync(userId, id, Arg.Any<bool>()).Returns((ICollection<CollectionCipher>)new List<CollectionCipher>());
+        sutProvider.GetDependency<ICollectionCipherRepository>().GetManyByUserIdCipherIdAsync(userId, id).Returns((ICollection<CollectionCipher>)new List<CollectionCipher>());
 
         var result = await sutProvider.Sut.PutCollections_vNext(id, model);
 
@@ -104,7 +104,7 @@ public class CiphersControllerTests
         var cipherDetails = CreateCipherDetailsMock(id, userId);
         sutProvider.GetDependency<ICipherRepository>().GetByIdAsync(id, userId).ReturnsForAnyArgs(cipherDetails, [(CipherDetails)null]);
 
-        sutProvider.GetDependency<ICollectionCipherRepository>().GetManyByUserIdCipherIdAsync(userId, id, Arg.Any<bool>()).Returns((ICollection<CollectionCipher>)new List<CollectionCipher>());
+        sutProvider.GetDependency<ICollectionCipherRepository>().GetManyByUserIdCipherIdAsync(userId, id).Returns((ICollection<CollectionCipher>)new List<CollectionCipher>());
 
         var result = await sutProvider.Sut.PutCollections_vNext(id, model);
 
@@ -116,7 +116,7 @@ public class CiphersControllerTests
     {
         sutProvider.GetDependency<IUserService>().GetProperUserId(default).ReturnsForAnyArgs(userId);
         sutProvider.GetDependency<ICurrentContext>().OrganizationUser(default).ReturnsForAnyArgs(true);
-        sutProvider.GetDependency<ICollectionCipherRepository>().GetManyByUserIdCipherIdAsync(userId, id, Arg.Any<bool>()).Returns(new List<CollectionCipher>());
+        sutProvider.GetDependency<ICollectionCipherRepository>().GetManyByUserIdCipherIdAsync(userId, id).Returns(new List<CollectionCipher>());
     }
 
     private CipherDetails CreateCipherDetailsMock(Guid id, Guid userId)

test/Api.Test/Vault/Controllers/SyncControllerTests.cs

@@ -116,7 +116,7 @@ public class SyncControllerTests
 
         // Returns for methods only called if we have enabled orgs
         collectionRepository.GetManyByUserIdAsync(user.Id, Arg.Any<bool>()).Returns(collections);
-        collectionCipherRepository.GetManyByUserIdAsync(user.Id, Arg.Any<bool>()).Returns(new List<CollectionCipher>());
+        collectionCipherRepository.GetManyByUserIdAsync(user.Id).Returns(new List<CollectionCipher>());
         // Back to standard test setup
         userService.TwoFactorIsEnabledAsync(user).Returns(false);
         userService.HasPremiumFromOrganization(user).Returns(false);
@@ -280,7 +280,7 @@ public class SyncControllerTests
 
         // Returns for methods only called if we have enabled orgs
         collectionRepository.GetManyByUserIdAsync(user.Id, Arg.Any<bool>()).Returns(collections);
-        collectionCipherRepository.GetManyByUserIdAsync(user.Id, Arg.Any<bool>()).Returns(new List<CollectionCipher>());
+        collectionCipherRepository.GetManyByUserIdAsync(user.Id).Returns(new List<CollectionCipher>());
         // Back to standard test setup
         userService.TwoFactorIsEnabledAsync(user).Returns(false);
         userService.HasPremiumFromOrganization(user).Returns(false);
@@ -344,7 +344,7 @@ public class SyncControllerTests
             await collectionRepository.ReceivedWithAnyArgs(1)
                 .GetManyByUserIdAsync(default, default);
             await collectionCipherRepository.ReceivedWithAnyArgs(1)
-                .GetManyByUserIdAsync(default, default);
+                .GetManyByUserIdAsync(default);
         }
         else
         {
@@ -352,7 +352,7 @@ public class SyncControllerTests
             await collectionRepository.ReceivedWithAnyArgs(0)
                 .GetManyByUserIdAsync(default, default);
             await collectionCipherRepository.ReceivedWithAnyArgs(0)
-                .GetManyByUserIdAsync(default, default);
+                .GetManyByUserIdAsync(default);
         }
 
         await userService.ReceivedWithAnyArgs(1)

test/Core.Test/Vault/Services/CipherServiceTests.cs

@@ -425,7 +425,7 @@ public class CipherServiceTests
         sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organization.Id).Returns(organization);
         var attachmentStorageService = sutProvider.GetDependency<IAttachmentStorageService>();
         var collectionCipherRepository = sutProvider.GetDependency<ICollectionCipherRepository>();
-        collectionCipherRepository.GetManyByUserIdCipherIdAsync(cipher.UserId.Value, cipher.Id, Arg.Any<bool>()).Returns(
+        collectionCipherRepository.GetManyByUserIdCipherIdAsync(cipher.UserId.Value, cipher.Id).Returns(
             Task.FromResult((ICollection<CollectionCipher>)new List<CollectionCipher>
             {
                 new CollectionCipher
@@ -505,7 +505,7 @@ public class CipherServiceTests
         Assert.Contains("ex from StartShareAttachmentAsync", exception.Message);
 
         await collectionCipherRepository.Received().UpdateCollectionsAsync(cipher.Id, cipher.UserId.Value,
-            Arg.Is<List<Guid>>(ids => ids.Count == 1 && ids[0] != collectionIds[0]), Arg.Any<bool>());
+            Arg.Is<List<Guid>>(ids => ids.Count == 1 && ids[0] != collectionIds[0]));
 
         await cipherRepository.Received().ReplaceAsync(Arg.Is<Cipher>(c =>
                 c.GetAttachments()[v0AttachmentId].Key == null
@@ -530,7 +530,7 @@ public class CipherServiceTests
         var attachmentStorageService = sutProvider.GetDependency<IAttachmentStorageService>();
         var userRepository = sutProvider.GetDependency<IUserRepository>();
         var collectionCipherRepository = sutProvider.GetDependency<ICollectionCipherRepository>();
-        collectionCipherRepository.GetManyByUserIdCipherIdAsync(cipher.UserId.Value, cipher.Id, Arg.Any<bool>()).Returns(
+        collectionCipherRepository.GetManyByUserIdCipherIdAsync(cipher.UserId.Value, cipher.Id).Returns(
             Task.FromResult((ICollection<CollectionCipher>)new List<CollectionCipher>
             {
                 new CollectionCipher
@@ -637,7 +637,7 @@ public class CipherServiceTests
         Assert.Contains("ex from StartShareAttachmentAsync", exception.Message);
 
         await collectionCipherRepository.Received().UpdateCollectionsAsync(cipher.Id, cipher.UserId.Value,
-            Arg.Is<List<Guid>>(ids => ids.Count == 1 && ids[0] != collectionIds[0]), Arg.Any<bool>());
+            Arg.Is<List<Guid>>(ids => ids.Count == 1 && ids[0] != collectionIds[0]));
 
         await cipherRepository.Received().ReplaceAsync(Arg.Is<Cipher>(c =>
                 c.GetAttachments()[v0AttachmentId1].Key == null