Rene Evertz
e2f72fbea0
# Conflicts: # BeWo/ServiceProxy/Generated.cs # BeWo/Services/BeWoWindowService.cs # BeWo/View/Controls/GkvAbrechnungDetailControl.xaml.cs # BeWo/View/Windows/BeWoWindowBuilder.cs # Data/Data.csproj # Host/ServiceRecordPage.aspx.cs # Service/Core/ServiceHelper.cs # Service/Security/SecurityContextInitializer.cs # Service/ServiceBehavior/AdminMultitenancyContextInitializer.cs
2238 lines
78 KiB
C#
2238 lines
78 KiB
C#
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();
|
|
|
|
}
|
|
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 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);
|
|
}
|
|
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 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);
|
|
}
|
|
}
|
|
}
|
|
} |