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/Events/Controllers/CollectController.cs

@@ -8,98 +8,99 @@ using Bit.Events.Models;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
-namespace Bit.Events.Controllers;
-
-[Route("collect")]
-[Authorize("Application")]
-public class CollectController : Controller
+namespace Bit.Events.Controllers
 {
-    private readonly ICurrentContext _currentContext;
-    private readonly IEventService _eventService;
-    private readonly ICipherRepository _cipherRepository;
-    private readonly IOrganizationRepository _organizationRepository;
-
-    public CollectController(
-        ICurrentContext currentContext,
-        IEventService eventService,
-        ICipherRepository cipherRepository,
-        IOrganizationRepository organizationRepository)
+    [Route("collect")]
+    [Authorize("Application")]
+    public class CollectController : Controller
     {
-        _currentContext = currentContext;
-        _eventService = eventService;
-        _cipherRepository = cipherRepository;
-        _organizationRepository = organizationRepository;
-    }
+        private readonly ICurrentContext _currentContext;
+        private readonly IEventService _eventService;
+        private readonly ICipherRepository _cipherRepository;
+        private readonly IOrganizationRepository _organizationRepository;
 
-    [HttpPost]
-    public async Task<IActionResult> Post([FromBody] IEnumerable<EventModel> model)
-    {
-        if (model == null || !model.Any())
+        public CollectController(
+            ICurrentContext currentContext,
+            IEventService eventService,
+            ICipherRepository cipherRepository,
+            IOrganizationRepository organizationRepository)
         {
-            return new BadRequestResult();
+            _currentContext = currentContext;
+            _eventService = eventService;
+            _cipherRepository = cipherRepository;
+            _organizationRepository = organizationRepository;
         }
-        var cipherEvents = new List<Tuple<Cipher, EventType, DateTime?>>();
-        var ciphersCache = new Dictionary<Guid, Cipher>();
-        foreach (var eventModel in model)
+
+        [HttpPost]
+        public async Task<IActionResult> Post([FromBody] IEnumerable<EventModel> model)
         {
-            switch (eventModel.Type)
+            if (model == null || !model.Any())
             {
-                // User events
-                case EventType.User_ClientExportedVault:
-                    await _eventService.LogUserEventAsync(_currentContext.UserId.Value, eventModel.Type, eventModel.Date);
-                    break;
-                // Cipher events
-                case EventType.Cipher_ClientAutofilled:
-                case EventType.Cipher_ClientCopiedHiddenField:
-                case EventType.Cipher_ClientCopiedPassword:
-                case EventType.Cipher_ClientCopiedCardCode:
-                case EventType.Cipher_ClientToggledCardCodeVisible:
-                case EventType.Cipher_ClientToggledHiddenFieldVisible:
-                case EventType.Cipher_ClientToggledPasswordVisible:
-                case EventType.Cipher_ClientViewed:
-                    if (!eventModel.CipherId.HasValue)
-                    {
-                        continue;
-                    }
-                    Cipher cipher = null;
-                    if (ciphersCache.ContainsKey(eventModel.CipherId.Value))
-                    {
-                        cipher = ciphersCache[eventModel.CipherId.Value];
-                    }
-                    else
-                    {
-                        cipher = await _cipherRepository.GetByIdAsync(eventModel.CipherId.Value,
-                           _currentContext.UserId.Value);
-                    }
-                    if (cipher == null)
-                    {
-                        continue;
-                    }
-                    if (!ciphersCache.ContainsKey(eventModel.CipherId.Value))
-                    {
-                        ciphersCache.Add(eventModel.CipherId.Value, cipher);
-                    }
-                    cipherEvents.Add(new Tuple<Cipher, EventType, DateTime?>(cipher, eventModel.Type, eventModel.Date));
-                    break;
-                case EventType.Organization_ClientExportedVault:
-                    if (!eventModel.OrganizationId.HasValue)
-                    {
-                        continue;
-                    }
-                    var organization = await _organizationRepository.GetByIdAsync(eventModel.OrganizationId.Value);
-                    await _eventService.LogOrganizationEventAsync(organization, eventModel.Type, eventModel.Date);
-                    break;
-                default:
-                    continue;
+                return new BadRequestResult();
             }
-        }
-        if (cipherEvents.Any())
-        {
-            foreach (var eventsBatch in cipherEvents.Batch(50))
+            var cipherEvents = new List<Tuple<Cipher, EventType, DateTime?>>();
+            var ciphersCache = new Dictionary<Guid, Cipher>();
+            foreach (var eventModel in model)
             {
-                await _eventService.LogCipherEventsAsync(eventsBatch);
+                switch (eventModel.Type)
+                {
+                    // User events
+                    case EventType.User_ClientExportedVault:
+                        await _eventService.LogUserEventAsync(_currentContext.UserId.Value, eventModel.Type, eventModel.Date);
+                        break;
+                    // Cipher events
+                    case EventType.Cipher_ClientAutofilled:
+                    case EventType.Cipher_ClientCopiedHiddenField:
+                    case EventType.Cipher_ClientCopiedPassword:
+                    case EventType.Cipher_ClientCopiedCardCode:
+                    case EventType.Cipher_ClientToggledCardCodeVisible:
+                    case EventType.Cipher_ClientToggledHiddenFieldVisible:
+                    case EventType.Cipher_ClientToggledPasswordVisible:
+                    case EventType.Cipher_ClientViewed:
+                        if (!eventModel.CipherId.HasValue)
+                        {
+                            continue;
+                        }
+                        Cipher cipher = null;
+                        if (ciphersCache.ContainsKey(eventModel.CipherId.Value))
+                        {
+                            cipher = ciphersCache[eventModel.CipherId.Value];
+                        }
+                        else
+                        {
+                            cipher = await _cipherRepository.GetByIdAsync(eventModel.CipherId.Value,
+                               _currentContext.UserId.Value);
+                        }
+                        if (cipher == null)
+                        {
+                            continue;
+                        }
+                        if (!ciphersCache.ContainsKey(eventModel.CipherId.Value))
+                        {
+                            ciphersCache.Add(eventModel.CipherId.Value, cipher);
+                        }
+                        cipherEvents.Add(new Tuple<Cipher, EventType, DateTime?>(cipher, eventModel.Type, eventModel.Date));
+                        break;
+                    case EventType.Organization_ClientExportedVault:
+                        if (!eventModel.OrganizationId.HasValue)
+                        {
+                            continue;
+                        }
+                        var organization = await _organizationRepository.GetByIdAsync(eventModel.OrganizationId.Value);
+                        await _eventService.LogOrganizationEventAsync(organization, eventModel.Type, eventModel.Date);
+                        break;
+                    default:
+                        continue;
+                }
             }
+            if (cipherEvents.Any())
+            {
+                foreach (var eventsBatch in cipherEvents.Batch(50))
+                {
+                    await _eventService.LogCipherEventsAsync(eventsBatch);
+                }
+            }
+            return new OkResult();
         }
-        return new OkResult();
     }
 }

src/Events/Controllers/InfoController.cs

@@ -1,20 +1,21 @@
 using Bit.Core.Utilities;
 using Microsoft.AspNetCore.Mvc;
 
-namespace Bit.Events.Controllers;
-
-public class InfoController : Controller
+namespace Bit.Events.Controllers
 {
-    [HttpGet("~/alive")]
-    [HttpGet("~/now")]
-    public DateTime GetAlive()
+    public class InfoController : Controller
     {
-        return DateTime.UtcNow;
-    }
+        [HttpGet("~/alive")]
+        [HttpGet("~/now")]
+        public DateTime GetAlive()
+        {
+            return DateTime.UtcNow;
+        }
 
-    [HttpGet("~/version")]
-    public JsonResult GetVersion()
-    {
-        return Json(CoreHelpers.GetVersion());
+        [HttpGet("~/version")]
+        public JsonResult GetVersion()
+        {
+            return Json(CoreHelpers.GetVersion());
+        }
     }
 }

src/Events/Models/EventModel.cs

@@ -1,11 +1,12 @@
 using Bit.Core.Enums;
 
-namespace Bit.Events.Models;
-
-public class EventModel
+namespace Bit.Events.Models
 {
-    public EventType Type { get; set; }
-    public Guid? CipherId { get; set; }
-    public DateTime Date { get; set; }
-    public Guid? OrganizationId { get; set; }
+    public class EventModel
+    {
+        public EventType Type { get; set; }
+        public Guid? CipherId { get; set; }
+        public DateTime Date { get; set; }
+        public Guid? OrganizationId { get; set; }
+    }
 }

src/Events/Program.cs

@@ -1,39 +1,40 @@
 using Bit.Core.Utilities;
 using Serilog.Events;
 
-namespace Bit.Events;
-
-public class Program
+namespace Bit.Events
 {
-    public static void Main(string[] args)
+    public class Program
     {
-        Host
-            .CreateDefaultBuilder(args)
-            .ConfigureCustomAppConfiguration(args)
-            .ConfigureWebHostDefaults(webBuilder =>
-            {
-                webBuilder.UseStartup<Startup>();
-                webBuilder.ConfigureLogging((hostingContext, logging) =>
-                    logging.AddSerilog(hostingContext, e =>
-                    {
-                        var context = e.Properties["SourceContext"].ToString();
-                        if (context.Contains("IdentityServer4.Validation.TokenValidator") ||
-                            context.Contains("IdentityServer4.Validation.TokenRequestValidator"))
+        public static void Main(string[] args)
+        {
+            Host
+                .CreateDefaultBuilder(args)
+                .ConfigureCustomAppConfiguration(args)
+                .ConfigureWebHostDefaults(webBuilder =>
+                {
+                    webBuilder.UseStartup<Startup>();
+                    webBuilder.ConfigureLogging((hostingContext, logging) =>
+                        logging.AddSerilog(hostingContext, e =>
                         {
-                            return e.Level > LogEventLevel.Error;
-                        }
+                            var context = e.Properties["SourceContext"].ToString();
+                            if (context.Contains("IdentityServer4.Validation.TokenValidator") ||
+                                context.Contains("IdentityServer4.Validation.TokenRequestValidator"))
+                            {
+                                return e.Level > LogEventLevel.Error;
+                            }
 
-                        if (e.Properties.ContainsKey("RequestPath") &&
-                            !string.IsNullOrWhiteSpace(e.Properties["RequestPath"]?.ToString()) &&
-                            (context.Contains(".Server.Kestrel") || context.Contains(".Core.IISHttpServer")))
-                        {
-                            return false;
-                        }
+                            if (e.Properties.ContainsKey("RequestPath") &&
+                                !string.IsNullOrWhiteSpace(e.Properties["RequestPath"]?.ToString()) &&
+                                (context.Contains(".Server.Kestrel") || context.Contains(".Core.IISHttpServer")))
+                            {
+                                return false;
+                            }
 
-                        return e.Level >= LogEventLevel.Error;
-                    }));
-            })
-            .Build()
-            .Run();
+                            return e.Level >= LogEventLevel.Error;
+                        }));
+                })
+                .Build()
+                .Run();
+        }
     }
 }

src/Events/Startup.cs

@@ -6,112 +6,113 @@ using Bit.Core.Utilities;
 using Bit.SharedWeb.Utilities;
 using IdentityModel;
 
-namespace Bit.Events;
-
-public class Startup
+namespace Bit.Events
 {
-    public Startup(IWebHostEnvironment env, IConfiguration configuration)
+    public class Startup
     {
-        CultureInfo.DefaultThreadCurrentCulture = new CultureInfo("en-US");
-        Configuration = configuration;
-        Environment = env;
-    }
-
-    public IConfiguration Configuration { get; }
-    public IWebHostEnvironment Environment { get; set; }
-
-    public void ConfigureServices(IServiceCollection services)
-    {
-        // Options
-        services.AddOptions();
-
-        // Settings
-        var globalSettings = services.AddGlobalSettingsServices(Configuration, Environment);
-
-        // Repositories
-        services.AddSqlServerRepositories(globalSettings);
-
-        // Context
-        services.AddScoped<ICurrentContext, CurrentContext>();
-
-        // Identity
-        services.AddIdentityAuthenticationServices(globalSettings, Environment, config =>
+        public Startup(IWebHostEnvironment env, IConfiguration configuration)
         {
-            config.AddPolicy("Application", policy =>
+            CultureInfo.DefaultThreadCurrentCulture = new CultureInfo("en-US");
+            Configuration = configuration;
+            Environment = env;
+        }
+
+        public IConfiguration Configuration { get; }
+        public IWebHostEnvironment Environment { get; set; }
+
+        public void ConfigureServices(IServiceCollection services)
+        {
+            // Options
+            services.AddOptions();
+
+            // Settings
+            var globalSettings = services.AddGlobalSettingsServices(Configuration, Environment);
+
+            // Repositories
+            services.AddSqlServerRepositories(globalSettings);
+
+            // Context
+            services.AddScoped<ICurrentContext, CurrentContext>();
+
+            // Identity
+            services.AddIdentityAuthenticationServices(globalSettings, Environment, config =>
             {
-                policy.RequireAuthenticatedUser();
-                policy.RequireClaim(JwtClaimTypes.AuthenticationMethod, "Application", "external");
-                policy.RequireClaim(JwtClaimTypes.Scope, "api");
+                config.AddPolicy("Application", policy =>
+                {
+                    policy.RequireAuthenticatedUser();
+                    policy.RequireClaim(JwtClaimTypes.AuthenticationMethod, "Application", "external");
+                    policy.RequireClaim(JwtClaimTypes.Scope, "api");
+                });
             });
-        });
 
-        // Services
-        var usingServiceBusAppCache = CoreHelpers.SettingHasValue(globalSettings.ServiceBus.ConnectionString) &&
-            CoreHelpers.SettingHasValue(globalSettings.ServiceBus.ApplicationCacheTopicName);
-        if (usingServiceBusAppCache)
-        {
-            services.AddSingleton<IApplicationCacheService, InMemoryServiceBusApplicationCacheService>();
-        }
-        else
-        {
-            services.AddSingleton<IApplicationCacheService, InMemoryApplicationCacheService>();
-        }
-        services.AddScoped<IEventService, EventService>();
-        if (!globalSettings.SelfHosted && CoreHelpers.SettingHasValue(globalSettings.Events.ConnectionString))
-        {
-            services.AddSingleton<IEventWriteService, AzureQueueEventWriteService>();
-        }
-        else
-        {
-            services.AddSingleton<IEventWriteService, RepositoryEventWriteService>();
+            // Services
+            var usingServiceBusAppCache = CoreHelpers.SettingHasValue(globalSettings.ServiceBus.ConnectionString) &&
+                CoreHelpers.SettingHasValue(globalSettings.ServiceBus.ApplicationCacheTopicName);
+            if (usingServiceBusAppCache)
+            {
+                services.AddSingleton<IApplicationCacheService, InMemoryServiceBusApplicationCacheService>();
+            }
+            else
+            {
+                services.AddSingleton<IApplicationCacheService, InMemoryApplicationCacheService>();
+            }
+            services.AddScoped<IEventService, EventService>();
+            if (!globalSettings.SelfHosted && CoreHelpers.SettingHasValue(globalSettings.Events.ConnectionString))
+            {
+                services.AddSingleton<IEventWriteService, AzureQueueEventWriteService>();
+            }
+            else
+            {
+                services.AddSingleton<IEventWriteService, RepositoryEventWriteService>();
+            }
+
+            // Mvc
+            services.AddMvc(config =>
+            {
+                config.Filters.Add(new LoggingExceptionHandlerFilterAttribute());
+            });
+
+            if (usingServiceBusAppCache)
+            {
+                services.AddHostedService<Core.HostedServices.ApplicationCacheHostedService>();
+            }
         }
 
-        // Mvc
-        services.AddMvc(config =>
+        public void Configure(
+            IApplicationBuilder app,
+            IWebHostEnvironment env,
+            IHostApplicationLifetime appLifetime,
+            GlobalSettings globalSettings)
         {
-            config.Filters.Add(new LoggingExceptionHandlerFilterAttribute());
-        });
+            app.UseSerilog(env, appLifetime, globalSettings);
 
-        if (usingServiceBusAppCache)
-        {
-            services.AddHostedService<Core.HostedServices.ApplicationCacheHostedService>();
+            // Add general security headers
+            app.UseMiddleware<SecurityHeadersMiddleware>();
+
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
+
+            // Default Middleware
+            app.UseDefaultMiddleware(env, globalSettings);
+
+            // Add routing
+            app.UseRouting();
+
+            // Add Cors
+            app.UseCors(policy => policy.SetIsOriginAllowed(o => CoreHelpers.IsCorsOriginAllowed(o, globalSettings))
+                .AllowAnyMethod().AllowAnyHeader().AllowCredentials());
+
+            // Add authentication and authorization to the request pipeline.
+            app.UseAuthentication();
+            app.UseAuthorization();
+
+            // Add current context
+            app.UseMiddleware<CurrentContextMiddleware>();
+
+            // Add MVC to the request pipeline.
+            app.UseEndpoints(endpoints => endpoints.MapDefaultControllerRoute());
         }
     }
-
-    public void Configure(
-        IApplicationBuilder app,
-        IWebHostEnvironment env,
-        IHostApplicationLifetime appLifetime,
-        GlobalSettings globalSettings)
-    {
-        app.UseSerilog(env, appLifetime, globalSettings);
-
-        // Add general security headers
-        app.UseMiddleware<SecurityHeadersMiddleware>();
-
-        if (env.IsDevelopment())
-        {
-            app.UseDeveloperExceptionPage();
-        }
-
-        // Default Middleware
-        app.UseDefaultMiddleware(env, globalSettings);
-
-        // Add routing
-        app.UseRouting();
-
-        // Add Cors
-        app.UseCors(policy => policy.SetIsOriginAllowed(o => CoreHelpers.IsCorsOriginAllowed(o, globalSettings))
-            .AllowAnyMethod().AllowAnyHeader().AllowCredentials());
-
-        // Add authentication and authorization to the request pipeline.
-        app.UseAuthentication();
-        app.UseAuthorization();
-
-        // Add current context
-        app.UseMiddleware<CurrentContextMiddleware>();
-
-        // Add MVC to the request pipeline.
-        app.UseEndpoints(endpoints => endpoints.MapDefaultControllerRoute());
-    }
 }