[HttpPost] //método executado pelo SUBMIT do formulário
public IActionResult Register(AccountRegisterModel model,
[FromServices] UsuarioRepository usuarioRepository)
{
//verificar se todos os campos foram validados com sucesso
if (ModelState.IsValid)
{
try
{
//verificar se já existe um usuário com o email informado cadastrado
if (usuarioRepository.GetByEmail(model.Email) != null)
{
//lançar uma exceção
throw new Exception("O email informado já encontra-se cadastrado.");
}
var usuario = new Usuario();
usuario.Nome = model.Nome;
usuario.Email = model.Email;
usuario.Senha = model.Senha;
usuario.DataCriacao = DateTime.Now;
usuarioRepository.Create(usuario);
TempData["MensagemSucesso"] = $"Usuário {usuario.Nome}, cadastrado com sucesso.";
ModelState.Clear();
}
catch (Exception e)
{
TempData["MensagemErro"] = "Erro: " + e.Message;
}
}
return(View());
}
public SuccessfulMessageResponse Register([FromBody] AccountRegisterModel model)
{
var emailExist = _readOnlyRepository.First <Account>(account1 => account1.Email == model.Email);
if (emailExist == null)
{
if (AccountHelpers.IsAValidRegister(model))
{
//string passwordEncode = BCrypt.Net.BCrypt.HashPassword(model.Password, 12);
var account = _mappingEngine.Map <AccountRegisterModel, Account>(model);
account.IsArchived = false;
//account.Password = passwordEncode;
account.Password = model.Password;
Account accountCreated = _writeOnlyRepository.Create(account);
if (accountCreated != null)
{
AccountHelpers.SendMessage(model.Email, model.FirstName + " " + model.LastName, 1);
AccountHelpers.CreateOrganization(accountCreated);
return(new SuccessfulMessageResponse("You have been registered succesfully"));
}
}
throw new BadRequestException("The Account couldn't be created");
}
throw new BadRequestException("The Email is already registered");
}
//
// GET: /AccountRegisterApi/
public HttpResponseMessage PostRegister(AccountRegisterModel model)
{
if (!model.Email.IsNullOrWhiteSpace() && !model.Password.IsNullOrWhiteSpace() &&
!model.ConfirmPassword.IsNullOrWhiteSpace() && !model.Surname.IsNullOrWhiteSpace() &&
!model.Name.IsNullOrWhiteSpace() && model.ConfirmPassword == model.Password)
{
var context = new StackOverflowContext();
var account = new Account
{
CreationDate = DateTime.Now,
Email = model.Email,
IsVerified = true,
LastLogDate = DateTime.Now,
Name = model.Name + " " + model.Surname,
Password = model.Password,
ViewsToProfile = 0
};
context.Accounts.Add(account);
context.SaveChanges();
HttpResponseMessage response = this.Request.CreateResponse(HttpStatusCode.Created, model);
return(response);
}
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest));
}
public async Task <bool> RegisterAsync(CustomerModel customerModel)
{
bool isEmailValid = await _loginRepository.IsEmailValidAsync(customerModel.Email);
if (isEmailValid)
{
string passowrdSalt = Hashing.GetSalt();
customerModel.Id = Guid.NewGuid();
AccountRegisterModel account = new AccountRegisterModel()
{
PassowrdSalt = passowrdSalt,
PasswordHash = Hashing.GenerateHash(customerModel.Password, passowrdSalt),
Id = Guid.NewGuid(),
CustomerId = customerModel.Id,
Balance = 1000,
OpenDate = DateTime.Now
};
return(await _loginRepository.RegisterAsync(customerModel, account));
}
else
{
throw new SystemException();
// throw new DuplicateEmailException();
}
}
public HttpResponseMessage RegisterStep3(HttpRequestMessage request, [FromBody] AccountRegisterModel model)
{
return(base.GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;
var errors = new List <string>();
if (model.CreditCard.Length != 16)
{
errors.Add("Credit card number is in an invalid format.");
}
var datePattern = @"^(0[1-9]|1[0-2])\/(0[1-9]|1[0-9]|2[0-9]|3[0-1])\/[0-9]{4}$";
var matchExpDate = Regex.Match(model.ExpDate, datePattern, RegexOptions.IgnoreCase);
if (!matchExpDate.Success)
{
errors.Add("Expiration date is invalid.");
}
if (errors.Count == 0)
{
response = request.CreateResponse(HttpStatusCode.OK);
}
else
{
response = request.CreateResponse(HttpStatusCode.BadRequest, errors.ToArray());
}
return response;
}));
}
public HttpResponseMessage RegisterStep1(HttpRequestMessage request, [FromBody] AccountRegisterModel model)
{
return(base.GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;
var errors = new List <string>();
var states = UIHelper.GetStates();
var state = states.FirstOrDefault(s => s.Abbrev.ToUpper() == model.State.ToUpper());
if (state == null)
{
errors.Add("Invalid state.");
}
var matchZipCode = Regex.Match(model.ZipCode, @"^\d{5}(?:[-\s]\d{4})?$");
if (!matchZipCode.Success)
{
errors.Add("Zip code is an invalid format.");
}
if (errors.Count == 0)
{
response = request.CreateResponse(HttpStatusCode.OK);
}
else
{
response = request.CreateResponse(HttpStatusCode.BadRequest, errors.ToArray());
}
return response;
}));
}
public ActionResult Register(AccountRegisterModel model)
{
if (ModelState.IsValid)
{
model.Email = model.Email.ToLower().Trim();
var errorMessage = _membershipService.CreateUser(model.Email, model.Password);
if (string.IsNullOrEmpty(errorMessage))
{
_formsService.SignIn(model.Email, false);
var user = _repository.Find <UserProfile>().GetBy(model.Email);
user.CompleteRegistration(model.Name, false);
_repository.Save(user);
return(RedirectTo <AccountController>(c => c.Show(user.Id, user.UrlName)));
}
ModelState.AddModelError("", errorMessage);
}
return(View(model));
}
public HttpResponseMessage CreateAccount(HttpRequestMessage request,
[FromBody] AccountRegisterModel accountRegisterModel)
{
return(GetResponseMessage(request, () =>
{
HttpResponseMessage response = null;
if (ValidateRegistrationStep1(request, accountRegisterModel).IsSuccessStatusCode&&
ValidateRegistrationStep2(request, accountRegisterModel).IsSuccessStatusCode&&
ValidateRegistrationStep3(request, accountRegisterModel).IsSuccessStatusCode)
{
_securityAdapter.Register(accountRegisterModel.LoginEmail, accountRegisterModel.Password, new
{
FirstName = accountRegisterModel.FirstName,
LastName = accountRegisterModel.LastName,
Address = accountRegisterModel.Address,
City = accountRegisterModel.City,
State = accountRegisterModel.State,
ZipCode = accountRegisterModel.ZipCode,
LoginEmail = accountRegisterModel.LoginEmail,
Password = accountRegisterModel.Password,
CreditCard = accountRegisterModel.CreditCard,
ExpDate = accountRegisterModel.ExpDate
});
_securityAdapter.Login(accountRegisterModel.LoginEmail, accountRegisterModel.Password, false);
response = request.CreateResponse(HttpStatusCode.OK);
}
return response;
}));
}
public HttpResponseMessage CreateAccount(HttpRequestMessage request, [FromBody] AccountRegisterModel accountModel)
{
return(GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;
// revalidate all steps to ensure this operation is secure against hacks
if (ValidateRegistrationStep1(request, accountModel).IsSuccessStatusCode&&
ValidateRegistrationStep2(request, accountModel).IsSuccessStatusCode&&
ValidateRegistrationStep3(request, accountModel).IsSuccessStatusCode)
{
_SecurityAdapter.Register(accountModel.LoginEmail, accountModel.Password,
propertyValues: new
{
FirstName = accountModel.FirstName,
LastName = accountModel.LastName,
Address = accountModel.Address,
City = accountModel.City,
State = accountModel.State,
ZipCode = accountModel.ZipCode,
CreditCard = accountModel.CreditCard,
ExpDate = accountModel.ExpDate.Substring(0, 2) + accountModel.ExpDate.Substring(3, 2)
});
_SecurityAdapter.Login(accountModel.LoginEmail, accountModel.Password, false);
response = request.CreateResponse(HttpStatusCode.OK);
}
return response;
}));
}
public CrmResponse <String> AccountRegister(AccountRegisterModel registerModel)
{
string _errormsg;
CrmResponse <String> _response = new CrmResponse <string>();
if (registerModel.Password.Equals(registerModel.RePassword))
{
var data = _accountData.AccountRegisterData(registerModel.FullName, registerModel.Email, registerModel.Password, out _errormsg);
if (!_errormsg.Equals(""))
{
_response.Message = _errormsg;
_response.Success = false;
_response.Data = null;
}
else
{
_response.Message = "";
_response.Success = true;
_response.Data = data;
}
}
else
{
_response.Message = "Password did not match";
_response.Success = false;
_response.Data = null;
}
return(_response);
}
public HttpResponseMessage CreateAccount(HttpRequestMessage request, [FromBody] AccountRegisterModel model)
{
return(base.GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (this.RegisterStep1(request, model).IsSuccessStatusCode&&
this.RegisterStep2(request, model).IsSuccessStatusCode&&
this.RegisterStep3(request, model).IsSuccessStatusCode)
{
this._securityAdapter.Register(model.LoginEmail, model.Password,
new
{
FirstName = model.FirstName,
LastName = model.LastName,
Address = model.Address,
City = model.City,
State = model.State,
ZipCode = model.ZipCode,
CreditCard = model.CreditCard,
ExpDate = model.ExpDate.Replace("/", "")
});
this._securityAdapter.Login(model.LoginEmail, model.Password, false);
response = request.CreateResponse(HttpStatusCode.OK);
}
return response;
}));
}
/// <summary>
/// 生成Word
/// </summary>
/// <param name="model">页面模型</param>
/// <param name="XGDicList">生成字典集合</param>
private void TZWord(AccountRegisterModel model, List <Dictionary <string, string> > XGDicList, string OPath)
{
string abspath = System.Web.Hosting.HostingEnvironment.MapPath("~/DocumentTemplate/AccountDoc/手动生成台帐清单.docx");
WordInfo word = new WordInfo(abspath, OPath, "pdf");
Dictionary <string, string> dic = new Dictionary <string, string>();
//找到图片存入
dic.Add("$事件标题$", model.title);
dic.Add("$当 事 人$", model.people);
dic.Add("$事件内容$", model.content);
dic.Add("$发现时间$", model.registertime.ToString("yyyy-MM-dd HH:mm:ss"));
dic.Add("$地 点$", model.address);
string srname = string.Empty;
if (!string.IsNullOrEmpty(model.taskclassid))
{
sm_specialrectifications sms = zxzzbll.GetClassByID(int.Parse(model.taskclassid));
if (sms != null)
{
srname = sms.srname;
}
}
dic.Add("$任务分类$", srname);
word.ReplaceRangs(dic);
word.AddPictures(XGDicList);
word.Dispose();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
var model = new AccountRegisterModel();
model.FirstName = FirstName.Text;
model.LastName = LastName.Text;
model.Email = Email.Text;
model.Password = Password.Password;
model.ConfirmPassword = ConfirmPassword.Password;
var client = new RestClient("http://minitrelloapis.apphb.com");
var request = new RestRequest("/register", Method.POST);
request.RequestFormat = DataFormat.Json;
request.AddBody(model);
var asyncHandler = client.ExecuteAsync <ReturnModel>(request, r =>
{
if (r.ResponseStatus == ResponseStatus.Completed)
{
if (r.Data != null)
{
NavigationService.Navigate(new Uri("/login.xaml", UriKind.Relative));
}
}
});
}
private List <string> ValidateRegistrationStep2Inner(AccountRegisterModel accountModel)
{
List <string> errors = new List <string>();
if (!string.IsNullOrWhiteSpace(accountModel.LoginEmail))
{
var regExp = @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z";
if (!Regex.IsMatch(accountModel.LoginEmail, regExp, RegexOptions.IgnoreCase))
{
errors.Add("Email format is not valid");
}
if (_SecurityAdapter.UserExists(accountModel.LoginEmail))
{
errors.Add("An account is already registered with this email address.");
}
}
else
{
errors.Add("LoginEmail is required");
}
if (String.IsNullOrWhiteSpace(accountModel.Password) ||
accountModel.Password.Length < 6)
{
errors.Add("Invalid Password");
}
if (String.IsNullOrWhiteSpace(accountModel.PasswordConfirm) ||
accountModel.Password != accountModel.PasswordConfirm)
{
errors.Add("Passwords do not match");
}
return(errors);
}
public async Task <bool> RegisterAsync(CustomerModel customerModel, AccountRegisterModel accountRegisterModel)
{
try
{
CustomerEntity customer = new CustomerEntity()
{
PasswordHash = accountRegisterModel.PasswordHash,
PassowrdSalt = accountRegisterModel.PassowrdSalt,
Email = customerModel.Email,
FirstName = customerModel.FirstName,
LastName = customerModel.LastName,
Id = customerModel.Id
};
AccountEntity account = _mapper.Map <AccountEntity>(accountRegisterModel);
await _accountContext.Customers.AddAsync(customer);
await _accountContext.Accounts.AddAsync(account);
await _accountContext.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
throw new SystemException();
}
}
public HttpResponseMessage ValidateRegistrationStep1(HttpRequestMessage request,
[FromBody] AccountRegisterModel accountRegisterModel)
{
return(GetResponseMessage(request, () =>
{
HttpResponseMessage response = null;
List <string> errors = new List <string>();
List <State> states = Helpers.States.GetStates();
State state = states.FirstOrDefault(item => item.Name == accountRegisterModel.State);
if (state == null)
{
errors.Add("Invalid state.");
}
if (errors.Count() == 0)
{
response = request.CreateResponse(HttpStatusCode.OK);
}
else
{
response = request.CreateResponse <string[]>(HttpStatusCode.BadRequest, errors.ToArray());
}
return response;
}));
}
public async Task <IActionResult> Register(AccountRegisterModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = new ApplicationUser {
UserName = model.UserName
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _databaseService.RegisterAccount(new Account { UserId = user.Id });
await _signInManager.SignInAsync(user, false);
return(RedirectToAction("Index", "Home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
public async Task <IActionResult> RegisterAsync(AccountRegisterModel registerModel)
{
using var connection = new MySqlConnection(AppConfig.Constants.DbConnectionString);
using var command = new MySqlCommand("RegisterUser", connection)
{
CommandType = CommandType.StoredProcedure
};
command.Parameters.AddRange(new[]
{
new MySqlParameter("login", registerModel.Login),
new MySqlParameter("email", registerModel.Email),
new MySqlParameter("password", registerModel.Password),
new MySqlParameter("name", registerModel.Name),
new MySqlParameter("surname", registerModel.Surname),
new MySqlParameter("user_id", MySqlDbType.Int64)
{
Direction = ParameterDirection.ReturnValue
}
});
connection.Open();
await command.ExecuteNonQueryAsync();
var userId = Convert.ToInt64(command.Parameters["user_id"].Value);
var confirmationCode = Guid.NewGuid();
await AddConfirmationCodeAsync(userId, registerModel.Email, confirmationCode);
await SendConfirmationCodeAsync(registerModel.Email, confirmationCode);
return(ResponseModel.OK.ToResult());
}
public HttpResponseMessage ValidateRegistrationStep3(HttpRequestMessage request,
[FromBody] AccountRegisterModel accountRegisterModel)
{
return(GetResponseMessage(request, () =>
{
HttpResponseMessage response = null;
List <string> errors = new List <string>();
if (accountRegisterModel.CreditCard.Length != 16)
{
errors.Add("Credit Card # must be 16 characters");
}
if (errors.Count() == 0)
{
response = request.CreateResponse(HttpStatusCode.OK);
}
else
{
response = request.CreateResponse(HttpStatusCode.BadRequest, errors.ToArray());
}
return response;
}));
}
public IActionResult Register(AccountRegisterModel model, //campos do formulário
[FromServices] UsuarioRepository usuarioRepository) //injeção de dependência
{
if (ModelState.IsValid)
{
try
{
//verificar se o email informado já encontra-se cadastrado.
if (usuarioRepository.Consultar(model.Email) != null)
{
TempData["MensagemErro"] = "O email informado já encontra-se cadastrado. Tente outro.";
}
else
{
var usuario = new Usuario(); //criando um usuário
usuario.Nome = model.Nome;
usuario.Email = model.Email;
usuario.Senha = MD5Encrypt.GenerateHash(model.Senha);
usuario.DataCriacao = DateTime.Now;
usuarioRepository.Inserir(usuario); //gravando no banco..
TempData["MensagemSucesso"] = "Conta de usuário cadastrada com sucesso!";
ModelState.Clear(); //limpar o conteudo do formulário
}
}
catch (Exception e)
{
TempData["MensagemErro"] = e.Message;
}
}
return(View());
}
public Account Register([FromBody] AccountRegisterModel model)
{
var newUser = _mappingEngine.Map <AccountRegisterModel, Account>(model);
var createdUser = _writeOnlyRepository.Create(newUser);
var x = Request;
return(createdUser);
}
public static AccountRegisterModel Register(AccountRegisterModel registerModel)
{
var client = new RestClient(BaseUrl);
var request = InitRequest("/register", Method.POST, registerModel);
IRestResponse <AccountRegisterModel> response = client.Execute <AccountRegisterModel>(request);
return(response.Data);
}
public CreatedAccountModel Register([FromBody] AccountRegisterModel model)
{
var newUser = _mappingEngine.Map <AccountRegisterModel, Account>(model);
var createdUser = _writeOnlyRepository.Create(newUser);
var craetedUserModel = _mappingEngine.Map <Account, CreatedAccountModel>(createdUser);
return(craetedUserModel);
}
public ActionResult Register(AccountRegisterModel viewModel)
{
_SecurityAdapter.Initialize();
// Ensure we have a valid viewModel to work with
if (!ModelState.IsValid)
{
return(View(viewModel));
}
// Prepare the identity with the provided information
var user = new IdentityUser
{
UserName = viewModel.Name ?? viewModel.Email,
Email = viewModel.Email
};
// Try to create a user with the given identity
try
{
_SecurityAdapter.Register(viewModel.LoginID, viewModel.Password,
propertyValues: new
{
Name = viewModel.Name,
Email = viewModel.Email,
LastLoginDate = DateTime.Now,
IsLock = false,
Deleted = false,
Active = true,
CreatedBy = User.Identity.Name,
CreatedOn = DateTime.Now,
UpdatedBy = User.Identity.Name,
UpdatedOn = DateTime.Now,
});
//// If the user could not be created
//if (!result.Succeeded)
//{
// // Add all errors to the page so they can be used to display what went wrong
// AddErrors(result);
// return View(viewModel);
//}
// If the user was able to be created we can sign it in immediately
// Note: Consider using the email verification proces
var success = _SecurityAdapter.Login(viewModel.LoginID, viewModel.Password, false);
return(RedirectToLocal());
}
catch (DbEntityValidationException ex)
{
// Add all errors to the page so they can be used to display what went wrong
AddErrors(ex);
return(View(viewModel));
}
}
public ActionResult Register(AccountRegisterModel model)
{
if (User.Identity.Name != "Admin")
{
return(RedirectToAction("Index", "Home"));
}
if (ModelState.IsValid)
{
users user = null;
//Проверяем существует ли такой пользователь в БД
using (database_murom_factory2Entities1 db = new database_murom_factory2Entities1())
{
user = db.users.FirstOrDefault(u => u.Login == model.Login);
}
//Если такого пользователя нет, то заносим его в БД
if (user == null)
{
using (database_murom_factory2Entities1 db = new database_murom_factory2Entities1())
{
user = db.users.Add(new users()
{
Email = model.Email,
access = null,
group_rank = null,
id_group_rank = null,
id_rank = null,
Login = model.Login,
Name = model.Name,
Password = model.Password,
Patronymic = model.Patronymic,
Phone = model.Phone,
Position = model.Position,
rank = null,
Surname = model.Surname,
User_chat = null
});
db.SaveChanges();
// Проверяем, что пользователь успешно добавился
user = db.users.Where(u => u.Login == model.Login && u.Password == model.Password).FirstOrDefault();
}
//Если пользователь успешно добавлен - возвращаемся
if (user != null)
{
return(RedirectToAction("AdminIndex", "Admin"));
}
}
else
{
ModelState.AddModelError("", "Пользователь с таким логином уже существует");
}
}
return(View(model));
}
public CreatedAccountModel Register([FromBody] AccountRegisterModel model)
{
EmailWithMailgun.SendMessage("Correo", model.Email, "Hola");
var newUser = _mappingEngine.Map <AccountRegisterModel, Account>(model);
var createdUser = _writeOnlyRepository.Create(newUser);
var craetedUserModel = _mappingEngine.Map <Account, CreatedAccountModel>(createdUser);
return(craetedUserModel);
}
public async Task <IActionResult> Register([FromBody] AccountRegisterModel accountRegisterModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (string.IsNullOrEmpty(accountRegisterModel.Username))
{
accountRegisterModel.Username = accountRegisterModel.Email;
}
var user = new IdentityUser(accountRegisterModel.Username, accountRegisterModel.Email);
if (accountRegisterModel.Claims != null)
{
foreach (string claim in accountRegisterModel.Claims)
{
user.AddClaim(new UserClaim(JwtClaimTypes.Role, claim));
}
}
var result = await _userManager.CreateAsync(user, accountRegisterModel.Password);
if (result == null)
{
return(StatusCode(500, "Internal Server Error"));
}
if (result.Succeeded)
{
if (!string.IsNullOrEmpty(accountRegisterModel.Cell))
{
await _userManager.SetPhoneNumberAsync(user, accountRegisterModel.Cell);
}
return(Ok(new
{
user.Id,
user.CreatedOn
}));
}
AddErrorsToModelState(result);
if (ModelState.IsValid)
{
return(BadRequest());
}
return(BadRequest(ModelState));
}
public ApplicationUser AccountRegisterModelToApplicationUser(AccountRegisterModel login)
{
return(new ApplicationUser
{
FullName = login.FullName,
Address = login.Address,
Email = login.Email,
AvatarUrl = login.AvatarUrl,
DateCreated = DateTime.Now,
UserName = login.Email,
PhoneNumber = login.PhoneNumber,
});
}
public IActionResult Register(AccountRegisterModel register)
{
if (ModelState.IsValid)
{
if (!_context.Users.Any(u => u.Email == register.Email))
{
User user = new User
{
Email = register.Email,
Username = register.Username,
Password = Crypto.HashPassword(register.Password),
CreatedAt = DateTime.Now,
Token = Guid.NewGuid().ToString(),
IsCompany = register.IsCompany
};
_context.Users.Add(user);
_context.SaveChanges();
Response.Cookies.Append("token", user.Token, new Microsoft.AspNetCore.Http.CookieOptions
{
Expires = DateTime.Now.AddYears(1),
HttpOnly = true
});
return(RedirectToAction("profile", "account"));
}
else
{
ModelState.AddModelError("Email", "This user is already in registered");
}
}
AccountIndexViewModel data = new AccountIndexViewModel
{
Register = register
};
data.Breadcumb = new BreadcumbViewModel
{
Title = "Register",
Path = new Dictionary <string, string>()
};
data.Breadcumb.Path.Add("index", "Home");
data.Breadcumb.Path.Add("Register", null);
ViewBag.Partial = data.Breadcumb;
return(View("~/Views/Account/Register.cshtml"));
}
public async Task <ActionResult> CreateAccount(AccountRegisterModel accountViewModel)
{
if (ModelState.IsValid)
{
var account = new Account(accountViewModel);
var result = await userManager.CreateAsync(account, accountViewModel.Password);
if (result.Succeeded)
{
// nên đăng nhập luôn.
TempData["message"] = "Register success!";
return(Redirect("/Home"));
}
}
return(View("Register", accountViewModel));
}
protected override void OnTestRunInitialize()
{
this.Target = new AccountRegisterModel();
this.Target.Navigate();
}
protected override void OnTestRunInitialize()
{
// DriverFactory.DriverGenerationMethod = () => new FirefoxDriver();
this.Target = new AccountRegisterModel();
this.Target.Navigate();
}
protected override void OnTestRunInitialize()
{
// TODO Stuart: Does Target store any state? Can I just put in ctor? Try it (Selenium could choke).
this.Target = new AccountRegisterModel();
this.Target.Navigate();
}
