130 lines
4.2 KiB
C#
130 lines
4.2 KiB
C#
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.Extensions.Logging;
|
|
using RobotNet10.MapEditor.Shared.DTOs.Node;
|
|
using RobotNet10.MapEditor.Shared.DTOs.Requests;
|
|
using RobotNet10.MapEditor.Shared.DTOs.Responses;
|
|
using RobotNet10.MapManager.Services;
|
|
|
|
namespace RobotNet10.MapManager.Controllers;
|
|
|
|
/// <summary>
|
|
/// Controller for managing nodes
|
|
/// </summary>
|
|
[ApiController]
|
|
[Route("api/nodes")]
|
|
[Authorize]
|
|
public class NodesController(
|
|
INodeService nodeService,
|
|
ILogger<NodesController> logger) : ControllerBase
|
|
{
|
|
private readonly INodeService _nodeService = nodeService;
|
|
private readonly ILogger<NodesController> _logger = logger;
|
|
|
|
/// <summary>
|
|
/// Get all nodes for a layout level
|
|
/// </summary>
|
|
/// <param name="layoutLevelId">Layout level ID</param>
|
|
/// <returns>List of nodes with vehicle properties</returns>
|
|
[HttpGet("level/{layoutLevelId}")]
|
|
[ProducesResponseType(typeof(List<NodeDto>), 200)]
|
|
public async Task<ActionResult<List<NodeDto>>> GetNodesByLevel(Guid layoutLevelId)
|
|
{
|
|
var nodes = await _nodeService.GetNodesByLevelAsync(layoutLevelId, includeVehicleProperties: true);
|
|
var dtos = nodes.Select(MapToDto).ToList();
|
|
|
|
return Ok(dtos);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get node by ID
|
|
/// </summary>
|
|
/// <param name="nodeId">Node database ID</param>
|
|
/// <returns>Node details with vehicle properties</returns>
|
|
[HttpGet("{nodeId}")]
|
|
[ProducesResponseType(typeof(NodeDto), 200)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<NodeDto>> GetNode(Guid nodeId)
|
|
{
|
|
var node = await _nodeService.GetByIdAsync(nodeId, includeVehicleProperties: true);
|
|
|
|
if (node == null)
|
|
{
|
|
return NotFound(CreateErrorResponse($"Node with ID '{nodeId}' not found", "NODE_NOT_FOUND"));
|
|
}
|
|
|
|
return Ok(MapToDto(node));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update node
|
|
/// </summary>
|
|
/// <param name="nodeId">Node database ID</param>
|
|
/// <param name="request">Update request</param>
|
|
/// <returns>Updated node</returns>
|
|
[HttpPut("{nodeId}")]
|
|
[ProducesResponseType(typeof(NodeDto), 200)]
|
|
[ProducesResponseType(400)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<NodeDto>> UpdateNode(
|
|
Guid nodeId,
|
|
[FromBody] UpdateNodeRequest request)
|
|
{
|
|
try
|
|
{
|
|
var node = await _nodeService.UpdateAsync(nodeId, request);
|
|
|
|
return Ok(MapToDto(node));
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Warning)) _logger.LogWarning(ex, "Failed to update node: {NodeId}", nodeId);
|
|
|
|
if (ex.Message.Contains("not found"))
|
|
return NotFound(CreateErrorResponse(ex.Message, "NODE_NOT_FOUND"));
|
|
|
|
return BadRequest(CreateErrorResponse(ex.Message, "VALIDATION_ERROR"));
|
|
}
|
|
}
|
|
|
|
// Helper method to map entity to DTO
|
|
private static NodeDto MapToDto(Data.Node node)
|
|
{
|
|
return new NodeDto
|
|
{
|
|
Id = node.Id,
|
|
LevelId = node.LevelId,
|
|
NodeId = node.NodeId,
|
|
NodeName = node.NodeName,
|
|
NodeDescription = node.NodeDescription,
|
|
MapId = node.MapId,
|
|
X = node.X,
|
|
Y = node.Y,
|
|
VehicleProperties = node.VehicleProperties?.Select(vp => new NodeVehiclePropertyDto
|
|
{
|
|
Id = vp.Id,
|
|
NodeId = vp.NodeId,
|
|
VehicleTypeId = vp.VehicleTypeId,
|
|
VehicleTypeIdString = vp.VehicleType?.VehicleTypeId,
|
|
Theta = vp.Theta,
|
|
Actions = vp.Actions,
|
|
AllowedDeviationXY = vp.AllowedDeviationXY,
|
|
AllowedDeviationTheta = vp.AllowedDeviationTheta
|
|
}).ToList()
|
|
};
|
|
}
|
|
|
|
private static ErrorResponseDto CreateErrorResponse(
|
|
string error,
|
|
string? errorCode = null,
|
|
Dictionary<string, object>? details = null)
|
|
{
|
|
return new ErrorResponseDto
|
|
{
|
|
Error = error,
|
|
ErrorCode = errorCode,
|
|
Details = details
|
|
};
|
|
}
|
|
}
|