Moonlight-Panel/Servers
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated to latest moonlight and mooncore version. Done refactoring to async scheme and other changes. Recreated database migrations and cleaned models

Browse Source
This commit is contained in:
ChiaraBm
2025-09-22 12:13:57 +02:00
parent 91fb15a03e
commit 85392208c4
150 changed files with 2722 additions and 2726 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
MoonlightServers.ApiServer/Http/Controllers/Admin/Nodes/NodeAllocationsController.cs
View File

@@ -1,9 +1,7 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MoonCore.Exceptions;
using MoonCore.Extended.Abstractions;
using MoonCore.Extended.Models;
using MoonCore.Models;
using MoonlightServers.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Mappers;
@@ -30,38 +28,39 @@ public class NodeAllocationsController : Controller
[HttpGet]
[Authorize(Policy = "permissions:admin.servers.nodes.get")]
public async Task<ActionResult<IPagedData<NodeAllocationResponse>>> Get(
public async Task<ActionResult<CountedData<NodeAllocationResponse>>> GetAsync(
[FromRoute] int nodeId,
[FromQuery] PagedOptions options
[FromQuery] int startIndex,
[FromQuery] int count
)
{
var count = await AllocationRepository
if (count > 100)
return Problem("Only 100 items can be fetched at a time", statusCode: 400);
var totalCount = await AllocationRepository
.Get()
.CountAsync(x => x.Node.Id == nodeId);
var allocations = await AllocationRepository
.Get()
.OrderBy(x => x.Id)
.Skip(options.Page * options.PageSize)
.Take(options.PageSize)
.Skip(startIndex)
.Take(count)
.Where(x => x.Node.Id == nodeId)
.AsNoTracking()
.ProjectToAdminResponse()
.ToArrayAsync();
return new PagedData<NodeAllocationResponse>()
return new CountedData<NodeAllocationResponse>()
{
Items = allocations,
CurrentPage = options.Page,
PageSize = options.PageSize,
TotalItems = count,
TotalPages = (int)Math.Ceiling(Math.Max(0, count) / (double)options.PageSize)
TotalCount = totalCount
};
}
[HttpGet("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.nodes.get")]
public async Task<ActionResult<NodeAllocationResponse>> GetSingle([FromRoute] int nodeId, [FromRoute] int id)
public async Task<ActionResult<NodeAllocationResponse>> GetSingleAsync([FromRoute] int nodeId, [FromRoute] int id)
{
var allocation = await AllocationRepository
.Get()
@@ -78,7 +77,7 @@ public class NodeAllocationsController : Controller
[HttpPost]
[Authorize(Policy = "permissions:admin.servers.nodes.create")]
public async Task<ActionResult<NodeAllocationResponse>> Create(
public async Task<ActionResult<NodeAllocationResponse>> CreateAsync(
[FromRoute] int nodeId,
[FromBody] CreateNodeAllocationRequest request
)
@@ -92,13 +91,13 @@ public class NodeAllocationsController : Controller
var allocation = AllocationMapper.ToAllocation(request);
var finalAllocation = await AllocationRepository.Add(allocation);
var finalAllocation = await AllocationRepository.AddAsync(allocation);
return AllocationMapper.ToNodeAllocation(finalAllocation);
}
[HttpPatch("{id:int}")]
public async Task<ActionResult<NodeAllocationResponse>> Update(
public async Task<ActionResult<NodeAllocationResponse>> UpdateAsync(
[FromRoute] int nodeId,
[FromRoute] int id,
[FromBody] UpdateNodeAllocationRequest request
@@ -113,13 +112,13 @@ public class NodeAllocationsController : Controller
return Problem("No allocation with that id found", statusCode: 404);
AllocationMapper.Merge(request, allocation);
await AllocationRepository.Update(allocation);
await AllocationRepository.UpdateAsync(allocation);
return AllocationMapper.ToNodeAllocation(allocation);
}
[HttpDelete("{id:int}")]
public async Task<ActionResult> Delete([FromRoute] int nodeId, [FromRoute] int id)
public async Task<ActionResult> DeleteAsync([FromRoute] int nodeId, [FromRoute] int id)
{
var allocation = await AllocationRepository
.Get()
@@ -129,12 +128,12 @@ public class NodeAllocationsController : Controller
if (allocation == null)
return Problem("No allocation with that id found", statusCode: 404);
await AllocationRepository.Remove(allocation);
await AllocationRepository.RemoveAsync(allocation);
return NoContent();
}
[HttpPost("range")]
public async Task<ActionResult> CreateRange(
public async Task<ActionResult> CreateRangeAsync(
[FromRoute] int nodeId,
[FromBody] CreateNodeAllocationRangeRequest request
)
@@ -179,58 +178,60 @@ public class NodeAllocationsController : Controller
})
.ToArray();
await AllocationRepository.RunTransaction(async set => { await set.AddRangeAsync(allocations); });
await AllocationRepository.RunTransactionAsync(async set => { await set.AddRangeAsync(allocations); });
return NoContent();
}
[HttpDelete("all")]
public async Task<ActionResult> DeleteAll([FromRoute] int nodeId)
public async Task<ActionResult> DeleteAllAsync([FromRoute] int nodeId)
{
var allocations = AllocationRepository
.Get()
.Where(x => x.Node.Id == nodeId)
.ToArray();
await AllocationRepository.RunTransaction(set => { set.RemoveRange(allocations); });
await AllocationRepository.RunTransactionAsync(set => { set.RemoveRange(allocations); });
return NoContent();
}
[HttpGet("free")]
[Authorize(Policy = "permissions:admin.servers.nodes.get")]
public async Task<IPagedData<NodeAllocationResponse>> GetFree(
public async Task<ActionResult<CountedData<NodeAllocationResponse>>> GetFreeAsync(
[FromRoute] int nodeId,
[FromQuery] PagedOptions options,
[FromQuery] int startIndex,
[FromQuery] int count,
[FromQuery] int serverId = -1
)
{
if (count > 100)
return Problem("Only 100 items can be fetched at a time", statusCode: 400);
var node = NodeRepository
.Get()
.FirstOrDefault(x => x.Id == nodeId);
if (node == null)
throw new HttpApiException("A node with this id could not be found", 404);
return Problem("A node with this id could not be found", statusCode: 404);
var freeAllocationsQuery = AllocationRepository
.Get()
.OrderBy(x => x.Id)
.Where(x => x.Node.Id == node.Id)
.Where(x => x.Server == null || x.Server.Id == serverId);
var count = await freeAllocationsQuery.CountAsync();
var totalCount = await freeAllocationsQuery.CountAsync();
var allocations = await freeAllocationsQuery
.Skip(options.Page * options.PageSize)
.Take(options.PageSize)
.Skip(startIndex)
.Take(count)
.AsNoTracking()
.ProjectToAdminResponse()
.ToArrayAsync();
return new PagedData<NodeAllocationResponse>()
return new CountedData<NodeAllocationResponse>()
{
Items = allocations,
CurrentPage = options.Page,
PageSize = options.PageSize,
TotalItems = count,
TotalPages = (int)Math.Ceiling(Math.Max(0, count) / (double)options.PageSize)
TotalCount = totalCount
};
}
}

9
MoonlightServers.ApiServer/Http/Controllers/Admin/Nodes/NodeStatusController.cs
View File

@@ -1,6 +1,5 @@
using System.Diagnostics;
using Microsoft.AspNetCore.Mvc;
using MoonCore.Exceptions;
using MoonCore.Extended.Abstractions;
using Microsoft.AspNetCore.Authorization;
using Microsoft.EntityFrameworkCore;
@@ -25,9 +24,9 @@ public class NodeStatusController : Controller
[HttpGet("{nodeId:int}/system/status")]
[Authorize(Policy = "permissions:admin.servers.nodes.status")]
public async Task<ActionResult<NodeSystemStatusResponse>> GetStatus([FromRoute] int nodeId)
public async Task<ActionResult<NodeSystemStatusResponse>> GetStatusAsync([FromRoute] int nodeId)
{
var node = await GetNode(nodeId);
var node = await GetNodeAsync(nodeId);
if (node.Value == null)
return node.Result ?? Problem("Unable to retrieve node");
@@ -39,7 +38,7 @@ public class NodeStatusController : Controller
try
{
var statusResponse = await NodeService.GetSystemStatus(node.Value);
var statusResponse = await NodeService.GetSystemStatusAsync(node.Value);
sw.Stop();
@@ -69,7 +68,7 @@ public class NodeStatusController : Controller
return response;
}
private async Task<ActionResult<Node>> GetNode(int nodeId)
private async Task<ActionResult<Node>> GetNodeAsync(int nodeId)
{
var result = await NodeRepository
.Get()

42
MoonlightServers.ApiServer/Http/Controllers/Admin/Nodes/NodesController.cs
View File

@@ -1,10 +1,7 @@
using System.ComponentModel.DataAnnotations;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MoonCore.Extended.Abstractions;
using Microsoft.AspNetCore.Authorization;
using MoonCore.Exceptions;
using MoonCore.Extended.Models;
using MoonCore.Helpers;
using MoonCore.Models;
using MoonlightServers.ApiServer.Database.Entities;
@@ -27,32 +24,35 @@ public class NodesController : Controller
[HttpGet]
[Authorize(Policy = "permissions:admin.servers.nodes.get")]
public async Task<IPagedData<NodeResponse>> Get([FromQuery] PagedOptions options)
public async Task<ActionResult<CountedData<NodeResponse>>> GetAsync(
[FromQuery] int startIndex,
[FromQuery] int count
)
{
var count = await NodeRepository.Get().CountAsync();
if (count > 100)
return Problem("Only 100 items can be fetched at a time", statusCode: 400);
var totalCount = await NodeRepository.Get().CountAsync();
var items = await NodeRepository
.Get()
.OrderBy(x => x.Id)
.Skip(options.Page * options.PageSize)
.Take(options.PageSize)
.Skip(startIndex)
.Take(count)
.AsNoTracking()
.ProjectToAdminResponse()
.ToArrayAsync();
return new PagedData<NodeResponse>()
return new CountedData<NodeResponse>()
{
Items = items,
CurrentPage = options.Page,
PageSize = options.PageSize,
TotalItems = count,
TotalPages = (int)Math.Ceiling(Math.Max(0, count) / (double)options.PageSize)
TotalCount = totalCount
};
}
[HttpGet("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.nodes.get")]
public async Task<ActionResult<NodeResponse>> GetSingle([FromRoute] int id)
public async Task<ActionResult<NodeResponse>> GetSingleAsync([FromRoute] int id)
{
var node = await NodeRepository
.Get()
@@ -62,27 +62,27 @@ public class NodesController : Controller
if (node == null)
return Problem("No node with this id found", statusCode: 404);
return node;
}
[HttpPost]
[Authorize(Policy = "permissions:admin.servers.nodes.create")]
public async Task<ActionResult<NodeResponse>> Create([FromBody] CreateNodeRequest request)
public async Task<ActionResult<NodeResponse>> CreateAsync([FromBody] CreateNodeRequest request)
{
var node = NodeMapper.ToNode(request);
node.TokenId = Formatter.GenerateString(6);
node.Token = Formatter.GenerateString(32);
var finalNode = await NodeRepository.Add(node);
var finalNode = await NodeRepository.AddAsync(node);
return NodeMapper.ToAdminNodeResponse(finalNode);
}
[HttpPatch("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.nodes.update")]
public async Task<ActionResult<NodeResponse>> Update([FromRoute] int id, [FromBody] UpdateNodeRequest request)
public async Task<ActionResult<NodeResponse>> UpdateAsync([FromRoute] int id, [FromBody] UpdateNodeRequest request)
{
var node = await NodeRepository
.Get()
@@ -92,14 +92,14 @@ public class NodesController : Controller
return Problem("No node with this id found", statusCode: 404);
NodeMapper.Merge(request, node);
await NodeRepository.Update(node);
await NodeRepository.UpdateAsync(node);
return NodeMapper.ToAdminNodeResponse(node);
}
[HttpDelete("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.nodes.delete")]
public async Task<ActionResult> Delete([FromRoute] int id)
public async Task<ActionResult> DeleteAsync([FromRoute] int id)
{
var node = await NodeRepository
.Get()
@@ -107,8 +107,8 @@ public class NodesController : Controller
if (node == null)
return Problem("No node with this id found", statusCode: 404);
await NodeRepository.Remove(node);
await NodeRepository.RemoveAsync(node);
return Ok();
}
}

15
MoonlightServers.ApiServer/Http/Controllers/Admin/Nodes/StatisticsController.cs
View File

@@ -2,7 +2,6 @@ using System.Diagnostics.CodeAnalysis;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MoonCore.Exceptions;
using MoonCore.Extended.Abstractions;
using MoonlightServers.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Services;
@@ -27,14 +26,14 @@ public class StatisticsController : Controller
[HttpGet]
[SuppressMessage("ReSharper.DPA", "DPA0011: High execution time of MVC action", MessageId = "time: 1142ms",
Justification = "The daemon has an artificial delay of one second to calculate accurate cpu usage values")]
public async Task<ActionResult<StatisticsResponse>> Get([FromRoute] int nodeId)
public async Task<ActionResult<StatisticsResponse>> GetAsync([FromRoute] int nodeId)
{
var node = await GetNode(nodeId);
var node = await GetNodeAsync(nodeId);
if (node.Value == null)
return node.Result ?? Problem("Unable to retrieve node");
var statistics = await NodeService.GetStatistics(node.Value);
var statistics = await NodeService.GetStatisticsAsync(node.Value);
return new StatisticsResponse()
{
@@ -66,14 +65,14 @@ public class StatisticsController : Controller
}
[HttpGet("docker")]
public async Task<ActionResult<DockerStatisticsResponse>> GetDocker([FromRoute] int nodeId)
public async Task<ActionResult<DockerStatisticsResponse>> GetDockerAsync([FromRoute] int nodeId)
{
var node = await GetNode(nodeId);
var node = await GetNodeAsync(nodeId);
if (node.Value == null)
return node.Result ?? Problem("Unable to retrieve node");
var statistics = await NodeService.GetDockerStatistics(node.Value);
var statistics = await NodeService.GetDockerStatisticsAsync(node.Value);
return new DockerStatisticsResponse()
{
@@ -87,7 +86,7 @@ public class StatisticsController : Controller
};
}
private async Task<ActionResult<Node>> GetNode(int nodeId)
private async Task<ActionResult<Node>> GetNodeAsync(int nodeId)
{
var result = await NodeRepository
.Get()

24
MoonlightServers.ApiServer/Http/Controllers/Admin/Servers/ServerVariablesController.cs
View File

@@ -1,10 +1,7 @@
using System.ComponentModel.DataAnnotations;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Authorization;
using MoonCore.Exceptions;
using MoonCore.Extended.Abstractions;
using MoonCore.Extended.Models;
using MoonCore.Models;
using MoonlightServers.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Mappers;
@@ -30,11 +27,15 @@ public class ServerVariablesController : Controller
[HttpGet("{serverId:int}/variables")]
[Authorize(Policy = "permissions:admin.servers.read")]
public async Task<ActionResult<PagedData<ServerVariableResponse>>> Get(
public async Task<ActionResult<CountedData<ServerVariableResponse>>> GetAsync(
[FromRoute] int serverId,
[FromQuery] PagedOptions options
[FromQuery] int startIndex,
[FromQuery] int count
)
{
if (count > 100)
return Problem("Only 100 items can be fetched at a time", statusCode: 400);
var serverExists = await ServerRepository
.Get()
.AnyAsync(x => x.Id == serverId);
@@ -46,23 +47,20 @@ public class ServerVariablesController : Controller
.Get()
.Where(x => x.Server.Id == serverId);
var count = await query.CountAsync();
var totalCount = await query.CountAsync();
var variables = await query
.OrderBy(x => x.Id)
.Skip(options.Page * options.PageSize)
.Take(options.PageSize)
.Skip(startIndex)
.Take(count)
.AsNoTracking()
.ProjectToAdminResponse()
.ToArrayAsync();
return new PagedData<ServerVariableResponse>()
return new CountedData<ServerVariableResponse>()
{
Items = variables,
CurrentPage = options.Page,
PageSize = options.PageSize,
TotalItems = count,
TotalPages = (int)Math.Ceiling(Math.Max(0, count) / (double)options.PageSize)
TotalCount = totalCount
};
}
}

51
MoonlightServers.ApiServer/Http/Controllers/Admin/Servers/ServersController.cs
View File

@@ -1,13 +1,8 @@
using System.ComponentModel.DataAnnotations;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Authorization;
using Microsoft.Extensions.Logging;
using MoonCore.Exceptions;
using MoonCore.Extended.Abstractions;
using MoonCore.Extended.Helpers;
using MoonCore.Extended.Models;
using MoonCore.Helpers;
using MoonCore.Models;
using Moonlight.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Database.Entities;
@@ -54,9 +49,15 @@ public class ServersController : Controller
[HttpGet]
[Authorize(Policy = "permissions:admin.servers.read")]
public async Task<ActionResult<IPagedData<ServerResponse>>> Get([FromQuery] PagedOptions options)
public async Task<ActionResult<CountedData<ServerResponse>>> GetAsync(
[FromQuery] int startIndex,
[FromQuery] int count
)
{
var count = await ServerRepository.Get().CountAsync();
if (count > 100)
return Problem("Only 100 items can be fetched at a time", statusCode: 400);
var totalCount = await ServerRepository.Get().CountAsync();
var servers = await ServerRepository
.Get()
@@ -65,25 +66,22 @@ public class ServersController : Controller
.Include(x => x.Variables)
.Include(x => x.Star)
.OrderBy(x => x.Id)
.Skip(options.Page * options.PageSize)
.Take(options.PageSize)
.Skip(startIndex)
.Take(count)
.AsNoTracking()
.ProjectToAdminResponse()
.ToArrayAsync();
return new PagedData<ServerResponse>()
return new CountedData<ServerResponse>()
{
Items = servers,
CurrentPage = options.Page,
PageSize = options.PageSize,
TotalItems = count,
TotalPages = (int)Math.Ceiling(Math.Max(0, count) / (double)options.PageSize)
TotalCount = totalCount
};
}
[HttpGet("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.read")]
public async Task<ActionResult<ServerResponse>> GetSingle([FromRoute] int id)
public async Task<ActionResult<ServerResponse>> GetSingleAsync([FromRoute] int id)
{
var server = await ServerRepository
.Get()
@@ -104,7 +102,7 @@ public class ServersController : Controller
[HttpPost]
[Authorize(Policy = "permissions:admin.servers.write")]
public async Task<ActionResult<ServerResponse>> Create([FromBody] CreateServerRequest request)
public async Task<ActionResult<ServerResponse>> CreateAsync([FromBody] CreateServerRequest request)
{
// Check if owner user exist
if (UserRepository.Get().All(x => x.Id != request.OwnerId))
@@ -192,11 +190,11 @@ public class ServersController : Controller
server.Node = node;
server.Star = star;
var finalServer = await ServerRepository.Add(server);
var finalServer = await ServerRepository.AddAsync(server);
try
{
await ServerService.Sync(finalServer);
await ServerService.SyncAsync(finalServer);
}
catch (Exception e)
{
@@ -204,7 +202,7 @@ public class ServersController : Controller
// We are deleting the server from the database after the creation has failed
// to ensure we won't have a bugged server in the database which doesn't exist on the node
await ServerRepository.Remove(finalServer);
await ServerRepository.RemoveAsync(finalServer);
throw;
}
@@ -214,7 +212,10 @@ public class ServersController : Controller
[HttpPatch("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.write")]
public async Task<ActionResult<ServerResponse>> Update([FromRoute] int id, [FromBody] UpdateServerRequest request)
public async Task<ActionResult<ServerResponse>> UpdateAsync(
[FromRoute] int id,
[FromBody] UpdateServerRequest request
)
{
//TODO: Handle shrinking virtual disk
@@ -277,16 +278,16 @@ public class ServersController : Controller
serverVar.Value = variable.Value;
}
await ServerRepository.Update(server);
await ServerRepository.UpdateAsync(server);
// Notify the node about the changes
await ServerService.Sync(server);
await ServerService.SyncAsync(server);
return ServerMapper.ToAdminServerResponse(server);
}
[HttpDelete("{id:int}")]
public async Task<ActionResult> Delete([FromRoute] int id, [FromQuery] bool force = false)
public async Task<ActionResult> DeleteAsync([FromRoute] int id, [FromQuery] bool force = false)
{
var server = await ServerRepository
.Get()
@@ -308,7 +309,7 @@ public class ServersController : Controller
{
// If the sync fails on the node and we aren't forcing the deletion,
// we don't want to delete it from the database yet
await ServerService.SyncDelete(server);
await ServerService.SyncDeleteAsync(server);
}
catch (Exception e)
{
@@ -323,7 +324,7 @@ public class ServersController : Controller
throw;
}
await ServerRepository.Remove(server);
await ServerRepository.RemoveAsync(server);
return NoContent();
}
}

37
MoonlightServers.ApiServer/Http/Controllers/Admin/Stars/StarDockerImagesController.cs
View File

@@ -1,12 +1,7 @@
using System.ComponentModel.DataAnnotations;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MoonCore.Exceptions;
using MoonCore.Extended.Abstractions;
using MoonCore.Extended.Helpers;
using Microsoft.AspNetCore.Authorization;
using MoonCore.Extended.Models;
using MoonCore.Helpers;
using MoonCore.Models;
using MoonlightServers.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Mappers;
@@ -33,9 +28,10 @@ public class StarDockerImagesController : Controller
[HttpGet]
[Authorize(Policy = "permissions:admin.servers.stars.get")]
public async Task<ActionResult<IPagedData<StarDockerImageResponse>>> Get(
public async Task<ActionResult<CountedData<StarDockerImageResponse>>> GetAsync(
[FromRoute] int starId,
[FromQuery] PagedOptions options
[FromQuery] int startIndex,
[FromQuery] int count
)
{
var starExists = StarRepository
@@ -49,29 +45,26 @@ public class StarDockerImagesController : Controller
.Get()
.Where(x => x.Star.Id == starId);
var count = await query.CountAsync();
var totalCount = await query.CountAsync();
var dockerImages = await query
.OrderBy(x => x.Id)
.Skip(options.Page * options.PageSize)
.Take(options.PageSize)
.Skip(startIndex)
.Take(count)
.AsNoTracking()
.ProjectToAdminResponse()
.ToArrayAsync();
return new PagedData<StarDockerImageResponse>()
return new CountedData<StarDockerImageResponse>()
{
Items = dockerImages,
CurrentPage = options.Page,
PageSize = options.PageSize,
TotalItems = count,
TotalPages = (int)Math.Ceiling(Math.Max(0, count) / (double)options.PageSize)
TotalCount = totalCount
};
}
[HttpGet("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.stars.read")]
public async Task<ActionResult<StarDockerImageResponse>> GetSingle([FromRoute] int starId, [FromRoute] int id)
public async Task<ActionResult<StarDockerImageResponse>> GetSingleAsync([FromRoute] int starId, [FromRoute] int id)
{
var starExists = StarRepository
.Get()
@@ -94,7 +87,7 @@ public class StarDockerImagesController : Controller
[HttpPost]
[Authorize(Policy = "permissions:admin.servers.stars.write")]
public async Task<ActionResult<StarDockerImageResponse>> Create(
public async Task<ActionResult<StarDockerImageResponse>> CreateAsync(
[FromRoute] int starId,
[FromBody] CreateStarDockerImageRequest request
)
@@ -109,14 +102,14 @@ public class StarDockerImagesController : Controller
var dockerImage = DockerImageMapper.ToDockerImage(request);
dockerImage.Star = star;
var finalDockerImage = await DockerImageRepository.Add(dockerImage);
var finalDockerImage = await DockerImageRepository.AddAsync(dockerImage);
return DockerImageMapper.ToAdminResponse(finalDockerImage);
}
[HttpPatch("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.stars.write")]
public async Task<ActionResult<StarDockerImageResponse>> Update(
public async Task<ActionResult<StarDockerImageResponse>> UpdateAsync(
[FromRoute] int starId,
[FromRoute] int id,
[FromBody] UpdateStarDockerImageRequest request
@@ -137,14 +130,14 @@ public class StarDockerImagesController : Controller
return Problem("No star docker image with this id found", statusCode: 404);
DockerImageMapper.Merge(request, dockerImage);
await DockerImageRepository.Update(dockerImage);
await DockerImageRepository.UpdateAsync(dockerImage);
return DockerImageMapper.ToAdminResponse(dockerImage);
}
[HttpDelete("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.stars.write")]
public async Task<ActionResult> Delete([FromRoute] int starId, [FromRoute] int id)
public async Task<ActionResult> DeleteAsync([FromRoute] int starId, [FromRoute] int id)
{
var starExists = StarRepository
.Get()
@@ -160,7 +153,7 @@ public class StarDockerImagesController : Controller
if (dockerImage == null)
return Problem("No star docker image with this id found", statusCode: 404);
await DockerImageRepository.Remove(dockerImage);
await DockerImageRepository.RemoveAsync(dockerImage);
return NoContent();
}
}

10
MoonlightServers.ApiServer/Http/Controllers/Admin/Stars/StarImportExportController.cs
View File

@@ -1,9 +1,7 @@
using System.Text;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using MoonCore.Exceptions;
using MoonCore.Helpers;
using MoonlightServers.ApiServer.Mappers;
using MoonlightServers.ApiServer.Services;
using MoonlightServers.Shared.Http.Responses.Admin.Stars;
@@ -23,15 +21,15 @@ public class StarImportExportController : Controller
[HttpGet("{starId:int}/export")]
[Authorize(Policy = "permissions:admin.servers.stars.get")]
public async Task<ActionResult> Export([FromRoute] int starId)
public async Task<ActionResult> ExportAsync([FromRoute] int starId)
{
var exportedStar = await ImportExportService.Export(starId);
var exportedStar = await ImportExportService.ExportAsync(starId);
return Content(exportedStar, "application/json");
}
[HttpPost("import")]
[Authorize(Policy = "permissions:admin.servers.stars.create")]
public async Task<StarResponse> Import()
public async Task<StarResponse> ImportAsync()
{
if (Request.Form.Files.Count == 0)
throw new HttpApiException("No file to import provided", 400);
@@ -44,7 +42,7 @@ public class StarImportExportController : Controller
using var sr = new StreamReader(stream, Encoding.UTF8);
var content = await sr.ReadToEndAsync();
var star = await ImportExportService.Import(content);
var star = await ImportExportService.ImportAsync(content);
return StarMapper.ToAdminResponse(star);
}

37
MoonlightServers.ApiServer/Http/Controllers/Admin/Stars/StarVariablesController.cs
View File

@@ -1,10 +1,8 @@
using System.ComponentModel.DataAnnotations;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Authorization;
using MoonCore.Exceptions;
using MoonCore.Extended.Abstractions;
using MoonCore.Extended.Models;
using MoonCore.Models;
using MoonlightServers.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Mappers;
@@ -30,11 +28,15 @@ public class StarVariablesController : Controller
[HttpGet]
[Authorize(Policy = "permissions:admin.servers.stars.get")]
public async Task<ActionResult<IPagedData<StarVariableResponse>>> Get(
public async Task<ActionResult<CountedData<StarVariableResponse>>> GetAsync(
[FromRoute] int starId,
[FromQuery] PagedOptions options
[FromQuery] int startIndex,
[FromQuery] int count
)
{
if (count > 100)
return Problem("Only 100 items can be fetched at a time", statusCode: 400);
var starExists = StarRepository
.Get()
.Any(x => x.Id == starId);
@@ -46,29 +48,26 @@ public class StarVariablesController : Controller
.Get()
.Where(x => x.Star.Id == starId);
var count = await query.CountAsync();
var totalCount = await query.CountAsync();
var variables = await query
.OrderBy(x => x.Id)
.Skip(options.Page * options.PageSize)
.Take(options.PageSize)
.Skip(startIndex)
.Take(count)
.AsNoTracking()
.ProjectToAdminResponse()
.ToArrayAsync();
return new PagedData<StarVariableResponse>()
return new CountedData<StarVariableResponse>()
{
Items = variables,
CurrentPage = options.Page,
PageSize = options.PageSize,
TotalItems = count,
TotalPages = (int)Math.Ceiling(Math.Max(0, count) / (double)options.PageSize)
TotalCount = totalCount
};
}
[HttpGet("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.stars.get")]
public async Task<StarVariableResponse> GetSingle(
public async Task<StarVariableResponse> GetSingleAsync(
[FromRoute] int starId,
[FromRoute] int id
)
@@ -92,7 +91,7 @@ public class StarVariablesController : Controller
[HttpPost("")]
[Authorize(Policy = "permissions:admin.servers.stars.create")]
public async Task<StarVariableResponse> Create([FromRoute] int starId,
public async Task<StarVariableResponse> CreateAsync([FromRoute] int starId,
[FromBody] CreateStarVariableRequest request)
{
var star = StarRepository
@@ -105,14 +104,14 @@ public class StarVariablesController : Controller
var starVariable = StarVariableMapper.ToStarVariable(request);
starVariable.Star = star;
await VariableRepository.Add(starVariable);
await VariableRepository.AddAsync(starVariable);
return StarVariableMapper.ToAdminResponse(starVariable);
}
[HttpPatch("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.stars.update")]
public async Task<StarVariableResponse> Update(
public async Task<StarVariableResponse> UpdateAsync(
[FromRoute] int starId,
[FromRoute] int id,
[FromBody] UpdateStarVariableRequest request
@@ -133,14 +132,14 @@ public class StarVariablesController : Controller
throw new HttpApiException("No variable with this id found", 404);
StarVariableMapper.Merge(request, starVariable);
await VariableRepository.Update(starVariable);
await VariableRepository.UpdateAsync(starVariable);
return StarVariableMapper.ToAdminResponse(starVariable);
}
[HttpDelete("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.stars.delete")]
public async Task Delete([FromRoute] int starId, [FromRoute] int id)
public async Task DeleteAsync([FromRoute] int starId, [FromRoute] int id)
{
var starExists = StarRepository
.Get()
@@ -156,6 +155,6 @@ public class StarVariablesController : Controller
if (starVariable == null)
throw new HttpApiException("No variable with this id found", 404);
await VariableRepository.Remove(starVariable);
await VariableRepository.RemoveAsync(starVariable);
}
}

44
MoonlightServers.ApiServer/Http/Controllers/Admin/Stars/StarsController.cs
View File

@@ -1,10 +1,7 @@
using System.ComponentModel.DataAnnotations;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Authorization;
using MoonCore.Exceptions;
using MoonCore.Extended.Abstractions;
using MoonCore.Extended.Models;
using MoonCore.Models;
using MoonlightServers.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Mappers;
@@ -26,32 +23,35 @@ public class StarsController : Controller
[HttpGet]
[Authorize(Policy = "permissions:admin.servers.stars.read")]
public async Task<ActionResult<IPagedData<StarResponse>>> Get([FromQuery] PagedOptions options)
public async Task<ActionResult<CountedData<StarResponse>>> GetAsync(
[FromQuery] int startIndex,
[FromQuery] int count
)
{
var count = await StarRepository.Get().CountAsync();
if (count > 100)
return Problem("Only 100 items can be fetched at a time", statusCode: 400);
var totalCount = await StarRepository.Get().CountAsync();
var stars = await StarRepository
.Get()
.OrderBy(x => x.Id)
.Skip(options.Page * options.PageSize)
.Take(options.PageSize)
.Skip(startIndex)
.Take(count)
.AsNoTracking()
.ProjectToAdminResponse()
.ToArrayAsync();
return new PagedData<StarResponse>()
return new CountedData<StarResponse>()
{
CurrentPage = options.Page,
Items = stars,
PageSize = options.PageSize,
TotalItems = count,
TotalPages = (int)Math.Ceiling(Math.Max(0, count) / (double)options.PageSize)
TotalCount = totalCount
};
}
[HttpGet("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.stars.read")]
public async Task<ActionResult<StarResponse>> GetSingle([FromRoute] int id)
public async Task<ActionResult<StarResponse>> GetSingleAsync([FromRoute] int id)
{
var star = await StarRepository
.Get()
@@ -67,7 +67,7 @@ public class StarsController : Controller
[HttpPost]
[Authorize(Policy = "permissions:admin.servers.stars.create")]
public async Task<ActionResult<StarResponse>> Create([FromBody] CreateStarRequest request)
public async Task<ActionResult<StarResponse>> CreateAsync([FromBody] CreateStarRequest request)
{
var star = StarMapper.ToStar(request);
@@ -86,14 +86,14 @@ public class StarsController : Controller
star.DefaultDockerImage = -1;
star.ParseConfiguration = "[]";
var finalStar = await StarRepository.Add(star);
var finalStar = await StarRepository.AddAsync(star);
return StarMapper.ToAdminResponse(finalStar);
}
[HttpPatch("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.stars.update")]
public async Task<ActionResult<StarResponse>> Update(
public async Task<ActionResult<StarResponse>> UpdateAsync(
[FromRoute] int id,
[FromBody] UpdateStarRequest request
)
@@ -104,16 +104,16 @@ public class StarsController : Controller
if (star == null)
return Problem("No star with that id found", statusCode: 404);
StarMapper.Merge(request, star);
await StarRepository.Update(star);
await StarRepository.UpdateAsync(star);
return StarMapper.ToAdminResponse(star);
}
[HttpDelete("{id:int}")]
[Authorize(Policy = "permissions:admin.servers.stars.delete")]
public async Task<ActionResult> Delete([FromRoute] int id)
public async Task<ActionResult> DeleteAsync([FromRoute] int id)
{
var star = await StarRepository
.Get()
@@ -121,8 +121,8 @@ public class StarsController : Controller
if (star == null)
return Problem("No star with that id found", statusCode: 404);
await StarRepository.Remove(star);
await StarRepository.RemoveAsync(star);
return NoContent();
}
}

55
MoonlightServers.ApiServer/Http/Controllers/Client/FilesController.cs
View File

@@ -1,7 +1,6 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MoonCore.Exceptions;
using MoonCore.Extended.Abstractions;
using MoonlightServers.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Services;
@@ -37,14 +36,14 @@ public class FilesController : Controller
}
[HttpGet("list")]
public async Task<ActionResult<ServerFilesEntryResponse[]>> List([FromRoute] int serverId, [FromQuery] string path)
public async Task<ActionResult<ServerFilesEntryResponse[]>> ListAsync([FromRoute] int serverId, [FromQuery] string path)
{
var server = await GetServerById(serverId, ServerPermissionLevel.Read);
var server = await GetServerByIdAsync(serverId, ServerPermissionLevel.Read);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
var entries = await ServerFileSystemService.List(server.Value, path);
var entries = await ServerFileSystemService.ListAsync(server.Value, path);
return entries.Select(x => new ServerFilesEntryResponse()
{
@@ -57,57 +56,57 @@ public class FilesController : Controller
}
[HttpPost("move")]
public async Task<ActionResult> Move([FromRoute] int serverId, [FromQuery] string oldPath, [FromQuery] string newPath)
public async Task<ActionResult> MoveAsync([FromRoute] int serverId, [FromQuery] string oldPath, [FromQuery] string newPath)
{
var server = await GetServerById(serverId, ServerPermissionLevel.ReadWrite);
var server = await GetServerByIdAsync(serverId, ServerPermissionLevel.ReadWrite);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
await ServerFileSystemService.Move(server.Value, oldPath, newPath);
await ServerFileSystemService.MoveAsync(server.Value, oldPath, newPath);
return NoContent();
}
[HttpDelete("delete")]
public async Task<ActionResult> Delete([FromRoute] int serverId, [FromQuery] string path)
public async Task<ActionResult> DeleteAsync([FromRoute] int serverId, [FromQuery] string path)
{
var server = await GetServerById(serverId, ServerPermissionLevel.ReadWrite);
var server = await GetServerByIdAsync(serverId, ServerPermissionLevel.ReadWrite);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
await ServerFileSystemService.Delete(server.Value, path);
await ServerFileSystemService.DeleteAsync(server.Value, path);
return NoContent();
}
[HttpPost("mkdir")]
public async Task<ActionResult> Mkdir([FromRoute] int serverId, [FromQuery] string path)
public async Task<ActionResult> MkdirAsync([FromRoute] int serverId, [FromQuery] string path)
{
var server = await GetServerById(serverId, ServerPermissionLevel.ReadWrite);
var server = await GetServerByIdAsync(serverId, ServerPermissionLevel.ReadWrite);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
await ServerFileSystemService.Mkdir(server.Value, path);
await ServerFileSystemService.MkdirAsync(server.Value, path);
return NoContent();
}
[HttpPost("touch")]
public async Task<ActionResult> Touch([FromRoute] int serverId, [FromQuery] string path)
public async Task<ActionResult> TouchAsync([FromRoute] int serverId, [FromQuery] string path)
{
var server = await GetServerById(serverId, ServerPermissionLevel.ReadWrite);
var server = await GetServerByIdAsync(serverId, ServerPermissionLevel.ReadWrite);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
await ServerFileSystemService.Mkdir(server.Value, path);
await ServerFileSystemService.MkdirAsync(server.Value, path);
return NoContent();
}
[HttpGet("upload")]
public async Task<ActionResult<ServerFilesUploadResponse>> Upload([FromRoute] int serverId)
public async Task<ActionResult<ServerFilesUploadResponse>> UploadAsync([FromRoute] int serverId)
{
var serverResult = await GetServerById(serverId, ServerPermissionLevel.ReadWrite);
var serverResult = await GetServerByIdAsync(serverId, ServerPermissionLevel.ReadWrite);
if (serverResult.Value == null)
return serverResult.Result ?? Problem("Unable to retrieve server");
@@ -137,9 +136,9 @@ public class FilesController : Controller
}
[HttpGet("download")]
public async Task<ActionResult<ServerFilesDownloadResponse>> Download([FromRoute] int serverId, [FromQuery] string path)
public async Task<ActionResult<ServerFilesDownloadResponse>> DownloadAsync([FromRoute] int serverId, [FromQuery] string path)
{
var serverResult = await GetServerById(serverId, ServerPermissionLevel.Read);
var serverResult = await GetServerByIdAsync(serverId, ServerPermissionLevel.Read);
if (serverResult.Value == null)
return serverResult.Result ?? Problem("Unable to retrieve server");
@@ -170,9 +169,9 @@ public class FilesController : Controller
}
[HttpPost("compress")]
public async Task<ActionResult> Compress([FromRoute] int serverId, [FromBody] ServerFilesCompressRequest request)
public async Task<ActionResult> CompressAsync([FromRoute] int serverId, [FromBody] ServerFilesCompressRequest request)
{
var server = await GetServerById(serverId, ServerPermissionLevel.ReadWrite);
var server = await GetServerByIdAsync(serverId, ServerPermissionLevel.ReadWrite);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
@@ -180,14 +179,14 @@ public class FilesController : Controller
if (!Enum.TryParse(request.Type, true, out CompressType type))
return Problem("Invalid compress type provided", statusCode: 400);
await ServerFileSystemService.Compress(server.Value, type, request.Items, request.Destination);
await ServerFileSystemService.CompressAsync(server.Value, type, request.Items, request.Destination);
return Ok();
}
[HttpPost("decompress")]
public async Task<ActionResult> Decompress([FromRoute] int serverId, [FromBody] ServerFilesDecompressRequest request)
public async Task<ActionResult> DecompressAsync([FromRoute] int serverId, [FromBody] ServerFilesDecompressRequest request)
{
var server = await GetServerById(serverId, ServerPermissionLevel.ReadWrite);
var server = await GetServerByIdAsync(serverId, ServerPermissionLevel.ReadWrite);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
@@ -195,11 +194,11 @@ public class FilesController : Controller
if (!Enum.TryParse(request.Type, true, out CompressType type))
return Problem("Invalid decompress type provided", statusCode: 400);
await ServerFileSystemService.Decompress(server.Value, type, request.Path, request.Destination);
await ServerFileSystemService.DecompressAsync(server.Value, type, request.Path, request.Destination);
return NoContent();
}
private async Task<ActionResult<Server>> GetServerById(int serverId, ServerPermissionLevel level)
private async Task<ActionResult<Server>> GetServerByIdAsync(int serverId, ServerPermissionLevel level)
{
var server = await ServerRepository
.Get()
@@ -209,7 +208,7 @@ public class FilesController : Controller
if (server == null)
return Problem("No server with this id found", statusCode: 404);
var authorizeResult = await AuthorizeService.Authorize(
var authorizeResult = await AuthorizeService.AuthorizeAsync(
User, server,
ServerPermissionConstants.Files,
level

25
MoonlightServers.ApiServer/Http/Controllers/Client/PowerController.cs
View File

@@ -1,10 +1,7 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MoonCore.Exceptions;
using MoonCore.Extended.Abstractions;
using MoonCore.Helpers;
using Moonlight.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Services;
using MoonlightServers.Shared.Constants;
@@ -34,44 +31,44 @@ public class PowerController : Controller
[HttpPost("start")]
[Authorize]
public async Task<ActionResult> Start([FromRoute] int serverId)
public async Task<ActionResult> StartAsync([FromRoute] int serverId)
{
var server = await GetServerById(serverId);
var server = await GetServerByIdAsync(serverId);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
await ServerService.Start(server.Value);
await ServerService.StartAsync(server.Value);
return NoContent();
}
[HttpPost("stop")]
[Authorize]
public async Task<ActionResult> Stop([FromRoute] int serverId)
public async Task<ActionResult> StopAsync([FromRoute] int serverId)
{
var server = await GetServerById(serverId);
var server = await GetServerByIdAsync(serverId);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
await ServerService.Stop(server.Value);
await ServerService.StopAsync(server.Value);
return NoContent();
}
[HttpPost("kill")]
[Authorize]
public async Task<ActionResult> Kill([FromRoute] int serverId)
public async Task<ActionResult> KillAsync([FromRoute] int serverId)
{
var server = await GetServerById(serverId);
var server = await GetServerByIdAsync(serverId);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
await ServerService.Kill(server.Value);
await ServerService.KillAsync(server.Value);
return NoContent();
}
private async Task<ActionResult<Server>> GetServerById(int serverId)
private async Task<ActionResult<Server>> GetServerByIdAsync(int serverId)
{
var server = await ServerRepository
.Get()
@@ -81,7 +78,7 @@ public class PowerController : Controller
if (server == null)
return Problem("No server with this id found", statusCode: 404);
var authorizeResult = await AuthorizeService.Authorize(
var authorizeResult = await AuthorizeService.AuthorizeAsync(
User, server,
ServerPermissionConstants.Power,
ServerPermissionLevel.ReadWrite

92
MoonlightServers.ApiServer/Http/Controllers/Client/ServersController.cs
View File

@@ -1,24 +1,19 @@
using System.ComponentModel.DataAnnotations;
using System.Security.Claims;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MoonCore.Exceptions;
using MoonCore.Extended.Abstractions;
using MoonCore.Extended.Models;
using MoonCore.Models;
using Moonlight.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Extensions;
using MoonlightServers.ApiServer.Mappers;
using MoonlightServers.ApiServer.Models;
using MoonlightServers.ApiServer.Services;
using MoonlightServers.Shared.Constants;
using MoonlightServers.Shared.Enums;
using MoonlightServers.Shared.Http.Requests.Client.Servers;
using MoonlightServers.Shared.Http.Responses.Client.Servers;
using MoonlightServers.Shared.Http.Responses.Client.Servers.Allocations;
using MoonlightServers.Shared.Models;
namespace MoonlightServers.ApiServer.Http.Controllers.Client;
@@ -52,8 +47,14 @@ public class ServersController : Controller
}
[HttpGet]
public async Task<ActionResult<PagedData<ServerDetailResponse>>> GetAll([FromQuery] PagedOptions options)
public async Task<ActionResult<CountedData<ServerDetailResponse>>> GetAllAsync(
[FromQuery] int startIndex,
[FromQuery] int count
)
{
if (count > 100)
return Problem("Only 100 items can be fetched at a time", statusCode: 400);
var userIdClaim = User.FindFirstValue("UserId");
if (string.IsNullOrEmpty(userIdClaim))
@@ -68,12 +69,12 @@ public class ServersController : Controller
.Include(x => x.Node)
.Where(x => x.OwnerId == userId);
var count = await query.CountAsync();
var totalCount = await query.CountAsync();
var items = await query
.OrderBy(x => x.Id)
.Skip(options.Page * options.PageSize)
.Take(options.PageSize)
.Skip(startIndex)
.Take(count)
.AsNoTracking()
.ToArrayAsync();
@@ -94,19 +95,22 @@ public class ServersController : Controller
}).ToArray()
}).ToArray();
return new PagedData<ServerDetailResponse>()
return new CountedData<ServerDetailResponse>()
{
Items = mappedItems,
CurrentPage = options.Page,
TotalItems = count,
PageSize = options.PageSize,
TotalPages = (int)Math.Ceiling(Math.Max(0, count) / (double)options.PageSize)
TotalCount = totalCount
};
}
[HttpGet("shared")]
public async Task<ActionResult<PagedData<ServerDetailResponse>>> GetAllShared([FromQuery] PagedOptions options)
public async Task<ActionResult<CountedData<ServerDetailResponse>>> GetAllSharedAsync(
[FromQuery] int startIndex,
[FromQuery] int count
)
{
if (count > 100)
return Problem("Only 100 items can be fetched at a time", statusCode: 400);
var userIdClaim = User.FindFirstValue("UserId");
if (string.IsNullOrEmpty(userIdClaim))
@@ -124,12 +128,12 @@ public class ServersController : Controller
.ThenInclude(x => x.Allocations)
.Where(x => x.UserId == userId);
var count = await query.CountAsync();
var totalCount = await query.CountAsync();
var items = await query
.OrderBy(x => x.Id)
.Skip(options.Page * options.PageSize)
.Take(options.PageSize)
.Skip(startIndex)
.Take(count)
.ToArrayAsync();
var ownerIds = items
@@ -164,18 +168,15 @@ public class ServersController : Controller
}
}).ToArray();
return new PagedData<ServerDetailResponse>()
return new CountedData<ServerDetailResponse>()
{
Items = mappedItems,
CurrentPage = options.Page,
TotalItems = count,
PageSize = options.PageSize,
TotalPages = (int)Math.Ceiling(Math.Max(0, count) / (double)options.PageSize)
TotalCount = totalCount
};
}
[HttpGet("{serverId:int}")]
public async Task<ActionResult<ServerDetailResponse>> Get([FromRoute] int serverId)
public async Task<ActionResult<ServerDetailResponse>> GetAsync([FromRoute] int serverId)
{
var server = await ServerRepository
.Get()
@@ -187,7 +188,7 @@ public class ServersController : Controller
if (server == null)
return Problem("No server with this id found", statusCode: 404);
var authorizationResult = await AuthorizeService.Authorize(
var authorizationResult = await AuthorizeService.AuthorizeAsync(
User,
server,
String.Empty,
@@ -238,18 +239,18 @@ public class ServersController : Controller
}
[HttpGet("{serverId:int}/status")]
public async Task<ActionResult<ServerStatusResponse>> GetStatus([FromRoute] int serverId)
public async Task<ActionResult<ServerStatusResponse>> GetStatusAsync([FromRoute] int serverId)
{
var server = await GetServerById(
var server = await GetServerByIdAsync(
serverId,
ServerPermissionConstants.Console,
ServerPermissionLevel.None
);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
var status = await ServerService.GetStatus(server.Value);
var status = await ServerService.GetStatusAsync(server.Value);
return new ServerStatusResponse()
{
@@ -258,14 +259,14 @@ public class ServersController : Controller
}
[HttpGet("{serverId:int}/ws")]
public async Task<ActionResult<ServerWebSocketResponse>> GetWebSocket([FromRoute] int serverId)
public async Task<ActionResult<ServerWebSocketResponse>> GetWebSocketAsync([FromRoute] int serverId)
{
var serverResult = await GetServerById(
var serverResult = await GetServerByIdAsync(
serverId,
ServerPermissionConstants.Console,
ServerPermissionLevel.Read
);
if (serverResult.Value == null)
return serverResult.Result ?? Problem("Unable to retrieve server");
@@ -292,18 +293,18 @@ public class ServersController : Controller
}
[HttpGet("{serverId:int}/logs")]
public async Task<ActionResult<ServerLogsResponse>> GetLogs([FromRoute] int serverId)
public async Task<ActionResult<ServerLogsResponse>> GetLogsAsync([FromRoute] int serverId)
{
var server = await GetServerById(
var server = await GetServerByIdAsync(
serverId,
ServerPermissionConstants.Console,
ServerPermissionLevel.Read
);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
var logs = await ServerService.GetLogs(server.Value);
var logs = await ServerService.GetLogsAsync(server.Value);
return new ServerLogsResponse()
{
@@ -312,18 +313,18 @@ public class ServersController : Controller
}
[HttpGet("{serverId:int}/stats")]
public async Task<ActionResult<ServerStatsResponse>> GetStats([FromRoute] int serverId)
public async Task<ActionResult<ServerStatsResponse>> GetStatsAsync([FromRoute] int serverId)
{
var server = await GetServerById(
var server = await GetServerByIdAsync(
serverId,
ServerPermissionConstants.Console,
ServerPermissionLevel.Read
);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
var stats = await ServerService.GetStats(server.Value);
var stats = await ServerService.GetStatsAsync(server.Value);
return new ServerStatsResponse()
{
@@ -337,9 +338,9 @@ public class ServersController : Controller
}
[HttpPost("{serverId:int}/command")]
public async Task<ActionResult> Command([FromRoute] int serverId, [FromBody] ServerCommandRequest request)
public async Task<ActionResult> CommandAsync([FromRoute] int serverId, [FromBody] ServerCommandRequest request)
{
var server = await GetServerById(
var server = await GetServerByIdAsync(
serverId,
ServerPermissionConstants.Console,
ServerPermissionLevel.ReadWrite
@@ -348,12 +349,13 @@ public class ServersController : Controller
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
await ServerService.RunCommand(server.Value, request.Command);
await ServerService.RunCommandAsync(server.Value, request.Command);
return NoContent();
}
private async Task<ActionResult<Server>> GetServerById(int serverId, string permissionId, ServerPermissionLevel level)
private async Task<ActionResult<Server>> GetServerByIdAsync(int serverId, string permissionId,
ServerPermissionLevel level)
{
var server = await ServerRepository
.Get()
@@ -363,7 +365,7 @@ public class ServersController : Controller
if (server == null)
return Problem("No server with this id found", statusCode: 404);
var authorizeResult = await AuthorizeService.Authorize(User, server, permissionId, level);
var authorizeResult = await AuthorizeService.AuthorizeAsync(User, server, permissionId, level);
if (!authorizeResult.Succeeded)
{

11
MoonlightServers.ApiServer/Http/Controllers/Client/SettingsController.cs
View File

@@ -1,7 +1,6 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MoonCore.Exceptions;
using MoonCore.Extended.Abstractions;
using MoonlightServers.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Services;
@@ -32,18 +31,18 @@ public class SettingsController : Controller
[HttpPost("{serverId:int}/install")]
[Authorize]
public async Task<ActionResult> Install([FromRoute] int serverId)
public async Task<ActionResult> InstallAsync([FromRoute] int serverId)
{
var server = await GetServerById(serverId);
var server = await GetServerByIdAsync(serverId);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
await ServerService.Install(server.Value);
await ServerService.InstallAsync(server.Value);
return NoContent();
}
private async Task<ActionResult<Server>> GetServerById(int serverId)
private async Task<ActionResult<Server>> GetServerByIdAsync(int serverId)
{
var server = await ServerRepository
.Get()
@@ -53,7 +52,7 @@ public class SettingsController : Controller
if (server == null)
return Problem("No server with this id found", statusCode: 404);
var authorizeResult = await AuthorizeService.Authorize(
var authorizeResult = await AuthorizeService.AuthorizeAsync(
User, server,
ServerPermissionConstants.Settings,
ServerPermissionLevel.ReadWrite

53
MoonlightServers.ApiServer/Http/Controllers/Client/SharesController.cs
View File

@@ -1,15 +1,11 @@
using System.ComponentModel.DataAnnotations;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MoonCore.Exceptions;
using MoonCore.Extended.Abstractions;
using MoonCore.Extended.Models;
using MoonCore.Models;
using Moonlight.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Mappers;
using MoonlightServers.ApiServer.Models;
using MoonlightServers.ApiServer.Services;
using MoonlightServers.Shared.Constants;
using MoonlightServers.Shared.Enums;
@@ -42,12 +38,16 @@ public class SharesController : Controller
}
[HttpGet]
public async Task<ActionResult<IPagedData<ServerShareResponse>>> GetAll(
public async Task<ActionResult<CountedData<ServerShareResponse>>> GetAllAsync(
[FromRoute] int serverId,
[FromQuery] PagedOptions options
[FromQuery] int startIndex,
[FromQuery] int count
)
{
var server = await GetServerById(serverId);
if (count > 100)
return Problem("Only 100 items can be fetched at a time", statusCode: 400);
var server = await GetServerByIdAsync(serverId);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
@@ -56,12 +56,12 @@ public class SharesController : Controller
.Get()
.Where(x => x.Server.Id == server.Value.Id);
var count = await query.CountAsync();
var totalCount = await query.CountAsync();
var items = await query
.OrderBy(x => x.Id)
.Skip(options.Page * options.PageSize)
.Take(options.PageSize)
.Skip(startIndex)
.Take(count)
.ToArrayAsync();
var userIds = items
@@ -81,23 +81,20 @@ public class SharesController : Controller
Permissions = ShareMapper.MapToPermissionLevels(x.Content)
}).ToArray();
return new PagedData<ServerShareResponse>()
return new CountedData<ServerShareResponse>()
{
Items = mappedItems,
CurrentPage = options.Page,
PageSize = options.PageSize,
TotalItems = count,
TotalPages = (int)Math.Ceiling(Math.Max(0, count) / (double)options.PageSize)
TotalCount = totalCount
};
}
[HttpGet("{id:int}")]
public async Task<ActionResult<ServerShareResponse>> Get(
public async Task<ActionResult<ServerShareResponse>> GetAsync(
[FromRoute] int serverId,
[FromRoute] int id
)
{
var server = await GetServerById(serverId);
var server = await GetServerByIdAsync(serverId);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
@@ -124,12 +121,12 @@ public class SharesController : Controller
}
[HttpPost]
public async Task<ActionResult<ServerShareResponse>> Create(
public async Task<ActionResult<ServerShareResponse>> CreateAsync(
[FromRoute] int serverId,
[FromBody] CreateShareRequest request
)
{
var server = await GetServerById(serverId);
var server = await GetServerByIdAsync(serverId);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
@@ -150,7 +147,7 @@ public class SharesController : Controller
UserId = user.Id
};
var finalShare = await ShareRepository.Add(share);
var finalShare = await ShareRepository.AddAsync(share);
var mappedItem = new ServerShareResponse()
{
@@ -163,13 +160,13 @@ public class SharesController : Controller
}
[HttpPatch("{id:int}")]
public async Task<ActionResult<ServerShareResponse>> Update(
public async Task<ActionResult<ServerShareResponse>> UpdateAsync(
[FromRoute] int serverId,
[FromRoute] int id,
[FromBody] UpdateShareRequest request
)
{
var server = await GetServerById(serverId);
var server = await GetServerByIdAsync(serverId);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
@@ -185,7 +182,7 @@ public class SharesController : Controller
share.UpdatedAt = DateTime.UtcNow;
await ShareRepository.Update(share);
await ShareRepository.UpdateAsync(share);
var user = await UserRepository
.Get()
@@ -205,12 +202,12 @@ public class SharesController : Controller
}
[HttpDelete("{id:int}")]
public async Task<ActionResult> Delete(
public async Task<ActionResult> DeleteAsync(
[FromRoute] int serverId,
[FromRoute] int id
)
{
var server = await GetServerById(serverId);
var server = await GetServerByIdAsync(serverId);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
@@ -222,11 +219,11 @@ public class SharesController : Controller
if (share == null)
return Problem("A share with that id cannot be found", statusCode: 404);
await ShareRepository.Remove(share);
await ShareRepository.RemoveAsync(share);
return NoContent();
}
private async Task<ActionResult<Server>> GetServerById(int serverId)
private async Task<ActionResult<Server>> GetServerByIdAsync(int serverId)
{
var server = await ServerRepository
.Get()
@@ -235,7 +232,7 @@ public class SharesController : Controller
if (server == null)
return Problem("No server with this id found", statusCode: 404);
var authorizeResult = await AuthorizeService.Authorize(
var authorizeResult = await AuthorizeService.AuthorizeAsync(
User, server,
ServerPermissionConstants.Shares,
ServerPermissionLevel.ReadWrite

43
MoonlightServers.ApiServer/Http/Controllers/Client/VariablesController.cs
View File

@@ -1,18 +1,14 @@
using System.ComponentModel.DataAnnotations;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MoonCore.Exceptions;
using MoonCore.Extended.Abstractions;
using MoonCore.Extended.Models;
using MoonCore.Models;
using Moonlight.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Database.Entities;
using MoonlightServers.ApiServer.Services;
using MoonlightServers.Shared.Constants;
using MoonlightServers.Shared.Enums;
using MoonlightServers.Shared.Http.Requests.Client.Servers.Variables;
using MoonlightServers.Shared.Http.Responses.Client.Servers.Shares;
using MoonlightServers.Shared.Http.Responses.Client.Servers.Variables;
namespace MoonlightServers.ApiServer.Http.Controllers.Client;
@@ -41,12 +37,16 @@ public class VariablesController : Controller
}
[HttpGet]
public async Task<ActionResult<PagedData<ServerVariableDetailResponse>>> Get(
public async Task<ActionResult<CountedData<ServerVariableDetailResponse>>> GetAsync(
[FromRoute] int serverId,
[FromQuery] PagedOptions options
[FromQuery] int startIndex,
[FromQuery] int count
)
{
var server = await GetServerById(serverId, ServerPermissionLevel.Read);
if (count > 100)
return Problem("Only 100 items can be fetched at a time", statusCode: 400);
var server = await GetServerByIdAsync(serverId, ServerPermissionLevel.Read);
if (server.Value == null)
return server.Result ?? Problem("Unable to retrieve server");
@@ -55,12 +55,12 @@ public class VariablesController : Controller
.Get()
.Where(x => x.Star.Id == server.Value.Star.Id);
var count = await query.CountAsync();
var totalCount = await query.CountAsync();
var starVariables = await query
.OrderBy(x => x.Id)
.Skip(options.Page * options.PageSize)
.Take(options.PageSize)
.Skip(startIndex)
.Take(count)
.ToArrayAsync();
var starVariableKeys = starVariables
@@ -87,25 +87,22 @@ public class VariablesController : Controller
};
}).ToArray();
return new PagedData<ServerVariableDetailResponse>()
return new CountedData<ServerVariableDetailResponse>()
{
Items = responses,
CurrentPage = options.Page,
PageSize = options.PageSize,
TotalItems = count,
TotalPages = (int)Math.Ceiling(Math.Max(0, count) / (double)options.PageSize)
TotalCount = totalCount
};
}
[HttpPut]
public async Task<ActionResult<ServerVariableDetailResponse>> UpdateSingle(
public async Task<ActionResult<ServerVariableDetailResponse>> UpdateSingleAsync(
[FromRoute] int serverId,
[FromBody] UpdateServerVariableRequest request
)
{
// TODO: Handle filter
var serverResult = await GetServerById(serverId, ServerPermissionLevel.ReadWrite);
var serverResult = await GetServerByIdAsync(serverId, ServerPermissionLevel.ReadWrite);
if (serverResult.Value == null)
return serverResult.Result ?? Problem("Unable to retrieve server");
@@ -119,7 +116,7 @@ public class VariablesController : Controller
throw new HttpApiException($"No variable with the key found: {request.Key}", 400);
serverVariable.Value = request.Value;
await ServerRepository.Update(server);
await ServerRepository.UpdateAsync(server);
return new ServerVariableDetailResponse()
{
@@ -133,12 +130,12 @@ public class VariablesController : Controller
}
[HttpPatch]
public async Task<ActionResult<ServerVariableDetailResponse[]>> Update(
public async Task<ActionResult<ServerVariableDetailResponse[]>> UpdateAsync(
[FromRoute] int serverId,
[FromBody] UpdateServerVariableRangeRequest request
)
{
var serverResult = await GetServerById(serverId, ServerPermissionLevel.ReadWrite);
var serverResult = await GetServerByIdAsync(serverId, ServerPermissionLevel.ReadWrite);
if (serverResult.Value == null)
return serverResult.Result ?? Problem("Unable to retrieve server");
@@ -158,7 +155,7 @@ public class VariablesController : Controller
serverVariable.Value = variable.Value;
}
await ServerRepository.Update(server);
await ServerRepository.UpdateAsync(server);
return request.Variables.Select(requestVariable =>
{
@@ -177,7 +174,7 @@ public class VariablesController : Controller
}).ToArray();
}
private async Task<ActionResult<Server>> GetServerById(int serverId, ServerPermissionLevel level)
private async Task<ActionResult<Server>> GetServerByIdAsync(int serverId, ServerPermissionLevel level)
{
var server = await ServerRepository
.Get()
@@ -189,7 +186,7 @@ public class VariablesController : Controller
if (server == null)
return Problem("No server with this id found", statusCode: 404);
var authorizeResult = await AuthorizeService.Authorize(
var authorizeResult = await AuthorizeService.AuthorizeAsync(
User, server,
ServerPermissionConstants.Variables,
level

2
MoonlightServers.ApiServer/Http/Controllers/Remote/Nodes/NodeTripController.cs
View File

@@ -9,5 +9,5 @@ namespace MoonlightServers.ApiServer.Http.Controllers.Remote.Nodes;
public class NodeTripController : Controller
{
[HttpGet("trip")]
public Task Get() => Task.CompletedTask;
public Task GetAsync() => Task.CompletedTask;
}

25
MoonlightServers.ApiServer/Http/Controllers/Remote/ServersController.cs
View File

@@ -31,8 +31,14 @@ public class ServersController : Controller
}
[HttpGet]
public async Task<PagedData<ServerDataResponse>> Get([FromQuery] int page, [FromQuery] int pageSize)
public async Task<ActionResult<CountedData<ServerDataResponse>>> GetAsync(
[FromQuery] int startIndex,
[FromQuery] int count
)
{
if (count > 100)
return Problem("Only 100 items can be fetched at a time", statusCode: 400);
// Load the node via the id
var nodeId = int.Parse(User.Claims.First(x => x.Type == "nodeId").Value);
@@ -52,8 +58,8 @@ public class ServersController : Controller
.ThenInclude(x => x.DockerImages)
.Include(x => x.Variables)
.Include(x => x.Allocations)
.Skip(page * pageSize)
.Take(pageSize)
.Skip(startIndex)
.Take(count)
.ToArrayAsync();
var serverData = new List<ServerDataResponse>();
@@ -68,18 +74,15 @@ public class ServersController : Controller
serverData.Add(convertedData);
}
return new PagedData<ServerDataResponse>()
return new CountedData<ServerDataResponse>()
{
Items = serverData.ToArray(),
CurrentPage = page,
PageSize = pageSize,
TotalItems = total,
TotalPages = total == 0 ? 0 : total / pageSize
TotalCount = total
};
}
[HttpGet("{id:int}")]
public async Task<ServerDataResponse> Get([FromRoute] int id)
public async Task<ServerDataResponse> GetAsync([FromRoute] int id)
{
// Load the node via the id
var nodeId = int.Parse(User.Claims.First(x => x.Type == "nodeId").Value);
@@ -111,7 +114,7 @@ public class ServersController : Controller
}
[HttpGet("{id:int}/install")]
public async Task<ServerInstallDataResponse> GetInstall([FromRoute] int id)
public async Task<ServerInstallDataResponse> GetInstallAsync([FromRoute] int id)
{
// Load the node via the id
var nodeId = int.Parse(User.Claims.First(x => x.Type == "nodeId").Value);
@@ -180,7 +183,6 @@ public class ServersController : Controller
Port = x.Port
}).ToArray(),
Variables = server.Variables.ToDictionary(x => x.Key, x => x.Value),
Bandwidth = server.Bandwidth,
Cpu = server.Cpu,
Disk = server.Disk,
Memory = server.Memory,
@@ -189,7 +191,6 @@ public class ServersController : Controller
PullDockerImage = dockerImage.AutoPulling,
ParseConiguration = server.Star.ParseConfiguration,
StopCommand = server.Star.StopCommand,
UseVirtualDisk = server.UseVirtualDisk
};
}
}