674 lines
24 KiB
C#
674 lines
24 KiB
C#
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.Extensions.Logging;
|
|
using RobotNet10.MapEditor.Shared.DTOs.Layout;
|
|
using RobotNet10.MapEditor.Shared.DTOs.Requests;
|
|
using RobotNet10.MapEditor.Shared.DTOs.Responses;
|
|
using RobotNet10.MapEditor.Shared.Models;
|
|
using RobotNet10.MapManager.Services;
|
|
|
|
namespace RobotNet10.MapManager.Controllers;
|
|
|
|
/// <summary>
|
|
/// Controller for managing layouts, versions, and levels
|
|
/// </summary>
|
|
[ApiController]
|
|
[Route("api/layouts")]
|
|
[Authorize]
|
|
public class LayoutManagerController(
|
|
ILayoutService layoutService,
|
|
IImageStorageService imageStorageService,
|
|
ILogger<LayoutManagerController> logger) : ControllerBase
|
|
{
|
|
private readonly ILayoutService _layoutService = layoutService;
|
|
private readonly IImageStorageService _imageStorageService = imageStorageService;
|
|
private readonly ILogger<LayoutManagerController> _logger = logger;
|
|
|
|
// ==========================================
|
|
// LAYOUT OPERATIONS
|
|
// ==========================================
|
|
|
|
/// <summary>
|
|
/// Create a new layout
|
|
/// </summary>
|
|
[HttpPost]
|
|
[ProducesResponseType(typeof(LayoutDto), 201)]
|
|
[ProducesResponseType(400)]
|
|
public async Task<ActionResult<LayoutDto>> CreateLayout([FromBody] CreateLayoutRequest request)
|
|
{
|
|
try
|
|
{
|
|
var layout = await _layoutService.CreateLayoutAsync(request);
|
|
var dto = MapLayoutToDto(layout);
|
|
|
|
return CreatedAtAction(
|
|
nameof(GetLayout),
|
|
new { layoutId = layout.Id },
|
|
dto);
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Warning)) _logger.LogWarning(ex, "Failed to create layout: {LayoutId}", request.LayoutId);
|
|
return BadRequest(CreateErrorResponse(ex.Message, "VALIDATION_ERROR"));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Search layouts by text
|
|
/// </summary>
|
|
[HttpGet]
|
|
[ProducesResponseType(typeof(List<LayoutDto>), 200)]
|
|
public async Task<ActionResult<List<LayoutDto>>> SearchLayouts([FromQuery] string? search)
|
|
{
|
|
var layouts = await _layoutService.SearchLayoutsAsync(search);
|
|
var dtos = layouts.Select(MapLayoutToDto).ToList();
|
|
|
|
return Ok(dtos);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get layout by database ID
|
|
/// </summary>
|
|
[HttpGet("{layoutId:guid}")]
|
|
[ProducesResponseType(typeof(LayoutDto), 200)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<LayoutDto>> GetLayout(Guid layoutId)
|
|
{
|
|
var layout = await _layoutService.GetLayoutByIdAsync(layoutId);
|
|
|
|
if (layout == null)
|
|
{
|
|
return NotFound(CreateErrorResponse($"Layout with ID '{layoutId}' not found", "LAYOUT_NOT_FOUND"));
|
|
}
|
|
|
|
return Ok(MapLayoutToDto(layout));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get layout by layout ID string
|
|
/// </summary>
|
|
[HttpGet("by-id/{layoutId}")]
|
|
[ProducesResponseType(typeof(LayoutDto), 200)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<LayoutDto>> GetLayoutByLayoutId(string layoutId)
|
|
{
|
|
var layout = await _layoutService.GetLayoutByLayoutIdAsync(layoutId);
|
|
|
|
if (layout == null)
|
|
{
|
|
return NotFound(CreateErrorResponse($"Layout with ID '{layoutId}' not found", "LAYOUT_NOT_FOUND"));
|
|
}
|
|
|
|
return Ok(MapLayoutToDto(layout));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get layout by name
|
|
/// </summary>
|
|
[HttpGet("by-name/{layoutName}")]
|
|
[ProducesResponseType(typeof(LayoutDto), 200)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<LayoutDto>> GetLayoutByName(string layoutName)
|
|
{
|
|
var layout = await _layoutService.GetLayoutByNameAsync(layoutName);
|
|
|
|
if (layout == null)
|
|
{
|
|
return NotFound(CreateErrorResponse($"Layout with name '{layoutName}' not found", "LAYOUT_NOT_FOUND"));
|
|
}
|
|
|
|
return Ok(MapLayoutToDto(layout));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update layout
|
|
/// </summary>
|
|
[HttpPut("{layoutId:guid}")]
|
|
[ProducesResponseType(typeof(LayoutDto), 200)]
|
|
[ProducesResponseType(400)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<LayoutDto>> UpdateLayout(
|
|
Guid layoutId,
|
|
[FromBody] UpdateLayoutRequest request)
|
|
{
|
|
try
|
|
{
|
|
var layout = await _layoutService.UpdateLayoutAsync(layoutId, request);
|
|
|
|
return Ok(MapLayoutToDto(layout));
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Warning)) _logger.LogWarning(ex, "Failed to update layout: {LayoutId}", layoutId);
|
|
|
|
if (ex.Message.Contains("not found"))
|
|
return NotFound(CreateErrorResponse(ex.Message, "LAYOUT_NOT_FOUND"));
|
|
|
|
return BadRequest(CreateErrorResponse(ex.Message, "VALIDATION_ERROR"));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete layout (must be deactivated first)
|
|
/// Hard delete with cascade
|
|
/// </summary>
|
|
[HttpDelete("{layoutId:guid}")]
|
|
[ProducesResponseType(204)]
|
|
[ProducesResponseType(400)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<IActionResult> DeleteLayout(Guid layoutId)
|
|
{
|
|
try
|
|
{
|
|
var deleted = await _layoutService.DeleteLayoutAsync(layoutId);
|
|
|
|
if (!deleted)
|
|
{
|
|
return NotFound(CreateErrorResponse($"Layout with ID '{layoutId}' not found", "LAYOUT_NOT_FOUND"));
|
|
}
|
|
|
|
return NoContent();
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Warning)) _logger.LogWarning(ex, "Failed to delete layout: {LayoutId}", layoutId);
|
|
return BadRequest(CreateErrorResponse(ex.Message, "VALIDATION_ERROR"));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Activate layout
|
|
/// </summary>
|
|
[HttpPost("{layoutId:guid}/activate")]
|
|
[ProducesResponseType(typeof(LayoutDto), 200)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<LayoutDto>> ActivateLayout(Guid layoutId)
|
|
{
|
|
try
|
|
{
|
|
var layout = await _layoutService.ActivateLayoutAsync(layoutId);
|
|
|
|
return Ok(MapLayoutToDto(layout));
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Warning)) _logger.LogWarning(ex, "Failed to activate layout: {LayoutId}", layoutId);
|
|
return NotFound(CreateErrorResponse(ex.Message, "LAYOUT_NOT_FOUND"));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deactivate layout
|
|
/// </summary>
|
|
[HttpPost("{layoutId:guid}/deactivate")]
|
|
[ProducesResponseType(typeof(LayoutDto), 200)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<LayoutDto>> DeactivateLayout(Guid layoutId)
|
|
{
|
|
try
|
|
{
|
|
var layout = await _layoutService.DeactivateLayoutAsync(layoutId);
|
|
|
|
return Ok(MapLayoutToDto(layout));
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Warning)) _logger.LogWarning(ex, "Failed to deactivate layout: {LayoutId}", layoutId);
|
|
return NotFound(CreateErrorResponse(ex.Message, "LAYOUT_NOT_FOUND"));
|
|
}
|
|
}
|
|
|
|
// ==========================================
|
|
// VERSION OPERATIONS
|
|
// ==========================================
|
|
|
|
/// <summary>
|
|
/// Create new version for a layout
|
|
/// </summary>
|
|
[HttpPost("{layoutId:guid}/versions")]
|
|
[ProducesResponseType(typeof(LayoutVersionDto), 201)]
|
|
[ProducesResponseType(400)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<LayoutVersionDto>> CreateVersion(
|
|
Guid layoutId,
|
|
[FromBody] CreateLayoutVersionRequest request)
|
|
{
|
|
try
|
|
{
|
|
var version = await _layoutService.CreateVersionAsync(layoutId, request);
|
|
var dto = MapVersionToDto(version);
|
|
|
|
return CreatedAtAction(
|
|
nameof(GetVersion),
|
|
new { versionId = version.Id },
|
|
dto);
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Warning)) _logger.LogWarning(ex, "Failed to create version for layout: {LayoutId}", layoutId);
|
|
|
|
if (ex.Message.Contains("not found"))
|
|
return NotFound(CreateErrorResponse(ex.Message, "LAYOUT_NOT_FOUND"));
|
|
|
|
return BadRequest(CreateErrorResponse(ex.Message, "VALIDATION_ERROR"));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get all versions for a layout
|
|
/// </summary>
|
|
[HttpGet("{layoutId:guid}/versions")]
|
|
[ProducesResponseType(typeof(List<LayoutVersionDto>), 200)]
|
|
public async Task<ActionResult<List<LayoutVersionDto>>> GetVersions(Guid layoutId)
|
|
{
|
|
var versions = await _layoutService.GetVersionsAsync(layoutId);
|
|
var dtos = versions.Select(MapVersionToDto).ToList();
|
|
|
|
return Ok(dtos);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get version by ID
|
|
/// </summary>
|
|
[HttpGet("versions/{versionId:guid}")]
|
|
[ProducesResponseType(typeof(LayoutVersionDto), 200)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<LayoutVersionDto>> GetVersion(Guid versionId)
|
|
{
|
|
var version = await _layoutService.GetVersionAsync(versionId);
|
|
|
|
if (version == null)
|
|
{
|
|
return NotFound(CreateErrorResponse($"Version with ID '{versionId}' not found", "VERSION_NOT_FOUND"));
|
|
}
|
|
|
|
return Ok(MapVersionToDto(version));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update version
|
|
/// </summary>
|
|
[HttpPut("versions/{versionId:guid}")]
|
|
[ProducesResponseType(typeof(LayoutVersionDto), 200)]
|
|
[ProducesResponseType(400)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<LayoutVersionDto>> UpdateVersion(
|
|
Guid versionId,
|
|
[FromBody] UpdateLayoutRequest request)
|
|
{
|
|
try
|
|
{
|
|
var version = await _layoutService.UpdateVersionAsync(versionId, request);
|
|
|
|
return Ok(MapVersionToDto(version));
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Warning)) _logger.LogWarning(ex, "Failed to update version: {VersionId}", versionId);
|
|
|
|
if (ex.Message.Contains("not found"))
|
|
return NotFound(CreateErrorResponse(ex.Message, "VERSION_NOT_FOUND"));
|
|
|
|
return BadRequest(CreateErrorResponse(ex.Message, "VALIDATION_ERROR"));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete version (layout must be deactivated first)
|
|
/// </summary>
|
|
[HttpDelete("versions/{versionId:guid}")]
|
|
[ProducesResponseType(204)]
|
|
[ProducesResponseType(400)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<IActionResult> DeleteVersion(Guid versionId)
|
|
{
|
|
try
|
|
{
|
|
var deleted = await _layoutService.DeleteVersionAsync(versionId);
|
|
|
|
if (!deleted)
|
|
{
|
|
return NotFound(CreateErrorResponse($"Version with ID '{versionId}' not found", "VERSION_NOT_FOUND"));
|
|
}
|
|
|
|
return NoContent();
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Warning)) _logger.LogWarning(ex, "Failed to delete version: {VersionId}", versionId);
|
|
return BadRequest(CreateErrorResponse(ex.Message, "VALIDATION_ERROR"));
|
|
}
|
|
}
|
|
|
|
// ==========================================
|
|
// LEVEL OPERATIONS
|
|
// ==========================================
|
|
|
|
/// <summary>
|
|
/// Create new level for a version
|
|
/// </summary>
|
|
[HttpPost("versions/{versionId:guid}/levels")]
|
|
[ProducesResponseType(typeof(LayoutLevelDto), 201)]
|
|
[ProducesResponseType(400)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<LayoutLevelDto>> CreateLevel(
|
|
Guid versionId,
|
|
[FromBody] CreateLayoutLevelRequest request)
|
|
{
|
|
try
|
|
{
|
|
var level = await _layoutService.CreateLevelAsync(versionId, request);
|
|
var dto = MapLevelToDto(level);
|
|
|
|
return CreatedAtAction(
|
|
nameof(GetLevel),
|
|
new { levelId = level.Id },
|
|
dto);
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Warning)) _logger.LogWarning(ex, "Failed to create level for version: {VersionId}", versionId);
|
|
|
|
if (ex.Message.Contains("not found"))
|
|
return NotFound(CreateErrorResponse(ex.Message, "VERSION_NOT_FOUND"));
|
|
|
|
return BadRequest(CreateErrorResponse(ex.Message, "VALIDATION_ERROR"));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a new layout level with background image in a single request
|
|
/// </summary>
|
|
/// <param name="versionId">Version ID</param>
|
|
/// <param name="layoutLevelId">Layout level identifier string</param>
|
|
/// <param name="levelOrder">Level order</param>
|
|
/// <param name="resolution">Resolution in meters per pixel</param>
|
|
/// <param name="originX">Origin X coordinate in meters</param>
|
|
/// <param name="originY">Origin Y coordinate in meters</param>
|
|
/// <param name="file">Background image file (PNG format, required)</param>
|
|
/// <returns>Created level with image metadata</returns>
|
|
[HttpPost("versions/{versionId:guid}/levels/with-image")]
|
|
[ProducesResponseType(typeof(LayoutLevelDto), 201)]
|
|
[ProducesResponseType(400)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<LayoutLevelDto>> CreateLevelWithImage(
|
|
Guid versionId,
|
|
[FromForm] string layoutLevelId,
|
|
[FromForm] int levelOrder,
|
|
[FromForm] double resolution,
|
|
[FromForm] double originX,
|
|
[FromForm] double originY,
|
|
IFormFile file)
|
|
{
|
|
// Validate file
|
|
if (file == null || file.Length == 0)
|
|
{
|
|
return BadRequest(CreateErrorResponse("Image file is required", "VALIDATION_ERROR"));
|
|
}
|
|
|
|
// Validate file type
|
|
if (!file.ContentType.Equals("image/png", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return BadRequest(CreateErrorResponse("Only PNG images are supported", "VALIDATION_ERROR"));
|
|
}
|
|
|
|
// Validate file size (max 10MB)
|
|
const long maxFileSize = 10 * 1024 * 1024;
|
|
if (file.Length > maxFileSize)
|
|
{
|
|
return BadRequest(CreateErrorResponse($"File size exceeds maximum of {maxFileSize / 1024 / 1024}MB", "VALIDATION_ERROR"));
|
|
}
|
|
|
|
try
|
|
{
|
|
// Step 1: Extract image dimensions
|
|
int imageWidth, imageHeight;
|
|
using (var stream = file.OpenReadStream())
|
|
{
|
|
(imageWidth, imageHeight) = await _imageStorageService.GetImageDimensionsAsync(stream);
|
|
}
|
|
|
|
// Step 2: Create level with complete coordinate system info
|
|
var request = new CreateLayoutLevelRequest
|
|
{
|
|
LayoutLevelId = layoutLevelId,
|
|
LevelOrder = levelOrder,
|
|
CoordinateSystem = new CoordinateSystemInfo
|
|
{
|
|
Resolution = resolution,
|
|
OriginX = originX,
|
|
OriginY = originY,
|
|
ImageWidth = imageWidth,
|
|
ImageHeight = imageHeight,
|
|
// Calculate bounds based on image size
|
|
BoundsMinX = originX,
|
|
BoundsMaxX = imageWidth * resolution + originX,
|
|
BoundsMinY = originY,
|
|
BoundsMaxY = imageHeight * resolution + originY
|
|
}
|
|
};
|
|
|
|
var level = await _layoutService.CreateLevelAsync(versionId, request);
|
|
|
|
// Step 3: Upload image
|
|
try
|
|
{
|
|
using var stream = file.OpenReadStream();
|
|
await _imageStorageService.SaveImageAsync(level.Id, stream);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Error)) _logger.LogError(ex, "Failed to save image after creating level {LevelId}, attempting rollback", level.Id);
|
|
|
|
// Attempt to delete the created level to maintain consistency
|
|
try
|
|
{
|
|
await _layoutService.DeleteLevelAsync(level.Id);
|
|
}
|
|
catch (Exception rollbackEx)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Error)) _logger.LogError(rollbackEx, "Failed to rollback level creation for {LevelId}", level.Id);
|
|
}
|
|
|
|
return StatusCode(500, CreateErrorResponse("Failed to save image. Level creation was rolled back.", "INTERNAL_ERROR"));
|
|
}
|
|
|
|
var dto = MapLevelToDto(level);
|
|
|
|
return CreatedAtAction(
|
|
nameof(GetLevel),
|
|
new { levelId = level.Id },
|
|
dto);
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Warning)) _logger.LogWarning(ex, "Failed to create level with image for version: {VersionId}", versionId);
|
|
|
|
if (ex.Message.Contains("not found"))
|
|
return NotFound(CreateErrorResponse(ex.Message, "VERSION_NOT_FOUND"));
|
|
|
|
if (ex.Message.Contains("Invalid image") || ex.Message.Contains("corrupted"))
|
|
return BadRequest(CreateErrorResponse("Invalid or corrupted image file", "VALIDATION_ERROR"));
|
|
|
|
return BadRequest(CreateErrorResponse(ex.Message, "VALIDATION_ERROR"));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Error)) _logger.LogError(ex, "Unexpected error creating level with image for version {VersionId}", versionId);
|
|
return StatusCode(500, CreateErrorResponse("Internal server error while creating level with image", "INTERNAL_ERROR"));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get all levels for a version
|
|
/// </summary>
|
|
[HttpGet("versions/{versionId:guid}/levels")]
|
|
[ProducesResponseType(typeof(List<LayoutLevelDto>), 200)]
|
|
public async Task<ActionResult<List<LayoutLevelDto>>> GetLevels(Guid versionId)
|
|
{
|
|
var levels = await _layoutService.GetLevelsAsync(versionId);
|
|
var dtos = levels.Select(MapLevelToDto).ToList();
|
|
|
|
return Ok(dtos);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get level by ID
|
|
/// </summary>
|
|
[HttpGet("levels/{levelId:guid}")]
|
|
[ProducesResponseType(typeof(LayoutLevelDto), 200)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<LayoutLevelDto>> GetLevel(Guid levelId)
|
|
{
|
|
var level = await _layoutService.GetLevelAsync(levelId);
|
|
|
|
if (level == null)
|
|
{
|
|
return NotFound(CreateErrorResponse($"Level with ID '{levelId}' not found", "LEVEL_NOT_FOUND"));
|
|
}
|
|
|
|
return Ok(MapLevelToDto(level));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update level
|
|
/// </summary>
|
|
[HttpPut("levels/{levelId:guid}")]
|
|
[ProducesResponseType(typeof(LayoutLevelDto), 200)]
|
|
[ProducesResponseType(400)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<ActionResult<LayoutLevelDto>> UpdateLevel(
|
|
Guid levelId,
|
|
[FromBody] UpdateLayoutLevelRequest request)
|
|
{
|
|
try
|
|
{
|
|
var level = await _layoutService.UpdateLevelAsync(levelId, request);
|
|
|
|
return Ok(MapLevelToDto(level));
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Warning)) _logger.LogWarning(ex, "Failed to update level: {LevelId}", levelId);
|
|
|
|
if (ex.Message.Contains("not found"))
|
|
return NotFound(CreateErrorResponse(ex.Message, "LEVEL_NOT_FOUND"));
|
|
|
|
return BadRequest(CreateErrorResponse(ex.Message, "VALIDATION_ERROR"));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete level (layout must be deactivated first)
|
|
/// </summary>
|
|
[HttpDelete("levels/{levelId:guid}")]
|
|
[ProducesResponseType(204)]
|
|
[ProducesResponseType(400)]
|
|
[ProducesResponseType(404)]
|
|
public async Task<IActionResult> DeleteLevel(Guid levelId)
|
|
{
|
|
try
|
|
{
|
|
var deleted = await _layoutService.DeleteLevelAsync(levelId);
|
|
|
|
if (!deleted)
|
|
{
|
|
return NotFound(CreateErrorResponse($"Level with ID '{levelId}' not found", "LEVEL_NOT_FOUND"));
|
|
}
|
|
|
|
return NoContent();
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
if (_logger.IsEnabled(LogLevel.Warning)) _logger.LogWarning(ex, "Failed to delete level: {LevelId}", levelId);
|
|
return BadRequest(CreateErrorResponse(ex.Message, "VALIDATION_ERROR"));
|
|
}
|
|
}
|
|
|
|
// ==========================================
|
|
// HELPER METHODS
|
|
// ==========================================
|
|
|
|
private static LayoutDto MapLayoutToDto(Data.Layout layout)
|
|
{
|
|
return new LayoutDto
|
|
{
|
|
Id = layout.Id,
|
|
LayoutId = layout.LayoutId,
|
|
LayoutName = layout.LayoutName,
|
|
Description = layout.Description,
|
|
IsActive = layout.IsActive,
|
|
CreatedDate = layout.CreatedDate,
|
|
ModifiedDate = layout.ModifiedDate,
|
|
CreatedBy = layout.CreatedBy,
|
|
ModifiedBy = layout.ModifiedBy,
|
|
Versions = layout.Versions?.Select(MapVersionToDto).ToList()
|
|
};
|
|
}
|
|
|
|
private static LayoutVersionDto MapVersionToDto(Data.LayoutVersion version)
|
|
{
|
|
return new LayoutVersionDto
|
|
{
|
|
Id = version.Id,
|
|
LayoutId = version.LayoutId,
|
|
Version = version.Version,
|
|
LayoutDescription = version.LayoutDescription,
|
|
CreatedBy = version.CreatedBy,
|
|
CreatedDate = version.CreatedDate,
|
|
IsActive = version.IsActive,
|
|
Levels = version.Levels?.Select(MapLevelToDto).ToList()
|
|
};
|
|
}
|
|
|
|
private static LayoutLevelDto MapLevelToDto(Data.LayoutLevel level)
|
|
{
|
|
return new LayoutLevelDto
|
|
{
|
|
Id = level.Id,
|
|
VersionId = level.VersionId,
|
|
LayoutLevelId = level.LayoutLevelId,
|
|
LevelOrder = level.LevelOrder,
|
|
EditorSettings = level.EditorSettings != null ? MapEditorSettingsToDto(level.EditorSettings) : null
|
|
};
|
|
}
|
|
|
|
private static LayoutLevelEditorSettingsDto MapEditorSettingsToDto(Data.LayoutLevelEditorSettings settings)
|
|
{
|
|
return new LayoutLevelEditorSettingsDto
|
|
{
|
|
Id = settings.Id,
|
|
LevelId = settings.LevelId,
|
|
EdgeMinLengthCreate = settings.EdgeMinLengthCreate,
|
|
EdgeNameAutoGenerate = settings.EdgeNameAutoGenerate,
|
|
NodeNameAutoGenerate = settings.NodeNameAutoGenerate,
|
|
NodeProximityRadius = settings.NodeProximityRadius,
|
|
OriginX = settings.OriginX,
|
|
OriginY = settings.OriginY,
|
|
Resolution = settings.Resolution,
|
|
BoundsMinX = settings.BoundsMinX,
|
|
BoundsMaxX = settings.BoundsMaxX,
|
|
BoundsMinY = settings.BoundsMinY,
|
|
BoundsMaxY = settings.BoundsMaxY,
|
|
ImageWidth = settings.ImageWidth,
|
|
ImageHeight = settings.ImageHeight,
|
|
CreatedDate = settings.CreatedDate,
|
|
ModifiedDate = settings.ModifiedDate
|
|
};
|
|
}
|
|
|
|
private static ErrorResponseDto CreateErrorResponse(
|
|
string error,
|
|
string? errorCode = null,
|
|
Dictionary<string, object>? details = null)
|
|
{
|
|
return new ErrorResponseDto
|
|
{
|
|
Error = error,
|
|
ErrorCode = errorCode,
|
|
Details = details
|
|
};
|
|
}
|
|
}
|