private void LoadPeriodGraphData(PMIOperation pmiOperation, string operationNumber)
        {
            //render second graphic
            var rawData = _clientPMIDetails
                          .GetValuePerformance(0, operationNumber, pmiOperation)
                          .OrderBy(c => c.Year);

            var transformed = new
            {
                Actual = rawData.Select(c => new object[]
                {
                    c.Year, c.Actual == -1 ? null : (decimal?)c.Actual
                }),
                Planned = rawData.Select(c => new object[]
                {
                    c.Year, c.Planned == -1 ? null : (decimal?)c.Planned
                }),
                Earned = rawData.Select(c => new object[]
                {
                    c.Year, c.Earned == -1 ? null : (decimal?)c.Earned
                }),
                AnnualPlanned = rawData.Select(c => new object[]
                {
                    c.Year, c.AnnualPlanned == -1 ? null : (decimal?)c.AnnualPlanned
                }),
                AnnualEarned = rawData.Select(c => new object[]
                {
                    c.Year, c.AnnualEarned == -1 ? null : (decimal?)c.AnnualEarned
                }),
                Raw   = rawData,
                Years = rawData.Select(c => c.Year).Distinct().OrderBy(c => c)
            };

            ViewBag.PeriodGraphData = transformed;
        }
        public void LoadPercentageProgress(PMIOperation pmiOperation, string operationNumber)
        {
            var milestoneOrOutput = pmiOperation.MilestoneOrOutput;

            var transformed = new
            {
                CostSpent   = pmiOperation.PercentageCostSpent,
                TimeElapsed = pmiOperation.PercentageOfTimeElapsed,
                Average     = pmiOperation.AverageOutput,
                Weighted    = pmiOperation.WeightedAverage,
                ListOutputs = milestoneOrOutput.Select(x => new { x.Item3, x.Item2 }).ToList()
            };

            ViewBag.PercentageProgress = transformed;
        }
        public void LoadPercentageProgressAnnual(PMIOperation pmiOperation, string operationNumber)
        {
            var MilestoneOrOutputAnnual = pmiOperation.MilestoneOrOutputAnnual;

            var transformed = new
            {
                CostSpentAnnual   = pmiOperation.PercentageCostSpentAnnual,
                TimeElapsedAnnual = pmiOperation.PercentageOfTimeElapsedAnnual,
                AverageAnnual     = pmiOperation.AverageOutputAnnual,
                WeightedAnnual    = pmiOperation.WeightedAverageAnnual,
                ListOutputsAnnual = MilestoneOrOutputAnnual
                                    .Select(x => new { x.Item3, x.Item2 })
                                    .ToList()
            };

            ViewBag.PercentageProgressAnnual = transformed;
        }
        public void LoadDISB95(PMIOperation pmiOperation, string operationNumber, bool isLive)
        {
            var pmi         = _clientPMIDetails.GetCurrentPMIEscalarBenchmark(operationNumber, pmiOperation, isLive);
            var transformed = new
            {
                MaxLevel = pmi.PmiEscalarBenchmark.ListPMIEscalar
                           .Where(x => x.PmiTypeId == pmi.MasterDISB95)
                           .Select(x => x.MaxLevel)
                           .FirstOrDefault(),
                AlertLevel = pmi.PmiEscalarBenchmark.ListPMIEscalar
                             .Where(x => x.PmiTypeId == pmi.MasterDISB95)
                             .Select(x => x.AlertLevel)
                             .FirstOrDefault(),
                ProblemLevel = pmi.PmiEscalarBenchmark.ListPMIEscalar
                               .Where(x => x.PmiTypeId == pmi.MasterDISB95)
                               .Select(x => x.ProblemLevel)
                               .FirstOrDefault(),
                Disbursement95 = pmi.Disbur95,
            };

            ViewBag.Disb95 = transformed;
        }
        public static AccumulateDisbursementData LoadAccumalteDisbursementsGraphData(
            List <HistoricAcumulated> historyAccumulated,
            PMIOperation pmiOperation,
            string operationNumber,
            bool prevVersion)
        {
            if (pmiOperation == null || pmiOperation.BenchmarkCurve == null)
            {
                return(null);
            }

            List <ListPMICurveModel>  pmi;
            List <HistoricAcumulated> history;

            if (!prevVersion)
            {
                pmi     = pmiOperation.BenchmarkCurve;
                history = pmiOperation.PersistedAccumulatedDisbursement
                          .Select(x =>
                                  new HistoricAcumulated()
                {
                    ACUMULATED = (float)x.Value,
                    MONTHS     = x.Key,
                    YEAR       =
                        pmiOperation.ApprovalDate != null
                                    ? ((DateTime)pmiOperation.ApprovalDate).AddMonths(x.Key).Year
                                    : 0
                }).ToList();

                return(new AccumulateDisbursementData
                {
                    IDB = pmi
                          .Select(c => new object[]
                    {
                        c.PeriodNumber,
                        c.Idb_Value,
                    })
                          .ToList(),
                    Country = pmi
                              .Select(c => new object[]
                    {
                        c.PeriodNumber,
                        c.AverageValue,
                    })
                              .ToList(),
                    Alert = pmi
                            .Select(c => new object[]
                    {
                        c.PeriodNumber,
                        c.UpperLimit,
                    })
                            .ToList(),
                    Problem = pmi
                              .Select(c => new object[]
                    {
                        c.PeriodNumber,
                        c.ProblemLevel,
                    })
                              .ToList(),
                    Percentage = history.Select(c => new object[]
                    {
                        c.MONTHS,
                        c.ACUMULATED,
                        c.YEAR
                    }).ToList(),
                });
            }

            bool sw = true;

            pmi = pmiOperation.BenchmarkCurve;
            int yearLimit = pmiOperation.GetYearLimitForIndicators;

            history = historyAccumulated;
            var TotalAccumulatedDisbursements = pmiOperation.AccumulatedDisbursement;

            if (pmiOperation.OperationIsClosed)
            {
                if (yearLimit < DateTime.Now.Year)
                {
                    sw = false;
                }

                history.RemoveAll(item => item.YEAR > yearLimit);
            }

            var result = new AccumulateDisbursementData
            {
                IDB = pmi
                      .Select(c => new object[]
                {
                    c.PeriodNumber,
                    c.Idb_Value
                })
                      .ToList(),
                Country = pmi
                          .Select(c => new object[]
                {
                    c.PeriodNumber,
                    c.AverageValue,
                })
                          .ToList(),
                Alert = pmi
                        .Select(c => new object[]
                {
                    c.PeriodNumber,
                    c.UpperLimit
                })
                        .ToList(),
                Problem = pmi
                          .Select(c => new object[]
                {
                    c.PeriodNumber,
                    c.ProblemLevel,
                })
                          .ToList(),
                Percentage = history.Select(c => new object[]
                {
                    c.MONTHS,
                    c.ACUMULATED,
                    c.YEAR
                }).ToList(),
            };

            if (pmiOperation.OperationIsClosed && sw)
            {
                result.Percentage.Add(new object[]
                {
                    pmiOperation.DisbursedMonths,
                    TotalAccumulatedDisbursements,
                    DateTime.Now.Year
                });
            }
            else
            {
                int CountHistory = history.Select(item => item.YEAR).Count();
                if (CountHistory == 0)
                {
                    result.Percentage.Add(new object[]
                    {
                        pmiOperation.DisbursedMonths,
                        TotalAccumulatedDisbursements,
                        yearLimit
                    });
                }
                else
                {
                    int yearMaxOfHistory = history.Select(item => item.YEAR).Max();
                    if (yearMaxOfHistory < yearLimit)
                    {
                        result.Percentage.Add(new object[]
                        {
                            pmiOperation.DisbursedMonths,
                            TotalAccumulatedDisbursements,
                            yearLimit
                        });
                    }
                }
            }

            return(result);
        }
        public void LoadAnnualGraphData(string operationNumber, PMIOperation pmiOperation)
        {
            int firstDisbursement = pmiOperation.YearOfDisbursement;
            var rawData           = _clientPMIDetails.GetIndexPerformance(operationNumber, pmiOperation).OrderBy(c => c.Year);

            if (firstDisbursement >= 2012)
            {
                var transformed =
                    new
                {
                    SPI =
                        rawData.Select(
                            c =>
                            new object[]
                    {
                        c.Year, c.SchedulePerformance == -1 ? null : (decimal?)c.SchedulePerformance
                    })
                        .ToList(),
                    CPI =
                        rawData.Select(
                            c =>
                            new object[]
                    {
                        c.Year, c.CostPerformance == -1 ? null : (decimal?)c.CostPerformance
                    })
                        .ToList(),
                    SPIa =
                        rawData.Select(
                            c =>
                            new object[]
                    {
                        c.Year,
                        c.AnnualSchedulePerformance == -1
                                            ? null
                                            : (decimal?)c.AnnualSchedulePerformance
                    }).ToList(),
                    CPIa =
                        rawData.Select(
                            c =>
                            new object[]
                    {
                        c.Year, c.AnnualCostPerformance == -1 ? null : (decimal?)c.AnnualCostPerformance
                    })
                        .ToList(),
                    Raw               = rawData,
                    Years             = rawData.Select(c => c.Year).Distinct().OrderBy(c => c),
                    firstDisbursement = 1
                };
                ViewBag.AnnualGraphData = transformed;
            }
            else
            {
                var transformed =
                    new
                {
                    SPIa =
                        rawData.Select(
                            c =>
                            new object[]
                    {
                        c.Year,
                        c.AnnualSchedulePerformance == -1
                                            ? null
                                            : (decimal?)c.AnnualSchedulePerformance
                    }).ToList(),
                    CPIa =
                        rawData.Select(
                            c =>
                            new object[]
                    {
                        c.Year, c.AnnualCostPerformance == -1 ? null : (decimal?)c.AnnualCostPerformance
                    })
                        .ToList(),
                    Raw               = rawData,
                    Years             = rawData.Select(c => c.Year).Distinct().OrderBy(c => c),
                    firstDisbursement = 2
                };
                ViewBag.AnnualGraphData = transformed;
            }
        }