protected static void AddActiveDirectoryUser(Guid userId, string name, string accountName, bool isDisabled = false,
            IEnumerable<KeyValuePair<string, string>> customProperties = null)
        {
            using (DbContext writeDbContext = new DbContext())
            {
                User user = new User
                {
                    Id = userId,
                    Name = name,
                    IsDisabled = isDisabled,
                };

                Account account = new Account
                {
                    UserId = user.Id,
                    Name = accountName,
                    Type = AccountType.ActiveDirectory
                };

                user.Accounts.Add(account);

                if (customProperties != null)
                {
                    user.CustomProperties.AddRange(customProperties.Select(c => new CustomProperty { Id = Guid.NewGuid(), Name = c.Key, Value = c.Value }));
                }

                writeDbContext.Users.Add(user);
                writeDbContext.SaveChanges();
            }
        }

 public ConcreteDatabase(
     DbContext context,
     IRelationalDataStoreCreator dataStoreCreator,
     ILoggerFactory loggerFactory)
     : base(context, dataStoreCreator, loggerFactory)
 {
 }

        public void ShouldQueryFirms()
        {
            var model = CreateModel();

            using (var connection = CreateConnection())
            using (var context = new DbContext(connection, model.Compile(), false))
            {
                var firm = context.Set<Firm>()
                    .Include(x => x.Balances)
                    .Include(x => x.Categories)
                    .Include(x => x.CategoryGroup)
                    .Include(x => x.Client)
                    .Include(x => x.Client.CategoryGroup)
                    .Include(x => x.Client.Contacts)
                    .Include(x => x.Territories)
                    .OrderBy(x => x.Id)
                    .FirstOrDefault();

                Assert.That(firm, Is.Not.Null);
                Assert.That(firm.Name, Is.Not.Null.And.EqualTo("Firm 1"));
                Assert.That(firm.Balances, Is.Not.Null.And.Count.EqualTo(2));
                Assert.That(firm.Categories, Is.Not.Empty.And.Count.EqualTo(1));
                Assert.That(firm.CategoryGroup, Is.Not.Null);
                Assert.That(firm.Client, Is.Not.Null.And.Property("Name").EqualTo("Client 1"));
                Assert.That(firm.Client.CategoryGroup, Is.Not.Null);
                Assert.That(firm.Client.Contacts, Is.Not.Null.And.Count.EqualTo(3));
                Assert.That(firm.Territories, Is.Not.Empty.And.Count.EqualTo(2));
            }
        }

 public void Store(DbContext dbContext)
 {
     if (HttpContext.Current.Items.Contains(DataContextKey))
         HttpContext.Current.Items[DataContextKey] = dbContext;
     else
         HttpContext.Current.Items.Add(DataContextKey, dbContext);
 }

        /// <summary>
        ///     Attempts to get the model hash calculated by Code First for the given context.
        ///     This method will return null if the context is not being used in Code First mode.
        /// </summary>
        /// <param name = "context">The context.</param>
        /// <returns>The hash string.</returns>
        public static string TryGetModelHash(DbContext context)
        {
            //Contract.Requires(context != null);

            var compiledModel = context.InternalContext.CodeFirstModel;
            return compiledModel == null ? null : new ModelHashCalculator().Calculate(compiledModel);
        }

        public static void CheckRegionAllowed(IPrincipal principal,DbContext db, string regionID)
        {
            String userID = ((KawalDesaIdentity)principal.Identity).User.Id;
            if (userID == null)
                throw new ApplicationException("region is not allowed for thee");

            var region = db.Set<Region>()
                .AsNoTracking()
                .Include(r => r.Parent)
                .Include(r => r.Parent.Parent)
                .Include(r => r.Parent.Parent.Parent)
                .Include(r => r.Parent.Parent.Parent.Parent)
                .First(r => r.Id == regionID);

            var regionIDs = new List<string>();
            var current = region;
            while(current != null)
            {
                regionIDs.Add(current.Id);
                current = current.Parent;
            }

            var allowed = db.Set<UserScope>()
                .Any(s => s.fkUserId == userID && regionIDs.Contains(s.fkRegionId));
            if (!allowed)
                throw new ApplicationException("region is not allowed for thee");
        }

 public EntityEntryGraphIterator(
     [NotNull] DbContext context,
     [NotNull] IStateManager stateManager)
 {
     _context = context;
     _stateManager = stateManager;
 }

        public DbContextWrapper(DbContext context)
        {
            Context = context;

            objectContext = ((IObjectContextAdapter) context).ObjectContext;
            objectContext.ObjectMaterialized += ObjectMaterializedHandler;
        }

        public void CheckValue(DbContext ctx, object actual)
        {
            var propertyType = Accessor.MemberType;

            var objectContext = ((IObjectContextAdapter)ctx).ObjectContext;
            var entitySet = objectContext.GetEntitySet(propertyType);
            var keyMembers = entitySet.ElementType.KeyMembers;

            ctx.Entry(actual).Reference(Accessor.Name).Load();

            var actualEntity = Accessor.GetValue(actual);
            if (actualEntity == null)
            {
                throw new AssertionException(ExpectedEntity.Dump(), "NULL");
            }
            foreach (var keyMember in keyMembers)
            {
                var accessor = new PropertyAccessor(propertyType.GetProperty(keyMember.Name));

                var actualKeyValue = accessor.GetValue(actualEntity);
                var expectedKeyValue = accessor.GetValue(ExpectedEntity);

                if (!expectedKeyValue.Equals(actualKeyValue))
                {
                    throw new AssertionException(ExpectedEntity.Dump(), actualEntity.Dump());
                }
            }
        }

 protected virtual void FindSets(ModelBuilder modelBuilder, DbContext context)
 {
     foreach (var setInfo in SetFinder.FindSets(context))
     {
         modelBuilder.Entity(setInfo.EntityType);
     }
 }

        public void Registrar(DbContext dbContext)
        {
            RegistrarModulo();
            RegistrarOperaciones();

            dbContext.Set<Formulario>().Add(_moduloFormulario);
        }

 public EntityFrameworkExternalDataSource(DbContext dbContext)
 {
     _dbContext = dbContext;
     SetOptionsForDbContext(_dbContext);
     _efManager = new EFManager(dbContext);
     _efManager.ReloadDbEntries();
 }

 public UserService(DbContext context, IRepository<User> users, IRepository<Message, int> messages)
 {
     this.users = users;
     this.messages = messages;
     this.userManager = new UserManager<User>(new UserStore<User>(context));
     this.roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(context));
 }

		public void GuardClause_all()
		{
			Assert.Throws<ArgumentNullException>(() =>
			{
				var value = new DbContext(null, null);
			});
		}

 /// <copydocfrom cref="IDbContextProvider.CurrentContext" />
 public DbContext CurrentContext()
 {
     lock (syncLock)
     {
         return context ?? (context = func());
     }
 }

 private static void ExecuteResources(DbContext context, IEnumerable<string> resources)
 {
     foreach (var resource in resources)
     {
         SqlBatchExecutor.ExecuteResourceStreamFromExecutingAssembly(context, resource);
     }
 }

 public DbDependencyResolver(DbContext context)
 {
     this.context = context;
     this.usersRepository = new DbUsersRepository(context);
     this.newsArticlesRepository = new DbRepository<NewsArticle>(context);
     this.commentsRepository = new DbRepository<Comment>(context);
 }

        protected static void AddTestData(DbContext context)
        {
            var address1 = new Address { Street = "3 Dragons Way", City = "Meereen" };
            var address2 = new Address { Street = "42 Castle Black", City = "The Wall" };
            var address3 = new Address { Street = "House of Black and White", City = "Braavos" };

            context.Set<Person>().AddRange(
                new Person { Name = "Daenerys Targaryen", Address = address1 },
                new Person { Name = "John Snow", Address = address2 },
                new Person { Name = "Arya Stark", Address = address3 },
                new Person { Name = "Harry Strickland" });

            context.Set<Address>().AddRange(address1, address2, address3);

            var address21 = new Address2 { Id = "1", Street = "3 Dragons Way", City = "Meereen" };
            var address22 = new Address2 { Id = "2", Street = "42 Castle Black", City = "The Wall" };
            var address23 = new Address2 { Id = "3", Street = "House of Black and White", City = "Braavos" };

            context.Set<Person2>().AddRange(
                new Person2 { Name = "Daenerys Targaryen", Address = address21 },
                new Person2 { Name = "John Snow", Address = address22 },
                new Person2 { Name = "Arya Stark", Address = address23 });

            context.Set<Address2>().AddRange(address21, address22, address23);

            context.SaveChanges();
        }

        public void AddUserWithCustomProperties()
        {
            Guid userId = Guid.NewGuid();
            const string userName = "user";

            const string emailName = "email";
            const string emailValue = "[email protected]";
            const string addressName = "address";
            const string addressValue = "street 123";

            var customProperties = new List<KeyValuePair<string, string>>
            {
                new KeyValuePair<string, string>(emailName,  emailValue),
                new KeyValuePair<string, string>(addressName, addressValue)
            };

            sut.AddUser(userId, userName, customProperties);
            sut.SaveChanges();

            using (DbContext readContext = new DbContext())
            {
                User user = readContext.Users.Include(u => u.CustomProperties).Single();

                Assert.AreEqual(userId, user.Id);
                Assert.AreEqual(userName, user.Name);

                Assert.AreEqual(2, user.CustomProperties.Count);
                Assert.IsNotNull(user.CustomProperties.SingleOrDefault(c => c.Name == emailName && c.Value == emailValue));
                Assert.IsNotNull(user.CustomProperties.SingleOrDefault(c => c.Name == addressName && c.Value == addressValue));
            }
        }

        private static void AppendDescriptionUsingContext(DbContext context, StringBuilder builder, EntityType type, ActionType aType, object entity)
        {
            string additionalInfo = string.Empty;
            string identity = string.Empty;
            var enrty = context.Entry(entity);

            var prop =
                enrty.Entity.GetType()
                    .GetProperties()
                    .FirstOrDefault(c => c.GetCustomAttributes(typeof(KeyAttribute), true).FirstOrDefault() != null);
            var name = enrty.Entity.GetType().GetProperties().FirstOrDefault(c => c.Name.Contains("Name"));

            identity = CreateIdentityString(entity, prop, identity, name);

            if (aType == ActionType.Updating)
            {
                additionalInfo = string.Format("Были изменены следующие поля: {0}",
                    string.Join(",", enrty.CurrentValues.PropertyNames));
            }

            if (aType != ActionType.Import || aType != ActionType.Export)
            {
                builder.Append(string.Format("Сущность \"{0}\" {1} была {2}.{3}", type.GetEntityTypeName(), identity,
                    aType.GetActionTypeName(), additionalInfo));
            }
        }