public async Task <IActionResult> RegisterUser([FromBody] UserRegisterRequestDto pUserRegister)
{
//valida el modelo
if (pUserRegister == null)
{
return(BadRequest());
}
//valida los datos
if (string.IsNullOrEmpty(pUserRegister.Email) ||
string.IsNullOrEmpty(pUserRegister.Password) ||
string.IsNullOrEmpty(pUserRegister.UserName))
{
return(Ok(new
{
CodigoError = Constantes.Error002,
IsSuccess = false,
IsWarning = true,
Message = "No se pudo realizar el registro,intente denuevo.",
}));
}
var response = await _usuarioApplication.UserRegister(pUserRegister);
return(Ok(response));
}
public async Task <JsonResult> RegisterAsync([FromBody] UserRegisterRequestDto userDto)
{
var(token, error) = await _registerService.RegisterAsync(userDto);
return(error == null?Json(token)
: Json(new { Error = error }));
}
public async Task <UserRegisterResponseDto> CreateAsync(UserRegisterRequestDto user, string password)
{
try
{
var userModel = _mapper.Map <User>(user);
var existingUser = _repositoryWraper.Users.FindByCondition(x => x.Email == user.Email).FirstOrDefault();
if (existingUser != null)
{
throw new ServiceCustomException("This Username is already taken");
}
var hashPassword = _passwordService.CreatePasswordHash(password);
userModel.PasswordSalt = hashPassword.Item1;
userModel.PasswordHash = hashPassword.Item2;
_repositoryWraper.Users.Create(userModel);
await _repositoryWraper.SaveAsync();
return(new UserRegisterResponseDto()
{
Id = userModel.Id, FirstName = userModel.FirstName, LastName = userModel.LastName
});
}
catch (ServiceCustomException ex)
{
throw ex;
}
catch (Exception ex)
{
_loggerManager.LogError($"Error in file name UserService.cs on function CreateAsync : {ex}");
throw ex;
}
}
public async Task <ActionResult> Register([FromBody] UserRegisterRequestDto request)
{
try
{
return(Ok(await _userService.Register(request)));
}
catch (Exception e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message));
}
}
public async Task <IActionResult> Register([FromBody] UserRegisterRequestDto registerRequestDto,
CancellationToken cancellationToken = default(CancellationToken))
{
if (_userService.UserExist(registerRequestDto.Email))
{
var errorMessage = ApiResponse.CreateErrorMessage(ErrorMessages.EmailExists, ErrorMessages.EmailKey);
return(BadRequest(new ApiResponse(StatusCodes.Status400BadRequest, errorMessage)));
}
var registerResponseDto = await _userService.CreateUserAsync(registerRequestDto, cancellationToken);
return(Ok(new ApiOkResponse(registerResponseDto)));
}
public async Task <UserRegisterResponseDto> Register(UserRegisterRequestDto register)
{
try
{
var validate = new UserRegisterValidator().Validate(register);
if (!validate.IsValid)
{
return(new UserRegisterResponseDto()
{
Sucess = false,
Message = validate.Errors[0].ErrorMessage
});
}
var userExists = await _repository.UserExists(register.Email);
if (userExists)
{
return(new UserRegisterResponseDto()
{
Sucess = false,
Message = "Usuário já existe, tente outro email"
});
}
else
{
var result = _mapper.Map <UserEntityDto>(await _repository.InsertAsync(_mapper.Map <User>(register)));
return(new UserRegisterResponseDto()
{
Sucess = true,
Message = "Usuário cadastrado com sucesso",
User = result
});
}
}
catch (Exception e)
{
return(new UserRegisterResponseDto()
{
Sucess = false,
Message = "Ocorreu um erro, tente novamente " + e.Message
});
}
}
public async Task <UserRegisterResponseDto> CreateUserAsync(UserRegisterRequestDto userRegisterRequestDto, CancellationToken cancellationToken)
{
GeneratePasswordHashAndSalt(userRegisterRequestDto.Password, out var passwordHash, out var passwordSalt);
var user = _mapper.Map <User>(userRegisterRequestDto);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _unitOfWork.UserRepository.AddAsync(user, cancellationToken);
await _unitOfWork.SaveAsync(cancellationToken);
var accountIdDto = new UserRegisterResponseDto {
Id = user.Id
};
return(accountIdDto);
}
public ActionResult Register(UserRegisterRequestDto userForRegisterDto)
{
var userExists = _authService.UserExists(userForRegisterDto.Email);
if (!userExists.Success)
{
return(BadRequest(userExists.Message));
}
var registerResult = _authService.Register(userForRegisterDto);
var result = _authService.CreateAccessToken(registerResult.Data);
if (!result.Success)
{
return(BadRequest(result.Message));
}
return(Ok(result.Data));
}
public IDataResult <User> Register(UserRegisterRequestDto userForRegisterDto)
{
byte[] passwordHash, passwordSalt;
HashingHelper.CreatePasswordHash(userForRegisterDto.Password, out passwordHash, out passwordSalt);
var user = new User
{
Email = userForRegisterDto.Email,
FirstName = userForRegisterDto.FirstName,
Surname = userForRegisterDto.Surname,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt,
StatusId = (int)EnumStatus.Active
};
if (_userRepository.Insert(user) <= 0)
{
return(new ErrorDataResult <User>(ErrorMessages.RegisterError));
}
return(new SuccessDataResult <User>(user, SuccessMessages.UserRegistered));
}
public async Task <ActionResult <UserDto> > Register([FromBody] UserRegisterRequestDto userRegisterDto)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByNameAsync(userRegisterDto.UserName);
if (user == null)
{
user = new AppUser
{
UserName = userRegisterDto.UserName
};
var result = await _userManager.CreateAsync(user, userRegisterDto.Password);
}
return(Ok(new UserDto {
UserName = user.UserName
}));
}
return(NotFound());
}
public async Task <AuthResponse> Register(UserRegisterRequestDto user)
{
if (await _userRepository.UserExists(user.Email))
{
return(new AuthResponse()
{
Result = false,
Errors = new List <string>()
{
"Email ya existe"
}
});
}
var newUser = new User()
{
Email = user.Email, UserName = user.Email
};
var isCreated = await _userRepository.CreateUser(newUser, user.Password);
if (isCreated.Succeeded)
{
var jwtToken = GenerateJwtToken(newUser);
return(new AuthResponse()
{
Result = true,
Token = jwtToken
});
}
throw new HandlerException(
HttpStatusCode.InternalServerError,
isCreated.Errors.Select(x => x.Description).ToList()
);
}
public async Task <Response <int> > UserRegister(UserRegisterRequestDto pUserRegisterDto)
{
var response = new Response <int>();
try
{
//asigna datos
pUserRegisterDto.DateCreate = DateTime.Now;
pUserRegisterDto.Status = 1;
if (pUserRegisterDto == null)
{
response.IsSuccess = false;
response.IsWarning = true;
response.CodigoError = "0";
response.Message = "Registro no válido,intente de nuevo.";
return(response);
}
var responseEmail = await this.ValidateByEmail(pUserRegisterDto.Email);
if (responseEmail.Data)
{
response.IsSuccess = false;
response.IsWarning = true;
response.CodigoError = "0";
response.Message = "Ingrese otro email ya esta registrado.";
return(response);
}
var responseUser = await this.ValidateByUser(pUserRegisterDto.UserName);
if (responseUser.Data)
{
response.IsSuccess = false;
response.IsWarning = true;
response.CodigoError = "0";
response.Message = "Ingrese otro usuario ya esta registrado.";
return(response);
}
//se mapea los datos
var userRegisterEntities = _mapper.Map <UserRegisterEntities>(pUserRegisterDto);
var responseRegister = await _usuarioDomain.UserRegister(userRegisterEntities);
if (responseRegister == 1)
{
response.Data = responseRegister;
response.Message = Constantes.CORRECTO_ADD;
return(response);
}
else
{
response.IsSuccess = false;
response.IsWarning = true;
response.CodigoError = Constantes.Error001;
response.Message = Constantes.ERROR_TRANSACCION;
}
}
catch (Exception ex)
{
response.IsWarning = true;
response.IsSuccess = false;
response.Message = "Error";
_logger.LogError(ex, ex.Message);
}
return(response);
}
/// <summary>
/// 用户注册
/// </summary>
/// <param name="userDto">用于注册的用户信息</param>
/// <returns>异步获取Token的任务，如果发生异常则会返回错误信息</returns>
public async Task <(AccessTokenResponseDto, Dictionary <string, string>)> RegisterAsync(UserRegisterRequestDto userDto)
{
// 如果用户不是通过浏览器在请求接口，失去焦点时验证用户名的动作就没意义
var error = await ValidateUsernameAsync(userDto.Username);
if (!string.IsNullOrEmpty(error))
{
return(null, new Dictionary <string, string>
{
["username"] = error
});
}
// 验证验证码
error = await ValidateCaptchaAsync(userDto.CaptchaId, userDto.CaptchaText);
if (!string.IsNullOrEmpty(error))
{
return(null, new Dictionary <string, string>
{
["captcha"] = error
});
}
try
{
Guid salt = Guid.NewGuid();
var user = new User
{
Username = userDto.Username,
PasswordHash = GeneratePasswordHash(userDto.Password, salt.ToString()),
Salt = salt.ToString(),
// 默认为普通用户
RoleId = (int)Roles.User
};
_dbContext.User.Add(user);
await _dbContext.SaveChangesAsync();
var token = new AccessTokenResponseDto
{
AccessToken = await _tokenAuthService.GenerateAccessTokenAsync(user),
RefreshToken = await _tokenAuthService.GenerateRefreshTokenAsync(user)
};
return(token, null);
}
catch
{
// 因为是多线程，依旧可能用户名重复
// 用户名重复会导致异常
return(null, new Dictionary <string, string>
{
["username"] = _msg.GetMessage("E003", "用户名")
});
}
}
public async Task <IActionResult> Register([FromBody] UserRegisterRequestDto user)
{
var result = await _userService.CreateAsync(user, user.Password);
return(Ok(result));
}
public async Task <IActionResult> Register([FromBody] UserRegisterRequestDto user)
{
return(Ok(await _authService.Register(user)));
}
