chore: implement file scoped

Author: Amitpnk

src/CleanArch.Api/Account/AccountController.cs

@@ -1,48 +1,47 @@
-using CleanArch.Application.Contracts.Persistence;
+using CleanArch.Application.Contracts.Persistence;
 using CleanArch.Domain.Services.Authentication;
 using Microsoft.AspNetCore.Mvc;
 using System.Threading.Tasks;
 
-namespace CleanArch.Api.Account
+namespace CleanArch.Api.Account;
+
+[Route("api/[controller]")]
+[ApiController]
+public class AccountController : ControllerBase
 {
-    [Route("api/[controller]")]
-    [ApiController]
-    public class AccountController : ControllerBase
+    private readonly IAuthenticationService _authenticationService;
+    public AccountController(IAuthenticationService authenticationService)
     {
-        private readonly IAuthenticationService _authenticationService;
-        public AccountController(IAuthenticationService authenticationService)
-        {
-            _authenticationService = authenticationService;
-        }
-
-        [HttpPost("authenticate")]
-        public async Task<IActionResult> AuthenticateAsync(AuthenticationRequest request)
-        {
-            return Ok(await _authenticationService.AuthenticateAsync(request));
-        }
-        [HttpPost("register")]
-        public async Task<IActionResult> RegisterAsync(RegistrationRequest request)
-        {
-            var origin = Request.Headers["origin"];
-            return Ok(await _authenticationService.RegisterAsync(request, origin));
-        }
-        [HttpGet("confirm-email")]
-        public async Task<IActionResult> ConfirmEmailAsync([FromQuery] string userId, [FromQuery] string code)
-        {
-            return Ok(await _authenticationService.ConfirmEmailAsync(userId, code));
-        }
-        [HttpPost("forgot-password")]
-        public async Task<IActionResult> ForgotPassword(ForgotPasswordRequest model)
-        {
-            await _authenticationService.ForgotPassword(model, Request.Headers["origin"]);
-            return Ok();
-        }
-        [HttpPost("reset-password")]
-        public async Task<IActionResult> ResetPassword(ResetPasswordRequest model)
-        {
+        _authenticationService = authenticationService;
+    }
 
-            return Ok(await _authenticationService.ResetPassword(model));
-        }
+    [HttpPost("authenticate")]
+    public async Task<IActionResult> AuthenticateAsync(AuthenticationRequest request)
+    {
+        return Ok(await _authenticationService.AuthenticateAsync(request));
+    }
+    [HttpPost("register")]
+    public async Task<IActionResult> RegisterAsync(RegistrationRequest request)
+    {
+        var origin = Request.Headers["origin"];
+        return Ok(await _authenticationService.RegisterAsync(request, origin));
+    }
+    [HttpGet("confirm-email")]
+    public async Task<IActionResult> ConfirmEmailAsync([FromQuery] string userId, [FromQuery] string code)
+    {
+        return Ok(await _authenticationService.ConfirmEmailAsync(userId, code));
+    }
+    [HttpPost("forgot-password")]
+    public async Task<IActionResult> ForgotPassword(ForgotPasswordRequest model)
+    {
+        await _authenticationService.ForgotPassword(model, Request.Headers["origin"]);
+        return Ok();
+    }
+    [HttpPost("reset-password")]
+    public async Task<IActionResult> ResetPassword(ResetPasswordRequest model)
+    {
 
+        return Ok(await _authenticationService.ResetPassword(model));
     }
+
 }

src/CleanArch.Api/Category/v1/CategoryController.cs

@@ -1,4 +1,4 @@
-using CleanArch.Api.Controllers;
+using CleanArch.Api.Controllers;
 using CleanArch.Application.Features.Categories.Commands.CreateCategory;
 using CleanArch.Application.Features.Categories.Queries.GetCategoriesList;
 using CleanArch.Application.Features.Categories.Queries.GetCategoriesListWithEvents;
@@ -8,37 +8,36 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
-namespace CleanArch.Api.Category.v1
+namespace CleanArch.Api.Category.v1;
+
+public class CategoryController : BaseController
 {
-    public class CategoryController : BaseController
-    {
 
-        [HttpGet("all", Name = "GetAllCategories")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        public async Task<ActionResult<List<CategoryListVm>>> GetAllCategories()
-        {
-            var dtos = await Mediator.Send(new GetCategoriesListQuery());
-            return Ok(dtos);
-        }
+    [HttpGet("all", Name = "GetAllCategories")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public async Task<ActionResult<List<CategoryListVm>>> GetAllCategories()
+    {
+        var dtos = await Mediator.Send(new GetCategoriesListQuery());
+        return Ok(dtos);
+    }
 
-        [Authorize]
-        [HttpGet("allwithevents", Name = "GetCategoriesWithEvents")]
-        [ProducesDefaultResponseType]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        public async Task<ActionResult<List<CategoryEventListVm>>> GetCategoriesWithEvents(bool includeHistory)
-        {
-            GetCategoriesListWithEventsQuery getCategoriesListWithEventsQuery = new GetCategoriesListWithEventsQuery() { IncludeHistory = includeHistory };
+    [Authorize]
+    [HttpGet("allwithevents", Name = "GetCategoriesWithEvents")]
+    [ProducesDefaultResponseType]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public async Task<ActionResult<List<CategoryEventListVm>>> GetCategoriesWithEvents(bool includeHistory)
+    {
+        GetCategoriesListWithEventsQuery getCategoriesListWithEventsQuery = new GetCategoriesListWithEventsQuery() { IncludeHistory = includeHistory };
 
-            var dtos = await Mediator.Send(getCategoriesListWithEventsQuery);
-            return Ok(dtos);
-        }
+        var dtos = await Mediator.Send(getCategoriesListWithEventsQuery);
+        return Ok(dtos);
+    }
 
-        [Authorize]
-        [HttpPost(Name = "AddCategory")]
-        public async Task<ActionResult<CreateCategoryCommandResponse>> Create([FromBody] CreateCategoryCommand createCategoryCommand)
-        {
-            var response = await Mediator.Send(createCategoryCommand);
-            return Ok(response);
-        }
+    [Authorize]
+    [HttpPost(Name = "AddCategory")]
+    public async Task<ActionResult<CreateCategoryCommandResponse>> Create([FromBody] CreateCategoryCommand createCategoryCommand)
+    {
+        var response = await Mediator.Send(createCategoryCommand);
+        return Ok(response);
     }
-}
+}

src/CleanArch.Api/Controllers/BaseController.cs

@@ -1,18 +1,17 @@
-using MediatR;
+using MediatR;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace CleanArch.Api.Controllers
+namespace CleanArch.Api.Controllers;
+
+[Authorize]
+[ApiController]
+[Route("api/v{version:apiVersion}/[controller]")]
+[ApiVersion("1.0")]
+public class BaseController : ControllerBase
 {
-    [Authorize]
-    [ApiController]
-    [Route("api/v{version:apiVersion}/[controller]")]
-    [ApiVersion("1.0")]
-    public class BaseController : ControllerBase
-    {
-        private IMediator _mediator;
+    private IMediator _mediator;
 
-        protected IMediator Mediator => _mediator ??= HttpContext.RequestServices.GetService<IMediator>();
-    }
-}
+    protected IMediator Mediator => _mediator ??= HttpContext.RequestServices.GetService<IMediator>();
+}

src/CleanArch.Api/Controllers/MetaController.cs

@@ -1,19 +1,18 @@
-using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc;
 using System.Diagnostics;
 
-namespace CleanArch.Api.Controllers
+namespace CleanArch.Api.Controllers;
+
+public class MetaController : ControllerBase
 {
-    public class MetaController : ControllerBase
+    [HttpGet("/info")]
+    public ActionResult<string> Info()
     {
-        [HttpGet("/info")]
-        public ActionResult<string> Info()
-        {
-            var assembly = typeof(Startup).Assembly;
+        var assembly = typeof(Startup).Assembly;
 
-            var lastUpdate = System.IO.File.GetLastWriteTime(assembly.Location);
-            var version = FileVersionInfo.GetVersionInfo(assembly.Location).ProductVersion;
+        var lastUpdate = System.IO.File.GetLastWriteTime(assembly.Location);
+        var version = FileVersionInfo.GetVersionInfo(assembly.Location).ProductVersion;
 
-            return Ok($"Version: {version}, Last Updated: {lastUpdate}");
-        }
+        return Ok($"Version: {version}, Last Updated: {lastUpdate}");
     }
-}
+}

src/CleanArch.Api/Event/v1/EventsController.cs

@@ -1,4 +1,4 @@
-using CleanArch.Api.Controllers;
+using CleanArch.Api.Controllers;
 using CleanArch.Application.Features.Events.Commands.CreateEvent;
 using CleanArch.Application.Features.Events.Commands.DeleteEvent;
 using CleanArch.Application.Features.Events.Commands.UpdateEvent;
@@ -12,67 +12,66 @@
 using System;
 using System.Threading.Tasks;
 
-namespace CleanArch.Api.Event.v1
+namespace CleanArch.Api.Event.v1;
+
+public class EventsController : BaseController
 {
-    public class EventsController : BaseController
+    [HttpGet(Name = "GetAllEvents")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesDefaultResponseType]
+    public async Task<IActionResult> GetAll()
     {
-        [HttpGet(Name = "GetAllEvents")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        [ProducesDefaultResponseType]
-        public async Task<IActionResult> GetAll()
-        {
-            var vm = await Mediator.Send(new GetEventsListQuery());
-            return Ok(vm);
-        }
-
-        [Authorize]
-        [HttpGet("{id}", Name = "GetEventById")]
-        public async Task<IActionResult> GetEventById(Guid id)
-        {
-            var getEventDetailQuery = new GetEventDetailQuery() { Id = id };
-            return Ok(await Mediator.Send(getEventDetailQuery));
-        }
+        var vm = await Mediator.Send(new GetEventsListQuery());
+        return Ok(vm);
+    }
 
-        [Authorize]
-        [HttpPost(Name = "AddEvent")]
-        public async Task<ActionResult<Guid>> Create([FromBody] CreateEventCommand createEventCommand)
-        {
-            var id = await Mediator.Send(createEventCommand);
-            return Ok(id);
-        }
+    [Authorize]
+    [HttpGet("{id}", Name = "GetEventById")]
+    public async Task<IActionResult> GetEventById(Guid id)
+    {
+        var getEventDetailQuery = new GetEventDetailQuery() { Id = id };
+        return Ok(await Mediator.Send(getEventDetailQuery));
+    }
 
-        [Authorize]
-        [HttpPut(Name = "UpdateEvent")]
-        [ProducesResponseType(StatusCodes.Status204NoContent)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        [ProducesDefaultResponseType]
-        public async Task<ActionResult> Update([FromBody] UpdateEventCommand updateEventCommand)
-        {
-            await Mediator.Send(updateEventCommand);
-            return NoContent();
-        }
+    [Authorize]
+    [HttpPost(Name = "AddEvent")]
+    public async Task<ActionResult<Guid>> Create([FromBody] CreateEventCommand createEventCommand)
+    {
+        var id = await Mediator.Send(createEventCommand);
+        return Ok(id);
+    }
 
-        [Authorize]
-        [HttpDelete("{id}", Name = "DeleteEvent")]
-        [ProducesResponseType(StatusCodes.Status204NoContent)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        [ProducesDefaultResponseType]
-        public async Task<ActionResult> Delete(Guid id)
-        {
-            var deleteEventCommand = new DeleteEventCommand() { EventId = id };
-            await Mediator.Send(deleteEventCommand);
-            return NoContent();
-        }
+    [Authorize]
+    [HttpPut(Name = "UpdateEvent")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesDefaultResponseType]
+    public async Task<ActionResult> Update([FromBody] UpdateEventCommand updateEventCommand)
+    {
+        await Mediator.Send(updateEventCommand);
+        return NoContent();
+    }
 
-        [Authorize]
-        [HttpGet("export", Name = "ExportEvents")]
-        [FileResultContentType("text/csv")]
-        public async Task<FileResult> ExportEvents()
-        {
-            var fileDto = await Mediator.Send(new GetEventsExportQuery());
+    [Authorize]
+    [HttpDelete("{id}", Name = "DeleteEvent")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesDefaultResponseType]
+    public async Task<ActionResult> Delete(Guid id)
+    {
+        var deleteEventCommand = new DeleteEventCommand() { EventId = id };
+        await Mediator.Send(deleteEventCommand);
+        return NoContent();
+    }
 
-            return File(fileDto.Data, fileDto.ContentType, fileDto.EventExportFileName);
-        }
+    [Authorize]
+    [HttpGet("export", Name = "ExportEvents")]
+    [FileResultContentType("text/csv")]
+    public async Task<FileResult> ExportEvents()
+    {
+        var fileDto = await Mediator.Send(new GetEventsExportQuery());
 
+        return File(fileDto.Data, fileDto.ContentType, fileDto.EventExportFileName);
     }
+
 }