public void Execute(
            IEnumerable <FM70PeriodisedValuesYearlyModel> ilrData,
            IList <FundingSummaryReportYearlyValueModel> yearlyData)
        {
            if (ilrData != null && ilrData.Any())
            {
                foreach (var year in ilrData)
                {
                    var data = year.Fm70PeriodisedValues.Where(d =>
                                                               d.DeliverableCode == DeliverableCode && AttributeNames.Contains(d.AttributeName)).ToList();

                    var yearData = new FundingSummaryReportYearlyValueModel();
                    for (var i = 1; i < 13; i++)
                    {
                        yearData.Values[i - 1] = GetPeriodValueSum(data, i);
                    }

                    yearData.FundingYear = year.FundingYear;
                    yearlyData.Add(yearData);
                }
            }
            else
            {
                var yearData = new FundingSummaryReportYearlyValueModel();
                for (var i = 1; i < 13; i++)
                {
                    yearData.Values[i - 1] = 0;
                }

                yearlyData.Add(yearData);
            }
        }
        public void Execute(
            IList <FundingSummaryModel> reportOutput,
            FundingReportRow row,
            IEnumerable <SupplementaryDataYearlyModel> esfDataModels,
            IEnumerable <FM70PeriodisedValuesYearlyModel> ilrData)
        {
            List <string> deliverableCodes = row.DeliverableCode?.Split(',').Select(x => x.Trim())
                                             .Where(x => !string.IsNullOrWhiteSpace(x)).ToList();

            List <FundingSummaryModel> reportRowsToTotal = deliverableCodes == null?
                                                           reportOutput.Where(r => r.ExcelRecordStyle == 2).ToList() :
                                                               reportOutput.Where(r => deliverableCodes.Contains(r.DeliverableCode) && r.ExcelRecordStyle == 4).ToList();

            if (!reportRowsToTotal.Any())
            {
                return;
            }

            var rowModel = new FundingSummaryModel(row.Title, HeaderType.None, 2)
            {
                DeliverableCode  = row.DeliverableCode,
                ExcelRecordStyle = 2
            };

            if (row.RowType == RowType.FinalTotal)
            {
                rowModel.ExcelHeaderStyle = 0;
                rowModel.ExcelRecordStyle = 0;
            }

            var yearlyValueTotals = new List <FundingSummaryReportYearlyValueModel>();

            foreach (var yearlyValue in reportRowsToTotal.First().YearlyValues)
            {
                var yearlyModel = new FundingSummaryReportYearlyValueModel
                {
                    FundingYear = yearlyValue.FundingYear
                };

                List <FundingSummaryReportYearlyValueModel> periodValues = reportRowsToTotal.SelectMany(r => r.YearlyValues).ToList();

                for (var i = 0; i < (periodValues.FirstOrDefault()?.Values.Length ?? 0); i++)
                {
                    yearlyModel.Values[i] = GetPeriodTotals(periodValues, i);
                }

                yearlyValueTotals.Add(yearlyModel);
            }

            rowModel.YearlyValues = yearlyValueTotals;

            yearlyValueTotals.ForEach(v =>
            {
                rowModel.Totals.Add(v.Values.Sum());
            });

            reportOutput.Add(rowModel);
        }
        public void Execute(
            IList <FundingSummaryModel> reportOutput,
            FundingReportRow row,
            IEnumerable <SupplementaryDataYearlyModel> esfDataModels,
            IEnumerable <FM70PeriodisedValuesYearlyModel> ilrData)
        {
            FundingSummaryModel rowModel      = new FundingSummaryModel(row.Title, HeaderType.None, 3);
            FundingSummaryModel grandTotalRow = reportOutput.FirstOrDefault(r => r.Title == "<ESF-1> Total (£)");

            if (row.RowType == RowType.FinalCumulative)
            {
                rowModel.ExcelHeaderStyle = 0;
                rowModel.ExcelRecordStyle = 0;
            }

            if (grandTotalRow == null)
            {
                reportOutput.Add(rowModel);
                return;
            }

            var yearlyValues    = new List <FundingSummaryReportYearlyValueModel>();
            var cumulativeTotal = 0M;

            foreach (var year in grandTotalRow.YearlyValues)
            {
                var yearValues = new FundingSummaryReportYearlyValueModel();
                for (var i = 0; i < 12; i++)
                {
                    cumulativeTotal     += year.Values[i];
                    yearValues.Values[i] = cumulativeTotal;
                }

                yearlyValues.Add(yearValues);
            }

            rowModel.YearlyValues = yearlyValues;

            var yearEndCumulative = 0M;

            for (var index = 0; index < grandTotalRow.Totals.Count - 1; index++)
            {
                var total = grandTotalRow.Totals[index];
                yearEndCumulative += total;
                rowModel.Totals.Add(yearEndCumulative);
            }

            reportOutput.Add(rowModel);
        }
Exemplo n.º 4
0
        public void Execute(
            IEnumerable <SupplementaryDataYearlyModel> data,
            IList <FundingSummaryReportYearlyValueModel> yearlyData)
        {
            foreach (var year in data)
            {
                var yearData = new FundingSummaryReportYearlyValueModel();
                for (var i = 1; i < 13; i++)
                {
                    var deliverableData = year.SupplementaryData.Where(supp => supp.CalendarMonth == i + EsfMonthPadding &&
                                                                       supp.DeliverableCode == DeliverableCode);
                    if (ReferenceType != null)
                    {
                        deliverableData =
                            deliverableData.Where(supp => supp.ReferenceType == ReferenceType);
                    }

                    yearData.Values[i - 1] = GetPeriodValueSum(deliverableData, i);
                }

                yearData.FundingYear = year.FundingYear;
                yearlyData.Add(yearData);
            }
        }