Controllers/V1/TasksController.cs - master - ivanstrike/tasker

Controllers/V1/TasksController.cs
297 строк10 KB
ivanstrike
Лабораторная работа 2
08 ноя 2025, 11:16
08 ноя 2025, 11:16ec39293
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using TaskerApi.Data;
using TaskerApi.DTOs;
using TaskerApi.Models;
using TaskStatus = TaskerApi.Models.TaskStatus;

namespace TaskerApi.Controllers.V1;

/// <summary>
/// Контроллер для управления задачами (API v1)
/// </summary>
[ApiController]
[ApiVersion("1.0")]
[Route("api/v{version:apiVersion}/[controller]")]
[Authorize]
public class TasksController : ControllerBase
{
    private readonly ApplicationDbContext _context;
    private readonly ILogger<TasksController> _logger;

    public TasksController(ApplicationDbContext context, ILogger<TasksController> logger)
    {
        _context = context;
        _logger = logger;
    }

    /// <summary>
    /// Получить все задачи текущего пользователя с пагинацией
    /// </summary>
    [HttpGet]
    [ProducesResponseType(typeof(PaginatedResult<TaskResponseDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<PaginatedResult<TaskResponseDto>>> GetTasks(
        [FromQuery] TaskStatus? status = null,
        [FromQuery] Guid? projectId = null,
        [FromQuery] TaskPriority? priority = null,
        [FromQuery] int page = 1,
        [FromQuery] int pageSize = 20)
    {
        var userId = GetCurrentUserId();

        var query = _context.Tasks
            .Include(t => t.AssignedTo)
            .Include(t => t.Project)
            .Where(t => t.AssignedToId == userId);

        if (status.HasValue)
        {
            query = query.Where(t => t.Status == status.Value);
        }

        if (projectId.HasValue)
        {
            query = query.Where(t => t.ProjectId == projectId.Value);
        }

        if (priority.HasValue)
        {
            query = query.Where(t => t.Priority == priority.Value);
        }

        var totalCount = await query.CountAsync();

        var pagination = new PaginationParams { Page = page, PageSize = pageSize };

        var tasks = await query
            .OrderByDescending(t => t.CreatedAt)
            .Skip(pagination.Skip)
            .Take(pagination.PageSize)
            .Select(t => new TaskResponseDto
            {
                Id = t.Id,
                Title = t.Title,
                Description = t.Description,
                Status = t.Status,
                Priority = t.Priority,
                ProjectId = t.ProjectId,
                ProjectName = t.Project != null ? t.Project.Name : null,
                AssignedToId = t.AssignedToId,
                AssignedToUsername = t.AssignedTo.Username,
                DueDate = t.DueDate,
                CreatedAt = t.CreatedAt,
                UpdatedAt = t.UpdatedAt,
                CompletedAt = t.CompletedAt
            })
            .ToListAsync();

        var result = new PaginatedResult<TaskResponseDto>
        {
            Items = tasks,
            Page = pagination.Page,
            PageSize = pagination.PageSize,
            TotalCount = totalCount
        };

        Response.Headers.Append("X-Pagination-Page", result.Page.ToString());
        Response.Headers.Append("X-Pagination-PageSize", result.PageSize.ToString());
        Response.Headers.Append("X-Pagination-TotalCount", result.TotalCount.ToString());
        Response.Headers.Append("X-Pagination-TotalPages", result.TotalPages.ToString());

        return Ok(result);
    }

    /// <summary>
    /// Получить задачу по ID
    /// </summary>
    [HttpGet("{id}")]
    [ProducesResponseType(typeof(TaskResponseDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<TaskResponseDto>> GetTask(Guid id)
    {
        var userId = GetCurrentUserId();

        var task = await _context.Tasks
            .Include(t => t.AssignedTo)
            .Include(t => t.Project)
            .FirstOrDefaultAsync(t => t.Id == id && t.AssignedToId == userId);

        if (task == null)
        {
            return NotFound(new { message = "Task not found" });
        }

        var response = new TaskResponseDto
        {
            Id = task.Id,
            Title = task.Title,
            Description = task.Description,
            Status = task.Status,
            Priority = task.Priority,
            ProjectId = task.ProjectId,
            ProjectName = task.Project?.Name,
            AssignedToId = task.AssignedToId,
            AssignedToUsername = task.AssignedTo.Username,
            DueDate = task.DueDate,
            CreatedAt = task.CreatedAt,
            UpdatedAt = task.UpdatedAt,
            CompletedAt = task.CompletedAt
        };

        return Ok(response);
    }

    /// <summary>
    /// Создать новую задачу
    /// </summary>
    [HttpPost]
    [ProducesResponseType(typeof(TaskResponseDto), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    public async Task<ActionResult<TaskResponseDto>> CreateTask([FromBody] CreateTaskDto dto)
    {
        var userExists = await _context.Users.AnyAsync(u => u.Id == dto.AssignedToId);
        if (!userExists)
        {
            return BadRequest(new { message = "Assigned user not found" });
        }

        if (dto.ProjectId.HasValue)
        {
            var projectExists = await _context.Projects.AnyAsync(p => p.Id == dto.ProjectId.Value);
            if (!projectExists)
            {
                return BadRequest(new { message = "Project not found" });
            }
        }

        var task = new TaskItem
        {
            Title = dto.Title,
            Description = dto.Description,
            Status = dto.Status,
            Priority = dto.Priority,
            ProjectId = dto.ProjectId,
            AssignedToId = dto.AssignedToId,
            DueDate = dto.DueDate,
            CreatedAt = DateTime.UtcNow
        };

        _context.Tasks.Add(task);
        await _context.SaveChangesAsync();

        await _context.Entry(task).Reference(t => t.AssignedTo).LoadAsync();
        await _context.Entry(task).Reference(t => t.Project).LoadAsync();

        var response = new TaskResponseDto
        {
            Id = task.Id,
            Title = task.Title,
            Description = task.Description,
            Status = task.Status,
            Priority = task.Priority,
            ProjectId = task.ProjectId,
            ProjectName = task.Project?.Name,
            AssignedToId = task.AssignedToId,
            AssignedToUsername = task.AssignedTo.Username,
            DueDate = task.DueDate,
            CreatedAt = task.CreatedAt,
            UpdatedAt = task.UpdatedAt,
            CompletedAt = task.CompletedAt
        };

        _logger.LogInformation("Task created: {TaskId}", task.Id);

        return CreatedAtAction(nameof(GetTask), new { id = task.Id, version = "1.0" }, response);
    }

    /// <summary>
    /// Обновить задачу
    /// </summary>
    [HttpPut("{id}")]
    [ProducesResponseType(typeof(TaskResponseDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<TaskResponseDto>> UpdateTask(Guid id, [FromBody] UpdateTaskDto dto)
    {
        var task = await _context.Tasks
            .Include(t => t.AssignedTo)
            .Include(t => t.Project)
            .FirstOrDefaultAsync(t => t.Id == id);

        if (task == null)
        {
            return NotFound(new { message = "Task not found" });
        }

        if (dto.Title != null) task.Title = dto.Title;
        if (dto.Description != null) task.Description = dto.Description;
        if (dto.Status.HasValue)
        {
            task.Status = dto.Status.Value;
            if (dto.Status.Value == TaskStatus.Completed && task.CompletedAt == null)
            {
                task.CompletedAt = DateTime.UtcNow;
            }
        }
        if (dto.Priority.HasValue) task.Priority = dto.Priority.Value;
        if (dto.ProjectId.HasValue) task.ProjectId = dto.ProjectId.Value;
        if (dto.AssignedToId.HasValue) task.AssignedToId = dto.AssignedToId.Value;
        if (dto.DueDate.HasValue) task.DueDate = dto.DueDate.Value;

        task.UpdatedAt = DateTime.UtcNow;

        await _context.SaveChangesAsync();

        await _context.Entry(task).Reference(t => t.AssignedTo).LoadAsync();
        await _context.Entry(task).Reference(t => t.Project).LoadAsync();

        var response = new TaskResponseDto
        {
            Id = task.Id,
            Title = task.Title,
            Description = task.Description,
            Status = task.Status,
            Priority = task.Priority,
            ProjectId = task.ProjectId,
            ProjectName = task.Project?.Name,
            AssignedToId = task.AssignedToId,
            AssignedToUsername = task.AssignedTo.Username,
            DueDate = task.DueDate,
            CreatedAt = task.CreatedAt,
            UpdatedAt = task.UpdatedAt,
            CompletedAt = task.CompletedAt
        };

        _logger.LogInformation("Task updated: {TaskId}", task.Id);

        return Ok(response);
    }

    /// <summary>
    /// Удалить задачу
    /// </summary>
    [HttpDelete("{id}")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> DeleteTask(int id)
    {
        var task = await _context.Tasks.FindAsync(id);

        if (task == null)
        {
            return NotFound(new { message = "Task not found" });
        }

        _context.Tasks.Remove(task);
        await _context.SaveChangesAsync();

        _logger.LogInformation("Task deleted: {TaskId}", task.Id);

        return NoContent();
    }

    private Guid GetCurrentUserId()
    {
        return Guid.Parse(User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier)?.Value ?? "0");
    }
}