public async Task ShouldGetAllCalendarEntryAttachmentsAsync() { // given var randomCalendarEntryAttachments = new List <CalendarEntryAttachment>(); for (var i = 0; i <= GetRandomNumber(); i++) { CalendarEntryAttachment randomCalendarEntryAttachment = await PostCalendarEntryAttachmentAsync(); randomCalendarEntryAttachments.Add(randomCalendarEntryAttachment); } List <CalendarEntryAttachment> inputCalendarEntryAttachments = randomCalendarEntryAttachments; List <CalendarEntryAttachment> expectedCalendarEntryAttachments = inputCalendarEntryAttachments; // when List <CalendarEntryAttachment> actualCalendarEntryAttachments = await this.otripleSApiBroker.GetAllCalendarEntryAttachmentsAsync(); // then foreach (CalendarEntryAttachment expectedCalendarEntryAttachment in expectedCalendarEntryAttachments) { CalendarEntryAttachment actualCalendarEntryAttachment = actualCalendarEntryAttachments.Single(studentAttachment => studentAttachment.CalendarEntryId == expectedCalendarEntryAttachment.CalendarEntryId); actualCalendarEntryAttachment.Should().BeEquivalentTo(expectedCalendarEntryAttachment); await DeleteCalendarEntryAttachmentAsync(actualCalendarEntryAttachment); } }
public async Task ShouldThrowDependencyExceptionOnAddWhenDbExceptionOccursAndLogItAsync() { // given CalendarEntryAttachment someCalendarEntryAttachment = CreateRandomCalendarEntryAttachment(); var databaseUpdateException = new DbUpdateException(); var expectedCalendarEntryAttachmentDependencyException = new CalendarEntryAttachmentDependencyException(databaseUpdateException); this.storageBrokerMock.Setup(broker => broker.InsertCalendarEntryAttachmentAsync(It.IsAny <CalendarEntryAttachment>())) .ThrowsAsync(databaseUpdateException); // when ValueTask <CalendarEntryAttachment> addCalendarEntryAttachmentTask = this.calendarEntryAttachmentService.AddCalendarEntryAttachmentAsync(someCalendarEntryAttachment); // then await Assert.ThrowsAsync <CalendarEntryAttachmentDependencyException>(() => addCalendarEntryAttachmentTask.AsTask()); this.storageBrokerMock.Verify(broker => broker.InsertCalendarEntryAttachmentAsync(It.IsAny <CalendarEntryAttachment>()), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedCalendarEntryAttachmentDependencyException))), Times.Once); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenCalendarEntryAttachmentIsNullAndLogItAsync() { // given CalendarEntryAttachment nullCalendarEntryAttachment = default; var nullCalendarEntryAttachmentException = new NullCalendarEntryAttachmentException(); var expectedCalendarEntryAttachmentValidationException = new CalendarEntryAttachmentValidationException(nullCalendarEntryAttachmentException); // when ValueTask <CalendarEntryAttachment> addCalendarEntryAttachmentTask = this.calendarEntryAttachmentService.AddCalendarEntryAttachmentAsync(nullCalendarEntryAttachment); // then await Assert.ThrowsAsync <CalendarEntryAttachmentValidationException>(() => addCalendarEntryAttachmentTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedCalendarEntryAttachmentValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertCalendarEntryAttachmentAsync(It.IsAny <CalendarEntryAttachment>()), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public ValueTask <CalendarEntryAttachment> AddCalendarEntryAttachmentAsync( CalendarEntryAttachment calendarEntryAttachment) => TryCatch(async() => { ValidateCalendarEntryAttachmentOnCreate(calendarEntryAttachment); return(await this.storageBroker.InsertCalendarEntryAttachmentAsync(calendarEntryAttachment)); });
public async void ShouldThrowValidationExceptionOnAddWhenAttachmentIdIsInvalidAndLogItAsync() { // given CalendarEntryAttachment randomCalendarEntryAttachment = CreateRandomCalendarEntryAttachment(); CalendarEntryAttachment inputCalendarEntryAttachment = randomCalendarEntryAttachment; inputCalendarEntryAttachment.AttachmentId = default; var invalidCalendarEntryAttachmentInputException = new InvalidCalendarEntryAttachmentException( parameterName: nameof(CalendarEntryAttachment.AttachmentId), parameterValue: inputCalendarEntryAttachment.AttachmentId); var expectedCalendarEntryAttachmentValidationException = new CalendarEntryAttachmentValidationException(invalidCalendarEntryAttachmentInputException); // when ValueTask <CalendarEntryAttachment> addCalendarEntryAttachmentTask = this.calendarEntryAttachmentService.AddCalendarEntryAttachmentAsync(inputCalendarEntryAttachment); // then await Assert.ThrowsAsync <CalendarEntryAttachmentValidationException>(() => addCalendarEntryAttachmentTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedCalendarEntryAttachmentValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertCalendarEntryAttachmentAsync(It.IsAny <CalendarEntryAttachment>()), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldAddCalendarEntryAttachmentAsync() { // given CalendarEntryAttachment randomCalendarEntryAttachment = CreateRandomCalendarEntryAttachment(); CalendarEntryAttachment inputCalendarEntryAttachment = randomCalendarEntryAttachment; CalendarEntryAttachment storageCalendarEntryAttachment = randomCalendarEntryAttachment; CalendarEntryAttachment expectedCalendarEntryAttachment = storageCalendarEntryAttachment; this.storageBrokerMock.Setup(broker => broker.InsertCalendarEntryAttachmentAsync(inputCalendarEntryAttachment)) .ReturnsAsync(storageCalendarEntryAttachment); // when CalendarEntryAttachment actualCalendarEntryAttachment = await this.calendarEntryAttachmentService.AddCalendarEntryAttachmentAsync(inputCalendarEntryAttachment); // then actualCalendarEntryAttachment.Should().BeEquivalentTo(expectedCalendarEntryAttachment); this.storageBrokerMock.Verify(broker => broker.InsertCalendarEntryAttachmentAsync(inputCalendarEntryAttachment), Times.Once); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldRetrieveCalendarEntryAttachmentById() { // given CalendarEntryAttachment randomCalendarEntryAttachment = CreateRandomCalendarEntryAttachment(); CalendarEntryAttachment storageCalendarEntryAttachment = randomCalendarEntryAttachment; CalendarEntryAttachment expectedCalendarEntryAttachment = storageCalendarEntryAttachment; this.storageBrokerMock.Setup(broker => broker.SelectCalendarEntryAttachmentByIdAsync( randomCalendarEntryAttachment.CalendarEntryId, randomCalendarEntryAttachment.AttachmentId)) .ReturnsAsync(randomCalendarEntryAttachment); // when CalendarEntryAttachment actualCalendarEntryAttachment = await this.calendarEntryAttachmentService.RetrieveCalendarEntryAttachmentByIdAsync( randomCalendarEntryAttachment.CalendarEntryId, randomCalendarEntryAttachment.AttachmentId); // then actualCalendarEntryAttachment.Should().BeEquivalentTo(expectedCalendarEntryAttachment); this.storageBrokerMock.Verify(broker => broker.SelectCalendarEntryAttachmentByIdAsync( randomCalendarEntryAttachment.CalendarEntryId, randomCalendarEntryAttachment.AttachmentId), Times.Once); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); }
private static void ValidateCalendarEntryAttachmentIsNull(CalendarEntryAttachment calendarEntryAttachment) { if (calendarEntryAttachment is null) { throw new NullCalendarEntryAttachmentException(); } }
private static void ValidateCalendarEntryAttachmentOnCreate(CalendarEntryAttachment calendarEntryAttachment) { ValidateCalendarEntryAttachmentIsNull(calendarEntryAttachment); ValidateCalendarEntryAttachmentIds( calendarEntryAttachment.CalendarEntryId, calendarEntryAttachment.AttachmentId); }
public ValueTask <CalendarEntryAttachment> RemoveCalendarEntryAttachmentByIdAsync( Guid calendarEntryId, Guid attachmentId) => TryCatch(async() => { ValidateCalendarEntryAttachmentIds(calendarEntryId, attachmentId); CalendarEntryAttachment maybeCalendarEntryAttachment = await this.storageBroker.SelectCalendarEntryAttachmentByIdAsync(calendarEntryId, attachmentId); ValidateStorageCalendarEntryAttachment(maybeCalendarEntryAttachment, calendarEntryId, attachmentId); return(await this.storageBroker.DeleteCalendarEntryAttachmentAsync(maybeCalendarEntryAttachment)); });
private static void ValidateStorageCalendarEntryAttachment( CalendarEntryAttachment storageCalendarEntryAttachment, Guid calendarEntryId, Guid attachmentId) { if (storageCalendarEntryAttachment is null) { throw new NotFoundCalendarEntryAttachmentException(calendarEntryId, attachmentId); } }
public async ValueTask <CalendarEntryAttachment> InsertCalendarEntryAttachmentAsync( CalendarEntryAttachment calendarEntryAttachment) { EntityEntry <CalendarEntryAttachment> calendarEntryAttachmentEntityEntry = await this.CalendarEntriesAttachments.AddAsync(calendarEntryAttachment); await this.SaveChangesAsync(); return(calendarEntryAttachmentEntityEntry.Entity); }
public async ValueTask <CalendarEntryAttachment> DeleteCalendarEntryAttachmentAsync( CalendarEntryAttachment calendarEntryAttachment) { EntityEntry <CalendarEntryAttachment> calendarEntryAttachmentEntityEntry = this.CalendarEntriesAttachments.Remove(calendarEntryAttachment); await this.SaveChangesAsync(); return(calendarEntryAttachmentEntityEntry.Entity); }
private static void ValidateCalendarEntryAttachmentOnAdd(CalendarEntryAttachment calendarEntryAttachment) { ValidateCalendarEntryAttachmentIsNull(calendarEntryAttachment); Validate( (Rule: IsInvalid(calendarEntryAttachment.AttachmentId), Parameter: nameof(CalendarEntryAttachment.AttachmentId)), (Rule: IsInvalid(calendarEntryAttachment.CalendarEntryId), Parameter: nameof(CalendarEntryAttachment.CalendarEntryId))); }
public async ValueTask <CalendarEntryAttachment> DeleteCalendarEntryAttachmentAsync( CalendarEntryAttachment calendarEntryAttachment) { using var broker = new StorageBroker(this.configuration); EntityEntry <CalendarEntryAttachment> calendarEntryAttachmentEntityEntry = broker.CalendarEntriesAttachments.Remove(entity: calendarEntryAttachment); await broker.SaveChangesAsync(); return(calendarEntryAttachmentEntityEntry.Entity); }
ShouldThrowValidationExceptionOnRemoveWhenStorageCalendarEntryAttachmentIsInvalidAndLogItAsync() { // given DateTimeOffset randomDateTime = GetRandomDateTime(); CalendarEntryAttachment randomCalendarEntryAttachment = CreateRandomCalendarEntryAttachment(randomDateTime); Guid inputAttachmentId = randomCalendarEntryAttachment.AttachmentId; Guid inputCalendarEntryId = randomCalendarEntryAttachment.CalendarEntryId; CalendarEntryAttachment nullStorageCalendarEntryAttachment = null; var notFoundCalendarEntryAttachmentException = new NotFoundCalendarEntryAttachmentException(inputCalendarEntryId, inputAttachmentId); var expectedCalendarEntryValidationException = new CalendarEntryAttachmentValidationException(notFoundCalendarEntryAttachmentException); this.storageBrokerMock.Setup(broker => broker.SelectCalendarEntryAttachmentByIdAsync(inputCalendarEntryId, inputAttachmentId)) .ReturnsAsync(nullStorageCalendarEntryAttachment); // when ValueTask <CalendarEntryAttachment> removeCalendarEntryAttachmentTask = this.calendarEntryAttachmentService.RemoveCalendarEntryAttachmentByIdAsync(inputCalendarEntryId, inputAttachmentId); // then await Assert.ThrowsAsync <CalendarEntryAttachmentValidationException>(() => removeCalendarEntryAttachmentTask.AsTask()); this.storageBrokerMock.Verify(broker => broker.SelectCalendarEntryAttachmentByIdAsync(It.IsAny <Guid>(), It.IsAny <Guid>()), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedCalendarEntryValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.DeleteCalendarEntryAttachmentAsync(It.IsAny <CalendarEntryAttachment>()), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldRemoveCalendarEntryAttachmentAsync() { // given var randomCalendarEntryId = Guid.NewGuid(); var randomAttachmentId = Guid.NewGuid(); Guid inputCalendarEntryId = randomCalendarEntryId; Guid inputAttachmentId = randomAttachmentId; CalendarEntryAttachment randomCalendarEntryAttachment = CreateRandomCalendarEntryAttachment(); randomCalendarEntryAttachment.CalendarEntryId = inputCalendarEntryId; randomCalendarEntryAttachment.AttachmentId = inputAttachmentId; CalendarEntryAttachment storageCalendarEntryAttachment = randomCalendarEntryAttachment; CalendarEntryAttachment expectedCalendarEntryAttachment = storageCalendarEntryAttachment; this.storageBrokerMock.Setup(broker => broker.SelectCalendarEntryAttachmentByIdAsync(inputCalendarEntryId, inputAttachmentId)) .ReturnsAsync(storageCalendarEntryAttachment); this.storageBrokerMock.Setup(broker => broker.DeleteCalendarEntryAttachmentAsync(storageCalendarEntryAttachment)) .ReturnsAsync(expectedCalendarEntryAttachment); // when CalendarEntryAttachment actualCalendarEntryAttachment = await this.calendarEntryAttachmentService.RemoveCalendarEntryAttachmentByIdAsync( inputCalendarEntryId, inputAttachmentId); // then actualCalendarEntryAttachment.Should().BeEquivalentTo(expectedCalendarEntryAttachment); this.storageBrokerMock.Verify(broker => broker.SelectCalendarEntryAttachmentByIdAsync(inputCalendarEntryId, inputAttachmentId), Times.Once); this.storageBrokerMock.Verify(broker => broker.DeleteCalendarEntryAttachmentAsync(storageCalendarEntryAttachment), Times.Once); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenReferneceExceptionAndLogItAsync() { // given CalendarEntryAttachment randomCalendarEntryAttachment = CreateRandomCalendarEntryAttachment(); CalendarEntryAttachment someCalendarEntryAttachment = randomCalendarEntryAttachment; string randomMessage = GetRandomMessage(); string exceptionMessage = randomMessage; var foreignKeyConstraintConflictException = new ForeignKeyConstraintConflictException(exceptionMessage); var invalidCalendarEntryAttachmentReferenceException = new InvalidCalendarEntryAttachmentReferenceException(foreignKeyConstraintConflictException); var expectedCalendarEntryAttachmentValidationException = new CalendarEntryAttachmentValidationException(invalidCalendarEntryAttachmentReferenceException); this.storageBrokerMock.Setup(broker => broker.InsertCalendarEntryAttachmentAsync(someCalendarEntryAttachment)) .ThrowsAsync(foreignKeyConstraintConflictException); // when ValueTask <CalendarEntryAttachment> addCalendarEntryAttachmentTask = this.calendarEntryAttachmentService.AddCalendarEntryAttachmentAsync(someCalendarEntryAttachment); // then await Assert.ThrowsAsync <CalendarEntryAttachmentValidationException>(() => addCalendarEntryAttachmentTask.AsTask()); this.storageBrokerMock.Verify(broker => broker.InsertCalendarEntryAttachmentAsync(It.IsAny <CalendarEntryAttachment>()), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedCalendarEntryAttachmentValidationException))), Times.Once); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenCalendarEntryAttachmentAlreadyExistsAndLogItAsync() { // given CalendarEntryAttachment randomCalendarEntryAttachment = CreateRandomCalendarEntryAttachment(); CalendarEntryAttachment alreadyExistsCalendarEntryAttachment = randomCalendarEntryAttachment; string randomMessage = GetRandomMessage(); string exceptionMessage = randomMessage; var duplicateKeyException = new DuplicateKeyException(exceptionMessage); var alreadyExistsCalendarEntryAttachmentException = new AlreadyExistsCalendarEntryAttachmentException(duplicateKeyException); var expectedCalendarEntryAttachmentValidationException = new CalendarEntryAttachmentValidationException(alreadyExistsCalendarEntryAttachmentException); this.storageBrokerMock.Setup(broker => broker.InsertCalendarEntryAttachmentAsync(alreadyExistsCalendarEntryAttachment)) .ThrowsAsync(duplicateKeyException); // when ValueTask <CalendarEntryAttachment> addCalendarEntryAttachmentTask = this.calendarEntryAttachmentService.AddCalendarEntryAttachmentAsync(alreadyExistsCalendarEntryAttachment); // then await Assert.ThrowsAsync <CalendarEntryAttachmentValidationException>(() => addCalendarEntryAttachmentTask.AsTask()); this.storageBrokerMock.Verify(broker => broker.InsertCalendarEntryAttachmentAsync(It.IsAny <CalendarEntryAttachment>()), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedCalendarEntryAttachmentValidationException))), Times.Once); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldPostCalendarEntryAttachmentAsync() { // given CalendarEntryAttachment randomCalendarEntryAttachment = await CreateRandomCalendarEntryAttachment(); CalendarEntryAttachment inputCalendarEntryAttachment = randomCalendarEntryAttachment; CalendarEntryAttachment expectedCalendarEntryAttachment = inputCalendarEntryAttachment; // when CalendarEntryAttachment actualCalendarEntryAttachment = await this.otripleSApiBroker.PostCalendarEntryAttachmentAsync(inputCalendarEntryAttachment); CalendarEntryAttachment retrievedCalendarEntryAttachment = await this.otripleSApiBroker.GetCalendarEntryAttachmentByIdsAsync( inputCalendarEntryAttachment.CalendarEntryId, inputCalendarEntryAttachment.AttachmentId); // then actualCalendarEntryAttachment.Should().BeEquivalentTo(expectedCalendarEntryAttachment); retrievedCalendarEntryAttachment.Should().BeEquivalentTo(expectedCalendarEntryAttachment); await DeleteCalendarEntryAttachmentAsync(actualCalendarEntryAttachment); }
public async void ShouldThrowValidationExceptionOnAddWhenCalendarEntryAttachmentIsInvalidAndLogItAsync() { // given var invalidCalendarEntryAttachment = new CalendarEntryAttachment(); var invalidCalendarEntryAttachmentInputException = new InvalidCalendarEntryAttachmentException(); invalidCalendarEntryAttachmentInputException.AddData( key: nameof(CalendarEntryAttachment.AttachmentId), values: "Id is required"); invalidCalendarEntryAttachmentInputException.AddData( key: nameof(CalendarEntryAttachment.CalendarEntryId), values: "Id is required"); var expectedCalendarEntryAttachmentValidationException = new CalendarEntryAttachmentValidationException(invalidCalendarEntryAttachmentInputException); // when ValueTask <CalendarEntryAttachment> addCalendarEntryAttachmentTask = this.calendarEntryAttachmentService.AddCalendarEntryAttachmentAsync(invalidCalendarEntryAttachment); // then await Assert.ThrowsAsync <CalendarEntryAttachmentValidationException>(() => addCalendarEntryAttachmentTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameValidationExceptionAs( expectedCalendarEntryAttachmentValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertCalendarEntryAttachmentAsync(It.IsAny <CalendarEntryAttachment>()), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldDeleteCalendarEntryAttachmentAsync() { // given CalendarEntryAttachment randomCalendarEntryAttachment = await PostCalendarEntryAttachmentAsync(); CalendarEntryAttachment inputCalendarEntryAttachment = randomCalendarEntryAttachment; CalendarEntryAttachment expectedCalendarEntryAttachment = inputCalendarEntryAttachment; // when CalendarEntryAttachment deletedCalendarEntryAttachment = await DeleteCalendarEntryAttachmentAsync(inputCalendarEntryAttachment); ValueTask <CalendarEntryAttachment> getCalendarEntryAttachmentByIdTask = this.otripleSApiBroker.GetCalendarEntryAttachmentByIdsAsync( inputCalendarEntryAttachment.CalendarEntryId, inputCalendarEntryAttachment.AttachmentId); // then deletedCalendarEntryAttachment.Should().BeEquivalentTo(expectedCalendarEntryAttachment); await Assert.ThrowsAsync <HttpResponseNotFoundException>(() => getCalendarEntryAttachmentByIdTask.AsTask()); }
public async ValueTask <CalendarEntryAttachment> PostCalendarEntryAttachmentAsync(CalendarEntryAttachment calendarEntryAttachment) => await this.apiFactoryClient.PostContentAsync(CalendarEntryAttachmentsRelativeUrl, calendarEntryAttachment);
private void btnSave_Click(object sender, EventArgs e) { Building selectedBuilding = null; if (String.IsNullOrWhiteSpace(cbEvent.Text) || String.IsNullOrWhiteSpace(tbVenue.Text) ) { Controller.HandleError("Please complete all fields", "Validation Error"); return; } if (rbFinancial.Checked) { selectedBuilding = (cbBuilding.SelectedItem as Building); if (selectedBuilding == null) { Controller.HandleError("Building required", "Validation Error"); return; } } var minTime = new TimeSpan(05, 00, 00); var maxTime = new TimeSpan(23, 59, 00); if (dtpEventTime.Value.TimeOfDay < minTime || dtpEventTime.Value.TimeOfDay > maxTime) { Controller.HandleError("Event time must be > 05:00 and < 23:59", "Validation Error"); return; } if (dtpEventToTime.Value.TimeOfDay < minTime || dtpEventToTime.Value.TimeOfDay > maxTime) { Controller.HandleError("Event time must be > 05:00 and < 23:59", "Validation Error"); return; } if (dtpEventDate.Value.Date < DateTime.Today) { Controller.HandleError("Cannot schedule an event in the past.", "Validation Error"); return; } if (!string.IsNullOrWhiteSpace(tbBCC.Text)) { if (!tbBCC.Text.Contains("@") || !tbBCC.Text.Contains(".")) { Controller.HandleError("BCC not a valid email address.", "Validation Error"); return; } } DateTime fromDate = dtpEventDate.Value.Date + dtpEventTime.Value.TimeOfDay; DateTime toDate = dtpEventToDate.Value.Date + dtpEventToTime.Value.TimeOfDay; if (fromDate >= toDate) { Controller.HandleError("To Date/Time cannot be more than the From Date/Time.", "Validation Error"); return; } using (var context = SqlDataHandler.GetDataContext()) { BuildingCalendarEntry editItem = null; if (_Item == null) { editItem = new BuildingCalendarEntry(); context.BuildingCalendarEntrySet.Add(editItem); } else { editItem = context.BuildingCalendarEntrySet.Include(a => a.UserInvites).Single(a => a.id == _Item.id); foreach (var itm in editItem.UserInvites.ToList()) { context.CalendarUserInviteSet.Remove(itm); } } if (selectedBuilding != null) { editItem.BuildingId = selectedBuilding.ID; } else { editItem.BuildingId = null; } if (rbStaff.Checked) { editItem.CalendarEntryType = CalendarEntryType.Staff; } else { editItem.CalendarEntryType = CalendarEntryType.Financial; } if (rbFinancial.Checked) { var pm = (from b in context.tblBuildings join u in context.tblUsers on b.pm equals u.email where b.id == editItem.BuildingId select u).SingleOrDefault(); if (pm != null) { editItem.UserId = pm.id; } else if (editItem.id == 0) { editItem.UserId = Controller.user.id; } editItem.UserInvites = new List <CalendarUserInvite>(); } else { editItem.UserId = Controller.user.id; editItem.UserInvites = new List <CalendarUserInvite>(); foreach (var checkedItem in cbUserInvites.CheckedItems) { var usr = (tblUser)checkedItem; editItem.UserInvites.Add(new CalendarUserInvite() { CalendarEntry = editItem, UserId = usr.id }); } } editItem.EntryDate = fromDate; editItem.EventToDate = toDate; editItem.Event = cbEvent.Text; editItem.Venue = tbVenue.Text; editItem.NotifyTrustees = cbNotifyTrustees.Checked; editItem.InviteSubject = tbSubject.Text; editItem.BCCEmailAddress = tbBCC.Text; editItem.InviteBody = tbBodyContent.Text; if (cbRoom.SelectedItem != null) { editItem.MeetingRoomId = (cbRoom.SelectedItem as IdValue).Id; } else { editItem.MeetingRoomId = null; } if (CheckDoubleBooking(context, editItem)) { return; } //check for attachments if (_FileToLoad != null) { CalendarEntryAttachment fileItem = null; if (editItem.id > 0) { fileItem = context.CalendarEntryAttachmentSet.Where(a => a.BuildingCalendarEntryId == editItem.id).FirstOrDefault(); } if (fileItem == null) { fileItem = new CalendarEntryAttachment() { CalendarEntry = editItem }; context.CalendarEntryAttachmentSet.Add(fileItem); } fileItem.FileData = _FileToLoad; fileItem.FileName = tbAttachment.Text; } context.SaveChanges(); } LoadGrid(); }