public async Task <IdentityResult> CreateAsync(SignupDto dto)
{
var user = _mapper.Map <User>(dto);
user.UserName = user.Email;
IdentityResult result = await _userManager.CreateAsync(user, user.Password);
if (result.Succeeded)
{
}
object data = new
{
email = user.Email,
firstName = user.FirstName,
lastName = user.LastName,
created_at = DateTime.Now,
last_login = DateTime.Now,
phones = user.Phones
};
//_repositoryFacade.SetCache(
// user.Email.ToString(), JsonConvert.SerializeObject(
// data, Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, Formatting = Formatting.Indented }));
return(result);
}
public async Task <IActionResult> CreateUserAsync([FromBody] SignupDto dto, [FromServices] IValidator <SignupDto> validator)
{
var validated = await validator.ValidateAsync(dto);
if (!validated.IsValid)
{
return(UnprocessableEntity(validated.Errors.Select(e => new { message = e.ErrorMessage, statusCode = e.ErrorCode }).Distinct()));
}
var user = this._mapper.Map <ApplicationUser>(dto);
user.CreatedAt = DateTime.Now;
IdentityResult result = await _userManager.CreateAsync(user, user.Password);
if (result.Succeeded)
{
var response = await _userManager.FindByEmailAsync(user.Email);
if (response != null)
{
return(Ok(new { message = "successful operation", statusCode = 200 }));
}
return(BadRequest());
}
return(UnprocessableEntity(result.Errors.Where(e => e.Code.ToUpper() == "DuplicateEmail".ToUpper()).Select(e => new { message = "E-mail already exists", statusCode = 422 }).Distinct()));
}
/// <summary>
/// Signups the specified new user.
/// </summary>
/// <param name="newUser">The new user.</param>
/// <returns></returns>
public bool Signup(SignupDto newUser)
{
User user = new User();
var checkUser = glitteDb.Users.Where(i => i.Email == newUser.Email).SingleOrDefault();
try
{
if (checkUser == null)
{
user.Firstname = newUser.Firstname;
user.Lastname = newUser.Lastname;
user.Image = newUser.Image;
user.Country_id = newUser.Country_id;
user.Email = newUser.Email;
user.Password = newUser.Password;
user.Phone = newUser.Phone;
glitteDb.Users.Add(user);
glitteDb.SaveChanges();
return(true);
}
}
catch (Exception) {
return(false);
}
return(false);
}
public async Task <User> Create(SignupDto user)
{
// validation
if (string.IsNullOrWhiteSpace(user.Password))
{
throw new Exception("Password is required");
}
if (await _context.Users.AnyAsync(x => x.Username == user.Username))
{
throw new Exception($"Username {user.Username} is already taken");
}
User newUser = new User();
if (newUser.Id == null)
{
newUser.Id = Guid.NewGuid().ToString();
}
byte[] passwordHash, passwordSalt;
CreatePasswordHash(user.Password, out passwordHash, out passwordSalt);
newUser.Email = user.Email;
newUser.Username = user.Username;
newUser.Name = user.Name;
newUser.PasswordHash = passwordHash;
newUser.PasswordSalt = passwordSalt;
_context.Users.Add(newUser);
_context.SaveChanges();
return(newUser);
}
public bool Signup(SignupDto userData)
{
if (ModelState.IsValid)
{
UserBll userBll = new UserBll();
return(userBll.Signup(userData));
}
return(false);
}
public async Task SignupUser(SignupDto entity)
{
var userToDb = _mapper.Map <SignupDto, User> (entity);
if (userToDb != null)
{
await _userManager.CreateAsync(userToDb, entity.Password);
}
}
public async Task <ActionResult> SignUpUser([FromBody] SignupDto user)
{
if (user == null)
{
return(BadRequest());
}
await _uow.UserRepository.SignupUser(user);
return(Ok(user));
}
public async Task <IDataResult <ApplicationUser> > SignUp(SignupDto registerDto)
{
var result = await _userManager.CreateAsync(new ApplicationUser { UserName = registerDto.Email, Email = registerDto.Email }, registerDto.Password);
if (result.Succeeded)
{
var user = await _userManager.FindByEmailAsync(registerDto.Email);
return(new SuccessDataResult <ApplicationUser>(user, "Başaıyla kaydedildi"));
}
return(new ErrorDataResult <ApplicationUser>("Kayıt Başarısız"));
}
public async Task <IActionResult> SignUp(SignupDto signupDto)
{
var user = new ApplicationUser
{
UserName = signupDto.UserName,
Email = signupDto.Email
};
var result = await this.userService.CreateAsync(user, signupDto.Password);
return(Ok(result));
}
public async Task <ActionResult> Signup([FromBody] SignupDto signupDto)
{
try
{
await this.UserService.Signup(signupDto.username, signupDto.password);
return(Ok(new { message = "Ok!" }));
}
catch (Exception e)
{
return(BadRequest(new { error = e.Message }));
}
}
public async Task <IActionResult> SignUp(SignupDto signupDto)
{
var user = new ApplicationUser
{
UserName = signupDto.Username,
Email = signupDto.Email,
City = signupDto.City
};
var result = await _userManager.CreateAsync(user, signupDto.Password); //password hashleneceği için yukarı yazmadık
if (!result.Succeeded)
{
return(BadRequest(Response <NoContent> .Fail(result.Errors.Select(x => x.Description).ToList(), 400)));
}
return(NoContent());
}
public async Task <IActionResult> SignupAsync(SignupDto dto)
{
var result = await _homeService.CreateAsync(dto);
if (result.Succeeded)
{
_logger.LogInformation("會員 {0} 註冊成功", dto.Account);
return(Ok(result.Data));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(error.Code, error.Description);
}
return(ValidationProblem());
}
public async Task <IActionResult> Signup(SignupDto data)
{
try
{
var signupData = _mapper.Map <User>(data);
_authenticationService.Register(signupData, data.Password);
await _unitOfWork.Save();
var authData = _mapper.Map <AuthDto>(signupData);
return(Ok(authData));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> Signup([FromBody] SignupDto user)
{
try
{
if (user.Password != user.ConfirmPassword)
{
return(BadRequest("Passwords do not match"));
}
var newUser = await _userService.Create(user);
return(Ok(newUser));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> SignupAsync([FromBody] SignupDto signupDto, [FromServices] IValidator <SignupDto> validator)
{
var validated = await validator.ValidateAsync(signupDto);
if (!validated.IsValid)
{
return(BadRequest(validated.Errors.Select(e => new { message = e.ErrorMessage, statusCode = e.ErrorCode }).Distinct()));
}
var result = await _authService.CreateAsync(signupDto);
if (!result.Succeeded)
{
return(Ok(result.Errors.Select(e => new { message = "E-mail already exists", statusCode = 409 })));
}
return(Ok(new { message = "user created", statusCode = 201 }));
}
public async Task <IActionResult> SignUp(SignupDto signupDto)
{
var user = new ApplicationUser
{
UserName = signupDto.UserName,
Email = signupDto.Email,
City = signupDto.City
};
var result = await _userManager.CreateAsync(user, signupDto.Password);
if (!result.Succeeded)
{
return(BadRequest(Response <NoContent> .Fail(result.Errors.Select(x => x.Description).ToList(),
(int)ResponseCodes.BadRequest)));
}
return(NoContent());
}
public async Task <IActionResult> Register(SignupDto signupDto)
{
var userExists = await _authService.UserExists(signupDto.Email);
if (!userExists.IsSuccess)
{
return(BadRequest(userExists.Message));
}
var registerResult = await _authService.SignUp(signupDto);
var result = _authService.CreateAccessToken(registerResult.Data, ipAddress());
if (result.IsSuccess)
{
return(Ok(result.Data));
}
return(BadRequest(result.Message));
}
public async Task <ActionResult <SignupResponseDto> > SignupUser([FromBody] SignupDto signupDetails)
{
// Handle HTTP requests
// Validate incoming models
// Pass on to the relevant service
// Catch any errors
// Return response with valid codes
if (signupDetails == null)
{
throw new BusinessException("No signup details provided");
}
if (!ModelState.IsValid)
{
throw new BusinessException("Invalid model object");
}
//additional code
var response = await _userService.SignupsUserAsync(signupDetails);
return(response);
}
public async Task <IActionResult> Signup(SignupDto signup)
{
if (await _userManager.Users.AnyAsync(u => u.Email == signup.Email.ToLower()))
{
ModelState.AddModelError("EmailAddress", "An account with that email address already exists");
return(new UnprocessableEntityObjectResult(new ValidationProblemDetails(ModelState)));
}
var user = new AppUser
{
Email = signup.Email,
UserName = signup.Email
};
var result = await _userManager.CreateAsync(user, signup.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(error.Code, error.Description);
}
return(new UnprocessableEntityObjectResult(new ValidationProblemDetails(ModelState)));
}
return(CreatedAtAction(
actionName: nameof(UsersController.GetUser),
controllerName: UsersController.ControllerName,
routeValues: new { userId = user.Id },
value: new UserDto
{
Email = user.Email,
PhoneNumber = user.PhoneNumber,
UserId = user.Id,
Username = user.UserName
}));
}
public async Task <ApplicationResult <Member> > CreateAsync(SignupDto dto)
{
var member = await FindByAccountAsync(dto.Account);
if (member == null)
{
return(ApplicationResult <Member> .Failed(new ApplicationError
{
Code = nameof(Member.Account),
Description = "會員已存在!"
}));
}
var newMemberSeq = Guid.NewGuid();
var newMember = new FdMember()
{
MemberSeq = newMemberSeq,
Account = dto.Account,
Password = dto.Password,
CreateTime = DateTime.Now,
UpdateTime = DateTime.Now
};
await _memberRepository.InsertAsync(newMember);
var effectRows = await _unitOfWork.SaveChangesAsync();
var result = effectRows > 0 ? ApplicationResult <Member> .Success : ApplicationResult <Member> .Failed();
if (result.Succeeded)
{
result.Data = _mapper.Map <Member>(newMember);
}
return(result);
}
public bool Signup(SignupDto newUser)
{
operationOnUser = new UserOperation();
return(operationOnUser.Signup(newUser));
}
public async Task <SignupResponseDto> SignupsUserAsync(SignupDto signup)
{
// Use the User ID to retrieve the user that is not verified
var user = await _userRepository.FindByIdAsync(signup.UserId);
if (user == null)
{
throw new BusinessException("User ID does not exist.");
}
else if (user.IsInitialised)
{
throw new BusinessException("User is already initialised.");
}
// Initialise generator for later
var generator = RandomNumberGenerator.Create();
// Name validation
if (signup.Name.Length < 3 || signup.Name.Length > 64)
{
throw new BusinessException("Name length must be between 4-64 characters.");
}
// Password validation
if (signup.Password.Length == 2048)
{
throw new BusinessException("Josh, let's not get ahead of ourselves.");
}
else if (signup.Password.Length < 10 || signup.Password.Length > 1024)
{
throw new BusinessException("Password must be between 10-1024 characeters.");
}
// Check if MFA is required
if (user.MFAEnabled)
{
// Generate a new TOTP Code
if (user.TOTPSecret == "" || signup.MFACode == "")
{
// Generate TOTP
byte[] rndArray = new byte[30];
generator.GetBytes(rndArray);
// var totpSecret = ByteStringConversion.ToString(rndArray);
var totpSecret = Base32Encoding.ToString(rndArray);
if (totpSecret == null || totpSecret == "")
{
throw new BusinessException("Error when trying to create MFA code for user, please tell Dave there is an issue.");
}
// Add it to user
user.TOTPSecret = totpSecret;
// Save the user
_userRepository.Update(user);
await _unitOfWork.CompleteAsync();
// Return TOTP value
return(new SignupResponseDto(false, totpSecret));
}
else // Attempt to validate incoming code
{
var totp = new Totp(Base32Encoding.ToBytes(user.TOTPSecret));
long timeWindowUsed = 0;
var isValid = totp.VerifyTotp(signup.MFACode, out timeWindowUsed, VerificationWindow.RfcSpecifiedNetworkDelay);
if (!isValid)
{
throw new BusinessException("The MFA Code provided was not valid. Please try again.");
}
}
}
// If all previous requirements are met:
// generate the salt
byte[] saltRndArray = new byte[32];
generator.GetBytes(saltRndArray);
var salt = ByteStringConversion.ToString(saltRndArray);
// hash the salt and password
var hashedPassword = "";
using (SHA256 sha256Hash = SHA256.Create())
{
// ComputeHash - returns byte array
byte[] hashedPasswordByteArray = sha256Hash.ComputeHash(Encoding.UTF8.GetBytes(salt + signup.Password));
hashedPassword = ByteStringConversion.ToString(hashedPasswordByteArray);
}
// set the salt and password hash for the user
if (salt != "" || hashedPassword != "")
{
user.PasswordSalt = salt;
user.PasswordHash = hashedPassword;
}
// Set the name
user.Name = signup.Name;
// Set the initialised flag
user.IsInitialised = true;
_userRepository.Update(user);
await _unitOfWork.CompleteAsync();
return(new SignupResponseDto(true, ""));
}
public IActionResult SetupMFA([FromBody] SignupDto signupDetails)
{
throw new NotImplementedException();
}
