Motion-ERP.API/Controllers/AssetsController.cs - main - HiddenLogic/Motion-ERP

Motion-ERP.API/Controllers/AssetsController.cs
142 строки5 KB
adnet
Initial commit: Motion-ERP solution structure
30 июл 2026, 17:01
30 июл 2026, 17:01bf32c92
using Microsoft.AspNetCore.Mvc;
using Motion_ERP_Application.DTOs;
using Motion_ERP_Application.Interfaces;
using Motion_ERP_Domain.Exceptions;
using Motion_ERP_Domain.Enums;

namespace Motion_ERP_API.Controllers;

[ApiController]
[Route("api/[controller]")]
public class AssetsController : ControllerBase
{
    private readonly IAssetService _assetService;

    public AssetsController(IAssetService assetService)
    {
        _assetService = assetService;
    }

    [HttpGet]
    [ProducesResponseType(typeof(IEnumerable<AssetListDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<IEnumerable<AssetListDto>>> GetAll([FromQuery] string? search, [FromQuery] string? status, CancellationToken ct)
    {
        var assets = await _assetService.GetAllAsync(search, status, ct);
        return Ok(assets);
    }

    [HttpGet("{id}")]
    [ProducesResponseType(typeof(AssetDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<AssetDto>> GetById(Guid id, CancellationToken ct)
    {
        try
        {
            var asset = await _assetService.GetAssetByIdAsync(id, ct);
            return Ok(asset);
        }
        catch (DomainException ex)
        {
            return NotFound(ex.Message);
        }
    }

    [HttpPost]
    [ProducesResponseType(typeof(AssetDto), StatusCodes.Status201Created)]
    public async Task<ActionResult<AssetDto>> Create(CreateAssetDto dto, CancellationToken ct)
    {
        var asset = await _assetService.CreateAssetAsync(dto, ct);
        return CreatedAtAction(nameof(GetById), new { id = asset.AssetId }, asset);
    }

    [HttpPut("{id}")]
    [ProducesResponseType(typeof(AssetDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<AssetDto>> Update(Guid id, UpdateAssetDto dto, CancellationToken ct)
    {
        try
        {
            var asset = await _assetService.UpdateAssetAsync(id, dto, ct);
            return Ok(asset);
        }
        catch (DomainException ex)
        {
            return NotFound(ex.Message);
        }
    }

    [HttpDelete("{id}")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> Delete(Guid id, CancellationToken ct)
    {
        try
        {
            await _assetService.DeleteAssetAsync(id, ct);
            return NoContent();
        }
        catch (DomainException ex)
        {
            return NotFound(ex.Message);
        }
    }

    [HttpGet("{id}/components")]
    [ProducesResponseType(typeof(IEnumerable<ComponentDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<IEnumerable<ComponentDto>>> GetComponents(Guid id, CancellationToken ct)
    {
        var components = await _assetService.GetComponentsAsync(id, ct);
        return Ok(components);
    }

    [HttpPost("{id}/components")]
    [ProducesResponseType(typeof(ComponentDto), StatusCodes.Status201Created)]
    public async Task<ActionResult<ComponentDto>> AddComponent(Guid id, CreateComponentDto dto, CancellationToken ct)
    {
        var component = await _assetService.AddComponentAsync(id, dto, ct);
        return CreatedAtAction(nameof(GetComponents), new { id }, component);
    }

    [HttpDelete("{assetId}/components/{componentId}")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    public async Task<IActionResult> RemoveComponent(Guid assetId, Guid componentId, CancellationToken ct)
    {
        await _assetService.RemoveComponentAsync(componentId, ct);
        return NoContent();
    }

    [HttpPut("{id}/status")]
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    public async Task<IActionResult> ChangeStatus(Guid id, [FromQuery] string status, CancellationToken ct)
    {
        try
        {
            await _assetService.ChangeStatusAsync(id, Enum.Parse<AssetStatus>(status), ct);
            return Ok();
        }
        catch (ArgumentException)
        {
            return BadRequest("Недопустимый статус.");
        }
        catch (DomainException ex)
        {
            return BadRequest(ex.Message);
        }
    }

    [HttpGet("{id}/availability")]
    [ProducesResponseType(typeof(AvailabilityResultDto), StatusCodes.Status200OK)]
    public async Task<ActionResult<AvailabilityResultDto>> CheckAvailability(Guid id, [FromQuery] DateTime from, [FromQuery] DateTime to, CancellationToken ct)
    {
        try
        {
            var result = await _assetService.CheckAvailabilityAsync(id, from, to, ct);
            return Ok(result);
        }
        catch (DomainException ex)
        {
            return NotFound(ex.Message);
        }
    }
}