BeWoPlaner/ReportImp/FeidPartnerReports/Calculation/CustomCalculations.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Service.DCEntityMapper;
using BeWo.Service.Plugins;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.Extensions;
using BS.Shared.Services;
using DevExpress.XtraCharts;
using DevExpress.XtraCharts.Design;

namespace FeidPartnerReports.Calculation
{
	public class CustomCalculations : BS.Shared.Services.Calculations
    {

        public override decimal? GetApprovedHoursForPeriod(SupportConceptCostBearerRelDC relDC,
                                                          SupportConceptApprovalPeriodDC scap,
                                                          List<CostRatePeriodDC> costRatePeriods,
                                                          DateTime? pStart,
                                                          DateTime? pEnd,
                                                          bool useIsCalculationWithFactor)
        {
            if (!pStart.HasValue || !pEnd.HasValue)
            {
                return 0;
            }
            return GetApprovedHoursForPeriod(pStart.Value, pEnd.Value, GetApprovedHoursPerMonth(scap, costRatePeriods));

        }

        public override decimal GetApprovedHoursForPeriod(SupportConceptCostBearerRelDC relDC, DateTime pStart, DateTime pEnd)
        {
            return base.GetApprovedHoursForPeriod(relDC, pStart, pEnd);
        }

        public override decimal? GetApprovedHoursForPeriod(SupportConceptApprovalPeriodDC scap, List<CostRatePeriodDC> costRatePeriods, DateTime? pStart,
            DateTime? pEnd)
        {
            return base.GetApprovedHoursForPeriod(scap, costRatePeriods, pStart, pEnd);
        }

        public override decimal? GetApprovedHoursTillNow(SupportConceptApprovalPeriodDC scap, List<CostRatePeriodDC> costRates, DateTime? appointedDate,
            bool excludeRateFactor)
        {
            DateTime end = (appointedDate.HasValue && appointedDate.Value < DateTime.Now.Date)
                ? appointedDate.Value
                : DateTime.Now.Date;

            if (scap.EndDate < end)
            {
                end = scap.EndDate.Value;
            }

            if (scap.StartDate.HasValue)
            {
                return GetApprovedHoursForPeriod(scap.StartDate.Value, end, GetApprovedHoursPerMonth(scap, costRates));
            }

            return 0;

        }

       

        public override decimal? GetApprovedHoursTillNow(SupportConceptCostBearerRelDC relDC, DateTime? appointedDate)
        {
            decimal totalApproved = 0;

            if (relDC.ApprovalPeriodList != null)
            {
                foreach (var scap in relDC.ApprovalPeriodList)
                {
                    totalApproved += GetApprovedHoursTillNow(scap, relDC.CostBearer.CostRatePeriods, appointedDate, false) ?? 0;
                }
            }

            return totalApproved;
        }

        public override decimal? GetApprovedHoursTotal(SupportConceptCostBearerRelDC relDC, bool useIsCalculationWithFactor)
        {
            if (relDC.StartDate.HasValue && relDC.EndDate.HasValue)
            {
                decimal total = 0;
                foreach (var scap in relDC.ApprovalPeriodList)
                {
                    var approvedPerMonth = GetApprovedHoursPerMonth(scap, relDC.CostBearer.CostRatePeriods);
                    // Anpassung auf Minuten noch nötig!!!
                    // var approvedPerMonth = GetApprovedHoursPerMonth(scap, relDC);
                    var approved = GetApprovedHoursForPeriod(scap.StartDate.Value, scap.EndDate.Value, approvedPerMonth);

                    total += approved;
                }
                return total;

                //return GetApprovedHoursForPeriod(relDC.StartDate.Value, relDC.EndDate.Value, GetApprovedHoursPerMonth(relDC));
            }
            return base.GetApprovedHoursTotal(relDC, useIsCalculationWithFactor);
        }

        private decimal GetApprovedHoursForPeriod(DateTime von, DateTime bis, decimal apprrovedPerMonth)
        {
            var monate = DateTimeUtils.GetTotalMonths(von, bis);

            var proMonat = apprrovedPerMonth;

            var gesamt = monate.GanzeMonate * proMonat;

            if (monate.AnzahlMonateGesamt - monate.GanzeMonate > 0)
            {
                gesamt += proMonat * (monate.AnzahlMonateGesamt - monate.GanzeMonate);
            }

            return gesamt;

        }

        public decimal GetApprovedHoursPerMonthGehtNicht(SupportConceptCostBearerRelDC c2s)
        {
            decimal total = 0;
            foreach (var scap in c2s.ApprovalPeriodList)
            {
                total += GetApprovedHoursPerMonth(scap, c2s.CostBearer.CostRatePeriods);
            }
            return total;
        }

        private decimal GetApprovedHoursPerMonth(SupportConceptApprovalPeriodDC scap, List<CostRatePeriodDC> costRatePeriods)
        {
            if (scap.ApprovedBEInterval.HasValue && scap.ApprovedBEPerInterval.HasValue)
            {
                if (scap.ApprovedBEInterval.Value == SupportConceptApprovalInterval.Monthly)
                {
                    return scap.ApprovedBEPerInterval.Value;
                }
                else if (scap.ApprovedBEInterval.Value == SupportConceptApprovalInterval.Quarterly)
                {
                    return scap.ApprovedBEPerInterval.Value / 3;
                }
                else if (scap.ApprovedBEInterval.Value == SupportConceptApprovalInterval.HalfYearly)
                {
                    return scap.ApprovedBEPerInterval.Value / 6;
                }
                else if (scap.ApprovedBEInterval.Value == SupportConceptApprovalInterval.Yearly)
                {
                    return scap.ApprovedBEPerInterval.Value / 12;
                }
            }

            var flsProWoche = GetApprovedHoursPerWeek(scap, costRatePeriods) ?? 0;

            return flsProWoche * 4.34m;
        }

        public override decimal? GetApprovedHoursPerWeekAverage(SupportConceptCostBearerRelDC relDC, bool useIsCalculationWithFactor)
        {
            // Fahrtzeiten nicht in Ministatistik nur für Abrechnung
            relDC.ApprovalPeriodList = relDC.ApprovalPeriodList.Where(p => p.ServiceCategory == null || String.IsNullOrEmpty(p.ServiceCategory.Abbreviation) ||
            !p.ServiceCategory.Abbreviation.Contains("FZQA")).ToList();

            var duration = relDC.GetApprovedDuration();
            if (!duration.HasValue)
            {
                return null;
            }
            if (relDC.ApprovalPeriodList != null && relDC.ApprovalPeriodList.Count == 1)
            {
                decimal? hoursPerWeek = GetApprovedHoursPerWeek(relDC.ApprovalPeriodList[0], relDC.CostBearer.CostRatePeriods);
                if (useIsCalculationWithFactor)
                    hoursPerWeek = ApplyIsCalculationWithFactor(relDC, hoursPerWeek);
                return hoursPerWeek;
            }

            if (duration.Value.Days != 0)
            {
                var averagePerDay = this.GetApprovedHoursTotal(relDC, useIsCalculationWithFactor) / duration.Value.Days;
                return averagePerDay * 7;
            }

            return null;
        }
    }  
}