Exemple #1
0
        /// <summary>
        /// 提前下发PDA拣料任务
        /// </summary>
        public string LesStockPickPDA(string xml)
        {
            try { XDocument.Parse(xml); }
            catch (Exception ex) { return("ERROR:" + ex.Message); }

            try
            {
                using (GeelyPtlEntities dbContext = new GeelyPtlEntities())
                {
                    AST_LesTask_PDA astLesTask = AST_LesTaskConverter.ConvertRequestPDA(xml, dbContext);
                    if (!dbContext.AST_LesTask_PDAs.Any(lt => lt.BillCode == astLesTask.BillCode))
                    {
                        AST_LesTaskMessage_PDA astLesTaskMessage = new AST_LesTaskMessage_PDA();
                        astLesTaskMessage.AST_LesTask_PDA = astLesTask;
                        astLesTaskMessage.ReceivedXml     = xml;
                        astLesTaskMessage.ReceivedTime    = DateTime.Now;

                        dbContext.AST_LesTask_PDAs.Add(astLesTask);
                        dbContext.AST_LesTaskMessage_PDAs.Add(astLesTaskMessage);

                        foreach (AST_LesTaskItem_PDA astLesTaskItem in astLesTask.AST_LesTaskItem_PDAs)
                        {
                            dbContext.AST_LesTaskItem_PDAs.Add(astLesTaskItem);
                        }

                        dbContext.SaveChanges();
                    }
                }

                return(AST_LesTaskConverter.ConvertResponse(xml, true, string.Empty));
            }
            catch (Exception ex)
            {
                string message = ex.Message;
                DbEntityValidationException dbEntityValidationException = ex as DbEntityValidationException;
                if (dbEntityValidationException != null)
                {
                    foreach (DbEntityValidationResult validationResult in dbEntityValidationException.EntityValidationErrors)
                    {
                        foreach (DbValidationError validationError in validationResult.ValidationErrors)
                        {
                            message += Environment.NewLine + validationError.ErrorMessage;
                        }
                    }
                }
                message += Environment.NewLine + ex.StackTrace;

                Logger.Log("LesStockPickPDA", DateTime.Now.ToString("HH:mm:ss") + Environment.NewLine +
                           xml + Environment.NewLine
                           + message + Environment.NewLine
                           + Environment.NewLine);

                return(AST_LesTaskConverter.ConvertResponse(xml, false, message));
            }
        }
        /// <summary>
        /// 按托合并原始分拣任务-PDA。
        /// </summary>
        /// <param name="astPalletArrived">从接口解析还未持久化的托盘抵达记录。</param>
        /// <param name="dbContext">数据上下文。</param>
        public static void GeneratePDA(AST_PalletArrived_PDA astPalletArrived, GeelyPtlEntities dbContext)
        {
            List <AST_LesTask_PDA> astLesTasks = dbContext.AST_LesTask_PDAs
                                                 .Where(lt => lt.BatchCode == astPalletArrived.BatchCode &&
                                                        lt.CFG_PalletId == astPalletArrived.CFG_PalletId &&
                                                        lt.CFG_ChannelId == astPalletArrived.CFG_ChannelId &&
                                                        astPalletArrived.PickBillIds.Contains(lt.BillCode) &&
                                                        !lt.TaskGenerated)
                                                 .ToList();

            if (astLesTasks.Count > 0)
            {
                AST_LesTask_PDA mainAstLesTask = astLesTasks.First();

                AST_PalletTask_PDA astPalletTask = new AST_PalletTask_PDA();
                astPalletTask.CFG_PalletId  = astPalletArrived.CFG_PalletId;
                astPalletTask.BatchCode     = mainAstLesTask.BatchCode;
                astPalletTask.PickBillIds   = astPalletArrived.PickBillIds;
                astPalletTask.ProjectCode   = astPalletArrived.ProjectCode;
                astPalletTask.WbsId         = mainAstLesTask.WbsId;
                astPalletTask.ProjectStep   = astPalletArrived.ProjectStep;
                astPalletTask.CFG_ChannelId = astPalletArrived.CFG_ChannelId;
                astPalletTask.PickStatus    = PickStatus.New;
                astPalletTask.CreateTime    = DateTime.Now;

                dbContext.AST_PalletTask_PDAs.Add(astPalletTask);

                //提取当前目标工位、当前批次、当前巷道、当前托盘未合并的原始任务
                List <int> cfgWorkStationIds = astLesTasks
                                               .Select(lt => lt.CFG_WorkStationId)
                                               .Distinct()
                                               .ToList();
                foreach (int cfgWorkStationId in cfgWorkStationIds)
                {
                    ILookup <int, AST_LesTask_PDA> astLesTaskLookupByFromPalletPosition = astLesTasks
                                                                                          .Where(lt => lt.CFG_WorkStationId == cfgWorkStationId)
                                                                                          .OrderBy(lt => lt.FromPalletPosition)
                                                                                          .ToLookup(lt => lt.FromPalletPosition);

                    //明细的合并,特殊件单独拣
                    foreach (IGrouping <int, AST_LesTask_PDA> astLesTaskGroupingByFromPalletPosition in astLesTaskLookupByFromPalletPosition)
                    {
                        int             fromPalletPosition          = astLesTaskGroupingByFromPalletPosition.Key;
                        AST_LesTask_PDA mainAstLesTaskByWorkStation = astLesTaskGroupingByFromPalletPosition.First();

                        List <AST_LesTaskItem_PDA> normalAstLesTaskItems  = new List <AST_LesTaskItem_PDA>();
                        List <AST_LesTaskItem_PDA> specialAstLesTaskItems = new List <AST_LesTaskItem_PDA>();

                        foreach (AST_LesTask_PDA astLesTask in astLesTaskGroupingByFromPalletPosition)
                        {
                            normalAstLesTaskItems.AddRange(astLesTask.AST_LesTaskItem_PDAs.Where(lti => !lti.IsSpecial));
                            specialAstLesTaskItems.AddRange(astLesTask.AST_LesTaskItem_PDAs.Where(lti => lti.IsSpecial));
                        }

                        //普通件
                        if (normalAstLesTaskItems.Count > 0)
                        {
                            AST_LesTaskItem_PDA mainAstLesTaskItem = normalAstLesTaskItems.First();
                            int totalNormalQuantity = normalAstLesTaskItems.Sum(lti => lti.ToPickQuantity);

                            AST_PalletTaskItem_PDA astPalletTaskItem = new AST_PalletTaskItem_PDA();
                            astPalletTaskItem.AST_PalletTask_PDA = astPalletTask;
                            astPalletTaskItem.CFG_WorkStationId  = cfgWorkStationId;
                            astPalletTaskItem.BoxCode            = mainAstLesTaskByWorkStation.BoxCode;
                            astPalletTaskItem.FromPalletPosition = fromPalletPosition;
                            astPalletTaskItem.MaterialCode       = mainAstLesTaskItem.MaterialCode;
                            astPalletTaskItem.MaterialName       = mainAstLesTaskItem.MaterialName;
                            astPalletTaskItem.MaterialBarcode    = mainAstLesTaskItem.MaterialBarcode;
                            astPalletTaskItem.ToPickQuantity     = totalNormalQuantity;
                            astPalletTaskItem.MaxQuantityInSingleCartPosition = mainAstLesTaskItem.MaxQuantityInSingleCartPosition;
                            astPalletTaskItem.IsSpecial  = false;
                            astPalletTaskItem.IsBig      = mainAstLesTaskItem.IsBig;
                            astPalletTaskItem.PickStatus = PickStatus.New;

                            dbContext.AST_PalletTaskItem_PDAs.Add(astPalletTaskItem);

                            foreach (AST_LesTaskItem_PDA normalAstLesTaskItem in normalAstLesTaskItems)
                            {
                                normalAstLesTaskItem.AST_PalletTaskItem_PDA = astPalletTaskItem;
                            }
                        }

                        //特殊件
                        foreach (AST_LesTaskItem_PDA astLesTaskItem in specialAstLesTaskItems)
                        {
                            AST_PalletTaskItem_PDA astPalletTaskItem = new AST_PalletTaskItem_PDA();
                            astPalletTaskItem.AST_PalletTask_PDA = astPalletTask;
                            astPalletTaskItem.CFG_WorkStationId  = cfgWorkStationId;
                            astPalletTaskItem.BoxCode            = mainAstLesTaskByWorkStation.BoxCode;
                            astPalletTaskItem.FromPalletPosition = fromPalletPosition;
                            astPalletTaskItem.MaterialCode       = astLesTaskItem.MaterialCode;
                            astPalletTaskItem.MaterialName       = astLesTaskItem.MaterialName;
                            astPalletTaskItem.MaterialBarcode    = astLesTaskItem.MaterialBarcode;
                            astPalletTaskItem.ToPickQuantity     = astLesTaskItem.ToPickQuantity;
                            astPalletTaskItem.MaxQuantityInSingleCartPosition = astLesTaskItem.MaxQuantityInSingleCartPosition;
                            astPalletTaskItem.IsSpecial  = true;
                            astPalletTaskItem.IsBig      = astLesTaskItem.IsBig;
                            astPalletTaskItem.PickStatus = PickStatus.New;

                            dbContext.AST_PalletTaskItem_PDAs.Add(astPalletTaskItem);

                            astLesTaskItem.AST_PalletTaskItem_PDA = astPalletTaskItem;
                        }

                        //标记已合并按托任务
                        foreach (AST_LesTask_PDA astLesTask in astLesTaskGroupingByFromPalletPosition)
                        {
                            astLesTask.TaskGenerated = true;
                        }
                    }
                }
            }
        }
Exemple #3
0
        /// <summary>
        /// 转换 LES 原始任务报文-PDA。
        /// </summary>
        /// <param name="xml">LES 原始任务报文。</param>
        /// <param name="dbContext">数据库上下文。</param>
        /// <returns>成功解析的实体。</returns>
        public static AST_LesTask_PDA ConvertRequestPDA(string xml, GeelyPtlEntities dbContext)
        {
            XDocument       xDocument        = XDocument.Parse(xml);
            XElement        serviceElement   = xDocument.Descendants("Service").First();
            XElement        dataElement      = serviceElement.Descendants("Data").First();
            XElement        requestElement   = dataElement.Descendants("Request").First();
            XElement        taskElement      = requestElement.Descendants("ASSEMBLE").First();
            List <XElement> taskItemElements = requestElement.Descendants("ASSEMBLEITEM").ToList();

            if (taskItemElements.Count == 0)
            {
                throw new InterfaceDataException("没有明细。");
            }

            AST_LesTask_PDA astLesTask = new AST_LesTask_PDA();

            astLesTask.ProjectCode = taskElement.Element("ProjectCode").Value;
            astLesTask.WbsId       = taskElement.Element("PS_POSID").Value;
            astLesTask.ProjectStep = taskElement.Element("StageCode").Value;
            astLesTask.BillCode    = taskElement.Element("PickNO").Value;
            astLesTask.BillDate    = DateTime.Parse(taskElement.Element("Bill_Date").Value, CultureInfo.InvariantCulture);

            //工位随时会新增
            string cfgWorkStationCode = taskElement.Element("STATIONCODE").Value;

            if (string.IsNullOrEmpty(cfgWorkStationCode))
            {
                cfgWorkStationCode = "#";
            }
            CFG_WorkStation cfgWorkStation = dbContext.CFG_WorkStations
                                             .FirstOrDefault(ws => ws.Code == cfgWorkStationCode);

            if (cfgWorkStation == null)
            {
                using (GeelyPtlEntities innerDbContext = new GeelyPtlEntities())
                {
                    cfgWorkStation      = new CFG_WorkStation();
                    cfgWorkStation.Code = cfgWorkStationCode;
                    cfgWorkStation.Name = cfgWorkStation.Code;

                    innerDbContext.CFG_WorkStations.Add(cfgWorkStation);

                    //每个工位有 8 个车位
                    for (int position = 1; position <= 8; position++)
                    {
                        CFG_WorkStationCurrentCart cfgWorkStationCurrentCart = new CFG_WorkStationCurrentCart();
                        cfgWorkStationCurrentCart.CFG_WorkStation = cfgWorkStation;
                        cfgWorkStationCurrentCart.Position        = position;

                        innerDbContext.CFG_WorkStationCurrentCarts.Add(cfgWorkStationCurrentCart);
                    }

                    innerDbContext.SaveChanges();
                }
            }

            astLesTask.CFG_WorkStationId = cfgWorkStation.Id;
            astLesTask.GzzList           = taskElement.Element("GZZLIST").Value;
            astLesTask.BatchCode         = taskElement.Element("BatchCode").Value;

            string      cfgChannelCode = taskElement.Element("ChannelCode").Value;
            CFG_Channel cfgChannel     = dbContext.CFG_Channels
                                         .FirstOrDefault(c => c.Code == cfgChannelCode);

            if (cfgChannel == null)
            {
                throw new InterfaceDataException("无效的分拣巷道:" + cfgChannelCode);
            }

            astLesTask.CFG_ChannelId = cfgChannel.Id;

            //托盘随时会增加
            string     cfgPalletCode = taskElement.Element("PalletCode").Value;
            CFG_Pallet cfgPallet     = dbContext.CFG_Pallets
                                       .FirstOrDefault(p => p.Code == cfgPalletCode);

            if (cfgPallet == null)
            {
                using (GeelyPtlEntities innerDbContext = new GeelyPtlEntities())
                {
                    cfgPallet            = new CFG_Pallet();
                    cfgPallet.Code       = cfgPalletCode;
                    cfgPallet.PalletType = "01";

                    innerDbContext.CFG_Pallets.Add(cfgPallet);

                    innerDbContext.SaveChanges();
                }
            }

            astLesTask.CFG_PalletId       = cfgPallet.Id;
            astLesTask.BoxCode            = taskElement.Element("BoxCode").Value;
            astLesTask.FromPalletPosition = int.Parse(taskElement.Element("FromPalletPosition").Value, CultureInfo.InvariantCulture);
            if (astLesTask.FromPalletPosition < 1 || astLesTask.FromPalletPosition > 10)
            {
                astLesTask.FromPalletPosition = 1;
            }
            astLesTask.RequestTime = DateTime.Now;

            foreach (XElement taskItemElement in taskItemElements)
            {
                AST_LesTaskItem_PDA astLesTaskItem = new AST_LesTaskItem_PDA();
                astLesTaskItem.AST_LesTask_PDA = astLesTask;
                astLesTaskItem.BillDetailId    = taskItemElement.Element("BillDtlID").Value;
                astLesTaskItem.MaterialCode    = taskItemElement.Element("MaterialCode").Value;
                astLesTaskItem.MaterialName    = taskItemElement.Element("MaterialName").Value;
                astLesTaskItem.MaterialBarcode = taskItemElement.Element("MaterialBarcode").Value;
                astLesTaskItem.ToPickQuantity  = (int)decimal.Parse(taskItemElement.Element("NEED_PICK_NUM").Value, CultureInfo.InvariantCulture);
                astLesTaskItem.MaxQuantityInSingleCartPosition = (int)decimal.Parse(taskItemElement.Element("MaxQuantityInSingleCartPosition").Value, CultureInfo.InvariantCulture);
                if (astLesTaskItem.MaxQuantityInSingleCartPosition <= 0)
                {
                    astLesTaskItem.MaxQuantityInSingleCartPosition = int.MaxValue;
                }
                astLesTaskItem.IsSpecial = taskItemElement.Element("IsSpecial").Value == "1";
                astLesTaskItem.IsBig     = taskItemElement.Element("STORETYPE").Value == "04";

                astLesTask.AST_LesTaskItem_PDAs.Add(astLesTaskItem);
            }

            return(astLesTask);
        }
        /// <summary>
        /// 按巷道查询当前PDA任务。
        /// </summary>
        /// <param name="cfgChannelId">巷道的主键。</param>
        /// <param name="dPtlPalletLastArriveTime">PTL托盘最后到达时间。</param>
        private AssortingKanbanTaskInfo QueryPDACurrentTaskInfo(int cfgChannelId, DateTime dPtlPalletLastArriveTime)
        {
            AssortingKanbanTaskInfo result = new AssortingKanbanTaskInfo();

            try
            {
                using (GeelyPtlEntities dbContext = new GeelyPtlEntities())
                {
                    DateTime minTime = DateTime.Today;
                    DateTime maxTime = minTime.AddDays(1);

                    AST_PalletTask_PDA astPalletTask = null;
                    if (dPtlPalletLastArriveTime == DateTime.MinValue)
                    {
                        astPalletTask = dbContext.AST_PalletTask_PDAs
                                        .Where(pt => pt.CFG_ChannelId == cfgChannelId && pt.PickStatus != PickStatus.Finished && pt.CreateTime > minTime && pt.CreateTime < maxTime)
                                        .OrderByDescending(pt => pt.Id)
                                        .FirstOrDefault();
                    }
                    else
                    {
                        astPalletTask = dbContext.AST_PalletTask_PDAs
                                        .Where(pt => pt.CFG_ChannelId == cfgChannelId && pt.PickStatus != PickStatus.Finished && pt.CreateTime > minTime && pt.CreateTime <maxTime &&
                                                                                                                                                                           pt.CreateTime> dPtlPalletLastArriveTime)
                                        .OrderByDescending(pt => pt.Id)
                                        .FirstOrDefault();
                    }

                    //AST_PalletTask_PDA astPalletTask = dbContext.AST_PalletTask_PDAs
                    //                                   .Where(pt => pt.CFG_ChannelId == cfgChannelId && pt.PickStatus != PickStatus.Finished && pt.CreateTime > minTime && pt.CreateTime < maxTime)
                    //                                   .OrderByDescending(pt => pt.Id)
                    //                                   .FirstOrDefault();

                    //AST_CartTask astCartTask = dbContext.AST_CartTaskItems
                    //                               .Where(cti => cti.AST_CartTask.CFG_ChannelId == cfgChannelId && cti.AssortingStatus != AssortingStatus.Finished)
                    //                               .Select(cti => cti.AST_CartTask)
                    //                               .FirstOrDefault();

                    if (astPalletTask == null)
                    {
                        result = null;
                        return(result);
                    }

                    string currentBatchCode = astPalletTask.BatchCode;

                    if (!string.IsNullOrEmpty(currentBatchCode))
                    {
                        AST_LesTask_PDA currentBatchFirstAstLesTask = dbContext.AST_LesTask_PDAs
                                                                      .Where(lt => lt.CFG_ChannelId == cfgChannelId && lt.BatchCode == currentBatchCode && lt.CFG_PalletId == astPalletTask.CFG_PalletId)
                                                                      .OrderByDescending(lt => lt.Id).FirstOrDefault();

                        result.CurrentBatchInfo.PickType = ConverterPickTypeToText(currentBatchFirstAstLesTask.WbsId); //PDA手持机拣料
                        //result.CurrentBatchInfo.PickType = currentBatchFirstAstLesTask.WbsId; //PDA手持机拣料
                        //result.CurrentBatchInfo.PickType = 2; //PDA手持机拣料
                        result.CurrentBatchInfo.ProjectCode         = currentBatchFirstAstLesTask.ProjectCode;
                        result.CurrentBatchInfo.ProjectStep         = currentBatchFirstAstLesTask.ProjectStep;
                        result.CurrentBatchInfo.BatchCode           = currentBatchFirstAstLesTask.BatchCode;
                        result.CurrentBatchInfo.FinishedPalletCount = dbContext.AST_PalletTask_PDAs
                                                                      .Count(pr => pr.CFG_ChannelId == cfgChannelId && pr.BatchCode == currentBatchCode && pr.PickStatus == PickStatus.Finished);
                        //result.CurrentBatchInfo.FinishedPalletCount = 0;
                        result.CurrentBatchInfo.TotalPalletCount = dbContext.AST_LesTask_PDAs
                                                                   .Where(lt => lt.CFG_ChannelId == cfgChannelId && lt.BatchCode == currentBatchCode)
                                                                   .Select(lt => lt.CFG_PalletId)
                                                                   .Distinct()
                                                                   .Count();
                        //以下 4 个汇总界面不展示
                        result.CurrentBatchInfo.FinishedMaterialTypeCount = 0;
                        result.CurrentBatchInfo.TotalMaterialTypeCount    = 0;
                        result.CurrentBatchInfo.FinishedMaterialCount     = 0;
                        result.CurrentBatchInfo.TotalMaterialCount        = 0;

                        List <CFG_ChannelCurrentCart> cfgChannelCurrentCarts = dbContext.CFG_ChannelCurrentCarts
                                                                               .Where(ccc => ccc.CFG_ChannelId == cfgChannelId)
                                                                               .OrderBy(ccc => ccc.Position)
                                                                               .ToList();
                        foreach (CFG_ChannelCurrentCart cfgChannelCurrentCart in cfgChannelCurrentCarts)
                        {
                            CFG_ChannelCurrentCartDto cfgChannelCurrentCartDto = new CFG_ChannelCurrentCartDto();
                            cfgChannelCurrentCartDto.CFG_ChannelCurrentCartId = cfgChannelCurrentCart.Id;
                            cfgChannelCurrentCartDto.CFG_ChannelId            = cfgChannelCurrentCart.CFG_ChannelId;
                            cfgChannelCurrentCartDto.Position   = cfgChannelCurrentCart.Position;
                            cfgChannelCurrentCartDto.CFG_CartId = cfgChannelCurrentCart.CFG_CartId;
                            if (cfgChannelCurrentCart.CFG_Cart != null)
                            {
                                cfgChannelCurrentCartDto.CartCode = cfgChannelCurrentCart.CFG_Cart.Code;
                                cfgChannelCurrentCartDto.CartName = cfgChannelCurrentCart.CFG_Cart.Name;
                            }
                        }

                        if (astPalletTask != null)
                        {
                            AST_PalletTaskDto astPalletTaskDto = new AST_PalletTaskDto();
                            astPalletTaskDto.AST_PalletTaskId     = astPalletTask.Id;
                            astPalletTaskDto.CFG_PalletId         = astPalletTask.CFG_PalletId;
                            astPalletTaskDto.PalletCode           = astPalletTask.CFG_Pallet.Code;
                            astPalletTaskDto.PalletType           = astPalletTask.CFG_Pallet.PalletType;
                            astPalletTaskDto.PalletRotationStatus = astPalletTask.CFG_Pallet.PalletRotationStatus;

                            List <AST_PalletTaskItem_PDA> astPalletTaskItems = astPalletTask.AST_PalletTaskItem_PDAs
                                                                               .OrderBy(pti => pti.FromPalletPosition)
                                                                               .ToList();
                            foreach (AST_PalletTaskItem_PDA astPalletTaskItem in astPalletTaskItems)
                            {
                                AST_PalletTaskItemDto astPalletTaskItemDto = new AST_PalletTaskItemDto();
                                astPalletTaskItemDto.AST_PalletTaskItemId = astPalletTaskItem.Id;
                                astPalletTaskItemDto.FromPalletPosition   = astPalletTaskItem.FromPalletPosition;
                                astPalletTaskItemDto.WorkStationCode      = astPalletTaskItem.CFG_WorkStation.Code;
                                astPalletTaskItemDto.MaterialCode         = astPalletTaskItem.MaterialCode;
                                astPalletTaskItemDto.MaterialName         = astPalletTaskItem.MaterialName;
                                astPalletTaskItemDto.MaterialBarcode      = astPalletTaskItem.MaterialBarcode;
                                astPalletTaskItemDto.ToPickQuantity       = astPalletTaskItem.ToPickQuantity;
                                astPalletTaskItemDto.IsSpecial            = astPalletTaskItem.IsSpecial;
                                astPalletTaskItemDto.IsBig          = astPalletTaskItem.IsBig;
                                astPalletTaskItemDto.PickStatus     = astPalletTaskItem.PickStatus;
                                astPalletTaskItemDto.PickedQuantity = astPalletTaskItem.PickedQuantity;

                                astPalletTaskDto.Items.Add(astPalletTaskItemDto);
                            }

                            result.CurrentPalletTask = astPalletTaskDto;
                        }

                        //if (astCartTask != null)
                        //{
                        //    AST_CartTaskDto astCartTaskDto = new AST_CartTaskDto();
                        //    astCartTaskDto.AST_CartTaskId = astCartTask.Id;
                        //    astCartTaskDto.CFG_CartId = astCartTask.CFG_CartId;
                        //    astCartTaskDto.CartCode = astCartTask.CFG_Cart.Code;
                        //    astCartTaskDto.CartName = astCartTask.CFG_Cart.Name;

                        //    List<AST_CartTaskItem> astCartTaskItems = astCartTask.AST_CartTaskItems
                        //                                                  .OrderBy(cti => cti.CartPosition)
                        //                                                  .ToList();
                        //    foreach (AST_CartTaskItem astCartTaskItem in astCartTaskItems)
                        //    {
                        //        AST_PalletTaskItem astPalletTaskItem = astCartTaskItem.AST_PalletTaskItem;

                        //        AST_CartTaskItemDto astCartTaskItemDto = new AST_CartTaskItemDto();
                        //        astCartTaskItemDto.AST_CartTaskItemId = astCartTaskItem.Id;
                        //        astCartTaskItemDto.CartPosition = astCartTaskItem.CartPosition;
                        //        astCartTaskItemDto.WorkStationCode = astCartTask.CFG_WorkStation.Code;
                        //        astCartTaskItemDto.MaterialCode = astPalletTaskItem.MaterialCode;
                        //        astCartTaskItemDto.MaterialName = astPalletTaskItem.MaterialName;
                        //        astCartTaskItemDto.MaterialBarcode = astPalletTaskItem.MaterialBarcode;
                        //        astCartTaskItemDto.MaxQuantityInSingleCartPosition = astPalletTaskItem.MaxQuantityInSingleCartPosition;
                        //        astCartTaskItemDto.IsSpecial = astPalletTaskItem.IsSpecial;
                        //        astCartTaskItemDto.IsBig = astPalletTaskItem.IsBig;
                        //        astCartTaskItemDto.AssortingStatus = astCartTaskItem.AssortingStatus;
                        //        astCartTaskItemDto.PickedQuantity = astCartTaskItem.AssortedQuantity;

                        //        astCartTaskDto.Items.Add(astCartTaskItemDto);
                        //    }

                        //    result.CurrentCartTask = astCartTaskDto;
                        //}
                    }
                }
            }
            catch (Exception ex)
            {
                string message = ex.Message;
                DbEntityValidationException dbEntityValidationException = ex as DbEntityValidationException;
                if (dbEntityValidationException != null)
                {
                    foreach (DbEntityValidationResult validationResult in dbEntityValidationException.EntityValidationErrors)
                    {
                        foreach (DbValidationError validationError in validationResult.ValidationErrors)
                        {
                            message += Environment.NewLine + validationError.ErrorMessage;
                        }
                    }
                }
                message += Environment.NewLine + ex.StackTrace;

                Logger.Log("ForAssortingKanbanService.QueryPDACurrentTaskInfo", DateTime.Now.ToString("HH:mm:ss") + Environment.NewLine
                           + message + Environment.NewLine
                           + Environment.NewLine);
            }

            return(result);
        }
        void threadStart(object unused)
        {
            while (!this.threadNeedQuit)
            {
                try
                {
                    if (this.holdingDays > 0 && this.holdingDays < TimeSpan.MaxValue.TotalDays)
                    {
                        DateTime minTime = DateTime.Today.Subtract(TimeSpan.FromDays(this.holdingDays));

                        using (GeelyPtlEntities dbContext = new GeelyPtlEntities())
                        {
                            //装配指引部分
                            List <ASM_AssembleIndication> asmAssembleIndications = dbContext.ASM_AssembleIndications
                                                                                   .Where(ai => ai.CarArrivedTime < minTime &&
                                                                                          ai.AssembleStatus == AssembleStatus.Finished &&
                                                                                          ai.ASM_AssembleResults.All(ar => ar.ASM_AssembleResultMessage.SentSuccessful))
                                                                                   .ToList();
                            foreach (ASM_AssembleIndication asmAssembleIndication in asmAssembleIndications)
                            {
                                ASM_AssembleIndicationMessage     asmAssembleIndicationMessage = asmAssembleIndication.ASM_AssembleIndicationMessage;
                                List <ASM_AssembleIndicationItem> asmAssembleIndicationItems   = asmAssembleIndication.ASM_AssembleIndicationItems.ToList();
                                List <ASM_Task>           asmTasks           = asmAssembleIndication.ASM_Tasks.ToList();
                                List <ASM_AssembleResult> asmAssembleResults = asmAssembleIndication.ASM_AssembleResults.ToList();

                                foreach (ASM_AssembleResult asmAssembleResult in asmAssembleResults)
                                {
                                    ASM_AssembleResultMessage     asmAssembleResultMessage = asmAssembleResult.ASM_AssembleResultMessage;
                                    List <ASM_AssembleResultItem> asmAssembleResultItems   = asmAssembleResult.ASM_AssembleResultItems.ToList();

                                    dbContext.ASM_AssembleResultItems.RemoveRange(asmAssembleResultItems);
                                    dbContext.ASM_AssembleResultMessages.Remove(asmAssembleResultMessage);
                                    dbContext.ASM_AssembleResults.Remove(asmAssembleResult);
                                }

                                foreach (ASM_Task asmTask in asmTasks)
                                {
                                    List <ASM_TaskItem> asmTaskItems = asmTask.ASM_TaskItems.ToList();

                                    dbContext.ASM_TaskItems.RemoveRange(asmTaskItems);
                                    dbContext.ASM_Tasks.Remove(asmTask);
                                }

                                dbContext.ASM_AssembleIndicationItems.RemoveRange(asmAssembleIndicationItems);
                                dbContext.ASM_AssembleIndicationMessages.Remove(asmAssembleIndicationMessage);
                                dbContext.ASM_AssembleIndications.Remove(asmAssembleIndication);
                            }

                            //分拣部分
                            List <AST_PalletArrived> astPalletArriveds = dbContext.AST_PalletArriveds
                                                                         .Where(pa => pa.ArrivedTime < minTime)
                                                                         .ToList();
                            foreach (AST_PalletArrived astPalletArrived in astPalletArriveds)
                            {
                                AST_PalletArrivedMessage astPalletArrivedMessage = astPalletArrived.AST_PalletArrivedMessage;

                                dbContext.AST_PalletArrivedMessages.Remove(astPalletArrivedMessage);
                                dbContext.AST_PalletArriveds.Remove(astPalletArrived);
                            }

                            List <AST_PalletTask> astPalletTasks = dbContext.AST_PalletTasks
                                                                   .Where(pt => pt.CreateTime < minTime &&
                                                                          pt.PickStatus == PickStatus.Finished)
                                                                   .ToList();
                            foreach (AST_PalletTask astPalletTask in astPalletTasks)
                            {
                                List <AST_PalletTaskItem> astPalletTaskItems = astPalletTask.AST_PalletTaskItems.ToList();
                                foreach (AST_PalletTaskItem astPalletTaskItem in astPalletTaskItems)
                                {
                                    List <AST_LesTaskItem>  astLesTaskItems  = astPalletTaskItem.AST_LesTaskItems.ToList();
                                    List <AST_CartTaskItem> astCartTaskItems = astPalletTaskItem.AST_CartTaskItems.ToList();

                                    List <AST_LesTask>        astLesTasks        = new List <AST_LesTask>();
                                    List <AST_LesTaskMessage> astLesTaskMessages = new List <AST_LesTaskMessage>();
                                    foreach (AST_LesTaskItem astLesTaskItem in astLesTaskItems)
                                    {
                                        AST_LesTask        astLesTask        = astLesTaskItem.AST_LesTask;
                                        AST_LesTaskMessage astLesTaskMessage = astLesTask.AST_LesTaskMessage;

                                        if (astLesTask != null && !astLesTasks.Contains(astLesTask))
                                        {
                                            astLesTasks.Add(astLesTask);
                                        }
                                        if (astLesTaskMessage != null && !astLesTaskMessages.Contains(astLesTaskMessage))
                                        {
                                            astLesTaskMessages.Add(astLesTaskMessage);
                                        }

                                        dbContext.AST_LesTaskItems.Remove(astLesTaskItem);
                                    }
                                    dbContext.AST_LesTaskMessages.RemoveRange(astLesTaskMessages);
                                    dbContext.AST_LesTasks.RemoveRange(astLesTasks);

                                    List <AST_CartTask> astCartTasks = new List <AST_CartTask>();
                                    foreach (AST_CartTaskItem astCartTaskItem in astCartTaskItems)
                                    {
                                        AST_CartTask astCartTask = astCartTaskItem.AST_CartTask;

                                        if (astCartTask != null && !astCartTasks.Contains(astCartTask))
                                        {
                                            astCartTasks.Add(astCartTask);
                                        }

                                        dbContext.AST_CartTaskItems.Remove(astCartTaskItem);
                                    }
                                    dbContext.AST_CartTasks.RemoveRange(astCartTasks);

                                    dbContext.AST_PalletTaskItems.Remove(astPalletTaskItem);
                                }

                                dbContext.AST_PalletTasks.Remove(astPalletTask);
                            }

                            List <AST_PalletResult> astPalletResults = dbContext.AST_PalletResults
                                                                       .Where(pr => pr.EndPickTime < minTime &&
                                                                              pr.AST_PalletResultMessage.SentSuccessful)
                                                                       .ToList();
                            foreach (AST_PalletResult astPalletResult in astPalletResults)
                            {
                                AST_PalletResultMessage     astPalletResultMessage = astPalletResult.AST_PalletResultMessage;
                                List <AST_PalletResultItem> astPalletResultItems   = astPalletResult.AST_PalletResultItems.ToList();

                                dbContext.AST_PalletResultItems.RemoveRange(astPalletResultItems);
                                dbContext.AST_PalletResultMessages.Remove(astPalletResultMessage);
                                dbContext.AST_PalletResults.Remove(astPalletResult);
                            }

                            List <AST_CartResult> astCartResults = dbContext.AST_CartResults
                                                                   .Where(cr => cr.EndPickTime < minTime &&
                                                                          cr.AST_CartResultMessage.SentSuccessful)
                                                                   .ToList();
                            foreach (AST_CartResult astCartResult in astCartResults)
                            {
                                AST_CartResultMessage     astCartResultMessage = astCartResult.AST_CartResultMessage;
                                List <AST_CartResultItem> astCartResultItems   = astCartResult.AST_CartResultItems.ToList();

                                dbContext.AST_CartResultItems.RemoveRange(astCartResultItems);
                                dbContext.AST_CartResultMessages.Remove(astCartResultMessage);
                                dbContext.AST_CartResults.Remove(astCartResult);
                            }

                            //手持机分拣部分
                            List <AST_PalletArrived_PDA> astPalletArrived_PDAs = dbContext.AST_PalletArrived_PDAs
                                                                                 .Where(pa => pa.ArrivedTime < minTime)
                                                                                 .ToList();
                            foreach (AST_PalletArrived_PDA astPalletArrived_PDA in astPalletArrived_PDAs)
                            {
                                AST_PalletArrivedMessage_PDA astPalletArrivedMessage_PDA = astPalletArrived_PDA.AST_PalletArrivedMessage_PDA;

                                dbContext.AST_PalletArrivedMessage_PDAs.Remove(astPalletArrivedMessage_PDA);
                                dbContext.AST_PalletArrived_PDAs.Remove(astPalletArrived_PDA);
                            }

                            List <AST_PalletTask_PDA> astPalletTask_PDAs = dbContext.AST_PalletTask_PDAs
                                                                           .Where(pt => pt.CreateTime < minTime &&
                                                                                  pt.PickStatus == PickStatus.Finished)
                                                                           .ToList();
                            foreach (AST_PalletTask_PDA astPalletTask_PDA in astPalletTask_PDAs)
                            {
                                List <AST_PalletTaskItem_PDA> astPalletTaskItem_PDAs = astPalletTask_PDA.AST_PalletTaskItem_PDAs.ToList();
                                foreach (AST_PalletTaskItem_PDA astPalletTaskItem_PDA in astPalletTaskItem_PDAs)
                                {
                                    List <AST_LesTaskItem_PDA> astLesTaskItem_PDAs = astPalletTaskItem_PDA.AST_LesTaskItem_PDAs.ToList();

                                    List <AST_LesTask_PDA>        astLesTask_PDAs        = new List <AST_LesTask_PDA>();
                                    List <AST_LesTaskMessage_PDA> astLesTaskMessage_PDAs = new List <AST_LesTaskMessage_PDA>();
                                    foreach (AST_LesTaskItem_PDA astLesTaskItem_PDA in astLesTaskItem_PDAs)
                                    {
                                        // AST_LesTaskItem_PDA -> AST_LesTask_PDA FK ERROR
                                        AST_LesTask_PDA        astLesTask_PDA        = astLesTaskItem_PDA.AST_LesTask_PDA;
                                        AST_LesTaskMessage_PDA astLesTaskMessage_PDA = null;
                                        if (astLesTask_PDA != null)
                                        {
                                            astLesTaskMessage_PDA = astLesTask_PDA.AST_LesTaskMessage_PDA;
                                        }

                                        if (astLesTask_PDA != null && !astLesTask_PDAs.Contains(astLesTask_PDA))
                                        {
                                            astLesTask_PDAs.Add(astLesTask_PDA);
                                        }
                                        if (astLesTaskMessage_PDA != null && !astLesTaskMessage_PDAs.Contains(astLesTaskMessage_PDA))
                                        {
                                            astLesTaskMessage_PDAs.Add(astLesTaskMessage_PDA);
                                        }

                                        dbContext.AST_LesTaskItem_PDAs.Remove(astLesTaskItem_PDA);
                                    }
                                    dbContext.AST_LesTaskMessage_PDAs.RemoveRange(astLesTaskMessage_PDAs);
                                    dbContext.AST_LesTask_PDAs.RemoveRange(astLesTask_PDAs);

                                    dbContext.AST_PalletTaskItem_PDAs.Remove(astPalletTaskItem_PDA);
                                }

                                dbContext.AST_PalletTask_PDAs.Remove(astPalletTask_PDA);
                            }

                            List <AST_PalletPickResult_PDA> astPalletPickResults = dbContext.AST_PalletPickResult_PDAs
                                                                                   .Where(pa => pa.ReceivedTime < minTime)
                                                                                   .ToList();
                            foreach (AST_PalletPickResult_PDA astPalletPickResult in astPalletPickResults)
                            {
                                dbContext.AST_PalletPickResult_PDAs.Remove(astPalletPickResult);
                            }

                            List <AST_PalletPickResultMessage_PDA> astPalletPickResultMessages = dbContext.AST_PalletPickResultMessage_PDAs
                                                                                                 .Where(t => t.ReceivedTime < minTime).ToList();
                            foreach (AST_PalletPickResultMessage_PDA astPalletPickResultMessage in astPalletPickResultMessages)
                            {
                                dbContext.AST_PalletPickResultMessage_PDAs.Remove(astPalletPickResultMessage);
                            }

                            //AGV搬运部分
                            List <DST_DistributeTask> dstDistributeTasks = dbContext.DST_DistributeTasks.Where(t => t.reqTime < minTime).ToList();
                            foreach (DST_DistributeTask dstDistributeTask in dstDistributeTasks)
                            {
                                dbContext.DST_DistributeTasks.Remove(dstDistributeTask);
                            }

                            List <DST_DistributeTaskResult> dstDistributeTaskResults = dbContext.DST_DistributeTaskResults.Where(t => t.receiveTime < minTime).ToList();
                            foreach (DST_DistributeTaskResult dstDistributeTaskResult in dstDistributeTaskResults)
                            {
                                dbContext.DST_DistributeTaskResults.Remove(dstDistributeTaskResult);
                            }

                            List <DST_DistributeArriveTask> dstDistributeArriveTasks = dbContext.DST_DistributeArriveTasks.Where(t => t.receiveTime < minTime).ToList();
                            foreach (DST_DistributeArriveTask dstDistributeArriveTask in dstDistributeArriveTasks)
                            {
                                dbContext.DST_DistributeArriveTasks.Remove(dstDistributeArriveTask);
                            }

                            List <DST_DistributeArriveTaskResult> dstDistributeArriveTaskResults = dbContext.DST_DistributeArriveTaskResults.Where(t => t.sendTime < minTime).ToList();
                            foreach (DST_DistributeArriveTaskResult dstDistributeArriveTaskResult in dstDistributeArriveTaskResults)
                            {
                                dbContext.DST_DistributeArriveTaskResults.Remove(dstDistributeArriveTaskResult);
                            }

                            List <DST_DistributeArriveResult> dstDistributeArriveResults = dbContext.DST_DistributeArriveResults.Where(t => t.arriveTime < minTime).ToList();
                            foreach (DST_DistributeArriveResult dstDistributeArriveResult in dstDistributeArriveResults)
                            {
                                dbContext.DST_DistributeArriveResults.Remove(dstDistributeArriveResult);
                            }

                            dbContext.SaveChanges();
                        }
                    }
                }
                catch (Exception ex)
                {
                    string message = ex.Message;
                    DbEntityValidationException dbEntityValidationException = ex as DbEntityValidationException;
                    if (dbEntityValidationException != null)
                    {
                        foreach (DbEntityValidationResult validationResult in dbEntityValidationException.EntityValidationErrors)
                        {
                            foreach (DbValidationError validationError in validationResult.ValidationErrors)
                            {
                                message += Environment.NewLine + validationError.ErrorMessage;
                            }
                        }
                    }
                    message += Environment.NewLine + ex.StackTrace;

                    Logger.Log(this.GetType().Name, DateTime.Now.ToString("HH:mm:ss") + Environment.NewLine
                               + message + Environment.NewLine
                               + Environment.NewLine);
                }
                finally
                {
                    Thread.Sleep(this.threadPeriod);
                }
            }
        }