Exemplo n.º 1
0
        public void Dispatch(string connectionId, Model.ProgressState ps, CancellationToken cancellationToken, string workDispatchId, string userName)
        {
            Locker.LockKey = workDispatchId;
            ConnectionId   = connectionId;
            ps.State       = StateType.Start;
            NotifyConnection(ps.Clone());

            IQueryable <SortOrderDispatch> sortOrderDispatchQuery = SortOrderDispatchRepository.GetQueryable();
            IQueryable <SortOrder>         sortOrderQuery         = SortOrderRepository.GetQueryable();
            IQueryable <SortOrderDetail>   sortOrderDetailQuery   = SortOrderDetailRepository.GetQueryable();

            IQueryable <OutBillMaster>  outBillMasterQuery  = OutBillMasterRepository.GetQueryable();
            IQueryable <OutBillDetail>  outBillDetailQuery  = OutBillDetailRepository.GetQueryable();
            IQueryable <MoveBillMaster> moveBillMasterQuery = MoveBillMasterRepository.GetQueryable();
            IQueryable <MoveBillDetail> moveBillDetailQuery = MoveBillDetailRepository.GetQueryable();

            IQueryable <SortingLowerlimit> sortingLowerlimitQuery = SortingLowerlimitRepository.GetQueryable();
            IQueryable <SortingLine>       sortingLineQuery       = SortingLineRepository.GetQueryable();
            IQueryable <Storage>           storageQuery           = StorageRepository.GetQueryable();

            IQueryable <SortWorkDispatch> sortWorkDispatchQuery = SortWorkDispatchRepository.GetQueryable();

            workDispatchId = workDispatchId.Substring(0, workDispatchId.Length - 1);
            int[] work = workDispatchId.Split(',').Select(s => Convert.ToInt32(s)).ToArray();

            //调度表未作业的数据
            var temp = sortOrderDispatchQuery.Where(s => work.Any(w => w == s.ID) && s.WorkStatus == "1")
                       .Join(sortOrderQuery,
                             dp => new { dp.OrderDate, dp.DeliverLineCode },
                             om => new { om.OrderDate, om.DeliverLineCode },
                             (dp, om) => new { dp.OrderDate, dp.SortingLine, dp.DeliverLineCode, om.OrderID }
                             ).Join(sortOrderDetailQuery,
                                    dm => new { dm.OrderID },
                                    od => new { od.OrderID },
                                    (dm, od) => new { dm.OrderDate, dm.SortingLine, od.Product, od.UnitCode, od.Price, od.RealQuantity }
                                    ).GroupBy(r => new { r.OrderDate, r.SortingLine, r.Product, r.UnitCode, r.Price })
                       .Select(r => new { r.Key.OrderDate, r.Key.SortingLine, r.Key.Product, r.Key.UnitCode, r.Key.Price, SumQuantity = r.Sum(p => p.RealQuantity * r.Key.Product.UnitList.Unit02.Count) })
                       .GroupBy(r => new { r.OrderDate, r.SortingLine })
                       .Select(r => new { r.Key.OrderDate, r.Key.SortingLine, Products = r })
                       .ToArray();

            var    employee        = EmployeeRepository.GetQueryable().FirstOrDefault(i => i.UserName == userName);
            string operatePersonID = employee != null?employee.ID.ToString() : "";

            if (employee == null)
            {
                ps.State = StateType.Error;
                ps.Errors.Add("未找到当前用户,或当前用户不可用!");
                NotifyConnection(ps.Clone());
                return;
            }

            decimal sumAllotQuantity     = 0;
            decimal sumAllotLineQuantity = 0;

            MoveBillMaster lastMoveBillMaster = null;

            foreach (var item in temp)
            {
                try
                {
                    if (cancellationToken.IsCancellationRequested)
                    {
                        return;
                    }

                    bool hasError = false;
                    ps.State = StateType.Info;
                    ps.Messages.Add("开始调度" + item.SortingLine.SortingLineName);
                    NotifyConnection(ps.Clone());

                    using (var scope = new TransactionScope())
                    {
                        if (item.Products.Count() > 0)
                        {
                            if (cancellationToken.IsCancellationRequested)
                            {
                                return;
                            }

                            if (lastMoveBillMaster != null && lastMoveBillMaster.WarehouseCode != item.SortingLine.Cell.WarehouseCode)
                            {
                                if (MoveBillCreater.CheckIsNeedSyncMoveBill(lastMoveBillMaster.WarehouseCode))
                                {
                                    MoveBillCreater.CreateSyncMoveBillDetail(lastMoveBillMaster);
                                }
                            }

                            sumAllotLineQuantity = 0;

                            if (cancellationToken.IsCancellationRequested)
                            {
                                return;
                            }
                            MoveBillMaster moveBillMaster = MoveBillCreater.CreateMoveBillMaster(item.SortingLine.Cell.WarehouseCode,
                                                                                                 item.SortingLine.MoveBillTypeCode,
                                                                                                 operatePersonID);
                            moveBillMaster.Origin      = "2";
                            moveBillMaster.Description = "分拣调度生成!";
                            lastMoveBillMaster         = moveBillMaster;
                            foreach (var product in item.Products.ToArray())
                            {
                                if (cancellationToken.IsCancellationRequested)
                                {
                                    return;
                                }

                                decimal sumBillQuantity = temp.Sum(t => t.Products.Sum(p => p.SumQuantity));
                                sumAllotQuantity += product.SumQuantity;

                                decimal sumBillProductQuantity = item.Products.Sum(p => p.SumQuantity);
                                sumAllotLineQuantity += product.SumQuantity;

                                ps.State                = StateType.Processing;
                                ps.TotalProgressName    = "分拣作业调度";
                                ps.TotalProgressValue   = (int)(sumAllotQuantity / sumBillQuantity * 100);
                                ps.CurrentProgressName  = "正在调度:" + item.SortingLine.SortingLineName;
                                ps.CurrentProgressValue = (int)(sumAllotLineQuantity / sumBillProductQuantity * 100);
                                NotifyConnection(ps.Clone());

                                if (cancellationToken.IsCancellationRequested)
                                {
                                    return;
                                }
                                //获取分拣线下限数据
                                var sortingLowerlimitQuantity = sortingLowerlimitQuery.Where(s => s.ProductCode == product.Product.ProductCode &&
                                                                                             s.SortingLineCode == product.SortingLine.SortingLineCode);
                                decimal lowerlimitQuantity = 0;
                                if (sortingLowerlimitQuantity.Count() > 0)
                                {
                                    lowerlimitQuantity = sortingLowerlimitQuantity.Sum(s => s.Quantity);
                                }

                                if (cancellationToken.IsCancellationRequested)
                                {
                                    return;
                                }
                                //获取分拣备货区库存
                                var storageQuantity = storageQuery.Where(s => s.ProductCode == product.Product.ProductCode)
                                                      .Join(sortingLineQuery,
                                                            s => s.Cell,
                                                            l => l.Cell,
                                                            (s, l) => new { l.SortingLineCode, s.Quantity }
                                                            )
                                                      .Where(r => r.SortingLineCode == product.SortingLine.SortingLineCode);
                                decimal storQuantity = 0;
                                if (storageQuantity.Count() > 0)
                                {
                                    storQuantity = storageQuantity.Sum(s => s.Quantity);
                                }
                                //获取当前这个卷烟库存数量
                                string[] areaTypes        = new string[] { "1", "2", "4" };
                                var      areaSumQuantitys = storageQuery.Where(s => areaTypes.Any(t => t == s.Cell.Area.AreaType) &&
                                                                               s.ProductCode == product.Product.ProductCode).ToArray();
                                decimal areaQuantiy = 0;
                                if (areaSumQuantitys.Count() > 0)
                                {
                                    areaQuantiy = areaSumQuantitys.Sum(s => s.Quantity - s.OutFrozenQuantity);
                                }

                                if (cancellationToken.IsCancellationRequested)
                                {
                                    return;
                                }

                                //获取移库量(按整件计)出库量加上下限量减去备货区库存量取整
                                decimal quantity = 0;

                                quantity = Math.Ceiling((product.SumQuantity + lowerlimitQuantity - storQuantity) / product.Product.Unit.Count)
                                           * product.Product.Unit.Count;

                                if (areaQuantiy < quantity)//判断当前这个卷烟库存是否小于移库量
                                {
                                    //出库量减去备货区库存量取整
                                    quantity = Math.Ceiling((product.SumQuantity - storQuantity) / product.Product.Unit.Count)
                                               * product.Product.Unit.Count;

                                    if (areaQuantiy < quantity)
                                    {
                                        //出库量减去备货区库存量
                                        quantity = product.SumQuantity - storQuantity;
                                    }
                                }

                                if (quantity > 0)
                                {
                                    if (cancellationToken.IsCancellationRequested)
                                    {
                                        return;
                                    }
                                    AlltoMoveBill(moveBillMaster, product.Product, item.SortingLine.Cell, ref quantity, cancellationToken, ps, item.SortingLine.Cell.CellCode);
                                }

                                if (quantity > 0)
                                {
                                    //生成移库不完整,可能是库存不足;
                                    hasError = true;
                                    ps.State = StateType.Error;
                                    ps.Errors.Add(product.Product.ProductCode + " " + product.Product.ProductName + " 库存不足!");
                                    NotifyConnection(ps.Clone());
                                }
                            }

                            if (!hasError)
                            {
                                if (cancellationToken.IsCancellationRequested)
                                {
                                    return;
                                }

                                OutBillMaster outBillMaster = OutBillCreater.CreateOutBillMaster(item.SortingLine.Cell.WarehouseCode,
                                                                                                 item.SortingLine.OutBillTypeCode,
                                                                                                 operatePersonID);
                                outBillMaster.Origin      = "2";
                                outBillMaster.Description = "分拣调度生成!";
                                //添加出库单细单
                                foreach (var product in item.Products.ToArray())
                                {
                                    if (cancellationToken.IsCancellationRequested)
                                    {
                                        return;
                                    }
                                    OutBillCreater.AddToOutBillDetail(outBillMaster, product.Product, product.Price, product.SumQuantity);
                                }

                                if (cancellationToken.IsCancellationRequested)
                                {
                                    return;
                                }
                                //添加出库、移库主单和作业调度表
                                SortWorkDispatch sortWorkDisp = AddSortWorkDispMaster(moveBillMaster, outBillMaster, item.SortingLine.SortingLineCode, item.OrderDate);

                                //修改线路调度作业状态和作业ID
                                var sortDispTemp = sortOrderDispatchQuery.Where(s => work.Any(w => w == s.ID) &&
                                                                                s.OrderDate == item.OrderDate &&
                                                                                s.SortingLineCode == item.SortingLine.SortingLineCode);

                                foreach (var sortDisp in sortDispTemp.ToArray())
                                {
                                    if (cancellationToken.IsCancellationRequested)
                                    {
                                        return;
                                    }
                                    sortDisp.SortWorkDispatchID = sortWorkDisp.ID;
                                    sortDisp.WorkStatus         = "2";
                                }
                                if (cancellationToken.IsCancellationRequested)
                                {
                                    return;
                                }
                                SortWorkDispatchRepository.SaveChanges();
                                scope.Complete();
                                ps.Messages.Add(item.SortingLine.SortingLineName + " 调度成功!");
                            }
                            else
                            {
                                ps.State = StateType.Info;
                                ps.Messages.Add(item.SortingLine.SortingLineName + " 调度失败!");
                                NotifyConnection(ps.Clone());
                                return;
                            }
                        }
                    }
                    if (cancellationToken.IsCancellationRequested)
                    {
                        return;
                    }
                    if (MoveBillCreater.CheckIsNeedSyncMoveBill(lastMoveBillMaster.WarehouseCode))
                    {
                        MoveBillCreater.CreateSyncMoveBillDetail(lastMoveBillMaster);
                    }
                    MoveBillMasterRepository.SaveChanges();
                }
                catch (Exception e)
                {
                    ps.State = StateType.Info;
                    ps.Errors.Add(item.SortingLine.SortingLineName + "作业调度失败! 详情:" + e.Message);
                    NotifyConnection(ps.Clone());
                    return;
                }
            }

            ps.State = StateType.Info;
            ps.Messages.Add("调度完成!");
            NotifyConnection(ps.Clone());
        }
Exemplo n.º 2
0
        public bool AllotConfirm(string billNo, string userName, ref string errorInfo)
        {
            try
            {
                var ibm      = OutBillMasterRepository.GetQueryable().FirstOrDefault(i => i.BillNo == billNo && i.Status == "3");
                var employee = EmployeeRepository.GetQueryable().FirstOrDefault(i => i.UserName == userName);

                if (employee == null)
                {
                    errorInfo = "当前用户不存在或不可用,未能审核!";
                    return(false);
                }
                if (ibm == null)
                {
                    errorInfo = "当前订单状态不是已分配,或当前订单不存在!";
                    return(false);
                }
                if (!(ibm.OutBillDetails.All(b => b.BillQuantity == b.AllotQuantity) &&
                      ibm.OutBillDetails.Sum(b => b.BillQuantity) == ibm.OutBillAllots.Sum(a => a.AllotQuantity)))
                {
                    errorInfo = "当前订单分配未完成或分配结果不正确!";
                    return(false);
                }
                if (!string.IsNullOrEmpty(ibm.LockTag))
                {
                    errorInfo = "当前订单其他人正在操作,请稍候重试!";
                    return(false);
                }
                using (var scope = new TransactionScope())
                {
                    if (MoveBillCreater.CheckIsNeedSyncMoveBill(ibm.WarehouseCode))
                    {
                        var moveBillMaster = MoveBillCreater.CreateMoveBillMaster(ibm.WarehouseCode, "3001", employee.ID.ToString());
                        MoveBillCreater.CreateSyncMoveBillDetail(moveBillMaster);
                        moveBillMaster.Status         = "2";
                        moveBillMaster.Description    = "出库生成同步移库单!";
                        moveBillMaster.VerifyDate     = DateTime.Now;
                        moveBillMaster.VerifyPersonID = employee.ID;
                        if (MoveBillCreater.CheckIsNeedSyncMoveBill(ibm.WarehouseCode))
                        {
                            errorInfo = "生成同步移库单不完整,请重新确认!";
                            return(false);
                        }
                        else
                        {
                            ibm.MoveBillMasterBillNo = moveBillMaster.BillNo;
                        }
                    }

                    ibm.Status     = "4";
                    ibm.UpdateTime = DateTime.Now;
                    OutBillMasterRepository.SaveChanges();
                    scope.Complete();
                    return(true);
                }
            }
            catch (Exception e)
            {
                errorInfo = "确认分配失败,详情:" + e.Message;
                return(false);
            }
        }
Exemplo n.º 3
0
        public bool LowerLimitMoveLibrary(string userName, bool isEnableStocking, out string errorInfo)
        {
            IQueryable <SortingLowerlimit> sortingLowerlimitQuery = SortingLowerlimitRepository.GetQueryable();
            IQueryable <SortingLine>       sortingLineQuery       = SortingLineRepository.GetQueryable();
            IQueryable <Storage>           storageQuery           = StorageRepository.GetQueryable();

            bool Result = true;

            errorInfo = string.Empty;

            var sortLowerlimit = sortingLowerlimitQuery.Where(s => s.Quantity > 0)
                                 .GroupBy(s => new { s.SortingLine, s.Product, s.UnitCode })
                                 .Select(l => new { l.Key.SortingLine, l.Key.Product, l.Key.UnitCode, SumQuantity = l.Sum(p => p.Quantity) })
                                 .GroupBy(o => new { o.SortingLine })
                                 .Select(t => new { t.Key.SortingLine, product = t })
                                 .ToArray();

            string cellCode = "";
            var    sortings = sortingLineQuery.Where(s => s.SortingLineCode == s.SortingLineCode).ToArray();

            foreach (var sort in sortings)
            {
                cellCode += sort.Cell.CellCode;
            }

            var    employee        = EmployeeRepository.GetQueryable().FirstOrDefault(i => i.UserName == userName);
            string operatePersonID = employee != null?employee.ID.ToString() : "";

            MoveBillMaster lastMoveBillMaster = null;

            if (sortLowerlimit.Count() > 0)
            {
                foreach (var item in sortLowerlimit)
                {
                    if (item.product.Count() > 0)
                    {
                        if (lastMoveBillMaster != null && lastMoveBillMaster.WarehouseCode != item.SortingLine.Cell.WarehouseCode)
                        {
                            if (MoveBillCreater.CheckIsNeedSyncMoveBill(lastMoveBillMaster.WarehouseCode))
                            {
                                MoveBillCreater.CreateSyncMoveBillDetail(lastMoveBillMaster);
                            }
                        }

                        MoveBillMaster moveBillMaster = MoveBillCreater.CreateMoveBillMaster(item.SortingLine.Cell.WarehouseCode,
                                                                                             item.SortingLine.MoveBillTypeCode,
                                                                                             operatePersonID);
                        moveBillMaster.Origin      = "1";
                        moveBillMaster.Description = "根据 " + item.SortingLine.SortingLineName + "下限生成移库单!";
                        bool hasError = false;
                        lastMoveBillMaster = moveBillMaster;
                        foreach (var product in item.product.ToArray())
                        {
                            //获取分拣备货区库存
                            var storageQuantity = storageQuery.Where(s => s.ProductCode == product.Product.ProductCode)
                                                  .Join(sortingLineQuery,
                                                        s => s.Cell,
                                                        l => l.Cell,
                                                        (s, l) => new { l.SortingLineCode, s.Quantity }
                                                        )
                                                  .Where(r => r.SortingLineCode == product.SortingLine.SortingLineCode);

                            decimal storQuantity = 0;
                            if (storageQuantity.Count() > 0)
                            {
                                storQuantity = storageQuantity.Sum(s => s.Quantity);
                            }

                            //获取移库量(按整件计)
                            decimal quantity = 0;
                            if (isEnableStocking)
                            {
                                quantity = Math.Ceiling(product.SumQuantity - storQuantity);
                            }
                            else
                            {
                                quantity = Math.Ceiling(product.SumQuantity);
                            }

                            CancellationToken cancellationToken = new CancellationToken();
                            ProgressState     ps = new ProgressState();
                            AlltoMoveBill(moveBillMaster, product.Product, item.SortingLine.Cell, ref quantity, cancellationToken, ps, cellCode);

                            if (quantity > 0)
                            {
                                //生成移库不完整,可能是库存不足;
                                hasError   = true;
                                errorInfo += item.SortingLine.SortingLineName + "  卷烟:" + product.Product.ProductCode + "(" + product.Product.ProductName + ")  库存不足!";
                            }
                        }
                        if (!hasError && Result)
                        {
                            MoveBillMasterRepository.SaveChanges();
                            errorInfo += "分拣线:" + item.SortingLine.SortingLineName + " 根据下限生成移库单成功!";

                            if (lastMoveBillMaster != null)
                            {
                                if (MoveBillCreater.CheckIsNeedSyncMoveBill(lastMoveBillMaster.WarehouseCode))
                                {
                                    MoveBillCreater.CreateSyncMoveBillDetail(lastMoveBillMaster);
                                }
                            }
                            MoveBillMasterRepository.SaveChanges();
                        }
                        else
                        {
                            Result = false;
                        }
                    }
                }
            }
            return(Result);
        }
Exemplo n.º 4
0
        public void Dispatch(string connectionId, Model.ProgressState ps, CancellationToken cancellationToken, string workDispatchId, string userName)
        {
            Locker.LockKey = workDispatchId;
            ConnectionId   = connectionId;
            ps.State       = StateType.Start;
            NotifyConnection(ps.Clone());

            IQueryable <SortOrderDispatch> sortOrderDispatchQuery = SortOrderDispatchRepository.GetQueryable();
            IQueryable <SortOrder>         sortOrderQuery         = SortOrderRepository.GetQueryable();
            IQueryable <SortOrderDetail>   sortOrderDetailQuery   = SortOrderDetailRepository.GetQueryable();

            IQueryable <OutBillMaster>  outBillMasterQuery  = OutBillMasterRepository.GetQueryable();
            IQueryable <OutBillDetail>  outBillDetailQuery  = OutBillDetailRepository.GetQueryable();
            IQueryable <MoveBillMaster> moveBillMasterQuery = MoveBillMasterRepository.GetQueryable();
            IQueryable <MoveBillDetail> moveBillDetailQuery = MoveBillDetailRepository.GetQueryable();

            IQueryable <SortingLowerlimit> sortingLowerlimitQuery = SortingLowerlimitRepository.GetQueryable();
            IQueryable <SortingLine>       sortingLineQuery       = SortingLineRepository.GetQueryable();
            IQueryable <Storage>           storageQuery           = StorageRepository.GetQueryable();

            IQueryable <SortWorkDispatch> sortWorkDispatchQuery = SortWorkDispatchRepository.GetQueryable();

            IQueryable <THOK.Authority.DbModel.SystemParameter> systemParQuery = SystemParameterRepository.GetQueryable();


            var IsUselowerlimit = systemParQuery.FirstOrDefault(s => s.ParameterName == "IsUselowerlimit"); //查询调度是否使用下限 0 否 1是
            var isRoundingTray  = systemParQuery.FirstOrDefault(s => s.ParameterName == "isRoundingTray");  //查询立式机总量大于20件的是否取整托盘 0表示不取整托盘。其它任意数字表示大于的总数

            workDispatchId = workDispatchId.Substring(0, workDispatchId.Length - 1);
            int[] work = workDispatchId.Split(',').Select(s => Convert.ToInt32(s)).ToArray();

            //调度表未作业的数据
            var temp = sortOrderDispatchQuery.Join(sortOrderQuery,
                                                   dp => new { dp.OrderDate, dp.DeliverLineCode },
                                                   om => new { om.OrderDate, om.DeliverLineCode },
                                                   (dp, om) => new { dp.ID, dp.WorkStatus, dp.OrderDate, dp.SortingLine, dp.DeliverLineCode, om.OrderID }
                                                   ).Join(sortOrderDetailQuery,
                                                          dm => new { dm.OrderID },
                                                          od => new { od.OrderID },
                                                          (dm, od) => new { dm.ID, dm.WorkStatus, dm.OrderDate, dm.SortingLine, od.Product, od.UnitCode, od.Price, od.RealQuantity }
                                                          ).WhereIn(s => s.ID, work)
                       .Where(s => s.WorkStatus == "1")
                       .GroupBy(r => new { r.OrderDate, r.SortingLine, r.Product, r.UnitCode, r.Price })
                       .Select(r => new { r.Key.OrderDate, r.Key.SortingLine, r.Key.Product, r.Key.UnitCode, r.Key.Price, SumQuantity = r.Sum(p => p.RealQuantity * r.Key.Product.UnitList.Unit02.Count) })
                       .AsParallel()
                       .GroupBy(r => new { r.OrderDate, r.SortingLine })
                       .Select(r => new { r.Key.OrderDate, r.Key.SortingLine, Products = r })
                       .OrderBy(s => s.SortingLine.SortingLineCode)                      //如果取整托盘多余的量是1号线就倒序排序,目前多余的量放入2号线,所以先调度一号线
                       .ToArray();

            var temp1 = sortingLowerlimitQuery.GroupBy(r => new { r.Product, r.SortType })
                        .Select(s => new { s.Key.Product, s.Key.SortType }).ToArray();

            var temp2 = sortOrderDispatchQuery.Join(sortOrderQuery,
                                                    dp => new { dp.OrderDate, dp.DeliverLineCode },
                                                    om => new { om.OrderDate, om.DeliverLineCode },
                                                    (dp, om) => new { dp.ID, dp.WorkStatus, dp.OrderDate, om.OrderID }
                                                    ).Join(sortOrderDetailQuery,
                                                           dm => new { dm.OrderID },
                                                           od => new { od.OrderID },
                                                           (dm, od) => new { dm.ID, dm.WorkStatus, od.Product, od.RealQuantity }
                                                           ).WhereIn(s => s.ID, work)
                        .GroupBy(r => new { r.Product })
                        .Select(s => new { s.Key.Product, Quantity = s.Sum(p => p.RealQuantity * s.Key.Product.UnitList.Unit02.Count) })
                        .ToArray();

            Dictionary <string, decimal> proQuan = new Dictionary <string, decimal>();

            var    employee        = EmployeeRepository.GetQueryable().FirstOrDefault(i => i.UserName == userName);
            string operatePersonID = employee != null?employee.ID.ToString() : "";

            if (employee == null)
            {
                ps.State = StateType.Error;
                ps.Errors.Add("未找到当前用户,或当前用户不可用!");
                NotifyConnection(ps.Clone());
                return;
            }

            decimal sumAllotQuantity     = 0;
            decimal sumAllotLineQuantity = 0;

            MoveBillMaster lastMoveBillMaster = null;

            foreach (var item in temp)
            {
                try
                {
                    if (cancellationToken.IsCancellationRequested)
                    {
                        return;
                    }

                    bool hasError = false;
                    ps.State = StateType.Info;
                    ps.Messages.Add("开始调度" + item.SortingLine.SortingLineName);
                    NotifyConnection(ps.Clone());

                    //using (var scope = new TransactionScope())
                    //{
                    if (item.Products.Count() > 0)
                    {
                        if (cancellationToken.IsCancellationRequested)
                        {
                            return;
                        }

                        if (lastMoveBillMaster != null && lastMoveBillMaster.WarehouseCode != item.SortingLine.Cell.WarehouseCode)
                        {
                            if (MoveBillCreater.CheckIsNeedSyncMoveBill(lastMoveBillMaster.WarehouseCode))
                            {
                                MoveBillCreater.CreateSyncMoveBillDetail(lastMoveBillMaster);
                            }
                        }

                        sumAllotLineQuantity = 0;

                        if (cancellationToken.IsCancellationRequested)
                        {
                            return;
                        }
                        MoveBillMaster moveBillMaster = MoveBillCreater.CreateMoveBillMaster(item.SortingLine.Cell.WarehouseCode,
                                                                                             item.SortingLine.MoveBillTypeCode,
                                                                                             operatePersonID);
                        moveBillMaster.Origin      = "2";
                        moveBillMaster.Description = item.SortingLine.SortingLineCode + " 分拣调度生成!";
                        lastMoveBillMaster         = moveBillMaster;
                        foreach (var product in item.Products.ToArray())
                        {
                            if (product.SumQuantity > 0)
                            {
                                if (cancellationToken.IsCancellationRequested)
                                {
                                    return;
                                }

                                decimal sumBillQuantity = temp.Sum(t => t.Products.Sum(p => p.SumQuantity));
                                sumAllotQuantity += product.SumQuantity;

                                decimal sumBillProductQuantity = item.Products.Sum(p => p.SumQuantity);
                                sumAllotLineQuantity += product.SumQuantity;

                                ps.State                = StateType.Processing;
                                ps.TotalProgressName    = "分拣作业调度";
                                ps.TotalProgressValue   = (int)(sumAllotQuantity / sumBillQuantity * 100);
                                ps.CurrentProgressName  = "正在调度:" + item.SortingLine.SortingLineName;
                                ps.CurrentProgressValue = (int)(sumAllotLineQuantity / sumBillProductQuantity * 100);
                                NotifyConnection(ps.Clone());

                                if (cancellationToken.IsCancellationRequested)
                                {
                                    return;
                                }
                                //获取分拣线下限数据
                                var sortingLowerlimitQuantity = sortingLowerlimitQuery.Where(s => s.ProductCode == product.Product.ProductCode &&
                                                                                             s.SortingLineCode == product.SortingLine.SortingLineCode);
                                decimal lowerlimitQuantity = 0;
                                if (sortingLowerlimitQuantity.Count() > 0)
                                {
                                    lowerlimitQuantity = sortingLowerlimitQuantity.Sum(s => s.Quantity);
                                }

                                if (cancellationToken.IsCancellationRequested)
                                {
                                    return;
                                }
                                //获取分拣备货区库存
                                var storageQuantity = storageQuery.Where(s => s.ProductCode == product.Product.ProductCode)
                                                      .Join(sortingLineQuery,
                                                            s => s.Cell,
                                                            l => l.Cell,
                                                            (s, l) => new { l.SortingLineCode, s.Quantity }
                                                            )
                                                      .Where(r => r.SortingLineCode == product.SortingLine.SortingLineCode);
                                decimal storQuantity = 0;
                                if (storageQuantity.Count() > 0)
                                {
                                    storQuantity = storageQuantity.Sum(s => s.Quantity);
                                }
                                //获取当前这个卷烟库存数量
                                string[] areaTypes        = new string[] { "1", "2", "4" };
                                var      areaSumQuantitys = storageQuery.Where(s => areaTypes.Any(t => t == s.Cell.Area.AreaType) &&
                                                                               s.ProductCode == product.Product.ProductCode).ToArray();
                                decimal areaQuantiy = 0;
                                if (areaSumQuantitys.Count() > 0)
                                {
                                    areaQuantiy = areaSumQuantitys.Sum(s => s.Quantity - s.OutFrozenQuantity);
                                }

                                //是否使用下限
                                if (IsUselowerlimit != null && IsUselowerlimit.ParameterValue == "0")
                                {
                                    lowerlimitQuantity = 0;
                                }

                                if (cancellationToken.IsCancellationRequested)
                                {
                                    return;
                                }

                                //获取移库量(按整件计)出库量加上下限量减去备货区库存量取整
                                decimal quantity = 0;

                                quantity = Math.Ceiling((product.SumQuantity + lowerlimitQuantity - storQuantity) / product.Product.Unit.Count)
                                           * product.Product.Unit.Count;

                                //立式机大于20件的取整托盘
                                //查询这个卷烟是否是立式机的卷烟
                                if (isRoundingTray != null && Convert.ToInt32(isRoundingTray.ParameterValue) > 0)
                                {
                                    var temp3 = temp1.FirstOrDefault(s => s.Product.ProductCode == product.Product.ProductCode && s.SortType == "1");
                                    if (temp3 != null && temp.Count() >= 2 && quantity > 0)
                                    {
                                        //查询这个订单在分拣当中是否存在.大于20件取整托盘,
                                        var SumlowerlimitQuantity = temp2.FirstOrDefault(s => s.Product.ProductCode == temp3.Product.ProductCode);
                                        if (SumlowerlimitQuantity != null && SumlowerlimitQuantity.Quantity > (Convert.ToInt32(isRoundingTray.ParameterValue) * product.Product.Unit.Count))
                                        {
                                            decimal WholeCare          = 0; //托盘数
                                            decimal SumSortingQuantity = 0; //整托盘的数量
                                            decimal Quantity1          = 0;
                                            decimal Quantity2          = 0;
                                            //取2条线数量总和取整托盘
                                            WholeCare          = Math.Ceiling(SumlowerlimitQuantity.Quantity / (product.Product.CellMaxProductQuantity * product.Product.Unit.Count));
                                            SumSortingQuantity = Convert.ToDecimal(WholeCare * (product.Product.Unit.Count * product.Product.CellMaxProductQuantity));

                                            if (item.SortingLine.SortingLineCode == "1")
                                            {
                                                //总订单量减去当前分拣线订单量,这里是另一条线的量
                                                Quantity1 = SumlowerlimitQuantity.Quantity - product.SumQuantity;
                                                if (Quantity1 > 0)
                                                {
                                                    //整托盘数量减去另一条线的量,
                                                    Quantity1 = Math.Ceiling(Quantity1 / product.Product.Unit.Count) * product.Product.Unit.Count;
                                                    Quantity2 = SumSortingQuantity - Quantity1;

                                                    if (Quantity2 >= quantity)
                                                    {
                                                        quantity = Quantity2;
                                                        proQuan.Add(product.Product.ProductCode, SumSortingQuantity - quantity);
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                if (proQuan.Keys.Contains(product.Product.ProductCode))
                                                {
                                                    if (proQuan[product.Product.ProductCode] >= quantity)
                                                    {
                                                        quantity = proQuan[product.Product.ProductCode];
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }

                                //取整托盘,查询这个卷烟是否是通道机的卷烟
                                decimal wholeTray = 0;
                                var     temp4     = temp1.FirstOrDefault(s => s.Product.ProductCode == product.Product.ProductCode && s.SortType == "2");
                                if (product.Product.IsRounding == "2" || temp4 != null)
                                {
                                    wholeTray = Math.Ceiling(quantity / (product.Product.CellMaxProductQuantity * product.Product.Unit.Count));
                                    quantity  = Convert.ToDecimal(wholeTray * (product.Product.Unit.Count * product.Product.CellMaxProductQuantity));
                                }

                                if (areaQuantiy < quantity)    //判断当前这个卷烟库存是否小于移库量
                                {
                                    //出库量减去备货区库存量取整
                                    quantity = Math.Ceiling((product.SumQuantity - storQuantity) / product.Product.Unit.Count)
                                               * product.Product.Unit.Count;

                                    if (areaQuantiy < quantity)
                                    {
                                        //出库量减去备货区库存量
                                        quantity = product.SumQuantity - storQuantity;
                                    }
                                }

                                //不取整的烟直接出库。
                                if (product.Product.IsRounding == "1")
                                {
                                    quantity = product.SumQuantity - storQuantity;
                                }

                                if (quantity > 0)
                                {
                                    if (cancellationToken.IsCancellationRequested)
                                    {
                                        return;
                                    }
                                    AlltoMoveBill(moveBillMaster, product.Product, item.SortingLine.Cell, ref quantity, cancellationToken, ps, item.SortingLine.Cell.CellCode);
                                }

                                if (quantity > 0)
                                {
                                    //生成移库不完整,可能是库存不足;
                                    hasError = true;
                                    ps.State = StateType.Error;
                                    ps.Errors.Add(item.SortingLine.SortingLineCode + "线," + product.Product.ProductCode + " " + product.Product.ProductName + ",库存不足!当前总量:" + Convert.ToDecimal(product.SumQuantity / product.Product.UnitList.Unit02.Count) + "(条),缺少:" + Convert.ToDecimal(quantity / product.Product.UnitList.Unit02.Count) + "(条)");
                                    NotifyConnection(ps.Clone());
                                }
                            }
                        }

                        if (!hasError)
                        {
                            if (cancellationToken.IsCancellationRequested)
                            {
                                return;
                            }

                            OutBillMaster outBillMaster = OutBillCreater.CreateOutBillMaster(item.SortingLine.Cell.WarehouseCode,
                                                                                             item.SortingLine.OutBillTypeCode,
                                                                                             operatePersonID);
                            outBillMaster.Origin      = "2";
                            outBillMaster.Description = item.SortingLine.SortingLineCode + " 分拣调度生成!";
                            //添加出库单细单
                            foreach (var product in item.Products.ToArray())
                            {
                                if (cancellationToken.IsCancellationRequested)
                                {
                                    return;
                                }
                                OutBillCreater.AddToOutBillDetail(outBillMaster, product.Product, product.Price, product.SumQuantity);
                            }

                            if (cancellationToken.IsCancellationRequested)
                            {
                                return;
                            }
                            //添加出库、移库主单和作业调度表
                            SortWorkDispatch sortWorkDisp = AddSortWorkDispMaster(moveBillMaster, outBillMaster, item.SortingLine.SortingLineCode, item.OrderDate);

                            //修改线路调度作业状态和作业ID
                            var sortDispTemp = sortOrderDispatchQuery.WhereIn(s => s.ID, work)
                                               .Where(s => s.OrderDate == item.OrderDate &&
                                                      s.SortingLineCode == item.SortingLine.SortingLineCode);

                            foreach (var sortDisp in sortDispTemp.ToArray())
                            {
                                if (cancellationToken.IsCancellationRequested)
                                {
                                    return;
                                }
                                sortDisp.SortWorkDispatchID = sortWorkDisp.ID;
                                sortDisp.WorkStatus         = "2";
                            }
                            if (cancellationToken.IsCancellationRequested)
                            {
                                return;
                            }
                            SortWorkDispatchRepository.SaveChanges();
                            //scope.Complete();
                            ps.Messages.Add(item.SortingLine.SortingLineName + " 调度成功!");
                        }
                        else
                        {
                            ps.State = StateType.Info;
                            ps.Messages.Add(item.SortingLine.SortingLineName + " 调度失败!");
                            NotifyConnection(ps.Clone());
                            return;
                        }
                    }
                    //}
                }
                catch (Exception e)
                {
                    ps.State = StateType.Info;
                    ps.Errors.Add(item.SortingLine.SortingLineName + "作业调度失败! 详情:" + e.Message);
                    NotifyConnection(ps.Clone());
                    return;
                }
            }

            if (cancellationToken.IsCancellationRequested)
            {
                return;
            }

            if (MoveBillCreater.CheckIsNeedSyncMoveBill(lastMoveBillMaster.WarehouseCode))
            {
                MoveBillCreater.CreateSyncMoveBillDetail(lastMoveBillMaster);
            }
            MoveBillMasterRepository.SaveChanges();

            ps.State = StateType.Info;
            ps.Messages.Add("调度完成!");
            NotifyConnection(ps.Clone());
        }