Run formatting (#2230)

src/Infrastructure.Dapper/Repositories/BaseRepository.cs

@@ -1,30 +1,29 @@
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public abstract class BaseRepository
 {
-    public abstract class BaseRepository
+    static BaseRepository()
     {
-        static BaseRepository()
-        {
-            SqlMapper.AddTypeHandler(new DateTimeHandler());
-        }
-
-        public BaseRepository(string connectionString, string readOnlyConnectionString)
-        {
-            if (string.IsNullOrWhiteSpace(connectionString))
-            {
-                throw new ArgumentNullException(nameof(connectionString));
-            }
-            if (string.IsNullOrWhiteSpace(readOnlyConnectionString))
-            {
-                throw new ArgumentNullException(nameof(readOnlyConnectionString));
-            }
-
-            ConnectionString = connectionString;
-            ReadOnlyConnectionString = readOnlyConnectionString;
-        }
-
-        protected string ConnectionString { get; private set; }
-        protected string ReadOnlyConnectionString { get; private set; }
+        SqlMapper.AddTypeHandler(new DateTimeHandler());
     }
+
+    public BaseRepository(string connectionString, string readOnlyConnectionString)
+    {
+        if (string.IsNullOrWhiteSpace(connectionString))
+        {
+            throw new ArgumentNullException(nameof(connectionString));
+        }
+        if (string.IsNullOrWhiteSpace(readOnlyConnectionString))
+        {
+            throw new ArgumentNullException(nameof(readOnlyConnectionString));
+        }
+
+        ConnectionString = connectionString;
+        ReadOnlyConnectionString = readOnlyConnectionString;
+    }
+
+    protected string ConnectionString { get; private set; }
+    protected string ReadOnlyConnectionString { get; private set; }
 }

src/Infrastructure.Dapper/Repositories/CollectionCipherRepository.cs

@@ -5,95 +5,94 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class CollectionCipherRepository : BaseRepository, ICollectionCipherRepository
 {
-    public class CollectionCipherRepository : BaseRepository, ICollectionCipherRepository
+    public CollectionCipherRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public CollectionCipherRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<ICollection<CollectionCipher>> GetManyByUserIdAsync(Guid userId)
     {
-        public CollectionCipherRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public CollectionCipherRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<ICollection<CollectionCipher>> GetManyByUserIdAsync(Guid userId)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<CollectionCipher>(
-                    "[dbo].[CollectionCipher_ReadByUserId]",
-                    new { UserId = userId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<CollectionCipher>(
+                "[dbo].[CollectionCipher_ReadByUserId]",
+                new { UserId = userId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<CollectionCipher>> GetManyByOrganizationIdAsync(Guid organizationId)
+    public async Task<ICollection<CollectionCipher>> GetManyByOrganizationIdAsync(Guid organizationId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<CollectionCipher>(
-                    "[dbo].[CollectionCipher_ReadByOrganizationId]",
-                    new { OrganizationId = organizationId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<CollectionCipher>(
+                "[dbo].[CollectionCipher_ReadByOrganizationId]",
+                new { OrganizationId = organizationId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<CollectionCipher>> GetManyByUserIdCipherIdAsync(Guid userId, Guid cipherId)
+    public async Task<ICollection<CollectionCipher>> GetManyByUserIdCipherIdAsync(Guid userId, Guid cipherId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<CollectionCipher>(
-                    "[dbo].[CollectionCipher_ReadByUserIdCipherId]",
-                    new { UserId = userId, CipherId = cipherId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<CollectionCipher>(
+                "[dbo].[CollectionCipher_ReadByUserIdCipherId]",
+                new { UserId = userId, CipherId = cipherId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task UpdateCollectionsAsync(Guid cipherId, Guid userId, IEnumerable<Guid> collectionIds)
+    public async Task UpdateCollectionsAsync(Guid cipherId, Guid userId, IEnumerable<Guid> collectionIds)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    "[dbo].[CollectionCipher_UpdateCollections]",
-                    new { CipherId = cipherId, UserId = userId, CollectionIds = collectionIds.ToGuidIdArrayTVP() },
-                    commandType: CommandType.StoredProcedure);
-            }
+            var results = await connection.ExecuteAsync(
+                "[dbo].[CollectionCipher_UpdateCollections]",
+                new { CipherId = cipherId, UserId = userId, CollectionIds = collectionIds.ToGuidIdArrayTVP() },
+                commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public async Task UpdateCollectionsForAdminAsync(Guid cipherId, Guid organizationId, IEnumerable<Guid> collectionIds)
+    public async Task UpdateCollectionsForAdminAsync(Guid cipherId, Guid organizationId, IEnumerable<Guid> collectionIds)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    "[dbo].[CollectionCipher_UpdateCollectionsAdmin]",
-                    new { CipherId = cipherId, OrganizationId = organizationId, CollectionIds = collectionIds.ToGuidIdArrayTVP() },
-                    commandType: CommandType.StoredProcedure);
-            }
+            var results = await connection.ExecuteAsync(
+                "[dbo].[CollectionCipher_UpdateCollectionsAdmin]",
+                new { CipherId = cipherId, OrganizationId = organizationId, CollectionIds = collectionIds.ToGuidIdArrayTVP() },
+                commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public async Task UpdateCollectionsForCiphersAsync(IEnumerable<Guid> cipherIds, Guid userId,
-            Guid organizationId, IEnumerable<Guid> collectionIds)
+    public async Task UpdateCollectionsForCiphersAsync(IEnumerable<Guid> cipherIds, Guid userId,
+        Guid organizationId, IEnumerable<Guid> collectionIds)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    "[dbo].[CollectionCipher_UpdateCollectionsForCiphers]",
-                    new
-                    {
-                        CipherIds = cipherIds.ToGuidIdArrayTVP(),
-                        UserId = userId,
-                        OrganizationId = organizationId,
-                        CollectionIds = collectionIds.ToGuidIdArrayTVP()
-                    },
-                    commandType: CommandType.StoredProcedure);
-            }
+            var results = await connection.ExecuteAsync(
+                "[dbo].[CollectionCipher_UpdateCollectionsForCiphers]",
+                new
+                {
+                    CipherIds = cipherIds.ToGuidIdArrayTVP(),
+                    UserId = userId,
+                    OrganizationId = organizationId,
+                    CollectionIds = collectionIds.ToGuidIdArrayTVP()
+                },
+                commandType: CommandType.StoredProcedure);
         }
     }
 }

src/Infrastructure.Dapper/Repositories/CollectionRepository.cs

@@ -7,181 +7,180 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class CollectionRepository : Repository<Collection, Guid>, ICollectionRepository
 {
-    public class CollectionRepository : Repository<Collection, Guid>, ICollectionRepository
+    public CollectionRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public CollectionRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<int> GetCountByOrganizationIdAsync(Guid organizationId)
     {
-        public CollectionRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public CollectionRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<int> GetCountByOrganizationIdAsync(Guid organizationId)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteScalarAsync<int>(
-                    "[dbo].[Collection_ReadCountByOrganizationId]",
-                    new { OrganizationId = organizationId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.ExecuteScalarAsync<int>(
+                "[dbo].[Collection_ReadCountByOrganizationId]",
+                new { OrganizationId = organizationId },
+                commandType: CommandType.StoredProcedure);
 
-                return results;
-            }
-        }
-
-        public async Task<Tuple<Collection, ICollection<SelectionReadOnly>>> GetByIdWithGroupsAsync(Guid id)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryMultipleAsync(
-                    $"[{Schema}].[Collection_ReadWithGroupsById]",
-                    new { Id = id },
-                    commandType: CommandType.StoredProcedure);
-
-                var collection = await results.ReadFirstOrDefaultAsync<Collection>();
-                var groups = (await results.ReadAsync<SelectionReadOnly>()).ToList();
-
-                return new Tuple<Collection, ICollection<SelectionReadOnly>>(collection, groups);
-            }
-        }
-
-        public async Task<Tuple<CollectionDetails, ICollection<SelectionReadOnly>>> GetByIdWithGroupsAsync(
-            Guid id, Guid userId)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryMultipleAsync(
-                    $"[{Schema}].[Collection_ReadWithGroupsByIdUserId]",
-                    new { Id = id, UserId = userId },
-                    commandType: CommandType.StoredProcedure);
-
-                var collection = await results.ReadFirstOrDefaultAsync<CollectionDetails>();
-                var groups = (await results.ReadAsync<SelectionReadOnly>()).ToList();
-
-                return new Tuple<CollectionDetails, ICollection<SelectionReadOnly>>(collection, groups);
-            }
-        }
-
-        public async Task<ICollection<Collection>> GetManyByOrganizationIdAsync(Guid organizationId)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Collection>(
-                    $"[{Schema}].[{Table}_ReadByOrganizationId]",
-                    new { OrganizationId = organizationId },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.ToList();
-            }
-        }
-
-        public async Task<CollectionDetails> GetByIdAsync(Guid id, Guid userId)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<CollectionDetails>(
-                    $"[{Schema}].[Collection_ReadByIdUserId]",
-                    new { Id = id, UserId = userId },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.FirstOrDefault();
-            }
-        }
-
-        public async Task<ICollection<CollectionDetails>> GetManyByUserIdAsync(Guid userId)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<CollectionDetails>(
-                    $"[{Schema}].[Collection_ReadByUserId]",
-                    new { UserId = userId },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.ToList();
-            }
-        }
-
-        public async Task CreateAsync(Collection obj, IEnumerable<SelectionReadOnly> groups)
-        {
-            obj.SetNewId();
-            var objWithGroups = JsonSerializer.Deserialize<CollectionWithGroups>(JsonSerializer.Serialize(obj));
-            objWithGroups.Groups = groups.ToArrayTVP();
-
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[Collection_CreateWithGroups]",
-                    objWithGroups,
-                    commandType: CommandType.StoredProcedure);
-            }
-        }
-
-        public async Task ReplaceAsync(Collection obj, IEnumerable<SelectionReadOnly> groups)
-        {
-            var objWithGroups = JsonSerializer.Deserialize<CollectionWithGroups>(JsonSerializer.Serialize(obj));
-            objWithGroups.Groups = groups.ToArrayTVP();
-
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[Collection_UpdateWithGroups]",
-                    objWithGroups,
-                    commandType: CommandType.StoredProcedure);
-            }
-        }
-
-        public async Task CreateUserAsync(Guid collectionId, Guid organizationUserId)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[CollectionUser_Create]",
-                    new { CollectionId = collectionId, OrganizationUserId = organizationUserId },
-                    commandType: CommandType.StoredProcedure);
-            }
-        }
-
-        public async Task DeleteUserAsync(Guid collectionId, Guid organizationUserId)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[CollectionUser_Delete]",
-                    new { CollectionId = collectionId, OrganizationUserId = organizationUserId },
-                    commandType: CommandType.StoredProcedure);
-            }
-        }
-
-        public async Task UpdateUsersAsync(Guid id, IEnumerable<SelectionReadOnly> users)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[CollectionUser_UpdateUsers]",
-                    new { CollectionId = id, Users = users.ToArrayTVP() },
-                    commandType: CommandType.StoredProcedure);
-            }
-        }
-
-        public async Task<ICollection<SelectionReadOnly>> GetManyUsersByIdAsync(Guid id)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<SelectionReadOnly>(
-                    $"[{Schema}].[CollectionUser_ReadByCollectionId]",
-                    new { CollectionId = id },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.ToList();
-            }
-        }
-
-        public class CollectionWithGroups : Collection
-        {
-            public DataTable Groups { get; set; }
+            return results;
         }
     }
+
+    public async Task<Tuple<Collection, ICollection<SelectionReadOnly>>> GetByIdWithGroupsAsync(Guid id)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryMultipleAsync(
+                $"[{Schema}].[Collection_ReadWithGroupsById]",
+                new { Id = id },
+                commandType: CommandType.StoredProcedure);
+
+            var collection = await results.ReadFirstOrDefaultAsync<Collection>();
+            var groups = (await results.ReadAsync<SelectionReadOnly>()).ToList();
+
+            return new Tuple<Collection, ICollection<SelectionReadOnly>>(collection, groups);
+        }
+    }
+
+    public async Task<Tuple<CollectionDetails, ICollection<SelectionReadOnly>>> GetByIdWithGroupsAsync(
+        Guid id, Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryMultipleAsync(
+                $"[{Schema}].[Collection_ReadWithGroupsByIdUserId]",
+                new { Id = id, UserId = userId },
+                commandType: CommandType.StoredProcedure);
+
+            var collection = await results.ReadFirstOrDefaultAsync<CollectionDetails>();
+            var groups = (await results.ReadAsync<SelectionReadOnly>()).ToList();
+
+            return new Tuple<CollectionDetails, ICollection<SelectionReadOnly>>(collection, groups);
+        }
+    }
+
+    public async Task<ICollection<Collection>> GetManyByOrganizationIdAsync(Guid organizationId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<Collection>(
+                $"[{Schema}].[{Table}_ReadByOrganizationId]",
+                new { OrganizationId = organizationId },
+                commandType: CommandType.StoredProcedure);
+
+            return results.ToList();
+        }
+    }
+
+    public async Task<CollectionDetails> GetByIdAsync(Guid id, Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<CollectionDetails>(
+                $"[{Schema}].[Collection_ReadByIdUserId]",
+                new { Id = id, UserId = userId },
+                commandType: CommandType.StoredProcedure);
+
+            return results.FirstOrDefault();
+        }
+    }
+
+    public async Task<ICollection<CollectionDetails>> GetManyByUserIdAsync(Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<CollectionDetails>(
+                $"[{Schema}].[Collection_ReadByUserId]",
+                new { UserId = userId },
+                commandType: CommandType.StoredProcedure);
+
+            return results.ToList();
+        }
+    }
+
+    public async Task CreateAsync(Collection obj, IEnumerable<SelectionReadOnly> groups)
+    {
+        obj.SetNewId();
+        var objWithGroups = JsonSerializer.Deserialize<CollectionWithGroups>(JsonSerializer.Serialize(obj));
+        objWithGroups.Groups = groups.ToArrayTVP();
+
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[Collection_CreateWithGroups]",
+                objWithGroups,
+                commandType: CommandType.StoredProcedure);
+        }
+    }
+
+    public async Task ReplaceAsync(Collection obj, IEnumerable<SelectionReadOnly> groups)
+    {
+        var objWithGroups = JsonSerializer.Deserialize<CollectionWithGroups>(JsonSerializer.Serialize(obj));
+        objWithGroups.Groups = groups.ToArrayTVP();
+
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[Collection_UpdateWithGroups]",
+                objWithGroups,
+                commandType: CommandType.StoredProcedure);
+        }
+    }
+
+    public async Task CreateUserAsync(Guid collectionId, Guid organizationUserId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[CollectionUser_Create]",
+                new { CollectionId = collectionId, OrganizationUserId = organizationUserId },
+                commandType: CommandType.StoredProcedure);
+        }
+    }
+
+    public async Task DeleteUserAsync(Guid collectionId, Guid organizationUserId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[CollectionUser_Delete]",
+                new { CollectionId = collectionId, OrganizationUserId = organizationUserId },
+                commandType: CommandType.StoredProcedure);
+        }
+    }
+
+    public async Task UpdateUsersAsync(Guid id, IEnumerable<SelectionReadOnly> users)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[CollectionUser_UpdateUsers]",
+                new { CollectionId = id, Users = users.ToArrayTVP() },
+                commandType: CommandType.StoredProcedure);
+        }
+    }
+
+    public async Task<ICollection<SelectionReadOnly>> GetManyUsersByIdAsync(Guid id)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<SelectionReadOnly>(
+                $"[{Schema}].[CollectionUser_ReadByCollectionId]",
+                new { CollectionId = id },
+                commandType: CommandType.StoredProcedure);
+
+            return results.ToList();
+        }
+    }
+
+    public class CollectionWithGroups : Collection
+    {
+        public DataTable Groups { get; set; }
+    }
 }

src/Infrastructure.Dapper/Repositories/DateTimeHandler.cs

@@ -1,18 +1,17 @@
 using System.Data;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
-{
-    public class DateTimeHandler : SqlMapper.TypeHandler<DateTime>
-    {
-        public override void SetValue(IDbDataParameter parameter, DateTime value)
-        {
-            parameter.Value = value;
-        }
+namespace Bit.Infrastructure.Dapper.Repositories;
 
-        public override DateTime Parse(object value)
-        {
-            return DateTime.SpecifyKind((DateTime)value, DateTimeKind.Utc);
-        }
+public class DateTimeHandler : SqlMapper.TypeHandler<DateTime>
+{
+    public override void SetValue(IDbDataParameter parameter, DateTime value)
+    {
+        parameter.Value = value;
+    }
+
+    public override DateTime Parse(object value)
+    {
+        return DateTime.SpecifyKind((DateTime)value, DateTimeKind.Utc);
     }
 }

src/Infrastructure.Dapper/Repositories/DeviceRepository.cs

@@ -5,84 +5,83 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class DeviceRepository : Repository<Device, Guid>, IDeviceRepository
 {
-    public class DeviceRepository : Repository<Device, Guid>, IDeviceRepository
+    public DeviceRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public DeviceRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<Device> GetByIdAsync(Guid id, Guid userId)
     {
-        public DeviceRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public DeviceRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<Device> GetByIdAsync(Guid id, Guid userId)
+        var device = await GetByIdAsync(id);
+        if (device == null || device.UserId != userId)
         {
-            var device = await GetByIdAsync(id);
-            if (device == null || device.UserId != userId)
-            {
-                return null;
-            }
-
-            return device;
+            return null;
         }
 
-        public async Task<Device> GetByIdentifierAsync(string identifier)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Device>(
-                    $"[{Schema}].[{Table}_ReadByIdentifier]",
-                    new
-                    {
-                        Identifier = identifier
-                    },
-                    commandType: CommandType.StoredProcedure);
+        return device;
+    }
 
-                return results.FirstOrDefault();
-            }
+    public async Task<Device> GetByIdentifierAsync(string identifier)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<Device>(
+                $"[{Schema}].[{Table}_ReadByIdentifier]",
+                new
+                {
+                    Identifier = identifier
+                },
+                commandType: CommandType.StoredProcedure);
+
+            return results.FirstOrDefault();
         }
+    }
 
-        public async Task<Device> GetByIdentifierAsync(string identifier, Guid userId)
+    public async Task<Device> GetByIdentifierAsync(string identifier, Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Device>(
-                    $"[{Schema}].[{Table}_ReadByIdentifierUserId]",
-                    new
-                    {
-                        UserId = userId,
-                        Identifier = identifier
-                    },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Device>(
+                $"[{Schema}].[{Table}_ReadByIdentifierUserId]",
+                new
+                {
+                    UserId = userId,
+                    Identifier = identifier
+                },
+                commandType: CommandType.StoredProcedure);
 
-                return results.FirstOrDefault();
-            }
+            return results.FirstOrDefault();
         }
+    }
 
-        public async Task<ICollection<Device>> GetManyByUserIdAsync(Guid userId)
+    public async Task<ICollection<Device>> GetManyByUserIdAsync(Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Device>(
-                    $"[{Schema}].[{Table}_ReadByUserId]",
-                    new { UserId = userId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Device>(
+                $"[{Schema}].[{Table}_ReadByUserId]",
+                new { UserId = userId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task ClearPushTokenAsync(Guid id)
+    public async Task ClearPushTokenAsync(Guid id)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync(
-                    $"[{Schema}].[{Table}_ClearPushTokenById]",
-                    new { Id = id },
-                    commandType: CommandType.StoredProcedure);
-            }
+            await connection.ExecuteAsync(
+                $"[{Schema}].[{Table}_ClearPushTokenById]",
+                new { Id = id },
+                commandType: CommandType.StoredProcedure);
         }
     }
 }

src/Infrastructure.Dapper/Repositories/EmergencyAccessRepository.cs

@@ -6,92 +6,91 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class EmergencyAccessRepository : Repository<EmergencyAccess, Guid>, IEmergencyAccessRepository
 {
-    public class EmergencyAccessRepository : Repository<EmergencyAccess, Guid>, IEmergencyAccessRepository
+    public EmergencyAccessRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public EmergencyAccessRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<int> GetCountByGrantorIdEmailAsync(Guid grantorId, string email, bool onlyRegisteredUsers)
     {
-        public EmergencyAccessRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public EmergencyAccessRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<int> GetCountByGrantorIdEmailAsync(Guid grantorId, string email, bool onlyRegisteredUsers)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteScalarAsync<int>(
-                    "[dbo].[EmergencyAccess_ReadCountByGrantorIdEmail]",
-                    new { GrantorId = grantorId, Email = email, OnlyUsers = onlyRegisteredUsers },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.ExecuteScalarAsync<int>(
+                "[dbo].[EmergencyAccess_ReadCountByGrantorIdEmail]",
+                new { GrantorId = grantorId, Email = email, OnlyUsers = onlyRegisteredUsers },
+                commandType: CommandType.StoredProcedure);
 
-                return results;
-            }
+            return results;
         }
+    }
 
-        public async Task<ICollection<EmergencyAccessDetails>> GetManyDetailsByGrantorIdAsync(Guid grantorId)
+    public async Task<ICollection<EmergencyAccessDetails>> GetManyDetailsByGrantorIdAsync(Guid grantorId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<EmergencyAccessDetails>(
-                    "[dbo].[EmergencyAccessDetails_ReadByGrantorId]",
-                    new { GrantorId = grantorId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<EmergencyAccessDetails>(
+                "[dbo].[EmergencyAccessDetails_ReadByGrantorId]",
+                new { GrantorId = grantorId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<EmergencyAccessDetails>> GetManyDetailsByGranteeIdAsync(Guid granteeId)
+    public async Task<ICollection<EmergencyAccessDetails>> GetManyDetailsByGranteeIdAsync(Guid granteeId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<EmergencyAccessDetails>(
-                    "[dbo].[EmergencyAccessDetails_ReadByGranteeId]",
-                    new { GranteeId = granteeId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<EmergencyAccessDetails>(
+                "[dbo].[EmergencyAccessDetails_ReadByGranteeId]",
+                new { GranteeId = granteeId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<EmergencyAccessDetails> GetDetailsByIdGrantorIdAsync(Guid id, Guid grantorId)
+    public async Task<EmergencyAccessDetails> GetDetailsByIdGrantorIdAsync(Guid id, Guid grantorId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<EmergencyAccessDetails>(
-                    "[dbo].[EmergencyAccessDetails_ReadByIdGrantorId]",
-                    new { Id = id, GrantorId = grantorId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<EmergencyAccessDetails>(
+                "[dbo].[EmergencyAccessDetails_ReadByIdGrantorId]",
+                new { Id = id, GrantorId = grantorId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.FirstOrDefault();
-            }
+            return results.FirstOrDefault();
         }
+    }
 
-        public async Task<ICollection<EmergencyAccessNotify>> GetManyToNotifyAsync()
+    public async Task<ICollection<EmergencyAccessNotify>> GetManyToNotifyAsync()
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<EmergencyAccessNotify>(
-                    "[dbo].[EmergencyAccess_ReadToNotify]",
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<EmergencyAccessNotify>(
+                "[dbo].[EmergencyAccess_ReadToNotify]",
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<EmergencyAccessDetails>> GetExpiredRecoveriesAsync()
+    public async Task<ICollection<EmergencyAccessDetails>> GetExpiredRecoveriesAsync()
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<EmergencyAccessDetails>(
-                    "[dbo].[EmergencyAccessDetails_ReadExpiredRecoveries]",
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<EmergencyAccessDetails>(
+                "[dbo].[EmergencyAccessDetails_ReadExpiredRecoveries]",
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
     }
 }

src/Infrastructure.Dapper/Repositories/EventRepository.cs

@@ -6,221 +6,220 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class EventRepository : Repository<Event, Guid>, IEventRepository
 {
-    public class EventRepository : Repository<Event, Guid>, IEventRepository
+    public EventRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public EventRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<PagedResult<IEvent>> GetManyByUserAsync(Guid userId, DateTime startDate, DateTime endDate,
+        PageOptions pageOptions)
     {
-        public EventRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
+        return await GetManyAsync($"[{Schema}].[Event_ReadPageByUserId]",
+            new Dictionary<string, object>
+            {
+                ["@UserId"] = userId
+            }, startDate, endDate, pageOptions);
+    }
 
-        public EventRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
+    public async Task<PagedResult<IEvent>> GetManyByOrganizationAsync(Guid organizationId,
+        DateTime startDate, DateTime endDate, PageOptions pageOptions)
+    {
+        return await GetManyAsync($"[{Schema}].[Event_ReadPageByOrganizationId]",
+            new Dictionary<string, object>
+            {
+                ["@OrganizationId"] = organizationId
+            }, startDate, endDate, pageOptions);
+    }
 
-        public async Task<PagedResult<IEvent>> GetManyByUserAsync(Guid userId, DateTime startDate, DateTime endDate,
-            PageOptions pageOptions)
+    public async Task<PagedResult<IEvent>> GetManyByOrganizationActingUserAsync(Guid organizationId, Guid actingUserId,
+        DateTime startDate, DateTime endDate, PageOptions pageOptions)
+    {
+        return await GetManyAsync($"[{Schema}].[Event_ReadPageByOrganizationIdActingUserId]",
+            new Dictionary<string, object>
+            {
+                ["@OrganizationId"] = organizationId,
+                ["@ActingUserId"] = actingUserId
+            }, startDate, endDate, pageOptions);
+    }
+
+    public async Task<PagedResult<IEvent>> GetManyByProviderAsync(Guid providerId,
+        DateTime startDate, DateTime endDate, PageOptions pageOptions)
+    {
+        return await GetManyAsync($"[{Schema}].[Event_ReadPageByProviderId]",
+            new Dictionary<string, object>
+            {
+                ["@ProviderId"] = providerId
+            }, startDate, endDate, pageOptions);
+    }
+
+    public async Task<PagedResult<IEvent>> GetManyByProviderActingUserAsync(Guid providerId, Guid actingUserId,
+        DateTime startDate, DateTime endDate, PageOptions pageOptions)
+    {
+        return await GetManyAsync($"[{Schema}].[Event_ReadPageByProviderIdActingUserId]",
+            new Dictionary<string, object>
+            {
+                ["@ProviderId"] = providerId,
+                ["@ActingUserId"] = actingUserId
+            }, startDate, endDate, pageOptions);
+    }
+
+    public async Task<PagedResult<IEvent>> GetManyByCipherAsync(Cipher cipher, DateTime startDate, DateTime endDate,
+        PageOptions pageOptions)
+    {
+        return await GetManyAsync($"[{Schema}].[Event_ReadPageByCipherId]",
+            new Dictionary<string, object>
+            {
+                ["@OrganizationId"] = cipher.OrganizationId,
+                ["@UserId"] = cipher.UserId,
+                ["@CipherId"] = cipher.Id
+            }, startDate, endDate, pageOptions);
+    }
+
+    public async Task CreateAsync(IEvent e)
+    {
+        if (!(e is Event ev))
         {
-            return await GetManyAsync($"[{Schema}].[Event_ReadPageByUserId]",
-                new Dictionary<string, object>
-                {
-                    ["@UserId"] = userId
-                }, startDate, endDate, pageOptions);
+            ev = new Event(e);
         }
 
-        public async Task<PagedResult<IEvent>> GetManyByOrganizationAsync(Guid organizationId,
-            DateTime startDate, DateTime endDate, PageOptions pageOptions)
+        await base.CreateAsync(ev);
+    }
+
+    public async Task CreateManyAsync(IEnumerable<IEvent> entities)
+    {
+        if (!entities?.Any() ?? true)
         {
-            return await GetManyAsync($"[{Schema}].[Event_ReadPageByOrganizationId]",
-                new Dictionary<string, object>
-                {
-                    ["@OrganizationId"] = organizationId
-                }, startDate, endDate, pageOptions);
+            return;
         }
 
-        public async Task<PagedResult<IEvent>> GetManyByOrganizationActingUserAsync(Guid organizationId, Guid actingUserId,
-            DateTime startDate, DateTime endDate, PageOptions pageOptions)
+        if (!entities.Skip(1).Any())
         {
-            return await GetManyAsync($"[{Schema}].[Event_ReadPageByOrganizationIdActingUserId]",
-                new Dictionary<string, object>
-                {
-                    ["@OrganizationId"] = organizationId,
-                    ["@ActingUserId"] = actingUserId
-                }, startDate, endDate, pageOptions);
+            await CreateAsync(entities.First());
+            return;
         }
 
-        public async Task<PagedResult<IEvent>> GetManyByProviderAsync(Guid providerId,
-            DateTime startDate, DateTime endDate, PageOptions pageOptions)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            return await GetManyAsync($"[{Schema}].[Event_ReadPageByProviderId]",
-                new Dictionary<string, object>
-                {
-                    ["@ProviderId"] = providerId
-                }, startDate, endDate, pageOptions);
-        }
-
-        public async Task<PagedResult<IEvent>> GetManyByProviderActingUserAsync(Guid providerId, Guid actingUserId,
-            DateTime startDate, DateTime endDate, PageOptions pageOptions)
-        {
-            return await GetManyAsync($"[{Schema}].[Event_ReadPageByProviderIdActingUserId]",
-                new Dictionary<string, object>
-                {
-                    ["@ProviderId"] = providerId,
-                    ["@ActingUserId"] = actingUserId
-                }, startDate, endDate, pageOptions);
-        }
-
-        public async Task<PagedResult<IEvent>> GetManyByCipherAsync(Cipher cipher, DateTime startDate, DateTime endDate,
-            PageOptions pageOptions)
-        {
-            return await GetManyAsync($"[{Schema}].[Event_ReadPageByCipherId]",
-                new Dictionary<string, object>
-                {
-                    ["@OrganizationId"] = cipher.OrganizationId,
-                    ["@UserId"] = cipher.UserId,
-                    ["@CipherId"] = cipher.Id
-                }, startDate, endDate, pageOptions);
-        }
-
-        public async Task CreateAsync(IEvent e)
-        {
-            if (!(e is Event ev))
+            connection.Open();
+            using (var bulkCopy = new SqlBulkCopy(connection, SqlBulkCopyOptions.KeepIdentity, null))
             {
-                ev = new Event(e);
+                bulkCopy.DestinationTableName = "[dbo].[Event]";
+                var dataTable = BuildEventsTable(bulkCopy, entities.Select(e => e is Event ? e as Event : new Event(e)));
+                await bulkCopy.WriteToServerAsync(dataTable);
             }
-
-            await base.CreateAsync(ev);
-        }
-
-        public async Task CreateManyAsync(IEnumerable<IEvent> entities)
-        {
-            if (!entities?.Any() ?? true)
-            {
-                return;
-            }
-
-            if (!entities.Skip(1).Any())
-            {
-                await CreateAsync(entities.First());
-                return;
-            }
-
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                connection.Open();
-                using (var bulkCopy = new SqlBulkCopy(connection, SqlBulkCopyOptions.KeepIdentity, null))
-                {
-                    bulkCopy.DestinationTableName = "[dbo].[Event]";
-                    var dataTable = BuildEventsTable(bulkCopy, entities.Select(e => e is Event ? e as Event : new Event(e)));
-                    await bulkCopy.WriteToServerAsync(dataTable);
-                }
-            }
-        }
-
-        private async Task<PagedResult<IEvent>> GetManyAsync(string sprocName,
-            IDictionary<string, object> sprocParams, DateTime startDate, DateTime endDate, PageOptions pageOptions)
-        {
-            DateTime? beforeDate = null;
-            if (!string.IsNullOrWhiteSpace(pageOptions.ContinuationToken) &&
-                long.TryParse(pageOptions.ContinuationToken, out var binaryDate))
-            {
-                beforeDate = DateTime.SpecifyKind(DateTime.FromBinary(binaryDate), DateTimeKind.Utc);
-            }
-
-            var parameters = new DynamicParameters(sprocParams);
-            parameters.Add("@PageSize", pageOptions.PageSize, DbType.Int32);
-            // Explicitly use DbType.DateTime2 for proper precision.
-            // ref: https://github.com/StackExchange/Dapper/issues/229
-            parameters.Add("@StartDate", startDate.ToUniversalTime(), DbType.DateTime2, null, 7);
-            parameters.Add("@EndDate", endDate.ToUniversalTime(), DbType.DateTime2, null, 7);
-            parameters.Add("@BeforeDate", beforeDate, DbType.DateTime2, null, 7);
-
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var events = (await connection.QueryAsync<Event>(sprocName, parameters,
-                    commandType: CommandType.StoredProcedure)).ToList();
-
-                var result = new PagedResult<IEvent>();
-                if (events.Any() && events.Count >= pageOptions.PageSize)
-                {
-                    result.ContinuationToken = events.Last().Date.ToBinary().ToString();
-                }
-                result.Data.AddRange(events);
-                return result;
-            }
-        }
-
-        private DataTable BuildEventsTable(SqlBulkCopy bulkCopy, IEnumerable<Event> events)
-        {
-            var e = events.FirstOrDefault();
-            if (e == null)
-            {
-                throw new ApplicationException("Must have some events to bulk import.");
-            }
-
-            var eventsTable = new DataTable("EventDataTable");
-
-            var idColumn = new DataColumn(nameof(e.Id), e.Id.GetType());
-            eventsTable.Columns.Add(idColumn);
-            var typeColumn = new DataColumn(nameof(e.Type), typeof(int));
-            eventsTable.Columns.Add(typeColumn);
-            var userIdColumn = new DataColumn(nameof(e.UserId), typeof(Guid));
-            eventsTable.Columns.Add(userIdColumn);
-            var organizationIdColumn = new DataColumn(nameof(e.OrganizationId), typeof(Guid));
-            eventsTable.Columns.Add(organizationIdColumn);
-            var cipherIdColumn = new DataColumn(nameof(e.CipherId), typeof(Guid));
-            eventsTable.Columns.Add(cipherIdColumn);
-            var collectionIdColumn = new DataColumn(nameof(e.CollectionId), typeof(Guid));
-            eventsTable.Columns.Add(collectionIdColumn);
-            var policyIdColumn = new DataColumn(nameof(e.PolicyId), typeof(Guid));
-            eventsTable.Columns.Add(policyIdColumn);
-            var groupIdColumn = new DataColumn(nameof(e.GroupId), typeof(Guid));
-            eventsTable.Columns.Add(groupIdColumn);
-            var organizationUserIdColumn = new DataColumn(nameof(e.OrganizationUserId), typeof(Guid));
-            eventsTable.Columns.Add(organizationUserIdColumn);
-            var actingUserIdColumn = new DataColumn(nameof(e.ActingUserId), typeof(Guid));
-            eventsTable.Columns.Add(actingUserIdColumn);
-            var deviceTypeColumn = new DataColumn(nameof(e.DeviceType), typeof(int));
-            eventsTable.Columns.Add(deviceTypeColumn);
-            var ipAddressColumn = new DataColumn(nameof(e.IpAddress), typeof(string));
-            eventsTable.Columns.Add(ipAddressColumn);
-            var dateColumn = new DataColumn(nameof(e.Date), typeof(DateTime));
-            eventsTable.Columns.Add(dateColumn);
-
-            foreach (DataColumn col in eventsTable.Columns)
-            {
-                bulkCopy.ColumnMappings.Add(col.ColumnName, col.ColumnName);
-            }
-
-            var keys = new DataColumn[1];
-            keys[0] = idColumn;
-            eventsTable.PrimaryKey = keys;
-
-            foreach (var ev in events)
-            {
-                ev.SetNewId();
-
-                var row = eventsTable.NewRow();
-
-                row[idColumn] = ev.Id;
-                row[typeColumn] = (int)ev.Type;
-                row[userIdColumn] = ev.UserId.HasValue ? (object)ev.UserId.Value : DBNull.Value;
-                row[organizationIdColumn] = ev.OrganizationId.HasValue ? (object)ev.OrganizationId.Value : DBNull.Value;
-                row[cipherIdColumn] = ev.CipherId.HasValue ? (object)ev.CipherId.Value : DBNull.Value;
-                row[collectionIdColumn] = ev.CollectionId.HasValue ? (object)ev.CollectionId.Value : DBNull.Value;
-                row[policyIdColumn] = ev.PolicyId.HasValue ? (object)ev.PolicyId.Value : DBNull.Value;
-                row[groupIdColumn] = ev.GroupId.HasValue ? (object)ev.GroupId.Value : DBNull.Value;
-                row[organizationUserIdColumn] = ev.OrganizationUserId.HasValue ?
-                    (object)ev.OrganizationUserId.Value : DBNull.Value;
-                row[actingUserIdColumn] = ev.ActingUserId.HasValue ? (object)ev.ActingUserId.Value : DBNull.Value;
-                row[deviceTypeColumn] = ev.DeviceType.HasValue ? (object)ev.DeviceType.Value : DBNull.Value;
-                row[ipAddressColumn] = ev.IpAddress != null ? (object)ev.IpAddress : DBNull.Value;
-                row[dateColumn] = ev.Date;
-
-                eventsTable.Rows.Add(row);
-            }
-
-            return eventsTable;
         }
     }
+
+    private async Task<PagedResult<IEvent>> GetManyAsync(string sprocName,
+        IDictionary<string, object> sprocParams, DateTime startDate, DateTime endDate, PageOptions pageOptions)
+    {
+        DateTime? beforeDate = null;
+        if (!string.IsNullOrWhiteSpace(pageOptions.ContinuationToken) &&
+            long.TryParse(pageOptions.ContinuationToken, out var binaryDate))
+        {
+            beforeDate = DateTime.SpecifyKind(DateTime.FromBinary(binaryDate), DateTimeKind.Utc);
+        }
+
+        var parameters = new DynamicParameters(sprocParams);
+        parameters.Add("@PageSize", pageOptions.PageSize, DbType.Int32);
+        // Explicitly use DbType.DateTime2 for proper precision.
+        // ref: https://github.com/StackExchange/Dapper/issues/229
+        parameters.Add("@StartDate", startDate.ToUniversalTime(), DbType.DateTime2, null, 7);
+        parameters.Add("@EndDate", endDate.ToUniversalTime(), DbType.DateTime2, null, 7);
+        parameters.Add("@BeforeDate", beforeDate, DbType.DateTime2, null, 7);
+
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var events = (await connection.QueryAsync<Event>(sprocName, parameters,
+                commandType: CommandType.StoredProcedure)).ToList();
+
+            var result = new PagedResult<IEvent>();
+            if (events.Any() && events.Count >= pageOptions.PageSize)
+            {
+                result.ContinuationToken = events.Last().Date.ToBinary().ToString();
+            }
+            result.Data.AddRange(events);
+            return result;
+        }
+    }
+
+    private DataTable BuildEventsTable(SqlBulkCopy bulkCopy, IEnumerable<Event> events)
+    {
+        var e = events.FirstOrDefault();
+        if (e == null)
+        {
+            throw new ApplicationException("Must have some events to bulk import.");
+        }
+
+        var eventsTable = new DataTable("EventDataTable");
+
+        var idColumn = new DataColumn(nameof(e.Id), e.Id.GetType());
+        eventsTable.Columns.Add(idColumn);
+        var typeColumn = new DataColumn(nameof(e.Type), typeof(int));
+        eventsTable.Columns.Add(typeColumn);
+        var userIdColumn = new DataColumn(nameof(e.UserId), typeof(Guid));
+        eventsTable.Columns.Add(userIdColumn);
+        var organizationIdColumn = new DataColumn(nameof(e.OrganizationId), typeof(Guid));
+        eventsTable.Columns.Add(organizationIdColumn);
+        var cipherIdColumn = new DataColumn(nameof(e.CipherId), typeof(Guid));
+        eventsTable.Columns.Add(cipherIdColumn);
+        var collectionIdColumn = new DataColumn(nameof(e.CollectionId), typeof(Guid));
+        eventsTable.Columns.Add(collectionIdColumn);
+        var policyIdColumn = new DataColumn(nameof(e.PolicyId), typeof(Guid));
+        eventsTable.Columns.Add(policyIdColumn);
+        var groupIdColumn = new DataColumn(nameof(e.GroupId), typeof(Guid));
+        eventsTable.Columns.Add(groupIdColumn);
+        var organizationUserIdColumn = new DataColumn(nameof(e.OrganizationUserId), typeof(Guid));
+        eventsTable.Columns.Add(organizationUserIdColumn);
+        var actingUserIdColumn = new DataColumn(nameof(e.ActingUserId), typeof(Guid));
+        eventsTable.Columns.Add(actingUserIdColumn);
+        var deviceTypeColumn = new DataColumn(nameof(e.DeviceType), typeof(int));
+        eventsTable.Columns.Add(deviceTypeColumn);
+        var ipAddressColumn = new DataColumn(nameof(e.IpAddress), typeof(string));
+        eventsTable.Columns.Add(ipAddressColumn);
+        var dateColumn = new DataColumn(nameof(e.Date), typeof(DateTime));
+        eventsTable.Columns.Add(dateColumn);
+
+        foreach (DataColumn col in eventsTable.Columns)
+        {
+            bulkCopy.ColumnMappings.Add(col.ColumnName, col.ColumnName);
+        }
+
+        var keys = new DataColumn[1];
+        keys[0] = idColumn;
+        eventsTable.PrimaryKey = keys;
+
+        foreach (var ev in events)
+        {
+            ev.SetNewId();
+
+            var row = eventsTable.NewRow();
+
+            row[idColumn] = ev.Id;
+            row[typeColumn] = (int)ev.Type;
+            row[userIdColumn] = ev.UserId.HasValue ? (object)ev.UserId.Value : DBNull.Value;
+            row[organizationIdColumn] = ev.OrganizationId.HasValue ? (object)ev.OrganizationId.Value : DBNull.Value;
+            row[cipherIdColumn] = ev.CipherId.HasValue ? (object)ev.CipherId.Value : DBNull.Value;
+            row[collectionIdColumn] = ev.CollectionId.HasValue ? (object)ev.CollectionId.Value : DBNull.Value;
+            row[policyIdColumn] = ev.PolicyId.HasValue ? (object)ev.PolicyId.Value : DBNull.Value;
+            row[groupIdColumn] = ev.GroupId.HasValue ? (object)ev.GroupId.Value : DBNull.Value;
+            row[organizationUserIdColumn] = ev.OrganizationUserId.HasValue ?
+                (object)ev.OrganizationUserId.Value : DBNull.Value;
+            row[actingUserIdColumn] = ev.ActingUserId.HasValue ? (object)ev.ActingUserId.Value : DBNull.Value;
+            row[deviceTypeColumn] = ev.DeviceType.HasValue ? (object)ev.DeviceType.Value : DBNull.Value;
+            row[ipAddressColumn] = ev.IpAddress != null ? (object)ev.IpAddress : DBNull.Value;
+            row[dateColumn] = ev.Date;
+
+            eventsTable.Rows.Add(row);
+        }
+
+        return eventsTable;
+    }
 }

src/Infrastructure.Dapper/Repositories/FolderRepository.cs

@@ -5,40 +5,39 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class FolderRepository : Repository<Folder, Guid>, IFolderRepository
 {
-    public class FolderRepository : Repository<Folder, Guid>, IFolderRepository
+    public FolderRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public FolderRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<Folder> GetByIdAsync(Guid id, Guid userId)
     {
-        public FolderRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public FolderRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<Folder> GetByIdAsync(Guid id, Guid userId)
+        var folder = await GetByIdAsync(id);
+        if (folder == null || folder.UserId != userId)
         {
-            var folder = await GetByIdAsync(id);
-            if (folder == null || folder.UserId != userId)
-            {
-                return null;
-            }
-
-            return folder;
+            return null;
         }
 
-        public async Task<ICollection<Folder>> GetManyByUserIdAsync(Guid userId)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Folder>(
-                    $"[{Schema}].[Folder_ReadByUserId]",
-                    new { UserId = userId },
-                    commandType: CommandType.StoredProcedure);
+        return folder;
+    }
 
-                return results.ToList();
-            }
+    public async Task<ICollection<Folder>> GetManyByUserIdAsync(Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<Folder>(
+                $"[{Schema}].[Folder_ReadByUserId]",
+                new { UserId = userId },
+                commandType: CommandType.StoredProcedure);
+
+            return results.ToList();
         }
     }
 }

src/Infrastructure.Dapper/Repositories/GrantRepository.cs

@@ -5,76 +5,75 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class GrantRepository : BaseRepository, IGrantRepository
 {
-    public class GrantRepository : BaseRepository, IGrantRepository
+    public GrantRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public GrantRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<Grant> GetByKeyAsync(string key)
     {
-        public GrantRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public GrantRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<Grant> GetByKeyAsync(string key)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Grant>(
-                    "[dbo].[Grant_ReadByKey]",
-                    new { Key = key },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Grant>(
+                "[dbo].[Grant_ReadByKey]",
+                new { Key = key },
+                commandType: CommandType.StoredProcedure);
 
-                return results.SingleOrDefault();
-            }
+            return results.SingleOrDefault();
         }
+    }
 
-        public async Task<ICollection<Grant>> GetManyAsync(string subjectId, string sessionId,
-            string clientId, string type)
+    public async Task<ICollection<Grant>> GetManyAsync(string subjectId, string sessionId,
+        string clientId, string type)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Grant>(
-                    "[dbo].[Grant_Read]",
-                    new { SubjectId = subjectId, SessionId = sessionId, ClientId = clientId, Type = type },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Grant>(
+                "[dbo].[Grant_Read]",
+                new { SubjectId = subjectId, SessionId = sessionId, ClientId = clientId, Type = type },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task SaveAsync(Grant obj)
+    public async Task SaveAsync(Grant obj)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    "[dbo].[Grant_Save]",
-                    obj,
-                    commandType: CommandType.StoredProcedure);
-            }
+            var results = await connection.ExecuteAsync(
+                "[dbo].[Grant_Save]",
+                obj,
+                commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public async Task DeleteByKeyAsync(string key)
+    public async Task DeleteByKeyAsync(string key)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync(
-                    "[dbo].[Grant_DeleteByKey]",
-                    new { Key = key },
-                    commandType: CommandType.StoredProcedure);
-            }
+            await connection.ExecuteAsync(
+                "[dbo].[Grant_DeleteByKey]",
+                new { Key = key },
+                commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public async Task DeleteManyAsync(string subjectId, string sessionId, string clientId, string type)
+    public async Task DeleteManyAsync(string subjectId, string sessionId, string clientId, string type)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync(
-                    "[dbo].[Grant_Delete]",
-                    new { SubjectId = subjectId, SessionId = sessionId, ClientId = clientId, Type = type },
-                    commandType: CommandType.StoredProcedure);
-            }
+            await connection.ExecuteAsync(
+                "[dbo].[Grant_Delete]",
+                new { SubjectId = subjectId, SessionId = sessionId, ClientId = clientId, Type = type },
+                commandType: CommandType.StoredProcedure);
         }
     }
 }

src/Infrastructure.Dapper/Repositories/GroupRepository.cs

@@ -7,135 +7,134 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class GroupRepository : Repository<Group, Guid>, IGroupRepository
 {
-    public class GroupRepository : Repository<Group, Guid>, IGroupRepository
+    public GroupRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public GroupRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<Tuple<Group, ICollection<SelectionReadOnly>>> GetByIdWithCollectionsAsync(Guid id)
     {
-        public GroupRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public GroupRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<Tuple<Group, ICollection<SelectionReadOnly>>> GetByIdWithCollectionsAsync(Guid id)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryMultipleAsync(
-                    $"[{Schema}].[Group_ReadWithCollectionsById]",
-                    new { Id = id },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryMultipleAsync(
+                $"[{Schema}].[Group_ReadWithCollectionsById]",
+                new { Id = id },
+                commandType: CommandType.StoredProcedure);
 
-                var group = await results.ReadFirstOrDefaultAsync<Group>();
-                var colletions = (await results.ReadAsync<SelectionReadOnly>()).ToList();
+            var group = await results.ReadFirstOrDefaultAsync<Group>();
+            var colletions = (await results.ReadAsync<SelectionReadOnly>()).ToList();
 
-                return new Tuple<Group, ICollection<SelectionReadOnly>>(group, colletions);
-            }
+            return new Tuple<Group, ICollection<SelectionReadOnly>>(group, colletions);
         }
+    }
 
-        public async Task<ICollection<Group>> GetManyByOrganizationIdAsync(Guid organizationId)
+    public async Task<ICollection<Group>> GetManyByOrganizationIdAsync(Guid organizationId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Group>(
-                    $"[{Schema}].[Group_ReadByOrganizationId]",
-                    new { OrganizationId = organizationId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Group>(
+                $"[{Schema}].[Group_ReadByOrganizationId]",
+                new { OrganizationId = organizationId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<Guid>> GetManyIdsByUserIdAsync(Guid organizationUserId)
+    public async Task<ICollection<Guid>> GetManyIdsByUserIdAsync(Guid organizationUserId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Guid>(
-                    $"[{Schema}].[GroupUser_ReadGroupIdsByOrganizationUserId]",
-                    new { OrganizationUserId = organizationUserId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Guid>(
+                $"[{Schema}].[GroupUser_ReadGroupIdsByOrganizationUserId]",
+                new { OrganizationUserId = organizationUserId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<Guid>> GetManyUserIdsByIdAsync(Guid id)
+    public async Task<ICollection<Guid>> GetManyUserIdsByIdAsync(Guid id)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Guid>(
-                    $"[{Schema}].[GroupUser_ReadOrganizationUserIdsByGroupId]",
-                    new { GroupId = id },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Guid>(
+                $"[{Schema}].[GroupUser_ReadOrganizationUserIdsByGroupId]",
+                new { GroupId = id },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<GroupUser>> GetManyGroupUsersByOrganizationIdAsync(Guid organizationId)
+    public async Task<ICollection<GroupUser>> GetManyGroupUsersByOrganizationIdAsync(Guid organizationId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<GroupUser>(
-                    $"[{Schema}].[GroupUser_ReadByOrganizationId]",
-                    new { OrganizationId = organizationId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<GroupUser>(
+                $"[{Schema}].[GroupUser_ReadByOrganizationId]",
+                new { OrganizationId = organizationId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task CreateAsync(Group obj, IEnumerable<SelectionReadOnly> collections)
+    public async Task CreateAsync(Group obj, IEnumerable<SelectionReadOnly> collections)
+    {
+        obj.SetNewId();
+        var objWithCollections = JsonSerializer.Deserialize<GroupWithCollections>(JsonSerializer.Serialize(obj));
+        objWithCollections.Collections = collections.ToArrayTVP();
+
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            obj.SetNewId();
-            var objWithCollections = JsonSerializer.Deserialize<GroupWithCollections>(JsonSerializer.Serialize(obj));
-            objWithCollections.Collections = collections.ToArrayTVP();
-
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[Group_CreateWithCollections]",
-                    objWithCollections,
-                    commandType: CommandType.StoredProcedure);
-            }
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[Group_CreateWithCollections]",
+                objWithCollections,
+                commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public async Task ReplaceAsync(Group obj, IEnumerable<SelectionReadOnly> collections)
+    public async Task ReplaceAsync(Group obj, IEnumerable<SelectionReadOnly> collections)
+    {
+        var objWithCollections = JsonSerializer.Deserialize<GroupWithCollections>(JsonSerializer.Serialize(obj));
+        objWithCollections.Collections = collections.ToArrayTVP();
+
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            var objWithCollections = JsonSerializer.Deserialize<GroupWithCollections>(JsonSerializer.Serialize(obj));
-            objWithCollections.Collections = collections.ToArrayTVP();
-
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[Group_UpdateWithCollections]",
-                    objWithCollections,
-                    commandType: CommandType.StoredProcedure);
-            }
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[Group_UpdateWithCollections]",
+                objWithCollections,
+                commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public async Task DeleteUserAsync(Guid groupId, Guid organizationUserId)
+    public async Task DeleteUserAsync(Guid groupId, Guid organizationUserId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[GroupUser_Delete]",
-                    new { GroupId = groupId, OrganizationUserId = organizationUserId },
-                    commandType: CommandType.StoredProcedure);
-            }
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[GroupUser_Delete]",
+                new { GroupId = groupId, OrganizationUserId = organizationUserId },
+                commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public async Task UpdateUsersAsync(Guid groupId, IEnumerable<Guid> organizationUserIds)
+    public async Task UpdateUsersAsync(Guid groupId, IEnumerable<Guid> organizationUserIds)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    "[dbo].[GroupUser_UpdateUsers]",
-                    new { GroupId = groupId, OrganizationUserIds = organizationUserIds.ToGuidIdArrayTVP() },
-                    commandType: CommandType.StoredProcedure);
-            }
+            var results = await connection.ExecuteAsync(
+                "[dbo].[GroupUser_UpdateUsers]",
+                new { GroupId = groupId, OrganizationUserIds = organizationUserIds.ToGuidIdArrayTVP() },
+                commandType: CommandType.StoredProcedure);
         }
     }
 }

src/Infrastructure.Dapper/Repositories/InstallationRepository.cs

@@ -2,16 +2,15 @@
 using Bit.Core.Repositories;
 using Bit.Core.Settings;
 
-namespace Bit.Infrastructure.Dapper.Repositories
-{
-    public class InstallationRepository : Repository<Installation, Guid>, IInstallationRepository
-    {
-        public InstallationRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
+namespace Bit.Infrastructure.Dapper.Repositories;
 
-        public InstallationRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-    }
+public class InstallationRepository : Repository<Installation, Guid>, IInstallationRepository
+{
+    public InstallationRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public InstallationRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
 }

src/Infrastructure.Dapper/Repositories/MaintenanceRepository.cs

@@ -4,74 +4,73 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class MaintenanceRepository : BaseRepository, IMaintenanceRepository
 {
-    public class MaintenanceRepository : BaseRepository, IMaintenanceRepository
+    public MaintenanceRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public MaintenanceRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task UpdateStatisticsAsync()
     {
-        public MaintenanceRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public MaintenanceRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task UpdateStatisticsAsync()
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync(
-                    "[dbo].[AzureSQLMaintenance]",
-                    new { operation = "statistics", mode = "smart", LogToTable = true },
-                    commandType: CommandType.StoredProcedure,
-                    commandTimeout: 172800);
-            }
+            await connection.ExecuteAsync(
+                "[dbo].[AzureSQLMaintenance]",
+                new { operation = "statistics", mode = "smart", LogToTable = true },
+                commandType: CommandType.StoredProcedure,
+                commandTimeout: 172800);
         }
+    }
 
-        public async Task DisableCipherAutoStatsAsync()
+    public async Task DisableCipherAutoStatsAsync()
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync(
-                    "sp_autostats",
-                    new { tblname = "[dbo].[Cipher]", flagc = "OFF" },
-                    commandType: CommandType.StoredProcedure);
-            }
+            await connection.ExecuteAsync(
+                "sp_autostats",
+                new { tblname = "[dbo].[Cipher]", flagc = "OFF" },
+                commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public async Task RebuildIndexesAsync()
+    public async Task RebuildIndexesAsync()
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync(
-                    "[dbo].[AzureSQLMaintenance]",
-                    new { operation = "index", mode = "smart", LogToTable = true },
-                    commandType: CommandType.StoredProcedure,
-                    commandTimeout: 172800);
-            }
+            await connection.ExecuteAsync(
+                "[dbo].[AzureSQLMaintenance]",
+                new { operation = "index", mode = "smart", LogToTable = true },
+                commandType: CommandType.StoredProcedure,
+                commandTimeout: 172800);
         }
+    }
 
-        public async Task DeleteExpiredGrantsAsync()
+    public async Task DeleteExpiredGrantsAsync()
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync(
-                    "[dbo].[Grant_DeleteExpired]",
-                    commandType: CommandType.StoredProcedure,
-                    commandTimeout: 172800);
-            }
+            await connection.ExecuteAsync(
+                "[dbo].[Grant_DeleteExpired]",
+                commandType: CommandType.StoredProcedure,
+                commandTimeout: 172800);
         }
+    }
 
-        public async Task DeleteExpiredSponsorshipsAsync(DateTime validUntilBeforeDate)
+    public async Task DeleteExpiredSponsorshipsAsync(DateTime validUntilBeforeDate)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync(
-                    "[dbo].[OrganizationSponsorship_DeleteExpired]",
-                    new { ValidUntilBeforeDate = validUntilBeforeDate },
-                    commandType: CommandType.StoredProcedure,
-                    commandTimeout: 172800);
-            }
+            await connection.ExecuteAsync(
+                "[dbo].[OrganizationSponsorship_DeleteExpired]",
+                new { ValidUntilBeforeDate = validUntilBeforeDate },
+                commandType: CommandType.StoredProcedure,
+                commandTimeout: 172800);
         }
     }
 }

src/Infrastructure.Dapper/Repositories/OrganizationApiKeyRepository.cs

@@ -6,33 +6,32 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class OrganizationApiKeyRepository : Repository<OrganizationApiKey, Guid>, IOrganizationApiKeyRepository
 {
-    public class OrganizationApiKeyRepository : Repository<OrganizationApiKey, Guid>, IOrganizationApiKeyRepository
+    public OrganizationApiKeyRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
     {
-        public OrganizationApiKeyRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+
+    }
+
+    public OrganizationApiKeyRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<IEnumerable<OrganizationApiKey>> GetManyByOrganizationIdTypeAsync(Guid organizationId, OrganizationApiKeyType? type = null)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-
-        }
-
-        public OrganizationApiKeyRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<IEnumerable<OrganizationApiKey>> GetManyByOrganizationIdTypeAsync(Guid organizationId, OrganizationApiKeyType? type = null)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                return await connection.QueryAsync<OrganizationApiKey>(
-                    "[dbo].[OrganizationApikey_ReadManyByOrganizationIdType]",
-                    new
-                    {
-                        OrganizationId = organizationId,
-                        Type = type,
-                    },
-                    commandType: CommandType.StoredProcedure);
-            }
+            return await connection.QueryAsync<OrganizationApiKey>(
+                "[dbo].[OrganizationApikey_ReadManyByOrganizationIdType]",
+                new
+                {
+                    OrganizationId = organizationId,
+                    Type = type,
+                },
+                commandType: CommandType.StoredProcedure);
         }
     }
 }

src/Infrastructure.Dapper/Repositories/OrganizationConnectionRepository.cs

@@ -6,32 +6,31 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class OrganizationConnectionRepository : Repository<OrganizationConnection, Guid>, IOrganizationConnectionRepository
 {
-    public class OrganizationConnectionRepository : Repository<OrganizationConnection, Guid>, IOrganizationConnectionRepository
+    public OrganizationConnectionRepository(GlobalSettings globalSettings)
+        : base(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public async Task<ICollection<OrganizationConnection>> GetByOrganizationIdTypeAsync(Guid organizationId, OrganizationConnectionType type)
     {
-        public OrganizationConnectionRepository(GlobalSettings globalSettings)
-            : base(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public async Task<ICollection<OrganizationConnection>> GetByOrganizationIdTypeAsync(Guid organizationId, OrganizationConnectionType type)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationConnection>(
-                    $"[{Schema}].[OrganizationConnection_ReadByOrganizationIdType]",
-                    new
-                    {
-                        OrganizationId = organizationId,
-                        Type = type
-                    },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<OrganizationConnection>(
+                $"[{Schema}].[OrganizationConnection_ReadByOrganizationIdType]",
+                new
+                {
+                    OrganizationId = organizationId,
+                    Type = type
+                },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
-
-        public async Task<ICollection<OrganizationConnection>> GetEnabledByOrganizationIdTypeAsync(Guid organizationId, OrganizationConnectionType type) =>
-            (await GetByOrganizationIdTypeAsync(organizationId, type)).Where(c => c.Enabled).ToList();
     }
+
+    public async Task<ICollection<OrganizationConnection>> GetEnabledByOrganizationIdTypeAsync(Guid organizationId, OrganizationConnectionType type) =>
+        (await GetByOrganizationIdTypeAsync(organizationId, type)).Where(c => c.Enabled).ToList();
 }

src/Infrastructure.Dapper/Repositories/OrganizationRepository.cs

@@ -6,93 +6,92 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class OrganizationRepository : Repository<Organization, Guid>, IOrganizationRepository
 {
-    public class OrganizationRepository : Repository<Organization, Guid>, IOrganizationRepository
+    public OrganizationRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public OrganizationRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<Organization> GetByIdentifierAsync(string identifier)
     {
-        public OrganizationRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public OrganizationRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<Organization> GetByIdentifierAsync(string identifier)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Organization>(
-                    "[dbo].[Organization_ReadByIdentifier]",
-                    new { Identifier = identifier },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Organization>(
+                "[dbo].[Organization_ReadByIdentifier]",
+                new { Identifier = identifier },
+                commandType: CommandType.StoredProcedure);
 
-                return results.SingleOrDefault();
-            }
+            return results.SingleOrDefault();
         }
+    }
 
-        public async Task<ICollection<Organization>> GetManyByEnabledAsync()
+    public async Task<ICollection<Organization>> GetManyByEnabledAsync()
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Organization>(
-                    "[dbo].[Organization_ReadByEnabled]",
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Organization>(
+                "[dbo].[Organization_ReadByEnabled]",
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<Organization>> GetManyByUserIdAsync(Guid userId)
+    public async Task<ICollection<Organization>> GetManyByUserIdAsync(Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Organization>(
-                    "[dbo].[Organization_ReadByUserId]",
-                    new { UserId = userId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Organization>(
+                "[dbo].[Organization_ReadByUserId]",
+                new { UserId = userId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<Organization>> SearchAsync(string name, string userEmail, bool? paid,
-            int skip, int take)
+    public async Task<ICollection<Organization>> SearchAsync(string name, string userEmail, bool? paid,
+        int skip, int take)
+    {
+        using (var connection = new SqlConnection(ReadOnlyConnectionString))
         {
-            using (var connection = new SqlConnection(ReadOnlyConnectionString))
-            {
-                var results = await connection.QueryAsync<Organization>(
-                    "[dbo].[Organization_Search]",
-                    new { Name = name, UserEmail = userEmail, Paid = paid, Skip = skip, Take = take },
-                    commandType: CommandType.StoredProcedure,
-                    commandTimeout: 120);
+            var results = await connection.QueryAsync<Organization>(
+                "[dbo].[Organization_Search]",
+                new { Name = name, UserEmail = userEmail, Paid = paid, Skip = skip, Take = take },
+                commandType: CommandType.StoredProcedure,
+                commandTimeout: 120);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task UpdateStorageAsync(Guid id)
+    public async Task UpdateStorageAsync(Guid id)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync(
-                    "[dbo].[Organization_UpdateStorage]",
-                    new { Id = id },
-                    commandType: CommandType.StoredProcedure,
-                    commandTimeout: 180);
-            }
+            await connection.ExecuteAsync(
+                "[dbo].[Organization_UpdateStorage]",
+                new { Id = id },
+                commandType: CommandType.StoredProcedure,
+                commandTimeout: 180);
         }
+    }
 
-        public async Task<ICollection<OrganizationAbility>> GetManyAbilitiesAsync()
+    public async Task<ICollection<OrganizationAbility>> GetManyAbilitiesAsync()
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationAbility>(
-                    "[dbo].[Organization_ReadAbilities]",
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<OrganizationAbility>(
+                "[dbo].[Organization_ReadAbilities]",
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
     }
 }

src/Infrastructure.Dapper/Repositories/OrganizationSponsorshipRepository.cs

@@ -5,143 +5,142 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class OrganizationSponsorshipRepository : Repository<OrganizationSponsorship, Guid>, IOrganizationSponsorshipRepository
 {
-    public class OrganizationSponsorshipRepository : Repository<OrganizationSponsorship, Guid>, IOrganizationSponsorshipRepository
+    public OrganizationSponsorshipRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public OrganizationSponsorshipRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<ICollection<Guid>> CreateManyAsync(IEnumerable<OrganizationSponsorship> organizationSponsorships)
     {
-        public OrganizationSponsorshipRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public OrganizationSponsorshipRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<ICollection<Guid>> CreateManyAsync(IEnumerable<OrganizationSponsorship> organizationSponsorships)
+        if (!organizationSponsorships.Any())
         {
-            if (!organizationSponsorships.Any())
-            {
-                return default;
-            }
-
-            foreach (var organizationSponsorship in organizationSponsorships)
-            {
-                organizationSponsorship.SetNewId();
-            }
-
-            var orgSponsorshipsTVP = organizationSponsorships.ToTvp();
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[dbo].[OrganizationSponsorship_CreateMany]",
-                    new { OrganizationSponsorshipsInput = orgSponsorshipsTVP },
-                    commandType: CommandType.StoredProcedure);
-            }
-
-            return organizationSponsorships.Select(u => u.Id).ToList();
+            return default;
         }
 
-        public async Task ReplaceManyAsync(IEnumerable<OrganizationSponsorship> organizationSponsorships)
+        foreach (var organizationSponsorship in organizationSponsorships)
         {
-            if (!organizationSponsorships.Any())
-            {
-                return;
-            }
-
-            var orgSponsorshipsTVP = organizationSponsorships.ToTvp();
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[dbo].[OrganizationSponsorship_UpdateMany]",
-                    new { OrganizationSponsorshipsInput = orgSponsorshipsTVP },
-                    commandType: CommandType.StoredProcedure);
-            }
+            organizationSponsorship.SetNewId();
         }
 
-        public async Task UpsertManyAsync(IEnumerable<OrganizationSponsorship> organizationSponsorships)
+        var orgSponsorshipsTVP = organizationSponsorships.ToTvp();
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            var createSponsorships = new List<OrganizationSponsorship>();
-            var replaceSponsorships = new List<OrganizationSponsorship>();
-            foreach (var organizationSponsorship in organizationSponsorships)
-            {
-                if (organizationSponsorship.Id.Equals(default))
-                {
-                    createSponsorships.Add(organizationSponsorship);
-                }
-                else
-                {
-                    replaceSponsorships.Add(organizationSponsorship);
-                }
-            }
-
-            await CreateManyAsync(createSponsorships);
-            await ReplaceManyAsync(replaceSponsorships);
-        }
-
-        public async Task DeleteManyAsync(IEnumerable<Guid> organizationSponsorshipIds)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync("[dbo].[OrganizationSponsorship_DeleteByIds]",
-                    new { Ids = organizationSponsorshipIds.ToGuidIdArrayTVP() }, commandType: CommandType.StoredProcedure);
-            }
-        }
-
-        public async Task<OrganizationSponsorship> GetBySponsoringOrganizationUserIdAsync(Guid sponsoringOrganizationUserId)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationSponsorship>(
-                    "[dbo].[OrganizationSponsorship_ReadBySponsoringOrganizationUserId]",
-                    new
-                    {
-                        SponsoringOrganizationUserId = sponsoringOrganizationUserId
-                    },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.SingleOrDefault();
-            }
-        }
-
-        public async Task<OrganizationSponsorship> GetBySponsoredOrganizationIdAsync(Guid sponsoredOrganizationId)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationSponsorship>(
-                    "[dbo].[OrganizationSponsorship_ReadBySponsoredOrganizationId]",
-                    new { SponsoredOrganizationId = sponsoredOrganizationId },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.SingleOrDefault();
-            }
-        }
-
-        public async Task<DateTime?> GetLatestSyncDateBySponsoringOrganizationIdAsync(Guid sponsoringOrganizationId)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                return await connection.QuerySingleOrDefaultAsync<DateTime?>(
-                    "[dbo].[OrganizationSponsorship_ReadLatestBySponsoringOrganizationId]",
-                    new { SponsoringOrganizationId = sponsoringOrganizationId },
-                    commandType: CommandType.StoredProcedure);
-            }
-        }
-
-        public async Task<ICollection<OrganizationSponsorship>> GetManyBySponsoringOrganizationAsync(Guid sponsoringOrganizationId)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationSponsorship>(
-                    "[dbo].[OrganizationSponsorship_ReadBySponsoringOrganizationId]",
-                    new
-                    {
-                        SponsoringOrganizationId = sponsoringOrganizationId
-                    },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.ToList();
-            }
+            var results = await connection.ExecuteAsync(
+                $"[dbo].[OrganizationSponsorship_CreateMany]",
+                new { OrganizationSponsorshipsInput = orgSponsorshipsTVP },
+                commandType: CommandType.StoredProcedure);
         }
 
+        return organizationSponsorships.Select(u => u.Id).ToList();
     }
+
+    public async Task ReplaceManyAsync(IEnumerable<OrganizationSponsorship> organizationSponsorships)
+    {
+        if (!organizationSponsorships.Any())
+        {
+            return;
+        }
+
+        var orgSponsorshipsTVP = organizationSponsorships.ToTvp();
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.ExecuteAsync(
+                $"[dbo].[OrganizationSponsorship_UpdateMany]",
+                new { OrganizationSponsorshipsInput = orgSponsorshipsTVP },
+                commandType: CommandType.StoredProcedure);
+        }
+    }
+
+    public async Task UpsertManyAsync(IEnumerable<OrganizationSponsorship> organizationSponsorships)
+    {
+        var createSponsorships = new List<OrganizationSponsorship>();
+        var replaceSponsorships = new List<OrganizationSponsorship>();
+        foreach (var organizationSponsorship in organizationSponsorships)
+        {
+            if (organizationSponsorship.Id.Equals(default))
+            {
+                createSponsorships.Add(organizationSponsorship);
+            }
+            else
+            {
+                replaceSponsorships.Add(organizationSponsorship);
+            }
+        }
+
+        await CreateManyAsync(createSponsorships);
+        await ReplaceManyAsync(replaceSponsorships);
+    }
+
+    public async Task DeleteManyAsync(IEnumerable<Guid> organizationSponsorshipIds)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            await connection.ExecuteAsync("[dbo].[OrganizationSponsorship_DeleteByIds]",
+                new { Ids = organizationSponsorshipIds.ToGuidIdArrayTVP() }, commandType: CommandType.StoredProcedure);
+        }
+    }
+
+    public async Task<OrganizationSponsorship> GetBySponsoringOrganizationUserIdAsync(Guid sponsoringOrganizationUserId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<OrganizationSponsorship>(
+                "[dbo].[OrganizationSponsorship_ReadBySponsoringOrganizationUserId]",
+                new
+                {
+                    SponsoringOrganizationUserId = sponsoringOrganizationUserId
+                },
+                commandType: CommandType.StoredProcedure);
+
+            return results.SingleOrDefault();
+        }
+    }
+
+    public async Task<OrganizationSponsorship> GetBySponsoredOrganizationIdAsync(Guid sponsoredOrganizationId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<OrganizationSponsorship>(
+                "[dbo].[OrganizationSponsorship_ReadBySponsoredOrganizationId]",
+                new { SponsoredOrganizationId = sponsoredOrganizationId },
+                commandType: CommandType.StoredProcedure);
+
+            return results.SingleOrDefault();
+        }
+    }
+
+    public async Task<DateTime?> GetLatestSyncDateBySponsoringOrganizationIdAsync(Guid sponsoringOrganizationId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            return await connection.QuerySingleOrDefaultAsync<DateTime?>(
+                "[dbo].[OrganizationSponsorship_ReadLatestBySponsoringOrganizationId]",
+                new { SponsoringOrganizationId = sponsoringOrganizationId },
+                commandType: CommandType.StoredProcedure);
+        }
+    }
+
+    public async Task<ICollection<OrganizationSponsorship>> GetManyBySponsoringOrganizationAsync(Guid sponsoringOrganizationId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<OrganizationSponsorship>(
+                "[dbo].[OrganizationSponsorship_ReadBySponsoringOrganizationId]",
+                new
+                {
+                    SponsoringOrganizationId = sponsoringOrganizationId
+                },
+                commandType: CommandType.StoredProcedure);
+
+            return results.ToList();
+        }
+    }
+
 }

src/Infrastructure.Dapper/Repositories/OrganizationUserRepository.cs

@@ -9,423 +9,422 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class OrganizationUserRepository : Repository<OrganizationUser, Guid>, IOrganizationUserRepository
 {
-    public class OrganizationUserRepository : Repository<OrganizationUser, Guid>, IOrganizationUserRepository
+    /// <summary>
+    /// For use with methods with TDS stream issues.
+    /// This has been observed in Linux-hosted SqlServers with large table-valued-parameters
+    /// https://github.com/dotnet/SqlClient/issues/54
+    /// </summary>
+    private string _marsConnectionString;
+
+    public OrganizationUserRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
     {
-        /// <summary>
-        /// For use with methods with TDS stream issues.
-        /// This has been observed in Linux-hosted SqlServers with large table-valued-parameters
-        /// https://github.com/dotnet/SqlClient/issues/54
-        /// </summary>
-        private string _marsConnectionString;
-
-        public OrganizationUserRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+        var builder = new SqlConnectionStringBuilder(ConnectionString)
         {
-            var builder = new SqlConnectionStringBuilder(ConnectionString)
-            {
-                MultipleActiveResultSets = true,
-            };
-            _marsConnectionString = builder.ToString();
+            MultipleActiveResultSets = true,
+        };
+        _marsConnectionString = builder.ToString();
+    }
+
+    public OrganizationUserRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<int> GetCountByOrganizationIdAsync(Guid organizationId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.ExecuteScalarAsync<int>(
+                "[dbo].[OrganizationUser_ReadCountByOrganizationId]",
+                new { OrganizationId = organizationId },
+                commandType: CommandType.StoredProcedure);
+
+            return results;
+        }
+    }
+
+    public async Task<int> GetCountByFreeOrganizationAdminUserAsync(Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.ExecuteScalarAsync<int>(
+                "[dbo].[OrganizationUser_ReadCountByFreeOrganizationAdminUser]",
+                new { UserId = userId },
+                commandType: CommandType.StoredProcedure);
+
+            return results;
+        }
+    }
+
+    public async Task<int> GetCountByOnlyOwnerAsync(Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.ExecuteScalarAsync<int>(
+                "[dbo].[OrganizationUser_ReadCountByOnlyOwner]",
+                new { UserId = userId },
+                commandType: CommandType.StoredProcedure);
+
+            return results;
+        }
+    }
+
+    public async Task<int> GetCountByOrganizationAsync(Guid organizationId, string email, bool onlyRegisteredUsers)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var result = await connection.ExecuteScalarAsync<int>(
+                "[dbo].[OrganizationUser_ReadCountByOrganizationIdEmail]",
+                new { OrganizationId = organizationId, Email = email, OnlyUsers = onlyRegisteredUsers },
+                commandType: CommandType.StoredProcedure);
+
+            return result;
+        }
+    }
+
+    public async Task<ICollection<string>> SelectKnownEmailsAsync(Guid organizationId, IEnumerable<string> emails,
+        bool onlyRegisteredUsers)
+    {
+        var emailsTvp = emails.ToArrayTVP("Email");
+        using (var connection = new SqlConnection(_marsConnectionString))
+        {
+            var result = await connection.QueryAsync<string>(
+                "[dbo].[OrganizationUser_SelectKnownEmails]",
+                new { OrganizationId = organizationId, Emails = emailsTvp, OnlyUsers = onlyRegisteredUsers },
+                commandType: CommandType.StoredProcedure);
+
+            // Return as a list to avoid timing out the sql connection
+            return result.ToList();
+        }
+    }
+
+    public async Task<OrganizationUser> GetByOrganizationAsync(Guid organizationId, Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<OrganizationUser>(
+                "[dbo].[OrganizationUser_ReadByOrganizationIdUserId]",
+                new { OrganizationId = organizationId, UserId = userId },
+                commandType: CommandType.StoredProcedure);
+
+            return results.SingleOrDefault();
+        }
+    }
+
+    public async Task<ICollection<OrganizationUser>> GetManyByUserAsync(Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<OrganizationUser>(
+                "[dbo].[OrganizationUser_ReadByUserId]",
+                new { UserId = userId },
+                commandType: CommandType.StoredProcedure);
+
+            return results.ToList();
+        }
+    }
+
+    public async Task<ICollection<OrganizationUser>> GetManyByOrganizationAsync(Guid organizationId,
+        OrganizationUserType? type)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<OrganizationUser>(
+                "[dbo].[OrganizationUser_ReadByOrganizationId]",
+                new { OrganizationId = organizationId, Type = type },
+                commandType: CommandType.StoredProcedure);
+
+            return results.ToList();
+        }
+    }
+
+    public async Task<Tuple<OrganizationUser, ICollection<SelectionReadOnly>>> GetByIdWithCollectionsAsync(Guid id)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryMultipleAsync(
+                "[dbo].[OrganizationUser_ReadWithCollectionsById]",
+                new { Id = id },
+                commandType: CommandType.StoredProcedure);
+
+            var user = (await results.ReadAsync<OrganizationUser>()).SingleOrDefault();
+            var collections = (await results.ReadAsync<SelectionReadOnly>()).ToList();
+            return new Tuple<OrganizationUser, ICollection<SelectionReadOnly>>(user, collections);
+        }
+    }
+
+    public async Task<OrganizationUserUserDetails> GetDetailsByIdAsync(Guid id)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<OrganizationUserUserDetails>(
+                "[dbo].[OrganizationUserUserDetails_ReadById]",
+                new { Id = id },
+                commandType: CommandType.StoredProcedure);
+
+            return results.SingleOrDefault();
+        }
+    }
+    public async Task<Tuple<OrganizationUserUserDetails, ICollection<SelectionReadOnly>>>
+        GetDetailsByIdWithCollectionsAsync(Guid id)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryMultipleAsync(
+                "[dbo].[OrganizationUserUserDetails_ReadWithCollectionsById]",
+                new { Id = id },
+                commandType: CommandType.StoredProcedure);
+
+            var user = (await results.ReadAsync<OrganizationUserUserDetails>()).SingleOrDefault();
+            var collections = (await results.ReadAsync<SelectionReadOnly>()).ToList();
+            return new Tuple<OrganizationUserUserDetails, ICollection<SelectionReadOnly>>(user, collections);
+        }
+    }
+
+    public async Task<ICollection<OrganizationUserUserDetails>> GetManyDetailsByOrganizationAsync(Guid organizationId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<OrganizationUserUserDetails>(
+                "[dbo].[OrganizationUserUserDetails_ReadByOrganizationId]",
+                new { OrganizationId = organizationId },
+                commandType: CommandType.StoredProcedure);
+
+            return results.ToList();
+        }
+    }
+
+    public async Task<ICollection<OrganizationUserOrganizationDetails>> GetManyDetailsByUserAsync(Guid userId,
+        OrganizationUserStatusType? status = null)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<OrganizationUserOrganizationDetails>(
+                "[dbo].[OrganizationUserOrganizationDetails_ReadByUserIdStatus]",
+                new { UserId = userId, Status = status },
+                commandType: CommandType.StoredProcedure);
+
+            return results.ToList();
+        }
+    }
+
+    public async Task<OrganizationUserOrganizationDetails> GetDetailsByUserAsync(Guid userId,
+        Guid organizationId, OrganizationUserStatusType? status = null)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<OrganizationUserOrganizationDetails>(
+                "[dbo].[OrganizationUserOrganizationDetails_ReadByUserIdStatusOrganizationId]",
+                new { UserId = userId, Status = status, OrganizationId = organizationId },
+                commandType: CommandType.StoredProcedure);
+
+            return results.SingleOrDefault();
+        }
+    }
+
+    public async Task UpdateGroupsAsync(Guid orgUserId, IEnumerable<Guid> groupIds)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.ExecuteAsync(
+                "[dbo].[GroupUser_UpdateGroups]",
+                new { OrganizationUserId = orgUserId, GroupIds = groupIds.ToGuidIdArrayTVP() },
+                commandType: CommandType.StoredProcedure);
+        }
+    }
+
+    public async Task<Guid> CreateAsync(OrganizationUser obj, IEnumerable<SelectionReadOnly> collections)
+    {
+        obj.SetNewId();
+        var objWithCollections = JsonSerializer.Deserialize<OrganizationUserWithCollections>(
+            JsonSerializer.Serialize(obj));
+        objWithCollections.Collections = collections.ToArrayTVP();
+
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[OrganizationUser_CreateWithCollections]",
+                objWithCollections,
+                commandType: CommandType.StoredProcedure);
         }
 
-        public OrganizationUserRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
+        return obj.Id;
+    }
 
-        public async Task<int> GetCountByOrganizationIdAsync(Guid organizationId)
+    public async Task ReplaceAsync(OrganizationUser obj, IEnumerable<SelectionReadOnly> collections)
+    {
+        var objWithCollections = JsonSerializer.Deserialize<OrganizationUserWithCollections>(
+            JsonSerializer.Serialize(obj));
+        objWithCollections.Collections = collections.ToArrayTVP();
+
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteScalarAsync<int>(
-                    "[dbo].[OrganizationUser_ReadCountByOrganizationId]",
-                    new { OrganizationId = organizationId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[OrganizationUser_UpdateWithCollections]",
+                objWithCollections,
+                commandType: CommandType.StoredProcedure);
+        }
+    }
 
-                return results;
+    public async Task<ICollection<OrganizationUser>> GetManyByManyUsersAsync(IEnumerable<Guid> userIds)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<OrganizationUser>(
+                "[dbo].[OrganizationUser_ReadByUserIds]",
+                new { UserIds = userIds.ToGuidIdArrayTVP() },
+                commandType: CommandType.StoredProcedure);
+
+            return results.ToList();
+        }
+    }
+
+    public async Task<ICollection<OrganizationUser>> GetManyAsync(IEnumerable<Guid> Ids)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<OrganizationUser>(
+                "[dbo].[OrganizationUser_ReadByIds]",
+                new { Ids = Ids.ToGuidIdArrayTVP() },
+                commandType: CommandType.StoredProcedure);
+
+            return results.ToList();
+        }
+    }
+
+    public async Task<OrganizationUser> GetByOrganizationEmailAsync(Guid organizationId, string email)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            var results = await connection.QueryAsync<OrganizationUser>(
+                "[dbo].[OrganizationUser_ReadByOrganizationIdEmail]",
+                new { OrganizationId = organizationId, Email = email },
+                commandType: CommandType.StoredProcedure);
+
+            return results.SingleOrDefault();
+        }
+    }
+
+    public async Task DeleteManyAsync(IEnumerable<Guid> organizationUserIds)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            await connection.ExecuteAsync("[dbo].[OrganizationUser_DeleteByIds]",
+                new { Ids = organizationUserIds.ToGuidIdArrayTVP() }, commandType: CommandType.StoredProcedure);
+        }
+    }
+
+    public async Task UpsertManyAsync(IEnumerable<OrganizationUser> organizationUsers)
+    {
+        var createUsers = new List<OrganizationUser>();
+        var replaceUsers = new List<OrganizationUser>();
+        foreach (var organizationUser in organizationUsers)
+        {
+            if (organizationUser.Id.Equals(default))
+            {
+                createUsers.Add(organizationUser);
+            }
+            else
+            {
+                replaceUsers.Add(organizationUser);
             }
         }
 
-        public async Task<int> GetCountByFreeOrganizationAdminUserAsync(Guid userId)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteScalarAsync<int>(
-                    "[dbo].[OrganizationUser_ReadCountByFreeOrganizationAdminUser]",
-                    new { UserId = userId },
-                    commandType: CommandType.StoredProcedure);
+        await CreateManyAsync(createUsers);
+        await ReplaceManyAsync(replaceUsers);
+    }
 
-                return results;
-            }
+    public async Task<ICollection<Guid>> CreateManyAsync(IEnumerable<OrganizationUser> organizationUsers)
+    {
+        if (!organizationUsers.Any())
+        {
+            return default;
         }
 
-        public async Task<int> GetCountByOnlyOwnerAsync(Guid userId)
+        foreach (var organizationUser in organizationUsers)
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteScalarAsync<int>(
-                    "[dbo].[OrganizationUser_ReadCountByOnlyOwner]",
-                    new { UserId = userId },
-                    commandType: CommandType.StoredProcedure);
-
-                return results;
-            }
+            organizationUser.SetNewId();
         }
 
-        public async Task<int> GetCountByOrganizationAsync(Guid organizationId, string email, bool onlyRegisteredUsers)
+        var orgUsersTVP = organizationUsers.ToTvp();
+        using (var connection = new SqlConnection(_marsConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var result = await connection.ExecuteScalarAsync<int>(
-                    "[dbo].[OrganizationUser_ReadCountByOrganizationIdEmail]",
-                    new { OrganizationId = organizationId, Email = email, OnlyUsers = onlyRegisteredUsers },
-                    commandType: CommandType.StoredProcedure);
-
-                return result;
-            }
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[{Table}_CreateMany]",
+                new { OrganizationUsersInput = orgUsersTVP },
+                commandType: CommandType.StoredProcedure);
         }
 
-        public async Task<ICollection<string>> SelectKnownEmailsAsync(Guid organizationId, IEnumerable<string> emails,
-            bool onlyRegisteredUsers)
-        {
-            var emailsTvp = emails.ToArrayTVP("Email");
-            using (var connection = new SqlConnection(_marsConnectionString))
-            {
-                var result = await connection.QueryAsync<string>(
-                    "[dbo].[OrganizationUser_SelectKnownEmails]",
-                    new { OrganizationId = organizationId, Emails = emailsTvp, OnlyUsers = onlyRegisteredUsers },
-                    commandType: CommandType.StoredProcedure);
+        return organizationUsers.Select(u => u.Id).ToList();
+    }
 
-                // Return as a list to avoid timing out the sql connection
-                return result.ToList();
-            }
+    public async Task ReplaceManyAsync(IEnumerable<OrganizationUser> organizationUsers)
+    {
+        if (!organizationUsers.Any())
+        {
+            return;
         }
 
-        public async Task<OrganizationUser> GetByOrganizationAsync(Guid organizationId, Guid userId)
+        var orgUsersTVP = organizationUsers.ToTvp();
+        using (var connection = new SqlConnection(_marsConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationUser>(
-                    "[dbo].[OrganizationUser_ReadByOrganizationIdUserId]",
-                    new { OrganizationId = organizationId, UserId = userId },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.SingleOrDefault();
-            }
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[{Table}_UpdateMany]",
+                new { OrganizationUsersInput = orgUsersTVP },
+                commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public async Task<ICollection<OrganizationUser>> GetManyByUserAsync(Guid userId)
+    public async Task<IEnumerable<OrganizationUserPublicKey>> GetManyPublicKeysByOrganizationUserAsync(
+        Guid organizationId, IEnumerable<Guid> Ids)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationUser>(
-                    "[dbo].[OrganizationUser_ReadByUserId]",
-                    new { UserId = userId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<OrganizationUserPublicKey>(
+                "[dbo].[User_ReadPublicKeysByOrganizationUserIds]",
+                new { OrganizationId = organizationId, OrganizationUserIds = Ids.ToGuidIdArrayTVP() },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<OrganizationUser>> GetManyByOrganizationAsync(Guid organizationId,
-            OrganizationUserType? type)
+    public async Task<IEnumerable<OrganizationUserUserDetails>> GetManyByMinimumRoleAsync(Guid organizationId, OrganizationUserType minRole)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationUser>(
-                    "[dbo].[OrganizationUser_ReadByOrganizationId]",
-                    new { OrganizationId = organizationId, Type = type },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<OrganizationUserUserDetails>(
+                "[dbo].[OrganizationUser_ReadByMinimumRole]",
+                new { OrganizationId = organizationId, MinRole = minRole },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<Tuple<OrganizationUser, ICollection<SelectionReadOnly>>> GetByIdWithCollectionsAsync(Guid id)
+    public async Task RevokeAsync(Guid id)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryMultipleAsync(
-                    "[dbo].[OrganizationUser_ReadWithCollectionsById]",
-                    new { Id = id },
-                    commandType: CommandType.StoredProcedure);
-
-                var user = (await results.ReadAsync<OrganizationUser>()).SingleOrDefault();
-                var collections = (await results.ReadAsync<SelectionReadOnly>()).ToList();
-                return new Tuple<OrganizationUser, ICollection<SelectionReadOnly>>(user, collections);
-            }
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[{Table}_Deactivate]",
+                new { Id = id },
+                commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public async Task<OrganizationUserUserDetails> GetDetailsByIdAsync(Guid id)
+    public async Task RestoreAsync(Guid id, OrganizationUserStatusType status)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationUserUserDetails>(
-                    "[dbo].[OrganizationUserUserDetails_ReadById]",
-                    new { Id = id },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.SingleOrDefault();
-            }
-        }
-        public async Task<Tuple<OrganizationUserUserDetails, ICollection<SelectionReadOnly>>>
-            GetDetailsByIdWithCollectionsAsync(Guid id)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryMultipleAsync(
-                    "[dbo].[OrganizationUserUserDetails_ReadWithCollectionsById]",
-                    new { Id = id },
-                    commandType: CommandType.StoredProcedure);
-
-                var user = (await results.ReadAsync<OrganizationUserUserDetails>()).SingleOrDefault();
-                var collections = (await results.ReadAsync<SelectionReadOnly>()).ToList();
-                return new Tuple<OrganizationUserUserDetails, ICollection<SelectionReadOnly>>(user, collections);
-            }
-        }
-
-        public async Task<ICollection<OrganizationUserUserDetails>> GetManyDetailsByOrganizationAsync(Guid organizationId)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationUserUserDetails>(
-                    "[dbo].[OrganizationUserUserDetails_ReadByOrganizationId]",
-                    new { OrganizationId = organizationId },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.ToList();
-            }
-        }
-
-        public async Task<ICollection<OrganizationUserOrganizationDetails>> GetManyDetailsByUserAsync(Guid userId,
-            OrganizationUserStatusType? status = null)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationUserOrganizationDetails>(
-                    "[dbo].[OrganizationUserOrganizationDetails_ReadByUserIdStatus]",
-                    new { UserId = userId, Status = status },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.ToList();
-            }
-        }
-
-        public async Task<OrganizationUserOrganizationDetails> GetDetailsByUserAsync(Guid userId,
-            Guid organizationId, OrganizationUserStatusType? status = null)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationUserOrganizationDetails>(
-                    "[dbo].[OrganizationUserOrganizationDetails_ReadByUserIdStatusOrganizationId]",
-                    new { UserId = userId, Status = status, OrganizationId = organizationId },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.SingleOrDefault();
-            }
-        }
-
-        public async Task UpdateGroupsAsync(Guid orgUserId, IEnumerable<Guid> groupIds)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    "[dbo].[GroupUser_UpdateGroups]",
-                    new { OrganizationUserId = orgUserId, GroupIds = groupIds.ToGuidIdArrayTVP() },
-                    commandType: CommandType.StoredProcedure);
-            }
-        }
-
-        public async Task<Guid> CreateAsync(OrganizationUser obj, IEnumerable<SelectionReadOnly> collections)
-        {
-            obj.SetNewId();
-            var objWithCollections = JsonSerializer.Deserialize<OrganizationUserWithCollections>(
-                JsonSerializer.Serialize(obj));
-            objWithCollections.Collections = collections.ToArrayTVP();
-
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[OrganizationUser_CreateWithCollections]",
-                    objWithCollections,
-                    commandType: CommandType.StoredProcedure);
-            }
-
-            return obj.Id;
-        }
-
-        public async Task ReplaceAsync(OrganizationUser obj, IEnumerable<SelectionReadOnly> collections)
-        {
-            var objWithCollections = JsonSerializer.Deserialize<OrganizationUserWithCollections>(
-                JsonSerializer.Serialize(obj));
-            objWithCollections.Collections = collections.ToArrayTVP();
-
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[OrganizationUser_UpdateWithCollections]",
-                    objWithCollections,
-                    commandType: CommandType.StoredProcedure);
-            }
-        }
-
-        public async Task<ICollection<OrganizationUser>> GetManyByManyUsersAsync(IEnumerable<Guid> userIds)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationUser>(
-                    "[dbo].[OrganizationUser_ReadByUserIds]",
-                    new { UserIds = userIds.ToGuidIdArrayTVP() },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.ToList();
-            }
-        }
-
-        public async Task<ICollection<OrganizationUser>> GetManyAsync(IEnumerable<Guid> Ids)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationUser>(
-                    "[dbo].[OrganizationUser_ReadByIds]",
-                    new { Ids = Ids.ToGuidIdArrayTVP() },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.ToList();
-            }
-        }
-
-        public async Task<OrganizationUser> GetByOrganizationEmailAsync(Guid organizationId, string email)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationUser>(
-                    "[dbo].[OrganizationUser_ReadByOrganizationIdEmail]",
-                    new { OrganizationId = organizationId, Email = email },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.SingleOrDefault();
-            }
-        }
-
-        public async Task DeleteManyAsync(IEnumerable<Guid> organizationUserIds)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync("[dbo].[OrganizationUser_DeleteByIds]",
-                    new { Ids = organizationUserIds.ToGuidIdArrayTVP() }, commandType: CommandType.StoredProcedure);
-            }
-        }
-
-        public async Task UpsertManyAsync(IEnumerable<OrganizationUser> organizationUsers)
-        {
-            var createUsers = new List<OrganizationUser>();
-            var replaceUsers = new List<OrganizationUser>();
-            foreach (var organizationUser in organizationUsers)
-            {
-                if (organizationUser.Id.Equals(default))
-                {
-                    createUsers.Add(organizationUser);
-                }
-                else
-                {
-                    replaceUsers.Add(organizationUser);
-                }
-            }
-
-            await CreateManyAsync(createUsers);
-            await ReplaceManyAsync(replaceUsers);
-        }
-
-        public async Task<ICollection<Guid>> CreateManyAsync(IEnumerable<OrganizationUser> organizationUsers)
-        {
-            if (!organizationUsers.Any())
-            {
-                return default;
-            }
-
-            foreach (var organizationUser in organizationUsers)
-            {
-                organizationUser.SetNewId();
-            }
-
-            var orgUsersTVP = organizationUsers.ToTvp();
-            using (var connection = new SqlConnection(_marsConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[{Table}_CreateMany]",
-                    new { OrganizationUsersInput = orgUsersTVP },
-                    commandType: CommandType.StoredProcedure);
-            }
-
-            return organizationUsers.Select(u => u.Id).ToList();
-        }
-
-        public async Task ReplaceManyAsync(IEnumerable<OrganizationUser> organizationUsers)
-        {
-            if (!organizationUsers.Any())
-            {
-                return;
-            }
-
-            var orgUsersTVP = organizationUsers.ToTvp();
-            using (var connection = new SqlConnection(_marsConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[{Table}_UpdateMany]",
-                    new { OrganizationUsersInput = orgUsersTVP },
-                    commandType: CommandType.StoredProcedure);
-            }
-        }
-
-        public async Task<IEnumerable<OrganizationUserPublicKey>> GetManyPublicKeysByOrganizationUserAsync(
-            Guid organizationId, IEnumerable<Guid> Ids)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationUserPublicKey>(
-                    "[dbo].[User_ReadPublicKeysByOrganizationUserIds]",
-                    new { OrganizationId = organizationId, OrganizationUserIds = Ids.ToGuidIdArrayTVP() },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.ToList();
-            }
-        }
-
-        public async Task<IEnumerable<OrganizationUserUserDetails>> GetManyByMinimumRoleAsync(Guid organizationId, OrganizationUserType minRole)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<OrganizationUserUserDetails>(
-                    "[dbo].[OrganizationUser_ReadByMinimumRole]",
-                    new { OrganizationId = organizationId, MinRole = minRole },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.ToList();
-            }
-        }
-
-        public async Task RevokeAsync(Guid id)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[{Table}_Deactivate]",
-                    new { Id = id },
-                    commandType: CommandType.StoredProcedure);
-            }
-        }
-
-        public async Task RestoreAsync(Guid id, OrganizationUserStatusType status)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[{Table}_Activate]",
-                    new { Id = id, Status = status },
-                    commandType: CommandType.StoredProcedure);
-            }
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[{Table}_Activate]",
+                new { Id = id, Status = status },
+                commandType: CommandType.StoredProcedure);
         }
     }
 }

src/Infrastructure.Dapper/Repositories/PolicyRepository.cs

@@ -6,83 +6,82 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class PolicyRepository : Repository<Policy, Guid>, IPolicyRepository
 {
-    public class PolicyRepository : Repository<Policy, Guid>, IPolicyRepository
+    public PolicyRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public PolicyRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<Policy> GetByOrganizationIdTypeAsync(Guid organizationId, PolicyType type)
     {
-        public PolicyRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public PolicyRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<Policy> GetByOrganizationIdTypeAsync(Guid organizationId, PolicyType type)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Policy>(
-                    $"[{Schema}].[{Table}_ReadByOrganizationIdType]",
-                    new { OrganizationId = organizationId, Type = (byte)type },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Policy>(
+                $"[{Schema}].[{Table}_ReadByOrganizationIdType]",
+                new { OrganizationId = organizationId, Type = (byte)type },
+                commandType: CommandType.StoredProcedure);
 
-                return results.SingleOrDefault();
-            }
+            return results.SingleOrDefault();
         }
+    }
 
-        public async Task<ICollection<Policy>> GetManyByOrganizationIdAsync(Guid organizationId)
+    public async Task<ICollection<Policy>> GetManyByOrganizationIdAsync(Guid organizationId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Policy>(
-                    $"[{Schema}].[{Table}_ReadByOrganizationId]",
-                    new { OrganizationId = organizationId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Policy>(
+                $"[{Schema}].[{Table}_ReadByOrganizationId]",
+                new { OrganizationId = organizationId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<Policy>> GetManyByUserIdAsync(Guid userId)
+    public async Task<ICollection<Policy>> GetManyByUserIdAsync(Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Policy>(
-                    $"[{Schema}].[{Table}_ReadByUserId]",
-                    new { UserId = userId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Policy>(
+                $"[{Schema}].[{Table}_ReadByUserId]",
+                new { UserId = userId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<Policy>> GetManyByTypeApplicableToUserIdAsync(Guid userId, PolicyType policyType,
-            OrganizationUserStatusType minStatus)
+    public async Task<ICollection<Policy>> GetManyByTypeApplicableToUserIdAsync(Guid userId, PolicyType policyType,
+        OrganizationUserStatusType minStatus)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Policy>(
-                    $"[{Schema}].[{Table}_ReadByTypeApplicableToUser]",
-                    new { UserId = userId, PolicyType = policyType, MinimumStatus = minStatus },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Policy>(
+                $"[{Schema}].[{Table}_ReadByTypeApplicableToUser]",
+                new { UserId = userId, PolicyType = policyType, MinimumStatus = minStatus },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<int> GetCountByTypeApplicableToUserIdAsync(Guid userId, PolicyType policyType,
-            OrganizationUserStatusType minStatus)
+    public async Task<int> GetCountByTypeApplicableToUserIdAsync(Guid userId, PolicyType policyType,
+        OrganizationUserStatusType minStatus)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var result = await connection.ExecuteScalarAsync<int>(
-                    $"[{Schema}].[{Table}_CountByTypeApplicableToUser]",
-                    new { UserId = userId, PolicyType = policyType, MinimumStatus = minStatus },
-                    commandType: CommandType.StoredProcedure);
+            var result = await connection.ExecuteScalarAsync<int>(
+                $"[{Schema}].[{Table}_CountByTypeApplicableToUser]",
+                new { UserId = userId, PolicyType = policyType, MinimumStatus = minStatus },
+                commandType: CommandType.StoredProcedure);
 
-                return result;
-            }
+            return result;
         }
     }
 }

src/Infrastructure.Dapper/Repositories/ProviderOrganizationRepository.cs

@@ -6,42 +6,41 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class ProviderOrganizationRepository : Repository<ProviderOrganization, Guid>, IProviderOrganizationRepository
 {
-    public class ProviderOrganizationRepository : Repository<ProviderOrganization, Guid>, IProviderOrganizationRepository
+    public ProviderOrganizationRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public ProviderOrganizationRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<ICollection<ProviderOrganizationOrganizationDetails>> GetManyDetailsByProviderAsync(Guid providerId)
     {
-        public ProviderOrganizationRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public ProviderOrganizationRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<ICollection<ProviderOrganizationOrganizationDetails>> GetManyDetailsByProviderAsync(Guid providerId)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<ProviderOrganizationOrganizationDetails>(
-                    "[dbo].[ProviderOrganizationOrganizationDetails_ReadByProviderId]",
-                    new { ProviderId = providerId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<ProviderOrganizationOrganizationDetails>(
+                "[dbo].[ProviderOrganizationOrganizationDetails_ReadByProviderId]",
+                new { ProviderId = providerId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ProviderOrganization> GetByOrganizationId(Guid organizationId)
+    public async Task<ProviderOrganization> GetByOrganizationId(Guid organizationId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<ProviderOrganization>(
-                    "[dbo].[ProviderOrganization_ReadByOrganizationId]",
-                    new { OrganizationId = organizationId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<ProviderOrganization>(
+                "[dbo].[ProviderOrganization_ReadByOrganizationId]",
+                new { OrganizationId = organizationId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.SingleOrDefault();
-            }
+            return results.SingleOrDefault();
         }
     }
 }

src/Infrastructure.Dapper/Repositories/ProviderRepository.cs

@@ -6,42 +6,41 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class ProviderRepository : Repository<Provider, Guid>, IProviderRepository
 {
-    public class ProviderRepository : Repository<Provider, Guid>, IProviderRepository
+    public ProviderRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public ProviderRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<ICollection<Provider>> SearchAsync(string name, string userEmail, int skip, int take)
     {
-        public ProviderRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public ProviderRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<ICollection<Provider>> SearchAsync(string name, string userEmail, int skip, int take)
+        using (var connection = new SqlConnection(ReadOnlyConnectionString))
         {
-            using (var connection = new SqlConnection(ReadOnlyConnectionString))
-            {
-                var results = await connection.QueryAsync<Provider>(
-                    "[dbo].[Provider_Search]",
-                    new { Name = name, UserEmail = userEmail, Skip = skip, Take = take },
-                    commandType: CommandType.StoredProcedure,
-                    commandTimeout: 120);
+            var results = await connection.QueryAsync<Provider>(
+                "[dbo].[Provider_Search]",
+                new { Name = name, UserEmail = userEmail, Skip = skip, Take = take },
+                commandType: CommandType.StoredProcedure,
+                commandTimeout: 120);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<ProviderAbility>> GetManyAbilitiesAsync()
+    public async Task<ICollection<ProviderAbility>> GetManyAbilitiesAsync()
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<ProviderAbility>(
-                    "[dbo].[Provider_ReadAbilities]",
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<ProviderAbility>(
+                "[dbo].[Provider_ReadAbilities]",
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
     }
 }

src/Infrastructure.Dapper/Repositories/ProviderUserRepository.cs

@@ -7,158 +7,157 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class ProviderUserRepository : Repository<ProviderUser, Guid>, IProviderUserRepository
 {
-    public class ProviderUserRepository : Repository<ProviderUser, Guid>, IProviderUserRepository
+    public ProviderUserRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public ProviderUserRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<int> GetCountByProviderAsync(Guid providerId, string email, bool onlyRegisteredUsers)
     {
-        public ProviderUserRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public ProviderUserRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<int> GetCountByProviderAsync(Guid providerId, string email, bool onlyRegisteredUsers)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var result = await connection.ExecuteScalarAsync<int>(
-                    "[dbo].[ProviderUser_ReadCountByProviderIdEmail]",
-                    new { ProviderId = providerId, Email = email, OnlyUsers = onlyRegisteredUsers },
-                    commandType: CommandType.StoredProcedure);
+            var result = await connection.ExecuteScalarAsync<int>(
+                "[dbo].[ProviderUser_ReadCountByProviderIdEmail]",
+                new { ProviderId = providerId, Email = email, OnlyUsers = onlyRegisteredUsers },
+                commandType: CommandType.StoredProcedure);
 
-                return result;
-            }
+            return result;
         }
+    }
 
-        public async Task<ICollection<ProviderUser>> GetManyAsync(IEnumerable<Guid> ids)
+    public async Task<ICollection<ProviderUser>> GetManyAsync(IEnumerable<Guid> ids)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<ProviderUser>(
-                    "[dbo].[ProviderUser_ReadByIds]",
-                    new { Ids = ids.ToGuidIdArrayTVP() },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<ProviderUser>(
+                "[dbo].[ProviderUser_ReadByIds]",
+                new { Ids = ids.ToGuidIdArrayTVP() },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<ProviderUser>> GetManyByUserAsync(Guid userId)
+    public async Task<ICollection<ProviderUser>> GetManyByUserAsync(Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<ProviderUser>(
-                    "[dbo].[ProviderUser_ReadByUserId]",
-                    new { UserId = userId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<ProviderUser>(
+                "[dbo].[ProviderUser_ReadByUserId]",
+                new { UserId = userId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ProviderUser> GetByProviderUserAsync(Guid providerId, Guid userId)
+    public async Task<ProviderUser> GetByProviderUserAsync(Guid providerId, Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<ProviderUser>(
-                    "[dbo].[ProviderUser_ReadByProviderIdUserId]",
-                    new { ProviderId = providerId, UserId = userId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<ProviderUser>(
+                "[dbo].[ProviderUser_ReadByProviderIdUserId]",
+                new { ProviderId = providerId, UserId = userId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.SingleOrDefault();
-            }
+            return results.SingleOrDefault();
         }
+    }
 
-        public async Task<ICollection<ProviderUser>> GetManyByProviderAsync(Guid providerId, ProviderUserType? type)
+    public async Task<ICollection<ProviderUser>> GetManyByProviderAsync(Guid providerId, ProviderUserType? type)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<ProviderUser>(
-                    "[dbo].[ProviderUser_ReadByProviderId]",
-                    new { ProviderId = providerId, Type = type },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<ProviderUser>(
+                "[dbo].[ProviderUser_ReadByProviderId]",
+                new { ProviderId = providerId, Type = type },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<ProviderUserUserDetails>> GetManyDetailsByProviderAsync(Guid providerId)
+    public async Task<ICollection<ProviderUserUserDetails>> GetManyDetailsByProviderAsync(Guid providerId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<ProviderUserUserDetails>(
-                    "[dbo].[ProviderUserUserDetails_ReadByProviderId]",
-                    new { ProviderId = providerId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<ProviderUserUserDetails>(
+                "[dbo].[ProviderUserUserDetails_ReadByProviderId]",
+                new { ProviderId = providerId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<ProviderUserProviderDetails>> GetManyDetailsByUserAsync(Guid userId,
-            ProviderUserStatusType? status = null)
+    public async Task<ICollection<ProviderUserProviderDetails>> GetManyDetailsByUserAsync(Guid userId,
+        ProviderUserStatusType? status = null)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<ProviderUserProviderDetails>(
-                    "[dbo].[ProviderUserProviderDetails_ReadByUserIdStatus]",
-                    new { UserId = userId, Status = status },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<ProviderUserProviderDetails>(
+                "[dbo].[ProviderUserProviderDetails_ReadByUserIdStatus]",
+                new { UserId = userId, Status = status },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<IEnumerable<ProviderUserOrganizationDetails>> GetManyOrganizationDetailsByUserAsync(Guid userId,
-            ProviderUserStatusType? status = null)
+    public async Task<IEnumerable<ProviderUserOrganizationDetails>> GetManyOrganizationDetailsByUserAsync(Guid userId,
+        ProviderUserStatusType? status = null)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<ProviderUserOrganizationDetails>(
-                    "[dbo].[ProviderUserProviderOrganizationDetails_ReadByUserIdStatus]",
-                    new { UserId = userId, Status = status },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<ProviderUserOrganizationDetails>(
+                "[dbo].[ProviderUserProviderOrganizationDetails_ReadByUserIdStatus]",
+                new { UserId = userId, Status = status },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task DeleteManyAsync(IEnumerable<Guid> providerUserIds)
+    public async Task DeleteManyAsync(IEnumerable<Guid> providerUserIds)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync("[dbo].[ProviderUser_DeleteByIds]",
-                    new { Ids = providerUserIds.ToGuidIdArrayTVP() }, commandType: CommandType.StoredProcedure);
-            }
+            await connection.ExecuteAsync("[dbo].[ProviderUser_DeleteByIds]",
+                new { Ids = providerUserIds.ToGuidIdArrayTVP() }, commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public async Task<IEnumerable<ProviderUserPublicKey>> GetManyPublicKeysByProviderUserAsync(
-            Guid providerId, IEnumerable<Guid> Ids)
+    public async Task<IEnumerable<ProviderUserPublicKey>> GetManyPublicKeysByProviderUserAsync(
+        Guid providerId, IEnumerable<Guid> Ids)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<ProviderUserPublicKey>(
-                    "[dbo].[User_ReadPublicKeysByProviderUserIds]",
-                    new { ProviderId = providerId, ProviderUserIds = Ids.ToGuidIdArrayTVP() },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<ProviderUserPublicKey>(
+                "[dbo].[User_ReadPublicKeysByProviderUserIds]",
+                new { ProviderId = providerId, ProviderUserIds = Ids.ToGuidIdArrayTVP() },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<int> GetCountByOnlyOwnerAsync(Guid userId)
+    public async Task<int> GetCountByOnlyOwnerAsync(Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteScalarAsync<int>(
-                    "[dbo].[ProviderUser_ReadCountByOnlyOwner]",
-                    new { UserId = userId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.ExecuteScalarAsync<int>(
+                "[dbo].[ProviderUser_ReadCountByOnlyOwner]",
+                new { UserId = userId },
+                commandType: CommandType.StoredProcedure);
 
-                return results;
-            }
+            return results;
         }
     }
 }

src/Infrastructure.Dapper/Repositories/Repository.cs

@@ -4,92 +4,91 @@ using Bit.Core.Entities;
 using Bit.Core.Repositories;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public abstract class Repository<T, TId> : BaseRepository, IRepository<T, TId>
+    where TId : IEquatable<TId>
+    where T : class, ITableObject<TId>
 {
-    public abstract class Repository<T, TId> : BaseRepository, IRepository<T, TId>
-        where TId : IEquatable<TId>
-        where T : class, ITableObject<TId>
+    public Repository(string connectionString, string readOnlyConnectionString,
+        string schema = null, string table = null)
+        : base(connectionString, readOnlyConnectionString)
     {
-        public Repository(string connectionString, string readOnlyConnectionString,
-            string schema = null, string table = null)
-            : base(connectionString, readOnlyConnectionString)
+        if (!string.IsNullOrWhiteSpace(table))
         {
-            if (!string.IsNullOrWhiteSpace(table))
-            {
-                Table = table;
-            }
-
-            if (!string.IsNullOrWhiteSpace(schema))
-            {
-                Schema = schema;
-            }
+            Table = table;
         }
 
-        protected string Schema { get; private set; } = "dbo";
-        protected string Table { get; private set; } = typeof(T).Name;
-
-        public virtual async Task<T> GetByIdAsync(TId id)
+        if (!string.IsNullOrWhiteSpace(schema))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<T>(
-                    $"[{Schema}].[{Table}_ReadById]",
-                    new { Id = id },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.SingleOrDefault();
-            }
+            Schema = schema;
         }
+    }
 
-        public virtual async Task<T> CreateAsync(T obj)
+    protected string Schema { get; private set; } = "dbo";
+    protected string Table { get; private set; } = typeof(T).Name;
+
+    public virtual async Task<T> GetByIdAsync(TId id)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            obj.SetNewId();
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var parameters = new DynamicParameters();
-                parameters.AddDynamicParams(obj);
-                parameters.Add("Id", obj.Id, direction: ParameterDirection.InputOutput);
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[{Table}_Create]",
-                    parameters,
-                    commandType: CommandType.StoredProcedure);
-                obj.Id = parameters.Get<TId>(nameof(obj.Id));
-            }
-            return obj;
+            var results = await connection.QueryAsync<T>(
+                $"[{Schema}].[{Table}_ReadById]",
+                new { Id = id },
+                commandType: CommandType.StoredProcedure);
+
+            return results.SingleOrDefault();
         }
+    }
 
-        public virtual async Task ReplaceAsync(T obj)
+    public virtual async Task<T> CreateAsync(T obj)
+    {
+        obj.SetNewId();
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[{Table}_Update]",
-                    obj,
-                    commandType: CommandType.StoredProcedure);
-            }
+            var parameters = new DynamicParameters();
+            parameters.AddDynamicParams(obj);
+            parameters.Add("Id", obj.Id, direction: ParameterDirection.InputOutput);
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[{Table}_Create]",
+                parameters,
+                commandType: CommandType.StoredProcedure);
+            obj.Id = parameters.Get<TId>(nameof(obj.Id));
         }
+        return obj;
+    }
 
-        public virtual async Task UpsertAsync(T obj)
+    public virtual async Task ReplaceAsync(T obj)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            if (obj.Id.Equals(default(TId)))
-            {
-                await CreateAsync(obj);
-            }
-            else
-            {
-                await ReplaceAsync(obj);
-            }
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[{Table}_Update]",
+                obj,
+                commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public virtual async Task DeleteAsync(T obj)
+    public virtual async Task UpsertAsync(T obj)
+    {
+        if (obj.Id.Equals(default(TId)))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync(
-                    $"[{Schema}].[{Table}_DeleteById]",
-                    new { Id = obj.Id },
-                    commandType: CommandType.StoredProcedure);
-            }
+            await CreateAsync(obj);
+        }
+        else
+        {
+            await ReplaceAsync(obj);
+        }
+    }
+
+    public virtual async Task DeleteAsync(T obj)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
+        {
+            await connection.ExecuteAsync(
+                $"[{Schema}].[{Table}_DeleteById]",
+                new { Id = obj.Id },
+                commandType: CommandType.StoredProcedure);
         }
     }
 }

src/Infrastructure.Dapper/Repositories/SendRepository.cs

@@ -5,42 +5,41 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class SendRepository : Repository<Send, Guid>, ISendRepository
 {
-    public class SendRepository : Repository<Send, Guid>, ISendRepository
+    public SendRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public SendRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<ICollection<Send>> GetManyByUserIdAsync(Guid userId)
     {
-        public SendRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public SendRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<ICollection<Send>> GetManyByUserIdAsync(Guid userId)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Send>(
-                    $"[{Schema}].[Send_ReadByUserId]",
-                    new { UserId = userId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Send>(
+                $"[{Schema}].[Send_ReadByUserId]",
+                new { UserId = userId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<Send>> GetManyByDeletionDateAsync(DateTime deletionDateBefore)
+    public async Task<ICollection<Send>> GetManyByDeletionDateAsync(DateTime deletionDateBefore)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Send>(
-                    $"[{Schema}].[Send_ReadByDeletionDateBefore]",
-                    new { DeletionDate = deletionDateBefore },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Send>(
+                $"[{Schema}].[Send_ReadByDeletionDateBefore]",
+                new { DeletionDate = deletionDateBefore },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
     }
 }

src/Infrastructure.Dapper/Repositories/SsoConfigRepository.cs

@@ -5,55 +5,54 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class SsoConfigRepository : Repository<SsoConfig, long>, ISsoConfigRepository
 {
-    public class SsoConfigRepository : Repository<SsoConfig, long>, ISsoConfigRepository
+    public SsoConfigRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public SsoConfigRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<SsoConfig> GetByOrganizationIdAsync(Guid organizationId)
     {
-        public SsoConfigRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public SsoConfigRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<SsoConfig> GetByOrganizationIdAsync(Guid organizationId)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<SsoConfig>(
-                    $"[{Schema}].[{Table}_ReadByOrganizationId]",
-                    new { OrganizationId = organizationId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<SsoConfig>(
+                $"[{Schema}].[{Table}_ReadByOrganizationId]",
+                new { OrganizationId = organizationId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.SingleOrDefault();
-            }
+            return results.SingleOrDefault();
         }
+    }
 
-        public async Task<SsoConfig> GetByIdentifierAsync(string identifier)
+    public async Task<SsoConfig> GetByIdentifierAsync(string identifier)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<SsoConfig>(
-                    $"[{Schema}].[{Table}_ReadByIdentifier]",
-                    new { Identifier = identifier },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<SsoConfig>(
+                $"[{Schema}].[{Table}_ReadByIdentifier]",
+                new { Identifier = identifier },
+                commandType: CommandType.StoredProcedure);
 
-                return results.SingleOrDefault();
-            }
+            return results.SingleOrDefault();
         }
+    }
 
-        public async Task<ICollection<SsoConfig>> GetManyByRevisionNotBeforeDate(DateTime? notBefore)
+    public async Task<ICollection<SsoConfig>> GetManyByRevisionNotBeforeDate(DateTime? notBefore)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<SsoConfig>(
-                    $"[{Schema}].[{Table}_ReadManyByNotBeforeRevisionDate]",
-                    new { NotBefore = notBefore },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<SsoConfig>(
+                $"[{Schema}].[{Table}_ReadManyByNotBeforeRevisionDate]",
+                new { NotBefore = notBefore },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
     }
 }

src/Infrastructure.Dapper/Repositories/SsoUserRepository.cs

@@ -5,40 +5,39 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class SsoUserRepository : Repository<SsoUser, long>, ISsoUserRepository
 {
-    public class SsoUserRepository : Repository<SsoUser, long>, ISsoUserRepository
+    public SsoUserRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public SsoUserRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task DeleteAsync(Guid userId, Guid? organizationId)
     {
-        public SsoUserRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public SsoUserRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task DeleteAsync(Guid userId, Guid? organizationId)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[SsoUser_Delete]",
-                    new { UserId = userId, OrganizationId = organizationId },
-                    commandType: CommandType.StoredProcedure);
-            }
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[SsoUser_Delete]",
+                new { UserId = userId, OrganizationId = organizationId },
+                commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public async Task<SsoUser> GetByUserIdOrganizationIdAsync(Guid organizationId, Guid userId)
+    public async Task<SsoUser> GetByUserIdOrganizationIdAsync(Guid organizationId, Guid userId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<SsoUser>(
-                    $"[{Schema}].[SsoUser_ReadByUserIdOrganizationId]",
-                    new { UserId = userId, OrganizationId = organizationId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<SsoUser>(
+                $"[{Schema}].[SsoUser_ReadByUserIdOrganizationId]",
+                new { UserId = userId, OrganizationId = organizationId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.SingleOrDefault();
-            }
+            return results.SingleOrDefault();
         }
     }
 }

src/Infrastructure.Dapper/Repositories/TaxRateRepository.cs

@@ -5,65 +5,64 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class TaxRateRepository : Repository<TaxRate, string>, ITaxRateRepository
 {
-    public class TaxRateRepository : Repository<TaxRate, string>, ITaxRateRepository
+    public TaxRateRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public TaxRateRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<ICollection<TaxRate>> SearchAsync(int skip, int count)
     {
-        public TaxRateRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public TaxRateRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<ICollection<TaxRate>> SearchAsync(int skip, int count)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<TaxRate>(
-                    $"[{Schema}].[TaxRate_Search]",
-                    new { Skip = skip, Count = count },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<TaxRate>(
+                $"[{Schema}].[TaxRate_Search]",
+                new { Skip = skip, Count = count },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<TaxRate>> GetAllActiveAsync()
+    public async Task<ICollection<TaxRate>> GetAllActiveAsync()
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<TaxRate>(
-                    $"[{Schema}].[TaxRate_ReadAllActive]",
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<TaxRate>(
+                $"[{Schema}].[TaxRate_ReadAllActive]",
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task ArchiveAsync(TaxRate model)
+    public async Task ArchiveAsync(TaxRate model)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.ExecuteAsync(
-                    $"[{Schema}].[TaxRate_Archive]",
-                    new { Id = model.Id },
-                    commandType: CommandType.StoredProcedure);
-            }
+            var results = await connection.ExecuteAsync(
+                $"[{Schema}].[TaxRate_Archive]",
+                new { Id = model.Id },
+                commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public async Task<ICollection<TaxRate>> GetByLocationAsync(TaxRate model)
+    public async Task<ICollection<TaxRate>> GetByLocationAsync(TaxRate model)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<TaxRate>(
-                    $"[{Schema}].[TaxRate_ReadByLocation]",
-                    new { Country = model.Country, PostalCode = model.PostalCode },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<TaxRate>(
+                $"[{Schema}].[TaxRate_ReadByLocation]",
+                new { Country = model.Country, PostalCode = model.PostalCode },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
     }
 }

src/Infrastructure.Dapper/Repositories/TransactionRepository.cs

@@ -6,55 +6,54 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class TransactionRepository : Repository<Transaction, Guid>, ITransactionRepository
 {
-    public class TransactionRepository : Repository<Transaction, Guid>, ITransactionRepository
+    public TransactionRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public TransactionRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public async Task<ICollection<Transaction>> GetManyByUserIdAsync(Guid userId)
     {
-        public TransactionRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
-
-        public TransactionRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public async Task<ICollection<Transaction>> GetManyByUserIdAsync(Guid userId)
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Transaction>(
-                    $"[{Schema}].[Transaction_ReadByUserId]",
-                    new { UserId = userId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Transaction>(
+                $"[{Schema}].[Transaction_ReadByUserId]",
+                new { UserId = userId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<Transaction>> GetManyByOrganizationIdAsync(Guid organizationId)
+    public async Task<ICollection<Transaction>> GetManyByOrganizationIdAsync(Guid organizationId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Transaction>(
-                    $"[{Schema}].[Transaction_ReadByOrganizationId]",
-                    new { OrganizationId = organizationId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Transaction>(
+                $"[{Schema}].[Transaction_ReadByOrganizationId]",
+                new { OrganizationId = organizationId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<Transaction> GetByGatewayIdAsync(GatewayType gatewayType, string gatewayId)
+    public async Task<Transaction> GetByGatewayIdAsync(GatewayType gatewayType, string gatewayId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<Transaction>(
-                    $"[{Schema}].[Transaction_ReadByGatewayId]",
-                    new { Gateway = gatewayType, GatewayId = gatewayId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<Transaction>(
+                $"[{Schema}].[Transaction_ReadByGatewayId]",
+                new { Gateway = gatewayType, GatewayId = gatewayId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.SingleOrDefault();
-            }
+            return results.SingleOrDefault();
         }
     }
 }

src/Infrastructure.Dapper/Repositories/UserRepository.cs

@@ -6,166 +6,165 @@ using Bit.Core.Repositories;
 using Bit.Core.Settings;
 using Dapper;
 
-namespace Bit.Infrastructure.Dapper.Repositories
+namespace Bit.Infrastructure.Dapper.Repositories;
+
+public class UserRepository : Repository<User, Guid>, IUserRepository
 {
-    public class UserRepository : Repository<User, Guid>, IUserRepository
+    public UserRepository(GlobalSettings globalSettings)
+        : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+    { }
+
+    public UserRepository(string connectionString, string readOnlyConnectionString)
+        : base(connectionString, readOnlyConnectionString)
+    { }
+
+    public override async Task<User> GetByIdAsync(Guid id)
     {
-        public UserRepository(GlobalSettings globalSettings)
-            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
-        { }
+        return await base.GetByIdAsync(id);
+    }
 
-        public UserRepository(string connectionString, string readOnlyConnectionString)
-            : base(connectionString, readOnlyConnectionString)
-        { }
-
-        public override async Task<User> GetByIdAsync(Guid id)
+    public async Task<User> GetByEmailAsync(string email)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            return await base.GetByIdAsync(id);
+            var results = await connection.QueryAsync<User>(
+                $"[{Schema}].[{Table}_ReadByEmail]",
+                new { Email = email },
+                commandType: CommandType.StoredProcedure);
+
+            return results.SingleOrDefault();
         }
+    }
 
-        public async Task<User> GetByEmailAsync(string email)
+    public async Task<User> GetBySsoUserAsync(string externalId, Guid? organizationId)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<User>(
-                    $"[{Schema}].[{Table}_ReadByEmail]",
-                    new { Email = email },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<User>(
+                $"[{Schema}].[{Table}_ReadBySsoUserOrganizationIdExternalId]",
+                new { OrganizationId = organizationId, ExternalId = externalId },
+                commandType: CommandType.StoredProcedure);
 
-                return results.SingleOrDefault();
-            }
+            return results.SingleOrDefault();
         }
+    }
 
-        public async Task<User> GetBySsoUserAsync(string externalId, Guid? organizationId)
+    public async Task<UserKdfInformation> GetKdfInformationByEmailAsync(string email)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<User>(
-                    $"[{Schema}].[{Table}_ReadBySsoUserOrganizationIdExternalId]",
-                    new { OrganizationId = organizationId, ExternalId = externalId },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<UserKdfInformation>(
+                $"[{Schema}].[{Table}_ReadKdfByEmail]",
+                new { Email = email },
+                commandType: CommandType.StoredProcedure);
 
-                return results.SingleOrDefault();
-            }
+            return results.SingleOrDefault();
         }
+    }
 
-        public async Task<UserKdfInformation> GetKdfInformationByEmailAsync(string email)
+    public async Task<ICollection<User>> SearchAsync(string email, int skip, int take)
+    {
+        using (var connection = new SqlConnection(ReadOnlyConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<UserKdfInformation>(
-                    $"[{Schema}].[{Table}_ReadKdfByEmail]",
-                    new { Email = email },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<User>(
+                $"[{Schema}].[{Table}_Search]",
+                new { Email = email, Skip = skip, Take = take },
+                commandType: CommandType.StoredProcedure,
+                commandTimeout: 120);
 
-                return results.SingleOrDefault();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<User>> SearchAsync(string email, int skip, int take)
+    public async Task<ICollection<User>> GetManyByPremiumAsync(bool premium)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ReadOnlyConnectionString))
-            {
-                var results = await connection.QueryAsync<User>(
-                    $"[{Schema}].[{Table}_Search]",
-                    new { Email = email, Skip = skip, Take = take },
-                    commandType: CommandType.StoredProcedure,
-                    commandTimeout: 120);
+            var results = await connection.QueryAsync<User>(
+                "[dbo].[User_ReadByPremium]",
+                new { Premium = premium },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.ToList();
         }
+    }
 
-        public async Task<ICollection<User>> GetManyByPremiumAsync(bool premium)
+    public async Task<string> GetPublicKeyAsync(Guid id)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<User>(
-                    "[dbo].[User_ReadByPremium]",
-                    new { Premium = premium },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<string>(
+                $"[{Schema}].[{Table}_ReadPublicKeyById]",
+                new { Id = id },
+                commandType: CommandType.StoredProcedure);
 
-                return results.ToList();
-            }
+            return results.SingleOrDefault();
         }
+    }
 
-        public async Task<string> GetPublicKeyAsync(Guid id)
+    public async Task<DateTime> GetAccountRevisionDateAsync(Guid id)
+    {
+        using (var connection = new SqlConnection(ReadOnlyConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                var results = await connection.QueryAsync<string>(
-                    $"[{Schema}].[{Table}_ReadPublicKeyById]",
-                    new { Id = id },
-                    commandType: CommandType.StoredProcedure);
+            var results = await connection.QueryAsync<DateTime>(
+                $"[{Schema}].[{Table}_ReadAccountRevisionDateById]",
+                new { Id = id },
+                commandType: CommandType.StoredProcedure);
 
-                return results.SingleOrDefault();
-            }
+            return results.SingleOrDefault();
         }
+    }
 
-        public async Task<DateTime> GetAccountRevisionDateAsync(Guid id)
+    public override async Task ReplaceAsync(User user)
+    {
+        await base.ReplaceAsync(user);
+    }
+
+    public override async Task DeleteAsync(User user)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ReadOnlyConnectionString))
-            {
-                var results = await connection.QueryAsync<DateTime>(
-                    $"[{Schema}].[{Table}_ReadAccountRevisionDateById]",
-                    new { Id = id },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.SingleOrDefault();
-            }
+            await connection.ExecuteAsync(
+                $"[{Schema}].[{Table}_DeleteById]",
+                new { Id = user.Id },
+                commandType: CommandType.StoredProcedure,
+                commandTimeout: 180);
         }
+    }
 
-        public override async Task ReplaceAsync(User user)
+    public async Task UpdateStorageAsync(Guid id)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            await base.ReplaceAsync(user);
+            await connection.ExecuteAsync(
+                $"[{Schema}].[{Table}_UpdateStorage]",
+                new { Id = id },
+                commandType: CommandType.StoredProcedure,
+                commandTimeout: 180);
         }
+    }
 
-        public override async Task DeleteAsync(User user)
+    public async Task UpdateRenewalReminderDateAsync(Guid id, DateTime renewalReminderDate)
+    {
+        using (var connection = new SqlConnection(ConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync(
-                    $"[{Schema}].[{Table}_DeleteById]",
-                    new { Id = user.Id },
-                    commandType: CommandType.StoredProcedure,
-                    commandTimeout: 180);
-            }
+            await connection.ExecuteAsync(
+                $"[{Schema}].[User_UpdateRenewalReminderDate]",
+                new { Id = id, RenewalReminderDate = renewalReminderDate },
+                commandType: CommandType.StoredProcedure);
         }
+    }
 
-        public async Task UpdateStorageAsync(Guid id)
+    public async Task<IEnumerable<User>> GetManyAsync(IEnumerable<Guid> ids)
+    {
+        using (var connection = new SqlConnection(ReadOnlyConnectionString))
         {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync(
-                    $"[{Schema}].[{Table}_UpdateStorage]",
-                    new { Id = id },
-                    commandType: CommandType.StoredProcedure,
-                    commandTimeout: 180);
-            }
-        }
+            var results = await connection.QueryAsync<User>(
+                $"[{Schema}].[{Table}_ReadByIds]",
+                new { Ids = ids.ToGuidIdArrayTVP() },
+                commandType: CommandType.StoredProcedure);
 
-        public async Task UpdateRenewalReminderDateAsync(Guid id, DateTime renewalReminderDate)
-        {
-            using (var connection = new SqlConnection(ConnectionString))
-            {
-                await connection.ExecuteAsync(
-                    $"[{Schema}].[User_UpdateRenewalReminderDate]",
-                    new { Id = id, RenewalReminderDate = renewalReminderDate },
-                    commandType: CommandType.StoredProcedure);
-            }
-        }
-
-        public async Task<IEnumerable<User>> GetManyAsync(IEnumerable<Guid> ids)
-        {
-            using (var connection = new SqlConnection(ReadOnlyConnectionString))
-            {
-                var results = await connection.QueryAsync<User>(
-                    $"[{Schema}].[{Table}_ReadByIds]",
-                    new { Ids = ids.ToGuidIdArrayTVP() },
-                    commandType: CommandType.StoredProcedure);
-
-                return results.ToList();
-            }
+            return results.ToList();
         }
     }
 }