void ShowExistingAnalogousReactions(ReactionVM masterReaction)
 {
     try
     {
         var viewModel = this.DataContext as ViewAnalogousVM;
         if (viewModel != null)
         {
             ViewAnalogousVM analogousReactionVM = viewModel.CollectExistingAnalogousReactions();
             AnalogousBuilder.BuildAnalogousGrid(analogousReactionVM, ConsolidatedGrid, false);
         }
     }
     catch (Exception ex)
     {
         Log.This(ex);
     }
 }
        public static ReactionParticipantVM AlreadyContains(TanChemical selectedChemical, ViewAnalogousVM analogousreactionVM, ReactionVM SelectedReaction, ParticipantType participantType, [Optional] List <ReactionParticipantVM> ReactionParticipant, [Optional] List <RsnVM> Rsn, [Optional] bool BulkValidation)
        {
            try
            {
                var ReactionParticipants = ReactionParticipant == null?analogousreactionVM.ReactionParticipants.OfReaction(SelectedReaction.Id) : ReactionParticipant;

                var Rsns = Rsn == null?analogousreactionVM.Rsns.OfReaction(SelectedReaction.Id, true).ToList() : Rsn;

                var chemicalName = new Models.TanChemicalVM
                {
                    Id        = selectedChemical.Id,
                    Name      = selectedChemical.Name,
                    NUM       = selectedChemical.NUM,
                    RegNumber = selectedChemical.RegNumber
                };
                var groupedValidations = S.GetGroupedCVTs();
                if (ReactionParticipants.Count() > 0)
                {
                    if (participantType == ParticipantType.Product)
                    {
                        var existingProducts = ReactionParticipants.OfReaction(SelectedReaction.Id).OfNumOrReg(selectedChemical.NUM, selectedChemical.RegNumber);
                        if (existingProducts != null && existingProducts.Any())
                        {
                            return(existingProducts.FirstOrDefault());
                        }
                    }

                    else if (SelectedReaction.SelectedStage != null)
                    {
                        #region Reactant Validations
                        if (participantType == ParticipantType.Reactant)
                        {
                            var stageReactants = ReactionParticipants.OfReactionAndStage(SelectedReaction.Id, SelectedReaction.SelectedStage.Id).OfNumOrReg(selectedChemical.NUM, selectedChemical.RegNumber).OfExceptTypes(ParticipantType.Solvent);
                            if (stageReactants != null && stageReactants.OfType(ParticipantType.Reactant).Any())
                            {
                                return(stageReactants.FirstOrDefault());
                            }
                            List <int> StageNumbers = new List <int>();
                            if (SelectedReaction.Stages.Count > 1)
                            {
                                StageNumbers = PressureValidations.GetStageDisplayOrdersFromFreetexts(Rsns, SelectedReaction, S.DUAL_ROLE_STRING);
                            }
                            else if (Rsns.Where(rsn => rsn.Reaction.Id == SelectedReaction.Id && rsn.Stage == null && rsn.CvtText.SafeEqualsLower(S.DUAL_ROLE_STRING)).Any())
                            {
                                StageNumbers.Add(1);
                            }
                            if (stageReactants != null && stageReactants.OfExceptTypes(ParticipantType.Reactant).Any())
                            {
                                if (!StageNumbers.Contains(SelectedReaction.SelectedStage.DisplayOrder))
                                {
                                    return(stageReactants.OfExceptTypes(ParticipantType.Reactant).FirstOrDefault());
                                }
                                else
                                {
                                    var rsnVM = Rsns.Where(rsn => rsn.Reaction.Id == SelectedReaction.Id &&
                                                           rsn.SelectedChemical == null &&
                                                           (rsn.FreeText.SafeContainsLower(S.DUAL_ROLE_STRING) || rsn.CvtText.SafeEqualsLower(S.DUAL_ROLE_STRING))).FirstOrDefault();
                                    if (rsnVM != null)
                                    {
                                        rsnVM.SelectedChemical = chemicalName;
                                    }
                                }
                            }

                            var Products = ReactionParticipants.OfReactionOfType(SelectedReaction.Id, ParticipantType.Product).OfNum(selectedChemical.NUM);
                            if (Products != null && Products.Any())
                            {
                                return(Products.FirstOrDefault());
                            }

                            var AmdProducts = ReactionParticipants.OfReactionOfType(SelectedReaction.Id, ParticipantType.Product).Where(ro => ro.Reg == selectedChemical.RegNumber && ro.Num != selectedChemical.NUM);
                            if (AmdProducts != null && AmdProducts.Any())
                            {
                                string       msg          = $"Selected chemical with same Reg and different num already involved in {AmdProducts.FirstOrDefault().ReactionVM.DisplayName} as a Product. Do you want to still add as Reactant?";
                                DialogResult dialogResult = System.Windows.Forms.MessageBox.Show(msg, "Reactions", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
                                if (dialogResult == DialogResult.No)
                                {
                                    return(AmdProducts.FirstOrDefault());
                                }
                            }

                            var otherstageReactants = ReactionParticipants.OfReactionAndExceptStage(SelectedReaction.Id, SelectedReaction.SelectedStage.Id)
                                                      .OfNumOrReg(selectedChemical.NUM, selectedChemical.RegNumber)
                                                      .OfExceptTypes(ParticipantType.Solvent, ParticipantType.Product)
                                                      .GroupBy(p => p.ParticipantType)
                                                      .ToDictionary(p => p.Key, p => p.ToList());
                            var duplicate = ValidateWithCVT1(otherstageReactants, Rsns, SelectedReaction, chemicalName, ParticipantType.Reactant);
                            if (duplicate != null)
                            {
                                return(duplicate);
                            }
                        }
                        #endregion

                        #region Solvent Validation
                        if (participantType == ParticipantType.Solvent)
                        {
                            var InStageSolvents = ReactionParticipants.OfReactionAndStage(SelectedReaction.Id, SelectedReaction.SelectedStage.Id).OfExceptTypes(ParticipantType.Reactant).OfNumOrReg(selectedChemical.NUM, selectedChemical.RegNumber);
                            if (InStageSolvents != null && InStageSolvents.OfType(ParticipantType.Solvent).Any())
                            {
                                return(InStageSolvents.FirstOrDefault());
                            }
                            List <int> StageNumbers = new List <int>();
                            if (SelectedReaction.Stages.Count > 1)
                            {
                                StageNumbers = PressureValidations.GetStageDisplayOrdersFromFreetexts(Rsns, SelectedReaction, S.DUAL_ROLE_STRING);
                            }
                            else if (Rsns.Where(rsn => rsn.Reaction.Id == SelectedReaction.Id && rsn.Stage == null && rsn.CvtText.SafeEqualsLower(S.DUAL_ROLE_STRING)).Any())
                            {
                                StageNumbers.Add(1);
                            }
                            if (InStageSolvents != null && InStageSolvents.OfExceptTypes(ParticipantType.Solvent).Any())
                            {
                                if (!StageNumbers.Contains(SelectedReaction.SelectedStage.DisplayOrder))
                                {
                                    return(InStageSolvents.OfExceptTypes(ParticipantType.Solvent).FirstOrDefault());
                                }
                                else
                                {
                                    var rsnVM = Rsns.Where(rsn => rsn.Reaction.Id == SelectedReaction.Id &&
                                                           rsn.SelectedChemical == null &&
                                                           (rsn.FreeText.SafeContainsLower(S.DUAL_ROLE_STRING) || rsn.CvtText.SafeEqualsLower(S.DUAL_ROLE_STRING))).FirstOrDefault();
                                    if (rsnVM != null)
                                    {
                                        rsnVM.SelectedChemical = chemicalName;
                                    }
                                }
                            }

                            var Products = ReactionParticipants.OfReactionOfType(SelectedReaction.Id, ParticipantType.Product).OfNumOrReg(selectedChemical.NUM, selectedChemical.RegNumber);
                            if (Products != null && Products.Any())
                            {
                                return(Products.FirstOrDefault());
                            }
                            var otherthanProductsAndSolvents = ReactionParticipants.OfReactionAndExceptStage(SelectedReaction.Id, SelectedReaction.SelectedStage.Id)
                                                               .OfNumOrReg(selectedChemical.NUM, selectedChemical.RegNumber)
                                                               .OfExceptTypes(ParticipantType.Solvent, ParticipantType.Reactant, ParticipantType.Product)
                                                               .GroupBy(p => p.ParticipantType)
                                                               .ToDictionary(p => p.Key, p => p.ToList());
                            var duplicate = ValidateWithCVT1(otherthanProductsAndSolvents, Rsns, SelectedReaction, chemicalName, ParticipantType.Solvent);
                            if (duplicate != null)
                            {
                                return(duplicate);
                            }
                        }
                        #endregion

                        #region Catalyst Validations
                        if (participantType == ParticipantType.Catalyst)
                        {
                            var InStageCatalysts = ReactionParticipants.OfReactionAndStage(SelectedReaction.Id, SelectedReaction.SelectedStage.Id).OfNumOrReg(selectedChemical.NUM, selectedChemical.RegNumber);
                            if (InStageCatalysts != null && InStageCatalysts.OfType(ParticipantType.Catalyst).Any())
                            {
                                return(InStageCatalysts.FirstOrDefault());
                            }
                            List <int> StageNumbers = new List <int>();
                            if (SelectedReaction.Stages.Count > 1)
                            {
                                StageNumbers = PressureValidations.GetStageDisplayOrdersFromFreetexts(Rsns, SelectedReaction, S.DUAL_ROLE_STRING);
                            }
                            else if (Rsns.Where(rsn => rsn.Reaction.Id == SelectedReaction.Id && rsn.Stage == null && rsn.CvtText.SafeEqualsLower(S.DUAL_ROLE_STRING)).Any())
                            {
                                StageNumbers.Add(1);
                            }
                            if (InStageCatalysts != null && InStageCatalysts.OfExceptTypes(ParticipantType.Catalyst).Any())
                            {
                                if (!StageNumbers.Contains(SelectedReaction.SelectedStage.DisplayOrder))
                                {
                                    return(InStageCatalysts.OfExceptTypes(ParticipantType.Catalyst).FirstOrDefault());
                                }
                                else
                                {
                                    var rsnVM = Rsns.Where(rsn => rsn.Reaction.Id == SelectedReaction.Id &&
                                                           rsn.SelectedChemical == null &&
                                                           (rsn.FreeText.SafeContainsLower(S.DUAL_ROLE_STRING) || rsn.CvtText.SafeEqualsLower(S.DUAL_ROLE_STRING))).FirstOrDefault();
                                    if (rsnVM != null)
                                    {
                                        rsnVM.SelectedChemical = chemicalName;
                                    }
                                }
                            }
                            var Products = ReactionParticipants.OfReactionOfType(SelectedReaction.Id, ParticipantType.Product).OfNumOrReg(selectedChemical.NUM, selectedChemical.RegNumber);
                            if (Products != null && Products.Any())
                            {
                                return(Products.FirstOrDefault());
                            }

                            var otherThanCatalysts = ReactionParticipants.OfReactionAndExceptStage(SelectedReaction.Id, SelectedReaction.SelectedStage.Id)
                                                     .OfNumOrReg(selectedChemical.NUM, selectedChemical.RegNumber)
                                                     .OfExceptTypes(ParticipantType.Catalyst, ParticipantType.Product)
                                                     .GroupBy(p => p.ParticipantType)
                                                     .ToDictionary(p => p.Key, p => p.ToList());
                            var duplicate = ValidateWithCVT1(otherThanCatalysts, Rsns, SelectedReaction, chemicalName, ParticipantType.Catalyst);
                            if (duplicate != null)
                            {
                                return(duplicate);
                            }
                        }
                        #endregion
                        #region Agent Validations
                        if (participantType == ParticipantType.Agent)
                        {
                            var InStageAgents = ReactionParticipants.OfReactionAndStage(SelectedReaction.Id, SelectedReaction.SelectedStage.Id).OfNumOrReg(selectedChemical.NUM, selectedChemical.RegNumber);
                            if (InStageAgents != null && InStageAgents.OfType(ParticipantType.Agent).Any())
                            {
                                return(InStageAgents.FirstOrDefault());
                            }
                            List <int> StageNumbers = new List <int>();
                            if (SelectedReaction.Stages.Count > 1)
                            {
                                StageNumbers = PressureValidations.GetStageDisplayOrdersFromFreetexts(Rsns, SelectedReaction, S.DUAL_ROLE_STRING);
                            }
                            else if (Rsns.Where(rsn => rsn.Reaction.Id == SelectedReaction.Id && rsn.Stage == null && rsn.CvtText.SafeEqualsLower(S.DUAL_ROLE_STRING)).Any())
                            {
                                StageNumbers.Add(1);
                            }
                            if (InStageAgents != null && InStageAgents.OfExceptTypes(ParticipantType.Agent).Any())
                            {
                                if (!StageNumbers.Contains(SelectedReaction.SelectedStage.DisplayOrder))
                                {
                                    return(InStageAgents.OfExceptTypes(ParticipantType.Agent).FirstOrDefault());
                                }
                                else
                                {
                                    var rsnVM = Rsns.Where(rsn => rsn.Reaction.Id == SelectedReaction.Id &&
                                                           rsn.SelectedChemical == null &&
                                                           (rsn.FreeText.SafeContainsLower(S.DUAL_ROLE_STRING) || rsn.CvtText.SafeEqualsLower(S.DUAL_ROLE_STRING))).FirstOrDefault();
                                    if (rsnVM != null)
                                    {
                                        rsnVM.SelectedChemical = chemicalName;
                                    }
                                }
                            }

                            var Products = ReactionParticipants.OfReactionOfType(SelectedReaction.Id, ParticipantType.Product).OfNumOrReg(selectedChemical.NUM, selectedChemical.RegNumber);
                            if (Products != null && Products.Any())
                            {
                                return(Products.FirstOrDefault());
                            }

                            var otherStageAgents = ReactionParticipants.OfReactionAndExceptStage(SelectedReaction.Id, SelectedReaction.SelectedStage.Id)
                                                   .OfNumOrReg(selectedChemical.NUM, selectedChemical.RegNumber)
                                                   .OfExceptTypes(ParticipantType.Agent, ParticipantType.Product)
                                                   .GroupBy(p => p.ParticipantType)
                                                   .ToDictionary(p => p.Key, p => p.ToList());

                            var duplicate = ValidateWithCVT1(otherStageAgents, Rsns, SelectedReaction, chemicalName, ParticipantType.Agent);
                            if (duplicate != null)
                            {
                                return(duplicate);
                            }
                        }
                        #endregion
                    }
                    else
                    {
                        return(null);
                    }
                }
                return(null);
            }
            catch (Exception ex)
            {
                Log.This(ex);
                return(null);
            }
        }
        public static ViewAnalogousVM GenerateNewAnalogousReactions(
            ReactionVM SelectedReaction,
            bool IsReactantsSelected,
            bool IsSolventsSelected,
            bool IsAgentsSelected,
            bool IsCatalystSelected,
            bool IspHSelected,
            bool IsTempSelected,
            bool IsTimeSelected,
            bool IsPressureSelected,
            bool IsRSNSelected,
            int ReactionsCountToCopy, int IndexToAdd
            )
        {
            ViewAnalogousVM vm            = new ViewAnalogousVM();
            var             mainViewModel = ((MainWindow)(App.Current.MainWindow)).DataContext as MainVM;

            mainViewModel.ProgressText = "Creating Analogous Reacions . .";
            try
            {
                vm.SelectedMasterReaction = SelectedReaction;
                List <ReactionParticipantVM> allParticipants = new List <ReactionParticipantVM>();
                List <RsnVM>      tanRsns      = new List <RsnVM>();
                List <ReactionVM> tanReactions = new List <ReactionVM>();
                var tanParticipants            = new List <ReactionParticipantVM>();
                if (IsReactantsSelected)
                {
                    var reactants = mainViewModel.TanVM.ReactionParticipants.OfType(ParticipantType.Reactant);
                    allParticipants.AddRange(reactants);
                }
                if (IsSolventsSelected)
                {
                    var solvents = mainViewModel.TanVM.ReactionParticipants.OfType(ParticipantType.Solvent);
                    allParticipants.AddRange(solvents);
                }

                if (IsAgentsSelected)
                {
                    var agents = mainViewModel.TanVM.ReactionParticipants.OfType(ParticipantType.Agent);
                    allParticipants.AddRange(agents);
                }

                if (IsCatalystSelected)
                {
                    var catalysts = mainViewModel.TanVM.ReactionParticipants.OfType(ParticipantType.Catalyst);
                    allParticipants.AddRange(catalysts);
                }
                for (int i = 0; i < ReactionsCountToCopy; i++)
                {
                    var reaction = new ReactionVM
                    {
                        DisplayOrder  = ++IndexToAdd,
                        Id            = Guid.NewGuid(),
                        TanVM         = SelectedReaction.TanVM,
                        AnalogousVMId = SelectedReaction.Id
                    };
                    #region Stages
                    var stages = new List <StageVM>();
                    foreach (var masterStage in SelectedReaction.Stages)
                    {
                        bool ValidStage     = true;
                        var  analogousStage = new StageVM {
                            Id = Guid.NewGuid(), ReactionVm = reaction
                        };
                        var Conditions = new List <StageConditionVM>();
                        if (masterStage.Conditions != null)
                        {
                            foreach (var selectedCondition in masterStage.Conditions)
                            {
                                var condition = new StageConditionVM
                                {
                                    DisplayOrder  = selectedCondition.DisplayOrder,
                                    Id            = Guid.NewGuid(),
                                    PH            = IspHSelected ? selectedCondition.PH : "",
                                    Pressure      = IsPressureSelected ? selectedCondition.Pressure : "",
                                    StageId       = analogousStage.Id,
                                    Temperature   = IsTempSelected ? selectedCondition.Temperature : "",
                                    Time          = IsTimeSelected ? selectedCondition.Time : "",
                                    TIME_TYPE     = IsTimeSelected ? selectedCondition.TIME_TYPE : "",
                                    PRESSURE_TYPE = IsPressureSelected ? selectedCondition.PRESSURE_TYPE : "",
                                    TEMP_TYPE     = IsTempSelected ? selectedCondition.TEMP_TYPE : "",
                                    PH_TYPE       = IspHSelected ? selectedCondition.PH_TYPE : "",
                                };
                                if ((IspHSelected && !string.IsNullOrEmpty(selectedCondition.PH)) || (IsPressureSelected && !string.IsNullOrEmpty(selectedCondition.Pressure)) ||
                                    (IsTempSelected && !string.IsNullOrEmpty(selectedCondition.Temperature)) || (IsTimeSelected && !string.IsNullOrEmpty(selectedCondition.Time)))
                                {
                                    Conditions.Add(condition);
                                }
                            }
                            analogousStage.SetConditions(Conditions);
                        }
                        var stageParticipants = (from sp in allParticipants where sp.StageVM.Id == masterStage.Id select sp).ToList();
                        foreach (var stageParticipant in stageParticipants)
                        {
                            var newParticipant = new ReactionParticipantVM
                            {
                                ChemicalType    = stageParticipant.ChemicalType,
                                DisplayOrder    = stageParticipant.DisplayOrder,
                                Name            = stageParticipant.Name,
                                Num             = stageParticipant.Num,
                                ParticipantType = stageParticipant.ParticipantType,
                                ReactionVM      = reaction,
                                Reg             = stageParticipant.Reg,
                                StageVM         = analogousStage,
                                TanChemicalId   = stageParticipant.TanChemicalId,
                                Yield           = stageParticipant.Yield,
                                Id = Guid.NewGuid()
                            };
                            tanParticipants.Add(newParticipant);
                        }
                        if (IsRSNSelected)
                        {
                            var stagersnList = (from rsn in mainViewModel.TanVM.Rsns where rsn.Reaction.Id == SelectedReaction.Id && rsn.Stage != null && rsn.Stage.Id == masterStage.Id select rsn).ToList();
                            foreach (var rsn in stagersnList)
                            {
                                var newRsn = new RsnVM
                                {
                                    CvtText  = rsn.CvtText,
                                    Reaction = reaction,
                                    IsRXN    = rsn.IsRXN,
                                    Stage    = analogousStage,
                                    FreeText = rsn.FreeText,
                                    Id       = Guid.NewGuid(),
                                    IsIgnorableInDelivery = rsn.IsIgnorableInDelivery,
                                    DisplayOrder          = rsn.DisplayOrder,
                                    ReactionParticipantId = rsn.ReactionParticipantId,
                                    SelectedChemical      = rsn.SelectedChemical
                                };
                                tanRsns.Add(newRsn);
                            }
                        }
                        if ((analogousStage.Conditions == null || !analogousStage.Conditions.Any()) &&
                            (tanParticipants == null || !tanParticipants.Where(tp => tp.StageVM != null && tp.StageVM.Id == analogousStage.Id).Any()) &&
                            (tanRsns == null || !tanRsns.Where(tp => tp.Stage != null && tp.Stage.Id == analogousStage.Id).Any()) && !mainViewModel.TanVM.ReactionParticipants.OfReactionAndStage(SelectedReaction.Id, masterStage.Id).OfType(ParticipantType.Reactant).Any())
                        {
                            ValidStage = false;
                        }
                        if (ValidStage)
                        {
                            stages.Add(analogousStage);
                        }
                    }
                    #endregion
                    reaction.SetStages(stages, 0, false, true);
                    tanReactions.Add(reaction);
                    var reactionParticipants = (from sp in allParticipants where sp.ReactionVM.Id == SelectedReaction.Id && sp.StageVM == null select sp).ToList();
                    foreach (var participant in reactionParticipants)
                    {
                        var newParticipant = new ReactionParticipantVM
                        {
                            ChemicalType    = participant.ChemicalType,
                            DisplayOrder    = participant.DisplayOrder,
                            Name            = participant.Name,
                            Num             = participant.Num,
                            ParticipantType = participant.ParticipantType,
                            ReactionVM      = reaction,
                            Reg             = participant.Reg,
                            StageVM         = null,
                            TanChemicalId   = participant.TanChemicalId,
                            Yield           = participant.Yield,
                            Id = Guid.NewGuid()
                        };
                        tanParticipants.Add(newParticipant);
                    }

                    if (IsRSNSelected)
                    {
                        var reationrsnList = (from rsn in mainViewModel.TanVM.Rsns where rsn.Reaction.Id == SelectedReaction.Id && rsn.Stage == null select rsn).ToList();
                        foreach (var rsn in reationrsnList)
                        {
                            var newRsn = new RsnVM
                            {
                                CvtText               = rsn.CvtText,
                                Reaction              = reaction,
                                FreeText              = rsn.FreeText,
                                IsRXN                 = rsn.IsRXN,
                                Stage                 = null,
                                Id                    = Guid.NewGuid(),
                                SelectedChemical      = rsn.SelectedChemical,
                                ReactionParticipantId = rsn.ReactionParticipantId,
                                DisplayOrder          = rsn.DisplayOrder,
                                IsIgnorableInDelivery = rsn.IsIgnorableInDelivery
                            };
                            tanRsns.Add(newRsn);
                        }
                    }
                }
                foreach (var participant in tanParticipants)
                {
                    vm.AllParticipants.Add(participant);
                    vm.ReactionParticipants.Add(participant);
                }
                vm.Rsns.Clear();
                foreach (var rsn in tanRsns)
                {
                    vm.Rsns.Add(rsn);
                }
                foreach (var reaction in tanReactions)
                {
                    vm.AnalogousReactions.Add(reaction);
                }
            }
            catch (Exception ex)
            {
                AppErrorBox.ShowErrorMessage("Can't Create Analogous Reactions", ex.Message);
            }
            return(vm);
        }
        public static void BuildAnalogousGrid(ViewAnalogousVM anagousReactionVM, RadGridView ConsolidatedGrid, bool NewAnalogous)
        {
            try
            {
                ConsolidatedGrid.ItemsSource = null;
                ConsolidatedGrid.Columns.Clear();
                ConsolidatedGrid.ColumnGroups.Clear();
                ConsolidatedGrid.Items.Clear();

                var mainViewModel = ((MainWindow)(App.Current.MainWindow)).DataContext as MainVM;
                if (anagousReactionVM != null)
                {
                    #region Add Columns

                    var maxProducts = mainViewModel.TanVM.ReactionParticipants.OfReactionOfType(anagousReactionVM.SelectedMasterReaction.Id, ParticipantType.Product).Select(p => p.DisplayOrder).Distinct().OrderByDescending(o => o).FirstOrDefault();
                    var maxStage    = anagousReactionVM.AnalogousReactions.Any() ? anagousReactionVM.AnalogousReactions[0]?.Stages.Count : 0;

                    GridViewDataColumn ReactionIdColumn = new Telerik.Windows.Controls.GridViewDataColumn();
                    ReactionIdColumn.Header            = RXNID;
                    ReactionIdColumn.DataMemberBinding = new Binding(RXNID);
                    ReactionIdColumn.IsVisible         = false;
                    ConsolidatedGrid.Columns.Add(ReactionIdColumn);

                    var snoNumberColumn = new Telerik.Windows.Controls.GridViewDataColumn();
                    snoNumberColumn.Header            = SNO;
                    snoNumberColumn.DataMemberBinding = new Binding(SNO);
                    snoNumberColumn.IsReadOnly        = true;
                    snoNumberColumn.Width             = 40;
                    ConsolidatedGrid.Columns.Add(snoNumberColumn);

                    var rxnColumn = new Telerik.Windows.Controls.GridViewDataColumn();
                    rxnColumn.Header            = RXN;
                    rxnColumn.DataMemberBinding = new Binding(RXN);
                    rxnColumn.IsReadOnly        = true;
                    rxnColumn.Width             = 100;
                    ConsolidatedGrid.Columns.Add(rxnColumn);

                    var cvtColumn = new Telerik.Windows.Controls.GridViewDataColumn();
                    cvtColumn.Header            = REACTIONCVT;
                    cvtColumn.DataMemberBinding = new Binding(REACTIONCVT);
                    cvtColumn.IsReadOnly        = true;
                    cvtColumn.Width             = 100;
                    ConsolidatedGrid.Columns.Add(cvtColumn);

                    var FreeTextColumn = new Telerik.Windows.Controls.GridViewDataColumn();
                    FreeTextColumn.Header            = REACTIONFREETEXT;
                    FreeTextColumn.DataMemberBinding = new Binding(REACTIONFREETEXT);
                    FreeTextColumn.IsReadOnly        = true;
                    FreeTextColumn.Width             = 100;
                    ConsolidatedGrid.Columns.Add(FreeTextColumn);

                    //for (int productIndex = 1; productIndex <= maxProducts; productIndex++)
                    //{
                    GridViewDataColumn ProductIdColumn = new Telerik.Windows.Controls.GridViewDataColumn();
                    ProductIdColumn.Header            = PRODUCT + "ID";
                    ProductIdColumn.DataMemberBinding = new Binding(PRODUCT + "ID");
                    ProductIdColumn.IsVisible         = false;
                    ConsolidatedGrid.Columns.Add(ProductIdColumn);

                    var ProductColumn = new Telerik.Windows.Controls.GridViewDataColumn();
                    ProductColumn.Header            = PRODUCT;
                    ProductColumn.DataMemberBinding = new Binding(PRODUCT);
                    ProductColumn.ColumnGroupName   = PRODUCT;
                    ProductColumn.Width             = 100;
                    ConsolidatedGrid.Columns.Add(ProductColumn);
                    //}

                    //for (int productIndex = 1; productIndex <= maxProducts; productIndex++)
                    //{
                    var YieldColumn = new Telerik.Windows.Controls.GridViewDataColumn();
                    YieldColumn.Header            = YIELD;
                    YieldColumn.DataMemberBinding = new Binding(YIELD);
                    YieldColumn.ColumnGroupName   = YIELD;
                    YieldColumn.Width             = 45;
                    ConsolidatedGrid.Columns.Add(YieldColumn);
                    //}

                    for (int stageIndex = 1; stageIndex <= maxStage; stageIndex++)
                    {
                        var stageGroup = new Telerik.Windows.Controls.GridViewColumnGroup {
                            Name = STAGE + stageIndex
                        };
                        ConsolidatedGrid.ColumnGroups.Add(stageGroup);

                        foreach (var participantName in ParticipantHeaders)
                        {
                            GridViewDataColumn IdColumn = new Telerik.Windows.Controls.GridViewDataColumn();
                            IdColumn.Header            = participantName + stageIndex + "ID";
                            IdColumn.DataMemberBinding = new Binding(participantName + stageIndex + "ID");
                            IdColumn.ColumnGroupName   = stageGroup.Name;
                            IdColumn.IsVisible         = false;
                            ConsolidatedGrid.Columns.Add(IdColumn);
                            var participantColumn = new Telerik.Windows.Controls.GridViewDataColumn();
                            participantColumn.Header            = participantName;
                            participantColumn.ColumnGroupName   = stageGroup.Name;
                            participantColumn.DataMemberBinding = new Binding(participantName + stageIndex);
                            participantColumn.Width             = 70;
                            ConsolidatedGrid.Columns.Add(participantColumn);
                        }

                        var Temperature = new Telerik.Windows.Controls.GridViewDataColumn();
                        Temperature.Header            = TEMPERATURE;
                        Temperature.ColumnGroupName   = stageGroup.Name;
                        Temperature.DataMemberBinding = new Binding(TEMPERATURE + stageIndex);
                        Temperature.Width             = 70;
                        Temperature.IsReadOnly        = true;
                        ConsolidatedGrid.Columns.Add(Temperature);

                        var Pressure = new Telerik.Windows.Controls.GridViewDataColumn();
                        Pressure.Header            = PRESSURE;
                        Pressure.ColumnGroupName   = stageGroup.Name;
                        Pressure.DataMemberBinding = new Binding(PRESSURE + stageIndex);
                        Pressure.Width             = 70;
                        Pressure.IsReadOnly        = true;
                        ConsolidatedGrid.Columns.Add(Pressure);

                        var Time = new Telerik.Windows.Controls.GridViewDataColumn();
                        Time.Header            = TIME;
                        Time.ColumnGroupName   = stageGroup.Name;
                        Time.DataMemberBinding = new Binding(TIME + stageIndex);
                        Time.Width             = 70;
                        Time.IsReadOnly        = true;
                        ConsolidatedGrid.Columns.Add(Time);

                        var pH = new Telerik.Windows.Controls.GridViewDataColumn();
                        pH.Header            = PH;
                        pH.ColumnGroupName   = stageGroup.Name;
                        pH.DataMemberBinding = new Binding(PH + stageIndex);
                        pH.Width             = 70;
                        pH.IsReadOnly        = true;
                        ConsolidatedGrid.Columns.Add(pH);

                        var StageCVT = new Telerik.Windows.Controls.GridViewDataColumn();
                        StageCVT.Header            = STAGECVT + stageIndex;
                        StageCVT.ColumnGroupName   = stageGroup.Name;
                        StageCVT.DataMemberBinding = new Binding(STAGECVT + stageIndex);
                        StageCVT.Width             = 70;
                        StageCVT.IsReadOnly        = true;
                        ConsolidatedGrid.Columns.Add(StageCVT);

                        var StageFreeText = new Telerik.Windows.Controls.GridViewDataColumn();
                        StageFreeText.Header            = STAGEFREETEXT;
                        StageFreeText.ColumnGroupName   = stageGroup.Name;
                        StageFreeText.DataMemberBinding = new Binding(STAGEFREETEXT + stageIndex);
                        StageFreeText.Width             = 70;
                        StageFreeText.IsReadOnly        = true;
                        ConsolidatedGrid.Columns.Add(StageFreeText);
                    }
                    ConsolidatedGrid.FrozenColumnCount = 9;
                    foreach (Telerik.Windows.Controls.GridViewDataColumn c in ConsolidatedGrid.Columns)
                    {
                        c.IsFilterable = false;
                    }
                    #endregion

                    foreach (var c in ConsolidatedGrid.Columns)
                    {
                        var dc = (GridViewDataColumn)c;
                    }

                    int rowCount = 1;
                    List <IDictionary <String, Object> > rows = new List <IDictionary <String, Object> >();

                    foreach (var reaction in anagousReactionVM.AnalogousReactions)
                    {
                        var row = (IDictionary <String, Object>) new ExpandoObject();
                        row[AG]    = 1;
                        row[SNO]   = rowCount++;
                        row[RXN]   = reaction.Name;
                        row[RXNID] = reaction.Id;

                        if (NewAnalogous)
                        {
                            var reactionRSN = anagousReactionVM.Rsns.Where(p => p.Reaction.Id == reaction.Id && p.Stage == null).OrderBy(p => p.DisplayOrder);
                            row[PRODUCT]          = string.Empty;
                            row[PRODUCT + "ID"]   = string.Empty;
                            row[YIELD]            = string.Empty;
                            row[REACTIONFREETEXT] = !string.IsNullOrEmpty(string.Join(",", reactionRSN.Select(rsn => rsn.FreeText).ToList())) ? string.Join(",", reactionRSN.Select(rsn => rsn.FreeText).ToList()) : string.Empty;
                            row[REACTIONCVT]      = !string.IsNullOrEmpty(string.Join(",", reactionRSN.Select(rsn => rsn.CvtText).ToList())) ? string.Join(",", reactionRSN.Select(rsn => rsn.CvtText).ToList()) : string.Empty;
                        }
                        else
                        {
                            var products = mainViewModel.TanVM.ReactionParticipants.OfReactionOfType(reaction.Id, ParticipantType.Product).OrderBy(p => p.DisplayOrder);

                            var reactionRSN = mainViewModel.TanVM.Rsns.Where(p => p.Reaction.Id == reaction.Id && p.Stage == null).OrderBy(p => p.DisplayOrder);
                            row[PRODUCT]          = string.Join(",", products.Select(n => n.Num).ToList());
                            row[PRODUCT + "ID"]   = string.Join(",", products.Select(n => n.Id).ToList());
                            row[YIELD]            = string.Join(",", products.Select(n => n.Yield).ToList());
                            row[REACTIONFREETEXT] = !string.IsNullOrEmpty(string.Join(",", reactionRSN.Select(rsn => rsn.FreeText).ToList())) ? string.Join(",", reactionRSN.Select(rsn => rsn.FreeText).ToList()) : string.Empty;
                            row[REACTIONCVT]      = !string.IsNullOrEmpty(string.Join(",", reactionRSN.Select(rsn => rsn.CvtText).ToList())) ? string.Join(",", reactionRSN.Select(rsn => rsn.CvtText).ToList()) : string.Empty;
                        }

                        if (reaction.Stages != null && reaction.Stages.Any())
                        {
                            int stageCount = 1;
                            foreach (var stage in reaction.Stages)
                            {
                                row.Add(STAGEID + stageCount, stage.Id);
                                var stageRsn = NewAnalogous ? anagousReactionVM.Rsns.Where(p => p.Reaction.Id == reaction.Id && p.Stage != null && p.Stage.Id == stage.Id).OrderBy(p => p.DisplayOrder) :
                                               mainViewModel.TanVM.Rsns.Where(p => p.Reaction.Id == reaction.Id && p.Stage != null && p.Stage.Id == stage.Id).OrderBy(p => p.DisplayOrder);

                                foreach (var participantType in ParticipantHeaders)
                                {
                                    if (participantType.Equals(ParticipantType.Reactant.ToString()) && !NewAnalogous)
                                    {
                                        var reactants = mainViewModel.TanVM.ReactionParticipants.OfReactionAndStage(reaction.Id, stage.Id).Where(p => p.ParticipantType.ToString() == participantType).OrderBy(p => p.DisplayOrder);
                                        var csvNames  = String.Join(",", reactants.Select(r => r.Num));
                                        row.Add(participantType.ToString() + stageCount, csvNames);
                                        row.Add(participantType.ToString() + stageCount + "ID", String.Join(",", reactants.Select(r => r.Id)));
                                    }
                                    else
                                    {
                                        var otherParticipants = anagousReactionVM.ReactionParticipants.OfReactionAndStage(reaction.Id, stage.Id).Where(p => p.ParticipantType.ToString() == participantType).OrderBy(p => p.DisplayOrder);
                                        if (otherParticipants.Count() > 0)
                                        {
                                            var csvNames = String.Join(",", otherParticipants.Select(r => r.Num));
                                            row.Add(participantType.ToString() + stageCount, csvNames);
                                            row.Add(participantType.ToString() + stageCount + "ID", String.Join(",", otherParticipants.Select(r => r.Id)));
                                        }
                                        else
                                        {
                                            row.Add(participantType.ToString() + stageCount, string.Empty);
                                            row.Add(participantType.ToString() + stageCount + "ID", string.Empty);
                                        }
                                    }
                                }
                                row.Add(TIME + stageCount, string.Join(",", stage.Conditions.Select(t => t.Time).ToList()));
                                row.Add(TEMPERATURE + stageCount, string.Join(",", stage.Conditions.Select(t => t.Temperature).ToList()));
                                row.Add(PRESSURE + stageCount, string.Join(",", stage.Conditions.Select(t => t.Pressure).ToList()));
                                row.Add(PH + stageCount, string.Join(",", stage.Conditions.Select(t => t.PH).ToList()));
                                row.Add(STAGECVT + stageCount, string.Join(",", stageRsn.Select(t => t.CvtText).ToList()));
                                row.Add(STAGEFREETEXT + stageCount, string.Join(",", stageRsn.Select(t => t.FreeText).ToList()));
                                stageCount++;
                            }
                        }
                        rows.Add(row);
                    }
                    ConsolidatedGrid.ItemsSource = rows;
                }
            }
            catch (Exception ex)
            {
                Log.This(ex);
                throw;
            }
        }