BeWoPlaner/ReportImp/FeidPartnerReports/CustomSupportConceptAnalysisCreator.cs

using System;
using System.Collections.Generic;
using System.Linq;

using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Service.DCEntityMapper;

using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using BS.Shared.Extensions;
using BS.Shared.Services;
using BeWo.Service.Configuration;
using BeWo.Service.Plugins;
using BeWo.Service.ServiceImplementations;

namespace FeidPartnerReports
{
	public class CustomSupportConceptAnalysisCreator : SupportConceptAnalysisCreator
    {
        public override List<SupportConceptOverviewDC> GetSupportConceptAnalysis2(IList<long> c2sOids, long? employeeOid, long? teamOid, long? catOid, DateTime? startDate, DateTime? endDate,
            int? expiredMonths, bool showArchivedScs)
        {
            var result = base.GetSupportConceptAnalysis2(c2sOids, employeeOid, teamOid, catOid, startDate, endDate, expiredMonths, showArchivedScs);
            // Die Berechnungen sind jetzt soweit in Ordnung, werden nur im letzen Schritt, dass was hier auch ist, wieder verfälscht,
            // da der Kostenträger auf Min und nicht wie von denen gewünscht Std ist - das drehe ich hier inkl. Beschriftung in Stunden zurück
            foreach (var iDC in result)
            {
                if (iDC.ServiceUnit.CostRateValue == 1)
                {
                    iDC.ServiceUnit.UnitName = "Stunden";
                    iDC.HeaderString.Replace("Minuten/Woche", "Stunden/Woche");
                    iDC.BEApprovedPerWeek = iDC.BEApprovedPerWeek / 60m;
                    iDC.BEApprovedSum = iDC.FLSApprovedSum;
                    iDC.BEApprovedTillNow = iDC.FLSApprovedTillNow;
                    iDC.BEBilledTillNow = iDC.FLSBilledTillNow;
                    iDC.BEDifferenceApprovedRecordedTillNow = iDC.FLSDifferenceApprovedRecordedTillNow;
                    iDC.BEDifferenceApprovedRecordedTillNowInPercent = iDC.FLSDifferenceApprovedRecordedTillNowInPercent;
                    iDC.BEOpen = iDC.FLSOpen;
                    iDC.BEOpenPerWeek = iDC.FLSOpenPerWeek;
                    if (iDC.BEOpenPerWeek > iDC.BEOpen)
                        iDC.BEOpenPerWeek = iDC.BEOpen;
                    iDC.BERecordedTillNow = iDC.FLSRecordedTillNow;
                    iDC.BERecordedTillNowInPercent = iDC.FLSRecordedTillNowInPercent;
                }
            }
            return result;
        }

        public override List<ServiceRecordDC> GetServiceRecordDCs(CostBearer2SupportConcept c2s, DateTime minDate, DateTime maxDate)
        {
            var dcList = new List<ServiceRecordDC>();
            if (_cs2ServiceRecords != null && _cs2ServiceRecords.Count > 0)
            {
                if (_cs2ServiceRecords.ContainsKey(c2s.Oid.Value))
                {
                    dcList = _cs2ServiceRecords[c2s.Oid.Value];
                    dcList = dcList.Where(s => s.Start >= minDate && s.Start < maxDate).ToList();
                    if (dcList != null && dcList.Count() > 0)
                    {
                        dcList = dcList.Where(s => !s.GroupOid.HasValue).ToList();
                    }
                }
            }

            // PseudoZeiteinträge gemäß Bewilligung hinzufügen
            var service = new OperationsServiceImp();
            long cb2scOid = c2s.Oid.Value;
            if (maxDate == DateTime.MaxValue)
            {
                maxDate = DateTime.Today;
            }

            var stats = service.CreateSupportConceptStatistics(cb2scOid, maxDate);
            if (stats.PeriodStatistics != null && stats.PeriodStatistics.Count > 0)
            {
                foreach (var item in stats.PeriodStatistics)
                {
                    DateTime start = minDate;
                    DateTime end = maxDate;
                    DateTime bewStart = item.SupportConceptApprovalPeriod.StartDate ?? DateTime.MinValue;
                    DateTime bewEnd = item.SupportConceptApprovalPeriod.EndDate ?? DateTime.MaxValue;
                    if (bewEnd < end)
                    {
                        end = bewEnd;
                    }
                    if (bewStart > start)
                    {
                        start = bewStart;
                    }

                    while (start < end.Date)
                    {
                        if (start > new DateTime(2024, 02, 29) && !EnthaeltEintraege(start, start.AddDays(7), dcList))
                        {
                            var sr = new ServiceRecord();
                            sr.Start = start;
                            sr.End = end;
                            sr.ServiceDescription =  DAOFactory.GenericDAO.LoadByID<ServiceDescription>(89);
                            sr.RoundedDuration = item.MinutesApprovedPerWeek;

                            if (bewStart.DayOfWeek != DayOfWeek.Monday && start >= bewStart && start <= bewStart.GetNext(DayOfWeek.Sunday).Date)
                            {
                                DateTime sundayDt = bewStart.GetNext(DayOfWeek.Sunday).Date;
                                var days = sundayDt.Day - start.Day + 1;
                                var firstAppr = item.MinutesApprovedPerWeek / 7 * days;
                                sr.RoundedDuration = firstAppr;
                            }
                            else if (bewEnd.DayOfWeek != DayOfWeek.Sunday && start < bewEnd && start >= bewEnd.GetLast(DayOfWeek.Monday).Date)
                            {
                                DateTime mondayDt = bewEnd.GetLast(DayOfWeek.Monday).Date;
                                var days = start.Day - mondayDt.Day + 1;
                                var lastAppr = item.MinutesApprovedPerWeek / 7 * days;
                                sr.RoundedDuration = lastAppr;
                            }

                            dcList.Add(CreateServiceRecordDC(sr));
                        }
                        start = start.AddDays(7);
                    }
                }
            }
            return dcList;
        }

        private bool EnthaeltEintraege(DateTime start, DateTime end, List<ServiceRecordDC> serviceRecords)
        {
            bool vorhandeneEintraege = false;
            if (serviceRecords != null && serviceRecords.Count > 0)
            {
                vorhandeneEintraege = serviceRecords.Any(s => s.Start.Value.Date >= start.Date && s.Start.Value.Date < end.Date && s.RoundedDuration > 0 && s.ServiceDescription.Category.IsBillable);
            }
            return vorhandeneEintraege;
        }
    }
}