BeWoPlaner/Service/SBD/VertretungsManager.cs

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

using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Service.DCEntityMapper;
using BeWo.Service.ServiceUtils.DistanceCalculator;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using BS.Shared.Extensions;
using DevExpress.XtraRichEdit.Commands;
using Employee = BeWo.Data.Entities.Employee;

namespace BeWo.Service.SBD
{
    public class VertretungsManager
    {
        private static List<ContactDC> LoadContactInformationForEntity<T>(Person p) where T : BeWoEntityBase
        {
            return MapperFactory.ContactDC_Contact.MapToNewDCs(p.Contacts);
        }

        public virtual List<CompactVertreterEmployeeDC> SucheVertreter(VertreterSucheFilterDC filter)
        {
            var vertretungsListe = CreateVertretungsListe(filter.StartDate, filter.EndDate);

            // EmployeeOids der Mitarbeiter, die einen abwesenden Mitarbeiter vertreten
            var ausgewaehlteVertreter = vertretungsListe.Where(vertretungsItem => vertretungsItem.VertretungsStatus != VertretungsStatus.KlientKrank &&
                                                                                    vertretungsItem.Vertreter != null &&
                                                                                    vertretungsItem.Vertreter.ActivationType == ActivationTypeId.Active).Select(item => item.Vertreter.EmployeeOid);

            // EmployeeOids der Betreuer abwesender Klienten, die nicht schon einen anderen Klienten vertreten
            var employeeOids = vertretungsListe.Where(vertretungsItem => vertretungsItem.Employee != null &&
                                                                            vertretungsItem.VertretungsStatus == VertretungsStatus.KlientKrank &&
                                                                            !ausgewaehlteVertreter.Contains(vertretungsItem.Employee.EmployeeOid)).Select(s => s.Employee.EmployeeOid);

            // EmployeeOids von abwesenden Mitarbeitern
            var abwesenendeEmployeeOids = vertretungsListe.Where(vertretungsItem => vertretungsItem.VertretungsStatus != VertretungsStatus.KlientKrank &&
                                                                                    vertretungsItem.Employee != null).Select(item => item.Employee.EmployeeOid);

            employeeOids = employeeOids.Where(e => !abwesenendeEmployeeOids.Contains(e));

            var allEmps = DAOFactory.GenericDAO.GetActiveByIDs<Employee>(employeeOids).ToList();
            var list = MapperFactory.CompactVertreterEmployeeDC_VertreterEmployee.MapToNewDCs(allEmps);

            //Setze Betreuungszeiten
            foreach (var vertreter in list)
            {
                foreach (var item in vertretungsListe)
                {
                    if (item.Employee != null && item.Employee.EmployeeOid == vertreter.EmployeeOid)
                    {
                        //if (vertreter.Arbeitszeit == null)
                        //{
                        //    vertreter.Arbeitszeit = new List<ArbeitszeitDC>();
                        //}

                        //if (vertreter.Arbeitszeit.Count == 0)
                        //{
                        //    vertreter.Arbeitszeit.Add(new ArbeitszeitDC
                        //    {
                        //        Eintraege = new List<ArbeitszeitEintragDC>()
                        //    });
                        //}
                        //vertreter.Arbeitszeit[0].Eintraege.AddRange(item.Arbeitszeiten);
                        vertreter.Arbeitszeit = new List<ArbeitszeitDC>();
                        vertreter.Arbeitszeit.Add(
                            new ArbeitszeitDC
                            {
                                Eintraege = item.Arbeitszeiten.ToList()
                            });
                    }
                }
            }

            if (filter.CustomerOid.HasValue && filter.VerwendeEntfernungssuche)
            {
                GetDistanceForVertreterEmployees(filter.CustomerOid.Value, ref list, allEmps);
            }

            return list;
            
        }

        public virtual List<VertretungsItemDC> CreateSubstitutions(DateTime start, DateTime end)
        {
            var vertretungsItems = new List<VertretungsItemDC>();

            end = end.Date.AddDays(1).AddTicks(-1);
            var vertretungen = DAOFactory.SearchDAO.FindVertretungen(start, end).Where(v => v.VertretenderMitarbeiterOid.HasValue).ToList();
            var absenceTimes = DAOFactory.SearchDAO.FindAbsenceTimes(start, end).ToList();

            var employeeAbsenceTimes = absenceTimes.Where(absenceTime => absenceTime.EmployeeOid.HasValue).ToList();
            var customerAbsenceTimes = absenceTimes.Where(absenceTime => absenceTime.CustomerOid.HasValue).ToList();

            var customerOids = vertretungen.Where(w => w.CustomerOid.HasValue && w.CustomerOid > 0).Select(s => s.CustomerOid.Value).ToList();
            customerOids.AddRangeIfElementsNotIn(absenceTimes.Where(w => w.CustomerOid.HasValue).Select(s => s.CustomerOid.Value).ToList());

            var customers = DAOFactory.GenericDAO.LoadByIDs<Customer>(customerOids);
            var customerContactInformation = new Dictionary<long, List<ContactDC>>();

            var employees = DAOFactory.GenericDAO.LoadByIDs<Employee>(employeeAbsenceTimes.Select(absenceTime => absenceTime.EmployeeOid.Value));

            var employeeVertretungsItems = new List<VertretungsItemDC>();
            var customerVertretungsItems = new List<VertretungsItemDC>();
            var employeeVertretungsItemsGuids2Ignore = new List<Guid>();

            foreach (var customer in customers)
            {
                var contacts = MapperFactory.ContactDC_Contact.MapToNewDCs(customer.Person.Contacts);

                if (customer.Oid != null)
                {
                    customerContactInformation.AddOrUpdateValueInDictionary(customer.Oid.Value, contacts);
                }
            }

            // Mitarbeiterabwesenheiten
            foreach (var absenceTime in employeeAbsenceTimes)
            {
                var employee = employees.FirstOrDefault(emp => emp.Oid.HasValue && emp.Oid.Value.Equals(absenceTime.EmployeeOid));
                if (employee == null)
                {
                    continue;
                }
                
                List<VertretungsItemDC> items = CreateVertretungsItemsForAbsenceEmployee(employee, vertretungen, absenceTime, start, end);
                employeeVertretungsItems.AddRange(items);
                
            }

            if (start.Date == end.Date) // Nur in Tagesansicht erst mal
            {
                // Vertretungen deren Klient wiederrum vertreten werden muss
                foreach (var vertretung in vertretungen)
                {
                    if (vertretung.VertretenderMitarbeiterOid.HasValue)
                    {
                        if (employeeAbsenceTimes.Count(ea => ea.EmployeeOid.HasValue && ea.EmployeeOid.Value == vertretung.VertretenderMitarbeiterOid.Value) == 0)
                        {
                            var employee = DAOFactory.GenericDAO.LoadByID<Employee>(vertretung.VertretenderMitarbeiterOid.Value);


                            List<VertretungsItemDC> items = CreateVertretungsItemsForAbsenceEmployee(employee, vertretungen, null, start, end);
                            employeeVertretungsItems.AddRange(items);
                        }
                    }


                }
            }

            // Klientenabwesenheiten
            foreach (var absenceTime in customerAbsenceTimes)
            {
                var customer = customers.FirstOrDefault(first => first.Oid.HasValue && first.Oid.Equals(absenceTime.CustomerOid)) ?? DAOFactory.GenericDAO.LoadByID<Customer>(absenceTime.CustomerOid.Value);

                if (customer.Person.LastName.Contains("Platz"))
                {

                }
                var absenceTimeDC = MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDC(absenceTime);
                var customerDC = MapperFactory.CompactCustomerDC_Customer.MapToNewDC(customer);
                var customerContactInformationList = LoadContactInformationForEntity<Customer>(customer.Person);
                var schools = MapperFactory.CustomerOrganisationRelationDC_Customer2Organisation.MapToNewDCs(customer.Customer2OrganisationList.Where(customer2Organisation => customer2Organisation.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && IstSchule(b.Entry.Value))));
                var schoolAssistanceTimes = GetSchoolAssistanceTimes(customer, start, end, absenceTime);
                var hauptbetreuer = customer.Employee2CustomerList.FirstOrDefault(e2c => e2c.IsActive == ActivationTypeId.Active &&
                                            (!e2c.StartDate.HasValue || e2c.StartDate.Value.Date <= end.Date) && (!e2c.EndDate.HasValue || e2c.EndDate.Value.Date >= start.Date) &&
                                            e2c.ValueList.Any(b => b.Entry.Type.Equals(ValueListEntryType.StaffRoleType) && b.Entry.Value.ToLower().Equals("hauptbetreuung")))?.Employee;
                if (hauptbetreuer == null)
                {
                    //hauptbetreuer = customer.Employee2CustomerList.FirstOrDefault()?.Employee;
                }
                MigriereSubstitutionStatus(customer);

                var assistingEmployees = new List<Employee>();
                customer.Arbeitszeiten.DoForEach(a => assistingEmployees.AddRangeIfElementsNotIn(a.ArbeitszeitEintraege.Where(ae => ae.Employee != null).Select(s => s.Employee)));

                schoolAssistanceTimes.DoForEach(a =>
                {
                    foreach (var assistanceTimeEntry in a.ArbeitszeitEintraege)
                    {
                        if (assistanceTimeEntry.Employee != null && assistanceTimeEntry.Employee.IsActive != ActivationTypeId.Active)
                        {
                            continue;
                        }

                        if (assistanceTimeEntry.Employee == null)
                        {
                            if (hauptbetreuer != null)
                            {
                                assistingEmployees.AddIfNotIn(hauptbetreuer);
                            }
                        }
                        else
                        {
                            assistingEmployees.AddIfNotIn(assistanceTimeEntry.Employee);
                        }
                    }
                });

                var hasCaregiver = customer.Employee2CustomerList.Any(e2c =>
                        (!e2c.StartDate.HasValue || e2c.StartDate.Value.Date <= end.Date) && (!e2c.EndDate.HasValue || e2c.EndDate.Value.Date >= start.Date) &&
                        e2c.ValueList.Any(b => b.Entry.Type.Equals(ValueListEntryType.StaffRoleType) && !b.Entry.Value.ToLower().Equals("ehemalige betreuung"))) || assistingEmployees.Any();
                if (hasCaregiver)
                {
                    var relatedEmployees = new List<Employee>(assistingEmployees);
                    relatedEmployees.AddRangeIfElementsNotIn(
                        customer.Employee2CustomerList
                            .Where(
                                e2c => e2c.Employee.IsActive == ActivationTypeId.Active &&
                                        (!e2c.StartDate.HasValue || e2c.StartDate.Value.Date <= end.Date) && (!e2c.EndDate.HasValue || e2c.EndDate.Value.Date >= start.Date) &&
                                        !e2c.ValueList.Any(
                                           w => w.Entry.Type.Equals(ValueListEntryType.StaffRoleType) &&
                                                !w.Entry.Value.ToLower().Equals("ehemalige betreuung")))
                            .Select(s => s.Employee));

                    foreach (var employee in relatedEmployees)
                    {
                        var employeeDC = MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(employee);
                        var employeeAddressString = GetEmployeeAddressInfo(employee);
                        var employeeContactInformationList = LoadContactInformationForEntity<Employee>(employee.Person);

                        var assistanceTimeEntries = GetAssistanceTimesForCustomer(customer, employee, absenceTime, start, end);

                        var dateTime = start;
                        while (dateTime <= end)
                        {
                            if (LiegtImZeitraum(dateTime, absenceTime))
                            {
                                var dateTimeCopy = dateTime;
                                var relevantAssistanceTimeEntries = assistanceTimeEntries.Where(entry => IsAbsenceTimeInAssistanceTime(dateTime, entry, absenceTime) && (entry.Employee != null && entry.Employee.Equals(employee) || entry.Employee == null && employee.Equals(hauptbetreuer))).ToList();
                                var vertretungsObjekte = vertretungen.Where(w => w.EmployeeOid.HasValue && w.EmployeeOid.Equals(employee.Oid) && w.CustomerOid.HasValue && w.CustomerOid.Equals(customer.Oid) && w.VertretungsZeitraumVon.Date <= dateTimeCopy && w.VertretungsZeitraumBis.Date >= dateTimeCopy).ToList();
                                var lastSubstitutions = DAOFactory.SearchDAO.GetLastSubstitutionItems(employee.Oid.Value, 3);
                                var lastSubstitutionDCs = MapperFactory.VertretungDC_Vertretung.MapToNewDCs(lastSubstitutions);
                                var assistanceTimeEntryDCs = MapperFactory.ArbeitszeitEintragDC_ArbeitszeitEintrag.MapToNewDCs(relevantAssistanceTimeEntries);

                                
                                foreach (var assistanceTimeEntry in relevantAssistanceTimeEntries)
                                {
                                    var assistanceTimeEntryDC = MapperFactory.ArbeitszeitEintragDC_ArbeitszeitEintrag.MapToNewDC(assistanceTimeEntry);

                                    var newVertretungsItem = new VertretungsItemDC
                                    {
                                        Id = Guid.NewGuid(),
                                        Datum = dateTime,
                                        Absencetime = absenceTimeDC,
                                        Arbeitszeiten = assistanceTimeEntryDCs,
                                        Employee = employeeDC,
                                        EmployeeAddressString = employeeAddressString,
                                        LastSubstitutions = lastSubstitutionDCs,
                                        Customer = customerDC,
                                        CustomerContactInformation = customerContactInformationList,
                                        EmployeeContactInformation = employeeContactInformationList,
                                        Schools = schools,
                                        VertretungsStatus = VertretungsStatus.KlientKrank,
                                        Bemerkung = absenceTime.Notice,
                                        AssistanceTime = assistanceTimeEntryDC,
                                        BetreuungszeitenAmDatum = assistanceTimeEntryDC != null ? assistanceTimeEntryDC.ToString() : String.Empty,
                                        AlleBetreuungszeiten = GetBetreuungszeitenString(assistanceTimeEntries)
                                    };

                                    AddKrankheitsZeitraumAndMeldungToItem(newVertretungsItem, newVertretungsItem.Absencetime);

                                    var vertretung = vertretungsObjekte.FirstOrDefault();
                                    Employee substitutionEmployee = null;

                                    if (vertretung?.VertretenderMitarbeiterOid != null)
                                    {
                                        if(GetIsSubstitutedCompletely(relevantAssistanceTimeEntries, vertretung, dateTime))
                                        {
                                            substitutionEmployee = DAOFactory.GenericDAO.LoadByID<Employee>(vertretung.VertretenderMitarbeiterOid.Value);
                                            var substitutionEmployeeDC = MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(substitutionEmployee);

                                            newVertretungsItem.Vertreter = substitutionEmployeeDC;

                                            newVertretungsItem.VertreterInfoString = GetEmployeeAddressInfo(substitutionEmployee);

                                            newVertretungsItem.Vertretung = MapperFactory.VertretungDC_Vertretung.MapToNewDC(vertretung);
                                            newVertretungsItem.Bemerkung = vertretung.Notice;

                                            newVertretungsItem.VertretungsStatus = VertretungsStatus.MaKrankVertretungVorhanden;
                                        }
                                    }

                                    // TODO: Hat die vertretungsItemListe Objekte mit dem Klienten im selben Zeitfenster?
                                    foreach (var employeeVertretungsItem in employeeVertretungsItems.Where(w => w.Customer.Equals(customerDC) && w.Employee != null && w.Employee.EmployeeOid == employeeDC.EmployeeOid))
                                    {
                                        if (employeeVertretungsItem.Datum == dateTime)
                                        {
                                            if (IsAbsenceTimeInAssistanceTime(dateTime, employeeVertretungsItem.AssistanceTime, absenceTime))
                                            {
                                                employeeVertretungsItemsGuids2Ignore.AddIfNotIn(employeeVertretungsItem.Id);
                                                if (newVertretungsItem.VertretungsStatus == VertretungsStatus.KlientKrank)
                                                {
                                                    newVertretungsItem.VertretungsStatus = VertretungsStatus.KlientUndMitarbeiterKrank;
                                                }
                                                else
                                                {
                                                    newVertretungsItem.VertretungsStatus =
                                                        VertretungsStatus.MaKrankKeineVertretungBenoetigt;
                                                }
                                            }
                                        }
                                    }

                                    //prüfe auch noch, ob zugeordneter Employee krank ist
                                    if (newVertretungsItem.VertretungsStatus == VertretungsStatus.KlientKrank)
                                    {
                                        if (newVertretungsItem.Employee != null)
                                        {
                                            if (employeeAbsenceTimes.Any(a => a.EmployeeOid == newVertretungsItem.Employee.EmployeeOid))
                                            {
                                                newVertretungsItem.VertretungsStatus = VertretungsStatus.KlientUndMitarbeiterKrank;
                                            }
                                        }
                                        //newVertretungsItem.VertretungsStatus = VertretungsStatus.KlientUndMitarbeiterKrank;
                                    }

                                    SetSubstitutionColor(newVertretungsItem);

                                    Organisation schule = null;
                                    var c2o = customer.Customer2OrganisationList.Where(customer2Organisation => customer2Organisation.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && IstSchule(b.Entry.Value))).FirstOrDefault();
                                    if (c2o != null)
                                    {
                                        schule = c2o.Organisation;
                                    }
                                    SetMailInfos(newVertretungsItem, customer, employee, substitutionEmployee, schule);


                                    SetSBDInformation(newVertretungsItem, customer, employee, false);

                                    SetTeamleitung(employee, newVertretungsItem);

                                    customerVertretungsItems.Add(newVertretungsItem);
                                }
                            }

                            dateTime = dateTime.AddDays(1);
                        }
                    }
                }
                else // Kein Betreuer, also auch keine Vertretungen, sondern nur Abwesenheiten
                {
                    var assistanceTimeEntries = GetAssistanceTimesForCustomer(customer, null, absenceTime, start, end);

                    var dateTime = start;
                    while (dateTime <= end)
                    {
                        if (LiegtImZeitraum(dateTime, absenceTime))
                        {
                            var relevantAssistanceTimeEntries = assistanceTimeEntries.Where(entry => IsAbsenceTimeInAssistanceTime(dateTime, entry, absenceTime)).ToList();
                            var assistanceTimeEntryDCs = MapperFactory.ArbeitszeitEintragDC_ArbeitszeitEintrag.MapToNewDCs(relevantAssistanceTimeEntries);

                            var newVertretungsItem = new VertretungsItemDC
                            {
                                Id = Guid.NewGuid(),
                                Datum = dateTime,
                                Absencetime = absenceTimeDC,
                                Arbeitszeiten = assistanceTimeEntryDCs,
                                Customer = customerDC,
                                CustomerContactInformation = customerContactInformationList,
                                Schools = schools,
                                VertretungsStatus = VertretungsStatus.KlientUndMitarbeiterKrank,
                                Bemerkung = absenceTime.Notice
                            };

                            SetzeSchule(newVertretungsItem, customer);

                            AddKrankheitsZeitraumAndMeldungToItem(newVertretungsItem, absenceTimeDC);

                            SetSubstitutionColor(newVertretungsItem);

                            SetSBDInformation(newVertretungsItem, customer, null, false);

                            customerVertretungsItems.Add(newVertretungsItem);
                        }

                        dateTime = dateTime.AddDays(1);
                    }
                }
            }

            vertretungsItems.AddRange(employeeVertretungsItems.Where(vertretungsItem => !employeeVertretungsItemsGuids2Ignore.Contains(vertretungsItem.Id)));

            //prüfen, ob Mitarbeiter bereits als Vertretung eingesetzt ist:
            //customerVertretungsItems = customerVertretungsItems.Where(c => c.Employee != null && c.Equals( !employeeVertretungsItems.Where(ei => ei.Vertreter != null).Select(ei2 => ei2.Vertreter.EmployeeOid).Contains(c.Employee.EmployeeOid))).ToList();
            var newList = new List<VertretungsItemDC>();
            foreach (var ci in customerVertretungsItems)
            {
                if (ci.Employee == null)
                {
                    newList.Add(ci);
                }
                else
                {
                    bool istAlsVertreterEingesetzt = false;

                    foreach (var ei in employeeVertretungsItems)
                    {
                        if (ei.Vertreter != null && ei.Vertreter.EmployeeOid == ci.Employee.EmployeeOid)
                        {
                            istAlsVertreterEingesetzt = true;
                        }
                    }

                    if (!istAlsVertreterEingesetzt)
                    {
                        newList.Add(ci);
                    }
                }
            }

            //customerVertretungsItems = customerVertretungsItems.Where(c => c.Employee == null || !employeeVertretungsItems.Where(ei => ei.Vertreter != null).Select(ei2 => ei2.Vertreter.EmployeeOid).Contains(c.Employee.EmployeeOid)).ToList();
            customerVertretungsItems = newList;

            vertretungsItems.AddRange(customerVertretungsItems);

            SetSubstitutingEmployee2CustomersRelation(vertretungsItems);

            vertretungsItems = RemoveDuplicates(vertretungsItems);
            return vertretungsItems;
        }


        //Erstellt Vertretungsitems für abwesenden MA oder MA, der als Vertreter bei einem anderen Klienten eingesetzt ist, so dass sein eigener Klient betreut werden muss
        public virtual List<VertretungsItemDC> CreateVertretungsItemsForAbsenceEmployee(Employee employee, List<Vertretung> vorhandeneVertretungen, AbsenceTime absenceTime, DateTime start, DateTime end)
        {
            var result = new List<VertretungsItemDC>();

            var employeeDC = MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(employee);
            var employeeAddressString = GetEmployeeAddressInfo(employee);
            var employeeContactInformationList = LoadContactInformationForEntity<Employee>(employee.Person);
            AbsenceTimeDC absenceTimeDC = null;
            if (absenceTime != null)
            {
                absenceTimeDC = MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDC(absenceTime);
            }
            //if (employee.Person.LastNameFirstName.Contains("Platzhalter"))
            //{
            //    int test = 0; 
            //}
            foreach (var employee2Customer in employee.Employee2CustomerList.Where(e2C => e2C.IsActive == ActivationTypeId.Active && (!e2C.StartDate.HasValue || e2C.StartDate.Value.Date <= end.Date) && (!e2C.EndDate.HasValue || e2C.EndDate.Value.Date >= start.Date)))
            {
                foreach (var valueListEntry2Object in employee2Customer.ValueList.Where(entry2Object => entry2Object.Entry.Type == ValueListEntryType.StaffRoleType))
                {
                    var customer = employee2Customer.Customer;
                    var customerDC = MapperFactory.CompactCustomerDC_Customer.MapToNewDC(customer);

                    var customerContactInformationList = LoadContactInformationForEntity<Customer>(customer.Person);
                    var c2oList = customer.Customer2OrganisationList.Where(customer2Organisation => customer2Organisation.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && IstSchule(b.Entry.Value))).ToList();
                    var schools = MapperFactory.CustomerOrganisationRelationDC_Customer2Organisation.MapToNewDCs(c2oList);
                    Organisation schule = null;
                    if (c2oList.Count > 0)
                    {
                        schule = c2oList[0].Organisation;

                    }
                    var assistanceTimeEntries = GetAssistanceTimesForCustomer(customer, employee, absenceTime, start, end);
                    
                    var dateTime = start;
                    while (dateTime <= end)
                    {
                        if (absenceTime == null || LiegtImZeitraum(dateTime, absenceTime))
                        {
                            var dateTimeCopy = dateTime;
                            var relevantAssistanceTimeEntries = assistanceTimeEntries.Where(entry => IsAbsenceTimeInAssistanceTime(dateTimeCopy, entry, absenceTime));

                            foreach (var assistanceTimeEntry in relevantAssistanceTimeEntries)
                            {
                                var vertretungsObjekte = vorhandeneVertretungen.Where(w => w.EmployeeOid.HasValue && w.EmployeeOid.Equals(employee.Oid) && w.CustomerOid.HasValue && w.CustomerOid.Equals(customer.Oid) && w.VertretungsZeitraumVon.Date <= dateTimeCopy && w.VertretungsZeitraumBis.Date >= dateTimeCopy);
                                var lastSubstitutions = DAOFactory.SearchDAO.GetLastSubstitutionItems(employee.Oid.Value, 3);
                                var lastSubstitutionDCs = MapperFactory.VertretungDC_Vertretung.MapToNewDCs(lastSubstitutions);
                                var assistanceTimeEntryDC = MapperFactory.ArbeitszeitEintragDC_ArbeitszeitEintrag.MapToNewDC(assistanceTimeEntry);

                                var newVertretungsItem = new VertretungsItemDC
                                {
                                    Id = Guid.NewGuid(),
                                    Datum = dateTime,
                                    Absencetime = absenceTimeDC,
                                    AssistanceTime = assistanceTimeEntryDC,
                                    BetreuungszeitenAmDatum = assistanceTimeEntryDC != null ? assistanceTimeEntryDC.ToString() : String.Empty,
                                    AlleBetreuungszeiten = GetBetreuungszeitenString(assistanceTimeEntries),
                                    Employee = employeeDC,
                                    EmployeeAddressString = employeeAddressString,
                                    LastSubstitutions = lastSubstitutionDCs,
                                    Customer = customerDC,
                                    CustomerContactInformation = customerContactInformationList,
                                    EmployeeContactInformation = employeeContactInformationList,
                                    Schools = schools,
                                    Bemerkung = absenceTime?.Notice
                                };
                                if (newVertretungsItem.Absencetime != null)
                                {
                                    AddKrankheitsZeitraumAndMeldungToItem(newVertretungsItem, newVertretungsItem.Absencetime);
                                }
                                DateTime absenceTimeStartDate = newVertretungsItem.Datum;
                                if (absenceTime != null)
                                {
                                    absenceTimeStartDate = absenceTime.Start.Value;
                                }
                                GetVertretungsstatus(newVertretungsItem, dateTime, absenceTimeStartDate, customer);
                                if (absenceTime == null && newVertretungsItem.VertretungsStatus == VertretungsStatus.MaKrankKeineVertretungBenoetigt)
                                {
                                    newVertretungsItem.VertretungsStatus = VertretungsStatus.MaKrankVertretungBenoetigt;
                                }
                                //Es kann in Ausnahmen mehrere Vertretungen für den gleichen erkrankten MA geben. Z.B. wenn die erste Vertretung selber erkrankt und eine zweite ausgewählt wird.
                                Vertretung vertretung = null;
                                Employee vertreter = null;

                                foreach (var vo in vertretungsObjekte)
                                {
                                    if (vo.VertretenderMitarbeiterOid.HasValue)
                                    {
                                        vertreter = DAOFactory.GenericDAO.LoadByID<Employee>(vo.VertretenderMitarbeiterOid.Value);

                                        if (!IstAbwesend(vertreter.AbsenceTimes, dateTime))
                                        {
                                            vertretung = vo;
                                        }
                                    }

                                }



                                if (vertretung?.VertretenderMitarbeiterOid != null)
                                {
                                    if (GetIsSubstitutedCompletely(new List<ArbeitszeitEintrag> { assistanceTimeEntry }, vertretung, dateTime))
                                    {
                                        if (vertreter == null)
                                        {
                                            vertreter = DAOFactory.GenericDAO.LoadByID<Employee>(vertretung.VertretenderMitarbeiterOid.Value);
                                        }
                                        var substitutionEmployeeDC = MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(vertreter);

                                        newVertretungsItem.Vertreter = substitutionEmployeeDC;

                                        newVertretungsItem.VertreterInfoString = GetEmployeeAddressInfo(vertreter);

                                        newVertretungsItem.Vertretung = MapperFactory.VertretungDC_Vertretung.MapToNewDC(vertretung);
                                        newVertretungsItem.Bemerkung = vertretung.Notice;

                                        newVertretungsItem.VertretungsStatus = VertretungsStatus.MaKrankVertretungVorhanden;

                                        //if (IstAbwesend(vertreter.AbsenceTimes, dateTime))
                                        //{
                                        //    newVertretungsItem.VertretungsStatus = VertretungsStatus.MaKrankVertretungBenoetigt;
                                        //    newVertretungsItem.Vertreter = null;
                                        //    newVertretungsItem.VertreterInfoString = null;
                                        //    newVertretungsItem.Vertretung = null;
                                        //}
                                    }
                                }

                                SetSubstitutionColor(newVertretungsItem);

                                SetSBDInformation(newVertretungsItem, customer, employee, true);
                                SetMailInfos(newVertretungsItem, customer, employee, vertreter, schule);
                                SetTeamleitung(employee, newVertretungsItem);

                                if (newVertretungsItem.Absencetime == null)
                                {
                                    newVertretungsItem.Absencetime = new AbsenceTimeDC();
                                }
                                result.Add(newVertretungsItem);
                            }
                        }

                        dateTime = dateTime.AddDays(1);
                    }
                }
            }

            return result;
        }

        private bool IstAbwesend(IList<AbsenceTime> absenceTimes, DateTime datum)
        {
            foreach (var at in absenceTimes)
            {
                if ((!at.Start.HasValue || at.Start.Value.Date <= datum) && (!at.End.HasValue || at.End.Value.Date >= datum))
                {
                    return true;
                }
            }

            return false;
        }

        private List<VertretungsItemDC> RemoveDuplicates(List<VertretungsItemDC> vertretungsItems)
        {
            var newList = new List<VertretungsItemDC>();
            var keyDict = new Dictionary<string, bool>();
            foreach (var ci in vertretungsItems)
            {
                if (ci.Customer != null && ci.Employee != null && ci.Absencetime != null &&
                    (ci.VertretungsStatus == VertretungsStatus.KlientUndMitarbeiterKrank ||
                     ci.VertretungsStatus == VertretungsStatus.MaKrankKeineVertretungBenoetigt ||
                     ci.VertretungsStatus == VertretungsStatus.MaKrankVertretungVorhanden))
                {
                    String key = "";
                    if (ci.Vertretung != null &&
                        ci.Vertretung.VertretungsZeitraumVon.Hour == 0 &&
                        ci.Vertretung.VertretungsZeitraumVon.Minute == 0 &&
                        ci.Vertretung.VertretungsZeitraumBis.Hour == 23 &&
                        ci.Vertretung.VertretungsZeitraumBis.Minute == 59)
                    {
                        ci.Vertretung.VertretungsZeitraumBis = ci.Vertretung.VertretungsZeitraumBis.Date;

                        key = String.Format("{0}_{1}_{2:dd.MM.yyyy HH:mm} - {3:dd.MM.yyyy HH:mm}_{4}", ci.Customer.Oid, ci.Employee.EmployeeOid, ci.Vertretung.VertretungsZeitraumVon, ci.Vertretung.VertretungsZeitraumBis, ci.Absencetime.AbsenceTimeOid);
                    }
                    else
                    {
                        if (ci.Vertretung == null)
                        {
                            key = String.Format("{0}_{1}_{2}", ci.Customer.Oid, ci.Employee.EmployeeOid, ci.Absencetime.AbsenceTimeOid);
                        }
                    }
                    

                    if (String.IsNullOrEmpty(key) || !keyDict.ContainsKey(key))
                    {
                        newList.Add(ci);
                        if (!String.IsNullOrEmpty(key))
                        {
                            keyDict.Add(key, true);
                        }
                    }
                    else
                    {
                        int test = 0;
                    }
                }
                else
                {
                    newList.Add(ci);
                }
            }

            return newList;
        }

        public virtual List<VertretungsItemDC> CreateVertretungsListe(DateTime start, DateTime end)
        {
            return CreateSubstitutions(start, end);
        }

        private static void SetSubstitutingEmployee2CustomersRelation(IEnumerable<VertretungsItemDC> vertretungsItems)
        {
            var vertreterZuKlient = new Dictionary<string, CompactCustomerDC>();
            foreach (var item in vertretungsItems)
            {
                //Suche alle Vertreter für Klienten und merke diese
                if (item.VertretungsStatus != VertretungsStatus.KlientKrank)
                {
                    if (item.Vertreter != null && item.Customer != null)
                    {
                        var key = $"{item.Vertreter.EmployeeOid}_{item.Datum:dd.MM.yyyy}";

                        if (!vertreterZuKlient.ContainsKey(key))
                        {
                            vertreterZuKlient.Add(key, item.Customer);
                        }
                    }
                }

                if (item.MitarbeiterEinsatzBei == "???" && item.Employee != null)
                {
                    item.MitarbeiterEinsatzBei = "";

                    var key = $"{item.Employee.EmployeeOid}_{item.Datum:dd.MM.yyyy}";

                    if (vertreterZuKlient.ContainsKey(key))
                    {
                        item.MitarbeiterEinsatzBei = $"{vertreterZuKlient[key].LastNameFirstName}";
                    }
                }
            }
        }


        public virtual void SetSBDInformation(VertretungsItemDC vertretungsItem, Customer customer, Employee employee, bool isEmployeeAbsenceTime)
        {
            if (customer != null)
            {
                vertretungsItem.CustomerPflege = customer.Pflege ? "Ja" : "Nein";
                vertretungsItem.CustomerToilettengang = customer.Toilettengang ? "Ja" : "Nein";
                vertretungsItem.CustomerAggressivitaet = customer.Aggressiv ? "Ja" : "Nein";
                vertretungsItem.CustomerHygienebelehrung = customer.Hygienebelehrung ? "Ja" : "Nein";
                vertretungsItem.CustomerSchutzstufe = customer.Schutzstufe;
            }
            
            vertretungsItem.EmployeePflege = employee == null ? "Nein" : employee.Pflege ? "Ja" : "Nein";
            vertretungsItem.EmployeeToilettengang = employee == null ? "Nein" : employee.Toilettengang ? "Ja" : "Nein";
            vertretungsItem.EmployeeAggressivitaet = employee == null ? "Nein" : employee.Aggressiv ? "Ja" : "Nein";
            vertretungsItem.EmployeeHygienebelehrung = employee == null ? "Nein" : employee.Hygienebelehrung ? "Ja" : "Nein";
            vertretungsItem.EmployeeSchutzstufe = employee?.Schutzstufe;

            if (isEmployeeAbsenceTime)
            {
                if (customer != null)
                {
                    vertretungsItem.Pflege = customer.Pflege ? "Ja" : "Nein";
                    vertretungsItem.Toilettengang = customer.Toilettengang ? "Ja" : "Nein";
                    vertretungsItem.Aggressiv = customer.Aggressiv ? "Ja" : "Nein";

                    if (customer.Person.Sex.HasValue)
                    {
                        vertretungsItem.Geschlecht = Utils.GetSexAbbrevation(customer.Person.Sex);
                    }
                }
            }
            else
            {
                vertretungsItem.Pflege = employee == null ? "Nein" : employee.Pflege ? "Ja" : "Nein";
                vertretungsItem.Toilettengang = employee == null ? "Nein" : employee.Toilettengang ? "Ja" : "Nein";
                vertretungsItem.Aggressiv = employee == null ? "Nein" : employee.Aggressiv ? "Ja" : "Nein";

                if (employee?.Person.Sex != null)
                {
                    vertretungsItem.Geschlecht = Utils.GetSexAbbrevation(employee.Person.Sex);
                }

                vertretungsItem.MitarbeiterEinsatzBei = "???";
            }


            var customerToolTip = new StringBuilder();
            var employeeToolTip = new StringBuilder();
            var vertreterToolTip = new StringBuilder();


            String customerName = "";
            String employeeName = "";
            String vertreterName = "";

            if (vertretungsItem.Customer != null)
            {
                customerName = String.Format("{0} {1}", vertretungsItem.Customer.FirstName, vertretungsItem.Customer.LastName);
            }
            if (vertretungsItem.Employee != null)
            {
                employeeName = String.Format("{0} {1}", vertretungsItem.Employee.FirstName, vertretungsItem.Employee.LastName);
            }
            if (vertretungsItem.Vertreter != null)
            {
                vertreterName = String.Format("{0} {1}", vertretungsItem.Vertreter.FirstName, vertretungsItem.Vertreter.LastName);
            }

            String schoolString = "";
            if (vertretungsItem.Schools != null)
            {
                foreach (var item in vertretungsItem.Schools)
                {
                    if (schoolString.Length > 0)
                    {
                        schoolString += ", ";
                    }

                    schoolString += item.Organisation.Name;
                    if (!String.IsNullOrEmpty(item.Organisation.Street))
                    {
                        schoolString += "<LineBreak/>";
                        schoolString += item.Organisation.Street;
                    }
                    if (!String.IsNullOrEmpty(item.Organisation.PostalCode) || !String.IsNullOrEmpty(item.Organisation.Town))
                    {
                        schoolString += "<LineBreak/>";
                        schoolString += String.Format("{0} {1}", item.Organisation.PostalCode, item.Organisation.Town);
                    }
                    if (!String.IsNullOrEmpty(item.Customer2OrganisationNotice))
                    {
                        schoolString += "<LineBreak/>";
                        if (!item.Customer2OrganisationNotice.Contains("Klasse"))
                        {
                            schoolString += "Klasse ";
                        }
                        schoolString += item.Customer2OrganisationNotice;
                    }
                }
            }


            customerToolTip.AppendLine("<StackPanel xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'>");
            employeeToolTip.AppendLine("<StackPanel xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'>");
            vertreterToolTip.AppendLine("<StackPanel xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'>");

            //Customer Tooltip
            if (!String.IsNullOrEmpty(customerName))
            {
                customerToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='{0}' />", customerName));
            }
            if (vertretungsItem.Customer != null)
            {
                customerToolTip.AppendLine(String.Format("<TextBlock Text='{0}' />", vertretungsItem.Customer.AddressString));
            }
            String contactString = "";

            if (vertretungsItem.EmployeeContactInformation != null && vertretungsItem.EmployeeContactInformation.Count > 0)
            {
                foreach (var item in vertretungsItem.EmployeeContactInformation)
                {
                    if (contactString.Length > 0)
                    {
                        contactString += "<LineBreak/>";
                    }

                    var typeAsString = string.Empty;
                    switch (item.ContactType)
                    {
                        case ContactType.business_Mail:
                            typeAsString = "E-Mail: ";
                            break;
                        case ContactType.business_Fax:
                            typeAsString = "Fax: ";
                            break;
                        case ContactType.business_Phone:
                            typeAsString = "Tel.: ";
                            break;
                        case ContactType.business_MobilePhone:
                            typeAsString = "Handynr.: ";
                            break;
                    }

                    contactString += typeAsString + item.ContactValue;
                }
            }
            if (!String.IsNullOrEmpty(contactString))
            {
                customerToolTip.AppendLine(String.Format("<Separator />"));
                customerToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Kontakt:' /> "));
                customerToolTip.AppendLine(String.Format("<TextBlock>{0}</TextBlock>", contactString));
            }
            if (!String.IsNullOrEmpty(schoolString))
            {
                customerToolTip.AppendLine(String.Format("<Separator />"));
                customerToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Schule:' /> "));
                customerToolTip.AppendLine(String.Format("<TextBlock>{0}</TextBlock>", schoolString));
            }

            String alleBetreuungszeiten = vertretungsItem.AlleBetreuungszeiten;

            if (!String.IsNullOrEmpty(alleBetreuungszeiten))
            {
                alleBetreuungszeiten = alleBetreuungszeiten.Replace("\n", "<LineBreak/>");

                customerToolTip.AppendLine(String.Format("<Separator />"));
                customerToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Betreuungszeiten:' /> "));
                customerToolTip.AppendLine(String.Format("<TextBlock>{0}</TextBlock>", alleBetreuungszeiten));
            }


            var lastSubstitutions = string.Empty;
            if (vertretungsItem.LastSubstitutions != null)
            {
                foreach (var item in vertretungsItem.LastSubstitutions)
                {
                    if (lastSubstitutions.Length > 0)
                    {
                        lastSubstitutions += "<LineBreak/>";
                    }

                    var start = item.VertretungsZeitraumVon.Minute == 0 && item.VertretungsZeitraumVon.Hour == 0 ? item.VertretungsZeitraumVon.ToString("dd.MM.yyyy") : item.VertretungsZeitraumVon.ToString("dd.MM.yyyy HH:mm");
                    var end = item.VertretungsZeitraumBis.Minute == 0 && item.VertretungsZeitraumBis.Hour == 0 ? item.VertretungsZeitraumBis.ToString("dd.MM.yyyy") : item.VertretungsZeitraumBis.ToString("dd.MM.yyyy HH:mm");

                    lastSubstitutions += $"{start} - {end}";
                }
            }

            if (!String.IsNullOrEmpty(lastSubstitutions))
            {
                customerToolTip.AppendLine(String.Format("<Separator />"));
                customerToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Letzte Vertretungen:' /> "));
                customerToolTip.AppendLine(String.Format("<TextBlock>{0}</TextBlock>", lastSubstitutions));
            }

            var sbdStatus = string.Empty;

            //if (vertretungsItem.Absencetime != null)
            //{
            if (customer != null)
            {
                if (customer.Pflege)
                {
                    sbdStatus += "Benötigt Pflege";
                }

                if (customer.Toilettengang)
                {
                    if (sbdStatus.Length > 0)
                    {
                        sbdStatus += ", ";
                    }

                    sbdStatus += "Toilettengang";
                }

                if (customer.Aggressiv)
                {
                    if (sbdStatus.Length > 0)
                    {
                        sbdStatus += ", ";
                    }

                    sbdStatus += "Aggressivität";
                }

                if (customer.Hygienebelehrung)
                {
                    if (sbdStatus.Length > 0)
                    {
                        sbdStatus += ", ";
                    }

                    sbdStatus += "Hygienebelehrung";
                }

                if (!String.IsNullOrWhiteSpace(customer.Schutzstufe))
                {
                    if (sbdStatus.Length > 0)
                    {
                        sbdStatus += ", ";
                    }

                    sbdStatus += $"Schutzstufe {customer.Schutzstufe}";
                }

                // Vertretung gewünscht [ab x. Tag]
                if (customer.SubstitutionNeed == SubstitutionNeed.SubstitutionWanted)
                {
                    if (sbdStatus.Length > 0)
                    {
                        sbdStatus += "<LineBreak/>";
                    }

                    sbdStatus += "Vertretung gewünscht";

                    if (customer.AbWelchemKrankheitsTag > 0)
                    {
                        sbdStatus += $" ab {customer.AbWelchemKrankheitsTag}. Tag";
                    }
                }
            }
            if (!String.IsNullOrEmpty(sbdStatus))
            {
                customerToolTip.AppendLine(String.Format("<Separator />"));
                customerToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Weitere Informationen:' /> "));
                customerToolTip.AppendLine(String.Format("<TextBlock>{0}</TextBlock>", sbdStatus));
            }
            //}
            //else
            //{
            //    if (EmployeePflege?.Equals("Ja") ?? false)
            //    {
            //        result += "Benötigt Pflege";
            //    }

            //    if (EmployeeToilettengang?.Equals("Ja") ?? false)
            //    {
            //        if (result.Length > 0)
            //        {
            //            result += ", ";
            //        }

            //        result += "Toilettengang";
            //    }

            //    if (EmployeeAggressivitaet?.Equals("Ja") ?? false)
            //    {
            //        if (result.Length > 0)
            //        {
            //            result += ", ";
            //        }

            //        result += "Aggressivität";
            //    }

            //    if (EmployeeHygienebelehrung?.Equals("Ja") ?? false)
            //    {
            //        if (result.Length > 0)
            //        {
            //            result += ", ";
            //        }

            //        result += "Hygienebelehrung";
            //    }

            //    if (string.IsNullOrWhiteSpace(EmployeeSchutzstufe) == false)
            //    {
            //        if (result.Length > 0)
            //        {
            //            result += ", ";
            //        }

            //        result += $"Schutzstufe {EmployeeSchutzstufe}";
            //    }
            ////}

            

            //    <Separator Visibility="{Binding Path=Row.SchulbegleitenderDienstString, Converter={StaticResource StringLengthVisibilityConverter}}" />
            //    <TextBlock FontWeight="Bold" Text="Schulbegleitender Dienst:" Visibility="{Binding Path=Row.SchulbegleitenderDienstString, Converter={StaticResource StringLengthVisibilityConverter}}" />
            //    <TextBlock Text="{Binding Row.SchulbegleitenderDienstString}" Visibility="{Binding Path=Text, Converter={StaticResource StringLengthVisibilityConverter}, RelativeSource={RelativeSource Self}}" />

            //    <Separator Visibility="{Binding Row.EmployeeAddressString, Converter={StaticResource StringLengthVisibilityConverter}}" />
            //    <TextBlock FontWeight="Bold" Text="{markup:Translate Mitarbeiter/in:}" Visibility="{Binding Row.EmployeeAddressString, Converter={StaticResource StringLengthVisibilityConverter}}" />
            //    <TextBlock Text="{Binding Row.EmployeeAddressString}"  Visibility="{Binding Path=Text, Converter={StaticResource StringLengthVisibilityConverter}, RelativeSource={RelativeSource Self}}" />
            //</StackPanel>



            //Employee Tooltip
            if (!String.IsNullOrEmpty(employeeName))
            {
                employeeToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='{0}' />", employeeName));
            }
            //if (!String.IsNullOrEmpty(schoolString))
            //{
            //    employeeToolTip.AppendLine(String.Format("<Separator />"));
            //    employeeToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Schule:' /> "));
            //    employeeToolTip.AppendLine(String.Format("<TextBlock Text='{0}' />", schoolString));
            //}

            if (vertretungsItem.Employee != null)
            {
                employeeToolTip.AppendLine(String.Format("<Separator />"));
                employeeToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Wohnort:' /> "));
                employeeToolTip.AppendLine(String.Format("<TextBlock Text='{0}' />", vertretungsItem.Employee.DetailDescription));
            }

            //Vertreter Tooltip
            if (!String.IsNullOrEmpty(vertreterName))
            {
                vertreterToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='{0}' />", vertreterName));
            }
            //if (!String.IsNullOrEmpty(schoolString))
            //{
            //    vertreterToolTip.AppendLine(String.Format("<Separator />"));
            //    vertreterToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Schule:' /> "));
            //    vertreterToolTip.AppendLine(String.Format("<TextBlock Text='{0}' />", schoolString));
            //}

            if (vertretungsItem.Vertreter != null)
            {
                vertreterToolTip.AppendLine(String.Format("<Separator />"));
                vertreterToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Wohnort:' /> "));
                vertreterToolTip.AppendLine(String.Format("<TextBlock Text='{0}' />", vertretungsItem.Vertreter.DetailDescription));
            }
            customerToolTip.AppendLine("</StackPanel>");
            employeeToolTip.AppendLine("</StackPanel>");
            vertreterToolTip.AppendLine("</StackPanel>");



            //                < TextBlock FontWeight='Bold' Text='{0}'/>
            //                <Separator />
            //                <TextBlock Text='{1}'/>
            //            </StackPanel>", text1, text2); //.Replace("'", "\"");
            // //tt = @"<TextBlock FontWeight='Bold' Text='TESTSETSETESSETSET'/>";
            vertretungsItem.CustomerToolTip = customerToolTip.ToString();
            vertretungsItem.EmployeeToolTip = employeeToolTip.ToString();
            vertretungsItem.VertreterToolTip = vertreterToolTip.ToString();
            
            //< Separator Visibility = "{Binding Path=Row.SchoolString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock FontWeight = "Bold" Text = "Schule1:" Visibility = "{Binding Path=Row.SchoolString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock Text = "{Binding Row.SchoolString}" Visibility = "{Binding Path=Text, Converter={StaticResource StringLengthVisibilityConverter}, RelativeSource={RelativeSource Self}}" />


            //< Separator Visibility = "{Binding Path=Row.Customer.AddressString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock FontWeight = "Bold" Text = "Wohnort:" Visibility = "{Binding Path=Row.Customer.AddressString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock Text = "{Binding Row.Customer.AddressString}" />


            //< Separator Visibility = "{Binding Path=Row.CustomerContactInformationString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock FontWeight = "Bold" Text = "Kontakt:" Visibility = "{Binding Path=Row.CustomerContactInformationString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock Text = "{Binding Row.CustomerContactInformationString}" Visibility = "{Binding Path=Text, Converter={StaticResource StringLengthVisibilityConverter}, RelativeSource={RelativeSource Self}}" />


            //< Separator Visibility = "{Binding Path=Row.SchulbegleitenderDienstString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock FontWeight = "Bold" Text = "Schulbegleitender Dienst:" Visibility = "{Binding Path=Row.SchulbegleitenderDienstString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock Text = "{Binding Row.SchulbegleitenderDienstString}" Visibility = "{Binding Path=Text, Converter={StaticResource StringLengthVisibilityConverter}, RelativeSource={RelativeSource Self}}" />

        }

        private string GetBetreuungszeitenString(List<ArbeitszeitEintrag> assistanceTimeEntries)
        {
            Dictionary<AppointmentDayOfWeek, String> tag2Eintrag = new Dictionary<AppointmentDayOfWeek, String>();
            foreach (var item in assistanceTimeEntries)
            {
                if (!tag2Eintrag.ContainsKey(item.Tag))
                {
                    tag2Eintrag.Add(item.Tag, String.Format("{0}: {1}-{2}", item.Tag.ToString().Substring(0, 2), item.UhrzeitVon, item.UhrzeitBis));
                }
                else
                {
                    tag2Eintrag[item.Tag] += String.Format(", {0}-{1}", item.UhrzeitVon, item.UhrzeitBis);
                }
            }

            String str = "";

            foreach (var item in assistanceTimeEntries)
            {
                if (tag2Eintrag.ContainsKey(item.Tag))
                {
                    if (str.Length > 0)
                    {
                        str += "\n";
                    }
                    str += tag2Eintrag[item.Tag];
                    tag2Eintrag.Remove(item.Tag);
                }
                
            }
            return str;
        }


        public virtual void SetMailInfos(VertretungsItemDC vertretungsItem, Customer customer, Employee employee, Employee vertretung, Organisation school)
        {
            if (customer != null)
            {
                foreach (var c in customer.Person.Contacts)
                {
                    if (c.Type == ContactType.private_Mail || c.Type == ContactType.business_Mail)
                    {
                        vertretungsItem.MailCustomer = new MailDC();
                        vertretungsItem.MailCustomer.Receiver = c.Value;
                    }
                } 
            }

            if (employee != null)
            {
                
                foreach (var c in employee.Person.Contacts)
                {
                    if (c.Type == ContactType.private_Mail || c.Type == ContactType.business_Mail)
                    {
                        vertretungsItem.MailEmployee = new MailDC();
                        vertretungsItem.MailEmployee.Receiver = c.Value;
                    }
                }
                
            }

            if (vertretung != null)
            {

                foreach (var c in vertretung.Person.Contacts)
                {
                    if (c.Type == ContactType.private_Mail || c.Type == ContactType.business_Mail)
                    {
                        vertretungsItem.MailVertretung = new MailDC();
                        vertretungsItem.MailVertretung.Receiver = c.Value;
                    }
                }

            }

            if (school != null)
            {

                foreach (var c in school.Contacts)
                {
                    if (c.Type == ContactType.private_Mail || c.Type == ContactType.business_Mail)
                    {
                        vertretungsItem.MailSchule= new MailDC();
                        vertretungsItem.MailSchule.Receiver = c.Value;
                    }
                }

            }
        }

        public virtual void SetSubstitutionColor(VertretungsItemDC vertretungsItem)
        {
            switch (vertretungsItem.VertretungsStatus)
            {
                case VertretungsStatus.MaKrankVertretungBenoetigt:
                    vertretungsItem.KlientStatusColor = "#FF0000"; // Rot
                    break;
                case VertretungsStatus.MaKrankKeineVertretungBenoetigt:
                    vertretungsItem.KlientStatusColor = "#7FFF7F"; // Grün
                    break;
                case VertretungsStatus.KlientUndMitarbeiterKrank:
                    vertretungsItem.KlientStatusColor = "#7FFF7F"; // Grün
                    break;
                case VertretungsStatus.MaKrankVertretungVorhanden:
                    vertretungsItem.KlientStatusColor = "#7FFF7F"; // Grün
                    break;
                case VertretungsStatus.KlientKrank:
                    vertretungsItem.KlientStatusColor = "#FFFFA5"; // Gelb
                    break;
            }
        }

        private static void MigriereSubstitutionStatus(Customer customer)
        {
            if (customer != null)
            {
                if (customer.SubstitutionNeed == SubstitutionNeed.SubstitutionNeedUnset)
                {
                    if (customer.VertretungDringendErforderlich)
                    {
                        customer.SubstitutionNeed = SubstitutionNeed.SubstitutionNeeded;
                    }
                    else
                    {
                        customer.SubstitutionNeed = customer.VertretungGewuenscht ? SubstitutionNeed.SubstitutionWanted : SubstitutionNeed.NoSubstitutionWanted;
                    }
                }
                else
                {
                    customer.SubstitutionNeed = customer.SubstitutionNeed;
                }
            }
        }

        public virtual void SetTeamleitung(BeWoEntityBase employee, VertretungsItemDC item)
        {
            if (employee.Oid == null)
            {
                return;
            }

            var sb = new StringBuilder();
            var teams = DAOFactory.SearchDAO.FindTeamsOfEmployee(employee.Oid.Value);

            foreach (var team in teams)
            {
                if (team.Leader != null)
                {
                    if (sb.Length > 0)
                    {
                        sb.Append(", ");
                    }

                    sb.Append(team.Leader.Person.FirstNameLastName);
                }
            }

            item.Teamleitung = sb.ToString();
        }

        public virtual void SetzeSchule(VertretungsItemDC newItem, Customer customer)
        {
            if (customer != null)
            {
                foreach (var customer2Organisation in customer.Customer2OrganisationList)
                {
                    foreach (var valueListEntry2Object in customer2Organisation.ValueList)
                    {
                        if (valueListEntry2Object.Entry.Value != null && IstSchule(valueListEntry2Object.Entry.Value))
                        {
                            newItem.Schule = MapperFactory.CompactOrganisationDC_Organisation.MapToNewDC(customer2Organisation.Organisation);

                            if (customer2Organisation.Organisation.Address != null)
                            {
                                newItem.Schule.Street = customer2Organisation.Organisation.Address.Street;
                                newItem.Schule.PostalCode = customer2Organisation.Organisation.Address.PostalCode;
                                newItem.Schule.Town = customer2Organisation.Organisation.Address.Town;
                            }
                        }
                    }
                }
            }
        }

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

        private static bool LiegtImZeitraum(DateTime dateTime, AbsenceTime absenceTime)
        {
            return absenceTime.Start < dateTime.Date.AddDays(1) && absenceTime.End >= dateTime.Date;
        }

        public virtual void AddKrankheitsZeitraumAndMeldungToItem(VertretungsItemDC item, AbsenceTimeDC absenceTime)
        {
            if (!absenceTime.Start.HasValue || !absenceTime.End.HasValue)
            {
                item.Krankheitszeitraum = absenceTime.Start.HasValue ? absenceTime.Start.Value.ToString("dd.MM.yyyy") : "Unbekannt";

                item.Krankheitszeitraum += " - ";

                if (absenceTime.End.HasValue)
                {
                    item.Krankheitszeitraum += absenceTime.End.Value.ToString("dd.MM.yyyy");
                }
                else
                {
                    item.Krankheitszeitraum += "Unbekannt";
                }
            }
            else
            {
                if (absenceTime.Start.Value.Date != absenceTime.End.Value.Date)
                {
                    if (absenceTime.Start.Value.Hour == 0 && absenceTime.Start.Value.Minute == 0 &&
                        absenceTime.End.Value.Hour == 0 && absenceTime.End.Value.Minute == 0)
                    {
                        item.Krankheitszeitraum = absenceTime.Start.Value.ToString("dd.MM.yyyy") + " - " + absenceTime.End.Value.ToString("dd.MM.yyyy");
                    }
                    else
                    {
                        item.Krankheitszeitraum = absenceTime.Start.Value.ToString("dd.MM.yyyy HH:mm") + " - " + absenceTime.End.Value.ToString("dd.MM.yyyy HH:mm");
                    }
                }
                else
                {
                    if (absenceTime.Start.Value.Hour == 0 && absenceTime.Start.Value.Minute == 0 &&
                        absenceTime.End.Value.Hour == 0 && absenceTime.End.Value.Minute == 0)
                    {
                        item.Krankheitszeitraum = absenceTime.Start.Value.ToString("dd.MM.yyyy");
                    }
                    else
                    {
                        item.Krankheitszeitraum = absenceTime.Start.Value.ToString("dd.MM.yyyy HH:mm") + " - " + absenceTime.End.Value.ToString("HH:mm");
                    }
                }
            }


            if (absenceTime.KrankheitsMeldung != null)
            {
                item.Krankheitsmeldung = absenceTime.KrankheitsMeldung.Value;
            }
            else if (absenceTime.Start.HasValue)
            {
                item.Krankheitsmeldung = absenceTime.Start.Value;
            }
        }

        public virtual bool GetIsSubstitutedCompletely(IEnumerable<ArbeitszeitEintrag> assistanceTimes, Vertretung substitution, DateTime dateTime)
        {
            var isSubstituted = true;

            foreach (var assistanceTime in assistanceTimes)
            {
                var assistanceDateTimes = DateTimeUtils.GetAssistanceTimeComparisonDateTime(assistanceTime.UhrzeitVon, assistanceTime.UhrzeitBis, dateTime);
                if (substitution.VertretungsZeitraumBis.Hour == 0 && substitution.VertretungsZeitraumBis.Minute == 0)
                {
                    substitution.VertretungsZeitraumBis = substitution.VertretungsZeitraumBis.AddDays(1).AddTicks(-1);
                }

                isSubstituted = assistanceDateTimes.Start.AreInBetweenDates(assistanceDateTimes.End, substitution.VertretungsZeitraumVon, substitution.VertretungsZeitraumBis);

                if (!isSubstituted)
                {
                    break;
                }
            }

            return isSubstituted;
        }

        public virtual void GetVertretungsstatus(VertretungsItemDC vertretungsItem, DateTime dateTime, DateTime absenceTimeStartDate, Customer customer)
        {
            MigriereSubstitutionStatus(customer);

            if (customer.SubstitutionNeed == SubstitutionNeed.SubstitutionNeeded)
            {
                vertretungsItem.VertretungsStatus = VertretungsStatus.MaKrankVertretungBenoetigt;
                vertretungsItem.Dringlichkeit = "Dringend";
                vertretungsItem.DringlichkeitColor = "#FF0000"; // rot
            } 
            else if (customer.SubstitutionNeed == SubstitutionNeed.SubstitutionWanted)
            {
                vertretungsItem.Dringlichkeit = "Möglichst";
                vertretungsItem.DringlichkeitColor = "#F3D04F"; // Senfgelb
            }
            else if (customer.SubstitutionNeed == SubstitutionNeed.NoSubstitutionWanted)
            {
                vertretungsItem.VertretungsStatus = VertretungsStatus.MaKrankKeineVertretungBenoetigt;
                vertretungsItem.Dringlichkeit = "Kein Vertretungsbedarf";
                vertretungsItem.DringlichkeitColor = "#FFFFFF"; // weiß
            }

            if (customer.AbWelchemKrankheitsTag > 1 && dateTime < absenceTimeStartDate.AddDays(customer.AbWelchemKrankheitsTag - 1))
            {
                vertretungsItem.VertretungsStatus = VertretungsStatus.MaKrankKeineVertretungBenoetigt;
                vertretungsItem.Dringlichkeit = $"Vertretung erst ab dem {customer.AbWelchemKrankheitsTag}.Tag benötigt";
                vertretungsItem.DringlichkeitColor = "#FFFFFF"; // weiß
            }

            if (customer.AbWelchemKrankheitsTag <= 1 && customer.SubstitutionNeed != SubstitutionNeed.SubstitutionWanted && customer.SubstitutionNeed != SubstitutionNeed.SubstitutionNeeded)
            {
                vertretungsItem.VertretungsStatus = VertretungsStatus.MaKrankKeineVertretungBenoetigt;
            }
        }

        public virtual string GetEmployeeAddressInfo(Employee employee)
        {
            var result = string.Empty;


            var address = employee.Person.Address;

            if (address != null)
            {
                var addressInfo = string.Empty;

                addressInfo += employee.Person.LastNameFirstName;

                if (!string.IsNullOrWhiteSpace(address.Street))
                {
                    if (addressInfo.Length > 0)
                    {
                        addressInfo += "\n\n";
                    }

                    addressInfo += address.Street;
                }

                if (!string.IsNullOrWhiteSpace(address.PostalCode))
                {
                    if (addressInfo.Length > 0)
                    {
                        addressInfo += "\n";
                    }

                    addressInfo += address.PostalCode;
                }

                if (!string.IsNullOrWhiteSpace(address.Town))
                {
                    if (addressInfo.Length > 0)
                    {
                        addressInfo += " ";
                    }

                    addressInfo += address.Town;
                }

                result = addressInfo;
            }

            return result;
        }

        public virtual bool IsAbsenceTimeInAssistanceTime(DateTime currentDate, ArbeitszeitEintrag assistanceTime, AbsenceTime absenceTime)
        {
            if (currentDate.DayOfWeek != DateTimeUtils.ConvertAppointmentDayOfWeekToDayOfWeek(assistanceTime.Tag))
            {
                return false;
            }
            if (absenceTime == null)
            {
                return true;
            }
            var assistanceTimeDates = DateTimeUtils.GetAssistanceTimeComparisonDateTime(assistanceTime.UhrzeitVon, assistanceTime.UhrzeitBis, currentDate);

            var absenceTimeEnd = absenceTime.End;

            if (absenceTimeEnd.HasValue && absenceTimeEnd.Value.Hour == 0 && absenceTimeEnd.Value.Minute == 0)
            {
                absenceTimeEnd = absenceTimeEnd.Value.AddHours(23).AddMinutes(59).AddSeconds(59);
            }

            return assistanceTimeDates.Start.IsIntervalOverlappingWithAbsenceTimeInterval(assistanceTimeDates.End, absenceTime.Start.Value, absenceTimeEnd);
        }

        public virtual bool IsAbsenceTimeInAssistanceTime(DateTime currentDate, ArbeitszeitEintragDC assistanceTime, AbsenceTime absenceTime)
        {
            if (currentDate.DayOfWeek != DateTimeUtils.ConvertAppointmentDayOfWeekToDayOfWeek(assistanceTime.Tag) || absenceTime.Start == null)
            {
                return false;
            }

            var assistanceTimeDates = DateTimeUtils.GetAssistanceTimeComparisonDateTime(assistanceTime.UhrzeitVon, assistanceTime.UhrzeitBis, currentDate);

            var absenceTimeEnd = absenceTime.End;

            //if (absenceTimeEnd.HasValue && absenceTime.Start.Value.Equals(absenceTimeEnd.Value))
            //{
            //    absenceTimeEnd = absenceTimeEnd.Value.AddHours(23).AddMinutes(59).AddSeconds(59);
            //}
            if (absenceTimeEnd.HasValue && absenceTimeEnd.Value.Hour == 0 && absenceTimeEnd.Value.Minute == 0 && absenceTimeEnd.Value.Second == 0)
            {
                absenceTimeEnd = absenceTimeEnd.Value.Date.AddHours(23).AddMinutes(59).AddSeconds(59);
            }

            return assistanceTimeDates.Start.IsIntervalOverlappingWithAbsenceTimeInterval(assistanceTimeDates.End, absenceTime.Start.Value, absenceTimeEnd);
        }

        public virtual List<ArbeitszeitEintrag> GetAssistanceTimesForCustomer(Customer customer, Employee employee, AbsenceTime absenceTime, DateTime start, DateTime end)
        {
            var assistanceTimeEntries = new List<ArbeitszeitEintrag>();

            var allSchoolAssistanceTimes = new List<Arbeitszeit>();
            var allCustomerAssistanceTimes = new List<Arbeitszeit>();

            var schoolAssistanceTimes = new List<Arbeitszeit>();
            var customerAssistanceTimes = new List<Arbeitszeit>();

            var hasSchoolAssistanceTimes = customer.Customer2OrganisationList.Any(a => a.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && IstSchule(b.Entry.Value)));
            if (hasSchoolAssistanceTimes)
            {
                var school = customer.Customer2OrganisationList.FirstOrDefault(f => f.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && IstSchule(b.Entry.Value)));
                if (school != null)
                {
                    allSchoolAssistanceTimes.AddRange(school.Organisation.Arbeitszeiten);
                }
            }

            var hasAssistanceTimes = customer.Arbeitszeiten?.Count > 0;
            if (hasAssistanceTimes)
            {
                allCustomerAssistanceTimes.AddRange(customer.Arbeitszeiten);
            }

            var dateTime = start;
            while (dateTime <= end)
            {
                if (absenceTime == null || LiegtImZeitraum(dateTime, absenceTime))
                {
                    customerAssistanceTimes.AddRange(allCustomerAssistanceTimes.Where(w => IsArbeitszeitValid(w, dateTime)));

                    schoolAssistanceTimes.AddRange(allSchoolAssistanceTimes.Where(w => IsArbeitszeitValid(w, dateTime)));
                }

                dateTime = dateTime.AddDays(1);
            }

            if (customerAssistanceTimes.Count > 0)
            {
                customerAssistanceTimes.DoForEach(assistanceTime => assistanceTimeEntries.AddRange(assistanceTime.ArbeitszeitEintraege.Where(entry => entry.Employee == null || entry.Employee.Equals(employee))));
            }
            else
            {
                schoolAssistanceTimes.DoForEach(assistanceTime => assistanceTimeEntries.AddRange(assistanceTime.ArbeitszeitEintraege.Where(entry => entry.Employee == null || entry.Employee.Equals(employee))));
            }

            return assistanceTimeEntries;
        }

        public virtual bool IsArbeitszeitValid(Arbeitszeit arbeitszeit, DateTime time)
        {
            if (arbeitszeit.GueltigVon == null && arbeitszeit.GueltigBis == null)
            {
                return true;
            }

            if (arbeitszeit.GueltigVon.HasValue && arbeitszeit.GueltigBis.HasValue)
            {
                return time.InBetween(arbeitszeit.GueltigVon.Value, arbeitszeit.GueltigBis.Value, true);
            }

            if (arbeitszeit.GueltigVon == null && arbeitszeit.GueltigBis.HasValue)
            {
                return time <= arbeitszeit.GueltigBis;
            }

            if (arbeitszeit.GueltigBis == null)
            {
                return time >= arbeitszeit.GueltigVon;
            }

            return false;
        }

        public virtual List<Arbeitszeit> GetSchoolAssistanceTimes(Customer customer, DateTime start, DateTime end, AbsenceTime absenceTime)
        {
            var allSchoolAssistanceTimes = new List<Arbeitszeit>();

            var schoolAssistanceTimes = new List<Arbeitszeit>();

            var hasSchoolAssistanceTimes = customer.Customer2OrganisationList.Any(a => a.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && IstSchule(b.Entry.Value)));
            if (hasSchoolAssistanceTimes)
            {
                var school = customer.Customer2OrganisationList.FirstOrDefault(f => f.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && IstSchule(b.Entry.Value)));
                if (school != null)
                {
                    allSchoolAssistanceTimes.AddRange(school.Organisation.Arbeitszeiten);
                }
            }

            var dateTime = start;
            while (dateTime <= end)
            {
                if (LiegtImZeitraum(dateTime, absenceTime))
                {
                    schoolAssistanceTimes.AddRange(allSchoolAssistanceTimes.Where(w => IsArbeitszeitValid(w, dateTime)));
                }

                dateTime = dateTime.AddDays(1);
            }

            return schoolAssistanceTimes;
        }

        protected void GetDistanceForVertreterEmployees(long customerOid, ref List<CompactVertreterEmployeeDC> list, IList<Employee> employees)
        {
            var customer = DAOFactory.GenericDAO.LoadByID<Customer>(customerOid);
            var school = customer.Customer2OrganisationList.FirstOrDefault(f => f.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && IstSchule(b.Entry.Value)));

            var origin = new Address[] { school.Person.Address };
            var destinations = employees.Select(x => x.Person.Address).ToArray();

            var matrix = AddressRouteManager.GetMatrix(origin, destinations);

            Employee empl; AddressRoute route;
            foreach (var employee in list)
            {
                empl = employees.FirstOrDefault(e => e.Person.Oid.Value == employee.PersonOid);
                route = matrix.GetRoute(school.Person.Address, empl.Person.Address);
                employee.AddressRoute = MapperFactory.AddressRouteDC_AddressRoute.MapToNewDC(route);
            }
        }

        public virtual void SaveVertretung(VertretungDC vertretung)
        {
            var x = MapperFactory.VertretungDC_Vertretung.MapToNewEntity(vertretung);

            DAOFactory.GenericDAO.Insert(x);
        }
    }
}