ersatztv/ErsatzTV/Controllers/Api/ScheduleController.cs

using System.ComponentModel.DataAnnotations;
using System.Linq;
using ErsatzTV.Application.ProgramSchedules;
using ErsatzTV.Controllers.Api.Requests;
using ErsatzTV.Core;
using ErsatzTV.Core.Api.Scheduling;
using ErsatzTV.Extensions;
using MediatR;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace ErsatzTV.Controllers.Api;

[ApiController]
public class ScheduleController(IMediator mediator) : ControllerBase
{
    [HttpGet("/api/schedules")]
    [Tags("Schedules")]
    [EndpointSummary("Get all schedules")]
    [EndpointGroupName("general")]
    [ProducesResponseType(typeof(List<ProgramScheduleViewModel>), StatusCodes.Status200OK)]
    public async Task<List<ProgramScheduleViewModel>> GetAll(CancellationToken cancellationToken) =>
        await mediator.Send(new GetAllProgramSchedules(), cancellationToken);

    [HttpGet("/api/schedules/{id:int}", Name = "GetScheduleById")]
    [Tags("Schedules")]
    [EndpointSummary("Get a schedule by id")]
    [EndpointGroupName("general")]
    [ProducesResponseType(typeof(ProgramScheduleViewModel), StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
    public async Task<IActionResult> GetById(int id, CancellationToken cancellationToken)
    {
        Option<ProgramScheduleViewModel> result = await mediator.Send(new GetProgramScheduleById(id), cancellationToken);
        return result.ToGetResult();
    }

    [HttpPost("/api/schedules")]
    [Tags("Schedules")]
    [EndpointSummary("Create a schedule")]
    [EndpointGroupName("general")]
    [ProducesResponseType(typeof(ProgramScheduleViewModel), StatusCodes.Status201Created)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
    public async Task<IActionResult> Create(
        [Required] [FromBody] CreateScheduleRequest request,
        CancellationToken cancellationToken)
    {
        Either<BaseError, CreateProgramScheduleResult> result =
            await mediator.Send(request.ToCreateCommand(), cancellationToken);
        return await result.Match(
            Left: error => Task.FromResult(error.ToErrorResult()),
            Right: async created =>
            {
                Option<ProgramScheduleViewModel> schedule =
                    await mediator.Send(new GetProgramScheduleById(created.ProgramScheduleId), cancellationToken);
                return schedule.Match(
                    Some: vm => (IActionResult)new CreatedResult($"/api/schedules/{vm.Id}", vm),
                    None: () => ApiResults.NotFoundProblem());
            });
    }

    [HttpPut("/api/schedules/{id:int}")]
    [Tags("Schedules")]
    [EndpointSummary("Update a schedule")]
    [EndpointGroupName("general")]
    [ProducesResponseType(typeof(ProgramScheduleViewModel), StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
    public async Task<IActionResult> Update(
        int id,
        [Required] [FromBody] UpdateScheduleRequest request,
        CancellationToken cancellationToken)
    {
        Either<BaseError, UpdateProgramScheduleResult> result =
            await mediator.Send(request.ToCommand(id), cancellationToken);
        return await result.Match(
            Left: error => Task.FromResult(error.ToErrorResult()),
            Right: async _ =>
            {
                Option<ProgramScheduleViewModel> schedule =
                    await mediator.Send(new GetProgramScheduleById(id), cancellationToken);
                return schedule.Match(
                    Some: vm => (IActionResult)new OkObjectResult(vm),
                    None: () => ApiResults.NotFoundProblem());
            });
    }

    [HttpDelete("/api/schedules/{id:int}")]
    [Tags("Schedules")]
    [EndpointSummary("Delete a schedule")]
    [EndpointGroupName("general")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
    public async Task<IActionResult> Delete(int id, CancellationToken cancellationToken)
    {
        Either<BaseError, Unit> result = await mediator.Send(new DeleteProgramSchedule(id), cancellationToken);
        return result.ToDeletedResult();
    }

    [HttpGet("/api/schedules/{id:int}/items")]
    [Tags("Schedules")]
    [EndpointSummary("Get schedule items")]
    [EndpointDescription(
        "Returns the schedule's items plus a computed, best-effort runtime estimate: each item carries a " +
        "nullable durationEstimate and the envelope carries a nullable totalDurationEstimate. Estimates are " +
        "derived from referenced collection/media runtimes and are null when unbounded or unknown.")]
    [EndpointGroupName("general")]
    [ProducesResponseType(typeof(ScheduleItemsResponseModel), StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
    public async Task<IActionResult> GetItems(int id, CancellationToken cancellationToken)
    {
        Option<ProgramScheduleViewModel> schedule = await mediator.Send(new GetProgramScheduleById(id), cancellationToken);
        if (schedule.IsNone)
        {
            return ApiResults.NotFoundProblem();
        }

        ProgramScheduleItemsWithDurationViewModel items =
            await mediator.Send(new GetProgramScheduleItemsWithDurations(id), cancellationToken);
        return new OkObjectResult(ScheduleItemResponseMapper.ProjectToResponseModel(items));
    }

    [HttpPost("/api/schedules/{id:int}/items")]
    [Tags("Schedules")]
    [EndpointSummary("Add a schedule item")]
    [EndpointGroupName("general")]
    [ProducesResponseType(typeof(ScheduleItemResponseModel), StatusCodes.Status201Created)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
    public async Task<IActionResult> AddItem(
        int id,
        [Required] [FromBody] ScheduleItemRequest request,
        CancellationToken cancellationToken)
    {
        Either<BaseError, ProgramScheduleItemViewModel> result =
            await mediator.Send(request.ToAddCommand(id), cancellationToken);
        return result.ToCreatedResult(
            item => $"/api/schedules/{id}/items/{item.Id}",
            item => ScheduleItemResponseMapper.ProjectToResponseModel(item));
    }

    [HttpPut("/api/schedules/{id:int}/items")]
    [Tags("Schedules")]
    [EndpointSummary("Replace schedule items")]
    [EndpointGroupName("general")]
    [ProducesResponseType(typeof(List<ScheduleItemResponseModel>), StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
    public async Task<IActionResult> ReplaceItems(
        int id,
        [Required] [FromBody] ReplaceScheduleItemsRequest request,
        CancellationToken cancellationToken)
    {
        Either<BaseError, IEnumerable<ProgramScheduleItemViewModel>> result =
            await mediator.Send(request.ToCommand(id), cancellationToken);
        return result
            .Map(items => items.Select(ScheduleItemResponseMapper.ProjectToResponseModel).ToList())
            .ToUpdatedResult();
    }

    [HttpDelete("/api/schedules/{id:int}/items/{itemId:int}")]
    [Tags("Schedules")]
    [EndpointSummary("Delete a schedule item")]
    [EndpointGroupName("general")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
    public async Task<IActionResult> DeleteItem(int id, int itemId, CancellationToken cancellationToken)
    {
        Either<BaseError, Unit> result =
            await mediator.Send(new DeleteProgramScheduleItem(id, itemId), cancellationToken);
        return result.ToDeletedResult();
    }
}