private void CheckEvent(string eventData, AppointmentId appointmentId, int[] expectedSequenceNumbers)
{
var calendar = OutlookTestContext.DeserializeICalendar(eventData);
Assert.That(calendar.Events.Count, Is.EqualTo(3));
var masterEvent = calendar.Events.Single(e => e.Summary == "Treffen");
var exeption1Event = calendar.Events.Single(e => e.Summary == "Ex 1");
var exeption2Event = calendar.Events.Single(e => e.Summary == "Ex 2");
CollectionAssert.AreEquivalent(expectedSequenceNumbers, calendar.Events.Select(e => e.Sequence));
Assert.That(exeption1Event.UID, Is.EqualTo(masterEvent.UID));
Assert.That(exeption2Event.UID, Is.EqualTo(masterEvent.UID));
using (var masterAppointment = OutlookTestContext.GetOutlookEvent(appointmentId))
{
GenericComObjectWrapper <AppointmentItem> exeption1Appointment;
GenericComObjectWrapper <AppointmentItem> exeption2Appointment;
using (var r = GenericComObjectWrapper.Create(masterAppointment.Inner.GetRecurrencePattern()))
{
exeption1Appointment = GenericComObjectWrapper.Create(r.Inner.Exceptions[1].AppointmentItem);
exeption2Appointment = GenericComObjectWrapper.Create(r.Inner.Exceptions[2].AppointmentItem);
}
Assert.That(masterEvent.Start.Value, Is.EqualTo(masterAppointment.Inner.Start));
Assert.That(exeption1Event.Start.Value, Is.EqualTo(exeption1Appointment.Inner.Start));
Assert.That(exeption2Event.Start.Value, Is.EqualTo(exeption2Appointment.Inner.Start));
}
}
public override int GetHashCode()
{
int hash = 1;
if (UserId != 0)
{
hash ^= UserId.GetHashCode();
}
if (AppointmentId != 0)
{
hash ^= AppointmentId.GetHashCode();
}
if (ActiveState != 0)
{
hash ^= ActiveState.GetHashCode();
}
hash ^= activeGates_.GetHashCode();
hash ^= finishGates_.GetHashCode();
if (CreateTime != 0L)
{
hash ^= CreateTime.GetHashCode();
}
if (LastModifyTime != 0L)
{
hash ^= LastModifyTime.GetHashCode();
}
return(hash);
}
private ImportRequest CreateAppendRequest()
=> new ImportRequest(
"mboc_upsertAppointmentUrl",
new List <string> {
"pSourceApp", "pSourceType", "pAppointmentId", "pAppointmentGuid", "pUrl", "pUrlDesc"
}.ToArray(),
new List <string> {
SourceApp, SourceType, AppointmentId.ToString(), AppointmentGuid?.ToString(), Uri, Description
}.ToArray());
public override bool Equals(object obj)
{
var appointment = obj as Appointment;
return(appointment != null &&
AppointmentId.Equals(appointment.AppointmentId) &&
Title == appointment.Title &&
StartTime == appointment.StartTime &&
EndTime == appointment.EndTime);
}
public async Task HandleAsync(ScheduleAppointmentCommand command, CancellationToken cancellationToken = default(CancellationToken))
{
using (var unitOfWork = await _unitOfWorkFactory.CreateAsync())
{
// Convert from external representations to domain representations
var appointmentId = new AppointmentId(command.AppointmentId);
var doctorId = new DoctorId(command.DoctorId);
var patientId = new PatientId(command.PatientId);
var appointmentDuration = new AppointmentDuration(command.AppointmentDurationInMinutes);
// Invoke domain logic
await _scheduleAppointmentService.ScheduleAsync(appointmentId, doctorId, patientId, command.AppointmentAt,
appointmentDuration, cancellationToken);
await unitOfWork.CommitAsync();
}
}
public static AppointmentItemWrapper GetOutlookEvent (AppointmentId id)
{
return OutlookEventRepository.GetOutlookEventForTesting (id.EntryId, s_mapiNameSpace, s_outlookFolderStoreId);
}
public static string SyncOutlookToCalDav_EventsExistsInCalDav (string existingEventData, AppointmentId existingAppointmentId)
{
var entityRelationStorage = new InMemoryEntityRelationStorage<AppointmentId, DateTime, IEntityRelationData<AppointmentId, DateTime, WebResourceName, string>, WebResourceName, string>();
entityRelationStorage.SaveEntityRelationData (new List<IEntityRelationData<AppointmentId, DateTime, WebResourceName, string>>()
{
new OutlookEventRelationData()
{
AtypeId = existingAppointmentId,
AtypeVersion = new DateTime (1),
BtypeId = new WebResourceName("/e1"),
BtypeVersion = "v1"
}
});
return SyncOutlookToCalDav_EventsExistsInCalDav (existingEventData, entityRelationStorage);
}
public static AppointmentItemWrapper GetOutlookEvent(AppointmentId id)
{
return(OutlookEventRepository.GetOutlookEventForTesting(id.EntryId, s_mapiNameSpace, s_outlookFolderStoreId));
}
public static string SyncOutlookToCalDav_EventsExistsInCalDav(string existingEventData, AppointmentId existingAppointmentId)
{
var entityRelationStorage = new InMemoryEntityRelationStorage <AppointmentId, DateTime, IEntityRelationData <AppointmentId, DateTime, WebResourceName, string>, WebResourceName, string>();
entityRelationStorage.SaveEntityRelationData(new List <IEntityRelationData <AppointmentId, DateTime, WebResourceName, string> >()
{
new OutlookEventRelationData()
{
AtypeId = existingAppointmentId,
AtypeVersion = new DateTime(1),
BtypeId = new WebResourceName("/e1"),
BtypeVersion = "v1"
}
});
return(SyncOutlookToCalDav_EventsExistsInCalDav(existingEventData, entityRelationStorage));
}
List <AppointmentSlim> IQueryOutlookAppointmentItemFolderStrategy.QueryAppointmentFolder(IOutlookSession session, Folder calendarFolder, string filter, IGetVersionsLogger logger)
{
var events = new List <AppointmentSlim>();
using (var tableWrapper = GenericComObjectWrapper.Create(
calendarFolder.GetTable(filter)))
{
var table = tableWrapper.Inner;
table.Columns.RemoveAll();
table.Columns.Add(PR_GLOBAL_OBJECT_ID);
table.Columns.Add(PR_LONG_TERM_ENTRYID_FROM_TABLE);
table.Columns.Add(PR_ENTRYID);
table.Columns.Add(LastModificationTimeColumnId);
table.Columns.Add(SubjectColumnId);
table.Columns.Add(StartColumnId);
table.Columns.Add(EndColumnId);
while (!table.EndOfTable)
{
var row = table.GetNextRow();
string entryId;
byte[] entryIdArray = row[PR_LONG_TERM_ENTRYID_FROM_TABLE] as byte[];
if (entryIdArray != null && entryIdArray.Length > 0)
{
entryId = row.BinaryToString(PR_LONG_TERM_ENTRYID_FROM_TABLE);
}
else
{
// Fall back to short-term ENTRYID if long-term ID not available
entryId = row.BinaryToString(PR_ENTRYID);
s_logger.Warn($"Could not access long-term ENTRYID of appointment '{entryId}', use short-term ENTRYID as fallback.");
}
string globalAppointmentId = null;
try
{
byte[] globalIdArray = row[PR_GLOBAL_OBJECT_ID] as byte[];
if (globalIdArray != null && globalIdArray.Length > 0)
{
globalAppointmentId = row.BinaryToString(PR_GLOBAL_OBJECT_ID);
}
}
catch (Exception ex)
{
s_logger.Warn($"Could not access GlobalAppointmentID of appointment '{entryId}'.", ex);
}
var subject = (string)row[SubjectColumnId];
var appointmentId = new AppointmentId(entryId, globalAppointmentId);
var lastModificationTimeObject = row[LastModificationTimeColumnId];
DateTime lastModificationTime;
if (lastModificationTimeObject != null)
{
lastModificationTime = ((DateTime)lastModificationTimeObject).ToUniversalTime();
}
else
{
s_logger.Warn($"Column '{nameof(LastModificationTimeColumnId)}' of event '{entryId}' is NULL.");
logger.LogWarning(entryId, $"Column '{nameof(LastModificationTimeColumnId)}' is NULL.");
lastModificationTime = OutlookUtility.OUTLOOK_DATE_NONE;
}
var startObject = row[StartColumnId];
DateTime?start;
if (startObject != null)
{
start = (DateTime)startObject;
}
else
{
s_logger.Warn($"Column '{nameof(StartColumnId)}' of event '{entryId}' is NULL.");
logger.LogWarning(entryId, $"Column '{nameof(StartColumnId)}' is NULL.");
start = null;
}
var endObject = row[EndColumnId];
DateTime?end;
if (endObject != null)
{
end = (DateTime)endObject;
}
else
{
s_logger.Warn($"Column '{nameof(EndColumnId)}' of event '{entryId}' is NULL.");
logger.LogWarning(entryId, $"Column '{nameof(EndColumnId)}' is NULL.");
end = null;
}
events.Add(new AppointmentSlim(EntityVersion.Create(appointmentId, lastModificationTime.ToUniversalTime()), start, end, subject));
}
}
return(events);
}
private async Task<Tuple<AppointmentId, AppointmentItemWrapper>[]> GetAppointmentsWithId (AppointmentId[] ids)
{
return (await Task.WhenAll (ids.Select (async i => Tuple.Create( i, await GetOrNull (i) )))).Where (a => a.Item2 != null).ToArray();
}
private async Task<AppointmentItemWrapper[]> GetAppointments(AppointmentId[] ids)
{
return (await Task.WhenAll(ids.Select(GetOrNull).Where(a => a != null))).ToArray();
}
private async Task DeleteAppointment (AppointmentItemWrapper item, Dictionary<AppointmentId, IEntityRelationData<AppointmentId, DateTime, WebResourceName, string>> relations)
{
IEntityRelationData<AppointmentId, DateTime, WebResourceName, string> relation;
var appointmentId = new AppointmentId(item.Inner.EntryID, item.Inner.GlobalAppointmentID);
if (relations.TryGetValue (appointmentId, out relation))
{
await _btypeRepository.TryDelete (relation.BtypeId, relation.BtypeVersion, NullEventSynchronizationContext.Instance);
relations.Remove (appointmentId);
}
item.Inner.Delete();
}
private void SwitchEventCategories(ChangedOptions changedOption, string oldCategory, string newCategory, AppointmentId eventId)
{
using (var eventWrapper = new AppointmentItemWrapper(
(AppointmentItem)_session.GetItemFromID(eventId.EntryId, changedOption.New.OutlookFolderStoreId),
entryId => (AppointmentItem)_session.GetItemFromID(entryId, changedOption.New.OutlookFolderStoreId)))
{
var categories = eventWrapper.Inner.Categories
.Split(new[] { CultureInfo.CurrentCulture.TextInfo.ListSeparator }, StringSplitOptions.RemoveEmptyEntries)
.Select(c => c.Trim());
eventWrapper.Inner.Categories = string.Join(
CultureInfo.CurrentCulture.TextInfo.ListSeparator,
categories
.Except(new[] { oldCategory })
.Concat(new[] { newCategory })
.Distinct());
eventWrapper.Inner.Save();
}
}
public async Task Handle(LocationSet @event)
{
var command = new AppointmentBookCommand(AppointmentId.With(@event.Id));
await commandBus.PublishAsync(command, cancellationToken : CancellationToken.None);
}
private void CheckEvent (string eventData, AppointmentId appointmentId, int[] expectedSequenceNumbers)
{
var calendar = OutlookTestContext.DeserializeICalendar (eventData);
Assert.That (calendar.Events.Count, Is.EqualTo (3));
var masterEvent = calendar.Events.Single (e => e.Summary == "Treffen");
var exeption1Event = calendar.Events.Single (e => e.Summary == "Ex 1");
var exeption2Event = calendar.Events.Single (e => e.Summary == "Ex 2");
CollectionAssert.AreEquivalent (expectedSequenceNumbers, calendar.Events.Select (e => e.Sequence));
Assert.That (exeption1Event.UID, Is.EqualTo (masterEvent.UID));
Assert.That (exeption2Event.UID, Is.EqualTo (masterEvent.UID));
using (var masterAppointment = OutlookTestContext.GetOutlookEvent (appointmentId))
{
GenericComObjectWrapper<AppointmentItem> exeption1Appointment;
GenericComObjectWrapper<AppointmentItem> exeption2Appointment;
using (var r = GenericComObjectWrapper.Create (masterAppointment.Inner.GetRecurrencePattern()))
{
exeption1Appointment = GenericComObjectWrapper.Create (r.Inner.Exceptions[1].AppointmentItem);
exeption2Appointment = GenericComObjectWrapper.Create (r.Inner.Exceptions[2].AppointmentItem);
}
Assert.That (masterEvent.Start.Value, Is.EqualTo (masterAppointment.Inner.Start));
Assert.That (exeption1Event.Start.Value, Is.EqualTo (exeption1Appointment.Inner.Start));
Assert.That (exeption2Event.Start.Value, Is.EqualTo (exeption2Appointment.Inner.Start));
}
}
async Task<AppointmentItemWrapper> GetOrNull (AppointmentId id)
{
try
{
var itemById =
await _outlookRepository.Get (
new[] { id },
NullLoadEntityLogger.Instance,
NullEventSynchronizationContext.Instance);
return itemById.FirstOrDefault ()?.Entity;
}
catch (COMException x) when (x.HResult == unchecked((int) 0x8004010F))
{
return null;
}
}
public Task HandleAsync(IDomainEvent <OrderAggregate, OrderId, OrderPaymentCompleted> domainEvent, ISagaContext sagaContext, CancellationToken cancellationToken)
{
completed = true;
Publish(new AppointmentCompletedCommand(AppointmentId.With(base.Id.Value)));
return(Task.CompletedTask);
}
public void AnnounceAppointmentDeleted (AppointmentId id)
{
_hashesById.Remove (id);
}
public async Task ScheduleAsync(AppointmentId appointmentId, DoctorId doctorId, PatientId patientId, DateTime requestedAppointmentAt, AppointmentDuration requestedAppointmentDuration,
CancellationToken cancellationToken = default)
{
if (requestedAppointmentAt < _systemClockService.UtcNow.DateTime)
{
throw new DomainValidationException("The appointment could not be scheduled because it occurs in the past.");
}
var doctor = await _doctorRepository.GetByIdAsync(doctorId, cancellationToken);
if (doctor == null)
{
throw new EntityNotFoundException("The requested doctor was not found.");
}
var patient = await _patientRepository.GetByIdAsync(patientId, cancellationToken);
if (patient == null)
{
throw new EntityNotFoundException("The requested patient was not found.");
}
// Does the requested appointment occur during the doctor's availability?
var doctorAvailabilities = await _doctorAvailabilityRepository.GetAllForDoctorAsync(doctorId, cancellationToken);
var doctorIsAvailable = doctorAvailabilities.Any(a =>
a.DayOfWeek == requestedAppointmentAt.DayOfWeek && // Occurs on an available day of the week
a.StartsAt <= requestedAppointmentAt.TimeOfDay && // After that day of the week's start time
a.EndsAt >= requestedAppointmentAt.TimeOfDay + requestedAppointmentDuration); // And ends before that day of the week's end time
if (!doctorIsAvailable)
{
throw new DomainValidationException("The appointment could not be scheduled because it is outside of the doctor's availability.");
}
// Determine if there are any scheduling conflicts.
// Algorithm description: Two time periods overlap if each one starts before the other one ends.
var doctorAppointments = await _appointmentRepository.GetAllUpcomingForDoctorAsync(doctorId, cancellationToken);
var doctorHasConflictingAppointment = doctorAppointments.Any(existingAppointment =>
requestedAppointmentAt < existingAppointment.AppointmentAt.Add(existingAppointment.AppointmentDuration) &&
existingAppointment.AppointmentAt < requestedAppointmentAt.Add(requestedAppointmentDuration));
if (doctorHasConflictingAppointment)
{
throw new DomainValidationException("The appointment could not be scheduled because the doctor has a conflicting appointment.");
}
var patientAppointments = await _appointmentRepository.GetAllUpcomingForPatientAsync(patientId, cancellationToken);
var patientHasConflictingAppointment = patientAppointments.Any(existingAppointment =>
requestedAppointmentAt < existingAppointment.AppointmentAt.Add(existingAppointment.AppointmentDuration) &&
existingAppointment.AppointmentAt < requestedAppointmentAt.Add(requestedAppointmentDuration));
if (patientHasConflictingAppointment)
{
throw new DomainValidationException("The appointment could not be scheduled because the patient has a conflicting appointment.");
}
var appointment = new Appointment(appointmentId, doctorId, patientId, requestedAppointmentAt, requestedAppointmentDuration);
await _appointmentRepository.CreateAsync(appointment, cancellationToken);
}
public void AnnounceAppointmentDeleted (AppointmentId id)
{
}
