BeWoPlaner/Service/ServiceImplementations/OperationsServiceImp.cs

using BeWo.Data;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Data.ICD10;
using BeWo.Data.ICF;
using BeWo.Service.Configuration;
using BeWo.Service.Core;
using BeWo.Service.DCEntityMapper;
using BeWo.Service.Dienstplanung;
using BeWo.Service.Dokumentverwaltung;
using BeWo.Service.Invoicing;
using BeWo.Service.OwnChat;
using BeWo.Service.PivotTabelle;
using BeWo.Service.Plugins;
using BeWo.Service.SBD;
using BeWo.Service.Security;
using BeWo.Service.ServiceContracts;
using BeWo.Service.Vorlagen;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using BS.Shared.DataContracts.Reports;
using BS.Shared.Extensions;
using BS.Shared.Services;
using Dakota.Logic;
using Newtonsoft.Json;
using RestSharp;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Net;
using System.ServiceModel;
using System.Text;
using System.Threading;
using System.Web;
using System.Windows;
using BeWo.Data.Utils;
using Utils = BeWo.Service.Core.Utils;
using System.Collections.Specialized;

namespace BeWo.Service.ServiceImplementations
{
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Single)]
    public class OperationsServiceImp : IOperationsService
    {
        private static object _Lock = string.Empty;
        private static Dictionary<string, string> _ContractStates = new Dictionary<string, string>();
        private static Dictionary<string, DateTime> _ContractStateDate = new Dictionary<string, DateTime>();

        public Mandator GetMandatorEntity()
        {
            return AppSettings.GetMandatorEntity();
        }

        public void DeactivateInvoices(List<InvoiceDC> pInvoices)
        {
            try
            {
                ServiceLogic.SetActivationType<Invoice>(pInvoices.ToDictionary(i => i.InvoiceOid.Value, i => i.InvoiceVersion.Value), ActivationTypeId.Deleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateServiceCategories(Dictionary<long, long> pOid2Version)
        {
            try
            {
                ServiceLogic.SetActivationType<ServiceCategory>(pOid2Version, ActivationTypeId.Deleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateAdditionalServices(Dictionary<long, long> pOid2Version)
        {
            try
            {
                ServiceLogic.SetActivationType<AdditionalService>(pOid2Version, ActivationTypeId.Deleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateServiceCategory(long pOid, long pVersion)
        {
            try
            {
                ServiceLogic.SetActivationType<ServiceCategory>(new Dictionary<long, long>
                {
                    {
                        pOid, pVersion
                    }
                }, ActivationTypeId.Deleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateServiceDescription(long pOid, long pVersion)
        {
            try
            {
                ServiceLogic.SetActivationType<ServiceDescription>(new Dictionary<long, long>
                {
                    {
                        pOid, pVersion
                    }
                }, ActivationTypeId.Deleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateServiceDescriptions(Dictionary<long, long> pOid2Version)
        {
            try
            {
                ServiceLogic.SetActivationType<ServiceDescription>(pOid2Version, ActivationTypeId.Deleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateAdditionalServiceRegions(Dictionary<long, long> pOid2Version)
        {
            try
            {
                ServiceLogic.SetActivationType<AdditionalServiceRegion>(pOid2Version, ActivationTypeId.Deleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteAccountingTransaction(long pOid, long pVersion)
        {
            try
            {
                DeleteAccountingTransactions(new Dictionary<long, long>
                {
                    {
                        pOid, pVersion
                    }
                });
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteAccountingTransactions(Dictionary<long, long> pOid2Version)
        {
            try
            {
                List<AccountingTransaction> lOriginals = DAOFactory.GenericDAO.LoadByIDs<AccountingTransaction>(pOid2Version.Select(e => e.Key));
                lOriginals.DoForEach(or => MapperFactory.AccountingTransactionDC_AccountingTransaction.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));

                // DAOFactory.GenericDAO.Deactivate<AccountingTransaction>(lOriginals);
                DAOFactory.GenericDAO.Delete(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteFileAttachment(long pOid, long pVersion)
        {
            try
            {
                DeleteFileAttachments(new Dictionary<long, long>
                {
                    {
                        pOid, pVersion
                    }
                });
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteFileAttachments(Dictionary<long, long> pOid2Version)
        {
            try
            {
                ServiceLogic.SetActivationType<FileAttachment>(pOid2Version, ActivationTypeId.Deleted);

                //var lOriginals = DAOFactory.GenericDAO.LoadByIDs<FileAttachment>(pOid2Version.Select(e => e.Key));
                //lOriginals.DoForEach(or => MapperFactory.FileAttachmentDC_FileAttachment.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));

                //var fileAttachmentOids = new List<long>();

                //lOriginals.DoForEach(fileAttachment =>
                //{
                //    if(fileAttachment.Oid.HasValue)
                //    {
                //        fileAttachmentOids.AddIfNotIn(fileAttachment.Oid.Value);
                //    }
                //});

                //FileAttachmentUtils.DeleteFilesFromFileDirectory(fileAttachmentOids);

                //DAOFactory.GenericDAO.Delete(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteServiceCategories(Dictionary<long, long> pOid2Version)
        {
            try
            {
                List<ServiceCategory> lOriginals = DAOFactory.GenericDAO.LoadByIDs<ServiceCategory>(pOid2Version.Select(e => e.Key));
                lOriginals.DoForEach(or => MapperFactory.ServiceCategoryDC_ServiceCategory.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));

                DAOFactory.GenericDAO.Delete(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteServiceCategory(long pOid, long pVersion)
        {
            try
            {
                DeleteServiceCategories(new Dictionary<long, long>
                {
                    {
                        pOid, pVersion
                    }
                });
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteServiceDescription(long pOid, long pVersion)
        {
            try
            {
                DeleteServiceDescriptions(new Dictionary<long, long>
                {
                    {
                        pOid, pVersion
                    }
                });
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteServiceDescriptions(Dictionary<long, long> pOid2Version)
        {
            try
            {
                List<ServiceDescription> lOriginals = DAOFactory.GenericDAO.LoadByIDs<ServiceDescription>(pOid2Version.Select(e => e.Key));
                lOriginals.DoForEach(or => MapperFactory.ServiceDescriptionDC_ServiceDescription.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));

                DAOFactory.GenericDAO.Delete(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteServiceRecord(long pOid, long pVersion)
        {
            try
            {
                DeleteServiceRecords(new Dictionary<long, long>
                {
                    {
                        pOid, pVersion
                    }
                });
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteServiceRecords(Dictionary<long, long> pOid2Version)
        {
            InternalDeleteServicerecords(pOid2Version);
        }

        public static void InternalDeleteServicerecords(IDictionary<long, long> pOid2Version)
        {
            try
            {
                var lOriginals = DAOFactory.GenericDAO.LoadByIDs<ServiceRecord>(pOid2Version.Select(e => e.Key));

                lOriginals.DoForEach(or => MapperFactory.ServiceRecordDC_ServiceRecord.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));

                var srListToDelete = new List<ServiceRecord>();

                foreach (var item in lOriginals)
                {
                    if (item.Group != null)
                    {
                        RemoveServiceRecordsFromConfirmationReceiptSignatureForDeletion(item.Group.ServiceRecordList);

                        DeleteServiceRecordsFromAppointments(item.Group.ServiceRecordList.ToList());

                        DAOFactory.GenericDAO.Delete(item.Group);
                    }
                    else
                    {
                        srListToDelete.Add(item);
                    }
                }

                if (srListToDelete.Count <= 0)
                {
                    return;
                }

                RemoveServiceRecordsFromConfirmationReceiptSignatureForDeletion(srListToDelete);

                DeleteServiceRecordsFromAppointments(srListToDelete);

                DAOFactory.GenericDAO.Delete(srListToDelete);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        private static void DeleteServiceRecordsFromAppointments(List<ServiceRecord> serviceRecords)
        {
            MakeServiceRecordHistoryEntry(serviceRecords, null, StatementType.Delete);

            RemoveServiceRecordsFromConfirmationReceiptSignatures(MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(serviceRecords), DAOFactory.GenericDAO.LoadByIDs<ServiceRecord>(serviceRecords.Select(s => s.Oid.Value)), true);

            var appointmentsToUpdate = DAOFactory.SearchDAO.LoadAppointmentsWithServiceRecords(serviceRecords.Select(s => s.Oid.Value).ToList());

            appointmentsToUpdate.DoForEach(appointment => appointment.ServiceRecordList = appointment.ServiceRecordList.Where(sr => !serviceRecords.Select(s => s.Oid.Value).Contains(sr.Oid.Value)).ToList());

            DAOFactory.GenericDAO.Update(appointmentsToUpdate);
        }

        public Settlement2DC GenerateInitialSettlementDC(long pCostBearer2SupportConceptOid)
        {
            return GenerateInitialSettlementDCForPeriod(pCostBearer2SupportConceptOid, null, null);
        }

        public Settlement2DC GenerateInitialSettlementDCForPeriod(long pCostBearer2SupportConceptOid, DateTime? periodStart, DateTime? periodEnd)
        {
            try
            {
                var lCb2Sc = DAOFactory.GenericDAO.LoadByID<CostBearer2SupportConcept>(pCostBearer2SupportConceptOid);

                var costBearer = lCb2Sc.CostBearer;
                string tenant = null;

                if (MultitenancyOperationContextExt.Current != null)
                {
                    tenant = MultitenancyOperationContextExt.Current.Tenant;
                }

                var factory = PluginLoader.FindClass<InvoiceFactory>(costBearer.ID);

                if (factory == null)
                {
                    factory = InvoiceFactory.GetInstance(costBearer.ID, tenant);
                }

                var creator = factory.CreateSettlementInvoiceCreator(costBearer.ID, tenant, lCb2Sc);

                var lResult = creator.GenerateSettlementInvoice(lCb2Sc, periodStart, periodEnd);

                return lResult;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<Settlement2DC> GenerateInitialSettlementDCsForPeriod(long pCostBearer, DateTime periodStart, DateTime periodEnd)
        {
            return new CustomerServiceImp()
                .GetAllActiveSupportConceptsCompact()
                .Where(i => i.IsApproved && i.CostBearerOids2CostBearerRelOids.ContainsKey(pCostBearer))
                .Select(i => GenerateInitialSettlementDCForPeriod(i.CostBearerOids2CostBearerRelOids[pCostBearer], periodStart, periodEnd))
                .ToList();
        }

        public Settlement2DC GenerateDifferenzSettlementDC(long pCostBearer2SupportConceptOid)
        {
            try
            {
                var newInvoice = GenerateInitialSettlementDC(pCostBearer2SupportConceptOid);

                var existingInvoices = DAOFactory.SearchDAO.GetSettlementInvoiceByCostBearer2SupportConceptOid(pCostBearer2SupportConceptOid);
                if (existingInvoices.Count == 0) //Sollte eigentlich nicht sein
                {
                    return newInvoice;
                }

                var juengsteRechnung = existingInvoices.OrderByDescending(i => i.InvoiceBase.AccountingPeriodEnd).First();
                var acs = PluginLoader.FindClass<AccountingService>();


                return acs.ErstelleDifferenzSpitzabrechnung(newInvoice, MapperFactory.SettlementDC_SettlementInvoice.MapToNewDC(juengsteRechnung));



            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<AccountingTransactionDC> GetAccountingTransactions(DateTimeSpan pSpan, long? pSupportConceptOid, long? pSupportConceptCostBearerRelOid)
        {
            try
            {
                return MapperFactory.AccountingTransactionDC_AccountingTransaction.MapToNewDCs(DAOFactory.SearchDAO.FindAccoutingTransactions(pSpan, pSupportConceptOid, pSupportConceptCostBearerRelOid));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<InvoiceDC> GetAllActiveInvoices()
        {
            try
            {
                return MapperFactory.InvoiceDC_Invoice.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<Invoice>());
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<CompactSupportConceptDC> GetAllActiveSupportConceptCostbearer(bool onlyApproved, bool onlyWithAssignedCostbearer, long employeeOid)
        {
            try
            {
                var s = PluginLoader.FindClass<CustomerService>();

                return s.GetAllActiveSupportConceptCostbearer(onlyApproved, onlyWithAssignedCostbearer, employeeOid);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<AdditionalServiceDC> GetAllAdditionalService()
        {
            try
            {
                IList<AdditionalService> list = DAOFactory.GenericDAO.GetAllActive<AdditionalService>();
                return MapperFactory.AdditionalServiceDC_AdditionalService.MapToNewDCs(list);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<AdditionalServiceRegionDC> GetAllAdditionalServiceRegion()
        {
            try
            {
                var result = new List<AdditionalServiceRegionDC>();

                result =
                    MapperFactory.AdditionalServiceRegionDC_AdditionalServiceRegion.MapToNewDCs(
                        DAOFactory.GenericDAO.GetAllActive<AdditionalServiceRegion>());

                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceCategoryDC> GetAllServiceCategories()
        {
            try
            {
                IList<ServiceCategory> list = DAOFactory.GenericDAO.GetAllActive<ServiceCategory>();
                var dcList = MapperFactory.ServiceCategoryDC_ServiceCategory.MapToNewDCs(list);

                //AppSettings settings = AppSettings.CreateSettings();
                //if (settings.SortServiceDescriptionAlphabetically)
                //{
                //    dcList = dcList.OrderBy(c => c.Name).ToList();
                //}
                //else
                //{
                dcList.Sort((a, b) =>
                {
                    if (a.Position == b.Position)
                    {
                        return a.ServiceCategoryOid.Value.CompareTo(b.ServiceCategoryOid.Value);
                    }
                    else
                    {
                        return a.Position.CompareTo(b.Position);
                    }
                });
                //}

                return dcList;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceDescriptionDC> GetAllServiceDescriptions()
        {
            try
            {
                IList<ServiceDescription> list = DAOFactory.GenericDAO.GetAllActive<ServiceDescription>();

                var dcList = MapperFactory.ServiceDescriptionDC_ServiceDescription.MapToNewDCs(list);

                AppSettings settings = AppSettings.CreateSettings();
                if (settings.SortServiceDescriptionAlphabetically)
                {
                    dcList = dcList.OrderBy(sd => sd.Name).ToList();
                }
                else
                {
                    dcList.Sort((a, b) =>
                    {
                        if (a.Position == b.Position)
                        {
                            return a.ServiceDescriptionOid.Value.CompareTo(b.ServiceDescriptionOid.Value);
                        }
                        else
                        {
                            return a.Position.CompareTo(b.Position);
                        }
                    });
                }

                return dcList;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceDescriptionDC> FindServiceDescriptionsForCategory(long pCategoryOid)
        {
            try
            {
                return MapperFactory.ServiceDescriptionDC_ServiceDescription.MapToNewDCs(DAOFactory.SearchDAO.FindServiceDescriptionForCategory(pCategoryOid));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public ServiceDescriptionDC GetServiceDescription(long pServiceDescriptionOid)
        {
            try
            {
                return MapperFactory.ServiceDescriptionDC_ServiceDescription.MapToNewDC(DAOFactory.GenericDAO.GetByID<ServiceDescription>(pServiceDescriptionOid));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public string GetCompressedICD10Diagnosis()
        {
            try
            {
                return ICD10DAO.GetCompressedString();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public CustomerInfoDC GetCustomerInfosForCustomerOid(long customerOid)
        {
            try
            {
                var result = new CustomerInfoDC();
                var customer = DAOFactory.GenericDAO.LoadByID<Customer>(customerOid);

                if (customer.SupportConcepts == null || !customer.SupportConcepts.Exists(sc => sc.IsActive == ActivationTypeId.Active))
                {
                    result.CurrentSupportConcept = "Kein aktueller Hilfeplan";
                }
                else
                {
                    SupportConcept currentSC = customer.SupportConcepts.Where(sc => sc.IsActive == ActivationTypeId.Active).OrderByDescending(sc => sc.StartDate).First();

                    result.CurrentSupportConcept = "Akt. HP: ";
                    if (currentSC.StartDate.HasValue)
                    {
                        result.CurrentSupportConcept += currentSC.StartDate.Value.ToShortDateString().Remove(6, 2);
                    }

                    if (currentSC.EndDate.HasValue)
                    {
                        result.CurrentSupportConcept += " - " + currentSC.EndDate.Value.ToShortDateString().Remove(6, 2);
                    }

                    result.SupportConceptInfos = GetSupportConceptInfosForSupportConceptOid(currentSC.Oid.Value);
                }

                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceRecordDC> GetCustomerServiceRecordsCompact(long pCustomerOid, long costbearer2SupportConceptOid, long? days)
        {
            try
            {
                var result = new List<ServiceRecordDC>();
                var srList = DAOFactory.SearchDAO.FindServiceRecordsDetailsForLastDays(costbearer2SupportConceptOid, days);

                if (srList != null)
                {
                    var serviceRecordsProcessed = new Dictionary<long, bool>();
                    foreach (var item in srList)
                    {
                        if (!serviceRecordsProcessed.ContainsKey(item.Oid.Value))
                        {
                            //ServiceRecordDC dc = MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDC(item);
                            //result.Add(dc);
                            var dc = CreateServiceRecordDCCompact(item);
                            if (dc != null)
                            {
                                result.Add(dc);
                            }

                            serviceRecordsProcessed.Add(item.Oid.Value, true);
                        }
                    }
                }

                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceRecordDC> GetCustomerServiceRecords(long pCustomerOid, bool fetchArchivedSupportConcepts)
        {
            try
            {
                var result = new List<ServiceRecordDC>();

                var lCustomer = DAOFactory.SearchDAO.FindCustomerWithServiceRecordsWithDetail(pCustomerOid);
                if (lCustomer != null)
                {
                    var srList = lCustomer.ServiceRecordList;

                    if (srList != null)
                    {
                        var serviceRecordsProcessed = new Dictionary<long, bool>();
                        foreach (var item in srList)
                        {
                            if (!serviceRecordsProcessed.ContainsKey(item.Oid.Value))
                            {
                                var dc = CreateServiceRecordDCIfSupportConceptIsActive(item, lCustomer, !fetchArchivedSupportConcepts);
                                if (dc != null)
                                {
                                    result.Add(dc);
                                }

                                serviceRecordsProcessed.Add(item.Oid.Value, true);
                            }
                        }
                    }
                }

                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceRecordDC> GetCustomerServiceRecordsInMonth(long pCustomerOid, DateTime pMonth)
        {
            try
            {
                var list = GetCustomerServiceRecords(pCustomerOid, false);

                return list.Where(i => i.Start.HasValue && i.Start.Value.Year.Equals(pMonth.Year) && i.Start.Value.Month.Equals(pMonth.Month)).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceRecordDC> GetEmployeesServiceRecords(long pEmployeeOid)
        {
            try
            {
                IEnumerable<ServiceRecord> list = DAOFactory.SearchDAO.FindEmployeeServiceRecordsWithoutCustomer(pEmployeeOid, null);

                return MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(list);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceRecordDC> GetEmployeesServiceRecords2(long pEmployeeOid, long? days)
        {
            try
            {
                IEnumerable<ServiceRecord> list = DAOFactory.SearchDAO.FindEmployeeServiceRecordsWithoutCustomer(pEmployeeOid, days);

                return MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(list);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceRecordDC> GetEmployeesServiceRecordsWithStartEndDate(long pEmployeeOid, DateTime start, DateTime ende)
        {
            try
            {
                IEnumerable<ServiceRecord> list = DAOFactory.SearchDAO.FindEmployeeServiceRecordsWithoutCustomerWithStartEndDate(pEmployeeOid, start, ende);

                return MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(list);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceRecordDC> GetCustomerServiceRecordsCompactWithStartEndDate(long pCustomerOid, long costbearer2SupportConceptOid, DateTime start, DateTime ende)
        {
            try
            {
                var result = new List<ServiceRecordDC>();
                var srList = DAOFactory.SearchDAO.FindServiceRecordsDetailsForLastDaysWithStartEndDate(costbearer2SupportConceptOid, start, ende);

                if (srList != null)
                {
                    var serviceRecordsProcessed = new Dictionary<long, bool>();
                    foreach (var item in srList)
                    {
                        if (!serviceRecordsProcessed.ContainsKey(item.Oid.Value))
                        {
                            //ServiceRecordDC dc = MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDC(item);
                            //result.Add(dc);
                            var dc = CreateServiceRecordDCCompact(item);
                            if (dc != null)
                            {
                                result.Add(dc);
                            }

                            serviceRecordsProcessed.Add(item.Oid.Value, true);
                        }
                    }
                }

                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceRecordDC> GetEmployeesServiceRecordsInSpan(long pEmployeeOid, DateTimeSpan limitinDateTimeSpan)
        {
            try
            {
                IEnumerable<ServiceRecord> list = DAOFactory.SearchDAO.FindEmployeeServiceRecordsWithoutCustomerInSpan(pEmployeeOid, limitinDateTimeSpan);

                return MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(list);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<FileAttachmentDC> GetFileAttachments(TableID pObjectTid, long pObjectOid)
        {
            try
            {
                var files = DAOFactory.SearchDAO.FindFileAttachmentInfos(pObjectTid, pObjectOid).ToList();

                var fileAttachments = files.Select(item => MapperFactory.FileAttachmentDC_FileAttachmentInfo.MapToNewDC(item)).ToList();

                fileAttachments.DoForEach(fileAttachment =>
                {
                    if (fileAttachment.BinaryData != null)
                    {
                        return;
                    }

                    fileAttachment.BinaryData = FileAttachmentUtils.LoadFileFromDirectory(fileAttachment.FileAttachmentOid);
                });

                return fileAttachments;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<BeWoFolderDC> GetFolderTree(TableID pObjectTid, long pObjectOid)
        {
            try
            {
                return DokumentManager.GetFolderTree(pObjectTid, pObjectOid);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteFolder(long pBeWoFolderOid, long pVersion)
        {
            try
            {
                DokumentManager.DeleteFolder(pBeWoFolderOid, pVersion);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public long InsertNewFolder(BeWoFolderDC folder)
        {
            try
            {
                return DokumentManager.InsertNewFolder(folder);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public BeWoFolderDC UpdateFolder(BeWoFolderDC folder)
        {
            try
            {
                return DokumentManager.UpdateFolder(folder);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public FileAttachmentDC UpdateFileAttachment(FileAttachmentDC file)
        {
            try
            {
                return DokumentManager.UpdateFileAttachment(file);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public FileAttachmentDC DoTheRealFileUpdate(FileAttachmentDC file)
        {
            try
            {
                return DokumentManager.DoTheRealFileUpdate(file);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public MandatorDC GetMandator()
        {
            return GetMandator2(true);
        }

        public MandatorDC GetMandator2(bool fetchContractState)
        {
            try
            {
                Mandator man = GetMandatorEntity();
                MandatorDC manDc = MapperFactory.MandatorDC_Mandator.MapToNewDC(man);

                Dictionary<string, string> settingValueDict = GetSettingsValueDict(manDc.Settings);

                if (fetchContractState)
                {
                    string contractState = GetContractState();
                    if (!String.IsNullOrEmpty(contractState) && contractState == "Fehler")
                    {
                        contractState = man.LastModules;
                    }
                    else
                    {
                        if (contractState != man.LastModules)
                        {
                            man.LastModules = contractState;
                            DAOFactory.GenericDAO.Update(man);
                        }
                    }
                    Dictionary<string, string> contractStateDict = GetSettingsValueDict(contractState);

                    foreach (var kv in contractStateDict)
                    {
                        if (settingValueDict.ContainsKey(kv.Key))
                        {
                            settingValueDict.Remove(kv.Key);
                        }

                        settingValueDict.Add(kv.Key, kv.Value);
                    }
                }

                if (!settingValueDict.ContainsKey("Arbeitszeiterfassung") && settingValueDict.ContainsKey("ShowWorktime"))
                {
                    if (settingValueDict["ShowWorktime"] != "0")
                    {
                        settingValueDict.Add("Arbeitszeiterfassung", "1");
                    }
                }

                if (!settingValueDict.ContainsKey("ShowScheduler") && man.IsSchedulerAllowed)
                {
                    settingValueDict.Add("ShowScheduler", "1");
                }

                if (!settingValueDict.ContainsKey("ShowMedication") && man.IsMedicationAllowed)
                {
                    settingValueDict.Add("ShowMedication", "1");
                }

                if (!settingValueDict.ContainsKey("ShowDistanceFields") && settingValueDict.ContainsKey("ShowKilometer"))
                {
                    if (settingValueDict["ShowKilometer"] != "0")
                    {
                        settingValueDict.Add("ShowDistanceFields", "1");
                    }
                }
                if (!settingValueDict.ContainsKey("EinheitZeiterfassung") && settingValueDict.ContainsKey("IsZeiterfassungInStdMin"))
                {
                    if (settingValueDict["IsZeiterfassungInStdMin"] == "1")
                    {
                        settingValueDict.Add("EinheitZeiterfassung", "2");
                    }
                }

                if (!settingValueDict.ContainsKey("FilterGroupServiceCategories"))
                {
                    settingValueDict.Add("FilterGroupServiceCategories", "0");
                }

                manDc.Settings = "";


                foreach (var kv in settingValueDict)
                {
                    if (manDc.Settings.Length > 0)
                    {
                        manDc.Settings += ";";
                    }

                    manDc.Settings += String.Format("{0}={1}", kv.Key, kv.Value);
                }

                return manDc;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceRecordHistoryDC> GetServiceRecordHistory(long serviceRecordOid)
        {
            try
            {
                IEnumerable<ServiceRecordHistory> historyList = DAOFactory.SearchDAO.FindServiceRecordHistory(serviceRecordOid);

                List<ServiceRecordHistoryDC> result = MapperFactory.ServiceRecordHistoryDC_ServiceRecordHistory.MapToNewDCs(historyList);
                foreach (var srh in result)
                {
                    if (srh.DurationInStunden.HasValue && srh.DurationInStunden.Value == ZeiterfassungsDauer.Stunden)
                    {
                        srh.RoundedDuration = srh.RoundedDuration / 60;
                    }
                }
                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public ServiceRecordGroupDC GetServiceRecordGroup(long pGroupOid)
        {
            try
            {
                ServiceRecordGroup group = DAOFactory.SearchDAO.FindServiceRecordGroup(pGroupOid);

                ServiceRecordGroupDC groupDC = MapperFactory.ServiceRecordGroupDC_ServiceRecordGroup.MapToNewDC(group);

                var result = new List<ServiceRecordDC>();

                var serviceRecordsProcessed = new Dictionary<long, bool>();
                foreach (ServiceRecord item in group.ServiceRecordList)
                {
                    if (!serviceRecordsProcessed.ContainsKey(item.Oid.Value))
                    {
                        var dc = new ServiceRecordDC();

                        dc.ServiceRecordOid = item.Oid;
                        dc.ServiceRecordVersion = item.Version;
                        dc.Start = item.Start;
                        dc.End = item.End;
                        dc.Notice = item.Notice;
                        dc.Notice2 = item.Notice2;
                        dc.Notice3 = item.Notice3;
                        dc.Notice4 = item.Notice4;
                        dc.Notice5 = item.Notice5;
                        dc.RoundedDuration = item.RoundedDuration;
                        dc.InsertedOn = item.InsTs;
                        dc.InsUser = item.InsUser;

                        dc.DurationInStunden = item.DurationInStunden;
                        dc.ServiceRecordFormat = item.ServiceRecordFormat;

                        CompactCustomerDC customerDC = null;
                        if (item.Customer != null)
                        {
                            customerDC = new CompactCustomerDC();

                            customerDC.CustomerOid = item.Customer.Oid.Value;
                            customerDC.CustomerVersion = item.Customer.Version.Value;
                            customerDC.FirstName = item.Customer.Person.FirstName;
                            customerDC.LastName = item.Customer.Person.LastName;
                            customerDC.DateOfBirth = item.Customer.Person.DateOfBirth;
                            customerDC.Sex = item.Customer.Person.Sex;
                            customerDC.ActivationType = item.Customer.IsActive;
                            customerDC.TerminationDate = item.Customer.TerminationDate;
                            customerDC.EquityContribution = item.Customer.EquityContribution;
                        }

                        dc.Customer = customerDC;
                        if (item.Employee != null)
                        {
                            var employeeDC = new CompactEmployeeDC();

                            employeeDC.EmployeeOid = item.Employee.Oid.Value;
                            employeeDC.EmployeeVersion = item.Employee.Version.Value;
                            employeeDC.FirstName = item.Employee.Person.FirstName;
                            employeeDC.LastName = item.Employee.Person.LastName;
                            employeeDC.PersonnelNumber = item.Employee.PersonnelNumber;
                            //employeeDC.FLSPerWeek = item.Employee.WeeklyFLS;

                            dc.Employee = employeeDC;
                        }

                        CompactSupportConceptDC scDC = null;
                        if (item.SupportConcept != null)
                        {
                            scDC = new CompactSupportConceptDC();

                            scDC.SupportConceptOid = item.SupportConcept.Oid.Value;
                            scDC.SupportConceptVersion = item.SupportConcept.Version.Value;
                            scDC.Customer = customerDC;
                            scDC.ActivationType = item.SupportConcept.IsActive;
                            scDC.ConferenceDate = item.SupportConcept.ConferenceDate;
                        }

                        dc.SupportConcept = scDC;

                        CostBearer2SupportConcept cb2sc = item.CostBearer2SupportConcept;
                        if (cb2sc != null)
                        {
                            dc.CostBearer2SupportConceptOid = cb2sc.Oid.Value;

                            if (scDC != null)
                            {
                                var costBearer = new CompactCostBearerDC();

                                costBearer.IsCalculatingWithFactor = cb2sc.CostBearer.IsCalculatingWithFactor;
                                costBearer.CostBearerID = cb2sc.CostBearer.ID;
                                costBearer.CostBearerOid = cb2sc.CostBearer.Oid.Value;
                                costBearer.CostBearer2SupportConceptOid = cb2sc.Oid.Value;
                                costBearer.SupportConceptStatus = cb2sc.Status;
                                costBearer.RequestedStartDate = cb2sc.RequestedStartDate;
                                costBearer.RequestedEndDate = cb2sc.RequestedEndDate;
                                costBearer.ApprovedStartDate = cb2sc.ApprovedStartDate;
                                costBearer.ApprovedEndDate = cb2sc.ApprovedEndDate;

                                // costBearer.ApprovedFLS = cb2sc.ApprovedFLS;
                                // costBearer.ApprovedFLSTotal = cb2sc.ApprovedFLSTotal;
                                costBearer.CustomerReferenceNumber = cb2sc.CustomerReferenceNumber;

                                if (cb2sc.CostBearer.Organisation != null)
                                {
                                    CompactOrganisationDC orgDC = MapperFactory.CompactOrganisationDC_Organisation.MapToNewDC(cb2sc.CostBearer.Organisation);

                                    costBearer.Organisation = orgDC;

                                    dc.CostBearer = orgDC;
                                }

                                scDC.CostBearerList.Add(costBearer);
                                scDC.CustomerReferenceNumbers.Add(cb2sc.CustomerReferenceNumber);
                                scDC.CostBearerRelOids.Add(cb2sc.Oid.Value);
                            }
                        }

                        dc.GroupEmployeeCount = item.GroupEmployeeCount;
                        dc.GroupPersonCount = item.GroupPersonCount;
                        dc.GroupRoundedDuration = item.GroupRoundedDuration;
                        dc.GroupOid = item.GroupOid;
                        dc.SignatureOid = item.SignatureOid;

                        result.Add(dc);

                        serviceRecordsProcessed.Add(item.Oid.Value, true);
                    }
                }

                groupDC.ServiceRecordList = result;

                return groupDC;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public long GetLastServiceRecordGroupOid()
        {
            var sc = DAOFactory.GenericDAO.GetAllActiveAndArchived<ServiceRecordGroup>();

            long x = sc.Last().Oid.Value;

            return x;
        }

        public List<SupportConcetInfoDC> GetSupportConceptInfosForSupportConceptOid(long supportConceptOid)
        {
            try
            {
                var sc = DAOFactory.GenericDAO.LoadByID<SupportConcept>(supportConceptOid);
                return sc.CostBearer2SupportConceptList.Select(
                    cb2sc =>
                    {
                        Calculations calc = PluginLoader.FindClass<Calculations>(cb2sc.CostBearer.ID) ?? Calculations.GetInstance(cb2sc.CostBearer.ID);
                        var res = new SupportConcetInfoDC
                        {
                            CostBearer = cb2sc.CostBearer.Organisation.Name,
                            ApprovedHours = calc.GetApprovedHoursTotal(cb2sc.MapToNewDC(), true) ?? 0m,
                            RecordedHours = calc.GetBillableDurationInMinutes(cb2sc.ServiceRecords.MapToNewDCsCompact()) / 60
                        };

                        // if (cb2sc.ApprovedStartDate.HasValue && cb2sc.ApprovedEndDate.HasValue)
                        // {
                        // decimal lDurationInWeeks = Convert.ToDecimal((cb2sc.ApprovedEndDate.Value - cb2sc.ApprovedStartDate.Value).Days + 1) / 7;

                        // if (cb2sc.ApprovedFLSTotal == null)
                        // {
                        // if (cb2sc.ApprovedFLS.HasValue)
                        // {
                        // res.ApprovedHours = cb2sc.ApprovedFLS.Value * lDurationInWeeks;
                        // }
                        // }
                        // else
                        // {
                        // res.ApprovedHours = cb2sc.ApprovedFLSTotal.Value;
                        // }
                        // }

                        // res.RecordedHours = 0;
                        // if (cb2sc.ServiceRecords != null)
                        // {
                        // foreach (var sr in cb2sc.ServiceRecords)
                        // {
                        // if (sr.ServiceDescription != null && sr.ServiceDescription.ServiceCategory != null && sr.ServiceDescription.ServiceCategory.IsBillable)
                        // {
                        // decimal rd = sr.RoundedDuration;

                        // if (sr.ServiceDescription.ServiceCategory.Percentage != 100)
                        // {
                        // rd = (rd * sr.ServiceDescription.ServiceCategory.Percentage) / 100;
                        // }

                        // res.RecordedHours += rd;
                        // }
                        // }
                        // }

                        // res.RecordedHours /= 60;
                        return res;
                    }).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<SupportConceptTreeNodeDC> GetSupportConceptTreeAllActive()
        {
            try
            {
                return BuildTree(DAOFactory.GenericDAO.GetAllActiveAndArchived<SupportConcept>());
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<SupportConceptTreeNodeDC> GetSupportConceptTreeAllActiveWithCostbearer()
        {
            try
            {
                return BuildTree(DAOFactory.GenericDAO.GetAllActive<SupportConcept>().Where(sc => sc.CostBearer2SupportConceptList.Count > 0));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<SupportConceptTreeNodeDC> GetSupportConceptTreeAllCurrent()
        {
            try
            {
                return BuildTree(DAOFactory.SearchDAO.FindCurrentSupportConcepts());
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<SupportConceptTreeNodeDC> GetSupportConceptTreeByEmployee(long pEmployeeOid)
        {
            try
            {
                var s = PluginLoader.FindClass<CustomerService>();

                return s.GetSupportConceptTreeByEmployee(pEmployeeOid);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<SupportConceptTreeNodeDC> GetSupportConceptTreeInSpan(DateTimeSpan pSpan)
        {
            try
            {
                return BuildTree(DAOFactory.SearchDAO.FindSupportConceptsInSpan(pSpan));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public SupportConceptTreeNodeDetailInfoDC GetSupportConceptTreeNodeDetailInfo(long pCustomerOid, long? pSupportConceptOid, long? pCostbearer2SupportConceptOid)
        {
            try
            {
                var dc = new SupportConceptTreeNodeDetailInfoDC();

                if (pCustomerOid > 0)
                {
                    var customer = DAOFactory.GenericDAO.LoadByID<Customer>(pCustomerOid);

                    dc.CustomerAbsenceTimes = MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDCs(customer.AbsenceTimes);
                }
                if (pSupportConceptOid != null)
                {
                    var sc = DAOFactory.GenericDAO.LoadByID<SupportConcept>(pSupportConceptOid.Value);

                    var list = new List<ValueListEntryType>();
                    list.Add(ValueListEntryType.SupportConceptGoalType);
                    list.Add(ValueListEntryType.SupportConceptGoalCategoryType);
                    list.Add(ValueListEntryType.SupportConceptIndividualGoalCategoryType);
                    list.Add(ValueListEntryType.SupportConceptIndividualGoalType);

                    dc.SupportConceptGoals =
                        MapperFactory.ValueListEntryDC_ValueListEntry.MapToNewDCs(
                            sc.ValueList.FindByTypes(list)
                                .Select(e2o => e2o.Entry)
                                .Where(e => e.IsActive == ActivationTypeId.Active));

                    dc.ServiceAccountings = MapperFactory.ServiceAccountingDC_ServiceAccounting.MapToNewDCs(sc.ServiceAccountings);
                }

                if (pCostbearer2SupportConceptOid != null)
                {
                    var c2s = DAOFactory.GenericDAO.LoadByID<CostBearer2SupportConcept>(pCostbearer2SupportConceptOid.Value);
                    dc.ApprovalPeriods = MapperFactory.SupportConceptApprovalPeriodDC_SupportConceptApprovalPeriod.MapToNewDCs(c2s.ApprovalPeriodList);
                    if (dc.ApprovalPeriods != null)
                    {
                        foreach (SupportConceptApprovalPeriodDC item in dc.ApprovalPeriods)
                        {
                            if (!item.StartDate.HasValue)
                            {
                                item.StartDate = c2s.ApprovedStartDate.HasValue ? c2s.ApprovedStartDate : c2s.RequestedStartDate;
                            }

                            if (!item.EndDate.HasValue)
                            {
                                item.EndDate = c2s.ApprovedEndDate.HasValue ? c2s.ApprovedEndDate : c2s.RequestedEndDate;
                            }
                        }
                    }
                }

                return dc;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<SupportConceptTreeNodeDetailInfoDC> GetSupportConceptTreeNodeDetailInfos(List<long> supportConceptOids)
        {
            try
            {
                var result = new List<SupportConceptTreeNodeDetailInfoDC>();

                if (supportConceptOids.Count > 0)
                {
                    var scList = DAOFactory.GenericDAO.LoadByIDs<SupportConcept>(supportConceptOids);

                    foreach (var sc in scList)
                    {
                        var list = new List<ValueListEntryType>();
                        list.Add(ValueListEntryType.SupportConceptGoalType);
                        list.Add(ValueListEntryType.SupportConceptGoalCategoryType);
                        list.Add(ValueListEntryType.SupportConceptIndividualGoalCategoryType);
                        list.Add(ValueListEntryType.SupportConceptIndividualGoalType);

                        var dc = new SupportConceptTreeNodeDetailInfoDC
                        {
                            SupportConceptGoals = MapperFactory.ValueListEntryDC_ValueListEntry.MapToNewDCs(
                                sc.ValueList.FindByTypes(list)
                                    .Select(e2o => e2o.Entry)
                                    .Where(e => e.IsActive == ActivationTypeId.Active)),
                            ServiceAccountings = MapperFactory.ServiceAccountingDC_ServiceAccounting.MapToNewDCs(sc.ServiceAccountings),
                        };

                        if(sc.Customer?.Oid.HasValue ?? false)
                        {
                            dc.CustomerOid = sc.Customer.Oid.Value;
                        }

                        if(sc.Oid.HasValue)
                        {
                            dc.SupportConceptOid = sc.Oid.Value;
                        }

                        result.Add(dc);
                    }
                }
                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public CompactOrganisationDC FillCostbearerDetails(CompactOrganisationDC dc)
        {
            try
            {
                if (dc.CostRatePeriods == null || dc.CostRatePeriods.Count == 0)
                {
                    var org = DAOFactory.GenericDAO.LoadByID<Organisation>(dc.OrganisationOid);
                    if (org != null)
                    {
                        MapperFactory.CompactOrganisationDC_Organisation.MergeWithDC(org, dc);
                    }
                }

                return dc;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<AccountingTransactionDC> GetUnassignedAccountingTransactions()
        {
            try
            {
                IEnumerable<AccountingTransaction> list = DAOFactory.SearchDAO.FindUnassignedAccountingTransactions();

                return MapperFactory.AccountingTransactionDC_AccountingTransaction.MapToNewDCs(list);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<VarFieldDC> GetVarFieldDefs(TableID tid)
        {
            try
            {
                return MapperFactory.VarFieldDC_VarField.VarFieldMapToDCs(DAOFactory.SearchDAO.GetVarFieldDefs(tid), null);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<long> InsertNewAccountingTransactions(List<AccountingTransactionDC> pAccountingTransactions)
        {
            try
            {
                foreach (var at in pAccountingTransactions)
                {
                    if (at.SupportConceptCostBearerRelDC != null && at.SupportConceptCostBearerRelDC.CostBearer2SupportConceptOid.HasValue && !at.SupportConceptCostBearerRelDC.CostBearer2SupportConceptVersion.HasValue)
                    {
                        var c2s = DAOFactory.GenericDAO.LoadByID<CostBearer2SupportConcept>(at.SupportConceptCostBearerRelDC.CostBearer2SupportConceptOid.Value);
                        var c2sDc = MapperFactory.SupportConceptCostBearerRelDC_CostBearer2SupportConcept.MapToNewDC(c2s);
                        at.SupportConceptCostBearerRelDC = c2sDc;
                    }

                }

                List<AccountingTransaction> lEntities = MapperFactory.AccountingTransactionDC_AccountingTransaction.MapToNewEntities(pAccountingTransactions);
                DAOFactory.GenericDAO.Insert(lEntities);
                return lEntities.Select(e => e.Oid.Value).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void InsertNewInvoices(List<InvoiceDC> pInvoices)
        {
            try
            {
                DAOFactory.GenericDAO.Insert(MapperFactory.InvoiceDC_Invoice.MapToNewEntities(pInvoices));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<long> InsertNewServiceCategories(List<ServiceCategoryDC> pServiceCategories)
        {
            try
            {
                List<ServiceCategory> lServiceCategories = MapperFactory.ServiceCategoryDC_ServiceCategory.MapToNewEntities(pServiceCategories);
                DAOFactory.GenericDAO.Insert(lServiceCategories);
                return lServiceCategories.Select(sc => sc.Oid.Value).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<long> InsertNewAdditionalServices(IEnumerable<AdditionalServiceDC> pAdditionalServiceDcs)
        {
            try
            {
                List<AdditionalService> lAdditionalServices = MapperFactory.AdditionalServiceDC_AdditionalService.MapToNewEntities(pAdditionalServiceDcs);
                DAOFactory.GenericDAO.Insert(lAdditionalServices);
                return lAdditionalServices.Select(ads => ads.Oid.Value).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<long> InsertNewServiceDescriptions(List<ServiceDescriptionDC> pServiceDescriptions)
        {
            try
            {
                List<ServiceDescription> lServiceDescriptions = MapperFactory.ServiceDescriptionDC_ServiceDescription.MapToNewEntities(pServiceDescriptions);
                DAOFactory.GenericDAO.Insert(lServiceDescriptions);
                IList<SupportConcept> scToSave = new List<SupportConcept>();
                //Prüfe ob es HPs gibt wo die Leistung hinterlegt werden muss

                IList<long> newServiceDescriptionOids = new List<long>();
                foreach (ServiceDescription newSd in lServiceDescriptions)
                {
                    newServiceDescriptionOids.Add(newSd.Oid.Value);
                }

                foreach (ServiceDescription newSd in lServiceDescriptions)
                {
                    ServiceCategory cat = newSd.ServiceCategory;

                    IEnumerable<ServiceDescription> descList = DAOFactory.SearchDAO.FindServiceDescriptionForCategory(cat.Oid.Value);

                    IList<long> oids = new List<long>();
                    foreach (ServiceDescription oldSd in descList)
                    {
                        if (!newServiceDescriptionOids.Contains(oldSd.Oid.Value))
                        {
                            oids.Add(oldSd.Oid.Value);
                        }
                    }

                    //Prüfe für alle Leistungen dieser Kategorie, ob sie im Hilfeplan angehakt wurden
                    IEnumerable<ServiceAccounting> accountingList = DAOFactory.SearchDAO.FindServiceAccountingsForServiceDescriptions(oids);

                    var supportConceptCountDict = new Dictionary<long, int>();
                    foreach (ServiceAccounting acc in accountingList)
                    {
                        if (acc.SupportConceptOid.HasValue)
                        {
                            if (supportConceptCountDict.ContainsKey(acc.SupportConceptOid.Value))
                            {
                                supportConceptCountDict[acc.SupportConceptOid.Value]++;
                            }
                            else
                            {
                                supportConceptCountDict.Add(acc.SupportConceptOid.Value, 1);
                            }
                        }
                    }

                    IList<long> supportConceptToUpdateOids = new List<long>();
                    foreach (var pair in supportConceptCountDict)
                    {
                        if (pair.Value == oids.Count)
                        {
                            //Wenn es für alle alten Leistungen eine ServiceAccounting gibt, füge die neue Leistung auch hinzu
                            supportConceptToUpdateOids.Add(pair.Key);
                        }
                    }

                    foreach (long scOid in supportConceptToUpdateOids)
                    {
                        var sc = DAOFactory.GenericDAO.LoadByID<SupportConcept>(scOid);
                        var newSa = new ServiceAccounting();
                        newSa.ServiceDescription = newSd;

                        sc.ServiceAccountings.Add(newSa);

                        scToSave.Add(sc);
                    }
                }

                if (scToSave.Count > 0)
                {
                    DAOFactory.GenericDAO.Insert(scToSave);
                }


                return lServiceDescriptions.Select(sd => sd.Oid.Value).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<long> InsertNewAdditionalServiceRegions(List<AdditionalServiceRegionDC> pAdditionalServiceRegions)
        {
            try
            {
                List<AdditionalServiceRegion> lAdditionalServiceRegions = MapperFactory.AdditionalServiceRegionDC_AdditionalServiceRegion.MapToNewEntities(pAdditionalServiceRegions);
                DAOFactory.GenericDAO.Insert(lAdditionalServiceRegions);
                return lAdditionalServiceRegions.Select(asr => asr.Oid.Value).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public long InsertNewAdditionalServiceRegion(AdditionalServiceRegionDC pAdditionalServiceRegionDC)
        {
            try
            {
                AdditionalServiceRegion lAdditionalServiceRegion = MapperFactory.AdditionalServiceRegionDC_AdditionalServiceRegion.MapToNewEntity(pAdditionalServiceRegionDC);
                DAOFactory.GenericDAO.Insert(lAdditionalServiceRegion);
                return lAdditionalServiceRegion.Oid.Value;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public AdditionalServiceRegionDC GetAdditionalServiceRegion(long pRegionOid)
        {
            try
            {
                return MapperFactory.AdditionalServiceRegionDC_AdditionalServiceRegion.MapToNewDC(DAOFactory.GenericDAO.GetByID<AdditionalServiceRegion>(pRegionOid));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public ServiceRecordGroupDC InsertNewServiceRecordGroup(ServiceRecordGroupDC pServiceRecordGroup)
        {
            try
            {
                var group = MapperFactory.ServiceRecordGroupDC_ServiceRecordGroup.MapToNewEntity(pServiceRecordGroup);
                var lServiceRecords = new List<ServiceRecord>();

                if (pServiceRecordGroup.ServiceRecordList != null && pServiceRecordGroup.ServiceRecordList.Count > 0)
                {
                    lServiceRecords = MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewEntities(pServiceRecordGroup.ServiceRecordList);

                    foreach (var iServiceRecord in lServiceRecords)
                    {
                        if (!group.StartDate.HasValue && group.EndDate.HasValue)
                        {
                            group.StartDate = group.EndDate.Value.AddMinutes((double)group.RoundedDuration * -1);
                        }

                        if (group.StartDate.HasValue && group.EndDate.HasValue)
                        {
                            //Korrigieren
                            if (group.StartDate.Value == group.EndDate.Value)
                            {
                                if (iServiceRecord.RoundedDuration > 0)
                                {
                                    group.EndDate = group.StartDate.Value.AddMinutes((double)iServiceRecord.RoundedDuration);
                                }
                            }
                        }

                        if (group.StartDate.HasValue)
                        {
                            iServiceRecord.Start = group.StartDate;
                        }

                        if (group.EndDate.HasValue)
                        {
                            iServiceRecord.End = group.EndDate;
                        }

                        //if(group.RoundedDuration == 0)
                        //{
                        if (group.EndDate.HasValue && group.StartDate.HasValue)
                        {
                            var minutes = group.EndDate.Value.Subtract(group.StartDate.Value).TotalMinutes;

                            group.RoundedDuration = (decimal)minutes;
                        }
                        //}

                        //if(!iServiceRecord.GroupRoundedDuration.HasValue || iServiceRecord.GroupRoundedDuration.Value == 0)
                        //{
                        iServiceRecord.GroupRoundedDuration = group.RoundedDuration;
                        //}

                        if (iServiceRecord.IP == null)
                        {
                            iServiceRecord.IP = Utils.GetClientIP();
                        }

                        // iServiceRecord.Group = group;
                    }

                    group.ServiceRecordList = lServiceRecords;


                    var gdc = PluginLoader.FindClass<GroupDurationCalculator>();

                    gdc?.CalculateGroupDuration(@group);
                }

                DAOFactory.GenericDAO.Insert(group);

                if (lServiceRecords.Count > 0)
                {
                    MakeServiceRecordHistoryEntry(lServiceRecords, lServiceRecords.Select(sr => sr.Oid.Value).ToList(), StatementType.Insert);
                }

                var newGroupDC = MapperFactory.ServiceRecordGroupDC_ServiceRecordGroup.MapToNewDC(group);

                newGroupDC.ServiceRecordList = MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(group.ServiceRecordList);

                return newGroupDC;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteAdditionalServiceGroupOfPeopleRelation(long pOid, long pVersion)
        {
            try
            {
                DeleteAdditionalServiceGroupOfPeopleRelations(new Dictionary<long, long> { { pOid, pVersion } });
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteAdditionalServiceBookings(Dictionary<long, long> pOid2Version)
        {
            try
            {
                List<AdditionalServiceBooking> lOriginals =
                    DAOFactory.GenericDAO.LoadByIDs<AdditionalServiceBooking>(pOid2Version.Select(e => e.Key));
                lOriginals.DoForEach(or => MapperFactory.AdditionalServiceBookingDC_AdditionalServiceBooking.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));

                List<AdditionalServiceBooking> asbListToDelete = lOriginals.ToList();
                if (asbListToDelete.Count <= 0)
                    return;

                DAOFactory.GenericDAO.Delete(asbListToDelete);

                IList<AssessmentSheetEntry> allEntries = DAOFactory.GenericDAO.GetAll<AssessmentSheetEntry>();
                var entries2Delete = new List<AssessmentSheetEntry>();

                foreach (AdditionalServiceBooking item in lOriginals)
                {
                    entries2Delete.AddRange(allEntries.Where(e => pOid2Version.ContainsKey(e.Customer.Oid.Value) &&
                                                                  e.Day.Equals(item.Datum.Value) &&
                                                                  e.SystemEntryID.Equals(SystemEntryID.AdditionalServiceAssessmentSheet)).ToList());
                }

                DAOFactory.GenericDAO.Delete(entries2Delete);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void RemoveAdditionalServiceCustomer(List<long> customerOids, long? regionOid, DateTime monat)
        {
            try
            {
                foreach (var oid in customerOids)
                {
                    var bookings = DAOFactory.SearchDAO.GetAdditionalServiceBookingsForCustomer(oid, monat, monat.AddMonths(1).AddDays(-1));



                    foreach (var item in bookings)
                    {
                        if (item.AdditionalServiceRegion != null && item.AdditionalServiceRegion.Oid == regionOid)
                        {
                            var entries2Delete = new List<Customer2AddServiceBooking>();
                            foreach (var c2a in item.Customer2AddServiceBookings)
                            {
                                if (c2a.CustomerOid == oid)
                                {
                                    entries2Delete.Add(c2a);
                                }
                            }
                            item.Customer2AddServiceBookings.RemoveRange(entries2Delete);
                            DAOFactory.GenericDAO.Update(item);
                        }
                    }



                }


            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateAdditionalServiceGroupOfPeopleRelations(List<AdditionalServiceGroupOfPeopleRelationDC> pAdditionalServiceGroupOfPeopleRelations)
        {
            try
            {
                List<AdditionalService2GroupOfPeople> lOriginals = DAOFactory.GenericDAO.LoadByIDs<AdditionalService2GroupOfPeople>(pAdditionalServiceGroupOfPeopleRelations.Select(dc => dc.AdditionalService2GroupOfPeopleOid.Value));
                MapperFactory.AdditionalServiceGroupOfPeopleRelationDC_AdditionalService2GroupOfPeople.MergeWithEntitys(pAdditionalServiceGroupOfPeopleRelations, lOriginals);
                DAOFactory.GenericDAO.Update(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateAdditionalServiceBookings(List<AdditionalServiceBookingDC> pAdditionalServiceBookings)
        {
            try
            {
                //Bugfix: die AdditionalServiceBookingList enthält manchmal mehrere Objekte mit gleicher OID

                //var distinctDcs = pAdditionalServiceBookings.Distinct().ToList();
                var distinctDcs = new List<AdditionalServiceBookingDC>();
                var dict = new Dictionary<long, bool>();

                foreach (var item in pAdditionalServiceBookings)
                {
                    if (!item.AdditionalServiceBookingOid.HasValue)
                    {
                        distinctDcs.Add(item);
                    }
                    else if (!dict.ContainsKey(item.AdditionalServiceBookingOid.Value))
                    {
                        distinctDcs.Add(item);
                        dict.Add(item.AdditionalServiceBookingOid.Value, true);
                    }
                }

                List<AdditionalServiceBooking> lOriginals = DAOFactory.GenericDAO.LoadByIDs<AdditionalServiceBooking>(distinctDcs.Select(dc => dc.AdditionalServiceBookingOid.Value));
                MapperFactory.AdditionalServiceBookingDC_AdditionalServiceBooking.MergeWithEntitys(distinctDcs, lOriginals);
                DAOFactory.GenericDAO.Update(lOriginals);

                var entries2Update = new List<AssessmentSheetEntry>();
                var entries2Delete = new List<AssessmentSheetEntry>();
                var newEntries = new List<AssessmentSheetEntry>();

                IList<AssessmentSheetValue> avList = DAOFactory.GenericDAO.GetAll<AssessmentSheetValue>();

                AssessmentSheetValue yes = avList.First(v => !String.IsNullOrEmpty(v.Description) && v.Description.Equals("Ja") &&
                                                             v.SystemEntryID.Equals(SystemEntryID.AdditionalServiceAssessmentSheet));

                //var no = avList.First(v => !String.IsNullOrEmpty(v.Description) && v.Description.Equals("Nein") &&
                //                                                                    v.SystemEntryID.Equals(SystemEntryID.AdditionalServiceAssessmentSheet));

                foreach (AdditionalServiceBooking item in lOriginals)
                {
                    IEnumerable<AssessmentSheetEntry> list = DAOFactory.SearchDAO.GetAdditionalAssessmentSheetEntries(item.Datum.Value);

                    IEnumerable<AssessmentSheetEntry> list2 = list.Where(e => !String.IsNullOrEmpty(e.AssessmentSheetCategory.Description) &&
                                                                              e.AssessmentSheetCategory.Description.Equals(item.AdditionalServiceRegion.AdditionalService.Name) &&
                                                                              item.Customer2AddServiceBookings.Exists(c2a => c2a.CustomerOid == e.Customer.Oid));

                    entries2Update.AddRange(list2);

                    foreach (Customer2AddServiceBooking c2a in item.Customer2AddServiceBookings)
                    {
                        bool containsEntry = false;

                        foreach (AssessmentSheetEntry entry in entries2Update)
                        {
                            if (entry.Customer.Oid == null)
                                continue;
                            if (entry.Customer.Oid.Value.Equals(c2a.CustomerOid))
                            {
                                containsEntry = true;
                                if (c2a.Participated)
                                    entry.AssessmentSheetValue = yes;
                                else
                                    entries2Delete.Add(entry);
                            }
                        }

                        if (c2a.Participated && !containsEntry)
                        {
                            AssessmentSheetCategory cat =
                                DAOFactory.SearchDAO.GetAddServiceAssessmentSheetCategoryWithName(
                                    item.AdditionalServiceRegion.AdditionalService.Name);
                            if (cat != null)
                            {
                                newEntries.Add(new AssessmentSheetEntry
                                {
                                    Customer = DAOFactory.GenericDAO.GetByID<Customer>(c2a.CustomerOid),
                                    AssessmentSheetCategory = cat,
                                    AssessmentSheetValue = yes,
                                    SystemEntryID = SystemEntryID.AdditionalServiceAssessmentSheet,
                                    Day = item.Datum.Value
                                });
                            }
                        }
                    }
                }

                entries2Update.RemoveRange(entries2Delete);

                DAOFactory.GenericDAO.Update(entries2Update);
                DAOFactory.GenericDAO.Delete(entries2Delete);
                DAOFactory.GenericDAO.Insert(newEntries);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public bool AssessmentSheetEntryBelongsToAddServices(long assessmentSheetCategoryOid)
        {
            var lOriginal = DAOFactory.GenericDAO.GetByID<AssessmentSheetCategory>(assessmentSheetCategoryOid);
            IList<AdditionalService> services = DAOFactory.GenericDAO.GetAll<AdditionalService>();

            bool result = lOriginal.SystemEntryID.Equals(SystemEntryID.AdditionalServiceAssessmentSheet) && services.Count(e => e.Name.Equals(lOriginal.Description)) > 0;

            return result;
        }

        public AdditionalServiceGroupOfPeopleDC UpdateAdditionalServiceGroupOfPeople(AdditionalServiceGroupOfPeopleDC pAdditionalServiceGroupOfPeople)
        {
            try
            {
                var lOriginal =
                    DAOFactory.GenericDAO.LoadByID<AdditionalServiceGroupOfPeople>(
                        pAdditionalServiceGroupOfPeople.AdditionalServiceGroupOfPeopleOid.Value);

                MapperFactory.AdditionalServiceGroupOfPeopleCD_AdditionalServiceGroupOfPeople.MergeWithEntity(
                    pAdditionalServiceGroupOfPeople, lOriginal);

                MapperFactory.CompactCustomerDC_Customer.MergeWithEntitys(
                    pAdditionalServiceGroupOfPeople.CustomerList, lOriginal.CustomerList);

                DAOFactory.GenericDAO.Update(lOriginal);

                AdditionalServiceGroupOfPeopleDC newGroupDC =
                    MapperFactory.AdditionalServiceGroupOfPeopleCD_AdditionalServiceGroupOfPeople.MapToNewDC(
                        lOriginal);

                newGroupDC.CustomerList =
                    MapperFactory.CompactCustomerDC_Customer.MapToNewDCs(lOriginal.CustomerList);

                return newGroupDC;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<long> InsertNewAdditionalServiceGroupOfPeopleRelations(List<AdditionalServiceGroupOfPeopleRelationDC> pAdditionalServiceGroupOfPeopleRelations)
        {
            try
            {
                List<AdditionalService2GroupOfPeople> lAdditionalServiceGroupOfPeopleRelations =
                    MapperFactory.AdditionalServiceGroupOfPeopleRelationDC_AdditionalService2GroupOfPeople.MapToNewEntities(pAdditionalServiceGroupOfPeopleRelations);

                DAOFactory.GenericDAO.Insert(lAdditionalServiceGroupOfPeopleRelations);

                return lAdditionalServiceGroupOfPeopleRelations.Select(asgopr => asgopr.Oid.Value).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<long> InsertNewAdditionalServiceGroupsOfPeople(List<AdditionalServiceGroupOfPeopleDC> pGroups)
        {
            try
            {
                List<AdditionalServiceGroupOfPeople> lGroups =
                    MapperFactory.AdditionalServiceGroupOfPeopleCD_AdditionalServiceGroupOfPeople.MapToNewEntities(
                        pGroups);

                DAOFactory.GenericDAO.Insert(lGroups);

                return lGroups.Select(asgop => asgop.Oid.Value).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<long> InsertNewServiceRecords(List<ServiceRecordDC> pServiceRecords)
        {
            return InternalInsertNewServiceRecords(MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewEntities(pServiceRecords));
        }

        public static List<long> InternalInsertNewServiceRecords(IEnumerable<ServiceRecord> lServiceRecords)
        {
            try
            {
                ServiceRecordGroup group = null;

                foreach (var iServiceRecord in lServiceRecords)
                {
                    if (string.IsNullOrEmpty(iServiceRecord.IP))
                    {
                        iServiceRecord.IP = OperationContext.Current != null ? Utils.GetClientIP() : "::1";
                    }

                    if (iServiceRecord.InsTs == null)
                    {
                        iServiceRecord.InsTs = DateTime.Now;
                    }

                    if (iServiceRecord.GroupEmployeeCount != null && iServiceRecord.GroupPersonCount != null &&
                       (iServiceRecord.GroupEmployeeCount.Value + iServiceRecord.GroupPersonCount.Value > 2))
                    {
                        if (group == null)
                        {
                            group = new ServiceRecordGroup
                            {
                                CustomerCount = iServiceRecord.GroupPersonCount.Value,
                                EmployeeCount = iServiceRecord.GroupEmployeeCount.Value,
                                RoundedDuration = iServiceRecord.GroupRoundedDuration.Value,
                                StartDate = iServiceRecord.Start,
                                EndDate = iServiceRecord.End
                            };
                        }

                        iServiceRecord.Group = group;
                    }
                    else
                    {
                        var srdc = PluginLoader.FindClass<ServiceRecordDurationCalculator>();
                        if (srdc != null)
                        {
                            srdc.CalculateRoundedDuration(iServiceRecord);
                        }

                        var bsi = PluginLoader.FindClass<SaveInterceptor>();
                        if (bsi != null)
                        {
                            bsi.BeforeSaveServiceRecord(iServiceRecord);
                        }
                    }
                }

                DAOFactory.GenericDAO.Insert(lServiceRecords);

                MakeServiceRecordHistoryEntry(lServiceRecords.ToList(), lServiceRecords.Select(sr => sr.Oid.Value).ToList(), StatementType.Insert);

                return lServiceRecords.Select(sr => sr.Oid.Value).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<long> InsertNewAdditionalServiceBookings(List<AdditionalServiceBookingDC> pAdditionalServiceBookings)
        {
            try
            {
                List<AdditionalServiceBooking> lAdditionalServiceBookings = MapperFactory.AdditionalServiceBookingDC_AdditionalServiceBooking.MapToNewEntities(pAdditionalServiceBookings);
                DAOFactory.GenericDAO.Insert(lAdditionalServiceBookings);

                foreach (AdditionalServiceBooking booking in lAdditionalServiceBookings)
                {
                    AttachAddServiceToAssessment(booking);
                }

                return lAdditionalServiceBookings.Select(asb => asb.Oid.Value).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public bool IsAlive()
        {
            return true;
        }

        public string PrepareFLSReport(FLSAnalysisDataReportDC pReportDC, string id)
        {
            try
            {
                string lResult = id + ".xml";

                string lDir = BS.Shared.Core.Utils.CreateSavePath(AppDomain.CurrentDomain.BaseDirectory, MultitenancyOperationContextExt.Current.Tenant + @"\temp");
                string lPath = BS.Shared.Core.Utils.CreateSavePath(lDir, lResult);

                BS.Shared.Core.Utils.XMLSerialize(lPath, pReportDC);

                return lResult;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public string PrepareSettlementReport(Settlement2DC pSettlementDC)
        {
            try
            {
                string lResult = Guid.NewGuid() + ".xml";

                string lDir = BS.Shared.Core.Utils.CreateSavePath(AppDomain.CurrentDomain.BaseDirectory, MultitenancyOperationContextExt.Current.Tenant + @"\temp");
                string lPath = BS.Shared.Core.Utils.CreateSavePath(lDir, lResult);

                BS.Shared.Core.Utils.XMLSerialize(lPath, pSettlementDC);

                return lResult;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateAccountingTransactions(List<AccountingTransactionDC> pAccountingTransactions)
        {
            try
            {
                List<AccountingTransaction> lOriginals = DAOFactory.GenericDAO.LoadByIDs<AccountingTransaction>(pAccountingTransactions.Select(dc => dc.AccountingTransactionOid.Value));
                MapperFactory.AccountingTransactionDC_AccountingTransaction.MergeWithEntitys(pAccountingTransactions, lOriginals);
                DAOFactory.GenericDAO.Update(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateInvoices(List<InvoiceDC> invoices)
        {
            try
            {
                List<Invoice> lOriginals = DAOFactory.GenericDAO.LoadByIDs<Invoice>(invoices.Select(dc => dc.InvoiceOid.Value));
                MapperFactory.InvoiceDC_Invoice.MergeWithEntitys(invoices, lOriginals);
                DAOFactory.GenericDAO.Update(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public MandatorDC UpdateMandator(MandatorDC mandator)
        {
            try
            {
                Mandator lOriginal = GetMandatorEntity();
                //var oldDc = MapperFactory.MandatorDC_Mandator.MapToNewDC(lOriginal);

                MapperFactory.MandatorDC_Mandator.MergeWithEntity(mandator, lOriginal);
                DAOFactory.GenericDAO.Update(lOriginal);
                return MapperFactory.MandatorDC_Mandator.MapToNewDC(lOriginal);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateServiceCategories(List<ServiceCategoryDC> pServiceCategories)
        {
            try
            {
                List<ServiceCategory> lOriginals = DAOFactory.GenericDAO.LoadByIDs<ServiceCategory>(pServiceCategories.Select(sc => sc.ServiceCategoryOid.Value));

                MapperFactory.ServiceCategoryDC_ServiceCategory.MergeWithEntitys(pServiceCategories, lOriginals);

                DAOFactory.GenericDAO.Update(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateAdditionalServices(List<AdditionalServiceDC> pAdditionalServices)
        {
            try
            {
                List<AdditionalService> lOriginals = DAOFactory.GenericDAO.LoadByIDs<AdditionalService>(pAdditionalServices.Select(sc => sc.AdditionalServiceOid.Value));

                MapperFactory.AdditionalServiceDC_AdditionalService.MergeWithEntitys(pAdditionalServices, lOriginals);

                DAOFactory.GenericDAO.Update(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateServiceDescriptions(List<ServiceDescriptionDC> pServiceDescriptions)
        {
            try
            {
                List<ServiceDescription> lOriginals = DAOFactory.GenericDAO.LoadByIDs<ServiceDescription>(pServiceDescriptions.Select(sc => sc.ServiceDescriptionOid.Value));

                MapperFactory.ServiceDescriptionDC_ServiceDescription.MergeWithEntitys(pServiceDescriptions, lOriginals);

                DAOFactory.GenericDAO.Update(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateAdditionalServiceRegions(List<AdditionalServiceRegionDC> pAdditionalServiceRegions)
        {
            try
            {
                List<AdditionalServiceRegion> lOriginals = DAOFactory.GenericDAO.LoadByIDs<AdditionalServiceRegion>(pAdditionalServiceRegions.Select(sc => sc.AdditionalServiceRegionOid.Value));

                MapperFactory.AdditionalServiceRegionDC_AdditionalServiceRegion.MergeWithEntitys(pAdditionalServiceRegions, lOriginals);

                DAOFactory.GenericDAO.Update(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public ServiceRecordGroupDC UpdateServiceRecordGroup(ServiceRecordGroupDC pServiceRecordGroup)
        {
            try
            {
                var lOriginal = DAOFactory.GenericDAO.LoadByID<ServiceRecordGroup>(pServiceRecordGroup.ServiceRecordGroupOid.Value);

                var originalStart = lOriginal.StartDate;
                var originalEnde = lOriginal.EndDate;

                if (originalStart.HasValue && originalEnde.HasValue && pServiceRecordGroup.StartDate.HasValue && pServiceRecordGroup.EndDate.HasValue)
                {
                    var minutesOrg = originalEnde.Value.Subtract(originalStart.Value).TotalMinutes;
                    var minutesNew = pServiceRecordGroup.EndDate.Value.Subtract(pServiceRecordGroup.StartDate.Value).TotalMinutes;

                    if (Math.Abs(minutesNew - minutesOrg) < 0.1 && pServiceRecordGroup.StartDate.Value.Hour == 0 && pServiceRecordGroup.StartDate.Value.Minute == 0 && pServiceRecordGroup.StartDate.Value.Second == 0)
                    {
                        // Prüfen, ob korrigiert werden muss
                        if (originalStart.Value.Hour != 0 || originalStart.Value.Minute != 0)
                        {
                            pServiceRecordGroup.StartDate = originalStart;
                            pServiceRecordGroup.EndDate = originalEnde;
                            pServiceRecordGroup.RoundedDuration = (decimal)originalEnde.Value.Subtract(originalStart.Value).TotalMinutes;
                            foreach (var srdc in pServiceRecordGroup.ServiceRecordList)
                            {
                                srdc.Start = originalStart;
                                srdc.End = originalEnde;
                                srdc.GroupRoundedDuration = pServiceRecordGroup.RoundedDuration;
                            }
                        }
                    }
                }

                if (!pServiceRecordGroup.StartDate.HasValue && pServiceRecordGroup.EndDate.HasValue)
                {
                    pServiceRecordGroup.StartDate = pServiceRecordGroup.EndDate.Value.AddMinutes((double)pServiceRecordGroup.RoundedDuration * -1);
                }

                pServiceRecordGroup.RoundedDuration = (decimal)pServiceRecordGroup.EndDate.Value.Subtract(pServiceRecordGroup.StartDate.Value).TotalMinutes;
                foreach (var srdc in pServiceRecordGroup.ServiceRecordList)
                {
                    srdc.GroupRoundedDuration = pServiceRecordGroup.RoundedDuration;
                }

                // (Veraltet. Es ist keine Änderung an der Zeit bei vorhandener Einzelunterschrift) Bei geänderten Daten oder Uhrzeiten werden die Klientenunterschriften gelöscht
                var serviceRecords = pServiceRecordGroup.ServiceRecordList;
                var originalServiceRecords = lOriginal.ServiceRecordList.ToList();
                var serviceRecordOidsWithDeletedSingleSignatures = DeleteSignaturesFromServiceRecords(serviceRecords, originalServiceRecords);
                var serviceRecordsdWithRemovedConfirmationReceiptSignatures = RemoveServiceRecordsFromConfirmationReceiptSignatures(serviceRecords, originalServiceRecords, false);

                MapperFactory.ServiceRecordGroupDC_ServiceRecordGroup.MergeWithEntity(pServiceRecordGroup, lOriginal);

                var lServiceRecords = new List<ServiceRecord>();

                // Update der einzelnen Servicerecords
                MapperFactory.ServiceRecordDC_ServiceRecord.MergeWithEntitys(pServiceRecordGroup.ServiceRecordList, lOriginal.ServiceRecordList);
                foreach (var iServiceRecord in lOriginal.ServiceRecordList)
                {
                    if (string.IsNullOrEmpty(iServiceRecord.IP))
                    {
                        iServiceRecord.IP = Utils.GetClientIP();
                    }

                    iServiceRecord.GroupOid = lOriginal.Oid;
                    lServiceRecords.Add(iServiceRecord);
                }

                var groupDurationCalculator = PluginLoader.FindClass<GroupDurationCalculator>();

                groupDurationCalculator?.CalculateGroupDuration(lOriginal);

                DAOFactory.GenericDAO.Update(lOriginal);

                // Die ServiceRecords, deren Einzelunterschriften duch bearbeitete Zeitangaben im Zuge des Updates gelöscht werden zu der SignatureStatus-Liste hinzugefügt (sollte eigentlich nicht vorkommen)
                var serviceRecords2SignatureStates = GenerateSignatureStates(serviceRecordOidsWithDeletedSingleSignatures, serviceRecordsdWithRemovedConfirmationReceiptSignatures, lOriginal.ServiceRecordList.ToList());

                MakeServiceRecordHistoryEntryWithSignatureStates(serviceRecords2SignatureStates, StatementType.Update);

                var newGroupDC = MapperFactory.ServiceRecordGroupDC_ServiceRecordGroup.MapToNewDC(lOriginal);

                newGroupDC.ServiceRecordList = MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(lOriginal.ServiceRecordList);

                return newGroupDC;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        private static void MakeServiceRecordHistoryEntryWithSignatureStates(List<ServiceRecord2SignatureStates> serviceRecords2SignatureStates, StatementType statementType)
        {
            var serviceRecordHistoryEntries = new List<ServiceRecordHistory>();

            foreach (var serviceRecord2SignatureState in serviceRecords2SignatureStates)
            {
                var serviceRecord = serviceRecord2SignatureState.ServiceRecord;
                var singleSignatureState = serviceRecord2SignatureState.SingleSignatureStateType;
                var customerMonthlySignatureState = serviceRecord2SignatureState.CustomerMonthlySignatureStateType;
                var employeeMonthlySignatureState = serviceRecord2SignatureState.EmployeeMonthlySignatreStateType;

                SignatureStateInfoFromServiceRecordHistoryEntry previousRecordHistorySignatureInfo = null;

                if (serviceRecord.Oid.HasValue)
                {
                    //previousRecordHistoryEntry = DAOFactory.SearchDAO.FindMostRecentServiceRecordHistoryEntryByServiceRecordOid(serviceRecord.Oid.Value);
                    previousRecordHistorySignatureInfo = DAOFactory.SearchDAO.FindMostRecentSignatureStatusInfoByServiceRecordOid(serviceRecord.Oid.Value);
                }

                serviceRecordHistoryEntries.AddIfNotIn(new ServiceRecordHistory
                {
                    TimeStamp = DateTime.Now,
                    ChangeType = statementType,
                    CostBearer2SupportConcept = serviceRecord.CostBearer2SupportConcept,
                    CostBearer2SupportConceptOid = serviceRecord.CostBearer2SupportConceptOid,
                    Customer = serviceRecord.Customer,
                    CustomerOid = serviceRecord.CustomerOid,
                    Employee = serviceRecord.Employee,
                    EmployeeOid = serviceRecord.EmployeeOid,
                    End = serviceRecord.End,
                    Group = serviceRecord.Group,
                    GroupEmployeeCount = serviceRecord.GroupEmployeeCount,
                    GroupOid = serviceRecord.GroupOid,
                    GroupPersonCount = serviceRecord.GroupPersonCount,
                    GroupRoundedDuration = serviceRecord.GroupRoundedDuration,
                    IP = serviceRecord.IP,
                    IsActive = serviceRecord.IsActive,
                    Notice = serviceRecord.Notice,
                    ServiceRecordOid = serviceRecord.Oid,
                    RoundedDuration = serviceRecord.RoundedDuration,
                    ServiceDescription = serviceRecord.ServiceDescription,
                    ServiceRecordType = serviceRecord.ServiceRecordType,
                    ServiceRecordInsTs = serviceRecord.InsTs,
                    ServiceRecordVersion = serviceRecord.Version ?? 0,
                    ServiceRecordInsUser = serviceRecord.InsUser,
                    ServiceRecordUdpUser = serviceRecord.UdpUser,
                    Start = serviceRecord.Start,
                    SupportConcept = serviceRecord.SupportConcept,
                    SystemEntryID = serviceRecord.SystemEntryID,
                    DistanceInMeter = serviceRecord.DistanceInMeter,
                    IsCreatedInMobileClient = serviceRecord.IsCreatedInMobileClient,
                    ServiceRecordSignatureStateType = singleSignatureState ?? previousRecordHistorySignatureInfo?.ServiceRecordSignatureStateType ?? SignatureStateType.None,
                    CustomerConfirmationReceiptSignatureStateType = customerMonthlySignatureState ?? previousRecordHistorySignatureInfo?.CustomerConfirmationReceiptSignatureStateType ?? SignatureStateType.None,
                    EmployeeConfirmationReceiptSignatureStateType = employeeMonthlySignatureState ?? previousRecordHistorySignatureInfo?.EmployeeConfirmationReceiptSignatureStateType ?? SignatureStateType.None,
                    CustomerConfirmationReceiptSignatureOid = previousRecordHistorySignatureInfo?.CustomerConfirmationReceiptSignatureOid,
                    EmployeeConfirmationReceiptSignatureOid = previousRecordHistorySignatureInfo?.EmployeeConfirmationReceiptSignatureOid
                });
            }

            DAOFactory.GenericDAO.Insert(serviceRecordHistoryEntries);
        }

        private static List<ServiceRecord2SignatureStates> GenerateSignatureStates(List<ServiceRecord> serviceRecordsWithDeletedSingleSignatures, List<ServiceRecord2SignatureStates> serviceRecordsdWithRemovedConfirmationReceiptSignatures, List<ServiceRecord> originals)
        {
            var serviceRecords2SignatureStates = new List<ServiceRecord2SignatureStates>();

            // Die ServiceRecords, deren Einzelunterschriften duch bearbeitete Zeitangaben im Zuge des Updates gelöscht werden zu der SignatureStatus-Liste hinzugefügt (sollte eigentlich nicht vorkommen)
            foreach (var serviceRecord in serviceRecordsWithDeletedSingleSignatures)
            {
                serviceRecords2SignatureStates.Add(new ServiceRecord2SignatureStates(serviceRecord, SignatureStateType.AutomaticallyDeleted, null, null));
            }

            // Die ServiceRecords, deren Monatsunterschriften duch bearbeitete Zeitangaben im Zuge des Updates gelöscht werden zu der SignatureStatus-Liste hinzugefügt
            foreach (var serviceRecord2SignatureStates in serviceRecordsdWithRemovedConfirmationReceiptSignatures)
            {
                var existingServiceRecord2SignatureStates = serviceRecords2SignatureStates.FirstOrDefault(f => f.ServiceRecord.Equals(serviceRecord2SignatureStates.ServiceRecord));

                if (existingServiceRecord2SignatureStates is null)
                {
                    serviceRecords2SignatureStates.Add(serviceRecord2SignatureStates);
                }
                else
                {
                    existingServiceRecord2SignatureStates.CustomerMonthlySignatureStateType = serviceRecord2SignatureStates.CustomerMonthlySignatureStateType;
                    existingServiceRecord2SignatureStates.EmployeeMonthlySignatreStateType = serviceRecord2SignatureStates.EmployeeMonthlySignatreStateType;
                }
            }

            // Die ServiceRecords, bei denen keine Zeitangaben geändert wurden und deren Unterschriften so erhalten bleiben, werden zu der SignatureStatus-Liste hinzugefügt
            foreach (var serviceRecord in originals)
            {
                if (serviceRecord.Oid is null)
                {
                    continue;
                }

                var oid = serviceRecord.Oid.Value;

                if (serviceRecordsWithDeletedSingleSignatures.All(a => a.Oid.HasValue && a.Oid.Value.Equals(oid)) &&
                   serviceRecordsdWithRemovedConfirmationReceiptSignatures.All(a => a.ServiceRecord.Oid.HasValue && a.ServiceRecord.Oid.Value.Equals(oid)))
                {
                    serviceRecords2SignatureStates.AddIfNotIn(new ServiceRecord2SignatureStates(serviceRecord, null, null, null));
                }
            }

            return serviceRecords2SignatureStates;
        }

        public void UpdateServiceRecords(List<ServiceRecordDC> pServiceRecords)
        {
            try
            {
                var lOriginals = DAOFactory.GenericDAO.LoadByIDs<ServiceRecord>(pServiceRecords.Select(sr => sr.ServiceRecordOid.Value));

                // ToDo: KGW? Man kann bei ServiceReocrds die Uhrzeiten, die eine Einzelunterschrift ungültig machen würde, nicht ändern.
                var serviceRecordsWithDeletedSingleSignatures = DeleteSignaturesFromServiceRecords(pServiceRecords, lOriginals);
                var serviceRecordsdWithRemovedConfirmationReceiptSignatures = RemoveServiceRecordsFromConfirmationReceiptSignatures(pServiceRecords, lOriginals, false);

                if (lOriginals.Count == 1 && pServiceRecords.Count == 1)
                {
                    var srDc = pServiceRecords[0];
                    var srOrg = lOriginals[0];

                    var originalStart = srOrg.Start;
                    var originalEnde = srOrg.End;

                    if (originalStart.HasValue && originalEnde.HasValue && srDc.Start.HasValue && srDc.End.HasValue)
                    {
                        var minutesOrg = originalEnde.Value.Subtract(originalStart.Value).TotalMinutes;
                        var minutesNew = srDc.End.Value.Subtract(srDc.Start.Value).TotalMinutes;

                        // Start und Ende korrigieren
                        if (Math.Abs(minutesNew - minutesOrg) < 0.1 && srDc.Start.Value.Hour == 0 && srDc.Start.Value.Minute == 0 && srDc.Start.Value.Second == 0)
                        {
                            // Prüfen, ob korrigiert werden muss
                            if (originalStart.Value.Hour != 0 ||
                               originalStart.Value.Minute != 0)
                            {
                                srDc.Start = originalStart;
                                srDc.End = originalEnde;
                                //pServiceRecordGroup.RoundedDuration = (decimal)originalEnde.Value.Subtract(originalStart.Value).TotalMinutes;
                            }
                        }
                    }
                }

                MapperFactory.ServiceRecordDC_ServiceRecord.MergeWithEntitys(pServiceRecords, lOriginals);

                var serviceRecordDurationCalculator = PluginLoader.FindClass<ServiceRecordDurationCalculator>();
                var groupDurationCalculator = PluginLoader.FindClass<GroupDurationCalculator>();

                foreach (var serviceRecord in lOriginals)
                {
                    serviceRecordDurationCalculator?.CalculateRoundedDuration(serviceRecord);

                    if (serviceRecord.GroupOid.HasValue && serviceRecord.GroupPersonCount.HasValue && serviceRecord.GroupEmployeeCount.HasValue && groupDurationCalculator != null)
                    {
                        var groupDuration = groupDurationCalculator.CalculateGroupDuration(serviceRecord.GroupPersonCount.Value, serviceRecord.GroupEmployeeCount.Value, serviceRecord.RoundedDuration);

                        var singleduration = Math.Ceiling(serviceRecord.RoundedDuration / serviceRecord.GroupPersonCount.Value);
                        
                        if (groupDuration != null)
                        {
                            singleduration = groupDuration.SingleDuration;
                        }

                        serviceRecord.RoundedDuration = singleduration;
                    }
                }

                var saveInterceptor = PluginLoader.FindClass<SaveInterceptor>();
                if (saveInterceptor != null)
                {
                    foreach (var serviceRecord in lOriginals)
                    {
                        saveInterceptor.BeforeSaveServiceRecord(serviceRecord);
                    }
                }

                DAOFactory.GenericDAO.Update(lOriginals);

                var serviceRecords2SignatureStates = GenerateSignatureStates(serviceRecordsWithDeletedSingleSignatures, serviceRecordsdWithRemovedConfirmationReceiptSignatures, lOriginals);//new List<ServiceRecord2SignatureStates>();

                MakeServiceRecordHistoryEntryWithSignatureStates(serviceRecords2SignatureStates, StatementType.Update);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public bool DoesNotOverlapWithOtherServiceRecord(ServiceRecordDC pServiceRecord, long customerOid, long? employeeOid)
        {
            //obsolete
            return false;
            //if (pServiceRecord.ServiceDescription.DoNotCheckOverlapping)
            //{
            //	return false;
            //}
            //var span = new DateTimeSpan
            //{StartDate = pServiceRecord.Start.Value, EndDate = pServiceRecord.End.Value.AddDays(1).AddTicks(-1)};

            //List<ServiceRecord> records = DAOFactory.SearchDAO.FindCustomerServiceRecords(customerOid, span, employeeOid, null).ToList();

            //return records.Count <= 0 || records.Where(record => record.CostBearer2SupportConcept.CostBearer.Oid == pServiceRecord.CostBearer.OrganisationOid).Select(record => TimeSpanOverlapsWithOtherTimeSpan(pServiceRecord.Start, record.Start, pServiceRecord.RoundedDuration, record.RoundedDuration)).All(timeCheck => !timeCheck);
        }

        public bool OverlapsWithAnotherAdditionalServiceBooking(long additionalServiceRegionOid, List<long> customerOids, DateTime pDatum)
        {
            List<AdditionalServiceBooking> bookings = DAOFactory.GenericDAO.GetAll<AdditionalServiceBooking>().Where(b => b.Datum.Equals(pDatum) && b.AdditionalServiceRegion.Oid.Value.Equals(additionalServiceRegionOid)).ToList();

            return bookings.Any(booking => booking.Customer2AddServiceBookings.Any(customer => customerOids.Contains(customer.CustomerOid)));
        }

        public List<AdditionalServiceGroupOfPeopleRelationDC> GetAllAdditionalServiceGroupOfPeopleRelation()
        {
            try
            {
                IList<AdditionalService2GroupOfPeople> as2gop = DAOFactory.GenericDAO.GetAll<AdditionalService2GroupOfPeople>();
                return as2gop.Select(item => MapperFactory.AdditionalServiceGroupOfPeopleRelationDC_AdditionalService2GroupOfPeople.MergeWithDC(item, new AdditionalServiceGroupOfPeopleRelationDC())).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<AdditionalServiceGroupOfPeopleDC> GetAllAdditionalServiceGroupOfPeople()
        {
            try
            {
                List<AdditionalServiceGroupOfPeopleDC> result =
                    MapperFactory.AdditionalServiceGroupOfPeopleCD_AdditionalServiceGroupOfPeople.MapToNewDCs(
                        DAOFactory.GenericDAO.GetAll<AdditionalServiceGroupOfPeople>()).ToList();

                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<AdditionalServiceBookingDC> GetAllAdditionalServiceBookings(long? regionOid, DateTime start, DateTime end)
        {
            try
            {
                //Filtere Customer mit TerminationDate raus
                var clist = DAOFactory.GenericDAO.GetAllActiveAndArchived<Customer>();

                var notAllowedCustomerOids = new List<long>();

                foreach (var c in clist)
                {
                    if (c.TerminationDate.HasValue && c.TerminationDate.Value < start)
                    {
                        notAllowedCustomerOids.Add(c.Oid.Value);
                    }
                }

                List<AdditionalServiceBookingDC> result =
                    MapperFactory.AdditionalServiceBookingDC_AdditionalServiceBooking.MapToNewDCs(
                        DAOFactory.SearchDAO.GetAdditionalServiceBookings(regionOid, start, end)).ToList();


                foreach (var booking in result)
                {
                    foreach (var oid in notAllowedCustomerOids)
                    {
                        if (booking.CustomerOidDict.ContainsKey(oid))
                        {
                            booking.CustomerOidDict.Remove(oid);
                        }
                    }
                }
                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<AdditionalServiceNoticeDC> GetAdditionalServiceNoticeList(long? regionOid, DateTime start, DateTime end)
        {
            try
            {
                var result =
                    MapperFactory.AdditionalServiceNoticeDC_AdditionalServiceNotice.MapToNewDCs(
                        DAOFactory.SearchDAO.GetAdditionalServiceNoticeList(regionOid, start, end)).ToList();

                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }


        public List<AdditionalServiceNoticeDC> UpdateAdditionalServiceNoticeList(List<AdditionalServiceNoticeDC> additionalServiceNoticeList)
        {
            try
            {
                var newDcs = additionalServiceNoticeList.Where(dc => !dc.Oid.HasValue);
                var newEntities = MapperFactory.AdditionalServiceNoticeDC_AdditionalServiceNotice.MapToNewEntities(newDcs);
                DAOFactory.GenericDAO.Insert(newEntities);

                var existingNotices = additionalServiceNoticeList.Where(dc => dc.Oid.HasValue).ToList();

                List<AdditionalServiceNotice> originals = DAOFactory.GenericDAO.LoadByIDs<AdditionalServiceNotice>(existingNotices.Select(dc => dc.Oid.Value));

                MapperFactory.AdditionalServiceNoticeDC_AdditionalServiceNotice.MergeWithEntitys(existingNotices, originals);

                DAOFactory.GenericDAO.Update(originals);

                var result = MapperFactory.AdditionalServiceNoticeDC_AdditionalServiceNotice.MapToNewDCs(originals);
                result.AddRange(MapperFactory.AdditionalServiceNoticeDC_AdditionalServiceNotice.MapToNewDCs(newEntities));
                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public Dictionary<ServiceRecordDC, List<ServiceRecordValidationResult>> ValidateGroupServiceRecordEntry(ServiceRecordDC pServiceRecord, List<ServiceRecordDC> groupServiceRecords, List<CompactEmployeeDC> employees, DateTime? date, int maxDaysEditServiceRecordsAllowed, decimal flsTotalRounded, out Dictionary<long, string> overlappingRecords, out Dictionary<long, string> overlappingEmployees)
        {
            var validator = PluginLoader.FindClass<ServiceRecordValidator>();
            return validator.ValidateGroupServiceRecordEntry(pServiceRecord, groupServiceRecords, employees, date, maxDaysEditServiceRecordsAllowed, flsTotalRounded, out overlappingRecords, out overlappingEmployees);

        }

        public List<ServiceRecordValidationResultDC> ValidateServiceRecordEntry(ServiceRecordDC newServiceRecord, SupportConceptStatisticsDC statistics, int maxDaysEditServiceRecordsAllowed, bool isGroupRecord, IList<long> employeeOids)
        {
            return ValidateServiceRecord(newServiceRecord, statistics, maxDaysEditServiceRecordsAllowed, employeeOids, null);
        }

        public List<ServiceRecordValidationResultDC> ValidateServiceRecord(ServiceRecordDC newServiceRecord, SupportConceptStatisticsDC statistics, int maxDaysEditServiceRecordsAllowed, IList<long> employeeOids, IList<long> cb2scOids)
        {
            var validator = PluginLoader.FindClass<ServiceRecordValidator>();
            return validator.ValidateServiceRecord(newServiceRecord, statistics, maxDaysEditServiceRecordsAllowed, employeeOids, cb2scOids);
        }

        public List<ServiceRecordValidationResultDC> ValidateServiceRecordDeletion(ServiceRecordDC serviceRecord, long employeeOid)
        {
            var validator = PluginLoader.FindClass<ServiceRecordValidator>();
            return validator.ValidateServiceRecordDeletion(serviceRecord, employeeOid);

        }

        public ServiceRecordValidationResultDC CheckForExistingSignature(ServiceRecordDC serviceRecord)
        {
            var validator = PluginLoader.FindClass<ServiceRecordValidator>();
            return validator.CheckForExistingSignature(serviceRecord);
        }

        public List<ServiceRecordValidationResult> CheckExistingSettlementInvoices(ServiceRecordDC pServiceRecord)
        {
            var result = new List<ServiceRecordValidationResult>();
            // 6. SettlementInvoiceAlreadyExisting
            try
            {
                IList<SettlementInvoice> allSettlementInvoices = DAOFactory.GenericDAO.GetAll<SettlementInvoice>();

                foreach (SettlementInvoice rechnung in allSettlementInvoices)
                {
                    if (rechnung.InvoiceBase.CostBearer2SupportConcept.Oid.HasValue)
                        if (rechnung.InvoiceBase.CostBearer2SupportConcept.Oid.Value.Equals(pServiceRecord.CostBearer2SupportConceptOid.Value) && rechnung.IsActive.Equals(ActivationTypeId.Active))
                        {
                            result.Add(ServiceRecordValidationResult.SettlementInvoiceAlreadyExisting);
                            break;
                        }
                }
            }
            catch (Exception)
            {
                result.Add(ServiceRecordValidationResult.Error);
            }

            return result;
        }

        public List<AdditionalServiceBookingDC> GetAllAdditionalServiceBookingsForCustomer(long customerOid, DateTime start, DateTime end)
        {
            try
            {
                ;
                List<AdditionalServiceBookingDC> result =
                    MapperFactory.AdditionalServiceBookingDC_AdditionalServiceBooking.MapToNewDCs(
                        DAOFactory.SearchDAO.GetAdditionalServiceBookingsForCustomer(customerOid, start, end));
                //var result =
                //	MapperFactory.AdditionalServiceBookingDC_AdditionalServiceBooking.MapToNewDCs(
                //		DAOFactory.GenericDAO.GetAll<AdditionalServiceBooking>()).ToList().Where(b => b.CustomerOidDict.Any(c => c.Key.Equals(customerOid))).ToList();

                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public ServiceRecordDC GetServiceRecordById(long pId)
        {
            try
            {
                var sr = DAOFactory.GenericDAO.GetByID<ServiceRecord>(pId);

                if (sr == null)
                    return null;

                ServiceRecordDC result = MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDC(sr);
                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<FileAttachmentDC> GetFileAttachmentInfoByType(FileAttachmentType fileAttachmentType)
        {
            try
            {
                return MapperFactory.FileAttachmentDC_FileAttachmentInfo.MapToNewDCs(DAOFactory.SearchDAO.FindFileAttachmentInfoByType(fileAttachmentType));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceRecordDC> GetActiveServiceRecordsBySupportConcept(long pSupportConceptOid)
        {
            try
            {
                return MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(DAOFactory.SearchDAO.FindServiceRecordsForSupportConcept(pSupportConceptOid));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void InsertBeWoMobilBrowserInfo(BeWoMobilBrowserInfoDC browserInfo)
        {
            try
            {
                BeWoMobilBrowserInfo info = MapperFactory.BeWoMobilBrowserInfoDC_BeWoMobilBrowserInfo.MapToNewEntity(browserInfo);
                DAOFactory.GenericDAO.Insert(info);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public IList<ServiceRecordDC> FindServiceRecordsForLastDays(long? costbearer2SupportConceptOid, int days, long? employeeOid)
        {
            try
            {
                return MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(DAOFactory.SearchDAO.FindServiceRecordsForDays(costbearer2SupportConceptOid, days, employeeOid));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public IEnumerable<CompactSupportConceptDC> GetCompactSupportConcepts(long supportConceptOid, long? employeeOid)
        {
            try
            {
                var s = PluginLoader.FindClass<CustomerService>();

                return s.GetCompactSupportConcepts(supportConceptOid, employeeOid);

            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        private static ServiceRecordDC CreateServiceRecordDCCompact(ServiceRecord sr)
        {
            var dc = new ServiceRecordDC();

            dc.ServiceRecordOid = sr.Oid;
            dc.ServiceRecordVersion = sr.Version;
            dc.Start = sr.Start;
            dc.End = sr.End;
            dc.Notice = sr.Notice;
            dc.Notice2 = sr.Notice2;
            dc.Notice3 = sr.Notice3;
            dc.Notice4 = sr.Notice4;
            dc.Notice5 = sr.Notice5;
            if (sr.ServiceDescription != null)
                dc.ServiceDescription = MapperFactory.ServiceDescriptionDC_ServiceDescription.MapToNewDC(sr.ServiceDescription);


            dc.RoundedDuration = sr.RoundedDuration;

            dc.DistanceInMeter = (int?)sr.DistanceInMeter;
            dc.DistanceInMeterDecimal = sr.DistanceInMeter;
            dc.Betrag = sr.Betrag;
            dc.InsertedOn = sr.InsTs;
            dc.InsUser = sr.InsUser;

            dc.DurationInStunden = sr.DurationInStunden;
            dc.ServiceRecordFormat = sr.ServiceRecordFormat;

            dc.GroupEmployeeCount = sr.GroupEmployeeCount;
            dc.GroupPersonCount = sr.GroupPersonCount;
            dc.GroupRoundedDuration = sr.GroupRoundedDuration;
            dc.ServiceRecordType = sr.ServiceRecordType ?? ServiceRecordTypeId.DefaultActivity;
            dc.GroupOid = sr.GroupOid;
            dc.SignatureOid = sr.SignatureOid;

            if (sr.GroupOid.HasValue)
            {
                dc.BackgroundColor = "#FFFDC784";
            }

            if (sr.ServiceRecordType.HasValue && sr.ServiceRecordType.Value == ServiceRecordTypeId.Content)
            {
                dc.BackgroundColor = "#FF78BFFF";
            }


            if (sr.Employee != null)
            {
                //dc.Employee = MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(sr.Employee);
                dc.Employee = new CompactEmployeeDC();
                dc.Employee.EmployeeOid = sr.Employee.Oid.Value;
                dc.Employee.EmployeeVersion = sr.Employee.Version.Value;
                dc.Employee.FirstName = sr.Employee.Person.FirstName;
                dc.Employee.LastName = sr.Employee.Person.LastName;
                dc.Employee.PersonnelNumber = sr.Employee.PersonnelNumber;
                //pDataContract.FLSPerWeek = pEntity.WeeklyFLS;
                dc.Employee.ActivationType = sr.Employee.IsActive;
            }

            //if(sr.DurationInStunden == ZeiterfassungsDauer.Stunden)
            //    dc.RoundedDuration = sr.RoundedDuration /60;
            //else
            //    dc.RoundedDuration = sr.RoundedDuration;

            //Goals -------------------------
            var list = new List<ValueListEntryType>();
            list.Add(ValueListEntryType.SupportConceptGoalType);
            list.Add(ValueListEntryType.SupportConceptGoalCategoryType);
            list.Add(ValueListEntryType.SupportConceptIndividualGoalCategoryType);
            list.Add(ValueListEntryType.SupportConceptIndividualGoalType);

            dc.Goals = new List<ValueListEntryDC>();
            foreach (var v2o in sr.ValueList.FindByTypes(list))
            {
                var entryDc = MapperFactory.ValueListEntryDC_ValueListEntry.MapToNewDC(v2o.Entry);
                entryDc.RatingTypeOid = v2o.RatingTypeOid;
                dc.Goals.Add(entryDc);
            }

            return dc;
        }

        private static ServiceRecordDC CreateServiceRecordDCIfSupportConceptIsActive(ServiceRecord sr, Customer cust, bool checkArchivedSupportConcepts)
        {
            ServiceRecordDC dc = null;
            if (!checkArchivedSupportConcepts || (sr.SupportConcept != null && sr.SupportConcept.IsActive == ActivationTypeId.Active))
            {
                dc = new ServiceRecordDC();

                dc.ServiceRecordOid = sr.Oid;
                dc.ServiceRecordVersion = sr.Version;
                dc.Start = sr.Start;
                dc.End = sr.End;
                dc.Notice = sr.Notice;
                dc.Notice2 = sr.Notice2;
                dc.Notice3 = sr.Notice3;
                dc.Notice4 = sr.Notice4;
                dc.Notice5 = sr.Notice5;
                if (sr.ServiceDescription != null)
                    dc.ServiceDescription = MapperFactory.ServiceDescriptionDC_ServiceDescription.MapToNewDC(sr.ServiceDescription);
                dc.RoundedDuration = sr.RoundedDuration;
                dc.InsertedOn = sr.InsTs;
                dc.InsUser = sr.InsUser;
                dc.DurationInStunden = sr.DurationInStunden;
                dc.SignatureOid = sr.SignatureOid;
                dc.ServiceRecordFormat = sr.ServiceRecordFormat;

                //Customer -----------------
                dc.Customer = new CompactCustomerDC();


                dc.Customer.CustomerOid = cust.Oid.Value;
                dc.Customer.CustomerVersion = cust.Version.Value;
                dc.Customer.FirstName = cust.Person.FirstName;
                dc.Customer.LastName = cust.Person.LastName;
                dc.Customer.Sex = cust.Person.Sex;
                //dc.Customer.DateOfBirth = cust.Person.DateOfBirth;
                //dc.Customer.ActivationType = cust.IsActive;
                //dc.Customer.TerminationDate = cust.TerminationDate;
                //dc.Customer.EquityContribution = cust.EquityContribution;

                //pDataContract.AbsenceTimes = MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDCs(pEntity.AbsenceTimes);


                //Employee -----------------


                if (sr.Employee != null)
                {
                    //dc.Employee = MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(sr.Employee);
                    dc.Employee = new CompactEmployeeDC();
                    dc.Employee.EmployeeOid = sr.Employee.Oid.Value;
                    dc.Employee.EmployeeVersion = sr.Employee.Version.Value;
                    dc.Employee.FirstName = sr.Employee.Person.FirstName;
                    dc.Employee.LastName = sr.Employee.Person.LastName;
                    dc.Employee.PersonnelNumber = sr.Employee.PersonnelNumber;
                    //pDataContract.FLSPerWeek = pEntity.WeeklyFLS;
                    dc.Employee.ActivationType = sr.Employee.IsActive;
                }


                //SupportConcept -----------------
                if (sr.SupportConcept != null)
                {
                    dc.SupportConcept = new CompactSupportConceptDC();

                    dc.SupportConcept.SupportConceptOid = sr.SupportConcept.Oid.Value;
                    dc.SupportConcept.SupportConceptVersion = sr.SupportConcept.Version.Value;
                    dc.SupportConcept.Customer = dc.Customer;
                    //pDataContract.Customer = MapperFactory.CompactCustomerDC_Customer.MapToNewDC(pEntity.Customer);
                    dc.SupportConcept.ActivationType = sr.SupportConcept.IsActive;
                    dc.SupportConcept.ConferenceDate = sr.SupportConcept.ConferenceDate;

                    //foreach (var iCBRel in pEntity.CostBearer2SupportConceptList)
                    //{
                    //    CompactCostBearerDC costBearer = new CompactCostBearerDC();

                    //    if (iCBRel.CostBearer.Organisation != null)
                    //    {
                    //        CompactOrganisationDC orgDC = new CompactOrganisationDC();
                    //        orgDC.Name = iCBRel.CostBearer.Organisation.Name;
                    //        orgDC.OrganisationOid = iCBRel.CostBearer.Organisation.Oid.Value;

                    //        if (iCBRel.CostBearer.Organisation.Address != null)
                    //        {
                    //            orgDC.Street = iCBRel.CostBearer.Organisation.Address.Street;
                    //            orgDC.PostalCode = iCBRel.CostBearer.Organisation.Address.PostalCode;
                    //            orgDC.Town = iCBRel.CostBearer.Organisation.Address.Town;
                    //        }
                    //        costBearer.Organisation = orgDC;
                    //    }
                    //    costBearer.CostBearerOid = iCBRel.CostBearer.Oid.Value;
                    //    costBearer.CostBearer2SupportConceptOid = iCBRel.Oid.Value;
                    //    costBearer.SupportConceptStatus = iCBRel.Status;
                    //    costBearer.RequestedStartDate = iCBRel.RequestedStartDate;
                    //    costBearer.RequestedEndDate = iCBRel.RequestedEndDate;
                    //    costBearer.ApprovedStartDate = iCBRel.ApprovedStartDate;
                    //    costBearer.ApprovedEndDate = iCBRel.ApprovedEndDate;
                    //    costBearer.ApprovedFLS = iCBRel.ApprovedFLS;
                    //    costBearer.ApprovedFLSTotal = iCBRel.ApprovedFLSTotal;
                    //    costBearer.CustomerReferenceNumber = iCBRel.CustomerReferenceNumber;
                    //    costBearer.IsCalculatingWithFactor = iCBRel.CostBearer.IsCalculatingWithFactor;

                    //    pDataContract.CostBearerList.Add(costBearer);
                    //    pDataContract.CustomerReferenceNumbers.Add(iCBRel.CustomerReferenceNumber);
                    //    pDataContract.CostBearerRelOids.Add(iCBRel.Oid.Value);
                    //}

                    //dc.SupportConcept = MapperFactory.CompactSupportConceptDC_SupportConcept.MapToNewDC(sr.SupportConcept);
                }

                //Costbearer -----------------
                if (sr.CostBearer2SupportConcept != null)
                {
                    dc.CostBearer2SupportConceptOid = sr.CostBearer2SupportConcept.Oid.Value;

                    if (dc.SupportConcept != null)
                    {
                        var costBearer = new CompactCostBearerDC();

                        if (sr.CostBearer2SupportConcept.CostBearer.Organisation != null)
                        {
                            var orgDC = new CompactOrganisationDC();
                            orgDC.Name = sr.CostBearer2SupportConcept.CostBearer.Organisation.Name;
                            orgDC.OrganisationOid = sr.CostBearer2SupportConcept.CostBearer.Organisation.Oid.Value;
                            orgDC.CostBearerOid = sr.CostBearer2SupportConcept.CostBearer.Oid;
                            dc.CostBearer = orgDC;
                            costBearer.Organisation = orgDC;
                        }

                        costBearer.CostBearerID = sr.CostBearer2SupportConcept.CostBearer.ID;
                        costBearer.CostBearerOid = sr.CostBearer2SupportConcept.CostBearer.Oid.Value;
                        costBearer.CostBearer2SupportConceptOid = sr.CostBearer2SupportConcept.Oid.Value;
                        costBearer.SupportConceptStatus = sr.CostBearer2SupportConcept.Status;
                        costBearer.RequestedStartDate = sr.CostBearer2SupportConcept.RequestedStartDate;
                        costBearer.RequestedEndDate = sr.CostBearer2SupportConcept.RequestedEndDate;
                        costBearer.ApprovedStartDate = sr.CostBearer2SupportConcept.ApprovedStartDate;
                        costBearer.ApprovedEndDate = sr.CostBearer2SupportConcept.ApprovedEndDate;
                        costBearer.CustomerReferenceNumber = sr.CostBearer2SupportConcept.CustomerReferenceNumber;
                        costBearer.IsCalculatingWithFactor = sr.CostBearer2SupportConcept.CostBearer.IsCalculatingWithFactor;

                        dc.SupportConcept.CostBearerList.Add(costBearer);
                        dc.SupportConcept.CustomerReferenceNumbers.Add(sr.CostBearer2SupportConcept.CustomerReferenceNumber);
                        dc.SupportConcept.CostBearerRelOids.Add(sr.CostBearer2SupportConcept.Oid.Value);
                    }

                    if (dc.CostBearer == null)
                    {
                        if (sr.CostBearer2SupportConcept.CostBearer.Organisation != null)
                            dc.CostBearer = MapperFactory.CompactOrganisationDC_Organisation.MapToNewDC(sr.CostBearer2SupportConcept.CostBearer.Organisation);
                    }
                }

                //Goals -------------------------
                var list = new List<ValueListEntryType>();
                list.Add(ValueListEntryType.SupportConceptGoalType);
                list.Add(ValueListEntryType.SupportConceptGoalCategoryType);
                list.Add(ValueListEntryType.SupportConceptIndividualGoalCategoryType);
                list.Add(ValueListEntryType.SupportConceptIndividualGoalType);
                dc.Goals = MapperFactory.ValueListEntryDC_ValueListEntry.MapToNewDCs(
                    sr.ValueList.FindByTypes(list).Select(e2o => e2o.Entry));

                dc.GroupEmployeeCount = sr.GroupEmployeeCount;
                dc.GroupPersonCount = sr.GroupPersonCount;
                dc.GroupRoundedDuration = sr.GroupRoundedDuration;
                dc.GroupOid = sr.GroupOid;
                dc.ServiceRecordType = sr.ServiceRecordType ?? ServiceRecordTypeId.DefaultActivity;
            }

            return dc;
        }

        public static Dictionary<string, string> GetSettingsValueDict(string settings)
        {
            var dict = new Dictionary<String, String>();
            if (!String.IsNullOrEmpty(settings))
            {
                string[] keyValuePairs = settings.Split(';');

                foreach (string pair in keyValuePairs)
                {
                    string[] keyValuePair = pair.Split('=');
                    if (keyValuePair.Length == 2)
                    {
                        dict.Add(keyValuePair[0], keyValuePair[1]);
                    }
                }
            }

            return dict;
        }


        private static string GetContractState()
        {
            try
            {
                String responseStr = "";
                String tenant = "";
                String typ = "&t=0";

                if (MultitenancyOperationContextExt.Current != null)
                {
                    tenant = MultitenancyOperationContextExt.Current.Tenant;
                }
                else
                {
                    tenant = SessionFacade.Tenant;
                    typ = "&t=1";
                }

                if (String.IsNullOrEmpty(tenant))
                {
                    return "";
                }

                Monitor.Enter(_Lock);

                if (_ContractStateDate.ContainsKey(tenant))
                {
                    DateTime oldDate = _ContractStateDate[tenant];
                    if (DateTime.Now.Subtract(oldDate).TotalMinutes > 5)
                    {
                        //Aktualisiere ContractState alle 5 Minuten
                        _ContractStates.Remove(tenant);
                        _ContractStateDate.Remove(tenant);
                    }
                }
                if (!_ContractStates.ContainsKey(tenant))
                {
                    string url = ConfigurationManager.AppSettings.Get("ContractStateUrl");
                    url = url.Replace("[TENANT]", tenant);
                    url += typ;

                    using (var client = new WebClient())
                    {
                        //MessageBox.Show(hostAddress);
                        byte[] response = client.DownloadData(url);

                        responseStr = Encoding.ASCII.GetString(response);
                        _ContractStates[tenant] = responseStr;
                        _ContractStateDate[tenant] = DateTime.Now;
                    }
                }
                else
                {
                    responseStr = _ContractStates[tenant];
                }
                return responseStr;
            }
            catch (Exception e)
            {
                return "Fehler";
            }
            finally
            {
                Monitor.Exit(_Lock);
            }

            return "";
        }

        public static void DeleteAdditionalServiceGroupOfPeopleRelations(Dictionary<long, long> pOid2Version)
        {
            try
            {
                List<AdditionalService2GroupOfPeople> lOriginals = DAOFactory.GenericDAO.LoadByIDs<AdditionalService2GroupOfPeople>(pOid2Version.Select(e => e.Key));

                lOriginals.DoForEach(or => MapperFactory.AdditionalServiceGroupOfPeopleRelationDC_AdditionalService2GroupOfPeople.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));

                List<AdditionalService2GroupOfPeople> srListToDelete = lOriginals.ToList();

                if (srListToDelete.Count > 0)
                    DAOFactory.GenericDAO.Delete(srListToDelete);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        private static void AttachAddServiceToAssessment(AdditionalServiceBooking pAdditionalServiceBookingDC)
        {
            try
            {
                var newCategoryDC = new AssessmentSheetCategoryDC { Description = pAdditionalServiceBookingDC.AdditionalServiceRegion.AdditionalService.Name };
                AssessmentSheetCategory lCategory = MapperFactory.AssessmentSheetCategoryDC_AssessmentSheetCategory.MapToNewEntity(newCategoryDC);
                lCategory.SystemEntryID = SystemEntryID.AdditionalServiceAssessmentSheet;

                AssessmentSheetCategory cat = DAOFactory.SearchDAO.GetAddServiceAssessmentSheetCategoryWithName(lCategory.Description);


                if (cat == null)
                {
                    DAOFactory.GenericDAO.Insert(lCategory);
                }
                else
                {
                    lCategory = cat;
                }

                IList<AssessmentSheetValue> values = DAOFactory.GenericDAO.GetAll<AssessmentSheetValue>();
                bool yesExists =
                    values.Count(
                        v =>
                            v.SystemEntryID.Equals(SystemEntryID.AdditionalServiceAssessmentSheet) &&
                            v.Description.Equals("Ja")) == 1;

                bool noExists =
                    values.Count(
                        v =>
                            v.SystemEntryID.Equals(SystemEntryID.AdditionalServiceAssessmentSheet) &&
                            v.Description.Equals("Nein")) == 1;

                var lYes = new AssessmentSheetValue
                {
                    Color = "#FF7FFF00",
                    Description = "Ja",
                    Position = 0,
                    Sign = "",
                    SystemEntryID = SystemEntryID.AdditionalServiceAssessmentSheet
                };

                var lNo = new AssessmentSheetValue
                {
                    Color = "#FFFF0000",
                    Description = "Nein",
                    Position = 0,
                    Sign = "x",
                    SystemEntryID = SystemEntryID.AdditionalServiceAssessmentSheet
                };

                if (!yesExists)
                {
                    DAOFactory.GenericDAO.Insert(lYes);
                }
                else
                {
                    lYes = values.First(
                        c =>
                            c.SystemEntryID.Equals(SystemEntryID.AdditionalServiceAssessmentSheet) &&
                            c.Description.Equals(lYes.Description));
                }

                if (!noExists)
                {
                    DAOFactory.GenericDAO.Insert(lNo);
                }
                else
                {
                    lNo = values.First(
                        c =>
                            c.SystemEntryID.Equals(SystemEntryID.AdditionalServiceAssessmentSheet) &&
                            c.Description.Equals(lNo.Description));
                }

                if (!lCategory.PossibleValues.Contains(lYes))
                    DAOFactory.AdoDAO.ExecuteQuery(string.Format("INSERT INTO assessmentsheetcategory2assessmentsheetvalue(assessmentsheetcategoryoid, assessmentsheetvalueoid) VALUES({0}, {1})", lCategory.Oid.Value, lYes.Oid.Value));

                if (!lCategory.PossibleValues.Contains(lNo))
                    DAOFactory.AdoDAO.ExecuteQuery(string.Format("INSERT INTO assessmentsheetcategory2assessmentsheetvalue(assessmentsheetcategoryoid, assessmentsheetvalueoid) VALUES({0}, {1})", lCategory.Oid.Value, lNo.Oid.Value));

                var entryList = new List<AssessmentSheetEntry>();
                string sqlString = string.Empty;

                foreach (Customer2AddServiceBooking customerParticipated in pAdditionalServiceBookingDC.Customer2AddServiceBookings)
                {
                    var customer = DAOFactory.GenericDAO.GetByID<Customer>(customerParticipated.CustomerOid);
                    entryList.Add(new AssessmentSheetEntry
                    {
                        Customer = customer,
                        AssessmentSheetCategory = lCategory,
                        AssessmentSheetValue = (customerParticipated.Participated ? lYes : lNo),
                        SystemEntryID = SystemEntryID.AdditionalServiceAssessmentSheet,
                        Day = pAdditionalServiceBookingDC.Datum
                    });
                    IList<AssessmentSheetCategory> customer2Category = DAOFactory.GenericDAO.GetAll<AssessmentSheetCategory>();
                    AssessmentSheetCategory f = customer2Category.First(
                        abc =>
                            abc.SystemEntryID.Equals(SystemEntryID.AdditionalServiceAssessmentSheet) &&
                            abc.Description.Equals(lCategory.Description));

                    if (f.Customers == null || !f.Customers.Contains(customer))
                        sqlString += string.Format("INSERT INTO customer2assessmentsheetcategory(customeroid, assessmentsheetoid) VALUES({0}, {1});", customer.Oid.Value, lCategory.Oid.Value);
                }

                DAOFactory.GenericDAO.Insert(entryList);
                DAOFactory.AdoDAO.ExecuteQuery(sqlString);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        // ToDo: Unterschriftenbemerkung hier einbauen
        private static void MakeServiceRecordHistoryEntry(List<ServiceRecord> lOriginals, IEnumerable<long> serviceRecordOidList, StatementType statementType)
        {
            var serviceRecordHistoryEntries = new List<ServiceRecordHistory>();

            if (statementType.Equals(StatementType.Insert) && serviceRecordOidList != null)
            {
                var iterator = 0;
                foreach (var history in lOriginals.Select(serviceRecordOriginal => new ServiceRecordHistory
                {
                    TimeStamp = DateTime.Now,
                    ChangeType = statementType,
                    CostBearer2SupportConcept = serviceRecordOriginal.CostBearer2SupportConcept,
                    CostBearer2SupportConceptOid = serviceRecordOriginal.CostBearer2SupportConceptOid,
                    Customer = serviceRecordOriginal.Customer,
                    CustomerOid = serviceRecordOriginal.CustomerOid,
                    Employee = serviceRecordOriginal.Employee,
                    EmployeeOid = serviceRecordOriginal.EmployeeOid,
                    End = serviceRecordOriginal.End,
                    Group = serviceRecordOriginal.Group,
                    GroupEmployeeCount = serviceRecordOriginal.GroupEmployeeCount,
                    GroupOid = serviceRecordOriginal.GroupOid,
                    GroupPersonCount = serviceRecordOriginal.GroupPersonCount,
                    GroupRoundedDuration = serviceRecordOriginal.GroupRoundedDuration,
                    IP = serviceRecordOriginal.IP,
                    IsActive = serviceRecordOriginal.IsActive,
                    Notice = serviceRecordOriginal.Notice,
                    ServiceRecordOid = serviceRecordOidList.ElementAt(iterator),
                    RoundedDuration = serviceRecordOriginal.RoundedDuration,
                    ServiceDescription = serviceRecordOriginal.ServiceDescription,
                    ServiceRecordType = serviceRecordOriginal.ServiceRecordType,
                    ServiceRecordInsTs = serviceRecordOriginal.InsTs,
                    ServiceRecordVersion = serviceRecordOriginal.Version ?? 0,
                    ServiceRecordInsUser = serviceRecordOriginal.InsUser,
                    ServiceRecordUdpUser = serviceRecordOriginal.UdpUser,
                    Start = serviceRecordOriginal.Start,
                    SupportConcept = serviceRecordOriginal.SupportConcept,
                    SystemEntryID = serviceRecordOriginal.SystemEntryID,
                    DistanceInMeter = serviceRecordOriginal.DistanceInMeter,
                    IsCreatedInMobileClient = serviceRecordOriginal.IsCreatedInMobileClient
                }))
                {
                    iterator++;
                    serviceRecordHistoryEntries.Add(history);
                }
            }
            else
            {
                foreach (var original in lOriginals)
                {
                    SignatureStateInfoFromServiceRecordHistoryEntry previousRecordHistorySignatureInfo = null;

                    if (original.Oid.HasValue)
                    {
                        previousRecordHistorySignatureInfo = DAOFactory.SearchDAO.FindMostRecentSignatureStatusInfoByServiceRecordOid(original.Oid.Value);
                    }

                    serviceRecordHistoryEntries.AddIfNotIn(new ServiceRecordHistory
                    {
                        TimeStamp = DateTime.Now,
                        ChangeType = statementType,
                        CostBearer2SupportConcept = original.CostBearer2SupportConcept,
                        CostBearer2SupportConceptOid = original.CostBearer2SupportConceptOid,
                        Customer = original.Customer,
                        CustomerOid = original.CustomerOid,
                        Employee = original.Employee,
                        EmployeeOid = original.EmployeeOid,
                        End = original.End,
                        Group = original.Group,
                        GroupEmployeeCount = original.GroupEmployeeCount,
                        GroupOid = original.GroupOid,
                        GroupPersonCount = original.GroupPersonCount,
                        GroupRoundedDuration = original.GroupRoundedDuration,
                        IP = original.IP,
                        IsActive = original.IsActive,
                        Notice = original.Notice,
                        ServiceRecordOid = original.Oid,
                        RoundedDuration = original.RoundedDuration,
                        ServiceDescription = original.ServiceDescription,
                        ServiceRecordType = original.ServiceRecordType,
                        ServiceRecordInsTs = original.InsTs,
                        ServiceRecordVersion = original.Version ?? 0,
                        ServiceRecordInsUser = original.InsUser,
                        ServiceRecordUdpUser = original.UdpUser,
                        Start = original.Start,
                        SupportConcept = original.SupportConcept,
                        SystemEntryID = original.SystemEntryID,
                        DistanceInMeter = original.DistanceInMeter,
                        IsCreatedInMobileClient = original.IsCreatedInMobileClient,
                        ServiceRecordSignatureStateType = previousRecordHistorySignatureInfo?.ServiceRecordSignatureStateType ?? SignatureStateType.None,
                        CustomerConfirmationReceiptSignatureStateType = previousRecordHistorySignatureInfo?.CustomerConfirmationReceiptSignatureStateType ?? SignatureStateType.None,
                        EmployeeConfirmationReceiptSignatureStateType = previousRecordHistorySignatureInfo?.EmployeeConfirmationReceiptSignatureStateType ?? SignatureStateType.None,
                        CustomerConfirmationReceiptSignatureOid = previousRecordHistorySignatureInfo?.CustomerConfirmationReceiptSignatureOid,
                        EmployeeConfirmationReceiptSignatureOid = previousRecordHistorySignatureInfo?.EmployeeConfirmationReceiptSignatureOid
                    });
                }
            }

            DAOFactory.GenericDAO.Insert(serviceRecordHistoryEntries);
        }

        public IList<TextModuleDC> GetAllTextModules()
        {
            try
            {
                var allTextModules = DAOFactory.GenericDAO.GetAll<TextModule>();

                return MapperFactory.TextModuleDC_TextModule.CreateDcList(allTextModules);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public IList<TextModuleDC> GetTextModules(bool pShouldShowAllTextModules, long pEmployeeOid, bool pHasRightToSeeAllTextModules, bool pIsInAdministrationView)
        {
            try
            {
                var textmodules = DAOFactory.SearchDAO.GetActiveTextModules(pShouldShowAllTextModules, pHasRightToSeeAllTextModules, pIsInAdministrationView, pEmployeeOid);

                var abc = textmodules.FirstOrDefault(f => f.Oid == 41);
                var isActive = abc?.IsActive;

                var list = MapperFactory.TextModuleDC_TextModule.CreateDcList(textmodules);

                var abcDC = list.FirstOrDefault(f => f.TextModuleOid == 41);
                var activationType = abcDC?.ActivationType;

                return list.OrderBy(t => t.Name).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public IList<TextModuleDC> GetTextModulesByServiceCategory(long pServiceCategoryOid)
        {
            try
            {
                return MapperFactory.TextModuleDC_TextModule.MapToNewDCs(DAOFactory.SearchDAO.GetActiveTextModuleByServiceCategory(pServiceCategoryOid));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public IList<long> InsertNewTextModules(IEnumerable<TextModuleDC> pTextbausteine)
        {
            try
            {
                var lTextbausteine = MapperFactory.TextModuleDC_TextModule.MapToNewEntities(pTextbausteine);

                foreach (var tm in lTextbausteine)
                {
                    tm.IsActive = ActivationTypeId.Active;
                }
                DAOFactory.GenericDAO.Insert(lTextbausteine);

                return lTextbausteine.Select(asb => asb.Oid.Value).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateTextModules(List<TextModuleDC> pTextbausteine)
        {
            try
            {
                var lOriginals = DAOFactory.GenericDAO.LoadByIDs<TextModule>(pTextbausteine.Select(sc => sc.TextModuleOid.Value));
                foreach (var item in pTextbausteine)
                {
                    item.ActivationType = ActivationTypeId.Active;
                }
                MapperFactory.TextModuleDC_TextModule.MergeWithEntitys(pTextbausteine, lOriginals);

                DAOFactory.GenericDAO.Update(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteTextModules(Dictionary<long, long> pOid2Version)
        {
            try
            {
                var lOriginals = DAOFactory.GenericDAO.LoadByIDs<TextModule>(pOid2Version.Select(e => e.Key));
                lOriginals.DoForEach(or => MapperFactory.TextModuleDC_TextModule.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));

                IList<TextModule> modulesToDelete = new List<TextModule>();

                foreach (var textModule in lOriginals)
                {
                    AddModuleAndChildsToList(textModule, modulesToDelete);
                }

                DAOFactory.GenericDAO.Delete(modulesToDelete);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        private void AddModuleAndChildsToList(TextModule textModule, IList<TextModule> modulesToDelete)
        {
            var children = DAOFactory.SearchDAO.GetChildTextModules(textModule);

            foreach (var child in children)
            {
                AddModuleAndChildsToList(child, modulesToDelete);
            }

            modulesToDelete.Add(textModule);
        }

        public IList<ServiceRecordDC> FindServiceRecordsInSpan(long pCostBearer2SupportConceptOid, DateTimeSpan period)
        {
            try
            {
                var records = DAOFactory.SearchDAO.FindServiceRecordsInSpan(pCostBearer2SupportConceptOid, period);
                return MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(records);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public SignatureDC InsertSignature(SignatureDC s)
        {
            try
            {
                var lSignature = MapperFactory.SignatureDC_Signature.MapToNewEntity(s);
                DAOFactory.GenericDAO.Insert(lSignature);
                var updatedSignatureDC = MapperFactory.SignatureDC_Signature.MapToNewDC(lSignature);

                if (s.ServiceRecordOid is null)
                {
                    if (s.BargeldtransaktionsOid.HasValue)
                    {
                        var transaction = DAOFactory.GenericDAO.LoadByID<Bargeldtransaktion>(s.BargeldtransaktionsOid.Value);

                        CreateTransactionHistoryObject(transaction, StatementType.Signature, SignatureStateType.Valid);
                    }

                    return updatedSignatureDC;
                }

                var sr = DAOFactory.GenericDAO.LoadByID<ServiceRecord>(s.ServiceRecordOid.Value);

                sr.SignatureOid = lSignature.Oid;

                DAOFactory.GenericDAO.Update(sr);

                MakeSignatureStatusTypeServiceRecordHistoryEntry(sr, SignatureStateType.Valid, null, null, null, null);

                return updatedSignatureDC;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }


        public EmployeeAPPCodeDC CreateNewEmployeeAPPCodeDC(long employeeOid, string kundennummer, string apikey)
        {
            try
            {
#if DEBUG
                kundennummer = "0000000001";
                apikey = "0b50c09aff87f20d9ced75340e04e5ccaa11dd3e7bcf25e9c4f94dc20d3cbb97";
#endif
                var appCodes = DAOFactory.SearchDAO.FindAllEmployeeAppCodes(employeeOid).ToList();

                if (appCodes.Any(c => !string.IsNullOrWhiteSpace(c.EmployeeCode)))
                {
                    var response = DeletZufallsCode(apikey, kundennummer, "E" + employeeOid);

                    if (response != 0)
                    {
                        return new EmployeeAPPCodeDC { Result = response };
                    }
                }

                var zufallscode = ErzeugeZufallsCode(apikey, kundennummer, "E" + employeeOid);

                if (zufallscode != null)
                {
                    var appcodes = DAOFactory.SearchDAO.FindAllEmployeeAppCodes(employeeOid).ToList();

                    var newCode = appcodes.Count > 0 ? appcodes[0] : new EmployeeAPPCode { EmployeeOid = employeeOid };

                    newCode.EmployeeCode = zufallscode;
                    newCode.EmployeeCodeGenDate = DateTime.Now;
                    newCode.NotfallStatement = string.Empty;
                    newCode.IsChatAktiv = 1;

                    DAOFactory.GenericDAO.Insert(newCode);

                    var employeeAppCodeDC = MapperFactory.EmployeeAPPCodeDC_EmployeeAPPCode.MapToNewDC(newCode);

                    return employeeAppCodeDC;
                }

                return null;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateIsChatActiveEmployeeAPPCodeDC(long employeeOid, int activeType)
        {
            try
            {
                var employeecode = DAOFactory.SearchDAO.FindAllEmployeeAppCodes(employeeOid).ToList();

                foreach (var items in employeecode)
                {
                    items.IsChatAktiv = activeType == 1 ? activeType : 0;
                }

                DAOFactory.GenericDAO.Update(employeecode);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateNotfallNacrichtEmployeeAPPCodeDC(long employeeOid, String notfallstate)
        {
            try
            {
                var employeecode = DAOFactory.SearchDAO.FindAllEmployeeAppCodes(employeeOid).ToList();

                foreach (var items in employeecode)
                {
                    items.NotfallStatement = notfallstate;
                }


                DAOFactory.GenericDAO.Update(employeecode);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }


        public CustomerAPPCodeDC CreateNewCustomerAPPCodeDC(long customerOid, string kundennummer, string apikey)
        {
            try
            {
#if DEBUG
                kundennummer = "0000000001";
                apikey = "0b50c09aff87f20d9ced75340e04e5ccaa11dd3e7bcf25e9c4f94dc20d3cbb97";
#endif

                var aa = DAOFactory.SearchDAO.FindAllCustomerAppCodes(customerOid).ToList();
                bool isOk = false;
                if (aa.Where(c => !String.IsNullOrWhiteSpace(c.CustomerCode)).Count() > 0)
                {
                    var response = DeletZufallsCode(apikey, kundennummer, "C" + customerOid);

                    if (response == 0)
                    {
                        isOk = true;
                    }
                    else
                    {
                        CustomerAPPCodeDC appcode = new CustomerAPPCodeDC();

                        appcode.Result = response;

                        return appcode;
                    }
                }
                else
                {
                    isOk = true;
                }


                if (isOk)
                {
                    string zufallscode = ErzeugeZufallsCode(apikey, kundennummer, "C" + customerOid);

                    if (zufallscode != null)
                    {
                        var appcodes = DAOFactory.SearchDAO.FindAllCustomerAppCodes(customerOid).ToList();
                        CustomerAPPCode newCode = null;
                        if (appcodes.Count > 0)
                        {
                            newCode = appcodes[0];
                        }
                        else
                        {
                            newCode = new CustomerAPPCode();
                            newCode.CustomerOid = customerOid;
                        }

                        newCode.CustomerCode = zufallscode; //bei C noch die UserID mitgeben
                        newCode.CustomerCodeGenDate = DateTime.Now;
                        newCode.IsChatAktiv = 1;

                        DAOFactory.GenericDAO.Insert(newCode);

                        var customerAPPCodeDC = MapperFactory.CustomerAPPCodeDC_CustomerAPPCode.MapToNewDC(newCode);

                        return customerAPPCodeDC;
                    }
                    else
                    {
                        return null;
                    }
                }
                else
                {
                    return null;
                }
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public ChatMessageDC CreateNewChatMessagesDC(long senderOid, long empfängerOid, string message, bool isDeliverd, long teamid, string messageid)
        {
            try
            {
                var chatMessage = new ChatMessage
                {
                    EmpfaengerPersonOid = empfängerOid,
                    SenderPersonOid = senderOid,
                    Uhrzeit = DateTime.Now,
                    IsDelivered = isDeliverd,
                    ChatText = Encoding.UTF8.GetBytes(message),
                    IstGelesen = 0,
                    MessageId = messageid

                };

                if (teamid != 0)
                {
                    chatMessage.TeamOid = teamid;
                }
                else
                {
                    chatMessage.TeamOid = null;
                }

                DAOFactory.GenericDAO.Insert(chatMessage);

                var ChatMessagesDC = MapperFactory.ChatMessagesDC_ChatMessages.MapToNewDC(chatMessage);

                return ChatMessagesDC;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateIsChatActiveCustomerAPPCodeDC(long customerOid, int activeType)
        {
            try
            {
                var customerChatCodes = DAOFactory.SearchDAO.FindAllCustomerAppCodes(customerOid).ToList();

                foreach (var items in customerChatCodes)
                {
                    items.IsChatAktiv = activeType == 1 ? activeType : 0;
                }

                DAOFactory.GenericDAO.Update(customerChatCodes);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public IList<CustomerAPPCodeDC> GetIsChatActiveCustomerAPPCodeDC(long customerOid, int activeType)
        {
            try
            {
                var customercode = DAOFactory.SearchDAO.FindAllCustomerAppCodes(customerOid);

                return MapperFactory.CustomerAPPCodeDC_CustomerAPPCode.MapToNewDCs(customercode);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public int DeletZufallsCode(string apikey, string customerId, string userId)
        {
            try
            {
#if DEBUG
                customerId = "0000000001";
                apikey = "0b50c09aff87f20d9ced75340e04e5ccaa11dd3e7bcf25e9c4f94dc20d3cbb97";
                //customerId = "4526293996";
#endif

                var serverUrl = OwnChatHelper.ErmittleServerURL(customerId);

                if (serverUrl.IsNullOrEmpty())
                {
                    return 3; // ServerURl konnte nicht ermittelt werden 
                }

                try
                {
                    ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

                    var url = $"{serverUrl}/api/ownchat/chatcode/revoke/{apikey}/{customerId}/{userId}";

                    var client = new RestClient(url);
                    var request = new RestRequest(Method.GET);

                    var response = client.Execute(request);

                    var result = JsonConvert.DeserializeAnonymousType(response.Content, new { Result = string.Empty });

                    return Convert.ToInt32(result.Result);
                }
                catch (Exception e)
                {
                    throw Utils.CreateBeWoFaultException(e);
                }
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public string ErzeugeZufallsCode(string apikey, string customerId, string userId)
        {

            var serverUrl = OwnChatHelper.ErmittleServerURL(customerId);

            try
            {
                ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

                var url = $"{serverUrl}/api/ownchat/chatcode/create/{apikey}/{customerId}/{userId}";

                var client = new RestClient(url);
                var request = new RestRequest(Method.GET);

                var response = client.Execute(request);

                var result = JsonConvert.DeserializeAnonymousType(response.Content, new { Result = string.Empty, ChatCode = string.Empty });

                return !result.Result.Equals("0") ? null : result.ChatCode;

                //var request = WebRequest.Create(url);

                //request.Credentials = CredentialCache.DefaultCredentials;

                //var response = request.GetResponse();

                //var responseFromServer = ReadStreamForChatCode(response);

                //var definiti = new {result = string.Empty, chatcode = string.Empty };

                //var jsonDatentyp = JsonConvert.DeserializeAnonymousType(responseFromServer, definiti);

                //response.Close();

                //return !jsonDatentyp.result.Equals("0") ? null : jsonDatentyp.chatcode;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        //private static string ErmittleServerURL(string customerId)
        //{
        //    try
        //    {
        //        ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

        //        var url = "https://dict.ownchat.de/api/server/resolve/1/" + customerId;

        //        var client = new RestClient(url);
        //        var request = new RestRequest(Method.GET);

        //        var response = client.Execute(request);

        //        var result = JsonConvert.DeserializeAnonymousType(response.Content, new { Status = string.Empty, Url = string.Empty, SyncType = string.Empty });

        //        return result.Url;
        //    }
        //    catch (Exception e)
        //    {
        //        throw Utils.CreateBeWoFaultException(e);
        //    }
        //}

        private static string ReadStreamForChatCode(WebResponse response)
        {
            try
            {
                var dataStream = response.GetResponseStream();

                var reader = new StreamReader(dataStream);

                var responseFromServer = reader.ReadToEnd();

                dataStream.Dispose();
                reader.Dispose();

                dataStream.Close();
                reader.Close();

                return responseFromServer;
            }
            catch (Exception)
            {
                return null;
            }
        }

        public List<ChatMessageDC> FindUnreadChatMessagesForRecipient(long personOid)
        {
            try
            {
                var chatMessage = DAOFactory.SearchDAO.FindUnreadChatMessagesForRecipient(personOid);

                var ChatMessagesDC = MapperFactory.ChatMessagesDC_ChatMessages.MapToNewDCs(chatMessage);

                return ChatMessagesDC;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public long InsertNewServiceRecordAndSignature(ServiceRecordDC sr, SignatureDC sig)
        {
            try
            {
                var dcList = new List<ServiceRecordDC> { sr };

                var oidList = InsertNewServiceRecords(dcList);
                var serviceRecordOid = oidList[0];

                if (!string.IsNullOrEmpty(sig.DataBild))
                {
                    var lSignature = MapperFactory.SignatureDC_Signature.MapToNewEntity(sig);

                    DAOFactory.GenericDAO.Insert(lSignature);

                    var serviceRecord = DAOFactory.GenericDAO.LoadByID<ServiceRecord>(serviceRecordOid);

                    MakeSignatureStatusTypeServiceRecordHistoryEntry(serviceRecord, SignatureStateType.Valid, null, null, null, null);
                }

                return serviceRecordOid;

            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public string CreateDefaultServiceRecords(DateTime monat, IList<long> oids)
        {
            try
            {
                var s = PluginLoader.FindClass<SchulbegleitenderDienstService>();

                return s.CreateDefaultServiceRecords(monat, oids);

            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public String CreateDefaultCustomerServiceRecords(DateTime start, DateTime end, IList<long> customerOids)
        {
            try
            {
                var s = PluginLoader.FindClass<OperationService>();

                return s.CreateDefaultCustomerServiceRecords(start, end, customerOids);

            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public List<OrganisationPersonRelationDC> LoadOrganisationPersonRelationsByOid(IEnumerable<long> pOids)
        {
            try
            {
                var customerPersonRels = DAOFactory.GenericDAO.LoadByIDs<Organisation2Person>(pOids);

                return MapperFactory.OrganisationPersonRelDC_Organisation2PersonMapper.MapToNewDCs(customerPersonRels);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ArbeitszeitDC> LoadArbeitszeitenForObject(TableID objectTid, long objectOid)
        {
            try
            {
                var arbeitszeiten = DAOFactory.SearchDAO.FindArbeitszeiten(objectTid, objectOid);

                return MapperFactory.ArbeitszeitDC_Arbeitszeit.MapToNewDCs(arbeitszeiten);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<BargeldkassenDC> LoadBargeldkassenForObject(TableID objectTid, long objectOid)
        {
            try
            {
                var bargeldkassen = DAOFactory.SearchDAO.FindBargeldkasse(objectTid, objectOid);

                return MapperFactory.BargeldkassenDCBargeldkasseDC_BargeldkassenDCBargeldkasse.MapToNewDCs(bargeldkassen);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public long InsertNewBargeldkasse(BargeldkassenDC pBargeldkasse)
        {
            try
            {
                var lBargeldkasse = MapperFactory.BargeldkassenDCBargeldkasseDC_BargeldkassenDCBargeldkasse.MapToNewEntity(pBargeldkasse);
                DAOFactory.GenericDAO.Insert(lBargeldkasse);

                return lBargeldkasse.Oid.Value;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public BargeldkassenDC UpdateBargeldkasse(BargeldkassenDC pBargeldkasse)
        {
            try
            {
                var lOriginal = DAOFactory.GenericDAO.LoadByID<Bargeldkasse>(pBargeldkasse.BargeldkassenOid.Value);

                #region Transaktionshistorie

                var changedTransactionOids = new List<long>();
                var transactionHistoryEntries = new List<Bargeldtransaktionshistory>();

                // Oid zu Änderungsart und Unterschriftenstatus zum Speichern nach dem Bargeldkassen-Update
                var oids2ChangeTypes = new Dictionary<long, KeyValuePair<StatementType, SignatureStateType>>();

                // Oids der Unterschriften, die durch die Änderung ungültig wurden
                var signatureOids2Delete = new List<long>();

                // Die unveränderten Transaktionen laden, um sie mit den geänderten zu vergleichen und herauszufinden, was geändert wurde.
                var originalTransactions = MapperFactory.BargeldtransaktionDC_Bargeldtransaktion.MapToNewDCs(lOriginal.Bargeldtransaktionen);

                // Die Oids der gelöschten Transaktionen, um die damit verbundenen Unterschriften zu löschen
                var deletedOids = new List<long>();

                foreach (var originalTransaction in originalTransactions)
                {
                    var changedOrDeletedTransactionDC = pBargeldkasse.Bargeldtransaktionen.FirstOrDefault(transaction => transaction.BargeldtransaktionOid.HasValue && transaction.BargeldtransaktionOid.Value.Equals(originalTransaction.BargeldtransaktionOid.Value));

                    // Die Transaktion wurde entfernt
                    if (changedOrDeletedTransactionDC is null && originalTransaction.BargeldtransaktionOid.HasValue)
                    {
                        if (originalTransaction.SignatureOid.HasValue)
                        {
                            signatureOids2Delete.AddRangeIfElementsNotIn(DAOFactory.SearchDAO.LoadSignatureOidsByTransaktionOid(originalTransaction.BargeldtransaktionOid.Value));
                            signatureOids2Delete.AddIfNotIn(originalTransaction.SignatureOid.Value);
                        }

                        deletedOids.AddIfNotIn(originalTransaction.BargeldtransaktionOid.Value);
                    }

                    // Die Transaktion ist nicht neu und wurde geändert
                    if ((changedOrDeletedTransactionDC?.BargeldtransaktionOid.HasValue ?? false) && !originalTransaction.Equals(changedOrDeletedTransactionDC))
                    {
                        // Es wurde eine Transaktion unterschrieben.
                        if (originalTransaction.SignatureOid is null && changedOrDeletedTransactionDC.SignatureOid.HasValue)
                        {
                            oids2ChangeTypes.AddIfNotIn(
                                new KeyValuePair<long, KeyValuePair<StatementType, SignatureStateType>>(
                                    changedOrDeletedTransactionDC.BargeldtransaktionOid.Value,
                                    new KeyValuePair<StatementType, SignatureStateType>(StatementType.Signature, SignatureStateType.Valid)));
                        }
                        else // Es wurde eine andere Eigenschaft geändert als die Unterschrift
                        {
                            var newSignatureState = SignatureStateType.None;

                            // Wenn die Transaktion eine Unterschrift vor der Änderung hatte, wird diese als ungültig gespeichert und gelöscht.
                            if (changedOrDeletedTransactionDC.SignatureOid.HasValue)
                            {
                                newSignatureState = SignatureStateType.Invalid;

                                signatureOids2Delete.AddRangeIfElementsNotIn(DAOFactory.SearchDAO.LoadSignatureOidsByTransaktionOid(changedOrDeletedTransactionDC.BargeldtransaktionOid.Value));
                                signatureOids2Delete.AddIfNotIn(changedOrDeletedTransactionDC.SignatureOid.Value);
                                changedOrDeletedTransactionDC.SignatureOid = null;
                            }
                            // Die Unterschrift wurde gelöscht
                            else if (changedOrDeletedTransactionDC.SignatureOid is null && originalTransaction.SignatureOid.HasValue)
                            {
                                signatureOids2Delete.AddRangeIfElementsNotIn(DAOFactory.SearchDAO.LoadSignatureOidsByTransaktionOid(changedOrDeletedTransactionDC.BargeldtransaktionOid.Value));
                                newSignatureState = SignatureStateType.ManuallyDeleted;
                            }

                            oids2ChangeTypes.AddIfNotIn(new KeyValuePair<long, KeyValuePair<StatementType, SignatureStateType>>(
                                changedOrDeletedTransactionDC.BargeldtransaktionOid.Value,
                                new KeyValuePair<StatementType, SignatureStateType>(StatementType.Update, newSignatureState)));
                        }

                        changedTransactionOids.AddIfNotIn(changedOrDeletedTransactionDC.BargeldtransaktionOid.Value);
                    }
                }
                #endregion

                var deletedTransactions = DAOFactory.GenericDAO.LoadByIDs<Bargeldtransaktion>(deletedOids);
                var signatures2Delete = new List<Signature>();

                // Die Transaktion wurde gelöscht
                foreach (var deletedTransaction in deletedTransactions)
                {
                    var signatureStateType = SignatureStateType.None;

                    if (deletedTransaction.SignatureOid.HasValue)
                    {
                        var signature = DAOFactory.GenericDAO.LoadByID<Signature>(deletedTransaction.SignatureOid.Value);
                        signatures2Delete.Add(signature);
                        deletedTransaction.SignatureOid = null;
                        signatureStateType = SignatureStateType.ManuallyDeleted;
                    }

                    transactionHistoryEntries.Add(CreateTransactionHistoryObject(deletedTransaction, StatementType.Delete, signatureStateType));
                }

                MapperFactory.BargeldkassenDCBargeldkasseDC_BargeldkassenDCBargeldkasse.MergeWithEntity(pBargeldkasse, lOriginal);

                var newTransactions = lOriginal.Bargeldtransaktionen.Where(transaction => transaction.Oid is null).ToList();

                DAOFactory.GenericDAO.Update(lOriginal);

                // Nach dem Insert der neuen Transaktionen haben diese eine Oid und es können die History-Einträge gemacht werden
                foreach (var newTransaction in newTransactions)
                {
                    transactionHistoryEntries.Add(CreateTransactionHistoryObject(newTransaction, StatementType.Insert, SignatureStateType.None));
                }

                // Die History-Einträge für die bearbeiteten werden gemacht
                foreach (var oid2ChangeTypes in oids2ChangeTypes)
                {
                    var editedTransaction = lOriginal.Bargeldtransaktionen.FirstOrDefault(transaction => transaction.Oid.HasValue && transaction.Oid.Value.Equals(oid2ChangeTypes.Key));

                    if (editedTransaction is null)
                    {
                        continue;
                    }

                    transactionHistoryEntries.Add(CreateTransactionHistoryObject(editedTransaction, oid2ChangeTypes.Value.Key, oid2ChangeTypes.Value.Value));
                }

                DAOFactory.GenericDAO.Insert(transactionHistoryEntries);

                signatureOids2Delete.AddRangeIfElementsNotIn(signatures2Delete.Where(s => s.Oid.HasValue).Select(s => s.Oid.Value));

                DAOFactory.GenericDAO.Delete(DAOFactory.GenericDAO.LoadByIDs<Signature>(signatureOids2Delete));

                return MapperFactory.BargeldkassenDCBargeldkasseDC_BargeldkassenDCBargeldkasse.MapToNewDC(lOriginal);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteBargeldtransaktionSignature(long signatureOid)
        {
            try
            {
                var signature2Delete = DAOFactory.GenericDAO.LoadByID<Signature>(signatureOid);

                DAOFactory.GenericDAO.Delete(signature2Delete);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateBargeldkasse(long pOid, long pVersion)
        {
            try
            {
                var bargeldkasse = DAOFactory.GenericDAO.LoadByID<Bargeldkasse>(pOid);

                var signatures2Delete = DAOFactory.SearchDAO.LoadSignaturesByTransactionOids(bargeldkasse.Bargeldtransaktionen.Where(transaction => transaction.SignatureOid.HasValue).Select(transaction => transaction.SignatureOid.Value).ToList());

                var historyEntries = new List<Bargeldtransaktionshistory>();

                foreach (var transaction in bargeldkasse.Bargeldtransaktionen)
                {
                    var signatureState = transaction.SignatureOid is null ? SignatureStateType.None : SignatureStateType.AutomaticallyDeleted;
                    historyEntries.Add(CreateTransactionHistoryObject(transaction, StatementType.Delete, signatureState));
                }

                DAOFactory.GenericDAO.Delete(signatures2Delete);

                DAOFactory.GenericDAO.Insert(historyEntries);

                ServiceLogic.SetActivationType<Bargeldkasse>(new Dictionary<long, long> { { pOid, pVersion } }, ActivationTypeId.Deleted);

                // SignatureOids aus den Transaktionen löschen, da die Signature-Objekte gelöscht wurden
                bargeldkasse = DAOFactory.GenericDAO.LoadByID<Bargeldkasse>(pOid);
                foreach (var transaction in bargeldkasse.Bargeldtransaktionen)
                {
                    transaction.SignatureOid = null;
                }

                DAOFactory.GenericDAO.Update(bargeldkasse);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        private static Bargeldtransaktionshistory CreateTransactionHistoryObject(Bargeldtransaktion transaction, StatementType changeType, SignatureStateType signatureState)
        {
            return new Bargeldtransaktionshistory
            {
                Betrag = transaction.Betrag,
                BargeldtransaktionOid = transaction.Oid,
                BargeldtransaktionInsTs = transaction.InsTs,
                BargeldtransaktionInsUser = transaction.InsUser,
                BargeldtransaktionUdpUser = transaction.UdpUser,
                BargeldtransaktionVersion = transaction.Version,
                ChangeType = changeType,
                Belegnummer = transaction.Belegnummer,
                Notice = transaction.Notice,
                IsActive = ActivationTypeId.Active,
                SignatureOid = transaction.SignatureOid,
                SignatureState = signatureState,
                Zahlungstyp = transaction.Zahlungstyp,
                Zahlungsdatum = transaction.Zahlungsdatum
            };
        }

        public List<NotizenKategorieDC> LoadNotizenKategorienForObject(TableID objectTid, long objectOid)
        {
            try
            {
                var kategorien = DAOFactory.SearchDAO.FindNotizenKategorien(objectTid, objectOid);

                if (kategorien.Count == 0)
                {
                    var newKat = new NotizenKategorie();
                    newKat.KategorieName = "Gesprächsnotizen";
                    newKat.ObjectOid = objectOid;
                    newKat.ObjectTid = objectTid;
                    DAOFactory.GenericDAO.Insert(newKat);

                    kategorien.Add(newKat);
                }

                return MapperFactory.NotizenKategorieDC_NotizenKategorie.MapToNewDCs(kategorien.Where(k => k.IsActive == ActivationTypeId.Active));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public long InsertNewNotizenKategorie(NotizenKategorieDC kategorie)
        {
            try
            {
                var entity = MapperFactory.NotizenKategorieDC_NotizenKategorie.MapToNewEntity(kategorie);
                DAOFactory.GenericDAO.Insert(entity);

                return entity.Oid.Value;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public NotizenKategorieDC UpdateNotizenKategorie(NotizenKategorieDC kategorie)
        {
            try
            {
                var lOriginal = DAOFactory.GenericDAO.LoadByID<NotizenKategorie>(kategorie.NotizenKategorieOid.Value);
                kategorie.NotizenKategorieVersion = lOriginal.Version;

                MapperFactory.NotizenKategorieDC_NotizenKategorie.MergeWithEntity(kategorie, lOriginal);
                DAOFactory.GenericDAO.Update(lOriginal);

                return MapperFactory.NotizenKategorieDC_NotizenKategorie.MapToNewDC(lOriginal);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateNotizenEintrag(long pOid, long pVersion)
        {
            try
            {
                ServiceLogic.SetActivationType<NotizenEintrag>(new Dictionary<long, long> { { pOid, pVersion } }, ActivationTypeId.Deleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateNotizenKategorie(long pOid, long pVersion)
        {
            try
            {
                ServiceLogic.SetActivationType<NotizenKategorie>(new Dictionary<long, long> { { pOid, pVersion } }, ActivationTypeId.Deleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateAbsenceTime(Dictionary<long, long> pOid2Version)
        {
            try
            {
                //ServiceLogic.SetActivationType<AbsenceTime>(pOid2Version, ActivationTypeId.Deleted);

                var lOriginals = DAOFactory.GenericDAO.LoadByIDs<AbsenceTime>(pOid2Version.Select(e => e.Key)).Where(e => e.SystemEntryID == null).ToList();
                DAOFactory.GenericDAO.Delete(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void InsertNewEmployeeAbsenceTime(long employeeOid, AbsenceTimeDC at)
        {
            try
            {
                var emp = DAOFactory.GenericDAO.GetByID<Employee>(employeeOid);
                emp.AbsenceTimes.Add(MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewEntity(at));

                DAOFactory.GenericDAO.Update(emp);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void InsertNewCustomerAbsenceTime(long customerOid, AbsenceTimeDC at)
        {
            try
            {
                var cust = DAOFactory.GenericDAO.GetByID<Customer>(customerOid);
                cust.AbsenceTimes.Add(MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewEntity(at));


                DAOFactory.GenericDAO.Update(cust);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteVertretung(long vert)
        {
            try
            {
                var origVertretung = DAOFactory.GenericDAO.LoadByID<Vertretung>(vert);

                DAOFactory.GenericDAO.Delete(origVertretung);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateVertretung(VertretungDC vert)
        {
            try
            {
                var origVertretung = DAOFactory.GenericDAO.LoadByID<Vertretung>(vert.VertretungOid.Value);

                // TODO: Beim Aufruf dieser Methode prüfen, ob eine Vertretung sich mit dem Objekt überschneidet
                var isOverlapping = DAOFactory.SearchDAO.CheckForOverlappingSubstitutions(vert.EmployeeOid, vert.CustomerOid, vert.VertretungsZeitraumVon, vert.VertretungsZeitraumBis, vert.VertretungOid);

                MapperFactory.VertretungDC_Vertretung.MergeWithEntity(vert, origVertretung);

                DAOFactory.GenericDAO.Update(origVertretung);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateVertretungAndAbsenceTime(VertretungDC vert, AbsenceTimeDC abs)
        {
            try
            {
                var origVertretung = DAOFactory.GenericDAO.LoadByID<Vertretung>(vert.VertretungOid.Value);

                MapperFactory.VertretungDC_Vertretung.MergeWithEntity(vert, origVertretung);

                DAOFactory.GenericDAO.Update(origVertretung);


                //Update AbsenceTime  
                var origAbsenceTime = DAOFactory.GenericDAO.LoadByID<AbsenceTime>(abs.AbsenceTimeOid.Value);

                MapperFactory.AbsenceTimeDC_AbsenceTime.MergeWithEntity(abs, origAbsenceTime);

                DAOFactory.GenericDAO.Update(origAbsenceTime);

            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void CreateVertretung(VertretungDC vertretung)
        {
            try
            {
                var vm = PluginLoader.FindClass<VertretungsManager>();

                vm.SaveVertretung(vertretung);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateAbsenceTime(AbsenceTimeDC abs)
        {
            try
            {
                var x = DAOFactory.GenericDAO.LoadByID<AbsenceTime>(abs.AbsenceTimeOid.Value);

                MapperFactory.AbsenceTimeDC_AbsenceTime.MergeWithEntity(abs, x);

                DAOFactory.GenericDAO.Update(x);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<VertretungsItemDC> GetVertretungsListe(DateTime datum)
        {
            try
            {
                var vm = PluginLoader.FindClass<VertretungsManager>();

                return vm.CreateVertretungsListe(datum.Date, datum.Date);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<VertretungsListeMitarbeiterItemsDC> VertretungsMitarbeiterListeWoechentlich(DateTime start, DateTime ende)
        {
            try
            {
                //      VertretungsManager mgr = new VertretungsManager();

                //var x = mgr.CreateVertretungsListe(start, ende);

                //            return x;
                return null;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public VertretungsKlientAccountingsListeItemsDC KlientenAbschlagsInfoListe(DateTime start, DateTime end)
        {
            try
            {
                //VertretungsAlgorithmus alorythmus = new VertretungsAlgorithmus(start, end,3);

                //VertretungsKlientAccountingsListeItemsDC cusAcc = new VertretungsKlientAccountingsListeItemsDC();

                //cusAcc.CustomerAccountItemList = alorythmus.c2a;

                //return cusAcc;
                return null;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<VertretungsItemDC> GetVertretungsListeForTimeSpan(DateTime start, DateTime ende)
        {
            try
            {
                var vm = PluginLoader.FindClass<VertretungsManager>();

                return vm.CreateVertretungsListe(start.Date, ende.Date);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }

        }

        public List<CompactVertreterEmployeeDC> GetLastVertreter(long? klientenOid)
        {
            try
            {
                var vertreterListe = DAOFactory.SearchDAO.FindLastVertretungen(klientenOid.Value);

                List<long> emOidList = new List<long>();

                foreach (var v in vertreterListe)
                {
                    if (v.VertretenderMitarbeiterOid.HasValue)
                    {
                        emOidList.Add(v.VertretenderMitarbeiterOid.Value);
                    }
                }


                var employee = DAOFactory.GenericDAO.GetActiveByIDs<Employee>(emOidList);

                var x = MapperFactory.CompactVertreterEmployeeDC_VertreterEmployee.MapToNewDCs(employee).OrderBy(e => e.LastName).ToList();
                //var x = MapperFactory.CompactEmployeeDC_Employee.MapToNewDCs(employee);

                return x;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<CompactTokenDC> GetAllTokens(SchulbegleitenderZugehoerigkeitsTyp zugehoerigkeitsTyp, long? oid)
        {
            try
            {
                var token = DAOFactory.GenericDAO.GetAllActive<Token>();

                IList<Token> fToken = new List<Token>();

                if (zugehoerigkeitsTyp == SchulbegleitenderZugehoerigkeitsTyp.Klient)
                {
                    IList<Customer2Token> c2tList = new List<Customer2Token>();

                    if (oid.HasValue)
                    {
                        c2tList = DAOFactory.SearchDAO.GetCustomer2TokensByCustomerOid(oid.Value);
                    }


                    foreach (var item in token)
                    {
                        fToken.Add(item);

                        foreach (var c2t in c2tList)
                        {
                            if (item.Oid == c2t.TokenOid)
                            {
                                item.MemberOid = oid;
                            }
                        }
                    }
                }
                else if (zugehoerigkeitsTyp == SchulbegleitenderZugehoerigkeitsTyp.Mitarbeiter)
                {
                    IList<Employee2Token> e2tList = new List<Employee2Token>();

                    if (oid.HasValue)
                    {
                        e2tList = DAOFactory.SearchDAO.GeEmployee2TokensByEmployeeOid(oid.Value);
                    }

                    foreach (var item in token)
                    {
                        fToken.Add(item);

                        foreach (var e2t in e2tList)
                        {
                            if (item.Oid == e2t.TokenOid)
                            {
                                item.MemberOid = oid;

                            }
                        }
                    }
                }

                return MapperFactory.CompactTokenDC_Token.MapToNewDCs(fToken);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateToken(TokenDC token)
        {
            try
            {
                var t = MapperFactory.TokenDC_Token.MapToNewEntity(token);

                DAOFactory.GenericDAO.Update(t);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void InsertNewToken(string beschreibung, TokenTyp typ, SchulbegleitenderZugehoerigkeitsTyp zugehoerigkeitsTyp, long? oid)
        {
            try
            {
                TokenDC token = new TokenDC()
                {
                    Beschreibung = beschreibung,
                    TokenTyp = typ
                };

                if (zugehoerigkeitsTyp == SchulbegleitenderZugehoerigkeitsTyp.Klient)
                {
                    var x = DAOFactory.GenericDAO.GetByID<Customer>(oid.Value);

                    var xyz = MapperFactory.CustomerDC_Customer.MapToNewDC(x);

                    CustomerTokenRelationDC c2t = new CustomerTokenRelationDC()
                    {
                        Customer = xyz
                    };

                    List<CustomerTokenRelationDC> c2tList = new List<CustomerTokenRelationDC>();
                    c2tList.Add(c2t);

                    token.RelatedCustomers = c2tList;

                }
                else if (zugehoerigkeitsTyp == SchulbegleitenderZugehoerigkeitsTyp.Mitarbeiter)
                {
                    var x = DAOFactory.GenericDAO.GetByID<Employee>(oid.Value);

                    var xyz = MapperFactory.EmployeeDC_Employee.MapToNewDC(x);

                    EmployeeTokenRelationDC e2t = new EmployeeTokenRelationDC()
                    {
                        Employee = xyz
                    };

                    List<EmployeeTokenRelationDC> e2tList = new List<EmployeeTokenRelationDC>();
                    e2tList.Add(e2t);

                    token.RelatedEmployees = e2tList;
                }

                var t = MapperFactory.TokenDC_Token.MapToNewEntity(token);

                DAOFactory.GenericDAO.Insert(t);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DoTokenAusschlussOperation(int art, long? Oid, SchulbegleitenderZugehoerigkeitsTyp zugehoerigkeitsTyp, Dictionary<string, CompactTokenDC> verfuegbarerAusschlussToken, string token)
        {
            try
            {
                if (art == 1)
                {
                    if (verfuegbarerAusschlussToken.ContainsKey(token))
                    {
                        CompactTokenDC nToken = null;

                        foreach (var tokenkey in verfuegbarerAusschlussToken)
                        {
                            if (tokenkey.Key.Equals(token))
                            {
                                nToken = tokenkey.Value;
                            }
                        }

                        if (nToken != null)
                        {
                            InsertNewRelationToken(nToken, TokenTyp.AusschlussKriterium, zugehoerigkeitsTyp, Oid);
                        }
                    }
                    else
                    {
                        InsertNewToken(token, TokenTyp.AusschlussKriterium, zugehoerigkeitsTyp, Oid);
                    }
                }

                if (art == 0)
                {
                    if (verfuegbarerAusschlussToken.ContainsKey(token))
                    {
                        CompactTokenDC nToken = null;

                        foreach (var tokenkey in verfuegbarerAusschlussToken)
                        {
                            if (tokenkey.Key.Equals(token))
                            {
                                nToken = tokenkey.Value;
                            }
                        }

                        if (nToken != null)
                        {
                            DeletTokenRelation(nToken, Oid, zugehoerigkeitsTyp);
                        }
                    }
                    else
                    {
                        if (zugehoerigkeitsTyp == SchulbegleitenderZugehoerigkeitsTyp.Klient)
                        {
                            var c2tList = GetCustomer2TokenList();

                            List<CompactTokenDC> otoken = new List<CompactTokenDC>();

                            foreach (var ct2 in c2tList)
                            {
                                if (ct2.Token.Beschreibung.Equals(token) && ct2.Customer.CustomerOid == Oid)
                                {
                                    otoken.Add(ct2.Token);
                                }
                            }

                            foreach (var ken in otoken)
                            {
                                if (ken != null)
                                    DeletTokenRelation(ken, Oid, zugehoerigkeitsTyp);
                            }
                        }
                        else if (zugehoerigkeitsTyp == SchulbegleitenderZugehoerigkeitsTyp.Mitarbeiter)
                        {
                            var e2tList = GetEmployee2TokenList();

                            List<CompactTokenDC> otoken = new List<CompactTokenDC>();

                            foreach (var et2 in e2tList)
                            {

                                if (et2.Token.Beschreibung.Equals(token) && et2.Employee.EmployeeOid == Oid)
                                {
                                    otoken.Add(et2.Token);
                                }
                            }

                            foreach (var ken in otoken)
                            {
                                DeletTokenRelation(ken, Oid, zugehoerigkeitsTyp);
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DoTokenWunschOperation(int art, long? Oid, SchulbegleitenderZugehoerigkeitsTyp zugehoerigkeitsTyp, Dictionary<string, CompactTokenDC> verfuegbarerWunschToken, string token)
        {
            try
            {
                if (art == 1)
                {
                    if (verfuegbarerWunschToken.ContainsKey(token))
                    {
                        CompactTokenDC nToken = null;

                        foreach (var tokenkey in verfuegbarerWunschToken)
                        {
                            if (tokenkey.Key.Equals(token))
                            {
                                nToken = tokenkey.Value;
                            }
                        }

                        if (nToken != null)
                        {
                            InsertNewRelationToken(nToken, TokenTyp.WunschKriterium, zugehoerigkeitsTyp, Oid);
                        }
                    }
                    else
                    {
                        InsertNewToken(token.ToString(), TokenTyp.WunschKriterium, zugehoerigkeitsTyp, Oid);
                    }

                }

                if (art == 0)
                {
                    if (verfuegbarerWunschToken.ContainsKey(token))
                    {
                        CompactTokenDC nToken = null;

                        foreach (var tokenkey in verfuegbarerWunschToken)
                        {
                            if (tokenkey.Key.Equals(token))
                            {
                                nToken = tokenkey.Value;
                            }
                        }

                        if (nToken != null)
                        {
                            DeletTokenRelation(nToken, Oid, zugehoerigkeitsTyp);
                        }
                    }
                    else
                    {
                        if (zugehoerigkeitsTyp == SchulbegleitenderZugehoerigkeitsTyp.Klient)
                        {
                            var c2tList = GetCustomer2TokenList();

                            List<CompactTokenDC> otoken = new List<CompactTokenDC>();

                            foreach (var ct2 in c2tList)
                            {
                                if (ct2.Token.Beschreibung.Equals(token) && ct2.Customer.CustomerOid == Oid)
                                {
                                    otoken.Add(ct2.Token);
                                }
                            }

                            foreach (var ken in otoken)
                            {
                                DeletTokenRelation(ken, Oid, zugehoerigkeitsTyp);
                            }
                        }
                        else if (zugehoerigkeitsTyp == SchulbegleitenderZugehoerigkeitsTyp.Mitarbeiter)
                        {
                            var e2tList = GetEmployee2TokenList();

                            List<CompactTokenDC> otoken = new List<CompactTokenDC>();

                            foreach (var et2 in e2tList)
                            {
                                if (et2.Token.Beschreibung.Equals(token) && et2.Employee.EmployeeOid == Oid)
                                {
                                    otoken.Add(et2.Token);
                                }
                            }

                            foreach (var ken in otoken)
                            {
                                DeletTokenRelation(ken, Oid, zugehoerigkeitsTyp);
                            }
                        }
                    }
                }

            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void InsertNewRelationToken(CompactTokenDC ctoken, TokenTyp typ, SchulbegleitenderZugehoerigkeitsTyp zugehoerigkeitsTyp, long? oid)
        {
            try
            {
                var tk = DAOFactory.GenericDAO.GetByID<Token>(ctoken.TokenOid.Value);

                var token = MapperFactory.TokenDC_Token.MapToNewDC(tk);

                if (zugehoerigkeitsTyp == SchulbegleitenderZugehoerigkeitsTyp.Klient)
                {
                    var x = DAOFactory.GenericDAO.GetByID<Customer>(oid.Value);

                    var xyz = MapperFactory.CustomerDC_Customer.MapToNewDC(x);

                    CustomerTokenRelationDC c2t = new CustomerTokenRelationDC()
                    {
                        Customer = xyz
                    };

                    List<CustomerTokenRelationDC> c2tList = new List<CustomerTokenRelationDC>();
                    c2tList.Add(c2t);

                    token.RelatedCustomers = c2tList;

                }
                else if (zugehoerigkeitsTyp == SchulbegleitenderZugehoerigkeitsTyp.Mitarbeiter)
                {
                    var x = DAOFactory.GenericDAO.GetByID<Employee>(oid.Value);

                    var xyz = MapperFactory.EmployeeDC_Employee.MapToNewDC(x);

                    EmployeeTokenRelationDC e2t = new EmployeeTokenRelationDC()
                    {
                        Employee = xyz
                    };

                    List<EmployeeTokenRelationDC> e2tList = new List<EmployeeTokenRelationDC>();
                    e2tList.Add(e2t);

                    token.RelatedEmployees = e2tList;
                }

                var tok = DAOFactory.GenericDAO.GetByID<Token>(token.TokenOid.Value);

                var t = MapperFactory.TokenDC_Token.MergeWithEntity(token, tok);

                DAOFactory.GenericDAO.Update(t);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteToken(TokenDC token)
        {
            try
            {
                var t = MapperFactory.TokenDC_Token.MapToNewEntity(token);

                DAOFactory.GenericDAO.Delete(t);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeletTokenRelation(CompactTokenDC token, long? oid, SchulbegleitenderZugehoerigkeitsTyp typ)
        {
            try
            {
                if (typ == SchulbegleitenderZugehoerigkeitsTyp.Klient)
                {
                    var tokenEntity = DAOFactory.GenericDAO.LoadByID<Token>(token.TokenOid.Value);

                    Customer2Token t = null;

                    foreach (var c2tToken in tokenEntity.Customer2TokenList)
                    {
                        if (c2tToken.Customer.Oid == oid)
                        {
                            t = c2tToken;
                        }
                    }

                    if (t != null)
                    {
                        tokenEntity.Customer2TokenList.Remove(t);
                        DAOFactory.GenericDAO.Update(tokenEntity);
                    }
                }
                else if (typ == SchulbegleitenderZugehoerigkeitsTyp.Mitarbeiter)
                {
                    var tokenEntity = DAOFactory.GenericDAO.LoadByID<Token>(token.TokenOid.Value);

                    Employee2Token t = null;

                    foreach (var e2tToken in tokenEntity.Employee2TokenList)
                    {
                        if (e2tToken.Employee.Oid == oid)
                        {
                            t = e2tToken;
                        }
                    }

                    if (t != null)
                    {
                        tokenEntity.Employee2TokenList.Remove(t);
                        DAOFactory.GenericDAO.Update(tokenEntity);
                    }
                }
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<CustomerTokenRelationDC> GetCustomer2TokenList()
        {
            try
            {
                var x = DAOFactory.GenericDAO.GetAllActive<Customer2Token>();

                var y = MapperFactory.CustomerTokenRelationDC_Customer2Token.MapToNewDCs(x);

                return y;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<EmployeeTokenRelationDC> GetEmployee2TokenList()
        {
            try
            {
                var x = DAOFactory.GenericDAO.GetAllActive<Employee2Token>();

                var y = MapperFactory.EmployeeTokenRelationDC_Employee2Token.MapToNewDCs(x);

                return y;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public string PrepareAuslastungReport(AuslastungAnalysisRootDC pReport, string id)
        {
            try
            {
                string lResult = id + ".xml";

                string lDir = BS.Shared.Core.Utils.CreateSavePath(AppDomain.CurrentDomain.BaseDirectory, MultitenancyOperationContextExt.Current.Tenant + @"\temp");
                string lPath = BS.Shared.Core.Utils.CreateSavePath(lDir, lResult);

                BS.Shared.Core.Utils.XMLSerialize(lPath, pReport);

                return lResult;
            }
            catch (Exception e)
            {
                throw (Utils.CreateBeWoFaultException(e));
            }
        }

        public ServiceRecordStatisticsInfoDC GetServiceRecordStatisticInfo(long costBearer2SupportConceptOid, DateTime statisticsDate)
        {
            var factory = PluginLoader.FindClass<ServiceRecordStatisticFactory>();

            if (factory != null)
            {
                return factory.GetServiceRecordStatisticInfo(costBearer2SupportConceptOid, statisticsDate);
            }

            return null;
        }

        public SupportConceptStatisticsDC CreateSupportConceptStatistics(long costBearer2SupportConceptOid, DateTime statisticsDate)
        {
            var factory = PluginLoader.FindClass<ServiceRecordStatisticFactory>();


            if (factory == null)
            {
                factory = new ServiceRecordStatisticFactory();
            }

            return factory.CreateSupportConceptStatistics(costBearer2SupportConceptOid, statisticsDate);
        }

        public void ResetTenant(String tenant)
        {
            WCFHibernateSessionManager.ResetSessionFactory(tenant);
        }

        public void ResetAllTenants()
        {
            //WCFHibernateSessionManager.ResetAllSessionFactories();
        }

        public String GetLicenseOrderUrl()
        {
            var url = ConfigurationManager.AppSettings.Get("LicenseOrderUrl");
            url = url.Replace("[TENANT]", MultitenancyOperationContextExt.Current.Tenant);


            return url;
        }

        public String GetLicenseOrderUrlNeu(String type)
        {
            var url = ConfigurationManager.AppSettings.Get("LicenseOrderUrl");
            url = url.Replace("[TENANT]", MultitenancyOperationContextExt.Current.Tenant);
            if (type == "1")
            {
                url += "&LicenseType=1";
            }
            else if (type == "2")
            {
                var m = GetMandator2(false);
                if (!m.AllowSbd)
                {
                    return "";
                }
                url += "&LicenseType=2";
            }

            return url;
        }

        public LicenseInfoDC GetLicenseInfo()
        {
            return SecurityUtils.GetLicenseInfo();
        }

        public GroupDurationDC CalculateGroupDuration(int personCount, int employeeCount, decimal totalDuration)
        {
            var calc = PluginLoader.FindClass<GroupDurationCalculator>();

            return calc?.CalculateGroupDuration(personCount, employeeCount, totalDuration);
        }

        public GroupDurationDC CalculateGroupDuration2(int personCount, int employeeCount, decimal totalDuration, long[] costBearer2SupportConceptArray)
        {
            var calc = PluginLoader.FindClass<GroupDurationCalculator>();

            return calc?.CalculateGroupDuration(personCount, employeeCount, totalDuration, costBearer2SupportConceptArray);
        }

        public IList<UiElementDC> GetUiElements(UiElementType? uiType, long? employeeOid, long? teamOid, long[] oidArray)
        {
            var factory = PluginLoader.FindClass<UiElementFactory>() ?? new UiElementFactory();

            return factory.GetUiElements(uiType, employeeOid, teamOid);
        }

        private static List<SupportConceptTreeNodeDC> BuildTree(IEnumerable<SupportConcept> pSupportConcepts)
        {
            var lResult = new List<SupportConceptTreeNodeDC>();

            foreach (var iSc in pSupportConcepts)
            {
                var lScNode = new SupportConceptTreeNodeDC
                {
                    NodeType = NodeType.SupportConcept,
                    SupportConcept = MapperFactory.CompactSupportConceptDC_SupportConcept.MapToNewDC(iSc),
                    Description = $"{iSc.Customer.Person.LastName}, {iSc.Customer.Person.FirstName}"
                };

                foreach (var iSc2Cb in iSc.CostBearer2SupportConceptList)
                {
                    var treeNode = new SupportConceptTreeNodeDC
                    {
                        NodeType = NodeType.SupportConceptCostBearerRelDC,
                        SupportConcept = lScNode.SupportConcept,
                        SupportConceptCostBearerRelDC = MapperFactory.SupportConceptCostBearerRelDC_CostBearer2SupportConcept.MapToNewDC(iSc2Cb)
                    };

                    if (iSc2Cb.CostBearer.Organisation != null)
                    {
                        treeNode.Description = iSc2Cb.CostBearer.Organisation.Name;
                    }

                    lScNode.ChildNodes.Add(treeNode);
                }

                lResult.Add(lScNode);
            }

            return lResult.OrderBy(s => s.Description).ToList();
        }

        public void CreateNewPerson2OrganisationRelation(long pOrganisationOid, ValueListEntryDC pValue, long personOid, string pMailAddress, string pFaxNumber, string pPhoneNumber, string pNotice)
        {
            try
            {
                var contactList = new List<Contact>
                {
                    new Contact {Type = ContactType.business_Fax, Value = pFaxNumber},
                    new Contact {Type = ContactType.business_Mail, Value = pMailAddress},
                    new Contact {Type = ContactType.business_Phone, Value = pPhoneNumber}
                };

                var organisation2Person = new Organisation2Person
                {
                    Organisation = DAOFactory.GenericDAO.LoadByID<Organisation>(pOrganisationOid),
                    Notice = pNotice,
                    RolleInOrganisation = pValue != null ? DAOFactory.GenericDAO.LoadByID<ValueListEntry>(pValue.ValueListEntryOid.Value) : null,
                    Person = DAOFactory.GenericDAO.LoadByID<Person>(personOid),
                    Contacts = contactList
                };

                DAOFactory.GenericDAO.Insert(organisation2Person);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeletePerson2OrganisationRelation(long oid)
        {
            try
            {
                var organisation2Person = DAOFactory.GenericDAO.LoadByID<Organisation2Person>(oid);

                DAOFactory.GenericDAO.Delete(organisation2Person);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public PdfChatHandoutDC GetHandOutPdfForChat(string customerId, string apikey)
        {
            try
            {
                var handout = new PdfChatHandoutDC();

                var serverUrl = OwnChatHelper.ErmittleServerURL(customerId);

                if (serverUrl == null)
                {
                    handout.Result = 11;

                    return handout;
                }

                if (string.IsNullOrEmpty(serverUrl))
                {
                    handout.Result = 11;

                    return handout;
                }

                var endurl = serverUrl + "/api/ownchat/createpdfmanual/" + apikey + "/" + customerId;


                //Bereich zum Testen  Multiform Test gedönse 
                //using (MultipartFormDataContent multiPartContent = new MultipartFormDataContent())
                //{
                //    Uri requestUri = new Uri(ChatDaten.ServerUrl + "/api/ownchat/createpdfmanual/");

                //    Links Content / Rechts name
                //    multiPartContent.Add(new StringContent(chatcode + ""), "chatcode");
                //    multiPartContent.Add(new StringContent(login + ""), "login");
                //    multiPartContent.Add(new StringContent(password + ""), "password");
                //    multiPartContent.Add(new StringContent("https://support.bewoplaner.de/bewoplaner_logo_small.png"), "custom_logo_url");

                //    httpRequest = new HttpRequestMessage();
                //    httpRequest.Method = HttpMethod.Post;
                //    httpRequest.RequestUri = requestUri;
                //    httpRequest.Content = multiPartContent;

                //    httpRequest.Headers.Add("Token", apikey);
                //    httpRequest.Headers.Add("CustomerID", customerId);


                //    HttpResponseMessage httpResponse = null;

                //    HttpClient httpClient = new HttpClient();

                //    httpResponse = await httpClient.SendAsync(httpRequest, CancellationToken.None).ConfigureAwait(false);


                //    string antwortResponse = await httpResponse.Content.ReadAsStringAsync();

                //    var jsonDatentyp = JsonConvert.DeserializeObject<PdfChatHandoutDC>(antwortResponse);

                //    return jsonDatentyp;
                //}

                //neu post bereich 
                //Dictionary<string, string> dic = new Dictionary<string, string>();

                //dic.Add("chatcode", "Hier ChatCode");
                //dic.Add("login", "hier benutzername");
                //dic.Add("password", "hier passwort");
                //dic.Add("custom_logo_url", "https://support.bewoplaner.de/bewoplaner_logo_small.png");

                //string postdaten = "";
                //foreach (var key in dic.Keys)
                //{
                //    postdaten += HttpUtility.UrlEncode(key) + "=" + HttpUtility.UrlEncode(dic[key]) + "&";
                //}

                //WebRequest requesten = WebRequest.Create(endurl);
                //requesten.Method = "POST";
                //requesten.ContentType = "application/x-www-form-urlencoded";
                ////requesten.Headers["Token"] = "hier ggf. token hin ";
                //requesten.Headers["CustomerID"] = customerId;

                //byte[] daten = Encoding.ASCII.GetBytes(postdaten);

                //requesten.ContentLength = daten.Length;

                //Stream requestStream = requesten.GetRequestStream();

                //requestStream.Write(daten, 0, daten.Length);

                //requestStream.Close();


                //neu ende 


                //############################
                var postparameter = new Dictionary<string, string>
                {
                    { "username", "HAns" },
                    { "password", "Dito" },
                    //neu | hinzufügen laut document
                    { "chatcode", "yyAbrams" }
                };

                var postdaten = "";
                //int i = 0;
                foreach (var key in postparameter.Keys)
                {
                    //hier noch chatcode übergeben
                    postdaten += HttpUtility.UrlEncode(key) + "=" + HttpUtility.UrlEncode(postparameter[key]) + "&";
                }

                var requesten = WebRequest.Create(endurl);

                requesten.Method = "POST";
                requesten.ContentType = "application/x-www-form-urlencoded";

                var daten = Encoding.ASCII.GetBytes(postdaten);

                requesten.ContentLength = daten.Length;

                try
                {
                    var requestStream = requesten.GetRequestStream();

                    requestStream.Write(daten, 0, daten.Length);

                    requestStream.Close();

                }
                catch (Exception)
                {
                    MessageBox.Show("Es konnte keine Verbindung aufgebaut werden.", "Fehler", MessageBoxButton.OK);

                }

                //response bereich | Verarbeiten
                var response = (HttpWebResponse)requesten.GetResponse();
                //response.ContentType = "application/pdf";

                //######################################################################

                //alt get bereich
                //WebRequest request = WebRequest.Create(endurl);

                //request.Method = WebRequestMethods.Http.Post;

                //request.Credentials = CredentialCache.DefaultCredentials;
                //request.Proxy = null;

                //WebResponse response = request.GetResponse();

                using (var stream = response.GetResponseStream())
                {
                    var buffer = new byte[stream.Length];
                    stream.Read(buffer, 0, buffer.Length);
                    File.WriteAllBytes("foo.pdf", buffer);
                }

                string responseFromServer = ReadStreamForChatCode(response);

                if (responseFromServer.Contains("PDF"))
                {
                    var hd = new PdfChatHandoutDC
                    {
                        File = responseFromServer,
                        Result = 0
                    };
                    //hd.TestStream = dataStream;

                    return hd;
                }

                var jsonDatentyp = JsonConvert.DeserializeObject<PdfChatHandoutDC>(responseFromServer);

                return jsonDatentyp;
            }
            catch (Exception e)
            {
                //throw Utils.CreateBeWoFaultException(e);
                var handout = new PdfChatHandoutDC
                {
                    Result = 60,
                    File = e.Message
                };

                return handout;
            }
        }

        public CustomerAPPCodeDC DeletCustomerChatCode(string apikey, string kundennummer, long customeroid)
        {
            var customerAppCode = new CustomerAPPCodeDC();
            var result = DeletZufallsCode(apikey, kundennummer, "C" + customeroid);

            if (result == 0 || result == 32)
            {
                try
                {
                    var customerappcode = DAOFactory.SearchDAO.FindAllCustomerAppCodes(customeroid).ToList();

                    var anzahl = customerappcode.Count;

                    if (anzahl > 0)
                    {
                        foreach (var code in customerappcode)
                        {
                            code.CustomerCode = string.Empty;
                            code.CustomerCodeGenDate = DateTime.Now;
                        }

                        DAOFactory.GenericDAO.Update(customerappcode);

                        customerAppCode.Result = 0;
                        return customerAppCode;
                    }

                    customerAppCode.Result = 4;
                    return customerAppCode;
                }
                catch (Exception e)
                {
                    throw Utils.CreateBeWoFaultException(e);
                }
            }

            customerAppCode.Result = result;
            return customerAppCode;
        }

        public EmployeeAPPCodeDC DeletEmployeeChatCode(string apikey, string kundennummer, long employeeoid)
        {
            var employeeAppCode = new EmployeeAPPCodeDC();
            var result = DeletZufallsCode(apikey, kundennummer, "E" + employeeoid);

            if (result == 0 || result == 32)
            {
                try
                {
                    var employeeappcode = DAOFactory.SearchDAO.FindAllEmployeeAppCodes(employeeoid).ToList();

                    var anzahl = employeeappcode.Count;

                    if (anzahl > 0)
                    {
                        foreach (var code in employeeappcode)
                        {
                            code.EmployeeCode = string.Empty;
                            code.EmployeeCodeGenDate = DateTime.Now;
                        }

                        DAOFactory.GenericDAO.Update(employeeappcode);

                        employeeAppCode.Result = 0; // alles ok 

                        return employeeAppCode;
                    }

                    employeeAppCode.Result = 4; // ChatCode Datensatz konnte nicht gefunden werden

                    return employeeAppCode;
                }
                catch (Exception e)
                {
                    throw Utils.CreateBeWoFaultException(e);
                }
            }

            employeeAppCode.Result = result;

            return employeeAppCode;
        }

        public Dictionary<string, string> GetTranslationDictionary()
        {
            var translationDictionary = PluginLoader.FindClass<TranslationDictionary>();

            return translationDictionary?.GetTranslationDictionary();
        }

        public IList<TextbausteinDC> GetAllTextbausteine()
        {
            try
            {
                return MapperFactory.TextbausteinDC_Textbaustein.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<Textbaustein>());
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public IList<long> InsertNewTextbausteine(IEnumerable<TextbausteinDC> pTextbausteine)
        {
            try
            {
                var lTextbausteine = MapperFactory.TextbausteinDC_Textbaustein.MapToNewEntities(pTextbausteine);
                DAOFactory.GenericDAO.Insert(lTextbausteine);

                return lTextbausteine.Select(asb => asb.Oid.Value).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateTextbausteine(List<TextbausteinDC> pTextbausteine)
        {
            try
            {
                var lOriginals = DAOFactory.GenericDAO.LoadByIDs<Textbaustein>(pTextbausteine.Select(sc => sc.TextbausteinOid.Value));

                MapperFactory.TextbausteinDC_Textbaustein.MergeWithEntitys(pTextbausteine, lOriginals);

                DAOFactory.GenericDAO.Update(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteTextbausteine(Dictionary<long, long> pOid2Version)
        {
            try
            {
                var lOriginals = DAOFactory.GenericDAO.LoadByIDs<Textbaustein>(pOid2Version.Select(e => e.Key));
                lOriginals.DoForEach(or => MapperFactory.TextbausteinDC_Textbaustein.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));

                DAOFactory.GenericDAO.Delete(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public SbdConfigDC GetSbdConfig()
        {
            try
            {
                var pi = PluginLoader.FindClass<SchulbegleitenderDienstService>();

                if (pi != null)
                {
                    return pi.GetSbdConfig();
                }

                return new SbdConfigDC();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void SaveSbdConfig(SbdConfigDC config)
        {
            try
            {
                var pi = PluginLoader.FindClass<SchulbegleitenderDienstService>();

                pi?.SaveSbdConfig(config);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        private static void AnonymizePerson(long pPersonOid)
        {
            try
            {
                const string anonimyzedName = "Anonymisiert";

                var pPerson = DAOFactory.GenericDAO.LoadByID<Person>(pPersonOid);

                pPerson.Abbreviation = null;
                if (pPerson.DateOfBirth != null)
                {
                    pPerson.DateOfBirth = new DateTime(pPerson.DateOfBirth.Value.Year, 1, 1);
                }

                pPerson.FirstName = anonimyzedName;
                pPerson.LastName = anonimyzedName;
                pPerson.Notice = null;

                if (pPerson.Address != null)
                {
                    pPerson.Address.AddressLine1 = null;
                    pPerson.Address.AddressLine2 = null;
                    pPerson.Address.Country = null;
                    pPerson.Address.Street = null;
                    pPerson.Address.State = null;
                    pPerson.Address.PostalCode = null;
                    pPerson.Address.Town = null;
                    pPerson.Address.InsUser = anonimyzedName;
                    pPerson.Address.UdpUser = anonimyzedName;
                }

                pPerson.AufenthaltsStatus = null;
                pPerson.Profession = null;
                pPerson.Title = null;
                pPerson.InsUser = anonimyzedName;
                pPerson.UdpUser = anonimyzedName;
                var bankaccountOid = pPerson.BankAccount?.Oid;

                if (bankaccountOid != null)
                {
                    pPerson.BankAccount = null;
                }

                pPerson.FamilyStatus = null;
                if (pPerson.InvoiceAddress != null)
                {
                    pPerson.InvoiceAddress.AddressLine1 = null;
                    pPerson.InvoiceAddress.AddressLine2 = null;
                    pPerson.InvoiceAddress.Country = null;
                    pPerson.InvoiceAddress.Street = null;
                    pPerson.InvoiceAddress.State = null;
                    pPerson.InvoiceAddress.InsUser = anonimyzedName;
                    pPerson.InvoiceAddress.UdpUser = anonimyzedName;
                }

                pPerson.IsMigrant = false;
                pPerson.Nationalitaet = null;
                pPerson.Contacts.Clear();

                pPerson.Images?.Clear();

                DAOFactory.GenericDAO.Update(pPerson);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void AnonymizeCustomer(long pCustomerOid)
        {
            try
            {
                const string anonimyzedName = "Anonymisiert";
                var customer = DAOFactory.GenericDAO.GetByID<Customer>(pCustomerOid);

                if (customer.Person.Oid != null)
                {
                    AnonymizePerson(customer.Person.Oid.Value);
                }

                customer.VarFieldValueList?.Clear();

                customer.AbWelchemKrankheitsTag = 0;
                customer.AbsenceTimes.DoForEach(at =>
                {
                    at.Notice = null;
                    at.InsUser = anonimyzedName;
                    at.UdpUser = anonimyzedName;
                });

                customer.Ansprechpartner = null;
                customer.AssessmentSheetCategoryList?.Clear();
                customer.AssistanceBegin = null;
                customer.AusstVersAmt = null;
                customer.AusweisGueltigBis = null;
                customer.AusweisGueltigVon = null;
                customer.AusweisUnbefristetGueltig = null;
                customer.AusweisAktenzeichen = null;
                customer.BehinderungsartenListe?.Clear();
                customer.BeiblattGueltigBis = null;
                customer.Childs = null;
                customer.CostCenter = null;
                customer.Ansprechpartner = null;
                customer.AssistanceBegin = null;
                customer.Customer2CostBearerList?.Clear();
                customer.Customer2OrganisationList?.Clear();

                var personRelations2Delete = customer.Customer2PersonList.Where(person => !person.IstFamilie && person.Oid != null).ToList();

                customer.Customer2PersonList.RemoveRange(personRelations2Delete);

                customer.Customer2PersonList.DoForEach(personRelation =>
                {
                    personRelation.InsUser = anonimyzedName;
                    personRelation.UdpUser = anonimyzedName;
                    personRelation.Notice = null;
                });

                customer.CustomerAlias = null;
                customer.DebitorNumber = null;
                customer.Diagnosis = null;
                customer.Diagnosis2CustomerList?.Clear();
                customer.DistanceInMeter = null;
                customer.Employee2CustomerList?.Clear();
                customer.Environment = null;
                customer.EquityContribution = null;
                customer.FamilyData = null;
                customer.GradDerBehinderung = null;
                customer.ICD10Diagnosis = null;
                customer.InsUser = anonimyzedName;
                customer.IsAdvisedOrAttended = null;
                customer.Jugendamt = null;
                customer.Medication = null;
                customer.Medikamentenverordnungslisten?.Clear();
                customer.MerkzeichenListe?.Clear();
                customer.Notice = null;
                customer.Pflegegrad = null;
                customer.PlacementList?.Clear();
                customer.ReferenceNumber = null;
                customer.Team2CustomerList?.Clear();
                customer.TerminationDate = null;
                customer.TerminationReason = null;
                customer.UdpUser = anonimyzedName;
                customer.ValueList?.Clear();
                customer.VertretungDringendErforderlich = false;
                customer.VertretungGewuenscht = false;

                customer.ServiceRecordList?.DoForEach(record =>
                {
                    record.Notice = null;
                    record.Notice2 = null;
                    record.Notice3 = null;
                    record.Notice4 = null;
                    record.Notice5 = null;
                    record.RTFNotice1 = null;
                    record.RTFNotice2 = null;
                    record.RTFNotice3 = null;
                    record.RTFNotice4 = null;
                    record.RTFNotice5 = null;
                    record.InsUser = anonimyzedName;
                    record.UdpUser = anonimyzedName;
                });

                customer.SupportConcepts?.DoForEach(supportConcept =>
                {
                    supportConcept.Notice = null;
                    supportConcept.InsUser = anonimyzedName;
                    supportConcept.UdpUser = anonimyzedName;

                    supportConcept.CostBearer2SupportConceptList.DoForEach(cb2SC =>
                    {
                        cb2SC.CustomerReferenceNumber = null;
                        cb2SC.Notice = null;
                        cb2SC.InsUser = anonimyzedName;
                        cb2SC.UdpUser = anonimyzedName;
                    });
                });

                if (customer.Oid != null)
                {
                    var bargeldKassen = DAOFactory.SearchDAO.FindBargeldkasse(TableID.Customer, customer.Oid.Value);

                    DAOFactory.GenericDAO.Delete(bargeldKassen);

                    var fileAttachments = DAOFactory.SearchDAO.FindFileAttachments(TableID.Customer, customer.Oid.Value);

                    FileAttachmentUtils.DeleteFilesFromFileDirectory(fileAttachments.Where(fileAttachment => fileAttachment.Oid.HasValue).Select(fileAttachment => fileAttachment.Oid.Value).ToList());

                    DAOFactory.GenericDAO.Delete(fileAttachments);
                }

                DAOFactory.GenericDAO.Update(customer);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        // TODO: Den ersten Buchstaben des Klienten und den Namen des Mitarbeiters speichern, der ihn gelöscht hat. -> Neue Tabelle
        public void DeleteCustomerForGood(long pCustomerOid)
        {
            try
            {
                var deletionHistoryEntry = new DeletionHistory();

                var appointments = DAOFactory.SearchDAO.FindAppointmentsForCustomer(pCustomerOid);
                var customer = DAOFactory.GenericDAO.LoadByID<Customer>(pCustomerOid);
                var supportConceptOids = customer.SupportConcepts.Select(sc => sc.Oid.Value).ToList();

                UserDC user;
                if (LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
                {
                    user = MapperFactory.UserDC_User.MapToNewDC(LoggedInUserOperationContextExt.Current.User);
                }
                else
                {
                    user = MapperFactory.UserDC_User.MapToNewDC(SessionFacade.LoggedInUser);
                }

                if (user != null)
                {
                    string initial;

                    if (customer.Person.FirstName.Length > 0)
                    {
                        initial = customer.Person.FirstName[0].ToString();
                    }
                    else if (customer.Person.LastName.Length > 0)
                    {
                        initial = customer.Person.LastName[0].ToString();
                    }
                    else if (customer.CustomerAlias?.Length > 0)
                    {
                        initial = customer.CustomerAlias[0].ToString();
                    }
                    else
                    {
                        initial = "unbekannt";
                    }

                    deletionHistoryEntry.DeletingEmployeeName = $"{user.Employee.FirstName} {user.Employee.LastName}";
                    deletionHistoryEntry.DeletedEntityName = initial;
                    deletionHistoryEntry.DeletedEntityTableId = TableID.Customer;
                }

                appointments.DoForEach(app => app.CustomerList.Remove(customer));

                DAOFactory.GenericDAO.Update(appointments);

                var costBearer2SupportConcepts = new List<CostBearer2SupportConcept>();
                var groupsToGetReferencesRemoved = new List<GroupOfPeople>();
                foreach (var sc in customer.SupportConcepts)
                {
                    foreach (var cb2sc in sc.CostBearer2SupportConceptList)
                    {
                        groupsToGetReferencesRemoved.AddRangeIfElementsNotIn(DAOFactory.SearchDAO.GroupOfPeopleForSupportConcept(cb2sc.Oid.Value));
                        costBearer2SupportConcepts.AddIfNotIn(cb2sc);
                    }
                }

                foreach (var group in groupsToGetReferencesRemoved)
                {
                    group.CostBearer2SupportConceptList.RemoveRange(costBearer2SupportConcepts);
                }

                DAOFactory.GenericDAO.Update(groupsToGetReferencesRemoved);

                DAOFactory.GenericDAO.Update(customer.SupportConcepts);

                var additionalServiceGroups = DAOFactory.SearchDAO.GetAdditionalServiceGroupOfPeopleForCustomer(customer.Oid.Value);
                foreach (var additionalServiceGroup in additionalServiceGroups)
                {
                    additionalServiceGroup.CustomerList.Remove(customer);
                }

                DAOFactory.GenericDAO.Update(additionalServiceGroups);

                var additionalServiceBookings = DAOFactory.SearchDAO.GetAllAdditionalServiceBookingsForCustomer(customer.Oid.Value);
                DAOFactory.GenericDAO.Delete(additionalServiceBookings);

                var images2delete = customer.Person.Images;
                customer.Person.Images.Clear();

                DAOFactory.GenericDAO.Delete(images2delete);
                DAOFactory.GenericDAO.Update(customer);

                customer.SupportConcepts.DoForEach(s => s.CostBearer2SupportConceptList?.Clear());
                foreach (var assessmentSheetCategory in customer.AssessmentSheetCategoryList)
                {
                    assessmentSheetCategory.Customers.Remove(customer);
                }

                var assessmentSheetEntries = DAOFactory.SearchDAO.GetAssessmentSheetEntriesForCustomer(customer.Oid.Value, DateTime.MinValue, DateTime.MaxValue);

                var invoiceBases2Delete = DAOFactory.SearchDAO.GetInvoiceBasesBySupportConceptOids(supportConceptOids);
                invoiceBases2Delete.DoForEach(ib => ib.InvoiceItems.Clear());

                var settlementInvoices = DAOFactory.SearchDAO.GetSettlementInvoiceBySupportConceptOids(supportConceptOids);
                var serviceInvoices = DAOFactory.SearchDAO.GetServiceInvoicesByInvoiceBaseOids(invoiceBases2Delete.Select(s => s.Oid.Value).ToList());

                var invoiceItems = new List<InvoiceItem>();
                invoiceBases2Delete.DoForEach(ib => invoiceItems.AddRange(ib.InvoiceItems));
                DAOFactory.GenericDAO.Update(invoiceBases2Delete);

                if (supportConceptOids.Any())
                {
                    var tasksAndAppointments2Delete = DAOFactory.SearchDAO.GetTasksAndAppointmentsBySupportConceptOids(supportConceptOids);
                    DAOFactory.GenericDAO.Delete(tasksAndAppointments2Delete);
                }

                DAOFactory.GenericDAO.Delete(invoiceItems);
                DAOFactory.GenericDAO.Delete(settlementInvoices);
                DAOFactory.GenericDAO.Delete(serviceInvoices);

                invoiceBases2Delete = DAOFactory.SearchDAO.GetInvoiceBasesBySupportConceptOids(supportConceptOids);
                DAOFactory.GenericDAO.Delete(invoiceBases2Delete);

                var customer2Tokens2Delete = DAOFactory.SearchDAO.GetCustomer2TokensByCustomerOid(customer.Oid.Value);
                DAOFactory.GenericDAO.Delete(customer2Tokens2Delete);

                DAOFactory.GenericDAO.Delete(assessmentSheetEntries);

                DAOFactory.GenericDAO.Update(customer);

                DAOFactory.GenericDAO.Delete(customer.SupportConcepts);

                DAOFactory.GenericDAO.Delete(DAOFactory.GenericDAO.LoadByID<Customer>(customer.Oid.Value));

                if (deletionHistoryEntry.DeletingEmployeeName != null)
                {
                    DAOFactory.GenericDAO.Insert(deletionHistoryEntry);
                }
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        // TODO: implementieren!
        public void DeletePersonForGood(long pPersonOid)
        {
            try
            {

            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        // TODO: implementieren!
        public void DeleteEmployeeForGood(long pEmployeeOid)
        {
            try
            {
                var deletionHistoryEntry = new DeletionHistory();

                //var appointments = DAOFactory.SearchDAO.FindAppointmentsForEmployee(pEmployeeOid);
                var emp = DAOFactory.GenericDAO.LoadByID<Employee>(pEmployeeOid);
                //var supportConceptOids = customer.SupportConcepts.Select(sc => sc.Oid.Value).ToList();

                UserDC user;
                if (LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
                {
                    user = MapperFactory.UserDC_User.MapToNewDC(LoggedInUserOperationContextExt.Current.User);
                }
                else
                {
                    user = MapperFactory.UserDC_User.MapToNewDC(SessionFacade.LoggedInUser);
                }

                if (user != null)
                {
                    string initial;

                    if (emp.Person.FirstName.Length > 0)
                    {
                        initial = emp.Person.FirstName[0].ToString();
                    }
                    else if (emp.Person.LastName.Length > 0)
                    {
                        initial = emp.Person.LastName[0].ToString();
                    }
                    else
                    {
                        initial = "unbekannt";
                    }

                    deletionHistoryEntry.DeletingEmployeeName = $"{user.Employee.FirstName} {user.Employee.LastName}";
                    deletionHistoryEntry.DeletedEntityName = initial;
                    deletionHistoryEntry.DeletedEntityTableId = TableID.Employee;
                }

                //appointments.DoForEach(app => app.CustomerList.Remove(customer));

                //DAOFactory.GenericDAO.Update(appointments);

                //var costBearer2SupportConcepts = new List<CostBearer2SupportConcept>();
                //var groupsToGetReferencesRemoved = new List<GroupOfPeople>();
                //foreach (var sc in customer.SupportConcepts)
                //{
                //    foreach (var cb2sc in sc.CostBearer2SupportConceptList)
                //    {
                //        groupsToGetReferencesRemoved.AddRangeIfElementsNotIn(DAOFactory.SearchDAO.GroupOfPeopleForSupportConcept(cb2sc.Oid.Value));
                //        costBearer2SupportConcepts.AddIfNotIn(cb2sc);
                //    }
                //}

                //foreach (var group in groupsToGetReferencesRemoved)
                //{
                //    group.CostBearer2SupportConceptList.RemoveRange(costBearer2SupportConcepts);
                //}

                //DAOFactory.GenericDAO.Update(groupsToGetReferencesRemoved);

                //DAOFactory.GenericDAO.Update(customer.SupportConcepts);

                //var additionalServiceGroups = DAOFactory.SearchDAO.GetAdditionalServiceGroupOfPeopleForCustomer(customer.Oid.Value);
                //foreach (var additionalServiceGroup in additionalServiceGroups)
                //{
                //    additionalServiceGroup.CustomerList.Remove(customer);
                //}

                //DAOFactory.GenericDAO.Update(additionalServiceGroups);

                //var additionalServiceBookings = DAOFactory.SearchDAO.GetAllAdditionalServiceBookingsForCustomer(customer.Oid.Value);
                //DAOFactory.GenericDAO.Delete(additionalServiceBookings);

                //var images2delete = customer.Person.Images;
                //customer.Person.Images.Clear();

                //DAOFactory.GenericDAO.Delete(images2delete);
                //DAOFactory.GenericDAO.Update(customer);

                //customer.SupportConcepts.DoForEach(s => s.CostBearer2SupportConceptList?.Clear());
                //foreach (var assessmentSheetCategory in customer.AssessmentSheetCategoryList)
                //{
                //    assessmentSheetCategory.Customers.Remove(customer);
                //}

                //var assessmentSheetEntries = DAOFactory.SearchDAO.GetAssessmentSheetEntriesForCustomer(customer.Oid.Value, DateTime.MinValue, DateTime.MaxValue);

                //var invoiceBases2Delete = DAOFactory.SearchDAO.GetInvoiceBasesBySupportConceptOids(supportConceptOids);
                //invoiceBases2Delete.DoForEach(ib => ib.InvoiceItems.Clear());

                //var settlementInvoices = DAOFactory.SearchDAO.GetSettlementInvoiceBySupportConceptOids(supportConceptOids);
                //var serviceInvoices = DAOFactory.SearchDAO.GetServiceInvoicesByInvoiceBaseOids(invoiceBases2Delete.Select(s => s.Oid.Value).ToList());

                //var invoiceItems = new List<InvoiceItem>();
                //invoiceBases2Delete.DoForEach(ib => invoiceItems.AddRange(ib.InvoiceItems));
                //DAOFactory.GenericDAO.Update(invoiceBases2Delete);

                //if (supportConceptOids.Any())
                //{
                //    var tasksAndAppointments2Delete = DAOFactory.SearchDAO.GetTasksAndAppointmentsBySupportConceptOids(supportConceptOids);
                //    DAOFactory.GenericDAO.Delete(tasksAndAppointments2Delete);
                //}

                //DAOFactory.GenericDAO.Delete(invoiceItems);
                //DAOFactory.GenericDAO.Delete(settlementInvoices);
                //DAOFactory.GenericDAO.Delete(serviceInvoices);

                //invoiceBases2Delete = DAOFactory.SearchDAO.GetInvoiceBasesBySupportConceptOids(supportConceptOids);
                //DAOFactory.GenericDAO.Delete(invoiceBases2Delete);

                //var customer2Tokens2Delete = DAOFactory.SearchDAO.GetCustomer2TokensByCustomerOid(customer.Oid.Value);
                //DAOFactory.GenericDAO.Delete(customer2Tokens2Delete);

                //DAOFactory.GenericDAO.Delete(assessmentSheetEntries);

                //DAOFactory.GenericDAO.Update(customer);

                //DAOFactory.GenericDAO.Delete(customer.SupportConcepts);

                DAOFactory.GenericDAO.Delete(emp);

                if (deletionHistoryEntry.DeletingEmployeeName != null)
                {
                    DAOFactory.GenericDAO.Insert(deletionHistoryEntry);
                }

            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        // TODO: implementieren!
        public void AnonymizeEmployee(long pEmployeeOid)
        {
            try
            {
                var employee = DAOFactory.GenericDAO.LoadByID<Employee>(pEmployeeOid);

                if (employee.Person.Oid != null)
                {
                    AnonymizePerson(employee.Person.Oid.Value);
                }

                var fileAttachments = DAOFactory.SearchDAO.FindFileAttachments(TableID.Employee, pEmployeeOid);

                FileAttachmentUtils.DeleteFilesFromFileDirectory(fileAttachments.Where(fileAttachment => fileAttachment.Oid.HasValue).Select(fileAttachment => fileAttachment.Oid.Value).ToList());

                DAOFactory.GenericDAO.Delete(fileAttachments);

                employee.AbsenceTimes?.Clear();

                DAOFactory.GenericDAO.Update(employee);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        // TODO: implementieren!
        public void DeleteAppointmentsInInterval(bool pHasRightToSeeAllEmployeeAppointments, long pEmployeeOid, DateTime pIntervalEnd, List<long> pSelectedEmployees, List<long> pSelectedCustomers, List<long> pSelectedResources, bool pEmployeesOnly, bool pCustomersOnly, bool pResourcesOnly, bool pPrivateAppointmentsOnly, bool pOnlyMyAppointments, Dictionary<UserRightType, bool> pUserRights)
        {
            try
            {
                var appointments2Delete = DAOFactory.SearchDAO.LoadFilteredAppointments(pHasRightToSeeAllEmployeeAppointments, pEmployeeOid, new DateTime(1, 1, 1), pIntervalEnd, pSelectedEmployees, pSelectedCustomers, pSelectedResources, pEmployeesOnly, pCustomersOnly, pResourcesOnly, pPrivateAppointmentsOnly, pOnlyMyAppointments, true);
                DAOFactory.GenericDAO.Delete(appointments2Delete);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public string GetMessageFromServer(TableID pObjectTid, long? pObjectOid, MessageType pMessageType)
        {
            try
            {
                var actualTextMessage = "";
                const string foreground = "Foreground=\"Red\"";
                const string fontWeight = "FontWeight=\"Bold\"";

                if (pObjectTid == TableID.Customer && pMessageType == MessageType.Anonymization)
                {
                    actualTextMessage = "Achtung!&#x0a;&#x0a;Das Anonymisieren eines Klienten kann nicht rückgängig gemacht werden!&#x0a;";
                }

                if (pObjectTid == TableID.Customer && pMessageType == MessageType.DeleteForGood)
                {
                    actualTextMessage = "Achtung!&#x0a;&#x0a;Das endgültige Löschen eines Klienten kann nicht rückgängig gemacht werden!&#x0a;";
                }

                if (pObjectTid == TableID.Person && pMessageType == MessageType.DeleteForGood)
                {
                    actualTextMessage = "Achtung!&#x0a;&#x0a;Das endgültige Löschen einer Person kann nicht rückgängig gemacht werden!&#x0a;";
                }

                if (pObjectTid == TableID.Employee && pMessageType == MessageType.Anonymization)
                {
                    actualTextMessage = "Achtung!&#x0a;&#x0a;Das Anonymisieren eines Mitarbeiters kann nicht rückgängig gemacht werden!&#x0a;";
                }

                if (pObjectTid == TableID.Employee && pMessageType == MessageType.DeleteForGood)
                {
                    actualTextMessage = "Achtung!&#x0a;&#x0a;Das endgültige Löschen eines Mitarbeiters kann nicht rückgängig gemacht werden!&#x0a;";
                }

                return $"<TextBlock xmlns =\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\" Grid.Row=\"0\" TextAlignment=\"Center\" {fontWeight} TextWrapping=\"Wrap\" Background=\"Transparent\" FontSize=\"14\" Margin=\"3\" {foreground} HorizontalAlignment=\"Center\" Text=\"{actualTextMessage}\"/>";
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public string GetMessageFromServerForDeletingAppointments(bool pHasRightToSeeAllEmployeeAppointments, long pEmployeeOid, DateTime pIntervalEnd, List<long> pSelectedEmployees, List<long> pSelectedCustomers, List<long> pSelectedResources, bool pEmployeesOnly, bool pCustomersOnly, bool pResourcesOnly, bool pPrivateAppointmentsOnly, bool pOnlyMyAppointments, Dictionary<UserRightType, bool> pUserRights)
        {
            var appointments2Delete = DAOFactory.SearchDAO.LoadFilteredAppointments(pHasRightToSeeAllEmployeeAppointments, pEmployeeOid, new DateTime(1, 1, 1), pIntervalEnd, pSelectedEmployees, pSelectedCustomers, pSelectedResources, pEmployeesOnly, pCustomersOnly, pResourcesOnly, pPrivateAppointmentsOnly, pOnlyMyAppointments, true);

            var actualTextMessage = $"Achtung!&#x0a;&#x0a;Das Löschen von {appointments2Delete.Count} {(appointments2Delete.Count == 1 ? "Termin" : "Terminen")} bis zum {pIntervalEnd.ToShortDateString()} kann nicht rückgängig gemacht werden!&#x0a;";

            return $"<TextBlock xmlns =\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\" Grid.Row=\"0\" TextAlignment=\"Center\" FontWeight=\"Bold\" TextWrapping=\"Wrap\" Background=\"Transparent\" FontSize=\"14\" Margin=\"3\" Foreground=\"Red\" HorizontalAlignment=\"Center\" Text=\"{actualTextMessage}\"/>";
        }

        public SignatureDC GetSignature(long pSignatureOid)
        {
            try
            {
                var lOriginal = DAOFactory.GenericDAO.LoadByID<Signature>(pSignatureOid);

                return MapperFactory.SignatureDC_Signature.MapToNewDC(lOriginal);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<BudgetDC> GetAllBudgets()
        {
            try
            {
                var list = DAOFactory.GenericDAO.GetAllActive<Budget>();
                return MapperFactory.BudgetDC_Budget.MapToNewDCs(list);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void InsertNewBudget(List<BudgetDC> budgets)
        {
            try
            {
                var budget = MapperFactory.BudgetDC_Budget.MapToNewEntities(budgets);
                DAOFactory.GenericDAO.Insert(budget);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateBudget(Dictionary<long, long> pOid2Version)
        {
            try
            {
                ServiceLogic.SetActivationType<Budget>(pOid2Version, ActivationTypeId.Deleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateBudget(List<BudgetDC> budgets)
        {
            try
            {
                var lOriginals = DAOFactory.GenericDAO.LoadByIDs<Budget>(budgets.Select(sc => sc.BudgetOid.Value));

                MapperFactory.BudgetDC_Budget.MergeWithEntitys(budgets, lOriginals);

                DAOFactory.GenericDAO.Update(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<PreisDC> GetAllPreise()
        {
            try
            {
                var list = DAOFactory.GenericDAO.GetAllActive<Preis>();
                return MapperFactory.PreisDC_Preis.MapToNewDCs(list);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void InsertNewPreis(List<PreisDC> preise)
        {
            try
            {
                var preis = MapperFactory.PreisDC_Preis.MapToNewEntities(preise);
                DAOFactory.GenericDAO.Insert(preis);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivatePreis(Dictionary<long, long> pOid2Version)
        {
            try
            {
                ServiceLogic.SetActivationType<Preis>(pOid2Version, ActivationTypeId.Deleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdatePreis(List<PreisDC> preise)
        {
            try
            {
                var lOriginals = DAOFactory.GenericDAO.LoadByIDs<Preis>(preise.Select(sc => sc.PreisOid.Value));

                MapperFactory.PreisDC_Preis.MergeWithEntitys(preise, lOriginals);

                DAOFactory.GenericDAO.Update(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }


        public FlexibleReportResultDC GetFlexibleReportResult(FlexibleReportFilterDC filter)
        {
            try
            {
                return FlexibleReportManager.GetFlexibleReportResult(filter);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public IList<FlexibleReportLayoutDC> GetFlexibleReportLayouts()
        {
            try
            {
                return FlexibleReportManager.GetFlexibleReportLayouts();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void InsertNewFlexibleReportLayout(FlexibleReportLayoutDC flexibleReportLayoutDC)
        {
            try
            {
                FlexibleReportManager.InsertNewFlexibleReportLayout(flexibleReportLayoutDC);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateFlexibleReportLayouts(IList<FlexibleReportLayoutDC> flexibleReportLayouts)
        {
            try
            {
                FlexibleReportManager.UpdateFlexibleReportLayouts(flexibleReportLayouts);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public bool CheckForOverlappingSubstitutionEntries(DateTime startDate, DateTime endDate, long? employeeOid, long? customerOid, long? substitutionOid)
        {
            try
            {
                return DAOFactory.SearchDAO.CheckForOverlappingSubstitutions(employeeOid, customerOid, startDate, endDate, substitutionOid);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public IList<HomeViewPanelDC> GetHomeViewPanels()
        {
            try
            {
                var hcg = PluginLoader.FindClass<HomeContentGenerator>();

                return hcg.GetHomeViewPanels();

            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        public bool CheckForOverlappingAbsenceTimes(DateTime startDate, DateTime endDate, long? employeeOid, long? customerOid)
        {
            try
            {
                return DAOFactory.SearchDAO.CheckForOverlappingAbsenceTimes(startDate, endDate, employeeOid, customerOid);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public IList<ValueListEntryDC> GetIcf()
        {
            try
            {
                #region auskommentiert
                //string key = "2BT%eGprU\"E$!\"5Flq@l^^KZaYa\"u/icq@MMSWsy$XFo@#q3Arbnx@Plzv7s\\+$a";

                //string url = "https://support.bewoplaner.de/api/geticf.php?k=[TENANT]";


                //if (MultitenancyOperationContextExt.Current != null)
                //{
                //    url = url.Replace("[TENANT]", MultitenancyOperationContextExt.Current.Tenant);
                //}
                //else
                //{
                //    url = url.Replace("[TENANT]", SessionFacade.Tenant);
                //}

                //String json = "";

                //using (var client = new WebClient())
                //{
                //    byte[] response = client.UploadValues(url, "POST", new NameValueCollection()
                //    {
                //        {"API-KEY", key}
                //    });

                //    json = System.Text.Encoding.ASCII.GetString(response);


                //}

                //[{"Oid":"1","Code":"","Bezeichnung":"Kapitel 1: Lernen und Wissensanwendung","Beschreibung":"","ParentOID":""}
                //var icfentry = new { Oid = 0, Code = "", Bezeichnung = "", Beschreibung = "", ParentOid = 0 };

                //var icfList = JsonConvert.DeserializeObject<List<Icf>>(json);


                ////var rawList = DAOFactory.GenericDAO.GetAll<Icf>().ToList();

                //var icfs = new List<ValueListEntryDC>
                //{
                //    new ValueListEntryDC() {ParentOid = -1, TypeDescription = "ICF"}
                //};

                //icfs.AddRange(icfList.Select(x => new ValueListEntryDC()
                //{
                //    ValueListEntryOid = x.Oid,
                //    ParentOid = x.ParentOID,
                //    TypeDescription = x.Bezeichnung,
                //    Abbreviation = x.Code,
                //    Notice = x.Beschreibung
                //}));

                //var wholeICF = ICFDAO.GetWholeIcf();
                #endregion

                return ICFDAO.GetIcf();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public List<ValueListEntryDC> GetWholeIcf()
        {
            try
            {
                return ICFDAO.GetWholeIcf();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ValueListEntryDC> GetWholeIcfOhneImportierte(List<ValueListEntryDC> vorhandeneZiele)
        {
            try
            {
                List<ValueListEntryDC> listeMitUeberschneidungen = new List<ValueListEntryDC>();
                var icf = ICFDAO.GetWholeIcf();

                foreach (var chapter in icf)
                {
                    foreach (var vorhandenesKapitel in vorhandeneZiele)
                    {
                        // TEMPORÄR ZUM TESTEN; Richtiger Ansatz, aber muss differenzieren, ob es oberkapitel sind
                        if (vorhandenesKapitel != null && vorhandenesKapitel.DisplayName == chapter.DisplayName && !vorhandenesKapitel.DisplayName.Contains("ICF") &&
                            !vorhandenesKapitel.DisplayName.Contains("Komponente") && !vorhandenesKapitel.DisplayName.Contains("Kapitel"))
                        {
                            if (!icf.Any(c => c.ParentOid == vorhandenesKapitel.ValueListEntryOid))
                            {
                                listeMitUeberschneidungen.Add(chapter);
                            }
                        }
                    }
                }

                // Statt Parent-Objekten vllt eher Children zusammensuchen?
                List<ValueListEntryDC> parentObjekte = new List<ValueListEntryDC>();
                foreach (var item in listeMitUeberschneidungen)
                {
                    if (item.ValueListEntryOid == 85)
                        Console.WriteLine("hallo");
                    if (item.ParentOid != null)
                    {
                        var parent = listeMitUeberschneidungen.FirstOrDefault(i => i.ValueListEntryOid == item.ParentOid);

                        if (parent != null)
                        {
                            parentObjekte.Add(parent);
                        }
                    }
                }
                //listeMitUeberschneidungen.RemoveRange(parentObjekte);

                Dictionary<long?, List<ValueListEntryDC>> alleKinderDerVadderOid = new Dictionary<long?, List<ValueListEntryDC>>();
                foreach (var item in icf)
                {
                    if (item.ParentOid.HasValue && !alleKinderDerVadderOid.ContainsKey(item.ParentOid.Value))
                    {
                        alleKinderDerVadderOid.Add(item.ParentOid.Value, new List<ValueListEntryDC>());
                    }
                    if (alleKinderDerVadderOid.ContainsKey(item.ParentOid.Value))
                    {
                        alleKinderDerVadderOid[item.ParentOid.Value].Add(item);
                    }
                }


                //icf.RemoveRange(listeMitUeberschneidungen);

                icf = EntferneParentOhneKinder(listeMitUeberschneidungen, alleKinderDerVadderOid, icf);

                var funktionenDesBewusstseins = icf.Where(i => i.DisplayName.Contains("Funktionen des Bewusstseins")).ToList();

                return icf;

                // Komplett importiertes verschwindet jetzt, außer alles, wo "Kapitel", "Komponente" oder "ICF" enthalten ist (if-Bedingungen weiter oben)
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        // enthält alles, außer das, was gebraucht wird
        private List<ValueListEntryDC> EntferneParentOhneKinder(List<ValueListEntryDC> listeMitUeberschneidungen, Dictionary<long?, List<ValueListEntryDC>> alleKinderDerVadderOid, List<ValueListEntryDC> icf)
        {
            // Zum Zeitpunkt des Aufrufens dieser Methode sind alle Ziele, die bereits importiert wurden, aus dem ICF entfernt, sofern diese keine Kinder mehr haben 
            // (also alle "Blätter" des Baums. Die leeren Äste sind allerdings noch da. Jeder Ast muss jetzt geprüft werden, und zwar darauf, ob er noch mindestens ein Blatt hat)
            List<ValueListEntryDC> toRemove = new List<ValueListEntryDC>();

            foreach (var item in listeMitUeberschneidungen)
            {
                var kinderlisteFuerCurrent = (alleKinderDerVadderOid.ContainsKey(item.ValueListEntryOid)) ? alleKinderDerVadderOid[item.ValueListEntryOid] : null;
                bool enthealtBereitsAlleKinder = true;

                if (kinderlisteFuerCurrent != null)
                {
                    foreach (var child in kinderlisteFuerCurrent)
                    {
                        if (!listeMitUeberschneidungen.Contains(child))
                        {
                            enthealtBereitsAlleKinder = false;
                            break;
                        }
                    }
                }

                if (enthealtBereitsAlleKinder)
                    toRemove.Add(item);
            }

            //icf.RemoveRange(toRemove); // Entfernen klappt nicht

            for (int i = icf.Count - 1; i >= 0; i--)
            {
                var current = icf[i];
                foreach (var c in toRemove) // In toRemove stehen alle drin, die nicht sollen, und nur das gewollte fehlt (noch in listeMitUeberschneidungen)
                {
                    if (current.ValueListEntryOid == 85)
                        Console.WriteLine("hallo"); // Es gibt im ICF keinen Eintrag damit.. hä?
                    if (c.ValueListEntryOid == 85)
                        Console.WriteLine("hallo");

                    if (c.ValueListEntryOid == current.ValueListEntryOid)
                    {
                        icf.Remove(c); // Code kommt hier nicht an
                    }
                }
            }

            return icf;
        }

        public IList<ReportTemplateDC> GetReportTemplates(string url)
        {
            try
            {
                if (url.IsNullOrEmpty())
                    return null;

                var index = url.IndexOf("type=") + 5;
                var typeString = url.Substring(index);
                if (typeString.IndexOf("&") > 0)
                {
                    typeString = typeString.Substring(0, typeString.IndexOf("&"));
                }
                if (!Enum.TryParse(typeString, out ReportTypes reportType))
                    return null;

                var list = MapperFactory.ReportTemplateDC_ReportTemplate.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<ReportTemplate>().Where(x => x.ReportTemplateType == reportType));

                if (list.Count == 0 && reportType == ReportTypes.RosterReport)
                {
                    list.Add(new ReportTemplateDC
                    {
                        DisplayName = "Dienstplanung",
                        ReportTemplateType = ReportTypes.RosterReport,
                        Oid = -1
                    });

                    list.Add(new ReportTemplateDC
                    {
                        DisplayName = "Arbeitszeiterfassung",
                        ReportTemplateType = ReportTypes.RosterReportIst,
                        Oid = -2
                    });
                }
                return list;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        //public Tuple<IList<AbsenceTimeDC>, IList<EmployeeDC>> GetAbsenceTimeDCEmployee11()
        //{
        //    try
        //    {
        //        return GetAbsenceTimeDCEmployee41(DateTime.MinValue, DateTime.MaxValue, null, null);
        //    }
        //    catch (Exception e)
        //    {
        //        throw Utils.CreateBeWoFaultException(e);
        //    }
        //}

        //public Tuple<IList<AbsenceTimeDC>, IList<EmployeeDC>> GetAbsenceTimeDCEmployee21(List<AbsenceReasonDC> absenceReasons, List<EmploymentTypeDC> employmentTypes)
        //{
        //    try
        //    {
        //        return GetAbsenceTimeDCEmployee41(DateTime.MinValue, DateTime.MaxValue, absenceReasons, employmentTypes);
        //    }
        //    catch (Exception e)
        //    {
        //        throw Utils.CreateBeWoFaultException(e);
        //    }
        //}

        //public Tuple<IList<AbsenceTimeDC>, IList<EmployeeDC>> GetAbsenceTimeDCEmployee31(DateTime start, DateTime end)
        //{
        //    try
        //    {
        //        return GetAbsenceTimeDCEmployee41(start, end, null, null);
        //    }
        //    catch (Exception e)
        //    {
        //        throw Utils.CreateBeWoFaultException(e);
        //    }
        //}

        //public Tuple<IList<AbsenceTimeDC>, IList<EmployeeDC>> GetAbsenceTimeDCEmployee41(DateTime start, DateTime end, List<AbsenceReasonDC> absenceReasons, List<EmploymentTypeDC> employmentTypes)
        //{
        //    try
        //    {
        //        var absenceReasonIDs = (absenceReasons == null || !absenceReasons.Any()) ? null : absenceReasons.Select(x => x.AbsenceReasonOid.Value).ToList();
        //        var employmentTypeIDs = (employmentTypes == null || !employmentTypes.Any()) ? null : employmentTypes.Select(x => x.EmploymentTypeOid.Value).ToList();

        //        return GetAbsenceTimeDCEmployee51(start, end, absenceReasonIDs, employmentTypeIDs);
        //    }
        //    catch (Exception e)
        //    {
        //        throw Utils.CreateBeWoFaultException(e);
        //    }
        //}

        //public Tuple<IList<AbsenceTimeDC>, IList<EmployeeDC>> GetAbsenceTimeDCEmployee51(DateTime start, DateTime end, List<long> absenceReasonIDs, List<long> employmentTypeIDs)
        //{
        //    try
        //    {
        //        Func<AbsenceTime, bool> endHasValueMatch = (x) => x.End.HasValue;

        //        Func<AbsenceTime, bool> leftMatch;
        //        Func<AbsenceTime, bool> rightMatch;
        //        Func<AbsenceTime, bool> absenceReasonMatch;
        //        Func<Employee, bool> employmentTypeMatch;

        //        if (start != DateTime.MinValue) leftMatch = (x) => start <= x.End;
        //        else leftMatch = (x) => true;

        //        if (end != DateTime.MaxValue) rightMatch = (x) => end >= x.Start;
        //        else rightMatch = (x) => true;

        //        if (absenceReasonIDs != null) absenceReasonMatch = (x) => absenceReasonIDs.Contains(x.AbsenceReason.Oid.Value);
        //        else absenceReasonMatch = (x) => true;

        //        if (employmentTypeIDs != null) employmentTypeMatch = (x) => employmentTypeIDs.Contains(x.Oid.Value);
        //        else employmentTypeMatch = (x) => true;

        //        Func<AbsenceTime, bool> absenceMatch = (x) => rightMatch(x) && (!endHasValueMatch(x) || leftMatch(x)) && absenceReasonMatch(x);
        //        //startMatch(x) && (!endHasValueMatch(x) || endMatch(x)) && absenceReasonMatch(x);

        //        var res1 = new List<AbsenceTime>();
        //        var res2 = new HashSet<Employee>();

        //        var allAbsences = DAOFactory.GenericDAO.GetAllActive<AbsenceTime>().Where(x => x.EmployeeOid.HasValue);
        //        var allEmployees = DAOFactory.GenericDAO.GetAllActive<Employee>().ToList();

        //        foreach (var absence in allAbsences.Where(absenceMatch)) //allAbsences.Where(absenceMatch))
        //        {
        //            var employee = allEmployees.Find(x => x.Oid == absence.EmployeeOid.Value);

        //            if (!employmentTypeMatch(employee))
        //                continue;

        //            res1.Add(absence);
        //            res2.Add(employee);
        //        }

        //        return new Tuple<IList<AbsenceTimeDC>, IList<EmployeeDC>>(MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDCs(res1), MapperFactory.EmployeeDC_Employee.MapToNewDCs(res2.ToList()));
        //    }
        //    catch (Exception e)
        //    {
        //        throw Utils.CreateBeWoFaultException(e);
        //    }
        //}

        public IList<AbsenceReasonDC> GetAllAbsenceReason()
        {
            try
            {
                var list = DAOFactory.GenericDAO.GetAllActive<AbsenceReason>();
                return MapperFactory.AbsenceReasonDC_AbsenceReason.MapToNewDCs(list);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public AbsenceTimeDC UpdateAbsenceTimeWithReturn(AbsenceTimeDC abs)
        {
            try
            {
                var testbefore = abs.AbsenceTimeVersion;

                var x = DAOFactory.GenericDAO.LoadByID<AbsenceTime>(abs.AbsenceTimeOid.Value);

                MapperFactory.AbsenceTimeDC_AbsenceTime.MergeWithEntity(abs, x);

                DAOFactory.GenericDAO.Update(x);

                var y = DAOFactory.GenericDAO.LoadByID<AbsenceTime>(abs.AbsenceTimeOid.Value);

                var z = MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDC(y);

                return z;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public AbsenceTimeDC InsertAbsenceTimeWithReturn(AbsenceTimeDC absenceTimeDC)
        {
            try
            {
                var emp = DAOFactory.GenericDAO.GetByID<Employee>(absenceTimeDC.EmployeeOid.Value);
                emp.AbsenceTimes.Add(MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewEntity(absenceTimeDC));
                DAOFactory.GenericDAO.Update(emp);

                emp = DAOFactory.GenericDAO.LoadByID<Employee>(absenceTimeDC.EmployeeOid.Value);
                var newAbsenceTimeOid = emp.AbsenceTimes.Max(x => x.Oid);
                var newAbsenceTimeDC = DAOFactory.GenericDAO.GetByID<AbsenceTime>(newAbsenceTimeOid.Value);

                newAbsenceTimeDC.EmployeeOid = emp.Oid;
                return MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDC(newAbsenceTimeDC);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteAbsenceTime(AbsenceTimeDC absenceTimeDC)
        {
            try
            {
                var emp = DAOFactory.GenericDAO.GetByID<Employee>(absenceTimeDC.EmployeeOid.Value);
                emp.AbsenceTimes.Remove(emp.AbsenceTimes.First(a => a.Oid == absenceTimeDC.AbsenceTimeOid));
                DAOFactory.GenericDAO.Update(emp);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<SupportConceptCostBearerRelDC> GetSupportConceptCostBearerRelDCsByOids(List<long> supportConcept2CostbearerOids)
        {
            var costbearer2SupportConcepts = DAOFactory.SearchDAO.FindCostBearer2SupportConceptsByOids(supportConcept2CostbearerOids);

            return MapperFactory.SupportConceptCostBearerRelDC_CostBearer2SupportConcept.MapToNewDCs(costbearer2SupportConcepts);
        }

        public List<DienstInfoDC> GetAllDienste(long? wOid)
        {
            try
            {
                return DienstplanungsManager.GetAllDienste(wOid);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void InsertNewDienst(List<DienstInfoDC> dienst)
        {
            try
            {
                DienstplanungsManager.InsertNewDienst(dienst);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateDienst(Dictionary<long, long> pOid2Version)
        {
            try
            {
                DienstplanungsManager.DeactivateDienst(pOid2Version);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateDienst(List<DienstInfoDC> dienste)
        {
            try
            {
                DienstplanungsManager.UpdateDienst(dienste);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<RatingTypeDC> GetAllRatingTypes()
        {
            try
            {
                var list = DAOFactory.GenericDAO.GetAllActive<RatingType>();
                var result = MapperFactory.RatingTypeDC_RatingType.MapToNewDCs(list);

                return result.OrderBy(r => r.Position).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void InsertNewRatingType(List<RatingTypeDC> ratingTypes)
        {
            try
            {
                var ratingType = MapperFactory.RatingTypeDC_RatingType.MapToNewEntities(ratingTypes);
                DAOFactory.GenericDAO.Insert(ratingType);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateRatingType(Dictionary<long, long> pOid2Version)
        {
            try
            {
                ServiceLogic.SetActivationType<RatingType>(pOid2Version, ActivationTypeId.Deleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateRatingType(List<RatingTypeDC> ratingTypes)
        {
            try
            {
                var lOriginals = DAOFactory.GenericDAO.LoadByIDs<RatingType>(ratingTypes.Select(r => r.RatingTypeOid.Value));

                MapperFactory.RatingTypeDC_RatingType.MergeWithEntitys(ratingTypes, lOriginals);

                DAOFactory.GenericDAO.Update(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<GoalRatingDC> FetchServiceRecordRatings(long? supportConceptOid, long? costBearer2SupportConceptOid, long? supportConceptApprovalPeriodOid, long? serviceCategoryOid, DateTime? start, DateTime? end)
        {
            try
            {
                var types = new List<ValueListEntryType>();
                types.Add(ValueListEntryType.SupportConceptGoalCategoryType);
                types.Add(ValueListEntryType.SupportConceptIndividualGoalCategoryType);

                var goals = DAOFactory.SearchDAO.FindValueListEntries(types);

                Dictionary<long, ValueListEntryDC> oid2Entry = new Dictionary<long, ValueListEntryDC>();

                foreach (var valueListEntry in goals)
                {
                    if (!oid2Entry.ContainsKey(valueListEntry.Oid.Value))
                    {
                        oid2Entry.Add(valueListEntry.Oid.Value, MapperFactory.ValueListEntryDC_ValueListEntry.MapToNewDC(valueListEntry));
                    }
                }

                var allRatingTypes = MapperFactory.RatingTypeDC_RatingType.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<RatingType>());

                List<GoalRatingDC> result = new List<GoalRatingDC>();
                if (end.HasValue)
                {
                    end = end.Value.Date.AddDays(1).AddSeconds(-1);
                }
                var records = DAOFactory.SearchDAO.FindServiceRecords(supportConceptOid, costBearer2SupportConceptOid, serviceCategoryOid, start, end);

                foreach (var serviceRecord in records)
                {
                    var dc = CreateServiceRecordDCCompact(serviceRecord);
                    if (dc.Goals != null)
                    {
                        foreach (var ve in dc.Goals)
                        {
                            var gr = new GoalRatingDC();
                            gr.GoalEntry = ve;


                            if (ve.Type == ValueListEntryType.SupportConceptGoalType || ve.Type == ValueListEntryType.SupportConceptIndividualGoalType)
                            {
                                //Bei Maßnahmen nimm das übergeordnete Ziel
                                if (ve.ParentOid.HasValue && oid2Entry.ContainsKey(ve.ParentOid.Value))
                                {
                                    gr.GoalEntry = oid2Entry[ve.ParentOid.Value];
                                }
                            }

                            gr.ServiceRecord = dc;

                            if (ve.RatingTypeOid.HasValue)
                            {
                                gr.RatingType = allRatingTypes.FirstOrDefault(r => r.RatingTypeOid.HasValue && r.RatingTypeOid == ve.RatingTypeOid);
                            }
                            result.Add(gr);

                        }
                    }

                }

                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<DienstEintragDC> GetAllDienstEintraegeAsList(long wOid, int year, int month)
        {
            try
            {
                return DienstplanungsManager.GetAllDienstEintraegeAsList(wOid, year, month);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public List<DienstvertretungDC> GetAllDienstvertretungenAsList(long wOid, int year, int month)
        {
            try
            {
                return DienstplanungsManager.GetAllDienstvertretungenAsList(wOid, year, month);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public List<DienstBlockDC> GetDienstEintraege(long wOid, int year, int month)
        {
            try
            {
                return DienstplanungsManager.GetDienstEintraege(wOid, year, month);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public List<DienstBlockDC> GetDienstvertretungen(long wOid, int year, int month)
        {
            try
            {
                return DienstplanungsManager.GetDienstvertretungen(wOid, year, month);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }


        public void InsertNewDienstEintrag(DienstEintragDC dienstEintrag)
        {
            try
            {
                DienstplanungsManager.InsertNewDienstEintrag(dienstEintrag);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public bool InsertNewDienstEintrag2(DienstEintragDC dienstEintrag, List<DienstEintragDC> alleDiensteintraege, List<DienstvertretungDC> alleDienstvertretungen,
            int day, DateTime pflichtStart, DateTime pflichtEnde)
        {
            try
            {
                return DienstplanungsManager.InsertNewDienstEintrag2(dienstEintrag, alleDiensteintraege, alleDienstvertretungen, day, pflichtStart, pflichtEnde);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public void InsertNewDienstEintraege(List<DienstEintragDC> dienstEintraege)
        {
            try
            {
                DienstplanungsManager.InsertNewDienstEintraege(dienstEintraege);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void InsertNewDienstvertretung(DienstvertretungDC dienstvertretung)
        {
            try
            {
                DienstplanungsManager.InsertNewDienstvertretung(dienstvertretung);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public bool InsertNewDienstvertretung2(DienstvertretungDC dienstvertretung, List<DienstEintragDC> alleDiensteintraege, List<DienstvertretungDC> alleDienstvertretungen,
            int day, DateTime pflichtStart, DateTime pflichtEnde)
        {
            try
            {
                return DienstplanungsManager.InsertNewDienstvertretung2(dienstvertretung, alleDiensteintraege, alleDienstvertretungen, day, pflichtStart, pflichtEnde);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void UpdateDienstEintrag(DienstEintragDC dienstEintrag)
        {
            try
            {
                DienstplanungsManager.UpdateDienstEintrag(dienstEintrag);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteDienstEintrag(long empId, long wohnId, int zeile, DateTime date)
        {
            try
            {
                DienstplanungsManager.DeleteDienstEintrag(empId, wohnId, zeile, date);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public bool DeleteDienstEintrag2(long empId, long wohnId, int zeile, DateTime date, DienstEintragDC dienstEintrag, List<DienstEintragDC> alleDiensteintraege,
            List<DienstvertretungDC> alleDienstvertretungen, int day, DateTime pflichtStart, DateTime pflichtEnde)
        {
            try
            {
                return DienstplanungsManager.DeleteDienstEintrag2(empId, wohnId, zeile, date, dienstEintrag, alleDiensteintraege, alleDienstvertretungen, day, pflichtStart, pflichtEnde);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public void DeleteDienstvertretung(long empId, long wohnId, int zeile, DateTime date)
        {
            try
            {
                DienstplanungsManager.DeleteDienstvertretung(empId, wohnId, zeile, date);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public bool DeleteDienstvertretung2(long empId, long wohnId, int zeile, DateTime date, DienstvertretungDC dienstvertretung, List<DienstEintragDC> alleDiensteintraege,
            List<DienstvertretungDC> alleDienstvertretungen, int day, DateTime pflichtStart, DateTime pflichtEnde)
        {
            try
            {
                return DienstplanungsManager.DeleteDienstvertretung2(empId, wohnId, zeile, date, dienstvertretung, alleDiensteintraege, alleDienstvertretungen, day, pflichtStart, pflichtEnde);

            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteCertainDienstEintragOutOfTable(long dienstEintragOid)
        {
            try
            {
                DienstplanungsManager.DeleteCertainDienstEintragOutOfTable(dienstEintragOid);
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }
        public string GetBemerkungForDienstEintrag(long empId, long wohnId, int zeile, DateTime date)
        {
            try
            {
                return DienstplanungsManager.GetBemerkungForDienstEintrag(empId, wohnId, zeile, date);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public DienstEintragDC GetDienstEintrag(long empId, long wohnId, int zeile, DateTime date)
        {
            try
            {
                return DienstplanungsManager.GetDienstEintrag(empId, wohnId, zeile, date);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public DienstvertretungDC GetDienstvertretung(long empId, long wohnId, int zeile, DateTime date)
        {
            try
            {
                return DienstplanungsManager.GetDienstvertretung(empId, wohnId, zeile, date);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public virtual List<FeiertagDC> ErstelleDefaultFeiertage(int year)
        {
            try
            {
                var vs = PluginLoader.FindClass<VacationService>();

                var list = vs.GetFeiertage(year, vs.Bundesland);

                return list;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public List<FeiertagDC> GetDefaultFeiertageForYear(int year)
        {
            try
            {
                var vs = PluginLoader.FindClass<VacationService>();
                var ber = PluginLoader.FindClass<MitarbeiterstundenkontoBerechnung>();
                var altList = ber.GetFeiertage(year);
                var list = vs.GetFeiertage(year, vs.Bundesland);

                return list;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public void InsertRegelmaessigerDienst(RegelmaessigerDienstDC dienst)
        {
            try
            {
                DAOFactory.GenericDAO.Insert(MapperFactory.RegelmaessigerDienstDC_RegelmaessigerDienst.MapToNewEntity(dienst));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public List<DienstEintragDC> InsertRegelmaessigerDienst2(RegelmaessigerDienstDC dienst, List<DienstEintragDC> alleDienstEintraege, List<DienstvertretungDC> alleDienstvertretungen,
            List<AbsenceTimeDC> absenceTimes, bool enableDiensteAnFeiertagen, List<FeiertagDC> feiertage, List<DienstZeileDC> dienstZeilenListe, DateTime pflichtStart, DateTime pflichtEnde,
             bool enableStatusZeile, DateTime datum)
        {
            try
            {
                DAOFactory.GenericDAO.Insert(MapperFactory.RegelmaessigerDienstDC_RegelmaessigerDienst.MapToNewEntity(dienst));
                return DienstplanungsManager.AddRegelmaessigeDiensteToDienstplaner(dienst, alleDienstEintraege, alleDienstvertretungen, absenceTimes, feiertage, enableDiensteAnFeiertagen,
                    dienstZeilenListe, pflichtStart, pflichtEnde, enableStatusZeile, datum);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public void DeleteRegelmaessigerDienst(RegelmaessigerDienstDC dienst)
        {
            try
            {
                DAOFactory.GenericDAO.Delete(DAOFactory.GenericDAO.GetByID<RegelmaessigerDienst>((long)dienst.Oid));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void InsertConfirmationReceiptSignature(ConfirmationReceiptSignatureDC confirmationReceiptSignature)
        {
            try
            {
                var confRecSig = MapperFactory.ConfirmationReceiptSignatureDC_ConfirmationReceiptSignature.MapToNewEntity(confirmationReceiptSignature);

                DAOFactory.GenericDAO.Insert(confRecSig);

                MakeHistoryEntriesForConfirmationReceiptSignatures(new List<ConfirmationReceiptSignature> { confRecSig }, SignatureStateType.Valid);
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        public void InsertConfirmationReceiptSignatures(List<ConfirmationReceiptSignatureDC> confirmationReceiptSignatures)
        {
            try
            {
                var confRecSigs = MapperFactory.ConfirmationReceiptSignatureDC_ConfirmationReceiptSignature.MapToNewEntities(confirmationReceiptSignatures);

                DAOFactory.GenericDAO.Insert(confRecSigs);

                MakeHistoryEntriesForConfirmationReceiptSignatures(confRecSigs, SignatureStateType.Valid);
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        // ToDo: Ist der SignatureStateType Valid und ist die CRSOid null, die CRSOid hinzufügen!
        private static void MakeHistoryEntriesForConfirmationReceiptSignatures(List<ConfirmationReceiptSignature> confirmationReceiptSignatures, SignatureStateType signatureStateType)
        {
            foreach (var confirmationReceiptSignature in confirmationReceiptSignatures)
            {
                foreach (var serviceRecord in confirmationReceiptSignature.ServiceRecords)
                {
                    SignatureStateType? customerMonthlySignatureStateType;
                    SignatureStateType? employeeMonthlySignatureStateType;

                    long? customerConfirmationReceiptSignatureOid = null;
                    long? employeeConfirmationReceiptSignatureOid = null;

                    if (confirmationReceiptSignature.SignatureType == SignatureType.Customer)
                    {
                        customerMonthlySignatureStateType = signatureStateType;
                        employeeMonthlySignatureStateType = null;

                        if (signatureStateType == SignatureStateType.Valid)
                        {
                            customerConfirmationReceiptSignatureOid = confirmationReceiptSignature.Oid;
                        }
                    }
                    else
                    {
                        customerMonthlySignatureStateType = null;
                        employeeMonthlySignatureStateType = signatureStateType;

                        if (signatureStateType == SignatureStateType.Valid)
                        {
                            employeeConfirmationReceiptSignatureOid = confirmationReceiptSignature.Oid;
                        }
                    }

                    MakeSignatureStatusTypeServiceRecordHistoryEntry(serviceRecord, null, customerMonthlySignatureStateType, employeeMonthlySignatureStateType, customerConfirmationReceiptSignatureOid, employeeConfirmationReceiptSignatureOid);
                }
            }
        }

        public void DeleteConfirmationReceiptSignature(long confirmationReceiptSignatureOid)
        {
            try
            {
                var confirmationReceiptSignatureToDelete = DAOFactory.GenericDAO.LoadByID<ConfirmationReceiptSignature>(confirmationReceiptSignatureOid);

                //DAOFactory.GenericDAO.Delete(confirmationReceiptSignatureToDelete);

                ServiceLogic.SetActivationType<ConfirmationReceiptSignature>(new Dictionary<long, long> { { confirmationReceiptSignatureOid, confirmationReceiptSignatureToDelete.Version.Value } }, ActivationTypeId.Deleted);

                MakeHistoryEntriesForConfirmationReceiptSignatures(new List<ConfirmationReceiptSignature> { confirmationReceiptSignatureToDelete }, SignatureStateType.ManuallyDeleted);
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        public ConfirmationReceiptSignatureDC UpdateConfirmationReceiptSignature(ConfirmationReceiptSignatureDC confirmationReceiptSignature)
        {
            try
            {
                var confirmationReceiptSignatureToUpdate = DAOFactory.GenericDAO.LoadByID<ConfirmationReceiptSignature>(confirmationReceiptSignature.ConfirmationReceiptSignatureOid.Value);

                MapperFactory.ConfirmationReceiptSignatureDC_ConfirmationReceiptSignature.MergeWithEntity(confirmationReceiptSignature, confirmationReceiptSignatureToUpdate);

                DAOFactory.GenericDAO.Update(confirmationReceiptSignatureToUpdate);

                var updatedConfirmationReceiptSignature = DAOFactory.GenericDAO.LoadByID<ConfirmationReceiptSignature>(confirmationReceiptSignature.ConfirmationReceiptSignatureOid.Value);

                return MapperFactory.ConfirmationReceiptSignatureDC_ConfirmationReceiptSignature.MapToNewDC(updatedConfirmationReceiptSignature);
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        public List<ConfirmationReceiptSignatureDC> GetConfirmationReceiptSignaturesByEmployee(long employeeOid, DateTimeSpan timeSpan)
        {
            try
            {
                var signatures = DAOFactory.SearchDAO.GetConfirmationReceiptSignaturesByEmployee(employeeOid, timeSpan);

                var signatureDCs = MapperFactory.ConfirmationReceiptSignatureDC_ConfirmationReceiptSignature.MapToNewDCs(signatures);

                return signatureDCs;
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        public List<ConfirmationReceiptSignatureDC> GetConfirmationReceiptSignaturesByServiceRecord(long serviceRecordOid)
        {
            try
            {
                var signatures = DAOFactory.SearchDAO.GetConfirmationReceiptSignaturesByServiceRecord(serviceRecordOid);

                var signatureDCs = MapperFactory.ConfirmationReceiptSignatureDC_ConfirmationReceiptSignature.MapToNewDCs(signatures);

                return signatureDCs;
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        public List<EmployeeDC> GetAbsenceOverview(AbsenceOverviewFilterDC filter)
        {
            try
            {
                var res = new List<EmployeeDC>();
                var vs = PluginLoader.FindClass<VacationService>();

                var allEmployees = DAOFactory.GenericDAO.GetAllActive<Employee>().ToList();

                List<Team> teams = new List<Team>();
                if (filter.Teams != null)
                    teams = DAOFactory.GenericDAO.GetActiveByIDs<Team>(filter.Teams) as List<Team>;


                //foreach (var emp in allEmployees.OrderBy(x => x.Person.LastNameFirstName))
                List<Employee> benoetigteMitarbeiter = new List<Employee>();
                if (teams.Count == 0)
                    benoetigteMitarbeiter = allEmployees;
                else
                {
                    foreach (var team in teams)
                    {
                        benoetigteMitarbeiter.AddRange(team.MemberList);
                    }
                }
                benoetigteMitarbeiter.OrderBy(x => x.Person.LastNameFirstName).ToList();

                foreach (var emp in benoetigteMitarbeiter)
                {
                    if (filter.EmploymentType != null)
                        if (!emp.Contracts.Any(x => x.EmploymentType != null && filter.EmploymentType.Contains(x.EmploymentType.Oid.Value)))
                            continue;


                    var dict = vs.BerechneUrlaubskonto(emp, filter.Year);

                    if (filter.AbsenceReasons != null)
                        emp.AbsenceTimes.RemoveRange(x => !filter.AbsenceReasons.Contains(x.AbsenceReason.Oid.Value));

                    //if (filter.Teams != null)
                    //{
                    //    bool isInTeam = false;
                    //    foreach (var team in teams)
                    //    {
                    //        if (team.MemberList.Contains(emp))
                    //            isInTeam = true;
                    //    }
                    //    if (!isInTeam)
                    //        continue;
                    //}

                    var empDC = MapperFactory.EmployeeDC_Employee.MapToNewDC(emp);
                    if (dict.ContainsKey(filter.Year))
                    {
                        empDC.Urlaubskonto = dict[filter.Year];
                    }
                    else
                    {
                        int test = 0;
                    }

                    res.Add(empDC);
                }

                return res.OrderBy(e => e.LastNameFirstName).ToList();
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }
        public List<CompactTeamDC> GetCertainTeamsById(List<long> oids)
        {
            var teams = DAOFactory.GenericDAO.GetActiveByIDs<Team>(oids);
            return MapperFactory.CompactTeamDC_Team.MapToNewDCs(teams);
        }
        public UrlaubskontoDC GetUrlaubskontoByEmployee(long empOid, int year)
        {
            try
            {
                var vs = PluginLoader.FindClass<VacationService>();
                var emp = DAOFactory.GenericDAO.GetByID<Employee>(empOid);

                return vs.BerechneUrlaubskonto(emp, year)[year];
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }
        public List<AbsenceTimeDC> GetAbsenceTimesForMonth(long empOid, int month, int year, long absenceReason)
        {
            // monat und jahr sind 0
            var date = new DateTime(year, month, 1);
            List<AbsenceTime> timesForMonth = DAOFactory.SearchDAO.FindAbsenceTimesForEmployee(date, date.AddMonths(1).AddTicks(-1), empOid) as List<AbsenceTime>;

            List<AbsenceTime> urlaub = new List<AbsenceTime>();

            foreach (var item in timesForMonth)
            {
                if (item.AbsenceReason.Description.Equals("Urlaub"))
                    urlaub.Add(item);
            }

            List<AbsenceTimeDC> dcs = MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDCs(urlaub);

            return dcs;
        }

        public List<ConfirmationReceiptSignatureDC> GetAllConfirmationReceiptSignatures()
        {
            try
            {
                return MapperFactory.ConfirmationReceiptSignatureDC_ConfirmationReceiptSignature.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<ConfirmationReceiptSignature>());
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        public List<ServiceRecordDC> GetServiceRecordsByIds(List<long> serviceRecordOids)
        {
            try
            {
                return MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(DAOFactory.GenericDAO.LoadByIDs<ServiceRecord>(serviceRecordOids));
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }


        public String GetOwnChatSettingsUrl()
        {
            //var url = ConfigurationManager.AppSettings.Get("OwnChatSettingsUrl");
            //url = url.Replace("[TENANT]", MultitenancyOperationContextExt.Current.Tenant);

            //return url;

            if (MultitenancyOperationContextExt.Current != null)
            {
                var tenant = MultitenancyOperationContextExt.Current.Tenant;

                var mandant = GetMandatorEntity();

                var apikey = mandant.Apikey;

#if DEBUG       
                tenant = "6000000000";
                apikey = "CpmUcJGhFwySzMjFrahNKeWdv4paFo5VTfdS6ebq111DpL8LurkX3aKOPwiLVCdv";
#endif


                var serverUrl = OwnChatHelper.ErmittleServerURL(tenant);
                if (String.IsNullOrEmpty(serverUrl))
                {
                    return "https://www.bewoplaner.de";
                }
                String accesstokenUrl = String.Format("{0}/api/ownchat/settings/accesstoken/{1}/{2}", serverUrl, tenant, apikey);
                WebRequest request = WebRequest.Create(accesstokenUrl);

                request.Credentials = CredentialCache.DefaultCredentials;

                WebResponse response = request.GetResponse();

                string responseFromServer = ReadStreamForChatCode(response);

                var definition = new { result = "", errortext = "", token = "" };

                var jsondaten = JsonConvert.DeserializeAnonymousType(responseFromServer, definition);

                response.Close();


                return String.Format("{0}/settings/{1}/{2}", serverUrl, tenant, jsondaten.token);
            }


            return "https://www.bewoplaner.de";
        }

        public bool HasConfirmationReceiptSignaturesByEmployeeAndServiceRecords(long employeeOid, IEnumerable<long> serviceRecordOids)
        {
            try
            {
                return DAOFactory.SearchDAO.HasConfirmationReceiptSignaturesByEmployeeAndServiceRecords(employeeOid, serviceRecordOids);
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        public bool HasConfirmationReceiptSignatureByDateAndCustomer(long customerOid, DateTimeSpan timeSpan, SignatureType signatureType)
        {
            try
            {
                return DAOFactory.SearchDAO.HasConfirmationReceiptSignatureByDateAndCustomer(customerOid, timeSpan, signatureType);
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        public ServiceCategoryDC LoadServiceCategory(long serviceCategoryOid)
        {
            try
            {
                var serviceCategory = DAOFactory.GenericDAO.LoadByID<ServiceCategory>(serviceCategoryOid);

                return MapperFactory.ServiceCategoryDC_ServiceCategory.MapToNewDC(serviceCategory);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ConfirmationReceiptSignatureDC> FindConfirmationReceiptSignaturesByEmployeeAndServiceRecords(long employeeOid, IEnumerable<long> serviceRecordOids)
        {
            try
            {
                var confirmationReceiptSignatureEntities = DAOFactory.SearchDAO.FindConfirmationReceiptSignaturesByEmployeeAndServiceRecords(employeeOid, serviceRecordOids);

                return MapperFactory.ConfirmationReceiptSignatureDC_ConfirmationReceiptSignature.MapToNewDCs(confirmationReceiptSignatureEntities);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<VorlagentabelleDC> GetVorlagentabelleDCs()
        {
            try
            {
                return VorlagenManager.GetVorlagentabelleDCs();
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);

            }
        }

        public DokumentvorlageDC InsertTemplate(DokumentvorlageDC dc)
        {
            try
            {
                return VorlagenManager.InsertTemplate(dc);
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }
        public List<PlatzhalterDC> GetPlatzhalterForCustomer()
        {
            try
            {
                return VorlagenManager.GetPlatzhalterForCustomer();
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }
        public List<PlatzhalterDC> GetPlatzhalterForSupportConcept()
        {
            try
            {
                return VorlagenManager.GetPlatzhalterForSupportConcept();
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }
        public List<PlatzhalterDC> GetPlatzhalterForEmployee()
        {
            try
            {
                return VorlagenManager.GetPlatzhalterForEmployee();
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }
        public BeWoFolderDC GetFolderById(long oid)
        {
            try
            {
                return VorlagenManager.GetFolderById(oid);
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }
        public VorlagentabelleDC GetVorlagentabelleById(long oid)
        {
            try
            {
                return VorlagenManager.GetVorlagentabelleById(oid);
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }
        public List<DokumentvorlageDC> GetDokumentvorlagenInFolder(long folderOid)
        {
            try
            {
                return VorlagenManager.GetDokumentvorlagenInFolder(folderOid);
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }

        public List<SupportConceptDC> GetSupportConceptsById(IEnumerable<long> supportConceptOids)
        {
            try
            {
                var supportConcepts = DAOFactory.GenericDAO.LoadByIDs<SupportConcept>(supportConceptOids);

                return MapperFactory.SupportConceptDC_SupportConcept.MapToNewDCs(supportConcepts);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public void DeleteTemplates(List<DokumentvorlageDC> vorlagen)
        {
            try
            {
                VorlagenManager.DeleteTemplates(vorlagen);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public bool HasConfirmationReceiptSignature(IList<long> serviceRecordOids, SignatureType signatureType)
        {
            try
            {
                return DAOFactory.SearchDAO.HasConfirmationReceiptSignature(serviceRecordOids, signatureType);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public string ReplacePlaceholdersInTemplate(DokumentvorlageDC template, long? objectOid, long? tableOid)
        {
            try
            {
                return VorlagenManager.ReplacePlaceholdersInTemplate(template, objectOid, tableOid);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void InsertFileAttachment(FileAttachmentDC fileAttachmentDC)
        {
            try
            {
                DokumentManager.InsertFileAttachment(fileAttachmentDC);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<FileAttachmentDC> SearchForFiles(string nutzereingabe)
        {
            try
            {
                return DokumentManager.SearchForFiles(nutzereingabe);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public string GetObjectForFilePath(TableID table, long? oid)
        {
            try
            {
                return DokumentManager.GetObjectForFilePath(table, oid);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }


        public void RemoveAllDiensteForOneMonth(CompactWohnheimDC wh, DateTime month, List<RegelmaessigerDienstDC> rd)
        {
            try
            {
                DienstplanungsManager.RemoveAllDiensteForOneMonth(wh, month, rd);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public void RemoveAllDiensteForOneYear(CompactWohnheimDC wh, DateTime year, List<RegelmaessigerDienstDC> rd)
        {
            try
            {
                DienstplanungsManager.RemoveAllDiensteForOneYear(wh, year, rd);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public string GetColorForStatus(bool status)
        {
            try
            {
                return DienstplanungsManager.GetColorForStatus(status);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public string GetColorForForeground()
        {
            try
            {
                return DienstplanungsManager.GetColorForForeground();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public string GetColorForServiceRecordView2()
        {
            try
            {
                return "#008EED";
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public DienstplanerRootDC BuildDienstplanerRootObject(DateTime date, long wohnheimOid)
        {
            try
            {
                DienstplanerRootDC root = DienstplanungsManager.BuildDienstplanerRootObject(date, wohnheimOid);
                //root.Feiertage = GetDefaultFeiertageForYear(date.Year);

                return root;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public void DeleteRegelmaessigeDiensteOfRemovedEmployee(List<CompactEmployeeDC> employee, long wOid)
        {
            try
            {
                DienstplanungsManager.DeleteRegelmaessigeDiensteOfRemovedEmployee(employee, wOid);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<CompactEmployeeDC> GetCompactEmployeesForTeam(long teamOid)
        {
            try
            {
                return DienstplanungsManager.GetCompactEmployeesForTeam(teamOid);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public DienstZeileDC InitStatusZeile(DateTime date)
        {

            try
            {
                return DienstplanungsManager.InitStatusZeile(date);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public List<string> SetSortierMethoden()
        {
            try
            {
                return DienstplanungsManager.SetSortierMethoden();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public List<DienstBlockDC> DienstBloeckeNeuSortieren(List<DienstBlockDC> bloecke, string auswahl, bool aufsteigend)
        {
            try
            {
                return DienstplanungsManager.DienstBloeckeNeuSortieren(bloecke, auswahl, aufsteigend);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }


        public Dictionary<string, string> GetAdditionalEmployeeInformationForScheduler(long empOid)
        {
            Dictionary<string, string> dict = new Dictionary<string, string>();

            var employee = DAOFactory.GenericDAO.GetByID<Employee>(empOid);

            dict.Add("Vorname", employee.Person.FirstName);
            dict.Add("Nachname", employee.Person.LastName);
            if (employee.Person.DateOfBirth != null)
            {
                var dateAndTime = employee.Person.DateOfBirth.ToString().Split(' ');
                dict.Add("Geburtstag", dateAndTime[0]);
            }
            //if(employee.AbsenceTimes != null)
            //{
            //    int c = 1;
            //    foreach (var item in employee.AbsenceTimes)
            //    {
            //        dict.Add("Abwesenheit " + c, item.AbsenceSpan.ToDateString());
            //        c++;
            //    }
            //}
            if (employee.IsQualified != null)
                dict.Add("Qualifiziert", ((bool)employee.IsQualified) ? "Ja" : "Nein");
            if (employee.Schutzstufe != null)
                dict.Add("Schutzstufe", employee.Schutzstufe);


            return dict;
        }

        public string GetXAMLInformationStringForEmployee(long empOid)
        {
            try
            {
                return XAMLInformation.InfoViaXAMLManager.GetXAMLInformationStringForEmployee(empOid, null);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public string GetXAMLInformationStringForScheduler(long customerOid)
        {
            try
            {
                return XAMLInformation.InfoViaXAMLManager.GetXAMLInformationStringForScheduler(customerOid);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public string GetXAMLInformationStringForCustomer(long customerOid)
        {
            try
            {
                return XAMLInformation.InfoViaXAMLManager.GetXAMLInformationStringForCustomer(customerOid, null);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ConfirmationReceiptSignatureDC> LoadConfirmationReceiptSignaturesByServiceRecordOids(IList<long> serviceRecordOids, SignatureType signatureType, out List<long> serviceRecordOidsWithSignatures)
        {
            try
            {
                var signatures = DAOFactory.SearchDAO.LoadConfirmationReceiptSignaturesByServiceRecordOids(serviceRecordOids, signatureType);

                serviceRecordOidsWithSignatures = new List<long>();

                foreach (var crs in signatures)
                {
                    foreach (var sr in crs.ServiceRecords)
                    {
                        if (sr.Oid.HasValue && serviceRecordOids.Contains(sr.Oid.Value))
                        {
                            serviceRecordOidsWithSignatures.AddIfNotIn(sr.Oid.Value);
                        }
                    }
                }

                return MapperFactory.ConfirmationReceiptSignatureDC_ConfirmationReceiptSignature.MapToNewDCs(signatures);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ConfirmationReceiptSignatureDC> UpdateConfirmationReceiptSignatures(IList<ConfirmationReceiptSignatureDC> confirmationReceiptSignatures2Update)
        {
            try
            {
                var lOriginals = DAOFactory.GenericDAO.LoadByIDs<ConfirmationReceiptSignature>(confirmationReceiptSignatures2Update.Where(w => w.ConfirmationReceiptSignatureOid.HasValue).Select(confirmationReceiptSignatur => confirmationReceiptSignatur.ConfirmationReceiptSignatureOid.Value));

                MapperFactory.ConfirmationReceiptSignatureDC_ConfirmationReceiptSignature.MergeWithEntitys(confirmationReceiptSignatures2Update, lOriginals);

                DAOFactory.GenericDAO.Update(lOriginals);

                lOriginals = DAOFactory.GenericDAO.LoadByIDs<ConfirmationReceiptSignature>(confirmationReceiptSignatures2Update.Where(w => w.ConfirmationReceiptSignatureOid.HasValue).Select(confirmationReceiptSignatur => confirmationReceiptSignatur.ConfirmationReceiptSignatureOid.Value));

                return MapperFactory.ConfirmationReceiptSignatureDC_ConfirmationReceiptSignature.MapToNewDCs(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteConfirmationReceiptSignatures(Dictionary<long, long> oid2Version)
        {
            try
            {
                var originals = DAOFactory.GenericDAO.LoadByIDs<ConfirmationReceiptSignature>(oid2Version.Select(e => e.Key));

                ServiceLogic.SetActivationType<ConfirmationReceiptSignature>(oid2Version, ActivationTypeId.Deleted);

                MakeHistoryEntriesForConfirmationReceiptSignatures(originals, SignatureStateType.ManuallyDeleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public bool HasConfirmationReceiptSignaturesByCustomerAndServiceRecords(long customerOid, IEnumerable<long> serviceRecordOids)
        {
            try
            {
                return DAOFactory.SearchDAO.HasConfirmationReceiptSignaturesByCustomerAndServiceRecords(customerOid, serviceRecordOids);
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        public List<ConfirmationReceiptSignatureDC> LoadAllConfirmationReceiptSignaturesByServiceRecordOids(IList<long> serviceRecordOids, out Dictionary<SignatureType, List<long>> serviceRecordOidsWithSignature)
        {
            try
            {
                var confirmationReceiptSignatures = DAOFactory.SearchDAO.LoadConfirmationReceiptSignaturesByServiceRecordOids(serviceRecordOids);

                serviceRecordOidsWithSignature = new Dictionary<SignatureType, List<long>>();

                foreach (var csr in confirmationReceiptSignatures)
                {
                    serviceRecordOidsWithSignature.AddOrUpdateValueInDictionary(csr.SignatureType, csr.ServiceRecords.Where(sr => sr.Oid.HasValue).Select(sr => sr.Oid.Value).ToList());
                }

                return MapperFactory.ConfirmationReceiptSignatureDC_ConfirmationReceiptSignature.MapToNewDCs(confirmationReceiptSignatures);
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        public List<long> LoadServiceRecordOidsWithConfirmationReceiptSignatures(IList<long> serviceRecordOids)
        {
            try
            {
                return DAOFactory.SearchDAO.LoadServiceRecordOidsWithConfirmationReceiptSignatures(serviceRecordOids);
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        public List<long> LoadServiceRecordOidsWithCustomerConfirmationReceiptSignatures(IList<long> serviceRecordOids, SignatureType signatureType)
        {
            try
            {
                return DAOFactory.SearchDAO.LoadServiceRecordOidsWithConfirmationReceiptSignatures(serviceRecordOids, signatureType);
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        public List<ServiceRecordDC> GetServiceRecordsWithoutConfirmationReceiptSignature(IList<long> serviceRecordOids, SignatureType signatureType)
        {
            try
            {
                return MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(DAOFactory.SearchDAO.GetServiceRecordsWithoutConfirmationReceiptSignature(serviceRecordOids, signatureType));
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        /// <summary>
        /// Entfernt ServiceRecords von ConfirmationReceiptSignature-Objekten (Monatsunterschriften).
        /// Hat ein ConfirmationReceiptSignature-Objekt keine verknüpften ServiceRecords, wird es gelöscht.
        /// </summary>
        /// <param name="serviceRecordsToUpdate">ServiceRecords, die geändert oder gelöscht werden</param>
        /// <param name="oldServiceRecords">Die originalen ServiceRecords, mit denen die geänderten verglichen werden</param>
        /// <param name="isDeleting">Ist true, wenn es sich um das Löschen von ServiceRecords handelt</param>
        private static List<ServiceRecord2SignatureStates> RemoveServiceRecordsFromConfirmationReceiptSignatures(List<ServiceRecordDC> serviceRecordsToUpdate, IEnumerable<ServiceRecord> oldServiceRecords, bool isDeleting)
        {
            var result = new List<ServiceRecord2SignatureStates>();
            var serviceRecordOids = new List<long>();
            var oldVsNew = new Dictionary<ServiceRecord, ServiceRecordDC>();
            var orderedOldOnes = oldServiceRecords.Where(x => x.Oid.HasValue).OrderBy(x => x.Oid.Value).ToList();
            var orderedNewOnes = serviceRecordsToUpdate.Where(x => x.ServiceRecordOid.HasValue).OrderBy(x => x.ServiceRecordOid.Value).ToList();

            foreach (var oldSr in orderedOldOnes)
            {
                var newSr = orderedNewOnes.FirstOrDefault(f => f.ServiceRecordOid == oldSr.Oid);

                if (newSr != null)
                {
                    oldVsNew.Add(oldSr, newSr);
                }
            }

            foreach (var kvp in oldVsNew)
            {
                if (kvp.Value.ServiceRecordOid.HasValue && (kvp.Key.Start != kvp.Value.Start || kvp.Key.End != kvp.Value.End || isDeleting))
                {
                    serviceRecordOids.AddIfNotIn(kvp.Value.ServiceRecordOid.Value);
                }
            }

            var confirmationReceiptSignatures = DAOFactory.SearchDAO.LoadAllActiveConfirmationReceiptSignaturesByServiceRecordOids(serviceRecordOids);

            var confirmationReceiptSignatures2Delete = new List<ConfirmationReceiptSignature>();
            var confirmationReceiptSignatures2Update = new List<ConfirmationReceiptSignature>();

            foreach (var signature in confirmationReceiptSignatures)
            {
                var signatures2Keep = signature.ServiceRecords.Where(sr => sr.Oid.HasValue && !serviceRecordOids.Contains(sr.Oid.Value)).ToList();

                if (signatures2Keep.Count == 0)
                {
                    confirmationReceiptSignatures2Delete.AddIfNotIn(signature);
                    continue;
                }

                signature.ServiceRecords.Clear();
                signature.ServiceRecords = signatures2Keep;

                confirmationReceiptSignatures2Update.AddIfNotIn(signature);
            }

            DAOFactory.GenericDAO.Update(confirmationReceiptSignatures2Update);

            var oids2Versions = new Dictionary<long, long>();
            confirmationReceiptSignatures2Delete.DoForEach(signature =>
            {
                if (signature.Oid is null || signature.Version is null)
                {
                    return;
                }

                oids2Versions.Add(signature.Oid.Value, signature.Version.Value);
            });

            ServiceLogic.SetActivationType<ConfirmationReceiptSignature>(oids2Versions, ActivationTypeId.Deleted);

            var timeAlteredServiceRecords = DAOFactory.GenericDAO.LoadByIDs<ServiceRecord>(serviceRecordOids);

            var mostRecentSignatureStatusInfos = DAOFactory.SearchDAO.FindMostRecentSignatureStatusInfoByServiceRecords(serviceRecordOids);

            if (confirmationReceiptSignatures2Update.Any())
            {
                foreach (var serviceRecord in timeAlteredServiceRecords)
                {
                    SignatureStateInfoFromServiceRecordHistoryEntry previousRecordHistorySignatureInfo = null;

                    if (serviceRecord.Oid.HasValue && mostRecentSignatureStatusInfos.ContainsKey(serviceRecord.Oid.Value))
                    {
                        previousRecordHistorySignatureInfo = mostRecentSignatureStatusInfos[serviceRecord.Oid.Value];
                    }

                    var newCustomerSignatureState = DetermineNewSignatureState(previousRecordHistorySignatureInfo?.CustomerConfirmationReceiptSignatureStateType);
                    var newEmployeeSignatureState = DetermineNewSignatureState(previousRecordHistorySignatureInfo?.EmployeeConfirmationReceiptSignatureStateType);

                    var newSignatureStatesObject = new ServiceRecord2SignatureStates(
                        serviceRecord,
                        null,
                        newCustomerSignatureState,
                        newEmployeeSignatureState
                    );

                    result.Add(newSignatureStatesObject);
                }
            }

            foreach (var confirmationReceiptSignature in confirmationReceiptSignatures2Delete)
            {
                var first = confirmationReceiptSignature.ServiceRecords.FirstOrDefault();

                // Eine Unterschrift, die in der confirmationReceiptSignatures2Delete ist, hat nur noch den einen ServiceRecord, der gerade in der Zeit bearbeitet wird!
                if (first != null)
                {
                    var signatureOid = confirmationReceiptSignature.Oid.Value;

                    var formerlySignedServiceRecords = DAOFactory.SearchDAO.FindFormerlyLinkedServiceRecordsBySignatureOid(signatureOid);

                    var blah = DAOFactory.SearchDAO.FindMostRecentSignatureStatusInfoByServiceRecords(formerlySignedServiceRecords.Select(sr => sr.Oid.Value).ToList());

                    mostRecentSignatureStatusInfos.AddAndIgnoreDuplicates(blah);

                    confirmationReceiptSignature.ServiceRecords.AddRangeIfElementsNotIn(formerlySignedServiceRecords);
                }

                foreach (var serviceRecord in confirmationReceiptSignature.ServiceRecords)
                {
                    var previousServiceRecord2SignatureStates = result.FirstOrDefault(f => f.ServiceRecord.Equals(serviceRecord));

                    var newSignatureStatesObject = new ServiceRecord2SignatureStates(
                        serviceRecord,
                        null,
                        SignatureStateType.None,
                        SignatureStateType.None
                    );

                    if (previousServiceRecord2SignatureStates is null)
                    {
                        SignatureStateInfoFromServiceRecordHistoryEntry previousRecordHistorySignatureInfo = null;

                        if (serviceRecord.Oid.HasValue && mostRecentSignatureStatusInfos.ContainsKey(serviceRecord.Oid.Value))
                        {
                            previousRecordHistorySignatureInfo = mostRecentSignatureStatusInfos[serviceRecord.Oid.Value];
                        }

                        newSignatureStatesObject.CustomerMonthlySignatureStateType = DetermineNewDeletedSignatureState(previousRecordHistorySignatureInfo?.CustomerConfirmationReceiptSignatureStateType);
                        newSignatureStatesObject.EmployeeMonthlySignatreStateType = DetermineNewDeletedSignatureState(previousRecordHistorySignatureInfo?.EmployeeConfirmationReceiptSignatureStateType);
                    }
                    else
                    {
                        newSignatureStatesObject.CustomerMonthlySignatureStateType = DetermineNewDeletedSignatureState(previousServiceRecord2SignatureStates.CustomerMonthlySignatureStateType);
                        newSignatureStatesObject.EmployeeMonthlySignatreStateType = DetermineNewDeletedSignatureState(previousServiceRecord2SignatureStates.EmployeeMonthlySignatreStateType);
                    }

                    result.AddIfNotIn(newSignatureStatesObject);
                }
            }

            return result;
        }

        private static SignatureStateType DetermineNewDeletedSignatureState(SignatureStateType? previouSignatureStateType)
        {
            switch (previouSignatureStateType)
            {
                case null:
                    return SignatureStateType.None;
                case SignatureStateType.None:
                    return SignatureStateType.None;
                case SignatureStateType.ManuallyDeleted:
                    return SignatureStateType.ManuallyDeleted;
                default:
                    return SignatureStateType.AutomaticallyDeleted;
            }
        }

        private static SignatureStateType DetermineNewSignatureState(SignatureStateType? previousSignatureStateType)
        {
            var newSignatureStateType = SignatureStateType.None;

            switch (previousSignatureStateType)
            {
                case SignatureStateType.Valid:
                    newSignatureStateType = SignatureStateType.Invalid;
                    break;
                case SignatureStateType.Invalid:
                    newSignatureStateType = SignatureStateType.Invalid;
                    break;
                case SignatureStateType.ManuallyDeleted:
                    newSignatureStateType = (SignatureStateType)previousSignatureStateType;
                    break;
                case SignatureStateType.AutomaticallyDeleted:
                    newSignatureStateType = (SignatureStateType)previousSignatureStateType;
                    break;
            }

            return newSignatureStateType;
        }

        /// <summary>
        /// Löscht die Zeiterfassungseinträge aus der Linktable, die Zeiterfassungseinträge mit Monatsunterschriften verbindet.
        /// </summary>
        /// <param name="serviceRecords">Die Zeiterfassungseinträge, die gelöscht werden und eventuell mit Monatsunterschriften verknüpft sind.</param>
        private static void RemoveServiceRecordsFromConfirmationReceiptSignatureForDeletion(IEnumerable<ServiceRecord> serviceRecords)
        {
            var serviceRecordOids = serviceRecords.Select(serviceRecord => serviceRecord.Oid.Value).ToList();

            var confirmationReceiptSignatures = DAOFactory.SearchDAO.LoadAllConfirmationReceiptSignaturesByServiceRecordOids(serviceRecordOids);

            foreach (var signature in confirmationReceiptSignatures)
            {
                var serviceRecords2Keep = signature.ServiceRecords.Where(serviceRecord => serviceRecord.Oid.HasValue && !serviceRecordOids.Contains(serviceRecord.Oid.Value)).ToList();
                signature.ServiceRecords.Clear();
                signature.ServiceRecords = serviceRecords2Keep;
            }

            DAOFactory.GenericDAO.Update(confirmationReceiptSignatures);
        }

        public List<RatingTypeDC> GetRatingTypesByOids(List<long> ratingTypeOids)
        {
            try
            {
                var ratingTypes = DAOFactory.GenericDAO.LoadByIDs<RatingType>(ratingTypeOids);

                return MapperFactory.RatingTypeDC_RatingType.MapToNewDCs(ratingTypes);
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        public UrlaubsplanerRootDC BuildUrlaubsplanerRootObject(AbsenceOverviewFilterDC filter)
        {
            UrlaubsplanerRootDC root = new UrlaubsplanerRootDC();
            var empService = new EmployeeServiceImp();

            root.Feiertage = GetDefaultFeiertageForYear(filter.Year).Where(f => f.Datum.Month == filter.Month).ToList();
            root.Abwesenheiten = empService.GetAllEmployeeAbsenceTimesForMonth(filter.Year, filter.Month);
            root.GeschenkteUrlaubstage = empService.GetGeschenkteUrlaubstageForYear(filter.Year);

            var DCsToDelete = empService.GetAllAbwesenheitsInformationPrints();
            empService.DeleteAbwesenheitsInformationPrints(DCsToDelete);

            //root.AlleAbwesenheitsInformationDCs = new List<AbwesenheitsInformationDC>();

            //var employee = GetAbsenceOverview(filter);

            //foreach (var emp in employee)
            //{
            //    root.AlleAbwesenheitsInformationDCs.Add(new AbwesenheitsInformationDC()
            //    {
            //        Employee = emp,
            //        Month = filter.Month,
            //        Year = filter.Year,
            //        AbsenceTimes = root.Abwesenheiten.Where(a => a.EmployeeOid == emp.EmployeeOid).ToList(),
            //        GeschenkteUrlaubstage = root.GeschenkteUrlaubstage.Where(u => u.Employee == emp.EmployeeOid).ToList()
            //    });
            //}

            return root;
        }

        public string GetInformationStringForUrlaubsplaner(UrlaubskontoDC dc, decimal tageUrlaub, decimal tageKrank, bool urlaubVerfallen)
        {
            try
            {
                return XAMLInformation.InfoViaXAMLManager.GetXAMLInformationStringForUrlaubsplaner(dc, tageUrlaub, tageKrank, urlaubVerfallen);
            }
            catch (Exception exception)
            {
                throw Utils.CreateBeWoFaultException(exception);
            }
        }

        /// <summary>
        /// Löscht die Einzelunterschriften von ServiceRecords und aktualisiert die ServiceRecords
        /// </summary>
        /// <param name="serviceRecords"></param>
        /// <param name="originals"></param>
        private static List<ServiceRecord> DeleteSignaturesFromServiceRecords(IEnumerable<ServiceRecordDC> serviceRecords, List<ServiceRecord> originals)
        {
            var result = new List<ServiceRecord>();
            var oldVsNew = new Dictionary<ServiceRecord, ServiceRecordDC>();
            var orderedOldOnes = originals.Where(x => x.Oid.HasValue).OrderBy(x => x.Oid.Value).ToList();
            var orderedNewOnes = serviceRecords.Where(x => x.ServiceRecordOid.HasValue).OrderBy(x => x.ServiceRecordOid.Value).ToList();

            foreach (var oldSr in orderedOldOnes)
            {
                var newSr = orderedNewOnes.FirstOrDefault(f => f.ServiceRecordOid == oldSr.Oid);

                if (newSr != null)
                {
                    oldVsNew.Add(oldSr, newSr);
                }
            }

            var signatureOids = new List<long>();
            foreach (var kvp in oldVsNew)
            {
                if ((kvp.Key.Start != kvp.Value.Start || kvp.Key.End != kvp.Value.End) && kvp.Key.SignatureOid.HasValue)
                {
                    signatureOids.AddIfNotIn(kvp.Key.SignatureOid.Value);
                    kvp.Value.SignatureOid = null;
                }
            }

            if (signatureOids.Any())
            {
                var signatures2Delete = DAOFactory.GenericDAO.LoadByIDs<Signature>(signatureOids);

                var oids2Versions = new Dictionary<long, long>();
                signatures2Delete.DoForEach(signature =>
                {
                    oids2Versions.Add(signature.Oid.Value, signature.Version.Value);
                });

                ServiceLogic.SetActivationType<Signature>(oids2Versions, ActivationTypeId.Deleted);

                foreach (var serviceRecord in originals)
                {
                    //MakeSignatureStatusTypeServiceRecordHistoryEntry(serviceRecord, SignatureStateType.Invalid, null, null);
                    result.AddIfNotIn(serviceRecord);
                }
            }

            return result;
        }

        public List<DienstZeileDC> InitDienstzeilen(DienstBlockDC block, List<DienstInfoDC> dienste, DateTime date, int? standardanzahlZeilen)
        {
            try
            {
                return DienstplanungsManager.Init(block, dienste, date, standardanzahlZeilen);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public List<DienstZeileDC> InitDienstzeilenNachSortieren(List<DienstBlockDC> bloecke, List<DienstInfoDC> dienste, DateTime date, int? standardanzahlZeilen)
        {
            try
            {
                return DienstplanungsManager.InitNachSortieren(bloecke, dienste, date, standardanzahlZeilen);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public DienstplanerMonthlySummaryDC BerechneSollSaldoUndIstFuerEinzelnenMitarbeiter(DateTime date, long empOid, List<DienstEintragDC> dienstEintraege, List<DienstvertretungDC> dienstvertretungen,
            List<AbsenceTimeDC> absenceTimes, List<OvertimeDC> overtimes, out long stundenBeiAbwesenheitKey, out decimal stundenBeiAbwesenheitValue)
        {
            return DienstplanungsManager.BerechneSollSaldoUndIstFuerEinzelnenMitarbeiter(date, empOid, dienstEintraege, dienstvertretungen, absenceTimes, overtimes, out stundenBeiAbwesenheitKey, out stundenBeiAbwesenheitValue);
        }


        public void SaveAllFilesToDisk()
        {
            var oid = DAOFactory.SearchDAO.GetMaxOidFromFileAttachment();

            for (int i = 1; i <= oid; i++)
            {
                var file = DAOFactory.GenericDAO.LoadByID<FileAttachment>(i);

                try
                {
                    //prüfe ob Datei existiert, sonst kommt ein Hibernate Fehler

                    if (file.Data?.Length > 0)
                    {
                        FileAttachmentUtils.SaveFileToFileDirectory(file);
                    }
                }
                catch (Exception)
                {

                }



            }
        }

        public List<ServiceRecordDC> GetCustomerServiceRecordsWithStartEndDate(long pCustomerOid, long costbearer2SupportConceptOid, DateTime start, DateTime ende)
        {
            try
            {
                var serviceRecords = DAOFactory.SearchDAO.FindServiceRecordsDetailsForLastDaysWithStartEndDate(costbearer2SupportConceptOid, start, ende);
                var distinctServiceRecords = serviceRecords.Distinct();

                return MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(distinctServiceRecords);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ConfirmationReceiptSignatureDC> GetConfirmationReceiptSignatures(List<long> oids)
        {
            try
            {
                var signatures = DAOFactory.GenericDAO.GetActiveByIDs<ConfirmationReceiptSignature>(oids);

                return MapperFactory.ConfirmationReceiptSignatureDC_ConfirmationReceiptSignature.MapToNewDCs(signatures);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public SchedulerAppointmentDC GetRootAppointment(string recurrenceId)
        {
            try
            {
                if (Guid.TryParse(recurrenceId, out var guid))
                {
                    var rootAppointment = DAOFactory.SearchDAO.FindRootAppointmentByRecurrenceId(recurrenceId);

                    return MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDC(rootAppointment);
                }

                return null;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public Dictionary<string, string> GetDiagiosisStringsForICD10Codes(List<string> icd10Codes)
        {
            try
            {
                var result = new Dictionary<string, string>();

                foreach (var code in icd10Codes)
                {
                    result.AddIfNotIn(new KeyValuePair<string, string>(code, ICD10DAO.GetDiagnosisForCode(code)));
                }

                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteSignature(long signatureOid, long serviceRecordOid)
        {
            try
            {
                var serviceRecord = DAOFactory.GenericDAO.LoadByID<ServiceRecord>(serviceRecordOid);

                var signature = DAOFactory.GenericDAO.LoadByID<Signature>(signatureOid);

                if (signature?.Oid is null || serviceRecord?.SignatureOid is null)
                {
                    return;
                }

                if (!serviceRecord.SignatureOid.Value.Equals(signature.Oid.Value))
                {
                    return;
                }

                MapperFactory.SignatureDC_Signature.ConcurrencyCheck(signature.Version, signature);

                DAOFactory.GenericDAO.Delete(signature);

                serviceRecord.SignatureOid = null;
                DAOFactory.GenericDAO.Update(serviceRecord);

                MakeSignatureStatusTypeServiceRecordHistoryEntry(serviceRecord, SignatureStateType.ManuallyDeleted, null, null, null, null);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        /// <summary>
        /// Prüft, ob der angegebene ServiceRecord auch eine Monatsunterschrift(ConfirmationReceiptSignature) hat.
        /// </summary>
        /// <param name="serviceRecordOid">Oid des ServiceRecords</param>
        /// <param name="signatureType">Mitarbeiter- oder Klientenunterschrift</param>
        /// <returns>Ob der ServiceRecord mit einer Monatsunterschrift verknüpft ist</returns>
        public bool CheckForConfirmationReceiptSignatureForServiceRecord(long serviceRecordOid, SignatureType signatureType)
        {
            try
            {
                return DAOFactory.SearchDAO.CheckForConfirmationReceiptSignatureForServiceRecord(serviceRecordOid, signatureType);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        private static void MakeSignatureStatusTypeServiceRecordHistoryEntry(ServiceRecord serviceRecord, SignatureStateType? singleSignatureStateType, SignatureStateType? customerMonthlySignatureStateType, SignatureStateType? employeeMonthlySignatureStateType, long? customerConfirmationReceiptSignatureOid, long? employeeConfirmationReceiptsignatureOid)
        {
            // Alten Unterschriftenstatus aus ServiceRecordHistory laden
            SignatureStateInfoFromServiceRecordHistoryEntry previousRecordHistorySignatureInfo = null;

            if (serviceRecord.Oid.HasValue)
            {
                previousRecordHistorySignatureInfo = DAOFactory.SearchDAO.FindMostRecentSignatureStatusInfoByServiceRecordOid(serviceRecord.Oid.Value);
            }

            var seviceRecordHistoryEntry = new ServiceRecordHistory
            {
                TimeStamp = DateTime.Now,
                ChangeType = StatementType.Signature,
                CostBearer2SupportConcept = serviceRecord.CostBearer2SupportConcept,
                CostBearer2SupportConceptOid = serviceRecord.CostBearer2SupportConceptOid,
                Customer = serviceRecord.Customer,
                CustomerOid = serviceRecord.CustomerOid,
                Employee = serviceRecord.Employee,
                EmployeeOid = serviceRecord.EmployeeOid,
                End = serviceRecord.End,
                Group = serviceRecord.Group,
                GroupEmployeeCount = serviceRecord.GroupEmployeeCount,
                GroupOid = serviceRecord.GroupOid,
                GroupPersonCount = serviceRecord.GroupPersonCount,
                GroupRoundedDuration = serviceRecord.GroupRoundedDuration,
                IP = serviceRecord.IP,
                IsActive = serviceRecord.IsActive,
                Notice = serviceRecord.Notice,
                ServiceRecordOid = serviceRecord.Oid,
                RoundedDuration = serviceRecord.RoundedDuration,
                ServiceDescription = serviceRecord.ServiceDescription,
                ServiceRecordType = serviceRecord.ServiceRecordType,
                ServiceRecordInsTs = serviceRecord.InsTs,
                ServiceRecordVersion = serviceRecord.Version.Value,
                ServiceRecordInsUser = serviceRecord.InsUser,
                ServiceRecordUdpUser = serviceRecord.UdpUser,
                Start = serviceRecord.Start,
                SupportConcept = serviceRecord.SupportConcept,
                SystemEntryID = serviceRecord.SystemEntryID,
                DistanceInMeter = serviceRecord.DistanceInMeter,
                IsCreatedInMobileClient = serviceRecord.IsCreatedInMobileClient,
                CustomerConfirmationReceiptSignatureStateType = customerMonthlySignatureStateType ?? previousRecordHistorySignatureInfo?.CustomerConfirmationReceiptSignatureStateType ?? SignatureStateType.None,
                EmployeeConfirmationReceiptSignatureStateType = employeeMonthlySignatureStateType ?? previousRecordHistorySignatureInfo?.EmployeeConfirmationReceiptSignatureStateType ?? SignatureStateType.None,
                ServiceRecordSignatureStateType = singleSignatureStateType ?? previousRecordHistorySignatureInfo?.ServiceRecordSignatureStateType ?? SignatureStateType.None,
                CustomerConfirmationReceiptSignatureOid = customerConfirmationReceiptSignatureOid ?? previousRecordHistorySignatureInfo?.CustomerConfirmationReceiptSignatureOid,
                EmployeeConfirmationReceiptSignatureOid = employeeConfirmationReceiptsignatureOid ?? previousRecordHistorySignatureInfo?.EmployeeConfirmationReceiptSignatureOid
            };

            DAOFactory.GenericDAO.Insert(seviceRecordHistoryEntry);
        }

        public string GetDakotaFileFormat(object param)
        {
            try
            {
                //var test_oid = Convert.ToInt64(param);
                //var test_invoicebase = DAOFactory.GenericDAO.GetByID<InvoiceBase>(test_oid);
                //var test_datetime = test_invoicebase.InvoiceDate.Value;

                //var manager = new DakotaManager(test_datetime.Month, DateTime.Now);
                //var oids = new List<Int64>();

                //oids.Add(test_oid);

                //foreach (var invoicebase_oid in oids)
                //{
                //    var service = DAOFactory.SearchDAO.GetServiceInvoiceByInvoiceBaseOid(invoicebase_oid);
                //    var invoicebase = DAOFactory.GenericDAO.GetByID<InvoiceBase>(invoicebase_oid);
                //    var orga = invoicebase.CostBearer2SupportConcept.CostBearer.Organisation;
                //    var customer = invoicebase.CostBearer2SupportConcept.SupportConcept.Customer;
                //    var mandator = GetMandatorEntity();

                //    var servicedc = MapperFactory.ServiceInvoiceDC_ServiceInvoice.MapToNewDC(service);
                //    var orgadc = MapperFactory.OrganisationDC_OrganisationMapper.MapToNewDC(orga);
                //    var customerdc = MapperFactory.CustomerDC_Customer.MapToNewDC(customer);
                //    var mandatordc = MapperFactory.MandatorDC_Mandator.MapToNewDC(mandator);

                //    manager.Add(servicedc, orgadc, customerdc, mandatordc);
                //}


                //manager.Apply();

                //manager.Save(@"C:\Projects\GKV Abrechnung Tests", true);

                ////return manager.DakotaFileDict.First().Value.GetNutzdatendatei();

                //var nutzdatendatei = manager.DakotaFileDict.First().Value.GetNutzdatendatei();

                //String url = "http://localhost:3777/Host/GkvAbrechnungView.aspx";
                ////String url = "https://app8.bewoplaner.de/service/GkvAbrechnungView.aspx";
                //using (WebClient client = new WebClient())
                //{
                //    //MessageBox.Show(hostAddress);

                //    var nvc = new NameValueCollection();
                //    nvc.Add("Kundennummer", "7375324044");
                //    nvc.Add("IKDatenannahmestelle", manager.DakotaFileDict.First().Value.GetIKEmpfang());
                //    nvc.Add("IKEmpfang", manager.DakotaFileDict.First().Value.GetIKEmpfang());
                //    nvc.Add("TransferName", manager.DakotaFileDict.First().Value.GetTransferName());
                //    nvc.Add("Nutzdatendatei", nutzdatendatei);
                //    nvc.Add("Auftragsdatei", manager.DakotaFileDict.First().Value.GetAuftragsdatei());

                //    byte[] response = client.UploadValues(url, "POST", nvc);

                //    String responseStr = System.Text.Encoding.ASCII.GetString(response);
                //}

                //return nutzdatendatei;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }

            throw new NotImplementedException();
        }

        public List<ServiceRecordDC> GetEmployeesServiceRecordsWithStartEndDatePaginated(long pEmployeeOid, DateTime start, DateTime ende, int firstResult, int maxResults, out int rowCount)
        {
            try
            {
                var serviceRecords = DAOFactory.SearchDAO.FindEmployeeServiceRecordsWithoutCustomerWithStartEndDatePaginated(pEmployeeOid, start, ende, firstResult, maxResults, out rowCount);

                return MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(serviceRecords);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceRecordDC> GetEmployeesServiceRecords2Paginated(long pEmployeeOid, long? days, int firstResult, int maxResults, out int rowCount)
        {
            try
            {
                var serviceRecords = DAOFactory.SearchDAO.FindEmployeeServiceRecordsWithoutCustomerPaginated(pEmployeeOid, days, firstResult, maxResults, out rowCount);

                return MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(serviceRecords);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<ServiceRecordDC> GetCustomerServiceRecordsWithStartEndDatePaginated(long pCustomerOid, long costbearer2SupportConceptOid, DateTime start, DateTime ende, int firstResult, int maxResults, out int rowCount)
        {
            try
            {
                var serviceRecords = DAOFactory.SearchDAO.FindServiceRecordsDetailsForLastDaysWithStartEndDatePaginated(costbearer2SupportConceptOid, start, ende, firstResult, maxResults, out rowCount);
                var distinctServiceRecords = serviceRecords.Distinct();

                return MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(distinctServiceRecords);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public IList<ServiceRecordDC> FindServiceRecordsForLastDaysPaginated(long? costbearer2SupportConceptOid, int days, long? employeeOid, int firstResult, int maxResults, out int rowCount)
        {
            try
            {
                return MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(DAOFactory.SearchDAO.FindServiceRecordsForDaysPaginated(costbearer2SupportConceptOid, days, employeeOid, firstResult, maxResults, out rowCount));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<BargeldtransaktionshistoryDC> LoadBargeldtransaktionshistoryEntries(long transaktionsOid)
        {
            try
            {
                var historyEntries = DAOFactory.SearchDAO.LoadBargeldtransaktionshistoryEntries(transaktionsOid);

                return MapperFactory.BargeldtransaktionshistoryDC_Bargeldtransaktionshistory.MapToNewDCs(historyEntries);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<SignatureDC> GetAllSignatures()
        {
            try
            {
                return MapperFactory.SignatureDC_Signature.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<Signature>());
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<BargeldtransaktionshistoryDC> LoadBargeldtransaktionshistoryEntriesByTransaktionsOids(List<long> transaktionsOids)
        {
            try
            {
                return MapperFactory.BargeldtransaktionshistoryDC_Bargeldtransaktionshistory.MapToNewDCs(DAOFactory.SearchDAO.LoadBargeldtransaktionshistoryEntriesByTransaktionsOids(transaktionsOids));
            }
            catch(Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
    }

    public class ServiceRecord2SignatureStates
    {
        public ServiceRecord ServiceRecord { get; }
        public SignatureStateType? SingleSignatureStateType { get; set; }
        public SignatureStateType? CustomerMonthlySignatureStateType { get; set; }
        public SignatureStateType? EmployeeMonthlySignatreStateType { get; set; }

        /// <summary>
        /// Erzeugt das Objekt mit den SignatureStates. Wird als Wert eines States null übergeben, wird beim Erzeugen des ServiceRecordHistory-Eintrags der Wert des vorherigen ServiceRecordHistory-Eintrags genommen, falls vorhanden.
        /// </summary>
        /// <param name="serviceRecord"></param>
        /// <param name="singleSignatureStateType"></param>
        /// <param name="customerMonthlySignatureStateType"></param>
        /// <param name="employeeMonthlySignatreStateType"></param>
        public ServiceRecord2SignatureStates(ServiceRecord serviceRecord, SignatureStateType? singleSignatureStateType, SignatureStateType? customerMonthlySignatureStateType, SignatureStateType? employeeMonthlySignatreStateType)
        {
            ServiceRecord = serviceRecord;
            SingleSignatureStateType = singleSignatureStateType;
            CustomerMonthlySignatureStateType = customerMonthlySignatureStateType;
            EmployeeMonthlySignatreStateType = employeeMonthlySignatreStateType;
        }

        public override bool Equals(object obj)
        {
            if (obj is ServiceRecord2SignatureStates sr2Ss && !(sr2Ss.ServiceRecord is null))
            {
                return ServiceRecord?.Equals(sr2Ss.ServiceRecord) ?? false;
            }

            return false;
        }
    }
}