BeWoPlaner/ReportImp/SHKServiceSBD/CustomMitarbeiterstundenkontoBerechnung.cs

using System;
using System.Collections.Generic;
using System.Linq;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Report.ReportObjects;
using BeWo.Service.Dienstplanung;
using BS.Shared;
using BS.Shared.DataContracts;

namespace SHKServiceSBD
{
	public class CustomMitarbeiterstundenkontoBerechnung : MitarbeiterstundenkontoBerechnung
	{
        private Dictionary<string, decimal> _SollStundenProTagDict = new Dictionary<string, decimal>(); //Speicher die Sollstunden aus den Betreuungszeiten des Kindes pro EmployeeOid und Tag (Key = {employee oid}_{datum]) 
        private Organisation _Martinsschule = null;
        private DateTime _BerichtsAnfang = DateTime.MinValue;

        public override void CreateEmployeeDetails(MitarbeiterstundenkontoRO ro)
        {
            base.CreateEmployeeDetails(ro);

            foreach (var ed in ro.EmployeeDetailList)
            {
                var c = ed.Employee.GetValidContractForDate(_BerichtsAnfang);
                if (c != null)
                {
                    ed.Custom14 = c.HourlyRate ?? 0;
                    ed.Custom15 = ed.Custom14 * Math.Round(ed.UeberstundenGesamt ?? 0, 2, MidpointRounding.AwayFromZero);
                }
            }
        }

        protected override void StarteBerechnung(DateTime berichtsAnfang, DateTime berichtsEnde, MitarbeiterstundenkontoRO.EmployeeDetail empDetail)
        {
            _BerichtsAnfang = berichtsAnfang;
            SucheMartinsschule();
            SetzeBundesland(empDetail);
            BerechneBewilligteSollZeitProWoche(empDetail, berichtsAnfang);
            BerechneAlleSollZeiten(empDetail, berichtsAnfang, berichtsEnde);

        }

        private void SucheMartinsschule()
        {
            if (_Martinsschule == null)
            {
                _Martinsschule = DAOFactory.SearchDAO.FindOrganisation("Martinsschule", false).FirstOrDefault();
            }
        }

        private void SetzeBundesland(MitarbeiterstundenkontoRO.EmployeeDetail empDetail)
        {
            string bundesland = "hessen";

            //Ermittle Bundesland und geplante Sollzeit anhand der Schule des betreuten Kindes;
            foreach (var e2c in empDetail.Employee.Employee2CustomerList)
            {
                var kind = e2c.Customer;

                foreach (var c2o in kind.Customer2OrganisationList)
                {
                    if (c2o.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && IstSchule(b.Entry.Value)))
                    {
                        foreach (var vv in c2o.Organisation.VarFieldValueList)
                        {
                            if (vv.VarFieldDefOid == 1)
                            {
                                var varFieldValue = BS.Shared.Core.Utils.XMLDeserializeFromString(vv.SerializedValue, Type.GetType(vv.TypeName));

                                if (varFieldValue != null && varFieldValue.ToString() == "Bayern")
                                {
                                    bundesland = "Bayern";
                                }
                            }
                        }
                    }
                }
            }


            this.vacationService.Bundesland = bundesland;
        }

        private bool IstTeamMartinsschule(MitarbeiterstundenkontoRO.EmployeeDetail empDetail, DateTime stichtag)
        {
            var istImTeam = empDetail.Teams != null && empDetail.Teams.Any(t => t.Name == "Martinsschule");

            if (istImTeam)
            {
                return true;
            }

            //Prüfe ob Vertragsart zum Stichtag "Martinsschule" ist
            var c = empDetail.Employee.GetValidContractForDate(stichtag);
            if (c != null && c.ContractTypeValueListEntry != null && c.ContractTypeValueListEntry.Value == "Martinsschule")
            {
                return true;
            }
            return false;
        }

        //private IList<Arbeitszeit> GetSollArbeitszeiten(MitarbeiterstundenkontoRO.EmployeeDetail empDetail, Customer customer)
        //{
        //    //Prüfe ob Mitarbeiter zu Team Martinsschule gehört, dann nehme die Betreuungszeiten (Stundenplan) der Schule, sonst den des betreuten Klienten
        //    if (IstTeamMartinsschule(empDetail) && _Martinsschule != null)
        //    {
        //        return _Martinsschule.Arbeitszeiten;
        //    }
        //    else
        //    {
        //        return customer.Arbeitszeiten;
        //    }
            
        //}

        private void BerechneAlleSollZeiten(MitarbeiterstundenkontoRO.EmployeeDetail empDetail, DateTime berichtsAnfang, DateTime berichtsEnde)
        {

            //Abesenheit "MA krank in der Schulzeit":
            //Wenn ein Kind zugeordnet ist, dann wird die Zeit von dem entsprechenden Tag aus der Betreuungszeit genommen und bei Krank eingetragen
            //Wenn ein die Ma der Martinschule zugeordnet sind, dann wird die Zeit genommen, die in der Organisation Martinschule hinterlegt ist und bei Krank eingetragen
            //Wenn kein Kind zugeordnet ist, dann Vertragliche Arbeitszeit, und bei Krank eingetragen

            //Prüfe Team Martinsschule
            DateTime ersterVertragsStart = berichtsAnfang;
            DateTime letzerVertragsEnde = berichtsEnde;

            foreach (var c in empDetail.Employee.Contracts)
            {
                if (c.EntryDate.HasValue && c.EntryDate.Value < ersterVertragsStart)
                {
                    ersterVertragsStart = c.EntryDate.Value;
                }
            }

            DateTime vertragsStart = ersterVertragsStart;
            DateTime vertragsEnde = letzerVertragsEnde;

            var contract = empDetail.Employee.GetValidContractForDate(vertragsStart);

            while (contract != null)
            {
                vertragsEnde = berichtsEnde;
                if (contract.ContractEndDate.HasValue && contract.ContractEndDate < vertragsEnde)
                {
                    vertragsEnde = contract.ContractEndDate.Value;
                }
                bool istTeamMartinsschule = IstTeamMartinsschule(empDetail, vertragsStart);
                if (istTeamMartinsschule && _Martinsschule != null)
                {
                    BerechneSollZeitenDictionary(_Martinsschule.Arbeitszeiten, empDetail, vertragsStart, vertragsEnde, false);
                }
                foreach (var e2c in empDetail.Employee.Employee2CustomerList)
                {
                    var start = vertragsStart;
                    var ende = vertragsEnde;

                    if (e2c.StartDate.HasValue && e2c.StartDate > start)
                    {
                        start = e2c.StartDate.Value;
                    }
                    if (e2c.EndDate.HasValue && e2c.EndDate < ende)
                    {
                        ende = e2c.EndDate.Value;
                    }

                    if (start <= ende)
                    {
                        var kind = e2c.Customer;

                        BerechneSollZeitenDictionary(kind.Arbeitszeiten, empDetail, start, ende, false);
                    }
                }

                //Füge Soll für Kinder, die bei den Mitarbeiterarbeitszeiten eingetragen wurden hinzu:
                BerechneSollZeitenDictionary(empDetail.Employee.Arbeitszeiten, empDetail, vertragsStart, vertragsEnde, true);


                
                var ctemp = GetNextValidContractForDate(vertragsEnde.AddDays(1), empDetail.Employee);
                if (ctemp != null && ctemp.Oid != contract.Oid)
                {
                    contract = ctemp;
                }
                else
                {
                    contract = null;
                }

                if (contract != null && contract.EntryDate.HasValue && contract.EntryDate >= vertragsStart)
                {
                    vertragsStart = contract.EntryDate.Value;
                }
            }
        }


        private void BerechneBewilligteSollZeitProWoche(MitarbeiterstundenkontoRO.EmployeeDetail empDetail, DateTime datum)
        {
            decimal sollProWoche = 0;
            if (IstTeamMartinsschule(empDetail, datum) && _Martinsschule != null)
            {
                sollProWoche = BerechneSollZeitFuerWoche(empDetail.Employee, _Martinsschule.Arbeitszeiten, datum);
            }
            foreach (var e2c in empDetail.Employee.Employee2CustomerList)
            {
                var kind = e2c.Customer;
                sollProWoche += BerechneSollZeitFuerWoche(empDetail.Employee, kind.Arbeitszeiten, datum);
            }
            empDetail.Custom1 = sollProWoche;

        }

        private decimal BerechneSollZeitFuerWoche(Employee e, IList<Arbeitszeit> arbeitszeiten, DateTime datum)
        {
            decimal soll = 0;
            if (arbeitszeiten != null)
            {   
                foreach (var az in arbeitszeiten)
                {
                    if ((!az.GueltigVon.HasValue || az.GueltigVon.Value <= datum) &&  (!az.GueltigBis.HasValue || az.GueltigBis.Value >= datum))
                    {
                        foreach (var ae in az.ArbeitszeitEintraege)
                        {
                            if (ae.Employee == null || ae.Employee.Oid == e.Oid)
                            {
                                soll += ae.BerechneStunden();
                            }
                        }
                    }
                }

            }

            return soll;

        }

        private void BerechneSollZeitenDictionary(IList<Arbeitszeit> arbeitszeiten, MitarbeiterstundenkontoRO.EmployeeDetail empDetail, DateTime start, DateTime ende, bool arbeitszeitenSindVomMitarbeiter)
        {
            
            DateTime dt = start;
            while (dt <= ende)
            {
                String key = String.Format("{0}_{1:yyyyMMdd}", empDetail.Employee.Oid, dt);
                if (!_SollStundenProTagDict.ContainsKey(key))
                {
                    decimal soll = 0;
                    bool gibtAz = false;
                    foreach (var az in arbeitszeiten)
                    {
                        
                        if ((!az.GueltigVon.HasValue || az.GueltigVon.Value <= dt) && (!az.GueltigBis.HasValue || az.GueltigBis.Value >= dt))
                        {
                            if (!arbeitszeitenSindVomMitarbeiter)
                            {
                                gibtAz = true;
                            }
                            foreach (var ae in az.ArbeitszeitEintraege)
                            {
                                if (arbeitszeitenSindVomMitarbeiter)
                                {
                                    //Wenn das Flag arbeitszeitenSindVomMitarbeiter gesetzt ist, werden nur Einträge geprüft, bei dem auch ein Klient zugeordnet ist
                                    if (ae.Customer != null)
                                    {
                                        if (ae.IstAmGleichenWochentag(dt))
                                        {
                                            gibtAz = true;
                                            soll += ae.BerechneStunden();
                                        }
                                    }
                                }
                                else
                                {
                                    if (ae.Employee == null || ae.Employee.Oid == empDetail.Employee.Oid)
                                    {
                                        if (ae.IstAmGleichenWochentag(dt))
                                        {
                                            soll += ae.BerechneStunden();
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if (gibtAz)
                    {
                        _SollStundenProTagDict[key] = soll;
                    }
                }

                dt = dt.AddDays(1);
            }
        }

        protected override decimal? GetSollNachArbeitszeiten(Employee emp, DateTime start, DateTime ende)
        {
            var soll = base.GetSollNachArbeitszeiten(emp, start, ende);
            return soll;
            if (soll == null)
            {
                DateTime startTemp = start;

                while (startTemp < ende)
                {
                    String key = String.Format("{0}_{1:yyyyMMdd}", emp.Oid, startTemp);
                    if (_SollStundenProTagDict.ContainsKey(key))
                    {
                        if (soll == null)
                        {
                            soll = 0;
                        }
                        soll += _SollStundenProTagDict[key];
                    }
                    startTemp = startTemp.AddDays(1);
                }
            }

            return soll;
        }

        protected override decimal GetSollNachArbeitszeitenFuerTag(Employee emp, DateTime tag)
        {
            if (tag.Day == 24 && tag.Month == 12 && tag.Year == 2025)
            {

            }

            decimal soll = 0;
            var fak = GetFeiertagsFaktor(tag);

            if (BerechneFeiertageAlsArbeitszeit())
            {
                if (fak == 1)
                {
                    fak = 0;
                }
            }

            if (fak < 1)
            {
                if (emp.Arbeitszeiten != null)
                {
                    foreach (var az in emp.Arbeitszeiten)
                    {
                        if ((!az.GueltigVon.HasValue || az.GueltigVon.Value <= tag) &&
                            (!az.GueltigBis.HasValue || az.GueltigBis.Value >= tag))
                        {
                            var std = GetArbeitszeitStundenFuerTag(az, tag);
                            soll += (std * (1 - fak));
                        }
                    }
                }
            }

            return soll;
        }

        public virtual bool IstSchule(String name)
        {
            if (!String.IsNullOrEmpty(name))
            {
                return name.ToLower().Contains("schule") || name.ToLower().Contains("kindergarten");
            }
            return false;
        }

        public override bool AddServiceRecordToDuration(StundenkontoServiceRecord item)
        {
            if (item.ServiceDescription != null && item.ServiceDescription.Category != null)
            {
                if (!item.ServiceDescription.Name.Contains("Pause") && item.ServiceDescription.Name != "Zeitabzug")
                {
                    if (item.ServiceDescription.Category.Name == "Arbeitszeit" || item.ServiceDescription.Category.Name == "Buchhaltung")
                    {
                        return true;
                    }
                }
            }
            if (item.ServiceDescription.Name.Contains("Pause"))
            {
                int test = 0;
            }
            return false;
        }

        public override decimal BerechneSollProWoche(Contract c, MitarbeiterstundenkontoRO.EmployeeDetail ed)
        {
            //if (c != null && c.MonthlyTotalHours.HasValue && c.MonthlyTotalHours.Value > 0)
            //{
            //    if (ed != null && ed.Employee != null && ed.Employee.IsActive == ActivationTypeId.Active)
            //    {
            //        var name = ed.LastName;
            //    }
            //    var sollProWoche = Math.Round(c.MonthlyTotalHours.Value / 4.348m, 2, MidpointRounding.AwayFromZero);
            //    if (ed.SollProTag == 0)
            //    {
            //        ed.SollProTag = sollProWoche / 5;
            //    }
            //    return sollProWoche;
            //}

            return base.BerechneSollProWoche(c, ed);
        }

        public override void BerechneSollStundenFuerDayDetail(MitarbeiterstundenkontoRO.EmployeeDetail ed, MitarbeiterstundenkontoRO.DayDetail dd)
        {
            base.BerechneSollStundenFuerDayDetail(ed, dd);

        }

        protected override ServiceRecordSummary BerechneStunden(MitarbeiterstundenkontoRO.EmployeeDetail empDetail, IList<StundenkontoServiceRecord> groupFilteredRecords, DateTime berichtsAnfang,
            DateTime berichtsEnde)
        {
            decimal flsGesamt = 0;
            decimal arbeitszeit = 0;

            var sum = new ServiceRecordSummary();
            sum.RecordsImBerichtszeitraum = new List<StundenkontoServiceRecord>();
            //base.CorrectOverlappingTimes(groupFilteredRecords);

            foreach (var item in groupFilteredRecords)
            {
                if (!IsServiceRecordFehlzeit(item))
                {
                    if (item.Start >= berichtsAnfang && item.Start < berichtsEnde)
                    {
                        //if (AddServiceRecordToDuration(item))
                        //{
                        var duration = GetDuration(item, empDetail);


                        if (item.ServiceDescription != null &&
                            item.ServiceDescription.Category != null)
                        {
                            if (item.ServiceDescription.Category.Name == "Arbeitszeit" || item.ServiceDescription.Category.Name == "Buchhaltung")
                            {
                                if (!item.ServiceDescription.Name.Contains("Pause"))
                                {
                                    arbeitszeit += duration;
                                }
                                else
                                {
                                    //arbeitszeit -= duration;
                                }
                            }
                            else if (item.ServiceDescription.Category.IsBillable)
                            {
                                flsGesamt += duration;
                            }

                        }
                        sum.RecordsImBerichtszeitraum.Add(item);
                    }
                }
            }

            sum.IstAbrechenbar = flsGesamt;
            sum.IstNichtAbrechenbar = arbeitszeit - flsGesamt;

            return sum;
        }


        public override IList<MitarbeiterstundenkontoRO.DayDetail> CreateDayDetails(DateTime berichtStart, DateTime berichtEnde, MitarbeiterstundenkontoRO.EmployeeDetail ed, IList<StundenkontoServiceRecord> recordsAll)
        {
            var list = base.CreateDayDetails(berichtStart, berichtEnde, ed, recordsAll);
            foreach (var dd in list)
            {
                dd.PauseInMinuten = 0;
                
                foreach (var sr in recordsAll)
                {
                    if (sr.Start >= berichtStart && sr.Start < berichtEnde && sr.Start.Day == dd.Date.Day)
                    {
                        decimal duration = GetDuration(sr, ed);

                        if (sr.ServiceDescription.Name.Contains("Pause"))
                        {
                            dd.PauseInMinuten += duration;
                            dd.MinutesTotal -= duration;
                        }

                    }
                }

                var absenceTimes = ed.Employee.AbsenceTimes;

                if (dd.AbsenceTimes == null && absenceTimes != null)
                {
                    foreach (var absenceTime in absenceTimes)
                    {
                        if (absenceTime.Start < dd.Date.AddDays(1) && (!absenceTime.End.HasValue || absenceTime.End >= dd.Date))
                        {
                            if (dd.AbsenceTimes == null)
                            {
                                dd.AbsenceTimes = new List<AbsenceTime>();
                            }
                            dd.AbsenceTimes.Add(absenceTime);
                        }
                    }
                }

                bool feiertagAnrechnen = true;
                if (dd.AbsenceTimes != null)
                {
                    if (dd.Date.Year == 2024 && dd.Date.Month == 12 && dd.Date.Day == 24)
                    {
                        int test = 0;
                    }
                    foreach (var at in dd.AbsenceTimes)
                    {
                        if (IstAnrechenbareAbsenceTime(at))
                        {
                            var sollProTag = BerechneSollAmTag(ed, dd.Date);

                            if (at.AbsenceReason.Description.ToLower().Contains("krank in der schulzeit") ||
                                at.AbsenceReason.Description.ToLower().Contains("mutterschutz"))
                            {
                                if (at.AbsenceReason.Description.ToLower().Contains("mutterschutz") && IstTeamMartinsschule(ed, dd.Date))
                                {
                                    //sollProTag unverändert laut Frau Hildmann am 22.04.2025
                                }
                                else
                                {
                                    var key = String.Format("{0}_{1:yyyyMMdd}", ed.Employee.Oid, dd.Date);
                                    if (_SollStundenProTagDict.ContainsKey(key))
                                    {
                                        sollProTag = _SollStundenProTagDict[key];
                                    }
                                }
                            }
                            var faktor = GetFeiertagsFaktor(dd.Date);
                            if (faktor > 0)
                            {
                                if (at.AbsenceReason.Description.ToLower().Contains("krankengeld") || at.AbsenceReason.Description.ToLower().Contains("elternzeit") || at.AbsenceReason.Description.ToLower().Contains("krank ohne lohnfortzahlung"))
                                {
                                    feiertagAnrechnen = false;
                                    dd.HoursSick = sollProTag;
                                }
                            }

                            if (faktor < 1 && dd.Date.DayOfWeek != DayOfWeek.Saturday && dd.Date.DayOfWeek != DayOfWeek.Sunday)
                            {
                                if (IsKrankheitAbsenceTime(at))
                                {
                                    dd.HoursSick = sollProTag;
                                }
                                else if (IsUrlaubAbsenceTime(at))
                                {
                                    dd.HoursInVacation = sollProTag;

                                    if (faktor > 0)
                                    {
                                        dd.HoursInVacation *= faktor;
                                    }
                                }
                                else
                                {
                                    dd.MinutesTotal = sollProTag * 60;
                                }
                            }
                        }
                        else
                        {
                            if (at.AbsenceReason.Description.ToLower().Contains("eigenes kind krank") || 
                                at.AbsenceReason.Description.ToLower().Contains("ohne lohnfortzahlung") ||
                                at.AbsenceReason.Description.ToLower().Contains("elternzeit") ||
                                at.AbsenceReason.Description.ToLower().Contains("mutterschutz") ||
                                at.AbsenceReason.Description.ToLower().Contains("krankengeld") ||
                                at.AbsenceReason.Description.ToLower().Contains("unbezahlter urlaub"))
                            {
                                dd.Custom1 = "x"; // String.Format("{0:0.00}", ed.SollProTag * 60);
                            }
                            if (at.AbsenceReason.Description.ToLower().Contains("krankengeld") || at.AbsenceReason.Description.ToLower().Contains("elternzeit") || at.AbsenceReason.Description.ToLower().Contains("krank ohne lohnfortzahlung"))
                            {
                                feiertagAnrechnen = false;
                            }
                        }
                    }
                }
                if (dd.Feiertag == null)
                {
                    //var ft = GetFerienTag(dd.Date);
                    //if (ft != null)
                    //{
                    //    dd.Feiertag = new FeiertagDC();
                    //    dd.Feiertag.Datum = dd.Date;
                    //    dd.Feiertag.Name = ft.Name;
                    //}
                }

                if (dd.IstFeiertag && dd.Date.DayOfWeek != DayOfWeek.Saturday && dd.Date.DayOfWeek != DayOfWeek.Sunday)
                {
                    if (feiertagAnrechnen && HatVertrag(ed, dd.Date))
                    {
                        var soll = BerechneSollAmTag(ed, dd.Date) * 60;
                        soll *= GetFeiertagsFaktor(dd.Date);
                        if (dd.MinutesTotal <= soll)
                        {
                            dd.MinutesTotal = soll;
                        }
                        else
                        {
                            int test = 0;
                        }
                    }
                    else
                    {
                        dd.MinutesTotal = 0;
                    }
                    
                }

            }
            return list;
        }

        public override decimal BerechneSollStundenFuerTag(MitarbeiterstundenkontoRO.EmployeeDetail ed, DateTime date)
        {
            if (date == new DateTime(2024, 12, 24))
            {
                int test = 0;
            }
            var soll = base.BerechneSollStundenFuerTag(ed, date);

            if (soll > 0 && IstFeiertag(date))
            {
                var at = GetAbsenceTimeForDate(ed, date);
                if (at != null)
                {
                    if (at.AbsenceReason.Description.ToLower().Contains("krankengeld") || at.AbsenceReason.Description.ToLower().Contains("elternzeit") || at.AbsenceReason.Description.ToLower().Contains("krank ohne lohnfortzahlung"))
                    {
                        return 0;
                    }
                }
                
            }

            return soll;
        }

        private bool HatVertrag(MitarbeiterstundenkontoRO.EmployeeDetail ed, DateTime date)
        {
            return ed.Employee.GetValidContractForDate(date) != null;
        }

        protected override bool HatArbeitszeitImZeitraum(IList<Arbeitszeit> arbeitszeiten, DateTime start, DateTime ende)
        {
            return false;
        }

        //protected override decimal? GetSollNachArbeitszeiten(Employee emp, DateTime start, DateTime ende)
        //{
        //    return null;
        //}

        //public override AbsenceTimeDays GetAbsenceTimeDaysWithWorkWeeks(Employee emp, DateTime start, DateTime end, int arbeitstageProWoche)
        //{
        //    return base.GetAbsenceTimeDaysWithWorkWeeks(emp.AbsenceTimes, start, end, arbeitstageProWoche);

        //}

        public override bool IstAnrechenbareAbsenceTime(AbsenceTime item)
        {
            if (item.AbsenceReason.Description.ToLower().Contains("freizeitausgleich") || 
                item.AbsenceReason.Description.ToLower().Contains("krank in der freistellung") || 
                item.AbsenceReason.Description.ToLower().Contains("krank beweglicher ") ||
                item.AbsenceReason.Description.ToLower().Contains("unbezahlter urlaub") ||
                item.AbsenceReason.Description.ToLower().Contains("interner termin") ||
                item.AbsenceReason.Description.ToLower().Contains("krankengeld") ||
                //item.AbsenceReason.Description.ToLower().Contains("mutterschutz") ||
                item.AbsenceReason.Description.ToLower().Contains("elternzeit"))
            {
                return false;
            }
            return base.IstAnrechenbareAbsenceTime(item);
        }

        public override bool IsKrankheitAbsenceTime(AbsenceTime item)
        {
            if (item.AbsenceReason.Description.ToLower().Contains("beschäftigungsverbot"))
            {
                return true;
            }
            if (item.AbsenceReason.Description.ToLower().IndexOf("unbezahlter urlaub") >= 0)
            {
                return false;
            }
            if (item.AbsenceReason.Description.ToLower().IndexOf("krankengeld") >= 0)
            {
                return false;
            }
            return base.IsKrankheitAbsenceTime(item);
        }

        public override bool IsUrlaubAbsenceTime(AbsenceTime item)
        {
            if ((item.AbsenceReason.Description.ToLower().IndexOf("krank") >= 0))
            {
                return false;
            }
            return base.IsUrlaubAbsenceTime(item);
        }

        public override bool SollPauseBerechnen()
        {
            return true;
        }

        public override bool ShouldCreateDayDetails()
        {
            return true;
        }

        public override bool BerechneFeiertageAlsArbeitszeit()
        {
            return true;
        }

        public override bool AbsenceTimeAufIstStundenAddieren(AbsenceTime at)
        {
            return false;
        }

        public override decimal GetArbeitstageImBereich(DateTime von, DateTime bis, Employee emp)
        {
            DateTime start = von;
            DateTime end = bis;

            TimeSpan ts = end.Subtract(start);

            var maxDays = (decimal)ts.TotalDays;

            while (start < end)
            {
                int arbeitstageProWoche = 5;

                var c = GetContractForDate(emp, start, start);

                if (c != null && c.WeeklyDays.HasValue && c.WeeklyDays > 0)
                {
                    arbeitstageProWoche = c.WeeklyDays.Value;
                }


                if (arbeitstageProWoche <= 5 && (start.DayOfWeek == DayOfWeek.Saturday || start.DayOfWeek == DayOfWeek.Sunday))
                {
                    maxDays -= 1;
                }
                else if (arbeitstageProWoche == 6 && start.DayOfWeek == DayOfWeek.Sunday)
                {
                    maxDays -= 1;
                }
                else
                {
                    var istArbeitstag = true;

                    if (arbeitstageProWoche < 5)
                    {
                        //Wenn Tage < 5 hole die zu arbeitenden Wochentage aus dem Stundenplan des betreuten Kindes

                        decimal stundenAnDiesemTag = 0;
                        foreach (var e2c in emp.Employee2CustomerList)
                        {
                            if ((!e2c.StartDate.HasValue || e2c.StartDate.Value.Date <= start.Date) && (!e2c.EndDate.HasValue || e2c.EndDate.Value.Date >= start.Date))
                            {
                                var kind = e2c.Customer;

                                foreach (var az in kind.Arbeitszeiten)
                                {
                                    if ((!az.GueltigVon.HasValue || az.GueltigVon.Value.Date <= start.Date) && (!az.GueltigBis.HasValue || az.GueltigBis.Value.Date >= start.Date))
                                    {
                                        istArbeitstag = false;
                                        foreach (var ae in az.ArbeitszeitEintraege)
                                        {
                                            if (ae.Customer == null || ae.Customer.Oid == kind.Oid)
                                            {
                                                if (ae.IstAmGleichenWochentag(start))
                                                {
                                                    stundenAnDiesemTag += ae.BerechneStunden();
                                                }
                                            }
                                        }

                                        if (stundenAnDiesemTag > 0)
                                        {
                                            istArbeitstag = true;
                                        }
                                    }

                                }
                            }
                            
                        }
                        if (!istArbeitstag)
                        {
                            maxDays--; // Kein Arbeitstag, also Anzahl um eins verringern
                        }
                    }

                    if (istArbeitstag)
                    {
                        foreach (var at in emp.AbsenceTimes)
                        {
                            if (at.AbsenceReason.Description.ToLower().Contains("unbezahlter urlaub") || at.AbsenceReason.Description.ToLower().Contains("krankengeld") || at.AbsenceReason.Description.ToLower().Contains("elternzeit"))
                            {
                                if (at.Start.Value <= start && (!at.End.HasValue || at.End.Value >= start))
                                {
                                    if (maxDays >= 1)
                                    {
                                        maxDays--;
                                    }
                                }
                            }
                        }
                    }
                }
                start = start.AddDays(1);
            }
            return maxDays;

            
        }

        public override decimal? GetSollStundenForAbsenceTime(MitarbeiterstundenkontoRO.EmployeeDetail ed, AbsenceTime at, DateTime datum)
        {
            if (at.AbsenceReason.Description.Contains("krank in der Schulzeit") || at.AbsenceReason.Description.Contains("Mutterschutz"))
            {
                var key = String.Format("{0}_{1:yyyyMMdd}", ed.Employee.Oid, datum);
                if (_SollStundenProTagDict.ContainsKey(key))
                {
                   return _SollStundenProTagDict[key];
                }
            }

            return base.GetSollStundenForAbsenceTime(ed, at, datum);

        }

        public override decimal BerechneStundenDurchAbwesenheiten(AbsenceTimeDays ath, DateTime start, DateTime ende, Contract c, MitarbeiterstundenkontoRO.EmployeeDetail ed)
        {
            if (ath.StundenGesamt.HasValue)
            {
                return ath.StundenGesamt.Value;
            }
            return base.BerechneStundenDurchAbwesenheiten(ath, start, ende, c, ed);
        }

        public override MitarbeiterstundenkontoRO.DayDetail CreateDayDetail(DateTime date, MitarbeiterstundenkontoRO.EmployeeDetail ed)
        {
            var dd = base.CreateDayDetail(date, ed);
            dd.MaxHoursUntilBreak = null;
            dd.MaxHoursUntilBreak2 = null;
            dd.BreakMinutes = null;
            dd.BreakMinutes2 = null;
            return dd;
        }

        protected override decimal GetDuration(StundenkontoServiceRecord sr, MitarbeiterstundenkontoRO.EmployeeDetail ed)
        {
            var d = base.GetDuration(sr, ed);

            if (sr.ServiceDescription.Category.Name == "Buchhaltung" && sr.ServiceDescription.Name.Contains("negativ"))
            {
                d *= -1;
            }

            if (sr.ServiceDescription.Name.Contains("Pause"))
            {
                int test = 0;
            }

            return d;
        }

        public override decimal GetFeiertagsFaktor(DateTime start)
        {
            //if (GetFerienTag(start) != null)
            //{
            //    return 1;
            //}
            if (start.Month == 12)
            {
                if (start.Day == 24 || start.Day == 31)
                {
                    return 0.5m;
                }
            }
            
            return base.GetFeiertagsFaktor(start);
        }

        public override decimal BerechnePauseMinuten(IList<StundenkontoServiceRecord> srListAlle)
        {
            var srList = srListAlle.Where(s => s.ServiceDescription.Category.Name == "Arbeitszeit");
            decimal pausenZeit = 0;

            List<StundenkontoServiceRecord> pausen = new List<StundenkontoServiceRecord>();
            List<StundenkontoServiceRecord> nichtpausen = new List<StundenkontoServiceRecord>();

            foreach (var sr in srList)
            {
                if (sr.ServiceDescription.Name.Contains("Pause"))
                {
                    pausen.Add(sr);
                }
                else
                {
                    nichtpausen.Add(sr);
                }
            }

            foreach (var pause in pausen)
            {
                pausenZeit += pause.RoundedDuration;
            }
            return pausenZeit;
        }

        protected override bool StundenDurchAbwesenheitenDuerfenNegativSein()
        {
            return true;
        }

        public FerienDC GetFerienTag(DateTime start)
        {
            return vacationService.GetFerien(start, vacationService.Bundesland);
        }

    }
}