StandardPda/MES.Service/Dto/service/GetTransferListResponse.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,25 @@
using System.Collections.Generic;

namespace MES.Service.Dto.service
{
    public class GetTransferListResponse
    {
        public int Code { get; set; }
        public string Msg { get; set; }
        public TransferListData Data { get; set; }
    }

    public class TransferListData
    {
        public string StackCode { get; set; }
        public List<SnItem> SnList { get; set; }
    }

    public class SnItem
    {
        public string SnNo { get; set; }
        public string TickeNo { get; set; }
        public string SnStatus { get; set; }
        public string MediumBoxCode { get; set; }
    }
}

 StandardPda/MES.Service/Modes/MesPalletBinding1.cs

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

namespace MES.Service.Modes;

/// <summary>
///     æ ˆæ¿ç»‘定信息表
/// </summary>
[SugarTable("MES_PALLET_BINDING")]
public class MesPalletBinding1
{
    /// <summary>
    ///     ä¸»é”®ID
    /// </summary>
    [SugarColumn(ColumnName = "ID",
        OracleSequenceName = "SEQ_MES_PALLET_BINDING_ID",
        IsPrimaryKey = true)]
    public decimal Id { get; set; }

    /// <summary>
    ///     æ ˆæ¿ç 
    /// </summary>
    [SugarColumn(ColumnName = "STACKCODE")]
    public string Stackcode { get; set; }

    /// <summary>
    ///     ç™»å½•å·
    /// </summary>
    [SugarColumn(ColumnName = "LOGIN_ID")]
    public string LoginId { get; set; }

    /// <summary>
    ///     SN号
    /// </summary>
    [SugarColumn(ColumnName = "SN_NO")]
    public string SnNo { get; set; }

    /// <summary>
    ///     å·¥å•å•å·
    /// </summary>
    [SugarColumn(ColumnName = "TICKET_NO")]
    public string TicketNo { get; set; }

    /// <summary>
    ///     ä¸­ç®±ç 
    /// </summary>
    [SugarColumn(ColumnName = "MEDIUMBOXCODE")]
    public string Mediumboxcode { get; set; }

    /// <summary>
    ///     åˆ›å»ºæ—¶é—´(解绑时间)
    /// </summary>
    [SugarColumn(ColumnName = "CREATE_DATE")]
    public DateTime? CreateDate { get; set; }

    /// <summary>
    ///     åˆ›å»ºäºº
    /// </summary>
    [SugarColumn(ColumnName = "CREATED_BY")]
    public string CreatedBy { get; set; }

    /// <summary>
    ///     å…¥åº“标识：0-未入库，1-已入库，2-已销售出库，默认0
    /// </summary>
    [SugarColumn(ColumnName = "IS_INBOUND")]
    public decimal IsInbound { get; set; }

    /// <summary>
    ///     å…¥åº“时间
    /// </summary>
    [SugarColumn(ColumnName = "INBOUND_TIME")]
    public DateTime? InboundTime { get; set; }

    /// <summary>
    ///     äº§æµ‹æ ˆæ¿ç»‘定时间(接口TransitTime)
    /// </summary>
    [SugarColumn(ColumnName = "BIND_TRANSIT_TIME")]
    public DateTime? BindTransitTime { get; set; }

    /// <summary>
    ///     çº¿ä½“编码
    /// </summary>
    [SugarColumn(ColumnName = "LINE_NO")]
    public string LineNo { get; set; }

    /// <summary>
    ///     å…¥åº“单号
    /// </summary>
    [SugarColumn(ColumnName = "RK_NO")]
    public string RkNo { get; set; }

    /// <summary>
    ///     å…¥åº“条码
    /// </summary>
    [SugarColumn(ColumnName ="RK_CODE")]
    public string RkCode { get; set; }
}

 StandardPda/MES.Service/service/Warehouse/MesInvItemStocksManager.cs

@@ -14,7 +14,8 @@
    /// </summary>
    /// <param name="searchDto">搜索请求参数</param>
    /// <returns>分页结果</returns>
    public PagedResult<ReturnableStockDto> GetReturnableStocks(ReturnableStockSearchDto searchDto)
    public PagedResult<ReturnableStockDto> GetReturnableStocks(
        ReturnableStockSearchDto searchDto)
    {
        // å‚数校验
        if (searchDto.PageIndex < 1)
@@ -59,16 +60,21 @@
        }

        // 1.1 æå–去重后的条码列表用于查询
        var distinctBarcodes = rackingTaskData.Select(x => x.ItemBarcode).Distinct().ToList();
        var distinctBarcodes = rackingTaskData.Select(x => x.ItemBarcode)
            .Distinct().ToList();

        // 2. æž„建查询条件
        var query = Db.Queryable<MesInvItemStocks>()
            .LeftJoin<MesItems>((stock, item) => stock.ItemId == item.Id)
            .LeftJoin<MesDepots>((stock, item, depot) => stock.DepotsCode == depot.DepotCode)
            .LeftJoin<Organize>((stock, item, depot, org) => item.UseOrg == org.Id.ToString())
            .LeftJoin<MesUnit>((stock, item, depot, org, unit) => item.ItemUnit == unit.Id.ToString())
            .Where((stock, item, depot, org, unit) => 
                (distinctBarcodes.Contains(stock.ItemBarcode) || distinctBarcodes.Contains(stock.StackCode) ) && 
            .LeftJoin<MesDepots>((stock, item, depot) =>
                stock.DepotsCode == depot.DepotCode)
            .LeftJoin<Organize>((stock, item, depot, org) =>
                item.UseOrg == org.Id.ToString())
            .LeftJoin<MesUnit>((stock, item, depot, org, unit) =>
                item.ItemUnit == unit.Id.ToString())
            .Where((stock, item, depot, org, unit) =>
                (distinctBarcodes.Contains(stock.ItemBarcode) ||
                 distinctBarcodes.Contains(stock.StackCode)) &&
                stock.Quantity > 0);

        // 3. åº”用搜索条件
@@ -82,85 +88,99 @@
                if (conditions.IqcStatus == "1")
                {
                    // å½“IqcStatus为"1"时，查询特采直接使用、已检、免检状态
                    query = query.Where((stock, item, depot, org, unit) => 
                        stock.IqcStatus == "特采直接使用" || 
                        stock.IqcStatus == "已检" || 
                    query = query.Where((stock, item, depot, org, unit) =>
                        stock.IqcStatus == "特采直接使用" ||
                        stock.IqcStatus == "已检" ||
                        stock.IqcStatus == "免检");
                }
                else
                {
                    // å…¶ä»–情况按原值匹配
                    query = query.Where((stock, item, depot, org, unit) => stock.IqcStatus == conditions.IqcStatus);
                    query = query.Where((stock, item, depot, org, unit) =>
                        stock.IqcStatus == conditions.IqcStatus);
                }
            }

            if (conditions.Quantity.HasValue)
            {
                query = query.Where((stock, item, depot, org, unit) => stock.Quantity == conditions.Quantity.Value);
                query = query.Where((stock, item, depot, org, unit) =>
                    stock.Quantity == conditions.Quantity.Value);
            }

            // æ¨¡ç³ŠåŒ¹é…æ¡ä»¶

            if (!string.IsNullOrEmpty(conditions.DepotName))
            {
                query = query.Where((stock, item, depot, org, unit) => 
                    depot.DepotName != null && depot.DepotName.Contains(conditions.DepotName));
                query = query.Where((stock, item, depot, org, unit) =>
                    depot.DepotName != null &&
                    depot.DepotName.Contains(conditions.DepotName));
            }

            if (!string.IsNullOrEmpty(conditions.DepotSectionsCode))
            {
                query = query.Where((stock, item, depot, org, unit) => 
                    stock.DepotSectionsCode != null && stock.DepotSectionsCode.Contains(conditions.DepotSectionsCode));
                query = query.Where((stock, item, depot, org, unit) =>
                    stock.DepotSectionsCode != null &&
                    stock.DepotSectionsCode.Contains(conditions
                        .DepotSectionsCode));
            }

            if (!string.IsNullOrEmpty(conditions.ItemNo))
            {
                query = query.Where((stock, item, depot, org, unit) => 
                    item.ItemNo != null && item.ItemNo.Contains(conditions.ItemNo));
                query = query.Where((stock, item, depot, org, unit) =>
                    item.ItemNo != null &&
                    item.ItemNo.Contains(conditions.ItemNo));
            }

            if (!string.IsNullOrEmpty(conditions.ItemName))
            {
                query = query.Where((stock, item, depot, org, unit) => 
                    item.ItemName != null && item.ItemName.Contains(conditions.ItemName));
                query = query.Where((stock, item, depot, org, unit) =>
                    item.ItemName != null &&
                    item.ItemName.Contains(conditions.ItemName));
            }

            if (!string.IsNullOrEmpty(conditions.ItemModel))
            {
                query = query.Where((stock, item, depot, org, unit) => 
                    item.ItemModel != null && item.ItemModel.Contains(conditions.ItemModel));
                query = query.Where((stock, item, depot, org, unit) =>
                    item.ItemModel != null &&
                    item.ItemModel.Contains(conditions.ItemModel));
            }

            if (!string.IsNullOrEmpty(conditions.ItemUnitName))
            {
                query = query.Where((stock, item, depot, org, unit) => 
                    unit.Fname != null && unit.Fname.Contains(conditions.ItemUnitName));
                query = query.Where((stock, item, depot, org, unit) =>
                    unit.Fname != null &&
                    unit.Fname.Contains(conditions.ItemUnitName));
            }

            if (!string.IsNullOrEmpty(conditions.OrgCode))
            {
                query = query.Where((stock, item, depot, org, unit) => 
                    org.Fnumber != null && org.Fnumber.Contains(conditions.OrgCode));
                query = query.Where((stock, item, depot, org, unit) =>
                    org.Fnumber != null &&
                    org.Fnumber.Contains(conditions.OrgCode));
            }

            if (!string.IsNullOrEmpty(conditions.OrgName))
            {
                query = query.Where((stock, item, depot, org, unit) => 
                    org.Fname != null && org.Fname.Contains(conditions.OrgName));
                query = query.Where((stock, item, depot, org, unit) =>
                    org.Fname != null &&
                    org.Fname.Contains(conditions.OrgName));
            }

            if (!string.IsNullOrEmpty(conditions.ItemBarcode))
            {
                query = query.Where((stock, item, depot, org, unit) => 
                    stock.ItemBarcode != null && stock.ItemBarcode.Contains(conditions.ItemBarcode));
                query = query.Where((stock, item, depot, org, unit) =>
                    stock.ItemBarcode != null &&
                    stock.ItemBarcode.Contains(conditions.ItemBarcode));
            }

            // æ—¥æœŸèŒƒå›´æ¡ä»¶
            if (!string.IsNullOrEmpty(conditions.IndepDateStart))
            {
                if (DateTime.TryParse(conditions.IndepDateStart, out var startDate))
                if (DateTime.TryParse(conditions.IndepDateStart,
                        out var startDate))
                {
                    query = query.Where((stock, item, depot, org, unit) => stock.IndepDate >= startDate);
                    query = query.Where((stock, item, depot, org, unit) =>
                        stock.IndepDate >= startDate);
                }
            }

@@ -168,14 +188,16 @@
            {
                if (DateTime.TryParse(conditions.IndepDateEnd, out var endDate))
                {
                    query = query.Where((stock, item, depot, org, unit) => stock.IndepDate <= endDate);
                    query = query.Where((stock, item, depot, org, unit) =>
                        stock.IndepDate <= endDate);
                }
            }
        }

        // 4. æŸ¥è¯¢æ‰€æœ‰ç¬¦åˆæ¡ä»¶çš„数据（不分页）
        var queryResult = query
            .OrderByDescending((stock, item, depot, org, unit) => stock.IndepDate)
            .OrderByDescending((stock, item, depot, org, unit) =>
                stock.IndepDate)
            .Select((stock, item, depot, org, unit) => new
            {
                stock.IqcStatus,
@@ -197,14 +219,16 @@
            .ToList();

        // 5. åœ¨å†…存中转换为DTO，关联PalletCode并赋值ItemBarcode（优先使用箱条码StockStackCode）
        var tempDataList = queryResult.Select(x => 
        var tempDataList = queryResult.Select(x =>
        {
            // ä¼˜å…ˆä½¿ç”¨StockStackCode，否则使用ItemBarcode去查找PalletCode
            var barcodeToMatch = !string.IsNullOrEmpty(x.StockStackCode) ? x.StockStackCode : x.ItemBarcode;
            var barcodeToMatch = !string.IsNullOrEmpty(x.StockStackCode)
                ? x.StockStackCode
                : x.ItemBarcode;
            var rackingTask = rackingTaskData
                .Where(r => r.ItemBarcode == barcodeToMatch)
                .FirstOrDefault();
            

            // æ ¹æ®Code值确定库存状态: null为立库入库中(0), 200为已在立库内(1)
            string stockStatus = "进入立库的路上"; // é»˜è®¤ä¸ºç«‹åº“入库中
            if (rackingTask?.Code != null)
@@ -238,7 +262,9 @@
        if (conditions != null && !string.IsNullOrEmpty(conditions.StackCode))
        {
            tempDataList = tempDataList
                .Where(x => x.StackCode != null && x.StackCode.Contains(conditions.StackCode))
                .Where(x =>
                    x.StackCode != null &&
                    x.StackCode.Contains(conditions.StackCode))
                .ToList();
        }

@@ -294,16 +320,19 @@
        // 6. åº”用ItemType筛选(在内存中过滤)
        if (conditions?.ItemType != null)
        {
            dataList = dataList.Where(x => x.ItemType == conditions.ItemType).ToList();
            dataList = dataList.Where(x => x.ItemType == conditions.ItemType)
                .ToList();
        }

        // 7. è®¡ç®—总记录数和分页参数（基于最终结果）
        var totalRecords = dataList.Count;
        var totalPages = (int)Math.Ceiling((double)totalRecords / searchDto.PageSize);
        var totalPages =
            (int)Math.Ceiling((double)totalRecords / searchDto.PageSize);
        var skip = (searchDto.PageIndex - 1) * searchDto.PageSize;

        // 8. å¯¹æœ€ç»ˆç»“果进行分页
        var pagedDataList = dataList.Skip(skip).Take(searchDto.PageSize).ToList();
        var pagedDataList =
            dataList.Skip(skip).Take(searchDto.PageSize).ToList();

        // 9. è¿”回分页结果
        return new PagedResult<ReturnableStockDto>
@@ -381,17 +410,21 @@
            .ToList();

        // 3. åœ¨å†…存中进行数据转换
        var result = queryResult.Select(x => {
        var result = queryResult.Select(x =>
        {
            // æ ¹æ®æ¡ç æŸ¥æ‰¾å¯¹åº”的立库任务信息
            var rackingTask = rackingTaskData
                .Where(r => r.ItemBarcode == x.ItemBarcode)
                .FirstOrDefault();
            
                        // æ ¹æ®Code值确定库存状态: null为立库入库中(0), 200为已在立库内(1)

            // æ ¹æ®Code值确定库存状态: null为立库入库中(0), 200为已在立库内(1)
            string stockStatus = "0"; // é»˜è®¤ä¸ºç«‹åº“入库中
            if (rackingTask?.Code != null)
            {
                stockStatus = rackingTask.Code == "200" ? "1" : "2"; // 200对应已在立库中(1)，其他非500值为进入立库的路上(2)
                stockStatus =
                    rackingTask.Code == "200"
                        ? "1"
                        : "2"; // 200对应已在立库中(1)，其他非500值为进入立库的路上(2)
            }

            return new ReturnableStockDto
@@ -439,6 +472,20 @@
            // å¯¹æ¯ä¸ªæ¡ç å•ç‹¬å¤„理
            foreach (var barcode in dto.ItemBarcodes)
            {
                // æ£€æŸ¥æœ€è¿‘两分钟内是否已经存在相同的 barcode è¢«å¤„理过
                var twoMinutesAgo = DateTime.Now.AddMinutes(-2);
                var recentTask = Db.Queryable<XbRackingTaskSyxtLog>()
                    .Where(x =>
                        x.ItemBarcode == barcode &&
                        x.CreateDate >= twoMinutesAgo)
                    .First();

                if (recentTask != null)
                {
                    throw new Exception(
                        $"物料条码 {barcode} åœ¨ä¸¤åˆ†é’Ÿå†…已被扫描处理，请勿重复操作。为避免立库系统任务重复下发，系统限制同一物料条码在两分钟内只能处理一次。");
                }

                decimal messageId = 0;
                string taskCode = "";

@@ -456,7 +503,8 @@
                        .LeftJoin<MesItems>((stock, item) =>
                            stock.ItemId == item.Id)
                        .Where((stock, item) =>
                            (stock.ItemBarcode == barcode || stock.StackCode == barcode) && stock.Quantity > 0)
                            (stock.ItemBarcode == barcode ||
                             stock.StackCode == barcode) && stock.Quantity > 0)
                        .GroupBy((stock, item) =>
                            new { stock.ItemId, stock.LotNo })
                        .Select((stock, item) => new
@@ -465,7 +513,8 @@
                            ItemName = SqlFunc.AggregateMax(item.ItemName),
                            LotNo = stock.LotNo ?? "",
                            Quantity = SqlFunc.AggregateSum(stock.Quantity),
                            StackCode = SqlFunc.AggregateMax(stock.DepotSectionsCode)
                            StackCode =
                                SqlFunc.AggregateMax(stock.DepotSectionsCode)
                        })
                        .ToList();

@@ -488,16 +537,17 @@
                        taskCode = taskCode,
                        taskType = "1",
                        palletCode = rackingTaskInfo?.PalletCode ?? "",
                        widthType = rackingTaskInfo?.WidthType?.ToString() ?? "2000",
                        widthType = rackingTaskInfo?.WidthType?.ToString() ??
                                    "2000",
                        station = dto.Station
                    };
                    var requestList = new[] { requestData };
                    var jsonRequest = JsonConvert.SerializeObject(requestList);

                    // 5. è®°å½•åˆ°MessageCenter表(请求前)
                     

                    var messageCenter = new MessageCenter
                    { 
                    {
                        TableName = "XB_RACKING_TASK_SYXT_LOG",
                        Url =
                            "http://172.20.5.5:50080/Services/Wmcs/RetrieveTask",
@@ -511,7 +561,8 @@
                        Data = jsonRequest,
                        DataInserted = jsonRequest
                    };
                    messageId = Db.Insertable(messageCenter).ExecuteReturnIdentity();
                    messageId = Db.Insertable(messageCenter)
                        .ExecuteReturnIdentity();

                    // 6. è°ƒç”¨HTTP接口
                    var apiUrl =

 StandardPda/MES.Service/service/Warehouse/MesPalletBinding1Manager.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,166 @@
using MES.Service.DB;
using MES.Service.Dto.service;
using MES.Service.Modes;
using Newtonsoft.Json;
using System.Text;

namespace MES.Service.service.Warehouse;

public class MesPalletBinding1Manager : Repository<MesPalletBinding1>
{
    /// <summary>
    /// è°ƒç”¨æŽ¥å£èŽ·å–栈板绑定信息
    /// </summary>
    /// <param name="stackCode">栈板码</param>
    /// <returns>接口返回结果</returns>
    public async Task<GetTransferListResponse> GetTransferListByStackCodeAsync(
        MesPalletBinding palletBinding)
    {
        try
        {
            // API URL
            string apiUrl =
                "http://no2api.dream-maker.com/bu/storage/pallet/getTransferList";

            // æž„建请求体
            var requestData = new { stackCode = palletBinding.StackCode };
            var jsonContent = JsonConvert.SerializeObject(requestData);
            var content = new StringContent(jsonContent, Encoding.UTF8,
                "application/json");

            // å‘送HTTP请求
            using (var httpClient = new HttpClient())
            {
                var response = await httpClient.PostAsync(apiUrl, content);
                var responseContent =
                    await response.Content.ReadAsStringAsync();

                // ååºåˆ—化响应
                var result =
                    JsonConvert.DeserializeObject<GetTransferListResponse>(
                        responseContent);
                return result;
            }
        }
        catch (Exception ex)
        {
            throw new Exception($"调用接口获取栈板绑定信息失败: {ex.Message}");
        }
    }

    /// <summary>
        /// å°†æŽ¥å£è¿”回的数据插入到数据库中
        /// </summary>
        /// <param name="palletBinding">栈板绑定信息</param>
        /// <returns>插入记录数</returns>
        public int InsertPalletBindingData(MesPalletBinding palletBinding)
        {
            var response = GetTransferListByStackCodeAsync(palletBinding).Result;

            if (response?.Data?.SnList == null || string.IsNullOrEmpty(response.Data.StackCode))
            {
                return 0;
            }

            int insertedCount = 0;
            
            try
            {
                // å‡†å¤‡è¦æ’入的数据列表
                var bindingList = new List<MesPalletBinding1>();
                
                foreach (var snItem in response.Data.SnList)
                {
                    var binding = new MesPalletBinding1
                    {
                        Stackcode = response.Data.StackCode,
                        SnNo = snItem.SnNo,
                        TicketNo = snItem.TickeNo,
                        Mediumboxcode = snItem.MediumBoxCode,
                        CreateDate = DateTime.Now,
                        IsInbound = 0 // é»˜è®¤æœªå…¥åº“
                    };
                    
                    bindingList.Add(binding);
                }
                
                // æ‰¹é‡æ’入数据到数据库
                if (bindingList.Any())
                {
                    // æ‰¹é‡æ’入新数据
                    var insertedIds = Db.Insertable(bindingList).PageSize(1)
                        .IgnoreColumnsNull()
                        .ExecuteCommand();
                    insertedCount = insertedIds;
                }
            }
            catch (Exception ex)
            {
                throw new Exception($"插入栈板绑定数据失败: {ex.Message}");
            }
            
            return insertedCount;
        }

        /// <summary>
        /// æ£€æŸ¥æ ˆæ¿ç åœ¨æ•°æ®åº“中是否存在
        /// </summary>
        /// <param name="stackCode">栈板码</param>
        /// <returns>存在返回true，否则返回false</returns>
        public bool CheckStackCodeExists(string stackCode)
        {
            try
            {
                if (string.IsNullOrEmpty(stackCode))
                {
                    return false;
                }

                // æŸ¥è¯¢MES_PALLET_BINDING表中是否存在该栈板码的数据
                var exists = Db.Queryable<MesPalletBinding1>()
                    .Any(x => x.Stackcode == stackCode);

                return exists;
            }
            catch (Exception ex)
            {
                throw new Exception($"检查栈板码是否存在时出错: {ex.Message}");
            }
        }

        /// <summary>
        /// å°†æŽ¥å£è¿”回的数据插入到数据库中（带存在性检查）
        /// </summary>
        /// <param name="palletBinding">栈板绑定信息</param>
        /// <returns>操作结果</returns>
        public async Task<int> InsertPalletBindingDataWithCheckAsync(MesPalletBinding palletBinding)
        {
            // å…ˆæ£€æŸ¥æ ˆæ¿ç æ˜¯å¦å­˜åœ¨
            bool exists = CheckStackCodeExists(palletBinding.StackCode);
            return exists ? 1 :
                // è°ƒç”¨åŽŸæ¥çš„插入方法
                InsertPalletBindingData(palletBinding);
        }

    /// <summary>
    /// æ ¹æ®æ ˆæ¿ç åˆ é™¤æ—§æ•°æ®
    /// </summary>
    /// <param name="stackCode">栈板码</param>
    /// <returns>删除记录数</returns>
    private async Task<int> DeleteByStackCodeAsync(string stackCode)
    {
        try
        {
            var deleteResult = await Db.Deleteable<MesPalletBinding1>()
                .Where(x => x.Stackcode == stackCode)
                .ExecuteCommandAsync();
            return deleteResult;
        }
        catch (Exception ex)
        {
            // è®°å½•é”™è¯¯ä½†ä¸æŠ›å‡ºå¼‚常，允许插入操作继续
            Console.WriteLine($"删除旧数据时出错: {ex.Message}");
            return 0;
        }
    }
}

 StandardPda/MESApplication/Controllers/Warehouse/MesPalletBinding1Controller.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,113 @@
using MES.Service.Dto.service;
using MES.Service.Modes;
using MES.Service.service;
using MES.Service.service.Warehouse;
using MES.Service.util;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;

namespace MESApplication.Controllers.Warehouse
{
    [ApiController]
    [Route("api/[controller]")]
    public class MesPalletBinding1Controller : ControllerBase
    {
        private readonly MessageCenterManager _manager = new();
        private readonly MesPalletBinding1Manager m = new();
        private readonly string METHOD = "POST";
        private readonly string TableName = "mespalletbinding1";

        private readonly string URL =
            "http://localhost:10054/api/mespalletbinding1/";

        /// <summary>
        /// ä»Žå¤–部接口获取栈板绑定信息并保存到数据库
        /// </summary>
        /// <param name="palletBinding">栈板绑定信息</param>
        /// <returns></returns>
        [HttpPost("SavePalletBindingData")]
        public ResponseResult SavePalletBindingData([FromBody] MesPalletBinding palletBinding)
        {
            try
            {
                // è°ƒç”¨ä¸šåŠ¡é€»è¾‘层方法将数据保存到数据库
                int insertedCount = m.InsertPalletBindingData(palletBinding);

                if (insertedCount > 0)
                {
                    return new ResponseResult
                    {
                        status = 0,
                        message = $"成功插入 {insertedCount} æ¡æ ˆæ¿ç»‘定数据",
                        data = insertedCount
                    };
                }
                else
                {
                    return new ResponseResult
                    {
                        status = 1,
                        message = "未插入任何数据，可能是因为接口返回的数据为空",
                        data = null
                    };
                }
            }
            catch (Exception ex)
            {
                return ResponseResult.ResponseError(ex);
            }
        }

        /// <summary>
        /// æ£€æŸ¥æ ˆæ¿ç åœ¨æ•°æ®åº“中是否存在
        /// </summary>
        /// <param name="stackCode">栈板码</param>
        /// <returns></returns>
        [HttpPost("CheckStackCodeExists")]
        public ResponseResult CheckStackCodeExists([FromBody] dynamic request)
        {
            try
            {
                string stackCode = request.stackCode;
                bool exists = m.CheckStackCodeExists(stackCode);

                return new ResponseResult
                {
                    status = 0,
                    message = exists ? "栈板码已存在" : "栈板码不存在",
                    data = exists
                };
            }
            catch (Exception ex)
            {
                return ResponseResult.ResponseError(ex);
            }
        }

        /// <summary>
        /// ä»Žå¤–部接口获取栈板绑定信息并保存到数据库（带存在性检查）
        /// </summary>
        /// <param name="palletBinding">栈板绑定信息</param>
        /// <returns></returns>
        [HttpPost("SavePalletBindingDataWithCheck")]
        public async Task<ResponseResult> SavePalletBindingDataWithCheck([FromBody] MesPalletBinding palletBinding)
        {
            try
            {
                // è°ƒç”¨ä¸šåŠ¡é€»è¾‘层方法将数据保存到数据库（带存在性检查）
                int result = await m.InsertPalletBindingDataWithCheckAsync(palletBinding);

                return new ResponseResult
                {
                    status = 0,
                    message = result > 0 ? $"成功处理 {result} æ¡æ ˆæ¿ç»‘定数据" : "未处理任何数据，可能是因为接口返回的数据为空",
                    data = result
                };
            }
            catch (Exception ex)
            {
                return ResponseResult.ResponseError(ex);
            }
        }
    }
}