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

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

namespace MoonlightServers.Api.Admin.Templates;

[ApiController]
[Route("api/admin/servers/templates")]
public class CrudController : Controller
{
    private readonly DatabaseRepository<Template> DatabaseRepository;
    private readonly DatabaseRepository<TemplateDockerImage> DockerImageRepository;

    public CrudController(
        DatabaseRepository<Template> databaseRepository,
        DatabaseRepository<TemplateDockerImage> dockerImageRepository
    )
    {
        DatabaseRepository = databaseRepository;
        DockerImageRepository = dockerImageRepository;
    }

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

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

        // Query building

        var query = DatabaseRepository
            .Query();

        // Filters
        if (filterOptions != null)
        {
            foreach (var filterOption in filterOptions.Filters)
            {
                query = filterOption.Key switch
                {
                    nameof(Template.Name) =>
                        query.Where(role => EF.Functions.ILike(role.Name, $"%{filterOption.Value}%")),

                    _ => query
                };
            }
        }

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

        var total = await query.CountAsync();

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

    [HttpGet("{id:int}")]
    [Authorize(Policy = Permissions.Templates.View)]
    public async Task<ActionResult<DetailedTemplateDto>> GetAsync([FromRoute] int id)
    {
        var template = await DatabaseRepository
            .Query()
            .Include(x => x.DefaultDockerImage)
            .FirstOrDefaultAsync(x => x.Id == id);

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

        return TemplateMapper.ToDetailedDto(template);
    }

    [HttpPost]
    [Authorize(Policy = Permissions.Templates.Create)]
    public async Task<ActionResult<TemplateDto>> CreateAsync([FromBody] CreateTemplateDto request)
    {
        var template = TemplateMapper.ToEntity(request);

        // Fill in default values
        template.LifecycleConfig = new()
        {
            StartupCommands = [
                new StartupCommand
                {
                    DisplayName = "Default Startup",
                    Command = "bash startup.sh"
                }
            ],
            StopCommand = "^C",
            OnlineLogPatterns = ["I am online"]
        };

        template.InstallationConfig = new()
        {
            DockerImage = "debian",
            Script = "#!/bin/bash\necho Installing",
            Shell = "/bin/bash"
        };

        template.FilesConfig = new()
        {
            ConfigurationFiles = []
        };
        
        template.MiscellaneousConfig = new()
        {
            UseLegacyStartup = true
        };

        var finalRole = await DatabaseRepository.AddAsync(template);

        return TemplateMapper.ToDto(finalRole);
    }

    [HttpPut("{id:int}")]
    [Authorize(Policy = Permissions.Templates.Edit)]
    public async Task<ActionResult<DetailedTemplateDto>> UpdateAsync([FromRoute] int id, [FromBody] UpdateTemplateDto request)
    {
        var template = await DatabaseRepository
            .Query()
            .FirstOrDefaultAsync(x => x.Id == id);

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

        TemplateMapper.Merge(template, request);

        template.DefaultDockerImage = await DockerImageRepository
            .Query()
            .Where(x => x.Template.Id == id)
            .FirstOrDefaultAsync(x => x.Id == request.DefaultDockerImageId);

        await DatabaseRepository.UpdateAsync(template);

        return TemplateMapper.ToDetailedDto(template);
    }

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

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

        await DatabaseRepository.RemoveAsync(template);

        return NoContent();
    }
}