659ec6b3eb
Die Abfrage nach der Ressourcenbelegung kommt nur ein mal und das Abbrechen des Speicherns hat keinen "kaputten" Reload zur Folge
Das Löschen eines Serientermins mit veränderten oder gelöschten Elementen führt zu keiner Exception mehr, da ich den Service-Aufruf auf synchron geändert habe.
Es gibt allerdings noch Bugs! -> Serientermin erstellen und ein Element davon ändern führt zu einer doppelten Abfrage, ausgelöst durch die Überlappungsprüfung, die eine Überlappung mit der Serie selbst feststellt!
2260 lines
105 KiB
C#
2260 lines
105 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;
|
|
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.Core;
|
|
using BS.Shared.DataContracts;
|
|
using BS.Shared.DataContracts.Compact;
|
|
using BS.Shared.Extensions;
|
|
using DevExpress.XtraScheduler;
|
|
using static System.String;
|
|
using Resource = BeWo.Data.Entities.Resource;
|
|
using Utils = BeWo.Service.Core.Utils;
|
|
using SUtils = BS.Shared.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 lOriginals = DAOFactory.GenericDAO.GetAllActive<Resource>();
|
|
|
|
lOriginals = lOriginals.Where(resource =>
|
|
{
|
|
return resource.ValueList.All(valueListEntry2Object => valueListEntry2Object.Entry.IsActive.Equals(ActivationTypeId.Active));
|
|
}).ToList();
|
|
|
|
var ressourcen = MapperFactory.ResourceDC_Resource.MapToNewDCs(lOriginals);
|
|
|
|
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> LoadFilteredAppointmentsMitAufgaben(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, bool pShowTasks)
|
|
{
|
|
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 Ressourcen 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 serientermine = appointments.Where(app => app.RecurrenceInfo != null && app.Type == 1).ToList();
|
|
|
|
var all = MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(appointments).OrderBy(a => a.StartDate).ToList();
|
|
|
|
var filteredEmployeeOids = new List<long>();
|
|
if(ownerOid.HasValue)
|
|
{
|
|
filteredEmployeeOids.Add(ownerOid.Value);
|
|
}
|
|
|
|
if(pSelectedEmployees != null)
|
|
{
|
|
foreach(var empOid in pSelectedEmployees)
|
|
{
|
|
filteredEmployeeOids.Add(empOid);
|
|
}
|
|
}
|
|
|
|
var result = FilterAppointments(all, pEmployeeOid, filteredEmployeeOids, pSelectedCustomer, pSelectedResources, pCustomersOnly, pResourcesOnly, pShowTasks);
|
|
|
|
//Check fehlerhaftes RecurrenceInfos
|
|
foreach(var app in result)
|
|
{
|
|
if(!IsNullOrEmpty(app.RecurrenceInfo))
|
|
{
|
|
if(app.RecurrenceInfo.Contains("WeekDays=\"0\""))
|
|
{
|
|
app.RecurrenceInfo = app.RecurrenceInfo.Replace("WeekDays=\"0\"", "WeekDays=\"2\"");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Ausnahmen immer laden. Entsprechen die Ausnahmen nicht den Filterkriterien, werden sie als gelöscht markiert, um nicht auf dem Client angezeigt zu werden.
|
|
var ausnahmen = MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(DAOFactory.SearchDAO.FindAppointmentsByRecurrenecInfo(result.Where(w => w.Type == 1).Select(s => s.RecurrenceInfo).ToList(), true));
|
|
var demFilterEntsprechendeTermine = FilterAppointments(ausnahmen, pEmployeeOid, filteredEmployeeOids, pSelectedCustomer, pSelectedResources, pCustomersOnly, pResourcesOnly, pShowTasks);
|
|
|
|
foreach(var appointment in ausnahmen.Where(w => !demFilterEntsprechendeTermine.Contains(w)))
|
|
{
|
|
var kosmetisch = new SchedulerAppointmentDC
|
|
{
|
|
SchedulerAppointmentOid = appointment.SchedulerAppointmentOid * -1,
|
|
NewSchedulerAppointmentVersion = 1,
|
|
Type = 4,
|
|
RecurrenceInfo = appointment.RecurrenceInfo,
|
|
EmployeeList = appointment.EmployeeList,
|
|
CustomerList = appointment.CustomerList,
|
|
ResourceList = appointment.ResourceList,
|
|
Originator = appointment.Originator
|
|
};
|
|
|
|
result.Add(kosmetisch);
|
|
}
|
|
|
|
UserDC user;
|
|
if(LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
|
|
{
|
|
user = MapperFactory.UserDC_User.MapToNewDC(LoggedInUserOperationContextExt.Current.User);
|
|
}
|
|
else
|
|
{
|
|
user = MapperFactory.UserDC_User.MapToNewDC(SessionFacade.LoggedInUser);
|
|
}
|
|
|
|
if(user != null)
|
|
{
|
|
result = result.Where(w => BS.Shared.Core.Utils.CheckSchedulerRights(w, SchedulerRightsCheckType.View, user)).ToList();
|
|
}
|
|
|
|
// Aufgaben laden
|
|
var oldTasks = DAOFactory.SearchDAO.LoadTasksForConversion(pEmployeeOid);
|
|
var taskAppointments = new List<SchedulerAppointment>();
|
|
|
|
foreach(var task in oldTasks)
|
|
{
|
|
var taskAsAppointment = new SchedulerAppointment
|
|
{
|
|
SupportConceptList = new List<SupportConcept> { task.SupportConcept },
|
|
EmployeeList = new List<Employee2SchedulerAppointment>(),
|
|
FormerTaskOid = task.Oid,
|
|
Subject = task.Title,
|
|
CompletedNotice = task.CompletedNotice,
|
|
TaskDescription = task.Description,
|
|
IsActive = task.IsActive,
|
|
IsTask = true,
|
|
DueDate = task.DueDate,
|
|
StartDate = task.CompletedDate.HasValue ? task.DueDate?.GetShortDateTime() : task.InsTs?.GetShortDateTime(),
|
|
EndDate = task.DueDate?.GetShortDateTime().AddDays(1) ?? DateTime.MaxValue.Date
|
|
};
|
|
|
|
foreach(var employee in task.EmployeeList)
|
|
{
|
|
var rel = new Employee2SchedulerAppointment
|
|
{
|
|
Employee = DAOFactory.GenericDAO.LoadByID<Employee>(employee.Oid.Value),
|
|
ParticipationAnswer = ParticipationAnswer.Offen
|
|
};
|
|
|
|
taskAsAppointment.EmployeeList.AddIfNotIn(rel);
|
|
}
|
|
|
|
taskAppointments.Add(taskAsAppointment);
|
|
}
|
|
|
|
InsertSchedulerAppointments(MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(taskAppointments));
|
|
|
|
var taskAppointmentDCs = MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(DAOFactory.SearchDAO.LoadTaskAppointmentsForEmployee(pEmployeeOid));
|
|
|
|
result.AddRangeIfElementsNotIn(taskAppointmentDCs);
|
|
|
|
return result;
|
|
}
|
|
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 Ressourcen 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();
|
|
|
|
var filteredEmployeeOids = new List<long>();
|
|
if (ownerOid.HasValue)
|
|
{
|
|
filteredEmployeeOids.Add(ownerOid.Value);
|
|
}
|
|
|
|
if (pSelectedEmployees != null)
|
|
{
|
|
foreach (var empOid in pSelectedEmployees)
|
|
{
|
|
filteredEmployeeOids.Add(empOid);
|
|
}
|
|
}
|
|
|
|
var result = FilterAppointments(all, pEmployeeOid, filteredEmployeeOids, pSelectedCustomer, pSelectedResources, pCustomersOnly, pResourcesOnly);
|
|
|
|
//Check fehlerhafte RecurrenceInfos
|
|
foreach (var app in result)
|
|
{
|
|
if (!IsNullOrEmpty(app.RecurrenceInfo))
|
|
{
|
|
if (app.RecurrenceInfo.Contains("WeekDays=\"0\""))
|
|
{
|
|
app.RecurrenceInfo = app.RecurrenceInfo.Replace("WeekDays=\"0\"", "WeekDays=\"2\"");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Ausnahmen immer laden. Entsprechen die Ausnahmen nicht den Filterkriterien, werden sie als gelöscht markiert, um nicht auf dem Client angezeigt zu werden.
|
|
var ausnahmen = MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(DAOFactory.SearchDAO.FindAppointmentsByRecurrenecInfo(result.Where(w => w.Type == 1).Select(s => s.RecurrenceInfo).ToList(), true));
|
|
var demFilterEntsprechendeTermine = FilterAppointments(ausnahmen, pEmployeeOid, filteredEmployeeOids, pSelectedCustomer, pSelectedResources, pCustomersOnly, pResourcesOnly);
|
|
|
|
foreach(var appointment in ausnahmen.Where(w => !demFilterEntsprechendeTermine.Contains(w)))
|
|
{
|
|
var kosmetisch = new SchedulerAppointmentDC
|
|
{
|
|
SchedulerAppointmentOid = appointment.SchedulerAppointmentOid * -1,
|
|
NewSchedulerAppointmentVersion = 1,
|
|
Type = 4,
|
|
RecurrenceInfo = appointment.RecurrenceInfo,
|
|
EmployeeList = appointment.EmployeeList,
|
|
CustomerList = appointment.CustomerList,
|
|
ResourceList = appointment.ResourceList,
|
|
Originator = appointment.Originator
|
|
};
|
|
|
|
result.Add(kosmetisch);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
private static List<SchedulerAppointmentDC> FilterAppointments(IEnumerable<SchedulerAppointmentDC> pAppointments, long pEmployeeOid, ICollection<long> pFilteredEmployeeOids, ICollection<long> pSelectedCustomers, ICollection<long> pSelectedResources, bool pCustomersOnly, bool pResourcesOnly, bool pShowTasks = false)
|
|
{
|
|
var result = new List<SchedulerAppointmentDC>();
|
|
|
|
foreach(var app in pAppointments)
|
|
{
|
|
var 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(pFilteredEmployeeOids.Contains(emp.Employee.EmployeeOid))
|
|
{
|
|
add = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Prüfe Klientenfilter
|
|
if(!add)
|
|
{
|
|
if(app.CustomerList != null && app.CustomerList.Count > 0)
|
|
{
|
|
if(pCustomersOnly)
|
|
{
|
|
add = true;
|
|
}
|
|
else if(pSelectedCustomers != null && pSelectedCustomers.Count > 0)
|
|
{
|
|
foreach(var cust in app.CustomerList)
|
|
{
|
|
if(pSelectedCustomers.Contains(cust.CustomerOid))
|
|
{
|
|
add = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Prüfe Ressourcenfilter
|
|
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 (app.IsTask && !pShowTasks)
|
|
{
|
|
add = false;
|
|
}
|
|
|
|
if(add)
|
|
{
|
|
result.Add(app);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public List<SchedulerAppointmentDC> GetAllTasksForEmployee(long pEmployeeOid)
|
|
{
|
|
try
|
|
{
|
|
var oldTasks = DAOFactory.SearchDAO.LoadTasksForConversion(pEmployeeOid);
|
|
var taskAppointments = new List<SchedulerAppointment>();
|
|
|
|
foreach(var task in oldTasks)
|
|
{
|
|
var taskAsAppointment = new SchedulerAppointment
|
|
{
|
|
SupportConceptList = new List<SupportConcept> {task.SupportConcept},
|
|
EmployeeList = new List<Employee2SchedulerAppointment>(),
|
|
FormerTaskOid = task.Oid,
|
|
Subject = task.Title,
|
|
CompletedNotice = task.CompletedNotice,
|
|
TaskDescription = task.Description,
|
|
IsActive = task.IsActive,
|
|
IsTask = true,
|
|
DueDate = task.DueDate,
|
|
StartDate = task.CompletedDate.HasValue ? task.DueDate?.GetShortDateTime() : task.InsTs?.GetShortDateTime(),
|
|
EndDate = task.DueDate?.GetShortDateTime().AddDays(1) ?? DateTime.MaxValue.Date
|
|
};
|
|
|
|
foreach(var employee in task.EmployeeList)
|
|
{
|
|
var rel = new Employee2SchedulerAppointment
|
|
{
|
|
Employee = DAOFactory.GenericDAO.LoadByID<Employee>(employee.Oid.Value),
|
|
ParticipationAnswer = ParticipationAnswer.Offen
|
|
};
|
|
|
|
taskAsAppointment.EmployeeList.AddIfNotIn(rel);
|
|
}
|
|
|
|
taskAppointments.Add(taskAsAppointment);
|
|
}
|
|
|
|
InsertSchedulerAppointments(MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(taskAppointments));
|
|
|
|
var taskAppointmentDCs = DAOFactory.SearchDAO.LoadTaskAppointmentsForEmployee(pEmployeeOid);
|
|
|
|
var monday = DateTime.Today.FirstDateOfWeek(DateTime.Today.GetIso8601WeekOfYear());
|
|
|
|
var appointments = DAOFactory.SearchDAO.LoadFilteredAppointmentsForEmployee(false, pEmployeeOid, monday, monday.AddDays(14), new List<long>(), new List<long>(), new List<long>(), false, false, false, false, true, false);
|
|
|
|
taskAppointmentDCs.AddRangeIfElementsNotIn(appointments);
|
|
|
|
return MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(taskAppointmentDCs);
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SchedulerAppointmentDC> GetSchedulerAppointmentTasksForEmployeeBySupportConecpt(long pEmployeeOid, long pSupportConceptOid)
|
|
{
|
|
try
|
|
{
|
|
var taskAppointments = DAOFactory.SearchDAO.GetTasksForEmployeeBySupportConcept(pEmployeeOid, pSupportConceptOid);
|
|
|
|
var dataContracts = MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(taskAppointments);
|
|
|
|
return dataContracts;
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SchedulerAppointmentDC> LoadTasksAndAppointmentsForEmployee(long pEmployeeOid, DateTime pInvertalStart, int pBufferSize, long? pEmployeeAppointmentsOid)
|
|
{
|
|
try
|
|
{
|
|
var oldTasks = DAOFactory.SearchDAO.LoadTasksForConversion(pEmployeeOid);
|
|
var taskAppointments = new List<SchedulerAppointment>();
|
|
|
|
foreach (var task in oldTasks)
|
|
{
|
|
var taskAsAppointment = new SchedulerAppointment
|
|
{
|
|
SupportConceptList = new List<SupportConcept> { task.SupportConcept },
|
|
EmployeeList = new List<Employee2SchedulerAppointment>(),
|
|
FormerTaskOid = task.Oid,
|
|
Subject = task.Title,
|
|
CompletedNotice = task.CompletedNotice,
|
|
TaskDescription = task.Description,
|
|
IsActive = task.IsActive,
|
|
IsTask = true,
|
|
DueDate = task.DueDate,
|
|
CompletedDate = task.CompletedDate,
|
|
StartDate = task.CompletedDate.HasValue ? task.DueDate?.GetShortDateTime() : task.InsTs?.GetShortDateTime(),
|
|
EndDate = task.DueDate?.GetShortDateTime().AddDays(1) ?? DateTime.MaxValue.Date
|
|
};
|
|
|
|
foreach (var employee in task.EmployeeList)
|
|
{
|
|
var rel = new Employee2SchedulerAppointment
|
|
{
|
|
Employee = DAOFactory.GenericDAO.LoadByID<Employee>(employee.Oid.Value),
|
|
ParticipationAnswer = ParticipationAnswer.Offen
|
|
};
|
|
|
|
taskAsAppointment.EmployeeList.AddIfNotIn(rel);
|
|
}
|
|
|
|
taskAppointments.Add(taskAsAppointment);
|
|
}
|
|
|
|
InsertSchedulerAppointments(MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(taskAppointments));
|
|
|
|
var taskAppointmentDCs = DAOFactory.SearchDAO.LoadTaskAppointmentsForEmployee(pEmployeeOid);
|
|
|
|
var monday = DateTime.Today.FirstDateOfWeek(pInvertalStart.AddDays(-1 * pBufferSize).GetIso8601WeekOfYear());
|
|
|
|
if(!pEmployeeAppointmentsOid.HasValue)
|
|
{
|
|
pEmployeeAppointmentsOid = pEmployeeOid;
|
|
}
|
|
|
|
var appointments = DAOFactory.SearchDAO.LoadFilteredAppointmentsForEmployee(false, pEmployeeAppointmentsOid.Value, monday, monday.AddDays(3 * pBufferSize), new List<long>(), new List<long>(), new List<long>(), false, false, false, false, true, false).ToList();
|
|
|
|
|
|
UserDC user;
|
|
if (LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
|
|
{
|
|
user = MapperFactory.UserDC_User.MapToNewDC(LoggedInUserOperationContextExt.Current.User);
|
|
}
|
|
else
|
|
{
|
|
user = MapperFactory.UserDC_User.MapToNewDC(SessionFacade.LoggedInUser);
|
|
}
|
|
|
|
var loggedInEmployee = DAOFactory.GenericDAO.LoadByID<Employee>(pEmployeeOid);
|
|
|
|
if(!user.HasRight(UserRightType.KalenderMitarbeitertermineAnsehen))
|
|
{
|
|
var appointments2remove = appointments.Where(appointment => appointment.EmployeeList.Count > 0 && appointment.EmployeeList.Any(a => !a.Employee.Equals(loggedInEmployee))).ToList();
|
|
appointments = appointments.Except(appointments2remove).ToList();
|
|
}
|
|
|
|
// TODO: Testen!
|
|
if(!user.HasRight(UserRightType.KalenderKliententermineAlleAnsehen))
|
|
{
|
|
var ownCustomers = loggedInEmployee.Employee2CustomerList.Select(s => s.Customer).ToList();
|
|
var appointmentsWithOtherCustomers = appointments.Where(w => w.CustomerList.Any(a => !ownCustomers.Contains(a))).ToList();
|
|
|
|
appointments = appointments.Except(appointmentsWithOtherCustomers).ToList();
|
|
}
|
|
|
|
if(!user.HasRight(UserRightType.KalenderRessourcentermineAnsehen))
|
|
{
|
|
var appsToRemove = appointments.Where(appointment => appointment.ResourceList.Any()).ToList();
|
|
appointments = appointments.Except(appsToRemove).ToList();
|
|
}
|
|
|
|
|
|
var nullerIndex = new List<SchedulerAppointment>();
|
|
|
|
var recurringAppointments = appointments.Where(app => app.RecurrenceInfo != null);
|
|
recurringAppointments.DoForEach(app =>
|
|
{
|
|
var index = Utils.ExtractIndexFromRecurrenceInfo(app.RecurrenceInfo);
|
|
|
|
if(index == 0)
|
|
{
|
|
nullerIndex.Add(app);
|
|
}
|
|
});
|
|
|
|
nullerIndex.DoForEach(app =>
|
|
{
|
|
var id = Utils.ExtractIdFromRecurrenceInfo(app.RecurrenceInfo);
|
|
|
|
if(app.Type == (int) AppointmentType.ChangedOccurrence)
|
|
{
|
|
var toRemove = appointments.Find(f => f.RecurrenceInfo != null && f.RecurrenceInfo.Contains(id) && !f.RecurrenceInfo.Contains("Index") && f.Type == (int) AppointmentType.Pattern);
|
|
appointments.Remove(toRemove);
|
|
}
|
|
});
|
|
|
|
taskAppointmentDCs.AddRangeIfElementsNotIn(appointments);
|
|
|
|
return MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDCs(taskAppointmentDCs);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public void InsertTestAppointments(long pEmployeeOid)
|
|
{
|
|
try
|
|
{
|
|
CreateTestAppointmentsForEmployee(pEmployeeOid);
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
private static void CreateTestAppointmentsForEmployee(long pEmployeeOid)
|
|
{
|
|
#if DEBUG
|
|
var employee = DAOFactory.GenericDAO.LoadByID<Employee>(pEmployeeOid);
|
|
var employeesWithoutEmployee = DAOFactory.GenericDAO.GetAllActive<Employee>().Where(emp => !emp.Equals(employee)).ToList();
|
|
var customers = DAOFactory.GenericDAO.GetAllActive<Customer>();
|
|
var ownCustomers = employee.Employee2CustomerList.Select(e2c => e2c.Customer).ToList();
|
|
var resources = DAOFactory.GenericDAO.GetAllActive<Resource>();
|
|
|
|
var secondEmployee = employeesWithoutEmployee.FirstOrDefault() ?? employee;
|
|
var fiveOfSecondEmployeesCustomers = secondEmployee.Employee2CustomerList.Select(e2c => e2c.Customer).TakeWhile((t, j) => j != 5).ToList();
|
|
|
|
var fiveOfMyOwnCustomers = ownCustomers.TakeWhile((t, i) => i != 5).ToList();
|
|
var fiveCustomers = customers.TakeWhile((t, i) => i != 5).ToList();
|
|
var fiveResources = resources.TakeWhile((t, i) => i != 3).ToList();
|
|
|
|
var employeeListIncludingLoggedInEmployee1 = employeesWithoutEmployee.TakeWhile((t, i) => i != 4).Select(t => new Employee2SchedulerAppointment(t)).ToList();
|
|
employeeListIncludingLoggedInEmployee1.Add(new Employee2SchedulerAppointment(employee));
|
|
|
|
var employeeListIncludingLoggedInEmployee2 = employeesWithoutEmployee.TakeWhile((t, i) => i != 4).Select(t => new Employee2SchedulerAppointment(t)).ToList();
|
|
employeeListIncludingLoggedInEmployee2.Add(new Employee2SchedulerAppointment(employee));
|
|
|
|
var employeeListIncludingLoggedInEmployee3 = employeesWithoutEmployee.TakeWhile((t, i) => i != 4).Select(t => new Employee2SchedulerAppointment(t)).ToList();
|
|
employeeListIncludingLoggedInEmployee3.Add(new Employee2SchedulerAppointment(employee));
|
|
|
|
var employeeListIncludingLoggedInEmployee4 = employeesWithoutEmployee.TakeWhile((t, i) => i != 4).Select(t => new Employee2SchedulerAppointment(t)).ToList();
|
|
employeeListIncludingLoggedInEmployee4.Add(new Employee2SchedulerAppointment(employee));
|
|
|
|
var employeeListIncludingLoggedInEmployee5 = employeesWithoutEmployee.TakeWhile((t, i) => i != 4).Select(t => new Employee2SchedulerAppointment(t)).ToList();
|
|
employeeListIncludingLoggedInEmployee5.Add(new Employee2SchedulerAppointment(employee));
|
|
|
|
var employeeListIncludingLoggedInEmployee6 = employeesWithoutEmployee.TakeWhile((t, i) => i != 4).Select(t => new Employee2SchedulerAppointment(t)).ToList();
|
|
employeeListIncludingLoggedInEmployee6.Add(new Employee2SchedulerAppointment(employee));
|
|
|
|
var employeeListIncludingLoggedInEmployee7 = employeesWithoutEmployee.TakeWhile((t, i) => i != 4).Select(t => new Employee2SchedulerAppointment(t)).ToList();
|
|
employeeListIncludingLoggedInEmployee7.Add(new Employee2SchedulerAppointment(employee));
|
|
|
|
var employeeListIncludingLoggedInEmployee8 = employeesWithoutEmployee.TakeWhile((t, i) => i != 4).Select(t => new Employee2SchedulerAppointment(t)).ToList();
|
|
employeeListIncludingLoggedInEmployee8.Add(new Employee2SchedulerAppointment(employee));
|
|
|
|
var monday = DateTime.Today.FirstDateOfWeek(DateTime.Today.GetIso8601WeekOfYear());
|
|
var tuesday = monday.AddDays(1);
|
|
var wednesday = monday.AddDays(2);
|
|
var thursday = monday.AddDays(3);
|
|
var friday = monday.AddDays(4);
|
|
var saturday = monday.AddDays(5);
|
|
var sunday = monday.AddDays(6);
|
|
|
|
//Originator ist angemeldeten Mitarbeiter
|
|
GenerateAppointments(monday, false, employee, fiveCustomers, fiveOfMyOwnCustomers, fiveResources, employeesWithoutEmployee.TakeWhile((t, i) => i != 5).Select(t => new Employee2SchedulerAppointment(t)).ToList(), null);
|
|
|
|
//Termin von anderem Mitarbeiter
|
|
GenerateAppointments(tuesday, false, secondEmployee, fiveCustomers, fiveOfMyOwnCustomers, fiveResources, employeeListIncludingLoggedInEmployee1, null);
|
|
|
|
//Originator ist angemeldeter Mitarbeiter und in Liste
|
|
GenerateAppointments(wednesday, false, employee, fiveCustomers, fiveOfMyOwnCustomers, fiveResources, employeeListIncludingLoggedInEmployee2, null);
|
|
|
|
//Originator ist nicht angemeldeter Mitarbeiter und der ist auch nicht in der Liste
|
|
GenerateAppointments(thursday, false, secondEmployee, fiveCustomers, fiveOfSecondEmployeesCustomers, fiveResources, employeesWithoutEmployee.TakeWhile((t, i) => i != 5).Select(t => new Employee2SchedulerAppointment(t)).ToList(), null);
|
|
|
|
//Private Termine
|
|
GenerateAppointments(friday, true, employee, fiveCustomers, fiveOfMyOwnCustomers, fiveResources, employeesWithoutEmployee.TakeWhile((t, i) => i != 5).Select(t => new Employee2SchedulerAppointment(t)).ToList(), null);
|
|
GenerateAppointments(saturday, true, secondEmployee, fiveCustomers, fiveOfSecondEmployeesCustomers, fiveResources, employeesWithoutEmployee.TakeWhile((t, i) => i != 5).Select(t => new Employee2SchedulerAppointment(t)).ToList(), null);
|
|
GenerateAppointments(sunday, true, secondEmployee, fiveCustomers, fiveOfSecondEmployeesCustomers, fiveResources, employeeListIncludingLoggedInEmployee3, null);
|
|
GenerateAppointments(friday.AddHours(12), true, employee, fiveCustomers, fiveOfMyOwnCustomers, fiveResources, employeeListIncludingLoggedInEmployee4, null);
|
|
|
|
|
|
//AllDay-Termine ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
var mon = monday.AddDays(7);
|
|
var tue = tuesday.AddDays(7);
|
|
var wed = wednesday.AddDays(7);
|
|
var thu = thursday.AddDays(7);
|
|
var fri = friday.AddDays(7);
|
|
var sat = saturday.AddDays(7);
|
|
var sun = sunday.AddDays(7);
|
|
|
|
//Originator ist angemeldeten Mitarbeiter
|
|
GenerateAppointments(mon, false, employee, fiveCustomers, fiveOfMyOwnCustomers, fiveResources, employeesWithoutEmployee.TakeWhile((t, i) => i != 5).Select(t => new Employee2SchedulerAppointment(t)).ToList(), null, true);
|
|
|
|
//Termin von anderem Mitarbeiter
|
|
GenerateAppointments(tue, false, secondEmployee, fiveCustomers, fiveOfMyOwnCustomers, fiveResources, employeeListIncludingLoggedInEmployee5, null, true);
|
|
|
|
//Originator ist angemeldeter Mitarbeiter und in Liste
|
|
GenerateAppointments(wed, false, employee, fiveCustomers, fiveOfMyOwnCustomers, fiveResources, employeeListIncludingLoggedInEmployee6, null, true);
|
|
|
|
//Originator ist nicht angemeldeter Mitarbeiter und der ist auch nicht in der Liste
|
|
GenerateAppointments(thu, false, secondEmployee, fiveCustomers, fiveOfSecondEmployeesCustomers, fiveResources, employeesWithoutEmployee.TakeWhile((t, i) => i != 5).Select(t => new Employee2SchedulerAppointment(t)).ToList(), null, true);
|
|
|
|
|
|
//Private Termine
|
|
GenerateAppointments(fri, true, employee, fiveCustomers, fiveOfMyOwnCustomers, fiveResources, employeesWithoutEmployee.TakeWhile((t, i) => i != 5).Select(t => new Employee2SchedulerAppointment(t)).ToList(), null, true);
|
|
GenerateAppointments(sat, true, secondEmployee, fiveCustomers, fiveOfSecondEmployeesCustomers, fiveResources, employeesWithoutEmployee.TakeWhile((t, i) => i != 5).Select(t => new Employee2SchedulerAppointment(t)).ToList(), null, true);
|
|
GenerateAppointments(sun, true, secondEmployee, fiveCustomers, fiveOfSecondEmployeesCustomers, fiveResources, employeeListIncludingLoggedInEmployee7, null, true);
|
|
GenerateAppointments(fri.AddHours(12), true, employee, fiveCustomers, fiveOfMyOwnCustomers, fiveResources, employeeListIncludingLoggedInEmployee8, null, true);
|
|
// --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
var ttttttt1 = employeeListIncludingLoggedInEmployee1.Select(s => s.Oid).ToList();
|
|
var ttttttt2 = employeeListIncludingLoggedInEmployee2.Select(s => s.Oid).ToList();
|
|
var ttttttt3 = employeeListIncludingLoggedInEmployee3.Select(s => s.Oid).ToList();
|
|
var ttttttt4 = employeeListIncludingLoggedInEmployee4.Select(s => s.Oid).ToList();
|
|
var ttttttt5 = employeeListIncludingLoggedInEmployee5.Select(s => s.Oid).ToList();
|
|
var ttttttt6 = employeeListIncludingLoggedInEmployee6.Select(s => s.Oid).ToList();
|
|
var ttttttt7 = employeeListIncludingLoggedInEmployee7.Select(s => s.Oid).ToList();
|
|
var ttttttt8 = employeeListIncludingLoggedInEmployee8.Select(s => s.Oid).ToList();
|
|
|
|
var mo = mon.AddDays(7);
|
|
var tu = tue.AddDays(7);
|
|
|
|
// Tägliche Termine
|
|
var everyThirdMondayNoEnd = GenerateTestAppointment(false, false, mo.AddHours(9), mo.AddHours(10), AppointmentType.Pattern, "Täglich, alle 3 Tage. Endlos", employee);
|
|
everyThirdMondayNoEnd.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Daily, 0, 0, mo.AddHours(9), null, 1);
|
|
DAOFactory.GenericDAO.Insert(everyThirdMondayNoEnd);
|
|
|
|
var everyWeekdayNoEnd = GenerateTestAppointment(false, false, mo.AddHours(10), mo.AddHours(11), AppointmentType.Pattern, "Wochentäglich. Endlos", employee);
|
|
everyWeekdayNoEnd.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Daily, 0, 1, mo.AddHours(10), null, 1);
|
|
DAOFactory.GenericDAO.Insert(everyWeekdayNoEnd);
|
|
|
|
var everyThirdMondayEndsAfter12Times = GenerateTestAppointment(false, false, mo.AddHours(11), mo.AddHours(12), AppointmentType.Pattern, "Täglich, alle 3 Tage. Endet nach 12 Terminen", employee);
|
|
everyThirdMondayEndsAfter12Times.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Daily, 1, 0, mo.AddHours(11), null, 1);
|
|
DAOFactory.GenericDAO.Insert(everyThirdMondayEndsAfter12Times);
|
|
|
|
var everyWorkdayEndsAfter12Times = GenerateTestAppointment(false, false, mo.AddHours(12), mo.AddHours(13), AppointmentType.Pattern, "Wochentäglich. Endet nach 12 Terminen", employee);
|
|
everyWorkdayEndsAfter12Times.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Daily, 1, 1, mo.AddHours(12), null, 1);
|
|
DAOFactory.GenericDAO.Insert(everyWorkdayEndsAfter12Times);
|
|
|
|
var everyWorkdayEndsOnSpecificDate = GenerateTestAppointment(false, false, mo.AddHours(13), mo.AddHours(14), AppointmentType.Pattern, $"Wochentäglich. Endet am {mo.AddHours(13).AddDays(11):dd.MM.yyyy}", employee);
|
|
everyWorkdayEndsOnSpecificDate.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Daily, 2, 1, mo.AddHours(13), everyWorkdayEndsOnSpecificDate.StartDate.Value.AddDays(11), 0);
|
|
DAOFactory.GenericDAO.Insert(everyWorkdayEndsOnSpecificDate);
|
|
|
|
var everyThreeDaysEndsOnSpecificDate = GenerateTestAppointment(false, false, mo.AddHours(15), mo.AddHours(16), AppointmentType.Pattern, "Jeden dritten Tag. Endet 11 Tage nach Beginn", employee);
|
|
everyThreeDaysEndsOnSpecificDate.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Daily, 2, 0, mo.AddHours(15), mo.AddHours(15).AddDays(11), 0);
|
|
DAOFactory.GenericDAO.Insert(everyThreeDaysEndsOnSpecificDate);
|
|
|
|
// Wöchentliche Termine
|
|
var everyThirdWeekMondayAndTuesday = GenerateTestAppointment(false, false, mo.AddHours(16), mo.AddHours(17), AppointmentType.Pattern, "Jede dritte Woche Montags und Dienstags. Endlos", employee);
|
|
everyThirdWeekMondayAndTuesday.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Weekly, 0, 0, mo.AddHours(16), null, 1);
|
|
DAOFactory.GenericDAO.Insert(everyThirdWeekMondayAndTuesday);
|
|
|
|
var everySecondWeekMondaysAndTuesdays = GenerateTestAppointment(false, false, mo.AddHours(18), mo.AddHours(19), AppointmentType.Pattern, "Jede zweite Woche am Montag und Dienstag. Endet nach 17 Terminen", employee);
|
|
everySecondWeekMondaysAndTuesdays.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Weekly, 0, 1, mo.AddHours(18), null, 17);
|
|
DAOFactory.GenericDAO.Insert(everySecondWeekMondaysAndTuesdays);
|
|
|
|
var everyWeekMondaysAndTuesdays = GenerateTestAppointment(false, false, mo.AddHours(19), mo.AddHours(20), AppointmentType.Pattern, $"Jede Woche am Montag und Dienstag. Endet am {mo.AddHours(19).AddDays(20):dd.MM.yyyy}", employee);
|
|
everyWeekMondaysAndTuesdays.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Weekly, 1, 1, mo.AddHours(19), mo.AddHours(19).AddDays(20), 1);
|
|
DAOFactory.GenericDAO.Insert(everyWeekMondaysAndTuesdays);
|
|
|
|
// Monatliche Termine
|
|
var m1 = GenerateTestAppointment(false, false, tu.AddHours(8), tu.AddHours(9), AppointmentType.Pattern, $"Am {tu.FirstDateOfWeek(tu.GetIso8601WeekOfYear())} jedes 2. Monats. Endlos", employee);
|
|
m1.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Monthly, 0, 0, tu.AddHours(8), null, 1);
|
|
DAOFactory.GenericDAO.Insert(m1);
|
|
|
|
var m2 = GenerateTestAppointment(false, false, tu.AddHours(9), tu.AddHours(10), AppointmentType.Pattern, "Jeden dritten Mittwoch jedes 2. Monats. Endlos", employee);
|
|
m2.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Monthly, 0, 1, tu.AddHours(9), null, 1);
|
|
DAOFactory.GenericDAO.Insert(m2);
|
|
|
|
var m3 = GenerateTestAppointment(false, false, tu.AddHours(10), tu.AddHours(11), AppointmentType.Pattern, "Jeden 3. jedes 3. Monats. Endet nach 3 Terminen", employee);
|
|
m3.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Monthly, 1, 0, tu.AddHours(10), null, 3);
|
|
DAOFactory.GenericDAO.Insert(m3);
|
|
|
|
var m4 = GenerateTestAppointment(false, false, tu.AddHours(11), tu.AddHours(12), AppointmentType.Pattern, "Jeden 3. Montag jedes 3. Monats. Endet nach 3 Terminen", employee);
|
|
m4.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Monthly, 1, 1, tu.AddHours(11), null, 3);
|
|
DAOFactory.GenericDAO.Insert(m4);
|
|
|
|
var m5 = GenerateTestAppointment(false, false, tu.AddHours(12), tu.AddHours(13), AppointmentType.Pattern, $"Am 17. jedes 3. Monats. Endet am {tu.AddMonths(6):dd.MM.yyyy}", employee);
|
|
m5.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Monthly, 2, 0, tu.AddHours(12), tu.AddHours(12).AddMonths(6), 1);
|
|
DAOFactory.GenericDAO.Insert(m5);
|
|
|
|
var m6 = GenerateTestAppointment(false, false, tu.AddHours(13), tu.AddHours(14), AppointmentType.Pattern, $"Jeden 3. Montag jedes Monats. Endet am {tu.AddMonths(4):dd.MM.yyyy}", employee);
|
|
m6.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Monthly, 2, 1, tu.AddHours(13), tu.AddHours(13).AddMonths(4), 1);
|
|
DAOFactory.GenericDAO.Insert(m6);
|
|
|
|
// Jährliche Termine
|
|
|
|
var y1 = GenerateTestAppointment(false, false, tu.AddHours(14), tu.AddHours(16), AppointmentType.Pattern, $"Jährlich am {tu:dd.MM.}. Endlos", employee);
|
|
y1.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Yearly, 0, 0, tu.AddHours(14), null, 1);
|
|
DAOFactory.GenericDAO.Insert(y1);
|
|
|
|
|
|
var y2 = GenerateTestAppointment(false, false, tu.AddHours(16), tu.AddHours(17), AppointmentType.Pattern, $"Jährlich am 3. Montag im {tu:MMMM}. Endlos", employee);
|
|
y2.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Yearly, 0, 1, tu.AddHours(16), null, 1);
|
|
DAOFactory.GenericDAO.Insert(y2);
|
|
|
|
var y3 = GenerateTestAppointment(false, false, tu.AddHours(17), tu.AddHours(18), AppointmentType.Pattern, $"Jährlich jeden {tu.Day}. im {mo.Month:MMMM}. Endet nach 3 Terminen", employee);
|
|
y3.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Yearly, 1, 0, tu.AddHours(17), null, 3);
|
|
DAOFactory.GenericDAO.Insert(y3);
|
|
|
|
var y4 = GenerateTestAppointment(false, false, tu.AddHours(18), tu.AddHours(19), AppointmentType.Pattern, $"Jährlich jeden 3. Montag im {mo.Month:MMMM}. Endet nach 3 Terminen", employee);
|
|
y4.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Yearly, 1, 1, tu.AddHours(18), null, 3);
|
|
DAOFactory.GenericDAO.Insert(y4);
|
|
|
|
var y5 = GenerateTestAppointment(false, false, tu.AddHours(19), tu.AddHours(20), AppointmentType.Pattern, $"Jährlich am x. [Monat]. Endet am xx.xx.xxxx (1 Jahr später)", employee);
|
|
y5.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Yearly, 2, 0, tu.AddHours(19), tu.AddHours(19).AddYears(1), 3);
|
|
DAOFactory.GenericDAO.Insert(y5);
|
|
|
|
var y6 = GenerateTestAppointment(false, false, tu.AddHours(20), tu.AddHours(21), AppointmentType.Pattern, $"Jährlich jeden 3. Mittwoch im {tu:MMMM}. Endet am {tu.AddHours(20).AddYears(1):dd.MM.yyyy}", employee);
|
|
y6.RecurrenceInfo = GenerateRecurrenceInfo(RecurrenceType.Yearly, 2, 1, tu.AddHours(20), tu.AddHours(20).AddYears(1), 3);
|
|
DAOFactory.GenericDAO.Insert(y6);
|
|
// --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
#endif
|
|
}
|
|
|
|
private static string CreateRandomLocationName()
|
|
{
|
|
var random = new Random(Convert.ToInt32(DateTime.Now.Ticks.ToString().Substring(0, 9))).Next();
|
|
var location = "";
|
|
|
|
if(random % 2 == 0)
|
|
{
|
|
location = "Duisburg";
|
|
}
|
|
else if(random % 3 == 0)
|
|
{
|
|
location = "Düsseldorf";
|
|
}
|
|
else if (random % 5 == 0)
|
|
{
|
|
location = "Köln";
|
|
}
|
|
|
|
return location;
|
|
}
|
|
|
|
private static void GenerateAppointments(DateTime pFirstDate, bool pIsPrivate, Employee pEmployee, IList<Customer> pCustomerList, IList<Customer> pOwnCustomers, IList<Resource> pResourceList, IList<Employee2SchedulerAppointment> pEmployees, string pRecurrenceInfo, bool pIsAllDay = false)
|
|
{
|
|
const int startHours = 6;
|
|
|
|
for(var i = 0; i < 12; i++)
|
|
{
|
|
var appointment = GenerateTestAppointment(
|
|
pIsPrivate,
|
|
new List<Customer>(),
|
|
new List<Resource>(),
|
|
new List<Employee2SchedulerAppointment>(),
|
|
pIsAllDay,
|
|
pIsAllDay ? pFirstDate.GetShortDateTime() : pFirstDate.AddHours(startHours + i),
|
|
pIsAllDay ? pFirstDate.GetShortDateTime().AddDays(1) : pFirstDate.AddHours(startHours + i + 1),
|
|
AppointmentType.Normal,
|
|
$"Testtermin von {pEmployee.Person.FirstNameLastName}",
|
|
pEmployee);
|
|
|
|
switch (i)
|
|
{
|
|
case 1:
|
|
appointment.CustomerList = pCustomerList;
|
|
appointment.Subject += " mit Klienten";
|
|
break;
|
|
case 2:
|
|
appointment.Subject += " mit Mitarbeitern";
|
|
break;
|
|
case 3:
|
|
appointment.ResourceList = pResourceList;
|
|
appointment.Subject += " mit Ressourcen";
|
|
break;
|
|
case 4:
|
|
appointment.CustomerList = pCustomerList;
|
|
appointment.Subject += " mit Klienten und Mitarbeitern";
|
|
break;
|
|
case 5:
|
|
appointment.CustomerList = pCustomerList;
|
|
appointment.ResourceList = pResourceList;
|
|
appointment.Subject += " mit Klienten und Ressourcen";
|
|
break;
|
|
case 6:
|
|
appointment.CustomerList = pCustomerList;
|
|
appointment.ResourceList = pResourceList;
|
|
appointment.Subject += " mit Klienten, Mitarbeitern und Ressourcen";
|
|
break;
|
|
case 7:
|
|
appointment.ResourceList = pResourceList;
|
|
appointment.Subject += " mit Mitarbeitern und Ressourcen";
|
|
break;
|
|
case 8:
|
|
appointment.CustomerList = pOwnCustomers;
|
|
appointment.Subject += " mit eigenen Klienten";
|
|
break;
|
|
case 9:
|
|
appointment.CustomerList = pOwnCustomers;
|
|
appointment.Subject += " mit eigenen Klienten und Mitarbeitern";
|
|
break;
|
|
case 10:
|
|
appointment.CustomerList = pOwnCustomers;
|
|
appointment.ResourceList = pResourceList;
|
|
appointment.Subject += " mit eigenen Klienten und Ressourcen";
|
|
break;
|
|
case 11:
|
|
appointment.CustomerList = pOwnCustomers;
|
|
appointment.ResourceList = pResourceList;
|
|
appointment.Subject += " mit eigenen Klienten, Mitarbeitern und Ressourcen";
|
|
break;
|
|
}
|
|
|
|
appointment.Subject = (pIsPrivate ? "Privat: " : "") + appointment.Subject;
|
|
|
|
if (pEmployees != null)
|
|
{
|
|
DAOFactory.GenericDAO.Insert(pEmployees);
|
|
pEmployees = DAOFactory.GenericDAO.LoadByIDs<Employee2SchedulerAppointment>(pEmployees.Where(w => w.Oid.HasValue).Select(s => s.Oid.Value));
|
|
appointment.EmployeeList = pEmployees;
|
|
}
|
|
|
|
DAOFactory.GenericDAO.Insert(appointment);
|
|
|
|
if(pEmployees != null)
|
|
{
|
|
foreach(var abc in appointment.EmployeeList)
|
|
{
|
|
abc.SchedulerAppointmentOid = appointment.Oid;
|
|
}
|
|
|
|
DAOFactory.GenericDAO.Update(appointment.EmployeeList);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static string GenerateRecurrenceInfo(RecurrenceType pType, int pRecurrenceMode, int pRecurrenceOption, DateTime pStartDate, DateTime? pRecurrenceEndDate, int pOccurrenceCount)
|
|
{
|
|
// pRecurrenceOption ist z.B. bei täglich "Alle x Tage" oder "Jeden Arbeitstag"
|
|
var monday = pStartDate.FirstDateOfWeek(pStartDate.GetIso8601WeekOfYear());
|
|
|
|
// XML für die RecurrenceInfo bauen
|
|
var ri = new RecurrenceInfo
|
|
{
|
|
Start = pStartDate,
|
|
Type = pType
|
|
};
|
|
|
|
switch(pRecurrenceMode)
|
|
{
|
|
case 0: // Ohne Enddatum
|
|
ri.Range = RecurrenceRange.NoEndDate;
|
|
ri.Periodicity = 3;
|
|
|
|
switch (pType)
|
|
{
|
|
case RecurrenceType.Daily:
|
|
ri.Start = monday;
|
|
|
|
if(pRecurrenceOption == 1) // Jeden Arbeitstag
|
|
{
|
|
ri.WeekDays = WeekDays.WorkDays;
|
|
}
|
|
break;
|
|
case RecurrenceType.Weekly:
|
|
ri.WeekDays = WeekDays.Monday | WeekDays.Tuesday;
|
|
break;
|
|
case RecurrenceType.Monthly:
|
|
ri.WeekDays = ri.Start.GetSchedulerWeekDays();
|
|
ri.Periodicity = 2;
|
|
ri.WeekOfMonth = pRecurrenceOption == 0 ? 0 : WeekOfMonth.Third;
|
|
|
|
if(pRecurrenceOption == 1) // Am x. Wochentag jedes y.
|
|
{
|
|
var date = DateTimeUtils.GetNthDayOfWeekInMonth(ri.Start, 3, DayOfWeek.Monday);
|
|
ri.Start = date;
|
|
ri.WeekDays = date.GetSchedulerWeekDays();
|
|
}
|
|
else // Am x. jedes y. Monats
|
|
{
|
|
ri.DayNumber = monday.Day;
|
|
}
|
|
|
|
break;
|
|
case RecurrenceType.Yearly:
|
|
if(pRecurrenceOption == 0)
|
|
{
|
|
ri.DayNumber = monday.Day;
|
|
}
|
|
|
|
ri.Periodicity = 1;
|
|
ri.WeekOfMonth = pRecurrenceOption == 0 ? 0 : WeekOfMonth.Third;
|
|
ri.WeekDays = monday.GetSchedulerWeekDays();
|
|
ri.Month = monday.Month;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
case 1: // Endet nach y Terminen
|
|
ri.Range = RecurrenceRange.OccurrenceCount;
|
|
|
|
var day = pStartDate;
|
|
|
|
switch (pType)
|
|
{
|
|
case RecurrenceType.Daily:
|
|
if(pRecurrenceOption == 1) // Jeden Arbeitstag endet nach y Terminen
|
|
{
|
|
ri.WeekDays = WeekDays.WorkDays;
|
|
var counter1 = 0;
|
|
|
|
do
|
|
{
|
|
if(day.DayOfWeek != DayOfWeek.Saturday && day.DayOfWeek != DayOfWeek.Sunday)
|
|
{
|
|
counter1++;
|
|
}
|
|
|
|
day = day.AddDays(1);
|
|
} while(counter1 < pOccurrenceCount - 1);
|
|
}
|
|
else
|
|
{
|
|
ri.Periodicity = 3;
|
|
ri.OccurrenceCount = pOccurrenceCount;
|
|
|
|
for (var i = 0; i < pOccurrenceCount - 1; i++)
|
|
{
|
|
day = day.AddDays(ri.Periodicity);
|
|
}
|
|
}
|
|
|
|
ri.End = day;
|
|
|
|
break;
|
|
case RecurrenceType.Weekly:
|
|
// Jeden Montag und Dienstag alle 2 Wochen
|
|
ri.WeekDays = WeekDays.Monday | WeekDays.Tuesday;
|
|
ri.OccurrenceCount = pOccurrenceCount;
|
|
ri.Periodicity = 2;
|
|
|
|
var weekDays = SUtils.GetWeekDaysFromNumber((int) ri.WeekDays);
|
|
|
|
var counter = 1;
|
|
var position = weekDays.IndexOf(day.DayOfWeek);
|
|
|
|
do
|
|
{
|
|
for(var i = position; i < weekDays.Count; i++)
|
|
{
|
|
day = SUtils.GetNextDateTime(day, weekDays.ElementAt(i), ri.Periodicity, RecurrenceType.Weekly);
|
|
counter++;
|
|
}
|
|
|
|
position = (weekDays.Count - 1) % (position == 0 ? position + 1 : position);
|
|
} while(counter < pOccurrenceCount);
|
|
|
|
ri.End = day;
|
|
break;
|
|
case RecurrenceType.Monthly:
|
|
ri.WeekDays = pStartDate.GetSchedulerWeekDays();
|
|
ri.WeekOfMonth = pRecurrenceOption == 0 ? 0 : pStartDate.GetWeekOfMonthForRecurrenceInfo();
|
|
|
|
if (pRecurrenceOption == 0) // Am 3. jedes 3. Monats. Endet nach 3 Terminen
|
|
{
|
|
ri.DayNumber = pStartDate.Day;
|
|
ri.Periodicity = 3;
|
|
ri.OccurrenceCount = pOccurrenceCount;
|
|
}
|
|
else // Jeden 3. Montag jedes 3. Monats. Endet nach 3 Terminen
|
|
{
|
|
ri.End = pStartDate.AddMonths(3 * pOccurrenceCount);
|
|
}
|
|
break;
|
|
case RecurrenceType.Yearly:
|
|
ri.Month = pStartDate.Month;
|
|
ri.WeekDays = pStartDate.GetSchedulerWeekDays();
|
|
ri.OccurrenceCount = pOccurrenceCount;
|
|
|
|
if (pRecurrenceOption == 0) // Am x. des Monats
|
|
{
|
|
ri.DayNumber = pStartDate.Day;
|
|
}
|
|
else // Jeden 3. Montag im Juni
|
|
{
|
|
ri.WeekOfMonth = pStartDate.GetWeekOfMonthForRecurrenceInfo();
|
|
}
|
|
break;
|
|
}
|
|
|
|
break;
|
|
case 2: // Endet am xx.xx.xxxx
|
|
if(!pRecurrenceEndDate.HasValue)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
ri.Range = RecurrenceRange.EndByDate;
|
|
ri.End = pRecurrenceEndDate.Value;
|
|
|
|
switch (pType)
|
|
{
|
|
// Start, End
|
|
case RecurrenceType.Daily:
|
|
if(pRecurrenceOption == 0) // Alle x Tage. Endet am xx.xx.xxxx
|
|
{
|
|
day = ri.Start;
|
|
while(day < ri.End && ri.OccurrenceCount < 3)
|
|
{
|
|
day = day.AddDays(3);
|
|
ri.OccurrenceCount++;
|
|
}
|
|
}
|
|
else // Jeden Arbeitstag. Endet am xx.xx.xxxx
|
|
{
|
|
ri.WeekDays = WeekDays.WorkDays;
|
|
ri.OccurrenceCount = (ri.End - ri.Start).Days + 1 - DateTimeUtils.GetNumberOfWeekEndDaysInBetween(ri.Start, ri.End);
|
|
}
|
|
break;
|
|
case RecurrenceType.Weekly:
|
|
ri.WeekDays = WeekDays.Monday | WeekDays.Wednesday | WeekDays.Friday;
|
|
|
|
var weekDays = SUtils.GetWeekDaysFromNumber((int)ri.WeekDays);
|
|
|
|
day = ri.Start;
|
|
var position = weekDays.IndexOf(day.DayOfWeek) + (weekDays.Count > 1 ? 1 : 0);
|
|
|
|
do
|
|
{
|
|
for (var i = position; i < weekDays.Count; i++)
|
|
{
|
|
day = SUtils.GetNextDateTime(day, weekDays.ElementAt(i), 1, RecurrenceType.Weekly).Date;
|
|
ri.OccurrenceCount++;
|
|
}
|
|
|
|
position = (weekDays.Count - 1) % (position == 0 ? position + 1 : position);
|
|
} while (day < ri.End.Date);
|
|
|
|
break;
|
|
case RecurrenceType.Monthly:
|
|
ri.WeekOfMonth = pRecurrenceOption == 0 ? 0 : pStartDate.GetWeekOfMonthForRecurrenceInfo();
|
|
|
|
if (pRecurrenceOption == 0) // Am 17. jedes 3. Monats. Endet am xx.xx.xxxx (17. diesen Monats + 6 Monate)
|
|
{
|
|
ri.End = new DateTime(ri.Start.AddMonths(7).Year, ri.Start.AddMonths(7).Month, 1, ri.Start.Hour, ri.Start.Minute, ri.Start.Second);
|
|
ri.DayNumber = 17;
|
|
ri.Periodicity = 3;
|
|
ri.WeekDays = new DateTime(ri.Start.Year, ri.Start.Month, 17).GetSchedulerWeekDays();
|
|
ri.OccurrenceCount = 3;
|
|
}
|
|
else // Am x. [Wochentag] jedes y. Monats. Endet am xx.xx.xxxx
|
|
{
|
|
// 5 mal
|
|
var abc = DateTimeUtils.GetNthDayOfWeekInMonth(ri.Start.AddMonths(4), 3, DayOfWeek.Wednesday);
|
|
ri.End = abc < pRecurrenceEndDate.Value ? pRecurrenceEndDate.Value : abc;
|
|
ri.WeekOfMonth = WeekOfMonth.Third;
|
|
ri.OccurrenceCount = 5;
|
|
ri.WeekDays = WeekDays.Monday;
|
|
}
|
|
break;
|
|
case RecurrenceType.Yearly:
|
|
ri.WeekOfMonth = pRecurrenceOption == 0 ? 0 : pStartDate.GetWeekOfMonthForRecurrenceInfo();
|
|
|
|
if (pRecurrenceOption == 0) // Am x. [Monat]. Endet am xx.xx.xxxx (1 Jahr später)
|
|
{
|
|
ri.End = ri.Start.AddYears(1);
|
|
ri.DayNumber = ri.Start.Day;
|
|
ri.WeekDays = ri.Start.GetSchedulerWeekDays();
|
|
ri.Month = ri.Start.Month;
|
|
ri.OccurrenceCount = ri.Start.AddYears(1).Year - ri.Start.Year + 1;
|
|
}
|
|
else // Jeden 3. Mittwoch im [Aktueller Monat]. Endet am xx.xx.xxxx (1 Jahr vom Startdatum entfernt)
|
|
{
|
|
var wednesday = ri.Start.FirstDateOfWeek(ri.Start.GetIso8601WeekOfYear()).AddDays(2);
|
|
|
|
ri.WeekDays = WeekDays.Wednesday;
|
|
ri.Start = DateTimeUtils.GetNthDayOfWeekInMonth(wednesday, 3, wednesday.DayOfWeek);
|
|
ri.DayNumber = ri.Start.Day;
|
|
ri.Month = ri.Start.Month;
|
|
ri.End = DateTimeUtils.GetNthDayOfWeekInMonth(ri.Start.AddYears(1), 3, ri.Start.DayOfWeek);
|
|
ri.OccurrenceCount = ri.End.Year - ri.Start.Year + 1;
|
|
}
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return ri.ToXml();
|
|
}
|
|
|
|
private static SchedulerAppointment GenerateTestAppointment(bool pIsPrivate, bool pIsAllDay, DateTime pStart, DateTime pEnd, AppointmentType pType, string pSubject, Employee pOriginator)
|
|
{
|
|
return GenerateTestAppointment(pIsPrivate, new List<Customer>(), new List<Resource>(), new List<Employee2SchedulerAppointment>(), pIsAllDay, pStart, pEnd, pType, pSubject, pOriginator);
|
|
}
|
|
|
|
private static SchedulerAppointment GenerateTestAppointment(bool pIsPrivate, IList<Customer> pCustomerList, IList<Resource> pResourceList, IList<Employee2SchedulerAppointment> pEmployeeList, bool pIsAllDay, DateTime pStart, DateTime pEnd, AppointmentType pType, string pSubject, Employee pOriginator)
|
|
{
|
|
var appointment = new SchedulerAppointment
|
|
{
|
|
AllDay = pIsAllDay,
|
|
CustomerList = pCustomerList,
|
|
EmployeeList = pEmployeeList,
|
|
ResourceList = pResourceList,
|
|
StartDate = pStart,
|
|
EndDate = pEnd,
|
|
Type = (int) pType,
|
|
Location = CreateRandomLocationName(),
|
|
IsPrivate = pIsPrivate,
|
|
Subject = pSubject,
|
|
Originator = pOriginator,
|
|
Notice = SUtils.TestAppointmentNotice
|
|
};
|
|
|
|
return appointment;
|
|
}
|
|
|
|
public void DeleteTestAppointments()
|
|
{
|
|
try
|
|
{
|
|
var testAppointments = DAOFactory.SearchDAO.GetTestAppointments();
|
|
|
|
DAOFactory.GenericDAO.Delete(testAppointments);
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<ResourceDC> CheckResourceAvailability(DateTime start, DateTime end, List<long> resourceOids, long? selectedAppointmentOid)
|
|
{
|
|
return MapperFactory.ResourceDC_Resource.MapToNewDCs(DAOFactory.SearchDAO.CheckAvailabilityOfResources(resourceOids, start, end, selectedAppointmentOid));
|
|
}
|
|
|
|
public SchedulerAppointmentDC FindRootAppointmentByRecurrenceId(string recurrenceId)
|
|
{
|
|
var rootAppointment = DAOFactory.SearchDAO.FindRootAppointmentByRecurrenceId(recurrenceId);
|
|
|
|
return rootAppointment == null ? null : MapperFactory.SchedulerAppointmentDCSchedulerAppointment.MapToNewDC(rootAppointment);
|
|
}
|
|
}
|
|
} |