コード例 #1
0
        public System.Data.DataTable GetSortWorkDispatch(int page, int rows, string OrderDate, string SortingLineCode, string DispatchStatus)
        {
            System.Data.DataTable         dt = new System.Data.DataTable();
            IQueryable <SortWorkDispatch> SortWorkDispatchQuery = SortWorkDispatchRepository.GetQueryable();
            var sortWorkDispatch = SortWorkDispatchQuery.Where(s => s.DispatchStatus != "4");

            if (OrderDate != string.Empty && OrderDate != null)
            {
                OrderDate        = Convert.ToDateTime(OrderDate).ToString("yyyyMMdd");
                sortWorkDispatch = sortWorkDispatch.Where(s => s.OrderDate == OrderDate);
            }
            if (SortingLineCode != string.Empty && SortingLineCode != null)
            {
                sortWorkDispatch = sortWorkDispatch.Where(s => s.SortingLineCode == SortingLineCode);
            }
            if (DispatchStatus != string.Empty && DispatchStatus != null)
            {
                sortWorkDispatch = sortWorkDispatch.Where(s => s.DispatchStatus == DispatchStatus);
            }
            var temp = sortWorkDispatch.OrderBy(b => new { b.OrderDate, b.SortingLineCode, b.DispatchStatus })
                       .AsEnumerable().Select(b => new
            {
                b.ID,
                b.OrderDate,
                b.SortingLineCode,
                b.SortingLine.SortingLineName,
                b.OutBillNo,
                b.MoveBillNo,
                b.DispatchBatch,
                DispatchStatus = WhatStatus(b.DispatchStatus),
                IsActive       = b.IsActive == "1" ? "可用" : "不可用",
                UpdateTime     = b.UpdateTime.ToString("yyyy-MM-dd HH:mm:ss")
            });

            dt.Columns.Add("订单日期", typeof(string));
            dt.Columns.Add("分拣线编码", typeof(string));
            dt.Columns.Add("分拣线名称", typeof(string));
            dt.Columns.Add("作业调度批次", typeof(string));
            dt.Columns.Add("出库单编号", typeof(string));
            dt.Columns.Add("移库单编号", typeof(string));
            dt.Columns.Add("作业状态", typeof(string));
            dt.Columns.Add("是否可用", typeof(string));
            dt.Columns.Add("更新时间", typeof(string));
            foreach (var t in temp)
            {
                dt.Rows.Add(
                    t.OrderDate
                    , t.SortingLineCode
                    , t.SortingLineName
                    , t.DispatchBatch
                    , t.OutBillNo
                    , t.MoveBillNo
                    , t.DispatchStatus
                    , t.IsActive
                    , t.UpdateTime
                    );
            }
            return(dt);
        }
コード例 #2
0
        public bool AntiTrial(string id, ref string errorInfo)
        {
            try
            {
                Guid ID       = new Guid(id);
                var  sortWork = SortWorkDispatchRepository.GetQueryable()
                                .FirstOrDefault(s => s.ID == ID);

                if (sortWork == null)
                {
                    errorInfo = "当前选择的调度记录不存在,未能反审!";
                    return(false);
                }
                if (sortWork.DispatchStatus != "2")
                {
                    errorInfo = "当前选择的调度记录不是已审核,未能反审!";
                    return(false);
                }
                if (sortWork.OutBillMaster.Status != "2")
                {
                    errorInfo = "当前选择的调度记录出库单不是已审核,未能反审!";
                    return(false);
                }
                if (sortWork.MoveBillMaster.Status != "2")
                {
                    errorInfo = "当前选择的调度记录移库单不是已审核,未能反审!";
                    return(false);
                }
                using (var scope = new TransactionScope())
                {
                    //出库反审
                    var outMaster = OutBillMasterRepository.GetQueryable().FirstOrDefault(o => o.BillNo == sortWork.OutBillNo);
                    outMaster.Status     = "1";
                    outMaster.UpdateTime = DateTime.Now;
                    //移库反审
                    var moveMater = MoveBillMasterRepository.GetQueryable().FirstOrDefault(m => m.BillNo == sortWork.MoveBillNo);
                    moveMater.Status     = "1";
                    moveMater.UpdateTime = DateTime.Now;
                    //分拣作业反审
                    sortWork.DispatchStatus = "1";
                    sortWork.UpdateTime     = DateTime.Now;
                    SortWorkDispatchRepository.SaveChanges();
                    scope.Complete();
                    return(true);
                }
            }
            catch (Exception e)
            {
                errorInfo = "反审失败,详情:" + e.Message;
                return(false);
            }
        }
コード例 #3
0
        public object GetDetails(int page, int rows, string OrderDate, string SortingLineCode, string DispatchStatus)
        {
            IQueryable <SortWorkDispatch> SortWorkDispatchQuery = SortWorkDispatchRepository.GetQueryable();
            var sortWorkDispatch = SortWorkDispatchQuery.Where(s => s.ID == s.ID);

            if (DispatchStatus == string.Empty || DispatchStatus == null)
            {
                sortWorkDispatch = SortWorkDispatchQuery.Where(s => s.DispatchStatus != "4");
            }

            if (OrderDate != string.Empty && OrderDate != null)
            {
                OrderDate        = Convert.ToDateTime(OrderDate).ToString("yyyyMMdd");
                sortWorkDispatch = sortWorkDispatch.Where(s => s.OrderDate == OrderDate);
            }
            if (SortingLineCode != string.Empty && SortingLineCode != null)
            {
                sortWorkDispatch = sortWorkDispatch.Where(s => s.SortingLineCode == SortingLineCode);
            }
            if (DispatchStatus != string.Empty && DispatchStatus != null)
            {
                sortWorkDispatch = sortWorkDispatch.Where(s => s.DispatchStatus == DispatchStatus);
            }
            var temp = sortWorkDispatch.OrderBy(b => new { b.OrderDate, b.SortingLineCode, b.DispatchStatus }).AsEnumerable().Select(b => new
            {
                b.ID,
                b.OrderDate,
                b.SortingLineCode,
                b.SortingLine.SortingLineName,
                b.OutBillNo,
                b.MoveBillNo,
                b.DispatchBatch,
                DispatchStatus = WhatStatus(b.DispatchStatus),
                IsActive       = b.IsActive == "1" ? "可用" : "不可用",
                UpdateTime     = (string)b.UpdateTime.ToString("yyyy-MM-dd HH:mm:ss")
            });

            int total = temp.Count();

            temp = temp.Skip((page - 1) * rows).Take(rows);
            return(new { total, rows = temp.ToArray() });
        }
コード例 #4
0
        private SortWorkDispatch AddSortWorkDispMaster(MoveBillMaster moveBillMaster, OutBillMaster outBillMaster, string sortingLineCode, string orderDate)
        {
            //添加分拣作业调度表
            SortWorkDispatch sortWorkDispatch = new SortWorkDispatch();
            var workDispatch = SortWorkDispatchRepository.GetQueryable()
                               .FirstOrDefault(w => w.OrderDate == orderDate &&
                                               w.SortingLineCode == sortingLineCode);

            sortWorkDispatch.ID              = Guid.NewGuid();
            sortWorkDispatch.OrderDate       = orderDate;
            sortWorkDispatch.SortingLineCode = sortingLineCode;
            sortWorkDispatch.DispatchBatch   = workDispatch == null ? "1" : (Convert.ToInt32(workDispatch.DispatchBatch) + 1).ToString();
            sortWorkDispatch.OutBillNo       = outBillMaster.BillNo;
            sortWorkDispatch.MoveBillNo      = moveBillMaster.BillNo;
            sortWorkDispatch.DispatchStatus  = "1";
            sortWorkDispatch.IsActive        = "1";
            sortWorkDispatch.UpdateTime      = DateTime.Now;
            SortWorkDispatchRepository.Add(sortWorkDispatch);
            return(sortWorkDispatch);
        }
コード例 #5
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());
        }
コード例 #6
0
        public bool Settle(string id, ref string errorInfo)
        {
            try
            {
                Guid ID       = new Guid(id);
                var  sortWork = SortWorkDispatchRepository.GetQueryable().FirstOrDefault(s => s.ID == ID);

                if (sortWork == null)
                {
                    errorInfo = "当前选择的调度记录不存在,未能结单!";
                    return(false);
                }
                if (sortWork.DispatchStatus == "1")
                {
                    errorInfo = "当前选择的调度记录不是执行中,未能结单!";
                    return(false);
                }
                if (sortWork.MoveBillMaster.Status == "1")
                {
                    errorInfo = "当前选择的调度记录移库单不是执行中,未能结单!";
                    return(false);
                }
                using (var scope = new TransactionScope())
                {
                    //移库细单解锁冻结量
                    var moveDetail = MoveBillDetailRepository.GetQueryable()
                                     .Where(m => m.BillNo == sortWork.MoveBillNo && m.Status != "2");

                    if (moveDetail.Any())
                    {
                        var sourceStorages = moveDetail.Select(m => m.OutStorage).ToArray();
                        var targetStorages = moveDetail.Select(m => m.InStorage).ToArray();

                        if (!Locker.Lock(sourceStorages) ||
                            !Locker.Lock(targetStorages))
                        {
                            errorInfo = "锁定储位失败,储位其他人正在操作,无法取消分配请稍候重试!";
                            return(false);
                        }

                        moveDetail.AsParallel().ForAll(
                            (Action <MoveBillDetail>) delegate(MoveBillDetail m)
                        {
                            if (m.InStorage.ProductCode == m.ProductCode &&
                                m.OutStorage.ProductCode == m.ProductCode &&
                                m.InStorage.InFrozenQuantity >= m.RealQuantity &&
                                m.OutStorage.OutFrozenQuantity >= m.RealQuantity)
                            {
                                m.InStorage.InFrozenQuantity   -= m.RealQuantity;
                                m.OutStorage.OutFrozenQuantity -= m.RealQuantity;
                                m.InStorage.LockTag             = string.Empty;
                                m.OutStorage.LockTag            = string.Empty;
                            }
                            else
                            {
                                throw new Exception("储位的卷烟或移库冻结量与当前分配不符,信息可能被异常修改,不能结单!");
                            }
                        }
                            );
                        //解锁分拣线路调度的状态,以便重新做作业调度;
                        foreach (var sortDisp in sortWork.SortOrderDispatchs)
                        {
                            sortDisp.SortWorkDispatchID = null;
                            sortDisp.WorkStatus         = "1";
                        }
                    }
                    else
                    {
                        //出库单作自动出库
                        var storages = StorageRepository.GetQueryable().Where(s => s.CellCode == sortWork.SortingLine.CellCode &&
                                                                              s.Quantity - s.OutFrozenQuantity > 0).ToArray();

                        if (!Locker.Lock(storages))
                        {
                            errorInfo = "锁定储位失败,储位其他人正在操作,无法取消分配请稍候重试!";
                            return(false);
                        }
                        var outAllots  = sortWork.OutBillMaster.OutBillAllots;
                        var outDetails = OutBillDetailRepository.GetQueryableIncludeProduct()
                                         .Where(o => o.BillNo == sortWork.OutBillMaster.BillNo);
                        outDetails.ToArray().AsParallel().ForAll(
                            (Action <OutBillDetail>) delegate(OutBillDetail o)
                        {
                            var ss = storages.Where(s => s.ProductCode == o.ProductCode).ToArray();
                            foreach (var s in ss)
                            {
                                lock (s)
                                {
                                    if (o.BillQuantity - o.AllotQuantity > 0)
                                    {
                                        decimal allotQuantity = s.Quantity;
                                        decimal billQuantity  = o.BillQuantity - o.AllotQuantity;
                                        allotQuantity         = allotQuantity < billQuantity ? allotQuantity : billQuantity;
                                        o.AllotQuantity      += allotQuantity;
                                        o.RealQuantity       += allotQuantity;
                                        s.Quantity           -= allotQuantity;

                                        var billAllot = new OutBillAllot()
                                        {
                                            BillNo          = sortWork.OutBillMaster.BillNo,
                                            OutBillDetailId = o.ID,
                                            ProductCode     = o.ProductCode,
                                            CellCode        = s.CellCode,
                                            StorageCode     = s.StorageCode,
                                            UnitCode        = o.UnitCode,
                                            AllotQuantity   = allotQuantity,
                                            RealQuantity    = allotQuantity,
                                            FinishTime      = DateTime.Now,
                                            Status          = "2"
                                        };
                                        lock (sortWork.OutBillMaster.OutBillAllots)
                                        {
                                            sortWork.OutBillMaster.OutBillAllots.Add(billAllot);
                                        }
                                    }
                                    else
                                    {
                                        break;
                                    }
                                }
                            }

                            if (o.BillQuantity - o.AllotQuantity > 0)
                            {
                                throw new Exception(sortWork.SortingLine.SortingLineName + " " + o.ProductCode + " " + o.Product.ProductName + "分拣备货区库存不足,未能结单!");
                            }
                        }
                            );

                        storages.AsParallel().ForAll(s => s.LockTag = string.Empty);
                    }

                    //出库结单
                    var outMaster = OutBillMasterRepository.GetQueryable()
                                    .FirstOrDefault(o => o.BillNo == sortWork.OutBillNo);
                    outMaster.Status     = "6";
                    outMaster.UpdateTime = DateTime.Now;
                    //移库结单
                    var moveMater = MoveBillMasterRepository.GetQueryable()
                                    .FirstOrDefault(m => m.BillNo == sortWork.MoveBillNo);
                    moveMater.Status     = "4";
                    moveMater.UpdateTime = DateTime.Now;
                    //分拣作业结单
                    sortWork.DispatchStatus = "4";
                    sortWork.UpdateTime     = DateTime.Now;
                    SortWorkDispatchRepository.SaveChanges();
                    scope.Complete();
                    return(true);
                }
            }
            catch (AggregateException ex)
            {
                errorInfo = "结单失败,详情:" + ex.InnerExceptions.Select(i => i.Message).Aggregate((m, n) => m + n);
                return(false);
            }
            catch (Exception e)
            {
                errorInfo = "结单失败,详情:" + e.Message;
                return(false);
            }
        }
コード例 #7
0
        public bool Audit(string id, string userName, ref string errorInfo)
        {
            try
            {
                Guid ID       = new Guid(id);
                var  sortWork = SortWorkDispatchRepository.GetQueryable().FirstOrDefault(s => s.ID == ID);
                var  employee = EmployeeRepository.GetQueryable().FirstOrDefault(i => i.UserName == userName);

                if (employee == null)
                {
                    errorInfo = "当前用户不存在或不可用,未能审核!";
                    return(false);
                }
                if (sortWork == null)
                {
                    errorInfo = "当前选择的调度记录不存在,未能审核!";
                    return(false);
                }
                if (sortWork.DispatchStatus != "1")
                {
                    errorInfo = "当前选择的调度记录不是已调度,未能审核!";
                    return(false);
                }
                if (sortWork.OutBillMaster.Status != "1")
                {
                    errorInfo = "当前选择的调度记录出库单不是已录入,未能审核!";
                    return(false);
                }
                if (sortWork.MoveBillMaster.Status != "1")
                {
                    errorInfo = "当前选择的调度记录移库单不是已录入,未能审核!";
                    return(false);
                }
                using (var scope = new TransactionScope())
                {
                    //出库审核
                    var outMaster = OutBillMasterRepository.GetQueryable()
                                    .FirstOrDefault(o => o.BillNo == sortWork.OutBillNo);
                    outMaster.Status         = "2";
                    outMaster.VerifyPersonID = employee.ID;
                    outMaster.VerifyDate     = DateTime.Now;
                    outMaster.UpdateTime     = DateTime.Now;
                    //移库审核
                    var moveMater = MoveBillMasterRepository.GetQueryable()
                                    .FirstOrDefault(m => m.BillNo == sortWork.MoveBillNo);
                    moveMater.Status         = "2";
                    moveMater.VerifyPersonID = employee.ID;
                    moveMater.VerifyDate     = DateTime.Now;
                    moveMater.UpdateTime     = DateTime.Now;
                    //分拣作业审核
                    sortWork.DispatchStatus = "2";
                    sortWork.UpdateTime     = DateTime.Now;
                    SortWorkDispatchRepository.SaveChanges();
                    scope.Complete();
                    return(true);
                }
            }
            catch (Exception e)
            {
                errorInfo = "审核失败,详情:" + e.Message;
                return(false);
            }
        }
コード例 #8
0
        public bool Delete(string id, ref string errorInfo)
        {
            try
            {
                Guid ID = new Guid(id);
                var  sortOrderDispatch = SortWorkDispatchRepository.GetQueryable().FirstOrDefault(s => s.ID == ID);
                if (sortOrderDispatch == null)
                {
                    errorInfo = "当前选择的调度记录不存在,未能删除!";
                    return(false);
                }
                if (sortOrderDispatch.DispatchStatus != "1")
                {
                    errorInfo = "当前选择的调度记录不是已调度,未能删除!";
                    return(false);
                }
                if (sortOrderDispatch.OutBillMaster.Status != "1")
                {
                    errorInfo = "当前选择的调度记录出库单不是已录入,未能删除!";
                    return(false);
                }
                if (sortOrderDispatch.MoveBillMaster.Status != "1")
                {
                    errorInfo = "当前选择的调度记录移库单不是已录入,未能删除!";
                    return(false);
                }

                using (var scope = new TransactionScope())
                {
                    //解锁移库冻结量
                    var moveDetail = MoveBillDetailRepository.GetQueryable()
                                     .Where(m => m.BillNo
                                            == sortOrderDispatch.MoveBillNo);

                    var sourceStorages = moveDetail.Select(m => m.OutStorage).ToArray();
                    var targetStorages = moveDetail.Select(m => m.InStorage).ToArray();

                    if (!Locker.Lock(sourceStorages) ||
                        !Locker.Lock(targetStorages))
                    {
                        errorInfo = "锁定储位失败,储位其他人正在操作,无法取消分配请稍候重试!";
                        return(false);
                    }

                    moveDetail.AsParallel().ForAll(
                        (Action <MoveBillDetail>) delegate(MoveBillDetail m)
                    {
                        if (m.InStorage.ProductCode == m.ProductCode &&
                            m.OutStorage.ProductCode == m.ProductCode &&
                            m.InStorage.InFrozenQuantity >= m.RealQuantity &&
                            m.OutStorage.OutFrozenQuantity >= m.RealQuantity)
                        {
                            m.InStorage.InFrozenQuantity   -= m.RealQuantity;
                            m.OutStorage.OutFrozenQuantity -= m.RealQuantity;
                            m.InStorage.LockTag             = string.Empty;
                            m.OutStorage.LockTag            = string.Empty;
                        }
                        else
                        {
                            throw new Exception("储位的卷烟或移库冻结量与当前分配不符,信息可能被异常修改,不能删除!");
                        }
                    }
                        );

                    Del(MoveBillDetailRepository, sortOrderDispatch.MoveBillMaster.MoveBillDetails); //删除移库细单
                    MoveBillMasterRepository.Delete(sortOrderDispatch.MoveBillMaster);               //删除移库主单

                    Del(OutBillDetailRepository, sortOrderDispatch.OutBillMaster.OutBillDetails);    //删除出库细单
                    OutBillMasterRepository.Delete(sortOrderDispatch.OutBillMaster);                 //删除出库主单

                    //修改线路调度表中作业状态
                    var sortDisp = SortOrderDispatchRepository.GetQueryable()
                                   .Where(s => s.SortWorkDispatchID
                                          == sortOrderDispatch.ID);
                    foreach (var item in sortDisp.ToArray())
                    {
                        item.WorkStatus         = "1";
                        item.SortWorkDispatchID = null;
                    }
                    SortWorkDispatchRepository.Delete(sortOrderDispatch);
                    SortWorkDispatchRepository.SaveChanges();
                    scope.Complete();
                    return(true);
                }
            }
            catch (Exception e)
            {
                errorInfo = "删除失败,详情:" + e.Message;
                return(false);
            }
        }
コード例 #9
0
        /// <summary>获得移库细单信息</summary>
        public System.Data.DataTable GetMoveBillDetail(int page, int rows, string BillNo, bool isAbnormity, bool isGroup, out string sortingName)
        {
            System.Data.DataTable dt = new System.Data.DataTable();
            IQueryable <THOK.Authority.DbModel.SystemParameter> systemParQuery = SystemParameterRepository.GetQueryable();

            BillNo = BillNo.Substring(0, BillNo.Length - 1);
            string[] BillNos = BillNo.Split(',');
            sortingName = "合单";
            isGroup     = true;
            if (BillNos.Count() > 0)
            {
                IQueryable <MoveBillDetail> MoveBillDetailQuery = MoveBillDetailRepository.GetQueryable();
                if (BillNos.Count() == 1)
                {
                    string billnoStr = BillNos[0].ToString();
                    var    sortWork  = SortWorkDispatchRepository.GetQueryable().FirstOrDefault(i => i.MoveBillNo == billnoStr);
                    if (sortWork != null)
                    {
                        sortingName = sortWork.SortingLine.SortingLineName;
                    }
                    else
                    {
                        sortingName = "";
                    }
                }
                var IsSummary = systemParQuery.FirstOrDefault(s => s.ParameterName == "IsSummary");//打印是否合单汇总0:不汇总;1:汇总
                if (IsSummary != null && IsSummary.ParameterValue == "0")
                {
                    isGroup = false;
                }
                var moves = MoveBillDetailQuery.Where(i => BillNos.Any(b => b == i.BillNo));
                if (isAbnormity == false)
                {
                    moves = moves.Where(i => i.Product.IsAbnormity != "1");
                }
                if (isGroup)
                {
                    var moveBillDetail = moves.Where(s => s.OutCell.Area.AreaType != "5" && s.Product.IsAbnormity == "1" && s.InCell.Area.AreaType == "5")
                                         .GroupBy(m => new { m.ProductCode, m.Product.ProductName, m.Product })
                                         .Select(r => new { r.Key.ProductCode, r.Key.ProductName, r.Key.Product, RealQuantity = r.Sum(p => p.RealQuantity) }).AsEnumerable()
                                         .Select(r => new { r.Product, isAbnormity = r.Product.IsAbnormity == "1" ? "*" : " ", r.ProductCode, r.ProductName, RealQuantity = r.RealQuantity / r.Product.Unit.Count, strRealQuantity = r.RealQuantity / r.Product.UnitList.Unit02.Count })
                                         .OrderBy(r => r.RealQuantity).ThenBy(s => s.Product.BelongRegion);

                    var moveBillDetail1 = moves.Where(s => s.OutCell.Area.AreaType != "5" && s.Product.IsAbnormity != "1" && s.InCell.Area.AreaType == "5")
                                          .GroupBy(m => new { m.ProductCode, m.Product.ProductName, m.Product })
                                          .Select(r => new { r.Key.ProductCode, r.Key.ProductName, r.Key.Product, RealQuantity = r.Sum(p => p.RealQuantity) }).AsEnumerable()
                                          .Select(r => new { r.Product, isAbnormity = r.Product.IsAbnormity == "1" ? "*" : " ", r.ProductCode, r.ProductName, RealQuantity = r.RealQuantity / r.Product.Unit.Count, strRealQuantity = r.RealQuantity / r.Product.UnitList.Unit02.Count })
                                          .OrderBy(r => r.RealQuantity).ThenBy(s => s.Product.BelongRegion);

                    var moveBillDetail2 = moves.Where(s => s.OutCell.Area.AreaType == "5" && s.InCell.Area.AreaType == "5").AsEnumerable()
                                          .Select(r => new { OutCellName = r.OutCell.CellName, InCellName = r.InCell.CellName, r.Product, isAbnormity = r.Product.IsAbnormity == "1" ? "*" : " ", r.ProductCode, r.Product.ProductName, RealQuantity = r.RealQuantity / r.Product.Unit.Count, strRealQuantity = r.RealQuantity / r.Product.UnitList.Unit02.Count })
                                          .OrderBy(r => r.RealQuantity).ThenBy(s => s.Product.BelongRegion);

                    dt.Columns.Add("产品代码", typeof(string));
                    dt.Columns.Add("产品名称", typeof(string));
                    dt.Columns.Add("数量(件)", typeof(string));
                    dt.Columns.Add("数量(条)", typeof(string));
                    dt.Columns.Add("异形烟(*)", typeof(string));
                    dt.Columns.Add("分拣互移", typeof(string));
                    dt.Columns.Add("01线签字", typeof(string));
                    dt.Columns.Add("02线签字", typeof(string));
                    foreach (var m in moveBillDetail)//异形烟
                    {
                        dt.Rows.Add
                        (
                            m.ProductCode
                            , m.ProductName
                            , m.RealQuantity
                            , m.strRealQuantity
                            , m.isAbnormity
                        );
                    }

                    foreach (var m in moveBillDetail1)//不是整托的烟和整托的烟排序
                    {
                        dt.Rows.Add
                        (
                            m.ProductCode
                            , m.ProductName
                            , m.RealQuantity
                            , m.strRealQuantity
                            , m.isAbnormity
                        );
                    }

                    foreach (var m in moveBillDetail2)//分拣线互移的烟
                    {
                        dt.Rows.Add
                        (
                            m.ProductCode
                            , m.ProductName
                            , Convert.ToDecimal(m.RealQuantity)
                            , Convert.ToDecimal(m.strRealQuantity)
                            , m.isAbnormity
                            , m.OutCellName + "移入" + m.InCellName
                        );
                    }
                    if (moveBillDetail.Count() > 0 || moveBillDetail1.Count() > 0 || moveBillDetail2.Count() > 0)
                    {
                        dt.Rows.Add(null, "总数:", moveBillDetail.Sum(m => m.RealQuantity) + moveBillDetail1.Sum(s => s.RealQuantity) + moveBillDetail2.Sum(b => b.RealQuantity));
                        dt.Rows.Add("出库:", null, "验收:", null);
                    }
                }
                else
                {
                    var moveBillDetail = moves.AsEnumerable().Select(i => new
                    {
                        OutCellName       = i.OutCell.CellName,
                        OutStorageCode    = i.OutStorageCode,
                        InCellName        = i.InCell.CellName,
                        InStorageCode     = i.InStorageCode,
                        ProductCode       = i.ProductCode,
                        ProductName       = i.Product.ProductName,
                        UnitCode          = i.UnitCode,
                        UnitName          = i.Unit.UnitName,
                        RealQuantity      = i.RealQuantity / i.Unit.Count,
                        strRealQuantity   = i.RealQuantity / i.Product.UnitList.Unit02.Count,
                        OperatePersonName = i.OperatePerson == null ? string.Empty : i.OperatePerson.EmployeeName,
                        Status            = i.Status == "0" ? "未开始" : i.Status == "1" ? "已申请" : i.Status == "2" ? "已完成" : "空",
                        isAbnormity       = i.Product.IsAbnormity == "1" ? "*" : "",
                    }).OrderBy(i => i.OutCellName).ThenBy(i => i.ProductCode);

                    dt.Columns.Add("移出储位名称", typeof(string));
                    dt.Columns.Add("移入储位名称", typeof(string));
                    dt.Columns.Add("产品代码", typeof(string));
                    dt.Columns.Add("产品名称", typeof(string));
                    //dt.Columns.Add("单位编码", typeof(string));
                    //dt.Columns.Add("单位名称", typeof(string));
                    dt.Columns.Add("数量(件)", typeof(string));
                    dt.Columns.Add("数量(条)", typeof(string));
                    dt.Columns.Add("异形烟(*)", typeof(string));
                    foreach (var m in moveBillDetail)
                    {
                        dt.Rows.Add
                        (
                            m.OutCellName
                            , m.InCellName
                            , m.ProductCode
                            , m.ProductName
                            //, m.UnitCode
                            //, m.UnitName
                            , m.RealQuantity
                            , m.strRealQuantity
                            , m.isAbnormity
                        );
                    }
                    if (moveBillDetail.Count() > 0)
                    {
                        dt.Rows.Add(null, null, null, null, "总数:", moveBillDetail.Sum(m => m.RealQuantity));
                    }
                }
            }
            return(dt);
        }
コード例 #10
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());
        }
コード例 #11
0
ファイル: TaskService.cs プロジェクト: radtek/wms_rfid_mdj
        private bool FinishMoveBillTask(Task task)
        {
            var moveDetail = MoveBillDetailRepository.GetQueryable()
                             .Where(i => i.BillNo == task.OrderID &&
                                    i.ID == task.AllotID &&
                                    i.Status == "1")
                             .FirstOrDefault();

            if (moveDetail != null &&
                (moveDetail.MoveBillMaster.Status == "2" ||
                 moveDetail.MoveBillMaster.Status == "3"
                ))
            {
                if (string.IsNullOrEmpty(moveDetail.InStorage.LockTag) &&
                    string.IsNullOrEmpty(moveDetail.OutStorage.LockTag) &&
                    moveDetail.InStorage.InFrozenQuantity >= moveDetail.RealQuantity &&
                    moveDetail.OutStorage.OutFrozenQuantity >= moveDetail.RealQuantity)
                {
                    moveDetail.Status                        = "2";
                    moveDetail.InStorage.Quantity           += moveDetail.RealQuantity;
                    moveDetail.InStorage.InFrozenQuantity   -= moveDetail.RealQuantity;
                    moveDetail.InStorage.Rfid                = "";
                    moveDetail.OutStorage.Quantity          -= moveDetail.RealQuantity;
                    moveDetail.OutStorage.OutFrozenQuantity -= moveDetail.RealQuantity;
                    moveDetail.OutStorage.Rfid               = "";
                    //判断移入的时间是否小于移出的时间
                    if (DateTime.Compare(moveDetail.InStorage.StorageTime, moveDetail.OutStorage.StorageTime) == 1)
                    {
                        moveDetail.InStorage.StorageTime = moveDetail.OutStorage.StorageTime;
                    }
                    moveDetail.MoveBillMaster.Status = "3";
                    moveDetail.FinishTime            = DateTime.Now;
                    var sortwork = SortWorkDispatchRepository.GetQueryable()
                                   .Where(s => s.MoveBillMaster.BillNo == moveDetail.MoveBillMaster.BillNo &&
                                          s.DispatchStatus == "2")
                                   .FirstOrDefault();
                    //修改分拣调度作业状态
                    if (sortwork != null)
                    {
                        sortwork.DispatchStatus = "3";
                    }
                    if (moveDetail.MoveBillMaster.MoveBillDetails.All(c => c.Status == "2"))
                    {
                        moveDetail.MoveBillMaster.Status = "4";
                    }

                    MoveBillDetailRepository.SaveChanges();
                    return(true);
                }
                else
                {
                    //"需确认移库的数据别人在操作或者完成的数量不对,完成出错!";
                    return(false);
                }
            }
            else
            {
                //"需确认移库的数据查询为空或者主单状态不对,完成出错!";
                return(false);
            }
        }