PT-HJ-CP-WMS/wms.api/Controllers/PtController.cs

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

namespace wms.api.Controllers
{
    /// <summary>
    /// 盘条库控制器
    /// </summary>
    [Route("api/[controller]/[action]")]
    [ApiController]
    public class PtController : BaseController
    {
        private readonly IPTService _ptService;
        private readonly ILogger<PtController> _logger;
        private readonly IMapper _mapper;
        private static object lockerPurchaseBillTrans = new object();
        private static object lockerErpUnlockStock = new object();
        private static object lockerProductionStockOut = new object();
        private static object lockerProductionFeedBack = new object();
        private static object lockerStockChange = new object();
        private static object lockerProductionBack = new object();
        private static object lockerPtPurchTaskIn = new object();
        private static object lockerPtApplyStockInLoc = new object();
        private static object lockerPtCompleteTask = new object();
        private static object lockerPtSrmPickOutCompleted = new object();
        private static object lockerSyncMaterInfoList = new object();
        private static object lockerPtWcsProductionOutTask = new object();
        private static object lockerGetPtTunnelList = new object();
        private static object lockerManualTaskOut = new object();
        private static object lockerPinkuInfoUpdate = new object();
        private static object lockerPinkucarryInTask = new object();
        private static object lockerPinkucarryOutTask = new object();
        private static object lockerPtCancelOrComplet = new object();
        private static object lockerPtCarryTask = 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 lockerProductRequisition = new object();
        private static object lockerPdaInsterInTask = new object();
        private static object lockerHandErrTask = new object();
        private static object lockerJKArriveInfo = new object();
        private static object lockerJKTransPTInfo = new object();
        private static object lockerPurchaseBillTransCheck = new object();
        private static object lockerFlowDataMoveJob = new object();

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

        public PtController(IPTService ptService, ILogger<PtController> logger, IMapper mapper) : base(ptService)
        {
            _ptService = ptService;
            _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);
            PTSyncMaterInfoResponse resbody = JsonConvert.DeserializeObject<PTSyncMaterInfoResponse>(WmsServiceExportApi(reqBody));
            if (reqBody.SyncType == 1)
            {
                reqBody.PageIndex = 1;
                while (resbody.ResData.Any())
                {
                    _ptService.SyncMaterInfo(resbody.ResData);
                    reqBody.PageIndex++;
                    resbody = JsonConvert.DeserializeObject<PTSyncMaterInfoResponse>(WmsServiceExportApi(reqBody));
                }
            }
            else if (reqBody.SyncType == 2)
            {
                //拿到增量
                var increconf = _ptService.GetSysConfigByCode(Const.MESMaterialInitIncrement);
                if (increconf != null)
                {
                    reqBody.StartTime = DateTime.Parse(increconf.SContent);
                    //reqBody.Count = int.Parse(increconf.Remark);
                    resbody = JsonConvert.DeserializeObject<PTSyncMaterInfoResponse>(WmsServiceExportApi(reqBody));
                    if (resbody.ResData.Any())
                    {
                        if (_ptService.SyncMaterInfo(resbody.ResData))
                        {
                            var lastdata = resbody.ResData.OrderBy(p => p.UpdatedTime).Last();
                            _ptService.UpdateSysConfigModelColumns(new sqlsugar.model.UpdateModelColumns<ptSysConfig>()
                            {
                                Columns = it => new ptSysConfig { 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<PTSyncMaterInfoResponse>(WmsServiceExportApi(reqBody));
                    if (resbody.ResData.Any())
                    {
                        if (_ptService.SyncMaterInfo(resbody.ResData))
                        {
                        }
                    }
                }
            }

            return result.ToCamelCaseString();
        }

        /// <summary>
        /// 采购到货单/采购退货单/到货重挂清单接口（二楼入库默认传2999）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PurchaseBillTrans(PurchaseBillTransReqest reqDto)
        {
            reqDto.ListInfo = reqDto.ListInfo.Where(p => p.RFID.StartsWith("PT")).ToList();
            var res = ConcurrencyReqControl<PurchaseBillTransReqest, SRes>(lockerPurchaseBillTrans, "PurchaseBillTrans", reqDto.BillCode, reqDto, _ptService.PurchaseBillTrans);
            if (res.ResCode != 200)
            {
                return res;
            }
            if (string.IsNullOrEmpty(reqDto.Equip))
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = "请扫描地码，地码没有传值";
                return res;
            }
            if (!string.IsNullOrEmpty(reqDto.Equip) && res.ResCode == 200)
            {
                if (reqDto.ListInfo.Count > 1)
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = "只能绑定一个盘条信息，当前接口传递多条数据F";
                    return res;
                }
                res = PdaPurchaseTask(new PtPurchaseTaskReqest() { Equip = reqDto.Equip, ConBarCode = reqDto.ListInfo.First().RFID, MatBarCode = reqDto.ListInfo.First().MatBarCode });
            }
            return res;
        }

        /// <summary>
        /// 采购到货单验证
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PurchaseBillTransCheck(PurchaseBillTransReqestCheck reqDto)
        {
            lock (lockerPurchaseBillTransCheck)
            {
                return _ptService.InsertBillInvinitCheck(reqDto);
            }
        }

        /// <summary>
        /// 盘条RFID验证
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PurchaseRFIDCheck(PurchaseRFIDCheckReqest reqDto)
        {
            lock (lockerPurchaseBillTransCheck)
            {
                return _ptService.PurchaseRFIDCheck(reqDto); ;
            }
        }

        /// <summary>
        /// 盘条主数据接收
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PtSyncMaterInfoList(PtSyncMaterInfoListRequest reqDto)
        {
            var res = new SRes();
            return ConcurrencyReqControl<PtSyncMaterInfoListRequest, SRes>(lockerSyncMaterInfoList, "PtSyncMaterInfoList", "物料主数据推送", reqDto, _ptService.GetSyncMaterInfo);
        }

        /// <summary>
        /// 采购到货单入库反馈/采购退货出库反馈/异常出库重挂反馈接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PurchaseBillTransFeedBack(PtAutoPurchData request)
        {
            var res = new SRes();
            //自动推送
            if (request.Type == "1")
            {
                var list = _ptService.GetBillFeedbackList(PtFackbeekType.InterfaceType_PT_PurchaseStockIn.ToString());
                if (!list.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "没有取到符合条件的数据";
                }
                //采购入库单
                if (list.Where(p => p.TypeCode == PtFackbeekType.InterfaceType_PT_PurchaseStockIn.ToString()).ToList().Any())
                {
                    var purch = list.Where(p => p.TypeCode == PtFackbeekType.InterfaceType_PT_PurchaseStockIn.ToString()).ToList();
                    PurchaseBillTransFeedBackRequest purchaseBill = new PurchaseBillTransFeedBackRequest();
                    var dtolist = _mapper.Map<List<PurchaseBillTransFeedBackRequestItem>>(purch);
                    var purchs = purch.First();
                    purchaseBill.ListInfo = dtolist;
                    purchaseBill.BillCode = purchs.DocsNo;
                    purchaseBill.BillType = purchs.TypeCode;
                    purchaseBill.ReqId = purchs.ReqNo;
                    var resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(purchaseBill));
                    var ids = purch.Select(p => p.Id).ToList();
                    if (resbody.ResCode == ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        _ptService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<ptBillPushinfo>()
                        {
                            Columns = it => new ptBillPushinfo() { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                            WhereExpression = it => ids.Contains(it.Id)
                        });
                    }
                    else
                    {
                        _ptService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<ptBillPushinfo>()
                        {
                            Columns = it => new ptBillPushinfo() { PostResult = 2, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                            WhereExpression = it => ids.Contains(it.Id)
                        });
                    }
                }
                var listAnewStockIn = _ptService.GetBillFeedbackList(PtFackbeekType.InterfaceType_PT_AnewStockIn.ToString());
                //重挂
                if (listAnewStockIn.Where(p => p.TypeCode == PtFackbeekType.InterfaceType_PT_AnewStockIn.ToString()).ToList().Any())
                {
                    var purch = listAnewStockIn.Where(p => p.TypeCode == PtFackbeekType.InterfaceType_PT_AnewStockIn.ToString()).ToList();
                    PurchaseBillTransFeedBackRequest purchaseBill = new PurchaseBillTransFeedBackRequest();
                    var dtolist = _mapper.Map<List<PurchaseBillTransFeedBackRequestItem>>(purch);
                    var purchs = purch.First();
                    purchaseBill.ListInfo = dtolist;
                    purchaseBill.BillCode = purchs.DocsNo;
                    purchaseBill.BillType = purchs.TypeCode;
                    purchaseBill.ReqId = purchs.ReqNo;
                    var resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(purchaseBill));
                    var ids = purch.Select(p => p.Id).ToList();
                    if (resbody.ResCode == ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        _ptService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<ptBillPushinfo>()
                        {
                            Columns = it => new ptBillPushinfo() { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                            WhereExpression = it => ids.Contains(it.Id)
                        });
                    }
                    else
                    {
                        _ptService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<ptBillPushinfo>()
                        {
                            Columns = it => new ptBillPushinfo() { PostResult = 2, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                            WhereExpression = it => ids.Contains(it.Id)
                        });
                    }
                }
            }

            return res;
        }

        /// <summary>
        /// 放行单传输接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public ErpUnlockStockResponse ErpUnlockStock(ErpUnlockStockRequest reqDto)
        {
            return ConcurrencyReqControl<ErpUnlockStockRequest, ErpUnlockStockResponse>(lockerErpUnlockStock, "PtErpUnlockStock", reqDto.BillCode, reqDto, _ptService.ErpUnlockStock);
        }

        /// <summary>
        /// 生产领料单传输接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ProductionStockOut(ProductionStockOutRequest reqDto)
        {
            return ConcurrencyReqControl<ProductionStockOutRequest, SRes>(lockerProductionStockOut, "PtProductionStockOut", reqDto.BillCode, reqDto, _ptService.ProductionStockOut);
        }

        /// <summary>
        /// 自动叫料
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        //[HttpPost]
        //public SRes WcsProductionOutRequest(WcsProductionOutRequest request)
        //{
        //    return ConcurrencyReqControl<WcsProductionOutRequest, SRes>(lockerPtWcsProductionOutTask, "PtWcsProductionOutRequest" , "自动叫料", request, _ptService.WcsProductionOutRequest);
        //}
        /// <summary>
        /// 自动叫料新
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes WcsProductionOutRequestNew(WcsProductionOutRequest request)
        {
            return ConcurrencyReqControl<WcsProductionOutRequest, SRes>(lockerPtWcsProductionOutTask, "PtWcsProductionOutRequest", "自动叫料", request, _ptService.WcsProductionOutRequest2);
        }

        /// <summary>
        /// 生产领料/退料/改判反馈接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ProductionFeedBack(PtAutoPurchData request)
        {
            var res = new SRes();
            //自动推送
            if (request.Type == "1")
            {
                var list = _ptService.GetProductionFeedBack();
                if (!list.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "没有取到符合条件的数据";
                    return res;
                }
                //生产领料反馈
                if (list.Where(p => p.TypeCode == PtFackbeekType.PickMat.ToString()).ToList().Any())
                {
                    var purch = list.Where(p => p.TypeCode == PtFackbeekType.PickMat.ToString()).ToList();
                    var purchs = purch.First();
                    purch = purch.Where(p => p.DocsNo == purchs.DocsNo).ToList();
                    ProductionFeedBackRequest purchaseBill = new ProductionFeedBackRequest();
                    var dtolist = _mapper.Map<List<ProductionFeedBackRequestItem>>(purch);
                    purchaseBill.ListInfo = dtolist;
                    purchaseBill.BillCode = purchs.DocsNo;
                    purchaseBill.BillType = purchs.TypeCode;
                    WmsServiceExportMq(purchaseBill);
                    var ids = purch.Select(p => p.Id).ToList();
                    _ptService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<ptBillPushinfo>()
                    {
                        Columns = it => new ptBillPushinfo() { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                        WhereExpression = it => ids.Contains(it.Id)
                    });
                }

                //退料
                if (true)
                {
                }
                //改判
                if (true)
                {
                }
            }
            return res;
        }

        /// <summary>
        /// 手动出库反馈接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ProductionFeedBackManual(PtAutoPurchData request)
        {
            var res = new SRes();
            //自动推送
            if (request.Type == "1")
            {
                var list = _ptService.GetProductionFeedBack();
                if (!list.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "没有取到符合条件的数据";
                    return res;
                }
                if (list.Where(p => p.TypeCode == "Manual").ToList().Any())
                {
                    var purch = list.Where(p => p.TypeCode == "Manual").ToList();
                    var purchs = purch.First();
                    purch = purch.Where(p => p.DocsNo == purchs.DocsNo).ToList();
                    ProductionFeedBackRequest purchaseBill = new ProductionFeedBackRequest();
                    var dtolist = _mapper.Map<List<ProductionFeedBackRequestItem>>(purch);
                    purchaseBill.ListInfo = dtolist;
                    purchaseBill.BillCode = purchs.DocsNo;
                    purchaseBill.BillType = purchs.TypeCode;
                    WmsServiceExportApi(purchaseBill);
                    var ids = purch.Select(p => p.Id).ToList();
                    _ptService.UpdatePuchinfoModelColumns(new sqlsugar.model.UpdateModelColumns<ptBillPushinfo>()
                    {
                        Columns = it => new ptBillPushinfo() { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                        WhereExpression = it => ids.Contains(it.Id)
                    });
                }
            }
            return res;
        }

        /// <summary>
        /// 炉号用完反馈给mes
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes BoilerNoFeedBack(PtAutoPurchData request)
        {
            var res = new SRes();
            var list = _ptService.GetSysConfigListByExpression(p => p.Default1 == "ProductPinKu" && p.Default6 == "0" && p.Default5 == p.Default7);
            if (!list.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有取到符合条件的数据";
                return res;
            }
            foreach (var item in list)
            {
                BoilerNoRequest boilerNoRequest = new BoilerNoRequest();
                boilerNoRequest.BoilerNo = item.Default5;

                _logger.LogInformation("推送mes炉号用完信号请求：" + JsonConvert.SerializeObject(boilerNoRequest));
                var resbody = JsonConvert.DeserializeObject<PushResponse1>(WmsServiceExportApi(boilerNoRequest));
                _logger.LogInformation("推送mes炉号用完信号返回：" + JsonConvert.SerializeObject(resbody));
                if (resbody.Success == true || resbody.Code == "200")
                {
                    _ptService.UpdateSysConfigModelColumns(new sqlsugar.model.UpdateModelColumns<ptSysConfig>()
                    {
                        Columns = it => new ptSysConfig() { Default6 = "1", EditTime = DateTime.Now },
                        WhereExpression = it => it.Id == item.Id
                    });
                }
            }
            return res;
        }

        /// <summary>
        /// 库存改判
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<StockChangeResItem> StockChange(PtStockChangeRequest reqDto)
        {
            lock (lockerStockChange)
            {
                return _ptService.StockChange(reqDto);
            }
            //return ConcurrencyReqControl<PtStockChangeRequest, SRes<StockChangeResItem>>(lockerStockChange, "PtStockChange", "PtStockChange", reqDto, _ptService.StockChange);
        }

        /// <summary>
        /// 生产退料单接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ProductionBack(ProductionBackRequest reqDto)
        {
            return ConcurrencyReqControl<ProductionBackRequest, SRes>(lockerProductionBack, "PtProductionBack", reqDto.BillCode, reqDto, _ptService.ProductionBack);
        }

        [HttpPost]
        public SRes WareCellInit(int row, int col, int deot, int rowcount, int tun)
        {
            return _ptService.WareCellInit(row, col, deot, rowcount, tun);
        }

        /// <summary>
        /// 实时库存查询接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public PTGetCurStockListResponse GetPtCurStockList(PtGetCurStockListRequest reqDto)
        {
            return _ptService.GetCurStockList(reqDto);
        }

        #region 盘条PDA功能

        /// <summary>
        /// 盘条解绑
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<int> Unbounding(PtUnboundRequest request)
        {
            return _ptService.Unbounding(request);
        }

        /// <summary>
        /// pda单据查询
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public string GetDocumentsAll(PtDocumentsRequest request)
        {
            return _ptService.GetPageDocumentsList(request).ToCamelCaseString();
        }

        /// <summary>
        /// pda单据明细查询（传单号）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public string GetDocumentDetails(PtDocumentsRequest request)
        {
            return _ptService.GetDocumentDetailListByDocsNo(request).ToCamelCaseString();
        }

        /// <summary>
        /// pda指定出库确定
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public string PdaManualTask(PtManualTaskRequest request)
        {
            request.BusType = TaskBusType.TaskBusType_HJ_PdaManualOut.GetDescription();
            return _ptService.ManualTask(request);
        }

        /// <summary>
        /// pda质检领料出库确定
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public string PdaQualityTask(PtManualTaskRequest request)
        {
            request.BusType = TaskBusType.TaskBusType_HJ_QualityOut.GetDescription();
            return _ptService.ManualTask(request);
        }

        /// <summary>
        /// pda重挂出库确定
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public string PdaInactionStockTask(PtManualTaskRequest request)
        {
            request.BusType = TaskBusType.TaskBusType_HJ_AnewOut.GetDescription();
            return _ptService.ManualTask(request);
        }

        /// <summary>
        /// 获取设备报警信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public string GetEquipErrorInfo(PtErrorInfoRequest request)
        {
            return "";
        }

        /// <summary>
        /// 获取物料报警信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public string GetMaterErrorInfo(PtErrorInfoRequest request)
        {
            return "";
        }

        /// <summary>
        /// 获取业务报警信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public string GetBusinessErrorInfo(PtErrorInfoRequest request)
        {
            return "";
        }

        /// <summary>
        /// 手动入库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PdaInsterInTask(PtGroupInTaskRequest request)
        {
            lock (lockerPdaInsterInTask)
            {
                request.Equip = Regex.Replace(request.Equip.Trim(), @"[\r\n]", "");
                request.Rfid = Regex.Replace(request.Rfid.Trim(), @"[\r\n]", "");
                return _ptService.PdaInsterInTask(request);
            }
        }

        /// <summary>
        /// PDA 采购入库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PdaPurchaseTask(PtPurchaseTaskReqest request)
        {
            if (string.IsNullOrWhiteSpace(request.ConBarCode))
            {
                return new SRes()
                {
                    ResCode = 0,
                    ResMsg = "条码不能传空值"
                };
            }
            lock (lockerPtPurchTaskIn)
            {
                request.Equip = Regex.Replace(request.Equip.Trim(), @"[\r\n]", "");
                return _ptService.PtPurchaseTask(request);
            }
        }

        /// <summary>
        /// PDA 生产领料确定
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PdaProductRequisition(PtUnboundRequest request)
        {
            lock (lockerProductRequisition)
            {
                return _ptService.PdaProductRequisition(request);
            }
        }

        /// <summary>
        /// PDA 生产领料空架子发回
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PdaProductRequisition2(PtUnboundRequest request)
        {
            lock (lockerProductRequisition)
            {
                return _ptService.PdaProductRequisition2(request);
            }
        }

        /// <summary>
        /// 监控领料出扫过码的架子搬走
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes MoniterEmptCon(PtUnboundRequest request)
        {
            lock (lockerProductRequisition)
            {
                return _ptService.MoniterEmptCon(request);
            }
        }

        #endregion 盘条PDA功能

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

        #region WCS调用

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

        /// <summary>
        /// 分配货位
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<PtApplyStockInLocResponse> ApplyStockInLoc(PtApplyStockInLocRequest reqEntity)
        {
            return ConcurrencyReqControl<PtApplyStockInLocRequest, SRes<PtApplyStockInLocResponse>>(lockerPtApplyStockInLoc, "PtApplyStockInLoc", "分配货位" + reqEntity.PickUpEquipmentNo, reqEntity, _ptService.PtApplyStockInLoc);
        }

        /// <summary>
        /// 完成任务
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<int> CompleteTask(CompleteTaskRequest reqDto)
        {
            lock (lockerPtCompleteTask)
            {
                var res = new SRes<int>();
                res = _ptService.PtCompleteTask(reqDto);
                //如果是二楼入库，调用下机科的接口
                if (res.Memo3 == "1")
                {
                    //try
                    //{
                    //    var tsk = _ptService.GetTask(reqDto.TaskNum);
                    //    var req = new JKPalletizerRequest()
                    //    {
                    //        wmsNo = "YL01",
                    //        taskId = tsk.ResData.Id.ToString(),
                    //        rfId = tsk.ResData.BarCode,
                    //        rowNo = tsk.ResData.Tunnel,
                    //        palletizerNo = Math.Ceiling(decimal.Parse(tsk.ResData.Tunnel) / 2).ToString()
                    //    };
                    //    _logger.LogInformation("调用机科接口请求：" + JsonConvert.SerializeObject(req));
                    //    var apiurl = wms.util.AppSettings.GetConfig("JKPushUrl");
                    //    var strpost = HttpUtil.PostRequest(apiurl, JsonConvert.SerializeObject(req), 30000, "UTF-8", "application/json");
                    //    _logger.LogInformation("调用机科接口返回：" + strpost);

                    //}
                    //catch (Exception ex)
                    //{
                    //    _logger.LogInformation("调用机科接口异常:" + ex.ToString());
                    //}
                }
                return res;
            }
        }

        /// <summary>
        /// 堆垛机取货完成通知机科
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<int> NoticeToJK(CompleteTaskRequest reqDto)
        {
            lock (lockerPtCompleteTask)
            {
                var res = new SRes<int>();
                try
                {
                    var tsk = _ptService.GetCurTask(reqDto.TaskNum);
                    if (tsk.ResData == null)
                    {
                        tsk.ResData = _mapper.Map<ptWCS_TaskInfo>(_ptService.GetTask(reqDto.TaskNum).ResData);
                    }
                    if (tsk.ResData.Type != TaskType.EnterDepot || tsk.ResData.AddrFrom != "2999")
                    {
                        res.ResMsg = reqDto.TaskNum + "不符合回调任务";
                        return res;
                    }
                    var tasknum = RedisHelper.Get("Pt:NoticeToJK:Tun" + tsk.ResData.Tunnel);
                    if (reqDto.TaskNum.ToString() == tasknum && reqDto.OperationType == 1)
                    {
                        res.ResMsg = tasknum + "重复请求";
                        return res;
                    }

                    var req = new JKPalletizerRequest()
                    {
                        wmsNo = "YL01",
                        taskId = tsk.ResData.ID.ToString(),
                        rfId = tsk.ResData.BarCode,
                        rowNo = tsk.ResData.Tunnel,
                        palletizerNo = Math.Ceiling(decimal.Parse(tsk.ResData.Tunnel) / 2).ToString()
                    };
                    _logger.LogInformation("调用机科接口请求：" + JsonConvert.SerializeObject(req));
                    var apiurl = wms.util.AppSettings.GetConfig("JKPushUrl");
                    var strpost = HttpUtil.PostRequest(apiurl, JsonConvert.SerializeObject(req), 30000, "UTF-8", "application/json");
                    _logger.LogInformation("调用机科接口返回：" + strpost);
                    RedisHelper.Set("Pt:NoticeToJK:Tun" + tsk.ResData.Tunnel, reqDto.TaskNum);
                }
                catch (Exception ex)
                {
                    _logger.LogInformation("调用机科接口异常:" + ex.ToString());
                }
                return res;
            }
        }

        /// <summary>
        /// 堆垛机出库放货完成
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<int> SrmPickOutCompleted(PtSrmPickOutCompletedRequest reqDto)
        {
            lock (lockerPtSrmPickOutCompleted)
            {
                return _ptService.PtSrmPickOutCompleted(reqDto);
            }
        }

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

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

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

        /// <summary>
        /// 架子管理接口，wcs上报agv取货完成信号,清除起始位置
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PinkuInfoManagement(PtSrmPickOutCompletedRequest request)
        {
            return ConcurrencyReqControl<PtSrmPickOutCompletedRequest, SRes>(lockerPinkuInfoUpdate, "PinkuInfoManagement", request.TaskNum.ToString(), request, _ptService.PinkuInfoManagement);
        }

        /// <summary>
        /// 堆垛机入库站台架子搬运任务请求(入库站台到22支架)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PinKuCarryInTask(PinkucarryTaskRequest request)
        {
            lock (lockerProductRequisition)
            {
                return ConcurrencyReqControl<PinkucarryTaskRequest, SRes>(lockerPinkucarryInTask, "PinKuCarryInTask", request.Equip, request, _ptService.PinKuCarryInTask);
            }
        }

        /// <summary>
        /// 堆垛机出库站台架子搬运任务请求（交接区支架到出库口）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PinKuCarryOutTask(PinkucarryTaskRequest request)
        {
            return ConcurrencyReqControl<PinkucarryTaskRequest, SRes>(lockerPinkucarryOutTask, "PinKuCarryOutTask", request.Equip, request, _ptService.PinKuCarryOutTask);
        }

        #endregion WCS调用

        /// <summary>
        /// 生产交接区6个点位的物料编码接收绑定
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ProductMaterInfo(ProductMaterInfoRequest request)
        {
            return ConcurrencyReqControl<ProductMaterInfoRequest, SRes>(lockerPinkucarryOutTask, "ProductMaterInfo", request.Equip, request, _ptService.ProductMaterInfo);
        }

        #region 异常处理功能

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

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

        /// <summary>
        /// 删除条码信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes DeleteBarCodeInfo(DetailCodeStrRequest request)
        {
            lock (lockerDeleteStockInfo)
            {
                return _ptService.DeleteBarCodeInfo(request);
            }
        }

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

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

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

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

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

        #endregion 异常处理功能

        #region 定时器

        /// <summary>
        /// 启用job
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost]
        public string StartJob(AutoDetailRequest req)
        {
            var res = new SRes();
            var sysjob = _ptService.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 = _ptService.GetJobEntityByCode(reqEntity.Code);
            if (jobEntity == null)
            {
                res.ResCode = 0;
                res.ResMsg = "没有找到该编码";
                return res.ToCamelCaseString();
            }
            var jobapilist = _ptService.GetJobapilist(jobEntity.Id);
            if (jobapilist.Any())
            {
                foreach (var item in jobapilist)
                {
                    Task.Run(() => { HttpUtil.PostRequest(item.ApiUrl, item.RequestBody); });
                }
            }
            return res.ToCamelCaseString();
        }

        #endregion 定时器

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

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

        /// <summary>
        /// 分页Job列表
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public List<dto.response.hj.SysJobDto> GetSysJobList(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";
            }
        }

        [HttpPost]
        public SRes HandErrTask(DetailListRequest2Str request)
        {
            lock (lockerHandErrTask)
            {
                foreach (var item in request.IdList)
                {
                    var res = _ptService.HandErrTask(new DetailRequest2Str() { Id = item });
                    if (res.ResCode != 200)
                    {
                        return res;
                    }
                }
                return new SRes();
            }
        }

        /// <summary>
        /// 更新单据状态
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes UpdateDocState(UpdateDocStateReqest req)
        {
            return _ptService.UpdateDocState(req);
        }

        /// <summary>
        /// 修改任务RFID
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes UpdateTaskCont(UpdateTaskContRequest req)
        {
            return _ptService.UpdateTaskCont(req);
        }

        /// <summary>
        /// 修改货位RFID
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes UpdateLocationContGrpBarCode(UpdateLocationContGrpBarCode req)
        {
            return _ptService.UpdateLocationContGrpBarCode(req);
        }

        /// <summary>
        /// 添加组盘信息
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes AddStock(UpdateTaskContRequest req)
        {
            return _ptService.AddStock(req);
        }

        /// <summary>
        /// 机科对接-获取巷道
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost]
        public JKGetTunRes JKGetTun1(JKGetTunRequest req)
        {
            var res = new JKGetTunRes();
            var task = _ptService.GetTaskNum(req.rfId);
            if (task.ResData == 0)
            {
                res.palletizerNo = task.ResMsg;
                return res;
            }
            var tun = GetTunnelPriorityList(new GetTunnelPriorityListRequest() { TaskNum = task.ResData }).ResData.Split(',')[0];
            if (string.IsNullOrEmpty(tun))
            {
                res.palletizerNo = "没有可用的巷道";
                return res;
            }

            res.rowNo = tun;
            res.palletizerNo = Math.Ceiling(decimal.Parse(tun) / 2).ToString();
            return res;
        }

        /// <summary>
        /// 机科对接-获取巷道
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost]
        public JKGetTunResNew JKGetTun(JKGetTunRequest req)
        {
            var res = new JKGetTunResNew() { ListData = new List<JKGetTunRes>() };
            var task = _ptService.GetTaskNum(req.rfId);
            if (task.ResData == 0)
            {
                //res.palletizerNo = task.ResMsg;
                return res;
            }
            var tun = GetTunnelPriorityList(new GetTunnelPriorityListRequest() { TaskNum = task.ResData }).ResData.Split(',');
            if (tun != null && tun.Any())
            {
                foreach (var item in tun)
                {
                    res.ListData.Add(new JKGetTunRes()
                    {
                        rowNo = item,
                        palletizerNo = Math.Ceiling(decimal.Parse(item) / 2).ToString()
                    });
                }
            }

            //res.rowNo = tun;
            //res.palletizerNo = Math.Ceiling(decimal.Parse(tun) / 2).ToString();
            return res;
        }

        /// <summary>
        /// 机科对接-达到二楼取货站台通知
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost]
        public JKPalletizerRes JKArriveInfo(JKArrRequest req)
        {
            lock (lockerJKArriveInfo)
            {
                var res = new JKPalletizerRes();
                var task = _ptService.GetTaskNum(req.rfId);
                if (task.ResData == 0)
                {
                    res.code = 0;
                    res.message = task.ResMsg;
                    return res;
                }
                //更新任务表当前位置
                var curpoint = "";
                var srm = "";
                switch (req.rowNo)
                {
                    case "1":
                        curpoint = "1027";
                        srm = "SRM1";
                        break;

                    case "2":
                        curpoint = "1028";
                        srm = "SRM1";
                        break;

                    case "3":
                        curpoint = "1029";
                        srm = "SRM2";
                        break;

                    case "4":
                        curpoint = "1030";
                        srm = "SRM2";
                        break;

                    case "5":
                        curpoint = "1031";
                        srm = "SRM3";
                        break;

                    case "6":
                        curpoint = "1032";
                        srm = "SRM3";
                        break;

                    case "7":
                        curpoint = "1033";
                        srm = "SRM4";
                        break;

                    case "8":
                        curpoint = "1034";
                        srm = "SRM4";
                        break;
                }
                if (string.IsNullOrEmpty(curpoint))
                {
                    res.code = 0;
                    res.message = "请确认巷道编号传输是否正确";
                    return res;
                }
                _ptService.UpdateTask(task.ResData, curpoint, srm, req.rowNo);
                return res;
            }
        }

        /// <summary>
        /// 机科对接-接收盘条信息接口
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost]
        public JKPalletizerRes JKTransPTInfo(JKTransPTInfo req)
        {
            lock (lockerJKTransPTInfo)
            {
                var res = new JKPalletizerRes();
                var temp = PurchaseBillTrans(new PurchaseBillTransReqest()
                {
                    BillCode = req.BillCode,
                    BillType = req.BillType,
                    Equip = "2999",
                    ReqId = req.ReqId,
                    SupCode = req.SupCode,
                    SupName = req.SupName,
                    WareCode = req.WareCode,
                    ListInfo = new List<ListInfoItem>()
                    {
                       new ListInfoItem()
                       {
                        Batch= req.Batch,
                        BoilerNo = req.BoilerNo,
                        Brand = req.Brand,
                        Carbon = req.Carbon,
                        Describe = req.Describe,
                        ExecStandard = req.ExecStandard,
                        HoldDuration = req.HoldDuration,
                        Licence = req.Licence,
                        MatBarCode = req.MatBarCode,
                        MatCode = req.MatCode,
                        PackNo = req.PackNo,
                        ProductDate = req.ProductDate,
                        RFID = req.RFID,
                        RodBar = req.RodBar,
                        Weight = req.Weight
                       }
                     }
                });
                if (temp.ResCode != 200)
                {
                    res.code = 0;
                    res.message = temp.ResMsg;
                    return res;
                }
                return res;
            }
        }

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