wms / wms_NouYaWmsN5 · Files

using System;
using System.Collections.Generic;
using System.Linq;
using Infrastructure;
using WebRepository;

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.已经完成);
                        if (td == null)
                        {
                            Response.Message = "重发";
                            return Response;
                        }
                        if (td.SourceLocation.Contains("ProductStationC0") && td.SourceLocation != "ProductStationC09")
                        {
                           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 && a.StartStation.Contains("ProductStationC0"))
                                 on se.Code equals sts.StartStation
                                 select se).FirstOrDefault();
                            if (stationEmpty != null)
                            {
                                stationEmpty.Containercode = "";
                                stationEmpty.UpdateBy = "wms";
                                stationEmpty.UpdateTime = DateTime.Now;
                                _unitWork.Update(stationEmpty);
                            }
                        }

                        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
                        {
                            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;
                            }
                        }
                        if (loc == null)
                        {
                            while (true)
                            {
                                Inventory inve = _unitWork.Find<Inventory>(n => n.ContainerCode == td.ContainerCode).FirstOrDefault();
                                if (inve != null)
                                {
                                    if (td.Roadway == 3)
                                    {
                                        if (td.TaskType == TaskType.容器回库 && td.Roadway == 3 && inve.IsFold == "isflod")
                                        {

                                            if (stationRoadway.StationPlace == StationPlace.巷道北面)
                                            {
                                                loc = _unitWork.Find<Location>(n => n.Status == ContainerStatus.空 && n.IsStop == false && n.MaxHeight >= sTKStatusModel.Height && n.Roadway == stationRoadway.RoadWay && n.ContainerCode == "").OrderBy(b => b.MaxHeight).ThenBy(a => a.Layer).ThenBy(y => y.Row).FirstOrDefault();
                                            }
                                            else if (stationRoadway.StationPlace == StationPlace.巷道南面)
                                            {
                                                loc = _unitWork.Find<Location>(n => n.Status == ContainerStatus.空 && n.IsStop == false && n.MaxHeight >= sTKStatusModel.Height && n.Roadway == stationRoadway.RoadWay && n.ContainerCode == "").OrderBy(b => (b.Layer)).ThenBy(a => a.MaxHeight).ThenByDescending(y => y.Row).FirstOrDefault();
                                            }
                                        }
                                        else
                                        {
                                            if (stationRoadway.StationPlace == StationPlace.巷道北面)
                                            {
                                                loc = _unitWork.Find<Location>(n => n.Status == ContainerStatus.空 && n.IsStop == false && n.MaxHeight >= sTKStatusModel.Height && n.Roadway == stationRoadway.RoadWay && n.ContainerCode == "").OrderBy(b => b.MaxHeight).ThenBy(a => a.Layer).ThenBy(y => y.Row).FirstOrDefault();
                                            }
                                            else if (stationRoadway.StationPlace == StationPlace.巷道南面)
                                            {
                                                loc = _unitWork.Find<Location>(n => n.Status == ContainerStatus.空 && n.IsStop == false && n.MaxHeight >= sTKStatusModel.Height && n.Roadway == stationRoadway.RoadWay && n.ContainerCode == "").OrderBy(b => (b.Layer == 1 ? 13 : b.Layer)).ThenBy(a => a.MaxHeight).ThenByDescending(y => y.Row).FirstOrDefault();
                                            }
                                        }
                                    }
                                    else
                                    {
                                        if (stationRoadway.StationPlace == StationPlace.巷道北面)
                                        {
                                            loc = _unitWork.Find<Location>(n => n.Status == ContainerStatus.空 && n.IsStop == false && n.MaxHeight >= sTKStatusModel.Height && n.Roadway == stationRoadway.RoadWay && n.ContainerCode == "").OrderBy(b => b.MaxHeight).ThenBy(a => a.Layer).ThenBy(y => y.Row).FirstOrDefault();
                                        }
                                        else if (stationRoadway.StationPlace == StationPlace.巷道南面)
                                        {
                                            loc = _unitWork.Find<Location>(n => n.Status == ContainerStatus.空 && n.IsStop == false && n.MaxHeight >= sTKStatusModel.Height && n.Roadway == stationRoadway.RoadWay && n.ContainerCode == "").OrderBy(b => (b.MaxHeight)).ThenBy(a => a.Layer).ThenByDescending(y => y.Row).FirstOrDefault();
                                        }
                                    }
                                }
                                

                                //更新仓位对应的容器，如果回库分配的不是原仓位则更新仓位且锁定
                                if (loc == null)
                                {
                                    Response.Code = 300;
                                    Response.Status = false;
                                    Response.Message = "未找到仓位！";
                                    return Response;
                                }
                                else
                                {
                                    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();
                        Container container = _unitWork.Find<Container>(n => n.Code == td.ContainerCode).FirstOrDefault();
                        if (container == null)
                        {
                            Response.Code = 300;
                            Response.Status = false;
                            Response.Message = "未找到该容器！";
                            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> 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);

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

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

                                    //删除已完成的托盘出库任务
                                    _unitWork.Delete(pouttask);
                                    _unitWork.Delete(t);
                                }
                                else if (t.TaskType == TaskType.站台到站台)
                                {
                                    t.Status = TaskStatus.已经完成;   //更新托盘出库任务为已完成
                                    t.UpdateBy = "wms";
                                    t.UpdateTime = DateTime.Now;
                                    _unitWork.Update(t);

                                    Task pouttask = _unitWork.FindSingle<Task>(u => u.TaskNo == t.TaskNo);
                                    if (pouttask == null)
                                    {
                                        throw new Exception("任务主表:" + t.TaskNo + "不存在！");
                                    }

                                    Station stationSource = _unitWork.Find<Station>(n => n.Code == t.SourceLocation).FirstOrDefault();

                                    if (stationSource != null)
                                    {
                                        if (stationSource.Containercode == td.ContainerCode)
                                        {
                                            stationSource.Containercode = "";
                                            _unitWork.Update(stationSource);
                                        }
                                    }

                                    pouttask.FirstStatus = TaskStatus.已经完成;
                                    pouttask.LastStatus = TaskStatus.已经完成;
                                    pouttask.UpdateBy = "wms";
                                    pouttask.UpdateTime = DateTime.Now;
                                    _unitWork.Update(pouttask);

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

                                    //删除已完成的托盘出库任务
                                    _unitWork.Delete(pouttask);
                                    _unitWork.Delete(t);
                                }
                                else if (t.TaskType == TaskType.直接出库)
                                {
                                    t.Status = TaskStatus.已经完成;   //更新托盘出库任务为已完成
                                    t.UpdateBy = "wms";
                                    t.UpdateTime = DateTime.Now;
                                    _unitWork.Update(t);

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

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

                                    //删除已完成的托盘出库任务
                                    _unitWork.Delete(pouttask);
                                    _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.分拣出库)//出库任务类型
                                    {
                                        //更新出库明细状态
                                        ShipmentDetail shipmentDetail = _context.Set<ShipmentDetail>().AsQueryable().Where(u => u.SourceCode == t.SourceCode && u.ShipmentCode == t.OrderCode && u.MaterialCode == t.MaterialCode && u.Status == ShipmentHeaderStatus.分配完成).SingleOrDefault();
                                        //  ShipmentDetail shipmentDetail = _unitWork.Find<ShipmentDetail>(u => u.SourceCode == t.SourceCode && u.ShipmentCode == t.OrderCode && u.MaterialCode == t.MaterialCode).FirstOrDefault();
                                        if (shipmentDetail != null)
                                        {
                                            shipmentDetail.Status = ShipmentHeaderStatus.过账;
                                            shipmentDetail.UpdateBy = "wms";
                                            shipmentDetail.UpdateTime = DateTime.Now;
                                            _unitWork.Update(shipmentDetail);
                                            //更新主出库单头尾状态
                                            //  ShipmentHeader shipmentHeader = _unitWork.Find<ShipmentHeader>(u => u.Code == t.OrderCode).FirstOrDefault();
                                            ShipmentHeader shipmentHeader = _context.Set<ShipmentHeader>().AsQueryable().Where(u => u.Code == t.OrderCode).SingleOrDefault();
                                            ShipmentDetail shipdt = _unitWork.Find<ShipmentDetail>(u => u.ShipmentCode == t.OrderCode).OrderBy(a => a.Status).FirstOrDefault();
                                            if (shipmentHeader.FirstStatus < shipmentDetail.Status)
                                            {
                                                shipmentHeader.FirstStatus = shipmentDetail.Status;
                                            }
                                            if (shipmentHeader.LastStatus < shipdt.Status)
                                            {
                                                shipmentHeader.LastStatus = shipdt.Status;
                                            }
                                            shipmentHeader.UpdateBy = "wms";
                                            shipmentHeader.UpdateTime = DateTime.Now;
                                            _unitWork.Update(shipmentHeader);

                                            //已完成的出库单据迁移至历史出库单据，暂以过账状态，后期与ERP对接后以回传状态
                                            if (shipmentHeader.LastStatus == ShipmentHeaderStatus.过账)
                                            {
                                                ShipmentHeaderHistory shipmentHeaderHistory = new ShipmentHeaderHistory();
                                                shipmentHeader.CopyTo(shipmentHeaderHistory);
                                                shipmentHeaderHistory.Id = null;
                                                _unitWork.Add(shipmentHeaderHistory);

                                                List<ShipmentDetail> shipdtls = _context.Set<ShipmentDetail>().AsQueryable().Where(u => u.ShipmentCode == shipmentHeader.Code).ToList();
                                                //  List<ShipmentDetail> shipdtls = _unitWork.Find<ShipmentDetail>(u => u.ShipmentCode == shipmentHeader.Code).ToList();
                                                foreach (ShipmentDetail sd in shipdtls)
                                                {
                                                    ShipmentDetailHistory shipmentDetailHistory = new ShipmentDetailHistory();
                                                    sd.CopyTo(shipmentDetailHistory);
                                                    shipmentDetailHistory.Id = null;
                                                    shipmentDetailHistory.ShipmentId = shipmentHeaderHistory.Id;
                                                    _unitWork.Add(shipmentDetailHistory);

                                                    _unitWork.Delete(sd);
                                                }
                                                _unitWork.Delete(shipmentHeader);
                                            }
                                        }
                                    }
                                    //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 (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 = "";
                                    //if (cont != null && td.TaskType != TaskType.盘点)
                                    //{
                                    //    _appc.DeleteByTracking(cont);
                                    //}
                                }
                                else if (st.IsOccupy == 1 && td.IsOccupy != 0)
                                {
                                    st.Containercode = td.ContainerCode;
                                }

                                Container cont = _unitWork.Find<Container>(n => n.Code == td.ContainerCode).FirstOrDefault();
                                if (cont != null && td.TaskType != TaskType.盘点 && st.Type != StationType.暂存区站台)
                                {
                                    cont.Status = "empty";
                                    cont.Height = 0;
                                    cont.LocationCode = st.Code;
                                    _unitWork.Update(cont);
                                }

                                st.UpdateBy = "wms";
                                st.UpdateTime = DateTime.Now;
                                _unitWork.Update(st);
                                List<Inventory> inventories = _unitWork.Find<Inventory>(n => n.ContainerCode == td.ContainerCode).ToList();
                                if (st.Type == StationType.暂存区站台 || td.TaskType == TaskType.盘点)
                                {
                                    foreach (Inventory inv in inventories)
                                    {
                                        inv.LocationCode = st.Code;
                                        inv.TaskStatus = InventoryTaskType.无任务;
                                        _appi.UpdateByTracking(inv);
                                    }
                                }
                                else
                                {
                                    foreach (Inventory inv in inventories)
                                    {
                                        _unitWork.Delete(inv);
                                        InventoryTransaction inventoryTransaction = new InventoryTransaction();
                                        inventoryTransaction.Type = TransactionType.出库;
                                        inventoryTransaction.SourceCode = td.OrderCode;
                                        inventoryTransaction.ContainerCode = inv.ContainerCode;
                                        inventoryTransaction.MaterialCode = inv.MaterialCode;
                                        inventoryTransaction.Batch = inv.Batch;
                                        inventoryTransaction.Lot = inv.Lot;
                                        inventoryTransaction.Qty = inv.Qty;
                                        inventoryTransaction.Status = inv.Status;
                                        inventoryTransaction.CreateTime = DateTime.Now;
                                        inventoryTransaction.UpdateTime = DateTime.Now;
                                        _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;

                            //切片机补空板任务完成后，PP片InStationC03站台补给空栈板逻辑
                            if ((td.TaskType == TaskType.空容器出库 || td.TaskType == TaskType.站台到站台) && td.DestinationLocation.Contains("ProductStationC0") && td.DestinationLocation != "ProductStationC09")
                            {
                                //站台暂存表中没有InStationC03站台的数据，站台表InStationC03站台可用，任务子表中不存在任务类型为空容器出库、目的库位是切片机的任务，（只有站台到站台的任务，并且目的站台为切片机）
                                if (!_unitWork.IsExist<StoreStation>(n => n.StationCode == "InStationC03" ) && _unitWork.IsExist<Station>(n => n.Code == "InStationC03" && n.IsStop == 0) && !_unitWork.IsExist<TaskDetail>(n => n.TaskType == TaskType.空容器出库 && n.DestinationLocation.Contains("ProductStationC0") && n.DestinationLocation != "ProductStationC09"))
                                {
                                    //可用的空容器
                                    var container = (from con in _unitWork.Find<Container>(n => n.Status == ContainerStatus.空 && n.IsLock == 0)
                                                     join loca in _unitWork.Find<Location>(n => n.Roadway == td.Roadway && n.Status == LocationStatus.空容器)
                                                     on con.LocationCode equals loca.Code
                                                     select con).FirstOrDefault();
                                    if (container != null)
                                    {
                                        //建立容器出库任务
                                        //任务表中不存在当前托盘的任务
                                        if (!_unitWork.IsExist<TaskDetail>(n => (n.Status >= TaskStatus.新建任务 && n.Status < TaskStatus.已经完成) && n.ContainerCode == container.Code))
                                        {
                                            //任务表中目的库位为InStationC03的任务
                                            int ptdcount = _unitWork.Find<TaskDetail>(n => (n.Status >= TaskStatus.新建任务 && n.Status < TaskStatus.已经完成) && n.DestinationLocation == "InStationC03").Count();
                                            //如果不存在
                                            if (ptdcount < 1)
                                            {
                                                Task ptask = new Task();
                                                TaskDetail ptaskDetail = new TaskDetail();
                                                var taskNo = _apprd.GetTaskNo(TaskNo.空板补充);
                                                ptask.TaskNo = taskNo;
                                                ptask.OrderCode = taskNo;
                                                ptask.BusinessType = BusinessType.出库_其他出库单;
                                                ptask.FirstStatus = TaskStatus.待下发任务;
                                                ptask.LastStatus = TaskStatus.待下发任务;
                                                ptask.CreateTime = DateTime.Now;
                                                _unitWork.Add(ptask);

                                                ptaskDetail.TaskNo = taskNo;
                                                ptaskDetail.OrderCode = taskNo;
                                                ptaskDetail.TaskType = TaskType.空容器出库;
                                                ptaskDetail.ContainerCode = container.Code;
                                                ptaskDetail.SourceLocation = container.LocationCode;
                                                ptaskDetail.DestinationLocation = "InStationC03";
                                                ptaskDetail.OderQty = 0;
                                                ptaskDetail.ContainerQty = 0;
                                                ptaskDetail.HadQty = 0;
                                                ptaskDetail.Roadway = td.Roadway;
                                                ptaskDetail.Station = "InStationC03";
                                                ptaskDetail.Status = TaskStatus.待下发任务;
                                                ptaskDetail.Priority = 0;
                                                ptaskDetail.CreateTime = DateTime.Now;
                                                _unitWork.Add(ptaskDetail);

                                                container.IsLock = 1;
                                                _unitWork.Update(container);

                                                Location locat = _unitWork.Find<Location>(n => n.Code == container.LocationCode).FirstOrDefault();
                                                _unitWork.Update<Location>(n => n.Id == locat.Id && n.Version == locat.Version, n => new Location
                                                {
                                                    Status = LocationStatus.任务锁定中,
                                                });

                                                StoreStation storeStation = new StoreStation
                                                {
                                                    StationCode = "InStationC03",
                                                    ContainerCode = container.Code,
                                                    Status = StoreStationStatus.任务中,
                                                    CreateTime = DateTime.Now
                                                };
                                                _unitWork.Add(storeStation);
                                            }
                                        }
                                    }
                                }
                            }
                            //InStationC03站台空容器补给任务完成后，判断该任务是否为补给InStationC03的任务
                            else if (td.TaskType == TaskType.空容器出库 && td.DestinationLocation == "InStationC03")
                            {
                                //查询是否已经建立了补给入库站台的任务
                                TaskDetail tdPP = _unitWork.Find<TaskDetail>(n => n.TaskType == TaskType.站台到站台 && n.Status == TaskStatus.新建任务 && n.SourceLocation == "InStationC03" && n.ContainerCode == td.ContainerCode).FirstOrDefault();
                                if (tdPP != null)
                                {
                                    tdPP.Status = TaskStatus.待下发任务;
                                    _unitWork.Update(tdPP);
                                }
                                else
                                {
                                    StoreStation storeStation = _unitWork.Find<StoreStation>(n => n.ContainerCode == td.ContainerCode).FirstOrDefault();
                                    if (storeStation != null)
                                    {
                                        storeStation.Status = StoreStationStatus.到达站台;
                                        storeStation.CreateTime = DateTime.Now;
                                    }
                                    _unitWork.Update(storeStation);
                                    if (_unitWork.Find<StoreStation>(n => n.StationCode == "InStationC03").Count() < 2 && _unitWork.IsExist<Station>(n => n.Code == "InStationC03" && n.IsStop == 0))
                                    {
                                        //从库内调出第二个空板补给任务
                                        var container = (from con in _unitWork.Find<Container>(n => n.Status == ContainerStatus.空 && n.IsLock == 0)
                                                         join loca in _unitWork.Find<Location>(n => n.Roadway == td.Roadway && n.Status == LocationStatus.空容器)
                                                         on con.LocationCode equals loca.Code
                                                         select con).FirstOrDefault();
                                        if (container != null)
                                        {
                                            //建立容器出库任务
                                            if (!_unitWork.IsExist<TaskDetail>(n => (n.Status >= TaskStatus.新建任务 && n.Status < TaskStatus.已经完成) && n.ContainerCode == container.Code))
                                            {
                                                int ptdcount = _unitWork.Find<TaskDetail>(n => (n.Status >= TaskStatus.新建任务 && n.Status < TaskStatus.已经完成) && n.DestinationLocation == "InStationC03").Count();
                                                if (ptdcount < 1)
                                                {
                                                    Task ptask = new Task();
                                                    TaskDetail ptaskDetail = new TaskDetail();
                                                    var taskNo = _apprd.GetTaskNo(TaskNo.空板补充);
                                                    ptask.TaskNo = taskNo;
                                                    ptask.OrderCode = taskNo;
                                                    ptask.BusinessType = BusinessType.出库_其他出库单;
                                                    ptask.FirstStatus = TaskStatus.待下发任务;
                                                    ptask.LastStatus = TaskStatus.待下发任务;
                                                    ptask.CreateTime = DateTime.Now;
                                                    _unitWork.Add(ptask);

                                                    ptaskDetail.TaskNo = taskNo;
                                                    ptaskDetail.OrderCode = taskNo;
                                                    ptaskDetail.TaskType = TaskType.空容器出库;
                                                    ptaskDetail.ContainerCode = container.Code;
                                                    ptaskDetail.SourceLocation = container.LocationCode;
                                                    ptaskDetail.DestinationLocation = "InStationC03";
                                                    ptaskDetail.OderQty = 0;
                                                    ptaskDetail.ContainerQty = 0;
                                                    ptaskDetail.HadQty = 0;
                                                    ptaskDetail.Roadway = td.Roadway;
                                                    ptaskDetail.Station = "InStationC03";
                                                    ptaskDetail.Status = TaskStatus.待下发任务;
                                                    ptaskDetail.Priority = 0;
                                                    ptaskDetail.CreateTime = DateTime.Now;
                                                    _unitWork.Add(ptaskDetail);

                                                    container.IsLock = 1;
                                                    _unitWork.Update(container);

                                                    Location locat = _unitWork.Find<Location>(n => n.Code == container.LocationCode).FirstOrDefault();
                                                    _unitWork.Update<Location>(n => n.Id == locat.Id && n.Version == locat.Version, n => new Location
                                                    {
                                                        Status = LocationStatus.任务锁定中,
                                                    });

                                                    StoreStation NewstoreStation = new StoreStation
                                                    {
                                                        StationCode = "InStationC03",
                                                        ContainerCode = container.Code,
                                                        Status = StoreStationStatus.任务中,
                                                        CreateTime = DateTime.Now
                                                    };
                                                    _unitWork.Add(NewstoreStation);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        else if (sTKStatusModel.Status == 40)  //堆垛机入库完成容器到达仓位
                        {
                            string locationStatus = ContainerStatus.有;
                            foreach (TaskDetail t in taskDetails)
                            {
                                if (t.TaskType == TaskType.容器回库)
                                {
                                    //判断是否为木栈板回库 找到对应出库明细任务
                                    if (_unitWork.IsExist<Station>(n => n.Type == StationType.木栈板补给站台w_1 || n.Type == StationType.木栈板补给站台w_2))
                                    {
                                        ShipmentDetail shipmentDetail = _unitWork.Find<ShipmentDetail>(n => n.ShipmentCode == t.OrderCode && n.Status == ShipmentHeaderStatus.分配完成).FirstOrDefault();
                                        if (shipmentDetail != null)
                                        {
                                            var con = (from c in _unitWork.Find<Container>(n => n.IsLock == 0)
                                                       join i in _unitWork.Find<Inventory>(n => n.MaterialCode == shipmentDetail.MaterialCode && n.Status == InventoryTaskType.无任务)
                                                       on c.Code equals i.ContainerCode
                                                       select c).FirstOrDefault();
                                            int ptdcount = _unitWork.Find<TaskDetail>(n => (n.Status >= TaskStatus.新建任务 && n.Status < TaskStatus.已经完成) && n.ContainerCode == con.Code && n.TaskType == TaskType.容器出库).Count();
                                            if (ptdcount < 1)
                                            {
                                                Station station = _unitWork.Find<Station>(n => n.Type == StationType.木板补给终点站台).FirstOrDefault();
                                                Task ptask = new Task();
                                                TaskDetail ptaskDetail = new TaskDetail();
                                                var taskNo = _apprh.GetTaskNo(TaskNo.空板补充);
                                                ptask.TaskNo = taskNo;
                                                ptask.OrderCode = taskNo;
                                                ptask.BusinessType = BusinessType.出库_其他出库单;
                                                ptask.FirstStatus = TaskStatus.待下发任务;
                                                ptask.LastStatus = TaskStatus.待下发任务;
                                                _unitWork.Add(ptask);

                                                ptaskDetail.TaskNo = taskNo;
                                                ptaskDetail.OrderCode = taskNo;
                                                ptaskDetail.TaskType = TaskType.空容器出库;
                                                ptaskDetail.ContainerCode = con.Code;
                                                ptaskDetail.SourceLocation = con.LocationCode;
                                                if (con.Type == ContainerType.木栈板母板_1)
                                                {
                                                    ptaskDetail.DestinationLocation = _unitWork.Find<Station>(n => n.Type == StationType.木栈板母板补给站台s_1).Select(n => n.Code).ToString();
                                                }
                                                else
                                                {
                                                    ptaskDetail.DestinationLocation = _unitWork.Find<Station>(n => n.Type == StationType.木栈板母板补给站台s_2).Select(n => n.Code).ToString();
                                                }
                                                ptaskDetail.Station = ptaskDetail.DestinationLocation;
                                                ptaskDetail.OderQty = 0;
                                                ptaskDetail.ContainerQty = 0;
                                                ptaskDetail.HadQty = 0;
                                                ptaskDetail.Roadway = int.Parse(_unitWork.Find<Location>(n => n.ContainerCode == con.Code).Select(n => n.Roadway).ToString());
                                                ptaskDetail.Status = TaskStatus.待下发任务;
                                                ptaskDetail.Priority = 0;
                                                _unitWork.Add(ptaskDetail);
                                                Inventory inventory = _unitWork.Find<Inventory>(n => n.ContainerCode == con.Code && n.MaterialCode == shipmentDetail.MaterialCode).FirstOrDefault();
                                                inventory.Qty -= 1;
                                                _unitWork.Update(inventory);
                                                station.Containercode = con.Code;
                                                _unitWork.Update(station);
                                                Location Location = _unitWork.Find<Location>(n => n.ContainerCode == con.Code).FirstOrDefault();
                                                _unitWork.Update<Location>(n => n.Id == Location.Id && n.Version == Location.Version, n => new Location
                                                {
                                                    IsStop = true
                                                });
                                                Container Container = _unitWork.Find<Container>(n => n.Code == con.Code).FirstOrDefault();
                                                Container.IsLock = 1;
                                                _unitWork.Update(Container);
                                                shipmentDetail.Status = ShipmentHeaderStatus.回传;
                                                _unitWork.Update(shipmentDetail);
                                            }
                                        }
                                    }
                                    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);

                                    //已完成的托盘入库任务迁移至历史任务表
                                    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.分拣出库)//出库任务类型
                                    {
                                        //更新出库明细状态
                                        ShipmentDetail shipmentDetail = _context.Set<ShipmentDetail>().AsQueryable().Where(u => u.SourceCode == t.SourceCode && u.ShipmentCode == t.OrderCode && u.MaterialCode == t.MaterialCode && t.OderQty == t.HadQty).SingleOrDefault();
                                        //  ShipmentDetail shipmentDetail = _unitWork.Find<ShipmentDetail>(u => u.SourceCode == t.SourceCode && u.ShipmentCode == t.OrderCode && u.MaterialCode == t.MaterialCode).FirstOrDefault();
                                        if (shipmentDetail != null)
                                        {
                                            shipmentDetail.Status = ShipmentHeaderStatus.过账;
                                            shipmentDetail.UpdateBy = "wms";
                                            shipmentDetail.UpdateTime = DateTime.Now;
                                            _unitWork.Update(shipmentDetail);
                                            //更新主出库单头尾状态
                                            //  ShipmentHeader shipmentHeader = _unitWork.Find<ShipmentHeader>(u => u.Code == t.OrderCode).FirstOrDefault();
                                            ShipmentHeader shipmentHeader = _context.Set<ShipmentHeader>().AsQueryable().Where(u => u.Code == t.OrderCode).SingleOrDefault();
                                            ShipmentDetail shipdt = _unitWork.Find<ShipmentDetail>(u => u.ShipmentCode == t.OrderCode).OrderBy(a => a.Status).FirstOrDefault();
                                            if (shipmentHeader.FirstStatus < shipmentDetail.Status)
                                            {
                                                shipmentHeader.FirstStatus = shipmentDetail.Status;
                                            }
                                            if (shipmentHeader.LastStatus < shipdt.Status)
                                            {
                                                shipmentHeader.LastStatus = shipdt.Status;
                                            }
                                            shipmentHeader.UpdateBy = "wms";
                                            shipmentHeader.UpdateTime = DateTime.Now;
                                            _unitWork.Update(shipmentHeader);

                                            //已完成的出库单据迁移至历史出库单据，暂以过账状态，后期与ERP对接后以回传状态
                                            if (shipmentHeader.LastStatus == ShipmentHeaderStatus.过账)
                                            {
                                                ShipmentHeaderHistory shipmentHeaderHistory = new ShipmentHeaderHistory();
                                                shipmentHeader.CopyTo(shipmentHeaderHistory);
                                                shipmentHeaderHistory.Id = null;
                                                _unitWork.Add(shipmentHeaderHistory);

                                                List<ShipmentDetail> shipdtls = _context.Set<ShipmentDetail>().AsQueryable().Where(u => u.ShipmentCode == shipmentHeader.Code).ToList();
                                                //  List<ShipmentDetail> shipdtls = _unitWork.Find<ShipmentDetail>(u => u.ShipmentCode == shipmentHeader.Code).ToList();
                                                foreach (ShipmentDetail sd in shipdtls)
                                                {
                                                    ShipmentDetailHistory shipmentDetailHistory = new ShipmentDetailHistory();
                                                    sd.CopyTo(shipmentDetailHistory);
                                                    shipmentDetailHistory.Id = null;
                                                    shipmentDetailHistory.ShipmentId = shipmentHeaderHistory.Id;
                                                    _unitWork.Add(shipmentDetailHistory);

                                                    _unitWork.Delete(sd);
                                                }
                                                _unitWork.Delete(shipmentHeader);
                                            }
                                        }
                                    }
                                    else 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.Code == t.OrderCode).SingleOrDefault();
                                            ReceiptDetail recepdt = _unitWork.Find<ReceiptDetail>(u => u.ReceiptCode == t.OrderCode).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.空容器入库) //空容器入库任务类型
                                    {
                                        locationStatus = LocationStatus.空容器;
                                    }
                                    else if (t.TaskType == TaskType.出库查看)
                                    {

                                    }
                                    //else if (t.TaskType == TaskType.盘点)
                                    //{
                                    //    Inventory inventory = _unitWork.Find<Inventory>(n => n.ContainerCode == t.ContainerCode).FirstOrDefault();
                                    //    List<Inventory> invs = _unitWork.Find<Inventory>(n => n.ContainerCode == inventory.ContainerCode).ToList();
                                    //    foreach (Inventory inv in invs)
                                    //    {
                                    //        inv.TaskStatus = "cyclecountLock";
                                    //        _appi.UpdateByTracking(inv);
                                    //    }
                                    //    CyclecountHeader cycher = _unitWork.Find<CyclecountHeader>(n => n.Code == t.OrderCode).FirstOrDefault();
                                    //    CyclecountDetail cycdel = _unitWork.Find<CyclecountDetail>(n => n.Status == ReceiptHeaderStatus.过账 && n.MaterialCode == t.MaterialCode && n.ContainerCode == t.ContainerCode && n.Code == t.OrderCode).FirstOrDefault();
                                    //    CyclecountDetail cycdelEnd = _unitWork.Find<CyclecountDetail>(n => n.Code == t.OrderCode && n.Id != cycdel.Id).OrderBy(n => n.Status).FirstOrDefault();
                                    //    if (cycdel != null)
                                    //    {
                                    //        cycdel.Status = ReceiptHeaderStatus.回传;
                                    //        _unitWork.Update(cycdel);
                                    //        if (cycdelEnd.Status >= cycdel.Status)
                                    //        {
                                    //            cycher.Status = (short)cycdel.Status;
                                    //            _unitWork.Update(cycher);
                                    //        }
                                    //        if (t.OderQty < t.HadQty)
                                    //        {
                                    //            //erp传数据
                                    //        }
                                    //        else if (t.OderQty > t.HadQty)
                                    //        {
                                    //            //erp传数据
                                    //        }
                                    //    }
                                    //}
                                    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 loc = _unitWork.Find<Location>(u => u.Code == td.DestinationLocation).FirstOrDefault();
                            if (loc == null)
                            {
                                throw new Exception("仓位:" + td.DestinationLocation + "不存在！");
                            }
                            _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 == 2)
                                    {
                                        inv.WarehouseType = "PPJ_WareCell";
                                    }
                                    else if (loc.Roadway == 3)
                                    {
                                        inv.WarehouseType = "PPP_WareCell";
                                    }
                                    else if (loc.Roadway == 4)
                                    {
                                        inv.WarehouseType = "TB_WareCell";
                                    }

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

                                    if (inv.TaskStatus == InventoryTaskType.任务锁定中)
                                    {
                                        inv.TaskStatus = InventoryTaskType.无任务;
                                    }
                                    _appi.Update(inv);
                                }
                            }
                            //托盘入库完成，解锁并释放容器
                            Container container = _unitWork.Find<Container>(u => u.Code == td.ContainerCode).FirstOrDefault();
                            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;
            }
        }
    }
}