public void NewInvocationContextIsConfiguredCorrectly()
 {
     var configuration = new DomainConfiguration();
     configuration.EnsureCommitted();
     var domainContext = new DomainContext(configuration);
     var context = new InvocationContext(domainContext);
     Assert.Same(domainContext, context.DomainContext);
 }

 private static IUnitOfWork ReinitializeDatabase(DomainContext dbContext)
 {
     // force to single_user so that we can drop the database in order to prevent this error: "database is currently in use ..."
     dbContext.Database.ExecuteSqlCommand(string.Format("ALTER DATABASE {0} SET SINGLE_USER WITH ROLLBACK IMMEDIATE", Fixture.DatabaseName));
     new DatabaseInitializer().InitializeDatabase(dbContext);
     return new UnitOfWork(dbContext);
 }

		public void WhenHandlerRegistered_ThenCanProcessEntity()
		{
			var id = Guid.NewGuid();
			var product = new Product(id, "DevStore");

			var context = default(IDomainContext);
			var eventStream = new EventStream();
			IDomainEventStore store = new ConsoleEventStore();

			// Keep the handlers so they are not GC'ed.
			var handlers = new object[]
			{ 
				new ConsoleHandler(eventStream), 
				new SendMailHandler(eventStream),
			};

			context = new DomainContext(eventStream, store);
			context.Save(product);

			// Save changes and cause publication of pending events 
			// in the newly created domain object.
			context.SaveChanges();

			Console.WriteLine();

			// Here some command might pull the product from the 
			// context, and invoke a domain method.
			var savedProduct = context.Find<Product>(id);
			product.Publish(1);

			// Saving again causes persistence of the entity state 
			// as well as publishing the events.
			context.SaveChanges();
		}

 public IEnumerable<Person> GetAll()
 {
     var context = new DomainContext(this.ConnectionString);
     return context.Persons.Include("AssignedSymptoms").Include("FirstPersonPersons");/*.Include("SecondPersonPersons").Include("PersonContacts").Include("AssignedRiskFactors")
         .Include("Credentials").Include("PersonGroups").Include("PersonOperations").Include("PersonDiseases").Include("PersonAllergicReactions")
         .Include("ConsultationsAsDoctor").Include("ConsultationsAsPatient").Include("PersonHospitalizations");*/
 }

        /// <summary>
        /// Creates a new DomainContext and starts its processors, using the previously applied configurations.
        /// </summary>
        /// <returns>A new DomainContext</returns>
        public IDomainContext Start()
        {
            if (this.Configuring != null)
            {
                this.Configuring(this);
            }

            var context = new DomainContext(this.EventStore.Value,
                                            new EventBus(this.MessageBus.Value),
                                            new CommandBus(this.MessageBus.Value),
                                            this.Processors.Value,
                                            this.LoggerFactory.Value,
                                            this.Resolver.Value);

            if (this.Configured != null)
            {
                this.Configured(context);
            }

            this.Configuring = null;
            this.Configured = null;

            context.StartProcessors();

            return context;
        }

 public IEnumerable<PersonConsultation> GetAll()
 {
     var context = new DomainContext(this.ConnectionString);
     return context.PersonConsultations.Include("Doctor").Include("Patient").Include("ConsultationType").Include("PersonConsultationResearches")
         .Include("PersonConsultationLabAnalyzes").Include("PersonConsultationSymptoms").Include("PersonConsultationComplaints")
         .Include("PersonConsultationMeasurings").Include("PersonConsultationDiagnosises").Include("AssignedMedicaments").Include("AssignedMeasurings");
 }

 public void Modify(DomainContext context)
 {
     EntitySet<MockUser> users = context.EntityContainer.GetEntitySet<MockUser>();
     if (!users.Contains(this))
     {
         users.Attach(this);
     }
     this.RaiseDataMemberChanging("MutableProperty");
     this.MutableProperty++;
     this.RaiseDataMemberChanged("MutableProperty");
 }

        public IEnumerable<HospitalDepartment> GetEntitiesByQuery(Func<HospitalDepartment, bool> query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }

            using (var context = new DomainContext(this.ConnectionString))
            {
                return context.HospitalDepartments.Include("Hospital").Include("PersonHospitalizations").Where(query).ToList();
            }
        }

        public static void ChangeSentTimeout(DomainContext aContext, TimeSpan aSendTimeout)
        {
            PropertyInfo lChangeFactoryProperty = aContext.DomainClient.GetType().GetProperty("ChannelFactory");
            if (lChangeFactoryProperty == null)
            {
                throw new InvalidOperationException("There is no ChannelFactory property on the DomainClient.");
            }

            ChannelFactory lFactory = (ChannelFactory)lChangeFactoryProperty.GetValue(aContext.DomainClient, null);
            lFactory.Endpoint.Binding.ReceiveTimeout = aSendTimeout;
            lFactory.Endpoint.Binding.ReceiveTimeout = aSendTimeout;
        }

        public IEnumerable<PersonConsultationLabAnalyze> GetEntitiesByQuery(Func<PersonConsultationLabAnalyze, bool> query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }

            using (var context = new DomainContext(this.ConnectionString))
            {
                return context.PersonConsultationLabAnalyzes.Include("LabAnalyzeType").Include("PersonConsultation").Where(query).ToList();
            }
        }

        public IEnumerable<AssignedRiskFactor> GetEntitiesByQuery(Func<AssignedRiskFactor, bool> query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }

            using (var context = new DomainContext(this.ConnectionString))
            {
                return context.AssignedRiskFactors.Include("Person").Include("RiskFactor").Where(query).ToList();
            }
        }

        public IEnumerable<OnceRiskFactorNotification> GetEntitiesByQuery(Func<OnceRiskFactorNotification, bool> query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }

            using (var context = new DomainContext(this.ConnectionString))
            {
                return context.OnceRiskFactorNotifications.Where(query).ToList();
            }
        }

        public IEnumerable<PersonAllergicReaction> GetEntitiesByQuery(Func<PersonAllergicReaction, bool> query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }

            using (var context = new DomainContext(this.ConnectionString))
            {
                return context.PersonAllergicReactions.Include("Person").Include("AllergicReaction").Where(query).ToList();
            }
        }

        public IEnumerable<Research> GetEntitiesByQuery(Func<Research, bool> query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }

            using (var context = new DomainContext(this.ConnectionString))
            {
                return context.Researches.Include("PersonConsultationResearches").Where(query).ToList();
            }
        }

        public IEnumerable<AsignedSymptom> GetEntitiesByQuery(Func<AsignedSymptom, bool> query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }

            using (var context = new DomainContext(this.ConnectionString))
            {
                return context.AsignedSymptoms.Include("Person").Include("Symptom").Where(query);
            }
        }

        public IEnumerable<MedicamentForm> GetEntitiesByQuery(Func<MedicamentForm, bool> query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }

            using (var context = new DomainContext(this.ConnectionString))
            {
                return context.MedicamentForms.Include("Medicaments")
                    .Where(query).ToList();
            }
        }

        public IEnumerable<AssignedMedicamentMeasuring> GetEntitiesByQuery(Func<AssignedMedicamentMeasuring, bool> query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }

            using (var context = new DomainContext(this.ConnectionString))
            {
                return context.AssignedMedicamentMeasurings.Include("AssignedMedicament").Include("MeasuringType")
                    .Where(query).ToList();
            }
        }

        public void DeleteEntity(Guid id)
        {
            using (var context = new DomainContext(this.ConnectionString))
            {
                var medicament = context.Medicaments.FirstOrDefault(v => v.Id == id);
                if (medicament == null)
                {
                    return;
                }

                context.Medicaments.Remove(medicament);
                context.SaveChanges();
            }
        }

        public void DeleteEntity(Guid id)
        {
            using (var context = new DomainContext(this.ConnectionString))
            {
                var personConsultationMeasuring = context.PersonConsultationMeasurings.FirstOrDefault(v => v.Id == id);
                if (personConsultationMeasuring == null)
                {
                    return;
                }

                context.PersonConsultationMeasurings.Remove(personConsultationMeasuring);
                context.SaveChanges();
            }
        }

        public void DeleteEntity(Guid id)
        {
            using (var context = new DomainContext(this.ConnectionString))
            {
                var riskFactor = context.RiskFactors.FirstOrDefault(v => v.Id == id);
                if (riskFactor == null)
                {
                    return;
                }

                context.RiskFactors.Remove(riskFactor);
                context.SaveChanges();
            }
        }