API_PIR/Controllers/V2/UsersController.cs - master - Frozin/DIS-3

API_PIR/Controllers/V2/UsersController.cs
191 строка6 KB
Dobryk
Добавлены опциональные поля
20 окт 2025, 03:37
20 окт 2025, 03:3729d65b9
using API_PIR.Extensions;
using Microsoft.AspNetCore.Mvc;
using API_PIR.Interfaces;
using API_PIR.Models;

namespace API_PIR.Controllers.V2;

[ApiController]
[ApiVersion("2.0")]
[Route("api/v{version:apiVersion}/[controller]/[action]")]
public class UsersController : ControllerBase
{
    private readonly IUserService _userService;

    public UsersController(IUserService userService)
    {
        _userService = userService;
    }

    [HttpGet]
    public async Task<ActionResult<PaginatedList<UserModel>>> GetUsers(
        [FromQuery] string? role,
        [FromQuery] PaginationParameters paginationParameters,
        [FromQuery] string? fields = null)
    {
        var users = await _userService.GetAllUsersAsync();

        if (role is not null)
        {
            users = users.Where(u => u.Role == role);
        }

        var response = users
            .ToPaginatedList(paginationParameters.PageNumber, paginationParameters.PageSize);


        if (string.IsNullOrEmpty(fields))
            return Ok(response);

        var selectedFields = fields.Split(',', StringSplitOptions.RemoveEmptyEntries)
            .Select(f => f.Trim().ToLower())
            .ToHashSet();

        var result = response;
        result.Items = response.Items.Select(user => new UserModel
        {
            Id = user.Id,
            Username = selectedFields.Contains("username") ? user.Username : "",
            Role = selectedFields.Contains("role") ? user.Role : ""
        });

        return Ok(result);
    }

    [HttpGet("{id:guid}")]
    public async Task<ActionResult<UserModel>> GetUser(Guid id,
        [FromQuery] string? fields = null)
    {
        var user = await _userService.GetUserByIdAsync(id);
        if (user == null)
        {
            return NotFound(new { Message = $"User with ID {id} not found" });
        }

        if (string.IsNullOrEmpty(fields))
            return Ok(user);

        var selectedFields = fields.Split(',', StringSplitOptions.RemoveEmptyEntries)
            .Select(f => f.Trim().ToLower())
            .ToHashSet();

        var response = new UserModel
        {
            Id = user.Id,
            Username = selectedFields.Contains("username") ? user.Username : "",
            Role = selectedFields.Contains("role") ? user.Role : ""
        };

        return Ok(response);
    }

    [HttpPost]
    public async Task<ActionResult<UserModel>> CreateUser(
        UserModel user,
        [FromHeader(Name = "Idempotency-Key")] Guid? idempotencyKey = null)
    {
        var createdUser = await _userService.CreateUserAsync(user);
        return CreatedAtAction(nameof(GetUser), new { id = createdUser.Id }, createdUser);
    }

    [HttpPut("{id:guid}")]
    public async Task<ActionResult<UserModel>> UpdateUser(Guid id, UserModel user)
    {
        var updatedUser = await _userService.UpdateUserAsync(id, user);
        if (updatedUser == null)
        {
            return NotFound(new { Message = $"User with ID {id} not found" });
        }

        return Ok(updatedUser);
    }

    [HttpPatch("{id:guid}")]
    public async Task<ActionResult<UserModel>> PartialUpdateUser(Guid id, [FromBody] Dictionary<string, object> updates)
    {
        var existingUser = await _userService.GetUserByIdAsync(id);
        if (existingUser == null)
        {
            return NotFound(new { Message = $"User with ID {id} not found" });
        }

        foreach (var update in updates)
        {
            var property = typeof(UserModel).GetProperty(update.Key);
            if (property != null && property.CanWrite)
            {
                try
                {
                    var convertedValue = ConvertValue(update.Value, property.PropertyType);
                    property.SetValue(existingUser, convertedValue);
                }
                catch (Exception ex)
                {
                    return BadRequest(new
                    {
                        Message = $"Error updating property '{update.Key}': {ex.Message}"
                    });
                }
            }
        }

        var updatedUser = await _userService.UpdateUserAsync(id, existingUser);
        return Ok(updatedUser);
    }

    [HttpDelete("{id:guid}")]
    public async Task<ActionResult> DeleteUser(Guid id)
    {
        var result = await _userService.DeleteUserAsync(id);
        if (!result)
        {
            return NotFound(new { Message = $"User with ID {id} not found" });
        }

        return NoContent();
    }

    public static object? ConvertValue(object? value, Type? targetType)
    {
        if (value == null)
            return null;

        if (value.GetType() == targetType)
            return value;

        var stringValue = value.ToString();

        if (targetType is { IsGenericType: true } && targetType.GetGenericTypeDefinition() == typeof(Nullable<>))
        {
            if (string.IsNullOrEmpty(stringValue))
                return null;

            targetType = Nullable.GetUnderlyingType(targetType);
        }

        if (targetType == typeof(Guid))
        {
            if (stringValue != null)
                return Guid.Parse(stringValue);
        }
        else if (targetType == typeof(DateTime))
        {
            if (stringValue != null)
                return DateTime.Parse(stringValue);
        }

        if (targetType != null)
        {
            try
            {
                return Convert.ChangeType(value, targetType);
            }
            catch (Exception ex)
            {
                throw new Exception($"Could not convert value '{value}' to type {targetType.Name}. {ex.Message}");
            }
        }

        throw new Exception("Target type is null, could not convert value");
    }
}