예제 #1
0
        private void SetViewBag(string operationNumber, UseCountrySystemViewModel viewModel)
        {
            var outcomeResponse = _linkPredefinedIndicatorService.GetLinkIndicatorModelForCSResultMatrix(false, "LinkIndicator");

            ViewBag.LinkIndicatorModel = outcomeResponse.Filter;

            ViewBag.CRFIndicators = new List <SelectListItem>();
            if (viewModel != null)
            {
                var allCRFIndicatorIdUsed = viewModel.UCSStrategicObjective.SelectMany(x => x.ExpectedOutcomeIndicators).SelectMany(y => y.LinkedIndicators).Distinct();
                var crfIndicatorResponse  = _useCountrySystemService.GetCRFIndicatorsById(allCRFIndicatorIdUsed);
                ViewBag.CRFIndicators = crfIndicatorResponse.CRFIndicators;
            }

            this.SetViewBagListFromCatalog(_catalogService, new Dictionary <ConvergenceMasterDataTypeEnum, string>
            {
                { ConvergenceMasterDataTypeEnum.StrategicObjectiveType, "StrategicObjectiveList" },
                { ConvergenceMasterDataTypeEnum.TimmingType, "TimmingList" },
                { ConvergenceMasterDataTypeEnum.ForeseenActionType, "ForeseenActionsList" },
                { ConvergenceMasterDataTypeEnum.UseCountrySystemType, "UseCountryList" },
            });

            var forseenActionAux       = (List <SelectListItem>)ViewBag.ForeseenActionsList;
            var foreseenActionsListAux = forseenActionAux.ConvertToMultiDropDownItems();

            var forseenList = new List <MultiDropDownItem>();

            forseenList.Add(foreseenActionsListAux.SingleOrDefault(x => x.Value == _enumMappingService.GetMappingCode(ForeseenActionTypeEnum.NoForeseenAction).ToString()));
            forseenList.Add(foreseenActionsListAux.SingleOrDefault(x => x.Value == _enumMappingService.GetMappingCode(ForeseenActionTypeEnum.FiduciaryAssessment).ToString()));
            forseenList.Add(foreseenActionsListAux.SingleOrDefault(x => x.Value == _enumMappingService.GetMappingCode(ForeseenActionTypeEnum.CloseGap).ToString()));
            forseenList.Add(foreseenActionsListAux.SingleOrDefault(x => x.Value == _enumMappingService.GetMappingCode(ForeseenActionTypeEnum.StrNationalSystem).ToString()));
            forseenList.Add(foreseenActionsListAux.SingleOrDefault(x => x.Value == _enumMappingService.GetMappingCode(ForeseenActionTypeEnum.OpenDialogue).ToString()));
            forseenList.Add(foreseenActionsListAux.SingleOrDefault(x => x.Value == _enumMappingService.GetMappingCode(ForeseenActionTypeEnum.ValidationSystem).ToString()));
            forseenList.Add(foreseenActionsListAux.SingleOrDefault(x => x.Value == _enumMappingService.GetMappingCode(ForeseenActionTypeEnum.AgreementImplement).ToString()));
            forseenList.Add(foreseenActionsListAux.SingleOrDefault(x => x.Value == _enumMappingService.GetMappingCode(ForeseenActionTypeEnum.StrengtheningIntervention).ToString()));
            forseenList.Add(foreseenActionsListAux.SingleOrDefault(x => x.Value == _enumMappingService.GetMappingCode(ForeseenActionTypeEnum.UseSystemSuspended).ToString()));

            ViewBag.ForeseenActionsList = forseenList;
            ViewBag.CloseGapId          = _enumMappingService.GetMappingCode <ForeseenActionTypeEnum>(ForeseenActionTypeEnum.CloseGap);
        }
        public static UseCountrySystemViewModel UpdateUseCountrySystemViewModel(this UseCountrySystemViewModel model, ClientFieldData[] formData)
        {
            //Use of Country Systems Results Matrix
            var outcomeIdNew   = 0;
            var indicatorIdNew = 0;

            model.UCSStrategicObjective.Clear();
            var inputsCSResultsMatrix = new string[]
            {
                "operationId",
                "Component-OrderNumber",
                "strtegicObjective",
                "ExpectedOutcome",
                "Indicator",
                "UnitOfMeasure",
                "Baseline",
                "BaselineYear",
                "Source",
                "timming",
                "LinkedIndicator"
            };

            var fieldsCSResultsMatrix        = formData.Where(x => !string.IsNullOrWhiteSpace(x.Id) && inputsCSResultsMatrix.Any(y => x.Name == y));
            var fieldsCSResultsMatrixGrouped = fieldsCSResultsMatrix.GroupBy(x => x.Id);

            foreach (var cSResultsMatrixItem in fieldsCSResultsMatrixGrouped)
            {
                var strObjectiveId = cSResultsMatrixItem.Key;
                if (strObjectiveId.Contains("new-"))
                {
                    strObjectiveId = "0";
                }

                var newStrObjective = new UCSStrategicObjectiveViewModel()
                {
                    UCSStrategicObjectiveId = strObjectiveId.ConvertToInt(),
                };

                model.UCSStrategicObjective.Add(newStrObjective);

                var field = cSResultsMatrixItem.First(x => x.Name == inputsCSResultsMatrix[0]);
                if (field != null)
                {
                    newStrObjective.OperationId = field.ConvertToInt();
                }

                field = cSResultsMatrixItem.First(x => x.Name == inputsCSResultsMatrix[1]);
                if (field != null)
                {
                    newStrObjective.OrderNumber = field.ConvertToInt();
                }

                field = cSResultsMatrixItem.First(x => x.Name == inputsCSResultsMatrix[2]);
                if (field != null)
                {
                    newStrObjective.StrategicObjectiveTypeId = field.ConvertToInt();
                }

                var fieldsGroupedForOutcome = cSResultsMatrixItem.Where(x => x.ExtraData.ContainsKey("data-persist-outcomeid"))
                                              .GroupBy(x => x.ExtraData.Single(y => y.Key == "data-persist-outcomeid"));

                foreach (var outcomeItem in fieldsGroupedForOutcome)
                {
                    var outcomeId = outcomeItem.Key.Value;
                    if (outcomeId.Contains("new-"))
                    {
                        outcomeIdNew--;
                        outcomeId = outcomeIdNew.ToString();
                    }

                    field = outcomeItem.First(x => x.Name == inputsCSResultsMatrix[3]);
                    var ecpectedOutcome = field.ConvertToString();

                    var fieldsGroupedForIndicator = outcomeItem.Where(x => x.ExtraData.ContainsKey("data-persist-indicatorid"))
                                                    .GroupBy(x => x.ExtraData.Single(y => y.Key == "data-persist-indicatorid"));

                    foreach (var indicatorItem in fieldsGroupedForIndicator)
                    {
                        var indicatorId = indicatorItem.Key.Value;
                        if (indicatorId.Contains("new-"))
                        {
                            indicatorIdNew--;
                            indicatorId = indicatorIdNew.ToString();
                        }

                        var newOutcome = new UCSExpectedOutcomeIndicatorViewModel()
                        {
                            UCSStrategicObjectiveId = newStrObjective.UCSStrategicObjectiveId,
                            OperationId             = newStrObjective.OperationId,
                            ExpectedOutcomeId       = outcomeId.ConvertToInt(),
                            IndicatorId             = indicatorId.ConvertToInt(),
                            ExpectedOutcome         = ecpectedOutcome
                        };

                        newStrObjective.ExpectedOutcomeIndicators.Add(newOutcome);

                        field = indicatorItem.First(x => x.Name == inputsCSResultsMatrix[4]);
                        if (field != null)
                        {
                            newOutcome.Indicator = field.ConvertToString();
                        }

                        field = indicatorItem.First(x => x.Name == inputsCSResultsMatrix[5]);
                        if (field != null)
                        {
                            newOutcome.UnitOfMeasure = field.ConvertToString();
                        }

                        field = indicatorItem.First(x => x.Name == inputsCSResultsMatrix[6]);
                        if (field != null)
                        {
                            newOutcome.Baseline = field.ConvertToString();
                        }

                        field = indicatorItem.First(x => x.Name == inputsCSResultsMatrix[7]);
                        if (field != null)
                        {
                            newOutcome.BaselineYear = field.ConvertToString();
                        }

                        field = indicatorItem.First(x => x.Name == inputsCSResultsMatrix[8]);
                        if (field != null)
                        {
                            newOutcome.Source = field.ConvertToString();
                        }

                        field = indicatorItem.First(x => x.Name == inputsCSResultsMatrix[9]);
                        if (field != null)
                        {
                            newOutcome.TimmingTypeId = field.ConvertToInt();
                        }

                        var linkedIndicators = indicatorItem.Where(x => x.Name == "LinkedIndicator");

                        foreach (var linedField in linkedIndicators)
                        {
                            newOutcome.LinkedIndicators.Add(linedField.ConvertToInt());
                        }
                    }
                }
            }

            //Financial Management
            var inputsFinancialManagement = new string[]
            {
                "FinancialManagement-Id",
                "FinancialManagement-BaselineYear",
                "FinancialManagement-Baseline",
                "FinancialManagement-EstimateUseYear",
                "FinancialManagement-EstimatedUse",
                "FinancialManagement-ForeseenActions",
                "FinancialManagement-Comment"
            };

            var fieldsFinancialManagement        = formData.Where(x => !string.IsNullOrWhiteSpace(x.Id) && inputsFinancialManagement.Any(y => x.Name == y));
            var fieldsFinancialManagementGrouped = fieldsFinancialManagement.GroupBy(x => x.Id);

            foreach (var financialManagementItem in fieldsFinancialManagementGrouped)
            {
                var itemId = financialManagementItem.Key.Contains("new") ? 0 : financialManagementItem.Key.ConvertToInt(false);

                var financialManagementModel = model.FinancialManagement.FirstOrDefault(x => x.SystemRecordId == itemId);

                var financialManagementField = financialManagementItem.FirstOrDefault(x => x.Name == inputsFinancialManagement[1]);
                if (financialManagementField != null)
                {
                    financialManagementModel.BaseLineYear = financialManagementField.ConvertToInt(true);
                }

                financialManagementField = financialManagementItem.FirstOrDefault(x => x.Name == inputsFinancialManagement[2]);
                if (financialManagementField != null)
                {
                    financialManagementModel.BaseLine = financialManagementField.Value;
                }

                financialManagementField = financialManagementItem.FirstOrDefault(x => x.Name == inputsFinancialManagement[3]);
                if (financialManagementField != null)
                {
                    financialManagementModel.EstimateUseYear = financialManagementField.ConvertToInt(true);
                }

                financialManagementField = financialManagementItem.FirstOrDefault(x => x.Name == inputsFinancialManagement[4]);
                if (financialManagementField != null)
                {
                    financialManagementModel.EstimatedUse = financialManagementField.Value;
                }

                financialManagementField = financialManagementItem.FirstOrDefault(x => x.Name == inputsFinancialManagement[5]);
                if (financialManagementField != null)
                {
                    financialManagementModel.ForeseenActionIds = financialManagementField.ConvertToListInt(false);
                }

                financialManagementField = financialManagementItem.FirstOrDefault(x => x.Name == inputsFinancialManagement[6]);
                if (financialManagementField != null)
                {
                    financialManagementModel.Comment = financialManagementField.ConvertToString();
                }
            }

            //Procurement
            var inputsProcurement = new string[]
            {
                "Procurement-Id",
                "Procurement-BaselineYear",
                "Procurement-Baseline",
                "Procurement-EstimateUseYear",
                "Procurement-EstimatedUse",
                "Procurement-ForeseenActions",
                "Procurement-Comment"
            };

            var fieldsProcurement        = formData.Where(x => !string.IsNullOrWhiteSpace(x.Id) && inputsProcurement.Any(y => x.Name == y));
            var fieldsProcurementGrouped = fieldsProcurement.GroupBy(x => x.Id);

            foreach (var procurementItem in fieldsProcurementGrouped)
            {
                var itemId = procurementItem.Key.Contains("new") ? 0 : procurementItem.Key.ConvertToInt(false);

                var procurementModel = model.Procurement.FirstOrDefault(x => x.SystemRecordId == itemId);

                var procurementField = procurementItem.FirstOrDefault(x => x.Name == inputsProcurement[1]);
                if (procurementField != null)
                {
                    procurementModel.BaseLineYear = procurementField.ConvertToInt(true);
                }

                procurementField = procurementItem.FirstOrDefault(x => x.Name == inputsProcurement[2]);
                if (procurementField != null)
                {
                    procurementModel.BaseLine = procurementField.Value;
                }

                procurementField = procurementItem.FirstOrDefault(x => x.Name == inputsProcurement[3]);
                if (procurementField != null)
                {
                    procurementModel.EstimateUseYear = procurementField.ConvertToInt(true);
                }

                procurementField = procurementItem.FirstOrDefault(x => x.Name == inputsProcurement[4]);
                if (procurementField != null)
                {
                    procurementModel.EstimatedUse = procurementField.Value;
                }

                procurementField = procurementItem.FirstOrDefault(x => x.Name == inputsProcurement[5]);
                if (procurementField != null)
                {
                    procurementModel.ForeseenActionIds = procurementField.ConvertToListInt(false);
                }

                procurementField = procurementItem.FirstOrDefault(x => x.Name == inputsProcurement[6]);
                if (procurementField != null)
                {
                    procurementModel.Comment = procurementField.ConvertToString();
                }
            }

            return(model);
        }