public async Task <IActionResult> Register([FromBody] RegisterModelDto model)
{
var userExists = await userManager.FindByNameAsync(model.Username);
if (userExists != null)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new ResponseDto {
Status = "Error", Message = "User already exists!"
}));
}
ApplicationUser user = new ApplicationUser()
{
Email = model.Email,
SecurityStamp = Guid.NewGuid().ToString(),
UserName = model.Username
};
var result = await userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new ResponseDto {
Status = "Error", Message = "User creation failed! Please check user details and try again."
}));
}
return(Ok(new ResponseDto {
Status = "Success", Message = "User created successfully!"
}));
}
public async Task RegisterUserAsync(RegisterModelDto registerModel)
{
string roleNameUs = "User";
try
{
var userManager = _database.UserManager;
var user = await userManager.StoreofUser.FindByNameAsync(registerModel.Email);
if (user != null)
{
throw new Exception("Such user exist alredy");
}
user = new ApplicationUser {
UserName = registerModel.Email, Email = registerModel.Email
};
IdentityResult result = await userManager.CreateAsync(user, registerModel.Password);
if (!result.Succeeded)
{
throw new Exception(@"Can't crete user");
}
user = await userManager.FindByNameAsync(registerModel.Email);
if (!userManager.IsInRole(user.Id, roleNameUs))
{
await userManager.AddToRoleAsync(user.Id, roleNameUs);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
return;
}
public async Task <IActionResult> Register([FromBody] RegisterModelDto registerModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(new BadRequestError("Password and username required.")));
}
var newUser = new User()
{
FirstName = registerModel.FirstName.ToLowerInvariant(),
Email = registerModel.Email.ToLowerInvariant(),
Username = registerModel.Username.ToLowerInvariant(),
};
// Username unique?
var isUsernameUnique = await _wpbService.UsernameUnique(newUser.Username);
if (!isUsernameUnique)
{
return(BadRequest(new BadRequestError($"Username: {registerModel.Username} is already in use.")));
}
// Email unique?
var isEmailUnique = await _wpbService.EmailUnique(newUser.Email);
if (!isEmailUnique)
{
return(BadRequest(new BadRequestError($"Email: {registerModel.Email} is already in use.")));
}
// Add user
await _wpbService.CreateUserAsync(newUser, registerModel.Password);
// Build new user token
var tokenString = GenerateToken(newUser);
// This is just a regular member so we don't need to create any claims
// Add user claim
/*var newClaim = new UserClaim()
* {
* UserId = newUser.Id,
* ClaimName = WpbClaims.ReadTeamData
* };*/
return(Ok(
new
{
Id = newUser.Id.ToString(),
newUser.Username,
newUser.FirstName,
newUser.Email,
Token = tokenString
}));
}
// [ValidateAntiForgeryToken]
public async Task Register(RegisterModelDto model)
{
var result = await _applicationUserService.Create(model);
await Response.WriteAsync(JsonConvert.SerializeObject(result,
new JsonSerializerSettings {
Formatting = Formatting.Indented
}
));
}
public async Task RegisterAsync(RegisterModelDto registerModelDto)
{
ValidateEmail(registerModelDto.Email);
var user = _mapper.Map <User>(registerModelDto);
AppendRole(user, "user");
user.PasswordHash = _cryptoProvider.GetHash(registerModelDto.Password);
await _unitOfWork.Users.CreateAsync(user);
}
public User AddNewUser(RegisterModelDto dto)
{
var user = new User
{
UserName = dto.Email,
Email = dto.Email,
};
_context.Users.Add(user);
_context.SaveChanges();
return(user);
}
public async Task RegisterAsync(RegisterModelDto registerModelDto)
{
ValidateEmail(registerModelDto.Email);
var user = _mapper.Map <User>(registerModelDto);
AppendDefaultRole(user);
user.PasswordHash = _cryptoProvider.GetHash(registerModelDto.Password);
await _unitOfWork.Users.CreateAsync(user);
_logger.LogInformation($"User register with email {registerModelDto.Email}");
}
public async Task RegisterAsync_CallsCreate_IfRegisterModelIsValid()
{
var registerModel = new RegisterModelDto {
Email = "email-stub", Password = "******"
};
_unitOfWorkMock
.Setup(unitOfWork => unitOfWork.Users.Find(It.IsAny <Expression <Func <User, bool> > >()))
.Returns(new List <User>().AsQueryable());
await _sut.RegisterAsync(registerModel);
_unitOfWorkMock.Verify(work => work.Users.CreateAsync(It.IsAny <User>()), Times.Once);
}
public async Task RegisterAsync_ThrowsEntityExistsException_IfUserWithSpecifiedEmailAlreadyExists()
{
var registerModel = new RegisterModelDto {
Email = "email-stub", Password = "******"
};
var users = new List <User> {
new User()
};
_unitOfWorkMock
.Setup(unitOfWork => unitOfWork.Users.Find(It.IsAny <Expression <Func <User, bool> > >()))
.Returns(users.AsQueryable());
await Assert.ThrowsAsync <EntityExistsException>(() => _sut.RegisterAsync(registerModel));
}
public async Task <IActionResult> Register([FromBody] RegisterModelDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest("Parametre Hatalı"));
}
try
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user != null)
{
return(BadRequest("Bu kullanıcı zaten var "));
}
else
{
user = new ApplicationUser
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
UserName = model.UserName
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(Ok(CreateToken(user)));
}
else
{
return(BadRequest(result.Errors));
}
}
}
catch (Exception ex)
{
_logger.LogError($"Kayıt Esnasında Exception Hatası Alındı {ex}");
return(BadRequest($"Yeni kullanıcı kaydı sırasında hata alındı : {ex}"));
}
}
public async Task <IActionResult> Register([FromBody] RegisterModelDto registerModelDto)
{
if (!ModelState.IsValid)
{
return(BadRequest("Parametreler hatalı"));
}
try
{
var user = await _userManager.FindByNameAsync(registerModelDto.UserName);
if (user != null)
{
return(BadRequest("Bu kullanıcı zaten mevcut"));
}
else
{
user = new ApplicationUser
{
FirstName = registerModelDto.FirstName,
LastName = registerModelDto.LastName,
UserName = registerModelDto.UserName,
Email = registerModelDto.Email
};
var result = await _userManager.CreateAsync(user, registerModelDto.Password);
if (result.Succeeded)
{
return(Ok(CreateToken(user)));
}
else
{
return(BadRequest(result.Errors));
}
}
}
catch (Exception ex)
{
_logger.LogError($"Kayıt esnasında exception hatası alındı: {ex}");
return(BadRequest($"Yeni Kullanıcı Kaydı Esnasında Hata Alındı: {ex}"));
}
}
public async Task <UserDto> Create(RegisterModelDto model)
{
var user = _mapper.Map <RegisterModelDto, ApplicationUser>(model);
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var resultRole = await _userManager.AddToRoleAsync(user, model.Role);
if (!resultRole.Succeeded)
{
throw new Exception("Exception added roles!");
}
}
var userDto = _mapper.Map <ApplicationUser, UserDto>(user);
userDto.Password = user.PasswordHash;
userDto.Message = result.Succeeded.ToString();
return(userDto);
}
public async Task <IHttpActionResult> RegisterAsync([FromBody] RegisterViewModel registerModel)
{
if (!ModelState.IsValid)
{
return(InternalServerError());
}
;
RegisterModelDto registerModelDto = new RegisterModelDto()
{
Email = registerModel.Email,
Password = registerModel.Password,
ConfirmPassword = registerModel.ConfirmPassword
};
try
{
await _accountService.RegisterUserAsync(registerModelDto);
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
return(Ok());
}
public async Task <IActionResult> Register([FromBody] RegisterModelDto dto)
{
var user = await _accountSvc.FindUserAsync(dto.Email);
SimpleResponseDto respDto = new SimpleResponseDto();
if (user != null)
{
respDto.Success = false;
respDto.Message = "This email is already taken.";
return(Ok(respDto));
}
user = _mapper.Map <User>(dto);
string code = await _accountSvc.RegisterEmailConfirmationCodeAsync(user);
await _notificationService.SendConfirmEmailMailAsync(code, user);
var newUser = _accountSvc.RegisterUserAsync(user);
respDto.Success = true;
return(Ok(respDto));
}
public async Task <UserManagerResponse> Register([FromBody] RegisterModelDto model)
{
if (ModelState.IsValid)
{
var userCheck = await _userManager.FindByEmailAsync(model.Email);
if (userCheck == null)
{
var user = new User
{
Email = model.Email,
UserName = model.Email,
FirstName = model.FirstName,
LastName = model.LastName
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var resultRole = _roleManager.RoleExistsAsync("user").Result;
if (!resultRole)
{
var role = new Role("user");
var roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
return(new UserManagerResponse
{
Message = "Such User Already Exist"
});
}
}
await _userManager.AddToRoleAsync(user, "user");
await _signInManager.SignInAsync(user, false);
var encodedToken = JwtService.GenerateJwt(user, _userManager, _authenticationOptions);
return(await JwtService.GenerateJwt(user, _userManager, _authenticationOptions));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
return(new UserManagerResponse
{
Message = "Error"
});
}
}
}
return(new UserManagerResponse
{
Message = "User With Such Email Already Exist",
IsSucces = false
});
}
return(new UserManagerResponse
{
Message = "Successfully",
IsSucces = true
});
}
