Servers/MoonlightServers.Api/Admin/Templates/VariablesController.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Moonlight.Shared.Http.Responses;
using MoonlightServers.Api.Infrastructure.Database;
using MoonlightServers.Api.Infrastructure.Database.Entities;
using MoonlightServers.Shared;
using MoonlightServers.Shared.Admin.Templates;

namespace MoonlightServers.Api.Admin.Templates;

[ApiController]
[Route("api/admin/servers/templates/{templateId:int}/variables")]
public class VariablesController : Controller
{
    private readonly DatabaseRepository<TemplateVariable> VariableRepository;
    private readonly DatabaseRepository<Template> TemplateRepository;

    public VariablesController(
        DatabaseRepository<TemplateVariable> variableRepository,
        DatabaseRepository<Template> templateRepository
    )
    {
        VariableRepository = variableRepository;
        TemplateRepository = templateRepository;
    }

    [HttpGet]
    [Authorize(Policy = Permissions.Templates.View)]
    public async Task<ActionResult<PagedData<VariableDto>>> GetAsync(
        [FromRoute] int templateId,
        [FromQuery] int startIndex,
        [FromQuery] int length
    )
    {
        // Validation
        if (startIndex < 0)
            return Problem("Invalid start index specified", statusCode: 400);

        if (length is < 1 or > 100)
            return Problem("Invalid length specified");

        if (!await TemplateRepository.Query().AnyAsync(x => x.Id == templateId))
            return Problem("No template with that id found", statusCode: 404);

        // Query building

        var query = VariableRepository
            .Query()
            .Where(x => x.Template.Id == templateId);

        // Pagination
        var data = await query
            .OrderBy(x => x.Id)
            .ProjectToDto()
            .Skip(startIndex)
            .Take(length)
            .ToArrayAsync();

        var total = await query.CountAsync();

        return new PagedData<VariableDto>(data, total);
    }

    [HttpGet("{id:int}")]
    [Authorize(Policy = Permissions.Templates.View)]
    public async Task<ActionResult<VariableDto>> GetAsync(
        [FromRoute] int templateId,
        [FromRoute] int id
    )
    {
        var templateVariable = await VariableRepository
            .Query()
            .FirstOrDefaultAsync(x => x.Id == id && x.Template.Id == templateId);

        if (templateVariable == null)
            return Problem("No template or template variable found with that id");

        return TemplateMapper.ToDto(templateVariable);
    }

    [HttpPost]
    [Authorize(Policy = Permissions.Templates.Create)]
    public async Task<ActionResult<VariableDto>> CreateAsync(
        [FromRoute] int templateId,
        [FromBody] CreateVariableDto dto
    )
    {
        var template = await TemplateRepository
            .Query()
            .FirstOrDefaultAsync(x => x.Id == templateId);

        if (template == null)
            return Problem("No template with that id found", statusCode: 404);

        var variable = TemplateMapper.ToEntity(dto);

        variable.Template = template;

        var finalVariable = await VariableRepository.AddAsync(variable);

        return TemplateMapper.ToDto(finalVariable);
    }

    [HttpPut("{id:int}")]
    [Authorize(Policy = Permissions.Templates.Edit)]
    public async Task<ActionResult<VariableDto>> UpdateAsync(
        [FromRoute] int templateId,
        [FromRoute] int id,
        [FromBody] UpdateVariableDto dto
    )
    {
        var templateVariable = await VariableRepository
            .Query()
            .FirstOrDefaultAsync(x => x.Id == id && x.Template.Id == templateId);

        if (templateVariable == null)
            return Problem("No template or template variable found with that id");

        TemplateMapper.Merge(templateVariable, dto);

        await VariableRepository.UpdateAsync(templateVariable);

        return TemplateMapper.ToDto(templateVariable);
    }

    [HttpDelete("{id:int}")]
    [Authorize(Policy = Permissions.Templates.Delete)]
    public async Task<ActionResult> DeleteAsync(
        [FromRoute] int templateId,
        [FromRoute] int id
    )
    {
        var templateVariable = await VariableRepository
            .Query()
            .FirstOrDefaultAsync(x => x.Id == id && x.Template.Id == templateId);

        if (templateVariable == null)
            return Problem("No template or template variable found with that id");

        await VariableRepository.RemoveAsync(templateVariable);
        return NoContent();
    }
}