using AutoMapper;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using SqlSugar;
using System.Text.RegularExpressions;
using wms.api.Job;
using wms.dto;
using wms.dto.request;
using wms.dto.request.cp;
using wms.dto.request.cp.dto;
using wms.dto.request.hj;
using wms.dto.request.hj.dto;
using wms.dto.request.pt.dto;
using wms.dto.request.share;
using wms.dto.response;
using wms.dto.response.cp;
using wms.service.IService;
using wms.sqlsugar;
using wms.sqlsugar.model.cp;
using wms.util.Ext;
using wms.util.Http;

namespace wms.api.Controllers
{
    [Route("api/[controller]/[action]")]
    [ApiController]
    public class CpController : BaseController
    {
        private readonly ICPService _cpService;
        private readonly ILogger<CpController> _logger;
        private readonly IMapper _mapper;
        private static object lockerSalesDocTrans = new object();
        private static object lockerSalesBackDocTrans = new object();
        private static object lockerComPushApiResInfo = new object();
        private static object lockerStockChange = new object();
        private static object lockerMesReleaseFlag = new object();

        private static object lockerStockStateChange = new object();
        private static object lockerPdaCpGroupStock = new object();   //pda空托or 物料 or 间隔板组盘
        private static object lockerPdaTrayTaskOut = new object();   //pda空托 or 间隔板出库
        private static object lockerWCS_InTaskInfo = new object();   //入库任务
        private static object lockerGetCpTunnelList = new object();   //巷道锁
        private static object lockerCpCompleteTask = new object();
        private static object lockerCpApplyStockInLoc = new object();
        private static object lockerCpManualTaskOut = new object();
        private static object lockerCpSrmPickOutCompleted = new object();
        private static object lockerMoveTask = new object();
        private static object lockerSalesDocOutTask = new object();
        private static object lockerCpSyncMaterInfoList = new object();
        private static object lockerCpCancelOrComplet = new object();
        private static object lockerCpCarryTask = new object();
        private static object lockerUpdatePuchState = new object();
        private static object lockerForceCancelTask = new object();
        private static object lockerDeleteStockInfo = new object();
        private static object lockerUpdateStockState = new object();
        private static object lockerUpdateCellState = new object();
        private static object lockerDataSwapCell = new object();
        private static object lockerDataBasePatch = new object();
        private static object lockerDataMoveCell = new object();
        private static object lockerErpCancelStock = new object();
        private static object lockerPdaStockInBack = new object();
        private static object lockerPreLockedStock = new object();
        private static object lockerMoveTaskInfo = new object();
        private static object lockerTrayPortageTask = new object();
        private static object lockerTrayPortageTaskCheck = new object();

        private static object lockerPalletAutoInTask = new object();
        private static object lockWcsUploadInfo = new object();
        private static object lockLabellingMachine = new object();
        private static object lockerHandErrTask = new object();
        private static object lockerPalletManualMoveTask = new object();
        private static object lockerFlowDataMoveJob = new object();
        private static object lockerProductBoxDetailUploadJob = new object();

        private Repository<cpSysJob> _sysJobrepository => new Repository<cpSysJob>();

        public CpController(ICPService cpService, ILogger<CpController> logger, IMapper mapper) : base(cpService)
        {
            _cpService = cpService;
            _logger = logger;
            _mapper = mapper;
        }

        /// <summary>
        /// 同步物料基础信息
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public string SyncMaterInfo(SyncMaterInfoRequest reqBody)
        {
            var result = new SRes();
            //_logger.LogInformation("请求参数：{@reqBody},{aa}", reqBody,1);
            CPSyncMaterInfoResponse resbody = JsonConvert.DeserializeObject<CPSyncMaterInfoResponse>(WmsServiceExportApi(reqBody));
            if (reqBody.SyncType == 1)
            {
                reqBody.PageIndex = 1;
                while (resbody.ResData.Any())
                {
                    _cpService.SyncMaterInfo(resbody.ResData);
                    reqBody.PageIndex++;
                    resbody = JsonConvert.DeserializeObject<CPSyncMaterInfoResponse>(WmsServiceExportApi(reqBody));
                }
            }
            else if (reqBody.SyncType == 2)
            {
                //拿到增量
                var increconf = _cpService.GetSysConfigByCode(Const.MESMaterialInitIncrement);
                if (increconf != null)
                {
                    reqBody.StartTime = DateTime.Parse(increconf.SContent);
                    //reqBody.Count = int.Parse(increconf.Remark);
                    resbody = JsonConvert.DeserializeObject<CPSyncMaterInfoResponse>(WmsServiceExportApi(reqBody));
                    if (resbody.ResData.Any())
                    {
                        if (_cpService.SyncMaterInfo(resbody.ResData))
                        {
                            var lastdata = resbody.ResData.OrderBy(p => p.UpdatedTime).Last();
                            _cpService.UpdateSysConfigModelColumns(new sqlsugar.model.UpdateModelColumns<cpSysConfig>()
                            {
                                Columns = it => new cpSysConfig { SContent = lastdata.UpdatedTime.ToString("yyyy-MM-dd HH:mm:ss.fff") },
                                WhereExpression = it => it.Code == Const.MESMaterialInitIncrement
                            });
                        }
                    }
                    else
                    {
                        result.ResCode = ResponseStatusCodeEnum.NoResult.GetHashCode();
                        result.ResMsg = ResponseStatusCodeEnum.NoResult.GetDescription();
                    }
                }
                else
                {
                    result.ResCode = ResponseStatusCodeEnum.AccountError.GetHashCode();
                    result.ResMsg = "没有配置信息" + Const.MESMaterialInitIncrement;
                }
            }
            else
            {
                if (!string.IsNullOrEmpty(reqBody.MatCode))
                {
                    resbody = JsonConvert.DeserializeObject<CPSyncMaterInfoResponse>(WmsServiceExportApi(reqBody));
                    if (resbody.ResData.Any())
                    {
                        if (_cpService.SyncMaterInfo(resbody.ResData))
                        {
                        }
                    }
                }
            }
            return result.ToCamelCaseString();
        }

        /// <summary>
        /// 成品库主数据接收
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes CpSyncMaterInfoList(CpSyncMaterInfoListRequest request)
        {
            return ConcurrencyReqControl<CpSyncMaterInfoListRequest, SRes>(lockerCpSyncMaterInfoList, "CpSyncMaterInfoList", request.MatCode, request, _cpService.SyncMaterInfoList);
        }

        /// <summary>
        /// 销售单信息传输接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes SalesDocTrans(SalesDocTransRequest reqDto)
        {
            return ConcurrencyReqControl<SalesDocTransRequest, SRes>(lockerSalesDocTrans, "SalesDocTrans", reqDto.BillCode, reqDto, _cpService.SalesDocTrans);
            //if (res.ResCode == ResponseStatusCodeEnum.Sucess.GetHashCode())
            //{
            //    return ComPushApiResInfo(new ComPushApiResInfoRequest() { ApiId = "SalesDocTrans", ReqId = Guid.NewGuid().ToString(), ResCode = ResponseStatusCodeEnum.Sucess.GetDescription() });
            //}
            //else
            //{
            //    return ComPushApiResInfo(new ComPushApiResInfoRequest() { ApiId = "SalesDocTrans", ReqId = Guid.NewGuid().ToString(), ResCode = ResponseStatusCodeEnum.Fail.GetDescription() });
            //}
        }

        /// <summary>
        /// 销售单下发出库任务
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes SalesDocOutTask(SalesDocOutTaskRequest request)
        {
            lock (lockerCpCompleteTask)
            {
                return ConcurrencyReqControl<SalesDocOutTaskRequest, SRes>(lockerSalesDocOutTask, "SalesDocOutTask", request.SalesDoc, request, _cpService.SalesDocOutTask);
            }
        }

        /// <summary>
        ///单据预锁库存（手动按钮触发）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PreLockedStock(PreLockedStockRequest request)
        {
            return ConcurrencyReqControl<PreLockedStockRequest, SRes>(lockerPreLockedStock, "PreLockedStock", request.BillCode, request, _cpService.PreLockedStock);
        }

        /// <summary>
        /// 销售出库信息反馈接口/呆滞料/异常料出库反馈接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes SalesDocTransFeedBack(SalesDocAutoPushRequest request)
        {
            var res = new SRes();
            if (request.Type == "1")
            {
                var SalesDoclists = _cpService.GetBillFeedbackList(p => p.PostResult != 1 && p.PostQty <= 5 && p.TypeCode == CpFackbeekType.SalesDoc.ToString()).OrderBy(p => p.AddTime).Take(10);
                var ErrorMateriallists = _cpService.GetBillFeedbackList(p => p.PostResult != 1 && p.PostQty <= 5 && p.TypeCode == CpFackbeekType.ErrorMaterial.ToString()).OrderBy(p => p.AddTime).Take(10);
                if (SalesDoclists.Any())
                {
                    var doc = SalesDoclists.First();
                    var SalesDoclist = SalesDoclists.Where(p => p.DocsNo == doc.DocsNo).ToList();
                    List<string> boxlist = new List<string>();
                    foreach (var item in SalesDoclist)
                    {
                        boxlist.Add(item.HWBarCode);
                    }
                    var salesDocTrans = new SalesDocTransFeedBackRequest()
                    {
                        BillCode = doc.DocsNo,
                        BoxList = boxlist,
                        Type = CpFackbeekType.SalesDoc.ToString()
                    };
                    WmsServiceExportMq(salesDocTrans);
                    var ids = SalesDoclist.Select(p => p.Id).ToList();
                    _cpService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<cpBillPushinfo>()
                    {
                        Columns = it => new cpBillPushinfo() { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                        WhereExpression = it => ids.Contains(it.Id)
                    });
                }
                if (ErrorMateriallists.Any())
                {
                    var doc = ErrorMateriallists.First();
                    var ErrorMateriallist = ErrorMateriallists.Where(p => p.DocsNo == doc.DocsNo).ToList();
                    List<string> boxlist = new List<string>();
                    foreach (var item in ErrorMateriallist)
                    {
                        boxlist.Add(item.HWBarCode);
                    }
                    var errorMaterialTrans = new SalesDocTransFeedBackRequest()
                    {
                        BillCode = doc.DocsNo,
                        BoxList = boxlist,
                        Type = CpFackbeekType.ErrorMaterial.ToString()
                    };
                    WmsServiceExportMq(errorMaterialTrans);
                    var ids = ErrorMateriallist.Select(p => p.Id).ToList();
                    _cpService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<cpBillPushinfo>()
                    {
                        Columns = it => new cpBillPushinfo() { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                        WhereExpression = it => ids.Contains(it.Id)
                    });
                }
            }
            return res;
        }

        /// <summary>
        /// 退售单信息传输接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes SalesBackDocTrans(SalesDocTransRequest reqDto)
        {
            return ConcurrencyReqControl<SalesDocTransRequest, SRes>(lockerSalesBackDocTrans, "SalesBackDocTrans", reqDto.BillCode, reqDto, _cpService.SalesBackDocTrans);
        }

        /// <summary>
        /// 销售退货入库信息反馈接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes SalesBackDocTransFeedBack(string doccode)
        {
            var list = _cpService.GetBillFeedbackList(p => p.DocsNo == doccode);
            var dtolist = _mapper.Map<List<SalesDocTransFeedBackRequest>>(list);
            //var dto = new SalesDocTransFeedBackRequest() { ListInfo = dtolist };
            SRes resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(dtolist));
            return resbody;
        }

        /// <summary>
        /// 销售余料回库入库信息反馈接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes SalesLeftDocTransFeedBack(string doccode)
        {
            var list = _cpService.GetBillFeedbackList(p => p.DocsNo == doccode);
            var dtolist = _mapper.Map<List<SalesLeftDocTransFeedBackRequest>>(list);
            //var dto = new SalesDocTransFeedBackRequest() { ListInfo = dtolist };
            SRes resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(dtolist));
            return resbody;
        }

        /// <summary>
        /// 接收回馈接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ComPushApiResInfo(ComPushApiResInfoRequest reqDto)
        {
            lock (lockerComPushApiResInfo)
            {
                return JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(reqDto));
            }
        }

        /// <summary>
        /// 呆滞料/异常料出库接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ErrorMaterialStockOut(ErrorMaterialStockOutRequest reqDto)
        {
            return ConcurrencyReqControl<ErrorMaterialStockOutRequest, SRes>(lockerComPushApiResInfo, "CpErrorMaterialStockOut", reqDto.BillCode, reqDto, _cpService.ErrorMaterialStockOut);
        }

        /// <summary>
        /// 库存改判
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes StockChange(CpStockChangeRequest reqDto)
        {
            return ConcurrencyReqControl<CpStockChangeRequest, SRes>(lockerStockChange, "CpStockChange", reqDto.BillCode, reqDto, _cpService.StockChange);
        }

        /// <summary>
        /// MES放行标志
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes MesReleaseFlag(MesReleaseFlagDto reqDto)
        {
            lock (lockerMesReleaseFlag) { return _cpService.MesReleaseFlag(reqDto); }
        }

        /// <summary>
        /// 改判反馈接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes StockChangeFeedBack(SalesDocAutoPushRequest request)
        {
            var res = new SRes();
            if (request.Type == "1")
            {
                var list = _cpService.GetBillFeedbackList(p => p.PostResult != 1 && p.PostQty <= 5 && p.TypeCode == CpFackbeekType.StateTrans.ToString()).OrderBy(p => p.AddTime).Take(5);
                if (!list.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "没有取到数据" + ResponseStatusCodeEnum.Fail.GetDescription();
                    return res;
                }
                var doc = list.First();
                list = list.Where(p => p.DocsNo == doc.DocsNo);
                var dtolist = _mapper.Map<List<StockChangeFeedBackRequestItem>>(list);
                var StockChangeFeed = new dto.request.cp.StockChangeFeedBackRequest()
                {
                    ListInfo = dtolist,
                    BillCode = doc.DocsNo,
                    ReqId = Guid.NewGuid().ToString()
                };

                var resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(StockChangeFeed));
                var ids = list.Select(p => p.Id).ToList();
                if (resbody.ResCode == ResponseStatusCodeEnum.Sucess.GetHashCode())
                {
                    _cpService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<cpBillPushinfo>()
                    {
                        Columns = it => new cpBillPushinfo() { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                        WhereExpression = it => ids.Contains(it.Id)
                    });
                }
                else
                {
                    _cpService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<cpBillPushinfo>()
                    {
                        Columns = it => new cpBillPushinfo() { PostResult = 2, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                        WhereExpression = it => ids.Contains(it.Id)
                    });
                }
            }
            else
            {
                var list = _cpService.GetBillFeedbackList(p => p.PostResult != 1 && p.PostQty <= 5 && p.TypeCode == CpFackbeekType.StateTrans.ToString()).OrderBy(p => p.AddTime).Take(5);
                if (!list.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "没有取到数据" + ResponseStatusCodeEnum.Fail.GetDescription();
                    return res;
                }
                var doc = list.First();
                list = list.Where(p => p.DocsNo == doc.DocsNo);
                var dtolist = _mapper.Map<List<StockChangeFeedBackRequestItem>>(list);
                var StockChangeFeed = new dto.request.cp.StockChangeFeedBackRequest()
                {
                    ListInfo = dtolist,
                    BillCode = doc.DocsNo,
                    ReqId = Guid.NewGuid().ToString()
                };
                var resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(StockChangeFeed));
                var ids = list.Select(p => p.Id).ToList();
                if (resbody.ResCode == ResponseStatusCodeEnum.Sucess.GetHashCode())
                {
                    _cpService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<cpBillPushinfo>()
                    {
                        Columns = it => new cpBillPushinfo() { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "手动推送", EditTime = DateTime.Now },
                        WhereExpression = it => ids.Contains(it.Id)
                    });
                }
                else
                {
                    _cpService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<cpBillPushinfo>()
                    {
                        Columns = it => new cpBillPushinfo() { PostResult = 2, PostQty = it.PostQty + 1, ResDesc = "手动推送", EditTime = DateTime.Now },
                        WhereExpression = it => ids.Contains(it.Id)
                    });
                }
            }
            return res;
        }

        /// <summary>
        /// 实时库存查询接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public CPGetCurStockListResponse GetCpCurStockList(CpGetCurStockListRequest reqDto)
        {
            return _cpService.GetCurStockList(reqDto);
        }

        /// <summary>
        /// 移库货位上报MES接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes MoveStockLocationFeedBack(SalesDocAutoPushRequest request)
        {
            var res = new SRes();
            if (request.Type == "1")
            {
                var list = _cpService.GetBillFeedbackList(p => p.PostResult != 1 && p.PostQty <= 5 && p.TypeCode == CpFackbeekType.MoveCell.ToString()).OrderBy(p => p.AddTime).Take(2);
                if (!list.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "没有取到数据" + ResponseStatusCodeEnum.Fail.GetDescription();
                    return res;
                }
                var dtolist = _mapper.Map<List<MoveStockLocationFeedBackRequest>>(list);

                var resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(dtolist));
                var ids = list.Select(p => p.Id).ToList();
                if (resbody.ResCode == ResponseStatusCodeEnum.Sucess.GetHashCode())
                {
                    _cpService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<cpBillPushinfo>()
                    {
                        Columns = it => new cpBillPushinfo() { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                        WhereExpression = it => ids.Contains(it.Id)
                    });
                }
                else
                {
                    _cpService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<cpBillPushinfo>()
                    {
                        Columns = it => new cpBillPushinfo() { PostResult = 2, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                        WhereExpression = it => ids.Contains(it.Id)
                    });
                }
            }
            else
            {
                var list = _cpService.GetBillFeedbackList(p => p.PostResult != 1 && p.PostQty <= 5 && p.TypeCode == CpFackbeekType.MoveCell.ToString()).OrderBy(p => p.AddTime).Take(2);
                if (!list.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "没有取到数据" + ResponseStatusCodeEnum.Fail.GetDescription();
                    return res;
                }
                var dtolist = _mapper.Map<List<MoveStockLocationFeedBackRequest>>(list);

                var resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(dtolist));
                var ids = list.Select(p => p.Id).ToList();
                if (resbody.ResCode == ResponseStatusCodeEnum.Sucess.GetHashCode())
                {
                    _cpService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<cpBillPushinfo>()
                    {
                        Columns = it => new cpBillPushinfo() { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                        WhereExpression = it => ids.Contains(it.Id)
                    });
                }
                else
                {
                    _cpService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<cpBillPushinfo>()
                    {
                        Columns = it => new cpBillPushinfo() { PostResult = 2, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                        WhereExpression = it => ids.Contains(it.Id)
                    });
                }
            }
            return res;
        }

        /// <summary>
        /// 放行/冻结单传输接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public StockStateChangeResponse StockStateChange(StockStateChangeRequest reqDto)
        {
            return ConcurrencyReqControl<StockStateChangeRequest, StockStateChangeResponse>(lockerStockStateChange, "CpStockStateChange", reqDto.BillCode, reqDto, _cpService.StockStateChange);
        }

        /// <summary>
        /// 同步箱号信息（人工入库使用）
        /// </summary>
        /// <param name="reqBody"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes BoxBuildStockTrans(BoxBuildStockTransRequest reqBody)
        {
            var res = new SRes();
            BoxBuildStockTransResponse resbody = JsonConvert.DeserializeObject<BoxBuildStockTransResponse>(WmsServiceExportApi(reqBody));
            if (resbody.Items.Any() && resbody.Items.First().lst_Children.Any())
            {
                var code = _mapper.Map<List<cpBoxItems>>(resbody.Items.First().lst_Children);
                code.ForEach(p =>
                {
                    p.HuTotalWt = resbody.Items.FirstOrDefault().HuTotalWt;
                    p.HuNetWt = resbody.Items.FirstOrDefault().HuNetWt;
                    p.HuTareWt = resbody.Items.FirstOrDefault().HuTareWt;
                });
                _cpService.InsertBoxItems(code);
            }
            else
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqBody.HuNr + "MES返回明细" + ResponseStatusCodeEnum.Fail.GetDescription();
            }
            return res;
        }

        /// <summary>
        /// 成品入库反馈接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ProductStockInBack(SalesDocAutoPushRequest request)
        {
            var res = new SRes();
            if (request.Type == "1")
            {
                var list = _cpService.GetBillFeedbackList(p => p.PostResult != 1 && p.PostQty <= 5 && p.TypeCode == CpFackbeekType.ProductStockIn.ToString()).OrderBy(p => p.AddTime).Take(1);
                if (!list.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "没有取到数据" + ResponseStatusCodeEnum.Fail.GetDescription();
                    return res;
                }
                var product = new ProductStockInBackRequest()
                {
                    HuNr = list.First().HWBarCode,
                    StoreCode = list.First().WarehouseCode,
                    StoreName = "成品库",
                    LocatCode = list.First().WareCellCode
                };
                WmsServiceExportMq(product);
                var ids = list.Select(p => p.Id).ToList();
                _cpService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<cpBillPushinfo>()
                {
                    Columns = it => new cpBillPushinfo() { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                    WhereExpression = it => ids.Contains(it.Id)
                });
            }

            return res;
        }

        /// <summary>
        /// ERP取消出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ErpCancelStock(ErpCancelStockRequest request)
        {
            lock (lockerErpCancelStock)
            {
                return _cpService.ErpCancelStock(request);
            }
        }

        #region 手持机操作功能

        /// <summary>
        /// PDA 组盘绑定(只组盘)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PdaCpGroupStock(SouthPdaRequest request)
        {
            lock (lockerPdaCpGroupStock)
            {
                request.ContGrpBarCode = Regex.Replace(request.ContGrpBarCode.Trim(), @"[\r\n]", "");
                if (!string.IsNullOrEmpty(request.BoxCode))
                {
                    request.BoxCode = Regex.Replace(request.BoxCode.Trim(), @"[\r\n]", "");
                    var boxCode = _cpService.GetBoxCodedetails(request.BoxCode);
                    if (!boxCode.Any())
                    {
                        var tt = BoxBuildStockTrans(new BoxBuildStockTransRequest() { HuNr = request.BoxCode });
                        if (tt.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                        {
                            return new SRes() { ResCode = ResponseStatusCodeEnum.Fail.GetHashCode(), ResMsg = tt.ResMsg };
                        }
                    }
                    else
                    {
                        _cpService.DeleteoldBoxcodeinfo(request.BoxCode);
                        _logger.LogInformation("删除旧数据，获取最新数据" + request.BoxCode + "|" + request.ContGrpBarCode);
                        var tt = BoxBuildStockTrans(new BoxBuildStockTransRequest() { HuNr = request.BoxCode });
                        if (tt.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                        {
                            return new SRes() { ResCode = ResponseStatusCodeEnum.Fail.GetHashCode(), ResMsg = tt.ResMsg };
                        }
                    }
                }
                return _cpService.PdaGroupStock(request);
            }
        }

        /// <summary>
        /// 空托盘 or 间隔板出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PdaTrayTaskOut(TrayGroupOutRequest request)
        {
            lock (lockerPdaTrayTaskOut)
            {
                return _cpService.PdaTrayTaskOut(request);
            }
        }

        /// <summary>
        /// PDA 退料
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PdaStockInBack(SouthPdaRequest request)
        {
            lock (lockerPdaStockInBack)
            {
                return _cpService.PdaStockInBack(request);
            }
        }

        #endregion 手持机操作功能

        #region WCS调用

        /// <summary>
        /// 获取入库任务
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes WCS_InTaskInfo(TrayGroupOutRequest request)
        {
            return ConcurrencyReqControl<TrayGroupOutRequest, SRes>(lockerWCS_InTaskInfo, "WCS_InTaskInfo" + request.Equip, request.Code, request, _cpService.InsertWCSInTask);
        }

        /// <summary>
        /// WCS信息上传（称重）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes WcsUploadInfo(WcsUploadInfoRequest request)
        {
            lock (lockWcsUploadInfo)
            {
                return _cpService.WcsUploadInfo(request);
            }
        }

        /// <summary>
        /// 贴标机信息传输
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<LabellingMachineResponse> LabellingMachine(LabellingMachineRequest request)
        {
            lock (lockLabellingMachine)
            {
                return _cpService.LabellingMachine(request);
            }
        }

        /// <summary>
        /// 获取巷道
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<string> GetTunnelPriorityList(GetTunnelPriorityListRequest reqEntity)
        {
            lock (lockerGetCpTunnelList)
            {
                return _cpService.GetCpTunnelPriorityList(reqEntity);
            }
        }

        /// <summary>
        /// 分配货位
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<CpApplyStockInLocResponse> ApplyStockInLoc(CpApplyStockInLocRequest request)
        {
            return ConcurrencyReqControl<CpApplyStockInLocRequest, SRes<CpApplyStockInLocResponse>>(lockerCpApplyStockInLoc, "CpApplyStockInLoc", "分配货位" + request.TunnelNum, request, _cpService.CpApplyStockInLoc);
        }

        /// <summary>
        /// 完成任务
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<int> CompleteTask(CompleteTaskRequest reqDto)
        {
            lock (lockerCpCompleteTask)
            {
                var res = _cpService.CpCompleteTask(reqDto);
                //进程死锁失败的情况再重复调用一次
                if (res.ResCode == ResponseStatusCodeEnum.InnerServerErr.GetHashCode())
                {
                    res = _cpService.CpCompleteTask(reqDto);
                }
                return res;
            }
        }

        /// <summary>
        /// 堆垛机出库放货完成
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<int> SrmPickOutCompleted(CpSrmPickOutCompletedRequest request)
        {
            lock (lockerCpCompleteTask)
            {
                return _cpService.CpSrmPickOutCompleted(request);
            }
        }

        /// <summary>
        /// 移库任务申请
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<WcsMoveTaskResponse> WcsMoveTask(WcsMoveTaskRequest request)
        {
            lock (lockerCpCompleteTask)
            {
                return _cpService.WcsMoveTask(request);
            }
        }

        /// <summary>
        /// 修改任务状态
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes UpdateTaskState(UpdateTaskStateRequest request)
        {
            lock (lockerMoveTaskInfo)
            {
                return _cpService.UpdateTaskState(request);
            }
        }

        /// <summary>
        /// 手动移库确定
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes MoveTaskInfo(MoveTaskRequest request)
        {
            lock (lockerMoveTaskInfo)
            {
                return _cpService.MoveTaskInfo(request);
            }
        }

        /// <summary>
        /// 成品库 取消/完成任务验证（只验证不做业务处理，开放wcs系统调用）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes CancelTaskVerify(CancelTaskRequest request)
        {
            lock (lockerCpCancelOrComplet)
            {
                return _cpService.CpCancelTaskVerify(request);
            }
        }

        /// <summary>
        /// 成品库 执行任务（开放wcs调用，前端不调用）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes CarryTaskInfo(CancelTaskRequest request)
        {
            lock (lockerCpCarryTask)
            {
                return _cpService.CpCarryTaskInfo(request);
            }
        }

        #endregion WCS调用

        /// <summary>
        /// 手动出库确定
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ManualTask(CpManualTaskRequest request)
        {
            lock (lockerCpCompleteTask)
            {
                request.BusType = TaskBusType.TaskBusType_HJ_ManualOut.GetDescription();
                return _cpService.ManualTask(request);
            }
        }

        /// <summary>
        /// 异常箱出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ErrorManualTask(CpManualTaskRequest request)
        {
            lock (lockerCpCompleteTask)
            {
                request.BusType = TaskBusType.TaskBusType_HJ_ManualOut.GetDescription();
                return _cpService.ErrorManualTask(request);
            }
        }

        /// <summary>
        /// 手动出库确定（MES调用）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes MesManualTask(CpMesManualTaskRequest request)
        {
            lock (lockerCpCompleteTask)
            {
                return _cpService.MesManualTask(request);
            }
        }

        /// <summary>
        /// 成品货位初始化
        /// </summary>
        /// <param name="row"></param>
        /// <param name="col"></param>
        /// <param name="deot"></param>
        /// <param name="rowcount"></param>
        /// <param name="tun"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes CpWareCellInit(int row, int col, int deot, int rowcount, int tun)
        {
            return _cpService.CpWareCellInit(row, col, deot, rowcount, tun);
        }

        #region 异常处理

        /// <summary>
        /// 强制取消任务
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ForceCancelTask(ErrorTaskRequest request)
        {
            lock (lockerForceCancelTask)
            {
                return _cpService.ForceCancelTask(request);
            }
        }

        /// <summary>
        /// 删除库存信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes DeleteStockInfo(DetailCodeStrRequest request)
        {
            lock (lockerDeleteStockInfo)
            {
                return _cpService.DeleteStockInfo(request);
            }
        }

        /// <summary>
        /// 修改库存状态
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes UpdateStockState(DetailCodeStr1Requestdto request)
        {
            lock (lockerUpdateStockState)
            {
                return _cpService.UpdateStockState(request);
            }
        }

        /// <summary>
        /// 修改货位状态
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes UpdateCellState(DetailCodeStr1Requestdto request)
        {
            lock (lockerUpdateCellState)
            {
                return _cpService.UpdateCellState(request);
            }
        }

        /// <summary>
        /// 货位数据互换
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes DataSwapCell(DataSwapCellStrRequest request)
        {
            lock (lockerDataSwapCell)
            {
                return _cpService.DataSwapCell(request);
            }
        }

        /// <summary>
        /// 补数据
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes DataBasePatch(DataBasePatchRequest request)
        {
            lock (lockerDataBasePatch)
            {
                return _cpService.DataBasePatch(request);
            }
        }

        [HttpPost]
        public SRes UpdatePurchState(UpdatePurchStateRequestdto request)
        {
            lock (lockerUpdatePuchState)
            {
                return _cpService.UpdatePurchState(request);
            }
        }

        /// <summary>
        /// 货位数据转移
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes DataMoveCell(DataSwapCellStrRequest request)
        {
            lock (lockerDataMoveCell)
            {
                return _cpService.DataMoveCell(request);
            }
        }

        /// <summary>
        /// 修改任务目标地址
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes UpdateTaskAddrTo(UpdateTaskAddrToReq request)
        {
            lock (lockerUpdatePuchState)
            {
                return _cpService.UpdateTaskAddrTo(request);
            }
        }

        #endregion 异常处理

        #region 定时器

        /// <summary>
        /// 启用job
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost]
        public string StartJob(AutoDetailRequest req)
        {
            var res = new SRes();
            var sysjob = _cpService.GetJobEntityByid(req.Id);
            if (sysjob == null)
            {
                res.ResCode = 0;
                res.ResMsg = "没有找到对应的定时任务";
                return res.ToCamelCaseString();
            }
            JobScheduler.Start(sysjob.Code, Type.GetType("wms.api.Job.PostJob"), sysjob.CronExpression);
            return res.ToCamelCaseString();
        }

        /// <summary>
        /// 执行job
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public string ExecuteJob(DetailCodeStrRequest reqEntity)
        {
            var res = new SRes();
            if (string.IsNullOrEmpty(reqEntity.Code))
            {
                res.ResCode = 0;
                res.ResMsg = "参数错误";
                return res.ToCamelCaseString();
            }
            var jobEntity = _cpService.GetJobEntityByCode(reqEntity.Code);
            if (jobEntity == null)
            {
                res.ResCode = 0;
                res.ResMsg = "没有找到该编码";
                return res.ToCamelCaseString();
            }
            var jobapilist = _cpService.GetJobapilist(jobEntity.Id);
            if (jobapilist.Any())
            {
                foreach (var item in jobapilist)
                {
                    Task.Run(() => { HttpUtil.PostRequest(item.ApiUrl, item.RequestBody); });
                }
            }
            return res.ToCamelCaseString();
        }

        /// <summary>
        /// 分页Job列表
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public List<dto.response.hj.SysJobDto> GetSysJobList(wms.dto.request.hj.GetSysJobListRequest reqEntity)
        {
            var list = _sysJobrepository.GetList();
            var listdto = _mapper.Map<List<dto.response.hj.SysJobDto>>(list);
            if (listdto != null && listdto.Any())
            {
                for (int i = 0; i < list.Count; i++)
                {
                    listdto[i].JobExecuteStatus = GetExecuteStatus(new DetailCodeRequest() { Code = listdto[i].Code });
                }
                return listdto;
            }
            return new List<dto.response.hj.SysJobDto>();
        }

        /// <summary>
        /// 获取执行状态
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public string GetExecuteStatus(DetailCodeRequest reqEntity)
        {
            var jobInfo = _sysJobrepository.GetFirst(p => p.Code == reqEntity.Code);
            var jobs = JobScheduler.GetJobList(Const.JobGroupName).Result;
            if (jobs != null)
            {
                var temp = jobs.Where(p => p.JobName == jobInfo.Code);
                if (temp.Any())
                {
                    return temp.First().JobStatus;
                }
                else
                {
                    return "Stop";
                }
            }
            else
            {
                return "Stop";
            }
        }

        #endregion 定时器

        #region 时效调用接口

        /// <summary>
        /// 托盘搬运任务
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes TrayPortageTask(TrayGroupOutRequest request)
        {
            lock (lockerPalletAutoInTask)
            {
                return _cpService.TrayPortageTask(request);
            }
            //return ConcurrencyReqControl<TrayGroupOutRequest, SRes>(lockerTrayPortageTask, "TrayPortageTask", request.Equip, request, _cpService.TrayPortageTask);
        }

        /// <summary>
        /// 托盘搬运验证
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes TrayPortageTaskCheck(TrayGroupOutRequest request)
        {
            lock (lockerTrayPortageTaskCheck)
            {
                return _cpService.TrayPortageTaskCheck(request);
            }
            //return ConcurrencyReqControl<TrayGroupOutRequest, SRes>(lockerTrayPortageTaskCheck, "TrayPortageTaskCheck", request.Equip, request, _cpService.TrayPortageTaskCheck);
        }

        /// <summary>
        /// 成品自动入库（码垛完成入库）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletAutoInTask(PalletAutoTaskRequest request)
        {
            lock (lockerPalletAutoInTask)
            {
                return _cpService.PalletAutoInTask(request);
            }
            //return ConcurrencyReqControl<PalletAutoTaskRequest, SRes>(lockerPalletAutoInTask, "PalletAutoInTask", request.Equip, request, _cpService.PalletAutoInTask);
        }

        #endregion 时效调用接口

        /// <summary>
        /// 成品整箱上传接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ProductBoxDetailUpload(SalesDocAutoPushRequest request)
        {
            lock (lockerProductBoxDetailUploadJob)
            {
                var res = new SRes();
                if (request.Type == "1")
                {
                    var list = _cpService.GetBoxItemsList(p => p.UpLoadFlag == 0 || p.UpLoadFlag == 2).Where(p => p.IsNeedUpLoadFlag == 1);
                    if (!list.Any())
                    {
                        return new SRes() { ResCode = ResponseStatusCodeEnum.NoResult.GetHashCode(), ResMsg = ResponseStatusCodeEnum.NoResult.GetDescription() };
                    }
                    foreach (var itemhunr in list.GroupBy(p => p.HuNr))
                    {
                        if (itemhunr.Key.Length > 12)//特殊装箱不上传mes
                        {
                            _cpService.UpdateBoxItemsModelColumns(new sqlsugar.model.UpdateModelColumns<cpBoxItems>()
                            {
                                Columns = it => new cpBoxItems { UpLoadFlag = 1, EditTime = DateTime.Now, Memo = "特殊装箱不上传mes" },
                                WhereExpression = it => it.HuNr == itemhunr.Key
                            });
                            continue;
                        }
                        ProductBoxDetailUploadRequestNew itemreq = new ProductBoxDetailUploadRequestNew()
                        {
                            LayerList = new List<LayerListItem>()
                            {
                            }
                        };

                        int ovcflag = 0;
                        foreach (var item in list.Where(p => p.HuNr == itemhunr.Key).GroupBy(p => new { p.Layer }))
                        {
                            itemreq.HuNr = item.First().HuNr;
                            itemreq.SKU = item.First().Sku;
                            itemreq.SkuDesc = item.First().Sku;
                            itemreq.Batch = item.First().Batch;
                            itemreq.Winding = item.First().Winding;
                            itemreq.TimeStamp = item.First().TimeStamp;
                            itemreq.MachineCode = item.First().EquNo;
                            itemreq.OvcValue = list.Where(p => p.HuNr == item.First().HuNr).Average(p => decimal.Parse(string.IsNullOrEmpty(p.OvcValue) ? "0" : p.OvcValue)).ToString();

                            if (item.First().OvcFlag == 2)
                            {
                                if (ovcflag == 0)
                                {
                                    var response = HttpUtil.PostRequest("http://10.30.44.3:8011/api/sx/GetTorsRange", JsonConvert.SerializeObject(new DetailCodeRequest() { Code = itemhunr.Key }));
                                    var trayres = JsonConvert.DeserializeObject<SRes<GetTorsRangeRes>>(response);
                                    if (decimal.Parse(itemreq.OvcValue) >= trayres.ResData.TorsValue - trayres.ResData.TorsRangeValue && decimal.Parse(itemreq.OvcValue) <= trayres.ResData.TorsValue + trayres.ResData.TorsRangeValue)
                                    {
                                        ovcflag = 2;
                                    }
                                    else
                                    {
                                        ovcflag = 1;
                                    }
                                    itemreq.OvcFlag = ovcflag.ToString();
                                }
                            }
                            else
                            {
                                itemreq.OvcFlag = item.First().OvcFlag.ToString();
                            }

                            var laydetail = new LayerListItem()
                            {
                                LayerCode = item.Key.Layer.ToString().PadLeft(2, '0'),
                                layerName = "第" + item.Key.Layer + "层",
                                OvcFlag = item.First().OvcFlag.ToString(),
                                OvcValue = item.Average(p => decimal.Parse(string.IsNullOrEmpty(p.OvcValue) ? "0" : p.OvcValue)).ToString(),
                                SpoolList = new List<SpoolListItem>()
                            };
                            laydetail.SpoolList = list.Where(p => p.HuNr == item.First().HuNr && p.Layer == item.Key.Layer).Select(p => new SpoolListItem()
                            {
                                MatNo = p.CLBarCode,
                                SpoolNr = p.HWBarCode
                            }).ToList();
                            itemreq.LayerList.Add(laydetail);
                        }
                        _logger.LogInformation("推送箱号记录：" + itemreq.HuNr);
                        var resbody = JsonConvert.DeserializeObject<PushResponse>(WmsServiceExportApi(itemreq));
                        if (resbody.ResCode == 200)
                        {
                            _logger.LogInformation("推送箱号：" + itemreq.HuNr + "反馈：" + JsonConvert.SerializeObject(resbody));
                            _cpService.UpdateBoxItemsModelColumns(new sqlsugar.model.UpdateModelColumns<cpBoxItems>()
                            {
                                Columns = it => new cpBoxItems { UpLoadFlag = 1, EditTime = DateTime.Now },
                                WhereExpression = it => it.HuNr == itemhunr.Key
                            });
                        }
                        else
                        {
                            _logger.LogInformation("推送整箱数据反回" + JsonConvert.SerializeObject(resbody));
                            _cpService.UpdateErrorBoxinfo(itemhunr.Key, resbody.ResMsg);
                            if (resbody.ResMsg.Length > 400)
                            {
                                resbody.ResMsg = resbody.ResMsg.Substring(0, 400);
                            }
                            _cpService.UpdateBoxItemsModelColumns(new sqlsugar.model.UpdateModelColumns<cpBoxItems>()
                            {
                                Columns = it => new cpBoxItems { UpLoadFlag = 1, EditTime = DateTime.Now, Memo = resbody.ResMsg },
                                WhereExpression = it => it.HuNr == itemhunr.Key
                            });
                        }
                    }
                }

                return res;
            }
        }

        /// <summary>
        /// 异常数据重复上传接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ErrorRepeatProductBoxDetailUpload(SalesDocAutoPushRequest request)
        {
            var res = new SRes();
            var list = _cpService.GetBoxItemsHistoryList(p => p.HuNr == request.Type);
            if (!list.Any())
            {
                return new SRes() { ResCode = ResponseStatusCodeEnum.NoResult.GetHashCode(), ResMsg = ResponseStatusCodeEnum.NoResult.GetDescription() };
            }
            foreach (var itemhunr in list.GroupBy(p => p.HuNr))
            {
                ProductBoxDetailUploadRequestNew itemreq = new ProductBoxDetailUploadRequestNew()
                {
                    LayerList = new List<LayerListItem>()
                    {
                    }
                };

                int ovcflag = 0;
                foreach (var item in list.Where(p => p.HuNr == itemhunr.Key).GroupBy(p => new { p.Layer }))
                {
                    itemreq.HuNr = item.First().HuNr;
                    itemreq.SKU = item.First().Sku;
                    itemreq.SkuDesc = item.First().Sku;
                    itemreq.Batch = item.First().Batch;
                    itemreq.Winding = item.First().Winding;
                    itemreq.TimeStamp = item.First().TimeStamp;
                    itemreq.MachineCode = item.First().EquNo;
                    itemreq.OvcValue = list.Where(p => p.HuNr == item.First().HuNr).Average(p => decimal.Parse(string.IsNullOrEmpty(p.OvcValue) ? "0" : p.OvcValue)).ToString();

                    if (item.First().OvcFlag == 2)
                    {
                        if (ovcflag == 0)
                        {
                            var response = HttpUtil.PostRequest("http://10.30.44.3:8011/api/sx/GetTorsRange", JsonConvert.SerializeObject(new DetailCodeRequest() { Code = itemhunr.Key }));
                            var trayres = JsonConvert.DeserializeObject<SRes<GetTorsRangeRes>>(response);
                            if (decimal.Parse(itemreq.OvcValue) >= trayres.ResData.TorsValue - trayres.ResData.TorsRangeValue && decimal.Parse(itemreq.OvcValue) <= trayres.ResData.TorsValue + trayres.ResData.TorsRangeValue)
                            {
                                ovcflag = 2;
                            }
                            else
                            {
                                ovcflag = 1;
                            }
                            itemreq.OvcFlag = ovcflag.ToString();
                        }
                    }
                    else
                    {
                        itemreq.OvcFlag = item.First().OvcFlag.ToString();
                    }

                    var laydetail = new LayerListItem()
                    {
                        LayerCode = item.Key.Layer.ToString().PadLeft(2, '0'),
                        layerName = "第" + item.Key.Layer + "层",
                        OvcFlag = item.First().OvcFlag.ToString(),
                        OvcValue = item.Average(p => decimal.Parse(string.IsNullOrEmpty(p.OvcValue) ? "0" : p.OvcValue)).ToString(),
                        SpoolList = new List<SpoolListItem>()
                    };
                    laydetail.SpoolList = list.Where(p => p.HuNr == item.First().HuNr && p.Layer == item.Key.Layer).Select(p => new SpoolListItem()
                    {
                        MatNo = p.CLBarCode,
                        SpoolNr = p.HWBarCode
                    }).ToList();
                    itemreq.LayerList.Add(laydetail);
                }
                _logger.LogInformation("推送箱号记录：" + itemreq.HuNr);
                var resbody = JsonConvert.DeserializeObject<PushResponse>(WmsServiceExportApi(itemreq));
                if (resbody.ResCode == 200)
                {
                    _logger.LogInformation("推送箱号：" + itemreq.HuNr + "反馈：" + resbody.ResMsg);
                }
                else
                {
                    _logger.LogInformation("推送箱号：" + itemreq.HuNr + "反馈：" + resbody.ResMsg);
                }
            }

            return res;
        }

        /// <summary>
        /// 成品临时箱整箱上传接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes TempProductBoxDetailUpload(SalesDocAutoPushRequest request)
        {
            var res = new SRes();
            if (request.Type == "1")
            {
                var list = _cpService.GetBoxItemsList(p => p.UpLoadFlag == 0 || p.UpLoadFlag == 2).Where(p => p.IsNeedUpLoadFlag == 2);
                if (!list.Any())
                {
                    return new SRes() { ResCode = ResponseStatusCodeEnum.NoResult.GetHashCode(), ResMsg = ResponseStatusCodeEnum.NoResult.GetDescription() };
                }
                foreach (var item in list.GroupBy(p => p.HuNr))
                {
                    if (item.Key.StartsWith("Test"))//特殊装箱不上传mes
                    {
                        _cpService.UpdateBoxItemsModelColumns(new sqlsugar.model.UpdateModelColumns<cpBoxItems>()
                        {
                            Columns = it => new cpBoxItems { UpLoadFlag = 1, EditTime = DateTime.Now, Memo = "特殊装箱不上传mes" },
                            WhereExpression = it => it.HuNr == item.Key
                        });
                        continue;
                    }
                    ProductBoxDetailUploadRequest itemreq = new ProductBoxDetailUploadRequest()
                    {
                        TempHuNr = item.Key,
                        Lst_SpoolNr = item.Select(p => p.HWBarCode).ToList()
                    };

                    var resbody = JsonConvert.DeserializeObject<PushResponse>(WmsServiceExportApi(itemreq));
                    if (resbody.success == true)
                    {
                        _cpService.UpdateBoxItemsModelColumns(new sqlsugar.model.UpdateModelColumns<cpBoxItems>()
                        {
                            Columns = it => new cpBoxItems { UpLoadFlag = 1, EditTime = DateTime.Now },
                            WhereExpression = it => it.HuNr == item.Key
                        });
                    }
                    else
                    {
                        if (item.Key.StartsWith("HAZDA"))
                        {
                            //如果是临时箱子则标记成异常，不再上传
                            _cpService.UpdateBoxFail(item.Key);
                            _cpService.UpdateBoxItemsModelColumns(new sqlsugar.model.UpdateModelColumns<cpBoxItems>()
                            {
                                Columns = it => new cpBoxItems { UpLoadFlag = 1, EditTime = DateTime.Now, Memo = "临时箱推送MES失败，自动设置成异常箱" },
                                WhereExpression = it => it.HuNr == item.Key
                            });
                        }
                        else
                        {
                            _cpService.UpdateBoxItemsModelColumns(new sqlsugar.model.UpdateModelColumns<cpBoxItems>()
                            {
                                Columns = it => new cpBoxItems { UpLoadFlag = 2, EditTime = DateTime.Now },
                                WhereExpression = it => it.HuNr == item.Key
                            });
                        }
                    }
                }
            }

            return res;
        }

        /// <summary>
        /// 监控遗留的库存数据
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes MonitorLeftStock(WebErrorRequest request)
        {
            return _cpService.MonitorLeftStock(request);
        }

        /// <summary>
        /// 手动出库数据反馈(分发)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ManaelOutBack(SalesDocAutoPushRequest request)
        {
            var res = new SRes();
            if (request.Type == "1")
            {
                var ManaelOut = _cpService.GetBillFeedbackList(p => p.PostResult != 1 && p.PostQty <= 5 && p.TypeCode == CpFackbeekType.ManualOut.ToString()).OrderBy(p => p.AddTime).FirstOrDefault();
                if (ManaelOut == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.NoResult.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.NoResult.GetDescription();
                    return res;
                }
                var ManaelOutTrans = new ManaelOutBackRequest()
                {
                    HuNr = ManaelOut.HWBarCode,
                    Type = CpFackbeekType.ManualOut.ToString(),
                    OutTime = ManaelOut.AddTime.ToString("yyyyMMddHHmmss")
                };
                WmsServiceExportPubMq(ManaelOutTrans);
                _cpService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<cpBillPushinfo>()
                {
                    Columns = it => new cpBillPushinfo() { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                    WhereExpression = it => ManaelOut.Id == it.Id
                });
            }
            return res;
        }

        /// <summary>
        /// 验证箱号和托盘是否匹配
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes VerifyBoxNum(VerifyBoxNumRequest request)
        {
            return _cpService.VerifyBoxNum(request);
        }

        /// <summary>
        /// 成品库盘点报表生成
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes GenInventoryReport(DetailCodeRequest request)
        {
            //0 30 8 ? * *    每天上午8:30触发
            var res = new SRes();
            DateTime lastDay = Convert.ToDateTime(DateTime.Now.AddMonths(1).ToString("yyyy-MM-01")).AddDays(-1);
            if (lastDay.Day != DateTime.Now.Day)
            {
                res.ResMsg = "当前不是本月最后一天";
                return res;
            }
            _cpService.GenInventoryReport();

            return res;
        }

        /// <summary>
        /// 成品人工口上成品码垛托盘PDA提交接口(MES调用)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletManualMoveTask(PalletManualMoveTaskRequest request)
        {
            lock (lockerPalletManualMoveTask)
            {
                return _cpService.PalletManualMoveTask(request);
            }
        }

        /// <summary>
        /// 流水数据归档
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes FlowDataMoveJob(SalesDocAutoPushRequest request)
        {
            lock (lockerFlowDataMoveJob)
            {
                return _cpService.FlowDataMoveJob(request);
            }
        }

        /// <summary>
        /// 触发自动校秤任务
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public SRes TriggerAutoCalibration()
        {
            return _cpService.TriggerAutoCalibration();
        }
    }
}