Скоморохов Александр ФТ-404

WebApi.MinimalApi/Controllers/UsersController.cs

@@ -1,4 +1,8 @@
-using Microsoft.AspNetCore.Mvc;
+using AutoMapper;
+using Microsoft.AspNetCore.JsonPatch;
+using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json;
+using Swashbuckle.AspNetCore.Annotations;
 using WebApi.MinimalApi.Domain;
 using WebApi.MinimalApi.Models;
 
@@ -8,20 +12,167 @@ namespace WebApi.MinimalApi.Controllers;
 [ApiController]
 public class UsersController : Controller
 {
-    // Чтобы ASP.NET положил что-то в userRepository требуется конфигурация
-    public UsersController(IUserRepository userRepository)
+    private readonly IUserRepository userRepository;
+    private readonly IMapper mapper;
+    private readonly LinkGenerator linkGenerator;
+
+    public UsersController(IUserRepository userRepository, IMapper mapper, LinkGenerator linkGenerator)
     {
+        this.userRepository = userRepository;
+        this.mapper = mapper;
+        this.linkGenerator = linkGenerator;
     }
 
-    [HttpGet("{userId}")]
+    [HttpGet("{userId}", Name = nameof(GetUserById))]
+    [HttpHead("{userId}")]
+    [Produces("application/json", "application/xml")]
+    [SwaggerResponse(200, "OK", typeof(UserDto))]
+    [SwaggerResponse(404, "Пользователь не найден")]
     public ActionResult<UserDto> GetUserById([FromRoute] Guid userId)
     {
-        throw new NotImplementedException();
+        if (Request.Method == "HEAD")
+            Response.Body = Stream.Null;
+
+        var user = userRepository.FindById(userId);
+
+        if (user == null)
+            return NotFound();
+
+        return Ok(mapper.Map<UserDto>(user));
     }
 
     [HttpPost]
-    public IActionResult CreateUser([FromBody] object user)
+    [Consumes("application/json")]
+    [Produces("application/json", "application/xml")]
+    [SwaggerResponse(201, "Пользователь создан")]
+    [SwaggerResponse(400, "Некорректные входные данные")]
+    public IActionResult CreateUser([FromBody] CreatedUserDto user)
     {
-        throw new NotImplementedException();
+        if (user == null)
+            return BadRequest();
+
+        var createdUserEntity = mapper.Map<UserEntity>(user);
+        if (!ModelState.IsValid)
+            return UnprocessableEntity(ModelState);
+        if (!createdUserEntity.Login.All(char.IsLetterOrDigit))
+            ModelState.AddModelError("Login", "Login should contain only letters or digits");
+        if (!ModelState.IsValid)
+            return UnprocessableEntity(ModelState);
+
+        createdUserEntity = userRepository.Insert(createdUserEntity);
+        return CreatedAtRoute(
+            nameof(GetUserById),
+            new { userId = createdUserEntity.Id },
+            createdUserEntity.Id);
     }
-}
+
+    [HttpPut("{userId}")]
+    [Consumes("application/json")]
+    [Produces("application/json", "application/xml")]
+    [SwaggerResponse(201, "Пользователь создан")]
+    [SwaggerResponse(400, "Некорректные входные данные")]
+    public IActionResult UpdateUser([FromRoute] Guid userId, [FromBody] UpdatedUserDto user)
+    {
+        if (user == null || userId == Guid.Empty)
+            return BadRequest();
+
+        user.Id = userId;
+        var updatedUserEntity = mapper.Map<UserEntity>(user);
+        if (!ModelState.IsValid)
+            return UnprocessableEntity(ModelState);
+
+        userRepository.UpdateOrInsert(updatedUserEntity, out var isInserted);
+        if (isInserted)
+            return Created("User not found in repository. Created a new one successfully", updatedUserEntity);
+        return NoContent();
+    }
+
+    [HttpPatch("{userId}")]
+    [Consumes("application/json-patch+json")]
+    [Produces("application/json", "application/xml")]
+    [SwaggerResponse(204, "Пользователь обновлен")]
+    [SwaggerResponse(404, "Пользователь не найден")]
+    public IActionResult PartiallyUpdateUser([FromRoute] Guid userId, [FromBody] JsonPatchDocument<UpdatedUserDto> patchDoc)
+    {
+        if (patchDoc == null)
+            return BadRequest();
+        if (userId == Guid.Empty || userRepository.FindById(userId) == null)
+            return NotFound();
+
+        var updatedUser = new UpdatedUserDto()
+        {
+            Id = userId,
+        };
+        patchDoc.ApplyTo(updatedUser, ModelState);
+        TryValidateModel(updatedUser);
+
+        var updatedUserEntity = mapper.Map<UserEntity>(updatedUser);
+        if (!ModelState.IsValid)
+            return UnprocessableEntity(ModelState);
+
+        userRepository.Update(updatedUserEntity);
+        return NoContent();
+    }
+
+    [HttpDelete("{userId}")]
+    [Produces("application/json", "application/xml")]
+    [SwaggerResponse(204, "Пользователь удален")]
+    [SwaggerResponse(404, "Пользователь не найден")]
+    public IActionResult DeleteUser([FromRoute] Guid userId)
+    {
+        if (userId == Guid.Empty || userRepository.FindById(userId) == null)
+            return NotFound();
+
+        userRepository.Delete(userId);
+        return NoContent();
+    }
+
+    [HttpGet(Name = nameof(GetUsers))]
+    [Produces("application/json", "application/xml")]
+    [ProducesResponseType(typeof(IEnumerable<UserDto>), 200)]
+    public IActionResult GetUsers([FromQuery] int pageNumber=1, [FromQuery] int pageSize=10)
+    {
+        pageNumber = Math.Max(pageNumber, 1);
+        pageSize = Math.Clamp(pageSize, 1, 20);
+
+        var pageList = userRepository.GetPage(pageNumber, pageSize);
+        var previousPageLink = pageList.HasPrevious
+            ? linkGenerator.GetUriByRouteValues(HttpContext, "",
+                new
+                {
+                    pageNumber = pageList.CurrentPage - 1,
+                    pageSize = pageList.PageSize
+                })
+            : null;
+        var nextPageLink = pageList.HasNext
+            ? linkGenerator.GetUriByRouteValues(HttpContext, "", 
+                new 
+                {
+                    pageNumber = pageList.CurrentPage + 1, 
+                    pageSize = pageList.PageSize 
+                }) 
+            : null;
+
+        var paginationHeader = new
+        {
+            previousPageLink,
+            nextPageLink,
+            totalCount = pageList.Count,
+            pageSize = pageList.PageSize,
+            currentPage = pageList.CurrentPage,
+            totalPages = pageList.TotalPages,
+        };
+        Response.Headers.Append("X-Pagination", JsonConvert.SerializeObject(paginationHeader));
+
+        var users = mapper.Map<IEnumerable<UserDto>>(pageList);
+        return Ok(users);
+    }
+
+    [HttpOptions]
+    [SwaggerResponse(200, "OK")]
+    public IActionResult Options()
+    {
+        Response.Headers.Append("Allow", new[] {"GET", "POST", "OPTIONS"});
+        return Ok();
+    }
+}

WebApi.MinimalApi/Models/CreatedUserDto.cs

@@ -0,0 +1,16 @@
+using System.ComponentModel;
+using System.ComponentModel.DataAnnotations;
+
+namespace WebApi.MinimalApi.Models;
+
+public class CreatedUserDto
+{
+    [Required]
+    public string Login { get; set; }
+
+    [DefaultValue("John")]
+    public string FirstName { get; set; }
+
+    [DefaultValue("Doe")]
+    public string LastName { get; set; }
+}

WebApi.MinimalApi/Models/UpdatedUserDto.cs

@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace WebApi.MinimalApi.Models;
+
+public class UpdatedUserDto
+{
+    public Guid Id { get; set; }
+
+    [Required]
+    [RegularExpression("^[0-9\\p{L}]*$", ErrorMessage = "Login should contain only letters or digits")]
+    public string Login { get; set; }
+
+    [Required]
+    public string FirstName { get; set; }
+
+    [Required]
+    public string LastName { get; set; }
+}

WebApi.MinimalApi/Program.cs

@@ -4,10 +4,55 @@
     .ConfigureApiBehaviorOptions(options => {
         options.SuppressModelStateInvalidFilter = true;
         options.SuppressMapClientErrors = true;
+    });using Microsoft.AspNetCore.Mvc.Formatters;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+using WebApi.MinimalApi.Domain;
+using WebApi.MinimalApi.Models;
+using WebApi.MinimalApi.Samples;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.WebHost.UseUrls("http://localhost:5001");
+
+builder.Services.AddSingleton<IUserRepository, InMemoryUserRepository>();
+
+builder.Services.AddControllers(options =>
+    {
+        options.OutputFormatters.Add(new XmlDataContractSerializerOutputFormatter());
+        options.ReturnHttpNotAcceptable = true;
+        options.RespectBrowserAcceptHeader = true;
+    })
+    .ConfigureApiBehaviorOptions(options =>
+    {
+        options.SuppressModelStateInvalidFilter = true;
+        options.SuppressMapClientErrors = true;
+    })
+    .AddNewtonsoftJson(options =>
+    {
+        options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
+        options.SerializerSettings.DefaultValueHandling = DefaultValueHandling.Populate;
     });
 
+builder.Services.AddAutoMapper(cfg =>
+{
+    cfg.CreateMap<UserEntity, UserDto>()
+        .ForMember(dest => dest.FullName, opt => opt.MapFrom(src => $"{src.FirstName} {src.LastName}"));
+    cfg.CreateMap<CreatedUserDto, UserEntity>();
+    cfg.CreateMap<UpdatedUserDto, UserEntity>();
+}, new System.Reflection.Assembly[0]);
+
+builder.Services.AddSwaggerGeneration();
+
+var app = builder.Build();
+
+app.MapControllers();
+app.UseSwaggerWithUI();
+
+app.Run();
+
 var app = builder.Build();
 
 app.MapControllers();
 
-app.Run();
+app.Run();