public async void Task_DeleteAccount_OkResult()
{
//Arrange
var controller = new ComptesAPIController(repository);
//Act
string username = RandomString(7);
var account = new RegisterAccountViewModel()
{
Name = "Test name",
Username = username,
Email = "*****@*****.**",
Password = "******",
RepeatPassword = "******"
};
var existingAccount = await controller.AddAccount(account);
var okResult = existingAccount.Should().BeOfType <OkObjectResult>().Subject;
var result = okResult.Value.Should().BeAssignableTo <Account>().Subject;
var data = await controller.Delete(result.Id);
//Assert
Assert.IsType <OkObjectResult>(data);
}
private async Task <GNOrganization> InsertNewOrganization(RegisterAccountViewModel model)
{
GNOrganization org = null;
try
{
//insert new Org
org = new GNOrganization
{
Name = model.OrgName,
UTCOffsetDescription = model.UTCOffsetDescription,
AWSConfigId = base.db.AWSConfigs.FirstOrDefault().Id,
CreateDateTime = DateTime.Now,
};
org = await organizationService.Insert(org);
}
catch (Exception ex)
{
var ex2 = new Exception("Unable to add Organization.", ex);
LogUtil.Error(logger, ex2.Message, ex2);
throw ex2;
}
return(org);
}
public async Task RegisterAccountPost_Test()
{
var userWebService = new Mock <IUserService>();
var userName = "******";
var password = "******";
var email = "Test Email";
var role = "Operator";
var defaultContext = new DefaultHttpContext()
{
User = new ClaimsPrincipal()
};
var controller = new AccountController(userWebService.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = defaultContext
}
};
var registerAccountViewModel = new RegisterAccountViewModel
{
UserName = userName,
Password = password,
Email = email,
Role = role
};
var result = await controller.RegisterAccount(registerAccountViewModel);
Assert.IsInstanceOfType(result, typeof(ViewResult));
}
public async Task <IActionResult> RegisterAccount(RegisterAccountViewModel model)
{
// If invalid details, return current view.
if (!ModelState.IsValid)
{
return(View(model));
}
// Else create the Identity and store it
var user = new AppUser
{
Email = model.Email,
UserName = model.UserName,
NormalizedEmail = model.Email.ToLower(),
NormalizedUserName = model.UserName.ToLower()
};
var create = await _usermanager.CreateAsync(user, model.Password);
// If user can't be created, append the errors on the details and return the view.
if (!create.Succeeded)
{
foreach (var error in create.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
await _signinManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
public ActionResult Register(RegisterAccountViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var request = model.ConvertToRegisterUserLoginRequest();
var response = _membershipService.RegisterUserLogin(request);
if (response.UserLogin.IsAuthenticated)
{
var authCookie = SetRegistrationCookie(response);
Response.Cookies.Add(authCookie);
return(RedirectToLocal(returnUrl));
}
model.HasIssues = true;
model.ErrorMessage = !string.IsNullOrEmpty(response.ErrorMessage)
? response.ErrorMessage
: "Sorry we could not authenticate you. Please try again.";
return(View(model));
}
public async Task <ActionResult> RegisterAccount([FromForm] RegisterAccountViewModel model)
{
var token = GetPayLoad("payload");
var accountRegistrationClaim = GetClaim <RequestTokenClaim>(token);
var validateClaimResponse = await MediatorService.Send(new ValidateTokenRequest {
Token = accountRegistrationClaim.Token
});
if (!validateClaimResponse.IsSuccessful)
{
return(ResponseResult(validateClaimResponse));
}
model.Password = Convert.ToBase64String(
model.Password.GetBytes(Encoding.UTF8).ToArray());
var mappedAccount = Map <RegisterAccountViewModel, Account>(model);
var response = await MediatorService
.Send(new RegisterAccountRequest { Account = mappedAccount });
return(ResponseResult(response));
}
public async Task <IActionResult> Register([FromBody] RegisterAccountViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new User();
user.Name = model.Name;
user.Email = model.Email;
user.UserName = model.Email;
IdentityResult resultUser = await _userManager.CreateAsync(user, model.Password);
if (resultUser.Succeeded)
{
var roleUser = Roles.User.ToString().ToLower();
await _userManager.AddToRoleAsync(user, roleUser);
}
if (!resultUser.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(resultUser, ModelState)));
}
return(new OkObjectResult("Account created"));
}
public async Task <IActionResult> RegisterAccount(RegisterAccountViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
City = model.City
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
if (signInManager.IsSignedIn(User) && User.IsInRole("Admin"))
{
return(RedirectToAction("ListUsers", "Administration"));
}
await signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("index", "home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public async Task Should_Create_Account_When_Email_Or_Username_Is_NOT_Taken()
{
//Arrange
var userViewModel = new RegisterAccountViewModel
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Rasmus",
LastName = "Bak",
Phonenumber = "28929173",
Password = "******"
};
var user = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Rasmus",
LastName = "Bak",
PhoneNumber = "28929173",
};
_mocker.Mapper.Setup(x => x.Map <ApplicationUser>(userViewModel)).Returns(user);
userRepoMock.Setup(x => x.IsEmailOrUsernameTaken(user)).ReturnsAsync(false);
var response = new Response(true, null, null);
authServiceMock.Setup(x => x.RegisterUser(It.IsAny <ApplicationUser>(), userViewModel.Password)).ReturnsAsync(response);
//Act
var actual = await _sut.RegisterUser(userViewModel);
//Assert
Assert.True(actual.IsSuccess);
}
public ActionResult CreateAndEdit(RegisterAccountViewModel objRegister)
{
try
{
Validate(objRegister);
if (ModelState.IsValid)
{
Mapper.CreateMap <RegisterAccountViewModel, User>();
var objSave = Mapper.Map <User>(objRegister);
objSave.PassWord = Hashing.HashPassword(objSave.PassWord);
db.Users.Add(objSave);
//Update
if (objRegister.UserId > 0)
{
db.Entry(objSave).State = EntityState.Modified;
}
db.SaveChanges();
string url = Url.Action("RenderListUser", "UserManagement");
return(Json(new { success = true, url = url }));
}
return(PartialView("NewUserPatial", objRegister));
}
catch (Exception ex)
{
objRegister.Message = ex.ToString();
return(PartialView("NewUserPatial", objRegister));
}
}
public async Task <IActionResult> AddAccount([FromBody] RegisterAccountViewModel model)
{
model.Name = model.Name.Trim();
model.Password = model.Password.Trim();
model.RepeatPassword = model.RepeatPassword.Trim();
var targetAccount = accountRepository.GetByUserName(model.Username);
//db.Accounts.SingleOrDefault(a => a.Username == model.Username);
if (targetAccount != null)
{
return(BadRequest("Compte Existe déja."));
}
if (!model.Password.Equals(model.RepeatPassword))
{
return(BadRequest());
}
var hasher = new PasswordHasher <Account>();
var account = new Account {
Name = model.Name, Username = model.Username, Email = model.Email, RegistrationDateTime = DateTime.Now
};
account.PasswordHash = hasher.HashPassword(account, model.Password);
await accountRepository.AddAccount(account);
return(Ok(account));
}
public void RegisterAccount_WhenRegisterFails_ShouldReturnModelErrorState()
{
_userServiceMock.Setup(
x => x.RegisterAccount(It.IsAny <SiteUser>()))
.Returns(Task.FromResult(new ContactIdentityResult
(
new IdentityResult("We have an error"),
CustomerContact.CreateInstance()
)));
var model = new RegisterAccountViewModel
{
Email = "*****@*****.**",
AcceptMarketingEmail = true,
Password = "******",
Password2 = "Passwors@124#212",
};
model.Address = new AddressModel
{
Line1 = "Address",
City = "City",
CountryName = "Country",
FirstName = "Fisrt Name",
LastName = "Last Name",
PostalCode = "952595",
};
var result = _subject.RegisterAccount(model);
_subject.ModelState.Values.First().Errors.First().ErrorMessage.Should().Be("We have an error");
}
public async Task AddUserAsync(RegisterAccountViewModel model)
{
var url = "/Account/register";
var json = JsonConvert.SerializeObject(model);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var result = await _httpService.ExecuteQuery(url, HttpOperationMode.POST, httpContent);
}
public async Task <bool> CreateUser(RegisterAccountViewModel model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user != null)
{
throw new ApplicationException($"Email {model.Email} is already taken.");
}
var newUser = new ApplicationUser();
newUser.Email = model.Email;
newUser.UserName = model.Email.Substring(0, model.Email.IndexOf("@"));
newUser.EmailConfirmed = true;
newUser.FirstName = model.FirstName;
newUser.LastName = model.LastName;
newUser.UserImage = model.UserImage;
var identityResult = await _userManager.CreateAsync(newUser, model.Password);
if (!identityResult.Succeeded)
{
throw new ApplicationException("");
}
return(identityResult.Succeeded);
}
public async Task <ActionResult> AccountConfirm(RegisterAccountViewModel model)
{
string captchaErrorMsg = "Incorrect Captcha Response";
bool captchaValid = this.IsCaptchaValid(captchaErrorMsg);
if (!captchaValid)
{
ModelState.AddModelError("CaptchaCode", captchaErrorMsg);
LoadTimeZones(null);
return(View("Account"));
}
else if (ModelState.IsValid)
{
AspNetUser user = contactService.aspNetRoleService.db.AspNetUsers.Where(u => u.Email == model.Email).FirstOrDefault();
if (user != null)
{
model.IsExistingUser = true;
}
model.Password = "";
model.PasswordConfirm = "";
}
LoadTimeZones(model);
return(View(model));
}
public IActionResult Register()
{
var model = new RegisterAccountViewModel();
model.Classes = _context.Classes.Select(e => e).ToList();
return(View(model));
}
public void Add(RegisterAccountViewModel viewModel, Role role)
{
if (Context.Users.Any(usr => usr.Login.ToLower() == viewModel.Login))
{
throw new Exception("Istnieje użytkownik o podanym loginie");
}
if (Context.Users.Any(user => user.Email == viewModel.Email))
{
throw new Exception("Istnieje użytkownik o podanym mailu");
}
var salt = _hashHelper.GetSalt();
Add(new User()
{
Login = viewModel.Login, //string.Format("{0}.{1}", viewModel.FirstName.ToLower(), viewModel.LastName.ToLower()),
Password = _hashHelper.Compute(viewModel.Password, salt),
Salt = salt,
PasswordCreated = DateTime.Now,
Created = DateTime.Now,
Email = viewModel.Email,
FirstName = viewModel.FirstName,
LastName = viewModel.LastName,
Sex = viewModel.Sex,
Role = role
});
try
{
// Context.SaveChanges();
}
catch (DbEntityValidationException e)
{
logger.Error(e, e.Message);
}
}
public async Task <ActionResult> Register([FromForm] RegisterAccountViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
model.Password = Convert.ToBase64String(model.Password
.GetBytes(Encoding.UTF8)
.ToArray());
var mappedAccount = Map <RegisterAccountViewModel, Account>(model);
var result = await AccountManager.CreateAsync(mappedAccount);
if (result.Succeeded)
{
return(RedirectToAction("Login", "Account", new LoginViewModel {
EmailAddress = model.EmailAddress
}));
}
AddModelStateErrors(result.Errors);
//AddErrorsToModelState(response);
return(await ViewWithContent(ContentConstants.RegisterContentPath, model));
}
public async Task<IdentityResult> RegisterUser(RegisterAccountViewModel userInfo)
{
var user = new User
{
Email = userInfo.Email,
UserName = userInfo.UserName,
FirstName = userInfo.FirstName,
SecondName = userInfo.SecondName,
AvailabilityStatus = UserAvailabilityStatus.Offline
};
if (userInfo.File != null)
{
user.AvatarUrl = imageStoreService.Save(
userInfo.File.FileName,
userInfo.File.OpenReadStream());
}
var result = await userManager.CreateAsync(user, userInfo.Password);
if (!result.Succeeded)
{
return result;
}
result = await userManager.AddToRoleAsync(user, "User");
return result;
}
public async Task <IActionResult> RegisterAccount(RegisterAccountViewModel viewModel)
{
try
{
var registerAccountDto = new RegisterAccountDto
{
CurrentUserId = User.FindFirstValue(ClaimTypes.NameIdentifier),
UserName = viewModel.UserName,
Password = viewModel.Password,
Email = viewModel.Email,
Role = viewModel.Role
};
await this.service.RegisterAccountAsync(registerAccountDto);
}
catch (UserExeption ex)
{
return(View("Message", new MessageViewModel {
Message = ex.Message
}));
}
return(View("Message", new MessageViewModel
{
Message = $"Successful registration",
IsSuccess = true
}));
}
public void LogOff_Should_Succeed()
{
// arrange
var userName = "******";
var password = "******";
var fullName = "fullName";
var tuple = CreateAccountController(new AccountTestOptions
{
Username = userName,
Password = password,
FullName = fullName,
userAccounts = new List <UserAccount>()
});
var controller = tuple.Item1;
var loginManager = tuple.Item4;
var vm = new RegisterAccountViewModel
{
AccountNumber = userName,
Password = password,
AccountName = fullName,
InitialBalance = 1
};
// act
var actionResult = controller.LogOff() as RedirectToActionResult;
// assert
Assert.NotNull(actionResult);
Assert.Equal(actionResult.ActionName, "Login");
Assert.Equal(actionResult.ControllerName, "Account");
loginManager.Verify(c => c.SignOutAsync(), Times.Once);
}
public async Task <ActionResult> Register(RegisterAccountViewModel model)
{
try
{
if (ModelState.IsValid)
{
var result = await bookstoreService.RegiserNewAccount(model.Email, model.Password);
if (string.IsNullOrEmpty(result))
{
ModelState.AddModelError("", "Something went wrong!");
return(View(model));
}
else if (result.StartsWith("ERROR"))
{
ModelState.AddModelError("", result);
return(View(model));
}
else
{
ViewBag.Message = result;
ViewBag.IsError = false;
return(RedirectToAction("Login"));
}
}
return(View(model));
}
catch
{
return(View(model));
}
}
public async Task <ActionResult> RegisterUser(RegisterAccountViewModel model)
{
if (ModelState.IsValid)
{
//create user first
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
//if user is created
if (result.Succeeded)
{
//add role to user
var store = new RoleStore <IdentityRole>(_context);
var manager = new RoleManager <IdentityRole>(store);
var role = manager.FindById(model.IdentityRoleId);
UserManager.AddToRole(user.Id, role.Name);
return(RedirectToAction("Index", "Users"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
model.Roles = _context.Roles.ToList();
return(View("UsersForm", model));
}
public CheckoutMethodViewModel() : base()
{
LoginViewModel = new LoginViewModel();
RegisterAccountViewModel = new RegisterAccountViewModel
{
Address = new AddressModel()
};
}
public async Task AutologinUserAsync(RegisterAccountViewModel model)
{
var loginModel = new LoginAccountViewModel();
loginModel.Email = model.Email;
loginModel.Password = model.Password;
await GetUserAsync(loginModel);
}
public ActionResult New()
{
var viewModel = new RegisterAccountViewModel {
Roles = _context.Roles.ToList()
};
return(View("UsersForm", viewModel));
}
public async Task <ActionResult> Register(bool isModal = false)
{
var registerAccountViewModel = new RegisterAccountViewModel {
IsModal = isModal
};
return(await ViewWithContent(ContentConstants.RegisterContentPath, registerAccountViewModel));
}
public async Task <ActionResult> RegisterAccount(RegisterAccountViewModel viewModel)
{
if (viewModel.CurrentPage == null)
{
viewModel.CurrentPage = ContentReference.IsNullOrEmpty(StartPage.LoginRegistrationPage)
? new LoginRegistrationPage()
: _contentLoader.Get <LoginRegistrationPage>(StartPage.LoginRegistrationPage);
}
if (!ModelState.IsValid)
{
_addressBookService.LoadAddress(viewModel.Address);
return(View(viewModel));
}
viewModel.Address.BillingDefault = true;
viewModel.Address.ShippingDefault = true;
viewModel.Address.Email = viewModel.Email;
var customerAddress = CustomerAddress.CreateInstance();
_addressBookService.MapToAddress(viewModel.Address, customerAddress);
var user = new SiteUser
{
UserName = viewModel.Email,
Email = viewModel.Email,
Password = viewModel.Password,
FirstName = viewModel.Address.FirstName,
LastName = viewModel.Address.LastName,
RegistrationSource = "Registration page",
AcceptMarketingEmail = viewModel.AcceptMarketingEmail,
Addresses = new List <CustomerAddress>(new[] { customerAddress }),
IsApproved = true
};
var registration = await UserService.RegisterAccount(user);
if (registration.Result.Succeeded)
{
if (user.AcceptMarketingEmail)
{
var token = await _optinService.CreateOptinTokenData(user.Id);
SendMarketingEmailConfirmationMail(user.Id, registration.Contact, token);
}
var returnUrl = GetSafeReturnUrl(Request.UrlReferrer);
return(Json(new { ReturnUrl = returnUrl }, JsonRequestBehavior.DenyGet));
}
_addressBookService.LoadAddress(viewModel.Address);
AddErrors(registration.Result.Errors);
return(PartialView("RegisterAccount", viewModel));
}
public async Task <IActionResult> Register(RegisterAccountViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser()
{
Title = titles.FirstOrDefault(x => x.Id == model.TitleId).Value,
Forename = model.Forename,
Initial = model.Initial,
Surname = model.Surname,
DecorationId = model.DecorationId,
AddressLine1 = model.AddressLine1,
AddressLine2 = model.AddressLine2,
AddressLine3 = model.AddressLine3,
County = model.County,
Postcode = model.Postcode,
Country = model.Country,
PhoneNumber = model.PhoneNumber,
Email = model.Email,
UserName = model.Email,
IsNewsletterSubscriber = model.IsNewsletterSubscriber
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signManager.SignInAsync(user, false);
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
model = new RegisterAccountViewModel()
{
Decorations = _context.Decorations.Select(x => new SelectListItem()
{
Value = x.Id.ToString(),
Text = x.Name
}).ToList(),
Titles = titles.Select(x => new SelectListItem()
{
Value = x.Id.ToString(),
Text = x.Value
})
};
}
}
}
var errors = ModelState.Where(x => x.Value.Errors.Any())
.Select(x => new { x.Key, x.Value.Errors });
return(View(model));
}
public async Task <RegisterAccountResultViewModel> RegisterAccount(RegisterAccountViewModel model)
{
var emailExistsMessage = "Dit e-mailadres kan niet worden gebruikt om een account te registeren!";
var emailExistsRequest = _mapper.Map <UserEmailExistsRequest>(model);
var emailExistsResponse = await _bus.RequestAsync(emailExistsRequest);
if (emailExistsResponse.EmailExists)
{
return(new RegisterAccountResultViewModel
{
Message = emailExistsMessage
});
}
var userKey = Guid.NewGuid();
var createIdentityRequest = _mapper.Map <CreateIdentityRequest>(model);
createIdentityRequest.UserKey = userKey;
var createIdentityResponse = await _bus.RequestAsync(createIdentityRequest);
if (createIdentityResponse.IsSuccess)
{
var createUserRequest = _mapper.Map <CreateUserRequest>(model);
createUserRequest.UserKey = userKey;
var createUserResponse = await _bus.RequestAsync(createUserRequest);
if (createUserResponse.IsSuccess)
{
await SendActivationTokenEmail(createIdentityRequest.UserName, model.EmailAddress, createIdentityResponse.ActivationToken);
return(new RegisterAccountResultViewModel
{
Success = true,
Message = $"Het account is succesvol geregistreerd! Er is een e-mail verzonden naar {model.EmailAddress} om het account te activeren."
});
}
return(new RegisterAccountResultViewModel
{
Message = "Er is een fout opgetreden bij het afronden van de registratie van je account. Probeer het later opnieuw!"
});
}
if (createIdentityResponse.ErrorType == ErrorType.EmailExists)
{
return(new RegisterAccountResultViewModel
{
Message = emailExistsMessage
});
}
return(new RegisterAccountResultViewModel
{
Message = "Er is een fout opgetreden bij het registeren van je account. Probeer het later opnieuw!"
});
}
