public ActionResult Signup(SignupViewModel signup)
{
if (!ModelState.IsValid)
{
return(new ShapeResult(this, _services.New.Checkout_Signup(Signup: signup)));
}
var customer = _customerService.CreateCustomer(signup.Email, signup.Password);
customer.FirstName = signup.FirstName;
customer.LastName = signup.LastName;
customer.Title = signup.Title;
_authenticationService.SignIn(customer.User, true);
return(RedirectToAction("SelectAddress"));
}
public async Task <IActionResult> Signup(SignupViewModel model)
{
if (ModelState.IsValid)
{
if (!(await _roleManager.RoleExistsAsync(model.Role)))
{
var role = new IdentityRole {
Name = model.Role
};
var roleResult = await _roleManager.CreateAsync(role);
if (!roleResult.Succeeded)
{
var errors = roleResult.Errors.Select(s => s.Description);
ModelState.AddModelError("Role", string.Join(",", errors));
return(View(model));
}
}
if ((await _userManager.FindByEmailAsync(model.Email)) == null)
{
var user = new IdentityUser {
Email = model.Email,
UserName = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var claim = new Claim("Department", model.Department);
await _userManager.AddClaimAsync(user, claim);
await _userManager.AddToRoleAsync(user, model.Role);
return(RedirectToAction("Signin"));
}
ModelState.AddModelError("Signup", string.Join("", result.Errors.Select(x => x.Description)));
return(View(model));
}
}
return(View(model));
}
public async Task ShouldNotSignupWithEmailAlreadyTaken()
{
var server = new ServerFake();
var user = server.AppDbContext.CreateUser();
var viewModel = new SignupViewModel {
Name = "Another", Email = user.Email, Password = UserFactory.Password
};
var response = await server.CreateClient().PostAsJsonAsync("signup", viewModel);
var errors = await response.Content.ReadAsJsonAsync <List <string> >();
var expectedErrors = new [] { "E-mail já cadastrado." };
Assert.Equal((HttpStatusCode)422, response.StatusCode);
Assert.Equal(errors.OrderBy(e => e), expectedErrors.OrderBy(e => e));
Assert.False(server.Mailer.EmailSent);
}
public async Task <IActionResult> Signup([FromBody] SignupViewModel viewModel)
{
try
{
await _accountService.Signup(viewModel);
return(Ok());
}
catch (ArgumentException)
{
return(BadRequest());
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public ActionResult FeedbackPost(SignupViewModel input)
{
if (input == null)
{
return(Json(CommandResponse.Fail.SetMessage("Invalid input")));
}
if (input.Name.IsNullOrWhitespace())
{
return(Json(CommandResponse.Fail.SetMessage("Name is missing")));
}
var outcome = (DateTime.Now.Second % 2) > 0
? CommandResponse.Ok.SetMessage("Welcome to the team!")
: CommandResponse.Fail.SetMessage("Oops! Something went unexpectedly wrong.");
return(Json(outcome));
}
public ActionResult Signup(SignupViewModel model)
{
if (ModelState.IsValid)
{
var newUser = Mapper.Map <UserDto> (model);
newUser.RoleId = (int)Roles.ApprovedMember;
bool result = _userService.CreateUser(newUser);
if (result)
{
return(Redirect(Url.Action("Login", "Account")));
}
ModelState.AddModelError("", "Login is already taken");
}
return(View());
}
public async Task <Users> CreateUserAsync(SignupViewModel signp)
{
return(await Task.Run(() =>
{
return new Users()
{
ActiveCode = Guid.NewGuid().GetHashCode().ToString().Replace("-", "").Substring(4, 4),
ActiveDate = DateTime.Now,
Email = signp.Email,
IsConfirm = false,
Password = signp.Password.CreateSHA256(),
PhoneNumber = signp.PhoneNumber,
UserName = signp.UserName,
UserId = Guid.NewGuid()
};
}));
}
public async Task Signup(SignupViewModel viewModel)
{
var user = _context.Users.SingleOrDefault(u => u.Email == viewModel.Email);
if (user != null)
{
throw new ArgumentException();
}
var salt = AuthHelper.CreateSalt(128);
var passwordHash = AuthHelper.CreateHash(viewModel.Password, salt);
var newUser = new User(viewModel.Email, passwordHash, salt, viewModel.FirstName, viewModel.LastName, null);
_context.Users.Add(newUser);
await _context.SaveChangesAsync();
}
public string Signup([FromBody] SignupViewModel signupData)
{
Boolean success = AccountService.Signup(signupData);
if (success)
{
return(Login(new LoginViewModel()
{
Email = signupData.Email, Password = signupData.Password
}));
}
else
{
return new RequestResult()
{
State = RequestState.Failed
}
}.Serialize();
public static void SignUp(SignupViewModel svm)
{
if (AuthController.SignUp(svm))
{
LogIn(new LoginViewModel
{
Email = svm.Email,
Password = svm.Password
});
SignUpForm.Close();
}
else
{
MessageBox.Show("Could not register you with these credentials.",
"Authentication error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public IActionResult SignUp()
{
var authResponse = HttpContext.Session.Get <AuthenticationResponse>("AuthenticationResponse");
if (authResponse == null)
{
return(RedirectToAction("Authenticate", "Login"));
}
var viewModel = new SignupViewModel
{
SystemID = authResponse.systemID,
UserName = authResponse.userName,
};
return(View(viewModel));
}
public JsonResult PostSignup(SignupViewModel model)
{
if (model == null)
{
return(Json(null));
}
if (ModelState.IsValid)
{
model.SaveModel();
var jsonResult = Json(model, JsonRequestBehavior.AllowGet);
jsonResult.MaxJsonLength = int.MaxValue;
return(jsonResult);
}
else
{
return(Json(null));
}
}
public async Task <IActionResult> Index(SignupViewModel model)
{
var user = new ApplicationUser {
UserName = model.UserName, Email = model.Email
};
IdentityResult result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
user.AddToMailingList();
user.MailingList = true;
return(View("Index", "You've been added to the mailing list!"));
}
else
{
return(View());
}
}
public async Task <IActionResult> Signup([FromBody] SignupViewModel signupVM)
{
var user = new ApplicationUser()
{
Name = signupVM.Username,
UserName = signupVM.Email,
Email = signupVM.Email,
BirthDate = signupVM.BirthDate,
Gender = signupVM.Gender,
UserType = signupVM.UserRole
};
var result = await _userManager.CreateAsync(user, signupVM.Password);
if (result.Succeeded)
{
//Email Token For Email Confirmation
string confirmationToken = _userManager.GenerateEmailConfirmationTokenAsync(user).Result;
string confirmationTokenLink = Url.Action("EmailConfirmed", "Accounts", new
{
userId = user.Id,
token = confirmationToken
}, protocol: HttpContext.Request.Scheme);
//Adding User Claim
await _userManager.AddClaimAsync(user, new Claim(signupVM.UserRole, "True"));
//Send Email With Confirmation Token .
try
{
_emailSender.AccountConfirmationEmail(user.Email, confirmationTokenLink);
}
catch (Exception ex)
{
string error = ex.Message;
}
return(Ok(new
{
Status = "Success"
}));
}
return(Ok(new { Status = "Failed", Errors = result.Errors.Where(e => e.Code != "DuplicateUserName") }));
}
public async Task <IActionResult> SignUp(SignupViewModel signUp)
{
SignUpResponse result = await _account.SignUpAsync(signUp);
switch (result)
{
case SignUpResponse.Success:
return(Ok(new { Id = 0, Title = "Success Go To Active Account", Result = new { } }));
case SignUpResponse.Exception:
return(Ok(new { Id = -2, Title = "Exception", Result = new { } }));
case SignUpResponse.UserAlreadyExist:
return(Ok(new { Id = -3, Title = "User Already Exist", Result = new { } }));
default:
goto case SignUpResponse.Exception;
}
}
public ActionResult Signup(SignupViewModel user)
{
if (ModelState.IsValid)
{
using (ISession session = DBConnect.OpenUserSession())
{
using (ITransaction tx = session.BeginTransaction())
{
User qUserU = new User();
User qUserE = new User();
qUserU = session.Query <User>()
.Where(x => x.Username == user.Username)
.FirstOrDefault();
qUserE = session.Query <User>()
.Where(x => x.Email == user.Email)
.FirstOrDefault();
if (qUserU != null || qUserE != null)
{
if (qUserU != null)
{
ModelState.AddModelError("Username", "Username has been taken.");
}
if (qUserE != null)
{
ModelState.AddModelError("Email", "There exists an account with this email address.");
}
return(View());
}
else
{
user.RoleId = "user";
user.Id = Guid.NewGuid();
user.Salt = CreateSalt(10);
user.HashedPass = GenerateSHA256(user.Password, user.Salt);
session.Save(user);
tx.Commit();
return(RedirectToAction("Index", "Home"));
}
}
}
}
return(View());
}
public async Task <IActionResult> Create([Bind("DisplayName,Email,Password")] SignupViewModel args)
{
args.PasswordHash = BCrypt.Net.BCrypt.HashPassword(args.Password);
User user = new User
{
DisplayName = args.DisplayName,
Email = args.Email,
Password = args.PasswordHash
};
_context.Add(user);
await _context.SaveChangesAsync();
user = _context.Users.Single(u => u.Email.Equals(user.Email));
await this.Login(user);
return(RedirectToAction("Index", ""));
}
public IActionResult Signup(SignupViewModel model)
{
if (User.Identity.IsAuthenticated)
{
return(Redirect("/"));
}
var succeed = _cetUserService
.Signup(model.UserName, model.Password, model.Email, model.FirstName, model.LastName);
if (succeed)
{
return(RedirectToAction("Signin"));
}
else
{
return(RedirectToAction("Signup", new { error = "signup" }));
}
}
public ActionResult Signup(SignupViewModel memberData)
{
try
{
if (ModelState.IsValid)
{
bool valid = ValidateSignup(memberData);
if (!valid)
{
return(View());
}
Member member = new Member();
member.username = memberData.UserName;
member.email = memberData.Email;
member.created_at = DateTime.Now;
string hashedPass = Security.GenerateMd5(memberData.Password);
member.password = hashedPass;
member.is_active = false;
member.confirm_token = Security.Encrypt("OMAR*" + member.username + "*" + member.created_at + "*" + memberData.Password, true);
rpMember.Insert(member);
//Send verification link to email
string activationUrl = Url.Action("ConfirmSignup", "Member", new { token = member.confirm_token }, "http");
NotifyMember.AccountActivation(member.email, activationUrl);
return(View("Success", new MessageView()
{
Message = "We sent a link to " + member.email + " to activate your account."
}));
}
else
{
ModelState.AddModelError("", "There is an error in the input data, try again.");
}
}
catch (Exception e)
{
}
return(View());
}
public ActionResult Add(SignupViewModel model)
{
if (ModelState.IsValid)
{
var newUser = Mapper.Map <SimpleSocialNetwork.Domain.User>(model);
newUser.RoleId = (int)Roles.Moderator;
bool result = _userService.CreateUser(newUser);
if (result)
{
return(Redirect(Url.Action("Index", "Admin")));
}
else
{
ModelState.AddModelError("", "Login is already taken");
}
}
return(View());
}
public async Task <UserViewModel> CreateAsync(SignupViewModel model, CancellationToken ct)
{
var existingUser = await _userRepository.GetByEmailAsync(model.Email, ct : ct);
if (existingUser is not null)
{
return(null);
}
var user = model.Adapt <User>();
var secret = PasswordSecret.Create(model.Password);
user.Name ??= user.Email;
user.PasswordHash = secret.Hash;
user.Salt = secret.Salt;
var createdUser = await _userRepository.CreateAsync(user, ct);
return(createdUser.Adapt <UserViewModel>());
}
public ActionResult Identify(SignupViewModel model)
{
if (ModelState.IsValid)
{
if (model.Name == "The Man")
{
ModelState.AddModelError("Name", "No, there can only be one 'The man', and you are not it.");
}
}
if (ModelState.IsValid)
{
var cookie = new HttpCookie("name", model.Name);
cookie.Expires = DateTime.Now.AddYears(1);
Response.Cookies.Add(cookie);
return(RedirectToAction("Index"));
}
return(View(model));
}
public IActionResult Signup(SignupViewModel signupViewModel)
{
MyIdentityUser user = new MyIdentityUser()
{
Email = signupViewModel.Email,
UserName = signupViewModel.Email
};
IdentityResult result = _userManager.CreateAsync(user, signupViewModel.Password).Result;
if (result.Succeeded)
{
_signInManager.SignInAsync(user, true);
return(RedirectToAction("Index", "Home"));
}
else
{
return(Content("User account creation failed: " + result.Errors.First().Description));
}
}
public async Task <IActionResult> Signup(SignupViewModel signupViewModel)
{
if (ModelState.IsValid)
{
SignupViewModel vModel = new SignupViewModel();
SignupBO bo = new SignupBO(_pool, _userManager);
vModel = await bo.CreateUser(signupViewModel);
if (!vModel.IsValid)
{
ModelState.AddModelError("Signup", vModel.Message);
return(View(vModel));
}
else
{
RedirectToAction("Confirm");
}
}
return(View());
}
public IActionResult Signup(string username, string password, string repeatPassword)
{
var errors = new List <string>();
if (username == null || username.Length == 0)
{
errors.Add("Username is required.");
}
else if (_gymDb.Users.ToList().Find(user => user.Login == username) != null)
{
return(View(SignupViewModel.newErrorInstance("A user with that name already exists")));
}
else if (username.Length < 3)
{
errors.Add("Username too short.");
}
if (password == null || password.Length == 0)
{
errors.Add("Password is required.");
}
else if (password.Length < 8)
{
errors.Add("Password too short.");
}
else if (password != repeatPassword)
{
errors.Add("Different passwords were provided.");
}
if (errors.Count > 0)
{
return(View(SignupViewModel.newErrorInstance(string.Join(' ', errors))));
}
else
{
var user = new User(username, Cypher.sha256Hash(password));
_gymDb.Users.Add(user);
_gymDb.SaveChanges();
return(View(SignupViewModel.newSuccessInstance(username)));
}
}
public async Task <IActionResult> Signup(SignupViewModel signup, string ReturnUrl)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = signup.CustomerEmail, Email = signup.CustomerEmail, PhoneNumber = signup.CustomerPhone, Address = signup.CustomerAddress, Fullname = signup.CustomerName
};
var result = await _userManager.CreateAsync(user, signup.Password);
if (result.Succeeded)
{
var newUser = await _userManager.FindByEmailAsync(user.Email);
var addToRole = await _userManager.AddToRoleAsync(newUser, "User");
var token = await _userManager.GenerateEmailConfirmationTokenAsync(newUser);
//var confirmationLink = Url.Action("ConfirmEmail", "Identity",
// new { userId = user.Id, token = token }, Request.Scheme);
return(RedirectToAction("SendEmailConfirm", new { userId = user.Id, token = token }));
//await _signInManager.SignInAsync(user, isPersistent: false);
//if (!string.IsNullOrEmpty(ReturnUrl))
//{
// return Redirect(ReturnUrl);
//}
//else
//{
// return RedirectToAction("Index", "Home", new { Area = "Client" });
//}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(RedirectToAction("login", signup));
}
internal static string SaveUserDetails(SignupViewModel model, bool isNewUser)
{
using (var context = GetMMBContext())
{
if (Convert.ToBoolean(model.FirstName.Length) && Convert.ToBoolean(model.Password.Length) && Convert.ToBoolean(model.Email.Length) && Convert.ToBoolean(model.Username.Length))
{
if (model.Password == model.ConfirmPassword)
{
var userDetails = context.User.Where(r => r.Username == model.Username && r.Email == model.Email);
if (userDetails.Any())
{
return("Duplicate");
//username or email already exists
}
else
{
var userEntity = UserEntity();
userEntity.FirstName = model.FirstName;
userEntity.LastName = model.LastName;
userEntity.UserPassword = model.Password;
userEntity.RecordStatus = 0; //currently inactive account
userEntity.IsAdmin = 0;
userEntity.CreatedOn = DateTime.UtcNow;
userEntity.LastUpdatedOn = DateTime.UtcNow;
userEntity.ResetPasswordKey = "";
userEntity.Email = model.Email;
userEntity.Username = model.Username;
context.User.Add(userEntity);
context.SaveChanges();
return("Success");
}
}
}
else
{
//all fields are not filled
return("KnownFailure");
}
}
return("Failed");
}
public async Task IShouldCanCreateAUser()
{
// Prepare
var userViewModel = new SignupViewModel
{
Email = "*****@*****.**",
Password = "******"
};
var userResponse = new SignupViewModel
{
Email = "*****@*****.**",
Password = null
};
var mockForDomainUserService = new Mock <IUserService>();
mockForDomainUserService.Setup(service => service.GetUserByEmail(It.IsAny <string>()))
.ReturnsAsync(null as User)
.Verifiable();
var mockForApplicationUserService = new Mock <IUserApplicationService>();
mockForApplicationUserService.Setup(service => service.CreateUser(userViewModel))
.ReturnsAsync(userResponse)
.Verifiable();
var controller = new UserController(
mockForDomainUserService.Object,
mockForApplicationUserService.Object,
null, null);
// Action
var result = await controller.Create(userViewModel);
// Assert
Assert.IsInstanceOfType(result, typeof(ActionResult <SignupViewModel>));
Assert.AreEqual(userResponse, result.Value);
Assert.AreEqual(userResponse.Password, null);
mockForDomainUserService.VerifyAll();
mockForApplicationUserService.VerifyAll();
}
public async Task IShouldCanCreateAUser()
{
var userToCreate = new User
{
Id = "asdf798asdfas-asjkdhrjkwer8",
Email = "*****@*****.**"
};
var viewModel = new SignupViewModel
{
Email = "*****@*****.**"
};
var viewModelResult = new SignupViewModel
{
Email = "*****@*****.**"
};
var mockForDomainService = new Mock <IUserService>();
mockForDomainService.Setup(service => service.CreateUser(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(userToCreate)
.Verifiable();
var mockForMapper = new Mock <IMapper>();
mockForMapper.Setup(m => m.Map <User>(It.IsAny <SignupViewModel>()))
.Returns(userToCreate)
.Verifiable();
mockForMapper.Setup(m => m.Map <SignupViewModel>(It.IsAny <User>()))
.Returns(viewModelResult)
.Verifiable();
var service = new UserApplicationService(mockForMapper.Object,
mockForDomainService.Object);
var result = await service.CreateUser(viewModel);
Assert.AreEqual(viewModelResult, result);
mockForDomainService.VerifyAll();
mockForMapper.VerifyAll();
}
public ActionResult Signup(SignupViewModel viewModel)
{
//Declare redirect path variables:
string redirect_action;
string redirect_controller;
//Verify the user's password and confirmPassword are the same, else GET OUT!
if (viewModel.Password == viewModel.ConfirmPassword)
{
//Create a new user:
try
{
IUserMapper user = users_bll.Insert(new UserMapper {
Name = viewModel.Name, RoleName = "user", password_hash = viewModel.Password
});
//Set the session to log the user in:
setSessionData(user);
//redirect path variables:
redirect_action = "Index";
redirect_controller = "Dashboard";
}
catch (SqlBLLException) {
//redirect path variables:
redirect_action = "Signup";
redirect_controller = "Authentication";
TempData["ErrorMessage"] = "The username you entered already exists.";
}
}
else
{
//redirect path variables:
redirect_action = "Signup";
redirect_controller = "Authentication";
TempData["ErrorMessage"] = "The password you entered must match in both fields.";
}
//Redirect to the dashboard (protected page):
return(RedirectToAction(redirect_action, redirect_controller));
}
public ActionResult HtmlHelpers(SignupViewModel vm)
{
return View(vm);
}
public ActionResult ChameleonForms(SignupViewModel vm)
{
return View(vm);
}
public ActionResult EditorTemplates(SignupViewModel vm)
{
return View(vm);
}
private string _signupurl = "http://idea-bag.com/authentication/signupstandarduser";//"http://idea-bag.com/authentication/echoposttest";//
#endregion
#region Constructor
public SignupViewController (IntPtr handle) : base (handle)
{
this._viewmodel = new SignupViewModel (_signupurl);
this._viewmodel.OnSignupCompleted += HandleSignupCompleted;
}
