using AutoMapper;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using Org.BouncyCastle.Asn1.Ocsp;
using wms.api.Job;
using wms.dto;
using wms.dto.request;
using wms.dto.request.fj;
using wms.dto.request.cp;
using wms.dto.request.hj;
using wms.dto.request.hj.dto;
using wms.dto.request.share;
using wms.dto.request.sx;
using wms.dto.response;
using wms.dto.response.cp;
using wms.service.IService;
using wms.sqlsugar.model.sx;
using wms.util.Ext;
using wms.util.Http;
using wms.dto.response.sx;
using wms.service.Service;
using Castle.Core.Internal;
using wms.util.Check;
using Autofac.Core;

namespace wms.api.Controllers
{
    [Route("api/[controller]/[action]")]
    [ApiController]
    public class SxController : BaseController
    {
        private readonly ISXService _sxService;
        private readonly ILogger<SxController> _logger;
        private readonly IMapper _mapper;
        private static object lockerCurtainProductionOrder = new object();
        private static object lockerSpoolMaterialInfoTrans = new object();
        private static object lockerCloseWorkOrder = new object();
        private static object lockerSynchronizeBoxStatus = new object();

        private static object lockerlockerStockChange = new object();
        private static object lockerManualBuildStockTrans = new object();
        private static object lockerBomInfoTrans = new object();
        private static object lockerCompleteTask = new object();
        private static object lockerApplyStockInLoc = new object();
        private static object lockerSKUInfoTrans = new object();
        private static object lockerPackInfoTrans = new object();

        private static object lockerTorsChkComplete = new object();
        private static object lockerGetTunnelPriorityList = new object();
        private static object lockerApplyFloor = new object();
        private static object lockerTorsChkStockOut = new object();
        private static object lockerCancelOrComplet = new object();
        private static object lockerCarryTask = new object();
        private static object lockerPalletizingLayerPackStockOut = new object();
        private static object lockerTorsChkValue = new object();
        private static object lockerSrmPickOutCompleted = new object();
        private static object lockerTorsChkFloor = new object();
        private static object lockerPalletizingPatchWheel = new object();
        private static object lockerPalletizingForceknot = new object();
        private static object lockerPalletizinginfobinde = new object();
        private static object lockerCompletePalletizingTask = new object();
        private static object lockerSxMoveTask = new object();
        private static object lockerPalletizingSpcPackStockOut = new object();
        private static object lockerPalletizingSpcPackPreALL = new object();

        private static object lockerPalletizingSpcNotPackStockOut = new object();
        private static object lockerTorsChkStationbinde = new object();
        private static object lockerTorsChkErrorinfo = new object();
        private static object lockerTorsChkinfo = new object();
        private static object lockerPalletizingPackBStockOut = new object();
        private static object lockerSolderErrorStockOut = new object();
        private static object lockerChongraoPackStockOut = 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 lockerUpdatePuchState = new object();
        private static object lockerDataMoveCell = new object();
        private static object lockerTaskRepeatSend = new object();
        private static object lockerUpdateTaskState = new object();
        private static object lockerCancelPreStockinfo = new object();
        private static object lockerErrorDateclearJob = new object();
        private static object lockerFlowDataMoveJob = new object();

        public SxController(ISXService sxService, ILogger<SxController> logger, IMapper mapper) : base(sxService, logger)
        {
            _sxService = sxService;
            _logger = logger;
            _mapper = mapper;
        }

        /// <summary>
        /// 物料主数据推送接口(帘线)
        /// </summary>
        /// <param name="reqBody"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes SyncMaterInfoListForLX(SxSyncMaterInfoListRequest reqBody)
        {
            var res = new SRes();
            if (reqBody.ListInfo == null || !reqBody.ListInfo.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.DocDetailNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DocDetailNotExist.GetDescription();
                RedisHelper.Set("Sx:WMSErrorInfo:MESEquip3", new RedisErrorInfo() { Equip = "MESEquip3", Con = "MES推送物料主数据时" + ResponseStatusCodeEnum.DocDetailNotExist.GetDescription(), Time = DateTime.Now });
                return res;
            }
            try
            {
                HttpUtil.PostRequest("http://10.30.44.4:8066/api/Fj/SyncMaterInfoListForLX", JsonConvert.SerializeObject(reqBody), 30000, "UTF-8", "application/json");
            }
            catch (Exception ex)
            {
                _logger.LogInformation("物料主数据推送接口(帘线)异常:" + ex.ToString());
            }
            _sxService.SyncMaterInfo(reqBody.ListInfo);

            return res;
        }

        /// <summary>
        /// 帘线生产工单信息传输接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes CurtainProductionOrder(CurtainProductionOrderRequest reqDto)
        {
            lock (lockerCurtainProductionOrder)
            {
                return _sxService.CurtainProductionOrder(reqDto);
            }
            //return ConcurrencyReqControl<CurtainProductionOrderRequest, SRes>(lockerCurtainProductionOrder, "CurtainProductionOrder", reqDto.BillCode, reqDto, _sxService.CurtainProductionOrder);
        }

        /// <summary>
        /// 帘线工字轮信息传输接口(mes调用)
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost(Name = "SpoolMaterialInfoTrans")]
        public SRes SpoolMaterialInfoTrans(SxSpoolMaterialInfoTransRequest reqDto)
        {
            lock (lockerSpoolMaterialInfoTrans)
            {
                return _sxService.SpoolMaterialInfoTrans(reqDto);
            }
            //return ConcurrencyReqControl<SxSpoolMaterialInfoTransRequest, SRes>(lockerSpoolMaterialInfoTrans, "SxSpoolMaterialInfoTrans", reqDto.SpoolCode, reqDto, _sxService.SpoolMaterialInfoTrans);
        }

        /// <summary>
        /// 关闭工单
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost(Name = "CloseWorkOrder")]
        public SRes CloseWorkOrder(CloseWorkOrderRequest reqDto)
        {
            lock (lockerCloseWorkOrder)
            {
                return _sxService.CloseWorkOrder(reqDto);
            }
            //return ConcurrencyReqControl<SxSpoolMaterialInfoTransRequest, SRes>(lockerSpoolMaterialInfoTrans, "SxSpoolMaterialInfoTrans", reqDto.SpoolCode, reqDto, _sxService.SpoolMaterialInfoTrans);
        }

        /// <summary>
        /// 同步箱号状态
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost(Name = "SynchronizeBoxStatus")]
        public SRes SynchronizeBoxStatus(SynchronizeBoxStatusRequest reqDto)
        {
            lock (lockerSynchronizeBoxStatus)
            {
                return _sxService.SynchronizeBoxStatus(reqDto);
            }
        }

        /// <summary>
        /// SKU信息传输接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost(Name = "SKUInfoTrans")]
        public SRes SKUInfoTrans(SKUInfoTransRequest reqDto)
        {
            return ConcurrencyReqControl<SKUInfoTransRequest, SRes>(lockerSKUInfoTrans, "SKUInfoTrans", reqDto.SkuCode, reqDto, _sxService.SKUInfoTrans);
        }

        /// <summary>
        /// 包装信息传输接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost(Name = "PackInfoTrans")]
        public SRes PackInfoTrans(PackInfoTrans reqDto)
        {
            return ConcurrencyReqControl<PackInfoTrans, SRes>(lockerPackInfoTrans, "SKUInfoTrans", reqDto.PackCode, reqDto, _sxService.PackInfoTrans);
        }

        /// <summary>
        /// 扭转出库完成
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<int> TorsChkComplete(TorsChkCompleteRequest request)
        {
            return ConcurrencyReqControl<TorsChkCompleteRequest, SRes<int>>(lockerTorsChkComplete, "TorsChkComplete", request.TaskNo, request, _sxService.TorsChkComplete);
        }

        /// <summary>
        /// 扭转入库分配楼层接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<int> TorsChkFloor(TorsChkFloorRequest reqDto)
        {
            lock (lockerTorsChkFloor)
            {
                return _sxService.TorsChkFloor(reqDto);
            }
        }

        /// <summary>
        /// 扭转出库申请
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes TorsChkStockOut(TorsChkStockOutRequest request)
        {
            return ConcurrencyReqControl<TorsChkStockOutRequest, SRes>(lockerTorsChkStockOut, "TorsChkStockOut", request.Equip, request, _sxService.TorsChkStockOut);
        }

        /// <summary>
        /// 接收扭转值
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes TorsChkValue(TorsChkValueRequest request)
        {
            lock (lockerTorsChkValue)
            {
                return _sxService.TorsChkValue(request);
            }
        }

        /// <summary>
        /// 扭转工位产品绑定接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes TorsChkStationbinde(TorsChkStationbindeRequest request)
        {
            lock (lockerTorsChkStationbinde)
            {
                return _sxService.TorsChkStationbinde(request);
            }
        }

        /// <summary>
        /// 扭转异常信息上传
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes TorsChkErrorinfo(TorsChkErrorinfoRequest request)
        {
            lock (lockerTorsChkErrorinfo)
            {
                return _sxService.TorsChkErrorinfo(request);
            }
        }

        /// <summary>
        /// 扭转获取基础信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public TorsChkResponse GetTorsChkinfo(GetTorsChkinfoRequest request)
        {
            lock (lockerTorsChkinfo)
            {
                return _sxService.GetTorsChkinfo(request);
            }
        }

        [HttpPost]
        public SRes CellInfo(string code)
        {
            return _sxService.CellInfo(code);
        }

        /// <summary>
        /// 码垛层配装箱
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletizingLayerPackStockOut(PalletizingPackStockOutRequest request)
        {
            return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerPalletizingLayerPackStockOut, "PalletizingLayerPackStockOut", request.Equip, request, _sxService.PalletizingLayerPackStockOut);
        }

        /// <summary>
        /// 码垛SPC非控制装箱(缓存托盘)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletizingSpcNotPackStockOut2(PalletizingPackStockOutRequest request)
        {
            lock (lockerPalletizingSpcPackStockOut)
            {
                return _sxService.PalletizingSpcNotPackStockOut2(request);
            }
            //return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerPalletizingSpcPackStockOut, "PalletizingSpcPackStockOut", request.Equip, request, _sxService.PalletizingSpcNotPackStockOut);
        }

        /// <summary>
        /// 码垛SPC控制装箱(缓存托盘)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletizingSpcPackStockOut2(PalletizingPackStockOutRequest request)
        {
            lock (lockerPalletizingSpcPackStockOut)
            {
                return _sxService.PalletizingSpcPackStockOut2(request);
            }
            //return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerPalletizingSpcPackStockOut, "PalletizingSpcPackStockOut", request.Equip, request, _sxService.PalletizingSpcPackStockOut);
        }

        /// <summary>
        /// 码垛SPC装箱（控制非控制一起执行）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletizingSpcPackStockOutALL(PalletizingPackStockOutRequest request)
        {
            lock (lockerPalletizingSpcPackStockOut)
            {
                var timesign = IdFactory.NewId();

                var temp3 = _sxService.PalletizingPackBStockOut(request);

                //var temp1 = _sxService.PalletizingSpcPackStockOut3(request);//控制箱根据新逻辑已经合并到非控制箱中

                var temp2 = _sxService.PalletizingSpcNotPackStockOut3(request);

                temp2.ResMsg = "非控制箱执行结果:" + temp2.ResMsg + "；B质量码垛：" + temp3.ResMsg;
                return temp2;
            }
            //return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerPalletizingSpcPackStockOut, "PalletizingSpcPackStockOut", request.Equip, request, _sxService.PalletizingSpcPackStockOut);
        }

        /// <summary>
        /// 码垛SPC装箱库存程序
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletizingSpcPackRulePreAll(PalletizingPackStockOutRequest request)
        {
            lock (lockerPalletizingSpcPackPreALL)
            {
                //var temp1 = _sxService.PalletizingSpcPackRulePre(request);
                //var temp2 = _sxService.PalletizingSpcNotPackRulePre(request);//控制箱根据新逻辑已经合并到非控制箱中
                var temp2 = _sxService.PalletizingSpcNotPackRulePre2(request);
                temp2.ResMsg = "非控制箱预占库存执行结果:" + temp2.ResMsg; //+ ";控制箱预占库存执行结果："+ temp1.ResMsg;
                return temp2;
            }
            //return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerPalletizingSpcPackStockOut, "PalletizingSpcPackStockOut", request.Equip, request, _sxService.PalletizingSpcPackStockOut);
        }

        /// <summary>
        ///  码垛SPC非控制装箱计算预占箱号-去掉黑盘和批次限制
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletizingSpcNotPackRulePre2(PalletizingPackStockOutRequest request)
        {
            lock (lockerPalletizingSpcPackPreALL)
            {
                var temp2 = _sxService.PalletizingSpcNotPackRulePre2(request);
                temp2.ResMsg = "非控制箱预占库存执行结果:" + temp2.ResMsg;
                return temp2;
            }
            //return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerPalletizingSpcPackStockOut, "PalletizingSpcPackStockOut", request.Equip, request, _sxService.PalletizingSpcPackStockOut);
        }

        /// <summary>
        /// 码垛SPC装箱控制预占库存程序
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletizingSpcNotPackRulePre(PalletizingPackStockOutRequest request)
        {
            lock (lockerPalletizingSpcPackPreALL)
            {
                var temp2 = _sxService.PalletizingSpcNotPackRulePre(request);
                return temp2;
            }
            //return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerPalletizingSpcPackStockOut, "PalletizingSpcPackStockOut", request.Equip, request, _sxService.PalletizingSpcPackStockOut);
        }

        /// <summary>
        /// 码垛SPC装箱控制预占库存程序
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletizingSpcPackRulePre(PalletizingPackStockOutRequest request)
        {
            lock (lockerPalletizingSpcPackPreALL)
            {
                var temp2 = _sxService.PalletizingSpcPackRulePre(request);
                return temp2;
            }
            //return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerPalletizingSpcPackStockOut, "PalletizingSpcPackStockOut", request.Equip, request, _sxService.PalletizingSpcPackStockOut);
        }

        /// <summary>
        /// 码垛SPC非控制箱出预占库存
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletizingSpcNotPackStockOut3(PalletizingPackStockOutRequest request)
        {
            lock (lockerPalletizingSpcPackPreALL)
            {
                var temp2 = _sxService.PalletizingSpcNotPackStockOut3(request);
                return temp2;
            }
            //return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerPalletizingSpcPackStockOut, "PalletizingSpcPackStockOut", request.Equip, request, _sxService.PalletizingSpcPackStockOut);
        }

        /// <summary>
        /// 码垛SPC控制箱出预占库存
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletizingSpcPackStockOut3(PalletizingPackStockOutRequest request)
        {
            lock (lockerPalletizingSpcPackPreALL)
            {
                var temp2 = _sxService.PalletizingSpcPackStockOut3(request);
                return temp2;
            }
            //return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerPalletizingSpcPackStockOut, "PalletizingSpcPackStockOut", request.Equip, request, _sxService.PalletizingSpcPackStockOut);
        }

        /// <summary>
        /// B质量码垛装箱
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletizingPackBStockOut(PalletizingPackStockOutRequest request)
        {
            lock (lockerPalletizingSpcPackStockOut)
            {
                return _sxService.PalletizingPackBStockOut(request);
            }
            //return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerPalletizingPackBStockOut, "PalletizingPackBStockOut", request.Equip, request, _sxService.PalletizingPackBStockOut);
        }

        /// <summary>
        /// 重绕盘超时装箱码垛
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ChongraoPackStockOut(PalletizingPackStockOutRequest request)
        {
            lock (lockerPalletizingSpcPackStockOut)
            {
                return _sxService.ChongraoPackStockOut(request);
            }
        }

        /// <summary>
        /// 焊点不符合异常排出
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes SolderErrorStockOut(PalletizingPackStockOutRequest request)
        {
            return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerSolderErrorStockOut, "SolderErrorStockOut", request.Equip, request, _sxService.SolderErrorStockOut);
        }

        /// <summary>
        /// 特殊码垛出库(超时)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes SpecialStockOut(PalletizingPackStockOutRequest request)
        {
            lock (lockerPalletizingSpcPackStockOut)
            {
                return _sxService.SpecialStockOut(request);
            }
            //return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerPalletizingSpcPackStockOut, "PalletizingSpcPackStockOut", request.Equip, request, _sxService.SpecialStockOut);
        }

        /// <summary>
        /// 手动码垛
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ManualPalletizingStockOut(ManualPalletizingStockOutRequest request)
        {
            lock (lockerPalletizingSpcPackStockOut)
            {
                return _sxService.ManualPalletizingStockOut(request);
            }
            //return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerPalletizingSpcPackStockOut, "PalletizingSpcPackStockOut", request.Equip, request, _sxService.SpecialStockOut);
        }

        /// <summary>
        /// C级品码垛出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes CGrageStockOut(PalletizingPackStockOutRequest request)
        {
            lock (lockerPalletizingSpcPackStockOut)
            {
                return _sxService.CGrageStockOut(request);
            }
        }

        /// <summary>
        /// 清理库存 （码垛）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes OnePackStock(PalletizingPackStockOutRequest request)
        {
            return ConcurrencyReqControl<PalletizingPackStockOutRequest, SRes>(lockerPalletizingSpcPackStockOut, "PalletizingSpcPackStockOut", request.Equip, request, _sxService.OnePackStock);
        }

        /// <summary>
        /// 完成码垛任务（自动入库）
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<int> CompletePalletizingTask(SxPalletizingCompleteRequest reqDto)
        {
            lock (lockerCompletePalletizingTask)
            {
                return _sxService.CompletePalletizingTask(reqDto);
            }
        }

        /// <summary>
        /// 码垛补工字轮接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletizingPatchWheel(PalletizingPatchWheelRequest request)
        {
            return ConcurrencyReqControl<PalletizingPatchWheelRequest, SRes>(lockerPalletizingPatchWheel, "PalletizingPatchWheel", request.Equip, request, _sxService.PalletizingPatchWheel);
        }

        /// <summary>
        /// 码垛强制结盘
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes PalletizingForceknot(PalletizingForceknotRequest request)
        {
            lock (lockerPalletizingForceknot)
            {
                return _sxService.PalletizingForceknot(request);
            }
        }

        /// <summary>
        /// 码垛信息绑定（抓取完成）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes Palletizinginfobinde(PalletizinginfobindeRequest request)
        {
            lock (lockerPalletizinginfobinde)
            {
                return _sxService.Palletizinginfobinde(request);
            }
        }

        /// <summary>
        /// 手动出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ManualTask(DetailCodeStrdtoRequest request)
        {
            lock (lockerSKUInfoTrans)
            {
                return _sxService.Manaler(request);
            }
        }

        /// <summary>
        /// 手动出库（mes调用）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes MesManualTask(MesManualTaskRequest request)
        {
            lock (lockerSKUInfoTrans)
            {
                var cell = _sxService.GetLocationInfo(new DetailCodeRequest() { Code = request.BarCode });
                if (string.IsNullOrEmpty(cell.ResData))
                {
                    return new SRes()
                    {
                        ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode(),
                        ResMsg = "该条码不在时效库中" + request.BarCode
                    };
                }
                var newreq = new DetailCodeStrdtoRequest()
                {
                    Location = new List<string>() { cell.ResData },
                    EndPoint = 5,
                    User = request.User
                };
                return _sxService.Manaler(newreq);
            }
        }

        /// <summary>
        /// CD级品自动出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes CGradeAutoTask(DetailCodeStrdtoRequest request)
        {
            var list = _sxService.GetCGradeList();
            if (list.ResDataList.Any())
            {
                return ManualTask(new DetailCodeStrdtoRequest() { Location = new List<string>() { list.ResDataList.First() }, EndPoint = 5, User = "WMS自动触发CD排出" });
            }
            return null;
        }

        /// <summary>
        /// B质量超时自动出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes BGradeTimeOutAutoTask(DetailCodeStrdtoRequest request)
        {
            var list = _sxService.GetBGradeTimeOutList();
            if (list.ResDataList.Any())
            {
                return ManualTask(new DetailCodeStrdtoRequest() { Location = new List<string>() { list.ResDataList.First() }, EndPoint = 5, User = "B质量超时自动排出" });
            }
            return null;
        }

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

        /// <summary>
        /// 分配楼层(扫码分配)
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost(Name = "ApplyFloor")]
        public SRes<ApplyFloorResponse> ApplyFloor(ApplyFloorRequest reqDto)
        {
            lock (lockerApplyFloor)
            {
                var res = _sxService.ApplyFloor(reqDto);
                if (res.ResCode == ResponseStatusCodeEnum.StockNotExist.GetHashCode() || res.ResCode == ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode())//组盘数据不存在时，主动从mes同步一下
                {
                    try
                    {
                        _logger.LogInformation("触发主动拉取工字轮信息:" + reqDto.Code);
                        ApplyHunrRequest push = new ApplyHunrRequest() { SpoolNr = reqDto.Code };
                        var str = WmsServiceExportApi(push);
                        _logger.LogInformation("触发主动拉取工字轮返回:" + str);
                        var spoolMaterialInfo = JsonConvert.DeserializeObject<SxSpoolMaterialInfoTransRequest>(str);
                        if (!string.IsNullOrEmpty(spoolMaterialInfo.SpoolCode))
                        {
                            var temp = SpoolMaterialInfoTrans(spoolMaterialInfo);
                            if (temp.ResCode == 200)
                            {
                                res = _sxService.ApplyFloor(reqDto);
                            }
                            else
                            {
                                _logger.LogInformation("SpoolMaterialInfoTrans返回报错:" + temp.ResMsg + ",工字轮" + reqDto.Code);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.LogInformation("触发主动拉取工字轮信息异常" + reqDto.Code);
                    }
                }
                return res;
            }
        }

        /// <summary>
        /// 获取巷道
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<string> GetTunnelPriorityList(GetSxTunnelPriorityListRequest reqEntity)
        {
            lock (lockerGetTunnelPriorityList)
            {
                //如果不存在任务，则拉取一下条码信息（环线下面异常口回库情况）
                if (!_sxService.IsExistTask(new DetailCodeRequest() { Code = reqEntity.Code }).ResData)
                {
                    DataBasePatch2(new DataBasePatchRequest() { Code = reqEntity.Code });
                }
                //先判断有没有条码信息
                return _sxService.GetTunnelPriorityList(reqEntity);
            }
        }

        /// <summary>
        /// 分配货位
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<List<dto.response.hj.ApplyStockInLocResponse>> ApplyStockInLoc(SxApplyStockInLocRequest reqEntity)
        {
            return ConcurrencyReqControl<SxApplyStockInLocRequest, SRes<List<dto.response.hj.ApplyStockInLocResponse>>>(lockerApplyStockInLoc, "SxApplyStockInLoc" + reqEntity.TunnelNum + reqEntity.Floor, "分配货位" + reqEntity.TunnelNum + reqEntity.Floor, reqEntity, _sxService.ApplyStockInLoc);
        }

        /// <summary>
        /// 完成出库任务
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<int> CompleteTask(SxCompleteTaskRequest reqDto)
        {
            lock (lockerCompleteTask)
            {
                return _sxService.CompleteTask(reqDto);
            }
        }

        /// <summary>
        /// 堆垛机完成
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<int> SrmCompleted(SxCompleteTaskRequest reqDto)
        {
            lock (lockerSrmPickOutCompleted)
            {
                return _sxService.SrmCompleted(reqDto);
            }
        }

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

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

        [HttpPost]
        public SRes CancelTaskInfo(CancelTaskRequest request)
        {
            lock (lockerCarryTask)
            {
                var verifyres = _sxService.CancelTaskVerify(request);
                if (verifyres.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                {
                    return verifyres;
                }
                foreach (var item in request.TaskNo)
                {
                    var calres = _sxService.CancelTask(new CompleteTaskRequest() { TaskNum = item, WCSUpdateName = "wms" });
                    if (calres.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        return calres;
                    }
                    var forres = _sxService.ForceCancelTask(new ErrorTaskRequest() { TaskNo = item.ToString(), WareHouse = Const.SxWareHouse });
                    if (forres.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        return calres;
                    }
                }
                return new SRes();
            }
        }

        /// <summary>
        /// 帘线工字轮入库反馈接口
        /// </summary>
        /// <param name="billcode"></param>
        /// <returns></returns>
        [HttpPost(Name = "CurtainLineStockInFeedBack")]
        public PushResponse CurtainLineStockInFeedBack(PushDate request)
        {
            var result = new PushResponse();

            request.Type = SxFackbeekType.InterfaceType_SX_CurtainStockIn.ToString();
            var list = _sxService.GetPushDatelistAuto(request);
            if (!list.Any())
            {
                return new PushResponse() { ResCode = ResponseStatusCodeEnum.NoResult.GetHashCode(), ResMsg = ResponseStatusCodeEnum.NoResult.GetDescription() };
            }

            if (list.Where(p => p.TypeCode == SxFackbeekType.InterfaceType_SX_CurtainStockIn.ToString()).ToList().Any())
            {
                var onefloor = list.Where(p => p.TypeCode == SxFackbeekType.InterfaceType_SX_CurtainStockIn.ToString()).ToList();
                SpoolPushRequest push = new SpoolPushRequest();
                var info = _mapper.Map<List<ListInfo>>(onefloor);
                push.list = info;
                push.STORE_CODE = "sxhouse";
                push.STORE_NAME = "时效立库";
                WmsServiceExportApiMq(push);
                var ids = onefloor.Select(p => p.Id).ToList();
                _sxService.UpdatePushModelColumns(new sqlsugar.model.UpdateModelColumns<BillPushinfo>()
                {
                    Columns = it => new BillPushinfo { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                    WhereExpression = it => ids.Contains(it.Id)
                });
            }
            return result;
        }

        /// <summary>
        /// 时效库出库装箱工字轮信息反馈接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public PushResponse EnchaseStockOutFeedBack(PushDate request)
        {
            var res = new PushResponse();

            request.Type = SxFackbeekType.InterfaceType_SX_CurtainStockOut.ToString();
            var list = _sxService.GetPushDatelistAuto(request);
            ////if (!list.Any())
            ////{
            ////    return new PushResponse() { ResCode = ResponseStatusCodeEnum.NoResult.GetHashCode(), ResMsg = ResponseStatusCodeEnum.NoResult.GetDescription() };
            ////}

            if (list.Where(p => p.TypeCode == SxFackbeekType.InterfaceType_SX_CurtainStockOut.ToString()).ToList().Any())
            {
                var onefloor = list.Where(p => p.TypeCode == SxFackbeekType.InterfaceType_SX_CurtainStockOut.ToString()).ToList();
                SXProductStockInFeedBackRequest push = new SXProductStockInFeedBackRequest();
                var info = _mapper.Map<List<SXProductStockInFeedBackRequestItem>>(onefloor);
                push.ListInfo = info;
                push.WareCode = onefloor.FirstOrDefault().WarehouseCode;
                push.WareName = "时效库";
                push.Type = "1";
                var resbody = JsonConvert.DeserializeObject<PushResponse>(WmsServiceExportApiMq(push));
                var ids = onefloor.Select(p => p.Id).ToList();
                //if (resbody.success == true)
                //{
                _sxService.UpdatePushModelColumns(new sqlsugar.model.UpdateModelColumns<BillPushinfo>()
                {
                    Columns = it => new BillPushinfo { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                    WhereExpression = it => ids.Contains(it.Id)
                });
                //}
                //else
                //{
                //    _sxService.UpdatePushModelColumns(new sqlsugar.model.UpdateModelColumns<BillPushinfo>()
                //    {
                //        Columns = it => new BillPushinfo { PostResult = 2, PostQty = it.PostQty + 1, EditTime = DateTime.Now },
                //        WhereExpression = it => ids.Contains(it.Id)
                //    });
                //}
            }

            request.Type = SxFackbeekType.InterfaceType_SX_ErrorStockOut.ToString();
            var list1 = _sxService.GetPushDatelistAuto(request);
            ////if (!list.Any())
            ////{
            ////    return new PushResponse() { ResCode = ResponseStatusCodeEnum.NoResult.GetHashCode(), ResMsg = ResponseStatusCodeEnum.NoResult.GetDescription() };
            ////}

            if (list1.Where(p => p.TypeCode == SxFackbeekType.InterfaceType_SX_ErrorStockOut.ToString()).ToList().Any())
            {
                var onefloor = list1.Where(p => p.TypeCode == SxFackbeekType.InterfaceType_SX_ErrorStockOut.ToString()).ToList();
                SXProductStockInFeedBackRequest push = new SXProductStockInFeedBackRequest();
                var info = _mapper.Map<List<SXProductStockInFeedBackRequestItem>>(onefloor);
                push.ListInfo = info;
                push.WareCode = onefloor.FirstOrDefault().WarehouseCode;
                push.WareName = "时效库";
                push.Type = "2";
                var resbody = JsonConvert.DeserializeObject<PushResponse>(WmsServiceExportApiMq(push));
                var ids = onefloor.Select(p => p.Id).ToList();
                //if (resbody.success == true)
                //{
                _sxService.UpdatePushModelColumns(new sqlsugar.model.UpdateModelColumns<BillPushinfo>()
                {
                    Columns = it => new BillPushinfo { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                    WhereExpression = it => ids.Contains(it.Id)
                });
                //}
                //else
                //{
                //    _sxService.UpdatePushModelColumns(new sqlsugar.model.UpdateModelColumns<BillPushinfo>()
                //    {
                //        Columns = it => new BillPushinfo { PostResult = 2, PostQty = it.PostQty + 1, EditTime = DateTime.Now },
                //        WhereExpression = it => ids.Contains(it.Id)
                //    });
                //}
            }

            return res;
        }

        /// <summary>
        /// 工字轮装箱位置信息上传接口
        /// </summary>
        /// <param name="billcode"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes EnchaseCoordPosFeedBack(string doccode)
        {
            //var list = _sxService.GetBillFeedbackList(p => p.BillCode == doccode);
            //var dtolist = _mapper.Map<List<EnchaseCoordPosFeedBackRequestItem>>(list);
            //var dto = new EnchaseCoordPosFeedBackRequest() { ListInfo = dtolist };
            //SRes resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(dto));
            //return resbody;
            return null;
        }

        /// <summary>
        /// 库存改判
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes StockChange(SxStockChangeRequest reqDto)
        {
            lock (lockerlockerStockChange)
            {
                return _sxService.StockChange(reqDto);
            }
            //return ConcurrencyReqControl<SxStockChangeRequest, SRes>(lockerlockerStockChange, "SxStockChange", reqDto.BillCode, reqDto, _sxService.StockChange);
        }

        /// <summary>
        /// 改判反馈接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes StockChangeFeedBack(string doccode)
        {
            //var list = _sxService.GetBillFeedbackList(p => p.BillCode == doccode);
            //var dtolist = _mapper.Map<List<StockChangeFeedBackRequestItem>>(list);
            //var dto = new StockChangeFeedBackRequest() { ListInfo = dtolist };
            //SRes resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(dto));
            //return resbody;
            return null;
        }

        /// <summary>
        /// 实时库存查询接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public CurStockListResponse GetCurStockList(CurStockListRequest request)
        {
            return _sxService.GetCurStockList(request);
        }

        /// <summary>
        /// 移库货位上报MES接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes MoveStockLocationFeedBack(PushDate request)
        {
            var res = new PushResponse();
            request.Type = SxFackbeekType.InterfaceType_SX_CellMove.ToString();
            var list = _sxService.GetPushDatelistAuto(request);
            if (!list.Any())
            {
                return new PushResponse() { ResCode = ResponseStatusCodeEnum.NoResult.GetHashCode(), ResMsg = ResponseStatusCodeEnum.NoResult.GetDescription() };
            }
            var onefloor = list.Where(p => p.TypeCode == SxFackbeekType.InterfaceType_SX_CellMove.ToString()).ToList();
            dto.request.sx.MoveStockLocationFeedBackRequest push = new dto.request.sx.MoveStockLocationFeedBackRequest();
            var info = _mapper.Map<List<MoveStockLocationFeedBackRequestItem>>(onefloor);
            push.ListInfo = info;
            push.WareCode = onefloor.FirstOrDefault().WarehouseCode;
            var resbody = JsonConvert.DeserializeObject<PushResponse>(WmsServiceExportApi(push));
            var ids = onefloor.Select(p => p.Id).ToList();
            if (resbody.success == true)
            {
                _sxService.UpdatePushModelColumns(new sqlsugar.model.UpdateModelColumns<BillPushinfo>()
                {
                    Columns = it => new BillPushinfo { PostResult = 1, PostQty = it.PostQty + 1, ResDesc = "自动推送", EditTime = DateTime.Now },
                    WhereExpression = it => ids.Contains(it.Id)
                });
            }
            else
            {
                _sxService.UpdatePushModelColumns(new sqlsugar.model.UpdateModelColumns<BillPushinfo>()
                {
                    Columns = it => new BillPushinfo { PostResult = 2, PostQty = it.PostQty + 1, EditTime = DateTime.Now },
                    WhereExpression = it => ids.Contains(it.Id)
                });
            }
            return res;
        }

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

        [HttpPost]
        public string StartJob(AutoDetailRequest req)
        {
            var res = new SRes();
            var sysjob = _sxService.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();
        }

        [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 = _sxService.GetJobEntityByCode(reqEntity.Code);
            if (jobEntity == null)
            {
                res.ResCode = 0;
                res.ResMsg = "没有找到该编码";
                return res.ToCamelCaseString();
            }
            var jobapilist = _sxService.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 = _sxService.GetJobList();
            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 = _sxService.GetJobEntityByCode(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";
            }
        }

        /// <summary>
        /// 异常信息传输接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes GetMesErrorInfo(SxErrorinfoRequest request)
        {
            return _sxService.GetMesErrorInfo(request);
        }

        /// <summary>
        /// 更新箱号
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes UpdateBoxNo(UpdateBoxNoRequest request)
        {
            return _sxService.UpdateBoxNo(request);
        }

        /// <summary>
        /// 更新黑盘数量(MES调用)
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes UpdateBlackCount(UpdateBlackCountReq request)
        {
            return _sxService.UpdateBlackCount(request);
        }

        /// <summary>
        /// 更新箱号
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes test(UpdateBoxNoRequest request)
        {
            return null; ;
        }

        #region 异常处理

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

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

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

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

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

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

        /// <summary>
        /// 补数据（异常排出口回库使用）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes DataBasePatch2(DataBasePatchRequest request)
        {
            lock (lockerDataBasePatch)
            {
                ApplyHunrRequest push = new ApplyHunrRequest() { SpoolNr = request.Code };
                var spoolMaterialInfo = JsonConvert.DeserializeObject<SxSpoolMaterialInfoTransRequest>(WmsServiceExportApi(push));
                if (!string.IsNullOrEmpty(spoolMaterialInfo.SpoolCode))
                {
                    var temp = SpoolMaterialInfoTrans(spoolMaterialInfo);
                    if (temp.ResCode == 200)
                    {
                        return _sxService.DataBasePatch2(request);
                    }
                    else
                    {
                        return temp;
                    }
                }
                return null;
            }
        }

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

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

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

        /// <summary>
        /// 机器人任务重复下发
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes TaskRepeatSend(TaskRepeatRequest request)
        {
            lock (lockerTaskRepeatSend)
            {
                return _sxService.TaskRepeatSend(request);
            }
        }

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

        /// <summary>
        /// 取消预锁库存（用于出库）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes CancelPreStockinfo(CancelPreStockinfoRequest request)
        {
            lock (lockerCancelPreStockinfo)
            {
                return _sxService.CancelPreStockinfo(request);
            }
        }

        /// <summary>
        /// 获取扭转值范围
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<GetTorsRangeRes> GetTorsRange(DetailCodeRequest request)
        {
            return _sxService.GetTorsRange(request);
        }

        /// <summary>
        /// 删除扭转绑定信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes DeleteTorsBind(DetailCodeStrRequest request)
        {
            lock (lockerDeleteStockInfo)
            {
                return _sxService.DeleteTorsBind(request);
            }
        }

        /// <summary>
        /// 解锁工字轮锁定
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes DeleteHwPre(DetailCodeStrRequest request)
        {
            lock (lockerDeleteStockInfo)
            {
                return _sxService.DeleteHwPre(request);
            }
        }

        [HttpPost]
        public SRes test1()
        {
            var sysconfcon = int.Parse(_sxService.GetSysConfigByCode("TaskRemoveHours").SContent) * (-1);

            return new SRes() { ResMsg = sysconfcon.ToString() };
        }

        #endregion 异常处理

        [HttpPost]
        public SRes ErrorDateclearJob()
        {
            lock (lockerErrorDateclearJob)
            {
                return _sxService.ErrorDateclearJob();
            }
        }

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

        //public SRes<List<SBoxInfoRes>> GetSBoxInfoResList()
        //{
        //    var res = new SRes<List<SBoxInfoRes>>() { ResDataList = new List<List<SBoxInfoRes>>() };

        //    return res;
        //}
    }
}