Revert filescoped (#2227)

* Revert "Add git blame entry (#2226)"

This reverts commit 239286737d.

* Revert "Turn on file scoped namespaces (#2225)"

This reverts commit 34fb4cca2a.

src/Infrastructure.EntityFramework/Repositories/UserRepository.cs

@@ -5,141 +5,142 @@ using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 using DataModel = Bit.Core.Models.Data;
 
-namespace Bit.Infrastructure.EntityFramework.Repositories;
-
-public class UserRepository : Repository<Core.Entities.User, User, Guid>, IUserRepository
+namespace Bit.Infrastructure.EntityFramework.Repositories
 {
-    public UserRepository(IServiceScopeFactory serviceScopeFactory, IMapper mapper)
-        : base(serviceScopeFactory, mapper, (DatabaseContext context) => context.Users)
-    { }
-
-    public async Task<Core.Entities.User> GetByEmailAsync(string email)
+    public class UserRepository : Repository<Core.Entities.User, User, Guid>, IUserRepository
     {
-        using (var scope = ServiceScopeFactory.CreateScope())
+        public UserRepository(IServiceScopeFactory serviceScopeFactory, IMapper mapper)
+            : base(serviceScopeFactory, mapper, (DatabaseContext context) => context.Users)
+        { }
+
+        public async Task<Core.Entities.User> GetByEmailAsync(string email)
         {
-            var dbContext = GetDatabaseContext(scope);
-            var entity = await GetDbSet(dbContext).FirstOrDefaultAsync(e => e.Email == email);
-            return Mapper.Map<Core.Entities.User>(entity);
+            using (var scope = ServiceScopeFactory.CreateScope())
+            {
+                var dbContext = GetDatabaseContext(scope);
+                var entity = await GetDbSet(dbContext).FirstOrDefaultAsync(e => e.Email == email);
+                return Mapper.Map<Core.Entities.User>(entity);
+            }
         }
-    }
 
-    public async Task<DataModel.UserKdfInformation> GetKdfInformationByEmailAsync(string email)
-    {
-        using (var scope = ServiceScopeFactory.CreateScope())
+        public async Task<DataModel.UserKdfInformation> GetKdfInformationByEmailAsync(string email)
         {
-            var dbContext = GetDatabaseContext(scope);
-            return await GetDbSet(dbContext).Where(e => e.Email == email)
-                .Select(e => new DataModel.UserKdfInformation
+            using (var scope = ServiceScopeFactory.CreateScope())
+            {
+                var dbContext = GetDatabaseContext(scope);
+                return await GetDbSet(dbContext).Where(e => e.Email == email)
+                    .Select(e => new DataModel.UserKdfInformation
+                    {
+                        Kdf = e.Kdf,
+                        KdfIterations = e.KdfIterations
+                    }).SingleOrDefaultAsync();
+            }
+        }
+
+        public async Task<ICollection<Core.Entities.User>> SearchAsync(string email, int skip, int take)
+        {
+            using (var scope = ServiceScopeFactory.CreateScope())
+            {
+                var dbContext = GetDatabaseContext(scope);
+                List<User> users;
+                if (dbContext.Database.IsNpgsql())
                 {
-                    Kdf = e.Kdf,
-                    KdfIterations = e.KdfIterations
-                }).SingleOrDefaultAsync();
-        }
-    }
-
-    public async Task<ICollection<Core.Entities.User>> SearchAsync(string email, int skip, int take)
-    {
-        using (var scope = ServiceScopeFactory.CreateScope())
-        {
-            var dbContext = GetDatabaseContext(scope);
-            List<User> users;
-            if (dbContext.Database.IsNpgsql())
-            {
-                users = await GetDbSet(dbContext)
-                    .Where(e => e.Email == null ||
-                        EF.Functions.ILike(EF.Functions.Collate(e.Email, "default"), "a%"))
-                    .OrderBy(e => e.Email)
-                    .Skip(skip).Take(take)
-                    .ToListAsync();
+                    users = await GetDbSet(dbContext)
+                        .Where(e => e.Email == null ||
+                            EF.Functions.ILike(EF.Functions.Collate(e.Email, "default"), "a%"))
+                        .OrderBy(e => e.Email)
+                        .Skip(skip).Take(take)
+                        .ToListAsync();
+                }
+                else
+                {
+                    users = await GetDbSet(dbContext)
+                        .Where(e => email == null || e.Email.StartsWith(email))
+                        .OrderBy(e => e.Email)
+                        .Skip(skip).Take(take)
+                        .ToListAsync();
+                }
+                return Mapper.Map<List<Core.Entities.User>>(users);
             }
-            else
+        }
+
+        public async Task<ICollection<Core.Entities.User>> GetManyByPremiumAsync(bool premium)
+        {
+            using (var scope = ServiceScopeFactory.CreateScope())
             {
-                users = await GetDbSet(dbContext)
-                    .Where(e => email == null || e.Email.StartsWith(email))
-                    .OrderBy(e => e.Email)
-                    .Skip(skip).Take(take)
-                    .ToListAsync();
+                var dbContext = GetDatabaseContext(scope);
+                var users = await GetDbSet(dbContext).Where(e => e.Premium == premium).ToListAsync();
+                return Mapper.Map<List<Core.Entities.User>>(users);
             }
-            return Mapper.Map<List<Core.Entities.User>>(users);
         }
-    }
 
-    public async Task<ICollection<Core.Entities.User>> GetManyByPremiumAsync(bool premium)
-    {
-        using (var scope = ServiceScopeFactory.CreateScope())
+        public async Task<string> GetPublicKeyAsync(Guid id)
         {
-            var dbContext = GetDatabaseContext(scope);
-            var users = await GetDbSet(dbContext).Where(e => e.Premium == premium).ToListAsync();
-            return Mapper.Map<List<Core.Entities.User>>(users);
-        }
-    }
-
-    public async Task<string> GetPublicKeyAsync(Guid id)
-    {
-        using (var scope = ServiceScopeFactory.CreateScope())
-        {
-            var dbContext = GetDatabaseContext(scope);
-            return await GetDbSet(dbContext).Where(e => e.Id == id).Select(e => e.PublicKey).SingleOrDefaultAsync();
-        }
-    }
-
-    public async Task<DateTime> GetAccountRevisionDateAsync(Guid id)
-    {
-        using (var scope = ServiceScopeFactory.CreateScope())
-        {
-            var dbContext = GetDatabaseContext(scope);
-            return await GetDbSet(dbContext).Where(e => e.Id == id).Select(e => e.AccountRevisionDate)
-                .SingleOrDefaultAsync();
-        }
-    }
-
-    public async Task UpdateStorageAsync(Guid id)
-    {
-        await base.UserUpdateStorage(id);
-    }
-
-    public async Task UpdateRenewalReminderDateAsync(Guid id, DateTime renewalReminderDate)
-    {
-        using (var scope = ServiceScopeFactory.CreateScope())
-        {
-            var dbContext = GetDatabaseContext(scope);
-            var user = new User
+            using (var scope = ServiceScopeFactory.CreateScope())
             {
-                Id = id,
-                RenewalReminderDate = renewalReminderDate,
-            };
-            var set = GetDbSet(dbContext);
-            set.Attach(user);
-            dbContext.Entry(user).Property(e => e.RenewalReminderDate).IsModified = true;
-            await dbContext.SaveChangesAsync();
-        }
-    }
-
-    public async Task<Core.Entities.User> GetBySsoUserAsync(string externalId, Guid? organizationId)
-    {
-        using (var scope = ServiceScopeFactory.CreateScope())
-        {
-            var dbContext = GetDatabaseContext(scope);
-            var ssoUser = await dbContext.SsoUsers.SingleOrDefaultAsync(e =>
-                e.OrganizationId == organizationId && e.ExternalId == externalId);
-
-            if (ssoUser == null)
-            {
-                return null;
+                var dbContext = GetDatabaseContext(scope);
+                return await GetDbSet(dbContext).Where(e => e.Id == id).Select(e => e.PublicKey).SingleOrDefaultAsync();
             }
-
-            var entity = await dbContext.Users.SingleOrDefaultAsync(e => e.Id == ssoUser.UserId);
-            return Mapper.Map<Core.Entities.User>(entity);
         }
-    }
 
-    public async Task<IEnumerable<Core.Entities.User>> GetManyAsync(IEnumerable<Guid> ids)
-    {
-        using (var scope = ServiceScopeFactory.CreateScope())
+        public async Task<DateTime> GetAccountRevisionDateAsync(Guid id)
         {
-            var dbContext = GetDatabaseContext(scope);
-            var users = dbContext.Users.Where(x => ids.Contains(x.Id));
-            return await users.ToListAsync();
+            using (var scope = ServiceScopeFactory.CreateScope())
+            {
+                var dbContext = GetDatabaseContext(scope);
+                return await GetDbSet(dbContext).Where(e => e.Id == id).Select(e => e.AccountRevisionDate)
+                    .SingleOrDefaultAsync();
+            }
+        }
+
+        public async Task UpdateStorageAsync(Guid id)
+        {
+            await base.UserUpdateStorage(id);
+        }
+
+        public async Task UpdateRenewalReminderDateAsync(Guid id, DateTime renewalReminderDate)
+        {
+            using (var scope = ServiceScopeFactory.CreateScope())
+            {
+                var dbContext = GetDatabaseContext(scope);
+                var user = new User
+                {
+                    Id = id,
+                    RenewalReminderDate = renewalReminderDate,
+                };
+                var set = GetDbSet(dbContext);
+                set.Attach(user);
+                dbContext.Entry(user).Property(e => e.RenewalReminderDate).IsModified = true;
+                await dbContext.SaveChangesAsync();
+            }
+        }
+
+        public async Task<Core.Entities.User> GetBySsoUserAsync(string externalId, Guid? organizationId)
+        {
+            using (var scope = ServiceScopeFactory.CreateScope())
+            {
+                var dbContext = GetDatabaseContext(scope);
+                var ssoUser = await dbContext.SsoUsers.SingleOrDefaultAsync(e =>
+                    e.OrganizationId == organizationId && e.ExternalId == externalId);
+
+                if (ssoUser == null)
+                {
+                    return null;
+                }
+
+                var entity = await dbContext.Users.SingleOrDefaultAsync(e => e.Id == ssoUser.UserId);
+                return Mapper.Map<Core.Entities.User>(entity);
+            }
+        }
+
+        public async Task<IEnumerable<Core.Entities.User>> GetManyAsync(IEnumerable<Guid> ids)
+        {
+            using (var scope = ServiceScopeFactory.CreateScope())
+            {
+                var dbContext = GetDatabaseContext(scope);
+                var users = dbContext.Users.Where(x => ids.Contains(x.Id));
+                return await users.ToListAsync();
+            }
         }
     }
 }