public UserManagerTest()
{
var options = new DbContextOptionsBuilder <ApplicationContext>()
.UseInMemoryDatabase("DataBase")
.Options;
_context = new ApplicationContext(options);
//UserManager arrange vars
IUserStore <User> store = new UserStore <User, Role, ApplicationContext, Guid>(_context);
IOptions <IdentityOptions> optionsAccessor = new OptionsManager <IdentityOptions>(new OptionsFactory <IdentityOptions>(new List <IConfigureOptions <IdentityOptions> >(), new List <IPostConfigureOptions <IdentityOptions> >()));
IPasswordHasher <User> passwordHasher = new PasswordHasher <User>();
IEnumerable <IUserValidator <User> > userValidators = new List <IUserValidator <User> >();
IEnumerable <IPasswordValidator <User> > passwordValidators = new List <IPasswordValidator <User> >();
ILookupNormalizer lookupNormalizer = new UpperInvariantLookupNormalizer();
var describer = new IdentityErrorDescriber();
ILogger <UserManager <User> > logger = new Logger <UserManager <User> >(new NLogLoggerFactory());
_userManager = new UserManager <User>(
store,
optionsAccessor,
passwordHasher,
userValidators,
passwordValidators,
lookupNormalizer,
describer,
null,
logger);
}
public static PasswordBoxUserManager Create()
{
PasswordBoxDbContext context = new PasswordBoxDbContext();
IUserStore <User> userStore = new UserStore <User, Role, PasswordBoxDbContext>(context);
IdentityOptions options = GetDefaultOptions();
IOptions <IdentityOptions> optionResult = Microsoft.Extensions.Options.Options.Create(options);
IPasswordHasher <User> passwordHasher = new PasswordHasher <User>();
List <UserValidator <User> > validators = new List <UserValidator <User> >();
UserValidator <User> validator = new UserValidator <User>();
validators.Add(validator);
List <PasswordValidator <User> > passwordValidators = new List <PasswordValidator <User> >();
PasswordValidator <User> passwordValidator = new PasswordValidator <User>();
passwordValidators.Add(passwordValidator);
UpperInvariantLookupNormalizer normalizer = new UpperInvariantLookupNormalizer();
var logger = AppLogger.LoggerFactory.CreateLogger <PasswordBoxUserManager>();
IdentityErrorDescriber describer = new IdentityErrorDescriber();
return(new PasswordBoxUserManager(userStore, optionResult, passwordHasher, validators, passwordValidators, normalizer, describer, null, logger));
}
/// <summary>
/// Configures the schema needed for the KerykeionCms.
/// </summary>
/// <param name="builder">The builder being used to construct the model for this context.</param>
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
ILookupNormalizer normalizer = new UpperInvariantLookupNormalizer();
builder.Entity <IdentityRole <Guid> >().HasData
(
new IdentityRole <Guid> {
Name = RoleContstants.Administrator, Id = new Guid("A2EB5341-22E7-43C7-AC0E-C4AFED51DB2B"), NormalizedName = normalizer.NormalizeName(RoleContstants.Administrator)
},
new IdentityRole <Guid> {
Name = RoleContstants.Editor, Id = new Guid("57F5DC72-FA6D-4038-B337-D00BEF5A759A"), NormalizedName = normalizer.NormalizeName(RoleContstants.Editor)
},
new IdentityRole <Guid> {
Name = RoleContstants.RegularUser, Id = new Guid("2DD7B94B-CE9A-473A-B955-2FAD487BD435"), NormalizedName = normalizer.NormalizeName(RoleContstants.RegularUser)
}
);
builder.Entity <Link>()
.HasOne(l => l.Webpage)
.WithMany(w => w.Links)
.OnDelete(DeleteBehavior.Cascade);
builder.Entity <Article>()
.HasOne(l => l.Webpage)
.WithMany(w => w.Articles)
.OnDelete(DeleteBehavior.SetNull);
}
public Role(string Name, string DefaultGroup)
{
var normalizer = new UpperInvariantLookupNormalizer();
this.Name = Name;
this.DefaultGroup = DefaultGroup;
this.NormalizedName = normalizer.NormalizeName(this.Name);
}
private static RoleManager <ApplicationRole> CreateRoleManager(IRoleStore <ApplicationRole> store)
{
IEnumerable <IRoleValidator <ApplicationRole> > roleValidators = CreateRoleValidators();
ILookupNormalizer keyNormalizer = new UpperInvariantLookupNormalizer();
var errors = new IdentityErrorDescriber();
ILogger <RoleManager <ApplicationRole> > logger = TestHelper.CreateDebugLogger <RoleManager <ApplicationRole> >();
return(new RoleManager <ApplicationRole>(store, roleValidators, keyNormalizer, errors, logger));
}
public BaseService(ServiceContext serviceContext, IServiceManager serviceManager)
{
this.serviceContext = serviceContext;
this.mapper = serviceContext.GetItem <IMapper>("IMapper");
this.context = serviceContext.GetItem <BaseDbContext>("baseDbContext");
this.repositoryManager = new RepositoryManager(this.context);
this.normalizer = new UpperInvariantLookupNormalizer();
this.serviceManager = serviceManager;
}
public User(string username, string email, string[] roles, bool canUserChangePassword, string level)
{
var normalizer = new UpperInvariantLookupNormalizer();
UserName = username;
NormalizedUserName = normalizer.NormalizeName(UserName);
Email = email;
NormalizedEmail = normalizer.NormalizeEmail(email);
Roles = roles?.ToArray();
Level = level;
CanUserChangePassword = canUserChangePassword;
}
/// <summary>
/// Creates a user model with the specified email address and password.
/// </summary>
/// <param name="email">Email address of the user</param>
/// <param name="password">Password of the user</param>
/// <returns></returns>
private static SimpleIdentityUser CreateUser(string email, string password)
{
var normalizer = new UpperInvariantLookupNormalizer();
var user = new SimpleIdentityUser
{
Email = email,
NormalizedUserName = normalizer.Normalize(email),
};
var hasher = new PasswordHasher<SimpleIdentityUser>();
user.PasswordHash = hasher.HashPassword(user, password);
return user;
}
public User(UserData userData)
{
var normalizer = new UpperInvariantLookupNormalizer();
UserName = userData.Username;
NormalizedUserName = normalizer.NormalizeName(UserName);
Email = userData.Email;
NormalizedEmail = normalizer.NormalizeEmail(Email);
Roles = userData.Roles.ToArray();
Level = userData.Level;
CanUserChangePassword = userData.CanUserChangePassword;
PasswordHash = userData.HashedPassword;
SecurityStamp = userData.SecurityStamp;
Id = userData._EntityId;
}
public UsersController(ApplicationDbContext context,
IConfiguration configuration)
{
this.dbContext = context;
this._configuration = configuration;
var userStore = new UserStore <EventuresUser>(dbContext);
var hasher = new PasswordHasher <EventuresUser>();
var normalizer = new UpperInvariantLookupNormalizer();
var factory = new LoggerFactory();
var logger = new Logger <UserManager <EventuresUser> >(factory);
this.userManager = new UserManager <EventuresUser>(
userStore, null, hasher, null, null, normalizer, null, null, logger);
}
protected BaseController(IServiceManager serviceManager, ILogger <BaseController> logger)
{
this.logger = logger;
this.serviceManager = serviceManager;
this.mapper = this.serviceManager.serviceContext.GetItem <IMapper>("IMapper");
this.normalizer = this.serviceManager.serviceContext.GetItem <UpperInvariantLookupNormalizer>("ILookupNormalizer");
string userId = this.serviceManager.serviceContext.GetItem <string>("CurrentUserId");
if (!long.TryParse(userId, out currentUserId))
{
this.currentUserId = -1;
}
this.passwordHasher = new PasswordHasher <UserBo>();
}
public static UserManager <MemCheckUser> GetUserManager(MemCheckDbContext dbContext)
{
var userStore = new UserStore <MemCheckUser, MemCheckUserRole, MemCheckDbContext, Guid>(dbContext);
var optionsAccessor = Options.Create(new IdentityOptions());
var passwordHasher = new PasswordHasher <MemCheckUser>();
var userValidators = new UserValidator <MemCheckUser>().AsArray();
var passwordValidators = new PasswordValidator <MemCheckUser>().AsArray();
var keyNormalizer = new UpperInvariantLookupNormalizer();
var errors = new IdentityErrorDescriber();
var services = new ServiceCollection();
var logger = new LoggerFactory().CreateLogger <UserManager <MemCheckUser> >();
var serviceProvider = services.BuildServiceProvider();
var telemetryClient = new TelemetryClient(new TelemetryConfiguration());
//var roleChecker = new TestRoleChecker();
return(new MemCheckUserManager(userStore, optionsAccessor, passwordHasher, userValidators, passwordValidators, keyNormalizer, errors, serviceProvider, logger, telemetryClient, dbContext));
}
private static async Task Migrate(string connectionString)
{
var optionsBuilder = new DbContextOptionsBuilder();
optionsBuilder.UseSqlServer(connectionString);
var context = new BlogContext(optionsBuilder.Options);
context.Database.Migrate();
#if DEBUG
Console.WriteLine("Creating Test User");
var testUser = new IdentityUser("test");
var store = new UserOnlyStore <IdentityUser, BlogContext>(context);
var passwordHasher = new PasswordHasher <IdentityUser>();
var userValidators = Enumerable.Empty <IUserValidator <IdentityUser> >();
var passwordValidators = Enumerable.Empty <IPasswordValidator <IdentityUser> >();
var normalizer = new UpperInvariantLookupNormalizer();
var errDescriber = new IdentityErrorDescriber();
var userManager = new UserManager <IdentityUser>(store, null, passwordHasher, userValidators, passwordValidators, normalizer, errDescriber, null, null);
await userManager.CreateAsync(testUser, "123");
#endif
}
public async Task AddToRole(string roleName, string userName)
{
var user = await _userManager.FindByNameAsync(userName.ToUpper());
if (user != null)
{
if (!await _roleManager.RoleExistsAsync(roleName))
{
var normalizer = new UpperInvariantLookupNormalizer();
var identityRole = new IdentityRole(roleName);
identityRole.NormalizedName = normalizer.NormalizeName(roleName);
await _roleManager.CreateAsync(identityRole);
}
await _userManager.AddToRoleAsync(user, roleName);
//await _userManager.AddToRolesAsync(user, roleName);
//await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, roleName));
}
}
// Post api/UserProfile/UpdateUser
public async Task <ActionResult> PostUpdateUser(UpdateUserModel updateModel)
{
try
{
var userToChange = await _userManager.FindByIdAsync(updateModel.Id);
if (updateModel.Comment != null)
{
userToChange.Comment = updateModel.Comment;
}
if (updateModel.DataRestrictionId != 0)
{
userToChange.DataRestrictionId = updateModel.DataRestrictionId;
}
if (updateModel.Email != null) //todo: change only after getting email token
{
var normalizer = new UpperInvariantLookupNormalizer();
userToChange.Email = updateModel.Email;
userToChange.NormalizedEmail = normalizer.Normalize(updateModel.Email);
userToChange.UserName = updateModel.Email;
userToChange.NormalizedUserName = normalizer.Normalize(updateModel.Email);
}
if (updateModel.FirstName != null)
{
userToChange.FirstName = updateModel.FirstName;
}
if (updateModel.LastName != null)
{
userToChange.LastName = updateModel.LastName;
}
# region set roles
if (updateModel.UserRoles != null && IsAdmin(CurrentUser))
{
var rolesToSet = updateModel.UserRoles.Split(',');
foreach (var role in rolesToSet)
{
if (!await _roleManager.RoleExistsAsync(role))
{
return(Ok(IdentityResult.Failed(_userManager.ErrorDescriber.InvalidRoleName(role))));
}
}
var user = await _userManager.FindByIdAsync(updateModel.Id);
var oldRoles = await _userManager.GetRolesAsync(user);
await _userManager.RemoveFromRolesAsync(user, oldRoles);
foreach (var role in rolesToSet)
{
await _userManager.AddToRoleAsync(user, role);
}
//prevent user to remove the own admin role
if (CurrentUser == user && !rolesToSet.Contains("Admin"))
{
await _userManager.AddToRoleAsync(user, "Admin");
}
}
#endregion set roles
await _authContext.SaveChangesAsync();
return(Ok("")); //the result has to be an empty string for kendoGrid
}
public async Task <ActionResult> CreateAdmin(AdminViewModel viewModel)
{
if (viewModel.AdminPassword != viewModel.ConfirmPassword)
{
ViewBag.Languages = new SelectList(SupportedCultures.Cultures.Select(x => new { Value = x.TwoLetterISOLanguageName, Text = x.DisplayName }).ToList(), "Value", "Text");
ModelState.AddModelError("ConfirmPassword", "Password does not match");
return(View(viewModel));
}
SetupHelper.InitilizeDatabase();
if (SetupHelper.IsDbCreateComplete == true && SetupHelper.IsAdminCreateComplete == false)
{
if (!ModelState.IsValid)
{
ViewBag.Languages = new SelectList(SupportedCultures.Cultures.Select(x => new { Value = x.TwoLetterISOLanguageName, Text = x.DisplayName }).ToList(), "Value", "Text");
return(View(viewModel));
}
var optionBuilder = new DbContextOptionsBuilder <NccDbContext>();
SupportedDatabases supportedDatabases = TypeConverter.TryParseDatabaseEnum(SetupHelper.SelectedDatabase);
switch (supportedDatabases)
{
case SupportedDatabases.MSSQL:
optionBuilder.UseSqlServer(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"));
break;
case SupportedDatabases.MsSqlLocalStorage:
break;
case SupportedDatabases.MySql:
optionBuilder.UseMySql(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"));
break;
case SupportedDatabases.SqLite:
optionBuilder.UseSqlite(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"));
break;
case SupportedDatabases.PgSql:
break;
}
var nccDbConetxt = new NccDbContext(optionBuilder.Options);
var userStore = new NccUserStore(nccDbConetxt);
var identityOptions = Options.Create(new IdentityOptions());
var passwordHasher = new PasswordHasher <NccUser>();
var userValidatorList = new List <UserValidator <NccUser> >();
var passwordValidatorList = new List <PasswordValidator <NccUser> >();
var lookupNormalizer = new UpperInvariantLookupNormalizer();
var identityErrorDescriber = new IdentityErrorDescriber();
var logger = _loggerFactory.CreateLogger <UserManager <NccUser> >();
var authOption = new AuthenticationOptions();
var options = Options.Create <AuthenticationOptions>(authOption);
var scheme = new AuthenticationSchemeProvider(options);
var userManager = new UserManager <NccUser>(
userStore,
identityOptions,
passwordHasher,
userValidatorList,
passwordValidatorList,
lookupNormalizer,
identityErrorDescriber,
GlobalContext.App.ApplicationServices,
logger
);
var roleStore = new NccRoleStore(nccDbConetxt);
var roleValidatorList = new List <RoleValidator <NccRole> >();
var roleLogger = _loggerFactory.CreateLogger <RoleManager <NccRole> >();
var roleManager = new RoleManager <NccRole>(
roleStore,
roleValidatorList,
new UpperInvariantLookupNormalizer(),
new IdentityErrorDescriber(),
roleLogger
);
var claimsFactory = new UserClaimsPrincipalFactory <NccUser, NccRole>(userManager, roleManager, identityOptions);
var signInLogger = _loggerFactory.CreateLogger <SignInManager <NccUser> >();
var signInManager = new NccSignInManager <NccUser>(userManager, _httpContextAccessor, claimsFactory, identityOptions, signInLogger, scheme);
//nccDbConetxt.Database.Migrate();
var setupInfo = new WebSiteInfo()
{
SiteName = viewModel.SiteName,
Tagline = viewModel.Tagline,
AdminPassword = viewModel.AdminPassword,
AdminUserName = viewModel.AdminUserName,
ConnectionString = SetupHelper.ConnectionString,
Database = TypeConverter.TryParseDatabaseEnum(SetupHelper.SelectedDatabase),
Email = viewModel.Email,
Language = viewModel.Language,
TablePrefix = viewModel.TablePrefix
};
//SetupHelper.RegisterAuthServices(supportedDatabases);
var admin = await SetupHelper.CreateSuperAdminUser(nccDbConetxt, userManager, roleManager, signInManager, setupInfo);
if (admin != null)
{
SetupHelper.IsAdminCreateComplete = true;
SetupHelper.Language = viewModel.Language;
SetupHelper.SaveSetup();
SetupHelper.CrateNccWebSite(nccDbConetxt, setupInfo);
await SetupHelper.SaveBasicData(admin, nccDbConetxt, userManager, roleManager, signInManager, setupInfo);
return(Redirect("/Home/SetupSuccess"));
}
else
{
TempData["ErrorMessage"] = "Could not create Admin user and Roles.";
return(Redirect("/Home/Error"));
}
}
TempData["ErrorMessage"] = "Setup already completed.";
return(Redirect("/Home/Error"));
}
public async Task <ActionResult> CreateAdmin(AdminViewModel viewModel)
{
SetupHelper.InitilizeDatabase();
var optionBuilder = new DbContextOptionsBuilder <NccDbContext>();
DatabaseEngine dbe = TypeConverter.TryParseDatabaseEnum(SetupHelper.SelectedDatabase);
switch (dbe)
{
case DatabaseEngine.MSSQL:
optionBuilder.UseSqlServer(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"));
break;
case DatabaseEngine.MsSqlLocalStorage:
break;
case DatabaseEngine.MySql:
optionBuilder.UseMySql(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"));
break;
case DatabaseEngine.SqLite:
optionBuilder.UseSqlite(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"));
break;
case DatabaseEngine.PgSql:
break;
}
var nccDbConetxt = new NccDbContext(optionBuilder.Options);
var userStore = new NccUserStore(nccDbConetxt);
var identityOptions = Options.Create(new IdentityOptions());
var passwordHasher = new PasswordHasher <NccUser>();
var userValidatorList = new List <UserValidator <NccUser> >();
var passwordValidatorList = new List <PasswordValidator <NccUser> >();
var lookupNormalizer = new UpperInvariantLookupNormalizer();
var identityErrorDescriber = new IdentityErrorDescriber();
var logger = _loggerFactory.CreateLogger <UserManager <NccUser> >();
var userManager = new UserManager <NccUser>(
userStore,
identityOptions,
passwordHasher,
userValidatorList,
passwordValidatorList,
lookupNormalizer,
identityErrorDescriber,
GlobalConfig.App.ApplicationServices,
logger
);
var roleStore = new NccRoleStore(nccDbConetxt);
var roleValidatorList = new List <RoleValidator <NccRole> >();
var roleLogger = _loggerFactory.CreateLogger <RoleManager <NccRole> >();
var roleManager = new RoleManager <NccRole>(
roleStore,
roleValidatorList,
new UpperInvariantLookupNormalizer(),
new IdentityErrorDescriber(),
roleLogger,
_httpContextAccessor
);
var claimsFactory = new UserClaimsPrincipalFactory <NccUser, NccRole>(userManager, roleManager, identityOptions);
var signInLogger = _loggerFactory.CreateLogger <SignInManager <NccUser> >();
var signInManager = new NccSignInManager <NccUser>(userManager, _httpContextAccessor, claimsFactory, identityOptions, signInLogger);
//nccDbConetxt.Database.Migrate();
var setupInfo = new WebSiteInfo()
{
SiteName = viewModel.SiteName,
Tagline = viewModel.Tagline,
AdminPassword = viewModel.AdminPassword,
AdminUserName = viewModel.AdminUserName,
ConnectionString = SetupHelper.ConnectionString,
Database = TypeConverter.TryParseDatabaseEnum(SetupHelper.SelectedDatabase),
Email = viewModel.Email
};
var admin = await SetupHelper.CreateSuperAdminUser(userManager, roleManager, signInManager, setupInfo);
SetupHelper.RegisterAuthServices();
SetupHelper.IsAdminCreateComplete = true;
SetupHelper.SaveSetup();
SetupHelper.CrateNccWebSite(nccDbConetxt, setupInfo);
return(Redirect("/Home/SetupSuccess"));
}
static void Main(string[] args)
{
/*
* This cli is only for bootstrapping the DB with
* an admin user.
* For all other cases, use the admin features in the
* auth service.
*
* # use cases:
* 2. Grant role to user
* 3. Remove role from user
* 4. Create admin role
*/
var loggerFactory = new LoggerFactory();
loggerFactory
.AddConsole()
.AddDebug();
var keyNormalizer = new UpperInvariantLookupNormalizer();
var roleUsersStore = new DynamoRoleUsersStore <DynamoIdentityRole, DynamoIdentityUser>();
var userStore = new DynamoUserStore <DynamoIdentityUser, DynamoIdentityRole>(roleUsersStore);
var roleStore = new DynamoRoleStore <DynamoIdentityRole>();
var app = new CommandLineApplication();
app.HelpOption("-? | -h | --help");
var dbUrl = app.Option("-d|--dynamodb", "DynamoDB endpoint", CommandOptionType.SingleValue);
var region = app.Option("-R|--region", "AWS Region", CommandOptionType.SingleValue);
var tableNamePrefix = app.Option("-p|--prefix", "Table Name Prefix", CommandOptionType.SingleValue);
app.Command("role", roleCommand =>
{
roleCommand.HelpOption("-? | -h | --help");
var roleName = roleCommand.Option("-r|--role <role>", "role name", CommandOptionType.SingleValue);
roleCommand.Command("add", addRole =>
{
addRole.HelpOption("-? | -h | --help");
addRole.OnExecute(() =>
{
Program program = new Program(
loggerFactory,
userStore,
roleStore,
roleUsersStore,
keyNormalizer,
dbUrl.Value(),
region.Value(),
tableNamePrefix.Value());
program.CreateRole(roleName.Value()).Wait();
return(0);
});
});
roleCommand.Command("remove", removeRole =>
{
removeRole.HelpOption("-? | -h | --help");
removeRole.OnExecute(() =>
{
Program program = new Program(
loggerFactory,
userStore,
roleStore,
roleUsersStore,
keyNormalizer,
dbUrl.Value(),
region.Value(),
tableNamePrefix.Value());
program.RemoveRole(roleName.Value()).Wait();
return(0);
});
});
});
app.Command("claim", claimCommand =>
{
claimCommand.HelpOption("-? | -h | --help");
var roleName = claimCommand.Option("-r|--role <role>", "role name", CommandOptionType.SingleValue);
var claimType = claimCommand.Option("-t|--claim-type <type>", "claim type", CommandOptionType.SingleValue);
var claimValue = claimCommand.Option("-v|--claim-value <value>", "claim value", CommandOptionType.SingleValue);
claimCommand.Command("get", getClaims =>
{
getClaims.HelpOption("-? | -h | --help");
getClaims.OnExecute(() =>
{
Program program = new Program(
loggerFactory,
userStore,
roleStore,
roleUsersStore,
keyNormalizer,
dbUrl.Value(),
region.Value(),
tableNamePrefix.Value());
var claims = program.GetClaims(roleName.Value()).Result;
Console.WriteLine(JsonConvert.SerializeObject(claims, Formatting.Indented));
return(0);
});
});
claimCommand.Command("add", addClaim =>
{
addClaim.HelpOption("-? | -h | --help");
addClaim.OnExecute(() =>
{
Program program = new Program(
loggerFactory,
userStore,
roleStore,
roleUsersStore,
keyNormalizer,
dbUrl.Value(),
region.Value(),
tableNamePrefix.Value());
var claim = new Claim(claimType.Value(), claimValue.Value());
program.AddClaim(roleName.Value(), claim).Wait();
return(0);
});
});
claimCommand.Command("remove", removeClaim =>
{
removeClaim.HelpOption("-? | -h | --help");
removeClaim.OnExecute(() =>
{
Program program = new Program(
loggerFactory,
userStore,
roleStore,
roleUsersStore,
keyNormalizer,
dbUrl.Value(),
region.Value(),
tableNamePrefix.Value());
var claim = new Claim(claimType.Value(), claimValue.Value());
program.RemoveClaim(roleName.Value(), claim).Wait();
return(0);
});
});
});
app.Execute(args);
}
private void SeedDatabase()
{
var dbContext = this.CreateDbContext();
var userStore = new UserStore <EventuresUser>(dbContext);
var hasher = new PasswordHasher <EventuresUser>();
var normalizer = new UpperInvariantLookupNormalizer();
var userManager = new UserManager <EventuresUser>(
userStore, null, hasher, null, null, normalizer, null, null, null);
// Create GuestUser
this.GuestUser = new EventuresUser()
{
UserName = "******" + DateTime.Now.Ticks.ToString().Substring(10),
NormalizedUserName = "******" + DateTime.Now.Ticks.ToString().Substring(10),
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
FirstName = "Guest",
LastName = "User"
};
userManager
.CreateAsync(this.GuestUser, this.GuestUser.UserName)
.Wait();
// EventOpenFest has owner GuestUser
this.EventOpenFest = new Event()
{
Name = "OpenFest " + DateTime.Now.Ticks.ToString().Substring(10),
Place = "Online",
Start = DateTime.Now.AddDays(500),
End = DateTime.Now.AddDays(500).AddHours(8),
TotalTickets = 500,
PricePerTicket = 10.00M,
OwnerId = this.GuestUser.Id
};
dbContext.Add(this.EventOpenFest);
// Create UserMaria
this.UserMaria = new EventuresUser()
{
UserName = "******" + DateTime.Now.Ticks.ToString().Substring(10),
NormalizedUserName = "******" + DateTime.Now.Ticks.ToString().Substring(10),
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
FirstName = "Maria",
LastName = "Green",
};
userManager.CreateAsync(this.UserMaria, this.UserMaria.UserName).Wait();
// EventDevConf has owner UserMaria
this.EventDevConf = new Event()
{
Name = "Dev Conference " + DateTime.Now.Ticks.ToString().Substring(10),
Place = "Varna",
Start = DateTime.Now.AddMonths(5),
End = DateTime.Now.AddMonths(5).AddDays(5),
TotalTickets = 350,
PricePerTicket = 20.00m,
OwnerId = this.UserMaria.Id
};
dbContext.Add(this.EventDevConf);
dbContext.SaveChanges();
}
public IdentityServiceFactory()
{
var dataProtectorTokenProvider = new DataProtectorTokenProvider <DbUser>(
new EphemeralDataProtectionProvider(new NullLoggerFactory()), null, new NullLogger <DataProtectorTokenProvider <DbUser> >());
// service provider
var serviceProviderMock = new Mock <IServiceProvider>();
var serviceScopeMock = new Mock <IServiceScope>();
serviceScopeMock.Setup(x => x.ServiceProvider).Returns(serviceProviderMock.Object);
var serviceScopeFactoryMock = new Mock <IServiceScopeFactory>();
serviceScopeFactoryMock.Setup(x => x.CreateScope()).Returns(serviceScopeMock.Object);
var authenticationServiceMock = new Mock <IAuthenticationService>();
serviceProviderMock.Setup(x => x.GetService(typeof(IServiceScopeFactory))).Returns(serviceScopeFactoryMock.Object);
serviceProviderMock.Setup(x => x.GetService(typeof(DataProtectorTokenProvider <DbUser>))).Returns(dataProtectorTokenProvider);
serviceProviderMock.Setup(x => x.GetService(typeof(IAuthenticationService))).Returns(authenticationServiceMock.Object);
// http context
var httpContextAccessorMock = new Mock <IHttpContextAccessor>();
var httpContext = new DefaultHttpContext {
ServiceScopeFactory = serviceScopeFactoryMock.Object
};
httpContextAccessorMock.Setup(x => x.HttpContext).Returns(httpContext);
var httpContextAccessor = httpContextAccessorMock.Object;
// identity services
var identityOptionsAccessorMock = new Mock <IOptions <IdentityOptions> >();
identityOptionsAccessorMock.Setup(x => x.Value).Returns(() => new IdentityOptions
{
Tokens = new TokenOptions
{
ProviderMap = new Dictionary <string, TokenProviderDescriptor>
{
{ TokenOptions.DefaultProvider, new TokenProviderDescriptor(typeof(DataProtectorTokenProvider <DbUser>)) },
// { TokenOptions.DefaultEmailProvider, new TokenProviderDescriptor(typeof(EmailTokenProvider<DbUser>)) }
}
},
User = new UserOptions
{
RequireUniqueEmail = true
}
});
var identityOptionsAccessor = identityOptionsAccessorMock.Object;
var identityErrorDescriber = new IdentityErrorDescriber();
var lookupNormalizer = new UpperInvariantLookupNormalizer();
var connectionFactory = new DbConnectionFactory();
var userStore = new UserStore <Guid, DbUser, DbRole>(connectionFactory, identityErrorDescriber);
var roleStore = new RoleStore <Guid, DbRole>(connectionFactory, identityErrorDescriber);
var userManager = new UserManager <DbUser>(userStore, identityOptionsAccessor, new PasswordHasher <DbUser>(), null, null,
lookupNormalizer, identityErrorDescriber, serviceProviderMock.Object, new NullLogger <UserManager <DbUser> >());
userManager.RegisterTokenProvider(TokenOptions.DefaultProvider, dataProtectorTokenProvider);
var roleManager = new AspNetRoleManager <DbRole>(roleStore, null, lookupNormalizer, identityErrorDescriber,
new NullLogger <RoleManager <DbRole> >(), httpContextAccessor);
var userClaimsPrincipalFactory = new UserClaimsPrincipalFactory <DbUser, DbRole>(userManager, roleManager, identityOptionsAccessor);
var signInManager = new SignInManager <DbUser>(userManager, httpContextAccessor, userClaimsPrincipalFactory, identityOptionsAccessor,
new NullLogger <SignInManager <DbUser> >(), null, null);
UserManager = userManager;
RoleManager = roleManager;
SignInManager = signInManager;
}
