Exemplo n.º 1
0
        public void GivenCurrentUserIsKnown_WhenAccessingFaceToFaceCommunicationWithOwner_ThenOwnerSecurityTokenIsApplied()
        {
            Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("user"), new string[0]);

            var user = new PersonBuilder(this.DatabaseSession).WithLastName("user").WithUserName("user").Build();

            var owner = new PersonBuilder(this.DatabaseSession).WithLastName("owner").Build();
            var participant1 = new PersonBuilder(this.DatabaseSession).WithLastName("participant1").Build();
            var participant2 = new PersonBuilder(this.DatabaseSession).WithLastName("participant2").Build();

            this.DatabaseSession.Derive(true);
            this.DatabaseSession.Commit();

            var communication = new FaceToFaceCommunicationBuilder(this.DatabaseSession)
                .WithOwner(owner)
                .WithSubject("subject")
                .WithParticipant(participant1)
                .WithParticipant(participant2)
                .WithActualStart(DateTime.UtcNow)
                .Build();

            this.DatabaseSession.Derive(true);

            Assert.AreEqual(2, communication.SecurityTokens.Count);
            Assert.Contains(Singleton.Instance(this.DatabaseSession).DefaultSecurityToken, communication.SecurityTokens);
            Assert.Contains(owner.OwnerSecurityToken, communication.SecurityTokens);
        }
Exemplo n.º 2
0
        public void GivenCommunication_WhenPartiesChange_ThenPartiesAreUpdated()
        {
            var owner        = new PersonBuilder(this.Session).WithLastName("owner").Build();
            var participant1 = new PersonBuilder(this.Session).WithLastName("participant1").Build();
            var participant2 = new PersonBuilder(this.Session).WithLastName("participant1").Build();
            var organisation = new OrganisationBuilder(this.Session).WithName("organisation").Build();
            var contact      = new PersonBuilder(this.Session).WithLastName("participant1").Build();

            new OrganisationContactRelationshipBuilder(this.Session).WithContact(contact).WithOrganisation(organisation).Build();

            var communication = new FaceToFaceCommunicationBuilder(this.Session)
                                .WithOwner(owner)
                                .WithFromParty(participant1)
                                .WithToParty(contact)
                                .WithSubject("Hello")
                                .WithActualStart(this.Session.Now())
                                .Build();

            this.Session.Derive();

            Assert.Equal(4, communication.InvolvedParties.Count);
            Assert.Contains(owner, communication.InvolvedParties);
            Assert.Contains(participant1, communication.InvolvedParties);
            Assert.Contains(contact, communication.InvolvedParties);
            Assert.Contains(organisation, communication.InvolvedParties);

            communication.ToParty = participant2;

            this.Session.Derive();

            Assert.Equal(3, communication.InvolvedParties.Count);
            Assert.Contains(owner, communication.InvolvedParties);
            Assert.Contains(participant1, communication.InvolvedParties);
            Assert.Contains(participant2, communication.InvolvedParties);
        }
Exemplo n.º 3
0
        public void GivenCommunicationToOrganisation_WhenDerived_ThenCommunicationEventIsAddedToEachParty()
        {
            var owner        = new PersonBuilder(this.Session).WithLastName("owner").Build();
            var participant  = new PersonBuilder(this.Session).WithLastName("participant1").Build();
            var organisation = new OrganisationBuilder(this.Session).WithName("organisation").Build();
            var contact      = new PersonBuilder(this.Session).WithLastName("participant1").Build();

            new OrganisationContactRelationshipBuilder(this.Session).WithContact(contact).WithOrganisation(organisation).Build();

            var communication = new FaceToFaceCommunicationBuilder(this.Session)
                                .WithOwner(owner)
                                .WithFromParty(participant)
                                .WithToParty(contact)
                                .WithSubject("Hello")
                                .WithActualStart(DateTime.UtcNow)
                                .Build();

            this.Session.Derive();

            Assert.Equal(4, communication.PartiesWhereCommunicationEvent.Count);
            Assert.Contains(owner, communication.PartiesWhereCommunicationEvent);
            Assert.Contains(participant, communication.PartiesWhereCommunicationEvent);
            Assert.Contains(contact, communication.PartiesWhereCommunicationEvent);
            Assert.Contains(organisation, communication.PartiesWhereCommunicationEvent);
        }
        public void GivenCurrentUserIsKnown_WhenAccessingFaceToFaceCommunicationWithOwner_ThenOwnerSecurityTokenIsApplied()
        {
            this.SetIdentity("user");

            var owner        = new PersonBuilder(this.Session).WithLastName("owner").Build();
            var participant1 = new PersonBuilder(this.Session).WithLastName("participant1").Build();
            var participant2 = new PersonBuilder(this.Session).WithLastName("participant2").Build();

            this.Session.Derive();
            this.Session.Commit();

            var communication = new FaceToFaceCommunicationBuilder(this.Session)
                                .WithOwner(owner)
                                .WithSubject("subject")
                                .WithFromParty(participant1)
                                .WithToParty(participant2)
                                .WithActualStart(DateTime.UtcNow)
                                .Build();

            this.Session.Derive();

            Assert.Equal(2, communication.SecurityTokens.Count);
            Assert.Contains(this.Session.GetSingleton().DefaultSecurityToken, communication.SecurityTokens);
            Assert.Contains(owner.OwnerSecurityToken, communication.SecurityTokens);
        }
        public void Edit()
        {
            var organisations = new Organisations(this.Session).Extent();
            var organisation  = organisations.First(v => v.PartyName.Equals("Acme0"));
            var contact       = organisation.CurrentContacts.First;

            var allors         = new Organisations(this.Session).FindBy(M.Organisation.Name, "Allors BVBA");
            var firstEmployee  = allors.ActiveEmployees.First(v => v.FirstName.Equals("first"));
            var secondEmployee = allors.ActiveEmployees.First(v => v.FirstName.Equals("second"));

            var editCommunicationEvent = new FaceToFaceCommunicationBuilder(this.Session)
                                         .WithSubject("dummy")
                                         .WithFromParty(organisation.CurrentContacts.First)
                                         .WithToParty(firstEmployee)
                                         .WithLocation("old location")
                                         .Build();

            this.Session.Derive();
            this.Session.Commit();

            var before = new FaceToFaceCommunications(this.Session).Extent().ToArray();

            var page = this.organisationListPage.Select(organisation).SelectFaceToFaceCommunication(editCommunicationEvent);

            page.EventState.Set(new CommunicationEventStates(this.Session).Completed.Name)
            .Purposes.Toggle(new CommunicationEventPurposes(this.Session).Conference.Name)
            .Location.Set("new location")
            .Subject.Set("new subject")
            .FromParty.Set(secondEmployee.PartyName)
            .ToParty.Set(contact.PartyName)
            .ScheduledStart.Set(DateTimeFactory.CreateDate(2018, 12, 24))
            .ScheduledEnd.Set(DateTimeFactory.CreateDate(2018, 12, 24))
            .ActualStart.Set(DateTimeFactory.CreateDate(2018, 12, 24))
            .ActualEnd.Set(DateTimeFactory.CreateDate(2018, 12, 24))
            .Save.Click();

            this.Driver.WaitForAngular();
            this.Session.Rollback();

            var after = new FaceToFaceCommunications(this.Session).Extent().ToArray();

            Assert.Equal(after.Length, before.Length);

            Assert.Equal(new CommunicationEventStates(this.Session).Completed, editCommunicationEvent.CommunicationEventState);
            Assert.Contains(new CommunicationEventPurposes(this.Session).Conference, editCommunicationEvent.EventPurposes);
            Assert.Equal(secondEmployee, editCommunicationEvent.FromParty);
            Assert.Equal(contact, editCommunicationEvent.ToParty);
            Assert.Equal("new location", editCommunicationEvent.Location);
            Assert.Equal("new subject", editCommunicationEvent.Subject);
            //Assert.Equal(DateTimeFactory.CreateDate(2018, 12, 24).Date, communicationEvent.ScheduledStart);
            //Assert.Equal(DateTimeFactory.CreateDate(2018, 12, 24).Date, communicationEvent.ScheduledEnd.Value.Date);
            //Assert.Equal(DateTimeFactory.CreateDate(2018, 12, 24).Date, communicationEvent.ActualStart.Value.Date);
            //Assert.Equal(DateTimeFactory.CreateDate(2018, 12, 24).Date, communicationEvent.ActualEnd.Value.Date);
        }
Exemplo n.º 6
0
        public void GivenCommunicationEvent_WhenInProgress_ThenCurrentObjectStateIsInProgress()
        {
            var communication = new FaceToFaceCommunicationBuilder(this.DatabaseSession)
                .WithParticipant(new PersonBuilder(this.DatabaseSession).WithLastName("participant1").Build())
                .WithParticipant(new PersonBuilder(this.DatabaseSession).WithLastName("participant2").Build())
                .WithSubject("Hello")
                .WithActualStart(DateTime.UtcNow)
                .Build();

            this.DatabaseSession.Derive(true);

            Assert.AreEqual(new CommunicationEventObjectStates(this.DatabaseSession).InProgress, communication.CurrentObjectState);
        }
Exemplo n.º 7
0
        public void GivenCommunicationEvent_WhenInPast_ThenCurrencObjectStateIsCompleted()
        {
            var communication = new FaceToFaceCommunicationBuilder(this.DatabaseSession)
                .WithParticipant(new PersonBuilder(this.DatabaseSession).WithLastName("participant1").Build())
                .WithParticipant(new PersonBuilder(this.DatabaseSession).WithLastName("participant2").Build())
                .WithSubject("Hello")
                .WithActualStart(DateTime.UtcNow.AddHours(-2))
                .WithActualEnd(DateTime.UtcNow.AddHours(-1))
                .Build();

            this.DatabaseSession.Derive(true);

            Assert.AreEqual(new CommunicationEventObjectStates(this.DatabaseSession).Completed, communication.CurrentObjectState);
        }
Exemplo n.º 8
0
        public void GivenCommunicationEvent_WhenInProgress_ThenCurrentObjectStateIsInProgress()
        {
            var communication = new FaceToFaceCommunicationBuilder(this.Session)
                                .WithOwner(new PersonBuilder(this.Session).WithLastName("owner").Build())
                                .WithFromParty(new PersonBuilder(this.Session).WithLastName("participant1").Build())
                                .WithToParty(new PersonBuilder(this.Session).WithLastName("participant2").Build())
                                .WithSubject("Hello")
                                .WithActualStart(this.Session.Now())
                                .Build();

            this.Session.Derive();

            Assert.Equal(new CommunicationEventStates(this.Session).InProgress, communication.CommunicationEventState);
        }
Exemplo n.º 9
0
        public void GivenCommunicationEvent_WhenInFuture_ThenCurrencObjectStateIsScheduled()
        {
            var communication = new FaceToFaceCommunicationBuilder(this.Session)
                                .WithOwner(new PersonBuilder(this.Session).WithLastName("owner").Build())
                                .WithFromParty(new PersonBuilder(this.Session).WithLastName("participant1").Build())
                                .WithToParty(new PersonBuilder(this.Session).WithLastName("participant2").Build())
                                .WithSubject("Hello")
                                .WithActualStart(this.Session.Now().AddHours(+1))
                                .WithActualEnd(this.Session.Now().AddHours(+2))
                                .Build();

            this.Session.Derive();

            Assert.Equal(new CommunicationEventStates(this.Session).Scheduled, communication.CommunicationEventState);
        }
Exemplo n.º 10
0
        public void GivenCommunicationEvent_WhenInPast_ThenCurrencObjectStateIsCompleted()
        {
            var communication = new FaceToFaceCommunicationBuilder(this.Session)
                                .WithOwner(new PersonBuilder(this.Session).WithLastName("owner").Build())
                                .WithFromParty(new PersonBuilder(this.Session).WithLastName("participant1").Build())
                                .WithToParty(new PersonBuilder(this.Session).WithLastName("participant2").Build())
                                .WithSubject("Hello")
                                .WithActualStart(DateTime.UtcNow.AddHours(-2))
                                .WithActualEnd(DateTime.UtcNow.AddHours(-1))
                                .Build();

            this.Session.Derive();

            Assert.Equal(new CommunicationEventStates(this.Session).Completed, communication.CommunicationEventState);
        }
Exemplo n.º 11
0
        public void GivenFaceToFaceCommunicationIsBuild_WhenDeriving_ThenStatusIsSet()
        {
            var communication = new FaceToFaceCommunicationBuilder(this.Session)
                                .WithOwner(new PersonBuilder(this.Session).WithLastName("owner").Build())
                                .WithSubject("subject")
                                .WithFromParty(new PersonBuilder(this.Session).WithLastName("participant1").Build())
                                .WithToParty(new PersonBuilder(this.Session).WithLastName("participant2").Build())
                                .WithActualStart(DateTime.UtcNow)
                                .Build();

            Assert.False(this.Session.Derive(false).HasErrors);

            Assert.Equal(communication.CommunicationEventState, new CommunicationEventStates(this.Session).InProgress);
            Assert.Equal(communication.CommunicationEventState, communication.LastCommunicationEventState);
        }
Exemplo n.º 12
0
        public static FaceToFaceCommunicationBuilder WithDefaults(this FaceToFaceCommunicationBuilder @this, Organisation internalOrganisation)
        {
            var faker = @this.Session.Faker();

            var administrator = (Person) new UserGroups(@this.Session).Administrators.Members.First;

            @this.WithDescription(faker.Lorem.Sentence(20));
            @this.WithSubject(faker.Lorem.Sentence(5));
            @this.WithEventPurpose(new CommunicationEventPurposes(@this.Session).Meeting);
            @this.WithFromParty(internalOrganisation.ActiveEmployees.First);
            @this.WithToParty(internalOrganisation.ActiveCustomers.First);
            @this.WithOwner(administrator);
            @this.WithActualStart(DateTime.UtcNow);

            return(@this);
        }
Exemplo n.º 13
0
        public void GivenCurrentUserIsUnknown_WhenAccessingFaceToFaceCommunicationWithoutOwner_ThenDefaultSecurityTokenIsApplied()
        {
            var participant1 = new PersonBuilder(this.DatabaseSession).WithLastName("participant1").Build();
            var participant2 = new PersonBuilder(this.DatabaseSession).WithLastName("participant2").Build();

            this.DatabaseSession.Derive(true);
            this.DatabaseSession.Commit();

            var communication = new FaceToFaceCommunicationBuilder(this.DatabaseSession)
                .WithSubject("subject")
                .WithParticipant(participant1)
                .WithParticipant(participant2)
                .WithActualStart(DateTime.UtcNow)
                .Build();

            this.DatabaseSession.Derive(true);

            Assert.AreEqual(1, communication.SecurityTokens.Count);
            Assert.Contains(Singleton.Instance(this.DatabaseSession).DefaultSecurityToken, communication.SecurityTokens);
        }
Exemplo n.º 14
0
        public void GivenFaceToFaceCommunication_WhenConfirmed_ThenCurrentCommunicationEventStatusMustBeDerived()
        {
            var communication = new FaceToFaceCommunicationBuilder(this.Session)
                                .WithOwner(new PersonBuilder(this.Session).WithLastName("owner").Build())
                                .WithFromParty(new PersonBuilder(this.Session).WithLastName("participant1").Build())
                                .WithToParty(new PersonBuilder(this.Session).WithLastName("participant2").Build())
                                .WithSubject("Hello")
                                .WithActualStart(this.Session.Now())
                                .Build();

            this.Session.Derive();

            Assert.Equal(new CommunicationEventStates(this.Session).InProgress, communication.CommunicationEventState);

            communication.Close();

            this.Session.Derive();

            Assert.Equal(new CommunicationEventStates(this.Session).Completed, communication.CommunicationEventState);
        }
Exemplo n.º 15
0
        public void GivenCommunication_WhenDerived_ThenCommunicationEventIsAddedToEachParty()
        {
            var owner        = new PersonBuilder(this.Session).WithLastName("owner").Build();
            var participant1 = new PersonBuilder(this.Session).WithLastName("participant1").Build();
            var participant2 = new PersonBuilder(this.Session).WithLastName("participant2").Build();

            var communication = new FaceToFaceCommunicationBuilder(this.Session)
                                .WithOwner(owner)
                                .WithFromParty(participant1)
                                .WithToParty(participant2)
                                .WithSubject("Hello")
                                .WithActualStart(this.Session.Now())
                                .Build();

            this.Session.Derive();

            Assert.Equal(3, communication.InvolvedParties.Count);
            Assert.Contains(owner, communication.InvolvedParties);
            Assert.Contains(participant1, communication.InvolvedParties);
            Assert.Contains(participant2, communication.InvolvedParties);
        }
Exemplo n.º 16
0
        public void GivenFaceToFaceCommunication_WhenDeriving_ThenInvolvedPartiesAreDerived()
        {
            var owner        = new PersonBuilder(this.Session).WithLastName("owner").Build();
            var participant1 = new PersonBuilder(this.Session).WithLastName("participant1").Build();
            var participant2 = new PersonBuilder(this.Session).WithLastName("participant2").Build();

            this.Session.Derive();
            this.Session.Commit();

            var communication = new FaceToFaceCommunicationBuilder(this.Session)
                                .WithOwner(owner)
                                .WithSubject("subject")
                                .WithFromParty(participant1)
                                .WithToParty(participant2)
                                .WithActualStart(DateTime.UtcNow)
                                .Build();

            this.Session.Derive();

            Assert.Equal(3, communication.InvolvedParties.Count);
            Assert.Contains(participant1, communication.InvolvedParties);
            Assert.Contains(participant2, communication.InvolvedParties);
            Assert.Contains(owner, communication.InvolvedParties);
        }
        public void Edit()
        {
            var faker    = this.Session.Faker();
            var subject  = faker.Lorem.Sentence();
            var location = faker.Address.FullAddress();

            var person = new People(this.Session).Extent().First;

            var allors         = new Organisations(this.Session).FindBy(M.Organisation.Name, "Allors BVBA");
            var firstEmployee  = allors.ActiveEmployees.First();
            var secondEmployee = allors.ActiveEmployees.Last();

            var editCommunicationEvent = new FaceToFaceCommunicationBuilder(this.Session)
                                         .WithSubject(subject)
                                         .WithFromParty(person)
                                         .WithToParty(firstEmployee)
                                         .WithLocation(location)
                                         .Build();

            this.Session.Derive();
            this.Session.Commit();

            var before = new FaceToFaceCommunications(this.Session).Extent().ToArray();

            this.personListPage.Table.DefaultAction(person);
            var personOverview = new PersonOverviewComponent(this.personListPage.Driver);

            var communicationEventOverview = personOverview.CommunicationeventOverviewPanel.Click();

            communicationEventOverview.Table.DefaultAction(editCommunicationEvent);

            var faceToFaceCommunicationEditComponent = new FaceToFaceCommunicationEditComponent(this.Driver);

            var scheduleStartDate = DateTimeFactory.CreateDate(2018, 12, 24);
            var scheduleEndDate   = DateTimeFactory.CreateDate(2018, 12, 24);
            var actualStartDate   = DateTimeFactory.CreateDate(2018, 12, 24);
            var actualEndDate     = DateTimeFactory.CreateDate(2018, 12, 24);

            faceToFaceCommunicationEditComponent
            .CommunicationEventState.Select(new CommunicationEventStates(this.Session).Completed)
            .EventPurposes.Toggle(new CommunicationEventPurposes(this.Session).Conference)
            .Subject.Set(subject)
            .Location.Set(location)
            .FromParty.Select(secondEmployee)
            .ToParty.Select(person)
            .ScheduledStart.Set(scheduleStartDate)
            .ScheduledEnd.Set(scheduleEndDate)
            .ActualStart.Set(actualStartDate)
            .ActualEnd.Set(actualEndDate)
            .SAVE.Click();

            this.Driver.WaitForAngular();
            this.Session.Rollback();

            var after = new FaceToFaceCommunications(this.Session).Extent().ToArray();

            Assert.Equal(after.Length, before.Length);

            Assert.Equal(new CommunicationEventStates(this.Session).Completed, editCommunicationEvent.CommunicationEventState);
            Assert.Contains(new CommunicationEventPurposes(this.Session).Conference, editCommunicationEvent.EventPurposes);
            Assert.Equal(secondEmployee, editCommunicationEvent.FromParty);
            Assert.Equal(person, editCommunicationEvent.ToParty);
            Assert.Equal(subject, editCommunicationEvent.Subject);
            Assert.Equal(location, editCommunicationEvent.Location);
            Assert.Equal(scheduleStartDate.Date, editCommunicationEvent.ScheduledStart.Value.Date);
            Assert.Equal(scheduleEndDate.Date, editCommunicationEvent.ScheduledEnd.Value.Date);
            Assert.Equal(actualStartDate.Date, editCommunicationEvent.ActualStart.Value.Date);
            Assert.Equal(actualEndDate.Date, editCommunicationEvent.ActualEnd.Value.Date);
        }
Exemplo n.º 18
0
        public void GivenFaceToFaceCommunication_WhenDeriving_ThenInvolvedPartiesAreDerived()
        {
            var owner = new PersonBuilder(this.DatabaseSession).WithLastName("owner").Build();
            var participant1 = new PersonBuilder(this.DatabaseSession).WithLastName("participant1").Build();
            var participant2 = new PersonBuilder(this.DatabaseSession).WithLastName("participant2").Build();

            this.DatabaseSession.Derive(true);
            this.DatabaseSession.Commit();

            var communication = new FaceToFaceCommunicationBuilder(this.DatabaseSession)
                .WithOwner(owner)
                .WithSubject("subject")
                .WithParticipant(participant1)
                .WithParticipant(participant2)
                .WithActualStart(DateTime.UtcNow)
                .Build();

            this.DatabaseSession.Derive(true);

            Assert.AreEqual(3, communication.InvolvedParties.Count);
            Assert.Contains(participant1, communication.InvolvedParties);
            Assert.Contains(participant2, communication.InvolvedParties);
            Assert.Contains(owner, communication.InvolvedParties);

            communication.AddParticipant(owner);

            this.DatabaseSession.Derive(true);

            Assert.AreEqual(3, communication.InvolvedParties.Count);
        }
Exemplo n.º 19
0
        public void GivenFaceToFaceCommunicationIsBuild_WhenDeriving_ThenStatusIsSet()
        {
            var communication = new FaceToFaceCommunicationBuilder(this.DatabaseSession)
                .WithOwner(new PersonBuilder(this.DatabaseSession).WithLastName("owner").Build())
                .WithSubject("subject")
                .WithParticipant(new PersonBuilder(this.DatabaseSession).WithLastName("participant1").Build())
                .WithParticipant(new PersonBuilder(this.DatabaseSession).WithLastName("participant2").Build())
                .WithActualStart(DateTime.UtcNow)
                .Build();

            Assert.IsFalse(this.DatabaseSession.Derive().HasErrors);

            Assert.AreEqual(communication.CurrentCommunicationEventStatus.CommunicationEventObjectState, new CommunicationEventObjectStates(this.DatabaseSession).InProgress);
            Assert.AreEqual(communication.CurrentObjectState, new CommunicationEventObjectStates(this.DatabaseSession).InProgress);
            Assert.AreEqual(communication.CurrentObjectState, communication.LastObjectState);
        }
Exemplo n.º 20
0
        public void GivenFaceToFaceCommunication_WhenConfirmed_ThenCurrentCommunicationEventStatusMustBeDerived()
        {
            var communication = new FaceToFaceCommunicationBuilder(this.DatabaseSession)
                .WithParticipant(new PersonBuilder(this.DatabaseSession).WithLastName("participant1").Build())
                .WithParticipant(new PersonBuilder(this.DatabaseSession).WithLastName("participant2").Build())
                .WithSubject("Hello")
                .WithActualStart(DateTime.UtcNow)
                .Build();

            this.DatabaseSession.Derive(true);

            Assert.AreEqual(1, communication.CommunicationEventStatuses.Count);
            Assert.AreEqual(new CommunicationEventObjectStates(this.DatabaseSession).InProgress, communication.CurrentCommunicationEventStatus.CommunicationEventObjectState);

            communication.Close();

            this.DatabaseSession.Derive(true);

            Assert.AreEqual(2, communication.CommunicationEventStatuses.Count);
            Assert.AreEqual(new CommunicationEventObjectStates(this.DatabaseSession).Completed, communication.CurrentCommunicationEventStatus.CommunicationEventObjectState);
        }
        public void Edit()
        {
            var allors        = new Organisations(this.Session).FindBy(M.Organisation.Name, "Allors BVBA");
            var firstEmployee = allors.ActiveEmployees.First();

            var secondEmployee = allors.CreateEmployee("letmein", this.Session.Faker()); //second employee

            this.Session.Derive();

            var organisation = allors.ActiveCustomers.First(v => v.GetType().Name == typeof(Organisation).Name);
            var contact      = organisation.CurrentContacts.First;

            var editCommunicationEvent = new FaceToFaceCommunicationBuilder(this.Session)
                                         .WithSubject("dummy")
                                         .WithFromParty(organisation.CurrentContacts.First)
                                         .WithToParty(firstEmployee)
                                         .WithLocation("old location")
                                         .Build();

            this.Session.Derive();
            this.Session.Commit();

            var before = new FaceToFaceCommunications(this.Session).Extent().ToArray();

            this.organisationListPage.Table.DefaultAction(organisation);
            var organisationOverview = new OrganisationOverviewComponent(this.organisationListPage.Driver);

            var communicationEventOverview = organisationOverview.CommunicationeventOverviewPanel.Click();

            communicationEventOverview.Table.DefaultAction(editCommunicationEvent);

            var faceToFaceCommunicationEdit = new FaceToFaceCommunicationEditComponent(organisationOverview.Driver);

            faceToFaceCommunicationEdit
            .CommunicationEventState.Select(new CommunicationEventStates(this.Session).Completed)
            .EventPurposes.Toggle(new CommunicationEventPurposes(this.Session).Conference)
            .Location.Set("new location")
            .Subject.Set("new subject")
            .FromParty.Select(secondEmployee)
            .ToParty.Select(contact)
            .ScheduledStart.Set(DateTimeFactory.CreateDate(2018, 12, 24))
            .ScheduledEnd.Set(DateTimeFactory.CreateDate(2018, 12, 24))
            .ActualStart.Set(DateTimeFactory.CreateDate(2018, 12, 24))
            .ActualEnd.Set(DateTimeFactory.CreateDate(2018, 12, 24))
            .SAVE.Click();

            this.Driver.WaitForAngular();
            this.Session.Rollback();

            var after = new FaceToFaceCommunications(this.Session).Extent().ToArray();

            Assert.Equal(after.Length, before.Length);

            Assert.Equal(new CommunicationEventStates(this.Session).Completed, editCommunicationEvent.CommunicationEventState);
            Assert.Contains(new CommunicationEventPurposes(this.Session).Conference, editCommunicationEvent.EventPurposes);
            Assert.Equal(secondEmployee, editCommunicationEvent.FromParty);
            Assert.Equal(contact, editCommunicationEvent.ToParty);
            Assert.Equal("new location", editCommunicationEvent.Location);
            Assert.Equal("new subject", editCommunicationEvent.Subject);
            Assert.Equal(DateTimeFactory.CreateDate(2018, 12, 24).Date, editCommunicationEvent.ScheduledStart);
            Assert.Equal(DateTimeFactory.CreateDate(2018, 12, 24).Date, editCommunicationEvent.ScheduledEnd.Value.Date);
            Assert.Equal(DateTimeFactory.CreateDate(2018, 12, 24).Date, editCommunicationEvent.ActualStart.Value.Date);
            Assert.Equal(DateTimeFactory.CreateDate(2018, 12, 24).Date, editCommunicationEvent.ActualEnd.Value.Date);
        }