public async Task UserCanRegister()
{
using (var webServer = TestHelper.GetTestWeb())
{
var userDto = new CreateUserDto
{
Email = "*****@*****.**",
Password = "******",
Roles = new List <int> {
1
},
Username = "******"
};
var scenarioResult = await webServer.Scenario(x =>
{
x.Post.Json(userDto).ToUrl("/api/Users");
x.StatusCodeShouldBeOk();
});
var resultDto = scenarioResult.ResponseBody.ReadAsJson <UserDto>();
Assert.IsTrue(resultDto.Id > 0, "expected id to be assigned");
}
}
public async Task <Boolean> CreateUser(CreateUserDto user)
{
return(await _repository.CreateEntity(new User()
{
AccessFailedCount = 0,
EmailAddress = user.EmailAddress,
IsEmailConfirmed = false,
EmailConfirmationCode = "",
IsActive = false,
IsLockoutEnabled = false,
IsPhoneNumberConfirmed = false,
IsTwoFactorEnabled = false,
LastLoginTime = DateTime.Now,
Name = user.Name,
Password = user.Password,
PasswordResetCode = "",
PhoneNumber = user.PhoneNumber,
SecurityStamp = "Bill",
Surname = user.Surname,
FullName = user.FullName,
TenantId = user.TenantId
}));
}
/// <summary>
///
/// </summary>
/// <param name="userDto"></param>
/// <returns></returns>
public async Task CreateUserAsync(CreateUserDto userDto)
{
Check.NotNull(userDto, nameof(userDto));
var anyUserPhone = _userRepository
.GetExpression(e => e.PhoneNum == userDto.PhoneNum)
.AsNoTracking()
.Any();
if (anyUserPhone)
{
throw new WsBaseException("已经存在的手机号");
}
var userModel = _userRepository.MapTo(userDto);
userModel.PasswordSalt = StrHelper.CreateStr(6);
userModel.Password = _encryptions.CreateMd5(userDto.Password + userModel.PasswordSalt);
var createResult = await _userRepository.CreateAsync(userModel);
}
public async Task <ActionResult <UserDto> > CreateUser([FromBody] CreateUserDto user)
{
ApplicationUser iuser = new ApplicationUser
{
UserName = user.LoginName,
Email = user.Email
};
IdentityResult result = await _userManager.CreateAsync(iuser, user.Password);
if (result.Succeeded)
{
string token = await _userManager.GenerateEmailConfirmationTokenAsync(iuser);
_userService.SendConfirmationEmail(token, user.Email, user.LoginName);
await _signInManager.SignInAsync(iuser, false);
return(_userService.GenerateJwtToken(iuser));
}
return(new UserDto {
IdentityError = result.Errors
});
}
public async Task CreateUserConflictTest()
{
// Test conflicts
using (var scope = _fixture.Server.Host.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService <DatabaseFixture>().Context;
var appUserService = scope.ServiceProvider.GetRequiredService <IAppUsersService>();
var createdUser = await appUserService.Create(new AppUser
{
Email = "*****@*****.**",
UserName = "******",
});
// Test Email conflict request
var emailConflict = new CreateUserDto
{
Email = createdUser.Email,
UserName = "******"
};
using (var response = await SendCreateUserRequest(emailConflict))
{
Assert.Equal(HttpStatusCode.Conflict, response.StatusCode);
}
// Test Email conflict request
var usernameConflict = new CreateUserDto
{
Email = "*****@*****.**",
UserName = createdUser.UserName
};
using (var response = await SendCreateUserRequest(usernameConflict))
{
Assert.Equal(HttpStatusCode.Conflict, response.StatusCode);
}
}
}
public async Task AddTeamLeader(CreateUserDto CreateUserDto)
{
try
{
var teamLeader = new TeamLeader
{
FirstName = CreateUserDto.FirstName,
LastName = CreateUserDto.LastName,
Age = CreateUserDto.Age,
UserName = CreateUserDto.UserName,
Email = CreateUserDto.Email,
EmailConfirmed = true
};
Db.TeamLeaders.Add(teamLeader);
var result = await UserManager.CreateAsync(teamLeader, CreateUserDto.Password);
if (result.Succeeded)
{
Db.UserRoles.Add(new IdentityUserRole <string>
{
UserId = teamLeader.Id,
RoleId = "3"
});
Db.SaveChanges();
}
else
{
var Error = result.Errors;
}
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> Register([FromBody] CreateUserDto model)
{
try
{
var checkUser = await _userAppService.GetUserByEmailAddress(model.EmailAddress);
if (checkUser != null)
{
return(BadRequest($"User with {model.EmailAddress} already exists"));
}
var userId = await _userAppService.InsertUser(model);
if (userId < 1)
{
return(BadRequest("Your registration failed, please contact administrator or try again"));
}
return(Ok($"User with the Id of {userId} created successfully"));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public IHttpActionResult Register(CreateUserDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (_userService.FindByUsername(model.Username) != null)
{
return(BadRequest("Username already exists."));
}
var user = new User
{
Id = Guid.NewGuid(),
Username = model.Username,
Password = model.Password,
CreateDateTime = DateTime.Now
};
user = _userService.Add(user);
return(Ok(Mapper.Map <BasicUserDto>(user)));
}
public async Task <IActionResult> Register(RegisterUserViewModel model)
{
var userToCreate = new CreateUserDto
{
FirstName = model.FirstName,
LastName = model.LastName,
BirthDate = model.BirthDate,
Gender = model.Gender,
PersonalId = model.PersonalId,
Password = model.Password,
Email = model.Email
};
var response = await _clientWrapper.PostAsync("api/Users", userToCreate);
if (!response.IsSuccessStatusCode)
{
ModelState.AddModelError("", await response.Content.ReadAsStringAsync());
return(View());
}
await LoginAsync(model.Email);
return(RedirectToAction("Index", "Employees"));
}
