public ActionResult CreateAccount(CreateAccountViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
string error;
if (!Recapcha.ValidateCapcha(Request, Request.Form["recaptcha_challenge_field"],
Request.Form["recaptcha_response_field"], out error))
{
viewModel.CapchaError = error;
return(View(viewModel));
}
MembershipCreateStatus status;
var user = Membership.CreateUser(viewModel.Username, viewModel.Password,
viewModel.Email, null, null, true, null, out status);
if (status != MembershipCreateStatus.Success)
{
return(View(viewModel));
}
user.LastActivityDate = DateTime.Now;
FormsAuthentication.SetAuthCookie(viewModel.Username, viewModel.RememberMe);
return(RedirectToAction("Index", "Web"));
}
public ActionResult RegisterSave(CreateAccountViewModel model)
{
if (ModelState.IsValid)
{
ApplicationUser user = new ApplicationUser {
UserName = model.Name, Email = model.Email
};
IdentityResult result = UserManager.Create(user, model.Password);
if (result.Succeeded)
{
UserManager.AddToRole(user.Id, "User");
ClaimsIdentity ident = UserManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);// CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignOut();
AuthManager.SignIn(
new AuthenticationProperties
{
IsPersistent = false
},
ident);
return(RedirectToAction("Index", "PeoplesAward"));
}
else
{
AddErrorsFromResult(result);
}
}
ViewBag.Title = "Регистрация пользователя";
return(View("Register", model));
}
public ActionResult CreateAccount(CreateAccountViewModel viewModel)
{
LocalAuthenticationController.RequireLocalAuthMode();
if (!ModelState.IsValid)
{
return(ViewCreateAccount(viewModel));
}
var theSelectedOrganization = HttpRequestStorage.DatabaseEntities.Organizations.GetOrganization(viewModel.OrganizationID);
Check.EnsureNotNull(theSelectedOrganization);
var existingUser = HttpRequestStorage.DatabaseEntities.People.GetPersonByEmail(viewModel.Email, false);
if (existingUser != null)
{
SetMessageForDisplay($"{existingUser.GetFullNameFirstLastAndOrgAsUrl(CurrentFirmaSession)} already has an account.");
return(RedirectToAction(new SitkaRoute <UserController>(x => x.Detail(existingUser))));
}
var newUser = CreateNewFirmaPersonWithoutKeystone(theSelectedOrganization, viewModel);
HttpRequestStorage.DatabaseEntities.SaveChanges();
var saltAndHash = PBKDF2PasswordHash.CreateHash(viewModel.Password);
var personLoginAccount = new PersonLoginAccount(newUser, newUser.Email, DateTime.Now,
saltAndHash.PasswordHashed, saltAndHash.PasswordSalt, true, 0, 0);
HttpRequestStorage.DatabaseEntities.AllPersonLoginAccounts.Add(personLoginAccount);
HttpRequestStorage.DatabaseEntities.SaveChanges();
SetMessageForDisplay($"{newUser.GetFullNameFirstLastAndOrgAsUrl(CurrentFirmaSession)} successfully added. You may want to assign them a role.");
return(RedirectToAction(new SitkaRoute <UserController>(x => x.Detail(newUser))));
}
public ActionResult CreateAccount()
{
LocalAuthenticationController.RequireLocalAuthMode();
var viewModel = new CreateAccountViewModel();
return(ViewCreateAccount(viewModel));
}
private ActionResult ViewCreateAccount(CreateAccountViewModel viewModel)
{
var firmaPage = FirmaPageTypeEnum.InviteUser.GetFirmaPage();
var viewData = new CreateAccountViewData(CurrentFirmaSession, firmaPage);
return(RazorView <CreateAccount, CreateAccountViewData, CreateAccountViewModel>(viewData, viewModel));
}
public async Task <IActionResult> Register([FromBody] CreateAccountViewModel model)
{
var existingUser = await context.Users.FirstOrDefaultAsync(u => u.Email == model.Email || u.UserName == model.Username);
if (existingUser != null)
{
return(Ok("User already exists."));
}
User user = new User
{
Email = model.Email,
UserName = model.Username
};
var newUser = await userManager.CreateAsync(user);
if (!newUser.Succeeded)
{
return(Ok("Error: Could not create user."));
}
newUser = await userManager.AddPasswordAsync(user, model.Password);
await signInManager.SignInAsync(user, isPersistent : false);
return(Ok("User successfully created!"));
}
public ActionResult Create(CreateAccountViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Username,
Email = model.Email
};
bool b = true;
try
{
UserManager.Create(user, model.Password);
}
catch (Exception e)
{
b = false;
Console.WriteLine(e);
}
if (b)
{
AssignRoleTo(UserManager, Guid.Parse(user.Id), "User");
return(RedirectToAction("ListUsers"));
}
}
return(View(model));
}
public async Task <CommandResult <Guid> > CreateAdmin([FromBody] CreateAccountViewModel accountViewModel)
{
var createAccountCommandModel = _mapper.Map <AccountModel>(accountViewModel);
createAccountCommandModel.AccountRole = AdministratorRoles.Admin_Role;
return(await _accountManager.CreateAccount(createAccountCommandModel));
}
public IActionResult Create(CreateAccountViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var account = new Account(
userID: UserID,
name: model.Name,
type: model.Type.Value,
startingBalance: model.StartingBalance.Value,
isMainAccount: model.IsMainAccount,
isIncludedInNetWorth: model.IncludeInNetWorth,
isDormant: false,
displayOrder: model.DisplayOrder.Value,
numberLast4Digits: model.NumberLast4Digits
);
Db.InsertOrUpdate(account);
UnitOfWork.CommitChanges();
return(RedirectToAction(nameof(Index)));
}
public IActionResult Create(CreateAccountViewModel viewModel)
{
// If basic syntax check returns false return to view with proper messages
// defined in view model annotations.
if (!ModelState.IsValid)
{
return(View());
}
Profile addedProfile = UserAccountServiceLogic.CreateProfile(viewModel);
User addedUser = addedUser = UserAccountServiceLogic.CreateUser(viewModel, addedProfile);
addedProfile.User = addedUser;
if (UserAccountServiceLogic.AddUserAndDependenciesToDB(addedUser, userManager, viewModel, context).Result)
{
ViewBag.Message = localizer["CreateSuccess"];
return(RedirectToAction("Login"));
}
else
{
ViewBag.Message = localizer["CreateFail"];
return(View());
}
}
public ActionResult CreateAccount(CreateAccountViewModel NewAccount)
{
if (NewAccount.IsAccountNameExist())
{
return(View(NewAccount));
}
if (!NewAccount.IsInputPwIdentity())
{
return(View(NewAccount));
}
MemberUser MemAccount = new MemberUser();
MemAccount.UserLastName = NewAccount.UserLastName;
MemAccount.UserFirstName = NewAccount.UserFirstName;
MemAccount.UserEmail = NewAccount.UserEmail;
MemAccount.AccountName = NewAccount.AccountName;
NewAccount.EncryptPw();
MemAccount.AccountPassword = NewAccount.EncryptPassword;
db.MemberUsers.Add(MemAccount);
db.SaveChanges();
return(RedirectToAction("Index", "User"));
}
public async Task <IActionResult> Create(CreateAccountViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var cred = new NexusUserCredential
{
Username = model.Username,
Password = model.Password,
Pin = model.Pin
};
await _userManager.CreateAccount(HttpContext, cred, model.AutoLogin);
return(RedirectToAction("index", "node"));
}
catch (Exception e)
{
ModelState.AddModelError("summary", e.Message);
return(View(model));
}
}
public IActionResult Create(CreateAccountViewModel model)
{
if (ModelState.IsValid)
{
Account account = new Account
{
UserGuid = userManager.GetUserId(User),
BankName = model.BankName,
AccountName = model.AccountName,
AccountNumber = model.AccountNumber,
CardNumber = model.CardNumber,
Credit = Convert.ToInt64(model.Credit)
};
context.Account.Add(account);
if (Convert.ToBoolean(context.SaveChanges()))
{
TempData["ToasterState"] = ToasterState.Success;
TempData["ToasterType"] = ToasterType.Message;
TempData["ToasterMessage"] = Messages.CreateAccountSuccessful;
}
else
{
TempData["ToasterState"] = ToasterState.Error;
TempData["ToasterType"] = ToasterType.Message;
TempData["ToasterMessage"] = Messages.CreateAccountFailed;
}
return(RedirectToAction("Index"));
}
return(BadRequest());
}
public ActionResult CreateSavings([Bind(Include = "AccountName,BranchID,CustomerID")] CreateAccountViewModel model)
{
ViewBag.BranchID = new SelectList(db.Branches, "ID", "Name", model.BranchID);
if (ModelState.IsValid)
{
try
{
CustomerAccount customerAccount = new CustomerAccount();
customerAccount.AccountName = model.AccountName;
customerAccount.AccountType = AccountType.Savings;
customerAccount.CustomerID = model.CustomerID;
customerAccount.AccountNumber = custActLogic.GenerateCustomerAccountNumber(AccountType.Savings, model.CustomerID);
customerAccount.DateCreated = DateTime.Now;
customerAccount.BranchID = model.BranchID;
customerAccount.AccountStatus = AccountStatus.Closed;
customerAccount.AccountBalance = 0;
db.CustomerAccounts.Add(customerAccount);
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
AddError(ex.ToString());
return(View(model));
}
}
AddError("Please enter valid data");
return(View(model));
}
public async Task <IActionResult> CreateAccount([FromBody] CreateAccountViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _userService.CreteUserAsync(model.Email, model.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(error.Code, error.Description);
}
return(BadRequest(ModelState));
}
var token = await _userService.JwtLogin(model.Email, model.Password);
if (token != null)
{
return(new JsonResult(new TokenResponseViewModel
{
AccessToken = new JwtSecurityTokenHandler().WriteToken(token),
ExpiresIn = token.ValidTo
}));
}
return(BadRequest());
}
public async Task CreateAccount(CreateAccountViewModel vm)
{
var(password, salt) = _passwordProtectionService.Encrypt(vm.PlainTextPassword);
if (!vm.IsAdmin)
{
var customer = new Customer
{
FullName = vm.FullName,
PhoneNumber = vm.PhoneNumber,
Account = new Account {
Salt = salt, AccountType = AccountTypes.Standard, Password = password, Username = vm.Username
}
};
await _customerRepository.AddAysnc(customer);
await _customerRepository.SaveAsync();
return;
}
var account = new Account
{
Username = vm.Username, AccountType = AccountTypes.Admin, Password = password, Salt = salt
};
await _accountRepository.AddAysnc(account);
await _accountRepository.SaveAsync();
}
public IActionResult CreateWithRole()
{
var model = new CreateAccountViewModel
{
Roles = new List <SelectListItem>
{
new SelectListItem {
Text = "Client", Value = "Client"
},
new SelectListItem {
Text = "Secretary", Value = "Secretary"
},
new SelectListItem {
Text = "Mechanic", Value = "Mechanic"
},
new SelectListItem {
Text = "Admin", Value = "Admin"
},
},
Specialties = _specialtyRepository.GetComboSpecialty()
};
return(View(model));
}
public void Create_Post_Error()
{
// arrange
var mockAuthenticationService = new Mock <IAuthenticationService>();
var mockAccountService = new Mock <IAccountService>();
mockAccountService
.Setup(m => m.CreateAccount(It.IsAny <CreateAccountRequest>()))
.Returns(new CreateAccountResponse
{
Success = false
});
var controller = new AccountController(mockAccountService.Object, mockAuthenticationService.Object, null);
var model = new CreateAccountViewModel();
// act
var result = controller.Create(model) as ViewResult;
// assert
Assert.IsNotNull(result);
Assert.AreEqual(string.Empty, result.ViewName);
Assert.IsFalse(result.ViewData.ModelState.IsValid);
Assert.AreEqual(1, result.ViewData.ModelState.Count);
}
/// <summary>
/// Create an account from the view.
/// </summary>
/// <param name="createAccountViewModel"> The create account view model. </param>
/// <param name="linkToHome"> The link To Home. </param>
/// <returns> The <see cref="CreateAccountViewModel"/>. </returns>
public CreateAccountViewModel CreateAccount(CreateAccountViewModel createAccountViewModel, Uri linkToHome)
{
// Convert the given View Model to the coresponding data model
var userToCreate = this.userConversions.ConvertCreateAccountViewModelToUser(createAccountViewModel);
// Set up the credentials with a hashed password.
userToCreate.UserCredential = new UserCredential
{
UserName = createAccountViewModel.UserName,
PasswordHash = PasswordHash.HashPassword(PasswordHash.CreateSalt(createAccountViewModel.UserName.ToLower()), createAccountViewModel.Password)
};
userToCreate.IsActive = true;
userToCreate.Contact = new Contact();
// Create the user in the database.
var createdUser = this.userRepo.CreateUser(userToCreate);
var userView = this.userConversions.ConvertUserToCreateAccountViewModel(createdUser);
if (userView != null)
{
var email = new AccountCreatedEmail(userView.UserName, userView.UserType);
email.Send(linkToHome);
}
// Return the corresponding view model
return(userView);
}
public async Task <Object> CreateAccount(CreateAccountViewModel model)
{
Account account = new Account();
account.Username = model.Username;
if (account.Username.Length == 0)
{
return(_apiResponse.Error(ShoerserException.AccountException.A03, nameof(ShoerserException.AccountException.A03)));
}
account.FullName = model.FullName;
if (account.FullName.Length == 0)
{
return(_apiResponse.Error(ShoerserException.AccountException.A04, nameof(ShoerserException.AccountException.A04)));
}
account.Password = model.Password;
account.Address = model.Address;
account.Role = model.Role;
if (!account.Role.Equals(Role.Admin) && !account.Role.Equals(Role.Moderator) && !account.Role.Equals(Role.Customer))
{
return(_apiResponse.Error(ShoerserException.AccountException.A06, nameof(ShoerserException.AccountException.A06)));
}
account.CreatedAt = DateTime.Now;
_unitOfWork.AccountRepository.Add(account);
var result = _apiResponse.Ok(_unitOfWork.Save());
return(result);
}
public ActionResult Register(CreateAccountViewModel viewModel)
{
var validRes = ValidateRegistration(viewModel.Email, viewModel.Password, viewModel.ConfirmPassword, viewModel.Name);
if (!validRes.IsValid)
{
TempData[RegistrationValidationSummaryKey] = validRes.ValidationSummary;
return(this.RedirectLocal("~/Login"));
}
var user = _teeyootMembershipService.CreateUser(viewModel.Email, viewModel.Password, viewModel.Name, viewModel.Phone);
if (user == null)
{
return(this.RedirectLocal("~/Login"));
}
_teeyootUserService.SendWelcomeEmail(user);
_authenticationService.SignIn(user, false);
return(string.IsNullOrEmpty(viewModel.ReturnUrl)
? Redirect("~/")
: this.RedirectLocal(viewModel.ReturnUrl));
}
public async Task <IActionResult> CreateAccount([FromBody, BindRequired] CreateAccountViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(new { Error = "Invalid request" }));
}
if (!await userManager.UserIsInRole(User.Claims.First(f => f.Type == ClaimTypes.NameIdentifier).Value, "acct-managers"))
{
return(Forbid());
}
var user = new ApplicationUser {
UserName = model.Username,
Email = model.Email,
EmailConfirmed = true,
MemberId = model.MemberId,
LockoutEnabled = true,
Created = DateTimeOffset.Now
};
var result = await userManager.CreateAsync(user);
await userManager.AddClaimAsync(user, new Claim("name", model.Name));
return(Ok(new { Data = new AccountInfo {
Id = user.Id,
Username = user.UserName,
Email = user.Email,
Name = (await userManager.GetClaimsAsync(user)).FirstOrDefault(c => c.Type == "name")?.Value
} }));
}
public async Task <ActionResult> Create(CreateAccountViewModel account)
{
ApplicationUserManager userManager = HttpContext.GetOwinContext().Get <ApplicationUserManager>();
if (ModelState.IsValid)
{
var user = new User
{
UserName = account.NewUser.UserName,
Email = account.NewUser.Email,
FirstName = account.NewUser.FirstName,
LastName = account.NewUser.LastName,
PhoneNumber = account.NewUser.PhoneNumber,
OrganizationalUnitID = account.NewUser.OrganizationalUnitID
};
var result = await userManager.CreateAsync(user, account.Password);
if (result.Succeeded)
{
foreach (var role in account.RolesNames)
{
userManager.AddToRole(user.Id, role);
}
return(RedirectToAction("Index", "Users"));
}
AddErrors(result);
}
// Dotarcie do tego miejsca wskazuje, że wystąpił błąd, wyświetl ponownie formularz
account.AllRoles = db.Roles.ToList();
ViewBag.UnitIDs = new SelectList(db.OrganizationalUnits, "OrganizationalUnitID", "UnitName", account.NewUser.OrganizationalUnitID);
return(View(account));
}
public ActionResult CreateAdministrator(CreateAccountViewModel viewModel)
{
if (Membership.GetAllUsers().Count != 0) // This page is only accessible with no registered users in the db
{
return(new HttpUnauthorizedResult());
}
if (!ModelState.IsValid)
{
return(View(viewModel));
}
MembershipCreateStatus status;
var user = Membership.CreateUser(viewModel.Username, viewModel.Password,
viewModel.Email, null, null, true, null, out status);
if (status != MembershipCreateStatus.Success)
{
return(View(viewModel));
}
user.LastActivityDate = DateTime.Now;
if (!Roles.GetAllRoles().Contains("Administrator"))
{
Roles.CreateRole("Administrator");
}
Roles.AddUserToRole(viewModel.Username, "Administrator");
FormsAuthentication.SetAuthCookie(viewModel.Username, viewModel.RememberMe);
return(RedirectToAction("Index", "Web"));
}
public ActionResult CreateAccount(CreateAccountViewModel createAccountViewModel)
{
bool isAccountCreated = false;
try
{
isAccountCreated = identityService.CreateAccount(createAccountViewModel);
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, localizationManager.GetLocalizedString(ex.Message));
}
if (isAccountCreated)
{
AuthenticationResult result = LogIn(createAccountViewModel.Email, createAccountViewModel.Password, false);
if (result.IsSuccess)
{
return(authenticationManager.RedirectFromLoginPage(createAccountViewModel.Email));
}
}
//SetAllCountries(createAccountViewModel);
return(View(createAccountViewModel));
}
public IActionResult CheckUsername(CreateAccountViewModel viewModel)
{
HttpContext.Session.SetString(UsernameSession, _accountLogic.CheckUsername(viewModel.Account.UserName).ToString());
var ajaxError = new AJAXError(HttpContext.Session.GetString(UsernameSession), "#usernameError");
return(new JsonResult(JsonConvert.SerializeObject(ajaxError)));
}
public ActionResult Create(CreateAccountViewModel model)
{
if (model == null)
{
return(View("Error", "", Resources.NullArgument));
}
if (!ModelState.IsValid)
{
return(View("Create"));
}
try
{
var user = userService.Create(model.FirstName, model.LastName, model.Passport, model.Email);
var account = accountService.OpenAccount(model.AccountType, user.Id);
return(View("CreateSuccess", account));
}
catch (Exception e)
{
return(View("Error", "", e.Message));
}
}
public IActionResult CreateAccount(CreateAccountViewModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
ValidateCreateAccountModel(ref model);
if (ModelState.IsValid)
{
if (_accountProvider.CreateAccount(model.Email, model.FirstName, model.Surname,
model.Password, model.Telephone, model.BusinessName, model.AddressLine1,
model.AddressLine2, model.AddressLine3, model.City, model.County,
model.Postcode, model.Country, out Int64 userId))
{
UserSession session = GetUserSession();
if (session != null)
{
session.Login(userId, $"{model.FirstName} {model.Surname}", model.Email);
}
return(Redirect("/Account/"));
}
}
PrepareCreateAccountModel(ref model);
return(View(model));
}
public ActionResult CreateAccount(CreateAccountViewModel vm)
{
using (var client = new UserProfileServiceReference.UserProfileServiceClient())
{
var newUser = new UserProfileServiceReference.NewUser()
{
Email = vm.email,
FirstName = vm.firstname,
Surname = vm.surname,
Password = vm.password,
Username = vm.username,
};
var user = client.CreateUser(newUser);
if (user != null)
{
Session["AuthorizedAsUser"] = "******";
Session["UserId"] = client.GetUserByUserName(vm.username).Id;
}
}
if (Session["AuthorizedAsUser"] == "true")
{
return(View("UpdateProfile"));
}
else
{
return(View("Index"));
}
}
public ActionResult CreateAccount(CreateAccountViewModel model)
{
string socialNetwork = Request.QueryString["socialNetwork"];
string token = Request.QueryString["at"];
string secret = Request.QueryString["as"];
string twitterUserId = Request.QueryString["uid"];
if (ModelState.IsValid)
{
MembershipCreateStatus createStatus = _membershipService.CreateUser(model.Email, model.Password, model.UserName, socialNetwork, token, secret, model.FirstName, model.LastName, model.FacebookId, model.TwitterId, model.Gender, model.City, model.State, model.locale);
if (createStatus == MembershipCreateStatus.Success)
{
string ticket = _membershipService.GetAuthTicketFromEmail(model.Email);
_authenticationService.LogIn(ticket: ticket, createPersistentCookie: true);
return(RedirectToAction("Index", "Browse"));
}
else
{
ModelState.AddModelError("", ValidationHelpers.AccountValidation.ErrorCodeToString(createStatus));
}
}
//If error occured during account creation return to the registration page with model errors displayed
if (socialNetwork == "Facebook")
{
return(View("RegisterWithFacebook", model));
}
else
{
return(View("CreateAccount", model));
}
}
public async Task<IActionResult> Create(CreateAccountViewModel request)
{
var result = await _mediator.SendAsync(request);
if (!result.Succeeded)
{
AddErrorsToModelState(result);
return RedirectToAction("Create");
}
return RedirectToAction("Index");
}
public ActionResult Create(CreateAccountViewModel model)
{
if (this.ModelState.IsValid)
{
var request = new CreateAccountRequest
{
UserName = model.UserName,
Password = model.Password,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName
};
var response = this.accountService.CreateAccount(request);
if (response.Status == StatusCode.OK)
{
var messageResponse = this.SendActivateAccountToken(model.Email, response.ActivateAccountToken, model.FirstName, model.LastName);
if (messageResponse.Status == StatusCode.OK)
{
this.TempData["SuccessMessage"] = "You have successfully created a new account. An activation code has been sent to you by email. When you receive the this email, click on the link to activate your account.";
return this.RedirectToAction("LogIn");
}
else
{
this.ModelState.AddModelError(string.Empty, Resources.ErrorMessages.InternalServerError);
}
}
else if (response.Status == StatusCode.BadRequest)
{
this.ModelState.AddModelError(string.Empty, $"Your account was not created for the following reason: {this.GetErrorMessage(response.CreateAccountStatus)}");
}
else
{
this.ModelState.AddModelError(string.Empty, Resources.ErrorMessages.InternalServerError);
}
}
return this.View();
}
public AccountIndexViewModel(CreateAccountViewModel createAccountViewModel, LogOnViewModel logOnViewModel)
{
CreateAccountViewModel = createAccountViewModel;
LogOnViewModel = logOnViewModel;
}
public void Create_Post_InternalServerErrror()
{
// arrange
var mockAuthenticationService = new Mock<IAuthenticationService>();
var mockAccountService = new Mock<IAccountService>();
mockAccountService.Setup(m => m.CreateAccount(It.IsAny<CreateAccountRequest>()))
.Returns(new CreateAccountResponse
{
Status = StatusCode.InternalServerError
});
var controller = new AccountController(mockAuthenticationService.Object, mockAccountService.Object, null);
var model = new CreateAccountViewModel();
// act
var result = controller.Create(model) as ViewResult;
// assert
Assert.IsNotNull(result);
Assert.AreEqual(string.Empty, result.ViewName);
Assert.IsFalse(result.ViewData.ModelState.IsValid);
Assert.AreEqual(1, result.ViewData.ModelState.Count);
}
public void Create_Post_BadRequest()
{
// arrange
var mockAuthenticationService = new Mock<IAuthenticationService>();
var mockAccountService = new Mock<IAccountService>();
mockAccountService.Setup(m => m.CreateAccount(It.IsAny<CreateAccountRequest>()))
.Returns(new CreateAccountResponse
{
Status = StatusCode.BadRequest
});
var controller = new AccountController(mockAuthenticationService.Object, mockAccountService.Object, null);
var model = new CreateAccountViewModel
{
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
// act
var result = controller.Create(model) as ViewResult;
// assert
Assert.IsNotNull(result);
Assert.AreEqual(string.Empty, result.ViewName);
Assert.IsFalse(result.ViewData.ModelState.IsValid);
Assert.AreEqual(1, result.ViewData.ModelState.Count);
}
public void Create_Post_OK()
{
// arrange
var mockAuthenticationService = new Mock<IAuthenticationService>();
var mockAccountService = new Mock<IAccountService>();
mockAccountService.Setup(m => m.CreateAccount(It.IsAny<CreateAccountRequest>()))
.Returns(new CreateAccountResponse
{
Status = StatusCode.OK,
ActivateAccountToken = "YYYYYYYYYYYY",
CreateAccountStatus = CreateAccountStatus.Success
});
var mockMessagingService = new Mock<IMessageService>();
var controller = new AccountController(mockAuthenticationService.Object, mockAccountService.Object, mockMessagingService.Object);
//controller.Url = new UrlHelper(
// new RequestContext(this.mockContext.Object, new RouteData()),
// new RouteCollection()
//);
// mock url needed to mock the call to Url.Action
//var mockUrl = new Mock<UrlHelper>();
//mockUrl.Setup(x => x.Action("ActivateAccount", "Email", new { name = "FirstName", token = "token" })).Returns("/email/activateaccount?name=XXX&token=YYY");
//controller.Url = mockUrl.Object;
var model = new CreateAccountViewModel
{
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
// act
var result = controller.Create(model) as RedirectToRouteResult;
// assert
Assert.IsNotNull(result);
Assert.AreEqual("LogIn", result.RouteValues["action"]);
Assert.AreEqual(null, result.RouteValues["controller"]);
Assert.IsNotNull(controller.TempData["SuccessMessage"]);
}
