Exemplo n.º 1
0
        public void CompleteTrimSchedule(TrimScheduleInfo schedule, int id, int employeeId)
        {
            PartSequencingDataContext dbSeq = new PartSequencingDataContext();
            EmployeeDatabase dbEmp = new EmployeeDatabase();
            SequencingFactory factory = new SequencingFactory();

            var employee = dbEmp.GetEmployeeInfo(employeeId);
            var seqStations = dbSeq.SequencingStationSettings.Where(i => i.SequencingLocationId == id).ToList();

            if (seqStations.Count() > 0)
            {
                var seqStation = seqStations.FirstOrDefault();
                if (seqStation != null)
                {
                    var station = factory.UpdateNextBoxBySequencingId(seqStation.Id);
                    var statusLookup = dbSeq.SequencingStationLookups.Where(i => i.SequenceStationSettingsId == seqStation.Id).FirstOrDefault();

                    int boxNum = schedule.ScheduleStatus.CurrentBoxNumber;
                    int scheduleNum = schedule.ScheduleStatus.CurrentScheduleNumber;

                    //check if job completed already
                    bool isComplete = false;
                    var isCompleteResult = dbSeq.IsSequencingScheduleComplete(seqStation.Id, boxNum, scheduleNum);
                    if (isCompleteResult.HasValue == true) // it's null
                        isComplete = (bool)isCompleteResult;

                    if (isComplete)
                    {
                        throw new HttpResponseException(
                            HttpErrorResponse.GetHttpErrorResponse(
                            HttpStatusCode.NotFound, "Trim Schedule Already Completed", string.Format("Trim Schedule {0} Already Completed", scheduleNum)));
                    }

                    if (schedule.ScheduleStatus.CurrentBoxNumber == statusLookup.NextBoxNum
                        && schedule.ScheduleStatus.CurrentScheduleNumber == statusLookup.NextScheduleNum)
                    {
                        var lastjob = schedule.SeatSchedule.Last();
                        var firstjob = schedule.SeatSchedule.First();

                        //get schedule parameters by station
                        var itemsinbox = station.PartsPerBox;
                        var boxperschedule = station.BoxPerSchedule;
                        var itemsinschedule = itemsinbox * boxperschedule;

                        //get sequencing buffer
                        var lineBuffer = factory.GetSequencingBuffer(station);
                        //filter sequencing buffer by last job and first job
                        var validBuffer = lineBuffer.Where(i => i.OrderId <= lastjob.OrderId && i.OrderId >= firstjob.OrderId).OrderBy(s => s.OrderId).ToList();

                        if (validBuffer.Count() == itemsinschedule) //check if there is enough seats to fulfill schedule
                        {
                            if (schedule.OffsetSeats != null)
                            {
                                if (schedule.OffsetSeats.Count() > 0)
                                {

                                }
                            }


                            //save history
                            SequencingTrackingHistoryDetail histDetail = new SequencingTrackingHistoryDetail
                            {
                                BoxNum = schedule.ScheduleStatus.CurrentBoxNumber,
                                DTM = DateTime.Now,
                                ScheduleNum = schedule.ScheduleStatus.CurrentScheduleNumber,
                                SequencingStationSettingsId = station.Id,
                                Type = 1
                            };
                            dbSeq.SequencingTrackingHistoryDetails.InsertOnSubmit(histDetail);

                            foreach (var seat in schedule.SeatSchedule)
                            {
                                SequencingTrackingHistory hist = new SequencingTrackingHistory
                                {
                                    Position = seat.Index + 1,
                                    OrderId = seat.OrderId,
                                    ItemNumber = seat.ItemNumber,
                                    OrderNumber = seat.OrderNumber,
                                    ItemType = seat.ItemType,
                                    JobId = seat.JobId,
                                    SequencingTrackingHistoryDetail = histDetail,
                                };

                                dbSeq.SequencingTrackingHistories.InsertOnSubmit(hist);
                            }

                            //queue station items
                            if ((bool)station.SequencingLocation.QueueItems)
                            {
                                var queueStations = dbSeq.SequencingLocations.Where(l => l.ParentId == station.SequencingLocation.Id).ToList();

                                if (queueStations.Count() > 0)
                                {
                                    foreach (var st in queueStations)
                                    {
                                        var queueItems = (from s in schedule.SeatSchedule
                                                          select new SequencingStationQueue
                                                          {
                                                              OrderNumber = s.OrderNumber == null ? "" : s.OrderNumber.Trim(),
                                                              BoxNum = schedule.ScheduleStatus.CurrentBoxNumber,
                                                              InsertedDTM = DateTime.Now,
                                                              UpdatedDTM = DateTime.Now,
                                                              ItemNumber = s.ItemNumber.Trim(),
                                                              ItemType = s.ItemType.Trim(),
                                                              JobId = s.JobId,
                                                              OrderId = s.OrderId,
                                                              Region = "",
                                                              ScheduleNum = schedule.ScheduleStatus.CurrentScheduleNumber,
                                                              SequencingLocationId = st.Id,
                                                              OrderStatus = (byte)s.OrderStatus,
                                                          }).ToList();

                                        dbSeq.SequencingStationQueues.InsertAllOnSubmit(queueItems);
                                        dbSeq.SubmitChanges();
                                    }
                                }
                            }

                            //no parent station delete from the queue table
                            if (station.SequencingLocation.ParentId != null)
                            {
                                var deleteSeats = dbSeq.SequencingStationQueues.Where(i => i.OrderId <= lastjob.OrderId && i.OrderId >= firstjob.OrderId && i.SequencingLocationId == station.SequencingLocation.Id).OrderBy(s => s.OrderId).ToList();
                                dbSeq.SequencingStationQueues.DeleteAllOnSubmit(deleteSeats);
                                dbSeq.SubmitChanges();
                            }

                            var scheduleHist = new SequencingStationScheduleHistory
                            {
                                EmployeeId = employeeId,
                                EmployeeName = employee == null ? "Unknown Employee" : employee.Name.Trim(),
                                ScheduleNum = schedule.ScheduleStatus.CurrentScheduleNumber,
                                SequencingLocationId = id,
                                DateCompleted = DateTime.Now,
                            };
                            dbSeq.SequencingStationScheduleHistories.InsertOnSubmit(scheduleHist);

                            var nextjob = lineBuffer.Where(i => i.OrderId > lastjob.OrderId).OrderBy(s => s.OrderId).FirstOrDefault();
                            statusLookup.NextBoxNum = schedule.ScheduleStatus.CurrentBoxNumber + 1;
                            statusLookup.NextOrderId = nextjob == null ? statusLookup.NextOrderId + 1 : nextjob.OrderId;
                            statusLookup.NextScheduleNum = schedule.ScheduleStatus.CurrentScheduleNumber + 1;
                            
                            dbSeq.SubmitChanges();

                            //if (id == 7) //first row complete schedule
                            //{
                            //    CompleteTrimSchedule(schedule, 8, employeeId);
                            //}
                        }
                    }
                }
            }
        }
        public async Task<int> CompletePlasticSeqByLocationId(int id, int employeeId)
        {
            #region Complete Plastic Seq By Location Id
            try
            {
                PartSequencingDataContext dbSeq = new PartSequencingDataContext();
                EmployeeDatabase dbEmp = new EmployeeDatabase();
                PlasticSeqDatabase db = new PlasticSeqDatabase();

                int scheduleNum = 0;

                var seqStations = db.GetSequencingStationsBySequencingLocationId(id);

                if (seqStations.Count() > 0)
                {
                    var first = seqStations.FirstOrDefault();
                    if (first != null)
                        scheduleNum = first.NextBox.ScheduleNum;
                }

                Log.Logging.Info("Global Complete|Schedule #{0}|Location Id: {1}", scheduleNum, id);

                await Task.Run(() => Parallel.ForEach(seqStations, station =>
                {
                    Log.Logging.Info("Attempt Complete Schedule|Station: {0} Seq Id: {1}", station.SequencingLocation.Description, station.Id);
                    CompletePlasticSeqByStation(station);
                    Log.Logging.Info("Complete Schedule Done|Seq Id: {1}", id);
                }));

                var employee = dbEmp.GetEmployeeInfo(employeeId);

                var scheduleHist = new SequencingStationScheduleHistory
                {
                    EmployeeId = employeeId,
                    EmployeeName = employee == null ? "Unknown Employee" : employee.Name.Trim(),
                    ScheduleNum = scheduleNum,
                    SequencingLocationId = id,
                    DateCompleted = DateTime.Now,
                };

                dbSeq.SequencingStationScheduleHistories.InsertOnSubmit(scheduleHist);
                dbSeq.SubmitChanges();
                Log.Logging.Info("Insert|SequencingStationScheduleHistory|Schedule #{0}, {1}, {2}, {3}", scheduleNum, scheduleHist.SequencingLocationId, scheduleHist.EmployeeName, scheduleHist.DateCompleted);
                return 1;
            }
            catch (Exception ex)
            {
                Log.Logging.Fatal("FATAL|CompleteSequencingByAisleId(SeqId={0}, EmployeeId={1})", id, employeeId);
                Log.Logging.Fatal("FATAL|Error: {0}", ex.Message);
            }
            return 0;
            #endregion
        }