/// <summary>
/// Do indexes exist
/// </summary>
public static void Exist()
{
var context = ApplicationIdentityContext.Create();
IndexChecks.EnsureUniqueIndexOnUserName(context.Users);
IndexChecks.EnsureUniqueIndexOnRoleName(context.Roles);
}
public static void Exist()
{
var context = new ApplicationDbContext();
IndexChecks.EnsureUniqueIndexOnUserName(context.IdentityUsers);
IndexChecks.EnsureUniqueIndexOnRoleName(context.Roles);
}
/// <summary>
/// Adds mongodb implementation for the "Asp Net Core Identity" part (saving user and roles)
/// </summary>
/// <remarks><![CDATA[
/// Contains implemenations for
/// - IUserStore<T>
/// - IRoleStore<T>
/// ]]></remarks>
public static IIdentityServerBuilder AddMongoDbForAspIdentity <TIdentity, TRole>(this IIdentityServerBuilder builder, IConfigurationRoot configurationRoot) where
TIdentity : Microsoft.AspNetCore.Identity.MongoDB.IdentityUser where TRole : Microsoft.AspNetCore.Identity.MongoDB.IdentityRole
{
//User Mongodb for Asp.net identity in order to get users stored
var configurationOptions = configurationRoot.Get <ConfigurationOptions>();
var client = new MongoClient(configurationOptions.MongoConnection);
var database = client.GetDatabase(configurationOptions.MongoDatabaseName);
// Configure Asp Net Core Identity / Role to use MongoDB
builder.Services.AddSingleton <IUserStore <TIdentity> >(x =>
{
var usersCollection = database.GetCollection <TIdentity>("Identity_Users");
IndexChecks.EnsureUniqueIndexOnNormalizedEmail(usersCollection);
IndexChecks.EnsureUniqueIndexOnNormalizedUserName(usersCollection);
return(new UserStore <TIdentity>(usersCollection));
});
builder.Services.AddSingleton <IRoleStore <TRole> >(x =>
{
var rolesCollection = database.GetCollection <TRole>("Identity_Roles");
IndexChecks.EnsureUniqueIndexOnNormalizedRoleName(rolesCollection);
return(new RoleStore <TRole>(rolesCollection));
});
builder.Services.AddIdentity <TIdentity, TRole>();
return(builder);
}
public MongoRoleStore(IMongoDatabase database)
{
var rolesCollection = database.GetCollection <WrappedIdentityRole>("Identity_Roles");
IndexChecks.EnsureUniqueIndexOnNormalizedRoleName(rolesCollection);
innerStore = new RoleStore <WrappedIdentityRole>(rolesCollection);
}
private void EnsureIndexes()
{
IndexChecks.EnsureUniqueIndexOnUserName(this.Users);
IndexChecks.EnsureUniqueIndexOnEmail(this.Users);
IndexChecks.EnsureUniqueIndexOnRoleName(this.Roles);
IndexFacade.EnsureUniqueIndexOnPhoneNumber(this.Users);
IndexFacade.EnsureIndexesOnUserType(this.Users);
}
public static void Exist()
{
var context = ApplicationIdentityContext.Create();
IndexChecks.EnsureUniqueIndexOnUserName(context.Users);
IndexChecks.EnsureUniqueIndexOnRoleName(context.Roles);
context.Books.Indexes.CreateOne(Builders <Book> .IndexKeys.Ascending("BookName"));
}
public MongoUserStore(IMongoDatabase database)
{
var usersCollection = database.GetCollection <WrappedIdentityUser>("Identity_Users");
IndexChecks.EnsureUniqueIndexOnNormalizedEmail(usersCollection);
IndexChecks.EnsureUniqueIndexOnNormalizedUserName(usersCollection);
innerStore = new UserStore <WrappedIdentityUser>(usersCollection);
}
public static void Exist()
{
IContext context = new Context();
var users = context.GetUserCollection();
var roles = context.GetRoleCollection();
IndexChecks.EnsureUniqueIndexOnUserName(users);
IndexChecks.EnsureUniqueIndexOnRoleName(roles);
}
public void EnsureUniqueIndexOnRoleName_NoIndexOnRoleName_AddsUniqueIndexOnRoleName()
{
var roleCollectionName = "roleindextest";
Database.DropCollection(roleCollectionName);
var roles = Database.GetCollection(roleCollectionName);
IndexChecks.EnsureUniqueIndexOnRoleName(roles);
var index = roles.GetIndexes()
.Where(i => i.IsUnique)
.Where(i => i.Key.Count() == 1)
.First(i => i.Key.Contains("Name"));
Expect(index.Key.Count(), Is.EqualTo(1));
}
public void EnsureEmailUniqueIndex_NoIndexOnEmail_AddsUniqueIndexOnEmail()
{
var userCollectionName = "userindextest";
Database.DropCollection(userCollectionName);
var users = Database.GetCollection(userCollectionName);
IndexChecks.EnsureUniqueIndexOnEmail(users);
var index = users.GetIndexes()
.Where(i => i.IsUnique)
.Where(i => i.Key.Count() == 1)
.First(i => i.Key.Contains("Email"));
Expect(index.Key.Count(), Is.EqualTo(1));
}
public void EnsureEmailUniqueIndex_NoIndexOnEmail_AddsUniqueIndexOnEmail()
{
var userCollectionName = "userindextest";
Database.DropCollection(userCollectionName);
var usersNewApi = Database.GetCollection <IdentityUser>(userCollectionName);
IndexChecks.EnsureUniqueIndexOnEmail(usersNewApi);
var users = Database.GetCollection(userCollectionName);
var index = users.GetIndexes()
.Where(i => i.Options.Unique)
.FirstOrDefault(i => i.Field.Contains("Email"));
Assert.IsNotNull(index);
}
public void EnsureUniqueIndexOnRoleName_NoIndexOnRoleName_AddsUniqueIndexOnRoleName()
{
var roleCollectionName = "roleindextest";
Database.DropCollection(roleCollectionName);
var rolesNewApi = Database.GetCollection <IdentityRole>(roleCollectionName);
IndexChecks.EnsureUniqueIndexOnRoleName(rolesNewApi);
var roles = Database.GetCollection(roleCollectionName);
var index = roles.GetIndexes()
.Where(i => i.Options.Unique)
.FirstOrDefault(i => i.Field.Contains("Name"));
Assert.IsNotNull(index);
}
public void EnsureUniqueIndexOnUserName_NoIndexOnUserName_AddsUniqueIndexOnUserName()
{
var userCollectionName = "userindextest";
Database.DropCollection(userCollectionName);
var usersNewApi = DatabaseNewApi.GetCollection <IdentityUser>(userCollectionName);
IndexChecks.EnsureUniqueIndexOnUserName(usersNewApi);
var users = Database.GetCollection(userCollectionName);
var index = users.GetIndexes()
.Where(i => i.IsUnique)
.Where(i => i.Key.Count() == 1)
.First(i => i.Key.Contains("UserName"));
Expect(index.Key.Count(), Is.EqualTo(1));
}
public dbContext()
{
var conn = "mongodb://localhost:27017";
var client = new MongoClient(conn);
Database = client.GetDatabase("Rabbit");
var users = Database.GetCollection <User>("users");
var store = new UserStore <User>(users);
var manager = new UserManager <User>(store);
// if you want roles too:
var roles = Database.GetCollection <Role>("roles");
var roleStore = new RoleStore <Role>(roles);
IndexChecks.EnsureUniqueIndexOnUserName(users);
IndexChecks.EnsureUniqueIndexOnEmail(users);
IndexChecks.EnsureUniqueIndexOnRoleName(roles);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var builder = new ContainerBuilder();
// registrating all the existing controllers
builder.RegisterControllers(Assembly.GetExecutingAssembly());
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
// Init MongoDB Identity
var client = new MongoClient(ConfigurationManager.ConnectionStrings["MongoDB"].ConnectionString);
var database = client.GetDatabase(ConfigurationManager.AppSettings["DBName"]);
var usersCollection = database.GetCollection <ApplicationUser>("users");
var rolesCollection = database.GetCollection <IdentityRole>("roles");
IndexChecks.EnsureUniqueIndexOnEmail(usersCollection);
IndexChecks.EnsureUniqueIndexOnRoleName(rolesCollection);
builder.Register(b => database).AsSelf().SingleInstance();
// Register Repositories
builder.Register(b => new ProductRepository(database)).AsImplementedInterfaces().InstancePerLifetimeScope();
//builder.Register(b => new CommunityRepository(database)).AsImplementedInterfaces().InstancePerLifetimeScope();
//builder.Register(b => new ProductRepository(database)).AsImplementedInterfaces().InstancePerLifetimeScope();
// Register Services
builder.Register(b => new ProductService(b.Resolve <IProductRepository>())).AsImplementedInterfaces().InstancePerLifetimeScope();
//builder.Register(b => new CommunityService(b.Resolve<ICommunityRepository>(), b.Resolve<IProductRepository>())).AsImplementedInterfaces().InstancePerLifetimeScope();
//builder.Register(b => new ProductService(b.Resolve<IProductRepository>())).AsImplementedInterfaces().InstancePerLifetimeScope();
//builder.Register(b => new PaymentService()).AsImplementedInterfaces().InstancePerLifetimeScope();
IContainer container = builder.Build();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);
}
public static IIdentityServerBuilder AddMongoDbForAspIdentity <TIdentity, TRole>(this IIdentityServerBuilder builder, IConfiguration configuration)
where TIdentity : External.IdentityUser where TRole : External.IdentityRole
{
var configurationOptions = configuration.Get <ConfigurationOptions>();
// TODO: Inject connectionString and dbName
var client = new MongoClient(
//configurationOptions.MongoConnection
"mongodb://localhost:27017"
);
var database = client.GetDatabase(
//configurationOptions.MongoDatabaseName
"testDatabase"
);
// Changed to return UserStore instead of interface IUserStore to work
builder.Services.AddSingleton <IUserStore <TIdentity> >(x =>
{
var usersCollection = database.GetCollection <TIdentity>("Identity_Users");
IndexChecks.EnsureUniqueIndexOnNormalizedEmail(usersCollection);
IndexChecks.EnsureUniqueIndexOnNormalizedUserName(usersCollection);
return(new External.UserStore <TIdentity>(usersCollection));
});
// Changed to return RoleStore instead of interface IRoleStore to work
builder.Services.AddSingleton <IRoleStore <TRole> >(x =>
{
var rolesCollection = database.GetCollection <TRole>("Identity_Roles");
IndexChecks.EnsureUniqueIndexOnNormalizedRoleName(rolesCollection);
return(new RoleStore <TRole>(rolesCollection));
});
// TODO: Add password settings, etc.
// https://docs.microsoft.com/en-us/aspnet/core/security/authentication/identity-configuration?tabs=aspnetcore2x
builder.Services.AddIdentity <TIdentity, TRole>()
.AddUserStore <UserStore <TIdentity> >()
.AddRoleStore <RoleStore <TRole> >()
.AddDefaultTokenProviders();
//.AddOpenIddict();
return(builder);
}
public static IdentityBuilder AddMongoStores <TRepository>(this IdentityBuilder builder)
where TRepository : IMongoIdentityRepository
{
var provider = builder.Services.BuildServiceProvider();
var repo = (TRepository)provider.GetService <IMongoIdentityRepository>();
builder.Services.AddSingleton <IUserStore <AppUser> >(p =>
{
IndexChecks.EnsureUniqueIndexOnNormalizedEmail(
repo.GetDatabase().GetCollection <AppUser>(AppIndentityConstants.Mongo.IdentityUserCollectionName));
IndexChecks.EnsureUniqueIndexOnNormalizedUserName(
repo.GetDatabase().GetCollection <AppUser>(AppIndentityConstants.Mongo.IdentityUserCollectionName));
return(new AppUserStore <AppUser>(repo));
});
builder.Services.AddSingleton <IRoleStore <AppRole> >(p =>
{
IndexChecks.EnsureUniqueIndexOnNormalizedRoleName(
repo.GetDatabase().GetCollection <AppRole>(AppIndentityConstants.Mongo.IdentityRoleCollectionName));
return(new AppRoleStore <AppRole>(repo));
});
return(builder);
}
public static IdentityBuilder AddMongoIdentityStores <TIdentity, TRole>(this IServiceCollection services, IMongoDatabase database) where TIdentity : IdentityUser where TRole : IdentityRole
{
services.AddSingleton <IUserStore <TIdentity> >(x =>
{
IMongoCollection <TIdentity> usersCollection = database.GetCollection <TIdentity>("Identity_Users");
IndexChecks.EnsureUniqueIndexOnNormalizedEmail(usersCollection);
IndexChecks.EnsureUniqueIndexOnNormalizedUserName(usersCollection);
return(new UserStore <TIdentity>(usersCollection));
});
services.AddSingleton <IRoleStore <TRole> >(x =>
{
var rolesCollection = database.GetCollection <TRole>("Identity_Roles");
IndexChecks.EnsureUniqueIndexOnNormalizedRoleName(rolesCollection);
return(new RoleStore <TRole>(rolesCollection));
});
return(services.AddIdentity <TIdentity, TRole>());
}
protected override void Load(ContainerBuilder builder)
{
var databaseName = Configuration.GetValue <string>("squidex:stores:mongoDb:databaseName");
if (string.IsNullOrWhiteSpace(databaseName))
{
throw new ConfigurationException("You must specify the MongoDB database name in the 'squidex:stores:mongoDb:databaseName' configuration section.");
}
var connectionString = Configuration.GetValue <string>("squidex:stores:mongoDb:connectionString");
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new ConfigurationException("You must specify the MongoDB connection string in the 'squidex:stores:mongoDb:connectionString' configuration section.");
}
var databaseNameContent = Configuration.GetValue <string>("squidex:stores:mongoDb:databaseNameContent");
if (string.IsNullOrWhiteSpace(databaseNameContent))
{
databaseNameContent = databaseName;
}
builder.Register(c => new MongoClient(connectionString))
.As <IMongoClient>()
.SingleInstance();
builder.Register(c => c.Resolve <IMongoClient>().GetDatabase(databaseName))
.Named <IMongoDatabase>(MongoDatabaseName)
.SingleInstance();
builder.Register(c => c.Resolve <IMongoClient>().GetDatabase(databaseNameContent))
.Named <IMongoDatabase>(MongoDatabaseNameContent)
.SingleInstance();
builder.Register <IUserStore <IdentityUser> >(c =>
{
var usersCollection = c.ResolveNamed <IMongoDatabase>(MongoDatabaseName).GetCollection <IdentityUser>("Identity_Users");
IndexChecks.EnsureUniqueIndexOnNormalizedEmail(usersCollection);
IndexChecks.EnsureUniqueIndexOnNormalizedUserName(usersCollection);
return(new UserStore <IdentityUser>(usersCollection));
})
.SingleInstance();
builder.Register <IRoleStore <IdentityRole> >(c =>
{
var rolesCollection = c.ResolveNamed <IMongoDatabase>(MongoDatabaseName).GetCollection <IdentityRole>("Identity_Roles");
IndexChecks.EnsureUniqueIndexOnNormalizedRoleName(rolesCollection);
return(new RoleStore <IdentityRole>(rolesCollection));
})
.SingleInstance();
builder.RegisterType <MongoUserRepository>()
.As <IUserRepository>()
.InstancePerLifetimeScope();
builder.RegisterType <MongoPersistedGrantStore>()
.WithParameter(ResolvedParameter.ForNamed <IMongoDatabase>(MongoDatabaseName))
.As <IPersistedGrantStore>()
.SingleInstance();
builder.RegisterType <MongoEventConsumerInfoRepository>()
.WithParameter(ResolvedParameter.ForNamed <IMongoDatabase>(MongoDatabaseName))
.As <IEventConsumerInfoRepository>()
.AsSelf()
.SingleInstance();
builder.RegisterType <MongoContentRepository>()
.WithParameter(ResolvedParameter.ForNamed <IMongoDatabase>(MongoDatabaseNameContent))
.As <IContentRepository>()
.As <IEventConsumer>()
.AsSelf()
.SingleInstance();
builder.RegisterType <MongoHistoryEventRepository>()
.WithParameter(ResolvedParameter.ForNamed <IMongoDatabase>(MongoDatabaseName))
.As <IHistoryEventRepository>()
.As <IEventConsumer>()
.As <IExternalSystem>()
.AsSelf()
.SingleInstance();
builder.RegisterType <MongoSchemaRepository>()
.WithParameter(ResolvedParameter.ForNamed <IMongoDatabase>(MongoDatabaseName))
.As <ISchemaRepository>()
.As <IExternalSystem>()
.AsSelf()
.SingleInstance();
builder.RegisterType <MongoAppRepository>()
.WithParameter(ResolvedParameter.ForNamed <IMongoDatabase>(MongoDatabaseName))
.As <IAppRepository>()
.As <IEventConsumer>()
.As <IExternalSystem>()
.AsSelf()
.SingleInstance();
builder.Register(c =>
new CompoundEventConsumer(
c.Resolve <MongoSchemaRepository>(),
c.Resolve <CachingSchemaProvider>()))
.As <IEventConsumer>()
.AsSelf()
.SingleInstance();
builder.Register(c =>
new CompoundEventConsumer(
c.Resolve <MongoAppRepository>(),
c.Resolve <CachingAppProvider>()))
.As <IEventConsumer>()
.AsSelf()
.SingleInstance();
}
public static void Initialize(IlevusIdentityContext db)
{
IndexChecks.EnsureUniqueIndexOnEmail(db.Users);
IndexChecks.EnsureUniqueIndexOnUserName(db.Users);
IndexChecks.EnsureUniqueIndexOnRoleName(db.Roles);
}
