wms / wms_NouYaWmsN5 · Files

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.Xml;
using System.Linq;
using Infrastructure;
using WebRepository;
using ServiceReference1;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Information;

namespace WebApp
{
    /// <summary>
    /// 堆垛机运行节点接口App
    /// </summary>

    public partial class IStackerStatusApp : ApiApp
    {
        public IRepository<ReceiptHeader> _apprh;
        public IRepository<Container> _appc;
        public IRepository<ReceiptDetail> _apprd;
        public IRepository<Inventory> _appi;
        private object obj = new object();
        public IStackerStatusApp(IUnitWork unitWork, IRepository<Inventory> inventory, IRepository<Container> Container, IAuth auth, BaseDBContext context, IRepository<ReceiptDetail> receiptDetail, IRepository<ReceiptHeader> receiptHeader) : base(unitWork, auth, context)
        {
            _apprd = receiptDetail;
            _apprh = receiptHeader;
            _appi = inventory;
            _appc = Container;

            //系统字段赋值
            _apprd._loginInfo = _apprh._loginInfo = _loginInfo;
            _appi._loginInfo = _apprh._loginInfo = _loginInfo;
            _appc._loginInfo = _apprh._loginInfo = _loginInfo;
        }

        public Response<TaskDetail> SetStackerStatus(STKStatusModel sTKStatusModel)
        {
            using (var tran = _context.Database.BeginTransaction())
            {
                Response<TaskDetail> Response = new Response<TaskDetail>();
                try
                {
                    TaskDetail td = null;
                    if (sTKStatusModel.Status == 30)
                    {
                        td = _unitWork.FindSingle<TaskDetail>(u => u.TaskNo == sTKStatusModel.TaskNo && u.Status >= TaskStatus.新建任务 && u.Status < TaskStatus.已经完成);
                    }
                    else if (sTKStatusModel.Status == 40)
                    {
                        td = _unitWork.FindSingle<TaskDetail>(u => u.TaskNo == sTKStatusModel.TaskNo && u.Status >= TaskStatus.新建任务 && u.Status < TaskStatus.已经完成);
                    }
                    //WCS回库 货物到Rgv上给一次反馈站台占用解除
                    else if (sTKStatusModel.Status == 10)
                    {
                        td = _unitWork.FindSingle<TaskDetail>(u => u.TaskNo == sTKStatusModel.TaskNo && u.Status >= TaskStatus.新建任务 && u.Status < TaskStatus.已经完成);
                        Station stationType = _unitWork.Find<Station>(n => n.Code == td.SourceLocation).FirstOrDefault();
                        if (td == null)
                        {
                            td.UpdateTime = DateTime.Now;
                            td.Error = "任务重发，任务号：" + sTKStatusModel.TaskNo;
                            _unitWork.Update(td);
                            Response.Message = "重发";
                            return Response;
                        }
                        if (stationType != null)
                        {
                            if (stationType.Type == StationType.PP片上胶站台)
                            {
                                Station stationEmpty = (from se in _unitWork.Find<Station>(n => n.IsEmpty == 1 && n.IsStop == 0 && n.Containercode != "")
                                                        join sts in _unitWork.Find<StationToStation>(a => a.EndStation == td.SourceLocation)
                                                        on se.Code equals sts.StartStation
                                                        select se).FirstOrDefault();
                                if (stationEmpty != null)
                                {
                                    stationEmpty.Containercode = "";
                                    stationEmpty.UpdateBy = "wms";
                                    stationEmpty.UpdateTime = DateTime.Now;
                                    _unitWork.Update(stationEmpty);
                                }
                            }
                        }
                        if (td.TaskType == TaskType.移库)
                        {
                            Location loc = _unitWork.Find<Location>(n => n.Code == td.SourceLocation && n.Status == LocationStatus.任务锁定中).FirstOrDefault();
                            if (loc == null)
                            {
                                Response.Code = 300;
                                Response.Status = false;
                                Response.Message = "移库初始仓位状态不正确！";
                                td.Error = "移库初始仓位状态不正确！";
                                _unitWork.Update(td);
                                return Response;
                            }
                            else
                            {
                                //修改初始仓位
                                _unitWork.Update<Location>(n => n.Id == loc.Id && n.Version == loc.Version, n => new Location
                                {
                                    Status = LocationStatus.空仓位,
                                    ContainerCode = "",
                                    UpdateTime = DateTime.Now
                                });
                                td.UpdateTime = DateTime.Now;
                                td.Error = "堆垛机已接任务:"+ DateTime.Now;
                                _unitWork.Update(td);
                            }
                        }
                        else
                        {
                            Station station = _unitWork.Find<Station>(n => n.Code == td.SourceLocation && n.Containercode == td.ContainerCode && td.SourceLocation != "PP_SpecialPoint").FirstOrDefault();
                            if (station != null)
                            {
                                station.Containercode = "";
                                station.UpdateBy = "wms";
                                station.UpdateTime = DateTime.Now;
                            }
                            else if (_unitWork.IsExist<Station>(n => n.Containercode == td.SourceLocation))
                            {
                                station = _unitWork.Find<Station>(n => n.Code == td.SourceLocation).FirstOrDefault();
                                station.Containercode = "";
                                station.UpdateBy = "wms";
                                station.UpdateTime = DateTime.Now;
                            }
                            else
                            {
                                Response.Message = "重发";
                                return Response;
                            }
                            _unitWork.Update(station);
                            
                        }

                        tran.Commit();
                        return Response;
                    }
                    //WCS回库仓位高度请求
                    else if (sTKStatusModel.Status == 20)
                    {
                        td = _unitWork.Find<TaskDetail>(u => u.TaskNo == sTKStatusModel.TaskNo && u.Status >= TaskStatus.新建任务 && u.Status < TaskStatus.已经完成 && (u.TaskType == TaskType.容器回库 || u.TaskType == TaskType.空容器入库)).FirstOrDefault();
                        StationRoadway stationRoadway = _unitWork.Find<StationRoadway>(n => n.StationCode == td.SourceLocation).FirstOrDefault();
                        Location loc = null;
                        if (stationRoadway == null)
                        {
                            Response.Code = 300;
                            Response.Status = false;
                            Response.Message = "未找到起始站台！";
                            return Response;
                        }
                        else if (td == null)
                        {
                            Response.Code = 300;
                            Response.Status = false;
                            Response.Message = "未找到回库任务！";
                            return Response;
                        }
                        else if (_unitWork.IsExist<Location>(n => n.ContainerCode == td.ContainerCode))
                        {
                            if (_unitWork.IsExist<Inventory>(n => n.ContainerCode == td.ContainerCode && n.TaskStatus == InventoryTaskType.有盘点任务))
                            {
                                loc = _unitWork.Find<Location>(n => n.ContainerCode == td.ContainerCode).FirstOrDefault();
                            }
                            else
                            {
                                Response.Result = td;
                                Response.Message = "已有仓位！";
                                return Response;
                            }
                        }

                        Container container = _unitWork.Find<Container>(n => n.Code == td.ContainerCode).FirstOrDefault();
                        if (loc == null && container != null)
                        {
                            if (sTKStatusModel.Height == -1)
                            {
                                sTKStatusModel.Height = (int)container.Height;
                            }
                            string error = "";
                            while (true)
                            {
                                var tasks = _unitWork.Find<TaskDetail>(n => n.TaskNo != null).ToList();
                                //if (_unitWork.GetCount<Location>(n => n.Status == LocationStatus.空仓位 && n.IsStop == false && n.Roadway == stationRoadway.RoadWay && n.ContainerCode == "" && n.RowIndex == 2) < 8)
                                //{
                                //    loc = null;
                                //    error = "仓位不足8个！";
                                //    break;
                                //}
                                //RowIndex 1：里仓位，2：外仓位。查找到里仓位时外仓位要为空
                                loc = (from loca in _unitWork.Find<Location>(n => n.RowIndex == 1 && !tasks.Select(a => a.DestinationLocation).Contains(n.ContiguousCode) && !tasks.Select(a => a.SourceLocation).Contains(n.ContiguousCode) && n.Status == LocationStatus.空仓位 && n.IsStop == false && n.Roadway == stationRoadway.RoadWay && n.ContainerCode == "")
                                        join cLoca in _unitWork.Find<Location>(n => n.ContainerCode == "" && n.Status != LocationStatus.任务锁定中 && n.IsStop == false && n.Roadway == stationRoadway.RoadWay)
                                            on loca.ContiguousCode equals cLoca.Code
                                        select loca)
                                    .OrderBy(n => n.RowIndex == 1 ? 0 : n.RowIndex).ThenBy(b => b.MaxHeight).ThenBy(a => a.Layer).ThenBy(y => y.Row).FirstOrDefault();

                                if (loc == null)
                                {
                                    loc = (from loca in _unitWork.Find<Location>(n => n.RowIndex == 2 && !tasks.Select(a => a.DestinationLocation).Contains(n.ContiguousCode) && !tasks.Select(a => a.SourceLocation).Contains(n.ContiguousCode) && n.Status == LocationStatus.空仓位 && n.IsStop == false && n.Roadway == stationRoadway.RoadWay && n.ContainerCode == "")
                                            join cLoca in _unitWork.Find<Location>(n => n.Status != LocationStatus.任务锁定中 && n.IsStop == false && n.Roadway == stationRoadway.RoadWay)
                                                on loca.ContiguousCode equals cLoca.Code
                                            select loca)
                                        .OrderBy(n => n.RowIndex == 1 ? 0 : n.RowIndex).ThenBy(b => b.MaxHeight).ThenBy(a => a.Layer).ThenBy(y => y.Row).FirstOrDefault();
                                }


                                //更新仓位对应的容器，如果回库分配的不是原仓位则更新仓位且锁定
                                if (loc == null)
                                {
                                    Response.Code = 300;
                                    Response.Status = false;
                                    Response.Message = "未找到仓位！";
                                    td.Error = "未找到仓位！" + error;
                                    _unitWork.Update(td);
                                    tran.Commit();
                                    return Response;
                                }
                                else
                                {
                                    if (_unitWork.IsExist<TaskDetail>(a => (a.DestinationLocation == loc.ContiguousCode || a.SourceLocation == loc.ContiguousCode) && a.Roadway == 1))
                                    {
                                        continue;
                                    }
                                    int i = _unitWork.Update<Location>(n => n.Id == loc.Id && n.Version == loc.Version, n => new Location
                                    {
                                        Status = LocationStatus.任务锁定中,
                                        ContainerCode = td.ContainerCode,
                                        UpdateTime = DateTime.Now
                                    });
                                    if (i == 1)
                                    {
                                        break;
                                    }
                                }
                            }
                        }

                        List<Inventory> inventories = _unitWork.Find<Inventory>(n => n.ContainerCode == td.ContainerCode).ToList();
                        if (container == null)
                        {
                            Response.Code = 300;
                            Response.Status = false;
                            Response.Message = "未找到该容器！";
                            td.Error = "未找到该容器！";
                            _unitWork.Update(td);
                            return Response;
                        }
                        else
                        {
                            //更改容器
                            container.Height = sTKStatusModel.Height;
                            container.LocationCode = loc.Code;
                            container.LocationId = loc.Id;
                            _unitWork.Update(container);
                        }

                        //更新同个容器中其它物料对应新的回库仓位
                        if (inventories.Count > 0)
                        {
                            foreach (Inventory inv in inventories)
                            {
                                if (inv.LocationCode != loc.Code)
                                {
                                    inv.LocationCode = loc.Code;
                                    _appi.Update(inv);
                                }
                            }
                        }
                        //更改任务终点
                        td.DestinationLocation = loc.Code;
                        _unitWork.Update(td);
                        //如果入库起始站台为PP片排版房入库口，那么在请求仓位后就直接清除站台占用
                        Station stationOne = _unitWork.Find<Station>(n => n.Code == td.SourceLocation).FirstOrDefault();
                        if (stationOne.Containercode == td.ContainerCode && td.SourceLocation == "EntranceStationY01")
                        {
                            stationOne.Containercode = "";
                            stationOne.UpdateBy = "wms";
                            stationOne.UpdateTime = DateTime.Now;
                            _unitWork.Update(stationOne);
                        }
                        tran.Commit();
                        Response.Result = td;
                        return Response;
                    }
                    else
                    {
                        Response.Code = 500;
                        Response.Status = false;
                        Response.Message = "不识别的任务状态！";
                    }

                    if (td != null)
                    {
                        List<TaskDetail> taskDetailsShipments = _unitWork.Find<TaskDetail>(n => n.ContainerCode == td.ContainerCode && (n.TaskType == TaskType.整盘出库 || n.TaskType == TaskType.分拣出库) && n.Station == td.Station).ToList();
                        foreach (var taskDetailsShipment in taskDetailsShipments)
                        {
                            if (taskDetailsShipment.Status == TaskStatus.待下发任务)
                            {
                                taskDetailsShipment.Status = TaskStatus.下达任务;
                                _unitWork.Update(taskDetailsShipment);
                            }
                        }
                        List<TaskDetail> taskDetails = new List<TaskDetail>();
                        if (td.ContainerCode == "empty")
                        {
                            taskDetails = _unitWork.Find<TaskDetail>(u => u.TaskNo == td.TaskNo && u.Status > TaskStatus.待下发任务 && u.Status < TaskStatus.已经完成).ToList();
                        }
                        else
                        {
                            taskDetails = _unitWork.Find<TaskDetail>(u => u.ContainerCode == td.ContainerCode && u.Status >= TaskStatus.待下发任务 && u.Status < TaskStatus.已经完成).ToList();
                        }
                        if (sTKStatusModel.Status == 30)   //堆垛机出库完成容器到达站台
                        {
                            foreach (TaskDetail t in taskDetails)
                            {
                                
                                if (t.TaskType == TaskType.容器出库 || t.TaskType == TaskType.空容器出库 || t.TaskType == TaskType.盘点)
                                {
                                    t.Status = TaskStatus.已经完成;   //更新托盘出库任务为已完成
                                    t.UpdateBy = "wms";
                                    t.UpdateTime = DateTime.Now;
                                    _unitWork.Update(t);
                                }
                                else if (t.TaskType == TaskType.站台到站台)
                                {
                                    t.Status = TaskStatus.已经完成;   //更新托盘出库任务为已完成
                                    t.UpdateBy = "wms";
                                    t.UpdateTime = DateTime.Now;
                                    _unitWork.Update(t);

                                    Station stationSource = _unitWork.Find<Station>(n => n.Code == t.SourceLocation).FirstOrDefault();
                                    if (stationSource != null)
                                    {
                                        if (stationSource.Containercode == td.ContainerCode)
                                        {
                                            stationSource.Containercode = "";
                                            _unitWork.Update(stationSource);
                                        }
                                    }
                                }
                                else if (t.TaskType == TaskType.直接出库)
                                {
                                    t.Status = TaskStatus.已经完成;   //更新托盘出库任务为已完成
                                    t.UpdateBy = "wms";
                                    t.UpdateTime = DateTime.Now;
                                    _unitWork.Update(t);
                                }
                                else
                                {
                                    if ((t.TaskType == TaskType.整盘出库 || t.TaskType == TaskType.分拣出库) && td.Station == t.Station)//出库任务类型
                                    {
                                        List<InventoryOut> inventoryOuts = _unitWork.Find<InventoryOut>(n => n.ContainerCode == t.ContainerCode && n.ShipmentState == 0).ToList();
                                        foreach (InventoryOut inventoryOut in inventoryOuts)
                                        {
                                            inventoryOut.ShipmentState = 1;
                                            _unitWork.Update(inventoryOut);
                                            //更改出库明细状态
                                            //查找当前托盘的inventoryOut对应的出库单据明细，并将改明细状态修改
                                            ShipmentDetail InvshipmentDetail = _unitWork.Find<ShipmentDetail>(u => u.ShipmentCode == inventoryOut.ReceiptCode && u.Project == inventoryOut.QrCode && u.Status == ShipmentHeaderStatus.分配完成).FirstOrDefault();
                                            if (InvshipmentDetail != null)
                                            {
                                                InterfaceLog interfaceLog = _unitWork.Find<InterfaceLog>(n => n.TaskNo == InvshipmentDetail.SourceCode).FirstOrDefault();
                                                if (interfaceLog != null)
                                                {
                                                    interfaceLog.ComNum += 1;
                                                    _unitWork.Update(interfaceLog);
                                                }
                                                InvshipmentDetail.Status = ShipmentHeaderStatus.过账;
                                                InvshipmentDetail.UpdateBy = "wms";
                                                InvshipmentDetail.UpdateTime = DateTime.Now;
                                                _unitWork.Update(InvshipmentDetail);
                                            }
                                        }

                                        ShipmentHeader shipment = _unitWork
                                            .Find<ShipmentHeader>(n => n.SourceCode == t.SourceCode).FirstOrDefault();
                                        List<ShipmentDetail> shipmentDetails = _unitWork
                                            .Find<ShipmentDetail>(n => n.SourceCode == t.SourceCode).OrderBy(a => a.Status).ToList();
                                        shipment.FirstStatus = shipmentDetails.Last().Status;
                                        shipment.LastStatus = shipmentDetails.First().Status;
                                        _unitWork.Update(shipment);

                                    }
                                }

                                t.Status = TaskStatus.已经完成;  //更新任务明细状态为已完成
                                t.UpdateBy = "wms";
                                t.UpdateTime = DateTime.Now;
                                _unitWork.Update(t);
                                //更新主任务头尾状态
                                Task task = _context.Set<Task>().AsQueryable().Where(u => u.TaskNo == t.TaskNo).SingleOrDefault();
                                if (task == null)
                                {
                                    throw new Exception("任务主表:" + t.TaskNo + "不存在！");
                                }
                                // Task task = _unitWork.FindSingle<Task>(u => u.TaskNo == t.TaskNo);
                                TaskDetail tdel = _unitWork.Find<TaskDetail>(u => u.TaskNo == t.TaskNo).OrderBy(a => a.Status).FirstOrDefault();//同一个任务号下面最小的任务状态，包含其它容器的任务，用于更新主任务的尾状态
                                if (tdel == null)
                                {
                                    throw new Exception("任务子表:" + t.TaskNo + "不存在！");
                                }
                                if (task.FirstStatus < t.Status)
                                {
                                    task.FirstStatus = t.Status;
                                }
                                if (task.LastStatus < tdel.Status)
                                {
                                    task.LastStatus = tdel.Status;
                                }
                                task.UpdateBy = "wms";
                                task.UpdateTime = DateTime.Now;
                                _unitWork.Update(task);


                                //已完成的单据任务迁移至历史任务表
                                if (task.LastStatus == TaskStatus.已经完成)
                                {
                                    TaskHistory taskhis = new TaskHistory();
                                    task.CopyTo(taskhis);
                                    taskhis.Id = null;
                                    _unitWork.Add(taskhis);

                                    List<TaskDetail> taskdtls = _context.Set<TaskDetail>().AsQueryable().Where(u => u.TaskNo == task.TaskNo).ToList();
                                    foreach (TaskDetail tdl in taskdtls)
                                    {
                                        TaskDetailHistory taskdthis = new TaskDetailHistory();
                                        tdl.CopyTo(taskdthis);
                                        taskdthis.Id = null;
                                        _unitWork.Add(taskdthis);

                                        _unitWork.Delete(tdl);
                                    }
                                    _unitWork.Delete(task);
                                }
                            }

                            if (td.TaskType == TaskType.直接出库 || td.TaskType == TaskType.空容器出库 || td.TaskType == TaskType.容器出库 || td.TaskType == TaskType.站台到站台 || td.TaskType == TaskType.盘点)
                            {
                                //托盘出库完成，容器占用站台
                                Station st = _unitWork.Find<Station>(u => u.Code == td.Station).FirstOrDefault();
                                if (st == null)
                                {
                                    throw new Exception("站台:" + td.Station + "不存在！");
                                }
                                else if (st.IsOccupy == 0 && td.IsOccupy != 1)
                                {
                                    st.Containercode = "";
                                }
                                else if (st.IsOccupy == 1 && td.IsOccupy != 0)
                                {
                                    st.Containercode = td.ContainerCode;
                                }

                                st.UpdateBy = "wms";
                                st.UpdateTime = DateTime.Now;
                                _unitWork.Update(st);
                                List<Inventory> inventories = new List<Inventory>();
                                if (td.ContainerCode == "empty")
                                {
                                    inventories = _unitWork.Find<Inventory>(n => n.Id == td.InventoryId).ToList();
                                }
                                else
                                {
                                    inventories = _unitWork.Find<Inventory>(n => n.ContainerCode == td.ContainerCode && n.ContainerCode != "woodPallet").ToList();
                                } 
                                //暂存区出库完成更新库存状态并添加库存交易
                                if ((st.Type == StationType.暂存区站台) || td.TaskType == TaskType.盘点)
                                {
                                    foreach (Inventory inv in inventories)
                                    {
                                        if (st.Type == StationType.暂存区站台)
                                        {
                                            inv.TaskStatus = InventoryTaskType.无任务;
                                        }
                                        inv.LocationCode = st.Code;
                                        _appi.UpdateByTracking(inv);
                                        InventoryTransaction inventoryTransaction = new InventoryTransaction
                                        {
                                            Type = TransactionType.出库,
                                            SourceCode = inv.SourceCode,
                                            UserDef1 = td.OrderCode,
                                            ContainerCode = inv.ContainerCode,
                                            Position = inv.Position,
                                            TaskSteps = inv.TaskSteps,
                                            MaterialCode = inv.MaterialCode,
                                            Batch = inv.Batch,
                                            Lot = inv.Lot,
                                            Qty = inv.Qty,
                                            Supplier = inv.Supplier,
                                            ResidualWeight = inv.ResidualWeight,
                                            Retreat = inv.Retreat,
                                            Specification = inv.Specification,
                                            NameDescription = inv.NameDescription,
                                            Unit = inv.Unit,
                                            Size = inv.Size,
                                            NumberofSheets = inv.NumberofSheets,
                                            Groupnum = inv.Groupnum,
                                            OldBatch = inv.OldBatch,
                                            Combo = inv.Combo,
                                            Status = inv.Status,
                                            LocationCode = td.Station,
                                            StackingNumber = inv.StackingNumber,
                                            CreateTime = inv.CreateTime,
                                            UpdateTime = DateTime.Now
                                        };
                                        _unitWork.Add(inventoryTransaction);
                                    }
                                }
                                else
                                {
                                    //出库完成后删除库存并添加库存交易
                                    foreach (Inventory inv in inventories)
                                    {
                                        _unitWork.Delete(inv);
                                        InventoryTransaction inventoryTransaction = new InventoryTransaction
                                        {
                                            Type = TransactionType.出库,
                                            UserDef1 = td.OrderCode,
                                            SourceCode = inv.SourceCode,
                                            ContainerCode = inv.ContainerCode,
                                            Position = inv.Position,
                                            TaskSteps = inv.TaskSteps,
                                            MaterialCode = inv.MaterialCode,
                                            Batch = inv.Batch,
                                            Lot = inv.Lot,
                                            Qty = inv.Qty,
                                            QrCode = inv.QrCode,
                                            Supplier = inv.Supplier,
                                            ResidualWeight = inv.ResidualWeight,
                                            Retreat = inv.Retreat,
                                            Specification = inv.Specification,
                                            NameDescription = inv.NameDescription,
                                            Unit = inv.Unit,
                                            Size = inv.Size,
                                            NumberofSheets = inv.NumberofSheets,
                                            Groupnum = inv.Groupnum,
                                            OldBatch = inv.OldBatch,
                                            Combo = inv.Combo,
                                            Status = inv.Status,
                                            LocationCode = td.Station,
                                            StackingNumber = inv.StackingNumber,
                                            CreateTime = inv.CreateTime,
                                            UpdateTime = DateTime.Now,
                                            UpdateBy = "IStackerStatusApp"
                                        };
                                        _unitWork.Add(inventoryTransaction);
                                    }
                                }

                                if (td.TaskType != TaskType.盘点)
                                {
                                    //托盘出库完成，解锁并释放仓位
                                    Location loc = _unitWork.Find<Location>(u => u.Code == td.SourceLocation).FirstOrDefault();
                                    if (loc != null)
                                    {
                                        _unitWork.Update<Location>(n => n.Id == loc.Id && n.Version == loc.Version, n => new Location
                                        {
                                            ContainerCode = "",
                                            Status = "empty",
                                            UpdateBy = "wms",
                                            UpdateTime = DateTime.Now
                                        });
                                    }
                                }
                            }

                            //   Response.Result = td;

                            //空板补给
                            if (td.TaskType == TaskType.空容器出库)
                            {
                                StoreStation storeStation = _unitWork.Find<StoreStation>(n => n.ContainerCode == td.ContainerCode && n.Status == StoreStationStatus.任务中).FirstOrDefault();
                                if (storeStation != null)
                                {
                                    storeStation.Status = StoreStationStatus.到达站台;
                                    storeStation.UpdateTime = DateTime.Now;
                                    _unitWork.Update(storeStation);
                                }
                                TaskDetail tdPP = _unitWork.Find<TaskDetail>(n => n.TaskType == TaskType.站台到站台 && n.Status == TaskStatus.新建任务 && n.SourceLocation == td.Station && n.ContainerCode == td.ContainerCode).FirstOrDefault();
                                if (tdPP != null)
                                {
                                    tdPP.Status = TaskStatus.待下发任务;
                                    _unitWork.Update(tdPP);
                                }
                            }
                        }
                        else if (sTKStatusModel.Status == 40)  //堆垛机入库完成容器到达仓位
                        {
                            string locationStatus = ContainerStatus.有;
                            Container container = _unitWork.Find<Container>(u => u.Code == td.ContainerCode).FirstOrDefault();
                            foreach (TaskDetail t in taskDetails)
                            {
                                if (t.TaskType == TaskType.容器回库)
                                {
                                    t.Status = TaskStatus.已经完成;   //更新托盘入库任务为已完成
                                    t.UpdateBy = "wms";
                                    t.UpdateTime = DateTime.Now;
                                    _unitWork.Update(t);

                                    Task pintask = _unitWork.FindSingle<Task>(u => u.TaskNo == t.TaskNo);
                                    if (pintask == null)
                                    {
                                        throw new Exception("任务主表:" + t.TaskNo + "不存在！");
                                    }
                                    pintask.FirstStatus = TaskStatus.已经完成;
                                    pintask.LastStatus = TaskStatus.已经完成;
                                    pintask.UpdateBy = "wms";
                                    pintask.UpdateTime = DateTime.Now;
                                    _unitWork.Update(pintask);
                                    Station sta = _unitWork.Find<Station>(n => n.Code == t.SourceLocation).FirstOrDefault();

                                    //更新库存交易仓位
                                    List<InventoryTransaction> inventoryTransactions = _unitWork.Find<InventoryTransaction>(u => u.ContainerCode == t.ContainerCode && u.UserDef1 == t.TaskNo).ToList();
                                    if (inventoryTransactions.Count > 0)
                                    {
                                        foreach (InventoryTransaction i in inventoryTransactions)
                                        {
                                            i.LocationCode = t.DestinationLocation;
                                            i.UpdateTime = DateTime.Now;
                                            _unitWork.Update(i);
                                        }
                                    }
                                    

                                    //已完成的托盘入库任务迁移至历史任务表
                                    TaskHistory taskHistory = new TaskHistory();
                                    pintask.CopyTo(taskHistory);
                                    taskHistory.Id = null;
                                    _unitWork.Add(taskHistory);
                                    TaskDetailHistory taskDetailHistory = new TaskDetailHistory();
                                    t.CopyTo(taskDetailHistory);
                                    taskDetailHistory.Id = null;
                                    _unitWork.Add(taskDetailHistory);

                                    //删除已完成的托盘入库任务
                                    _unitWork.Delete(pintask);
                                    _unitWork.Delete(t);
                                }
                                else
                                {
                                    t.Status = TaskStatus.已经完成;  //更新任务明细状态为已完成
                                    t.UpdateBy = "wms";
                                    t.UpdateTime = DateTime.Now;
                                    _unitWork.Update(t);
                                    //更新主任务头尾状态
                                    Task task = _context.Set<Task>().AsQueryable().Where(u => u.TaskNo == t.TaskNo).SingleOrDefault();
                                    if (task == null)
                                    {
                                        throw new Exception("任务主表:" + t.TaskNo + "不存在！");
                                    }
                                    // Task task = _unitWork.FindSingle<Task>(u => u.TaskNo == t.TaskNo);
                                    TaskDetail tdel = _unitWork.Find<TaskDetail>(u => u.TaskNo == t.TaskNo).OrderBy(a => a.Status).FirstOrDefault();//同一个任务号下面最小的任务状态，包含其它容器的任务，用于更新主任务的尾状态
                                    if (tdel == null)
                                    {
                                        throw new Exception("任务子表:" + t.TaskNo + "不存在！");
                                    }
                                    if (task.FirstStatus < t.Status)
                                    {
                                        task.FirstStatus = t.Status;
                                    }
                                    if (task.LastStatus < tdel.Status)
                                    {
                                        task.LastStatus = tdel.Status;
                                    }
                                    task.UpdateBy = "wms";
                                    task.UpdateTime = DateTime.Now;
                                    _unitWork.Update(task);

                                    //已完成的单据任务迁移至历史任务表
                                    if (task.LastStatus == TaskStatus.已经完成)
                                    {
                                        TaskHistory taskhis = new TaskHistory();
                                        task.CopyTo(taskhis);
                                        taskhis.Id = null;
                                        _unitWork.Add(taskhis);

                                        List<TaskDetail> taskdtls = _context.Set<TaskDetail>().AsQueryable().Where(u => u.TaskNo == task.TaskNo).ToList();
                                        foreach (TaskDetail tdl in taskdtls)
                                        {
                                            TaskDetailHistory taskdthis = new TaskDetailHistory();
                                            tdl.CopyTo(taskdthis);
                                            taskdthis.Id = null;
                                            _unitWork.Add(taskdthis);

                                            _unitWork.Delete(tdl);
                                        }
                                        _unitWork.Delete(task);
                                    }

                                    if (t.TaskType == TaskType.整盘入库 || t.TaskType == TaskType.补充入库)//入库任务类型
                                    {
                                        //更新入库明细单据状态
                                        ReceiptDetail receiptDetail = _unitWork.Find<ReceiptDetail>(u => u.SourceCode == t.SourceCode && u.ReceiptCode == t.OrderCode && u.MaterialCode == t.MaterialCode && t.OderQty == t.HadQty).FirstOrDefault();
                                        if (receiptDetail != null)
                                        {
                                            receiptDetail.Status = ReceiptHeaderStatus.过账;
                                            receiptDetail.UpdateBy = "wms";
                                            receiptDetail.UpdateTime = DateTime.Now;
                                            _apprd.UpdateByTracking(receiptDetail);
                                            //更新入库主单据头尾状态
                                            // ReceiptHeader receiptHeader = _unitWork.Find<ReceiptHeader>(u => u.Code == t.OrderCode).FirstOrDefault();
                                            ReceiptHeader receiptHeader = _context.Set<ReceiptHeader>().AsQueryable().Where(u => u.SourceCode == t.SourceCode).SingleOrDefault();
                                            ReceiptDetail recepdt = _unitWork.Find<ReceiptDetail>(u => u.SourceCode == t.SourceCode).OrderBy(a => a.Status).FirstOrDefault();
                                            if (receiptHeader.FirstStatus < receiptDetail.Status)
                                            {
                                                receiptHeader.FirstStatus = receiptDetail.Status;
                                            }
                                            if (receiptHeader.LastStatus < recepdt.Status)
                                            {
                                                receiptHeader.LastStatus = recepdt.Status;
                                            }
                                            receiptHeader.UpdateBy = "wms";
                                            receiptHeader.UpdateTime = DateTime.Now;
                                            _apprh.UpdateByTracking(receiptHeader);
                                            //已完成的入库单据迁移至历史入库单据，暂以过账状态，后期与ERP对接后以回传状态
                                            if (receiptHeader.LastStatus == ReceiptHeaderStatus.过账)
                                            {
                                                ReceiptHeaderHistory receiptHeaderHistory = new ReceiptHeaderHistory();
                                                receiptHeader.CopyTo(receiptHeaderHistory);
                                                receiptHeaderHistory.Id = null;
                                                _unitWork.Add(receiptHeaderHistory);

                                                List<ReceiptDetail> recepdtls = _context.Set<ReceiptDetail>().AsQueryable().Where(u => u.ReceiptCode == receiptHeader.Code).ToList();
                                                // List<ReceiptDetail> recepdtls = _unitWork.Find<ReceiptDetail>(u => u.ReceiptCode == receiptHeader.Code).ToList();
                                                foreach (ReceiptDetail rd in recepdtls)
                                                {
                                                    ReceiptDetailHistory receiptDetailHistory = new ReceiptDetailHistory();
                                                    rd.CopyTo(receiptDetailHistory);
                                                    receiptDetailHistory.Id = null;
                                                    receiptDetailHistory.ReceiptId = receiptHeaderHistory.Id;
                                                    _unitWork.Add(receiptDetailHistory);

                                                    _unitWork.Delete(rd);
                                                }
                                                _unitWork.Delete(receiptHeader);
                                            }
                                        }
                                    }
                                    else if (t.TaskType == TaskType.空容器入库) //空容器入库任务类型
                                    {
                                        container.Status = ContainerStatus.空;
                                        if (container.Type == ContainerType.空托盘组)
                                        {
                                            locationStatus = LocationStatus.空容器组;
                                        }
                                        else
                                        {
                                            locationStatus = LocationStatus.空容器;
                                        }
                                    }
                                    else if (t.TaskType == TaskType.移库)
                                    {
                                        if (container.Status == ContainerStatus.空 && container.Type == ContainerType.普通栈板)
                                        {
                                            locationStatus = LocationStatus.空容器;
                                        }
                                        else if (container.Status == ContainerStatus.空 && container.Type == ContainerType.空托盘组)
                                        {
                                            locationStatus = LocationStatus.空容器组;
                                        }
                                    }
                                    else
                                    {
                                        throw new Exception("未知任务类型:" + t.TaskType);
                                    }
                                }
                            }

                            //清除该托盘占用的站台
                            Station s = _unitWork.Find<Station>(n => n.Code == td.SourceLocation && n.Containercode == td.ContainerCode && (td.TaskType == TaskType.容器回库 || td.TaskType == TaskType.空容器入库)).FirstOrDefault();
                            if (s != null)
                            {
                                s.Containercode = "";
                                _unitWork.Update(s);
                            }
                            //托盘入库完成，解锁并释放仓位
                            Location Fromloc = _unitWork.Find<Location>(u => u.Code == td.SourceLocation && u.ContainerCode == td.ContainerCode).FirstOrDefault();
                            Location loc = _unitWork.Find<Location>(u => u.Code == td.DestinationLocation).FirstOrDefault();
                            if (loc == null)
                            {
                                throw new Exception("目的仓位:" + td.DestinationLocation + "不存在！");
                            }
                            if(Fromloc != null && td.TaskType == TaskType.移库)
                            {
                                int fromiLoc = _unitWork.Update<Location>(n => n.Id == Fromloc.Id && n.Version == Fromloc.Version, n => new Location
                                {
                                    ContainerCode = "",
                                    Status = "empty",
                                    UpdateBy = "wcs",
                                    UpdateTime = DateTime.Now
                                });
                            }

                            int iLoc = _unitWork.Update<Location>(n => n.Id == loc.Id && n.Version == loc.Version, n => new Location
                            {
                                ContainerCode = td.ContainerCode,
                                Status = locationStatus,
                                UpdateBy = "wms",
                                UpdateTime = DateTime.Now
                            });

                            List<Inventory> inventories = _unitWork.Find<Inventory>(n => n.ContainerCode == td.ContainerCode && n.Status != "cyclecountLock").ToList();
                            //更新同个容器中其它物料对应新的回库仓位
                            if (inventories.Count > 0)
                            {
                                foreach (Inventory inv in inventories)
                                {
                                    if (loc.Roadway == 1)
                                    {
                                        inv.WarehouseType = "TB_WareCell";
                                    }
                                    if (loc.Roadway == 2)
                                    {
                                        inv.WarehouseType = "PP_WareCell";
                                    }
                                    else if (loc.Roadway == 3)
                                    {
                                        inv.WarehouseType = "PJ_WareCell";
                                    }

                                    if (inv.LocationCode != loc.Code)
                                    {
                                        inv.LocationCode = loc.Code;
                                    }

                                    if (inv.TaskStatus == InventoryTaskType.任务锁定中)
                                    {
                                        inv.TaskStatus = InventoryTaskType.无任务;
                                    }
                                    _appi.UpdateByTracking(inv);
                                    InterfaceLog inter = _unitWork.Find<InterfaceLog>(n => n.TaskNo == inv.SourceCode && n.Status != 1).FirstOrDefault();
                                    if (inter != null)
                                    {
                                        inter.ComNum += 1;
                                        _unitWork.Update(inter);
                                    }
                                }
                                
                            }
                            //托盘入库完成，解锁并释放容器
                            if (container == null)
                            {
                                throw new Exception("容器:" + td.ContainerCode + "不存在！");
                            }
                            container.LocationCode = td.DestinationLocation;
                            container.IsLock = ContainerLock.未锁;
                            container.UpdateBy = "wms";
                            container.UpdateTime = DateTime.Now;
                            _unitWork.Update(container);
                        }
                        else
                        {
                            Response.Code = 500;
                            Response.Status = false;
                            Response.Message = "不识别的任务状态！";
                        }
                    }
                    else
                    {
                        Response.Code = 500;
                        Response.Status = false;
                        Response.Message = "获取任务号错误，未找到此容器的任务！";
                    }
                    tran.Commit();
                }
                catch (Exception ex)
                {
                    tran.Rollback();
                    Response.Code = 500;
                    Response.Status = false;
                    Response.Message = ex.Message;
                }

                return Response;
            }
        }
    }
}