ownSoft/BeWoPlaner
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
101b563bd533986030dea5ec4bce12bbc01c852f
BeWoPlaner/Service/ServiceImplementations/ResourceServiceImp.cs
Lyndon 3a7014662b Mobilklient refaktoriert
2019-07-25 14:56:11 +02:00

2211 lines
102 KiB
C#
Raw Blame History

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
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.ReportServer.ServiceModel.DataContracts;
using DevExpress.XtraScheduler;
using DevExpress.XtraScheduler.Xml;
using static System.String;
using Appointment = BeWo.Data.Entities.Appointment;
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 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();
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();
}
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 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();
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);
}
var test = result.Where(w => w.SchedulerAppointmentOid == null).ToList();
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,
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);
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink