public DocumentDbIdentityUserBuilder WithNormalizedUserName()
{
LookupNormalizer normalizer = new LookupNormalizer();
identityUser.NormalizedUserName = normalizer.Normalize(identityUser.UserName);
return(this);
}
public DocumentDbIdentityUserBuilder WithNormalizedEmail()
{
LookupNormalizer normalizer = new LookupNormalizer();
identityUser.NormalizedEmail = normalizer.Normalize(identityUser.Email);
return(this);
}
public DocumentDbFixture()
{
// TODO: Until DocumentDB SDK exposes it's JSON.NET settings, we need to hijack the global settings to serialize claims
JsonConvert.DefaultSettings = () =>
{
return(new JsonSerializerSettings()
{
Converters = new List <JsonConverter>()
{
new JsonClaimConverter()
}
});
};
Client = new DocumentClient(
serviceEndpoint: new Uri("https://localhost:8081", UriKind.Absolute),
authKeyOrResourceToken: "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==",
connectionPolicy: new ConnectionPolicy()
{
EnableEndpointDiscovery = false
});
Normalizer = new LookupNormalizer();
DatabaseLink = UriFactory.CreateDatabaseUri(this.Database);
UserStoreCollectionLink = UriFactory.CreateDocumentCollectionUri(this.Database, this.UserStoreDocumentCollection);
RoleStoreCollectionLink = UriFactory.CreateDocumentCollectionUri(this.Database, this.RoleStoreDocumentCollection);
CreateTestDatabase();
}
public DocumentDbIdentityRoleBuilder WithNormalizedRoleName(string normalizedRoleName = null)
{
LookupNormalizer normalizer = new LookupNormalizer();
identityRole.NormalizedName = normalizedRoleName ?? normalizer.Normalize(identityRole.Name);
return(this);
}
public virtual async Task <IdentityDataSeedResult> SeedAsync(
string adminEmail,
string adminPassword,
Guid?tenantId = null)
{
Check.NotNullOrWhiteSpace(adminEmail, nameof(adminEmail));
Check.NotNullOrWhiteSpace(adminPassword, nameof(adminPassword));
var result = new IdentityDataSeedResult();
//"admin" user
const string adminUserName = "******";
var adminUser = await UserRepository.FindByNormalizedUserNameAsync(
LookupNormalizer.NormalizeName(adminUserName)
);
if (adminUser != null)
{
return(result);
}
adminUser = new IdentityUser(
GuidGenerator.Create(),
Guid.Empty,
adminUserName,
adminEmail,
tenantId
)
{
Name = adminUserName
};
(await UserManager.CreateAsync(adminUser, adminPassword)).CheckErrors();
result.CreatedAdminUser = true;
//"admin" role
const string adminRoleName = "admin";
var adminRole = await RoleRepository.FindByNormalizedNameAsync(LookupNormalizer.NormalizeName(adminRoleName));
if (adminRole == null)
{
adminRole = new IdentityRole(
GuidGenerator.Create(),
adminRoleName,
tenantId
)
{
IsStatic = true,
IsPublic = true
};
(await RoleManager.CreateAsync(adminRole)).CheckErrors();
result.CreatedAdminRole = true;
}
(await UserManager.AddToRoleAsync(adminUser, adminRoleName)).CheckErrors();
return(result);
}
public async Task GetListByNormalizedRoleNameAsync()
{
var users = await UserRepository.GetListByNormalizedRoleNameAsync(LookupNormalizer.NormalizeName("supporter"));
users.Count.ShouldBe(2);
users.ShouldContain(u => u.UserName == "john.nash");
users.ShouldContain(u => u.UserName == "neo");
}
public async Task GetRoleNamesAsync()
{
var john = await UserRepository.FindByNormalizedUserNameAsync(LookupNormalizer.NormalizeName("john.nash"));
var roles = await UserRepository.GetRoleNamesAsync(john.Id);
roles.Count.ShouldBe(3);
roles.ShouldContain("moderator");
roles.ShouldContain("supporter");
roles.ShouldContain("manager");
}
public async Task <IdentityDataSeedResult> SeedAsync(string adminEmail, string adminPassword, Guid?tenantId)
{
Check.NotNullOrWhiteSpace(adminEmail, nameof(adminEmail));
Check.NotNullOrWhiteSpace(adminPassword, nameof(adminPassword));
var result = new IdentityDataSeedResult();
using (CurrentTenant.Change(tenantId))
{
//"admin" user
const string adminUserName = "******";
var adminUser = await UserRepository.FindByNormalizedUserNameAsync(
LookupNormalizer.NormalizeName(adminUserName)
);
if (adminUser != null)
{
return(result);
}
adminUser = new IdentityUser(GuidGenerator.Create(), adminUserName, adminEmail, tenantId)
{
Name = adminUserName
};
(await UserManager.CreateAsync(adminUser, adminPassword)).CheckErrors();
result.CreatedAdminUser = true;
var adminRole = await RoleRepository.FindByNormalizedNameAsync(
LookupNormalizer.NormalizeName(ScoringRoleNames.Admin)
);
if (adminRole == null)
{
adminRole = new IdentityRole(GuidGenerator.Create(), ScoringRoleNames.Admin, tenantId)
{
IsStatic = true,
IsPublic = false
};
(await RoleManager.CreateAsync(adminRole)).CheckErrors();
result.CreatedAdminRole = true;
}
(await UserManager.AddToRoleAsync(adminUser, ScoringRoleNames.Admin)).CheckErrors();
var multiTenancySides = CurrentTenant.GetMultiTenancySide();
await GrantedAllPermissionsToAdminUser(adminUser, multiTenancySides);
return(result);
}
}
public async Task SendPasswordResetCodeAsync(string userName)
{
if (string.IsNullOrWhiteSpace(userName))
{
throw new ArgumentException("Invalid userName");
}
var userE = await UserManager.FindByNameAsync(LookupNormalizer.NormalizeName(userName)) ?? throw new EntityNotFoundException();
_ = await UserManager.UpdateSecurityStampAsync(userE);
var token = await UserManager.GeneratePasswordResetTotpTokenAsync(userE);
await EmailSender.SendAsync(userE.Email, "Password reset code", token);
}
public DocumentDbFixture()
{
Client = DocumentClientFactory.CreateClient(
serviceEndpoint: new Uri("https://localhost:8081", UriKind.Absolute),
authKeyOrResourceToken: "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==",
connectionPolicy: new ConnectionPolicy()
{
EnableEndpointDiscovery = false
});
Normalizer = new LookupNormalizer();
DatabaseLink = UriFactory.CreateDatabaseUri(this.Database);
UserStoreCollectionLink = UriFactory.CreateDocumentCollectionUri(this.Database, this.UserStoreDocumentCollection);
RoleStoreCollectionLink = UriFactory.CreateDocumentCollectionUri(this.Database, this.RoleStoreDocumentCollection);
CreateTestDatabase();
}
public async Task Should_Eager_Load_User_Collections()
{
var john = await UserRepository.FindByNormalizedUserNameAsync(LookupNormalizer.NormalizeName("john.nash"));
john.Roles.ShouldNotBeNull();
john.Roles.Any().ShouldBeTrue();
john.Logins.ShouldNotBeNull();
john.Logins.Any().ShouldBeTrue();
john.Claims.ShouldNotBeNull();
john.Claims.Any().ShouldBeTrue();
john.Tokens.ShouldNotBeNull();
john.Tokens.Any().ShouldBeTrue();
john.OrganizationUnits.ShouldNotBeNull();
john.OrganizationUnits.Any().ShouldBeTrue();
}
public DocumentDbIdentityUserBuilder AddRole(DocumentDbIdentityRole role = null)
{
if (role == null)
{
LookupNormalizer normalizer = new LookupNormalizer();
string newRoleName = Guid.NewGuid().ToString().ToUpper();
role = new DocumentDbIdentityRole()
{
Id = Guid.NewGuid().ToString().ToUpper(),
Name = newRoleName,
NormalizedName = normalizer.Normalize(newRoleName)
};
}
else
{
identityUser.Roles.Add(role);
}
return(this);
}
public async Task ResetPasswordAsync(string userName, string resetCode, string password)
{
if (string.IsNullOrWhiteSpace(userName) ||
string.IsNullOrWhiteSpace(resetCode) ||
string.IsNullOrWhiteSpace(password))
{
throw new ArgumentException();
}
var userE = await UserManager.FindByNameAsync(LookupNormalizer.NormalizeName(userName)) ?? throw new EntityNotFoundException();
if (!(await UserManager.VerifyPasswordResetTotpTokenAsync(userE, resetCode)))
{
throw new BusinessException();
}
await UserManager.RemovePasswordAsync(userE);
await UserManager.AddPasswordAsync(userE, password);
await UserManager.UpdateSecurityStampAsync(userE);
}
public async Task <bool> IsUsernameAvailable(string username)
{
return((await IdentityUserRepository.FindByNormalizedUserNameAsync(LookupNormalizer.NormalizeName(username))) == null);
}
public async System.Threading.Tasks.Task ModifyUserRolesChangesAsync(ApplicationUser user, string[] roles)
{
var userStore = new UserStore <ApplicationUser>(_context);
/* var manager = new UserManager<ApplicationUser>(userStore);
* Severity Code Description Project File Line Suppression State
* Error CS70 36
* There is no argument given that corresponds to the required formal parameter 'optionsAccessor'
* of 'UserManager<ApplicationUser>.UserManager(IUserStore<ApplicationUser>, IOptions<IdentityOptions>,
* IPasswordHasher<ApplicationUser>, IEnumerable<IUserValidator<ApplicationUser>>, IEnumerable<IPasswordValidator<ApplicationUser>>,
* ILookupNormalizer, IdentityErrorDescriber, IServiceProvider, ILogger<UserManager<ApplicationUser>>)'
* RateMyTeam D:\Projects\MembersRating\RateMyTeam\SeedData\SeedSampleData.cs 381 Active
*/
var passwordHasher = new PasswordHasher <ApplicationUser>();
var itemsValidators = new List <UserValidator <ApplicationUser> >();
itemsValidators.Add(new UserValidator <ApplicationUser>());
var passwordValidators = new List <PasswordValidator <ApplicationUser> >();
passwordValidators.Add(new PasswordValidator <ApplicationUser>());
var keyNormalizer = new LookupNormalizer();
var errors = new IdentityErrorDescriber();
//LoggerFactory logger = new LoggerFactory<ApplicationUserManager<ApplicationUser>>();
/*
* var _userManager = new UserManager<ApplicationUser>(
* userStore,
* null,
* passwordHasher,
* itemsValidators,
* passwordValidators,
* null,
* errors,
* services, null
* );
*/
// ApplicationUserManager _userManager = services.GetService(typeof(ApplicationUserManager)) as ApplicationUserManager;
//services.GetService<UserManager<ApplicationUser>>();
//UserManager<ApplicationUser> _userManager = dbContext.GetService<UserManager<ApplicationUser>>();
//var store = new UserStore(dbContext);
//if (_userManager == null)
// _userManager = new ApplicationUserManager(new UserStore<ApplicationUserManager<ApplicationUser>>(dbContext));
//var passwordHasher = new PasswordHasher();
// UserManager<ApplicationUser> _userManager = new UserManager<ApplicationUser>(store );
//ApplicationUser user = await _userManager.FindByEmailAsync(email);
var blUserExist = false;
var user_rec = _context.Users.SingleOrDefault(u => u.NormalizedEmail == user.Email.ToUpper());
if (user_rec != null)
{
blUserExist = true;
}
/*
* var listUserRoles = new List<IdentityRole>();
*
* foreach (string role in roles) {
* var role2 = new IdentityRole( role );
* var role_rec = _context.Roles.SingleOrDefault(r => r.NormalizedName == role.ToUpper());
* if (role_rec == null) {
* _roleManager.CreateAsync(role2).Wait();
* }
* else {
* _roleManager.UpdateAsync(role2).Wait();
* var userRole = new IdentityUserRole<string>
* {
* RoleId = role_rec.Id
* };
* user.Roles.Add(userRole);
* }
* userStore.AddToRoleAsync(user, role ).Wait();
* listUserRoles.Add(role2);
* }
*/
foreach (string role in roles)
{
var blUserIsInRole = await _userManager.IsInRoleAsync(user, role);
if (!blUserIsInRole)
{
await _userManager.AddToRoleAsync(user, role);
}
/*
* var = await _userManager.IsInRoleAsync(user_rec, "" );
*
* if (!await _userManager.IsInRoleAsync(user, adminRole.Name)) {
* await userManager.AddToRoleAsync(user, adminRole.Name);
* }*/
}
if (!blUserExist)
{
//var listUserRoles = user.Roles;
//user.Roles = listUserRoles;
//userStore.AddToRoleAsync(user, listUserRoles).Wait();
}
else
{
/*
* IdentityResult roleRuslt = isExist ? await _roleManager.UpdateAsync(role2).Wait()
* : await _roleManager.CreateAsync(role2).Wait()
*/
//_context.Entry(user).State = EntityState.Detached;
//_userManager.AddToRoleAsync(user, role).Wait();
//userStore.UpdateAsync(user).Wait();
}
try {
_context.SaveChanges();
}
catch (Exception ex) {
Console.WriteLine(ex.Message);
}
// var result = await _userManager.AddToRolesAsync(user, roles );
}
public virtual async Task <IdentityDataSeedResult> SeedAsync(
string adminPhoneNumber,
string adminPassword,
Guid?tenantId = null)
{
Check.NotNullOrWhiteSpace(adminPhoneNumber, nameof(adminPhoneNumber));
Check.NotNullOrWhiteSpace(adminPassword, nameof(adminPassword));
var result = new IdentityDataSeedResult();
//"超管账号" 用户
const string adminName = "超管账号";
string adminUserName = adminPhoneNumber; // 将用户名设置为手机号 userName -> phoneNumber(默认)
var adminUser = await UserRepository.FindByNormalizedUserNameAsync(
LookupNormalizer.NormalizeName(adminUserName)
);
if (adminUser != null)
{
return(result);
}
adminUser = new IdentityUser(
// GuidGenerator.Create (),
new Guid("716d0fe6-3101-057b-ba30-39f53e403930"),
adminUserName,
adminPhoneNumber,
tenantId
)
{
Name = adminName
};
(await UserManager.CreateAsync(adminUser, adminPassword)).CheckErrors();
result.CreatedAdminUser = true;
//"超级管理员" 角色
const string adminRoleName = "超级管理员";
var adminRole = await RoleRepository.FindByNormalizedNameAsync(LookupNormalizer.NormalizeName(adminRoleName));
if (adminRole == null)
{
adminRole = new IdentityRole(
// GuidGenerator.Create (),
new Guid("63eab816-3619-a6d7-c82b-39f53e403b4a"),
adminRoleName,
tenantId
)
{
IsStatic = true,
IsPublic = true
};
(await RoleManager.CreateAsync(adminRole)).CheckErrors();
result.CreatedAdminRole = true;
}
(await UserManager.AddToRoleAsync(adminUser, adminRoleName)).CheckErrors();
return(result);
}
public async Task <AppUserDto> GetByUsername(string username)
{
var userE = await IdentityUserRepository.FindByNormalizedUserNameAsync(LookupNormalizer.NormalizeName(username));
return(ObjectMapper.Map <Volo.Abp.Identity.IdentityUser, AppUserDto>(userE));
}
public async Task FindByNormalizedUserNameAsync()
{
(await UserRepository.FindByNormalizedUserNameAsync(LookupNormalizer.NormalizeName("john.nash"))).ShouldNotBeNull();
(await UserRepository.FindByNormalizedUserNameAsync(LookupNormalizer.NormalizeName("undefined-user"))).ShouldBeNull();
}
public async Task FindByNormalizedEmailAsync()
{
(await UserRepository.FindByNormalizedEmailAsync(LookupNormalizer.NormalizeEmail("*****@*****.**"))).ShouldNotBeNull();
(await UserRepository.FindByNormalizedEmailAsync(LookupNormalizer.NormalizeEmail("*****@*****.**"))).ShouldNotBeNull();
(await UserRepository.FindByNormalizedEmailAsync(LookupNormalizer.NormalizeEmail("*****@*****.**"))).ShouldBeNull();
}
