public async Task <SignUpViewModel> SignUp(SignUpInputModel signUpInputModel)
{
bool isOng = signUpInputModel.Document.Length > 11;
string profile = isOng ? UserProfileEnum.ONG.ToString() : UserProfileEnum.VOLUNTARY.ToString();
int personId = await _personRepository.AddPerson(new Person(signUpInputModel.Name, signUpInputModel.Phone));
if (personId > 0)
{
if (isOng)
{
await _personRepository.AddLegalPerson(new LegalPerson(signUpInputModel.Document, personId));
await _ongRepository.Add(new Ong(null, null, string.Empty, string.Empty, personId));
}
else
{
await _personRepository.AddPhysicalPerson(new PhysicalPerson(signUpInputModel.Document, personId));
}
}
int userId = await _userRepository.Add(new User(signUpInputModel.Password, profile, signUpInputModel.Facebook_Unique_id, signUpInputModel.Email, personId));
return(new SignUpViewModel(userId > 0));
}
public BaseResponseModel SignUp(SignUpInputModel inputModel)
{
var vm = new AuthResponseModel();
// Validate request
var validationState = new ValidationDictionary();
inputModel.ValidateRequest(validationState);
var user = new User
{
Email = inputModel.Email,
Role = Role.Member
};
UserService.GenerateUserPassword(user, inputModel.Password);
if (UserService.ValidateUser(user, validationState))
{
UserService.CreateUser(user);
// Authenticate to create token
user = UserService.Authenticate(user.Email, inputModel.Password);
_auth.DoAuth(user.Email, false);
vm.Success = true;
vm.Token = user.AuthToken.Token;
vm.Expires = user.AuthToken.Expires;
}
vm.Errors = validationState.Errors;
return(vm);
}
public void SignUp_Successful_For_Valid_User()
{
// Arrange
var inputModel = new SignUpInputModel
{
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
var user = new User()
{
Email = inputModel.Email,
AuthToken = new AuthToken()
};
var userService = new Mock <IUserService>();
userService.Setup(u => u.Authenticate(It.IsAny <string>(), It.IsAny <string>())).Returns(user);
userService.Setup(u => u.ValidateUser(It.IsAny <User>(), It.IsAny <IValidationDictionary>())).Returns(true);
var controller = CreateController(userService.Object);
// Act
var result = controller.SignUp(inputModel);
// Assert
Assert.IsTrue(result.Success);
}
public IActionResult SignUp([FromBody] SignUpInputModel inputModel)
{
if (!ModelState.IsValid)
{
BadRequest();
}
var user = _userService.Add(inputModel);
if (inputModel.AddOrganization)
{
_charityService.AddCharity(new CharityAddEditModel()
{
OwnerId = user.Id,
Name = inputModel.OrganizationName,
Description = inputModel.OrganizationDescription,
Category = inputModel.OrganizationType
});
}
if (user == null)
{
BadRequest("Cannot add to db");
}
return(Ok());
}
public async Task <IActionResult> SignUp([FromBody] SignUpInputModel signUpInputModel)
{
var signUpCommand = new SignUpCommand(signUpInputModel);
var signUpViewModel = await _mediator.Send(signUpCommand);
return(CreatedAtAction(nameof(GetUserById), new { userId = signUpViewModel.UserId }, signUpViewModel));
}
public async Task <IActionResult> SignUp([Bind("UserName,Email,Password,PasswordConfirm,IsAgree")] SignUpInputModel signUpInputModel)
{
if (signUpInputModel == null)
{
throw new ArgumentNullException(nameof(signUpInputModel));
}
if (!ModelState.IsValid)
{
return(View(signUpInputModel));
}
MangoUser mangoUser = new MangoUser
{
UserName = signUpInputModel.UserName,
Email = signUpInputModel.Email
};
if (await _userManager.FindByNameAsync(mangoUser.UserName) != null)
{
ModelState.AddModelError("UserName", "该用户名已被注册");
return(View(signUpInputModel));
}
using (var trans = await _transaction.BeginTransactionAsync())
{
try
{
var flag = await _userManager.CreateAsync(mangoUser, signUpInputModel.Password);
mangoUser = await _userManager.FindByNameAsync(mangoUser.UserName);
var roleFlag = await _userManager.AddToRoleAsync(mangoUser, "USER");
if (!flag.Succeeded || !roleFlag.Succeeded)
{
ViewData["Message"] = "Registration error occurred!";
trans.Rollback();
}
else
{
ViewData["Message"] = "Registration Successful!";
trans.Commit();
}
}
catch
{
trans.Rollback();
throw;
}
}
return(View("ResultPage"));
}
public User Add(SignUpInputModel inputModel)
{
if (Exists(inputModel.EmailAddress))
{
return(null);
}
var user = mapper.Map <SignUpInputModel, User>(inputModel);
context.Users.Add(user);
context.SaveChanges();
return(user);
}
public void SignUp_Failed_For_Invalid_User()
{
// Arrange
var inputModel = new SignUpInputModel
{
};
var userService = new Mock <IUserService>();
var controller = CreateController(userService.Object);
// Act
var result = controller.SignUp(inputModel);
// Assert
Assert.IsFalse(result.Success);
}
public async Task <IActionResult> SignUp(SignUpInputModel model, string button)
{
var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
if (button != "signup")
{
if (context != null)
{
await _interaction.GrantConsentAsync(context, ConsentResponse.Denied);
return(Redirect(model.ReturnUrl));
}
else
{
return(Redirect("~/"));
}
}
var user = new User {
UserName = model.Username, Email = model.Username
};
var passwordHash = _userManager.PasswordHasher.HashPassword(user, model.Password);
user.PasswordHash = passwordHash;
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
if (_interaction.IsValidReturnUrl(model.ReturnUrl) || Url.IsLocalUrl(model.ReturnUrl))
{
return(Redirect(model.ReturnUrl));
}
return(Redirect("~/"));
}
var vm = new SignUpViewModel
{
ReturnUrl = model.ReturnUrl,
Username = model.Username
};
return(View(vm));
}
public async Task <IActionResult> SignUp([FromBody] SignUpInputModel signUpInputModel)
{
if (await _userService.EmailExists(signUpInputModel.Email))
{
return(BadRequest("E-mail already registered!"));
}
var documentExist = await _userService.DocumentExists(signUpInputModel.Document);
if (!string.IsNullOrEmpty(documentExist))
{
return(BadRequest(documentExist));
}
var retorno = await _userService.SignUp(signUpInputModel);
return(Ok(retorno));
}
public void Validate_Successful_With_Valid_Information()
{
// Arrange
var model = new SignUpInputModel
{
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
var validationDictionary = new ValidationDictionary();
// Act
var result = model.ValidateRequest(validationDictionary);
// Assert
Assert.IsTrue(result);
}
public void Validate_Fails_Mismatched_Passwords()
{
// Arrange
var model = new SignUpInputModel
{
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
var validationDictionary = new ValidationDictionary();
// Act
var result = model.ValidateRequest(validationDictionary);
// Assert
Assert.IsFalse(result);
}
public IActionResult SignUp(SignUpInputModel signUpInputModel)
{
return(Created("", signUpInputModel));
}
