1235 lines
48 KiB
C#
1235 lines
48 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.ServiceModel;
|
|
using System.Xml;
|
|
using System.Xml.Linq;
|
|
|
|
using BeWo.Data.Access;
|
|
using BeWo.Data.Entities;
|
|
using BeWo.Service.Core;
|
|
using BeWo.Service.DCEntityMapper;
|
|
using BeWo.Service.ServiceContracts;
|
|
|
|
using BS.Shared;
|
|
using BS.Shared.DataContracts;
|
|
using BS.Shared.DataContracts.Compact;
|
|
using BS.Shared.Extensions;
|
|
using DevExpress.XtraScheduler;
|
|
using Resource = BeWo.Data.Entities.Resource;
|
|
using Utils = BeWo.Service.Core.Utils;
|
|
|
|
namespace BeWo.Service.ServiceImplementations
|
|
{
|
|
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Single)]
|
|
public class ResourceServiceImp : IResourceService
|
|
{
|
|
public void DeactivateResource(long pOid, long pVersion)
|
|
{
|
|
try
|
|
{
|
|
ServiceLogic.SetActivationType<Resource>(new Dictionary<long, long> { { pOid, pVersion } }, ActivationTypeId.Deleted);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public void DeactivateResources(Dictionary<long, long> pOid2Version)
|
|
{
|
|
try
|
|
{
|
|
ServiceLogic.SetActivationType<Resource>(pOid2Version, ActivationTypeId.Deleted);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public void DeleteBooking(long pOid, long pVersion)
|
|
{
|
|
try
|
|
{
|
|
this.DeleteBookings(new Dictionary<long, long> { { pOid, pVersion } });
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public void DeleteBookings(Dictionary<long, long> pOid2Version)
|
|
{
|
|
try
|
|
{
|
|
var lOriginals = DAOFactory.GenericDAO.LoadByIDs<ResourceBookingSequence>(pOid2Version.Select(e => e.Key));
|
|
lOriginals.DoForEach(or => MapperFactory.BookingSequenceDC_ResourceBookingSequence.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));
|
|
|
|
DAOFactory.GenericDAO.Delete(lOriginals);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public void DeleteResource(long pOid, long pVersion)
|
|
{
|
|
try
|
|
{
|
|
this.DeleteResources(new Dictionary<long, long> { { pOid, pVersion } });
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public void DeleteResources(Dictionary<long, long> pOid2Version)
|
|
{
|
|
try
|
|
{
|
|
var lOriginals = DAOFactory.GenericDAO.LoadByIDs<Resource>(pOid2Version.Select(e => e.Key));
|
|
lOriginals.DoForEach(or => MapperFactory.ResourceDC_Resource.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));
|
|
|
|
DAOFactory.GenericDAO.Delete(lOriginals);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<BookingSequenceDC> GetAllBookings(DateTime pStartSpan, DateTime pEndSpan)
|
|
{
|
|
try
|
|
{
|
|
var t = DAOFactory.SearchDAO.FindBookings(pStartSpan, pEndSpan);
|
|
//### Kalender
|
|
//ConvertResourceBookingsToResourceAppointments();
|
|
return MapperFactory.BookingSequenceDC_ResourceBookingSequence.MapToNewDCs(t);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<BookingSequenceDC> GetAllBookingsByResource(long pResourceOid, DateTime pStartSpan, DateTime pEndSpan)
|
|
{
|
|
try
|
|
{
|
|
var t = DAOFactory.SearchDAO.FindBookings(pResourceOid, pStartSpan, pEndSpan);
|
|
return MapperFactory.BookingSequenceDC_ResourceBookingSequence.MapToNewDCs(t);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<ResourceDC> GetAllResources()
|
|
{
|
|
try
|
|
{
|
|
return MapperFactory.ResourceDC_Resource.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<Resource>());
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<long> InsertNewBookings(List<BookingSequenceDC> pBookings)
|
|
{
|
|
try
|
|
{
|
|
var lEntities = MapperFactory.BookingSequenceDC_ResourceBookingSequence.MapToNewEntities(pBookings);
|
|
DAOFactory.GenericDAO.Insert(lEntities);
|
|
return lEntities.Select(e => e.Oid.Value).ToList();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<BookingSequenceDC> InsertNewBookingSequenceDCs(IEnumerable<BookingSequenceDC> pBookings)
|
|
{
|
|
try
|
|
{
|
|
var lEntities = MapperFactory.BookingSequenceDC_ResourceBookingSequence.MapToNewEntities(pBookings);
|
|
DAOFactory.GenericDAO.Insert(lEntities);
|
|
return MapperFactory.BookingSequenceDC_ResourceBookingSequence.MapToNewDCs(lEntities);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<long> InsertNewResources(List<ResourceDC> pResources)
|
|
{
|
|
try
|
|
{
|
|
List<Resource> lResources = MapperFactory.ResourceDC_Resource.MapToNewEntities(pResources);
|
|
DAOFactory.GenericDAO.Insert(lResources);
|
|
return lResources.Select(r => r.Oid.Value).ToList();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<long> UpdateBookings(List<BookingSequenceDC> pBookings)
|
|
{
|
|
try
|
|
{
|
|
var lOriginals = DAOFactory.GenericDAO.LoadByIDs<ResourceBookingSequence>(pBookings.Select(b => b.SequenceOid.Value));
|
|
MapperFactory.BookingSequenceDC_ResourceBookingSequence.MergeWithEntitys(pBookings, lOriginals);
|
|
DAOFactory.GenericDAO.Update(lOriginals);
|
|
return lOriginals.Select(b => b.Oid.Value).ToList();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<BookingSequenceDC> UpdateBookingSequenceDCs(List<BookingSequenceDC> pBookings)
|
|
{
|
|
try
|
|
{
|
|
var lOriginals = DAOFactory.GenericDAO.LoadByIDs<ResourceBookingSequence>(pBookings.Select(b => b.SequenceOid.Value));
|
|
MapperFactory.BookingSequenceDC_ResourceBookingSequence.MergeWithEntitys(pBookings, lOriginals);
|
|
DAOFactory.GenericDAO.Update(lOriginals);
|
|
return MapperFactory.BookingSequenceDC_ResourceBookingSequence.MapToNewDCs(lOriginals);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<ResourceDC> UpdateResourceDCs(List<ResourceDC> pResource)
|
|
{
|
|
try
|
|
{
|
|
var lOriginals = DAOFactory.GenericDAO.LoadByIDs<Resource>(pResource.Select(b => b.ResourceOid.Value));
|
|
MapperFactory.ResourceDC_Resource.MergeWithEntitys(pResource, lOriginals);
|
|
DAOFactory.GenericDAO.Update(lOriginals);
|
|
return MapperFactory.ResourceDC_Resource.MapToNewDCs(lOriginals);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<long> UpdateResources(List<ResourceDC> pResource)
|
|
{
|
|
try
|
|
{
|
|
var lOriginals = DAOFactory.GenericDAO.LoadByIDs<Resource>(pResource.Select(b => b.ResourceOid.Value));
|
|
MapperFactory.ResourceDC_Resource.MergeWithEntitys(pResource, lOriginals);
|
|
DAOFactory.GenericDAO.Update(lOriginals);
|
|
return lOriginals.Select(b => b.Oid.Value).ToList();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<ResourceAppointmentDC> UpdateResourceAppointments(List<ResourceAppointmentDC> pResourceAppointments)
|
|
{
|
|
try
|
|
{
|
|
var lOriginals = DAOFactory.GenericDAO.LoadByIDs<ResourceAppointment>(pResourceAppointments.Select(b => b.ResourceAppointmentOid.Value));
|
|
MapperFactory.ResourceAppointmentDC_ResourceAppointment.MergeWithEntitys(pResourceAppointments, lOriginals);
|
|
DAOFactory.GenericDAO.Update(lOriginals);
|
|
return MapperFactory.ResourceAppointmentDC_ResourceAppointment.MapToNewDCs(lOriginals);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<ResourceAppointmentDC> InsertNewResourceAppointments(IEnumerable<ResourceAppointmentDC> pResourceAppointments)
|
|
{
|
|
try
|
|
{
|
|
var lResources = MapperFactory.ResourceAppointmentDC_ResourceAppointment.MapToNewEntities(pResourceAppointments);
|
|
|
|
DAOFactory.GenericDAO.Insert(lResources);
|
|
return MapperFactory.ResourceAppointmentDC_ResourceAppointment.MapToNewDCs(lResources);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public void DeleteResourceAppointments(Dictionary<long, long> pOid2Version)
|
|
{
|
|
try
|
|
{
|
|
var lOriginals = DAOFactory.GenericDAO.LoadByIDs<ResourceAppointment>(pOid2Version.Select(e => e.Key));
|
|
lOriginals.DoForEach(or => MapperFactory.ResourceAppointmentDC_ResourceAppointment.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));
|
|
|
|
DAOFactory.GenericDAO.Delete(lOriginals);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
private void ConvertResourceBookingsToResourceAppointments()
|
|
{
|
|
try
|
|
{
|
|
const string selectQuery = "SELECT ResourceBookingSequenceOid, Oid FROM resourcebooking WHERE IsActive = 1 AND IsDeleted = 0";
|
|
var dataSet = DAOFactory.AdoDAO.ExecuteQuery(selectQuery);
|
|
var dataReader = dataSet.CreateDataReader();
|
|
var rbs2rb = new Dictionary<long, List<long>>();
|
|
var newSchedulerAppointments = new List<SchedulerAppointmentDC>();
|
|
var sequence2booking = new Dictionary<ResourceBookingSequence, List<ResourceBooking>>();
|
|
var allResourceBookings = DAOFactory.GenericDAO.GetAllActive<ResourceBooking>();
|
|
|
|
while (dataReader.Read())
|
|
{
|
|
rbs2rb.AddOrUpdateValueInDictionary((long) dataReader.GetValue(0), new List<long> {(long) dataReader.GetValue(1)});
|
|
}
|
|
|
|
if (allResourceBookings.Count == 0) return;
|
|
|
|
allResourceBookings = allResourceBookings.OrderBy(o => o.Oid).ToList();
|
|
|
|
foreach (var b in allResourceBookings)
|
|
{
|
|
if (!sequence2booking.ContainsKey(b.Sequence))
|
|
sequence2booking.Add(b.Sequence, new List<ResourceBooking> {b});
|
|
else
|
|
sequence2booking[b.Sequence].Add(b);
|
|
}
|
|
|
|
foreach (var kvp in sequence2booking)
|
|
{
|
|
var sequence = kvp.Key;
|
|
var frequencyType = sequence.FrequencyType;
|
|
|
|
foreach (var booking in kvp.Value)
|
|
{
|
|
var originator = DAOFactory.SearchDAO.FindEmployeeByFullname(booking.InsUser) ?? booking.Employee;
|
|
|
|
if (booking.Sequence.FrequencyType.Equals(ResourceBookingFrequencyType.MonthlyOnLastDay))
|
|
{
|
|
var singleBookings = ConvertType6ResourceAppointment(booking);
|
|
newSchedulerAppointments.AddRange(singleBookings);
|
|
continue;
|
|
}
|
|
|
|
var employeeList = new List<Employee2SchedulerAppointmentDC>();
|
|
if(booking.Employee != null)
|
|
employeeList.Add(new Employee2SchedulerAppointmentDC
|
|
{
|
|
Employee = MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(booking.Employee),
|
|
ParticipationAnswer = ParticipationAnswer.Zusage,
|
|
IsPC_CheckedTs = null,
|
|
IsPChanged = false
|
|
});
|
|
|
|
var resourceList = new List<ResourceDC> {MapperFactory.ResourceDC_Resource.MapToNewDC(booking.Sequence.Resource)};
|
|
|
|
var newSchedulerAppointment = new SchedulerAppointmentDC
|
|
{
|
|
AllDay = booking.Start.Equals(booking.End),
|
|
CustomerList = new List<CompactCustomerDC>(),
|
|
Description = booking.Notice,
|
|
EmployeeList = employeeList,
|
|
EndDate = booking.End,
|
|
StartDate = booking.Start,
|
|
IsPrivate = false,
|
|
ResourceList = resourceList,
|
|
Subject = booking.Notice,
|
|
Originator = MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(originator),
|
|
Type = 0,
|
|
FormerBookingSequenceOid = booking.Sequence.Oid
|
|
};
|
|
|
|
if (kvp.Value.Count > 1 && booking.SequencePosition > 0)
|
|
{
|
|
newSchedulerAppointment.Type = booking.IsDeleted ? 4 : 3;
|
|
}
|
|
else if(frequencyType > 0)
|
|
{
|
|
newSchedulerAppointment.Type = 1;
|
|
}
|
|
|
|
if(!booking.Sequence.FrequencyType.Equals(ResourceBookingFrequencyType.Once))
|
|
newSchedulerAppointment.RecurrenceInfo = CreateRecurrenceInfo(booking).ToXml();
|
|
|
|
if (newSchedulerAppointments.FirstOrDefault(f => f.FormerBookingSequenceOid.Equals(sequence.Oid)) != null)
|
|
{
|
|
var x = newSchedulerAppointments.First(f => f.FormerBookingSequenceOid.Equals(sequence.Oid) && f.RecurrenceInfo != null).RecurrenceInfo;
|
|
|
|
using (var reader = XmlReader.Create(new StringReader(x)))
|
|
{
|
|
reader.ReadToFollowing("RecurrenceInfo");
|
|
reader.MoveToAttribute("Id");
|
|
var id = reader.Value;
|
|
|
|
var doc = XDocument.Load(new StringReader(newSchedulerAppointment.RecurrenceInfo));
|
|
var xElement = doc.Element("RecurrenceInfo");
|
|
if (xElement != null)
|
|
{
|
|
xElement.RemoveAttributes();
|
|
xElement.Add(new XAttribute("Id", id));
|
|
xElement.Add(new XAttribute("Index", booking.SequencePosition));
|
|
}
|
|
|
|
newSchedulerAppointment.RecurrenceInfo = doc.ToString();
|
|
}
|
|
}
|
|
|
|
newSchedulerAppointments.Add(newSchedulerAppointment);
|
|
}
|
|
}
|
|
|
|
foreach (var resourcebooking in allResourceBookings)
|
|
{
|
|
resourcebooking.IsActive = ActivationTypeId.Deleted;
|
|
resourcebooking.Sequence.IsActive = ActivationTypeId.Deleted;
|
|
}
|
|
|
|
DAOFactory.GenericDAO.Update(allResourceBookings);
|
|
InsertSchedulerAppointments(newSchedulerAppointments);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(ex);
|
|
}
|
|
}
|
|
|
|
private static RecurrenceInfo CreateRecurrenceInfo(ResourceBooking booking)
|
|
{
|
|
var sequence = booking.Sequence;
|
|
var recInfo = new RecurrenceInfo {Range = RecurrenceRange.EndByDate};
|
|
DateTime? datum = null;
|
|
|
|
// Rekonstruktion der gelöschten Zeiten (der neue Termin wird sonst nicht als gelöscht angezeigt)
|
|
if (booking.Start == null)
|
|
{
|
|
var firstBooking = DAOFactory.SearchDAO.GetFirstResourceBookingFromSequence(sequence.Oid.Value);
|
|
var sequenceStartDate = firstBooking.Start.Value;
|
|
|
|
// Täglich
|
|
if (sequence.FrequencyType.Equals(ResourceBookingFrequencyType.Daily))
|
|
{
|
|
datum = sequenceStartDate.AddDays(sequence.RepeatInterval * booking.SequencePosition);
|
|
}
|
|
|
|
// Wöchentlich
|
|
if (sequence.FrequencyType.Equals(ResourceBookingFrequencyType.Weekly))
|
|
{
|
|
datum = sequenceStartDate.AddDays(sequenceStartDate.Day + 7 * sequence.RepeatInterval * booking.SequencePosition);
|
|
}
|
|
|
|
// Monatlich
|
|
if (sequence.FrequencyType.Equals(ResourceBookingFrequencyType.Monthly))
|
|
{
|
|
datum = sequenceStartDate.AddMonths(sequence.RepeatInterval*booking.SequencePosition);
|
|
}
|
|
|
|
// X. Wochentag des Monats
|
|
if (sequence.FrequencyType.Equals(ResourceBookingFrequencyType.MonthlyOnFirstDay))
|
|
{
|
|
datum = sequenceStartDate.AddMonthsDayDependent(sequence.RepeatInterval*booking.SequencePosition, true);
|
|
}
|
|
|
|
booking.Start = datum;
|
|
booking.End = booking.Start.Value.AddMinutes((firstBooking.End.Value - firstBooking.Start.Value).TotalMinutes);
|
|
}
|
|
|
|
if (booking.Start != null)
|
|
recInfo.Start = booking.Start.Value;
|
|
if (sequence.SequenceEnd != null)
|
|
recInfo.End = sequence.SequenceEnd.Value;
|
|
|
|
if (sequence.RepeatInterval > 1)
|
|
recInfo.Periodicity = sequence.RepeatInterval;
|
|
|
|
switch (booking.Sequence.FrequencyType)
|
|
{
|
|
case ResourceBookingFrequencyType.Daily:
|
|
recInfo.OccurrenceCount = ((recInfo.End - recInfo.Start).Days + 1) /
|
|
booking.Sequence.RepeatInterval;
|
|
recInfo.Type = RecurrenceType.Daily;
|
|
break;
|
|
case ResourceBookingFrequencyType.Weekly:
|
|
recInfo.OccurrenceCount = ((recInfo.End - recInfo.Start).Days / 7 + 1) /
|
|
booking.Sequence.RepeatInterval;
|
|
recInfo.Type = RecurrenceType.Weekly;
|
|
recInfo.WeekDays = GetWeekDay(recInfo.Start.DayOfWeek.ToString());
|
|
break;
|
|
case ResourceBookingFrequencyType.Monthly:
|
|
recInfo.Type = RecurrenceType.Monthly;
|
|
recInfo.OccurrenceCount = ((recInfo.End - recInfo.Start).Days / 30 + 1) /
|
|
booking.Sequence.RepeatInterval;
|
|
recInfo.WeekDays = GetWeekDay(recInfo.Start.DayOfWeek.ToString());
|
|
recInfo.DayNumber = recInfo.Start.Day;
|
|
recInfo.WeekOfMonth = WeekOfMonth.None;
|
|
break;
|
|
case ResourceBookingFrequencyType.MonthlyOnFirstDay:
|
|
recInfo.Type = RecurrenceType.Monthly;
|
|
recInfo.OccurrenceCount = ((recInfo.End - recInfo.Start).Days / 30 + 1) /
|
|
booking.Sequence.RepeatInterval;
|
|
recInfo.WeekDays = GetWeekDay(recInfo.Start.DayOfWeek.ToString());
|
|
recInfo.WeekOfMonth = recInfo.Start.GetWeekOfMonth(DayOfWeek.Sunday);
|
|
break;
|
|
}
|
|
|
|
return recInfo;
|
|
}
|
|
|
|
private static IEnumerable<SchedulerAppointmentDC> ConvertType6ResourceAppointment(ResourceBooking booking)
|
|
{
|
|
var sequence = booking.Sequence;
|
|
if (sequence.Oid == null) return null;
|
|
|
|
var firstBooking = DAOFactory.SearchDAO.GetFirstResourceBookingFromSequence(sequence.Oid.Value);
|
|
|
|
if (firstBooking.Start == null || firstBooking.End == null || sequence.SequenceEnd == null) return null;
|
|
|
|
// X. Letzten Wochentag im Monat berechnen für den gesamten Zeitraum (Typ 3 und 4 beachten, oder nicht?)
|
|
var duration = (firstBooking.End.Value - firstBooking.Start.Value).TotalMinutes;
|
|
var newDates = new List<DateTime>{firstBooking.Start.Value};
|
|
|
|
newDates.AddRange(CalculateLastXInMonthDates(DAOFactory.SearchDAO.GetExcludedBookingSequencePositions(sequence.Oid.Value), firstBooking.Start.Value, sequence));
|
|
|
|
var employee = MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(booking.Employee);
|
|
var employeeList = new List<Employee2SchedulerAppointmentDC>();
|
|
if (booking.Employee != null)
|
|
employeeList.Add(new Employee2SchedulerAppointmentDC
|
|
{
|
|
Employee = employee,
|
|
ParticipationAnswer = ParticipationAnswer.Zusage,
|
|
IsPC_CheckedTs = null,
|
|
IsPChanged = false
|
|
});
|
|
|
|
var resourceList = new List<ResourceDC> { MapperFactory.ResourceDC_Resource.MapToNewDC(booking.Sequence.Resource) };
|
|
|
|
return newDates.Select(date => new SchedulerAppointmentDC
|
|
{
|
|
AllDay = false,
|
|
CustomerList = new List<CompactCustomerDC>(),
|
|
Description = firstBooking.Notice,
|
|
EmployeeList = employeeList,
|
|
EndDate = date.AddMinutes(duration),
|
|
FormerBookingSequenceOid = firstBooking.Sequence.Oid,
|
|
IsPrivate = false,
|
|
Originator = employee,
|
|
ResourceList = resourceList,
|
|
StartDate = date,
|
|
Subject = firstBooking.Notice,
|
|
Type = 0
|
|
}).ToList();
|
|
}
|
|
|
|
private static IEnumerable<DateTime> CalculateLastXInMonthDates(ICollection<int> excludedBookingSequencePositions, DateTime pSequenceStart, ResourceBookingSequence pSequence)
|
|
{
|
|
// bearbeitete und gelöschte Termine nicht beachten
|
|
var result = new List<DateTime>();
|
|
|
|
var lCurrentPosition = 0;
|
|
var lCurrentSequencePosition = 1;
|
|
var lCurrentStart = pSequenceStart.AddMonthsDayDependent(1, false);
|
|
|
|
while (lCurrentStart <= pSequence.SequenceEnd)
|
|
{
|
|
lCurrentPosition++;
|
|
|
|
if (lCurrentPosition % pSequence.RepeatInterval == 0 && !excludedBookingSequencePositions.Contains(lCurrentSequencePosition))
|
|
{
|
|
result.Add(lCurrentStart);
|
|
lCurrentSequencePosition++;
|
|
}
|
|
|
|
lCurrentStart = lCurrentStart.AddMonthsDayDependent(1, false);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static WeekDays GetWeekDay(string name)
|
|
{
|
|
switch (name)
|
|
{
|
|
case "Sunday":
|
|
return WeekDays.Sunday;
|
|
case "Monday":
|
|
return WeekDays.Monday;
|
|
case "Tuesday":
|
|
return WeekDays.Thursday;
|
|
case "Wednesday":
|
|
return WeekDays.Wednesday;
|
|
case "Thursday":
|
|
return WeekDays.Thursday;
|
|
case "Friday":
|
|
return WeekDays.Friday;
|
|
case "Saturday":
|
|
return WeekDays.Saturday;
|
|
default:
|
|
return WeekDays.Sunday;
|
|
}
|
|
}
|
|
|
|
public List<ResourceAppointmentDC> GetAllResourceAppointments()
|
|
{
|
|
try
|
|
{
|
|
var lResources = DAOFactory.GenericDAO.GetAll<ResourceAppointment>();
|
|
return MapperFactory.ResourceAppointmentDC_ResourceAppointment.MapToNewDCs(lResources);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SchedulerAppointmentDC> GetAllSchedulerAppointments()
|
|
{
|
|
try
|
|
{
|
|
var lSchedulerAppointments = DAOFactory.GenericDAO.GetAll<SchedulerAppointment>();
|
|
return MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(lSchedulerAppointments);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SchedulerAppointmentDC> GetAllActiveSchedulerAppointments()
|
|
{
|
|
try
|
|
{
|
|
var lSchedulerAppointments = DAOFactory.GenericDAO.GetAllActive<SchedulerAppointment>();
|
|
return MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(lSchedulerAppointments);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public void DeleteSchedulerAppointments(Dictionary<long, long> pOid2Version)
|
|
{
|
|
try
|
|
{
|
|
var lOriginals = DAOFactory.GenericDAO.LoadByIDs<SchedulerAppointment>(pOid2Version.Select(n => n.Key));
|
|
lOriginals.DoForEach(on => MapperFactory.SchedulerAppointmentDCSchedulerAppointment.ConcurrencyCheck(pOid2Version[on.Oid.Value], on));
|
|
|
|
DAOFactory.GenericDAO.Delete(lOriginals);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SchedulerAppointmentDC> InsertSchedulerAppointments(IList<SchedulerAppointmentDC> pSchedulerAppointments)
|
|
{
|
|
try
|
|
{
|
|
foreach(var item in pSchedulerAppointments)
|
|
{
|
|
try
|
|
{
|
|
item.EmployeeList.ForEach(each =>
|
|
{
|
|
each.Employee2SchedulerAppointmentOid = null;
|
|
each.Employee2SchedulerAppointmentVersion = null;
|
|
each.SchedulerAppointmentOid = null;
|
|
each.IsPChanged = false;
|
|
each.IsPC_CheckedTs = null;
|
|
});
|
|
|
|
var lRelations = MapperFactory.Employee2SchedulerAppointmentDC_Employee2SchedulerAppointment.MapToNewEntities(item.EmployeeList);
|
|
DAOFactory.GenericDAO.Insert(lRelations);
|
|
var neu = MapperFactory.Employee2SchedulerAppointmentDC_Employee2SchedulerAppointment.MapToNewDCs(lRelations);
|
|
item.EmployeeList = neu;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(exception);
|
|
}
|
|
}
|
|
|
|
var lAppointments = MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewEntities(pSchedulerAppointments);
|
|
|
|
DAOFactory.GenericDAO.Insert(lAppointments);
|
|
return MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(lAppointments);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SchedulerAppointmentDC> UpdateSchedulerAppointments(List<SchedulerAppointmentDC> pSchedulerAppointments)
|
|
{
|
|
try
|
|
{
|
|
if (pSchedulerAppointments.Any(p => p.SchedulerAppointmentOid == null))
|
|
{
|
|
return new List<SchedulerAppointmentDC>();
|
|
}
|
|
|
|
var lOriginals = DAOFactory.GenericDAO.LoadByIDs<SchedulerAppointment>(pSchedulerAppointments.Select(b => b.SchedulerAppointmentOid.Value));
|
|
var allegleich = true;
|
|
|
|
var test = pSchedulerAppointments.Where(w => w.SchedulerAppointmentOid.HasValue && lOriginals.Any(a => a.Oid.HasValue &&
|
|
a.Oid.Value == w.SchedulerAppointmentOid.Value && a.RecurrenceInfo != null &&
|
|
w.RecurrenceInfo == null))
|
|
.ToList();
|
|
|
|
if(test.Count > 0)
|
|
{
|
|
var originalAppointments = lOriginals.Where(w => w.Oid.HasValue && test.Select(s => s.SchedulerAppointmentOid.Value).Contains(w.Oid.Value)).ToList();
|
|
|
|
foreach(var modifiedException in test)
|
|
{
|
|
var original = originalAppointments.FirstOrDefault(f => f.Oid.Value == modifiedException.SchedulerAppointmentOid.Value);
|
|
|
|
if(original == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(modifiedException.Type != 4)
|
|
{
|
|
modifiedException.Type = original.Type;
|
|
}
|
|
|
|
modifiedException.RecurrenceInfo = original.RecurrenceInfo;
|
|
}
|
|
}
|
|
|
|
// Die geänderten Anwesenheiten updaten und die entfernten löschen
|
|
foreach (var item in pSchedulerAppointments)
|
|
{
|
|
allegleich = false;
|
|
var lNewRelations = MapperFactory.Employee2SchedulerAppointmentDC_Employee2SchedulerAppointment.MapToNewEntities(item.EmployeeList.Where(e2a => e2a.Employee2SchedulerAppointmentOid == null));
|
|
var lOldRelations = MapperFactory.Employee2SchedulerAppointmentDC_Employee2SchedulerAppointment.MapToNewDCs(DAOFactory.GenericDAO.LoadByIDs<Employee2SchedulerAppointment>(item.EmployeeList.Where(w => w.Employee2SchedulerAppointmentOid != null).ToList().Select(s => s.Employee2SchedulerAppointmentOid.Value)));
|
|
|
|
var geaenderte = new List<Employee2SchedulerAppointmentDC>();
|
|
foreach (var i in lOldRelations)
|
|
{
|
|
geaenderte.AddRange(item.EmployeeList.Where(o => o.Employee2SchedulerAppointmentOid == i.Employee2SchedulerAppointmentOid &&
|
|
(o.Employee2SchedulerAppointmentVersion != i.Employee2SchedulerAppointmentVersion || o.ParticipationAnswer != i.ParticipationAnswer || o.IsPChanged != i.IsPChanged) &&
|
|
!geaenderte.Contains(o)));
|
|
}
|
|
|
|
geaenderte = UpdateEmployee2SchedulerAppointments(geaenderte);
|
|
|
|
var geloeschte = DAOFactory.SearchDAO.GetRemovedEmp2AppObjectsBySchAppOid(item.SchedulerAppointmentOid.Value).Where(g => !item.EmployeeList.Select(s => s.Employee2SchedulerAppointmentOid).Contains(g.Oid));
|
|
DAOFactory.GenericDAO.Delete(geloeschte);
|
|
|
|
DAOFactory.GenericDAO.Insert(lNewRelations);
|
|
var neu = MapperFactory.Employee2SchedulerAppointmentDC_Employee2SchedulerAppointment.MapToNewDCs(lNewRelations);
|
|
var alt = item.EmployeeList.Where(e2a => e2a.Employee2SchedulerAppointmentOid != null && !geaenderte.Contains(e2a)).ToList();
|
|
alt.AddRange(neu);
|
|
alt.AddRange(geaenderte);
|
|
item.EmployeeList = alt;
|
|
}
|
|
|
|
if (allegleich)
|
|
{
|
|
return pSchedulerAppointments;
|
|
}
|
|
|
|
MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MergeWithEntitys(pSchedulerAppointments, lOriginals);
|
|
DAOFactory.GenericDAO.Update(lOriginals);
|
|
return MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(lOriginals);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<ResourceAppointmentDC> GetResourceAppointmentsById(IEnumerable<long> pOids)
|
|
{
|
|
try
|
|
{
|
|
var lAppointments = DAOFactory.GenericDAO.LoadByIDs<ResourceAppointment>(pOids);
|
|
return MapperFactory.ResourceAppointmentDC_ResourceAppointment.MapToNewDCs(lAppointments);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<ResourceAppointmentDC> LoadPossibleDuplicates(string pRecurrenceInfo)
|
|
{
|
|
try
|
|
{
|
|
var possibleDuplicates = DAOFactory.SearchDAO.GetResourceAppointmentExceptionsWithIndexAndId(pRecurrenceInfo);
|
|
return MapperFactory.ResourceAppointmentDC_ResourceAppointment.MapToNewDCs(possibleDuplicates);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SchedulerAppointmentDC> GetSchedulerAppointmentsById(IEnumerable<long> pOids)
|
|
{
|
|
try
|
|
{
|
|
var lSchedulerAppointments = DAOFactory.GenericDAO.LoadByIDs<SchedulerAppointment>(pOids);
|
|
return MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(lSchedulerAppointments);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public SchedulerAppointmentDC GetSchedulerAppointmentByid(long oid)
|
|
{
|
|
try
|
|
{
|
|
var lSchedulerAppointments = DAOFactory.GenericDAO.GetByID<SchedulerAppointment>(oid);
|
|
return MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDC(lSchedulerAppointments);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public void DeactivateSchedulerAppointments(Dictionary<long, long> pOid2Version)
|
|
{
|
|
try
|
|
{
|
|
foreach (var kvp in pOid2Version)
|
|
{
|
|
ServiceLogic.SetActivationType<SchedulerAppointment>(new Dictionary<long, long> { { kvp.Key, kvp.Value } }, ActivationTypeId.Deleted);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SchedulerAppointmentDC> DeactivateSchedulerAppointmentsForSync(Dictionary<long, long> pOid2Version)
|
|
{
|
|
try
|
|
{
|
|
/*
|
|
* Type:
|
|
* 0: Normal
|
|
* 1: Pattern
|
|
* 2: Occurence
|
|
* 3: ChangedOccurence
|
|
* 4: DeletedOccurence
|
|
*/
|
|
|
|
var lOriginals = DAOFactory.GenericDAO.LoadByIDs<SchedulerAppointment>(pOid2Version.Keys);
|
|
|
|
if(lOriginals.Count > 0 && lOriginals.Any(a => a.Type == 3 && a.Oid.HasValue && pOid2Version.Keys.Contains(a.Oid.Value)))
|
|
{
|
|
// Bearbeitete Serientermine werden auf "gelöscht" gesetzt
|
|
var originalsToUpdate = lOriginals.Where(w => w.Type == 3 && w.Oid.HasValue && pOid2Version.Keys.Contains(w.Oid.Value)).ToList();
|
|
foreach(var original in originalsToUpdate)
|
|
{
|
|
original.Type = 4;
|
|
}
|
|
|
|
DAOFactory.GenericDAO.Update(originalsToUpdate);
|
|
|
|
var updatedAppointments = DAOFactory.GenericDAO.LoadByIDs<SchedulerAppointment>(originalsToUpdate.Select(s => s.Oid.Value));
|
|
|
|
foreach(var appointment in updatedAppointments)
|
|
{
|
|
// Die auf "gelöscht" gesetzten, bearbeiteten Serientermine werden aus dem Dictionary entfernt
|
|
if(appointment.Oid.HasValue && appointment.Version.HasValue && pOid2Version.ContainsKey(appointment.Oid.Value))
|
|
{
|
|
pOid2Version.Remove(appointment.Oid.Value);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Geänderte Serientermine werden anhand der RecurrenceId aus der Datenbank geladen und der Typ auf "gelöscht" gesetzt
|
|
//CB: Nur von Type = 1 also Root prüfen
|
|
foreach (var org in lOriginals)
|
|
{
|
|
if (org.Type == 1)
|
|
{
|
|
List<SchedulerAppointment> appointments = new List<SchedulerAppointment>();
|
|
appointments.Add(org);
|
|
var recurrenceIds = Utils.ExtractRecurrenceIdFromRecurrenceString(appointments);
|
|
|
|
if (recurrenceIds.Count > 0)
|
|
{
|
|
var exceptionsToDelete = DAOFactory.SearchDAO.FindAppointmentsByRecurrenceId(recurrenceIds);
|
|
|
|
exceptionsToDelete.DoForEach(exception =>
|
|
{
|
|
if (exception.Oid != null && exception.Version != null)
|
|
{
|
|
pOid2Version.AddIfNotIn(new KeyValuePair<long, long>(exception.Oid.Value,
|
|
exception.Version.Value));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
foreach (var kvp in pOid2Version)
|
|
{
|
|
ServiceLogic.SetActivationType<SchedulerAppointment>(new Dictionary<long, long> { { kvp.Key, kvp.Value } }, ActivationTypeId.Deleted);
|
|
}
|
|
|
|
return GetSchedulerAppointmentsById(pOid2Version.Keys);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public Dictionary<ValueListEntryDC, List<ResourceDC>> GetAllCategories2ResourcesInDictionary()
|
|
{
|
|
try
|
|
{
|
|
var ressourcen = MapperFactory.ResourceDC_Resource.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<Resource>());
|
|
|
|
return ressourcen.Select(res => res.ResourceCategory)
|
|
.Distinct()
|
|
.OrderBy(cat => cat.TypeDescription)
|
|
.Select(
|
|
cat =>
|
|
new
|
|
{
|
|
Key = cat,
|
|
Value = ressourcen.Where(res => res.ResourceCategory.Equals(cat)).OrderBy(res => res.Name).ToList()
|
|
}).ToDictionary(a => a.Key, a => a.Value);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SchedulerAppointmentDC> GetAllOpenAppointmentsForEmployee(long pEmployeeOid)
|
|
{
|
|
try
|
|
{
|
|
var offeneTermine = DAOFactory.SearchDAO.GetAllOpenAppointmentsForEmployee(pEmployeeOid);
|
|
offeneTermine.AddRange(DAOFactory.SearchDAO.GetAllParticipationNotificationsForEmployee(pEmployeeOid));
|
|
|
|
return MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(offeneTermine);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<Employee2SchedulerAppointmentDC> InsertEmployee2SchedulerAppointments(IEnumerable<Employee2SchedulerAppointmentDC> pEmployee2SchedulerAppointments)
|
|
{
|
|
try
|
|
{
|
|
var lRelations = MapperFactory.Employee2SchedulerAppointmentDC_Employee2SchedulerAppointment.MapToNewEntities(pEmployee2SchedulerAppointments);
|
|
|
|
DAOFactory.GenericDAO.Insert(lRelations);
|
|
return MapperFactory.Employee2SchedulerAppointmentDC_Employee2SchedulerAppointment.MapToNewDCs(lRelations);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<Employee2SchedulerAppointmentDC> UpdateEmployee2SchedulerAppointments(List<Employee2SchedulerAppointmentDC> pEmployee2SchedulerAppointments)
|
|
{
|
|
try
|
|
{
|
|
|
|
var lOriginals = DAOFactory.GenericDAO.LoadByIDs<Employee2SchedulerAppointment>(pEmployee2SchedulerAppointments.Select(b => b.Employee2SchedulerAppointmentOid.Value));
|
|
|
|
foreach (var item in pEmployee2SchedulerAppointments)
|
|
item.IsPChanged = item.ParticipationAnswer != lOriginals.Find(f => f.Oid == item.Employee2SchedulerAppointmentOid).ParticipationAnswer;
|
|
|
|
MapperFactory.Employee2SchedulerAppointmentDC_Employee2SchedulerAppointment.MergeWithEntitys(pEmployee2SchedulerAppointments, lOriginals);
|
|
DAOFactory.GenericDAO.Update(lOriginals);
|
|
return MapperFactory.Employee2SchedulerAppointmentDC_Employee2SchedulerAppointment.MapToNewDCs(lOriginals);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public void DeleteEmployee2SchedulerAppointments(Dictionary<long, long> pOid2Version)
|
|
{
|
|
try
|
|
{
|
|
var lOriginals = DAOFactory.GenericDAO.LoadByIDs<Employee2SchedulerAppointment>(pOid2Version.Select(e => e.Key));
|
|
lOriginals.DoForEach(or => MapperFactory.Employee2SchedulerAppointmentDC_Employee2SchedulerAppointment.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));
|
|
|
|
DAOFactory.GenericDAO.Delete(lOriginals);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SchedulerAppointmentDC> GetAllActiveAndNotDeclinedForEmployeeAppointments(long pEmployeeOid)
|
|
{
|
|
try
|
|
{
|
|
var blubb = DAOFactory.SearchDAO.GetAllActiveAndNotDeclinedForEmployeeAppointments(pEmployeeOid);
|
|
return MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(blubb);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public bool OverlappingAppointmentsExist(DateTime start, DateTime end, List<long> employees, List<long> customers, List<long> resources, long originator, long? appointmentOid, string recurrenceId = "", int ocurrenceIndex = 0)
|
|
{
|
|
try
|
|
{
|
|
return DAOFactory.SearchDAO.OverlappingAppointmentsExist(start, end, employees, customers, resources, originator, appointmentOid, recurrenceId, ocurrenceIndex);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SchedulerAppointmentDC> GetAllActiveAppointmentsForEmployeeInInterval(DateTime start, DateTime end, long pEmployeeOid)
|
|
{
|
|
return GetAllActiveAppointmentsForEmployeeInInterval2(start, end, pEmployeeOid, false);
|
|
}
|
|
|
|
// TODO: veraltet
|
|
public List<SchedulerAppointmentDC> GetAllActiveAppointmentsForEmployeeInInterval2(DateTime pStart, DateTime pEnd, long pEmployeeOid, bool pHasRightToSeeAllEmployeeAppointments)
|
|
{
|
|
try
|
|
{
|
|
var apps = pHasRightToSeeAllEmployeeAppointments ?
|
|
DAOFactory.SearchDAO.GetAllActiveAppointmentsInInterval(pStart, pEnd) :
|
|
DAOFactory.SearchDAO.GetAllActiveAppointmentsForEmployeeInInterval(pStart, pEnd, pEmployeeOid);
|
|
|
|
return MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(apps).OrderBy(a => a.StartDate).ToList();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<AbsenceTimeDC> GetAllActiveAbsenceTimesInInterval(DateTime pStart, DateTime pEnd, long pEmployeeOid, bool pHasRightToSeeAllEmployeeAppointments)
|
|
{
|
|
try
|
|
{
|
|
var absenceTimes = DAOFactory.SearchDAO.GetAllAbsenceTimesInIntervalByEmployee(pStart, pEnd, pEmployeeOid, pHasRightToSeeAllEmployeeAppointments);
|
|
var dcList = MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDCs(absenceTimes);
|
|
foreach (var at in dcList)
|
|
{
|
|
if (at.End.HasValue)
|
|
{
|
|
at.End = at.End.Value.Date.AddDays(1).AddTicks(-1);
|
|
}
|
|
}
|
|
return dcList.OrderBy(a => a.Start).ToList();
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SchedulerAppointmentDC> LoadFilteredAppointments(bool pHasRightToSeeAllEmployeeAppointments, long pEmployeeOid, DateTime pIntervalStart, DateTime pIntervalEnd, List<long> pSelectedEmployees, List<long> pSelectedCustomer, List<long> pSelectedResources, bool pEmployeesOnly, bool pCustomersOnly, bool pResourcesOnly, bool pPrivateAppointmentsOnly, bool pOnlyMyAppointments)
|
|
{
|
|
try
|
|
{
|
|
long? ownerOid = null;
|
|
|
|
//Keine Auswahl getroffen: Nur meine Termine anzeigen
|
|
if ((pSelectedEmployees == null || pSelectedEmployees.Count == 0) && (pSelectedCustomer == null || pSelectedCustomer.Count == 0) && (pSelectedResources == null || pSelectedResources.Count == 0))
|
|
{
|
|
ownerOid = pEmployeeOid;
|
|
}
|
|
//Benutzer hat sich selber selektiert
|
|
if (pSelectedEmployees != null && pSelectedEmployees.Exists(e => e == pEmployeeOid))
|
|
{
|
|
ownerOid = pEmployeeOid;
|
|
}
|
|
//Man hat nur Customer und/oder Resourcen ausgewählt, dann dürfen die eigenen nicht angezeigt werden
|
|
if ((pSelectedEmployees == null || pSelectedEmployees.Count == 0) &&
|
|
(pSelectedCustomer != null && pSelectedCustomer.Count > 0 ||
|
|
pSelectedResources != null && pSelectedResources.Count > 0))
|
|
{
|
|
ownerOid = null;
|
|
}
|
|
//Wenn man kein Recht hat alle zu sehen, muss immer auf Owner gefiltert werden
|
|
if (!pHasRightToSeeAllEmployeeAppointments)
|
|
{
|
|
ownerOid = pEmployeeOid;
|
|
}
|
|
|
|
if(!(!pHasRightToSeeAllEmployeeAppointments && pSelectedEmployees != null && pSelectedEmployees.Count == 1 && pSelectedEmployees.Contains(pEmployeeOid)))
|
|
{
|
|
//Rausnehmen, sonst werden Termine nicht gezeigt, bei denen man Owner ist und kein Employee ausgewählt wurde.
|
|
//Wird nicht rausgenommen, wenn man die Termine anderer Mitarbeiter nicht sehen darf und "nur meine Termine" ausgewählt hat.
|
|
//Sonst werden die Filter mit and und nicht mit or verknüpft.
|
|
pSelectedEmployees?.Remove(pEmployeeOid);
|
|
}
|
|
|
|
if(pPrivateAppointmentsOnly && (pSelectedEmployees == null || pSelectedEmployees.Count == 0) && (pSelectedCustomer == null || pSelectedCustomer.Count == 0) && (pSelectedResources == null || pSelectedResources.Count == 0) && !(pSelectedEmployees == null || pSelectedEmployees.Count == 0) &&
|
|
(pSelectedCustomer != null && pSelectedCustomer.Count > 0 ||
|
|
pSelectedResources != null && pSelectedResources.Count > 0))
|
|
{
|
|
ownerOid = pEmployeeOid;
|
|
}
|
|
|
|
var appointments = DAOFactory.SearchDAO.LoadFilteredAppointmentsForEmployee(pHasRightToSeeAllEmployeeAppointments, ownerOid, pIntervalStart, pIntervalEnd, pSelectedEmployees, pSelectedCustomer, pSelectedResources, pEmployeesOnly, pCustomersOnly, pResourcesOnly, pPrivateAppointmentsOnly, pOnlyMyAppointments, false).ToList();
|
|
|
|
var all = MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(appointments).OrderBy(a => a.StartDate).ToList();
|
|
|
|
List<long> filteredEmployeeOids = new List<long>();
|
|
if (ownerOid.HasValue)
|
|
{
|
|
filteredEmployeeOids.Add(ownerOid.Value);
|
|
}
|
|
|
|
if (pSelectedEmployees != null)
|
|
{
|
|
foreach (var empOid in pSelectedEmployees)
|
|
{
|
|
filteredEmployeeOids.Add(empOid);
|
|
}
|
|
}
|
|
|
|
List<SchedulerAppointmentDC> result = new List<SchedulerAppointmentDC>();
|
|
|
|
//Filter alle Termine raus, die vom Ersteller für andere MAs erstellt wurden
|
|
foreach (var app in all)
|
|
{
|
|
bool add = true;
|
|
if (app.Originator != null && app.Originator.EmployeeOid == pEmployeeOid)
|
|
{
|
|
if (app.EmployeeList != null && app.EmployeeList.Count > 0)
|
|
{
|
|
add = false;
|
|
foreach (var emp in app.EmployeeList)
|
|
{
|
|
if (filteredEmployeeOids.Contains(emp.Employee.EmployeeOid))
|
|
{
|
|
add = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//Prüfe Klienten Filter
|
|
if (!add)
|
|
{
|
|
if (app.CustomerList != null && app.CustomerList.Count > 0)
|
|
{
|
|
if (pCustomersOnly)
|
|
{
|
|
add = true;
|
|
}
|
|
else if (pSelectedCustomer != null && pSelectedCustomer.Count > 0)
|
|
{
|
|
foreach (var cust in app.CustomerList)
|
|
{
|
|
if (pSelectedCustomer.Contains(cust.CustomerOid))
|
|
{
|
|
add = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
//Prüfe Resourcen Filter
|
|
if (!add)
|
|
{
|
|
if (app.ResourceList != null && app.ResourceList.Count > 0)
|
|
{
|
|
if (pResourcesOnly)
|
|
{
|
|
add = true;
|
|
}
|
|
else if (pSelectedResources != null && pSelectedResources.Count > 0)
|
|
{
|
|
foreach (var res in app.ResourceList)
|
|
{
|
|
if (pSelectedResources.Contains(res.ResourceOid.Value))
|
|
{
|
|
add = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
if (add)
|
|
{
|
|
result.Add(app);
|
|
}
|
|
}
|
|
|
|
//Check fehlerhaftes RecurrenceInfos
|
|
foreach (var app in result)
|
|
{
|
|
if (!String.IsNullOrEmpty(app.RecurrenceInfo))
|
|
{
|
|
if (app.RecurrenceInfo.Contains("WeekDays=\"0\""))
|
|
{
|
|
app.RecurrenceInfo = app.RecurrenceInfo.Replace("WeekDays=\"0\"", "WeekDays=\"2\"");
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
////var appointments = DAOFactory.GenericDAO.GetAll<SchedulerAppointment>();
|
|
//var test = MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(appointments).OrderBy(a => a.StartDate).ToList();
|
|
|
|
//foreach (var dc in test)
|
|
//{
|
|
// if (dc.Type == 3)
|
|
// {
|
|
// dc.RecurrenceInfo = null;
|
|
// dc.Type = 0;
|
|
// }
|
|
//}
|
|
//return test;
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
}
|
|
} |