コード例 #1
0
        public void SendScrubbingInputData(ScrubCaCommand command)
        {
            PopulateFields(command.FieldsContent, command.Fields);
            foreach (var opt in command.Options)
            {
                PopulateFields(opt.FieldsContent, opt.Fields);
                foreach (var pyt in opt.Payouts)
                {
                    PopulateFields(pyt.FieldsContent, pyt.Fields);
                }
            }

            CaProcessViewModel viewModel = _apiService.Execute(command);

            IHubContext notifHub = GlobalHost.ConnectionManager.GetHubContext <NotificationHub>();

            if (viewModel != null)
            {
                notifHub.Clients.All.updateProcess(viewModel);
            }

            SummaryModel summaryModel = GetSummaryModel();

            if (summaryModel != null)
            {
                notifHub.Clients.All.updateSummaryModel(summaryModel);
            }
        }
コード例 #2
0
        public void PerformeDateOffset()
        {
            int dayOffset = 5;

            seedData.ForEach(c =>
            {
                c.CaId = seedData.Count + c.CaId;

                c.EventDate = c.EventDate.AddDays(dayOffset);
                if (c.Type == CommandType.Scrub)
                {
                    ScrubCaCommand cmd = (ScrubCaCommand)c;
                    cmd.FieldsContent  = AdjustDates(cmd.FieldsContent, dayOffset);
                    cmd.Options.ForEach(o =>
                    {
                        o.FieldsContent = AdjustDates(o.FieldsContent, dayOffset);
                        o.Payouts.ForEach(p => p.FieldsContent = AdjustDates(p.FieldsContent, dayOffset));
                    });
                }
            });

            CopySeedData();

            SendData();
        }
コード例 #3
0
        private void UpdateScrubbingInfo(ScrubCaCommand command)
        {
            CaTimelineView timeline = _context.CaTimelineViews.First(t => t.CaId == command.CaId);

            ScrubbingInfo info = null;

            if (command.Fields != null)
            {
                foreach (KeyValuePair <int, string> caField in command.Fields)
                {
                    info = _context.ScrubbingInfo.Single(s => s.FieldRegistryId == caField.Key && s.CaId == command.CaId && s.OptionNumber == null && s.PayoutNumber == null);

                    info.PayoutTypeId          = command.CaTypeId;
                    info.FieldDisplay          = info.FieldDisplay.Substring(0, info.FieldDisplay.Length - 4) + " (CO)";
                    info.ProcessedDateCategory = GetProcessedDateCategory(@command.EventDate, timeline.ScrubbingTarget, timeline.ScrubbingCritical);
                    info.IsSrubbed             = true;
                }
            }

            if (command.Options != null)
            {
                foreach (OptionDto optionDto in command.Options)
                {
                    if (optionDto.Fields != null)
                    {
                        foreach (KeyValuePair <int, string> optionField in optionDto.Fields)
                        {
                            info = _context.ScrubbingInfo.Single(s => s.FieldRegistryId == optionField.Key && s.CaId == command.CaId && s.OptionNumber == optionDto.OptionNumber && s.PayoutNumber == null);

                            info.PayoutTypeId          = GetOptionTypeId(command.CaId, optionDto.OptionNumber);
                            info.FieldDisplay          = info.FieldDisplay.Substring(0, info.FieldDisplay.Length - 4) + " (CO)";
                            info.ProcessedDateCategory = GetProcessedDateCategory(@command.EventDate, timeline.ScrubbingTarget, timeline.ScrubbingCritical);
                            info.IsSrubbed             = true;
                        }
                    }

                    if (optionDto.Payouts != null)
                    {
                        foreach (PayoutDto payoutDto in optionDto.Payouts)
                        {
                            if (payoutDto.Fields != null)
                            {
                                foreach (KeyValuePair <int, string> payoutField in payoutDto.Fields)
                                {
                                    info = _context.ScrubbingInfo.Single(s => s.FieldRegistryId == payoutField.Key && s.CaId == command.CaId && s.OptionNumber == optionDto.OptionNumber && s.PayoutNumber == payoutDto.PayoutNumber);

                                    info.PayoutTypeId          = GetPayoutTypeId(command.CaId, optionDto.OptionNumber, payoutDto.PayoutNumber);
                                    info.FieldDisplay          = info.FieldDisplay.Substring(0, info.FieldDisplay.Length - 4) + " (CO)";
                                    info.ProcessedDateCategory = GetProcessedDateCategory(@command.EventDate, timeline.ScrubbingTarget, timeline.ScrubbingCritical);
                                    info.IsSrubbed             = true;
                                }
                            }
                        }
                    }
                }
            }

            _context.SaveChanges();
        }
コード例 #4
0
        public IHttpActionResult PostScrubbing([FromBody] ScrubCaCommand command)
        {
            List <ScrubbingInfo> scrubbingViews = _context.ScrubbingInfo.Where(view => view.CaId == command.CaId).ToList();

            if (scrubbingViews.Count == 0)
            {
                CreateScrubbingInfo(command);
            }

            UpdateScrubbingInfo(command);

            return(Ok());
        }
コード例 #5
0
        private void CreateScrubbingInfo(ScrubCaCommand command)
        {
            ScrubbingInfo info = null;

            List <int> caFieldRegistryIds = _context
                                            .CaTypeFieldMap
                                            .Where(map => map.CaTypeRegistryId == command.CaTypeId)
                                            .Select(map => map.FieldRegistryId)
                                            .ToList();

            List <FieldRegistry> caFields = _context
                                            .FieldRegistry
                                            .Where(fld => caFieldRegistryIds.Contains(fld.FieldRegistryId))
                                            .ToList();

            foreach (FieldRegistry caField in caFields)
            {
                info = new ScrubbingInfo();
                info.FieldRegistryId       = caField.FieldRegistryId;
                info.CaId                  = command.CaId;
                info.CaTypeId              = command.CaTypeId;
                info.OptionNumber          = null;
                info.OptionTypeId          = null;
                info.PayoutNumber          = null;
                info.PayoutTypeId          = null;
                info.FieldDisplay          = caField.FieldDisplay + " (IN)";
                info.ProcessedDateCategory = ProcessedDateCategory.Missing;
                info.IsSrubbed             = false;

                _context.ScrubbingInfo.Add(info);
            }

            foreach (OptionDto optionDto in command.Options)
            {
                List <int> optionFieldRegistryIds = _context
                                                    .OptionTypeFieldMap
                                                    .Where(map => map.OptionTypeRegistryId == optionDto.OptionTypeId.Value)
                                                    .Select(map => map.FieldRegistryId)
                                                    .ToList();

                List <FieldRegistry> optionFields = _context
                                                    .FieldRegistry
                                                    .Where(fld => optionFieldRegistryIds.Contains(fld.FieldRegistryId))
                                                    .ToList();

                foreach (FieldRegistry optionField in optionFields)
                {
                    info = new ScrubbingInfo();
                    info.FieldRegistryId       = optionField.FieldRegistryId;
                    info.CaId                  = command.CaId;
                    info.CaTypeId              = command.CaTypeId;
                    info.OptionNumber          = optionDto.OptionNumber;
                    info.OptionTypeId          = optionDto.OptionTypeId.Value;
                    info.PayoutNumber          = null;
                    info.PayoutTypeId          = null;
                    info.FieldDisplay          = "O #" + optionDto.OptionNumber + " - " + optionField.FieldDisplay + " (IN)";
                    info.ProcessedDateCategory = ProcessedDateCategory.Missing;
                    info.IsSrubbed             = false;

                    _context.ScrubbingInfo.Add(info);
                }

                foreach (PayoutDto payoutDto in optionDto.Payouts)
                {
                    List <int> payoutFieldRegistryIds = _context
                                                        .PayoutTypeFieldMap
                                                        .Where(map => map.PayoutTypeRegistryId == payoutDto.PayoutTypeId.Value)
                                                        .Select(map => map.FieldRegistryId)
                                                        .ToList();

                    List <FieldRegistry> payoutFields = _context
                                                        .FieldRegistry
                                                        .Where(fld => payoutFieldRegistryIds.Contains(fld.FieldRegistryId))
                                                        .ToList();

                    foreach (FieldRegistry payoutField in payoutFields)
                    {
                        info = new ScrubbingInfo();
                        info.FieldRegistryId       = payoutField.FieldRegistryId;
                        info.CaId                  = command.CaId;
                        info.CaTypeId              = command.CaTypeId;
                        info.OptionNumber          = optionDto.OptionNumber;
                        info.OptionTypeId          = optionDto.OptionTypeId.Value;
                        info.PayoutNumber          = payoutDto.PayoutNumber;
                        info.PayoutTypeId          = payoutDto.PayoutTypeId.Value;
                        info.FieldDisplay          = "O #" + optionDto.OptionNumber + " " + "P #" + payoutDto.PayoutNumber + " - " + payoutField.FieldDisplay + " (IN)";
                        info.ProcessedDateCategory = ProcessedDateCategory.Missing;
                        info.IsSrubbed             = false;

                        _context.ScrubbingInfo.Add(info);
                    }
                }
            }

            _context.SaveChanges();
        }
コード例 #6
0
        public static void SendScrubCommand(Command command)
        {
            ScrubCaCommand scrubCommand = (ScrubCaCommand)command;

            POST(JsonConvert.SerializeObject(scrubCommand), "SendScrubbingInputData");
        }
コード例 #7
0
        public void CalculateAndUpdateCaTimeline(ScrubCaCommand command)
        {
            CaTimeline caTimeline = _context.CaTimeline.FirstOrDefault(ct => ct.CaId == command.CaId);

            if (caTimeline != null)
            {
                _context.CaTimeline.Remove(caTimeline);
                _context.SaveChanges();
            }

            CaTimeline newTimeline = new CaTimeline();

            newTimeline.CaId = command.CaId;

            //Scrubbing Process Dates
            CaTypeDateConfiguration caTypeStartDateConfiguration    = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Scrubbing && dc.DateType.Equals("S", StringComparison.CurrentCultureIgnoreCase));
            CaTypeDateConfiguration caTypeTargetDateConfiguration   = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Scrubbing && dc.DateType.Equals("T", StringComparison.CurrentCultureIgnoreCase));
            CaTypeDateConfiguration caTypeCriticalDateConfiguration = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Scrubbing && dc.DateType.Equals("C", StringComparison.CurrentCultureIgnoreCase));

            newTimeline.ScrubbingStart    = DateTime.Parse(command.Fields[caTypeStartDateConfiguration.FieldRegistryId]).AddDays(caTypeStartDateConfiguration.DateOffset);
            newTimeline.ScrubbingTarget   = DateTime.Parse(command.Fields[caTypeTargetDateConfiguration.FieldRegistryId]).AddDays(caTypeTargetDateConfiguration.DateOffset);
            newTimeline.ScrubbingCritical = DateTime.Parse(command.Fields[caTypeCriticalDateConfiguration.FieldRegistryId]).AddDays(caTypeCriticalDateConfiguration.DateOffset);

            //Notification Process Dates
            caTypeStartDateConfiguration    = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Notification && dc.DateType.Equals("S", StringComparison.CurrentCultureIgnoreCase));
            caTypeTargetDateConfiguration   = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Notification && dc.DateType.Equals("T", StringComparison.CurrentCultureIgnoreCase));
            caTypeCriticalDateConfiguration = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Notification && dc.DateType.Equals("C", StringComparison.CurrentCultureIgnoreCase));

            newTimeline.NotificationStart    = DateTime.Parse(command.Fields[caTypeStartDateConfiguration.FieldRegistryId]).AddDays(caTypeStartDateConfiguration.DateOffset);
            newTimeline.NotificationTarget   = DateTime.Parse(command.Fields[caTypeTargetDateConfiguration.FieldRegistryId]).AddDays(caTypeTargetDateConfiguration.DateOffset);
            newTimeline.NotificationCritical = DateTime.Parse(command.Fields[caTypeCriticalDateConfiguration.FieldRegistryId]).AddDays(caTypeCriticalDateConfiguration.DateOffset);

            if (command.VolManCho.Equals("M", StringComparison.CurrentCultureIgnoreCase))
            {
                newTimeline.ResponseStart    = null;
                newTimeline.ResponseTarget   = null;
                newTimeline.ResponseCritical = null;

                newTimeline.InstructionStart    = null;
                newTimeline.InstructionTarget   = null;
                newTimeline.InstructionCritical = null;
            }
            else
            {
                //Response Process Dates
                caTypeStartDateConfiguration    = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Response && dc.DateType.Equals("S", StringComparison.CurrentCultureIgnoreCase));
                caTypeTargetDateConfiguration   = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Response && dc.DateType.Equals("T", StringComparison.CurrentCultureIgnoreCase));
                caTypeCriticalDateConfiguration = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Response && dc.DateType.Equals("C", StringComparison.CurrentCultureIgnoreCase));

                List <DateTime> optionDates = new List <DateTime>();
                command.Options.ForEach(opt => FindDate(opt.Fields, caTypeStartDateConfiguration.FieldRegistryId, optionDates));
                newTimeline.ResponseStart = optionDates.Min().AddDays(caTypeStartDateConfiguration.DateOffset);

                optionDates = new List <DateTime>();
                command.Options.ForEach(opt => FindDate(opt.Fields, caTypeTargetDateConfiguration.FieldRegistryId, optionDates));
                newTimeline.ResponseTarget = optionDates.Min().AddDays(caTypeTargetDateConfiguration.DateOffset);

                optionDates = new List <DateTime>();
                command.Options.ForEach(opt => FindDate(opt.Fields, caTypeCriticalDateConfiguration.FieldRegistryId, optionDates));
                newTimeline.ResponseCritical = optionDates.Min().AddDays(caTypeCriticalDateConfiguration.DateOffset);

                //Instruction Process Dates
                caTypeStartDateConfiguration    = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Instruction && dc.DateType.Equals("S", StringComparison.CurrentCultureIgnoreCase));
                caTypeTargetDateConfiguration   = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Instruction && dc.DateType.Equals("T", StringComparison.CurrentCultureIgnoreCase));
                caTypeCriticalDateConfiguration = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Instruction && dc.DateType.Equals("C", StringComparison.CurrentCultureIgnoreCase));

                optionDates = new List <DateTime>();
                command.Options.ForEach(opt => FindDate(opt.Fields, caTypeStartDateConfiguration.FieldRegistryId, optionDates));
                newTimeline.InstructionStart = optionDates.Min().AddDays(caTypeStartDateConfiguration.DateOffset);

                optionDates = new List <DateTime>();
                command.Options.ForEach(opt => FindDate(opt.Fields, caTypeTargetDateConfiguration.FieldRegistryId, optionDates));
                newTimeline.InstructionTarget = optionDates.Min().AddDays(caTypeTargetDateConfiguration.DateOffset);

                optionDates = new List <DateTime>();
                command.Options.ForEach(opt => FindDate(opt.Fields, caTypeCriticalDateConfiguration.FieldRegistryId, optionDates));
                newTimeline.InstructionCritical = optionDates.Min().AddDays(caTypeCriticalDateConfiguration.DateOffset);
            }

            //Payment Process Dates
            caTypeStartDateConfiguration    = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Payment && dc.DateType.Equals("S", StringComparison.CurrentCultureIgnoreCase));
            caTypeTargetDateConfiguration   = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Payment && dc.DateType.Equals("T", StringComparison.CurrentCultureIgnoreCase));
            caTypeCriticalDateConfiguration = _context.DatesConfigurations.FirstOrDefault(dc => dc.CaType == command.CaTypeId && dc.ProcessType == ProcessType.Payment && dc.DateType.Equals("C", StringComparison.CurrentCultureIgnoreCase));

            List <DateTime> payoutDates = new List <DateTime>();

            command.Options.ForEach(opt => opt.Payouts.ForEach(pt => FindDate(pt.Fields, caTypeStartDateConfiguration.FieldRegistryId, payoutDates)));
            newTimeline.PaymentStart = payoutDates.Min().AddDays(caTypeStartDateConfiguration.DateOffset);

            payoutDates = new List <DateTime>();
            command.Options.ForEach(opt => opt.Payouts.ForEach(pt => FindDate(pt.Fields, caTypeTargetDateConfiguration.FieldRegistryId, payoutDates)));
            newTimeline.PaymentTarget = payoutDates.Min().AddDays(caTypeTargetDateConfiguration.DateOffset);

            payoutDates = new List <DateTime>();
            command.Options.ForEach(opt => opt.Payouts.ForEach(pt => FindDate(pt.Fields, caTypeCriticalDateConfiguration.FieldRegistryId, payoutDates)));
            newTimeline.PaymentCritical = payoutDates.Min().AddDays(caTypeCriticalDateConfiguration.DateOffset);

            _context.CaTimeline.Add(newTimeline);
            _context.SaveChanges();
        }
コード例 #8
0
        private void UpdateScrubbingInfo(ScrubCaCommand command)
        {
            ScrubbingInfo info = null;

            if (command.Fields != null)
            {
                foreach (KeyValuePair <int, string> caField in command.Fields)
                {
                    FieldRegistry fieldMetadata = _context.FieldRegistry.FirstOrDefault(f => f.FieldRegistryId == caField.Key);
                    info = _context.ScrubbingInfo.Single(s => s.FieldRegistryId == caField.Key && s.CaId == command.CaId && s.OptionNumber == null && s.PayoutNumber == null);

                    info.PayoutTypeId = command.CaTypeId;
                    info.FieldDisplay = info.FieldDisplay.Substring(0, info.FieldDisplay.Length - 4) + " (CO)";

                    if (fieldMetadata != null && fieldMetadata.FieldType == "DATE" && !string.IsNullOrEmpty(caField.Value))
                    {
                        info.DateFieldValue = DateTime.Parse(caField.Value);
                    }

                    info.ProcessedDateCategory = CalculateProcessedDateCategory(ProcessType.Scrubbing, info.CaId, command.EventDate);
                    info.ProcessedDate         = command.EventDate;
                    info.IsSrubbed             = true;
                }
            }

            if (command.Options != null)
            {
                foreach (OptionDto optionDto in command.Options)
                {
                    if (optionDto.Fields != null)
                    {
                        foreach (KeyValuePair <int, string> optionField in optionDto.Fields)
                        {
                            FieldRegistry fieldMetadata = _context.FieldRegistry.FirstOrDefault(f => f.FieldRegistryId == optionField.Key);
                            info = _context.ScrubbingInfo.Single(s => s.FieldRegistryId == optionField.Key && s.CaId == command.CaId && s.OptionNumber == optionDto.OptionNumber && s.PayoutNumber == null);

                            info.PayoutTypeId = GetOptionTypeId(command.CaId, optionDto.OptionNumber);
                            info.FieldDisplay = info.FieldDisplay.Substring(0, info.FieldDisplay.Length - 4) + " (CO)";

                            if (fieldMetadata != null && fieldMetadata.FieldType == "DATE" && !string.IsNullOrEmpty(optionField.Value))
                            {
                                info.DateFieldValue = DateTime.Parse(optionField.Value);
                            }

                            info.ProcessedDateCategory = CalculateProcessedDateCategory(ProcessType.Scrubbing, info.CaId, command.EventDate);
                            info.ProcessedDate         = command.EventDate;
                            info.IsSrubbed             = true;
                        }
                    }

                    if (optionDto.Payouts != null)
                    {
                        foreach (PayoutDto payoutDto in optionDto.Payouts)
                        {
                            if (payoutDto.Fields != null)
                            {
                                foreach (KeyValuePair <int, string> payoutField in payoutDto.Fields)
                                {
                                    FieldRegistry fieldMetadata = _context.FieldRegistry.FirstOrDefault(f => f.FieldRegistryId == payoutField.Key);
                                    info = _context.ScrubbingInfo.Single(s => s.FieldRegistryId == payoutField.Key && s.CaId == command.CaId && s.OptionNumber == optionDto.OptionNumber && s.PayoutNumber == payoutDto.PayoutNumber);

                                    info.PayoutTypeId = GetPayoutTypeId(command.CaId, optionDto.OptionNumber, payoutDto.PayoutNumber);
                                    info.FieldDisplay = info.FieldDisplay.Substring(0, info.FieldDisplay.Length - 4) + " (CO)";

                                    if (fieldMetadata != null && fieldMetadata.FieldType == "DATE" && !string.IsNullOrEmpty(payoutField.Value))
                                    {
                                        info.DateFieldValue = DateTime.Parse(payoutField.Value);
                                    }

                                    info.ProcessedDateCategory = CalculateProcessedDateCategory(ProcessType.Scrubbing, info.CaId, command.EventDate);
                                    info.ProcessedDate         = command.EventDate;
                                    info.IsSrubbed             = true;
                                }
                            }
                        }
                    }
                }
            }

            _context.SaveChanges();
        }