Controllers/V2/WorkersController.cs - master - Lexus_666/Pir_API

Controllers/V2/WorkersController.cs
253 строки8 KB
Lexus_666
Добавлена пагинация и опциональные поля
20 окт 2025, 03:36
20 окт 2025, 03:36b323cab
using Microsoft.AspNetCore.Mvc;
using Pir_API.Extensions;
using Pir_API.Interfaces;
using Pir_API.Model;
using Pir_API.Models;

namespace Pir_API.Controllers.V2;

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

    public WorkersController(IWorkerService workerService)
    {
        _workerService = workerService;
    }

    [HttpGet]
    public async Task<ActionResult<PaginatedList<WorkerModel>>> GetWorkers(
        [FromQuery] string? role,
        [FromQuery] PaginationParameters paginationParameters,
        [FromQuery] string? fields = null)
    {
        var workers = await _workerService.GetAllWorkersAsync();

        if (role is not null)
        {
            workers = workers.Where(w => w.Role == role);
        }

        var response = workers.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(worker => new WorkerModel
        {
            Id = worker.Id,
            Name = selectedFields.Contains("name") ? worker.Name : "",
            Surname = selectedFields.Contains("surname") ? worker.Surname : "",
            Phone = selectedFields.Contains("phone") ? worker.Phone : "",
            Role = selectedFields.Contains("role") ? worker.Role : "",
            OnWorkTimer = worker.OnWorkTimer,
            StartedAt = worker.StartedAt
        });
        return Ok(result);
    }

    [HttpGet("{id:guid}")]
    public async Task<ActionResult<WorkerModel>> GetWorker(Guid id,
        [FromQuery] string? fields = null)
    {
        var worker = await _workerService.GetWorkerByIdAsync(id);
        if (worker == null)
        {
            return NotFound(new { Message = $"Worker with ID {id} not found" });
        }

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

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

        var response = new WorkerModel
        {
            Id = worker.Id,
            Name = selectedFields.Contains("name") ? worker.Name : "",
            Surname = selectedFields.Contains("surname") ? worker.Surname : "",
            Phone = selectedFields.Contains("phone") ? worker.Phone : "",
            Role = selectedFields.Contains("role") ? worker.Role : "",
            OnWorkTimer = worker.OnWorkTimer,
            StartedAt = worker.StartedAt
        };
        return Ok(response);
    }

    [HttpPost]
    public async Task<ActionResult<WorkerModel>> CreateWorker(
        WorkerModel worker,
        [FromHeader(Name = "Idempotency-Key")] Guid? idempotencyKey = null)
    {
        var createdWorker = await _workerService.CreateWorkerAsync(worker);
        return CreatedAtAction(nameof(GetWorker), new { id = createdWorker.Id }, createdWorker);
    }

    [HttpPut("{id:guid}")]
    public async Task<ActionResult<WorkerModel>> UpdateWorker(Guid id, WorkerModel worker)
    {
        var updatedWorker = await _workerService.UpdateWorkerAsync(id, worker);
        if (updatedWorker == null)
        {
            return NotFound(new { Message = $"Worker with ID {id} not found" });
        }

        return Ok(updatedWorker);
    }

    [HttpPatch("{id:guid}")]
    public async Task<ActionResult<WorkerModel>> PartialUpdateWorker(Guid id, [FromBody] Dictionary<string, object> updates)
    {
        var existingWorker = await _workerService.GetWorkerByIdAsync(id);
        if (existingWorker == null)
        {
            return NotFound(new { Message = $"Worker with ID {id} not found" });
        }

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

        var updatedWorker = await _workerService.UpdateWorkerAsync(id, existingWorker);
        return Ok(updatedWorker);
    }

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

        return NoContent();
    }

    [HttpGet("{id:guid}/start")]
    public async Task<ActionResult<WorkerModel>> StartWork(Guid id)
    {
        var worker = await _workerService.StartWork(id);
        if (worker == null)
        {
            return NotFound(new { Message = $"Worker with ID {id} not found" });
        }

        return Ok(worker);
    }

    [HttpGet("{id:guid}/stop")]
    public async Task<ActionResult<object>> StopWork(Guid id)
    {
        var totalWorkTime = await _workerService.StopWork(id);
        if (totalWorkTime == null)
        {
            return NotFound(new { Message = $"Worker with ID {id} not found" });
        }

        return Ok(new
        {
            Message = "Work stopped successfully",
            TotalWorkTime = totalWorkTime.Value.ToString(@"hh\:mm\:ss")
        });
    }

    [HttpGet("{id:guid}/pause")]
    public async Task<ActionResult<WorkerModel>> PauseWork(Guid id)
    {
        var worker = await _workerService.PauseWork(id);
        if (worker == null)
        {
            return NotFound(new { Message = $"Worker with ID {id} not found" });
        }

        return Ok(worker);
    }

    [HttpGet("{id:guid}/continue")]
    public async Task<ActionResult<WorkerModel>> ContinueWork(Guid id)
    {
        var worker = await _workerService.ContinueWork(id);
        if (worker == null)
        {
            return NotFound(new { Message = $"Worker with ID {id} not found" });
        }

        return Ok(worker);
    }

    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);
        }
        else if (targetType == typeof(TimeSpan))
        {
            if (stringValue != null)
                return TimeSpan.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");
    }
}