using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using BeWo.Data.Entities;
using BeWo.View.Navigation.Filter;
using BS.Shared.Extensions;
using NHibernate;
using NHibernate.Criterion;
using NHibernate.Engine;
using NHibernate.Impl;
using NHibernate.Loader.Criteria;
using NHibernate.Persister.Entity;
using NHibernate.SqlCommand;

using BS.Shared.Core;
using BS.Shared;
using BS.Shared.DataContracts;
using DevExpress.XtraScheduler;
using DevExpress.XtraScheduler.Compatibility;
using NHibernate.Transform;
using static System.String;
using Appointment = BeWo.Data.Entities.Appointment;
using Login = BeWo.Data.Entities.Login;
using Resource = BeWo.Data.Entities.Resource;

namespace BeWo.Data.Access
{
    public class SearchDAO : AbstractBaseDAO
    {
        private static readonly Regex RecurrenceIdRegex = new Regex("(Id=\\\"[a-z0-9-]+\\\")");

        public IEnumerable<ValueListEntry> FindValueListEntry(ValueListEntryType pType)
        {
            return CreateCriteria<ValueListEntry>().Add(Restrictions.Eq(ValueListEntry.PropertyName_Type, pType)).AddOrder(Order.Asc(ValueListEntry.PropertyName_Value)).List<ValueListEntry>();
        }

        public IEnumerable<ValueListEntry> FindValueListEntries(List<ValueListEntryType> pTypes)
        {
            return CreateCriteria<ValueListEntry>().Add(Restrictions.In(ValueListEntry.PropertyName_Type, pTypes)).AddOrder(Order.Asc(ValueListEntry.PropertyName_Value)).List<ValueListEntry>();
        }

        public virtual IEnumerable<Employee> FindEmployee(string pFirstName, string pLastName, string pPersonnelNumber)
        {
            return CreateCriteria<Employee>()
            .Add(Restrictions.Like(Employee.PropertyName_PersonnelNumber, pPersonnelNumber, MatchMode.Anywhere))
            .CreateCriteria(Employee.PropertyName_Person, JoinType.InnerJoin)
                .Add(Restrictions.Like(Person.PropertyName_FirstName, pFirstName, MatchMode.Anywhere))
                .Add(Restrictions.Like(Person.PropertyName_LastName, pLastName, MatchMode.Anywhere))
            .List<Employee>();
        }

	    public virtual Employee FindEmployeeByFullname(string pFullname)
	    {
			var q = Session.CreateSQLQuery(Format("SELECT Oid FROM Person WHERE CONCAT_WS(' ', FirstName, LastName) LIKE '%{0}%'", pFullname));
		    var x = q.List<long>();

		    return x.Count > 0 ? DAOFactory.GenericDAO.GetByID<Employee>(x.First()) : null;
	    }

        public virtual IEnumerable<Wohnheim> FindWohnheim(string pwohnheimName, string pWohnheimStrasse, string pWohnheimPlz)
        {
            return CreateCriteria<Wohnheim>()
            .Add(Restrictions.Like(Wohnheim.PropertyName_WohnheimName, pwohnheimName, MatchMode.Anywhere))
            .CreateCriteria(Wohnheim.PropertyName_Wohnheim, JoinType.InnerJoin)
                .Add(Restrictions.Like(Wohnheim.PropertyName_Strasse, pWohnheimStrasse, MatchMode.Anywhere))
                .Add(Restrictions.Like(Wohnheim.PropertyName_PlZ, pWohnheimPlz, MatchMode.Anywhere))
            .List<Wohnheim>();
        }

        public virtual Wohnheim FindWohnheimByFullname(string pWohnheimName)
        {
            var q = Session.CreateSQLQuery(Format("SELECT Oid FROM Wohnheim WHERE CONCAT_WS(' ', WohnheimName) LIKE '%{0}%'", pWohnheimName));
            var x = q.List<long>();

            return x.Count > 0 ? DAOFactory.GenericDAO.GetByID<Wohnheim>(x.First()) : null;
        }

        public virtual IEnumerable<Customer> FindCustomer(string pFirstName, string pLastName, string pReferenceNumber)
        {
            return CreateCriteria<Customer>()
            .Add(Restrictions.Like(Customer.PropertyName_ReferenceNumber, pReferenceNumber, MatchMode.Anywhere))
            .CreateCriteria(Customer.PropertyName_Person, JoinType.InnerJoin)
                .Add(Restrictions.Like(Person.PropertyName_FirstName, pFirstName, MatchMode.Anywhere))
                .Add(Restrictions.Like(Person.PropertyName_LastName, pLastName, MatchMode.Anywhere))
            .List<Customer>();
        }

        public virtual IList<Customer> FindCustomer(string pFirstName, string pLastName, DateTime pBirthDate)
        {
            return CreateCriteriaIsActiveOrArchived<Customer>()
                .CreateCriteria(Customer.PropertyName_Person, JoinType.InnerJoin)
                .Add(Restrictions.Eq(Person.PropertyName_FirstName, pFirstName))
                .Add(Restrictions.Eq(Person.PropertyName_LastName, pLastName))
                .Add(Restrictions.Eq(Person.PropertyName_DateOfBirth, pBirthDate))
                .List<Customer>();
        }

        public virtual IEnumerable<Person> FindPerson(string pFirstName, string pLastName, DateTime? pDateOfBirth, PersonType? pPersonType)
        {
            var lCriteria = CreateCriteria<Person>()
             .Add(Restrictions.Like(Person.PropertyName_FirstName, pFirstName, MatchMode.Anywhere))
             .Add(Restrictions.Like(Person.PropertyName_LastName, pLastName, MatchMode.Anywhere));
            if (pDateOfBirth != null)
                lCriteria.Add(Restrictions.Eq(Person.PropertyName_DateOfBirth, pDateOfBirth));
            if (pPersonType != null)
                lCriteria.Add(Restrictions.Eq(Person.PropertyName_Type, pPersonType));

            return lCriteria.List<Person>();
        }

        public virtual IEnumerable<Organisation> FindOrganisation(string pName, bool pOnlyCostBearer)
        {
            var lCriteria = CreateCriteria<Organisation>()
             .Add(Restrictions.Like(Organisation.PropertyName_Name, pName, MatchMode.Anywhere));

            if (pOnlyCostBearer)
                lCriteria.Add(Restrictions.IsNotNull(Organisation.PropertyName_CostBearer));

            return lCriteria.List<Organisation>();
        }

        public virtual IEnumerable<Team> FindTeams(string pTeamName, string pLeaderFirstName, string pLeaderLastName)
        {
            return CreateCriteria<Team>()
            .Add(Restrictions.Like(Team.PropertyName_Name, pTeamName, MatchMode.Anywhere))
            .CreateCriteria(Team.PropertyName_Leader, JoinType.InnerJoin)
                .CreateCriteria(Employee.PropertyName_Person)
                    .Add(Restrictions.Like(Person.PropertyName_FirstName, pLeaderFirstName, MatchMode.Anywhere))
                    .Add(Restrictions.Like(Person.PropertyName_LastName, pLeaderLastName, MatchMode.Anywhere))
            .List<Team>();
        }

		public virtual IList<Team> FindTeamsOfEmployee(long employeeOid)
		{
			return CreateCriteriaIsActiveOrArchived<Team>()
			.CreateCriteria(Team.PropertyName_MemberList, JoinType.InnerJoin)
				.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, employeeOid))
			.List<Team>();
		}

		public virtual IEnumerable<Team> FindLeadingTeams(long employeeOid)
		{
			return CreateCriteriaIsActiveOrArchived<Team>()
			.CreateCriteria(Team.PropertyName_Leader, JoinType.InnerJoin)
				.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, employeeOid))
			.List<Team>();
		}

        public virtual IList<Team> FindAllActiveTeamsOfEmployee(long employeeOid)
        {
            return CreateCriteriaIsActive<Team>()
                  .CreateAlias(Team.PropertyName_MemberList, "m", JoinType.InnerJoin)
                  .CreateAlias(Team.PropertyName_Leader, "l", JoinType.InnerJoin)
                  .Add(Restrictions.Disjunction()
                      .Add(Restrictions.Eq("m." + BeWoEntityBase.PropertyName_Oid, employeeOid))
                      .Add(Restrictions.Eq("l." + BeWoEntityBase.PropertyName_Oid, employeeOid)))
                  .List<Team>().Distinct().ToList();

        }

        public virtual IList<Customer> FindCustomerOfTeam(long teamOid)
        {
            return CreateCriteriaIsActiveOrArchived<Customer>()
                .CreateCriteria(Customer.PropertyName_Team2CustomerList, JoinType.InnerJoin)
                .Add(Restrictions.Eq(Team2Customer.PropertyName_TeamOid, teamOid))
                .List<Customer>();
        }

        public IEnumerable<ResourceBookingSequence> FindBookings(long pResourceOid, DateTime pSpanStart, DateTime pSpanEnd)
        {
            var lResult = CreateCriteria<ResourceBookingSequence>()
                  .CreateAlias(ResourceBookingSequence.PropertyName_Resource, "r")
                  .CreateAlias(ResourceBookingSequence.PropertyName_Details, "d")
                  .Add(Restrictions.Eq("r." + BeWoEntityBase.PropertyName_Oid, pResourceOid))
                  .Add(Restrictions.Eq("d." + ResourceBooking.PropertyName_SequencePosition, 0))
                  .Add(Restrictions.Disjunction()
                      .Add(Restrictions.Between("d." + ResourceBooking.PropertyName_Start, pSpanStart, pSpanEnd))
                      .Add(Restrictions.Between(ResourceBookingSequence.PropertyName_SequenceEnd, pSpanStart, pSpanEnd))
                      .Add(Restrictions.Conjunction()
                          .Add(Restrictions.Le("d." + ResourceBooking.PropertyName_Start, pSpanStart))
                          .Add(Restrictions.Ge(ResourceBookingSequence.PropertyName_SequenceEnd, pSpanEnd))
                          )
                       )
                  .List<ResourceBookingSequence>();

            return lResult;
        }

        public IEnumerable<ResourceBookingSequence> FindBookings(DateTime pSpanStart, DateTime pSpanEnd)
        {
            var lResult = CreateCriteria<ResourceBookingSequence>()
                  .CreateAlias(ResourceBookingSequence.PropertyName_Details, "d")
                  .Add(Restrictions.Eq("d." + ResourceBooking.PropertyName_SequencePosition, 0))
                  .Add(Restrictions.Disjunction()
                      .Add(Restrictions.Between("d." + ResourceBooking.PropertyName_Start, pSpanStart, pSpanEnd))
                      .Add(Restrictions.Between(ResourceBookingSequence.PropertyName_SequenceEnd, pSpanStart, pSpanEnd))
                      .Add(Restrictions.Conjunction()
                          .Add(Restrictions.Le("d." + ResourceBooking.PropertyName_Start, pSpanStart))
                          .Add(Restrictions.Ge(ResourceBookingSequence.PropertyName_SequenceEnd, pSpanEnd))
                          )
                       )
                  .List<ResourceBookingSequence>();

            return lResult;
        }

        public List<ServiceRecord> FindServiceRecords(long? pEmployeeOid, long? pCostBearer2SupportConceptOid)
        {
            var c = CreateCriteria<ServiceRecord>()
                .CreateAlias(ServiceRecord.PropertyName_Employee, "e", JoinType.InnerJoin);

            if (pCostBearer2SupportConceptOid.HasValue)
            {
                c = c.CreateAlias(ServiceRecord.PropertyName_SupportConcept, "sc", JoinType.InnerJoin)
                     .CreateAlias("sc." + SupportConcept.PropertyName_CostBearer2SupportConceptList, "c2s", JoinType.InnerJoin);
            }

            if (pEmployeeOid.HasValue)
                c = c.Add(Restrictions.Eq("e." + BeWoEntityBase.PropertyName_Oid, pEmployeeOid));
            if (pCostBearer2SupportConceptOid.HasValue)
                c = c.Add(Restrictions.Eq("c2s." + BeWoEntityBase.PropertyName_Oid, pCostBearer2SupportConceptOid));

            return c.List<ServiceRecord>().ToList();
        }

		public List<ServiceRecord> FindServiceRecordsForSupportConcept(long pSupportConceptOid)
		{
			var c = CreateCriteria<ServiceRecord>()
				.CreateAlias(ServiceRecord.PropertyName_SupportConcept, "sc", JoinType.InnerJoin);

			c = c.Add(Restrictions.Eq("sc." + BeWoEntityBase.PropertyName_Oid, pSupportConceptOid));
			return c.List<ServiceRecord>().ToList();
		}

        public List<ServiceRecord> FindServiceRecords(long? supportConceptOid, long? costBearer2SupportConceptOid, long? serviceCategoryOid, DateTime? start, DateTime? end)
        {
            var c = CreateCriteria<ServiceRecord>()
                .CreateAlias(ServiceRecord.PropertyName_Employee, "e", JoinType.InnerJoin);

            if (supportConceptOid.HasValue)
            {
                c = c.CreateAlias(ServiceRecord.PropertyName_SupportConcept, "sc", JoinType.InnerJoin);
            }
            if (serviceCategoryOid.HasValue)
            {
                c = c.CreateAlias(ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
                    .CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "cat", JoinType.InnerJoin);
            }

            if (supportConceptOid.HasValue)
            {
                c = c.Add(Restrictions.Eq("sc." + BeWoEntityBase.PropertyName_Oid, supportConceptOid));
            }

            if (costBearer2SupportConceptOid.HasValue)
            {
                c = c.Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costBearer2SupportConceptOid));
            }

            if (serviceCategoryOid.HasValue)
            {
                c = c.Add(Restrictions.Eq("cat." + BeWoEntityBase.PropertyName_Oid, serviceCategoryOid));
            }

            if (start.HasValue && end.HasValue)
            {
                c.Add(Restrictions.Between(ServiceRecord.PropertyName_Start, start, end));
            }
            //{
            //    c = c.CreateAlias(ServiceRecord.PropertyName_SupportConcept, "sc", JoinType.InnerJoin)
            //        .CreateAlias("sc." + SupportConcept.PropertyName_CostBearer2SupportConceptList, "c2s", JoinType.InnerJoin);
            //}

            //if (pEmployeeOid.HasValue)
            //    c = c.Add(Restrictions.Eq("e." + BeWoEntityBase.PropertyName_Oid, pEmployeeOid));


            return c.List<ServiceRecord>().ToList();
        }

        public IList<SupportConceptApprovalPeriod2Employee> FindSupportConceptApprovalPeriod2Employees(Employee emp)
        {
            var c = CreateCriteria<SupportConceptApprovalPeriod2Employee>()
                .Add(Restrictions.Eq(SupportConceptApprovalPeriod2Employee.PropertyName_Employee, emp));
            return c.List<SupportConceptApprovalPeriod2Employee>().ToList();
        }

        public IList<SupportConceptApprovalPeriod2Employee> FindSupportConceptApprovalPeriod2Employees(SupportConceptApprovalPeriod scap)
        {
            var c = CreateCriteria<SupportConceptApprovalPeriod2Employee>()
                .Add(Restrictions.Eq(SupportConceptApprovalPeriod2Employee.PropertyName_SupportConceptApprovalPeriod, scap));
            return c.List<SupportConceptApprovalPeriod2Employee>().ToList();
        }

        public IEnumerable<ServiceRecord> FindServiceRecordsInSpan(long pCostBearer2SupportConceptOid, DateTimeSpan period)
        {
            var criteria = CreateCriteria<ServiceRecord>()
                .Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, pCostBearer2SupportConceptOid));

            if (period != null)
                criteria =
                    criteria.Add(
                        Restrictions.Or(
                            Restrictions.Between(ServiceRecord.PropertyName_Start, period.StartDateTime, period.EndDateTime),
                            Restrictions.Between(ServiceRecord.PropertyName_End, period.StartDateTime, period.EndDateTime)));

            return criteria.List<ServiceRecord>().ToList();
        }

        public IEnumerable<ServiceRecordHistory> FindServiceRecordHistory(long serviceRecordOid)
        {
            var criteria = CreateCriteria<ServiceRecordHistory>()
                .Add(Restrictions.Eq(ServiceRecordHistory.PropertyName_ServiceRecordOid, serviceRecordOid));


            return criteria.List<ServiceRecordHistory>().ToList();
        }

        public IEnumerable<ServiceRecord> FindEmployeeServiceRecordsWithoutCustomer(long pEmployeeOid, long? days)
        {

            var c = CreateCriteria<ServiceRecord>()
                  .Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, pEmployeeOid))
                  .Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));
			if (days.HasValue)
			{

				var minDate = DateTime.Now.Date.AddDays(-1 * days.Value);
				c.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, minDate));
			}

            return c.List<ServiceRecord>().ToList();
        }

		public IEnumerable<ServiceRecord> FindEmployeeServiceRecordsWithoutCustomerInSpan(long pEmployeeOid, DateTimeSpan period)
		{
			var criteria = CreateCriteria<ServiceRecord>()
				.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, pEmployeeOid))
				.Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));

			if (period != null)
			{
				criteria =
					criteria.Add(
						Restrictions.Or(
							Restrictions.Between(ServiceRecord.PropertyName_Start, period.StartDateTime, period.EndDateTime),
							Restrictions.Between(ServiceRecord.PropertyName_End, period.StartDateTime, period.EndDateTime)));
			}

			return criteria.List<ServiceRecord>().ToList();
		}

        public IEnumerable<ServiceRecord> FindEmployeeServiceRecordsWithoutCustomerWithStartEndDate(long pEmployeeOid, DateTime start, DateTime ende)
        {

            var c = CreateCriteria<ServiceRecord>()
                  .Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, pEmployeeOid))
                  .Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));

                    var max = ende.Date.AddDays(1);

                    c.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, start.Date))
                    .Add(Restrictions.Lt(ServiceRecord.PropertyName_End, max.Date));
            

            return c.List<ServiceRecord>().ToList();
        }

        public IList<ServiceRecord> FindEmployeeServiceRecords(long pEmployeeOid, DateTimeSpan pSpan, long? customerOid, ServiceRecordTypeId? srTypeFilter)
        {
            var lCriteria = CreateCriteria<ServiceRecord>()
                  .Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, pEmployeeOid));

			if (pSpan != null)
				lCriteria.Add(Restrictions.Between(ServiceRecord.PropertyName_Start, pSpan.StartDateTime, pSpan.EndDateTime));
            if (customerOid != null)
                lCriteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_CustomerOid, customerOid.Value));
			if (srTypeFilter.HasValue)
			{
				lCriteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_ServiceRecordType, srTypeFilter.Value));
			}

            var result = lCriteria.List<ServiceRecord>().ToList();

            return result;
        }

        public IList<ServiceRecord> FindCustomerServiceRecords(long customerOid)
        {
            var lCriteria = CreateCriteria<ServiceRecord>()
                  .Add(Restrictions.Eq(ServiceRecord.PropertyName_CustomerOid, customerOid));

            return lCriteria.List<ServiceRecord>();
        }

		public IList<ServiceRecord> FindCustomerServiceRecords(long customerOid, DateTimeSpan pSpan, long? employeeOid, ServiceRecordTypeId? srTypeFilter, bool includeEndDateInSearch)
        {
            var lCriteria = CreateCriteria<ServiceRecord>()
                .Add(Restrictions.Eq(ServiceRecord.PropertyName_CustomerOid, customerOid));


		    if (includeEndDateInSearch)
		    {
		        var orCriteria = Restrictions.Or(
		            Restrictions.Between(ServiceRecord.PropertyName_Start, pSpan.StartDateTime, pSpan.EndDateTime),
		            Restrictions.Between(ServiceRecord.PropertyName_End, pSpan.StartDateTime, pSpan.EndDateTime));

                orCriteria = Restrictions.Or(orCriteria,
                    Restrictions.And(
                        Restrictions.Le(ServiceRecord.PropertyName_Start,pSpan.EndDateTime),
                        Restrictions.Ge(ServiceRecord.PropertyName_End, pSpan.StartDateTime)));


                lCriteria.Add(orCriteria);
		    }
		    else
		    {
		        lCriteria.Add(Restrictions.Between(ServiceRecord.PropertyName_Start, pSpan.StartDateTime, pSpan.EndDateTime));
		    }
                  
                  

            if (employeeOid != null)
                lCriteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, employeeOid.Value));
			if (srTypeFilter.HasValue)
			{
				lCriteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_ServiceRecordType, srTypeFilter.Value));
			}
            return lCriteria.List<ServiceRecord>();
        }

        public IEnumerable<ServiceRecord> FindServiceRecordsInSpan(DateTimeSpan pSpan, ServiceRecordTypeId? srTypeFilter)
        {
            var lCriteria = CreateCriteria<ServiceRecord>()
                  .Add(Restrictions.Between(ServiceRecord.PropertyName_Start, pSpan.StartDateTime, pSpan.EndDateTime));
	        if (srTypeFilter.HasValue)
	        {
				lCriteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_ServiceRecordType, srTypeFilter.Value));
	        }
            return lCriteria.List<ServiceRecord>().ToList();
        }

        public IEnumerable<AccountingTransaction> FindUnassignedAccountingTransactions()
        {
            return CreateCriteria<AccountingTransaction>()
                  .Add(Restrictions.IsNull(AccountingTransaction.PropertyName_CostBearer2SupportConcept))
                .List<AccountingTransaction>().ToList();
        }

        public IEnumerable<SupportConcept> FindSupportConcept(
         string pCustomerFirstName,
         string pCustomerLastName,
         string pCustomerReferenceNumber,
         DateTime? pFrom,
         DateTime? pTill)
        {
            var lCriteria = CreateCriteria<SupportConcept>();

            //if (pFrom != null)
            //    lCriteria.Add(Expression.Ge(SupportConcept.PropertyName_Start, pFrom));
            //if (pTill != null)
            //    lCriteria.Add(Expression.Le(SupportConcept.PropertyName_End, pTill));

            lCriteria = lCriteria.CreateCriteria(SupportConcept.PropertyName_Customer, JoinType.InnerJoin);

            if (!IsNullOrEmpty(pCustomerReferenceNumber))
                lCriteria.Add(Restrictions.Eq(Customer.PropertyName_ReferenceNumber, pCustomerReferenceNumber));

            if (!Utils.AreAllNullOrEmpty(pCustomerFirstName, pCustomerLastName))
                lCriteria.CreateCriteria(Customer.PropertyName_Person)
                  .Add(Restrictions.Like(Person.PropertyName_FirstName, pCustomerFirstName, MatchMode.Anywhere))
                  .Add(Restrictions.Like(Person.PropertyName_LastName, pCustomerLastName, MatchMode.Anywhere));

            return lCriteria.List<SupportConcept>();
        }

        public IEnumerable<SupportConcept> FindCurrentSupportConcepts()
        {
            return CreateCriteriaIsActive<SupportConcept>()
                //.Add(Expression.Ge(SupportConcept.PropertyName_End, DateTime.Now))
                .List<SupportConcept>();
        }

        public IEnumerable<SupportConcept> FindSupportConceptsInSpan(DateTimeSpan pSpan)
        {
            return CreateCriteriaIsActive<SupportConcept>()
                //.Add(Expression.Disjunction()
                //     .Add(Expression.Between(SupportConcept.PropertyName_Start, pSpan.StartDateTime, pSpan.EndDateTime))
                //     .Add(Expression.Between(SupportConcept.PropertyName_End, pSpan.StartDateTime, pSpan.EndDateTime))
                //     .Add(Expression.Conjunction()
                //         .Add(Expression.Le(SupportConcept.PropertyName_Start, pSpan.StartDateTime))
                //         .Add(Expression.Ge(SupportConcept.PropertyName_End, pSpan.EndDateTime))
                //         )
                //      )
                 .List<SupportConcept>();
        }

        public IEnumerable<SupportConcept> FindExpiringSupportConcepts(long? employeeOid, DateTime minDate, DateTime expiredUntil)
        {
            var c = CreateCriteriaIsActive<SupportConcept>();
            if (employeeOid == null)
            {
                return c
                    .CreateCriteria(SupportConcept.PropertyName_CostBearer2SupportConceptList, JoinType.InnerJoin)
                       .Add(Restrictions.Between(CostBearer2SupportConcept.PropertyName_ApprovedEndDate, minDate, expiredUntil))
                   .List<SupportConcept>();
            }         

            return c
                .CreateAlias(SupportConcept.PropertyName_CostBearer2SupportConceptList, "cb2sc", JoinType.InnerJoin)
                .CreateAlias(SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
                .CreateAlias("c.Employee2CustomerList", "e2c", JoinType.InnerJoin)           
                .Add(Restrictions.Eq("e2c." + Employee2Customer.PropertyName_EmployeeOid, employeeOid.Value))
                .Add(Restrictions.Or(
                                Restrictions.Between("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedEndDate, minDate, expiredUntil),
                                Restrictions.And(Restrictions.IsNotNull("c.TerminationDate"), Restrictions.Between("c.TerminationDate", minDate, expiredUntil))))                                                             
                .List<SupportConcept>().Distinct().ToList();
        }

        public IEnumerable<SupportConcept> FindSupportConceptsWithConferenceDate(long? employeeOid, DateTime conferenceDateUntil)
        {
            var c = CreateCriteriaIsActive<SupportConcept>();
            if (employeeOid == null)
            {
                return c
                   .Add(Restrictions.Between(SupportConcept.PropertyName_ConferenceDate, DateTime.Now, conferenceDateUntil))
                   .List<SupportConcept>();
            }

            return c
                .CreateAlias(SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
                .CreateAlias("c.Employee2CustomerList", "e2c", JoinType.InnerJoin)
                .Add(Restrictions.Between(SupportConcept.PropertyName_ConferenceDate, DateTime.Now.Date, conferenceDateUntil))
                .Add(Restrictions.Eq("e2c." + Employee2Customer.PropertyName_EmployeeOid, employeeOid.Value))
                .List<SupportConcept>().Distinct().ToList();
        }
        public ApplicationUser FindUserForEmployee(Employee employee)
        {
            return CreateCriteria<ApplicationUser>()
                .Add(Restrictions.Eq(ApplicationUser.PropertyName_Employee, employee))
                .List<ApplicationUser>().FirstOrDefault();
        }

        public IEnumerable<Person> FindPersonsHavingBirthday(DateTime birthdayUntil)
        {
            var ts = birthdayUntil.Subtract(DateTime.Now);
            var days = ts.Days + 1;
            
            return CreateCriteriaIsActive<Person>()
               .Add(Expression.Sql(new SqlString("dayofyear(CAST(CONCAT(Year(CURDATE()), '-', Month(" + Person.PropertyName_DateOfBirth + "), '-', Day(" + Person.PropertyName_DateOfBirth + ")) AS DATE )) between dayofyear(CURDATE()) -4 and dayofyear(CURDATE()) + " + days)))
               .List<Person>();
        }
        
        public IEnumerable<Login> FindLastLogins(string loginName)
        {
            return CreateCriteria<Login>()
                .Add(Restrictions.Eq(Login.PropertyName_LoginName, loginName))
                .AddOrder(Order.Desc("Oid"))
                .SetMaxResults(10)
                .List<Login>();
        }

        public IEnumerable<Query> FindQuery(QueryType pType)
        {
            return CreateCriteria<Query>().Add(Restrictions.Eq(Query.PropertyName_Type, pType))
                .List<Query>().ToList();
        }

        public IList<AccountingTransaction> FindAccoutingTransactions(DateTimeSpan pSpan)
        {
            var lCriteria = CreateCriteriaIsActive<AccountingTransaction>();

            if (pSpan != null)
                lCriteria.Add(Restrictions.Between(AccountingTransaction.PropertyName_BookingDate, pSpan.StartDateTime, pSpan.EndDateTime));

            var test = lCriteria.List<AccountingTransaction>();

            return test;
        }

        public IEnumerable<AccountingTransaction> FindAccoutingTransactions(DateTimeSpan pSpan, long? pSupportConceptOid, long? pSupportConceptCostBearerRelOid)
        {
            var lCriteria = CreateCriteriaIsActive<AccountingTransaction>()
                .CreateAlias(AccountingTransaction.PropertyName_CostBearer2SupportConcept, "cb2sc", JoinType.LeftOuterJoin);

            if (pSpan != null)
                lCriteria.Add(Restrictions.Between(AccountingTransaction.PropertyName_BookingDate, pSpan.StartDateTime, pSpan.EndDateTime));

            if (pSupportConceptCostBearerRelOid != null)
                lCriteria.Add(Restrictions.Eq("cb2sc." + BeWoEntityBase.PropertyName_Oid, pSupportConceptCostBearerRelOid));

            if (pSupportConceptOid != null)
            {
                lCriteria.CreateCriteria("cb2sc." + CostBearer2SupportConcept.PropertyName_SupportConcept)
                    .Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, pSupportConceptOid));
            }

            var test = lCriteria.List<AccountingTransaction>();

            return test;
        }

        public IList<Settings> FindSettingsByValuePart(SettingsType pType, string pValuePart)
        {
            return CreateCriteria<Settings>()
                  .Add(Restrictions.Eq(Settings.PropertyName_Type, pType))
                  .Add(Restrictions.Like(Settings.PropertyName_Value, pValuePart, MatchMode.Anywhere))
                  .List<Settings>();
        }

        public IList<FileAttachment> FindFileAttachments(TableID pObjTid, long pObjOid)
        {
            return CreateCriteriaIsActive<FileAttachment>()
                .Add(Restrictions.Eq(FileAttachment.PropertyName_ObjectOid, pObjOid))
                .Add(Restrictions.Eq(FileAttachment.PropertyName_ObjectTid, pObjTid))
                .List<FileAttachment>();
        }

        public IEnumerable<FileAttachmentInfo> FindFileAttachmentInfos(TableID pObjTid, long pObjOid)
        {
            return CreateCriteriaIsActive<FileAttachmentInfo>()
                .Add(Restrictions.Eq(FileAttachmentInfo.PropertyName_ObjectOid, pObjOid))
                .Add(Restrictions.Eq(FileAttachmentInfo.PropertyName_ObjectTid, pObjTid))
                .List<FileAttachmentInfo>();
        }

        public IList<BeWoFolder> FindBeWoFolders(TableID pObjTid, long pObjOid)
        {
            var c = CreateCriteriaIsActive<BeWoFolder>()
                .Add(Restrictions.Eq(BeWoFolder.PropertyName_ObjectTid, pObjTid));

            if (pObjOid > 0)
            {
                c.Add(Restrictions.Eq(BeWoFolder.PropertyName_ObjectOid, pObjOid));
            }
            return c.List<BeWoFolder>();
        }

        //public IList<SupportConcept> FindAllActiveApprovedLVRSupportConcepts()
        //{
        //    return CreateCriteriaIsActive<SupportConcept>()
        //        .CreateCriteria(SupportConcept.PropertyName_CostBearer2SupportConceptList, JoinType.InnerJoin)
        //        .Add(Expression.Eq(CostBearer2SupportConcept.PropertyName_Status, CostBearer2SupportConceptStatus.Approved))
        //        .CreateCriteria(CostBearer2SupportConcept.PropertyName_CostBearer, JoinType.InnerJoin)
        //        .Add(Expression.Eq(CostBearer.PropertyName_SystemEntryID, SystemEntryID.CostBearerLVR))
        //        .List<SupportConcept>();
        //}

        public IList<SupportConcept> FindAllActiveApprovedSupportConcepts()
        {
            return CreateCriteriaIsActive<SupportConcept>()
                .CreateCriteria(SupportConcept.PropertyName_CostBearer2SupportConceptList, JoinType.InnerJoin)
                .Add(Restrictions.Eq(CostBearer2SupportConcept.PropertyName_Status, CostBearer2SupportConceptStatus.Approved))

                .List<SupportConcept>().Distinct().ToList();
        }

        public Employee FindEmployeeWithPersonOid(long pPersonOid)
        {
            var person = DAOFactory.GenericDAO.LoadByID<Person>(pPersonOid);
            if (person != null)
            {
                return CreateCriteria<Employee>()
                    .Add(Restrictions.Eq(Employee.PropertyName_Person, person)).UniqueResult<Employee>();
            }
            return null;
        }

        public Customer FindCustomerWithPersonOid(long pPersonOid)
        {
            var person = DAOFactory.GenericDAO.LoadByID<Person>(pPersonOid);
            if (person != null)
            {
                return CreateCriteria<Customer>()
                    .Add(Restrictions.Eq(Customer.PropertyName_Person, person)).UniqueResult<Customer>();
            }
            return null;
        }

        public IList<Customer> FindCustomersWithPersonOids(IEnumerable<long> pPersonOid)
        {
            
            return CreateCriteriaIsActive<Customer>()
                .CreateAlias(Customer.PropertyName_Person, "p", JoinType.InnerJoin)
                .Add(Restrictions.In("p." + BeWoEntityBase.PropertyName_Oid, pPersonOid.ToArray()))
                .List<Customer>();
        }

        public IList<Person> GetActivePersonsWithType(PersonType type)
        {
            return CreateCriteriaIsActive<Person>()
                .Add(Restrictions.Eq(Person.PropertyName_Type, type))
                .List<Person>();
        }

        public IEnumerable<Customer> GetAllActiveCustomersWithSupportConceptData()
        {
            return CreateCriteriaIsActiveOrArchived<Customer>()
                .CreateAlias(Customer.PropertyName_SupportConcepts, "sc", JoinType.LeftOuterJoin)
                .CreateCriteria("sc." + SupportConcept.PropertyName_CostBearer2SupportConceptList, JoinType.LeftOuterJoin)
				.Add(Restrictions.Eq("sc." + SupportConcept.PropertyName_IsActive, ActivationTypeId.Active))
                .List<Customer>();
        }

        public IEnumerable<Customer> GetAllActiveCustomersWithAddress()
        {
            return CreateCriteriaIsActive<Customer>()
                .CreateCriteria(Customer.PropertyName_Person, JoinType.LeftOuterJoin)
                .CreateCriteria(Person.PropertyName_Address, JoinType.LeftOuterJoin)
                .List<Customer>();
        }

		public IEnumerable<Customer> GetAllCustomersWithRelatedEmployee()
		{
            return CreateCriteria<Customer>()
                .CreateAlias("Person", "cp", JoinType.InnerJoin)
                .CreateAlias("cp." + Person.PropertyName_Address, "a", JoinType.LeftOuterJoin)
                .CreateAlias("Employee2CustomerList", "e2c", JoinType.LeftOuterJoin)
                .CreateAlias("e2c." + Employee2Customer.PropertyName_Employee, "e", JoinType.LeftOuterJoin)
                .CreateCriteria("e2c." + Employee2Customer.PropertyName_ValueList, JoinType.LeftOuterJoin)
                .CreateCriteria("e." + Employee.PropertyName_Person, JoinType.LeftOuterJoin)
                .List<Customer>();
        }

        public IList<ServiceRecord> FindServiceRecordsDetailsForLastDays(long costbearer2SupportConcept, long? days)
        {
            var c = CreateCriteria<ServiceRecord>()
                .Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costbearer2SupportConcept));

            if (days.HasValue)
            {
                
                var minDate = DateTime.Now.Date.AddDays(-1 * days.Value);
                c.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, minDate));
            }

            return c.CreateAlias(ServiceRecord.PropertyName_ValueList, "vl", JoinType.LeftOuterJoin)
                .CreateAlias(ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
                .CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "sc", JoinType.InnerJoin)
                .CreateAlias(ServiceRecord.PropertyName_Employee, "e", JoinType.InnerJoin)
                .CreateCriteria("e." + Employee.PropertyName_Person, JoinType.InnerJoin)
                .List<ServiceRecord>();
        }

        public IList<ServiceRecord> FindServiceRecordsDetailsForLastDaysWithStartEndDate(long costbearer2SupportConcept, DateTime start, DateTime ende)
        {
            var c = CreateCriteria<ServiceRecord>()
                .Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costbearer2SupportConcept));


            var max = ende.AddDays(1);

            c.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, start.Date))
            .Add(Restrictions.Lt(ServiceRecord.PropertyName_End, max.Date));
            

            return c.CreateAlias(ServiceRecord.PropertyName_ValueList, "vl", JoinType.LeftOuterJoin)
                .CreateAlias(ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
                .CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "sc", JoinType.InnerJoin)
                .CreateAlias(ServiceRecord.PropertyName_Employee, "e", JoinType.InnerJoin)
                .CreateCriteria("e." + Employee.PropertyName_Person, JoinType.InnerJoin)
                .List<ServiceRecord>();
        }

        public IList<ServiceRecord> FindServiceRecordsDetailWithServiceInfo(long costbearer2SupportConcept)
        {
            var c = CreateCriteria<ServiceRecord>()
                .Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costbearer2SupportConcept));

            
            return c.CreateAlias(ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
                .CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "sc", JoinType.InnerJoin)
                .List<ServiceRecord>();
        }

        public Customer FindCustomerWithServiceRecordsWithDetail(long pCustomerOid)
        {
            return CreateCriteria<Customer>()
                .Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, pCustomerOid))
                .CreateAlias(Customer.PropertyName_ServiceRecordList, "sr", JoinType.InnerJoin)
                .CreateCriteria("sr." + ServiceRecord.PropertyName_ValueList, JoinType.LeftOuterJoin)
                .CreateAlias("sr." + ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
                .CreateCriteria("sd." + ServiceDescription.PropertyName_ServiceCategory, JoinType.InnerJoin)
                .CreateAlias("sr." + ServiceRecord.PropertyName_CostBearer2SupportConcept, "c2s", JoinType.InnerJoin)
                .CreateCriteria("c2s." + CostBearer2SupportConcept.PropertyName_SupportConcept, JoinType.InnerJoin)
                .CreateAlias("c2s." + CostBearer2SupportConcept.PropertyName_CostBearer, "cb", JoinType.InnerJoin)
                .CreateAlias("cb." + CostBearer.PropertyName_Organisation, "org", JoinType.InnerJoin)
                .UniqueResult<Customer>();
        }

        public ServiceRecordGroup FindServiceRecordGroup(long pGroupOid)
        {
            return CreateCriteria<ServiceRecordGroup>()
                .Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, pGroupOid))
                .CreateCriteria(ServiceRecordGroup.PropertyName_ServiceRecordList, JoinType.InnerJoin)
                .UniqueResult<ServiceRecordGroup>();
        }

        public IEnumerable<SupportConcept> GetAllActiveAndArchivedSupportConceptsCompact()
        {
            return CreateCriteria<SupportConcept>()
                .Add(Restrictions.Or(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active), Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Archived)))
                .CreateAlias(SupportConcept.PropertyName_CostBearer2SupportConceptList, "cb2sc", JoinType.LeftOuterJoin)
                .CreateAlias(SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
                .CreateAlias("c." + Customer.PropertyName_Person, "p", JoinType.InnerJoin)
                .CreateAlias("p." + Person.PropertyName_Address, "a", JoinType.LeftOuterJoin)
                .CreateAlias("c." + Customer.PropertyName_Employee2CustomerList, "e2c", JoinType.LeftOuterJoin)
                .List<SupportConcept>();
        }

		public IEnumerable<SupportConcept> GetAllSupportConceptsCompact()
		{
			return CreateCriteria<SupportConcept>()
				.CreateAlias(SupportConcept.PropertyName_CostBearer2SupportConceptList, "cb2sc", JoinType.LeftOuterJoin)
				.CreateAlias(SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
				.CreateAlias("c." + Customer.PropertyName_Person, "p", JoinType.InnerJoin)
				.CreateAlias("p." + Person.PropertyName_Address, "a", JoinType.LeftOuterJoin)
				.CreateAlias("c." + Customer.PropertyName_Employee2CustomerList, "e2c", JoinType.LeftOuterJoin)
				.List<SupportConcept>();
		}

		public IList<ListedSupportConcept> GetAllActiveAndArchivedListedSupportConceptsCompact()
		{
			return Session.CreateCriteria<ListedSupportConcept>()
				.List<ListedSupportConcept>();
		}

		public IList<ListedSupportConcept> GetAllActiveAndArchivedListedSupportConceptsCompact(List<long> oids)
		{
			return Session.CreateCriteria<ListedSupportConcept>()
				.Add(Restrictions.In("SupportConceptOid", oids))
				.List<ListedSupportConcept>();
		}

        public IList<Customer> GetAllCustomerWithServiceRecordsInSpan(DateTimeSpan pSpan)
        {
            return CreateCriteria<Customer>()
                .CreateCriteria(Customer.PropertyName_ServiceRecordList, JoinType.InnerJoin)
                .Add(Restrictions.Between(ServiceRecord.PropertyName_Start, pSpan.StartDateTime, pSpan.EndDateTime))
                .List<Customer>();
        }

        public IEnumerable<AccountingTransaction> GetAllAccountingTransactionsWithDetails()
        {
            return CreateCriteria<AccountingTransaction>()
                .AddOrder(Order.Desc(AccountingTransaction.PropertyName_BookingDate))
                .CreateAlias(AccountingTransaction.PropertyName_CostBearer2SupportConcept, "cb2sc", JoinType.LeftOuterJoin)
                .CreateCriteria("cb2sc." + CostBearer2SupportConcept.PropertyName_CostBearer, JoinType.LeftOuterJoin)
                .CreateCriteria(CostBearer.PropertyName_Organisation, JoinType.LeftOuterJoin)
                .CreateCriteria("cb2sc." + CostBearer2SupportConcept.PropertyName_SupportConcept, JoinType.LeftOuterJoin)
                .CreateCriteria(SupportConcept.PropertyName_Customer, JoinType.LeftOuterJoin)
                .CreateCriteria(Customer.PropertyName_Person, JoinType.LeftOuterJoin)
                .List<AccountingTransaction>();
        }

        public IEnumerable<AccountingTransaction> FindAccountingTransactionsWithImportNotice(String notice)
        {
            return CreateCriteria<AccountingTransaction>()
                .Add(Restrictions.Eq(AccountingTransaction.PropertyName_ImportNotice, notice)).List<AccountingTransaction>();
        }

        public IEnumerable<SupportConcept> GetAllActiveAndArchivedSupportConcepts()
        {
            return CreateCriteria<SupportConcept>()
                .Add(Restrictions.Or(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active), Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Archived)))
                .CreateAlias(SupportConcept.PropertyName_CostBearer2SupportConceptList, "cb2sc", JoinType.InnerJoin)
                .CreateAlias("cb2sc." + CostBearer2SupportConcept.PropertyName_CostBearer, "cb", JoinType.InnerJoin)
                .CreateAlias("cb." + CostBearer.PropertyName_Organisation, "org", JoinType.InnerJoin)
                .CreateAlias(SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
                .CreateAlias("c." + Customer.PropertyName_Person, "p", JoinType.InnerJoin)
                .List<SupportConcept>();
        }

        public IEnumerable<Customer> GetAllActiveAndArchivedCustomersWithRelatedEmployee()
        {
            return CreateCriteria<Customer>()
                .Add(Restrictions.Or(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active), Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Archived)))
                .CreateAlias(Customer.PropertyName_Person, "cp", JoinType.InnerJoin)
                .CreateAlias("cp." + Person.PropertyName_Address, "a", JoinType.LeftOuterJoin)
                .CreateAlias(Customer.PropertyName_Employee2CustomerList, "e2c", JoinType.LeftOuterJoin)
                .CreateAlias("e2c." + Employee2Customer.PropertyName_Employee, "e", JoinType.LeftOuterJoin)
                .CreateCriteria("e2c." + Employee2Customer.PropertyName_ValueList, JoinType.LeftOuterJoin)
                .CreateCriteria("e." + Employee.PropertyName_Person, JoinType.LeftOuterJoin)
                .List<Customer>();
        }

        public IEnumerable<SettlementInvoice> GetSettlementInvoiceBySupportConceptOid(long supportConceptOid)
        {
            return CreateCriteriaIsActive<SettlementInvoice>()
                .CreateAlias(SettlementInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
                .Add(Restrictions.Eq("ib." + InvoiceBase.PropertyName_SupportConceptOid, supportConceptOid))
                .List<SettlementInvoice>();
        }

		public IList<SettlementInvoice> GetSettlementInvoiceByCostBearer2SupportConceptOid(long costBearer2SupportConceptOid)
		{
			return CreateCriteriaIsActive<SettlementInvoice>()
				.CreateAlias(SettlementInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
				.Add(Restrictions.Eq("ib." + InvoiceBase.PropertyName_CostBearer2SupportConceptOid, costBearer2SupportConceptOid))
				.List<SettlementInvoice>();
		}

        public IEnumerable<SettlementInvoice> GetSettlementInvoicesForCostBearerAndPeriod(long costBearerOid, DateTime periodStart, DateTime periodEnd)
        {
            return CreateCriteriaIsActive<SettlementInvoice>()
               .CreateAlias(SettlementInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
               .CreateAlias("ib." + InvoiceBase.PropertyName_CostBearer2SupportConcept, "cb2sc", JoinType.InnerJoin)
               .CreateAlias("cb2sc." + CostBearer2SupportConcept.PropertyName_CostBearer, "cb", JoinType.InnerJoin)
               .Add(Restrictions.Eq("cb." + BeWoEntityBase.PropertyName_Oid, costBearerOid))
               .Add(Restrictions.Or(
                    Restrictions.Between("ib." + InvoiceBase.PropertyName_AccountingPeriodStart, periodStart, periodEnd),
                    Restrictions.Between("ib." + InvoiceBase.PropertyName_AccountingPeriodEnd, periodStart, periodEnd)))
               .List<SettlementInvoice>();
        }

        public IList<InvoiceBase> GetInvoiceBaseByTypeAndSupportConceptOid(InvoiceType type, long supportConceptOid)
        {
            return SearchInvoiceBase(type, InvoiceBase.PropertyName_SupportConceptOid, supportConceptOid);
        }

        public IEnumerable<InvoiceBase> GetInvoiceBaseByOrganisationOid(InvoiceType type, long organisationOid)
        {
            return SearchInvoiceBase(type, InvoiceBase.PropertyName_RecipientOrganisationOid, organisationOid);
        }

        public IEnumerable<InvoiceBase> GetInvoiceBaseByCustomerOid(InvoiceType type, long customerOid)
        {
            return SearchInvoiceBase(type, InvoiceBase.PropertyName_RecipientCustomerOid, customerOid);
        }

        public IEnumerable<InvoiceBase> GetInvoiceBaseByPersonOid(InvoiceType type, long personOid)
        {
            return SearchInvoiceBase(type, InvoiceBase.PropertyName_RecipientPersonOid, personOid);
        }

        private IList<InvoiceBase> SearchInvoiceBase(InvoiceType type, string propertyname, long fkOid)
        {
            return CreateCriteriaIsActive<InvoiceBase>()
                .Add(Restrictions.Eq(InvoiceBase.PropertyName_Type, type))
                .Add(Restrictions.Eq(propertyname, fkOid))
                .List<InvoiceBase>();
        }

        public SettlementInvoice GetSettlementInvoiceByInvoiceBaseOid(long invoiceBaseOid)
        {
            return CreateCriteriaIsActive<SettlementInvoice>()
                .CreateAlias(SettlementInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
                .Add(Restrictions.Eq("ib." + BeWoEntityBase.PropertyName_Oid, invoiceBaseOid))
                .UniqueResult<SettlementInvoice>();
        }

        public ServiceInvoice GetServiceInvoiceByInvoiceBaseOid(long invoiceBaseOid)
        {
            var res = CreateCriteriaIsActive<ServiceInvoice>()
                .CreateAlias(ServiceInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
                .Add(Restrictions.Eq("ib." + BeWoEntityBase.PropertyName_Oid, invoiceBaseOid))
                .UniqueResult<ServiceInvoice>();

            return res;
        }

        public IEnumerable<AssessmentSheetEntry> GetAssessmentSheetEntriesForCustomer(long customerOid, DateTime startDt, DateTime endDt)
        {
            
            
            return CreateCriteriaIsActive<AssessmentSheetEntry>()
                .CreateAlias(AssessmentSheetEntry.PropertyName_Customer, "c", JoinType.InnerJoin)
                .Add(Restrictions.Eq("c." + BeWoEntityBase.PropertyName_Oid, customerOid))
                .Add(Restrictions.Ge(AssessmentSheetEntry.PropertyName_Day, startDt))
                .Add(Restrictions.Lt(AssessmentSheetEntry.PropertyName_Day, endDt))
                .List<AssessmentSheetEntry>();
        }

        public IList<VarFieldDef> GetVarFieldDefs(TableID tid)
        {
            return CreateCriteriaIsActive<VarFieldDef>()
                .Add(Restrictions.Eq(VarFieldDef.PropertyName_ObjectTid, tid))
                .List<VarFieldDef>();
        }

        public IEnumerable<Task> FindTasksForEmployee(long employeeoid)
        {
            return CreateCriteriaIsActive<Task>()
                .CreateAlias(Task.PropertyName_SupportConcept, "sc", JoinType.InnerJoin)
                .CreateAlias("sc." + SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
                .CreateCriteria(Task.PropertyName_EmployeeList, JoinType.InnerJoin)
                .Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, employeeoid))
                .Add(Restrictions.Eq("sc." + BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
                .Add(Restrictions.Eq("c." + BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
                .List<Task>();
        }

        public List<ServiceInvoice> GetServiceInvoices(long costBearerOid, long? supportConceptOid, DateTimeSpan period)
        {
            var criteria = CreateCriteriaIsActive<ServiceInvoice>()
              .CreateAlias(ServiceInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
              .Add(Restrictions.Eq("ib." + InvoiceBase.PropertyName_RecipientCostBearerOid, costBearerOid))
			  .Add(Restrictions.Eq("ib." + BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active));

            if (supportConceptOid.HasValue)
                criteria = criteria
                    .Add(Restrictions.Eq("ib." + InvoiceBase.PropertyName_SupportConceptOid, supportConceptOid.Value));

            if (period != null)
                criteria = criteria
                    .Add(Restrictions.Or(
                                Restrictions.Or(
                                        Restrictions.Between("ib." + InvoiceBase.PropertyName_AccountingPeriodStart, period.StartDateTime, period.EndDateTime),
                                        Restrictions.Between("ib." + InvoiceBase.PropertyName_AccountingPeriodEnd, period.StartDateTime, period.EndDateTime)),
                                Restrictions.And(
                                        Restrictions.Le("ib." + InvoiceBase.PropertyName_AccountingPeriodStart, period.StartDateTime),
                                        Restrictions.Ge("ib." + InvoiceBase.PropertyName_AccountingPeriodEnd, period.EndDateTime))));

            return criteria.List<ServiceInvoice>().ToList();
        }

        public List<ServiceInvoice> GetServiceInvoices(long? costbearer2SupportConceptOid, DateTimeSpan period)
        {
            var criteria = CreateCriteriaIsActive<ServiceInvoice>()
                .CreateAlias(ServiceInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
                .Add(Restrictions.Eq("ib." + BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active));

            if (costbearer2SupportConceptOid.HasValue)
                criteria = criteria
                    .Add(Restrictions.Eq("ib." + InvoiceBase.PropertyName_CostBearer2SupportConceptOid, costbearer2SupportConceptOid.Value));



            if (period != null)
                criteria = criteria
                    .Add(Restrictions.Or(
                        Restrictions.Or(
                            Restrictions.Between("ib." + InvoiceBase.PropertyName_AccountingPeriodStart, period.StartDateTime, period.EndDateTime),
                            Restrictions.Between("ib." + InvoiceBase.PropertyName_AccountingPeriodEnd, period.StartDateTime, period.EndDateTime)),
                        Restrictions.And(
                            Restrictions.Le("ib." + InvoiceBase.PropertyName_AccountingPeriodStart, period.StartDateTime),
                            Restrictions.Ge("ib." + InvoiceBase.PropertyName_AccountingPeriodEnd, period.EndDateTime))));

            return criteria.List<ServiceInvoice>().ToList();
        }

        public IEnumerable<AssessmentSheetCategory> GetAssessmentSheetCategoryListForCustomer(long customerOid)
        {

            return CreateCriteriaIsActive<AssessmentSheetCategory>()
                .CreateAlias(AssessmentSheetCategory.PropertyName_Customers, "c", JoinType.InnerJoin)
                .Add(Restrictions.Eq("c." + BeWoEntityBase.PropertyName_Oid, customerOid))
                .List<AssessmentSheetCategory>();

        }

        public IEnumerable<AbsenceTime> FindAbsenceTimes(bool fetchEmployees, bool fetchCustomers)
        {
            var criteria = CreateCriteriaIsActive<AbsenceTime>();
              
            if (!fetchEmployees)
                criteria = criteria
                    .Add(Restrictions.IsNull(AbsenceTime.PropertyName_EmployeeOid));
            else if (!fetchCustomers)
                criteria = criteria
                    .Add(Restrictions.IsNull(AbsenceTime.PropertyName_CustomerOid));

            return criteria.List<AbsenceTime>().ToList();

            
        }

        public IEnumerable<AbsenceTime> FindAbsenceTimes(DateTime startDate, DateTime endDate)
        {
            var criteria = CreateCriteriaIsActive<AbsenceTime>()
                .Add(
                    Restrictions.Or(
                        Restrictions.And(
                            Restrictions.Ge(AbsenceTime.PropertyName_End, startDate),
                            Restrictions.Lt(AbsenceTime.PropertyName_Start, endDate.Date.AddDays(1))
                        ),
                        Restrictions.And(
                            Restrictions.Lt(AbsenceTime.PropertyName_Start, endDate.Date.AddDays(1)),
                            Restrictions.IsNull(AbsenceTime.PropertyName_End)
                        )
                    )
                );

            return criteria.List<AbsenceTime>().ToList();


        }

        public IEnumerable<Vertretung> FindVertretungen(DateTime startDate, DateTime endDate)
        {
            var criteria = CreateCriteriaIsActive<Vertretung>()
                .Add(
                    Restrictions.Or(
                        Restrictions.And(
                            Restrictions.Ge(Vertretung.PropertyName_VertretungsZeitraumBis, startDate),
                            Restrictions.Le(Vertretung.PropertyName_VertretungsZeitraumVon, endDate)
                        ),
                        Restrictions.And(
                            Restrictions.Le(Vertretung.PropertyName_VertretungsZeitraumVon, endDate),
                            Restrictions.IsNull(Vertretung.PropertyName_VertretungsZeitraumBis)
                        )
                    )
                );

            return criteria.List<Vertretung>().ToList();


        }

        public IEnumerable<Appointment> FindAppointments(long? customerOid, long? employeeOid)
        {
            var criteria = CreateCriteriaIsActive<Appointment>();

            if(employeeOid.HasValue)
            {
                criteria = criteria.Add(Restrictions.Eq(AbsenceTime.PropertyName_EmployeeOid, employeeOid));
            }

            if(customerOid.HasValue)
            {
                criteria = criteria.Add(Restrictions.Eq(AbsenceTime.PropertyName_CustomerOid, customerOid));
            }

            return criteria.List<Appointment>().ToList();
        }

        public ServiceCategory FindDefaultIndividualServiceCategory()
        {
            return CreateCriteriaIsActive<ServiceCategory>()
                .Add(Restrictions.Eq(ServiceCategory.PropertyName_ScopeType, ScopeTypeId.Individual))
                .List<ServiceCategory>().FirstOrDefault();
        }

		public ServiceCategory FindServiceCategoryByName(String name)
		{
			return CreateCriteriaIsActive<ServiceCategory>()
				.Add(Restrictions.Eq(ServiceCategory.PropertyName_Name, name))
				.List<ServiceCategory>().FirstOrDefault();
		}

        public IEnumerable<FileAttachmentInfo> FindFileAttachmentInfoByType(FileAttachmentType type)
        {
            var criteria = CreateCriteria<FileAttachmentInfo>()
                .Add(Restrictions.Eq("Type", type));

            return criteria.List<FileAttachmentInfo>().ToList();
        }

		public IEnumerable<AssessmentSheetEntry> GetAdditionalAssessmentSheetEntries(DateTime dateTime)
		{
			return CreateCriteria<AssessmentSheetEntry>()
				.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_SystemEntryID, SystemEntryID.AdditionalServiceAssessmentSheet))
				.Add(Restrictions.Eq(AssessmentSheetEntry.PropertyName_Day, dateTime.Date))
				.List<AssessmentSheetEntry>();
		}

	    public IEnumerable<ResourceAppointment> GetResourceAppointmentExceptionsWithIndexAndId(string info)
	    {
		    return CreateCriteria<ResourceAppointment>()
				.Add(Restrictions.Like(ResourceAppointment.PropertyName_RecurrenceInfo, info))
				.List<ResourceAppointment>();

	    }

		public IEnumerable<AdditionalServiceBooking> GetAdditionalServiceBookings(long? regionOid, DateTime start, DateTime end)
		{
			var criteria = CreateCriteriaIsActive<AdditionalServiceBooking>()
				.Add(Restrictions.Between("Datum", start, end));

			if (regionOid.HasValue)
				criteria = criteria.CreateAlias(AdditionalServiceBooking.PropertyName_AdditionalServiceRegion, "asr", JoinType.InnerJoin)
					.Add(Restrictions.Eq("asr." + BeWoEntityBase.PropertyName_Oid, regionOid));

			return criteria.List<AdditionalServiceBooking>();
		}

		public IEnumerable<AdditionalServiceBooking> GetAdditionalServiceBookingsForCustomer(long customerOid, DateTime start, DateTime end)
		{
			return CreateCriteriaIsActive<AdditionalServiceBooking>()
				.CreateAlias(AdditionalServiceBooking.PropertyName_Customer2AddServiceBookings, "c2s", JoinType.InnerJoin)
				.Add(Restrictions.Between("Datum", start, end))
				.Add(Restrictions.Eq("c2s.CustomerOid", customerOid))
				.List<AdditionalServiceBooking>();
		}
        
		public AssessmentSheetCategory GetAddServiceAssessmentSheetCategoryWithName(string name)
		{
			return CreateCriteriaIsActive<AssessmentSheetCategory>()
				.Add(Restrictions.Eq(AssessmentSheetCategory.PropertyName_Description, name))
				.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_SystemEntryID, SystemEntryID.AdditionalServiceAssessmentSheet))
				.List<AssessmentSheetCategory>().FirstOrDefault();
		}

		public IList<ServiceRecord> GetBillableServiceRecords()
		{
			var c = CreateCriteria<ServiceRecord>()
				.CreateAlias(ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
				.CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "sc", JoinType.InnerJoin)
				.Add(Restrictions.Eq("sc." + ServiceCategory.PropertyName_IsBillable, true));

			return c.List<ServiceRecord>();
		}

	    public IList<ServiceRecord> GetBillableServiceRecords(DateTime start, DateTime end)
	    {
		    var c = CreateCriteria<ServiceRecord>()
			    .CreateAlias(ServiceRecord.PropertyName_ServiceDescription, "sd", JoinType.InnerJoin)
			    .CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "sc", JoinType.InnerJoin)
			    .Add(Restrictions.Eq("sc." + ServiceCategory.PropertyName_IsBillable, true))
			    .Add(Restrictions.Between(ServiceRecord.PropertyName_Start, start, end));


			return c.List<ServiceRecord>();
	    }

		public IEnumerable<ServiceDescription> FindServiceDescriptionForCategory(long categoryOid)
		{
			var c = CreateCriteriaIsActive<ServiceDescription>()
				.CreateAlias(ServiceDescription.PropertyName_ServiceCategory, "sc", JoinType.InnerJoin)
				.Add(Restrictions.Eq("sc."+ BeWoEntityBase.PropertyName_Oid, categoryOid));

			return c.List<ServiceDescription>();
		}

		public IEnumerable<ServiceAccounting> FindServiceAccountingsForServiceDescriptions(IList<long> descriptionOids)
		{
			var c = CreateCriteriaIsActive<ServiceAccounting>()
				.CreateAlias("ServiceDescription", "sd", JoinType.InnerJoin)
				.Add(Restrictions.In("sd." + BeWoEntityBase.PropertyName_Oid, descriptionOids.ToArray()));

			return c.List<ServiceAccounting>();
		}

        public IList<Medikamentenverordnungsliste> GetAllMedikamentenverordnungslistenButNewestByCustomerOid(long customerOid, long newestOid, bool isBedarfsListe)
		{
			var c = CreateCriteria<Medikamentenverordnungsliste>()
				.CreateAlias(Medikamentenverordnungsliste.PropertyName_Customer, "c")
				.Add(Restrictions.Eq("c." + BeWoEntityBase.PropertyName_Oid, customerOid))
				.Add(Restrictions.Not(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, newestOid)))
				.Add(Restrictions.Eq(Medikamentenverordnungsliste.PropertyName_MedListType, isBedarfsListe));

			return c.List<Medikamentenverordnungsliste>();
		}

		public IList<SchedulerAppointment> GetAllOpenAppointmentsForEmployee(long employeeOid)
		{
			var c = CreateCriteria<SchedulerAppointment>()
				.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
				.Add(Restrictions.Not(Restrictions.Eq(SchedulerAppointment.PropertyName_Originator + ".Oid", employeeOid)))
			    .Add(Restrictions.Or(Restrictions.Ge(SchedulerAppointment.PropertyName_EndDate, DateTime.Now.AddDays(-7)), Restrictions.IsNull(SchedulerAppointment.PropertyName_EndDate)))
                .CreateCriteria(SchedulerAppointment.PropertyName_EmployeeList)
				.Add(Restrictions.And(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", employeeOid),
					Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_ParticipationAnswer, ParticipationAnswer.Offen)));

			return c.List<SchedulerAppointment>();
		}

	    public IEnumerable<SchedulerAppointment> GetAllParticipationNotificationsForEmployee(long employeeOid)
	    {
			var c = CreateCriteria<SchedulerAppointment>()
				.Add(Restrictions.And(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active), Restrictions.Eq(SchedulerAppointment.PropertyName_Originator + ".Oid", employeeOid)))
				.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
			    .Add(Restrictions.Or(Restrictions.Ge(SchedulerAppointment.PropertyName_EndDate, DateTime.Now.AddDays(-7)), Restrictions.IsNull(SchedulerAppointment.PropertyName_EndDate)))
                .CreateCriteria(SchedulerAppointment.PropertyName_EmployeeList)
				.Add(Restrictions.And(Restrictions.And(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_IsPChanged, true), Restrictions.Not(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", employeeOid))), Restrictions.Not(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_ParticipationAnswer, ParticipationAnswer.Offen))))
                .Add(Restrictions.Not(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_ParticipationAnswer, ParticipationAnswer.Verstrichen)))
				.Add(Restrictions.IsNull(Employee2SchedulerAppointment.PropertyName_IsPC_CheckedTs));

		    var result = c.List<SchedulerAppointment>();

			return result;
	    }

		public IEnumerable<Employee2SchedulerAppointment> GetRemovedEmp2AppObjectsBySchAppOid(long schAppOid)
		{
			var c = CreateCriteria<Employee2SchedulerAppointment>()
				.Add(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment, schAppOid));

			return c.List<Employee2SchedulerAppointment>();
		}

	    public IEnumerable<SchedulerAppointment> GetAllActiveAndNotDeclinedForEmployeeAppointments(long employeeOid)
	    {
		    var detachedCriteria = DetachedCriteria.For<Employee2SchedulerAppointment>()
				.Add(Restrictions.And(Restrictions.Not(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", employeeOid)),
									  Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_ParticipationAnswer, ParticipationAnswer.Absage)));
		    detachedCriteria.SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment));

		    var crit = CreateCriteria<SchedulerAppointment>()
			    .Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
				.Add(Restrictions.Or(Restrictions.Eq(SchedulerAppointment.PropertyName_Originator + ".Oid", employeeOid), Subqueries.PropertyIn(BeWoEntityBase.PropertyName_Oid, detachedCriteria)));

			return crit.List<SchedulerAppointment>();
	    }

	    public bool ResetPasswordCodeExists(string code, long userOid)
	    {
		    var c = CreateCriteria<ApplicationUser>()
			    .Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, userOid))
			    .CreateCriteria(ApplicationUser.PropertyName_ResetPasswordInfos)
			    .Add(Restrictions.Eq(ResetPasswordInfo.PropertyName_Code, code));

		    return c.List<ApplicationUser>().Count > 0;
	    }

        public bool OverlappingAppointmentsExist(DateTime start, DateTime end, IEnumerable<long> employees, IEnumerable<long> customers, IEnumerable<long> resources, long originator, long? appointmentOid, string recurrenceId = "", int occurrenceIndex = 0)
        {
            if(employees == null)
            {
                employees = new List<long>();
            }

            if(customers == null)
            {
                customers = new List<long>();
            }

            if(resources == null)
            {
                resources = new List<long>();
            }

            var isRecurrenceException = appointmentOid == null;
            var isBeingUpdatedToNormalAppointment = false;
            Guid? recurrenceIdToIgnore = null;

            if(appointmentOid != null)
            {
                // Das Pattern wird geladen, bzw. mit der Ausnahme mit Index 0 verglichen
                // Wird die Serie in einen Einzeltermin geändert und es existiert eine Ausnahme mit Index 0, sollte die Ausnahme behalten werden und nicht der Root-Termin
                var original = DAOFactory.GenericDAO.LoadByID<SchedulerAppointment>(appointmentOid.Value);
                var ri = original?.GetRecurrenceId();
                if(ri != null && IsNullOrWhiteSpace(recurrenceId))
                {
                    isBeingUpdatedToNormalAppointment = true;
                    recurrenceIdToIgnore = ri;
                }
            }

            Guid? recurrenceGuid = null;

            if(Guid.TryParse(recurrenceId, out var parsedGuid))
            {
                recurrenceGuid = parsedGuid;
            }

            var betweenDateTimesCriterion = CreateBetweenDateTimesCriterion(start, end, nameof(SchedulerAppointment.StartDate), nameof(SchedulerAppointment.EndDate));

            var criteria = CreateCriteria<SchedulerAppointment>()
                .Add(Restrictions.Eq(nameof(BeWoEntityBase.IsActive), ActivationTypeId.Active))
                .Add(Restrictions.Eq(nameof(SchedulerAppointment.IsTask), false))
                .Add(betweenDateTimesCriterion);
            
            if (isRecurrenceException == false)
			{
			    criteria.Add(Restrictions.Not(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, appointmentOid)));
			}

		    var appTmp = criteria.List<SchedulerAppointment>();

            var appointments = appTmp.Where(a =>
			{
				if (a.RecurrenceInfo == null)
				{
				    return true;
				}

                var recId2 = a.GetRecurrenceIdAndIndex(out var index);

                return !(Guid.TryParse(recurrenceId, out var guid) && guid.Equals(recId2) && occurrenceIndex == index);
			});

			var schedulerAppointments = appointments as IList<SchedulerAppointment> ?? appointments.ToList();

            // Serientermine anhand der RecurrenceInfo erzeugen und den schedulerAppointments hinzufügen ------------------------------------------------------------
            var deletedOccurences = schedulerAppointments.Where(app => app.Type == 4).Select(app => Utils.GetOccurrenceId(app.RecurrenceInfo)).ToList();
            var changedOccurences = schedulerAppointments.Where(app => app.Type == 3).Select(app => Utils.GetOccurrenceId(app.RecurrenceInfo)).ToList();

            var recurringAppointmentsCriteria = CreateRecurrenceCriteria(start, end).Add(Restrictions.Eq(nameof(SchedulerAppointment.Type), 1));

            var recurringAppointments = recurringAppointmentsCriteria.List<SchedulerAppointment>().ToList();

            if(isBeingUpdatedToNormalAppointment)
            {
                recurringAppointments = recurringAppointments.Where(root =>
                {
                    var recId = root.GetRecurrenceId();

                    if(recId != null && recurrenceIdToIgnore != null)
                    {
                        if(recId.Equals(recurrenceIdToIgnore))
                        {
                            return false;
                        }
                    }

                    return true;
                }).ToList();

                schedulerAppointments = schedulerAppointments.Where(root =>
                {
                    var recId = root.GetRecurrenceId();

                    if(recId != null && recurrenceIdToIgnore != null)
                    {
                        if(recId.Equals(recurrenceIdToIgnore))
                        {
                            return false;
                        }
                    }

                    return true;
                }).ToList();
            }

            foreach(var appointment in recurringAppointments)
            {
                var recurrenceInfo = new RecurrenceInfo();
                recurrenceInfo.FromXml(appointment.RecurrenceInfo);

                var occurenceCalculator = OccurrenceCalculator.CreateInstance(recurrenceInfo);

                // Das Muster für die Terminserie wird berechnet
                var pattern = StaticAppointmentFactory.CreateAppointment(AppointmentType.Pattern);

                if(pattern == null)
                {
                    continue;
                }

                pattern.RecurrenceInfo.FromXml(appointment.RecurrenceInfo);
                pattern.Start = pattern.RecurrenceInfo.Start;
                pattern.End = appointment.EndDate.Value;//pattern.RecurrenceInfo.End;

                var patternId = pattern.RecurrenceInfo.Id.ToString();

                // In diesem Fall die Start- und Enddaten des zu überprüfenden, neuen Termins
                var interval = new TimeInterval(start, end);

                // Die Serientermine werden berechnet (ausnahmslos, d.h. es werden auch bearbeitete und gelöschte Termine erstellt, die herausgefiltert werden müssen).
                var occurrences = occurenceCalculator.CalcOccurrences(interval, pattern);

                foreach(var occurrence in occurrences.GetAppointments(interval))
                {
                    if(appointment.EndDate == null || appointment.StartDate == null)
                    {
                        continue;
                    }

                    // Terminindex in der Serie
                    var index = occurrence.RecurrenceIndex;

                    // Das Ende ist offen, da die Terminserie kein Ende hat. Deshalb wird das Ende berechnet.
                    var duration = (appointment.EndDate.Value - appointment.StartDate.Value).TotalMinutes;

                    var guidParsingSuccessful = Guid.TryParse(occurrence.RecurrenceInfo?.Id?.ToString(), out var occurrenceGuid);

                    // Der generierte Serientermin muss sich zeitlich mit dem neuen Termin überschneiden
                    // und darf nicht in der Liste der geänderten Serientermine oder der Liste der gelöschten Serientermine sein.

                    var isInIntervalTest = start.IsInInterval(end, occurrence.Start, occurrence.Start.AddMinutes(duration));

                    if(!isInIntervalTest || 
                       changedOccurences != null && changedOccurences.Any(changedOccurence => changedOccurence.PatternId.Equals(patternId) && changedOccurence.Index == index) ||
                       deletedOccurences != null && deletedOccurences.Any(deletedOccurence => deletedOccurence.PatternId.Equals(patternId) && deletedOccurence.Index == index) ||
                       index == occurrenceIndex && guidParsingSuccessful && recurrenceGuid!= null && recurrenceGuid.Equals(occurrenceGuid))
                    {
                        continue;
                    }

                    // Prüfen, ob es eine Ausnahme an dem Tag gibt, die zu dem Pattern gehört, um das Pattern auszuschließen
                    var relatedAppointments = FindAppointmentsByRecurrenceId(new List<string> {recurrenceInfo.Id.ToString()}, true);
                    var relatedAppointmentsInInterval = relatedAppointments.Where(a =>
                    {
                        if(a.StartDate == null || a.EndDate == null)
                        {
                            return false;
                        }

                        var myStart = a.StartDate.Value.Date;
                        var myEnd = a.EndDate.Value.Date;

                        var isInInterval = start.Date.InBetween(myStart.GetShortDateTime(), myEnd, true);

                        return isInInterval && a.Type != 4;
                    }).ToList();

                    var hasToStop = false;

                    // Prüfen, ob es sich bei dem Termin für den Überschneidungen gesucht werden, um zu unterscheiden, ob ein Serientermin in einen normalen geändert wird.
                    var root = FindRootAppointmentByRecurrenceId(recurrenceInfo.Id.ToString());
                    if(root.Oid != null && appointmentOid != null && root.Oid == appointmentOid && root.RecurrenceInfo != null && IsNullOrWhiteSpace(recurrenceId))
                    {
                        hasToStop = true;
                    }

                    // Indices und Ids der RecurrenceInfo vergleichen. Stimmen sie überein, dann wird das generiert Serienelement ignoriert.
                    if(occurrence.RecurrenceInfo?.Id != null && !hasToStop)
                    {
                        if(Guid.TryParse(occurrence.RecurrenceInfo.Id.ToString(), out var guid))
                        {
                            foreach(var relatedAppointment in relatedAppointmentsInInterval)
                            {
                                var relatedAppointmentRecurrenceId = relatedAppointment.GetRecurrenceIdAndIndex(out var relatedAppointmentRecurrenceIndex);

                                if(relatedAppointmentRecurrenceId != null)
                                {
                                    if(guid.Equals(relatedAppointmentRecurrenceId) && relatedAppointmentRecurrenceIndex.Equals(occurrence.RecurrenceIndex))
                                    {
                                        hasToStop = true;
                                        break;
                                    }
                                }
                            }
                        }
                    }

                    if(hasToStop)
                    {
                        continue;
                    }

                    var recurringAppointment = new SchedulerAppointment
                    {
                        AllDay                   = occurrence.AllDay,
                        CustomerList             = appointment.CustomerList,
                        Notice                   = appointment.Notice,
                        EmployeeList             = appointment.EmployeeList,
                        EndDate                  = occurrence.Start.AddMinutes(duration),
                        FormerBookingSequenceOid = appointment.FormerBookingSequenceOid,
                        IsPrivate                = appointment.IsPrivate,
                        Location                 = appointment.Location,
                        Originator               = appointment.Originator,
                        RecurrenceInfo           = occurrence.RecurrenceInfo.ToXml(),
                        ReminderInfo             = appointment.ReminderInfo,
                        ResourceList             = appointment.ResourceList,
                        StartDate                = occurrence.Start,
                        Subject                  = appointment.Subject ?? "",
                        Type                     = appointment.Type
                    };

                    schedulerAppointments.AddIfNotIn(recurringAppointment);
                }
            }
            // --------------------------------------------------------------------------------------------------------------------------------------

            // Falls es sich um eine Ausnahme einer Serie handelt, muss die Serie ignoriert werden
            var shouldIgnoreAppointment = false;
            if(isRecurrenceException && recurrenceId != null)
            {
                if(recurrenceGuid.HasValue)
                {
                    shouldIgnoreAppointment = true;
                }
            }

            var oidList = new List<long>();

            schedulerAppointments = schedulerAppointments.Where(appointment => appointment.Type != 4).ToList();

            foreach (var appointment in schedulerAppointments)
            {
                if(shouldIgnoreAppointment)
                {
                    if(!ShouldDoAppointmentOverlappingCheck(appointment, recurrenceGuid.Value))
                    {
                        continue;
                    }
                }

				oidList.AddRange(appointment.EmployeeList.Select(rel => rel.ParticipationAnswer != ParticipationAnswer.Absage && rel.Employee.Oid != null ? rel.Employee.Oid.Value : 0));
			}

			var hasOverlappingEmployeeAppointments = oidList.Intersect(employees).Any();
			var hasOverlappingCustomerAppointments = schedulerAppointments.Any(app =>
            {
                return ShouldDoAppointmentOverlappingCheck(app, recurrenceGuid) && app.CustomerList.Select(c => c.Oid ?? 0).Intersect(customers).Any();
            });

			var hasOverlappingResourceAppointments = schedulerAppointments.Any(app =>
            {
                return ShouldDoAppointmentOverlappingCheck(app, recurrenceGuid) && app.ResourceList.Select(r => r.Oid ?? 0).Intersect(resources).Any();
            });

			var hasOverlappingOriginatorAppointments = schedulerAppointments.Any(appointment =>
            {
                if(!ShouldDoAppointmentOverlappingCheck(appointment, recurrenceGuid))
                {
                    return false;
                }

                return appointment.Originator.Oid.HasValue &&
                       appointment.Originator.Oid.Value == originator &&
                       (appointment.EmployeeList.Count == 0 || appointment.EmployeeList.Any(a => a.Employee.Oid.HasValue && a.Employee.Oid.Value == originator));
            });

            return hasOverlappingEmployeeAppointments || hasOverlappingCustomerAppointments || hasOverlappingResourceAppointments || hasOverlappingOriginatorAppointments;
	    }

        private static bool ShouldDoAppointmentOverlappingCheck(SchedulerAppointment appointment, Guid? recurrenceId)
        {
            if(appointment.Oid.HasValue && recurrenceId.HasValue)
            {
                var recId = appointment.GetRecurrenceIdAndIndex(out var recIndex);

                if(appointment.RecurrenceInfo != null && recId != null)
                {
                    if(recId.Equals(recurrenceId))
                    {
                        return false;
                    }
                }
            }

            return true;
        }

        public IEnumerable<SchedulerAppointment> GetAllActiveAppointmentsForEmployeeInInterval(DateTime start, DateTime end, long pEmployeeOid)
        {
            var hasResources = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM resource2newschapp)";

            var criteria = CreateRecurrenceCriteria(start, end)
                .Add(Restrictions.Or(
                    Expression.Sql(new SqlString(hasResources)),
                    CreateOwnAppointmentsCriteria(pEmployeeOid)));

            return criteria.List<SchedulerAppointment>();
        }

        public IEnumerable<SchedulerAppointment> GetAllActiveAppointmentsInInterval(DateTime start, DateTime end)
		{
		    return CreateRecurrenceCriteria(start, end).List<SchedulerAppointment>();
		}

		public ResourceBooking GetFirstResourceBookingFromSequence(long sequenceOid)
	    {
			return CreateCriteria<ResourceBooking>()
				.Add(Restrictions.Eq(ResourceBooking.PropertyName_SequencePosition, 0))
				.CreateAlias(ResourceBooking.PropertyName_Sequence, "s")
				.Add(Restrictions.Eq("s." + BeWoEntityBase.PropertyName_Oid, sequenceOid)).UniqueResult<ResourceBooking>();
	    }

	    public List<int> GetExcludedBookingSequencePositions(long sequenceOid)
	    {
		    var c = CreateCriteria<ResourceBooking>()
			    .Add(Restrictions.Gt(ResourceBooking.PropertyName_SequencePosition, 0))
			    .CreateAlias(ResourceBooking.PropertyName_Sequence, "s")
			    .Add(Restrictions.Eq("s." + BeWoEntityBase.PropertyName_Oid, sequenceOid)).List<ResourceBooking>();

			return c.Select(s => s.SequencePosition).ToList();
	    }

        public IEnumerable<InvoiceBase> GetInvoiceBases(DateTime? startDate, DateTime? endDate, bool useInvoiceDate = true)
        {
            var lCriteria = CreateCriteriaIsActive<InvoiceBase>();
            if (useInvoiceDate)
            {
                if (startDate.HasValue)
                    lCriteria.Add(Restrictions.Ge(InvoiceBase.PropertyName_InvoiceDate, startDate));
                if (endDate.HasValue)
                    lCriteria.Add(Restrictions.Le(InvoiceBase.PropertyName_InvoiceDate, endDate));
            }
            else
            {
                if (startDate.HasValue)
                    lCriteria.Add(Restrictions.Ge(InvoiceBase.PropertyName_AccountingPeriodEnd, startDate));
                if (endDate.HasValue)
                    lCriteria.Add(Restrictions.Le(InvoiceBase.PropertyName_AccountingPeriodStart, endDate));
            }

            return lCriteria.List<InvoiceBase>();
        }

        public IEnumerable<SupportConcept> GetAllActiveSupportConceptsByCustomers(List<long> customerOids, bool expiredOnesToo = false)
	    {
		    var c = CreateCriteria<SupportConcept>()
				.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
				.CreateAlias(SupportConcept.PropertyName_Customer, "c")
				.Add(Restrictions.In("c." + BeWoEntityBase.PropertyName_Oid, customerOids));

		    if (expiredOnesToo)
		    {
			    
		    }

		    return c.List<SupportConcept>();
	    }

	    public IEnumerable<ServiceRecord> FindServiceRecordsForDays(long? costBearer2SupportConceptOid, int dayCount, long? employeeOid)
	    {
			var minStart = DateTime.Now.GetShortDateTime().AddDays(-dayCount);
		    var c = CreateCriteriaIsActive<ServiceRecord>();

		    if (costBearer2SupportConceptOid.HasValue)
		    {
			    c.Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costBearer2SupportConceptOid));
		    }
		    else
		    {
				c.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, employeeOid))
				 .Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));
		    }

		    if (dayCount > 0)
		    {
				c.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, minStart));
		    }

		    return c.List<ServiceRecord>();
	    }

        public IEnumerable<TextModule> GetActiveTextModuleByServiceCategory(long pServiceCategoryOid)
        {
            var c = CreateCriteria<TextModule>();

            c.Add(Restrictions.Or(Restrictions.Eq(TextModule.PropertyName_ServiceCategory + ".Oid", pServiceCategoryOid), Restrictions.IsNull(TextModule.PropertyName_ServiceCategory)));

            return c.List<TextModule>();
        }

        public IEnumerable<SchedulerAppointment> GetAllActiveAppointmentsForEmployeeInInterval2(DateTime start, DateTime end, List<long> pEmployeeOids)
		{
		    var mainCriteria = CreateRecurrenceCriteria(start, end);

		    var detachedCriteria1 = DetachedCriteria.For<Employee2SchedulerAppointment>()
		        .Add(Restrictions.In(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", pEmployeeOids))
		        .SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment));
		    var employee2SchedCrit = Subqueries.PropertyIn(BeWoEntityBase.PropertyName_Oid, detachedCriteria1);

		    var originatorCrit = Restrictions.In(SchedulerAppointment.PropertyName_Originator, pEmployeeOids);
		        
		    var detachedCriteria2 = DetachedCriteria.For<Employee2SchedulerAppointment>("e2s2")
		        .SetProjection(Projections.Property(BeWoEntityBase.PropertyName_Oid))
		        .Add(Restrictions.EqProperty("e2s2." + Employee2SchedulerAppointment.PropertyName_SchedulerAppointment, "sa.Oid"));

		    var employee2SchedCrit2 = Subqueries.NotExists(detachedCriteria2);

		    var and = Restrictions.And(originatorCrit, employee2SchedCrit2);

		    ICriterion employeeCriterion = Restrictions.Or(employee2SchedCrit, and);

		    mainCriteria.Add(employeeCriterion);

            var appointments = mainCriteria.List<SchedulerAppointment>();

            var exceptionalRecurrenceInfos = appointments.Where(w => w.RecurrenceInfo != null && w.Type == 3).ToList();

            var exceptionIds = new List<long>();
            var regex = new Regex("(Id=\\\"[a-z0-9-]+\\\")");

            foreach(var appointment in exceptionalRecurrenceInfos)
            {
                var match = regex.Match(appointment.RecurrenceInfo);
                if(match.Success)
                {
                    var value = match.Value;
                    var actualId = value.Split("\"");
                    if(actualId.Count > 1)
                    {
                        var id = actualId[1];

                        if(!appointments.Any(w => w.RecurrenceInfo != null && w.RecurrenceInfo.Contains(id) && w.Type == 1))
                        {
                            exceptionIds.Add(appointment.Oid.Value);
                        }
                    }
                }
            }

            var exceptionsToModify = appointments.Where(w => w.Oid.HasValue && exceptionIds.Contains(w.Oid.Value)).ToList();

            foreach(var exception in exceptionsToModify)
            {
                var replacingAppointment = new SchedulerAppointment
                {
                    Oid = exception.Oid.Value * -1,
                    Version = 1,
                    Type = 4,
                    RecurrenceInfo = exception.RecurrenceInfo,
                    Originator = exception.Originator,
                    EmployeeList = exception.EmployeeList,
                    CustomerList = exception.CustomerList,
                    ResourceList = exception.ResourceList
                };

                exception.RecurrenceInfo = null;
                exception.Type = 0;

                appointments.Add(replacingAppointment);
            }
		    
            var recurrenceIds = new List<string>();

            var allExceptionalRecurrenceInfos = appointments.Where(w => w.RecurrenceInfo != null);
            foreach(var appointment in allExceptionalRecurrenceInfos)
            {
                var match = regex.Match(appointment.RecurrenceInfo);
                if(match.Success)
                {
                    var value = match.Value;
                    var actualId = value.Split("\"");
                    if(actualId.Count > 1)
                    {
                        recurrenceIds.AddIfNotIn(actualId[1]);
                    }
                }
            }

            var changedOrDeletedOccurences = FindAppointmentsByRecurrenceId(recurrenceIds, true);

            appointments.AddRangeIfElementsNotIn(changedOrDeletedOccurences);

            return appointments;
		}

	    public IEnumerable<long> FilterEmployeesWithAppointments(List<long> pEmployeeOids, DateTime pStartTime, DateTime pEndTime)
	    {
		    var result            = new List<long>();
			var appointments      = GetAllActiveAppointmentsForEmployeeInInterval2(pStartTime, pEndTime, pEmployeeOids);
			var gefilterteTermine = appointments.Where(w => w.EmployeeList.Select(s => s.Employee.Oid.Value).Intersect(pEmployeeOids).Any() || !w.EmployeeList.Select(s => s.Employee.Oid.Value).Intersect(pEmployeeOids).Any() && pEmployeeOids.Contains(w.Originator.Oid.Value));

	        var employee2SchedulerAppointmentsList = gefilterteTermine.Select(s => s.EmployeeList).ToList();
	        foreach(var employee2SchedulerAppointments in employee2SchedulerAppointmentsList)
	        {
	            foreach(var employee2SchedulerAppointment in employee2SchedulerAppointments)
	            {
	                if(employee2SchedulerAppointment.Employee.Oid.HasValue && !result.Contains(employee2SchedulerAppointment.Employee.Oid.Value))
	                {
	                    result.Add(employee2SchedulerAppointment.Employee.Oid.Value);
	                }
	            }
	        }
	        
	        foreach(var originator in gefilterteTermine.Select(s => s.Originator))
	        {
	            if(originator.Oid.HasValue && !result.Contains(originator.Oid.Value))
	            {
	                result.Add(originator.Oid.Value);
	            }
	        }

		    var c = CreateCriteria<AbsenceTime>()
				.Add(Restrictions.In(AbsenceTime.PropertyName_EmployeeOid, pEmployeeOids))
				.Add(Restrictions.Or(
						Restrictions.Or(
								Restrictions.Or(
										Restrictions.And(
											Restrictions.Eq(AbsenceTime.PropertyName_Start, pStartTime), 
											Restrictions.Eq(AbsenceTime.PropertyName_End, pEndTime)), 
										Restrictions.And(
											Restrictions.And(
												Restrictions.Lt(AbsenceTime.PropertyName_Start, pStartTime), 
												Restrictions.Lt(AbsenceTime.PropertyName_End, pStartTime)),
											Restrictions.Gt(AbsenceTime.PropertyName_End, pEndTime))), 
										Restrictions.And(
											Restrictions.Lt(AbsenceTime.PropertyName_Start, pStartTime), 
											Restrictions.Gt(AbsenceTime.PropertyName_End, pStartTime))),
										Restrictions.And(
											Restrictions.Gt(AbsenceTime.PropertyName_Start, pStartTime),
											Restrictions.Lt(AbsenceTime.PropertyName_End, pEndTime))));

		    var abwesenheiten = c.List<AbsenceTime>();

		    foreach(var abwesenheit in abwesenheiten)
		    {
			    result.AddIfNotIn(abwesenheit.EmployeeOid.Value);
		    }

		    return result;
	    }
 
        public IEnumerable<Task> GetTasksForEmployeeByDate(long employeeOid, DateTime date){
            var c = CreateCriteria<Task>().Add(Restrictions.Between(Task.PropertyName_DueDate, date, date.AddDays(1))).
                CreateCriteria(Task.PropertyName_EmployeeList, JoinType.InnerJoin) 
                .Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, employeeOid)).List<Task>();
            
            return c;
        }

        public Wohnheimbuchung GetWohnheimbuchungByWohnheimAndBuchungsdatum(long pWohnheimOid, DateTime pBuchungsdatum)
        {
            var c = CreateCriteriaIsActive<Wohnheimbuchung>();

            c.Add(Restrictions.Eq(Wohnheimbuchung.PropertyName_Buchungsdatum, pBuchungsdatum))
                .Add(Restrictions.Eq(Format("{0}.Oid", Wohnheimbuchung.PropertyName_Wohnheim), pWohnheimOid));

            return c.UniqueResult<Wohnheimbuchung>();
        }

        public List<ServiceRecord> FindWohnheimbuchungsServiceRecords(long pWohnheimbuchungsOid)
        {
            var c = CreateCriteria<ServiceRecord>()
                .Add(Restrictions.Eq(ServiceRecord.PropertyName_WohnheimbuchungsOid, pWohnheimbuchungsOid));

            return c.List<ServiceRecord>().ToList();
        }

        public bool CheckIfUserGroupIsLastWithUserGroupEditingRights(List<long> pUserGroupOids)
        {
            var dc = DetachedCriteria.For<UserGroup>()
                .Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
                .SetProjection(Projections.Property(BeWoEntityBase.PropertyName_Oid));

            var c = CreateCriteriaIsActive<RightRelation>()
                .Add(Restrictions.Not(Restrictions.In(RightRelation.PropertyName_UserGroupOid, pUserGroupOids)))
                .Add(Restrictions.In(RightRelation.PropertyName_RightType, new[] { UserRightType.UserGroupView_View, UserRightType.UserGroupView_Edit, UserRightType.ViewAll, UserRightType.EditAll }))
                .Add(Subqueries.PropertyIn(RightRelation.PropertyName_UserGroupOid, dc));

            var result = c.List<RightRelation>();
            var nachUserGroupOidSortiert = new Dictionary<long, List<UserRightType>>();

            foreach (var relation in result)
            {
                nachUserGroupOidSortiert.AddOrUpdateValueInDictionary(relation.UserGroupOid.Value, relation.RightType);
            }

            var minRights2 = nachUserGroupOidSortiert.Any(intersection => 
                            intersection.Value.Contains(UserRightType.UserGroupView_Edit) && intersection.Value.Contains(UserRightType.ViewAll) ||
                            intersection.Value.Contains(UserRightType.UserGroupView_Edit) && intersection.Value.Contains(UserRightType.UserGroupView_View) ||
                            intersection.Value.Contains(UserRightType.EditAll) && intersection.Value.Contains(UserRightType.ViewAll) ||
                            intersection.Value.Contains(UserRightType.EditAll) && intersection.Value.Contains(UserRightType.UserGroupView_View));
            
            return minRights2 == false;
        }

        public ServiceDescription FindServiceDescriptionForWohnheimbuchungsServiceRecord(long pWohnheimbuchungsOid)
        {
            var dc = DetachedCriteria.For<ServiceRecord>()
                .Add(Restrictions.Eq(ServiceRecord.PropertyName_WohnheimbuchungsOid, pWohnheimbuchungsOid))
                .SetProjection(Projections.Property(ServiceRecord.PropertyName_ServiceDescription + ".Oid"));

            var c = CreateCriteriaIsActive<ServiceDescription>()
                .Add(Subqueries.PropertyIn(BeWoEntityBase.PropertyName_Oid, dc)).SetMaxResults(1);

            return c.List<ServiceDescription>().FirstOrDefault();
        }

        public IEnumerable<Bargeldkasse> FindBargeldkasse(TableID objectTid, long objectOid)
        {
            var c = CreateCriteriaIsActive<Bargeldkasse>()
                .Add(Restrictions.Eq(Bargeldkasse.PropertyName_ObjectTid, objectTid))
                .Add(Restrictions.Eq(Bargeldkasse.PropertyName_ObjectOid, objectOid));

            return c.List<Bargeldkasse>().ToList();
        }

        public IList<NotizenKategorie> FindNotizenKategorien(TableID objectTid, long objectOid)
        {
            var c = CreateCriteriaIsActiveOrArchived<NotizenKategorie>()
                .Add(Restrictions.Eq(NotizenKategorie.PropertyName_ObjectTid, objectTid))
                .Add(Restrictions.Eq(NotizenKategorie.PropertyName_ObjectOid, objectOid));

            return c.List<NotizenKategorie>().ToList();
        }

        public IEnumerable<MedRecord> FindMedRecordsForCustomer(long pCustomerOid)
        {
            var c = CreateCriteriaIsActive<MedRecord>()
                .Add(Restrictions.Eq(MedRecord.PropertyName_Customer + ".Oid", pCustomerOid));

            return c.List<MedRecord>().ToList();
        }

        public IEnumerable<Customer> FindAllChatActiveCustomers()
        {
            var c = CreateCriteriaIsActive<CustomerAPPCode>()
                .Add(Restrictions.Eq(CustomerAPPCode.PropertyName_IsChatAktiv, 1));

            var codes = c.List<CustomerAPPCode>().Select(s => s.CustomerOid.Value).ToArray();

            var c2 = CreateCriteriaIsActive<Customer>()
                .Add(Restrictions.In(BeWoEntityBase.PropertyName_Oid, codes));

            return c2.List<Customer>();
        }

        public IEnumerable<Employee2Customer> FindAllChatpartnerEmployee2Customer(long pRecipientOid)
        {
            var c = CreateCriteriaIsActive<Employee2Customer>()
                .Add(Restrictions.Eq(Employee2Customer.PropertyName_EmployeeOid, pRecipientOid))
                .Add(Restrictions.Eq(Employee2Customer.PropertyName_Chatpartner,true));

            return c.List<Employee2Customer>();
        }

        public IEnumerable<ChatMessage> FindAllChatMessages(long senderOid, long empfaengerOid,int maxNachrichten)
        {
            var c = CreateCriteriaIsActive<ChatMessage>()
                .Add(
                    Restrictions.Or(
                        Restrictions.And(
                            Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, senderOid),
                            Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, empfaengerOid)),
                        Restrictions.And(
                            Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, empfaengerOid),
                            Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, senderOid))))
                            .Add(Restrictions.IsNull(ChatMessage.PropertyName_TeamOid))
                            .AddOrder(Order.Desc(ChatMessage.PropertyName_Uhrzeit))
                            .SetMaxResults(maxNachrichten);

            return c.List<ChatMessage>();
        }
   
        public IEnumerable<ChatMessage> FindNextChatMessages(long senderOid, long empfaengerOid, int messlateZahl, List<string> list,bool isteam )
        {
            var c = CreateCriteriaIsActive<ChatMessage>();
            if (!isteam)
            {
                c.Add(
                    Restrictions.Or(
                        Restrictions.And(
                            Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, senderOid),
                            Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, empfaengerOid)),
                        Restrictions.And(
                            Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, empfaengerOid),
                            Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, senderOid)))).Add(Restrictions.IsNull(ChatMessage.PropertyName_TeamOid));
            }
            else
            {
                
                c.Add(Restrictions.Eq(ChatMessage.PropertyName_TeamOid, empfaengerOid));
            }

            c.Add(Restrictions.Not(Restrictions.In(ChatMessage.PropertyName_MessageId, list)));

            c.AddOrder(Order.Desc(ChatMessage.PropertyName_Uhrzeit));
            c.SetMaxResults(messlateZahl);

            return c.List<ChatMessage>();
        }

        public int CountChatMessages(int aktuelleZahl, long senderOid, long empfaengerOid,bool isTeam)
        {
            //Zähle hier alle ChatMessages
            int xc;
            if (!isTeam)
            {
                xc =
                    Session.QueryOver<ChatMessage>()
                        .Where(
                            message =>
                                message.SenderPersonOid == senderOid && message.EmpfaengerPersonOid == empfaengerOid ||
                                message.SenderPersonOid == empfaengerOid && message.EmpfaengerPersonOid == senderOid)
                        .RowCount();

            }
            else
            {
                xc =
                    Session.QueryOver<ChatMessage>()
                        .Where(
                            message =>
                                message.TeamOid == empfaengerOid)    
                        .RowCount();
            }
                                                                        
            int ergebnis = xc - aktuelleZahl;

            if (ergebnis < 0)
                ergebnis = 0;

            return ergebnis;
        }

        public IEnumerable<ChatMessage> FindAllChatMessagesFromTeam(long senderOid, long teamOid, int messlateZahl)
        {       
            var c = CreateCriteriaIsActive<ChatMessage>()
                .Add(Restrictions.Eq(ChatMessage.PropertyName_TeamOid, teamOid));

            c.AddOrder(Order.Desc(ChatMessage.PropertyName_Uhrzeit));
            c.SetMaxResults(messlateZahl);

            return c.List<ChatMessage>();
        }

        public IEnumerable<ChatMessage> FindAllEmpfängerChatMessages(long senderOid, long empfaengerOid)
        {
            var c = CreateCriteriaIsActive<ChatMessage>()
                .Add(Restrictions.And(
                            Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, senderOid),
                            Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, empfaengerOid)));

            return c.List<ChatMessage>();
        }

        public IEnumerable<ChatMessage> FindEmpfängerChatMessages(long senderOid, long empfaengerOid,string messageOid)
        {
            var c = CreateCriteriaIsActive<ChatMessage>()
                .Add(Restrictions.And(
                            Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, senderOid),
                            Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, empfaengerOid)));

            c.Add(Restrictions.Eq(ChatMessage.PropertyName_MessageId, messageOid));

            return c.List<ChatMessage>();
        }

        public IEnumerable<Employee> FindAllChatActiveEmployees()
        {
            var c = CreateCriteriaIsActive<EmployeeAPPCode>()
                .Add(Restrictions.Eq(EmployeeAPPCode.PropertyName_IsChatAktiv, 1));

            var codes = c.List<EmployeeAPPCode>().Select(s => s.EmployeeOid.Value).ToArray();

            var c2 = CreateCriteriaIsActive<Employee>()
                .Add(Restrictions.In(BeWoEntityBase.PropertyName_Oid, codes));

            return c2.List<Employee>();
        }

        public bool CheckIfEmployeeIsAllowedToChat(long pPersonOid)
        {
            var employee = FindEmployeeWithPersonOid(pPersonOid);

            var c = CreateCriteriaIsActive<EmployeeAPPCode>()
                .Add(Restrictions.Eq(EmployeeAPPCode.PropertyName_IsChatAktiv, 1))
                .Add(Restrictions.Eq(EmployeeAPPCode.PropertyName_EmployeeOid, employee.Oid));

            var codes = c.List<EmployeeAPPCode>().ToArray();
            
            return codes.Length > 0;
        }

        public IEnumerable<EmployeeAPPCode> FindAllEmployeeAppCodes(long employeeoid)
        {
            var c = CreateCriteriaIsActive<EmployeeAPPCode>()
                .Add(Restrictions.Eq(EmployeeAPPCode.PropertyName_EmployeeOid, employeeoid));
                
            return c.List<EmployeeAPPCode>();
        }
        
        public IEnumerable<CustomerAPPCode> FindAllCustomerAppCodes(long customeroid)
        {
            var c = CreateCriteriaIsActive<CustomerAPPCode>()
                .Add(Restrictions.Eq(CustomerAPPCode.PropertyName_CustomerOid, customeroid));


            return c.List<CustomerAPPCode>();
        }

        public IEnumerable<CustomerAPPCode> FindAllCustomerAppCodeBenutzer(string benutzername)
        {
            var c =
                CreateCriteriaIsActive<CustomerAPPCode>()
                    .Add(Restrictions.Eq(CustomerAPPCode.PropertyName_Benutzername, benutzername));

            return c.List<CustomerAPPCode>();
        }

        public IEnumerable<ChatMessage> FindAllChatMessagesForAndroid(long pSenderOid, long pRecipientOid, List<string> pExceptions, bool pForTeam)
        {
            var c = CreateCriteriaIsActive<ChatMessage>()
                .Add(
                    Restrictions.Or(
                        Restrictions.And(
                            Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, pSenderOid),
                            Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, pRecipientOid)),
                        Restrictions.And(
                            Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, pRecipientOid),
                            Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, pSenderOid))))
                .Add(Restrictions.Not(Restrictions.In(ChatMessage.PropertyName_MessageId, pExceptions)))
                .Add(Restrictions.IsNull(ChatMessage.PropertyName_TeamOid));

            if(pForTeam)
            {
                c = CreateCriteriaIsActive<ChatMessage>()
                    .Add(Restrictions.Eq(ChatMessage.PropertyName_TeamOid, pRecipientOid))
                    .Add(Restrictions.Not(Restrictions.In(ChatMessage.PropertyName_MessageId, pExceptions)));
            }

            return c.List<ChatMessage>();
        }

        //public IEnumerable<ChatMessage> FindAllUnreadChatMessages(List<long> pExceptions)
        //{
        //    var c = CreateCriteriaIsActive<ChatMessage>()
        //        .Add(Restrictions.Not(Restrictions.In(ChatMessage.PropertyName_MessageId, pExceptions)));

        //    return c.List<ChatMessage>();
        //}

        public Dictionary<Person, bool> FindAllChatAuthorizedPersonsForEmployee(long pEmployeeOid)
        {
            var result = new Dictionary<Person, bool>();

            var employee = CreateCriteriaIsActive<Employee>().Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, pEmployeeOid)).UniqueResult<Employee>();

            var relatedCustomerOids = employee.Employee2CustomerList.Select(s => s.CustomerOid.Value);

            var c1 = CreateCriteriaIsActive<CustomerAPPCode>()
                .Add(Restrictions.Eq(CustomerAPPCode.PropertyName_IsChatAktiv, 1));
            var codes = c1.List<CustomerAPPCode>().Select(s => s.CustomerOid.Value).ToArray();
            var c2 = CreateCriteriaIsActive<Customer>()
                .Add(Restrictions.In(BeWoEntityBase.PropertyName_Oid, codes))
                .Add(Restrictions.In(BeWoEntityBase.PropertyName_Oid, relatedCustomerOids.ToList()));

            var customers = c2.List<Customer>();
            var employees = FindAllChatActiveEmployees();

            employees.DoForEach(d => result.Add(d.Person, true));
            customers.DoForEach(d => result.Add(d.Person, false));

            return result;
        }

        public Dictionary<long, byte[]> FindImagesForChatAuthorizedPersonsForEmployee(long pEmployeeOid)
        {
            var result = new Dictionary<long, byte[]>();

            var employee = CreateCriteriaIsActive<Employee>().Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, pEmployeeOid)).UniqueResult<Employee>();

            var relatedCustomerOids = employee.Employee2CustomerList.Select(s => s.CustomerOid.Value);

            var c1 = CreateCriteriaIsActive<CustomerAPPCode>()
                .Add(Restrictions.Eq(CustomerAPPCode.PropertyName_IsChatAktiv, 1));
            var codes = c1.List<CustomerAPPCode>().Select(s => s.CustomerOid.Value).ToArray();
            var c2 = CreateCriteriaIsActive<Customer>()
                .Add(Restrictions.In(BeWoEntityBase.PropertyName_Oid, codes))
                .Add(Restrictions.In(BeWoEntityBase.PropertyName_Oid, relatedCustomerOids.ToList()));

            var customers = c2.List<Customer>();
            var employees = FindAllChatActiveEmployees();

            //foreach (var customer in customers.Where(w => w.CustomerImage != null))
            //{
            //    result.Add(customer.Person.Oid.Value, customer.CustomerImage);
            //}

            //foreach (var emp in employees.Where(w => w.EmployeeImage != null))
            //{
            //    result.Add(emp.Person.Oid.Value, emp.EmployeeImage);
            //}

            return result;
        }

        public IEnumerable<ChatMessage> FindUnreadChatMessagesForRecipient(long pRecipientOid)
        {
            var c = CreateCriteriaIsActive<ChatMessage>()
                .Add(Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, pRecipientOid))
                .Add(Restrictions.Eq(ChatMessage.PropertyName_IstGelesen, 0));

            return c.List<ChatMessage>();
        }

        public IEnumerable<ChatMessage> FindNewestChatMessages(long pRecipientPersonOid)
        {
            var blubb = FindTeamsOfEmployee(pRecipientPersonOid);

            var c = CreateCriteria<ChatMessage>();
            c.Add(Subqueries.PropertyIn("Oid",
                DetachedCriteria.For<NewestChatMessage>()

                .Add(
                    Restrictions.Or(
                        Restrictions.And(
                            Restrictions.Or(
                                Restrictions.Eq(NewestChatMessage.PropertyName_RecipientPersonOid, pRecipientPersonOid),
                                Restrictions.Eq(NewestChatMessage.PropertyName_SenderPersonOid, pRecipientPersonOid)),
                            Restrictions.Eq(NewestChatMessage.PropertyName_IsTeam, false)),
                        Restrictions.And(Restrictions.Eq(NewestChatMessage.PropertyName_IsTeam, true), Restrictions.In(NewestChatMessage.PropertyName_RecipientPersonOid, blubb.Select(s => s.Oid.Value).ToArray())))
                    )

                .SetProjection(Projections.Property("ChatMessageOid"))));

            var query = ToSql(c);

            return c.List<ChatMessage>();
        }

        public static string ToSql(ICriteria criteria)
        {
            var criteriaImpl = (CriteriaImpl) criteria;
            var sessionImpl = (SessionImpl) criteriaImpl.Session;
            var factory = (ISessionFactoryImplementor) sessionImpl.SessionFactory;
            var implementors = factory.GetImplementors(criteriaImpl.EntityOrClassName);

            if(implementors.Length == 0)
            {
                return "No entity or class name found!";
            }

            var loader = new CriteriaLoader((IOuterJoinLoadable)factory.GetEntityPersister(implementors[0]), factory, criteriaImpl, implementors[0], sessionImpl.EnabledFilters);

            return loader.SqlString.ToString();
        }

        public IEnumerable<string> FindChatMessageIds(List<string> messageIds)
        {
            var c = CreateCriteria<ChatMessage>()
                .Add(Restrictions.In(ChatMessage.PropertyName_MessageId, messageIds));

            var liste = c.List<ChatMessage>();

            return liste.Select(s => s.MessageId);
        }

        public IEnumerable<ChatMessage> LoadChatMessagesChunkwise(string pMessageId, long pRecipientOid, long pSenderOid, bool pForTeam, List<string> pExceptions, bool pIsInitialCall)
        {
            var c = CreateCriteriaIsActive<ChatMessage>()
                .Add(Restrictions.Or(
                    Restrictions.And(
                        Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, pSenderOid),
                        Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, pRecipientOid)),
                    Restrictions.And(
                        Restrictions.Eq(ChatMessage.PropertyName_SenderPersonOid, pRecipientOid),
                        Restrictions.Eq(ChatMessage.PropertyName_EmpfaengerPersonOid, pSenderOid))));

            c.Add(Restrictions.IsNull(ChatMessage.PropertyName_TeamOid));

            if (pForTeam)
            {
                c = CreateCriteriaIsActive<ChatMessage>()
                    .Add(Restrictions.Eq(ChatMessage.PropertyName_TeamOid, pRecipientOid));
            }

            if (!IsNullOrEmpty(pMessageId))
            {
                var c1 = CreateCriteriaIsActive<ChatMessage>()
                            .Add(Restrictions.Eq(ChatMessage.PropertyName_MessageId, pMessageId))
                            .AddOrder(Order.Desc(BeWoEntityBase.PropertyName_InsTs));

                var list = c1.List<ChatMessage>();
                if (list.Count > 0)
                {
                    var lastLoadedChatMessage = c1.List<ChatMessage>().First();

                    c.Add(Restrictions.Not(Restrictions.In(ChatMessage.PropertyName_MessageId, pExceptions)));

                    if (pIsInitialCall)
                    {
                        c.Add(Restrictions.Gt(BeWoEntityBase.PropertyName_InsTs, lastLoadedChatMessage.InsTs));
                    }
                }
            }

            c.AddOrder(Order.Desc(BeWoEntityBase.PropertyName_InsTs));
            c.SetMaxResults(50);

            var sqlQeury = ToSql(c);

            var result = c.List<ChatMessage>();

            return result;
        }

        public IList<ChatMediaMessage> GetChatMediaMessagesForChatMessage(long chatMessageOid)
        {
            var c = CreateCriteriaIsActive<ChatMediaMessage>()
                .Add(Restrictions.Eq(ChatMediaMessage.PropertyName_ChatMessageOid, chatMessageOid));

            return c.List<ChatMediaMessage>();
        }

        public NewestChatMessage GetNewestChatMessageForConversation(long pRecipientPersonOid, long pSenderPersonOid, bool pIsTeam)
        {
            var teams = new List<long>();

            if (pIsTeam)
            {
                var employee = FindEmployeeWithPersonOid(pSenderPersonOid);
                if (employee != null)
                {
                    teams.AddRange(FindTeamsOfEmployee(employee.Oid.Value).Select(s => s.Oid.Value));
                }
            }

            var c = CreateCriteria<NewestChatMessage>();

            if (pIsTeam)
            {
                c.Add(Restrictions.And(Restrictions.Eq(NewestChatMessage.PropertyName_IsTeam, true),
                Restrictions.Eq(NewestChatMessage.PropertyName_RecipientPersonOid, pRecipientPersonOid)));
            }
            else
            {
                c.Add(
                    Restrictions.And(
                        Restrictions.Or(
                            Restrictions.And(
                                Restrictions.Eq(NewestChatMessage.PropertyName_RecipientPersonOid, pRecipientPersonOid),
                                Restrictions.Eq(NewestChatMessage.PropertyName_SenderPersonOid, pSenderPersonOid)),
                            Restrictions.And(
                                Restrictions.Eq(NewestChatMessage.PropertyName_RecipientPersonOid, pSenderPersonOid),
                                Restrictions.Eq(NewestChatMessage.PropertyName_SenderPersonOid, pRecipientPersonOid))),

                        Restrictions.Eq(NewestChatMessage.PropertyName_IsTeam, false)));
            }

            return c.UniqueResult<NewestChatMessage>();
        }

        public IList<Organisation> GetAllOrganisation2PersonRelations(long personOid)
        {
            var c = CreateCriteriaIsActive<Person>()
                .Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid,personOid)).UniqueResult<Person>().Organisation2Persons.Select(s => s.Organisation).ToList();
                

            return c;
        }
        
        public IList<Person> GetAllPerson2OrganisationRelations(long organisationOid)
        {
            var c = CreateCriteriaIsActive<Organisation>()
                .Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, organisationOid)).UniqueResult<Organisation>().Organisation2PersonList.Select(s => s.Person).ToList();

            return c;
        }

        public ServiceRecord FindServiceRecordforHistory(long? pServiceRecordOid)
        {      
            var c = CreateCriteria<ServiceRecord>().Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, pServiceRecordOid));

            return c.UniqueResult<ServiceRecord>();
        }

        public ArbeitszeitListe FindEmployeeArbeitszeitListe(long employeeOid)
        {
            var c = CreateCriteria<Arbeitszeit>().Add(Restrictions.Eq(Arbeitszeit.PropertyName_EmployeeOid,employeeOid));

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


            foreach (var item in c.List<Arbeitszeit>())
            {
                nAr.Add(item.Oid.Value);
            }

            ArbeitszeitListe a = new ArbeitszeitListe();
            a.Arbeitszeit = c.List<Arbeitszeit>().ToList();
            
            if(nAr.Count != 0){
                var cEintrag =
                    CreateCriteria<ArbeitszeitEintrag>()
                        .Add(Restrictions.In(ArbeitszeitEintrag.PropertyName_ArbeitszeitOid, nAr)); 



                a.ArbeitszeitEintrag = cEintrag.List<ArbeitszeitEintrag>().ToList();

            }

            return a;
        }	

        public IList<SupportConcept> FindCostBearer2SupportConceptForDate(DateTime datum)
        {
            var c = CreateCriteriaIsActive<SupportConcept>();

            return c
                .CreateAlias(SupportConcept.PropertyName_CostBearer2SupportConceptList, "cb2sc", JoinType.InnerJoin)
                .CreateAlias(SupportConcept.PropertyName_Customer, "c", JoinType.InnerJoin)
                .Add(Restrictions.Or(
                    Restrictions.And(Restrictions.Le(CostBearer2SupportConcept.PropertyName_ApprovedStartDate, datum), Restrictions.Ge(CostBearer2SupportConcept.PropertyName_ApprovedEndDate, datum)),
                    Restrictions.And(Restrictions.Le(CostBearer2SupportConcept.PropertyName_ApprovedStartDate, datum), Restrictions.Ge(CostBearer2SupportConcept.PropertyName_ApprovedEndDate, datum))))
                .List<SupportConcept>().Distinct().ToList();
        }

        public IList<QuittierungsCheck> FindQuittierungsCheckWithCustomerOids(List<long> oids)
        {
            var c = CreateCriteria<QuittierungsCheck>()
                .Add(Restrictions.In(QuittierungsCheck.PropertyName_CustomerOid, oids))
                .List<QuittierungsCheck>();

            return c;
        }

        public IList<QuittierungsCheck> FindQuittierungsCheckWithCustomerOid(long oid)
        {

            var c = CreateCriteria<QuittierungsCheck>()
                    .Add(Restrictions.Eq(QuittierungsCheck.PropertyName_CustomerOid, oid));
                    //.UniqueResult<QuittierungsCheck>();


            return c.List<QuittierungsCheck>();
        }

        public IList<Timesheet> FindTimeSheetsForMonth(DateTime monat)
        {
            DateTime start = new DateTime(monat.Year, monat.Month, 1);
            DateTime end = start.AddMonths(1);

            return CreateCriteria<Timesheet>()
                .Add(Restrictions.And(Restrictions.Lt(SchedulerAppointment.PropertyName_StartDate, end), Restrictions.Ge(SchedulerAppointment.PropertyName_EndDate, start)))
                .List<Timesheet>();
        }

        public Timesheet FindEmployeeTimeSheetForMonth(long employeeOid, DateTime monat)
        {
            DateTime start = new DateTime(monat.Year, monat.Month, 1);
            DateTime end = start.AddMonths(1);

            return CreateCriteria<Timesheet>()
                .Add(Restrictions.Eq("EmployeeOid", employeeOid))
                .Add(Restrictions.And(Restrictions.Lt(SchedulerAppointment.PropertyName_StartDate, end),
                    Restrictions.Ge(SchedulerAppointment.PropertyName_EndDate, start)))
                .List<Timesheet>().FirstOrDefault();
        }

        public IList<Timesheet2Mail> FindTimeSheetMails(long timesheetOid, long employeeOid)
        {

            return CreateCriteria<Timesheet2Mail>()
                .Add(Restrictions.Eq("TimesheetOid", timesheetOid))
                .Add(Restrictions.Eq("EmployeeOid", employeeOid))
                .List<Timesheet2Mail>();
        }

        public IEnumerable<AbsenceTime> GetAllAbsenceTimesInIntervalByEmployee(DateTime start, DateTime end, long pEmployeeOid, bool pHasRightToSeeAllEmployeeAppointments)
	    {
			// Wenn das Enddatum null ist, wird das Ende des Intervalls als Enddatum gesetzt (Ist ja eh read-only).

		    var criteria = CreateCriteriaIsActive<AbsenceTime>()
				.Add(Restrictions.IsNotNull(AbsenceTime.PropertyName_EmployeeOid))
				.Add(Restrictions.Or
						(Restrictions.Or(Restrictions.Or(
						Restrictions.And(Restrictions.Ge(AbsenceTime.PropertyName_Start, start), Restrictions.Le(AbsenceTime.PropertyName_Start, end)), 
						Restrictions.Eq(AbsenceTime.PropertyName_Start, start)
						), Restrictions.And(Restrictions.Le(AbsenceTime.PropertyName_Start, start), Restrictions.IsNull(AbsenceTime.PropertyName_End))
						), Restrictions.And(Restrictions.Lt(AbsenceTime.PropertyName_Start, start), Restrictions.Gt(AbsenceTime.PropertyName_End, start)))
					);

		    if (!pHasRightToSeeAllEmployeeAppointments)
		    {
			    criteria.Add(Restrictions.Eq(AbsenceTime.PropertyName_EmployeeOid, pEmployeeOid));
		    }

			return criteria.List<AbsenceTime>();
	    }

	    public IEnumerable<TextModule> GetActiveTextModules(bool pShouldOnlyLoadOwnTextModules, bool pHasRightToSeeAll, bool pIsInAdministrationView, long pEmployeeOid)
	    {
		    var criteria = CreateCriteria<TextModule>();

	        if(pIsInAdministrationView)
	        {
	            criteria.Add(Restrictions.Eq(nameof(TextModule.IsOnlyForEmployee), false));
            }
	        else if(!pHasRightToSeeAll)
	        {
	            criteria.Add(Restrictions.Eq(nameof(TextModule.IsOnlyForEmployee), true))
	                .Add(Restrictions.Eq(nameof(TextModule.Employee) + "." + nameof(BeWoEntityBase.Oid), pEmployeeOid));
            }
	        else
	        {
	            criteria.Add(
	                Restrictions.Or(
	                    Restrictions.And(
	                        Restrictions.Eq(nameof(TextModule.IsOnlyForEmployee), true),
	                        Restrictions.Eq(nameof(TextModule.Employee) + "." + nameof(BeWoEntityBase.Oid), pEmployeeOid)),
	                    Restrictions.Eq(nameof(TextModule.IsOnlyForEmployee), false)));
            }
	        
            return criteria.List<TextModule>();
	    }

        public IEnumerable<TextModule> GetChildTextModules(TextModule textModule)
        {
            var criteria = CreateCriteria<TextModule>();

            criteria.Add(Restrictions.Eq(nameof(TextModule.Parent), textModule));
            
            return criteria.List<TextModule>();
        }

        public IEnumerable<ChatBewoMessageSync> FindEmployeeChatBewoMessageSync(long oid)
        {
            var c = CreateCriteriaIsActive<ChatBewoMessageSync>()
                .Add(Restrictions.Eq(ChatBewoMessageSync.PropertyName_EmployeeOid, oid));

            return c.List<ChatBewoMessageSync>();
        }

        public IList<Customer2Person> FindCustomerPersonRelationsForPerson(long personOid)
        {
            var c = CreateCriteriaIsActive<Customer2Person>()
                .CreateCriteria(Customer2Person.PropertyName_Person, JoinType.InnerJoin)
                .Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, personOid));

            return c.List<Customer2Person>();
        }

        public IList<SchedulerAppointment> LoadFilteredAppointments(bool pHasRightToSeeAllEmployeeAppointments, long pEmployeeOid, DateTime pIntervalStart, DateTime pIntervalEnd, List<long> pSelectedEmployees, List<long> pSelectedCustomers, List<long> pSelectedResources, bool pEmployeesOnly, bool pCustomersOnly, bool pResourcesOnly, bool pPrivateAppointmentsOnly, bool pOnlyMyAppointments, bool pIncludeInactiveOnes)
        {
            var recurrenceBetween = Format("'{0:yyyy-MM-dd} 00:00:00' BETWEEN STR_TO_DATE(SUBSTRING({1}, 24, 19), '%m/%d/%Y %H:%i:%s') AND STR_TO_DATE(SUBSTRING({1}, 50, 19), '%m/%d/%Y %H:%i:%s')", pIntervalStart, SchedulerAppointment.PropertyName_RecurrenceInfo);

            var criteria = CreateCriteria<SchedulerAppointment>();

            if(!pIncludeInactiveOnes)
            {
                criteria.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active));
            }
            
            criteria.Add(Restrictions.Or(
                    Restrictions.And(Restrictions.Not(Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, "Range", MatchMode.Anywhere)),
                        Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, "OccurrenceCount=\"10\"", MatchMode.Anywhere)),
                    Restrictions.Or(
                        Restrictions.Or(
                            Restrictions.And(Restrictions.Lt(SchedulerAppointment.PropertyName_StartDate, pIntervalEnd), Restrictions.Ge(SchedulerAppointment.PropertyName_EndDate, pIntervalStart)),
                            Restrictions.And(Restrictions.IsNotNull(SchedulerAppointment.PropertyName_RecurrenceInfo), Expression.Sql(new SqlString(recurrenceBetween)))),
                        Restrictions.And(Restrictions.Eq(SchedulerAppointment.PropertyName_Type, 3), Expression.Sql(new SqlString(recurrenceBetween))))));

            if(pPrivateAppointmentsOnly)
            {
                criteria.Add(Restrictions.Eq(SchedulerAppointment.PropertyName_IsPrivate, true));
            }
            else
            {
                if(pEmployeesOnly)
                {
                    var hasEmployees = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM employee2newschapp)";
                    criteria.Add(Expression.Sql(hasEmployees));
                }

                if(pCustomersOnly)
                {
                    var hasCustomers = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM customer2newschapp)";
                    criteria.Add(Expression.Sql(hasCustomers));
                }

                if(pResourcesOnly)
                {
                    var hasResources = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM resource2newschapp)";
                    criteria.Add(Expression.Sql(hasResources));
                }

                if(pSelectedEmployees.Any())
                {
                    var detachedCriteria1 = DetachedCriteria.For<Employee2SchedulerAppointment>()
                        .Add(Restrictions.In(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", pSelectedEmployees))
                        .SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment));
                    criteria.Add(Subqueries.PropertyIn(BeWoEntityBase.PropertyName_Oid, detachedCriteria1));
                }

                if(pSelectedCustomers.Any())
                {
                    var list = "";
                    for(var i = 0; i < pSelectedCustomers.Count; i++)
                    {
                        if(i != pSelectedCustomers.Count - 1)
                        {
                            list += "" + pSelectedCustomers[i] + ",";
                        }
                        else
                        {
                            list += "" + pSelectedCustomers[i];
                        }
                    }


                    var blah = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM customer2newschapp WHERE customeroid IN ({list}))";
                    criteria.Add(Expression.Sql(blah));
                }

                if(pSelectedResources.Any())
                {
                    var list = "";
                    for(var i = 0; i < pSelectedResources.Count; i++)
                    {
                        if(i != pSelectedResources.Count - 1)
                        {
                            list += "" + pSelectedResources[i] + ",";
                        }
                        else
                        {
                            list += "" + pSelectedResources[i];
                        }
                    }


                    var blah = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM resource2newschapp WHERE resourceoid IN ({list}))";
                    criteria.Add(Expression.Sql(blah));
                }
            }

            var test = criteria.List<SchedulerAppointment>().ToList();

            return criteria.List<SchedulerAppointment>();
        }

        public IEnumerable<SchedulerAppointment> LoadFilteredAppointmentsForEmployee(bool pHasRightToSeeAllEmployeeAppointments, long? pEmployeeOid, DateTime pIntervalStart, DateTime pIntervalEnd, List<long> pSelectedEmployees, List<long> pSelectedCustomers, List<long> pSelectedResources, bool pEmployeesOnly, bool pCustomersOnly, bool pResourcesOnly, bool pPrivateAppointmentsOnly, bool pOnlyMyAppointments, bool pIncludeInactiveOnes)
        {
            var mainCriteria = CreateRecurrenceCriteria(pIntervalStart, pIntervalEnd, pIncludeInactiveOnes);
            
            ICriterion ownAppointmentCriterion = null;
            ICriterion employeeCriterion = null;
            ICriterion customerCriterion = null;
            ICriterion resourceCriterion = null;

            if(pEmployeeOid.HasValue)
            {
                ownAppointmentCriterion = CreateOwnAppointmentsCriteria(pEmployeeOid.Value);
            }

            if(pPrivateAppointmentsOnly)
            {
                mainCriteria.Add(Restrictions.Eq(SchedulerAppointment.PropertyName_IsPrivate, true));
            }

            if(pEmployeesOnly)
            {
                var hasEmployees = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM employee2newschapp)";
                mainCriteria.Add(Expression.Sql(hasEmployees));
            }

            if(pCustomersOnly)
            {
                var hasCustomers = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM customer2newschapp)";
                mainCriteria.Add(Expression.Sql(hasCustomers));
            }

            if(pResourcesOnly)
            {
                var hasResources = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM resource2newschapp)";
                mainCriteria.Add(Expression.Sql(hasResources));
            }

            if(pSelectedEmployees.Any())
            {
                var detachedCriteria1 = DetachedCriteria.For<Employee2SchedulerAppointment>()
                    .Add(Restrictions.In(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", pSelectedEmployees))
                    .SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment));
                var employee2SchedCrit = Subqueries.PropertyIn(BeWoEntityBase.PropertyName_Oid, detachedCriteria1);

                var originatorCrit = Restrictions.In(SchedulerAppointment.PropertyName_Originator, pSelectedEmployees);
                //var notEmployee2SchedCrit = Subqueries.PropertyNotex(BeWoEntityBase.PropertyName_Oid, detachedCriteria1);

                //and not exists(
                //    SELECT
                //this_0_.Oid as y0_
                //FROM
                //    Employee2NewSchApp this_0_
                //    WHERE
                //this_0_.NewSchAppOid = this_.Oid
                //    )
                var detachedCriteria2 = DetachedCriteria.For<Employee2SchedulerAppointment>("e2s2")
                    .SetProjection(Projections.Property(BeWoEntityBase.PropertyName_Oid))
                    .Add(Restrictions.EqProperty("e2s2." + Employee2SchedulerAppointment.PropertyName_SchedulerAppointment, "sa.Oid"));
                //.Add(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment + ".Oid", mainCriteria.SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_Oid))));

                var employee2SchedCrit2 = Subqueries.NotExists(detachedCriteria2);
                
                var and = Restrictions.And(originatorCrit, employee2SchedCrit2);

                employeeCriterion = Restrictions.Or(employee2SchedCrit, and);
            }

            if(pSelectedCustomers.Any())
            {
                var list = "";
                for(var i = 0; i < pSelectedCustomers.Count; i++)
                {
                    if(i != pSelectedCustomers.Count - 1)
                    {
                        list += "" + pSelectedCustomers[i] + ",";
                    }
                    else
                    {
                        list += "" + pSelectedCustomers[i];
                    }
                }

                var blah = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM customer2newschapp WHERE customeroid IN ({list}))";
                customerCriterion = Expression.Sql(blah);
            }

            if(pSelectedResources.Any())
            {
                var list = "";
                for(var i = 0; i < pSelectedResources.Count; i++)
                {
                    if(i != pSelectedResources.Count - 1)
                    {
                        list += "" + pSelectedResources[i] + ",";
                    }
                    else
                    {
                        list += "" + pSelectedResources[i];
                    }
                }

                var blah = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM resource2newschapp WHERE resourceoid IN ({list}))";
                resourceCriterion = Expression.Sql(blah);
            }
            // AND {SchedulerAppointment.PropertyName_RecurrenceInfo} IS NOT NULL AND {SchedulerAppointment.PropertyName_RecurrenceInfo} NOT LIKE '%Index%'
            var listOfCriterias = new List<ICriterion>
            {
                employeeCriterion,
                customerCriterion,
                resourceCriterion
            };

            if(!pHasRightToSeeAllEmployeeAppointments && pSelectedEmployees.Count == 0)
            {
                mainCriteria.Add(ownAppointmentCriterion);
            }
            else
            {
                listOfCriterias.Add(ownAppointmentCriterion);
            }
            
            var orCriteria = CreateOrCriteria(listOfCriterias);

            if(orCriteria != null)
            {
                mainCriteria.Add(orCriteria);
            }

            var appointments = mainCriteria.List<SchedulerAppointment>();

            var exceptionalRecurrenceInfos = appointments.Where(w => w.RecurrenceInfo != null && w.Type == 3).ToList();
            
            var exceptionIds = new List<long>();
            
            foreach(var appointment in exceptionalRecurrenceInfos)
            {
                var match = RecurrenceIdRegex.Match(appointment.RecurrenceInfo);
                if(match.Success)
                {
                    var value = match.Value;
                    var actualId = value.Split("\"");
                    if(actualId.Count > 1)
                    {
                        var id = actualId[1];
                        
                        if(!appointments.Any(w => w.RecurrenceInfo != null && w.RecurrenceInfo.Contains(id) && w.Type == 1))
                        {
                            exceptionIds.Add(appointment.Oid.Value);
                        }
                    }
                }
            }

            // Serienausnahmen werden als gelöscht markiert und es wird die RecurrenceInfo entfernt.
            // Der Type wird auf "normal" gesetzt, damit nicht die ganze Serie angezeigt werden muss, die unter Umständen nichts mit den Filterkriterien zu tun hat.
            var exceptionsToModify = appointments.Where(w => w.Oid.HasValue && exceptionIds.Contains(w.Oid.Value)).ToList();

            foreach(var exception in exceptionsToModify)
            {
                var replacingAppointment = new SchedulerAppointment
                {
                    Oid = exception.Oid.Value * -1,
                    Version = 1,
                    Type = 4,
                    RecurrenceInfo = exception.RecurrenceInfo,
                    Originator = exception.Originator,
                    EmployeeList = exception.EmployeeList,
                    CustomerList = exception.CustomerList,
                    ResourceList = exception.ResourceList
                };

                exception.RecurrenceInfo = null;
                exception.Type = 0;

                appointments.Add(replacingAppointment);
            }
            
            // Wenn ein Serientermin bearbeitet wird, sodass er außerhalb des Fetch-Zeitraumes liegt, wird er nicht mehr korrekt angezeigt.
            // Deshalb werden hier alle Ausnahmen von den in der appointments-Collection enthaltenen Terminen mitgeladen.
            var allExceptionalRecurrenceInfos = appointments.Where(w => w.RecurrenceInfo != null);
            
            var changedOrDeletedOccurences = FindAppointmentsByRecurrenceId(ExtractRecurrenceIdFromRecurrenceInfo(allExceptionalRecurrenceInfos.Select(s => s.RecurrenceInfo).ToList()), true);

            appointments.AddRangeIfElementsNotIn(changedOrDeletedOccurences);

            return appointments;
        }

        private static ICriterion CreateOrCriteria(IReadOnlyCollection<ICriterion> criterionList)
        {
            ICriterion orCriterion = null;

            if (criterionList != null && criterionList.Count > 0)
            {
                foreach (var c in criterionList)
                {
                    if (c != null)
                    {
                        orCriterion = orCriterion == null ? c : Restrictions.Or(orCriterion, c);
                    }
                }
            }

            return orCriterion;
        }

        private static ICriterion CreateOwnAppointmentsCriteria(long pEmployeeOid)
        {
            var detachedCriteria = DetachedCriteria.For<Employee2SchedulerAppointment>()
                .Add(Restrictions.And(
                    Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", pEmployeeOid),
                    Restrictions.Not(Restrictions.Eq(Employee2SchedulerAppointment.PropertyName_ParticipationAnswer,
                        ParticipationAnswer.Absage))));
            detachedCriteria.SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment));

            var detachedCriteria2 = DetachedCriteria.For<Employee2SchedulerAppointment>()
                .SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment));

            ICriterion ownAppointmentCriterion = Restrictions.Or(
                //Restrictions.And(Restrictions.Eq(SchedulerAppointment.PropertyName_Originator + ".Oid", pEmployeeOid), Subqueries.PropertyNotIn(BeWoEntityBase.PropertyName_Oid, detachedCriteria2)),
                Restrictions.Eq(SchedulerAppointment.PropertyName_Originator + ".Oid", pEmployeeOid),
                Subqueries.PropertyIn(BeWoEntityBase.PropertyName_Oid, detachedCriteria));

            
            return ownAppointmentCriterion;
        }

        private ICriteria CreateRecurrenceCriteria(DateTime start, DateTime end, bool pIncludeInactiveOnes = false)
        {
            var recurrenceBetween = Format("'{0:yyyy-MM-dd} 00:00:00' BETWEEN STR_TO_DATE(SUBSTRING({1}, 24, 19), '%m/%d/%Y %H:%i:%s') AND STR_TO_DATE(SUBSTRING({1}, 50, 19), '%m/%d/%Y %H:%i:%s')", start, SchedulerAppointment.PropertyName_RecurrenceInfo);
            var recurrenceAfter = $"'{start:yyyy-MM-dd} 00:00:00' > STR_TO_DATE(SUBSTRING({SchedulerAppointment.PropertyName_RecurrenceInfo}, 24, 19), '%m/%d/%Y %H:%i:%s')";

            var criteria = CreateCriteria<SchedulerAppointment>("sa");

            if(!pIncludeInactiveOnes)
            {
                criteria.Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active));
            }
            
            criteria.Add(Restrictions.Or(
                    Restrictions.And(
                        Restrictions.Not(Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, "Range", MatchMode.Anywhere)),
                        Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, "OccurrenceCount=\"10\"", MatchMode.Anywhere)),
                    Restrictions.Or(
                        Restrictions.Or(
                            Restrictions.And(Restrictions.Lt(SchedulerAppointment.PropertyName_StartDate, end), Restrictions.Ge(SchedulerAppointment.PropertyName_EndDate, start)),
                            Restrictions.Or(Restrictions.And(
                                Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, "End", MatchMode.Anywhere),
                                Restrictions.And(Restrictions.IsNotNull(SchedulerAppointment.PropertyName_RecurrenceInfo), Expression.Sql(new SqlString(recurrenceBetween)))
                            ), Restrictions.And(
                                    Restrictions.And(
                                            Restrictions.IsNotNull(SchedulerAppointment.PropertyName_RecurrenceInfo), 
                                            Restrictions.Not(Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, "End", MatchMode.Anywhere))),
                                    Expression.Sql(recurrenceAfter)))
                        ),
                        Restrictions.And(Restrictions.Eq(SchedulerAppointment.PropertyName_Type, 3), Expression.Sql(new SqlString(recurrenceBetween))))));

            return criteria;
        }

        public IList<SchedulerAppointment> FindDeletedRecurrencesByRecurrenceId(string pRecurrenceId)
        {
            var c = CreateCriteria<SchedulerAppointment>()
                .Add(Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, pRecurrenceId, MatchMode.Anywhere))
                .Add(Restrictions.Eq(SchedulerAppointment.PropertyName_Type, 4));

            return c.List<SchedulerAppointment>();
        }

        public IList<SchedulerAppointment> FindAppointmentsByRecurrenecInfo(List<string> pRecurrenceInfos, bool pExcludeRootAppointments = false)
        {
            if(pRecurrenceInfos == null || pRecurrenceInfos.Count == 0)
            {
                return new List<SchedulerAppointment>();
            }

            return FindAppointmentsByRecurrenceId(ExtractRecurrenceIdFromRecurrenceInfo(pRecurrenceInfos), pExcludeRootAppointments);
        }
        
        public IList<SchedulerAppointment> FindAppointmentsByRecurrenceId(List<string> pRecurrenceIds, bool pExcludeRootAppointments = false)
        {
            if (pRecurrenceIds == null || pRecurrenceIds.Count == 0)
            {
                return new List<SchedulerAppointment>();
            }
            
            var criterionList = new List<ICriterion>();

            pRecurrenceIds.DoForEach(id =>
            {
                criterionList.AddIfNotIn(Restrictions.Like(SchedulerAppointment.PropertyName_RecurrenceInfo, id, MatchMode.Anywhere));
            });

            var recurrenceIdOr = CreateOrCriteria(criterionList);
            if (recurrenceIdOr == null)
            {
                return new List<SchedulerAppointment>(); ;
            }
            var c = CreateCriteria<SchedulerAppointment>()
                .Add(Restrictions.Eq(BeWoEntityBase.PropertyName_IsActive, ActivationTypeId.Active))
                .Add(Restrictions.IsNotNull(SchedulerAppointment.PropertyName_RecurrenceInfo))
                .Add(recurrenceIdOr);

            if(pExcludeRootAppointments)
            {
                c.Add(Restrictions.In(nameof(Appointment.Type), new []{ 2, 3, 4}));
            }
            
            return c.List<SchedulerAppointment>();
        }

        public SchedulerAppointment FindRootAppointmentByRecurrenceId(string recurrenceId)
        {
            if(Guid.TryParse(recurrenceId, out var guid))
            {
                var criteria = CreateCriteria<SchedulerAppointment>()
                    .Add(Restrictions.Like(nameof(SchedulerAppointment.RecurrenceInfo), recurrenceId, MatchMode.Anywhere))
                    .Add(Restrictions.Eq(nameof(Appointment.Type), 1));

                return criteria.List<SchedulerAppointment>().FirstOrDefault();
            }

            return null;
        }

        public IList<SchedulerAppointment> FindAppointmentsForCustomer(long pCustomerOid)
        {
            var blah = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM customer2newschapp WHERE customeroid IN ({pCustomerOid}))";
            var customerCriterion = Expression.Sql(blah);

            var c = CreateCriteria<SchedulerAppointment>().Add(customerCriterion);
            
            return c.List<SchedulerAppointment>();
        }

        public IList<GroupOfPeople> GroupOfPeopleForSupportConcept(long pCostBearer2SupportConceptOid)
        {
            var c = CreateCriteria<GroupOfPeople>();

                c.CreateCriteria(GroupOfPeople.PropertyName_CostBearer2SupportConceptList, JoinType.InnerJoin)
                .Add(Restrictions.Eq(BeWoEntityBase.PropertyName_Oid, pCostBearer2SupportConceptOid));

            return c.List<GroupOfPeople>();
        }

        public IList<CostRatePeriod> FindDefaultHourlyRateCostRatePeriods()
        {
            var c = CreateCriteria<CostRatePeriod>();

            c.Add(Restrictions.Eq(CostRatePeriod.PropertyName_CostRateType, CostRatePeriodType.HourlyRate))
                .Add(Restrictions.IsNull(CostRatePeriod.PropertyName_ObjectOid));

            return c.List<CostRatePeriod>();
        }

        public virtual IList GetSqlResult(string sql)
        {
            var q = Session.CreateSQLQuery(sql);
            return q.List();
            
        }

        public SchedulerAppointment FindRootAppointmentForException(SchedulerAppointmentDC pAppointment)
        {
            if(pAppointment?.RecurrenceInfo == null)
            {
                return null;
            }
            
            var match = RecurrenceIdRegex.Match(pAppointment.RecurrenceInfo);
            if(match.Success)
            {
                var value = match.Value;
                var actualId = value.Split("\"");
                if(actualId.Count > 1)
                {
                    var id = actualId[1];

                    var criteria = CreateCriteria<SchedulerAppointment>()
                        .Add(Restrictions.IsNotNull(nameof(SchedulerAppointment.RecurrenceInfo)))
                        .Add(Restrictions.Like(nameof(SchedulerAppointment.RecurrenceInfo), id, MatchMode.Anywhere))
                        .Add(Restrictions.Eq(nameof(Appointment.Type), 1));

                    var resultList = criteria.List<SchedulerAppointment>();

                    if(resultList == null || resultList.Count == 0)
                    {
                        return null;
                    }

                    return resultList.First();
                }
            }

            return null;
        }

        public SchedulerAppointment FindRootAppointmentForException(SchedulerAppointment pAppointment)
        {
            if(pAppointment?.RecurrenceInfo == null)
            {
                return null;
            }

            var match = RecurrenceIdRegex.Match(pAppointment.RecurrenceInfo);
            if(match.Success)
            {
                var value = match.Value;
                var actualId = value.Split("\"");
                if(actualId.Count > 1)
                {
                    var id = actualId[1];

                    var criteria = CreateCriteria<SchedulerAppointment>()
                        .Add(Restrictions.IsNotNull(nameof(SchedulerAppointment.RecurrenceInfo)))
                        .Add(Restrictions.Like(nameof(SchedulerAppointment.RecurrenceInfo), id, MatchMode.Anywhere))
                        .Add(Restrictions.Eq(nameof(Appointment.Type), 1));

                    var resultList = criteria.List<SchedulerAppointment>();

                    if(resultList == null || resultList.Count == 0)
                    {
                        return null;
                    }

                    return resultList.First();
                }
            }

            return null;
        }

        private static List<string> ExtractRecurrenceIdFromRecurrenceInfo(List<string> pRecurrenceInfos)
        {
            var recurrenceIds = new List<string>();

            foreach(var info in pRecurrenceInfos)
            {
                var match = RecurrenceIdRegex.Match(info);
                if(match.Success)
                {
                    var value = match.Value;
                    var actualId = value.Split("\"");
                    if(actualId.Count > 1)
                    {
                        recurrenceIds.AddIfNotIn(actualId[1]);
                    }
                }
            }

            return recurrenceIds;
        }

        public IList<Task> LoadTasksForConversion(long pEmployeeOid)
        {
            var c = CreateCriteriaIsActive<Task>();

            c.Add(Expression.Sql($"this_.{nameof(BeWoEntityBase.Oid)} NOT IN (SELECT {nameof(SchedulerAppointment.FormerTaskOid)} FROM newschedulerappointment WHERE {nameof(SchedulerAppointment.FormerTaskOid)} IS NOT NULL)"));
            
            var result = c.CreateAlias(nameof(Task.SupportConcept), "sc", JoinType.InnerJoin)
                .CreateAlias("sc." + nameof(SupportConcept.Customer), "c", JoinType.InnerJoin)
                .CreateCriteria(nameof(Task.EmployeeList), JoinType.InnerJoin)
                .Add(Restrictions.Eq(nameof(BeWoEntityBase.Oid), pEmployeeOid))
                .Add(Restrictions.Eq("sc." + nameof(BeWoEntityBase.IsActive), ActivationTypeId.Active))
                .Add(Restrictions.Eq("c." + nameof(BeWoEntityBase.IsActive), ActivationTypeId.Active))
                .List<Task>();

            return result;
        }

        public IList<SchedulerAppointment> LoadTaskAppointmentsForEmployee(long pEmployee, bool hideCompletedTasks)
        {
            var c = CreateCriteriaIsActive<SchedulerAppointment>()
                .Add(Restrictions.Eq(nameof(SchedulerAppointment.IsTask), true));

            if (hideCompletedTasks)
            {
                c.Add(Restrictions.IsNull(nameof(SchedulerAppointment.CompletedDate)));
            }

            var employeeListRelationCriteria = DetachedCriteria.For<Employee2SchedulerAppointment>()
                .Add(Restrictions.In(Employee2SchedulerAppointment.PropertyName_Employee + ".Oid", new List<long> { pEmployee }))
                .SetProjection(Projections.Property(Employee2SchedulerAppointment.PropertyName_SchedulerAppointment));
            
            var employee2SchedCrit = Subqueries.PropertyIn(BeWoEntityBase.PropertyName_Oid, employeeListRelationCriteria);

            c.Add(employee2SchedCrit);
            
            var result = c.List<SchedulerAppointment>();

            return result;
        }

        public IList<SchedulerAppointment> GetTasksForEmployeeBySupportConcept(long pEmployeeOid, long pSupportConceptOid)
        {
            var c = CreateCriteriaIsActive<SchedulerAppointment>();

            var employeeListRelationCriteria = DetachedCriteria.For<Employee2SchedulerAppointment>()
                .Add(Restrictions.In(nameof(Employee2SchedulerAppointment.Employee) + ".Oid", new List<long> {pEmployeeOid}))
                .SetProjection(Projections.Property(nameof(Employee2SchedulerAppointment.SchedulerAppointmentOid)));

            var employee2SchedCrit = Subqueries.PropertyIn(nameof(BeWoEntityBase.Oid), employeeListRelationCriteria);
            
            c.Add(employee2SchedCrit);

            var sql = Expression.Sql($"{nameof(BeWoEntityBase.Oid)} IN (SELECT newschappoid FROM supportconcept2newschapp WHERE supportconceptoid = {pSupportConceptOid})");

            c.Add(sql);
            
            return c.List<SchedulerAppointment>();
        }

        public IList<InvoiceBase> GetInvoiceBasesBySupportConceptOids(List<long> pSupprortConceptOids)
        {
            var c = CreateCriteria<InvoiceBase>();

            c.Add(Restrictions.In(nameof(InvoiceBase.SupportConceptOid), pSupprortConceptOids));

            return c.List<InvoiceBase>();
        }

        public IEnumerable<SettlementInvoice> GetSettlementInvoiceBySupportConceptOids(List<long> pSupportConceptOids)
        {
            return CreateCriteria<SettlementInvoice>()
                .CreateAlias(SettlementInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
                .Add(Restrictions.In("ib." + InvoiceBase.PropertyName_SupportConceptOid, pSupportConceptOids))
                .List<SettlementInvoice>();
        }

        public IList<ServiceInvoice> GetServiceInvoicesByInvoiceBaseOids(List<long> pIinvoiceBaseOids)
        {
            var res = CreateCriteria<ServiceInvoice>()
                .CreateAlias(ServiceInvoice.PropertyName_InvoiceBase, "ib", JoinType.InnerJoin)
                .Add(Restrictions.In("ib." + BeWoEntityBase.PropertyName_Oid, pIinvoiceBaseOids))
                .List<ServiceInvoice>();

            return res;
        }

        public IList<AdditionalServiceBooking> GetAllAdditionalServiceBookingsForCustomer(long pCustomerOid)
        {
            return CreateCriteria<AdditionalServiceBooking>()
                .CreateAlias(AdditionalServiceBooking.PropertyName_Customer2AddServiceBookings, "c2s", JoinType.InnerJoin)
                .Add(Restrictions.Eq("c2s.CustomerOid", pCustomerOid))
                .List<AdditionalServiceBooking>();
        }

        public IList<AdditionalServiceGroupOfPeople> GetAdditionalServiceGroupOfPeopleForCustomer(long pCustomerOid)
        {
            var c = CreateCriteria<AdditionalServiceGroupOfPeople>();

            c.CreateCriteria(nameof(AdditionalServiceGroupOfPeople.CustomerList), JoinType.InnerJoin)
                .Add(Restrictions.Eq(nameof(BeWoEntityBase.Oid), pCustomerOid));

            return c.List<AdditionalServiceGroupOfPeople>();
        }

        public IList<SchedulerAppointment> GetTasksAndAppointmentsBySupportConceptOids(List<long> pSupportConceptOids)
        {
            var c = CreateCriteria<SchedulerAppointment>();

            var list = "";
            for (var i = 0; i < pSupportConceptOids.Count; i++)
            {
                if (i != pSupportConceptOids.Count - 1)
                {
                    list += "" + pSupportConceptOids[i] + ",";
                }
                else
                {
                    list += "" + pSupportConceptOids[i];
                }
            }

            var blah = $"{nameof(BeWoEntityBase.Oid)} IN (SELECT newschappoid FROM supportconcept2newschapp WHERE supportconceptoid IN ({list}))";
            var supportConceptCriterion = Expression.Sql(blah);

            c.Add(supportConceptCriterion);

            return c.List<SchedulerAppointment>();
        }

        public IList<Customer2Token> GetCustomer2TokensByCustomerOid(long pCustomerOid)
        {
            var c = CreateCriteria<Customer2Token>();

            c.Add(Restrictions.Eq(nameof(Customer2Token.Customer) + "." + nameof(BeWoEntityBase.Oid), pCustomerOid));

            return c.List<Customer2Token>();
        }

        public IList<SchedulerAppointment> GetTestAppointments()
        {
            var c = CreateCriteria<SchedulerAppointment>();

            c.Add(Restrictions.Eq(nameof(BeWoEntityBase.Notice), Utils.TestAppointmentNotice));

            return c.List<SchedulerAppointment>();
        }

        public bool CheckForOverlappingSubstitutions(long? employeeOid, long? customerOid, DateTime startDate, DateTime endDate, long? substitutionOid)
        {
            var c = CreateCriteria<Vertretung>();

            var employeeRestriction = Restrictions.Eq(nameof(Vertretung.EmployeeOid), employeeOid);
            var customerRestriction = Restrictions.Eq(nameof(Vertretung.CustomerOid), customerOid);

            var notCurrentSubstitution = Restrictions.Not(Restrictions.Eq(nameof(BeWoEntityBase.Oid), substitutionOid));

            var peopleRestriction = Restrictions.Or(employeeRestriction, customerRestriction);
            var timeRestriction = CreateBetweenDateTimesCriterion(startDate, endDate, nameof(Vertretung.VertretungsZeitraumVon), nameof(Vertretung.VertretungsZeitraumBis));

            c.Add(peopleRestriction).Add(timeRestriction).Add(notCurrentSubstitution);

            return c.List<Vertretung>().Any();
        }

        private static AbstractCriterion CreateBetweenDateTimesCriterion(DateTime start, DateTime end, string propertyNameStart, string propertyNameEnd)
        {
            /* -- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET --
             * Sql für Spalten namens 'StartDate' und 'EndDate':
             * WHERE
             *      ((start >= StartDate AND end <= StartDate) OR (start <= StartDate AND end >= EndDate))
             *      OR
             *      ((start <= StartDate AND start >= EndDate) OR (start >= StartDate AND end <= EndDate))
             */

            //var inBetween1 = Restrictions.And(Restrictions.Ge(propertyNameStart, start), Restrictions.Le(propertyNameStart, end));
            //var inBetween2 = Restrictions.And(Restrictions.Le(propertyNameStart, start), Restrictions.Ge(propertyNameEnd, end));
            //var inBetween3 = Restrictions.And(Restrictions.Le(propertyNameStart, start), Restrictions.Ge(propertyNameEnd, start));
            //var inBetween4 = Restrictions.And(Restrictions.Ge(propertyNameStart, start), Restrictions.Le(propertyNameEnd, end));

            //return Restrictions.Or(Restrictions.Or(inBetween1, inBetween2), Restrictions.Or(inBetween3, inBetween4));
            // -- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET ----- VERALTET --

            // NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU
            /* Sql für Spalten namens 'StartDate' und 'EndDate':
             *  (StartDate < '2020-11-19 10:00:00' AND EndDate <= '2020-11-19 12:00:00' AND EndDate > '2020-11-19 10:00:00')
                OR
                (StartDate < '2020-11-19 10:00:00' AND EndDate > '2020-11-19 12:00:00')
                OR
                (StartDate > '2020-11-19 10:00:00' AND StartDate < '2020-11-19 12:00:00')
                OR
                (StartDate = '2020-11-19 10:00:00' AND EndDate = '2020-11-19 12:00:00')
                OR
                (StartDate = '2020-11-19 10:00:00' AND EndDate >= '2020-11-19 12:00:00')
             */
            // NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU -- NEU

            var inBetween1 = Restrictions.And(Restrictions.Lt(propertyNameStart, start), Restrictions.And(Restrictions.Le(propertyNameEnd, end), Restrictions.Gt(propertyNameEnd, start)));
            var inBetween2 = Restrictions.And(Restrictions.Lt(propertyNameStart, start), Restrictions.Gt(propertyNameEnd, end));
            var inBetween3 = Restrictions.And(Restrictions.Gt(propertyNameStart, start), Restrictions.Lt(propertyNameStart, end));
            var inBetween4 = Restrictions.And(Restrictions.Eq(propertyNameStart, start), Restrictions.Eq(propertyNameEnd, end));
            var inBetween5 = Restrictions.And(Restrictions.Eq(propertyNameStart, start), Restrictions.Le(propertyNameEnd, end));

            return Restrictions.Or(inBetween1, Restrictions.Or(Restrictions.Or(inBetween2, inBetween3), Restrictions.Or(inBetween4, inBetween5)));
        }

        public bool CheckForOverlappingAbsenceTimes(DateTime startDate, DateTime endDate, long? employeeOid, long? customerOid)
        {
            var c = CreateCriteria<AbsenceTime>();

            var peopleRestriction = employeeOid != null ? Restrictions.Eq(nameof(AbsenceTime.EmployeeOid), employeeOid) : Restrictions.Eq(nameof(AbsenceTime.CustomerOid), customerOid);

            var timeRestriction = CreateBetweenDateTimesCriterion(startDate, endDate, nameof(AbsenceTime.Start), nameof(AbsenceTime.End));

            c.Add(peopleRestriction).Add(timeRestriction);

            return c.List<AbsenceTime>().Any();
        }

        public IList<Vertretung> GetLastSubstitutionItems(long employeeOid, int count)
        {
            var criteria = CreateCriteria<Vertretung>();

            criteria.Add(Restrictions.Eq(nameof(Vertretung.EmployeeOid), employeeOid));

            criteria.AddOrder(Order.Desc(nameof(Vertretung.VertretungsZeitraumBis)));

            criteria.SetMaxResults(count);

            return criteria.List<Vertretung>().Where(w => w.VertretungsZeitraumVon > DateTime.MinValue && w.VertretungsZeitraumBis > DateTime.MinValue).ToList();
        }

        public Dictionary<Customer, List<ArbeitszeitEintrag>> GetAssistanceTimesForEmployee(long employeeOid, DateTime start, DateTime end)
        {
            // Arbeitszeit -> keine EmployeeOid, nur in den Arbeitszeiteinträgen

            var criteria = CreateCriteria<Arbeitszeit>();

            var detachedCriteria = DetachedCriteria.For<ArbeitszeitEintrag>().Add(Restrictions.Eq(nameof(ArbeitszeitEintrag.Employee) + ".Oid", employeeOid)).SetProjection(Projections.Property(nameof(ArbeitszeitEintrag.ArbeitszeitOid)));

            var subquery = Subqueries.PropertyIn(nameof(BeWoEntityBase.Oid), detachedCriteria);

            criteria.Add(subquery);

            criteria.Add(CreateArbeitszeitenTimeRestictions(start, end));

            var assistanceTimes = criteria.List<Arbeitszeit>();

            var result = new Dictionary<Customer, List<ArbeitszeitEintrag>>();

            foreach(var assistanceTimeEntry in assistanceTimes)
            {
                if(assistanceTimeEntry.Customer != null)
                {
                    result.AddOrUpdateValueInDictionary(assistanceTimeEntry.Customer, assistanceTimeEntry.ArbeitszeitEintraege.ToList());
                }
            }

            return result;
        }

        private ICriterion CreateArbeitszeitenTimeRestictions(DateTime start, DateTime end)
        {
            // GueltigVon und GueltigBis sind null
            var gueltigVonAndGueltigBisAreNull = Restrictions.And(Restrictions.IsNull(nameof(Arbeitszeit.GueltigVon)), Restrictions.IsNull(nameof(Arbeitszeit.GueltigBis)));

            // GueltigVon ist null, GueltigBis ist nicht null
            var gueltigVonIsNullAndGueltigBisIsGtStart = Restrictions.And(Restrictions.And(Restrictions.IsNull(nameof(Arbeitszeit.GueltigVon)), Restrictions.Gt(nameof(Arbeitszeit.GueltigBis), start)), Restrictions.And(Restrictions.IsNull(nameof(Arbeitszeit.GueltigVon)), Restrictions.Ge(nameof(Arbeitszeit.GueltigBis), start)));

            // GueltigVon ist nicht null, GueltigBis ist null
            var gueltigBisIsNullAndGueltigVonIsLtEnd = Restrictions.And(Restrictions.IsNotNull(nameof(Arbeitszeit.GueltigVon)), Restrictions.And(Restrictions.IsNull(nameof(Arbeitszeit.GueltigBis)), Restrictions.Gt(nameof(Arbeitszeit.GueltigVon), end)));

            var and1 = Restrictions.And(Restrictions.IsNotNull(nameof(Arbeitszeit.GueltigVon)), Restrictions.IsNotNull(nameof(Arbeitszeit.GueltigBis)));
            var and3 = Restrictions.And(Restrictions.Le(nameof(Arbeitszeit.GueltigVon), start), Restrictions.Ge(nameof(Arbeitszeit.GueltigBis), start));
            var and4 = Restrictions.And(Restrictions.Le(nameof(Arbeitszeit.GueltigVon), end), Restrictions.Gt(nameof(Arbeitszeit.GueltigBis), end));
            var and5 = Restrictions.And(Restrictions.Ge(nameof(Arbeitszeit.GueltigVon), start), Restrictions.Le(nameof(Arbeitszeit.GueltigBis), end));

            var or1 = Restrictions.Or(and4, and5);
            var or2 = Restrictions.Or(and3, or1);

            // GueltigVon und GueltigBis sind nicht null
            var gueltigVonAndGueltigBisAreNotNull = Restrictions.And(and1, or2);

            return Restrictions.Or(gueltigVonAndGueltigBisAreNull, Restrictions.Or(Restrictions.Or(gueltigVonIsNullAndGueltigBisIsGtStart, gueltigBisIsNullAndGueltigVonIsLtEnd), gueltigVonAndGueltigBisAreNotNull));
        }

        public IList<Customer> GetCustomersWithSubstitutionNeedUnset()
        {
            var c = CreateCriteria<Customer>();

            c.Add(Restrictions.IsNull(nameof(Customer.SubstitutionNeed)));

            return c.List<Customer>();
        }

        public List<long> FindTeamRelatedCustomerOids(long employeeOid)
        {
            var result = new List<long>();

            var teams = CreateCriteriaIsActive<Team>()
                .Add(Restrictions.IsNotNull(nameof(BeWoEntityBase.Oid)))
                .CreateCriteria(nameof(Team.MemberList), JoinType.InnerJoin)
                .Add(Restrictions.Eq(nameof(BeWoEntityBase.Oid), employeeOid))
                .List<Team>();

            var members = new List<Employee>();

            foreach(var team in teams)
            {
                members.AddRangeIfElementsNotIn(team.MemberList);
            }

            foreach(var member in members)
            {
                foreach(var employee2customer in member.Employee2CustomerList)
                {
                    if(employee2customer.CustomerOid.HasValue)
                    {
                        result.AddIfNotIn(employee2customer.CustomerOid.Value);
                    }
                }
            }

            return result;
        }

        public List<Customer> FindCustomersForAbsenceTimesByStartAndEnd(DateTime intervalStart, DateTime intervalEnd)
        {
            var criteria = CreateCriteriaIsActive<Customer>();
            // Arbeitszeiten im gewählten Intervall holen und dann die einträge nach customeroid durchsuchen
            // TODO: implementieren

            return criteria.List<Customer>().ToList();
        }

        public List<CostBearer2SupportConcept> FindCostBearer2SupportConceptsByOids(List<long> costbearer2SupportConceptOids)
        {
            var c = CreateCriteriaIsActive<CostBearer2SupportConcept>();
            
            c.Add(Restrictions.In(nameof(CostBearer2SupportConcept.Oid), costbearer2SupportConceptOids));

            return c.List<CostBearer2SupportConcept>().ToList();
        }

        public bool IsResourceAvailable(DateTime start, DateTime end, long resourceOid)
        {
            var c = CreateCriteriaIsActive<Resource>();

            var sql = $"SELECT COUNT(*) FROM resource WHERE oid = {resourceOid} AND isactive = 1 AND oid NOT IN (SELECT resourceoid FROM resource2newschapp r WHERE r.newschappoid NOT IN (SELECT oid FROM newschedulerappointment WHERE startdate > '{start:yyyy-MM-dd HH:mm:ss}' OR enddate < '{end:yyyy-MM-dd HH:mm:ss}'));";

            var criterion = Expression.Sql(sql);

            c.Add(criterion);

            return c.List().Count > 0;
        }

        public List<Resource> GetAvailableResources(DateTime start, DateTime end)
        {
            var c = CreateCriteria<Resource>("r").Add(Restrictions.Eq(nameof(BeWoEntityBase.IsActive), ActivationTypeId.Active));

            var sql = $"Oid NOT IN (SELECT Oid FROM resource WHERE isactive = 1 AND Oid NOT IN (SELECT resourceoid FROM resource2newschapp r2n WHERE r2n.newschappoid NOT IN (SELECT oid FROM newschedulerappointment WHERE startdate > '{start:yyyy-MM-dd HH:mm:ss}' OR enddate < '{end:yyyy-MM-dd HH:mm:ss}')))";

            var criterion = Expression.Sql(sql);

            c.Add(criterion);

            return c.List<Resource>().ToList();
        }

        /// <summary>
        /// Prüft anhand der Oids von Ressourcen deren Verfügbarkeit in einem Zeitraum.
        /// Gibt die nicht verfügbaren Ressourcen zurück für eine detaillierte Fehlermeldung.
        /// </summary>
        /// <param name="resourceOids">Die Oids der zu überprüfenden Ressourcen</param>
        /// <returns>test</returns>
        public List<Resource> CheckAvailabilityOfResources(List<long> resourceOids, DateTime start, DateTime end, long? selectedAppointmentOid)
        {
            var c = CreateCriteria<Resource>("r").Add(Restrictions.Eq(nameof(BeWoEntityBase.IsActive), ActivationTypeId.Active)).Add(Restrictions.In(nameof(BeWoEntityBase.Oid), resourceOids));

            var excludingSelectedAppointment = selectedAppointmentOid.HasValue ? $"oid <> {selectedAppointmentOid} AND " : "";

            var sql = "Oid IN " +
                        "(SELECT resourceoid FROM resource2newschapp r2n WHERE r2n.newschappoid IN " +
                            $"(SELECT oid FROM newschedulerappointment WHERE IsActive = 1 AND {excludingSelectedAppointment}('{start:yyyy-MM-dd HH:mm:ss}' > startdate OR '{end:yyyy-MM-dd HH:mm:ss}' > startdate) AND ('{start:yyyy-MM-dd HH:mm:ss}' < enddate OR '{end:yyyy-MM-dd HH:mm:ss}' < enddate)))";

            var criterion = Expression.Sql(sql);

            c.Add(criterion);
            
            var resources = c.List<Resource>().ToList();

            // TODO: Serien in dem Zeitraum erzeugen
            var recurringAppointmentsCriteria = CreateRecurrenceCriteria(start, end).Add(Restrictions.Eq(nameof(SchedulerAppointment.Type), 1));

            var recurringAppointments = recurringAppointmentsCriteria.List<SchedulerAppointment>().ToList();
            recurringAppointments = recurringAppointments.Where(s => s.ResourceList.Any(r => r.Oid.HasValue && resourceOids.Contains(r.Oid.Value))).ToList();

            var changedOccurrencesCriteria = CreateCriteriaIsActive<SchedulerAppointment>().Add(Restrictions.Eq(nameof(SchedulerAppointment.Type), 3));
            var deletedOccurrencesCriteria = CreateCriteria<SchedulerAppointment>().Add(Restrictions.Eq(nameof(SchedulerAppointment.Type), 4));

            var inBetween = CreateBetweenDateTimesCriterion(start, end, nameof(SchedulerAppointment.StartDate), nameof(SchedulerAppointment.EndDate));

            changedOccurrencesCriteria.Add(inBetween);
            deletedOccurrencesCriteria.Add(inBetween);

            var appointments = new List<SchedulerAppointment>();

            if(selectedAppointmentOid.HasValue)
            {
                changedOccurrencesCriteria.Add(Restrictions.Not(Restrictions.Eq(nameof(BeWoEntityBase.Oid), selectedAppointmentOid.Value)));
                deletedOccurrencesCriteria.Add(Restrictions.Not(Restrictions.Eq(nameof(BeWoEntityBase.Oid), selectedAppointmentOid.Value)));
            }

            var changedOccurrences = changedOccurrencesCriteria.List<SchedulerAppointment>().Where(a => a.ResourceList.Any(r => r.Oid.HasValue && resourceOids.Contains(r.Oid.Value))).ToList();
            var deletedOccurrences = deletedOccurrencesCriteria.List<SchedulerAppointment>().Where(a => a.ResourceList.Any(r => r.Oid.HasValue && resourceOids.Contains(r.Oid.Value))).ToList();
            // TODO: funktioniert nicht richtig
            // Sich wiederholende Termine erzeugen und dabei die Ausnahmen und gelöschten Ausnahmen ignorieren
            var interval = new TimeInterval(start, end);
            foreach(var recurringAppointment in recurringAppointments)
            {
                var recurrenceInfo = new RecurrenceInfo();
                recurrenceInfo.FromXml(recurringAppointment.RecurrenceInfo);

                var occurenceCalculator = OccurrenceCalculator.CreateInstance(recurrenceInfo);

                // Das Muster für die Terminserie wird berechnet
                var pattern = StaticAppointmentFactory.CreateAppointment(AppointmentType.Pattern);
                pattern.RecurrenceInfo.FromXml(recurringAppointment.RecurrenceInfo);
                pattern.Start = pattern.RecurrenceInfo.Start;
                pattern.End = pattern.RecurrenceInfo.End;

                var testResourceIds = recurringAppointment.ResourceList.Where(w => w.Oid.HasValue).Select(s => s.Oid.Value);

                //var patternId = pattern.RecurrenceInfo.Id.ToString();
                if(!Guid.TryParse(pattern.RecurrenceInfo.Id.ToString(), out var patternId))
                {
                    continue;
                }

                // Die Serientermine werden berechnet (ausnahmslos, d.h. es werden auch bearbeitete und gelöschte Termine erstellt, die herausgefiltert werden müssen).
                var occurrences = occurenceCalculator.CalcOccurrences(interval, pattern);

                foreach(var occurrence in occurrences.GetAppointments(interval))
                {
                    if(recurringAppointment.EndDate == null || recurringAppointment.StartDate == null)
                    {
                        continue;
                    }

                    // Sicher machen
                    var index = occurrence.RecurrenceIndex;

                    var isDeletedOrChanged = changedOccurrences.Any(a =>
                    {
                        var guid = a.GetRecurrenceIdAndIndex(out var i);

                        if(guid != null)
                        {
                            if(guid.Value.Equals(patternId) && index == i)
                            {
                                return true;
                            }
                        }

                        return false;
                    }) || deletedOccurrences.Any(a =>
                    {
                        var guid = a.GetRecurrenceIdAndIndex(out var i);

                        if(guid != null)
                        {
                            if(guid.Value.Equals(patternId) && index == i)
                            {
                                return true;
                            }
                        }

                        return false;
                    });

                    if(isDeletedOrChanged)
                    {
                        continue;
                    }

                    var duration = (recurringAppointment.EndDate.Value - recurringAppointment.StartDate.Value).TotalMinutes;
                    var isInIntervalTest = start.IsInInterval(end, occurrence.Start, occurrence.Start.AddMinutes(duration));

                    if(!isInIntervalTest)
                    {
                        continue;
                    }

                    var occurrenceAppointment = new SchedulerAppointment
                    {
                        AllDay = occurrence.AllDay,
                        CustomerList = recurringAppointment.CustomerList,
                        Notice = recurringAppointment.Notice,
                        EmployeeList = recurringAppointment.EmployeeList,
                        EndDate = occurrence.Start.AddMinutes(duration),
                        FormerBookingSequenceOid = recurringAppointment.FormerBookingSequenceOid,
                        IsPrivate = recurringAppointment.IsPrivate,
                        Location = recurringAppointment.Location,
                        Originator = recurringAppointment.Originator,
                        RecurrenceInfo = occurrence.RecurrenceInfo.ToXml(),
                        ReminderInfo = recurringAppointment.ReminderInfo,
                        ResourceList = recurringAppointment.ResourceList,
                        StartDate = occurrence.Start,
                        Subject = recurringAppointment.Subject ?? "",
                        Type = recurringAppointment.Type
                    };

                    appointments.AddIfNotIn(occurrenceAppointment);
                }
            }

            appointments.DoForEach(a => a.ResourceList.DoForEach(resources.AddIfNotIn));

            return resources;
        }

        public IList<ServiceRecord> FindCustomerServiceRecordsForKilometerauswertung(long customerOid, DateTimeSpan pSpan)
        {
            var lCriteria = CreateCriteria<ServiceRecord>()
                .Add(Restrictions.Eq(nameof(ServiceRecord.CustomerOid), customerOid))
                .Add(Restrictions.IsNotNull(nameof(ServiceRecord.DistanceInMeter)))
                .Add(Restrictions.Gt(nameof(ServiceRecord.DistanceInMeter), 0));

            var orCriteria = Restrictions.Or(
                Restrictions.Between(nameof(ServiceRecord.Start), pSpan.StartDateTime, pSpan.EndDateTime),
                Restrictions.Between(nameof(ServiceRecord.End), pSpan.StartDateTime, pSpan.EndDateTime));

            orCriteria = Restrictions.Or(orCriteria,
                Restrictions.And(
                    Restrictions.Le(nameof(ServiceRecord.Start), pSpan.EndDateTime),
                    Restrictions.Ge(nameof(ServiceRecord.End), pSpan.StartDateTime)));

            lCriteria.Add(orCriteria);

            lCriteria.Add(Restrictions.Eq(nameof(ServiceRecord.ServiceRecordType), ServiceRecordTypeId.DefaultActivity));

            return lCriteria.List<ServiceRecord>();
        }

        public Dictionary<long, List<ServiceRecord>> FindListOfCustomerServiceRecordsForKilometerauswertung(List<long> customerOids, DateTimeSpan span)
        {
            var lCriteria = CreateCriteria<ServiceRecord>()
                .Add(Restrictions.In(nameof(ServiceRecord.CustomerOid), customerOids))
                .Add(Restrictions.IsNotNull(nameof(ServiceRecord.DistanceInMeter)))
                .Add(Restrictions.Gt(nameof(ServiceRecord.DistanceInMeter), 0));

            var orCriteria = Restrictions.Or(
                Restrictions.Between(nameof(ServiceRecord.Start), span.StartDateTime, span.EndDateTime),
                Restrictions.Between(nameof(ServiceRecord.End), span.StartDateTime, span.EndDateTime));

            orCriteria = Restrictions.Or(orCriteria,
                Restrictions.And(
                    Restrictions.Le(nameof(ServiceRecord.Start), span.EndDateTime),
                    Restrictions.Ge(nameof(ServiceRecord.End), span.StartDateTime)));

            lCriteria.Add(orCriteria);

            lCriteria.Add(Restrictions.Eq(nameof(ServiceRecord.ServiceRecordType), ServiceRecordTypeId.DefaultActivity));

            var allServiceRecords = lCriteria.List<ServiceRecord>().ToList();

            var result = new Dictionary<long, List<ServiceRecord>>();

            foreach(var serviceRecord in allServiceRecords)
            {
                result.AddOrUpdateValueInDictionary(serviceRecord.CustomerOid.Value, new List<ServiceRecord> {serviceRecord});
            }

            return result;
        }

        public bool CheckForAnyServiceRecordsWithDistanceValues(List<long> customerOids, DateTimeSpan span)
        {
            return FindListOfCustomerServiceRecordsForKilometerauswertung(customerOids, span).Any();
        }

        public List<Customer> GetAllCustomersForEmployee(long? employeeOid)
        {
            ApplicationUser user;

            if(employeeOid.HasValue)
            {
                var employee = CreateCriteria<Employee>().Add(Restrictions.Eq(nameof(Employee.Oid), employeeOid)).UniqueResult<Employee>();
                user = FindUserForEmployee(employee);
            }
            else
            {
                if(LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
                {
                    user = LoggedInUserOperationContextExt.Current.User;
                }
                else
                {
                    user = SessionFacade.LoggedInUser;
                }
            }

            var rights = new List<UserRightType>();

            user.UserGroups.DoForEach(s => s.Rights.DoForEach(right => rights.AddIfNotIn(right.RightType)));

            var lCriteria = CreateCriteriaIsActive<Customer>();

            if(rights.Contains(UserRightType.ViewAll) || rights.Contains(UserRightType.CustomerView_View))
            {
                return lCriteria.List<Customer>().ToList();
            }

            var result = new List<Customer>();

            if(rights.Contains(UserRightType.Customer_ViewMyCustomers))
            {
                result = user.Employee.Employee2CustomerList.Select(employee2Customer => employee2Customer.Customer).Distinct().ToList();
            }

            if(rights.Contains(UserRightType.Customer_ViewMyTeams))
            {
                var teams = FindAllActiveTeamsOfEmployee(user.Employee.Oid.Value);

                teams.DoForEach(team =>
                {
                    team.MemberList.DoForEach(member => result.AddRangeIfElementsNotIn(member.Employee2CustomerList.Select(employee2Customer => employee2Customer.Customer)));
                });
            }

            return result;
        }

        // TODO 16.02.2021: Alias für EmployeeOid erstellen?
        public IList<ConfirmationReceiptSignature> GetConfirmationReceiptSignaturesByEmployee(long employeeOid, DateTimeSpan timeSpan)
        {
            var liste = CreateCriteria<ConfirmationReceiptSignature>()
                            .Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), SignatureType.Employee))
                            .Add(Restrictions.Eq(nameof(BeWoEntityBase.IsActive), ActivationTypeId.Active))
                            //.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.EmployeeOid), employeeOid))
                            .CreateAlias(nameof(ConfirmationReceiptSignature.Employee), "e", JoinType.InnerJoin)
                                .Add(Restrictions.Eq(nameof(BeWoEntityBase.Oid), employeeOid))
                            .CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "s", JoinType.InnerJoin)
                                .Add(CreateBetweenDateTimesCriterion(timeSpan.StartDateTime, timeSpan.EndDateTime, "s.Start", "s.End")).List<ConfirmationReceiptSignature>();

            return liste;
        }

        public List<ConfirmationReceiptSignature> GetConfirmationReceiptSignaturesByServiceRecord(long serviceRecordOid)
        {
            var criteria = CreateCriteria<ConfirmationReceiptSignature>()
                .CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "serviceRecord")
                .Add(Restrictions.Eq("serviceRecord.Oid", serviceRecordOid));

            return criteria.List<ConfirmationReceiptSignature>().ToList();
        }

        public IList<ServiceRecord> FindEmployeeServiceRecordsForKilometerauswertung(long employeeOid, DateTimeSpan timeSpan)
        {
            var lCriteria = CreateCriteria<ServiceRecord>()
                .Add(Restrictions.Eq(nameof(ServiceRecord.EmployeeOid), employeeOid))
                .Add(Restrictions.IsNotNull(nameof(ServiceRecord.DistanceInMeter)))
                .Add(Restrictions.Gt(nameof(ServiceRecord.DistanceInMeter), 0));

            var orCriteria = Restrictions.Or(
                Restrictions.Between(nameof(ServiceRecord.Start), timeSpan.StartDateTime, timeSpan.EndDateTime),
                Restrictions.Between(nameof(ServiceRecord.End), timeSpan.StartDateTime, timeSpan.EndDateTime));

            orCriteria = Restrictions.Or(orCriteria,
                Restrictions.And(
                    Restrictions.Le(nameof(ServiceRecord.Start), timeSpan.EndDateTime),
                    Restrictions.Ge(nameof(ServiceRecord.End), timeSpan.StartDateTime)));

            lCriteria.Add(orCriteria);

            lCriteria.Add(Restrictions.Eq(nameof(ServiceRecord.ServiceRecordType), ServiceRecordTypeId.DefaultActivity));

            return lCriteria.List<ServiceRecord>();
        }

        public Dictionary<long, List<ServiceRecord>> FindListOfEmployeeServiceRecordsForKilometerauswertung(List<long> employeeOids, DateTimeSpan span)
        {
            var lCriteria = CreateCriteria<ServiceRecord>()
                .Add(Restrictions.In(nameof(ServiceRecord.EmployeeOid), employeeOids))
                .Add(Restrictions.IsNotNull(nameof(ServiceRecord.DistanceInMeter)))
                .Add(Restrictions.Gt(nameof(ServiceRecord.DistanceInMeter), 0));

            var orCriteria = Restrictions.Or(
                Restrictions.Between(nameof(ServiceRecord.Start), span.StartDateTime, span.EndDateTime),
                Restrictions.Between(nameof(ServiceRecord.End), span.StartDateTime, span.EndDateTime));

            orCriteria = Restrictions.Or(orCriteria,
                Restrictions.And(
                    Restrictions.Le(nameof(ServiceRecord.Start), span.EndDateTime),
                    Restrictions.Ge(nameof(ServiceRecord.End), span.StartDateTime)));

            lCriteria.Add(orCriteria);

            lCriteria.Add(Restrictions.Eq(nameof(ServiceRecord.ServiceRecordType), ServiceRecordTypeId.DefaultActivity));

            var allServiceRecords = lCriteria.List<ServiceRecord>().ToList();

            var result = new Dictionary<long, List<ServiceRecord>>();

            foreach(var serviceRecord in allServiceRecords)
            {
                result.AddOrUpdateValueInDictionary(serviceRecord.EmployeeOid.Value, new List<ServiceRecord> { serviceRecord });
            }

            return result;
        }

        public IList<Employee> GetAllActiveEmployeesForEmployee(long? employeeOid)
        {
            ApplicationUser user;

            if(employeeOid.HasValue)
            {
                var employee = CreateCriteria<Employee>().Add(Restrictions.Eq(nameof(Employee.Oid), employeeOid)).UniqueResult<Employee>();
                user = FindUserForEmployee(employee);
            }
            else
            {
                if(LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
                {
                    user = LoggedInUserOperationContextExt.Current.User;
                }
                else
                {
                    user = SessionFacade.LoggedInUser;
                }
            }

            if(user.Employee.Oid == null)
            {
                return new List<Employee>();
            }

            var rights = new List<UserRightType>();

            user.UserGroups.DoForEach(s => s.Rights.DoForEach(right => rights.AddIfNotIn(right.RightType)));

            var lCriteria = CreateCriteriaIsActive<Employee>();

            if(rights.Contains(UserRightType.ViewAll) || rights.Contains(UserRightType.CustomerView_View))
            {
                return lCriteria.List<Employee>().ToList();
            }

            var result = new List<Employee>();

            if(rights.Contains(UserRightType.Employee_AllowViewOwnEmployees))
            {
                result.AddIfNotIn(user.Employee);
            }

            if(rights.Contains(UserRightType.Employee_AllowViewOwnTeam))
            {
                var leadingTeams = user.Employee.LeadingTeams;
                leadingTeams.DoForEach(team =>
                {
                    result.AddIfNotIn(team.Leader);

                    result.AddRangeIfElementsNotIn(team.MemberList);
                });

                var teams = FindTeamsOfEmployee(user.Employee.Oid.Value);
                teams.DoForEach(team =>
                {
                    result.AddIfNotIn(team.Leader);

                    result.AddRangeIfElementsNotIn(team.MemberList);
                });
            }

            return result;
        }

        public IList<Quittierungsbelegsstatus> GetAllQuittierungsbelegStatusForMonth(DateTime start, DateTime ende)
        {
            DateTime begin = new DateTime(start.Year, start.Month, start.Day);
            DateTime end = new DateTime(ende.Year, ende.Month, ende.Day);

            var crit = CreateCriteria<Quittierungsbelegsstatus>();
            crit.Add(Restrictions.Ge("Startdatum", begin));
            crit.Add(Restrictions.Le("Enddatum", end));
            return crit.List<Quittierungsbelegsstatus>();
        }
        
        public IList<Vorlagentabelle> GetAllActiveVorlagentabellen()
        {
            var crit = CreateCriteria<Vorlagentabelle>();
            crit.Add(Restrictions.Gt("IsActive", 0));
            return crit.List<Vorlagentabelle>();
        }

        public IList<Dokumentvorlage> GetAllDokumentvorlagenInFolder(long folderOid)
        {
            var crit = CreateCriteria<Dokumentvorlage>();
            crit.Add(Restrictions.Eq("Parent", folderOid));
            
            return crit.List<Dokumentvorlage>();
        }

        // TODO 16.02.2021: Alias für EmployeeOid erstellen?
        public bool HasConfirmationReceiptSignaturesByEmployeeAndServiceRecords(long employeeOid, IEnumerable<long> serviceRecordOids)
        {
              var criteria = CreateCriteria<ConfirmationReceiptSignature>()
                    .Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), SignatureType.Employee))
                  //.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.EmployeeOid), employeeOid))
                    .CreateAlias(nameof(ConfirmationReceiptSignature.Employee), "e", JoinType.InnerJoin)
                        .Add(Restrictions.Eq(nameof(BeWoEntityBase.Oid), employeeOid))
                    .CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "serviceRecord")
                        .Add(Restrictions.In("serviceRecord.Oid", serviceRecordOids.ToList()));

            var hasSignatures = criteria.List<ConfirmationReceiptSignature>().Any();

            return hasSignatures;
        }

        public bool HasConfirmationReceiptSignatureByDateAndCustomer(long customerOid, DateTimeSpan timeSpan, SignatureType signatureType)
        {
            var start = timeSpan.StartDate;
            var end = timeSpan.EndDate;

            var timeSpanCriterion = CreateBetweenDateTimesCriterion(start, end, $"serviceRecord.{nameof(ServiceRecord.Start)}", $"serviceRecord.{nameof(ServiceRecord.End)}");

            var criteria = CreateCriteria<ConfirmationReceiptSignature>()
                .Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
                .CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "serviceRecord")
                .Add(Restrictions.Eq($"serviceRecord.{nameof(ServiceRecord.CustomerOid)}", customerOid))
                .Add(timeSpanCriterion);

            return criteria.List<ConfirmationReceiptSignature>().Any();
        }

        public IList<Team> GetAllActiveTeamsForEmployee(long? employeeOid)
        {
            ApplicationUser user;
            var result = new List<Team>();

            if(employeeOid.HasValue)
            {
                var employee = CreateCriteria<Employee>().Add(Restrictions.Eq(nameof(Employee.Oid), employeeOid)).UniqueResult<Employee>();
                user = FindUserForEmployee(employee);
            }
            else
            {
                if(LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
                {
                    user = LoggedInUserOperationContextExt.Current.User;
                }
                else
                {
                    user = SessionFacade.LoggedInUser;
                }
            }

            if(user.Employee.Oid == null)
            {
                return result;
            }

            var rights = new List<UserRightType>();

            user.UserGroups.DoForEach(s => s.Rights.DoForEach(right => rights.AddIfNotIn(right.RightType)));
            
            if(rights.Contains(UserRightType.ViewAll) || rights.Contains(UserRightType.TeamView_ViewAll))
            {
                return CreateCriteriaIsActive<Team>().List<Team>();
            }

            if(rights.Contains(UserRightType.TeamView_ViewMyTeams))
            {
                result.AddRangeIfElementsNotIn(FindLeadingTeams(user.Employee.Oid.Value));
                result.AddRangeIfElementsNotIn(FindTeamsOfEmployee(user.Employee.Oid.Value));

                return result;
            }

            return result;
        }

        // TODO 16.02.2021: Alias für EmployeeOid erstellen?
        public IEnumerable<ConfirmationReceiptSignature> FindConfirmationReceiptSignaturesByEmployeeAndServiceRecords(long employeeOid, IEnumerable<long> serviceRecordOids)
        {
            var criteria = CreateCriteria<ConfirmationReceiptSignature>()
                .Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), SignatureType.Employee))
                //.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.EmployeeOid), employeeOid))
                .CreateAlias(nameof(ConfirmationReceiptSignature.Employee), "e", JoinType.InnerJoin)
                    .Add(Restrictions.Eq(nameof(BeWoEntityBase.Oid), employeeOid))
                .CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "serviceRecord")
                    .Add(Restrictions.In("serviceRecord.Oid", serviceRecordOids.ToList()));

            return criteria.List<ConfirmationReceiptSignature>();
        }

        //public SchedulerAppointment FindRootAppointmentByRecurrenceId(string recurrenceId)
        //{
        //    if(Guid.TryParse(recurrenceId, out var guid))
        //    {
        //        var criteria = CreateCriteria<SchedulerAppointment>()
        //            .Add(Restrictions.Like(nameof(SchedulerAppointment.RecurrenceInfo), recurrenceId, MatchMode.Anywhere))
        //            .Add(Restrictions.Eq(nameof(Appointment.Type), 1));

        //        return criteria.List<SchedulerAppointment>().FirstOrDefault();
        //    }

        //    return null;
        //}

        public SchedulerAppointment FindIndexZeroChangedOccurrence(Guid? recurrenceId)
        {
            if(recurrenceId == null)
            {
                return null;
            }

            var kek = recurrenceId.ToString();

            var str = $"<RecurrenceInfo Id=\"{kek}\" />";

            var criteria = CreateCriteria<SchedulerAppointment>()
                .Add(Restrictions.Like(nameof(SchedulerAppointment.RecurrenceInfo), str, MatchMode.Exact))
                .Add(Restrictions.Not(Restrictions.Like(nameof(SchedulerAppointment.RecurrenceInfo), "Index=\"", MatchMode.Anywhere)))
                .Add(Restrictions.Eq(nameof(Appointment.Type), 3));

            return criteria.List<SchedulerAppointment>().FirstOrDefault();
        }

        public string ValidateSchedulerAppointment(DateTime start, DateTime end, IEnumerable<long> employees, IEnumerable<long> customers, List<long> resources, long originator, long? appointmentOid, Guid? recurrenceId = null, int occurrenceIndex = 0, bool shouldSkipResourceAvailability = false)
        {
            var isOverlapping = OverlappingAppointmentsExist(start, end, employees, customers, resources, originator, appointmentOid, recurrenceId?.ToString() ?? "", occurrenceIndex);

            var unavailableResources = shouldSkipResourceAvailability ? new List<Resource>() : CheckAvailabilityOfResources(resources.ToList(), start, end, appointmentOid);

            var stringBuilder = new StringBuilder();
            
            if(unavailableResources.Any())
            {
                var names = string.Empty;

                unavailableResources.DoForEach(resource => names += resource.Name + ", ");

                names = names.TrimEnd(' ').TrimEnd(',');

                var resourceCount = resources.Count();

                var suffix = (resourceCount > 1 ? "n" : string.Empty);

                var ressourceWarningMessage = resourceCount > 1 ? 
                    $"Ein{(resourceCount > 1 ? "ige" : "e")} der ausgewählten Ressourcen ({names}) sind" : 
                    $"{(resourceCount > 1 ? "Eine der" : "Die")} ausgewählte{suffix} Ressource{suffix} ({names}) ist";

                ressourceWarningMessage += $" zum gewählten Zeitpunkt ({start.GetDateString(end)}) nicht verfügbar.";

                stringBuilder.Append(ressourceWarningMessage);
            }

            if(isOverlapping)
            {
                if(unavailableResources.Any())
                {
                    stringBuilder.Append("\n\n");
                }

                stringBuilder.Append("Dieser Termin überschneidet sich mit einem anderen bereits existierenden Termin.");
            }

            if(unavailableResources.Any() || isOverlapping)
            {
                stringBuilder.Append("\n\nMöchten Sie trotzdem speichern?");
            }

            return stringBuilder.ToString();
        }

        public virtual IList FindFileattachmentOids(string text)
        {
            var q = Session.CreateSQLQuery(Format("SELECT Oid, bewofolderoid, objectoid, objecttid, path FROM FileAttachment WHERE Path like '%{0}%'", text));

            return q.List();
        }
      
        public List<SupportConcept> GetActiveSupportConceptsForEmployee(long? employeeOid, CustomerFilterEnum supportConceptFilter)
        {
            ApplicationUser user;

            if(employeeOid.HasValue)
            {
                var employee = CreateCriteria<Employee>().Add(Restrictions.Eq(nameof(Employee.Oid), employeeOid)).UniqueResult<Employee>();
                user = FindUserForEmployee(employee);
            }
            else
            {
                if(LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
                {
                    user = LoggedInUserOperationContextExt.Current.User;
                }
                else
                {
                    user = SessionFacade.LoggedInUser;
                }
            }

            var lCriteria = CreateCriteriaIsActive<SupportConcept>();

            var teamCustomerOids = new List<long>();

            var teams = FindAllActiveTeamsOfEmployee(user.Employee.Oid.Value);

            var teamOids = teams.Select(team => team.Oid.Value);

            teams.DoForEach(team =>
            {
                team.MemberList.Where(member => member.Oid.HasValue && member.Oid != user.Employee.Oid).DoForEach(member =>
                {
                    // Nur, wo der Klient auch vom Team betreut wird
                    teamCustomerOids.AddRangeIfElementsNotIn(
                        member.Employee2CustomerList.Where(
                            employee2Customer => employee2Customer.CustomerOid.HasValue &&
                                                 employee2Customer.Customer.Team2CustomerList.Any(team2Customer => team2Customer.TeamOid.HasValue && teamOids.Contains(team2Customer.TeamOid.Value))
                        ).Select(employee2Customer => employee2Customer.CustomerOid.Value)
                        );
                });
            });

            // Der ApplicationUser darf alles Sehen oder alle Hilfepläne
            if(user.CheckForAtLeastOneRight(new List<UserRightType> {UserRightType.ViewAll, UserRightType.SupportConcept_ViewAllSupportConcepts}) && supportConceptFilter == CustomerFilterEnum.All)
            {
                return lCriteria.List<SupportConcept>().ToList();
            }

            // Der ApplicationUser darf die Hilfepläne seiner Teams sehen
            if(user.CheckForRight(UserRightType.SupportConcept_ViewMyTeams) && (supportConceptFilter == CustomerFilterEnum.TeamCustomer || supportConceptFilter == CustomerFilterEnum.All))
            {
                return GetAllActiveSupportConceptsByCustomers(teamCustomerOids, true).ToList();
            }

            var customerOids = user.Employee.Employee2CustomerList.Where(employee2Customer => employee2Customer.Customer.Oid.HasValue).Select(employee2Customer => employee2Customer.Customer.Oid.Value).Distinct().ToList();

            return GetAllActiveSupportConceptsByCustomers(customerOids, true).ToList();
        }

        public IEnumerable<SchedulerAppointment> GetAllMobileTestAppointments()
        {
            var c = CreateCriteria<SchedulerAppointment>()
                .Add(Restrictions.Eq(nameof(SchedulerAppointment.Notice), "mob-dev-app"));

            return c.List<SchedulerAppointment>();
        }

        public bool HasConfirmationReceiptSignature(IList<long> serviceRecordOids, SignatureType signatureType)
        {
            // Prüfen, ob alle ServiceRecords mit ein und derselben Mitarbeiterunterschrift verknüpft sind.
            // Eine Unterschrift kann mehrere ServiceRecords in der LinkListe haben, die nicht in der zu prüfenden Oid-Liste sind.
            var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
                .Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
                .CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
                .Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));

            var signatures = c.List<ConfirmationReceiptSignature>().ToList();

            var result = false;

            if(serviceRecordOids.Any() && signatures.Any())
            {
                var blubb = new List<long>();
                signatures.DoForEach(s => { 
                    s.ServiceRecords.DoForEach(sr =>
                    {
                        if(sr.Oid.HasValue)
                        {
                            blubb.AddIfNotIn(sr.Oid.Value);
                        }
                    });
                });

                result = serviceRecordOids.ContainsSameItemsAs(blubb);
            }

            return result;
        }

        // Methode, die herausfindet, ob eine Liste mit ServiceRecordOids zu genau einer Mitarbeiterunterschrift gehört
        public ConfirmationReceiptSignature GetConfirmationReceiptSignatureForServiceRecords(List<long> serviceRecordOids, SignatureType signatureType)
        {
            var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
                .Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
                .CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
                .Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));

            var signatures = c.List<ConfirmationReceiptSignature>().ToList();

            var relatedServiceRecordOids = new List<long>();
            signatures.DoForEach(s => relatedServiceRecordOids.AddRangeIfElementsNotIn(s.ServiceRecords.Select(x => x.Oid.Value)));

            var containsItems = relatedServiceRecordOids.ContainsItems(serviceRecordOids);

            return containsItems ? signatures.FirstOrDefault() : null;
        }

        public List<ConfirmationReceiptSignature> LoadConfirmationReceiptSignaturesByServiceRecordOids(IList<long> serviceRecordOids, SignatureType signatureType)
        {
            var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
                .Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
                .CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
                .Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));

            // Der ResultTransformer erzeugt ein SELECT DISTINCT für den Roottypen (ConfirmationReceiptSignature)
            c.SetResultTransformer(new DistinctRootEntityResultTransformer());

            var result = c.List<ConfirmationReceiptSignature>().ToList();

            return result;
        }

        public bool HasConfirmationReceiptSignaturesByCustomerAndServiceRecords(long customerOid, IEnumerable<long> serviceRecordOids)
        {
            var criteria = CreateCriteria<ConfirmationReceiptSignature>()
                .Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), SignatureType.Customer))
                .Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.CustomerOid), customerOid))
                .CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "serviceRecord")
                .Add(Restrictions.In("serviceRecord.Oid", serviceRecordOids.ToList()));

            var hasSignatures = criteria.List<ConfirmationReceiptSignature>().Any();

            return hasSignatures;
        }

        public List<ConfirmationReceiptSignature> LoadConfirmationReceiptSignaturesByServiceRecordOids(IList<long> serviceRecordOids)
        {
            var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
                .CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
                .Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));

            // Der ResultTransformer erzeugt ein SELECT DISTINCT für den Roottypen (ConfirmationReceiptSignature)
            c.SetResultTransformer(new DistinctRootEntityResultTransformer());

            var result = c.List<ConfirmationReceiptSignature>().ToList();

            return result;
        }

        public List<long> LoadServiceRecordOidsWithConfirmationReceiptSignatures(IList<long> serviceRecordOids)
        {
            var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
                .CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
                .Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));

            // Der ResultTransformer erzeugt ein SELECT DISTINCT für den Roottypen (ConfirmationReceiptSignature)
            c.SetResultTransformer(new DistinctRootEntityResultTransformer());

            var confirmationReceiptSignatures = c.List<ConfirmationReceiptSignature>().ToList();

            var result = new List<long>();

            confirmationReceiptSignatures.DoForEach(crs => crs.ServiceRecords.DoForEach(sr =>
            {
                if(sr.Oid.HasValue)
                {
                    result.AddIfNotIn(sr.Oid.Value);
                }
            }));

            return result;
        }

        public List<long> LoadServiceRecordOidsWithConfirmationReceiptSignatures(IList<long> serviceRecordOids, SignatureType signatureType)
        {
            var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
                .Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
                .CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
                .Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()));

            // Der ResultTransformer erzeugt ein SELECT DISTINCT für den Roottypen (ConfirmationReceiptSignature)
            c.SetResultTransformer(new DistinctRootEntityResultTransformer());

            var confirmationReceiptSignatures = c.List<ConfirmationReceiptSignature>().ToList();

            var result = new List<long>();

            confirmationReceiptSignatures.DoForEach(crs => crs.ServiceRecords.DoForEach(sr =>
            {
                if(sr.Oid.HasValue)
                {
                    result.AddIfNotIn(sr.Oid.Value);
                }
            }));

            return result;
        }

        public IEnumerable<ServiceRecord> GetServiceRecordsWithoutConfirmationReceiptSignature(IList<long> serviceRecordOids, SignatureType signatureType)
        {
            var c = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
                .Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
                .CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "sr", JoinType.InnerJoin)
                .Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()))
                .SetResultTransformer(new DistinctRootEntityResultTransformer());

            var confirmationReceiptSignatures = c.List<ConfirmationReceiptSignature>().ToList();

            var serviceRecords = new List<ServiceRecord>();

            confirmationReceiptSignatures.DoForEach(crs => serviceRecords.AddRangeIfElementsNotIn(crs.ServiceRecords));

            return serviceRecords;
        }
    }
}