AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP/Controllers/OrderController.cs

using Admin.NET.Plugin.AiDOP.Dto;
using Admin.NET.Plugin.AiDOP.Entity;
using Admin.NET.Plugin.AiDOP.Infrastructure;

namespace Admin.NET.Plugin.AiDOP.Controllers;

/// <summary>
/// 与 Gitee Ai-DOP Demo 的 <c>api/Order</c> 路由保持一致，便于前端与脚本迁移。
/// </summary>
[ApiController]
[Route("api/[controller]")]
[AllowAnonymous]
[NonUnify]
public class OrderController : ControllerBase
{
    private readonly SqlSugarRepository<AdoOrder> _orderRep;

    public OrderController(SqlSugarRepository<AdoOrder> orderRep)
    {
        _orderRep = orderRep;
    }

    [HttpGet]
    public async Task<IActionResult> GetOrders([FromQuery] OrderQueryDto query)
    {
        (query.Page, query.PageSize) = PagingGuard.Normalize(query.Page, query.PageSize);
        var q = _orderRep.AsQueryable();

        if (!string.IsNullOrWhiteSpace(query.OrderNo))
            q = q.Where(x => x.OrderNo.Contains(query.OrderNo));
        if (!string.IsNullOrWhiteSpace(query.CustomerName))
            q = q.Where(x => x.CustomerName.Contains(query.CustomerName));
        if (!string.IsNullOrWhiteSpace(query.Status))
            q = q.Where(x => x.Status == query.Status);

        var total = await q.CountAsync();
        var list = await q
            .OrderByDescending(x => x.CreatedTime)
            .Skip((query.Page - 1) * query.PageSize)
            .Take(query.PageSize)
            .ToListAsync();

        return Ok(new
        {
            total,
            page = query.Page,
            pageSize = query.PageSize,
            list = list.Select(x => new OrderDetailDto
            {
                Id = x.Id,
                OrderNo = x.OrderNo,
                CustomerName = x.CustomerName,
                Product = x.Product,
                Quantity = x.Quantity,
                UnitPrice = x.UnitPrice,
                Amount = x.Amount,
                Status = x.Status,
                DeliveryDate = x.DeliveryDate,
                Remark = x.Remark,
                CreatedTime = x.CreatedTime,
                UpdatedTime = x.UpdatedTime,
                CreatedBy = x.CreatedBy
            }).ToList()
        });
    }

    [HttpGet("{id:long}")]
    public async Task<IActionResult> GetOrder(long id)
    {
        var item = await _orderRep.GetByIdAsync(id);
        if (item == null)
            return NotFound();

        return Ok(new OrderDetailDto
        {
            Id = item.Id,
            OrderNo = item.OrderNo,
            CustomerName = item.CustomerName,
            Product = item.Product,
            Quantity = item.Quantity,
            UnitPrice = item.UnitPrice,
            Amount = item.Amount,
            Status = item.Status,
            DeliveryDate = item.DeliveryDate,
            Remark = item.Remark,
            CreatedTime = item.CreatedTime,
            UpdatedTime = item.UpdatedTime,
            CreatedBy = item.CreatedBy
        });
    }

    [HttpPost]
    public async Task<IActionResult> CreateOrder([FromBody] OrderCreateDto dto)
    {
        var item = new AdoOrder
        {
            OrderNo = $"SO{DateTime.Now:yyyyMMddHHmmss}{Random.Shared.Next(1000, 9999)}",
            CustomerName = dto.CustomerName,
            Product = dto.Product,
            Quantity = dto.Quantity,
            UnitPrice = dto.UnitPrice,
            Amount = dto.Quantity * dto.UnitPrice,
            DeliveryDate = dto.DeliveryDate,
            Remark = dto.Remark,
            Status = "待处理",
            CreatedTime = DateTime.Now
        };

        await _orderRep.AsInsertable(item).ExecuteReturnEntityAsync();

        return Ok(new { id = item.Id, message = "创建成功" });
    }

    [HttpPut("{id:long}")]
    public async Task<IActionResult> UpdateOrder(long id, [FromBody] OrderUpdateDto dto)
    {
        var item = await _orderRep.GetByIdAsync(id);
        if (item == null)
            return NotFound();

        item.CustomerName = dto.CustomerName;
        item.Product = dto.Product;
        item.Quantity = dto.Quantity;
        item.UnitPrice = dto.UnitPrice;
        item.Amount = dto.Quantity * dto.UnitPrice;
        item.DeliveryDate = dto.DeliveryDate;
        item.Remark = dto.Remark;
        item.Status = dto.Status;
        item.UpdatedTime = DateTime.Now;

        await _orderRep.AsUpdateable(item).ExecuteCommandAsync();

        return Ok(new { message = "更新成功" });
    }

    [HttpDelete("{id:long}")]
    public async Task<IActionResult> DeleteOrder(long id)
    {
        var item = await _orderRep.GetByIdAsync(id);
        if (item == null)
            return NotFound();

        await _orderRep.DeleteAsync(item);

        return Ok(new { message = "删除成功" });
    }
}