1、新增srm条码接收删除接口

kyy

2025-08-29 6f2f412a3ddf11af03d0efc1c002e2f261207fca

1、新增srm条码接收删除接口

 MES.Service/Dto/webApi/DeleteByDeliveryItemRequest.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,22 @@
using System.ComponentModel.DataAnnotations;
using MES.Service.Dto.webApi;

namespace MES.Service.Dto.webApi;

/// <summary>
/// æŒ‰é€è´§å•å·+行内码删除条码的请求模型
/// </summary>
public class DeleteByDeliveryItemRequest
{
    /// <summary>
    /// é€è´§å•å·ï¼ˆå¿…填，不能为空/空字符串）
    /// </summary>
    [Required(ErrorMessage = "送货单号 DeliveryNo ä¸èƒ½ä¸ºç©º")]
    public string DeliveryNo { get; set; }

    /// <summary>
    /// é€è´§å•è¡Œå†…码（必填，不能为空/空字符串）
    /// </summary>
    [Required(ErrorMessage = "送货单行内码 LineNo ä¸èƒ½ä¸ºç©º")]
    public string LineNo { get; set; }
}

 MES.Service/Dto/webApi/DeleteByDeliveryNoRequest.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,15 @@
using System.ComponentModel.DataAnnotations;

namespace MES.Service.Dto.webApi;

/// <summary>
/// æ ¹æ®é€è´§å•å·åˆ é™¤æ¡ç çš„请求模型
/// </summary>
public class DeleteByDeliveryNoRequest
{
    /// <summary>
    /// é€è´§å•å·ï¼ˆå¿…填，不能为空/空字符串）
    /// </summary>
    [Required(ErrorMessage = "送货单号 DeliveryNo ä¸èƒ½ä¸ºç©º")]
    public string DeliveryNo { get; set; }
}

 MES.Service/Dto/webApi/DeliveryBarcodeInfo.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,59 @@
namespace MES.Service.Dto.webApi;

public class DeliveryBarcodeInfo
{
    /// <summary>
    /// é€è´§å•å·
    /// </summary>
    public string? DeliveryNo { get; set; }
    
    /// <summary>
    /// é€è´§å•è¡Œå†…码
    /// </summary>
    public string? LineNo { get; set; }
    
    /// <summary>
    /// ç‰©æ–™æ¡ç 
    /// </summary>
    public string? SmallBarcode { get; set; }
    
    /// <summary>
    /// ç‰©æ–™å†…码
    /// </summary>
    public string? ProductCode { get; set; }
    
    /// <summary>
    /// æ¡ç æ•°é‡
    /// </summary>
    public decimal? IncludeQty { get; set; }
    
    /// <summary>
    /// ç®±æ¡ç 
    /// </summary>
    public string? OuterBarcode { get; set; }
    
    /// <summary>
    /// æ¡ç ç±»åž‹
    /// </summary>
    public string? BarcodeType { get; set; }
    
    /// <summary>
    /// æ˜¯å¦åˆå¹¶
    /// </summary>
    public bool? IsMerge { get; set; }
    
    /// <summary>
    /// æŽ¥å£ç±»åž‹
    /// </summary>
    public string? Type { get; set; }
    
    /// <summary>
    /// æ˜¯å¦å°¾ç®±
    /// </summary>
    public bool? IsLast { get; set; }
    
    /// <summary>
    /// ç®±è£…æ•°
    /// </summary>
    public int? PackingQty { get; set; }
}

 MES.Service/Modes/DeliveryBarcodeInformation.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,196 @@
using SqlSugar;

namespace MES.Service.Modes;

/// <summary>
///     æºå®¢äº‘条码信息表
/// </summary>
[SugarTable("TBL_BARCODE_INFORMATION")]
public class BarcodeInformation
{
    /// <summary>
    ///     SEQ_XKY
    /// </summary>
    [SugarColumn(ColumnName = "id", IsPrimaryKey = true)]
    public Guid Id { get; set; }

    /// <summary>
    ///     äº§å“ç¼–码
    /// </summary>
    [SugarColumn(ColumnName = "product_code")]
    public string? ProductCode { get; set; }

    /// <summary>
    ///     å°åŒ…条码
    /// </summary>
    [SugarColumn(ColumnName = "small_barcode")]
    public string? SmallBarcode { get; set; }

    /// <summary>
    ///     å¤§åŒ…条码
    /// </summary>
    [SugarColumn(ColumnName = "big_barcode")]
    public string? BigBarcode { get; set; }

    /// <summary>
    ///     å¤–箱条码
    /// </summary>
    [SugarColumn(ColumnName = "outer_barcode")]
    public string? OuterBarcode { get; set; }

    /// <summary>
    ///     å½“前小包条码包含的数量
    /// </summary>
    [SugarColumn(ColumnName = "include_qty")]
    public decimal? IncludeQty { get; set; }

    /// <summary>
    ///     å°åŒ…条码-长
    /// </summary>
    [SugarColumn(ColumnName = "small_package_length")]
    public string? SmallPackageLength { get; set; }

    /// <summary>
    ///     å°åŒ…条码-宽
    /// </summary>
    [SugarColumn(ColumnName = "small_package_width")]
    public string? SmallPackageWidth { get; set; }

    /// <summary>
    ///     å°åŒ…条码-高
    /// </summary>
    [SugarColumn(ColumnName = "small_package_height")]
    public string? SmallPackageHeight { get; set; }

    /// <summary>
    ///     å¤§åŒ…条码-长
    /// </summary>
    [SugarColumn(ColumnName = "big_package_length")]
    public string? BigPackageLength { get; set; }

    /// <summary>
    ///     å¤§åŒ…条码-宽
    /// </summary>
    [SugarColumn(ColumnName = "big_package_width")]
    public string? BigPackageWidth { get; set; }

    /// <summary>
    ///     å¤§åŒ…条码-高
    /// </summary>
    [SugarColumn(ColumnName = "big_package_height")]
    public string? BigPackageHeight { get; set; }

    /// <summary>
    ///     å¤–箱条码-长
    /// </summary>
    [SugarColumn(ColumnName = "outer_package_length")]
    public string? OuterPackageLength { get; set; }

    /// <summary>
    ///     å¤–箱条码-宽
    /// </summary>
    [SugarColumn(ColumnName = "outer_package_width")]
    public string? OuterPackageWidth { get; set; }

    /// <summary>
    ///     å¤–箱条码-高
    /// </summary>
    [SugarColumn(ColumnName = "outer_package_height")]
    public string? OuterPackageHeight { get; set; }

    /// <summary>
    ///     å½“前小包条码的流水码
    /// </summary>
    [SugarColumn(ColumnName = "small_package_sn")]
    public string? SmallPackageSn { get; set; }

    /// <summary>
    ///     å½“前大包条码的流水码
    /// </summary>
    [SugarColumn(ColumnName = "big_package_sn")]
    public string? BigPackageSn { get; set; }

    /// <summary>
    ///     å½“前外箱条码的流水码
    /// </summary>
    [SugarColumn(ColumnName = "out_package_sn")]
    public string? OutPackageSn { get; set; }

    /// <summary>
    ///     æ¡ç è§„则中对应的动态字段的值
    /// </summary>
    [SugarColumn(ColumnName = "dynamic_data")]
    public string? DynamicData { get; set; }

    /// <summary>
    ///     åŒ…装层级
    /// </summary>
    [SugarColumn(ColumnName = "pack_level")]
    public string? PackLevel { get; set; }

    /// <summary>
    ///     åˆ›å»ºæ—¶é—´
    /// </summary>
    [SugarColumn(ColumnName = "create_time")]
    public DateTime? CreateTime { get; set; }

    /// <summary>
    ///     æ›´æ–°æ—¶é—´
    /// </summary>
    [SugarColumn(ColumnName = "update_time")]
    public DateTime? UpdateTime { get; set; }

    /// <summary>
    ///     é€è´§å•å·
    /// </summary>
    [SugarColumn(ColumnName = "delivery_no")]
    public string? DeliveryNo { get; set; }

    /// <summary>
    ///     é‡‡è´­å•å·
    /// </summary>
    [SugarColumn(ColumnName = "po_erp_no")]
    public string? PoErpNo { get; set; }

    /// <summary>
    ///     é€è´§å•é¡¹æ¬¡
    /// </summary>
    [SugarColumn(ColumnName = "dnLines")]
    public string? DnLines { get; set; }

    /// <summary>
    ///     è®¢å•é¡¹æ¬¡(ERP)
    /// </summary>
    [SugarColumn(ColumnName = "po_line_no")]
    public string? PoLineNo { get; set; }

    /// <summary>
    ///     ä¾›åº”商编码
    /// </summary>
    [SugarColumn(ColumnName = "inner_vendor_code")]
    public string? InnerVendorCode { get; set; }

    /// <summary>
    ///     X
    /// </summary>
    [SugarColumn(ColumnName = "customize1")]
    public string? Customize1 { get; set; }

    /// <summary>
    ///     åŒæ­¥æ—¶é—´
    /// </summary>
    [SugarColumn(ColumnName = "SYNCHRONOUS_DATE")]
    public DateTime? SynchronousDate { get; set; }

    /// <summary>
    ///     ç”Ÿäº§æ—¥æœŸ
    /// </summary>
    [SugarColumn(ColumnName = "customize2")]
    public string? Customize2 { get; set; }

    /// <summary>
    ///     æœ‰æ•ˆæœŸ
    /// </summary>
    [SugarColumn(ColumnName = "customize3")]
    public string? Customize3 { get; set; }
}

 MES.Service/service/BasicData/DeliveryBarcodeManager.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,291 @@
using MES.Service.DB;
using MES.Service.Dto.webApi;
using MES.Service.Modes;
using System.Linq;

namespace MES.Service.service.BasicData;

/// <summary>
/// é€è´§å•æ¡ç ä¸šåŠ¡ç®¡ç†å™¨ï¼ˆå¯¹åº”TBL_BARCODE_INFORMATION表操作）
/// </summary>
public class DeliveryBarcodeManager : Repository<BarcodeInformation>
{
    /// <summary>
    /// å•ä¸ªé€è´§å•æ¡ç ä¿¡æ¯ä¿å­˜ï¼ˆæ”¯æŒæ–°å¢ž/删除，按Type区分操作类型）
    /// </summary>
    /// <param name="barcodeDto">送货单条码DTO（含操作类型Type）</param>
    /// <returns>操作是否成功</returns>
    public bool Save(DeliveryBarcodeInfo barcodeDto)
    {
        if (barcodeDto == null)
            throw new ArgumentNullException(nameof(barcodeDto), "条码DTO不能为空");

        // DTO转实体（映射字段关系）
        var barcodeEntity = ConvertDtoToEntity(barcodeDto);

        try
        {
            // æŒ‰Type区分操作类型（0=新增，1=删除）
            switch (barcodeDto.Type)
            {
                case "0":
                    return InsertBarcode(barcodeEntity);
                case "1":
                    return DeleteBarcode(barcodeEntity.Id);
                default:
                    throw new ArgumentOutOfRangeException(
                        nameof(barcodeDto.Type), 
                        barcodeDto.Type, 
                        "条码操作类型错误：仅支持 0（新增）、1（删除）");
            }
        }
        catch (Exception ex)
        {
            throw new ApplicationException($"单个条码操作失败（送货单号：{barcodeDto.DeliveryNo}）：{ex.Message}", ex);
        }
    }

    /// <summary>
    /// æ‰¹é‡é€è´§å•æ¡ç ä¿¡æ¯ä¿å­˜ï¼ˆæŒ‰Type分组处理，统一异常捕获）
    /// </summary>
    /// <param name="barcodeDtoList">送货单条码DTO列表</param>
    /// <returns>批量操作是否全部成功</returns>
    public bool SaveList(List<DeliveryBarcodeInfo> barcodeDtoList)
    {
        if (barcodeDtoList == null || !barcodeDtoList.Any())
        {
            throw new ArgumentException("批量操作的条码列表不能为空");
        }

        try
        {
            // 1. åˆ›å»ºå¼ºç±»åž‹çš„实体与类型组合列表（解决dynamic转换问题）
            var entityTypePairs = new List<EntityTypePair>();
            foreach (var dto in barcodeDtoList)
            {
                entityTypePairs.Add(new EntityTypePair
                {
                    Entity = ConvertDtoToEntity(dto),
                    Type = dto.Type
                });
            }

            // 2. æŒ‰æ“ä½œç±»åž‹Type分组（使用强类型避免类型推断问题）
            var typeGroupDict = entityTypePairs
                .GroupBy(pair => pair.Type)
                .ToDictionary(
                    group => group.Key, 
                    group => group.Select(pair => pair.Entity).ToList()
                );

            // 3. å­˜å‚¨å„组操作结果
            var groupResultList = new List<bool>();

            foreach (var (type, entityGroup) in typeGroupDict)
            {
                switch (type)
                {
                    case "0":
                        groupResultList.Add(InsertBarcodeBatch(entityGroup));
                        break;
                    case "1":
                        groupResultList.Add(DeleteBarcodeBatch(entityGroup.Select(e => e.Id).ToArray()));
                        break;
                    default:
                        throw new ArgumentOutOfRangeException(
                            nameof(type), 
                            type, 
                            "批量操作中存在非法Type：仅支持 0（新增）、1（删除）");
                }
            }

            // 4. æ‰€æœ‰åˆ†ç»„操作均成功才算批量成功
            if (groupResultList.All(result => result))
            {
                return true;
            }

            throw new NotImplementedException("批量条码操作部分失败，具体请查看日志");
        }
        catch (Exception ex)
        {
            throw new ApplicationException($"批量条码操作失败（总条数：{barcodeDtoList.Count}）：{ex.Message}", ex);
        }
    }
    
    /// <summary>
    /// æ ¹æ®é€è´§å•å·åˆ é™¤æ¡ç æ•°æ®
    /// </summary>
    /// <param name="deliveryNo">送货单号（不能为空/空字符串）</param>
    /// <returns>是否删除成功（true=至少删除1条，false=未找到对应数据）</returns>
    public bool DeleteByDeliveryNo(string deliveryNo)
    {
        // 1. æ ¡éªŒå‚数：送货单号不能为空
        if (string.IsNullOrWhiteSpace(deliveryNo))
            throw new ArgumentException("送货单号 DeliveryNo ä¸èƒ½ä¸ºç©ºæˆ–空格", nameof(deliveryNo));

        try
        {
            // 2. æ‰§è¡Œåˆ é™¤ï¼šæ ¹æ® DeliveryNo åŒ¹é…è¡¨ä¸­æ•°æ®ï¼ˆå¯¹åº”实体的 DeliveryNo å­—段）
            int deletedCount = Db.Deleteable<BarcodeInformation>()
                .Where(barcode => barcode.DeliveryNo == deliveryNo) // è¡¨å­—段与送货单号匹配
                .ExecuteCommand(); // è¿”回受影响的行数

            // 3. åˆ¤æ–­ç»“果：至少删除1条则视为成功，否则抛出“未找到数据”异常
            if (deletedCount > 0)
                return true;

            throw new KeyNotFoundException($"未找到送货单号为「{deliveryNo}」的条码数据，删除操作未执行");
        }
        catch (Exception ex)
        {
            // 4. åŒ…装业务异常，补充上下文信息
            throw new ApplicationException($"根据送货单号删除条码数据失败（DeliveryNo：{deliveryNo}）：{ex.Message}", ex);
        }
    }
    
    /// <summary>
    /// æŒ‰é€è´§å•å·+行内码联合删除条码数据
    /// </summary>
    /// <param name="deliveryNo">送货单号</param>
    /// <param name="lineNo">送货单行内码</param>
    /// <returns>是否删除成功（true=至少删除1条，false=未找到对应数据）</returns>
    public bool DeleteByDeliveryItem(string deliveryNo, string lineNo)
    {
        // 1. åŒå‚数校验：避免空值/空字符串
        if (string.IsNullOrWhiteSpace(deliveryNo))
            throw new ArgumentException("送货单号 DeliveryNo ä¸èƒ½ä¸ºç©ºæˆ–空格", nameof(deliveryNo));
        if (string.IsNullOrWhiteSpace(lineNo))
            throw new ArgumentException("送货单行内码 LineNo ä¸èƒ½ä¸ºç©ºæˆ–空格", nameof(lineNo));

        try
        {
            // 2. è”合条件删除：匹配 DeliveryNo（送货单号）和 DnLines（行内码，实体字段对应表的 dnLines åˆ—）
            int deletedCount = Db.Deleteable<BarcodeInformation>()
                .Where(barcode => 
                        barcode.DeliveryNo == deliveryNo // åŒ¹é…é€è´§å•å·
                        && barcode.DnLines == lineNo     // åŒ¹é…è¡Œå†…码（实体 DnLines å¯¹åº”表 dnLines å­—段）
                )
                .ExecuteCommand(); // è¿”回受影响的行数

            // 3. ç»“果判断：有数据被删除则成功，否则抛“未找到数据”异常
            if (deletedCount > 0)
                return true;

            throw new KeyNotFoundException(
                $"未找到送货单号「{deliveryNo}」且行内码「{lineNo}」对应的条码数据，删除操作未执行");
        }
        catch (Exception ex)
        {
            // 4. åŒ…装异常：补充联合条件上下文，便于定位问题
            throw new ApplicationException(
                $"按送货单号+行内码删除条码数据失败（DeliveryNo：{deliveryNo}，LineNo：{lineNo}）：{ex.Message}", 
                ex);
        }
    }
    #region ç§æœ‰è¾…助方法和内部类
    /// <summary>
    /// å†…部辅助类：用于关联实体和操作类型（解决dynamic类型转换问题）
    /// </summary>
    private class EntityTypePair
    {
        public BarcodeInformation Entity { get; set; }
        public string Type { get; set; }
    }

    /// <summary>
    /// DTO转实体：映射DeliveryBarcodeInfo到BarcodeInformation字段
    /// </summary>
    private BarcodeInformation ConvertDtoToEntity(DeliveryBarcodeInfo dto)
    {
        var entityId = dto.Type == "0" 
            ? Guid.NewGuid() 
            : (string.IsNullOrEmpty(dto.SmallBarcode) ? Guid.Empty : Guid.Parse(dto.SmallBarcode));

        return new BarcodeInformation
        {
            Id = entityId,
            ProductCode = dto.ProductCode,
            SmallBarcode = dto.SmallBarcode,
            OuterBarcode = dto.OuterBarcode,
            IncludeQty = dto.IncludeQty.HasValue ? Convert.ToDecimal(dto.IncludeQty) : 0,
            DeliveryNo = dto.DeliveryNo,
            DnLines = dto.LineNo,
            PackLevel = dto.BarcodeType,
            CreateTime = dto.Type == "0" ? DateTime.Now : (DateTime?)null,
            UpdateTime = DateTime.Now,
            
            // æ‰©å±•å­—段赋默认值
            BigBarcode = null,
            SmallPackageLength = null,
            SmallPackageWidth = null,
            SmallPackageHeight = null,
            BigPackageLength = null,
            BigPackageWidth = null,
            BigPackageHeight = null,
            OuterPackageLength = null,
            OuterPackageWidth = null,
            OuterPackageHeight = null,
            SmallPackageSn = null,
            BigPackageSn = null,
            OutPackageSn = null,
            DynamicData = null,
            PoErpNo = null,
            PoLineNo = null,
            InnerVendorCode = null,
            Customize1 = null,
            SynchronousDate = null,
            Customize2 = null,
            Customize3 = null
        };
    }

    /// <summary>
    /// å•ä¸ªæ¡ç æ–°å¢ž
    /// </summary>
    private bool InsertBarcode(BarcodeInformation entity)
    {
        var isInsertSuccess = base.Insert(entity);
        return isInsertSuccess ? true : throw new NotImplementedException("条码新增失败：数据库插入操作未执行成功");
    }

    /// <summary>
    /// å•ä¸ªæ¡ç åˆ é™¤ï¼ˆæŒ‰ä¸»é”®Id）
    /// </summary>
    private bool DeleteBarcode(Guid id)
    {
        if (id == Guid.Empty)
            throw new ArgumentException("删除操作的条码Id不能为空");

        var deleteRowCount = Db.Deleteable<BarcodeInformation>()
            .Where(entity => entity.Id == id)
            .ExecuteCommand();

        return deleteRowCount > 0 ? true : throw new NotImplementedException($"条码删除失败：未找到Id为「{id}」的条码记录");
    }

    /// <summary>
    /// æ‰¹é‡æ¡ç æ–°å¢ž
    /// </summary>
    private bool InsertBarcodeBatch(List<BarcodeInformation> entityList)
    {
        var isBatchInsertSuccess = base.InsertRange(entityList);
        return isBatchInsertSuccess ? true : throw new NotImplementedException($"批量条码新增失败：共{entityList.Count}条记录");
    }

    /// <summary>
    /// æ‰¹é‡æ¡ç åˆ é™¤ï¼ˆæŒ‰ä¸»é”®Id数组）
    /// </summary>
    private bool DeleteBarcodeBatch(Guid[] ids)
    {
        if (ids == null || ids.Length == 0)
            throw new ArgumentException("批量删除的条码Id数组不能为空");

        var deleteRowCount = Db.Deleteable<BarcodeInformation>()
            .Where(entity => ids.Contains(entity.Id))
            .ExecuteCommand();

        return deleteRowCount > 0 ? true : throw new NotImplementedException($"批量条码删除失败：共{ids.Length}个Id");
    }
    #endregion
}

 MESApplication/Controllers/BasicData/DeliveryBarcodeController.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,256 @@
using System.Dynamic;
using MES.Service.Dto.webApi;
using MES.Service.Modes;
using MES.Service.service;
using MES.Service.service.BasicData; // å‡è®¾DeliveryBarcodeManager在该命名空间下，可根据实际调整
using MES.Service.util;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;

namespace MESApplication.Controllers.BasicData;

/// <summary>
/// é€è´§å•æ¡ç æŽ§åˆ¶å™¨ï¼ˆå¯¹åº”携客云条码信息表操作）
/// </summary>
[ApiController]
[Route("api/[controller]")]
public class DeliveryBarcodeController : ControllerBase
{
    // æ¶ˆæ¯ä¸­å¿ƒç®¡ç†å™¨ï¼ˆå¤ç”¨åŽŸé€»è¾‘）
    private readonly MessageCenterManager _messageCenterManager = new();

    // é€è´§å•æ¡ç ä¸šåŠ¡é€»è¾‘管理器（对应业务层，需确保实际项目中存在该类）
    private readonly DeliveryBarcodeManager _deliveryBarcodeManager = new();

    // æŽ¥å£è¯·æ±‚方法（固定POST，与原控制器一致）
    private readonly string REQUEST_METHOD = "POST";

    // å¯¹åº”数据库表名（携客云条码信息表，与之前定义的实体类表名一致）
    private readonly string TARGET_TABLE = "TBL_BARCODE_INFORMATION";

    // åŸºç¡€æŽ¥å£URL（根据控制器名定义，保持REST风格）
    private readonly string BASE_API_URL = "http://localhost:10054/api/DeliveryBarcode/";

    /// <summary>
    /// å•ä¸ªé€è´§å•æ¡ç ä¿¡æ¯ä¿å­˜æŽ¥å£
    /// </summary>
    /// <param name="barcodeInfo">送货单条码DTO（单个）</param>
    /// <returns>统一响应结果</returns>
    [HttpPost("Save")]
    public ResponseResult Save(DeliveryBarcodeInfo barcodeInfo)
    {
        // 1. åˆå§‹åŒ–消息中心实体（用于日志/消息记录）
        var messageEntity = new MessageCenter
        {
            TableName = TARGET_TABLE,
            Url = BASE_API_URL + "Save", // æ‹¼æŽ¥å®Œæ•´æŽ¥å£URL
            Method = REQUEST_METHOD,
            Data = JsonConvert.SerializeObject(barcodeInfo), // åºåˆ—化DTO为JSON
            Status = 1, // çŠ¶æ€æ ‡è¯†ï¼ˆ1=待处理/处理中，与原逻辑一致）
            CreateBy = "PL017", // åˆ›å»ºäººï¼ˆå¤ç”¨åŽŸé…ç½®ï¼Œå¯æ ¹æ®å®žé™…调整为动态获取）
            Route = barcodeInfo.DeliveryNo ?? "未知送货单号", // è·¯ç”±æ ‡è¯†ï¼ˆç”¨é€è´§å•å·åŒºåˆ†ï¼Œæ— åˆ™å¡«é»˜è®¤å€¼ï¼‰
            DealWith = 0 // åˆå§‹å¤„理状态（0=未处理）
        };

        try
        {
            // 2. ä¸šåŠ¡é€»è¾‘处理：调用业务层保存单个条码信息
            dynamic resultData = new ExpandoObject();
            bool saveSuccess = _deliveryBarcodeManager.Save(barcodeInfo);
            resultData.tbBillList = saveSuccess; // å­˜å‚¨ä¿å­˜ç»“果（与原返回格式一致）

            // 3. æ›´æ–°æ¶ˆæ¯ä¸­å¿ƒå®žä½“状态
            messageEntity.Result = saveSuccess ? 1 : 0; // 1=成功，0=失败
            messageEntity.DealWith = 1; // 1=已处理
            _messageCenterManager.save(messageEntity); // ä¿å­˜æ¶ˆæ¯è®°å½•

            // 4. è¿”回成功响应（统一响应格式）
            return new ResponseResult
            {
                status = 0, // 0=成功状态码（与原逻辑一致）
                message = "单个送货单条码信息保存成功",
                data = resultData
            };
        }
        catch (Exception ex)
        {
            // 5. å¼‚常处理：捕获异常并更新消息中心
            messageEntity.Result = 0; // å¤±è´¥æ ‡è¯†
            messageEntity.DealWith = 0; // æœªå¤„理标识
            messageEntity.ResultData = ex.Message; // å¼‚常信息记录
            _messageCenterManager.save(messageEntity); // ä¿å­˜å¼‚常消息

            // 6. è¿”回异常响应（复用工具类的统一异常响应方法）
            return ResponseResult.ResponseError(ex);
        }
    }

    /// <summary>
    /// æ‰¹é‡é€è´§å•æ¡ç ä¿¡æ¯ä¿å­˜æŽ¥å£
    /// </summary>
    /// <param name="barcodeInfoList">送货单条码DTO列表（批量）</param>
    /// <returns>统一响应结果</returns>
    [HttpPost("SaveList")]
    public ResponseResult SaveList(List<DeliveryBarcodeInfo> barcodeInfoList)
    {
        // 1. åˆå§‹åŒ–消息中心实体（批量场景专用）
        var messageEntity = new MessageCenter
        {
            TableName = TARGET_TABLE,
            Url = BASE_API_URL + "SaveList", // æ‹¼æŽ¥æ‰¹é‡æŽ¥å£URL
            Method = REQUEST_METHOD,
            Data = JsonConvert.SerializeObject(barcodeInfoList), // åºåˆ—化DTO列表为JSON
            Status = 1,
            CreateBy = "PL017",
            Route = barcodeInfoList.Any() ? $"批量_{barcodeInfoList.First().DeliveryNo ?? "未知"}" : "空批量请求",
            DealWith = 0
        };

        try
        {
            // 2. ä¸šåŠ¡é€»è¾‘处理：调用业务层批量保存
            dynamic resultData = new ExpandoObject();
            bool batchSaveSuccess = _deliveryBarcodeManager.SaveList(barcodeInfoList);
            resultData.tbBillList = batchSaveSuccess; // ä¿æŒä¸Žå•ä¸ªä¿å­˜ä¸€è‡´çš„返回字段

            // 3. æ›´æ–°æ¶ˆæ¯ä¸­å¿ƒçŠ¶æ€
            messageEntity.Result = batchSaveSuccess ? 1 : 0;
            messageEntity.DealWith = 1;
            _messageCenterManager.save(messageEntity);

            // 4. è¿”回成功响应
            return new ResponseResult
            {
                status = 0,
                message = $"批量保存成功，共处理{barcodeInfoList.Count}条条码信息",
                data = resultData
            };
        }
        catch (Exception ex)
        {
            // 5. å¼‚常处理：记录异常并返回错误
            messageEntity.Result = 0;
            messageEntity.DealWith = 0;
            messageEntity.ResultData = $"批量保存异常：{ex.Message}";
            _messageCenterManager.save(messageEntity);

            return ResponseResult.ResponseError(ex);
        }
    }
    
    /// <summary>
    /// æ ¹æ®é€è´§å•å·åˆ é™¤æ¡ç æ•°æ®
    /// </summary>
    /// <param name="request">包含送货单号的请求模型</param>
    /// <returns>统一响应结果</returns>
    [HttpPost("DeleteByNo")] // è‹¥é¡¹ç›®æ”¯æŒ RESTful，可改为 [HttpDelete("DeleteByNo")]
    public ResponseResult DeleteByNo([FromBody] DeleteByDeliveryNoRequest request)
    {
        // 1. åˆå§‹åŒ–消息中心实体（记录删除操作日志）
        var messageEntity = new MessageCenter
        {
            TableName = TARGET_TABLE,
            Url = BASE_API_URL + "DeleteByNo", // æŽ¥å£URL
            Method = REQUEST_METHOD,
            Data = JsonConvert.SerializeObject(request), // åºåˆ—化请求参数
            Status = 1, // 1=处理中
            CreateBy = "PL017", // ä¸ŽåŽŸæœ‰æŽ¥å£ä¸€è‡´çš„创建人
            Route = request.DeliveryNo, // è·¯ç”±æ ‡è¯†=送货单号，便于定位日志
            DealWith = 0 // åˆå§‹=未处理
        };

        try
        {
            // 2. è°ƒç”¨ä¸šåŠ¡å±‚方法执行删除
            dynamic resultData = new ExpandoObject();
            bool deleteSuccess = _deliveryBarcodeManager.DeleteByDeliveryNo(request.DeliveryNo);
            resultData.deletedDeliveryNo = request.DeliveryNo; // è¿”回删除的送货单号
            resultData.isSuccess = deleteSuccess;

            // 3. æ›´æ–°æ¶ˆæ¯ä¸­å¿ƒçŠ¶æ€ï¼ˆæˆåŠŸï¼‰
            messageEntity.Result = 1; // 1=成功
            messageEntity.DealWith = 1; // 1=已处理
            _messageCenterManager.save(messageEntity);

            // 4. è¿”回成功响应
            return new ResponseResult
            {
                status = 0,
                message = $"成功删除送货单号「{request.DeliveryNo}」对应的条码数据",
                data = resultData
            };
        }
        catch (Exception ex)
        {
            // 5. å¼‚常处理：更新消息中心日志（失败）
            messageEntity.Result = 0; // 0=失败
            messageEntity.DealWith = 0; // 0=未处理
            messageEntity.ResultData = ex.Message; // è®°å½•å¼‚常信息
            _messageCenterManager.save(messageEntity);

            // 6. è¿”回统一异常响应
            return ResponseResult.ResponseError(ex);
        }
    }
    
    /// <summary>
    /// æŒ‰é€è´§å•å·+行内码联合删除条码数据
    /// </summary>
    /// <param name="request">包含送货单号和行内码的请求模型</param>
    /// <returns>统一响应结果</returns>
    [HttpPost("DeleteByItem")] // è‹¥ç”¨ RESTful è§„范，可改为 [HttpDelete("DeleteByItem")]
    public ResponseResult DeleteByItem([FromBody] DeleteByDeliveryItemRequest request)
    {
        // 1. åˆå§‹åŒ–消息中心实体：记录删除操作日志
        var messageEntity = new MessageCenter
        {
            TableName = TARGET_TABLE,
            Url = BASE_API_URL + "DeleteByItem", // æŽ¥å£URL
            Method = REQUEST_METHOD,
            Data = JsonConvert.SerializeObject(request), // åºåˆ—化请求参数（含双条件）
            Status = 1, // 1=处理中
            CreateBy = "PL017", // ä¸ŽåŽŸæœ‰æŽ¥å£ä¸€è‡´çš„创建人
            Route = $"{request.DeliveryNo}_{request.LineNo}", // è·¯ç”±æ ‡è¯†=“单号_行内码”，便于日志定位
            DealWith = 0 // åˆå§‹=未处理
        };

        try
        {
            // 2. è°ƒç”¨ä¸šåŠ¡å±‚联合删除方法
            dynamic resultData = new ExpandoObject();
            bool deleteSuccess = _deliveryBarcodeManager.DeleteByDeliveryItem(
                request.DeliveryNo, 
                request.LineNo
            );
            // å“åº”中返回关键条件，便于前端确认删除范围
            resultData.deletedDeliveryNo = request.DeliveryNo;
            resultData.deletedLineNo = request.LineNo;
            resultData.isSuccess = deleteSuccess;

            // 3. æ›´æ–°æ¶ˆæ¯ä¸­å¿ƒçŠ¶æ€ï¼ˆæˆåŠŸï¼‰
            messageEntity.Result = 1; // 1=成功
            messageEntity.DealWith = 1; // 1=已处理
            _messageCenterManager.save(messageEntity);

            // 4. è¿”回成功响应
            return new ResponseResult
            {
                status = 0,
                message = $"成功删除送货单号「{request.DeliveryNo}」-行内码「{request.LineNo}」对应的条码数据",
                data = resultData
            };
        }
        catch (Exception ex)
        {
            // 5. å¼‚常处理：记录消息中心日志（失败）
            messageEntity.Result = 0; // 0=失败
            messageEntity.DealWith = 0; // 0=未处理
            messageEntity.ResultData = ex.Message; // å­˜å‚¨å¼‚常信息
            _messageCenterManager.save(messageEntity);

            // 6. è¿”回统一异常响应
            return ResponseResult.ResponseError(ex);
        }
    } 
}