public async Task <IActionResult> Login(UserRegisterDto userLogin)
{
var userFromDb = await _userService.Login(userLogin.Username.ToLower(), userLogin.Password);
if (userFromDb == null)
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, userFromDb.Id.ToString()),
new Claim(ClaimTypes.Name, userFromDb.Username)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwtSecret));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var tokenDescriptor = new SecurityTokenDescriptor()
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(5),
SigningCredentials = creds,
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
return(Ok(new
{
token = tokenHandler.WriteToken(token)
}));
}
public async Task <UserRegisteredDto> RegisterUserAsync(UserRegisterDto userRegisterDto)
{
var existingUser = await this._userManager.FindByEmailAsync(userRegisterDto.Email);
if (existingUser != null)
{
return(new UserRegisteredDto
{
Succeeded = false,
Error = AccountServiceConstants.UserWithMailExist,
});
}
var newUser = _mapper.Map <User>(userRegisterDto);
var createdUser = await this._userManager.CreateAsync(newUser, userRegisterDto.Password);
var returnedUser = new UserRegisteredDto
{
Succeeded = createdUser.Succeeded
};
if (!createdUser.Succeeded)
{
returnedUser.Error = string.Join(" ", createdUser.Errors.Select(x => x.Description));
returnedUser.User = _mapper.Map <UserDto>(newUser);
return(returnedUser);
}
await _userManager.AddToRoleAsync(newUser, Roles.User);
returnedUser.User = _mapper.Map <UserDto>(newUser);
returnedUser.User.Roles = await _userManager.GetRolesAsync(newUser);
return(returnedUser);
}
public async Task <IActionResult> Register(UserRegisterDto userRegisterDto)
{
if (ModelState.IsValid)
{
var user = _mapper.Map <User>(userRegisterDto);
// добавляем пользователя
var result = await _userManager.CreateAsync(user, userRegisterDto.Password);
if (result.Succeeded)
{
var currentUser = await _userManager.FindByEmailAsync(user.Email);
await _userManager.AddToRoleAsync(currentUser, "User");
await _emailService.SendAsync(SeccessRegisterSettings.subject,
SeccessRegisterSettings.CteateMessage(userRegisterDto), userRegisterDto.Email);
// установка куки
await _signInManager.SignInAsync(user, false);
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
return(View(userRegisterDto));
}
public IDataResult <UserResponseDto> Register(UserRegisterDto userRegisterDto)
{
HashingHelper.CreatePasswordHash(userRegisterDto.Password, out byte[] passwordHash, out byte[] passwordSalt);
var user = new User
{
FirstName = userRegisterDto.FirstName,
LastName = userRegisterDto.LastName,
EMail = userRegisterDto.EMail,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt
};
var result = _userService.Add(user);
var userResponse = new UserResponseDto
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
EMail = user.EMail,
};
if (!result.Success)
{
userResponse.AccessToken = null;
return(new ErrorDataResult <UserResponseDto>(userResponse));
}
userResponse.AccessToken = CreateAccessTokenMine(user);
return(new SuccessDataResult <UserResponseDto>(Messages.UserRegistered, userResponse));
}
/// <inheritdoc/>
public async Task IsRegisterRequestValid(UserRegisterDto model)
{
var passwordList = _provider.GetBlacklistedPasswords();
if (passwordList.Contains(model.Password))
{
throw new AccountCreationException("Provided password is too weak.");
}
var user = new IdentityUser
{
UserName = model.Username
};
foreach (var userValidator in _userManager.UserValidators)
{
var validationResult = await userValidator.ValidateAsync(_userManager, user);
if (!validationResult.Succeeded)
{
throw new AccountCreationException("One or multiple errors occured during account creation",
validationResult.Errors.Select(x => x.Description));
}
}
}
public async Task <IActionResult> Register(UserRegisterDto userDto)
{
try
{
userDto.Dni = userDto.Dni;
if (await _repo.UserExist(userDto.Dni))
{
return(BadRequest("User already exists"));
}
User userToCreate = new User
{
Name = userDto.Name,
LastName = userDto.LastName,
Dni = userDto.Dni,
Email = userDto.Email,
LastLogin = DateTime.Now
};
var createdUser = await _repo.Register(userToCreate, userDto.Password);
return(StatusCode(201));
}
catch (Exception)
{
return(StatusCode(500, "Registration failed."));
}
}
public async Task <IActionResult> Register(UserRegisterDto model)
{
var userDb = await _authRepo.FindByUserNameAsync(model.UserName);
if (userDb != null)
{
return(BadRequest("Username is already used."));
}
var userToCreate = _mapper.Map <User>(model);
var result = await _authRepo.CreateUserAsync(userToCreate, model.Password);
if (!result.Succeeded)
{
return(BadRequest("Registration Failed."));
}
await _authRepo.AddToRoleAsync(userToCreate, RolePrefix.User);
var accessToken = await CreateAccessTokenAsync(userToCreate);
var refreshToken = await CreateRefreshTokenAsync(userToCreate.Id);
await _uow.CompleteAsync();
return(CreatedAtRoute("", new {
accessToken = new JwtSecurityTokenHandler().WriteToken(accessToken),
refreshToken = refreshToken.Value
}));
}
public async Task <ActionResult> Register(UserRegisterDto user)
{
if (this.ModelState.IsValid)
{
var createdUser = new UserIdentity {
UserName = user.Login, Email = user.Email
};
var result = await this.UserManager.CreateAsync(createdUser, user.Password);
if (result.Succeeded)
{
// return this.View(user);
return(this.RedirectToAction("Login", "Account"));
}
else
{
foreach (var resultError in result.Errors)
{
this.ModelState.AddModelError(" ", resultError);
}
}
}
return(this.View(user));
}
public IActionResult Authenticate([FromBody] UserRegisterDto userRegisterDto)
{
var user = _userRepository.Authenticate(userRegisterDto.userName, userRegisterDto.password);
if (user == null)
{
return(BadRequest(new { message = "Usuario o clave incorrecta." }
));
}
// Generate JWT
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.idUser.ToString())
}),
Expires = DateTime.UtcNow.AddHours(2),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
// return basic user info (without password) and token to store client side
return(Ok(new {
idUser = user.idUser,
name = user.name,
lastName = user.lastName,
username = user.userName,
state = user.state,
token = tokenString
}));
}
public async Task <ActionResult <UserDto> > Register(UserRegisterDto userRegisterDto)
{
if (await UserExists(userRegisterDto.Email))
{
return(BadRequest("Email is taken"));
}
using var hmac = new HMACSHA512();
var user = new User
{
FirstName = userRegisterDto.FirstName,
LastName = userRegisterDto.LastName,
Email = userRegisterDto.Email.ToLower(),
Phone = userRegisterDto.Phone,
PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(userRegisterDto.Password)),
PasswordSalt = hmac.Key
};
_unitOfWork.UserRepository.Add(user);
await _unitOfWork.Complete();
return(new UserDto
{
Email = user.Email,
Token = _tokenService.CreateToken(user)
});
}
public async Task RegisterAsync(UserRegisterDto userRegister)
{
var student = await _studentRepository.GetByAsync(st => st.StudentId == userRegister.StudentId);
if (student == null)
{
throw new Exception("There is no such student in database");
}
if (student.UserId != null)
{
throw new Exception("This student has user");
}
var user = await _userRepository.GetByAsync(u => u.Login == userRegister.Login);
if (user != null)
{
throw new Exception("User " + user.Login + " exist in database");
}
await _userRepository.CreateAsync(new User
{
Login = userRegister.Login,
Password = userRegister.Password,
Role = Roles.Student
});
var createdUser = await _userRepository.GetByAsync(u => u.Login == userRegister.Login);
student.UserId = createdUser.Id;
await _studentRepository.UpdateAsync(student);
}
public HttpResponseMessage Register(UserRegisterDto register)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Geçerli kayıt yapınız!"));
}
User myUser = _userDal.GetEntitiesByFilter(x => x.Email == register.Email).FirstOrDefault();
if (myUser == null)
{
myUser = new User();
myUser.FirstName = register.FirstName;
myUser.LastName = register.LastName;
myUser.Email = register.Email;
myUser.Password = register.Password;
myUser.Phone = register.Phone;
string cerezKodu = Guid.NewGuid().ToString("n").Substring(0, 12);
myUser.Cookie = cerezKodu;
_userDal.Add(myUser);
return(Request.CreateResponse(HttpStatusCode.OK, cerezKodu));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, register.Email + " adresiyle kayıt olunmuş!"));
}
}
public async Task <ActionResult <UserDto> > Register(UserRegisterDto userRegisterDto)
{
if (await UserExists(userRegisterDto.Username))
{
return(BadRequest("Username already exists"));
}
var user = _mapper.Map <AppUser>(userRegisterDto);
using var hmac = new HMACSHA512();
user.UserName = userRegisterDto.Username.ToLower();
user.PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(userRegisterDto.Password));
user.PasswordSalt = hmac.Key;
_context.Users.Add(user);
await _context.SaveChangesAsync();
return(new UserDto
{
Username = user.UserName,
Token = _tokenService.CreateToken(user),
Nickname = user.NickName
});
}
public async Task <User> Register(UserRegisterDto newuser, string password)
{
try
{
ServiceResponse <UserAuthDto> response = new ServiceResponse <UserAuthDto>();
CreatePasswordHash(password, out byte[] passwordHash, out byte[] passwordSalt);
User user = _mapper.Map <User>(newuser);
if (await UserExists(user.Email) == true)
{
return(null);
}
user.createdAt = DateTime.Now;
user.updatedAt = DateTime.Now;
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _context.Users.AddAsync(user);
await _context.SaveChangesAsync();
return(user);
}
catch (Exception ex)
{
_logger.Log(LogLevel.Error, ex.StackTrace);
_logger.Log(LogLevel.Error, ex.Message);
return(null);
}
}
public IActionResult Register(UserRegisterDto userRegisterDto)
{
var userExistsResult = _authService.UserWithEmailAlreadyExists(userRegisterDto.Email);
if (!userExistsResult.Success)
{
return(BadRequest(new ErrorResult(userExistsResult.Message)));
}
var registerResult = _authService.Register(userRegisterDto);
if (!registerResult.Success)
{
return(BadRequest(new ErrorResult(registerResult.Message)));
}
var tokenResult = _authService.CreateAccessToken(registerResult.Data);
if (!tokenResult.Success)
{
return(BadRequest(new ErrorResult(tokenResult.Message)));
}
return(Ok(new SuccessDataResult <AccessToken>(tokenResult.Data, registerResult.Message)));
}
public async Task <User> Register(UserRegisterDto userResgister)
{
byte[] passwordHash, passwordSalt;
var user = new User
{
Email = userResgister.Email,
UserType = userResgister.UserType,
FirstName = userResgister.FirstName,
LastName = userResgister.LastName
};
if (user.UserType != Utility.BaseEnums.UserType.Teacher)
{
user.Status = Utility.BaseEnums.UserStatus.Approved;
}
else
{
user.Status = Utility.BaseEnums.UserStatus.Pending;
}
CreatePasswordHash(userResgister.Password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _dbContext.Users.AddAsync(user);
await _dbContext.SaveChangesAsync();
return(user);
}
public async Task <AppIdentityResultWrapper> AddUserAsync(UserRegisterDto userToRegister)
{
var preparedUser = PrepareUserForCreation(userToRegister);
IdentityResult identityResult;
var resultWrapper = new AppIdentityResultWrapper
{
ModelErrors = new ModelStateDictionary()
};
if (String.IsNullOrEmpty(userToRegister.Password))
{
identityResult = await base.CreateAsync(preparedUser);
}
else
{
identityResult = await base.CreateAsync(preparedUser, userToRegister.Password);
}
if (identityResult.Succeeded)
{
resultWrapper.Succeeded = identityResult.Succeeded;
resultWrapper.UserId = preparedUser.Id;
resultWrapper.UserName = preparedUser.UserName;
return(resultWrapper);
}
identityResult.Errors.ToList().ForEach(err => resultWrapper.ModelErrors.AddModelError("", err));
return(resultWrapper);
}
public async Task <UserLoginDto> Register(UserRegisterDto input)
{
var exist = await db.AnyAsync <User>(u => u.UserName == input.UserName);
if (exist)
{
throw new Exception(string.Format("User {0} already existed", input.UserName));
}
User user = new User
{
UserName = input.UserName,
PassWord = input.Password,
Email = input.Email
};
var userLogin = new UserLoginDto();
try
{
await db.AddAsync <User>(user);
userLogin.UserName = user.UserName;
userLogin.Email = user.Email;
userLogin.Token = Nam.ULTILS.JWTToken.AuthenticationToken.CreateJWTToken(user);
}
catch (Exception ex)
{
throw new Exception(ex.ToString());
}
return(userLogin);
}
public async Task <ActionResult <UserDto> > Register(UserRegisterDto userRegisterDto)
{
if (CheckEmailExixtAsync(userRegisterDto.Email).Result.Value)
{
return(BadRequest(new ApiValidationErrorResponse {
Errors = new [] { "Email está en uso" }
}));
}
var user = new AppUser {
DisplayName = userRegisterDto.DisplayName,
Email = userRegisterDto.Email,
UserName = userRegisterDto.Email
};
var resut = await _userManager.CreateAsync(user, userRegisterDto.Password);
if (!resut.Succeeded)
{
return(Unauthorized(new ApiResponse(400)));
}
return(new UserDto {
DisplayName = user.DisplayName,
Email = user.Email,
Token = _tokenService.CreateToken(user)
});
}
public async Task <UserDto> Register(UserRegisterDto model)
{
User user = new User()
{
SecurityStamp = Guid.NewGuid().ToString(),
UserName = model.PhoneNumber,
Email = model.Email,
PhoneNumber = model.PhoneNumber,
Name = model.Name,
BirthYear = model.BirthYear,
RegisterDate = DateTime.Now,
Gender = model.Gender
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
if (!await _roleManager.RoleExistsAsync(UserRoles.Player))
{
await _roleManager.CreateAsync(new IdentityRole(UserRoles.Player));
}
await _userManager.AddToRoleAsync(user, UserRoles.Player);
}
var userDto = _mapper.Map <UserDto>(user);
return(userDto);
}
public UserDisplayDto CreateUser(UserRegisterDto user)
{
User createdUser = new User
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
PasswordHash = Util.HashHelper.GetMD5HashData(user.Password),
UserName = user.UserName,
CreatedOn = DateTime.Now
};
LMSEntities context = new LMSEntities();
UserRepository userRepository = new UserRepository(context);
createdUser = userRepository.Add(createdUser);
UserDisplayDto displayUser = new UserDisplayDto
{
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
};
return(displayUser);
}
public async Task <ActionResult> Register([FromBody] UserRegisterDto userRegister)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var user = new ApplicationUser
{
FirstName = userRegister.FirstName,
LastName = userRegister.LastName,
UserName = userRegister.Email,
Email = userRegister.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, userRegister.Password);
if (result.Succeeded)
{
return(CustomResponse(await _authenticationService.GenerateJWT(userRegister.Email)));
}
foreach (var error in result.Errors)
{
AddProccessError(error.Description);
}
return(CustomResponse());
}
public async Task <IActionResult> Register([FromBody] UserRegisterDto register,
[FromQuery] RegisterParams registerParams)
{
if (await _authRepo.UserExist(register.Username))
{
ModelState.AddModelError("Username", "Username Already Exist");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
User newUser = new User
{
Username = register.Username,
FirstName = register.FirstName,
LastName = register.LastName,
Phone = register.Phone,
Email = register.Email
};
User createdUser = await _authRepo.Register(newUser, register.Password);
return(StatusCode(201));
}
public async Task <Guid> Create(UserRegisterDto userRegisterDto)
{
var user = userBuilder.Build(userRegisterDto);
await userDataService.AddAsync(user);
return(user.Id);
}
public async Task <ServiceResponse <string> > Register(UserRegisterDto userRegisterDto)
{
if (await UserExists(userRegisterDto.Username))
{
return(ResponseResult.Failure <string>("User already exists"));
}
CreatePasswordHash(userRegisterDto.Password, out byte[] passwordHash, out byte[] passwordSalt);
User user = new User
{
Id = Guid.NewGuid(),
Username = userRegisterDto.Username,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt
};
_db.Users.Add(user);
await _db.SaveChangesAsync();
var token = CreateToken(user);
return(ResponseResult.Success(token));
}
public async Task <IActionResult> Register([FromBody] UserRegisterDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.Password != model.RePassword)
{
return(BadRequest("Password and RePassword not match"));
}
model.Username = model.Username.ToLower();
if (await this._authService.UserExists(model.Username))
{
return(BadRequest("Username already exists"));
}
var userToCreate = _mapper.Map <User>(model);
var createdUser = await this._authService.Register(userToCreate, model.Password);
var userToReturn = _mapper.Map <UserForDetailDto>(createdUser);
return(StatusCode(201));
}
public async Task <IActionResult> Register([FromBody] UserRegisterDto userRegisterDto)
{
// check if the user exists
if (await _authRepository.UserExits(userRegisterDto.UserName))
{
ModelState.AddModelError(userRegisterDto.UserName, "Username already exits");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userToCreate = new User
{
UserName = userRegisterDto.UserName,
UserRole = userRegisterDto.UserRole
// Other Information Regarding to User
};
// Create user
var createdUser = await _authRepository.Register(userToCreate, userRegisterDto.Password);
return(StatusCode(201));
}
public async Task <IActionResult> Login(UserRegisterDto UserLoginDto)
{
var userFromRepo = await _repo.Login(UserLoginDto.Username.ToLower(), UserLoginDto.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, userFromRepo.Id.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.Username)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config.GetSection("AppSettings:Token").Value));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = creds
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
return(Ok(new {
token = tokenHandler.WriteToken(token)
}));
}
public async Task <IActionResult> Register([FromBody] UserRegisterDto user)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!user.ConfirmPassword.Equals(user.Password))
{
return(BadRequest("Your passwords are not equals."));
}
var result = await _userService.Register(user);
if (!result)
{
return(BadRequest("Register is unsuccessful."));
}
return(Ok());
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
}
public UserDisplayDto CreateUser(UserRegisterDto user)
{
User createdUser = new User
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
PasswordHash = Util.HashHelper.GetMD5HashData(user.Password),
UserName = user.UserName,
CreatedOn = DateTime.Now
};
createdUser = _userRepository.Add(createdUser);
if (createdUser != null)
{
return(AutoMapper.Mapper.Map <User, UserDisplayDto>(createdUser));
}
UserDisplayDto displayUser = new UserDisplayDto
{
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
};
return(displayUser);
}
