BeWoPlaner/Data/Access/SearchDAO.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using BeWo.Data.Entities;
using BeWo.Data.Utils;
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 e.oid FROM employee e join Person p on e.personoid = p.oid WHERE CONCAT_WS(' ', FirstName, LastName) LIKE '%{0}%' AND Type = 1", pFullname));
			var x = q.List<long>();

			return x.Count > 0 ? DAOFactory.GenericDAO.GetByID<Employee>(x.Last()) : 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 IList<WohneinheitBelegung> FindWohneinheitBelegungForCustomer(long customerOid, DateTime datum)
		{
			var criteria = CreateCriteriaIsActive<WohneinheitBelegung>()
				.Add(Restrictions.Eq(WohneinheitBelegung.PropertyName_Customer, customerOid))
				.Add(
					Restrictions.Or(
						Restrictions.And(
							Restrictions.Le(WohneinheitBelegung.PropertyName_StartDate, datum.Date),
							Restrictions.Ge(WohneinheitBelegung.PropertyName_EndDate, datum.Date)
						),
						Restrictions.And(
							Restrictions.Le(WohneinheitBelegung.PropertyName_StartDate, datum.Date),
							Restrictions.IsNull(WohneinheitBelegung.PropertyName_EndDate)
						)
					)
				);

			return criteria.List<WohneinheitBelegung>();
		}

		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 IList<DienstEintrag> GetAllDienstEintraege(long wOid, DateTime start, DateTime end)
		{
			var c = CreateCriteria<DienstEintrag>()
				.Add(Restrictions.Eq("WohnheimOid", wOid))
				.Add(Restrictions.Between("Datum", start, end))
				.Add(Restrictions.Eq("IsActive", ActivationTypeId.Active));

			return c.List<DienstEintrag>();
		}

		public virtual IList<Employee> GetEmployeeForWohnheim(long wOid)
		{
			var c = CreateCriteria<Wohnheim>()
				.Add(Restrictions.Eq("WohnheimOid", wOid));

			return c.List<Employee>();
		}

		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 void RemoveServiceRecordsFromAppointments(IEnumerable<long> enumerable)
		{
			throw new NotImplementedException();
		}

		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_Start, 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 (!BS.Shared.Core.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 TwoFactorCode GetLastTwoFactorCode(string loginName, string bCryptPassword)
		{
			return CreateCriteriaIsActive<TwoFactorCode>()
				.Add(Expression.Eq("LoginName", loginName))
				.Add(Expression.Eq("Password", bCryptPassword))
				.AddOrder(new Order("Oid", false)).List<TwoFactorCode>().FirstOrDefault();
		}

		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.Or(
						Restrictions.Between("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedEndDate, minDate, expiredUntil),
						Restrictions.Between("cb2sc." + CostBearer2SupportConcept.PropertyName_RequestedEndDate, 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 CreateCriteriaIsActive<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, int maxResults)
		{
			return CreateCriteria<Login>()
				.Add(Restrictions.Eq(Login.PropertyName_LoginName, loginName))
				.AddOrder(Order.Desc("Oid"))
				.SetMaxResults(maxResults)
				.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>().Distinct().ToList();
		}

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


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

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

			var result = 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>();

			return result;
		}

		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 CreateCriteria<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 List<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<AbsenceTime> FindAbsenceTimesForEmployee
			(DateTime startDate, DateTime endDate, long empOid)
		{
			var criteria = CreateCriteriaIsActive<AbsenceTime>()
				.Add(Restrictions.Eq("EmployeeOid", empOid))
				.Add(Restrictions.Gt(AbsenceTime.PropertyName_Start, startDate))
				.Add(Restrictions.Lt(AbsenceTime.PropertyName_End, endDate));

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

		public IEnumerable<AbsenceTime> FindAbsenceTimesForMonth(DateTime startDate, DateTime endDate)
		{
			var criteria = CreateCriteriaIsActive<AbsenceTime>();
			criteria.Add(Restrictions.Gt("Start", startDate));
			criteria.Add(Restrictions.Lt("End", endDate));

			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<Vertretung> FindLastVertretungen(long customerOid)
		{
			var c = CreateCriteriaIsActive<Vertretung>();
			c.Add(Restrictions.Eq("CustomerOid", customerOid));

			return c.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<AdditionalServiceNotice> GetAdditionalServiceNoticeList(long? regionOid, DateTime start, DateTime end)
		{
			var c = CreateCriteriaIsActive<AdditionalServiceNotice>()
				.Add(Restrictions.Between("Monat", start, end));

			if (regionOid.HasValue)
			{
				c.Add(Restrictions.Eq("RegionOid", regionOid));
			}

			return c.List<AdditionalServiceNotice>();
		}

		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 IList GetBillableServiceRecordsSqlArray(DateTime start, DateTime end)
		{
			var q = Session.CreateSQLQuery(String.Format(@"
SELECT sr.Oid, sr.StartDate, sr.EndDate, sr.EmployeeOid, sr.CustomerOid, sr.GroupOid, sr.costbearer2supportconceptoid, sd.Name, sc.Name
FROM ServiceRecord sr
inner join ServiceDescription sd on sr.ServiceDescriptionOid = sd.Oid
inner join ServiceCategory sc on sd.ServiceCategoryOid = sc.Oid
WHERE sc.Billable = 1 and sr.StartDate >= '{0:yyyy-MM-dd}' and sr.StartDate < '{1:yyyy-MM-dd}'", start, end));

			return q.List();

		}

		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 is null)
			{
				employees = new List<long>();
			}

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

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

			var isRecurrenceException = appointmentOid is 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 is 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 => BS.Shared.Core.Utils.GetOccurrenceId(app.RecurrenceInfo)).ToList();
			var changedOccurences = schedulerAppointments.Where(app => app.Type == 3).Select(app => BS.Shared.Core.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 is null || recurrenceIdToIgnore is null)
					{
						return true;
					}

					return !recId.Equals(recurrenceIdToIgnore);
				}).ToList();

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

					if (recId is null || recurrenceIdToIgnore is null)
					{
						return true;
					}

					return !recId.Equals(recurrenceIdToIgnore);
				}).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 is 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 is null || appointment.StartDate is 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 employeeOidList = new List<long>();

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

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

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

			var hasOverlappingEmployeeAppointments = employeeOidList.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)
			{
				return true;
			}

			var recId = appointment.GetRecurrenceIdAndIndex(out var recIndex);

			if (appointment.RecurrenceInfo is null || recId is null)
			{
				return true;
			}

			return !recId.Equals(recurrenceId);
		}

		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<GkvAbrechnung> GetGkvAbrechnungen(DateTime? startDate, DateTime? endDate, bool useInvoiceDate = true)
		{
			if (endDate.HasValue)
				endDate = endDate.Value.Date.AddDays(1).AddMilliseconds(-1);

			var lCriteria = CreateCriteriaIsActive<GkvAbrechnung>();
			if (useInvoiceDate)
			{
				if (startDate.HasValue)
					lCriteria.Add(Restrictions.Ge(nameof(GkvAbrechnung.ErstelltAm), startDate));
				if (endDate.HasValue)
					lCriteria.Add(Restrictions.Le(nameof(GkvAbrechnung.ErstelltAm), endDate));
			}
			else
			{
				if (startDate.HasValue)
					lCriteria.Add(Restrictions.Ge(nameof(GkvAbrechnung.AbrechnungsZeitraumEnde), startDate));
				if (endDate.HasValue)
					lCriteria.Add(Restrictions.Le(nameof(GkvAbrechnung.AbrechnungsZeitraumStart), endDate));
			}

			return lCriteria.List<GkvAbrechnung>();
		}

		public IEnumerable<GkvTransferProtokoll> GetGkvTransferProtokollByDateRange(DateTime? start, DateTime? end)
		{
			var lCriteria = CreateCriteria<GkvTransferProtokoll>();

			if (start.HasValue)
				lCriteria.Add(Restrictions.Ge(nameof(GkvTransferProtokoll.ErstelltAm), start));
			if (end.HasValue)
				lCriteria.Add(Restrictions.Le(nameof(GkvTransferProtokoll.ErstelltAm), end));

			return lCriteria.List<GkvTransferProtokoll>();
		}

		public IEnumerable<InvoiceBase> GetInvoiceBases(DateTime? startDate, DateTime? endDate, long costBearerOid, String invoiceId)
		{
			var lCriteria = CreateCriteriaIsActive<InvoiceBase>();

			if (startDate.HasValue)
				lCriteria.Add(Restrictions.Ge(InvoiceBase.PropertyName_InvoiceDate, startDate));

			if (endDate.HasValue)
				lCriteria.Add(Restrictions.Le(InvoiceBase.PropertyName_InvoiceDate, endDate));

			lCriteria.Add(Restrictions.Eq(InvoiceBase.PropertyName_InvoiceId, invoiceId));

			lCriteria.CreateAlias(InvoiceBase.PropertyName_CostBearer2SupportConcept, "c2s");
			lCriteria.CreateAlias("c2s." + CostBearer2SupportConcept.PropertyName_CostBearer, "cb");
			lCriteria.Add(Restrictions.Eq("cb.Oid", costBearerOid));
			lCriteria.Add(Restrictions.Eq("c2s.CostBearer.Oid", costBearerOid));

			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)
		{
			if (pEmployeeOids == null)
			{
				pEmployeeOids = new List<long>();
			}

			var result = new List<long>();
			var appointments = GetAllActiveAppointmentsForEmployeeInInterval2(pStartTime, pEndTime, pEmployeeOids) ?? new List<SchedulerAppointment>();
			var gefilterteTermine =
				appointments.Where(w => w.EmployeeList != null && 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)).ToList();

			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 IEnumerable<Arbeitszeit> FindArbeitszeiten(TableID objectTid, long objectOid)
		{
			var c = CreateCriteriaIsActive<Arbeitszeit>();

			if (objectTid == TableID.Employee)
			{
				c.Add(Restrictions.Eq(Arbeitszeit.PropertyName_EmployeeOid, objectOid));
			}
			else
			{
				c.Add(Restrictions.Eq("Customer", DAOFactory.GenericDAO.GetByID<Customer>(objectOid)));
			}


			return c.List<Arbeitszeit>().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("cb2sc." + CostBearer2SupportConcept.PropertyName_RequestedStartDate, datum), Restrictions.Ge("cb2sc." + CostBearer2SupportConcept.PropertyName_RequestedEndDate, datum)),
					Restrictions.And(Restrictions.Le("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedStartDate, datum), Restrictions.Ge("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedEndDate, datum))))
				.List<SupportConcept>().Distinct().ToList();
		}

		public IList<SupportConcept> FindSupportConceptsInDateRange(bool auchArchivierteHolen, DateTime start, DateTime end)
		{
			ICriteria c = null;
			if (auchArchivierteHolen)
			{
				c = CreateCriteriaIsActiveOrArchived<SupportConcept>();
			}
			else
			{
				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.And(Restrictions.IsNull("cb2sc." + CostBearer2SupportConcept.PropertyName_RequestedStartDate), Restrictions.IsNull("cb2sc." + CostBearer2SupportConcept.PropertyName_RequestedEndDate)),
							Restrictions.And(Restrictions.IsNull("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedStartDate), Restrictions.IsNull("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedEndDate))),
						Restrictions.Or(
							Restrictions.And(Restrictions.Lt("cb2sc." + CostBearer2SupportConcept.PropertyName_RequestedStartDate, end), Restrictions.Ge("cb2sc." + CostBearer2SupportConcept.PropertyName_RequestedEndDate, start)),
							Restrictions.And(Restrictions.Lt("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedStartDate, end), Restrictions.Ge("cb2sc." + CostBearer2SupportConcept.PropertyName_ApprovedEndDate, start)))))
				.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 = CreateCriteriaIsActive<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<AiPromptbaustein> GetActiveAiPromptbausteine(bool shouldOnlyLoadOwnAiPromptbausteine, bool hasRightToSeeOther, bool isInAdministrationView, long employeeOid)
		{
			var criteria = CreateCriteriaIsActive<AiPromptbaustein>();



			//if (isInAdministrationView)
			//{
			//    criteria.Add(Restrictions.Eq(nameof(AiPromptbaustein.IsOnlyForEmployee), false));
			//}
			//else if (!hasRightToSeeAll)
			//{
			//    criteria.Add(Restrictions.Eq(nameof(AiPromptbaustein.IsOnlyForEmployee), true))
			//        .Add(Restrictions.Eq(nameof(AiPromptbaustein.Employee) + "." + nameof(BeWoEntityBase.Oid), employeeOid));
			//}
			//else
			//{
			//    criteria.Add(
			//        Restrictions.Or(
			//            Restrictions.And(
			//                Restrictions.Eq(nameof(AiPromptbaustein.IsOnlyForEmployee), true),
			//                Restrictions.Eq(nameof(AiPromptbaustein.Employee) + "." + nameof(BeWoEntityBase.Oid), employeeOid)),
			//            Restrictions.Eq(nameof(AiPromptbaustein.IsOnlyForEmployee), false)));
			//}

			return criteria.List<AiPromptbaustein>();
		}

		public IEnumerable<AiPromptbaustein> GetChildAiPromptbausteine(AiPromptbaustein aiPromptbaustein)
		{
			var criteria = CreateCriteria<AiPromptbaustein>();

			criteria.Add(Restrictions.Eq(nameof(AiPromptbaustein.Parent), aiPromptbaustein));

			return criteria.List<AiPromptbaustein>();
		}

		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>();
		}

		// KALENDER
		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, bool includeTasks)
		{
			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));
			}

			if (!includeTasks)
			{
				criteria.Add(Restrictions.Or(
					Restrictions.Eq(SchedulerAppointment.PropertyName_IsTask, false),
					Restrictions.IsNull(SchedulerAppointment.PropertyName_IsTask)));
			}

			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>();
		}

		// ToDo: zu anonymisierende Termine nicht herausfiltern! Also sämtliche, aktive Termine mit den ausgewählten Ressourcen laden!
		// KALENDER
		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 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);

				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);
			}

			var listOfCriterias = new List<ICriterion>
			{
				employeeCriterion,
				customerCriterion,
				resourceCriterion
			};

			if (pSelectedResources.Count == 0)
			{
				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>();

			#region Serientermine

			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);

			#endregion

			var deletedAppointments = appointments.Where(a => a.IsActive != ActivationTypeId.Active).ToList();

			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, bool excludeTasks = 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 (!excludeTasks)
			{
				criteria.Add(Restrictions.Not(Restrictions.Eq(nameof(SchedulerAppointment.IsTask), true)));
			}

			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<SchedulerAppointment> FindAppointmentsForEmployee(long employeeOid)
		{
			var blah = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM employee2newschapp WHERE employeeOid IN ({employeeOid}))";
			var ec = Expression.Sql(blah);

			var c = CreateCriteria<SchedulerAppointment>().Add(ec);

			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<Employee2Token> GeEmployee2TokensByEmployeeOid(long employeeOid)
		{
			var c = CreateCriteria<Employee2Token>();

			c.Add(Restrictions.Eq(nameof(Employee2Token.Employee) + "." + nameof(BeWoEntityBase.Oid), employeeOid));

			return c.List<Employee2Token>();
		}

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

			c.Add(Restrictions.Eq(nameof(BeWoEntityBase.Notice), BS.Shared.Core.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>
		/// <param name="start">Anfang des zu prüfenden Intervalls</param>
		/// <param name="end">Ende des zu prüfenden Intervalls</param>
		/// <param name="selectedAppointmentOid">Die Oid des Termins</param>
		/// <param name="recurrenceId">Recurrence Id, falls es sich um einen Serientermin handelt, der keine eigene Oid hat.</param>
		/// <param name="occurrenceIndex">Occurrence-Index des Serientermins ohne eigene Oid</param>
		/// <returns>Die im angegebenen Zeitraum belegten Ressourcen</returns>
		public List<Resource> CheckAvailabilityOfResources(List<long> resourceOids, DateTime start, DateTime end, long? selectedAppointmentOid, Guid? recurrenceId = null, int? occurrenceIndex = null)
		{
			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 Type <> 4 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();

			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();

			if (recurringAppointments.Count == 0)
			{
				return resources;
			}

			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 = new List<SchedulerAppointment>();

			var recurrenceIds = string.Empty;
			recurringAppointments.DoForEach(appointment => recurrenceIds += $"'{appointment.GetRecurrenceId()}',");
			recurrenceIds = recurrenceIds.Trim(',');

			if (recurrenceIds.Any())
			{
				var changedCriteria = CreateCriteriaIsActive<SchedulerAppointment>()
					.Add(Restrictions.Eq(nameof(SchedulerAppointment.Type), 3))
					.Add(Expression.Sql($"RecurrenceInfo IS NOT NULL AND RecurrenceInfo LIKE '%Id%' AND SUBSTRING(RecurrenceInfo, LOCATE('Id', RecurrenceInfo) + 4, 36) IN ({recurrenceIds})"));

				changedOccurrences = changedCriteria.List<SchedulerAppointment>().ToList();
			}

			//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();

			// 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;

				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);

				var occurrenceAppointments = occurrences.GetAppointments(interval);

				foreach (var occurrence in occurrenceAppointments)
				{
					if (recurringAppointment.EndDate is null || recurringAppointment.StartDate is null)
					{
						continue;
					}

					// Sicher machen
					var index = occurrence.RecurrenceIndex;

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

						if (guid is null)
						{
							return false;
						}

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

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

						if (guid is null)
						{
							return false;
						}

						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 ?? Empty,
						Type = recurringAppointment.Type
					};

					if (!(recurrenceId is null) && occurrenceIndex.HasValue)
					{
						var recId = occurrenceAppointment.GetRecurrenceId();

						if ((recId?.Equals(recurrenceId.Value) ?? false) && index.Equals(occurrenceIndex.Value))
						{
							continue;
						}
					}

					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), 0m));

			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);

			return lCriteria.List<ServiceRecord>();
		}

		public Dictionary<long, List<ServiceRecord>> FindListOfCustomerServiceRecordsForKilometerauswertung(List<long> customerOids, List<long> serviceDescriptionOids, 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), 0m));

			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);

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

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

			foreach (var serviceRecord in allServiceRecords)
			{
				if (serviceDescriptionOids == null || serviceDescriptionOids.Count == 0 || serviceDescriptionOids.Contains(serviceRecord.ServiceDescription.Oid.Value))
				{
					result.AddOrUpdateValueInDictionary(serviceRecord.CustomerOid.Value, new List<ServiceRecord> { serviceRecord });
				}
			}

			return result;
		}

		public bool CheckForAnyServiceRecordsWithDistanceValues(List<long> customerOids, DateTimeSpan span)
		{
			return FindListOfCustomerServiceRecordsForKilometerauswertung(customerOids, null, 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);

				result.AddRangeIfElementsNotIn(FindCustomersOfTeams(teams.Select(team => team.Oid.Value)));
			}

			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 = CreateCriteriaIsActive<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), 0m));

			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);

			return lCriteria.List<ServiceRecord>();
		}

		public Dictionary<long, List<ServiceRecord>> FindListOfEmployeeServiceRecordsForKilometerauswertung(List<long> employeeOids, List<long> serviceDescriptionOids, 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), 0m));

			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);

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

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

			foreach (var serviceRecord in allServiceRecords)
			{
				if (serviceDescriptionOids == null || serviceDescriptionOids.Count == 0 || serviceDescriptionOids.Contains(serviceRecord.ServiceDescription.Oid.Value))
				{
					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.EmployeeView_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();
		}

		// Mit confirmationreceiptsignature2servicerecord suchen: Klient UND Mitarbeiter
		public bool HasConfirmationReceiptSignatureByDateAndEmployeeAndCustomer(long customerOid, long employeeOid, DateTime serviceRecordStart, DateTime serviceRecordEnd, long costBearer2SupportConceptOid, out List<ConfirmationReceiptSignature> monatsunterschriften)
		{
			var timePartOfQuery = " STR_TO_DATE(CONCAT(SUBSTRING(monatsunterschrift.TimeSpanString, 18, 4), '-', SUBSTRING(monatsunterschrift.TimeSpanString, 4, 2), '-', SUBSTRING(monatsunterschrift.TimeSpanString, 1, 2)), '%Y-%m-%d') AND STR_TO_DATE(CONCAT(SUBSTRING(monatsunterschrift.TimeSpanString, 18, 4), '-', SUBSTRING(monatsunterschrift.TimeSpanString, 15, 2), '-', SUBSTRING(monatsunterschrift.TimeSpanString, 12, 2)), '%Y-%m-%d') ";

			var sql =
				"SELECT monatsunterschrift.* FROM confirmationreceiptsignature monatsunterschrift " +
				$"WHERE ('{serviceRecordStart:yyyy-MM-dd HH:mm:ss}' BETWEEN {timePartOfQuery} OR '{serviceRecordEnd:yyyy-MM-dd HH:mm:ss}' BETWEEN {timePartOfQuery}) " +
				$"AND (monatsunterschrift.CustomerOid = {customerOid} OR monatsunterschrift.EmployeeOid = {employeeOid}) " +
				"AND monatsunterschrift.Oid IN " +
				"(SELECT monatsunterschrift2sr.ConfirmationReceiptSignatureOid FROM confirmationreceiptsignature2servicerecord monatsunterschrift2sr " +
				"WHERE monatsunterschrift2sr.ServiceRecordOid IN " +
				$"(SELECT sr.Oid FROM servicerecord sr WHERE sr.CostBearer2SupportConceptOid = {costBearer2SupportConceptOid}))";

			var query = Session.CreateSQLQuery(sql);

			query.AddEntity("crs", typeof(ConfirmationReceiptSignature));

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

			monatsunterschriften = signatures;

			return signatures.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 resourceList = resources;
			if (shouldSkipResourceAvailability)
			{
				resourceList = null;
			}

			var isOverlapping = OverlappingAppointmentsExist(start, end, employees, customers, resourceList, originator, appointmentOid, recurrenceId?.ToString() ?? "", occurrenceIndex);

			// Die Ressourcen werden auf Verfügbarkeit im ausgewählten Zeitraum geprüft
			var info = shouldSkipResourceAvailability ? new Dictionary<string, List<string>>() : CheckResourceAvailabilityWithEmployeeInformation(start, end, resources, appointmentOid, recurrenceId, occurrenceIndex);

			var stringBuilder = new StringBuilder();

			foreach (var resourceName2Intervals in info)
			{
				stringBuilder.AppendLine($"Die Ressource \"{resourceName2Intervals.Key}\" ist im ausgewählten Zeitraum {start:dd.MM.yyyy HH:mm} bis {end:dd.MM.yyyy HH:mm} bereits gebucht:");
				if (!resourceName2Intervals.Value.All(IsNullOrWhiteSpace))
				{
					stringBuilder.Append("\r\n\r\n");
				}

				foreach (var interval in resourceName2Intervals.Value)
				{
					stringBuilder.AppendLine($"{interval}");
				}
			}

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

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

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

			return stringBuilder.ToString();
		}

		public virtual IList FindFileattachmentOids(string text)
		{
			var q = Session.CreateSQLQuery($"SELECT Oid, bewofolderoid, objectoid, objecttid, path FROM FileAttachment WHERE Path like '%{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);

			teams.DoForEach(team =>
			{
				var customer = FindCustomerOfTeam(team.Oid.Value);

				teamCustomerOids.AddRangeIfElementsNotIn(customer.Select(c => c.Oid.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();
			}

			var customerOids = user.Employee.Employee2CustomerList.Where(employee2Customer => employee2Customer.Customer.Oid.HasValue && (!employee2Customer.StartDate.HasValue || employee2Customer.StartDate <= DateTime.Now.Date) && (!employee2Customer.EndDate.HasValue || employee2Customer.EndDate >= DateTime.Now.Date)).Select(employee2Customer => employee2Customer.Customer.Oid.Value).Distinct().ToList();

			// Wählt man "Nur Klienten meiner Teams anzeigen", sollen nicht die Hilfepläne der eigenen Klienten angezeigt werden.
			if (supportConceptFilter == CustomerFilterEnum.TeamCustomer)
			{
				customerOids.Clear();
			}

			// Der ApplicationUser darf die Hilfepläne seiner Teams sehen
			if (user.CheckForRight(UserRightType.SupportConcept_ViewMyTeams) && (supportConceptFilter == CustomerFilterEnum.TeamCustomer || supportConceptFilter == CustomerFilterEnum.All))
			{
				foreach (var coid in customerOids)
				{
					if (!teamCustomerOids.Contains(coid))
					{
						teamCustomerOids.Add(coid);
					}
				}

				return GetAllActiveSupportConceptsByCustomers(teamCustomerOids, true).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 Unterschrift 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;
		}

		// ToDo: An neue Rechte anpassen!
		// 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))
				.AddOrder(Order.Desc(nameof(ConfirmationReceiptSignature.Oid)))
				.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;
		}

		public InvoiceBase FindMaxInvoiceNumber(string numberPrefix)
		{
			return CreateCriteriaIsActive<InvoiceBase>()
				.Add(Restrictions.Like(InvoiceBase.PropertyName_InvoiceNumber, numberPrefix + "%"))
				.List<InvoiceBase>().OrderByDescending(i => i.InvoiceNumber).FirstOrDefault();

		}

		public List<Customer> GetActiveCustomersForEmployee(long? employeeOid, CustomerFilterEnum customerFilter, bool ignoreViewAllRight = false)
		{
			ApplicationUser user;

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

			var lCriteria = CreateCriteriaIsActive<Customer>();

			// Der ApplicationUser darf alles sehen
			var viewAllRights = new List<UserRightType> { UserRightType.CustomerView_View };
			if (!ignoreViewAllRight)
			{
				viewAllRights.Add(UserRightType.ViewAll);
			}

			if (user.CheckForAtLeastOneRight(viewAllRights) && customerFilter == CustomerFilterEnum.All)
			{
				return lCriteria.List<Customer>().ToList();
			}

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

			// Der ApplicationUser darf die Klienten seiner Teams sehen
			if (user.CheckForRight(UserRightType.Customer_ViewMyTeams) && (customerFilter == CustomerFilterEnum.TeamCustomer || customerFilter == CustomerFilterEnum.All) && (user.Employee?.Oid.HasValue ?? false))
			{
				var teamCustomerOids = new List<long>();

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

				teams.DoForEach(team =>
				{
					if (team.Oid is null)
					{
						return;
					}

					var customer = FindCustomerOfTeam(team.Oid.Value);

					teamCustomerOids.AddRangeIfElementsNotIn(customer.Where(w => w.Oid.HasValue).Select(c => c.Oid.Value));
				});

				//foreach (var customerOid in customerOids.Where(customerOid => !teamCustomerOids.Contains(customerOid)))
				//{
				//    teamCustomerOids.Add(customerOid);
				//}

				return lCriteria.Add(Restrictions.In(nameof(Customer.Oid), teamCustomerOids.ToArray())).List<Customer>().ToList();
			}

			// Der ApplicationUser darf nur seine eigenen Klienten sehen
			return lCriteria.Add(Restrictions.In(nameof(Customer.Oid), customerOids.ToArray())).List<Customer>().ToList();
		}

		public IList<long> FindFamilyMemberOids()
		{
			var q = Session.CreateSQLQuery("SELECT personoid FROM customer2person where istfamilie = 1");
			return q.List<long>();
		}

		public IList FindCustomerOid2Persons(IList<long> personOids)
		{
			if (personOids == null || personOids.Count == 0)
			{
				return null;
			}

			String oidList = "";
			foreach (var oid in personOids)
			{
				if (oidList.Length > 0)
				{
					oidList += ",";
				}

				oidList += String.Format("{0}", oid);
			}

			return GetSqlResult("SELECT oid,personoid,customeroid,istfamilie FROM customer2person where personoid in (" + oidList + ")");

		}

		public List<SchedulerAppointment> FindActiveAppointmentsForCustomers(List<long> customerOids, DateTime startDate, DateTime endDate)
		{
			var customerOidSqlString = string.Empty;
			customerOids.DoForEach(oid => customerOidSqlString += $"{oid},");
			customerOidSqlString = customerOidSqlString.Trim(',');

			var sqlQuery = $" {nameof(BeWoEntityBase.Oid)} IN (SELECT newschappoid FROM customer2newschapp WHERE customeroid IN ({customerOidSqlString})) ";
			var customerCriterion = Expression.Sql(sqlQuery);

			var between = CreateBetweenDateTimesCriterion(startDate, endDate, nameof(SchedulerAppointment.StartDate), nameof(SchedulerAppointment.EndDate));

			var criteria = CreateCriteriaIsActive<SchedulerAppointment>()
				.Add(customerCriterion)
				.Add(between)
				.Add(Restrictions.Eq(nameof(SchedulerAppointment.IsTask), false));

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

		public List<SchedulerAppointment> LoadFilteredAllActiveAppointments(long employeeOid, DateTime start, DateTime end, List<long> customerOids)
		{
			var appointments = LoadFilteredAppointments(
				true,
				employeeOid,
				start, end,
				new List<long>(),
				customerOids,
				new List<long>(),
				false,
				true,
				false,
				false,
				false,
				false,
				true);

			return appointments.ToList();
		}

		public List<ServiceRecord> FindServiceRecordsForFlsAuslastungsauswertungByCustomerAndEmployees(long? customerOid, List<long> employeeOids, DateTime start, DateTime end, bool onlyBillableCategories)
		{
			var c = CreateCriteriaIsActive<ServiceRecord>().Add(Restrictions.Eq(nameof(ServiceRecord.CustomerOid), customerOid));

			c.Add(Restrictions.In(nameof(ServiceRecord.EmployeeOid), employeeOids));

			var betweenCriterion = CreateBetweenDateTimesCriterion(start, end, nameof(ServiceRecord.Start), nameof(ServiceRecord.End));

			c.Add(betweenCriterion);

			if (onlyBillableCategories)
			{
				c.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>().ToList();
		}

		public IList<GeschenkterUrlaubstag> FindGeschenkteUrlaubstageByEmpOid(long empOid)
		{
			var criteria = CreateCriteriaIsActive<GeschenkterUrlaubstag>()
				.Add(Restrictions.Eq("Employee", empOid));

			return criteria.List<GeschenkterUrlaubstag>();
		}

		public IList<GeschenkterUrlaubstag> FindGeschenkteUrlaubstageByYear(int year)
		{
			DateTime start = new DateTime(year, 1, 1).AddTicks(-1);
			DateTime end = new DateTime(year, 12, 31).AddDays(1).AddTicks(-1);

			var criteria = CreateCriteriaIsActive<GeschenkterUrlaubstag>()
				.Add(Restrictions.Between("Date", start, end));

			return criteria.List<GeschenkterUrlaubstag>();
		}

		public List<ServiceRecord> GetActiveServiceRecordsBySupportConceptWithServiceCategoryForCustomer(List<long> customerOids, long serviceCategoryOid, int month, int year)
		{
			var c = CreateCriteriaIsActive<SupportConcept>()
				.Add(Restrictions.In(nameof(SupportConcept.Customer) + ".Oid", customerOids.ToArray()))
				.CreateAlias(SupportConcept.PropertyName_ServiceAccountings, "sa", JoinType.InnerJoin)
				.CreateAlias("sa." + nameof(ServiceAccounting.ServiceDescription), "sd", JoinType.InnerJoin)
				.CreateAlias("sd." + ServiceDescription.PropertyName_ServiceCategory, "cat", JoinType.InnerJoin)
				.Add(Restrictions.Eq("cat.Oid", serviceCategoryOid));

			var c2 = CreateCriteriaIsActive<SupportConcept>()
				.Add(Restrictions.In(nameof(SupportConcept.Customer) + ".Oid", customerOids.ToArray()))
				.Add(Restrictions.IsEmpty(nameof(SupportConcept.ServiceAccountings)));

			var supportConcepts = c.List<SupportConcept>().ToList();
			supportConcepts.AddRangeIfElementsNotIn(c2.List<SupportConcept>());

			var start = new DateTime(year, month, 1, 0, 0, 0);
			var end = start.AddMonths(1).AddSeconds(-1);

			var criteria = CreateCriteriaIsActive<ServiceRecord>()
				.Add(Restrictions.In(nameof(ServiceRecord.CustomerOid), customerOids.ToArray()))
				.Add(CreateBetweenDateTimesCriterion(start, end, "Start", "End"))
				.Add(Restrictions.In(nameof(ServiceRecord.SupportConcept) + ".Oid", supportConcepts.Select(sc => sc.Oid).ToArray()));

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

		public List<Customer> GetCustomersForEmployeeWithServiceRecordsInInterval(DateTime start, DateTime end, long employeeOid)
		{
			var result = new List<Customer>();

			// Customers aus Zeitraum, die ServiceRecords haben, wo der Employee dabei ist.
			var serviceRecords = FindEmployeeServiceRecords(employeeOid, new DateTimeSpan(start, end), null, null);

			serviceRecords.DoForEach(sr =>
			{
				if (sr?.Customer != null)
				{
					result.AddIfNotIn(sr.Customer);
				}
			});

			return result;
		}

		public List<Customer> GetCustomersForTeamWithServiceRecordsInInterval(DateTime start, DateTime end, List<long> employeeOids)
		{
			var result = new List<Customer>();

			var serviceRecords = FindEmployeeServiceRecords(employeeOids, new DateTimeSpan(start, end));

			serviceRecords.DoForEach(sr =>
			{
				if (sr?.Customer != null)
				{
					result.AddIfNotIn(sr.Customer);
				}
			});

			return result;
		}

		public IList<ServiceRecord> FindEmployeeServiceRecords(List<long> employeeOids, DateTimeSpan span)
		{
			var lCriteria = CreateCriteria<ServiceRecord>()
				.Add(Restrictions.In(nameof(ServiceRecord.EmployeeOid), employeeOids));

			if (span != null)
			{
				lCriteria.Add(Restrictions.Between(ServiceRecord.PropertyName_Start, span.StartDateTime, span.EndDateTime));
			}

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

			return result;
		}

		public IList<DienstInfo> FindDiensteForWohnheim(long? whOid)
		{
			var criteria = CreateCriteriaIsActive<DienstInfo>()
				.Add(Restrictions.Or(Restrictions.Eq("Wohnheim", whOid), Restrictions.IsNull("Wohnheim")));

			return criteria.List<DienstInfo>(); // Hier fliegt man raus
		}

		public long? GetActiveMedVerListOidForCustomer(long customerOid)
		{
			// Gültig und MedListType = 0
			return GetActiveMedListByTypeForCustomer(customerOid, false);
		}

		public long? GetActiveMedListByTypeForCustomer(long customerOid, bool isBedarfsmedikation)
		{
			var criteria = CreateCriteria<Medikamentenverordnungsliste>()
				.Add(Restrictions.Eq(nameof(Medikamentenverordnungsliste.Gueltig), true))
				.Add(Restrictions.Eq(nameof(Medikamentenverordnungsliste.Customer) + ".Oid", customerOid))
				.Add(Restrictions.Eq(nameof(Medikamentenverordnungsliste.MedListType), isBedarfsmedikation));

			var list = criteria.UniqueResult<Medikamentenverordnungsliste>();

			return list?.Oid;
		}

		public List<SchedulerAppointment> LoadOccurrencesByRecurrenceId(string recurrenceId)
		{
			var criteria = CreateCriteria<SchedulerAppointment>()
				.Add(Restrictions.Like(nameof(SchedulerAppointment.RecurrenceInfo), recurrenceId, MatchMode.Anywhere));

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

			return list.ToList();
		}

		// TODO: Intervalle werden als frei angezeigt, wenn sie am Ende eines Tages sind und sich mit Serienterminen überschneiden
		public Dictionary<DateTime, List<DateTimeSpan>> FindAppointmentsInRange(int duration, DateTime intervalStart, DateTime intervalEnd, List<long> resourceOids, List<long> customerOids, List<long> employeeOids, long loggedInEmployeeOid, int intervalBuffer = 30, bool skipWeekends = true)
		{
			var result = new List<SchedulerAppointment>();
			var intervals = IntervalFinderHelper.CreateIntervals(duration, intervalStart, intervalEnd, skipWeekends, intervalBuffer);

			// Das subset enthält die zu prüfenden Tage im angegebenen Intervall.
			// 04.12.2023 15:00 bis 06.12.2023 12:00 wären 04.12.2023, 05.12.2023, 06.12.2023 im subset.
			var subset = IntervalFinderHelper.GenereateIntervalsForChecking(intervalStart, intervalEnd);

			// Es werden im subset nach überschneidenden Terminen gesucht.
			// 
			foreach (var dts in subset)
			{
				var start = dts.StartDate.MergeDatesByDate(intervalStart);
				var end = dts.EndDate.MergeDatesByDate(intervalEnd);

				var apptmts = LoadAppointmentsForIntervalFinder(start, end, resourceOids, customerOids, employeeOids, loggedInEmployeeOid, skipWeekends);

				result.AddRangeIfElementsNotIn(apptmts);
			}

			/*
            Normal = 0,
            Pattern = 1,
            Occurrence = 2,
            ChangedOccurrence = 3,
            DeletedOccurrence = 4
            */

			var changedOccurrences = result.Where(a => a.Type == 3).Select(s => BS.Shared.Core.Utils.GetOccurrenceId(s.RecurrenceInfo)).ToList();
			var deletedOccurrences = result.Where(a => a.Type == 4).Select(s => BS.Shared.Core.Utils.GetOccurrenceId(s.RecurrenceInfo)).ToList();

			var kek = IntervalFinderHelper.GetRecurrencesForIntervalFinder(result, intervalStart, intervalEnd, changedOccurrences, deletedOccurrences, skipWeekends);

			result.AddRange(kek);

			var freeIntervals = new List<DateTimeSpan>();

			if (intervals.Count > 0)
			{
				if (result.Count > 0)
				{
					foreach (var interval in intervals)
					{
						if (!result.Any(a => a.StartDate.HasValue && a.EndDate.HasValue && a.StartDate.Value.IsInInterval(a.EndDate.Value, interval.StartDate, interval.EndDate)))
						{
							freeIntervals.Add(interval);
						}
					}
				}
				else
				{
					return IntervalFinderHelper.CreateFreeIntervalsDictionary(intervals);
				}
			}

			return IntervalFinderHelper.CreateFreeIntervalsDictionary(freeIntervals);
		}

		public Dictionary<DateTimeSpan, Dictionary<DateTime, bool>> FindAppointmentsInRangeForIntervalFinder(int duration, DateTime intervalStart, DateTime intervalEnd, List<long> resourceOids, List<long> customerOids, List<long> employeeOids, long loggedInEmployeeOid, int intervalBuffer = 30, bool skipWeekends = true)
		{
			var result = new List<SchedulerAppointment>();

			var intervals = IntervalFinderHelper.CreateIntervals(duration, intervalStart, intervalEnd, skipWeekends, intervalBuffer);

			// Das subset enthält die zu prüfenden Tage im angegebenen Intervall.
			// 04.12.2023 15:00 bis 06.12.2023 12:00 wären 04.12.2023, 05.12.2023, 06.12.2023 im subset.
			var subset = IntervalFinderHelper.GenereateIntervalsForChecking(intervalStart, intervalEnd);

			// Es werden im subset nach überschneidenden Terminen gesucht.
			foreach (var dts in subset)
			{
				var start = dts.StartDate.MergeDatesByDate(intervalStart);
				var end = dts.EndDate.MergeDatesByDate(intervalEnd);

				var apptmts = LoadAppointmentsForIntervalFinder(start, end, resourceOids, customerOids, employeeOids, loggedInEmployeeOid, skipWeekends);

				result.AddRangeIfElementsNotIn(apptmts);
			}

			/*
            Normal = 0,
            Pattern = 1,
            Occurrence = 2,
            ChangedOccurrence = 3,
            DeletedOccurrence = 4
            */

			var changedOccurrences = result.Where(a => a.Type == 3).Select(s => BS.Shared.Core.Utils.GetOccurrenceId(s.RecurrenceInfo)).ToList();
			var deletedOccurrences = result.Where(a => a.Type == 4).Select(s => BS.Shared.Core.Utils.GetOccurrenceId(s.RecurrenceInfo)).ToList();

			var kek = IntervalFinderHelper.GetRecurrencesForIntervalFinder(result, intervalStart, intervalEnd, changedOccurrences, deletedOccurrences, skipWeekends);

			result.AddRange(kek);

			var freeIntervals = new List<DateTimeSpan>();

			if (intervals.Count > 0)
			{
				if (result.Count > 0)
				{
					foreach (var interval in intervals)
					{
						if (!result.Any(a => a.StartDate.HasValue && a.EndDate.HasValue && a.StartDate.Value.IsInInterval(a.EndDate.Value, interval.StartDate, interval.EndDate)))
						{
							freeIntervals.Add(interval);
						}
					}
				}
				else
				{
					return IntervalFinderHelper.CreateFreeIntervals(intervals, intervalStart, intervalEnd, intervalBuffer, duration);
				}
			}

			return IntervalFinderHelper.CreateFreeIntervals(freeIntervals, intervalStart, intervalEnd, intervalBuffer, duration);
		}

		private IEnumerable<SchedulerAppointment> LoadAppointmentsForIntervalFinder(DateTime intervalStart, DateTime intervalEnd, IReadOnlyCollection<long> resourceOids, IReadOnlyCollection<long> customerOids, List<long> employeeOids, long loggedInEmployeeOid, bool skipWeekends)
		{
			var result = new List<SchedulerAppointment>();

			if (intervalStart < intervalEnd)
			{
				var intervals = IntervalFinderHelper.GenerateIntervalsForCriteria(intervalStart, intervalEnd, skipWeekends);

				var intervalRecurrenceCriterias = IntervalFinderHelper.CreateIntervalRecurrenceCriterias(intervals, skipWeekends);

				var or = CreateOrCriteria(intervalRecurrenceCriterias);

				var criteria = CreateCriteriaIsActiveWithAlias<SchedulerAppointment>("sa")
					.Add(Restrictions.Not(Restrictions.Eq(nameof(SchedulerAppointment.IsTask), true)));

				if (intervals.Count > 0)
				{
					if (intervals.Count > 1)
					{
						var criterionList = new List<ICriterion>();

						foreach (var dts in intervals)
						{
							criterionList.AddIfNotIn(
								Restrictions.Or(
									Restrictions.Between(nameof(SchedulerAppointment.StartDate), dts.StartDate, dts.EndDate),
									Restrictions.Or(
										Restrictions.Between(nameof(SchedulerAppointment.EndDate), dts.StartDate, dts.EndDate),
										Restrictions.And(
											Restrictions.Lt(nameof(SchedulerAppointment.StartDate), dts.StartDate),
											Restrictions.Gt(nameof(SchedulerAppointment.EndDate), dts.EndDate)))
								));
						}

						criteria.Add(Restrictions.Or(or, CreateOrCriteria(criterionList)));
					}
					else
					{
						var dts = intervals.FirstOrDefault();

						if (dts != null)
						{
							var cri = Restrictions.Or(
								Restrictions.Between(nameof(SchedulerAppointment.StartDate), dts.StartDate, dts.EndDate),
								Restrictions.Or(
									Restrictions.Between(nameof(SchedulerAppointment.EndDate), dts.StartDate, dts.EndDate),
									Restrictions.And(
										Restrictions.Lt(nameof(SchedulerAppointment.StartDate), dts.StartDate),
										Restrictions.Gt(nameof(SchedulerAppointment.EndDate), dts.EndDate)))
							);

							criteria.Add(Restrictions.Or(or, cri));
						}
					}
				}

				ICriterion resourceCriterion = null;
				ICriterion customerCriterion = null;

				if (employeeOids.Count == 0)
				{
					employeeOids.Add(loggedInEmployeeOid);
				}

				var detachedCriteria1 = DetachedCriteria.For<Employee2SchedulerAppointment>()
					.Add(Restrictions.In(nameof(Employee2SchedulerAppointment.Employee) + ".Oid", employeeOids))
					.SetProjection(Projections.Property(nameof(Employee2SchedulerAppointment.SchedulerAppointmentOid)));
				var employee2SchedCrit = Subqueries.PropertyIn(nameof(BeWoEntityBase.Oid), detachedCriteria1);

				var originatorCrit = Restrictions.In(nameof(SchedulerAppointment.Originator), employeeOids);

				var detachedCriteria2 = DetachedCriteria.For<Employee2SchedulerAppointment>("e2s2")
					.SetProjection(Projections.Property(nameof(BeWoEntityBase.Oid)))
					.Add(Restrictions.EqProperty("e2s2." + nameof(Employee2SchedulerAppointment.SchedulerAppointmentOid), "sa.Oid"));

				var employee2SchedCrit2 = Subqueries.NotExists(detachedCriteria2);

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

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

				if (customerOids?.Count > 0)
				{
					var customerSql = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM customer2newschapp WHERE customeroid IN ({customerOids.ToSeparatedString(",")}))";
					customerCriterion = Expression.Sql(customerSql);
				}

				if (resourceOids?.Count > 0)
				{
					var resourceSql = $"{BeWoEntityBase.PropertyName_Oid} IN (SELECT newschappoid FROM resource2newschapp WHERE resourceoid IN ({resourceOids.ToSeparatedString(",")}))";
					resourceCriterion = Expression.Sql(resourceSql);
				}

				var listOfCriterias = new List<ICriterion>
				{
					employeeCriterion,
					customerCriterion,
					resourceCriterion
				};

				if (listOfCriterias.Count > 0)
				{
					var orCriteria = CreateOrCriteria(listOfCriterias);

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

				var criteriaAsString = criteria.ToString();

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

				result.AddRange(appointments);
			}

			return result;
		}

		private static string GetGeneratedSql(ICriteria criteria)
		{
			var criteriaImpl = (CriteriaImpl)criteria;
			var sessionImpl = (SessionImpl)criteriaImpl.Session;
			var factory = (SessionFactoryImpl)sessionImpl.SessionFactory;
			var implementors = factory.GetImplementors(criteriaImpl.EntityOrClassName);
			var loader = new CriteriaLoader((IOuterJoinLoadable)factory.GetEntityPersister(implementors[0]), factory, criteriaImpl, implementors[0], sessionImpl.EnabledFilters);

			return loader.SqlString.ToString();
		}

		public long GetMaxOidFromFileAttachment()
		{
			var q = Session.CreateSQLQuery("select max(oid) from fileattachment");
			return q.List<long>().First();
		}

		public IEnumerable<AbsenceTime> GetAllAbsenceTimesInIntervalForCustomers(DateTime start, DateTime end, List<long> customerOids)
		{
			// 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(nameof(AbsenceTime.CustomerOid)))
				.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)))
				)
				.Add(Restrictions.In(nameof(AbsenceTime.CustomerOid), customerOids));

			var absenceTimes = criteria.List<AbsenceTime>();

			return criteria.List<AbsenceTime>();
		}

		public IEnumerable<AbsenceTime> GetAllEmployeeAbsenceTimesInIntervalForEmployee(DateTime start, DateTime end, List<long> employeeOids)
		{
			// 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(nameof(AbsenceTime.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)))
				)
				.Add(Restrictions.In(nameof(AbsenceTime.EmployeeOid), employeeOids));

			return criteria.List<AbsenceTime>();
		}

		public List<Customer> FindAllCustomersForEmployee(long? employeeOid, CustomerFilterEnum customerFilter)
		{
			ApplicationUser user;

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

			var criteria = CreateCriteria<Customer>();

			// Der ApplicationUser darf alles sehen
			var viewAllRights = new List<UserRightType> { UserRightType.CustomerView_View };

			if (user.CheckForAtLeastOneRight(viewAllRights) && customerFilter == CustomerFilterEnum.All)
			{
				return criteria.List<Customer>().ToList();
			}

			var ownCustomerOids = user.Employee?.Employee2CustomerList.Where(employee2Customer => employee2Customer.Customer.Oid.HasValue).Select(employee2Customer => employee2Customer.Customer.Oid.Value).Distinct().ToList() ?? new List<long>();

			var customerOids = new List<long>();

			// Der ApplicationUser darf die Klienten seiner Teams sehen
			if (user.CheckForRight(UserRightType.Customer_ViewMyTeams) && (customerFilter == CustomerFilterEnum.TeamCustomer || customerFilter == CustomerFilterEnum.All) && (user.Employee?.Oid.HasValue ?? false))
			{
				var teams = FindAllActiveTeamsOfEmployee(user.Employee.Oid.Value);

				teams.DoForEach(team =>
				{
					if (team.Oid is null)
					{
						return;
					}

					var customer = FindCustomerOfTeam(team.Oid.Value);

					customerOids.AddRangeIfElementsNotIn(customer.Where(w => w.Oid.HasValue).Select(c => c.Oid.Value));
				});
			}

			// Der ApplicationUser darf seine eigenen Klienten sehen.
			if (user.CheckForRight(UserRightType.Customer_ViewMyCustomers) && (customerFilter == CustomerFilterEnum.All || customerFilter == CustomerFilterEnum.MyCustomer))
			{
				customerOids.AddRangeIfElementsNotIn(ownCustomerOids);
			}

			var visibleCustomers = criteria.Add(Restrictions.In(nameof(Customer.Oid), customerOids.ToArray())).List<Customer>().ToList();

			return visibleCustomers;
		}

		public IList<Employee> FindAllEmployeesForEmployee(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 criteria = CreateCriteria<Employee>();

			if (rights.Contains(UserRightType.EmployeeView_View))
			{
				return criteria.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 List<SchedulerAppointment> LoadAppointmentsWithServiceRecords(List<long> serviceRecordOids)
		{
			var c = CreateCriteria<SchedulerAppointment>()
				.CreateAlias(nameof(SchedulerAppointment.ServiceRecordList), "sr", JoinType.InnerJoin)
				.Add(Restrictions.In($"sr.{nameof(BeWoEntityBase.Oid)}", serviceRecordOids.ToArray()))
				.SetResultTransformer(new DistinctRootEntityResultTransformer());

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

		/*
         * public bool HasConfirmationReceiptSignature(IList<long> serviceRecordOids, SignatureType signatureType)
        {
            // Prüfen, ob alle ServiceRecords mit ein und derselben Unterschrift 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;
        }
         */

		public bool CheckForConfirmationReceiptSignatureForServiceRecord(long serviceRecordOid, SignatureType signatureType)
		{
			var critreria = CreateCriteriaIsActive<ConfirmationReceiptSignature>()
				.Add(Restrictions.Eq(nameof(ConfirmationReceiptSignature.SignatureType), signatureType))
				.CreateAlias(nameof(ConfirmationReceiptSignature.ServiceRecords), "serviceRecords", JoinType.InnerJoin)
				.Add(Restrictions.Eq($"serviceRecords.{nameof(BeWoEntityBase.Oid)}", serviceRecordOid));

			var signature = critreria.List<ConfirmationReceiptSignature>().ToList();

			return signature.Count == 1;
		}

		/// <summary>
		/// Prüft anhand der Oids von Ressourcen deren Verfügbarkeit in einem Zeitraum.
		/// Gibt die nicht verfügbaren Ressourcen und Mitarbeiter, die sie gebucht aben zurück für eine detaillierte Fehlermeldung.
		/// </summary>
		/// <param name="resourceOids">Die Oids der zu überprüfenden Ressourcen</param>
		/// <param name="start">Anfang des zu prüfenden Intervalls</param>
		/// <param name="end">Ende des zu prüfenden Intervalls</param>
		/// <param name="selectedAppointmentOid">Die Oid des Termins</param>
		/// <param name="recurrenceId">Recurrence Id, falls es sich um einen Serientermin handelt, der keine eigene Oid hat.</param>
		/// <param name="occurrenceIndex">Occurrence-Index des Serientermins ohne eigene Oid</param>
		/// <returns>Die im angegebenen Zeitraum belegten Ressourcen mit den Mitarbeitern, die sie gebucht haben</returns>
		public List<SchedulerAppointment> FindAppointmentsByResourcesInInterval(List<long> resourceOids, DateTime start, DateTime end, long? selectedAppointmentOid, Guid? recurrenceId = null, int? occurrenceIndex = null)
		{
			var betweenCriterion = CreateBetweenDateTimesCriterion(start, end, "StartDate", "EndDate");

			var c2 = CreateCriteriaIsActive<SchedulerAppointment>()
				//.Add(Restrictions.Not(Restrictions.Eq(nameof(SchedulerAppointment.Type), 4)))
				.Add(betweenCriterion);


			if (!(selectedAppointmentOid is null))
			{
				c2.Add(Restrictions.Not(Restrictions.Eq(nameof(BeWoEntityBase.Oid), selectedAppointmentOid)));
			}

			c2.CreateAlias(nameof(SchedulerAppointment.ResourceList), "resources", JoinType.InnerJoin)
				.Add(Restrictions.In($"resources.{nameof(BeWoEntityBase.Oid)}", resourceOids));

			var tempAppointments = c2.List<SchedulerAppointment>().ToList();

			var isBeingUpdatedToNormalAppointment = false;
			Guid? recurrenceIdToIgnore = null;
			if (selectedAppointmentOid.HasValue)
			{
				// 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>(selectedAppointmentOid.Value);
				var originalRecurrenceId = original?.GetRecurrenceId();

				if (!(originalRecurrenceId is null) && IsNullOrWhiteSpace(recurrenceId?.ToString()))
				{
					isBeingUpdatedToNormalAppointment = true;
					recurrenceIdToIgnore = originalRecurrenceId;
				}
			}

			var appointments = tempAppointments.Where(appointment =>
			{
				if (appointment.RecurrenceInfo is null)
				{
					return true;
				}

				var recId2 = appointment.GetRecurrenceIdAndIndex(out var index);
				return !((recurrenceId?.Equals(recId2) ?? false) && occurrenceIndex == index);
			}).ToList();


			var deletedOccurrences = appointments.Where(app => app.Type == 4).Select(app => BS.Shared.Core.Utils.GetOccurrenceId(app.RecurrenceInfo)).ToList();
			var changedOccurrences = appointments.Where(app => app.Type == 3).Select(app => BS.Shared.Core.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 => FilterRootAppointment(root, recurrenceIdToIgnore)).ToList();

				appointments = appointments.Where(root => FilterRootAppointment(root, recurrenceIdToIgnore)).ToList();
			}

			recurringAppointments = recurringAppointments.Where(s => s.ResourceList.Any(r => r.Oid.HasValue && resourceOids.Contains(r.Oid.Value))).ToList();

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

				var occurrenceCalculator = OccurrenceCalculator.CreateInstance(recurrenceInfo);

				var pattern = StaticAppointmentFactory.CreateAppointment(AppointmentType.Pattern);

				if (pattern is null)
				{
					continue;
				}

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

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

				var interval = new TimeInterval(start, end);

				var occurrences = occurrenceCalculator.CalcOccurrences(interval, pattern);

				foreach (var occurrence in occurrences.GetAppointments(interval))
				{
					if (appointment.EndDate is null || appointment.StartDate is 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 ||
					   changedOccurrences.Any(changedOccurence => changedOccurence.PatternId.Equals(patternId) && changedOccurence.Index == index) ||
					   deletedOccurrences.Any(deletedOccurence => deletedOccurence.PatternId.Equals(patternId) && deletedOccurence.Index == index) ||
					   index == occurrenceIndex && guidParsingSuccessful && recurrenceId != null && recurrenceId.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 && selectedAppointmentOid != null && root.Oid == selectedAppointmentOid && root.RecurrenceInfo != null && IsNullOrWhiteSpace(recurrenceId?.ToString()))
					{
						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
					};

					appointments.AddIfNotIn(recurringAppointment);
				}
			}

			return appointments.Where(appointment => appointment.Type != 4).OrderBy(appointment => appointment.StartDate).ToList();
		}

		private static bool FilterRootAppointment(SchedulerAppointment root, Guid? recurrenceIdToIgnore)
		{
			var recId = root.GetRecurrenceId();

			if (recId is null || recurrenceIdToIgnore is null)
			{
				return true;
			}

			return !recId.Equals(recurrenceIdToIgnore);
		}

		public List<ConfirmationReceiptSignature> LoadAllConfirmationReceiptSignaturesByServiceRecordOids(IList<long> serviceRecordOids)
		{
			var c = CreateCriteria<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 Dictionary<string, List<string>> CheckResourceAvailabilityWithEmployeeInformation(DateTime start, DateTime end, List<long> resourceOids, long? selectedAppointmentOid, Guid? recurrenceId = null, int occurrenceIndex = 0)
		{
			var appointments = FindAppointmentsByResourcesInInterval(resourceOids, start, end, selectedAppointmentOid, recurrenceId, occurrenceIndex);

			var user = LoggedInUserOperationContextExt.Current?.User ?? SessionFacade.LoggedInUser;

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

			if (user is null)
			{
				return result;
			}

			var loggedInEmployee = user.Employee;

			var hasRightToViewEmployeeAppointments = user.CheckForRight(UserRightType.KalenderMitarbeitertermineAnsehen);
			var hasRightToViewResourceAppointments = user.CheckForRight(UserRightType.KalenderRessourcentermineAnsehen);

			var dictionary = new Dictionary<Resource, List<SchedulerAppointment>>();

			foreach (var appointment in appointments)
			{
				foreach (var resource in appointment.ResourceList)
				{
					dictionary.AddOrUpdateValueInDictionary(resource, appointment);
				}
			}

			foreach (var resource2Appointments in dictionary)
			{
				foreach (var appointment in resource2Appointments.Value)
				{
					var originator = appointment.Originator;
					var employee2Appointments = appointment.EmployeeList;

					var isOwnAppointment = (originator?.Equals(loggedInEmployee) ?? false) || employee2Appointments.ToList().Any(e2a => e2a.Employee.Equals(loggedInEmployee));

					// Wenn isOwnAppointment true ist, darf der Benutzer die Uhrzeiten und die Mitarbeiter sehen. Ansonsten müssen die Rechte geprüft werden.
					if (isOwnAppointment || hasRightToViewEmployeeAppointments) // Es werden Zeit und Mitarbeiter angezeigt
					{
						result.AddOrUpdateValueInDictionary(resource2Appointments.Key.Name, $"{CreateDateTimeInfoFromAppointment(appointment.StartDate, appointment.EndDate, appointment.AllDay)} von {originator}");
					}
					else if (hasRightToViewResourceAppointments && !hasRightToViewEmployeeAppointments) // Nur die Uhrzeit anzeigen
					{
						result.AddOrUpdateValueInDictionary(resource2Appointments.Key.Name, $"{CreateDateTimeInfoFromAppointment(appointment.StartDate, appointment.EndDate, appointment.AllDay)}");
					}
					else if (!hasRightToViewEmployeeAppointments) // Es werden weder Zeit noch Mitarbeiter angezeigt
					{
						result.AddOrUpdateValueInDictionary(resource2Appointments.Key.Name, string.Empty);
					}
				}
			}

			return result;
		}

		private static string CreateDateTimeInfoFromAppointment(DateTime? start, DateTime? end, bool allDay)
		{
			if (start.HasValue && end.HasValue && allDay == false)
			{
				return start.Value.Date == end.Value.Date ? $"{start.Value.ToShortTimeString()} - {end.Value.ToShortTimeString()} " : $"{start.Value:dd.MM.yyyy HH:mm} - {end.Value:dd.MM.yyyy HH:mm} ";
			}

			if (allDay && start.HasValue && end.HasValue)
			{
				return start.Value.Date == end.Value.Date ? " " : $"{start.Value.ToShortDateString()} - {end.Value.ToShortDateString()} ";
			}

			return string.Empty;
		}

		public List<ValidationMessage> GetValidationMessagesForMonth(DateTime startDate, DateTime endDate)
		{
			var criteria = CreateCriteria<ValidationMessage>()
				.Add(Restrictions.Gt(ValidationMessage.PropertyName_InsTs, startDate))
				.Add(Restrictions.Lt(ValidationMessage.PropertyName_InsTs, endDate));

			var list = criteria.List<ValidationMessage>();

			return list.ToList();
		}

		public List<ServiceRecord> GetServiceRecordForTimeSpan(DateTime startDate, DateTime endDate)
		{
			var criteria = CreateCriteria<ServiceRecord>()
				.Add(Restrictions.Gt(ServiceRecord.PropertyName_Start, startDate))
				.Add(Restrictions.Lt(ServiceRecord.PropertyName_Start, endDate));

			var list = criteria.List<ServiceRecord>();

			return list.ToList();
		}

		/// <summary>
		/// VERALTET! FindMostRecentSignatureStatusInfoByServiceRecordOid benutzen!
		/// </summary>
		/// <param name="serviceRecordOid"></param>
		/// <returns></returns>
		public ServiceRecordHistory FindMostRecentServiceRecordHistoryEntryByServiceRecordOid(long serviceRecordOid)
		{
			try
			{
				var criteira = CreateCriteria<ServiceRecordHistory>()
					.Add(Restrictions.Eq(nameof(ServiceRecordHistory.ServiceRecordOid), serviceRecordOid))
					.AddOrder(Order.Desc(nameof(ServiceRecordHistory.InsTs)));

				return criteira.List<ServiceRecordHistory>().FirstOrDefault();
			}
			catch (Exception e)
			{
				return null;
			}
		}

		// ToDo: Veraltet und wird nicht mehr benutzt!
		public Dictionary<long, ServiceRecordHistory> FindMostRecentServiceRecordHistoryEntryByServiceRecords(List<long> serviceRecordOids)
		{
			var criteria = CreateCriteria<ServiceRecordHistory>()
				.Add(Restrictions.In(nameof(ServiceRecordHistory.ServiceRecordOid), serviceRecordOids))
				.AddOrder(Order.Desc(nameof(ServiceRecordHistory.InsTs)));

			var historyEntries = criteria.List<ServiceRecordHistory>();

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

			foreach (var entry in historyEntries)
			{
				if (entry.ServiceRecordOid.HasValue && result.ContainsKey(entry.ServiceRecordOid.Value) || entry.ServiceRecordOid is null)
				{
					continue;
				}

				result.AddIfNotIn(new KeyValuePair<long, ServiceRecordHistory>(entry.ServiceRecordOid.Value, entry));
			}

			return result;
		}

		public IEnumerable<ServiceRecordHistory> FindServiceRecordHistoriesInSpan(DateTimeSpan span, long? employeeOid, long? customerOid, StatementType? st)
		{
			var crit = CreateCriteria<ServiceRecordHistory>()
				.Add(Restrictions.Between(ServiceRecordHistory.PropertyName_Start, span.StartDateTime, span.EndDateTime));

			if (st.HasValue)
			{
				crit.Add(Restrictions.Eq(nameof(ServiceRecordHistory.ChangeType), st));
			}

			if (employeeOid.HasValue)
			{
				crit.Add(Restrictions.Eq(nameof(ServiceRecordHistory.EmployeeOid), employeeOid));
			}

			if (customerOid.HasValue)
			{
				crit.Add(Restrictions.Eq(nameof(ServiceRecordHistory.CustomerOid), customerOid));
			}


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

		// ToDo: Veraltet und wird nicht mehr benutzt!
		public List<ServiceRecord> FindFormerlyLinkedServiceRecords(long confirmationReceiptSignatureOid, long customerOid, long supportConceptOid, long costBearer2SupportConceptOid, string timeSpanString)
		{
			if (timeSpanString?.Length != 21)
			{
				return new List<ServiceRecord>();
			}

			var d1 = timeSpanString.Substring(0, 2);
			var m1 = timeSpanString.Substring(3, 2);
			var d2 = timeSpanString.Substring(11, 2);
			var m2 = timeSpanString.Substring(14, 2);
			var year = timeSpanString.Substring(17, 4);

			var timeSpanStart = DateTime.Parse($"{year}-{m1}-{d1}");
			var timeSpanEnd = DateTime.Parse($"{year}-{m2}-{d2}");

			// ToDo: Warum wird geprüft, ob der InsTs im Intervall liegt?
			// ToDo: Die ausschließen, die mit einer aktiven ConfirmationReceiptSignature verlinkt sind!
			var criteria = CreateCriteria<ServiceRecord>()
				//.Add(Restrictions.Between(nameof(ServiceRecord.InsTs), timeSpanStart, timeSpanEnd))
				.Add(Restrictions.Eq(nameof(ServiceRecord.CustomerOid), customerOid))
				.Add(Restrictions.Eq(nameof(ServiceRecord.SupportConcept) + ".Oid", supportConceptOid))
				.Add(Restrictions.Eq(nameof(ServiceRecord.CostBearer2SupportConceptOid), costBearer2SupportConceptOid))
				.Add(Restrictions.Between(nameof(ServiceRecord.Start), timeSpanStart, timeSpanEnd))
				.Add(Restrictions.Between(nameof(ServiceRecord.End), timeSpanStart, timeSpanEnd))
				//.Add(Expression.Sql(new SqlString($"this_.Oid NOT IN (SELECT ServiceRecordOid FROM confirmationreceiptsignature2servicerecord WHERE ConfirmationReceiptSignatureOid = {confirmationReceiptSignatureOid})")));
				.Add(Expression.Sql(new SqlString($"this_.Oid NOT IN (SELECT ServiceRecordOid FROM confirmationreceiptsignature2servicerecord WHERE ConfirmationReceiptSignatureOid IN (SELECT ConfirmationReceiptSignatureOid FROM confirmationreceiptsignature WHERE IsActive = 1))")));

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

		public List<ConfirmationReceiptSignature> LoadAllActiveConfirmationReceiptSignaturesByServiceRecordOids(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<ServiceRecord> FindFormerlyLinkedServiceRecordsBySignatureOid(long confirmationReceiptSignatureOid)
		{
			var sql = new SqlString($"this_.Oid NOT IN (SELECT ServiceRecordOid FROM confirmationreceiptsignature2servicerecord WHERE ConfirmationReceiptSignatureOid = {confirmationReceiptSignatureOid}) AND " +
									$"this_.Oid IN (SELECT ServiceRecordOid FROM servicerecordhistory WHERE CustomerConfirmationReceiptSignatureOid = {confirmationReceiptSignatureOid} OR EmployeeConfirmationReceiptSignatureOid = {confirmationReceiptSignatureOid})");

			var criteria = CreateCriteria<ServiceRecord>()
				.Add(Expression.Sql(sql));

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

		public SignatureStateInfoFromServiceRecordHistoryEntry FindMostRecentSignatureStatusInfoByServiceRecordOid(long serviceRecordOid)
		{
			var sqlQuery = Session.CreateSQLQuery($"SELECT * FROM ServiceRecordHistory WHERE ServiceRecordOid = {serviceRecordOid} ORDER BY InsTs DESC LIMIT 1")
				.AddScalar("CustomerConfirmationReceiptSignatureStateType", NHibernateUtil.Int32)
				.AddScalar("EmployeeConfirmationReceiptSignatureStateType", NHibernateUtil.Int32)
				.AddScalar("ServiceRecordSignatureStateType", NHibernateUtil.Int32)
				.AddScalar("CustomerConfirmationReceiptSignatureOid", NHibernateUtil.Int64)
				.AddScalar("EmployeeConfirmationReceiptSignatureOid", NHibernateUtil.Int64);

			var objectsList = sqlQuery.List<object[]>().ToList();

			var row = objectsList.FirstOrDefault();

			if (row is null || row.Length != 5)
			{
				return null;
			}

			var customerConfirmationReceiptSignatureState = (SignatureStateType)row[0];
			var employeeConfirmationReceiptSignatureState = (SignatureStateType)row[1];
			var serviceRecordSignatureStateType = (SignatureStateType)row[2];
			var customerConfirmationReceiptSignatureOid = (long?)row[3];
			var employeeConfirmationReceiptSignatureOid = (long?)row[4];

			return new SignatureStateInfoFromServiceRecordHistoryEntry(customerConfirmationReceiptSignatureState, employeeConfirmationReceiptSignatureState, serviceRecordSignatureStateType, customerConfirmationReceiptSignatureOid, employeeConfirmationReceiptSignatureOid);
		}

		public Dictionary<long, SignatureStateInfoFromServiceRecordHistoryEntry> FindMostRecentSignatureStatusInfoByServiceRecords(List<long> serviceRecordOids)
		{
			var result = new Dictionary<long, SignatureStateInfoFromServiceRecordHistoryEntry>();

			if (serviceRecordOids is null || serviceRecordOids.Count == 0)
			{
				return result;
			}

			var sqlQuery = Session.CreateSQLQuery($"SELECT * FROM servicerecordhistory WHERE ServiceRecordOid IN ({serviceRecordOids.Aggregate(string.Empty, (current, item) => current + $"{item},").TrimEnd(',')}) ORDER BY InsTs DESC")
				.AddScalar("ServiceRecordOid", NHibernateUtil.Int64)
				.AddScalar("CustomerConfirmationReceiptSignatureStateType", NHibernateUtil.Int32)
				.AddScalar("EmployeeConfirmationReceiptSignatureStateType", NHibernateUtil.Int32)
				.AddScalar("ServiceRecordSignatureStateType", NHibernateUtil.Int32)
				.AddScalar("CustomerConfirmationReceiptSignatureOid", NHibernateUtil.Int64)
				.AddScalar("EmployeeConfirmationReceiptSignatureOid", NHibernateUtil.Int64);

			var objectsList = sqlQuery.List<object[]>().ToList();

			foreach (var obj in objectsList)
			{
				if (obj?.Length != 6)
				{
					continue;
				}

				var serviceRecordOid = (long?)obj[0];

				if (serviceRecordOid is null || result.ContainsKey(serviceRecordOid.Value))
				{
					continue;
				}

				var customerConfirmationReceiptSignatureState = (SignatureStateType)obj[1];
				var employeeConfirmationReceiptSignatureState = (SignatureStateType)obj[2];
				var serviceRecordSignatureStateType = (SignatureStateType)obj[3];
				var customerConfirmationReceiptSignatureOid = (long?)obj[4];
				var employeeConfirmationReceiptSignatureOid = (long?)obj[5];

				result.AddIfNotIn(new KeyValuePair<long, SignatureStateInfoFromServiceRecordHistoryEntry>(serviceRecordOid.Value, new SignatureStateInfoFromServiceRecordHistoryEntry(customerConfirmationReceiptSignatureState, employeeConfirmationReceiptSignatureState, serviceRecordSignatureStateType, customerConfirmationReceiptSignatureOid, employeeConfirmationReceiptSignatureOid)));
			}

			return result;
		}

		#region MoK-Zeiterfassungspagination

		public IEnumerable<ServiceRecord> FindServiceRecordsForDaysPaginated(long? costBearer2SupportConceptOid, int dayCount, long? employeeOid, int firstResult, int maxResults, out int rowCount)
		{
			var minStart = DateTime.Now.GetShortDateTime().AddDays(-dayCount);
			var criteria = CreateCriteriaIsActive<ServiceRecord>();
			var rowCountCirteria = CreateCriteriaIsActive<ServiceRecord>();

			if (costBearer2SupportConceptOid.HasValue)
			{
				var groupOidsQuery = Session.CreateSQLQuery($"SELECT MIN(Oid) FROM servicerecord WHERE CostBearer2SupportConceptOid = {costBearer2SupportConceptOid} GROUP BY GroupOid");
				var groupOids = groupOidsQuery.List<long>().ToArray();

				criteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costBearer2SupportConceptOid));
				rowCountCirteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_CostBearer2SupportConceptOid, costBearer2SupportConceptOid));

				criteria.Add(Restrictions.Or(Restrictions.IsNull(nameof(ServiceRecord.GroupOid)), Restrictions.In(nameof(ServiceRecord.Oid), groupOids)));
				rowCountCirteria.Add(Restrictions.Or(Restrictions.IsNull(nameof(ServiceRecord.GroupOid)), Restrictions.In(nameof(ServiceRecord.Oid), groupOids)));
			}
			else
			{
				criteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, employeeOid))
					.Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));

				rowCountCirteria.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, employeeOid))
					.Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));
			}

			if (dayCount > 0)
			{
				var intervalStart = minStart;
				var intervalEnd = minStart.AddDays(dayCount + 1).AddSeconds(-1);

				var timesCriterion = CreateBetweenDateTimesCriterion(intervalStart, intervalEnd, nameof(ServiceRecord.Start), nameof(ServiceRecord.End));

				criteria.Add(timesCriterion);
				rowCountCirteria.Add(timesCriterion);
			}

			criteria.AddOrder(Order.Desc(nameof(ServiceRecord.Start))).AddOrder(Order.Desc(nameof(ServiceRecord.End))).AddOrder(Order.Desc(nameof(BeWoEntityBase.InsTs)));

			rowCount = rowCountCirteria.SetProjection(Projections.RowCount()).FutureValue<int>().Value;

			var serviceRecords = criteria.SetFirstResult(firstResult).SetMaxResults(maxResults).Future<ServiceRecord>();

			return serviceRecords;
		}

		public IEnumerable<ServiceRecord> FindEmployeeServiceRecordsWithoutCustomerPaginated(long pEmployeeOid, long? days, int firstResult, int maxResults, out int rowCount)
		{
			var criteria = CreateCriteria<ServiceRecord>()
				.Add(Restrictions.Eq(ServiceRecord.PropertyName_EmployeeOid, pEmployeeOid))
				.Add(Restrictions.IsNull(ServiceRecord.PropertyName_CostBearer2SupportConceptOid));

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

			if (days is object)
			{
				var intervalStart = DateTime.Now.GetShortDateTime().AddDays(-days.Value);
				var intervalEnd = intervalStart.AddDays(days.Value + 1).AddSeconds(-1);

				var timesCriterion = CreateBetweenDateTimesCriterion(intervalStart, intervalEnd, nameof(ServiceRecord.Start), nameof(ServiceRecord.End));

				criteria.Add(timesCriterion);
				rowCountCirteria.Add(timesCriterion);
			}

			criteria.AddOrder(Order.Desc(nameof(ServiceRecord.Start))).AddOrder(Order.Desc(nameof(ServiceRecord.End))).AddOrder(Order.Desc(nameof(BeWoEntityBase.InsTs)));

			rowCount = rowCountCirteria.SetProjection(Projections.RowCount()).FutureValue<int>().Value;

			return criteria.SetFirstResult(firstResult).SetMaxResults(maxResults).Future<ServiceRecord>();
		}

		public IEnumerable<ServiceRecord> FindServiceRecordsDetailsForLastDaysWithStartEndDatePaginated(long costbearer2SupportConcept, DateTime start, DateTime ende, int firstResult, int maxResults, out int rowCount)
		{
			var groupOidsQuery = Session.CreateSQLQuery($"SELECT MIN(Oid) FROM servicerecord WHERE CostBearer2SupportConceptOid = {costbearer2SupportConcept} GROUP BY GroupOid");
			var groupOids = groupOidsQuery.List<long>().ToArray();

			var criteria = CreateCriteria<ServiceRecord>()
				.Add(Restrictions.Eq(nameof(ServiceRecord.CostBearer2SupportConceptOid), costbearer2SupportConcept));

			var rowCountCirteria = CreateCriteria<ServiceRecord>()
				.Add(Restrictions.Eq(nameof(ServiceRecord.CostBearer2SupportConceptOid), costbearer2SupportConcept));

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

			criteria.Add(Restrictions.Ge(nameof(ServiceRecord.Start), start.Date))
				.Add(Restrictions.Le(nameof(ServiceRecord.Start), max));

			rowCountCirteria.Add(Restrictions.Ge(nameof(ServiceRecord.Start), start.Date))
				.Add(Restrictions.Le(nameof(ServiceRecord.Start), max));

			criteria.Add(Restrictions.Or(Restrictions.IsNull(nameof(ServiceRecord.GroupOid)), Restrictions.In(nameof(ServiceRecord.Oid), groupOids)));
			rowCountCirteria.Add(Restrictions.Or(Restrictions.IsNull(nameof(ServiceRecord.GroupOid)), Restrictions.In(nameof(ServiceRecord.Oid), groupOids)));

			criteria.AddOrder(Order.Desc(nameof(ServiceRecord.Start))).AddOrder(Order.Desc(nameof(ServiceRecord.End))).AddOrder(Order.Desc(nameof(BeWoEntityBase.InsTs)));

			rowCount = rowCountCirteria.SetProjection(Projections.RowCount()).FutureValue<int>().Value;

			var result = criteria
					.CreateAlias(nameof(ServiceRecord.ServiceDescription), "sd", JoinType.InnerJoin)
					.CreateAlias($"sd.{nameof(ServiceDescription.ServiceCategory)}", "sc", JoinType.InnerJoin)
					.SetFirstResult(firstResult)
					.SetMaxResults(maxResults)
					.Future<ServiceRecord>();

			return result;
		}

		public IEnumerable<ServiceRecord> FindEmployeeServiceRecordsWithoutCustomerWithStartEndDatePaginated(long pEmployeeOid, DateTime start, DateTime ende, int firstResult, int maxResults, out int rowCount)
		{

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

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

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

			criteria.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, start.Date))
				.Add(Restrictions.Le(ServiceRecord.PropertyName_End, max.Date));

			rowCountCirteria.Add(Restrictions.Ge(ServiceRecord.PropertyName_Start, start.Date))
				.Add(Restrictions.Le(ServiceRecord.PropertyName_End, max.Date));

			criteria.AddOrder(Order.Desc(nameof(ServiceRecord.Start))).AddOrder(Order.Desc(nameof(ServiceRecord.End))).AddOrder(Order.Desc(nameof(BeWoEntityBase.InsTs)));

			rowCount = rowCountCirteria.SetProjection(Projections.RowCount()).FutureValue<int>().Value;

			return criteria.SetFirstResult(firstResult).SetMaxResults(maxResults).Future<ServiceRecord>();
		}

		#endregion

		public Signature LoadSignatureByTransaktionsOid(long transaktionsOid)
		{
			var criteria = CreateCriteria<Signature>()
				.Add(Restrictions.Eq(nameof(Signature.BargeldtransaktionsOid), transaktionsOid));

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

		public List<long> LoadSignatureOidsByTransaktionOid(long transactionOid)
		{
			var criteria = CreateCriteria<Signature>()
				.Add(Restrictions.Eq(nameof(Signature.BargeldtransaktionsOid), transactionOid));

			return criteria.List<Signature>().Select(s => s.Oid.Value).ToList();
		}

		public List<Signature> LoadSignaturesByTransactionOids(List<long> transactionOids)
		{
			var criteria = CreateCriteria<Signature>()
				.Add(Restrictions.In(nameof(Signature.BargeldtransaktionsOid), transactionOids));

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

		public List<Bargeldtransaktionshistory> LoadBargeldtransaktionshistoryEntries(long transaktionsOid)
		{
			var criteria = CreateCriteria<Bargeldtransaktionshistory>()
				.Add(Restrictions.Eq(nameof(Bargeldtransaktionshistory.BargeldtransaktionOid), transaktionsOid));

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

		public int GetNextDatenaustauschreferenz(string datenannahmestelle)
		{
			var criteria = CreateCriteria<GkvTransferProtokoll>()
				.Add(Restrictions.Where<GkvTransferProtokoll>(x => x.SentApp8Success && x.IKDatenannahmestelle == datenannahmestelle))
				.SetProjection(Projections.Max("Datenaustauschreferenz"));

			var t = criteria.List<int?>().SingleOrDefault();

			return t + 1 ?? 1;
		}

		public int GetNextTransfernummer(string datenannahmestelle)
		{
			var criteria = CreateCriteria<GkvTransferProtokoll>()
				.Add(Restrictions.Where<GkvTransferProtokoll>(x => x.SentApp8Success && x.IKDatenannahmestelle == datenannahmestelle))
				.SetProjection(Projections.Max("Transfernummer"));

			var t = criteria.List<int?>().SingleOrDefault();

			return t + 1 ?? 0;
		}

		public List<Organisation> GetAllOrganisationByIKKrankenkasse(string ikkrankenkasse)
		{
			var criteria = CreateCriteria<Organisation>()
				.Add(Restrictions.Where<Organisation>(x => x.IKKrankenkasse == ikkrankenkasse));

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

		public List<Bargeldtransaktionshistory> LoadBargeldtransaktionshistoryEntriesByTransaktionsOids(List<long> transaktionsOids)
		{
			var criteria = CreateCriteriaIsActive<Bargeldtransaktionshistory>()
				.Add(Restrictions.In(nameof(Bargeldtransaktionshistory.BargeldtransaktionOid), transaktionsOids));

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

		public List<ValueListEntry> GetGoalCategoriesByOids(List<long> oids)
		{
			var criteria = CreateCriteriaIsActive<ValueListEntry>()
				.Add(
					Restrictions.Or(
						Restrictions.Eq(nameof(ValueListEntry.Type), ValueListEntryType.SupportConceptGoalCategoryType),
						Restrictions.Eq(nameof(ValueListEntry.Type), ValueListEntryType.SupportConceptIndividualGoalCategoryType)))
				.AddOrder(Order.Asc(nameof(ValueListEntry.Value)));

			return criteria.List<ValueListEntry>().OrderBy(valueListEntry => $"{valueListEntry.Abbreviation}-{valueListEntry.Value}").ToList();
		}

		public List<SupportConcept> FindSupportConceptsByCostbearer2SupportConceptRelOids(List<long> costbearer2SupportConceptRelOids)
		{
			var criteria = CreateCriteria<SupportConcept>()
				.CreateAlias(nameof(SupportConcept.CostBearer2SupportConceptList), "cb2Sc", JoinType.InnerJoin)
				.Add(Restrictions.In($"cb2Sc.{nameof(BeWoEntityBase.Oid)}", costbearer2SupportConceptRelOids.ToArray()));

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

		public virtual IList<Customer> FindCustomersOfTeams(IEnumerable<long> teamOids)
		{
			return CreateCriteriaIsActiveOrArchived<Customer>()
				.CreateCriteria(nameof(Customer.Team2CustomerList), JoinType.InnerJoin)
				.Add(Restrictions.In(nameof(Team2Customer.TeamOid), teamOids.ToArray()))
				.List<Customer>();
		}

		public List<Customer> FindCustomersForPaginatedQb(int firstResult, int maxResults, bool checkTeamCustomerRights, DateTime start, DateTime end, out int rowCount)
		{
			var user = LoggedInUserOperationContextExt.Current?.User ?? SessionFacade.LoggedInUser;

			var rights = new List<UserRightType>();
			foreach (var userGroup in user.UserGroups)
			{
				rights.AddRangeIfElementsNotIn(userGroup.Rights.Select(rightRelation => rightRelation.RightType));
			}

			var hasRightCustomerViewView = rights.Contains(UserRightType.CustomerView_View);
			var hasRightCustomerViewMyTeams = rights.Contains(UserRightType.Customer_ViewMyTeams);

			IList<long> customerOidsWithQb = null;
			ICriteria criteria = CreateCriteriaIsActive<Customer>();

			if (!hasRightCustomerViewView)
			{
				if (checkTeamCustomerRights && hasRightCustomerViewMyTeams)
				{
					criteria = criteria
						.CreateCriteria(nameof(Customer.Team2CustomerList), JoinType.InnerJoin)
						.Add(Restrictions.In(nameof(Team2Customer.TeamOid), user.Employee.LeadingTeams.Select(team => team.Oid.Value).ToArray()));

				}
				else
				{
					var allOwnCustomerOids = user.Employee.Employee2CustomerList.Select(e2C => e2C.Customer.Oid.Value).ToList();

					criteria = criteria
						.Add(Restrictions.In(nameof(BeWoEntityBase.Oid), allOwnCustomerOids));
				}
			}


			customerOidsWithQb = FilterCustomerOidsWithQuittierungsbeleg(criteria.List<Customer>().Select(c => c.Oid.Value).Distinct().ToArray(), start, end);

			var customers = criteria
				.Add(Restrictions.In(nameof(BeWoEntityBase.Oid), customerOidsWithQb.ToArray()))
				.CreateAlias(nameof(Customer.Person), "p", JoinType.InnerJoin)
				.AddOrder(Order.Asc($"p.{nameof(Person.LastName)}"))
				.SetFirstResult(firstResult)
				.SetMaxResults(maxResults)
				.Future<Customer>()
				.ToList();

			rowCount = customerOidsWithQb.Count;
			return customers;
		}

		public List<Customer> FindCustomersForPaginatedQbByOids(int firstResult, int maxResults, long[] customerOids, DateTime start, DateTime end, out int rowCount)
		{
			//rowCount = GetRowCountForQuittierungsbelegPagination(customerOids, start, end);
			var list = FilterCustomerOidsWithQuittierungsbeleg(customerOids, start, end);
			rowCount = list.Count;

			return CreateCriteriaIsActive<Customer>()
				.Add(Restrictions.In(nameof(BeWoEntityBase.Oid), list.ToArray()))
				.CreateAlias(nameof(Customer.Person), "p", JoinType.InnerJoin)
				.AddOrder(Order.Asc($"p.{nameof(Person.LastName)}"))
				.SetFirstResult(firstResult)
				.SetMaxResults(maxResults)
				.Future<Customer>()
				.ToList();
		}

		private IList<long> FilterCustomerOidsWithQuittierungsbeleg(long[] customerOids, DateTime start, DateTime end)
		{
			if (customerOids.Length == 0)
			{
				return new List<long>();
			}

			String oidList = "";

			for (int i = 0; i < customerOids.Length; i++)
			{
				if (oidList.Length > 0)
				{
					oidList += ",";
				}

				oidList += customerOids[i];
			}

			var sql = $"select distinct c.oid from customer c inner join servicerecord sr on c.oid = sr.customeroid where c.IsActive = 1 and sr.StartDate >= ':Start' and sr.StartDate < ':End' and c.oid in (:OidList)";
			sql = sql.Replace(":Start", String.Format("{0:yyyy-MM-dd}", start));
			sql = sql.Replace(":End", String.Format("{0:yyyy-MM-dd}", end.Date.AddDays(1)));
			sql = sql.Replace(":OidList", oidList);
			var q = Session.CreateSQLQuery(sql);
			return q.List<long>();

			//var customerCountWithQuittierungsbelegInSpan = CreateCriteriaIsActive<Customer>()
			//	.Add(Restrictions.In(nameof(BeWoEntityBase.Oid), customerOids))
			//	.CreateAlias(nameof(Customer.ServiceRecordList), "sr", JoinType.InnerJoin)
			//	.Add(Restrictions.Between($"sr.{nameof(ServiceRecord.Start)}", start, end))
			//	.SetProjection(Projections.CountDistinct(nameof(BeWoEntityBase.Oid))).FutureValue<int>().Value;

			//return customerCountWithQuittierungsbelegInSpan;
		}

		public long GetServiceRecordCountForServiceCategory(long catOid)
		{
			var sql = $"SELECT COUNT(sr.oid) FROM ServiceRecord sr join ServiceDescription sd on sr.ServiceDescriptionOid = sd.Oid WHERE sd.ServiceCategoryOid = {catOid}";
			var q = Session.CreateSQLQuery(sql);
			return q.List<long>().First();
		}

        public long GetServiceRecordCountForServiceDescription(long descOid)
        {
            var sql = $"SELECT COUNT(sr.oid) FROM ServiceRecord sr WHERE sr.ServiceDescriptionOid = {descOid}";
            var q = Session.CreateSQLQuery(sql);
            return q.List<long>().First();
        }
        public List<ServiceRecord> GetServiceRecordsForServiceDescriptionAndCustomer(long descOid, long cOid)
        {

            var desc = DAOFactory.GenericDAO.GetByID<ServiceDescription>(descOid);
            var criteria = CreateCriteria<ServiceRecord>()
                .Add(Restrictions.Eq(ServiceRecord.PropertyName_CustomerOid, cOid))
                .Add(Restrictions.Eq(ServiceRecord.PropertyName_ServiceDescription, desc));

            var list = criteria.List<ServiceRecord>();

            return list.ToList();
        }

		public string GetGkvRawData(long oid, GkvRawDataType gkvRawData)
		{
			var criteria = CreateCriteria<GkvTransferProtokoll>()
				.Add(Restrictions.Where<GkvTransferProtokoll>(x => x.Oid == oid));

			if (gkvRawData == GkvRawDataType.Auftragsdatei)
			{
				criteria = criteria.SetProjection(Projections.Property(nameof(GkvTransferProtokoll.Auftragsdatei)));
			}
			else if (gkvRawData == GkvRawDataType.Nutzdatendatei)
			{
				criteria = criteria.SetProjection(Projections.Property(nameof(GkvTransferProtokoll.Nutzdatendatei)));
			}
			else
			{
				throw new ArgumentOutOfRangeException(nameof(gkvRawData), $"GkvRawDataType \'{gkvRawData}\' unbekannt.");
			}

			var t = criteria.List<string>().SingleOrDefault();

			return t;
		}


		private int GetRowCountForQuittierungsbelegPagination(long[] customerOids, DateTime start, DateTime end)
		{
			var customerCountWithQuittierungsbelegInSpan = CreateCriteriaIsActive<Customer>()
				.Add(Restrictions.In(nameof(BeWoEntityBase.Oid), customerOids))
				.CreateAlias(nameof(Customer.ServiceRecordList), "sr", JoinType.InnerJoin)
				.Add(Restrictions.Between($"sr.{nameof(ServiceRecord.Start)}", start, end.AddDays(1).AddSeconds(-1)))
				.SetProjection(Projections.CountDistinct(nameof(BeWoEntityBase.Oid))).FutureValue<int>().Value;

			return customerCountWithQuittierungsbelegInSpan;
		}

		public Bargeldkasse FindBargeldkasseByBargeldtransaktion(long transaktionsoid)
		{
			return CreateCriteria<Bargeldkasse>()
				.CreateAlias(nameof(Bargeldkasse.Bargeldtransaktionen), "t", JoinType.InnerJoin)
				.Add(Restrictions.Eq($"t.{nameof(BeWoEntityBase.Oid)}", transaktionsoid))
				.UniqueResult<Bargeldkasse>();
		}

		/// <summary>
		/// Erzeugt einen SignatureHistory-Eintrag auf Basis einer Einzelunterschrift oder einer Bargeldtransaktionsunterschrift.
		/// </summary>
		/// <param name="signature">Unterschriftenobjekt</param>
		/// <param name="signatureEventType">Der Eventtyp, der besagt, ob es sich um ein Insert, Update, oder Delete der Unterschrift handelt.</param>
		/// <returns></returns>
		public SignatureHistory CreateSignatureHistoryEntry(Signature signature, SignatureEventType signatureEventType)
		{
			if (signature?.ServiceRecordOid is null && signature?.BargeldtransaktionsOid is null)
			{
				return null;
			}

			ServiceRecord serviceRecord = signature.ServiceRecordOid.HasValue
				? DAOFactory.GenericDAO.GetByID<ServiceRecord>(signature.ServiceRecordOid.Value)
				: null;

			Bargeldtransaktion bargeldtransaktion = signature.BargeldtransaktionsOid.HasValue
				? DAOFactory.GenericDAO.GetByID<Bargeldtransaktion>(signature.BargeldtransaktionsOid.Value)
				: null;

			Bargeldkasse bargeldkasse = bargeldtransaktion is object ? DAOFactory.SearchDAO.FindBargeldkasseByBargeldtransaktion(bargeldtransaktion.Oid.Value) : null;

			DateTime? signatureTimeSpanStart = serviceRecord?.Start ?? bargeldtransaktion?.Zahlungsdatum;
			DateTime? signatureTimeSpanEnd = serviceRecord?.End ?? bargeldtransaktion?.Zahlungsdatum;

			var employee = serviceRecord?.Employee;
			var customer = serviceRecord?.Customer;

			if ((bargeldkasse?.ObjectTid == TableID.Customer) && bargeldkasse?.ObjectOid is object)
			{
				customer = DAOFactory.GenericDAO.LoadByID<Customer>(bargeldkasse.ObjectOid.Value);
			}

			var signatureHistoryEntry = new SignatureHistory
			{
				SignatureOid = signature.Oid,
				CustomerOid = customer?.Oid,
				EmployeeOid = employee?.Oid,
				SignatureInsTs = signature.InsTs,
				BargeldtransaktionsOid = signature.BargeldtransaktionsOid,
				SignatureType = bargeldtransaktion is null ? SignatureTable.SingleSignature : SignatureTable.BargeldkasseneinzahlungsSignature,
				TimeSpanStart = signatureTimeSpanStart,
				TimeSpanEnd = signatureTimeSpanEnd,
				SignatureEventType = signatureEventType,
				DataBild = signature.DataBild
			};

			if (serviceRecord?.Oid is object)
			{
				signatureHistoryEntry.ServiceRecordOidList = new List<long> { serviceRecord.Oid.Value };
			}

			return signatureHistoryEntry;
		}

		/// <summary>
		/// Ezeugt einen SignatureHistory-Eintrag für eine Monatsunterschrift
		/// </summary>
		/// <param name="signature">Die Monatsunterschrift zu der ein SignatureHistory-Eintrag erzeugt wird.</param>
		/// <param name="signatureEventType">Der Eventtyp, der besagt, ob es sich um ein Insert, Update, oder Delete der Unterschrift handelt.</param>
		/// <returns>SignatureHistory-Einträge auf Basis der Monatsunterschrift</returns>
		public SignatureHistory CreateMonthlySignatureHistoryEntry(ConfirmationReceiptSignature signature, SignatureEventType signatureEventType)
		{
			var serviceRecordOids = signature.ServiceRecords.Select(serviceRecord => serviceRecord.Oid.Value).ToList();

			var a = signature.GetSignatureTimeSpan();

			return new SignatureHistory
			{
				SignatureOid = signature.Oid,
				SignatureInsTs = signature.InsTs,
				SignatureType = signature.CustomerOid.HasValue ? SignatureTable.CustomerMonthlySignature : SignatureTable.EmployeeMonthlySignature,
				ServiceRecordOidList = serviceRecordOids,
				CustomerOid = signature.CustomerOid,
				EmployeeOid = signature.CustomerOid is null ? signature.Employee?.Oid : null,
				SignatureEventType = signatureEventType,
				TimeSpanStart = a.StartDate,
				TimeSpanEnd = a.EndDate
			};
		}

		/// <summary>
		/// Erzeugt SignatureHistory-Einträge für alle unterschriebenen Bargeldtransaktionsunterschriften, falls man eine Bargeldkasse löscht.
		/// </summary>
		/// <param name="bargeldkasse">Die Bargeldkasse, die gelöscht wird.</param>
		/// <returns>SignatureHistory-Einträge auf Basis der Bargeldkasse</returns>
		public List<SignatureHistory> CreateSignatureHistoryEntryForBargeldkasse(Bargeldkasse bargeldkasse)
		{
			var signatureHistoryEntries = new List<SignatureHistory>();

			var signatureOids2Transaktionsoid = new Dictionary<long, long>();
			var bargeldtransaktionenMitUnterschrift = bargeldkasse.Bargeldtransaktionen.Where(t => t.SignatureOid.HasValue && t.Oid.HasValue).ToList();

			foreach (var transaktion in bargeldtransaktionenMitUnterschrift)
			{
				signatureOids2Transaktionsoid.Add(transaktion.SignatureOid.Value, transaktion.Oid.Value);
			}

			var signatures = DAOFactory.GenericDAO.LoadByIDs<Signature>(signatureOids2Transaktionsoid.Keys);

			signatures.DoForEach(sig =>
			{
				var transaktion = bargeldtransaktionenMitUnterschrift.FirstOrDefault(f => f.Oid.Equals(signatureOids2Transaktionsoid[sig.Oid.Value]));

				if (transaktion is null)
				{
					return;
				}

				var start = transaktion.Zahlungsdatum;

				signatureHistoryEntries.Add(new SignatureHistory
				{
					BargeldtransaktionsOid = signatureOids2Transaktionsoid[sig.Oid.Value],
					SignatureOid = sig.Oid,
					CustomerOid = bargeldkasse.ObjectOid,
					SignatureEventType = SignatureEventType.CascadingDelete,
					SignatureInsTs = sig.InsTs,
					SignatureType = SignatureTable.BargeldkasseneinzahlungsSignature,
					TimeSpanStart = transaktion.Zahlungsdatum,
					TimeSpanEnd = transaktion.Zahlungsdatum,
					DataBild = sig.DataBild
				});
			});

			return signatureHistoryEntries;
		}

		/// <summary>
		/// Erzeugt einen SignatureHistory-Eintrag für die Bargeldtransaktionsunterschrift, die gelöscht oder geändert wird.
		/// </summary>
		/// <param name="transaktion">Bargeldtransaktion, die unterschrieben worden ist</param>
		/// <param name="signatureEventType">Der Eventtyp, der besagt, ob es sich um ein Insert, Update, oder Delete der Unterschrift handelt.</param>
		/// <returns>SignatureHistory-Eintrag auf Basis des Bargeldtransaktion</returns>
		public SignatureHistory CreateSignatureHistoryForBargeldtransaktion(Bargeldtransaktion transaktion, SignatureEventType signatureEventType)
		{
			var bargeldkasse = DAOFactory.SearchDAO.FindBargeldkasseByBargeldtransaktion(transaktion.Oid.Value);
			var signature = DAOFactory.GenericDAO.LoadByID<Signature>(transaktion.SignatureOid.Value);

			if (bargeldkasse is null || signature is null)
			{
				return null;
			}

			return new SignatureHistory
			{
				SignatureEventType = signatureEventType,
				BargeldtransaktionsOid = transaktion.Oid,
				CustomerOid = bargeldkasse.ObjectOid,
				SignatureInsTs = signature.InsTs,
				SignatureOid = signature.Oid,
				TimeSpanStart = transaktion.Zahlungsdatum,
				TimeSpanEnd = transaktion.Zahlungsdatum,
				SignatureType = SignatureTable.BargeldkasseneinzahlungsSignature,
				DataBild = signature.DataBild
			};
		}

		/// <summary>
		/// Erzeugt einen SignatureHistory-Eintrag für die Unterschrift, die kaskadierend beim Löschen eines ServiceRecords gelöscht wird.
		/// </summary>
		/// <param name="serviceRecord">Oid des ServiceRecords</param>
		/// <returns>SignatureHistory-Eintrag auf Basis des ServiceRecords</returns>
		public SignatureHistory CreateSignatureHistoryForServiceRecordUpdate(ServiceRecord serviceRecord, SignatureEventType signatureEventType)
		{
			var signature = DAOFactory.GenericDAO.LoadByID<Signature>(serviceRecord.SignatureOid.Value);

			var signatureHistory = new SignatureHistory
			{
				CustomerOid = serviceRecord.CustomerOid,
				EmployeeOid = serviceRecord.EmployeeOid,
				SignatureEventType = signatureEventType,
				TimeSpanStart = serviceRecord.Start,
				TimeSpanEnd = serviceRecord.End,
				SignatureOid = signature.Oid,
				SignatureInsTs = signature.InsTs
			};

			return signatureHistory;
		}

		public ServiceRecord GetOldServiceRecordForSignatureHistoryEntry(long serviceRecordOid)
		{
			return CreateCriteria<ServiceRecord>()
				.Add(Restrictions.Eq(nameof(BeWoEntityBase.Oid), serviceRecordOid))
				.UniqueResult<ServiceRecord>();
		}

		public bool CheckForExistingServiceRecordSignature(long serviceRecordOid)
		{
			var sql = $"SELECT SignatureOID FROM ServiceRecord sr WHERE sr.Oid = {serviceRecordOid}";
			var query = Session.CreateSQLQuery(sql);

			return query.UniqueResult<long?>() is object;
		}

		public Signature LoadJustDeletedSignature(long oid, bool isServiceRecord)
		{
			var tableName = isServiceRecord ? "servicerecord" : "bargeldtransaktion";

			var sql = $"SELECT SignatureOid FROM {tableName} WHERE Oid = {oid} AND SignatureOid IS NOT NULL";

			var query = Session.CreateSQLQuery(sql);

			var signatureOid = query.UniqueResult<long?>();

			return signatureOid.HasValue ? DAOFactory.GenericDAO.GetByID<Signature>(signatureOid.Value) : null;
		}

		public List<Bargeldtransaktion> LoadBargeldTransaktionenNonLazy(long bargeldkassenOid)
		{
			var sql = $"SELECT t.Oid FROM bargeldtransaktion t WHERE t.BargeldkassenOid = {bargeldkassenOid}";

			var query = Session.CreateSQLQuery(sql);

			var transactionOids = query.List<long>().ToArray();

			var criteria = CreateCriteria<Bargeldtransaktion>()
				.Add(Restrictions.In(nameof(BeWoEntityBase.Oid), transactionOids));

			var transactionsGottenByIds = new List<Bargeldtransaktion>();

			foreach (var transactionOid in transactionOids)
			{
				transactionsGottenByIds.Add(DAOFactory.GenericDAO.GetByID<Bargeldtransaktion>(transactionOid));
			}

			var transactionsLoadedByIds = DAOFactory.GenericDAO.LoadByIDs<Bargeldtransaktion>(transactionOids);

			var transactionsCriteriaResult = criteria.List<Bargeldtransaktion>().ToList();

			return transactionsCriteriaResult;
		}
	}
}