Project/Controllers/WorkoutController.cs - master - Extrap/Network_technologies_Project

Project/Controllers/WorkoutController.cs
150 строк5 KB
Extrap
Конечка (хз, но для воскресенья да)
21 дек 2025, 22:48
21 дек 2025, 22:481c6535d
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Project.Interfaces;
using Project.Models;
using Project.Models.DTOs;
using Project.Services;
using System.Security.Claims;

namespace Project.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class WorkoutController : ControllerBase
    {
        private readonly IWorkoutRepository _workoutRepository;

        public WorkoutController(IWorkoutRepository workoutRepository)
        {
            _workoutRepository = workoutRepository;
        }

        [HttpGet]
        public async Task<IActionResult> GetUserWorkouts()
        {
            var userId = GetUserId();
            var workouts = await _workoutRepository.GetByUserAsync(userId);
            var response = workouts.Select(WorkoutResponseDTO.FromWorkout);
            return Ok(response);
        }

        [HttpGet("{id}")]
        public async Task<IActionResult> GetWorkoutById(Guid id)
        {
            var userId = GetUserId();
            try
            {
                var workout = await _workoutRepository.GetByIdAsync(id, userId);
                return Ok(WorkoutResponseDTO.FromWorkout(workout));
            }
            catch (KeyNotFoundException)
            {
                return NotFound(new { message = "Workout not found or access denied" });
            }
        }

        [HttpPost]
        public async Task<IActionResult> CreateWorkout([FromBody] WorkoutCreateDTO dto)
        {
            if (!WorkoutValidationService.ValidateWorkout(dto, out var errorMessage))
                return BadRequest(new { error = errorMessage });

            var userId = GetUserId();

            var workout = new Workout
            {
                UserId = userId,
                StartTime = dto.StartTime,
                DurationSeconds = dto.DurationSeconds,
                Type = dto.Type,
                DistanceKm = dto.DistanceKm,
                AvgHeartRate = dto.AvgHeartRate,
                MaxHeartRate = dto.MaxHeartRate,
                Calories = dto.Calories,
                Notes = dto.Notes
            };

            var createdWorkout = await _workoutRepository.CreateAsync(workout);
            return Ok(WorkoutResponseDTO.FromWorkout(createdWorkout));
        }

        [HttpPut]
        public async Task<IActionResult> UpdateWorkout([FromBody] WorkoutUpdateDTO dto)
        {
            if (!WorkoutValidationService.ValidateWorkout(dto, out var errorMessage))
                return BadRequest(new { error = errorMessage });

            var userId = GetUserId();

            var workoutToUpdate = new Workout
            {
                Id = dto.Id,
                StartTime = dto.StartTime,
                DurationSeconds = dto.DurationSeconds,
                Type = dto.Type,
                DistanceKm = dto.DistanceKm,
                AvgHeartRate = dto.AvgHeartRate,
                MaxHeartRate = dto.MaxHeartRate,
                Calories = dto.Calories,
                Notes = dto.Notes
            };

            try
            {
                var updatedWorkout = await _workoutRepository.UpdateAsync(workoutToUpdate, userId);
                return Ok(WorkoutResponseDTO.FromWorkout(updatedWorkout));
            }
            catch (KeyNotFoundException)
            {
                return NotFound(new { message = "Workout not found or access denied" });
            }
        }

        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteWorkout(Guid id)
        {
            var userId = GetUserId();
            try
            {
                await _workoutRepository.DeleteAsync(id, userId);
                return Ok(new { message = "Workout deleted successfully" });
            }
            catch (KeyNotFoundException)
            {
                return NotFound(new { message = "Workout not found or access denied" });
            }
        }

        [HttpPost("report")]
        public async Task<IActionResult> GetReport(
            [FromServices] ReportService reportService,
            [FromBody] ReportRequestDTO request)
        {
            var userId = GetUserId();
            try
            {
                var report = await reportService.GenerateReportAsync(userId, request);
                return Ok(report);
            }
            catch (InvalidOperationException ex)
            {
                return NotFound(new { message = ex.Message });
            }
        }

        // --- ВСПОМОГАТЕЛЬНЫЙ МЕТОД (Исправляет ошибку старого файла) ---
        private Guid GetUserId()
        {
            // Ищем ID в разных полях токена, чтобы не было ошибки
            var idClaim = User.FindFirst(ClaimTypes.NameIdentifier)?.Value
                          ?? User.FindFirst("sub")?.Value
                          ?? User.FindFirst("id")?.Value;

            if (Guid.TryParse(idClaim, out var userId))
                return userId;

            throw new UnauthorizedAccessException("Invalid User ID in token");
        }
    }
}