public async Task Should_Create_Admin_User_And_Role()
{
await _identityDataSeeder.SeedAsync("1q2w3E*");
(await _userRepository.FindByNormalizedUserNameAsync(_lookupNormalizer.Normalize("admin"))).ShouldNotBeNull();
(await _userRepository.FindByNormalizedUserNameAsync(_lookupNormalizer.Normalize("admin"))).Name.ShouldBe("admin");
(await _roleRepository.FindByNormalizedNameAsync(_lookupNormalizer.Normalize("admin"))).ShouldNotBeNull();
}
public async Task FindByIdAsync()
{
var user = await _identityUserRepository.FindByNormalizedUserNameAsync(_lookupNormalizer.NormalizeName("john.nash"));
user.ShouldNotBeNull();
(await _identityUserLookupAppService.FindByIdAsync(user.Id)).UserName.ShouldBe(user.UserName);
}
public virtual async Task SeedAsync(
string adminUserPassword,
IEnumerable <string> adminRolePermissions = null,
Guid?tenantId = null)
{
const string adminUserName = "******";
const string adminRoleName = "admin";
//"admin" user
var adminUser = await _userRepository.FindByNormalizedUserNameAsync(_lookupNormalizer.Normalize(adminUserName));
if (adminUser != null)
{
return;
}
adminUser = new IdentityUser(_guidGenerator.Create(), adminUserName, "*****@*****.**", tenantId);
CheckIdentityErrors(await _userManager.CreateAsync(adminUser, adminUserPassword));
//"admin" role
var adminRole = await _roleRepository.FindByNormalizedNameAsync(_lookupNormalizer.Normalize(adminRoleName));
if (adminRole == null)
{
adminRole = new IdentityRole(_guidGenerator.Create(), adminRoleName, tenantId);
CheckIdentityErrors(await _roleManager.CreateAsync(adminRole));
if (adminRolePermissions != null)
{
await AddRolePermissionsAsync(adminRole, adminRolePermissions);
}
}
CheckIdentityErrors(await _userManager.AddToRoleAsync(adminUser, adminRoleName));
}
private async Task CreateUserAsync(string userName, string name, string surname, DataSeedContext context)
{
await _identityOptions.SetAsync();
if ((await _identityUserRepository.FindByNormalizedUserNameAsync(_lookupNormalizer.NormalizeName(userName))) != null)
{
return;
}
var user = new IdentityUser(
_guidGenerator.Create(),
userName,
userName + "@abp.io",
context.TenantId
);
user.Name = name;
user.Surname = surname;
await _identityUserManager.CreateAsync(user,
"1q2w3E*"
);
await _identityUserManager.AddToRoleAsync(user, "admin");
}
public async Task Should_Set_Email_Of_A_User()
{
IdentityUser adminUser;
await WithUnitOfWorkAsync(async() =>
{
adminUser = await _identityUserRepository.FindByNormalizedUserNameAsync("ADMIN");
await _identityUserManager.SetEmailAsync(adminUser, "*****@*****.**");
await _identityUserManager.UpdateAsync(adminUser);
});
adminUser = await _identityUserRepository.FindByNormalizedUserNameAsync("ADMIN");
adminUser.Email.ShouldBe("*****@*****.**");
}
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(),
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 Should_Set_Email_Of_A_User()
{
IdentityUser adminUser;
/* Need to manually start Unit Of Work because
* FirstOrDefaultAsync should be executed while db connection / context is available.
*/
await WithUnitOfWorkAsync(async () =>
{
adminUser = await _identityUserRepository
.FindByNormalizedUserNameAsync("ADMIN");
await _identityUserManager.SetEmailAsync(adminUser, "*****@*****.**");
await _identityUserRepository.UpdateAsync(adminUser);
});
adminUser = await _identityUserRepository.FindByNormalizedUserNameAsync("ADMIN");
adminUser.Email.ShouldBe("*****@*****.**");
}
public async Task SendMessage(string targetUserName, string message)
{
var targetUser = await _identityUserRepository.FindByNormalizedUserNameAsync(_lookupNormalizer.NormalizeName(targetUserName));
message = $"{CurrentUser.UserName}: {message}";
await Clients
.User(targetUser.Id.ToString())
.SendAsync("ReceiveMessage", message);
}
public async Task SetRolesAsync()
{
using (var uow = _unitOfWorkManager.Begin())
{
var user = await _identityUserRepository.FindByNormalizedUserNameAsync(
_lookupNormalizer.NormalizeName("david")).ConfigureAwait(false);
user.ShouldNotBeNull();
var identityResult = await _identityUserManager.SetRolesAsync(user, new List <string>()
{
"moderator",
}).ConfigureAwait(false);
identityResult.Succeeded.ShouldBeTrue();
user.Roles.ShouldContain(x => x.RoleId == _testData.RoleModeratorId);
await uow.CompleteAsync().ConfigureAwait(false);
}
}
//added for passwordless authentication
public async Task <IActionResult> OnPostGeneratePasswordlessTokenAsync()
{
var adminUser = await _userRepository.FindByNormalizedUserNameAsync("admin");
var token = await UserManager.GenerateUserTokenAsync(adminUser, "PasswordlessLoginProvider",
"passwordless-auth");
PasswordlessLoginUrl = Url.Action("Login", "Passwordless",
new { token = token, userId = adminUser.Id.ToString() }, Request.Scheme);
return(Page());
}
public virtual async Task <IUserData> FindByUserNameAsync(
string userName,
CancellationToken cancellationToken = default)
{
return((
await _userRepository.FindByNormalizedUserNameAsync(
_lookupNormalizer.NormalizeName(userName),
includeDetails: false,
cancellationToken: cancellationToken
)
)?.ToAbpUserData());
}
public async Task AddMemberToOrganizationUnit()
{
using (var uow = _unitOfWorkManager.Begin())
{
var ou111 = await _organizationUnitRepository.GetAsync(
_lookupNormalizer.NormalizeName("OU111"));
var user = await _identityUserRepository.FindByNormalizedUserNameAsync(
_lookupNormalizer.NormalizeName("david"));
user.ShouldNotBeNull();
user.OrganizationUnits.Count.ShouldBe(1);
await _identityUserManager.AddToOrganizationUnitAsync(user.Id, ou111.Id);
await uow.CompleteAsync();
}
var updatedUser = await _identityUserRepository.FindByNormalizedUserNameAsync(
_lookupNormalizer.NormalizeName("david"));
updatedUser.OrganizationUnits.Count.ShouldBe(2);
}
private async Task CreateTestUserAsync()
{
var testUser = await _identityUserRepository.FindByNormalizedUserNameAsync("TEST");
if (testUser == null)
{
testUser = new IdentityUser(_guidGenerator.Create(), "test", "*****@*****.**");
await _identityUserManager.CreateAsync(testUser);
}
await _identityUserManager.RemovePasswordAsync(testUser);
await _identityUserManager.AddPasswordAsync(testUser, "1q2w3E*");
}
public async Task Should_Trigger_Distributed_EntityUpdated_Event()
{
using (var uow = _unitOfWorkManager.Begin())
{
var user = await _userRepository.FindByNormalizedUserNameAsync(_lookupNormalizer.NormalizeName("john.nash"));
await _userManager.SetEmailAsync(user, "*****@*****.**");
_testCounter.GetValue("EntityUpdatedEto<UserEto>").ShouldBe(0);
await uow.CompleteAsync();
}
_testCounter.GetValue("EntityUpdatedEto<UserEto>").ShouldBe(1);
}
private async Task CreateHostUserAsync(DataSeedContext context)
{
var user = await _userRepository.FindByNormalizedUserNameAsync("HostUser");
if (user == null)
{
user = new IdentityUser(
_guidGenerator.Create(),
"HostUser",
"*****@*****.**",
context.TenantId
);
user.SetProperty("IsHostUser", true);
await _userManager.CreateAsync(user, "1q2w3E*");
await _userManager.AddToRoleAsync(user, "admin");
}
}
public async Task RegisterAsync()
{
var registerDto = new RegisterDto
{
UserName = "******",
EmailAddress = "*****@*****.**",
Password = "******",
AppName = "MVC"
};
await _accountAppService.RegisterAsync(registerDto);
var user = await _identityUserRepository.FindByNormalizedUserNameAsync(
_lookupNormalizer.NormalizeName("bob.lee"));
user.ShouldNotBeNull();
user.UserName.ShouldBe("bob.lee");
user.Email.ShouldBe("*****@*****.**");
(await _userManager.CheckPasswordAsync(user, "P@ssW0rd")).ShouldBeTrue();
}
public virtual async Task <IdentityDataSeedResult> SeedAsync(
string adminUserPassword,
Guid?tenantId = null)
{
var result = new IdentityDataSeedResult();
const string adminUserName = "******";
const string adminRoleName = "admin";
//"admin" user
var adminUser = await _userRepository.FindByNormalizedUserNameAsync(_lookupNormalizer.Normalize(adminUserName));
if (adminUser != null)
{
return(result);
}
adminUser = new IdentityUser(_guidGenerator.Create(), adminUserName, "*****@*****.**", tenantId);
adminUser.Name = adminUserName;
CheckIdentityErrors(await _userManager.CreateAsync(adminUser, adminUserPassword));
result.CreatedAdminUser = true;
//"admin" role
var adminRole = await _roleRepository.FindByNormalizedNameAsync(_lookupNormalizer.Normalize(adminRoleName));
if (adminRole == null)
{
adminRole = new IdentityRole(_guidGenerator.Create(), adminRoleName, tenantId);
adminRole.IsStatic = true;
adminRole.IsPublic = true;
CheckIdentityErrors(await _roleManager.CreateAsync(adminRole));
result.CreatedAdminRole = true;
}
CheckIdentityErrors(await _userManager.AddToRoleAsync(adminUser, adminRoleName));
return(result);
}
private async Task CreateUserWithExtraProperty()
{
//"test" user
const string userName = "******";
var user = await UserRepository.FindByNormalizedUserNameAsync(LookupNormalizer.NormalizeName(userName));
if (user != null)
{
return;
}
user = new Volo.Abp.Identity.IdentityUser(
GuidGenerator.Create(),
userName,
"*****@*****.**"
)
{
Name = userName
};
user.SetProperty("WarehouseId", GuidGenerator.Create());
(await UserManager.CreateAsync(user, "1q2w3E*")).CheckErrors();
}
private async Task <IdentityUser> FindUserAsync(string userName)
{
return(await _userRepository.FindByNormalizedUserNameAsync(userName.ToUpperInvariant()));
}
private void AddUserPermissions()
{
var david = AsyncHelper.RunSync(() => _userRepository.FindByNormalizedUserNameAsync(_lookupNormalizer.NormalizeName("david")));
AddPermission(TestPermissionNames.MyPermission1, UserPermissionValueProvider.ProviderName, david.Id.ToString());
}
public static IdentityUser FindByNormalizedUserName(this IIdentityUserRepository repository, [NotNull] string normalizedUserName)
{
return(AsyncHelper.RunSync(() => repository.FindByNormalizedUserNameAsync(normalizedUserName)));
}
public async Task GetUserIdAsync()
{
var user = await _userRepository.FindByNormalizedUserNameAsync(_lookupNormalizer.Normalize("john.nash"));
user.ShouldNotBeNull();
(await _identityUserStore.GetUserIdAsync(user)).ShouldBe(user.Id.ToString());
}
public async Task SendMessageAsync(SendMessageInput input)
{
var targetId = (await _identityUserRepository.FindByNormalizedUserNameAsync(_lookupNormalizer.NormalizeName(input.TargetUserName))).Id;
await _distributedEventBus.PublishAsync(new ReceivedMessageEto(targetId, CurrentUser.UserName, input.Message));
}
private async Task AddUserPermissions()
{
var david = AsyncHelper.RunSync(() => _userRepository.FindByNormalizedUserNameAsync(_lookupNormalizer.NormalizeName("david")));
await AddPermission(TestPermissionNames.MyPermission1, UserPermissionValueProvider.ProviderName, david.Id.ToString()).ConfigureAwait(false);
}
