BeWoPlaner/Service/ServiceImplementations/EmployeeServiceImp.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using BeWo.Data;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Service.Core;
using BeWo.Service.DCEntityMapper;
using BeWo.Service.OwnChat;
using BeWo.Service.Plugins;
using BeWo.Service.SBD;
using BeWo.Service.Security;
using BeWo.Service.ServiceContracts;
using BeWo.Service.Urlaubsplanung;
using BeWo.View.Navigation.Filter;
using BS.Shared;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using BS.Shared.Extensions;

using NHibernate;
using BeWo.ServiceUtils.History;
using BeWoFault = BS.Shared.Core.BeWoFault;
using BeWoFaultType = BS.Shared.Core.BeWoFaultType;

namespace BeWo.Service.ServiceImplementations
{
	[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Single)]
	public class EmployeeServiceImp : IEmployeeService
	{
		public void ArchiveEmployee(long pOid, long pVersion)
		{
			try
			{
				var e = DAOFactory.GenericDAO.LoadByID<Employee>(pOid);
				e.Person.IsActive = ActivationTypeId.Archived;

				HistoryCreator.MakeNewEmployeeHistoryEntry(e, MapperFactory.EmployeeDC_Employee.MapToNewDC(e), StatementType.Archived);

				ServiceLogic.SetActivationType<Employee>(pOid, pVersion, ActivationTypeId.Archived);

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

		public void DeactivateAssessmentSheetCategories(List<AssessmentSheetCategoryDC> dcs)
		{
			try
			{
				ServiceLogic.SetActivationType<AssessmentSheetCategory>(dcs.ToDictionary(i => i.AssessmentSheetCategoryOid.Value, i => i.AssessmentSheetCategoryVersion.Value), ActivationTypeId.Deleted);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public void DeactivateAssessmentSheetEntries(List<AssessmentSheetEntryDC> dcs)
		{
			try
			{
				//ServiceLogic.SetActivationType<AssessmentSheetEntry>(dcs.ToDictionary(i => i.AssessmentSheetEntryOid.Value, i => i.AssessmentSheetEntryVersion.Value), ActivationTypeId.Deleted);
				var entries = DAOFactory.GenericDAO.LoadByIDs<AssessmentSheetEntry>(dcs.Select(i => i.AssessmentSheetEntryOid.Value)).Where(e => e.SystemEntryID == null);

				//entries.DoForEach(or => MapperFactory.AssessmentSheetEntryDC_AssessmentSheetEntry.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));
				DAOFactory.GenericDAO.Delete(entries);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public void DeactivateAssessmentSheetValues(List<AssessmentSheetValueDC> dcs)
		{
			try
			{
				ServiceLogic.SetActivationType<AssessmentSheetValue>(dcs.ToDictionary(i => i.AssessmentSheetValueOid.Value, i => i.AssessmentSheetValueVersion.Value), ActivationTypeId.Deleted);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public void DeactivateEmployee(long pOid, long pVersion)
		{
			try
			{
				var e = DAOFactory.GenericDAO.LoadByID<Employee>(pOid);
				e.Person.IsActive = ActivationTypeId.Deleted;
				ServiceLogic.SetActivationType<Employee>(pOid, pVersion, ActivationTypeId.Deleted);

				HistoryCreator.MakeNewEmployeeHistoryEntry(e, MapperFactory.EmployeeDC_Employee.MapToNewDC(e), StatementType.Delete);

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

		public void DeleteEmployeeCustomerRelationForEmployee(long employeeOid)
		{
			var emp = DAOFactory.GenericDAO.LoadByID<Employee>(employeeOid);
			foreach (var e2c in emp.Employee2CustomerList)
			{
				DAOFactory.GenericDAO.Delete(e2c);
			}
		}

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

				foreach (var key in pOid2Version.Keys)
				{
					DeleteEmployeeCustomerRelationForEmployee(key);
				}
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public void DeactivateNewsItems(List<NewsItemDC> dcs)
		{
			try
			{
				ServiceLogic.SetActivationType<NewsItem>(dcs.ToDictionary(i => i.NewsItemOid.Value, i => i.NewsItemVersion.Value), ActivationTypeId.Deleted);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

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

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

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

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

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

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

		public void DeleteEmployees(Dictionary<long, long> pOid2Version)
		{
			try
			{
				pOid2Version.Keys.DoForEach(SettingsLogic.RemoveFromAllHistories<Employee>);
				var lOriginals = DAOFactory.GenericDAO.LoadByIDs<Employee>(pOid2Version.Select(e => e.Key));
				lOriginals.DoForEach(or => MapperFactory.EmployeeDC_Employee.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));

				foreach (Employee e in lOriginals)
				{
					HistoryCreator.MakeNewEmployeeHistoryEntry(e, MapperFactory.EmployeeDC_Employee.MapToNewDC(e), StatementType.Delete);
				}

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

		public List<CompactEmployeeDC> FindEmployee(string pFirstName, string pLastName, string pPersonnelNumber)
		{
			try
			{
				return MapperFactory.CompactEmployeeDC_Employee.MapToNewDCs(DAOFactory.SearchDAO.FindEmployee(pFirstName, pLastName, pPersonnelNumber));
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<CompactTeamDC> FindTeams(string pTeamName, string pLeaderFirstName, string pLeaderLastName)
		{
			try
			{
				return MapperFactory.CompactTeamDC_Team.MapToNewDCs(DAOFactory.SearchDAO.FindTeams(pTeamName, pLeaderFirstName, pLeaderLastName));
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<CompactEmployeeDC> GetAllActiveAndArchivedEmployeesCompact()
		{
			try
			{
				var s = PluginLoader.FindClass<EmployeeService>();

				return s.GetAllActiveAndArchivedEmployeesCompact();

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

		public List<CompactEmployeeDC> GetAllActiveEmployeesCompact()
		{
			try
			{
				var s = PluginLoader.FindClass<EmployeeService>();

				return s.GetAllActiveEmployeesCompact();

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

		}

		public List<CompactEmployeeDC> GetAllAuthorizedCompactEmployees()
		{
			try
			{

				try
				{
					var s = PluginLoader.FindClass<EmployeeService>();

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

		public List<CompactEmployeeDC> GetAllTeamMember(CompactEmployeeDC employee)
		{
			try
			{
				Dictionary<long, bool> inTeamDict = new Dictionary<long, bool>();
				List<Employee> teamMember = new List<Employee>();
				var teams = DAOFactory.GenericDAO.GetAllActive<Team>();
				foreach (var team in teams)
				{
					bool contained = (team.Leader != null && team.Leader.Oid == employee.EmployeeOid);

					if (!contained)
					{
						foreach (var e in team.MemberList)
						{
							if (e.Oid.Value.Equals(employee.EmployeeOid))
								contained = true;
						}
					}
					if (contained)
					{
						foreach (var e in team.MemberList)
						{
							if (!inTeamDict.ContainsKey(e.Oid.Value))
							{
								teamMember.Add(e);
								inTeamDict.Add(e.Oid.Value, true);
							}
						}
					}
				}


				var dcList = MapperFactory.CompactEmployeeDC_Employee.MapToNewDCs(teamMember);
				if (!inTeamDict.ContainsKey(employee.EmployeeOid))
					dcList.Add(employee);
				return dcList;
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<EmploymentTypeDC> GetAllEmploymentTypes()
		{
			try
			{
				return MapperFactory.EmploymentTypeDC_EmploymentType.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<EmploymentType>());
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}
		public EmploymentTypeDC GetEmploymentType(long oid)
		{
			try
			{
				return MapperFactory.EmploymentTypeDC_EmploymentType.MapToNewDC(DAOFactory.GenericDAO.GetByID<EmploymentType>(oid));
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<long> InsertNewEmploymentTypes(List<EmploymentTypeDC> pEntries)
		{
			try
			{
				var lEntities = MapperFactory.EmploymentTypeDC_EmploymentType.MapToNewEntities(pEntries);
				DAOFactory.GenericDAO.Insert(lEntities);
				return lEntities.Select(e => e.Oid.Value).ToList();
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public void UpdateEmploymentTypes(List<EmploymentTypeDC> pEntries)
		{
			try
			{
				var lOriginals = DAOFactory.GenericDAO.LoadByIDs<EmploymentType>(pEntries.Select(en => en.EmploymentTypeOid.Value));
				MapperFactory.EmploymentTypeDC_EmploymentType.MergeWithEntitys(pEntries, lOriginals);
				DAOFactory.GenericDAO.Update(lOriginals);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

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

		public List<AssessmentSheetCategoryDC> GetAllAssessmentSheetCategories()
		{
			try
			{
				return MapperFactory.AssessmentSheetCategoryDC_AssessmentSheetCategory.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<AssessmentSheetCategory>().Where(cat => !cat.ScopeType.HasValue || cat.ScopeType.Value == ScopeTypeId.Global));
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<AssessmentSheetEntryDC> GetAllAssessmentSheetEntries()
		{
			try
			{
				return MapperFactory.AssessmentSheetEntryDC_AssessmentSheetEntry.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<AssessmentSheetEntry>());
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<AssessmentSheetValueDC> GetAllAssessmentSheetValues()
		{
			try
			{
				return MapperFactory.AssessmentSheetValueDC_AssessmentSheetValue.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<AssessmentSheetValue>());
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<EmployeeDC> GetAllEmployees()
		{
			try
			{
				return DAOFactory.GenericDAO.GetAll<Employee>().Select(emp => MapperFactory.EmployeeDC_Employee.MapToNewDC(emp)).ToList();
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<NewsItemDC> GetAllNewsItems()
		{
			try
			{
				return MapperFactory.NewsItemDC_NewsItem.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<NewsItem>());
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<CompactTeamDC> GetAllTeamsCompact()
		{
			try
			{
				var s = PluginLoader.FindClass<EmployeeService>();

                return s.GetAllTeamsCompact(false);

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

        public List<CompactTeamDC> GetAllTeamsIncludingOwnChatCompact()
        {
            try
            {
                var s = PluginLoader.FindClass<EmployeeService>();

                return s.GetAllTeamsCompact(true);

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

        public List<AssessmentSheetEntryDC> GetAssessmentSheetEntriesForCustomer(long customerOid, DateTime startDt, DateTime endDt)
        {
            

			try
			{
				return MapperFactory.AssessmentSheetEntryDC_AssessmentSheetEntry.MapToNewDCs(DAOFactory.SearchDAO.GetAssessmentSheetEntriesForCustomer(customerOid, startDt, endDt));
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

        public EmployeeDC GetEmployeeWithPersonOid(long pPersonOid)
        {
            try
            {
                return MapperFactory.EmployeeDC_Employee.MapToNewDC(DAOFactory.SearchDAO.FindEmployeeWithPersonOid(pPersonOid));
            }
            catch (Exception e)
            {
                throw new FaultException<BS.Shared.Core.BeWoFault>(new BS.Shared.Core.BeWoFault(String.Format("Mitarbeiter mit Id {0} wurde nicht gefunden!", pPersonOid)));
            }
        }
        
        public List<CompactEmployeeDC> GetLastOpenedEmployees()
        {
            try
            {
                return MapperFactory.CompactEmployeeDC_Employee.MapToNewDCs(SettingsLogic.GetLastOpened<Employee>());
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

		public List<CompactTeamDC> GetLastOpenedTeams()
		{
			try
			{
				return MapperFactory.CompactTeamDC_Team.MapToNewDCs(SettingsLogic.GetLastOpened<Team>());
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<NewsItemDC> GetPublishedNewsItems()
		{
			try
			{
				return this.GetAllNewsItems().Where(i => i.PublishDate.HasValue && i.PublishDate.Value.Date <= DateTime.Now).ToList();
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<NewsItemDC> GetPublishedNewsItemsForEmployee(long employeeOid, bool fetchTeamNews)
		{
			try
			{
				IList<long> teamOids = new List<long>();
				var allItems = DAOFactory.GenericDAO.GetAllActive<NewsItem>();

				if (fetchTeamNews)
				{
					var teams = DAOFactory.SearchDAO.FindTeamsOfEmployee(employeeOid);
					var leadingTeams = DAOFactory.SearchDAO.FindLeadingTeams(employeeOid);
					if (teams != null)
					{
						teamOids = teams.Select(t => t.Oid.Value).ToList();

					}
					if (leadingTeams != null)
					{
						teamOids.AddRange(leadingTeams.Select(t => t.Oid.Value));

					}
				}
				teamOids = teamOids.Distinct().ToList();
				var items =
						allItems.Where(
							i =>
							{
								if (!i.TeamOid.HasValue)
								{
									return i.PublishDate.HasValue && i.PublishDate.Value.Date <= DateTime.Now;
								}
								return teamOids.Contains(i.TeamOid.Value);

							}).ToList();

				var dcList = MapperFactory.NewsItemDC_NewsItem.MapToNewDCs(items);
				List<NewsItemDC> newDcList = new List<NewsItemDC>();
				if (fetchTeamNews)
				{
					foreach (var teamOid in teamOids)
					{
						if (dcList.Count(i => i.Team != null && i.Team.TeamOid == teamOid) == 0)
						{
							Team t = DAOFactory.GenericDAO.LoadByID<Team>(teamOid);
							NewsItemDC newDc = new NewsItemDC();
							newDc.Team = new CompactTeamDC();
							newDc.Team.Name = t.Name;
							newDc.Team.TeamOid = t.Oid.Value;
							newDc.Team.TeamVersion = t.Version.Value;

							newDcList.Add(newDc);
						}
					}
				}
				dcList.AddRange(newDcList);

				return dcList.OrderByDescending(i => i.PublishDate).ToList();

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

		public void DeleteNewsItem(long pOid, long pVersion)
		{
			try
			{
				var original = DAOFactory.GenericDAO.LoadByID<NewsItem>(pOid);

				MapperFactory.NewsItemDC_NewsItem.ConcurrencyCheck(pVersion, original);

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

		public long InsertNewNewsItem(NewsItemDC dc)
		{
			return InsertNewNewsItems(new List<NewsItemDC> { dc }).FirstOrDefault();

		}

		public long UpdateNewsItem(NewsItemDC dc)
		{
			try
			{
				var lOrigial = DAOFactory.GenericDAO.LoadByID<NewsItem>(dc.NewsItemOid.Value);
				MapperFactory.NewsItemDC_NewsItem.MergeWithEntity(dc, lOrigial);
				DAOFactory.GenericDAO.Update(lOrigial);
				return lOrigial.Oid.Value;
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public void InsertEmployeeCustomerRelation(CustomerEmployeeRelationDC pRelationDC)
		{
			try
			{
				DAOFactory.GenericDAO.Insert(MapperFactory.EmployeeCustomerRelDC_Employee2CustomerMapper.MapToNewEntity(pRelationDC));
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<long> InsertNewAssessmentSheetCategories(List<AssessmentSheetCategoryDC> dcs)
		{
			try
			{
				var newAssessmentSheetCategories = MapperFactory.AssessmentSheetCategoryDC_AssessmentSheetCategory.MapToNewEntities(dcs);
				DAOFactory.GenericDAO.Insert(newAssessmentSheetCategories);
				return newAssessmentSheetCategories.Select(i => i.Oid.Value).ToList();
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<long> InsertNewAssessmentSheetEntries(List<AssessmentSheetEntryDC> dcs)
		{
			try
			{
				var newAssessmentSheetEntries = MapperFactory.AssessmentSheetEntryDC_AssessmentSheetEntry.MapToNewEntities(dcs);
				DAOFactory.GenericDAO.Insert(newAssessmentSheetEntries);
				return newAssessmentSheetEntries.Select(i => i.Oid.Value).ToList();
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<long> InsertNewAssessmentSheetValues(List<AssessmentSheetValueDC> dcs)
		{
			try
			{
				var newAssessmentSheetValues = MapperFactory.AssessmentSheetValueDC_AssessmentSheetValue.MapToNewEntities(dcs);
				DAOFactory.GenericDAO.Insert(newAssessmentSheetValues);
				return newAssessmentSheetValues.Select(i => i.Oid.Value).ToList();
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public long InsertNewEmployee(EmployeeDC pEmployeeDC)
		{
			try
			{
				var li = SecurityUtils.GetLicenseInfo();
				if (li.EmployeeCount >= li.MaxEmployeeCount)
				{
					return -1;
				}

				var es = PluginLoader.FindClass<EmployeeService>();

				var id = es.InsertNewEmployee(pEmployeeDC);
				var temp = DAOFactory.GenericDAO.LoadByID<Employee>(id);

				HistoryCreator.MakeNewEmployeeHistoryEntry(temp, pEmployeeDC, StatementType.Insert);

				OwnChatHelper.StartOwnChatSync();

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

		public List<long> InsertNewNewsItems(List<NewsItemDC> dcs)
		{
			try
			{
				var newNewsItems = MapperFactory.NewsItemDC_NewsItem.MapToNewEntities(dcs);
				DAOFactory.GenericDAO.Insert(newNewsItems);
				return newNewsItems.Select(i => i.Oid.Value).ToList();
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public long InsertNewTeam(TeamDC pTeam)
		{
			try
			{
				Team lTeam = MapperFactory.TeamDC_Team.MapToNewEntity(pTeam);
				DAOFactory.GenericDAO.Insert(lTeam);

				OwnChatHelper.StartOwnChatSync();

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

		public TeamDC LoadTeam(long pTeamOid)
		{
			try
			{
				SettingsLogic.AddToUsersHistory<Team>(pTeamOid);
				return MapperFactory.TeamDC_Team.MapToNewDC(DAOFactory.GenericDAO.LoadByID<Team>(pTeamOid));
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public CompactTeamDC LoadCompactTeam(long pTeamOid)
		{
			try
			{
				SettingsLogic.AddToUsersHistory<Team>(pTeamOid);
				return MapperFactory.CompactTeamDC_Team.MapToNewDC(DAOFactory.GenericDAO.LoadByID<Team>(pTeamOid));
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

        public EmployeeDC LoadLoggedOnEmployee(long pEmployeeOid)
        {
            try
            {
                return MapperFactory.EmployeeDC_Employee.MapToNewDC(DAOFactory.GenericDAO.LoadByID<Employee>(pEmployeeOid));
            }
            catch (Exception e)
            {
                throw new FaultException<BS.Shared.Core.BeWoFault>(new BeWoFault(e), e.Message);
            }
        }


		public EmployeeDC LoadEmployee(long pEmployeeOid)
		{
			try
			{
				var es = PluginLoader.FindClass<EmployeeService>();

                return es.LoadEmployee(pEmployeeOid);
            }
            catch (Exception e)
            {
                throw new FaultException<BS.Shared.Core.BeWoFault>(new BS.Shared.Core.BeWoFault(e), e.Message);
            }
        }

		public CompactEmployeeDC LoadCompactEmployee(long pEmployeeOid)
		{
			try
			{
				SettingsLogic.AddToUsersHistory<Employee>(pEmployeeOid);
				return MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(DAOFactory.GenericDAO.LoadByID<Employee>(pEmployeeOid));
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public void UpdateAssessmentSheetCategories(List<AssessmentSheetCategoryDC> dcs)
		{
			try
			{
				var originals = DAOFactory.GenericDAO.LoadByIDs<AssessmentSheetCategory>(dcs.Select(i => i.AssessmentSheetCategoryOid.Value));
				MapperFactory.AssessmentSheetCategoryDC_AssessmentSheetCategory.MergeWithEntitys(dcs, originals);
				DAOFactory.GenericDAO.Update(originals);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public void UpdateAssessmentSheetEntries(List<AssessmentSheetEntryDC> dcs)
		{
			try
			{
				var originals = DAOFactory.GenericDAO.LoadByIDs<AssessmentSheetEntry>(dcs.Select(i => i.AssessmentSheetEntryOid.Value));

				var aSCategories = DAOFactory.GenericDAO.GetAll<AssessmentSheetCategory>().Where(c => c.SystemEntryID.Equals(SystemEntryID.AdditionalServiceAssessmentSheet));

				List<AssessmentSheetEntry> removeList = new List<AssessmentSheetEntry>();
				foreach (var ase in originals)
				{

					if (ase.SystemEntryID.Equals(SystemEntryID.AdditionalServiceAssessmentSheet) &&
						aSCategories.Count(c => c.Description.Equals(ase.AssessmentSheetCategory.Description)) > 0)
					{
						removeList.Add(ase);
					}
				}
				foreach (var ase in removeList)
				{
					originals.Remove(ase);
				}
				if (originals.Count > 0)
				{
					MapperFactory.AssessmentSheetEntryDC_AssessmentSheetEntry.MergeWithEntitys(dcs, originals);

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

		public void UpdateAssessmentSheetValues(List<AssessmentSheetValueDC> dcs)
		{
			try
			{
				var originals = DAOFactory.GenericDAO.LoadByIDs<AssessmentSheetValue>(dcs.Select(i => i.AssessmentSheetValueOid.Value));
				MapperFactory.AssessmentSheetValueDC_AssessmentSheetValue.MergeWithEntitys(dcs, originals);
				DAOFactory.GenericDAO.Update(originals);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public long UpdateEmployee(EmployeeDC pEmployeeDC)
		{
			try
			{
				var lOriginal = DAOFactory.GenericDAO.LoadByID<Employee>(pEmployeeDC.EmployeeOid.Value);

				HistoryCreator.MakeNewEmployeeHistoryEntry(lOriginal, pEmployeeDC, StatementType.Update);
				MapperFactory.EmployeeDC_Employee.MergeWithEntity(pEmployeeDC, lOriginal);



				DAOFactory.GenericDAO.Update(lOriginal);

				OwnChatHelper.StartOwnChatSync();
				return lOriginal.Oid.Value;
			}
			catch (StaleObjectStateException)
			{
				throw new FaultException<BeWoFault>(new BeWoFault("Wurde in der Zwischenzeit geändert", BeWoFaultType.Concurrency));
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public void UpdateNewsItems(List<NewsItemDC> dcs)
		{
			try
			{
				var originals = DAOFactory.GenericDAO.LoadByIDs<NewsItem>(dcs.Select(i => i.NewsItemOid.Value));
				MapperFactory.NewsItemDC_NewsItem.MergeWithEntitys(dcs, originals);
				DAOFactory.GenericDAO.Update(originals);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public long UpdateTeam(TeamDC pTeam)
		{
			try
			{
				Team lOriginal = DAOFactory.GenericDAO.LoadByID<Team>(pTeam.TeamOid.Value);
				MapperFactory.TeamDC_Team.MergeWithEntity(pTeam, lOriginal);
				DAOFactory.GenericDAO.Update(lOriginal);

				OwnChatHelper.StartOwnChatSync();

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

		public List<AbsenceTimeDC> GetAllEmployeeAbsenceTimes()
		{
			try
			{
				return MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDCs(DAOFactory.SearchDAO.FindAbsenceTimes(true, false));
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}
		public List<AbsenceTimeDC> GetAllEmployeeAbsenceTimesForMonth(int year, int month)
		{
			try
			{
				var startdate = new DateTime(year, month, 1);
				var enddate = startdate.AddMonths(1).AddTicks(-1);

				var absencetimes = DAOFactory.SearchDAO.FindAbsenceTimes(startdate, enddate);

				return MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDCs(absencetimes);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}
		public List<AbsenceTimeDC> GetMultipleEmployeeAbsenceTimesForMonth(int year, int month, List<long> empOids)
		{
			try
			{
				var startdate = new DateTime(year, month, 1);
				var enddate = startdate.AddMonths(1).AddTicks(-1);

				List<AbsenceTime> absenceTimes = new List<AbsenceTime>();

				foreach (var oid in empOids)
				{
					absenceTimes.AddRange(DAOFactory.SearchDAO.FindAbsenceTimesForEmployee(startdate, enddate, oid));
				}

				return MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDCs(absenceTimes);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}
		public List<AbsenceTimeDC> GetAllEmployeeAbsenceTimesForYear(int year)
		{
			try
			{
				var startdate = new DateTime(year, 1, 1);
				var enddate = startdate.AddYears(1).AddTicks(-1);

				var absencetimes = DAOFactory.SearchDAO.FindAbsenceTimes(startdate, enddate);

                return MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDCs(absencetimes);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        public List<CompactEmployeeDC> GetAllEmployeeMitUeberschneidendenAbwesenheiten(List<CompactEmployeeDC> compactEmployeeList, DateTime newAbsStart, DateTime newAbsEnd)
        {
            var result = new List<CompactEmployeeDC>();
            var employee = DAOFactory.GenericDAO.GetByIDs<Employee>(compactEmployeeList.Select(e => e.EmployeeOid));
            foreach (var emp in employee)
            {
                if (emp.AbsenceTimes != null)
                {
                    foreach (var abs in emp.AbsenceTimes)
                    {
                        // Jede vorhandene Abwesenheit auf eine Überschneidung prüfen
                        DateTime altStart = abs.Start ?? DateTime.MinValue;
                        DateTime altEnd = abs.End ?? DateTime.MaxValue;

                        if (newAbsEnd >= altStart && newAbsStart <= altEnd)
                        {
                            // Gibt es eine Überschneidung, diesen Mitarbeiter zum Result hinzufügen und mit dem nächsten weitermachen
                            result.Add(compactEmployeeList.First(c => c.EmployeeOid == emp.Oid));
                            break;
                        }
                    }
                }
            }

            return result;
        }
        public void SpeichereKalenderterminAlsAbwesenheit(List<CompactEmployeeDC> compactEmployeeList, AbsenceReasonDC reasonDC, string notice, DateTime newAbsStart, DateTime newAbsEnd)
        {
            // Da man technisch die EmployeeOid nicht mit speichern kann, wenn man in die DB insertet, muss der Employee geholt werden.
            // In den speichert man dann eine neue AbsenceTime und dann muss der Employee geupdated werden
            AbsenceReason reason = DAOFactory.GenericDAO.GetByID<AbsenceReason>(reasonDC.AbsenceReasonOid.Value);
            List<Employee> empList = DAOFactory.GenericDAO.GetByIDs<Employee>(compactEmployeeList.Select(e => e.EmployeeOid).ToList());

            foreach (var emp in empList)
            {
                AbsenceTime absenceTime = new AbsenceTime()
                {
                    AbsenceReason = reason,
                    CustomerOid = null,
                    EmployeeOid = emp.Oid,
                    IsActive = ActivationTypeId.Active,
                    Notice = notice,
                    Start = newAbsStart,
                    End = newAbsEnd
                };
                emp.AbsenceTimes.Add(absenceTime);
            }
            
            DAOFactory.GenericDAO.Update(empList);
        }

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

		public long InsertNewGroupOfPeople(GroupOfPeopleDC pGroupOfPeople)
		{
			try
			{
				GroupOfPeople obj = MapperFactory.GroupOfPeopleDC_GroupOfPeople.MapToNewEntity(pGroupOfPeople);
				DAOFactory.GenericDAO.Insert(obj);
				return obj.Oid.Value;
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public GroupOfPeopleDC LoadGroupOfPeople(long pOid)
		{
			try
			{
				return MapperFactory.GroupOfPeopleDC_GroupOfPeople.MapToNewDC(DAOFactory.GenericDAO.LoadByID<GroupOfPeople>(pOid));
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public long UpdateGroupOfPeople(GroupOfPeopleDC pGroupOfPeople)
		{
			try
			{
				GroupOfPeople lOriginal = DAOFactory.GenericDAO.LoadByID<GroupOfPeople>(pGroupOfPeople.GroupOfPeopleOid.Value);
				MapperFactory.GroupOfPeopleDC_GroupOfPeople.MergeWithEntity(pGroupOfPeople, lOriginal);
				DAOFactory.GenericDAO.Update(lOriginal);
				return lOriginal.Oid.Value;
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<CompactGroupOfPeopleDC> GetAllGroupsCompact(long? employeeOid)
		{
			try
			{
				var groups = GetAllGroupsContainingMemberOfEmployee(employeeOid);

				return MapperFactory.CompactGroupOfPeopleDC_GroupOfPeople.MapToNewDCs(groups);

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

		public List<GroupOfPeopleDC> GetAllGroups(long? employeeOid)
		{
			try
			{
				var groups = GetAllGroupsContainingMemberOfEmployee(employeeOid);

				return MapperFactory.GroupOfPeopleDC_GroupOfPeople.MapToNewDCs(groups.OrderBy(g => g.Name));
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		private IEnumerable<GroupOfPeople> GetAllGroupsContainingMemberOfEmployee(long? employeeOid)
		{
			var allgroups = DAOFactory.GenericDAO.GetAllActive<GroupOfPeople>();
			if (!employeeOid.HasValue)
				return allgroups;
			var groups = new List<GroupOfPeople>();
			Dictionary<long, bool> processedGroups = new Dictionary<long, bool>();
			Employee emp = DAOFactory.GenericDAO.LoadByID<Employee>(employeeOid.Value);


			ApplicationUser loggedInUser = null;

			if (LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
			{
				loggedInUser = LoggedInUserOperationContextExt.Current.User;
			}
			else
			{
				loggedInUser = SessionFacade.LoggedInUser;
			}

			bool nurEigene = true;
			if (loggedInUser != null)
			{

				//Alle
				if (Utils.UserHasRight(loggedInUser, UserRightType.SupportConcept_ViewAllSupportConcepts))
				{
					nurEigene = false;
				}
				//Vom Team
				else if (Utils.UserHasRight(loggedInUser, UserRightType.SupportConcept_ViewMyTeams))
				{
					//?
				}
				//Eigene
				else if (Utils.UserHasRight(loggedInUser, UserRightType.SupportConceptView_View))
				{
					nurEigene = true;
				}

			}

			foreach (var groupOfPeople in allgroups)
			{
				if (!processedGroups.ContainsKey(groupOfPeople.Oid.Value))
				{
					processedGroups.Add(groupOfPeople.Oid.Value, true);

					if (nurEigene)
					{
						if (employeeOid.Value == groupOfPeople.CreatedByEmployeeOid || ContainsMemberOfEmployee(groupOfPeople, emp))
							groups.Add(groupOfPeople);
					}
					else
					{
						groups.Add(groupOfPeople);
					}
				}
			}
			return groups;

		}

		private bool ContainsMemberOfEmployee(GroupOfPeople groupOfPeople, Employee emp)
		{
			return groupOfPeople.CostBearer2SupportConceptList.Any(c2s => emp.Employee2CustomerList.Any(e2c => e2c.CustomerOid == c2s.SupportConcept.Customer.Oid));
		}

		public bool IsAssessmentSheetEntryBelongingToAS(long assessmentSheetCategoryOid)
		{
			var cat = DAOFactory.GenericDAO.GetByID<AssessmentSheetCategory>(assessmentSheetCategoryOid);

			return cat.SystemEntryID.Equals(SystemEntryID.AdditionalServiceAssessmentSheet);
		}

		public bool IsAssessmentSheetCategoryBelongingToAS(long assessmentSheetCategoryOid)
		{
			try
			{
				var category = DAOFactory.GenericDAO.GetByID<AssessmentSheetCategory>(assessmentSheetCategoryOid);

				return category.SystemEntryID.Equals(SystemEntryID.AdditionalServiceAssessmentSheet);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<OvertimeDC> GetAllOvertimesFromEmployee(long employeeOid)
		{
			try
			{
				var allOvertimes = DAOFactory.GenericDAO.GetAll<Overtime>();
				var overtimes = allOvertimes.Where(o => o.EmployeeOid.Equals(employeeOid));

				return MapperFactory.OvertimeDC_Overtime.MapToNewDCs(overtimes);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<OvertimeDC> GetAllOvertimes()
		{
			try
			{
				var allOvertimes = DAOFactory.GenericDAO.GetAll<Overtime>();
				return MapperFactory.OvertimeDC_Overtime.MapToNewDCs(allOvertimes);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public void DeleteOvertimes(Dictionary<long, long> pOid2Version)
		{
			try
			{
				pOid2Version.Keys.DoForEach(SettingsLogic.RemoveFromAllHistories<Overtime>);
				var lOriginals = DAOFactory.GenericDAO.LoadByIDs<Overtime>(pOid2Version.Select(e => e.Key));
				lOriginals.DoForEach(or => MapperFactory.OvertimeDC_Overtime.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));

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

		public List<long> InsertOvertimes(List<OvertimeDC> pOvertimes)
		{
			try
			{
				var newOvertimes = MapperFactory.OvertimeDC_Overtime.MapToNewEntities(pOvertimes);
				DAOFactory.GenericDAO.Insert(newOvertimes);

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

		public List<long> UpdateOvertimes(List<OvertimeDC> pOvertimes)
		{
			try
			{
				var pOids = (from motherfucker in pOvertimes where motherfucker.OvertimeOid.HasValue select motherfucker.OvertimeOid.Value).ToList();
				var lOriginals = DAOFactory.GenericDAO.LoadByIDs<Overtime>(pOids);

				MapperFactory.OvertimeDC_Overtime.MergeWithEntitys(pOvertimes, lOriginals);
				DAOFactory.GenericDAO.Update(lOriginals);

				return (from mumu in lOriginals where mumu.Oid.HasValue select mumu.Oid.Value).ToList();
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<AuszahlungsartDC> GetAllAuszahlungsarten()
		{
			try
			{
				var alleAuszahlungsarten = DAOFactory.GenericDAO.GetAllActive<Auszahlungsart>();

				return MapperFactory.AuszahlungsartDC_Auszahlungsart.MapToNewDCs(alleAuszahlungsarten);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<long> InsertAuszahlungsarten(IEnumerable<AuszahlungsartDC> pAuszahlungsarten)
		{
			try
			{
				var neueAuszahlungsarten = MapperFactory.AuszahlungsartDC_Auszahlungsart.MapToNewEntities(pAuszahlungsarten);
				DAOFactory.GenericDAO.Insert(neueAuszahlungsarten);

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

		public List<long> UpdateAuszahlungsarten(List<AuszahlungsartDC> pAuszahlungsarten)
		{
			try
			{
				var pOids = (from motherfucker in pAuszahlungsarten where motherfucker.AuszahlungsartOid.HasValue select motherfucker.AuszahlungsartOid.Value).ToList();
				var lOriginals = DAOFactory.GenericDAO.LoadByIDs<Auszahlungsart>(pOids);

				MapperFactory.AuszahlungsartDC_Auszahlungsart.MergeWithEntitys(pAuszahlungsarten, lOriginals);
				DAOFactory.GenericDAO.Update(lOriginals);

				return (from mumu in lOriginals where mumu.Oid.HasValue select mumu.Oid.Value).ToList();
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public void DeleteAuszahlungsarten(Dictionary<long, long> pOid2Version)
		{
			try
			{
				pOid2Version.Keys.DoForEach(SettingsLogic.RemoveFromAllHistories<Auszahlungsart>);
				var lOriginals = DAOFactory.GenericDAO.LoadByIDs<Auszahlungsart>(pOid2Version.Select(e => e.Key));
				lOriginals.DoForEach(or => MapperFactory.AuszahlungsartDC_Auszahlungsart.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));

				//ServiceLogic.SetActivationType<Auszahlungsart>(pOid2Version, ActivationTypeId.Archived);

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

		public List<CompactTeamDC> GetTeamOidsByEmployee(long pEmployeeOid)
		{
			try
			{
				var liste = DAOFactory.SearchDAO.FindTeamsOfEmployee(pEmployeeOid);
				return MapperFactory.CompactTeamDC_Team.MapToNewDCs(liste);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<CompactEmployeeDC> GetAllChatActiveEmployeesCompact()
		{
			try
			{
				var employees = DAOFactory.SearchDAO.FindAllChatActiveEmployees();

                return MapperFactory.CompactEmployeeDC_Employee.MapToNewDCs(employees).OrderBy(e => e.ToString()).ToList();
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

		public List<EmployeeAPPCodeDC> GetAllEmployeeAppCodes(long pEmployeeOid)
		{
			try
			{
				var liste = DAOFactory.SearchDAO.FindAllEmployeeAppCodes(pEmployeeOid);

				return MapperFactory.EmployeeAPPCodeDC_EmployeeAPPCode.MapToNewDCs(liste);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public Byte[] GetEmployeeImage(long employeeOid)
		{
			try
			{
				var employee = DAOFactory.GenericDAO.GetByID<Employee>(employeeOid);

				return employee.Person.Images != null && employee.Person.Images.Count > 0 ? employee.Person.Images[0].Original : null;
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public Byte[] GetEmployeeThumbnail(long employeeOid)
		{
			try
			{
				var employee = DAOFactory.GenericDAO.GetByID<Employee>(employeeOid);

				return employee.Person.Images != null && employee.Person.Images.Count > 0 ? employee.Person.Images[0].SmallThumbnail : null;
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public CompactEmployeeDC GetActiveCompactEmployeeWithOid(long employeeOid)
		{
			try
			{
				var employee = DAOFactory.GenericDAO.GetByID<Employee>(employeeOid);

				return MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(employee);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public void InsertNewArbeitsZeit(ArbeitszeitDC arbeitszeit, ArbeitszeitEintragDC arbeitszeitEintrag)
		{
			try
			{
				var x = MapperFactory.ArbeitszeitDC_Arbeitszeit.MapToNewEntity(arbeitszeit);

				DAOFactory.GenericDAO.Insert(x);

				arbeitszeitEintrag.ArbeitszeitOid = x.Oid;

				var y = MapperFactory.ArbeitszeitEintragDC_ArbeitszeitEintrag.MapToNewEntity(arbeitszeitEintrag);

				DAOFactory.GenericDAO.Insert(y);

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

		public ArbeitszeitDC UpdateArbeitszeit(ArbeitszeitDC pArbeitszeit)
		{
			try
			{
				var lOriginal = DAOFactory.GenericDAO.LoadByID<Arbeitszeit>(pArbeitszeit.ArbeitszeitOid.Value);

				MapperFactory.ArbeitszeitDC_Arbeitszeit.MergeWithEntity(pArbeitszeit, lOriginal);
				DAOFactory.GenericDAO.Update(lOriginal);

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

		public void DeleteArbeitszeitEintrag(long arbeistzeitEintragOid)
		{
			try
			{
				var lOriginal = DAOFactory.GenericDAO.LoadByID<ArbeitszeitEintrag>(arbeistzeitEintragOid);

				DAOFactory.GenericDAO.Delete(lOriginal);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}
		public List<CompactVertreterEmployeeDC> GetAllActiveVertreterEmployeesCompact(long? customerOid, DateTime date)
		{
			var filter = new VertreterSucheFilterDC();
			filter.CustomerOid = customerOid;
			filter.StartDate = date;
			filter.EndDate = date;
			filter.VerwendeEntfernungssuche = false;
			return SucheVertreter(filter);
		}

		public List<CompactVertreterEmployeeDC> SucheVertreter(VertreterSucheFilterDC filter)
		{
			try
			{
				var s = PluginLoader.FindClass<VertretungsManager>();

				return s.SucheVertreter(filter);

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



		public List<EmployeeTokenRelationDC> LoadEmployeeTokenRelationsByOid(IEnumerable<long> pOids)
		{
			try
			{
				var customerTokenRels = DAOFactory.GenericDAO.LoadByIDs<Employee2Token>(pOids);

				return MapperFactory.EmployeeTokenRelationDC_Employee2Token.MapToNewDCs(customerTokenRels);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public EmployeeDC GetEmployeeByID(long employeeOid)
		{
			try
			{
				var employee = DAOFactory.GenericDAO.GetByID<Employee>(employeeOid);

				return MapperFactory.EmployeeDC_Employee.MapToNewDC(employee);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public void CreateOrUpdateChatBewoMessageSync(long? eOid, string text)
		{
			try
			{

				var chatMessageSync = DAOFactory.SearchDAO.FindEmployeeChatBewoMessageSync(eOid.Value);

				int count = chatMessageSync.Count();
				if (count > 0)
				{

					foreach (var item in chatMessageSync)
					{
						item.MessageSyncText = text;
					}

					DAOFactory.GenericDAO.Update(chatMessageSync);
				}
				else
				{
					ChatBewoMessageSyncDC cms = new ChatBewoMessageSyncDC();

					cms.EmployeeOid = eOid;
					cms.MessageSyncText = text;

					var x = MapperFactory.ChatBewoMessageSyncDC_ChatBewoMessageSync.MapToNewEntity(cms);
					DAOFactory.GenericDAO.Insert(x);
				}
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public ChatBewoMessageSyncDC GetChatBewoMessageSync(long? eOid)
		{
			try
			{
				var chatMessageSync = DAOFactory.GenericDAO.GetAllActive<ChatBewoMessageSync>();

				ChatBewoMessageSync cms = null;
				foreach (var item in chatMessageSync)
				{
					if (eOid == item.EmployeeOid)
					{
						cms = item;
					}
				}

				if (cms != null)
				{
					var x = MapperFactory.ChatBewoMessageSyncDC_ChatBewoMessageSync.MapToNewDC(cms);

					return x;
				}

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

		public void ReactivateEmployee(long pOid, long pVersion)
		{
			try
			{
				var e = DAOFactory.GenericDAO.LoadByID<Employee>(pOid);
				HistoryCreator.MakeNewEmployeeHistoryEntry(e, MapperFactory.EmployeeDC_Employee.MapToNewDC(e), StatementType.Reactivate);

				ServiceLogic.SetActivationType<Employee>(pOid, pVersion, ActivationTypeId.Active);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<CompactEmployeeDC> GetAllCompactEmployees()
		{
			try
			{
				var s = PluginLoader.FindClass<EmployeeService>();

				return s.GetAllCompactEmployees();

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

		public List<long> LoadTeamsRelatedCustomerOids(long employeeOid)
		{
			try
			{
				return DAOFactory.SearchDAO.FindTeamRelatedCustomerOids(employeeOid);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<EmployeeDC> GetAllActiveEmployees()
		{
			try
			{
				var employees = DAOFactory.GenericDAO.GetAllActive<Employee>();

				return MapperFactory.EmployeeDC_Employee.MapToNewDCs(employees);
			}
			catch (Exception exception)
			{
				throw Utils.CreateBeWoFaultException(exception);
			}
		}

		/// <summary>
		/// Lädt die aktiven CompactCustomerDCs für einen Mitarbeiter mit Rücksichtnahme auf dessen Rechte.
		/// </summary>
		/// <param name="employeeOid">Oid des Mitarbeiters für den die CompactCustomerDCs geladen werden sollen</param>
		/// <returns>Eine Liste mit CompactCustomerDCs</returns>
		public List<CompactCustomerDC> GetActiveCompactCustomersForEmployee(long? employeeOid)
		{
			try
			{
				var customers = DAOFactory.SearchDAO.GetAllCustomersForEmployee(employeeOid);

				return MapperFactory.CompactCustomerDC_Customer.MapToNewDCs(customers);
			}
			catch (Exception exception)
			{
				throw Utils.CreateBeWoFaultException(exception);
			}
		}

		/// <summary>
		/// Lädt die aktiven CompactEmployeeDCs für einen Mitarbeiter mit Rücksichtnahme auf dessen Rechte.
		/// </summary>
		/// <param name="employeeOid">Oid des Mitarbeiters für den die CompactEmployeeDCs geladen werden sollen</param>
		/// <returns>Eine Liste mit CompactEmployeeDCs</returns>
		public List<CompactEmployeeDC> GetActiveCompactEmployeesForEmployee(long employeeOid)
		{
			try
			{
				var employees = DAOFactory.SearchDAO.GetAllActiveEmployeesForEmployee(employeeOid);

				return MapperFactory.CompactEmployeeDC_Employee.MapToNewDCs(employees);
			}
			catch (Exception exception)
			{
				throw Utils.CreateBeWoFaultException(exception);
			}
		}

		/// <summary>
		/// Lädt die Oids der Klienten der Teams und deren Mitgliedern und Anführern.
		/// </summary>
		/// <param name="employeeOid">Mitarbeiter dessen Teams durchsucht werden sollen.</param>
		/// <param name="teamOid">Die Oid eines spezifischen Teams, das durchsucht werden soll. Ist die Oid null, werden alle mit dem angegebenen Mitarbeiter verknüpften Teams durchsucht.</param>
		/// <returns></returns>
		public List<long> GetTeamRelatedCustomerOids(long employeeOid, long? teamOid)
		{
			try
			{
				var result = new List<long>();

				var teams = new List<Team>();

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

				if (teamOid.HasValue)
				{
					teams.Add(DAOFactory.GenericDAO.LoadByID<Team>(teamOid.Value));
				}
				else
				{
					teams.AddRange(DAOFactory.SearchDAO.FindLeadingTeams(employeeOid));
					teams.AddRange(DAOFactory.SearchDAO.FindTeamsOfEmployee(employeeOid));
				}

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

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

		/// <summary>
		/// Lädt die aktiven TeamDCs für einen Mitarbeiter mit Rücksichtnahme auf dessen Rechte.
		/// </summary>
		/// <param name="employeeOid">Oid des Mitarbeiters für den die TeamDCs geladen werden sollen. Ist die employeeOid null, wird die des angemeldeten Mitarbeiters genommen.</param>
		/// <returns>Eine Liste mit TeamDCs</returns>
		public List<TeamDC> GetAllActiveTeamsForEmployee(long? employeeOid)
		{
			try
			{
				var teams = DAOFactory.SearchDAO.GetAllActiveTeamsForEmployee(employeeOid);

				return MapperFactory.TeamDC_Team.MapToNewDCs(teams);
			}
			catch (Exception exception)
			{
				throw Utils.CreateBeWoFaultException(exception);
			}
		}

		/// <summary>
		/// Lädt die aktiven CompactTeamDCs für einen Mitarbeiter mit Rücksichtnahme auf dessen Rechte.
		/// </summary>
		/// <param name="employeeOid">Oid des Mitarbeiters für den die CompactTeamDCs geladen werden sollen. Ist die employeeOid null, wird die des angemeldeten Mitarbeiters genommen.</param>
		/// <returns>Eine Liste mit CompactTeamDCs</returns>
		public List<CompactTeamDC> GetAllActiveCompactTeamsForEmployee(long? employeeOid)
		{
			try
			{
				var teams = DAOFactory.SearchDAO.GetAllActiveTeamsForEmployee(employeeOid);

				return MapperFactory.CompactTeamDC_Team.MapToNewDCs(teams);
			}
			catch (Exception exception)
			{
				throw Utils.CreateBeWoFaultException(exception);
			}
		}

		public List<SupportConceptDC> GetActiveSupportConceptsForEmployee(long? employeeOid, CustomerFilterEnum supportConceptFilter)
		{
			try
			{
				var supportConcepts = DAOFactory.SearchDAO.GetActiveSupportConceptsForEmployee(employeeOid, supportConceptFilter);

				return MapperFactory.SupportConceptDC_SupportConcept.MapToNewDCs(supportConcepts);
			}
			catch (Exception exception)
			{
				throw Utils.CreateBeWoFaultException(exception);
			}
		}

		public List<long> FindTeamCustomers(long? teamOid)
		{
			try
			{
				var customerOids = new List<long>();

				ApplicationUser loggedInUser;

				if (LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
				{
					loggedInUser = LoggedInUserOperationContextExt.Current.User;
				}
				else
				{
					loggedInUser = SessionFacade.LoggedInUser;
				}

				if (loggedInUser?.Employee != null)
				{
					var teams = new List<Team>();

					if (teamOid.HasValue)
					{
						teams.Add(DAOFactory.GenericDAO.LoadByID<Team>(teamOid.Value));
					}
					else if (loggedInUser.Employee.Oid.HasValue)
					{
						teams.AddRange(DAOFactory.SearchDAO.FindLeadingTeams(loggedInUser.Employee.Oid.Value));
						teams.AddRange(DAOFactory.SearchDAO.FindTeamsOfEmployee(loggedInUser.Employee.Oid.Value));
					}

					foreach (var team in teams)
					{
						if (!team.Oid.HasValue)
						{
							continue;
						}

						var customers = DAOFactory.SearchDAO.FindCustomerOfTeam(team.Oid.Value);
						foreach (var c in customers)
						{
							if (c.IsActive == ActivationTypeId.Active)
							{
								if (c.Oid.HasValue && !customerOids.Contains(c.Oid.Value))
								{
									customerOids.Add(c.Oid.Value);
								}
							}

						}

					}
				}

				return customerOids;
			}
			catch (Exception exception)
			{
				throw Utils.CreateBeWoFaultException(exception);
			}
		}

		public List<CompactCustomerDC> GetActiveCustomersForEmployee(long? employeeOid, CustomerFilterEnum customerFilter)
		{
			try
			{
				var customers = DAOFactory.SearchDAO.GetActiveCustomersForEmployee(employeeOid, customerFilter);

				return MapperFactory.CompactCustomerDC_Customer.MapToNewDCs(customers);
			}
			catch (Exception exception)
			{
				throw Utils.CreateBeWoFaultException(exception);
			}
		}

		public UrlaubsplanerRootDC BuildUrlaubsplanerRootObject(AbsenceOverviewFilterDC filter)
		{
			try
			{
				UrlaubsplanungsManager manager = new UrlaubsplanungsManager();
				return manager.BuildUrlaubsplanerRootObject(filter);
			}
			catch (Exception exception)
			{
				throw Utils.CreateBeWoFaultException(exception);
			}
		}

		public decimal CalculateUrlaubstage(DateTime entryDate, DateTime? endDate, int anzahlArbeitstage, int restlicheTageImJahr, decimal? urlaubstageProJahr) // Enddatum in die Parameterliste
		{
			try
			{
				decimal urlaubstage = 0;
				if (urlaubstageProJahr == null)
					urlaubstageProJahr = 0m;

				if (entryDate.Day == 1 && entryDate.Month == 1 || entryDate.Day == 2 && entryDate.Month == 1) //Erster Tag im Jahr
				{
					//Prüfen, ob Enddatum Ende des Jahres oder früher ist
					if (endDate == null)
					{
						if (anzahlArbeitstage < 5) // weniger als 5 Tage
							urlaubstage = (decimal)urlaubstageProJahr / 5m * anzahlArbeitstage;
						else
						{
							if (anzahlArbeitstage == 5) // 5 Tage
								urlaubstage = (decimal)urlaubstageProJahr;
							else if (anzahlArbeitstage == 6) // 6 Tage
								urlaubstage = (decimal)urlaubstageProJahr;
						}
					}
					else
					{
						if (anzahlArbeitstage < 5) // weniger als 5 Tage
							urlaubstage = (decimal)urlaubstageProJahr / 5m * anzahlArbeitstage;
						else
						{
							if (anzahlArbeitstage == 5) // 5 Tage
								urlaubstage = (decimal)urlaubstageProJahr / 365m * restlicheTageImJahr;
							else if (anzahlArbeitstage == 6) // 6 Tage
								urlaubstage = (decimal)urlaubstageProJahr / 365m * restlicheTageImJahr;
						}
					}

				}
				else if (/*entryDate.Day > 1 && */anzahlArbeitstage < 5) // Mitten im Jahr, weniger als 5 Tage
				{
					urlaubstage = (decimal)urlaubstageProJahr / 5m * 3m / 365m * restlicheTageImJahr;
				}
				else if (/*entryDate.Day > 1 && */anzahlArbeitstage >= 5) // Mitten im Jahr, 5 oder 6 Tage
				{
					urlaubstage = (decimal)urlaubstageProJahr / 365m * restlicheTageImJahr;
				}

				// Runden
				//urlaubstage = 25.51m;
				if (urlaubstage - (int)urlaubstage <= 0.1m)
				{
					urlaubstage = Math.Round(urlaubstage, MidpointRounding.AwayFromZero);
				}
				else if (urlaubstage - (int)urlaubstage <= 0.5m)
				{
					decimal digits = urlaubstage - (int)urlaubstage;
					urlaubstage = urlaubstage - digits + 0.5m;
				}
				else if (urlaubstage - (int)urlaubstage <= 1.0m)
				{
					urlaubstage = Math.Ceiling(urlaubstage);
				}

				return urlaubstage;
			}
			catch (Exception ex)
			{
				throw Utils.CreateBeWoFaultException(ex);
			}

		}

		public List<GeschenkterUrlaubstagDC> GetGeschenkteUrlaubstageForEmployee(long empOid)
		{
			try
			{
				List<GeschenkterUrlaubstagDC> tage = new List<GeschenkterUrlaubstagDC>();

				var tageEntities = DAOFactory.SearchDAO.FindGeschenkteUrlaubstageByEmpOid(empOid);
				if (tageEntities != null)
					tage.AddRange(MapperFactory.GeschenkterUrlaubstagDC_GeschenkterUrlaubstag.MapToNewDCs(tageEntities));

				return tage;
			}
			catch (Exception ex)
			{
				throw Utils.CreateBeWoFaultException(ex);
			}
		}
		public List<GeschenkterUrlaubstagDC> GetGeschenkteUrlaubstageForYear(int year)
		{
			try
			{
				List<GeschenkterUrlaubstagDC> tage = new List<GeschenkterUrlaubstagDC>();

				var tageEntities = DAOFactory.SearchDAO.FindGeschenkteUrlaubstageByYear(year);
				if (tageEntities != null)
					tage.AddRange(MapperFactory.GeschenkterUrlaubstagDC_GeschenkterUrlaubstag.MapToNewDCs(tageEntities));

                return tage;
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }
        public void InsertGeschenkterUrlaubstag(GeschenkterUrlaubstagDC dc)
        {
            try
            {
                var entity = MapperFactory.GeschenkterUrlaubstagDC_GeschenkterUrlaubstag.MapToNewEntity(dc);
                DAOFactory.GenericDAO.Insert(entity);
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }
        public void InsertMultipleGeschenkteUrlaubstage(List<GeschenkterUrlaubstagDC> dcs)
        {
            try
            {
                DAOFactory.GenericDAO.Insert(MapperFactory.GeschenkterUrlaubstagDC_GeschenkterUrlaubstag.MapToNewEntities(dcs));
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }
        public void DeleteGeschenkterUrlaubstag(long oid)
        {
            try
            {
                var lOriginal = DAOFactory.GenericDAO.LoadByID<GeschenkterUrlaubstag>((long)oid);
                DAOFactory.GenericDAO.Delete(lOriginal);
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }
        public virtual Dictionary<string, decimal> GetSonderurlaubForEmployee(long empOid, int berechnungsjahr)
        {
            Dictionary<string, decimal> sonderurlaub = new Dictionary<string, decimal>();
            try
            {
                var emp = DAOFactory.GenericDAO.GetByID<Employee>(empOid);
                Contract contract = null;
                foreach (var c in emp.Contracts)
                {
                    if (c.EntryDate.HasValue && !c.ContractEndDate.HasValue || c.EntryDate.HasValue && c.ContractEndDate.HasValue &&
                        berechnungsjahr >= c.EntryDate.Value.Year && berechnungsjahr <= c.ContractEndDate.Value.Year)
                    {
                        contract = c;
                        break;
                    }
                }
                // Wenn eine Behinderung von mind. 50 vorliegt stehen standardmäßig 5 Sonderurlaubstage zu
                if (contract != null && (contract.EntryDate.HasValue && contract.ContractEndDate.HasValue || contract.EntryDate.HasValue && !contract.ContractEndDate.HasValue))
                {
                    var yearStart = new DateTime(berechnungsjahr, 1, 1);
                    var yearEnd = new DateTime(berechnungsjahr, 12, 31);

                    // Schnittmenge aus Vertrag + Ausweis
                    var overlapStart = contract.EntryDate > emp.AusweisGueltigVon ? contract.EntryDate : emp.AusweisGueltigVon;
                    var overlapEnd = (contract.ContractEndDate ?? DateTime.MaxValue) < emp.AusweisGueltigBis ? (contract.ContractEndDate ?? DateTime.MaxValue) : emp.AusweisGueltigBis;

                    // Jetzt prüfen: gibt es davon etwas im Jahr?
                    if (overlapStart <= overlapEnd && overlapStart <= yearEnd && overlapEnd >= yearStart)
                    {
                        if (emp.GradDerBehinderung.IsNotNullOrEmpty())
                        {
                            int.TryParse(emp.GradDerBehinderung, out int grad);
                            if (grad >= 50)
                            {
                                // TODO Anteilig berechnen, (wenn Behinderung erst im Berechnungsjahr beginnt nur die "aktiven" Monate anrechnen und ab  

                                // Wenn keine Anzahl der wöchentlichen Arbeitstage gesetzt ist, 5 Tage
                                // Sonst Anzahl der wöchentlichen Arbeitstage (gesdetzlich so geregelt)
                                sonderurlaub.Add("Sonderurlaub aufgrund von Behinderungsgrad über 50", 5);
                            }
                        }
                    }
                }

                return sonderurlaub;

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

            return sonderurlaub;
        }
        public List<AbwesenheitsInformationPrintDC> InsertAbwesenheitsInformationPrint(List<AbwesenheitsInformationPrintDC> abwesenheitsInformationPrints)
        {
            try
            {
                DAOFactory.GenericDAO.Insert(MapperFactory.AbwesenheitsInformationPrintDC_AbwesenheitsInformationPrint.MapToNewEntities(abwesenheitsInformationPrints));

				var prints = DAOFactory.GenericDAO.GetAll<AbwesenheitsInformationPrint>();

				return MapperFactory.AbwesenheitsInformationPrintDC_AbwesenheitsInformationPrint.MapToNewDCs(prints);
			}
			catch (Exception ex)
			{
				throw Utils.CreateBeWoFaultException(ex);
			}
		}
		public List<AbwesenheitsInformationPrintDC> GetAbwesenheitsInformationPrints(List<long> oids)
		{
			try
			{
				var entities = DAOFactory.GenericDAO.LoadByIDs<AbwesenheitsInformationPrint>(oids);
				List<AbwesenheitsInformationPrintDC> objekte = MapperFactory.AbwesenheitsInformationPrintDC_AbwesenheitsInformationPrint.MapToNewDCs(entities);
				return objekte;
			}
			catch (Exception ex)
			{
				throw Utils.CreateBeWoFaultException(ex);
			}
		}
		public List<AbwesenheitsInformationPrintDC> GetAllAbwesenheitsInformationPrints()
		{
			try
			{
				var entities = DAOFactory.GenericDAO.GetAllActive<AbwesenheitsInformationPrint>();
				var dcs = MapperFactory.AbwesenheitsInformationPrintDC_AbwesenheitsInformationPrint.MapToNewDCs(entities);
				return dcs;
			}
			catch (Exception ex)
			{
				throw Utils.CreateBeWoFaultException(ex);
			}
		}
		public void DeleteAbwesenheitsInformationPrints(List<AbwesenheitsInformationPrintDC> dcs)
		{
			try
			{
				UrlaubsplanungsManager manager = new UrlaubsplanungsManager();
				manager.DeleteAbwesenheitsInformationPrints(dcs);
			}
			catch (Exception ex)
			{
				throw Utils.CreateBeWoFaultException(ex);
			}
		}
		public List<UrlaubskontoDarstellungDC> ErstelleUrlaubskontoDarstellung(EmployeeDC emp, int year)
		{
			try
			{
				var vs = PluginLoader.FindClass<VacationService>();
				return vs.BerechneUrlaubskontoZurDarstellung(emp, year);
			}
			catch (Exception ex)
			{
				throw Utils.CreateBeWoFaultException(ex);
			}
		}
		public Dictionary<long?, decimal> BerechneAnzEinerAbwesenheitFuerMehrereMitarbeiter(List<long?> empOids, int year, string reason)
		{
			try
			{
				var vs = PluginLoader.FindClass<VacationService>();
				return vs.BerechneAnzEinerAbwesenheitFuerMehrereMitarbeiter(empOids, year, reason);
			}
			catch (Exception ex)
			{
				throw Utils.CreateBeWoFaultException(ex);
			}
		}
		public decimal CountKrankheitstage(AbwesenheitsInformationDC infoDC)
		{
			try
			{
				var manager = new UrlaubsplanungsManager();
				return manager.CountKrankheitstage(infoDC);
			}
			catch (Exception ex)
			{
				throw Utils.CreateBeWoFaultException(ex);
			}
		}
		public decimal CountUrlaubstage(AbwesenheitsInformationDC infoDC)
		{
			try
			{
				var manager = new UrlaubsplanungsManager();
				return manager.CountUrlaubstage(infoDC);
			}
			catch (Exception ex)
			{
				throw Utils.CreateBeWoFaultException(ex);
			}
		}

		public List<EmployeeDC> GetAbsenceOverview(AbsenceOverviewFilterDC filter)
		{
			try
			{
				var res = new List<EmployeeDC>();
				var vs = PluginLoader.FindClass<VacationService>();

				var allEmployees = DAOFactory.GenericDAO.GetAllActive<Employee>().ToList();

				List<Team> teams = new List<Team>();
				if (filter.Teams != null)
					teams = DAOFactory.GenericDAO.GetActiveByIDs<Team>(filter.Teams) as List<Team>;


				//foreach (var emp in allEmployees.OrderBy(x => x.Person.LastNameFirstName))
				List<Employee> benoetigteMitarbeiter = new List<Employee>();
				if (teams.Count == 0)
					benoetigteMitarbeiter = allEmployees;
				else
				{
					foreach (var team in teams)
					{
						benoetigteMitarbeiter.AddRange(team.MemberList);
					}
				}
				benoetigteMitarbeiter.OrderBy(x => x.Person.LastNameFirstName).ToList();

				foreach (var emp in benoetigteMitarbeiter)
				{
					if (filter.EmploymentType != null)
						if (!emp.Contracts.Any(x => x.EmploymentType != null && filter.EmploymentType.Contains(x.EmploymentType.Oid.Value)))
							continue;

					if (res.Any(e => e.EmployeeOid == emp.Oid))
						continue;

					var dict = vs.BerechneUrlaubskonto(emp, filter.Year);

					if (filter.AbsenceReasons != null)
						emp.AbsenceTimes.RemoveRange(x => !filter.AbsenceReasons.Contains(x.AbsenceReason.Oid.Value));

					//if (filter.Teams != null)
					//{
					//    bool isInTeam = false;
					//    foreach (var team in teams)
					//    {
					//        if (team.MemberList.Contains(emp))
					//            isInTeam = true;
					//    }
					//    if (!isInTeam)
					//        continue;
					//}

					var empDC = MapperFactory.EmployeeDC_Employee.MapToNewDC(emp);
					if (dict.ContainsKey(filter.Year))
					{
						empDC.Urlaubskonto = dict[filter.Year];
					}
					else
					{
						int test = 0;
					}

					res.Add(empDC);
				}

				return res.OrderBy(e => e.LastNameFirstName).ToList();
			}
			catch (Exception exception)
			{
				throw Utils.CreateBeWoFaultException(exception);
			}
		}



		public CompactEmployeeDC FindCompactEmployeeByFullname(string fullname)
		{
			try
			{
				var employee = DAOFactory.SearchDAO.FindEmployeeByFullname(fullname);

				return employee is null ? null : MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(employee);
			}
			catch (Exception ex)
			{
				throw Utils.CreateBeWoFaultException(ex);
			}
		}

		public TeamDC FindTeamByOid(long teamOid, long employeeOid)
		{
			try
			{
				var teams = GetAllActiveTeamsForEmployee(employeeOid);

				return teams.FirstOrDefault(t => t.TeamOid.HasValue && t.TeamOid.Value.Equals(teamOid));
			}
			catch (Exception ex)
			{
				throw Utils.CreateBeWoFaultException(ex);
			}
		}

		public List<CompactTeamDC> LoadCompactTeamsByOid(List<long> teamOids)
		{
			try
			{
				return teamOids is null ? new List<CompactTeamDC>() : MapperFactory.CompactTeamDC_Team.MapToNewDCs(DAOFactory.GenericDAO.GetActiveByIDs<Team>(teamOids));
			}
			catch (Exception ex)
			{
				throw Utils.CreateBeWoFaultException(ex);
			}
		}

		public List<CompactTeamDC> FindLeadingCompactTeamsOfEmployee(long employeeOid)
		{
			try
			{
				return MapperFactory.CompactTeamDC_Team.MapToNewDCs(DAOFactory.SearchDAO.FindLeadingTeams(employeeOid));
			}
			catch (Exception ex)
			{
				throw Utils.CreateBeWoFaultException(ex);
			}
		}

        public List<CompactEmployeeDC> GetActiveCompactEmployeesByOids(List<long> employeeOids)
        {
            try
            {
                var employees = DAOFactory.SearchDAO.GetActiveEmployeesByOids(employeeOids);

                return MapperFactory.CompactEmployeeDC_Employee.MapToNewDCs(employees);
            }
            catch(Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }

        public List<TeamFolderRightDC> GetTeamRightsForFolder(long folderOid)
        {
            try
            {
                var rights = DAOFactory.SearchDAO.GetTeamRightsForFolder(folderOid);

                return MapperFactory.TeamFolderRight.MapToNewDCs(rights);
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }

        public List<TeamFolderRightDC> SaveTeamFolderRights(List<TeamFolderRightDC> list)
		{
            try
            {
                var originals = DAOFactory.GenericDAO.LoadByIDs<TeamFolderRight>(list.Where(t => t.Oid.HasValue).Select(t2 => t2.Oid.Value));
                MapperFactory.TeamFolderRight.MergeWithEntitys(list, originals);
                DAOFactory.GenericDAO.Update(originals);

                return MapperFactory.TeamFolderRight.MapToNewDCs(originals);
            }
            catch (Exception ex)
            {
                throw Utils.CreateBeWoFaultException(ex);
            }
        }
    }
}