public async Task <IActionResult> Register([FromBody] RegisterVm model)
{
if (ModelState.IsValid)
{
var userProfile = new UserProfile();
model.ToEntity(userProfile);
var result = await _userManager.CreateAsync(userProfile, model.Password);
if (result.Succeeded)
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
// Send an email with this link
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
//await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
// "Please confirm your account by clicking this link: <a href=\"" + callbackUrl + "\">link</a>");
await _signInManager.SignInAsync(userProfile, isPersistent : false);
return(Content("ok"));
}
else
{
Response.StatusCode = 422;
return(Json(new Dictionary <string, string[]>()
{
{
string.Empty, result.Errors.Select(e => e.Description).ToArray()
}
}));
}
}
Response.StatusCode = 422;
return(Json(ModelState.ToErrorsDictionary()));
}
public async Task <IActionResult> Register(RegisterVm register)
{
if (ModelState.IsValid)
{
var user = new User()
{
FirstName = register.FirstName,
LastName = register.LastName,
Email = register.Email,
PhoneNumber = register.Phone,
UserName = register.Email,
OfficeNo = register.OfficeId,
};
var result = await userManager.CreateAsync(user, register.Password);
if (result.Succeeded)
{
await signInManager.SignInAsync(user, false);
return(RedirectToAction("Index", "Product"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(register));
}
public Task <ApiResult <string> > Register(RegisterVm registerVm)
{
var apiResult = new ApiResult <string>
{
Code = Code.OK
};
registerVm.UserName = registerVm.UserName.Trim();
registerVm.PassWord = registerVm.PassWord.Trim();
if (_userService.ExistUserName(registerVm.UserName))
{
apiResult.Code = Code.BAD_REQUEST;
apiResult.Message = "用户名称存在";
return(Task.FromResult(apiResult));
}
if (_userService.ExistEmail(registerVm.Email))
{
apiResult.Code = Code.BAD_REQUEST;
apiResult.Message = "用户邮箱存在";
return(Task.FromResult(apiResult));
}
if (_userService.ExistMobilePhone(registerVm.MobilePhone))
{
apiResult.Code = Code.BAD_REQUEST;
apiResult.Message = "用户手机号码存在";
return(Task.FromResult(apiResult));
}
apiResult.Message = "注册成功";
_userService.Insert(registerVm);
return(Task.FromResult(apiResult));
}
public ActionResult Register(RegisterVm vm)
{
if (ModelState.IsValid)
{
//Check if nick name is also unic. (Along with email)
if (!IsNickNameUnic(vm.NickName))
{
ModelState.AddModelError("", "Такой логин уже зарегестрирован.");
}
AppUser user = new AppUser {
UserName = vm.Email, Email = vm.Email, UserNickName = vm.NickName
};
IdentityResult result = UserManager.Create(user, vm.Password);
if (result.Succeeded)
{
//Immediate sign in
SignIn(user);
return(RedirectToAction("Index", "Home"));
}
foreach (string error in result.Errors)
{
//Russian translation. Defaul is english
if (error.Contains("is already taken"))
{
ModelState.AddModelError("", "Такой email уже зарегестрирован.");
}
else
{
ModelState.AddModelError("", error);
}
}
}
return(View(vm));
}
public async Task RegisterStudent_returns_ViewResultWithModel()
{
var model = new RegisterVm
{
StudentCardNr = "studentcrnr",
Password = "******"
};
_messages.Setup(x => x.Dispatch(It.IsAny <GetInviteByTokenQuery>()))
.Returns(new Invite(123, "token", false, "*****@*****.**"));
_messages.Setup(x => x.Dispatch(It.IsAny <GetStudentQuery>()))
.Returns(new Student {
StudentCardNumber = "studentcrnr"
});
_userManager.Setup(x => x.CreateAsync(It.IsAny <ApplicationUser>(), "Password123"))
.Returns(Task.FromResult(new IdentityResult()));
// Act
var actionResult = await _sut.RegisterStudent(model);
var view = (ViewResult)actionResult;
var resultModel = (RegisterVm)view.Model;
// Assert
Assert.That(resultModel, Is.TypeOf <RegisterVm>());
}
public async Task <IActionResult> Create(RegisterVm register)
{
if (!ModelState.IsValid)
{
return(View());
}
AppUser newUser = new AppUser
{
Fullname = register.Fullname,
Email = register.Email,
UserName = register.Username
};
IdentityResult identityResult = await _userManager.CreateAsync(newUser, register.Password);
if (!identityResult.Succeeded)
{
foreach (var error in identityResult.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(register));
}
newUser.EmailConfirmed = true;
newUser.IsActivated = true;
await _userManager.AddToRoleAsync(newUser, "Member");
TempData["success"] = "User Created";
return(RedirectToAction("Index", "Users"));
}
public ActionResult Save(RegisterVm registerVm)
{
if (registerVm.data != null)
{
if (registerVm.register.id == 0)
{
registerVm.register.id = (registerVm.data.OrderByDescending(x => x.id).FirstOrDefault().id) + 1;
registerVm.data.Add(registerVm.register);
}
else
{
var obj = registerVm.data.Where(x => x.id == registerVm.register.id).FirstOrDefault();
obj.name = registerVm.register.name;
obj.email = registerVm.register.email;
obj.phone = registerVm.register.phone;
}
}
else
{
registerVm.register.id = 1;
registerVm.data = new List <register>();
registerVm.data.Add(registerVm.register);
}
ModelState.Clear();
return(View("Index", new RegisterVm
{
data = registerVm.data,
register = null
}));
}
public ActionResult New(RegisterVm registerVm)
{
ModelState.Clear();
registerVm.register = null;
registerVm.selectedIndex = 0;
return(View("Index", registerVm));
}
public IActionResult Register(RegisterVm model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = _mapper.Map <User>(model);
try
{
if (_userService.Register(user))
{
_mailSender.SendWelcomeMail(model.Email);
return(RedirectToAction("Index", "Home"));
}
else
{
model.IsInvalid = true;
model.ErrorMessage = "Email already registered";
return(View(model));
}
}
catch (System.Net.Mail.SmtpException)
{
return(ForbiddenView());
}
}
public async Task <IActionResult> Register([FromBody] RegisterVm reg)
{
if (!ModelState.IsValid)
{
return(BadRequest(new { Error = "Invalid data was submitted", Message = ModelState.Values.First(x => x.Errors.Count > 0).Errors.Select(t => t.ErrorMessage).First() }));
}
AppUsers user = reg.Transform();
var result = await _userManager.CreateAsync(user, user.Password);
if (!result.Succeeded)
{
return(BadRequest(new { Message = result.Errors.First().Description }));
}
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Name, user.UserName));
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, "User"));
if (await _userManager.Users.CountAsync() < 3)
{
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, "Researcher"));
}
else
{
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, "Assistant"));
}
var _user = await _userManager.FindByIdAsync(user.Id);
await _signInManager.SignInAsync(_user, true);
await db.SaveChangesAsync();
return(Created("", user));
}
public async Task <ActionResult> Register(RegisterVm register)
{
if (ModelState.IsValid)
{
var user = new IdentityUser
{
UserName = register.UserName,
Email = register.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, register.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(register));
}
public async Task <IActionResult> ResendRegistrationEmail(RegisterVm model)
{
Logger.LogInformation($"Resend Registration email callback url: {model.CallbackUrl}");
await _registerService.ResendActivationLink(model.EmailAddress);
return(View("SendRegistrationEmail", model));
}
// GET: Register
public ActionResult Index(RegisterVm registerVm = null)
{
if (registerVm != null)
{
return(View(registerVm));
}
return(View(new RegisterVm()));
}
public async Task <ViewResult> Register(RegisterVm vm)
{
if (vm.Email != vm.RepeatEmail)
{
ViewBag.ErrorMessage = "Emails must be the matching";
return(View());
}
if (vm.Password != vm.RepeatPassword)
{
ViewBag.ErrorMessage = "Password must be the matching";
return(View());
}
if (_userManager.Users.Any(u => u.UserName == vm.Login))
{
ViewBag.ErrorMessage = "Given login is already in use";
return(View());
}
var user = new AppUser
{
FirstName = vm.FirstName,
LastName = vm.LastName,
UserName = vm.Login,
Email = vm.Email,
EmailConfirmed = true
};
var passwordHasher = _userManager.PasswordHasher;
user.PasswordHash = passwordHasher.HashPassword(user, vm.Password);
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
ViewBag.ErrorMessage = "Cannot create user with given credentials";
return(View());
}
result = await _userManager.AddToRoleAsync(user, AppRoles.Student);
if (!result.Succeeded)
{
ViewBag.ErrorMessage = "Cannot create user with given credentials";
return(View());
}
var student = new Student
{
AppUser = user
};
_dbContext.Students.Add(student);
_dbContext.SaveChanges();
ViewBag.Message = "Registration was succesfull";
return(View(nameof(Login)));
}
private async Task <bool> UserExists(RegisterVm registerModel)
{
var result = await _userManager.Users.FirstOrDefaultAsync(p => p.Email == registerModel.Email || p.PhoneNumber == registerModel.PhoneNumber);
if (result != null)
{
return(true);
}
return(false);
}
public async Task <ApiResult> Register(RegisterVm model)
{
var user = _mapper.Map <UserDto>(model);
user.Role = Roles.Admin;
await _userService.CreateUserAsync(user);
return(ApiResult.Ok);
}
public async Task <IActionResult> RegisterStudent(string token)
{
await _signInManager.SignOutAsync();
var model = new RegisterVm
{
Token = token
};
return(View(model));
}
public async Task <IActionResult> CompleteRegistration(RegisterVm model, string returnUrl = "/MyAccounts")
{
try
{
if (!ModelState.IsValid)
{
_gtmService.RaiseRegistrationEvent_ActivationEmailSent(model, null, "Invalid registration details");
return(View(model));
}
var result = await _registerService.CreateAccount(new RegisterAccount
{
Password = model.Password,
EmailAddress = model.EmailAddress,
ExpiresAt = null,
LowellReferenceNumber = model.LowellReference
});
if (result.IsSuccess)
{
_gtmService.RaiseRegistrationEvent_ActivationEmailSent(model, result.SubjectId.ToString(), null);
await _webActivityService.LogRegistrationRequest(model.LowellReference, string.Empty);
return(View("SendRegistrationEmail", model));
}
else
{
Logger.LogError($"Complete Registration Error: {JsonConvert.SerializeObject(result)}");
if (result.ErrorCode == 1000)
{
AddErrors(ValidationMessages.UserNameAlreadyExists);
model.NotificationMessage = ValidationMessages.UserNameAlreadyExists;
_gtmService.RaiseRegistrationEvent_ActivationEmailSent(model, null, "Username already exists");
}
else
{
AddErrors(ValidationMessages.ConfirmRegistrationFailed);
model.NotificationMessage = ValidationMessages.ConfirmRegistrationFailed;
_gtmService.RaiseRegistrationEvent_ActivationEmailSent(model, null, "service unavailable");
}
return(View(model));
}
}
catch (Exception ex)
{
Logger.LogError(ex, $"Complete Registration Error: {ex.Message}");
_gtmService.RaiseRegistrationEvent_ActivationEmailSent(model,
string.IsNullOrEmpty(LoggedInUserId) ? null : LoggedInUserId, $"Unhandled exception: {ex.Message}");
return(View("Error"));
}
}
public async Task RegisterStudent_returns_jsonResult_When_Invite_Is_Null()
{
var model = new RegisterVm();
// Act
var actionResult = await _sut.RegisterStudent(model);
var result = (JsonResult)actionResult;
// Assert
Assert.That(result.Value, Is.EqualTo("Midagi läks valesti, võta ühendust kooli administraatoriga või proovi uuesti"));
}
public IHttpActionResult Register([FromBody] RegisterVm register)
{
try
{
var user = new User
{
FirstName = register.FirstName,
LastName = register.LastName,
Cpf = register.Cpf,
Contacts = new List <Contact>()
};
if (!string.IsNullOrWhiteSpace(register.Email))
{
user.Contacts.Add(new Contact
{
ContactType = ContactType.Email,
Description = register.Email,
UserId = user.UserId
});
}
if (!string.IsNullOrWhiteSpace(register.Telephone))
{
user.Contacts.Add(new Contact
{
ContactType = ContactType.Telephone,
Description = register.Telephone,
UserId = user.UserId
});
}
if (!string.IsNullOrWhiteSpace(register.CellPhone))
{
user.Contacts.Add(new Contact
{
ContactType = ContactType.Cellphone,
Description = register.CellPhone,
UserId = user.UserId
});
}
user.SetNewPassword(user.Password);
_db.Users.Add(user);
_db.SaveChanges();
return(Ok(user));
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(BadRequest(ex.Message));
}
}
public async Task <Tuple <bool, string> > Register(RegisterVm registerVm)
{
try
{
var checkIfUserExist = await UserExists(registerVm);
if (checkIfUserExist)
{
return(new Tuple <bool, string>(false, "Phone number or email has been taken"));
}
email = registerVm.Email;
fullName = registerVm.Surname + " " + registerVm.OtherNames;
User userToRegister = new User
{
Surname = registerVm.Surname,
OtherNames = registerVm.OtherNames,
Email = registerVm.Email,
PhoneNumber = registerVm.PhoneNumber,
Gender = registerVm.Sex,
DateOfBirth = registerVm.DateOfBirth,
UserName = registerVm.Email,
ResidentialAddress = registerVm.Address,
ImagePath = registerVm.ImagePath,
Organisation = registerVm.Organisation,
Society = registerVm.Society,
BCC = registerVm.BCC,
StateOfOrigin = registerVm.State,
NatureOfWork = registerVm.NatureOfWork,
Occupation = registerVm.Occupation,
WorshipCenter = registerVm.WorshipCenter,
Suggestion = registerVm.Suggestion,
MaritalStatus = registerVm.MaritalStatus,
MembershipCardNumber = registerVm.MCardNumber,
};
var result = await _userManager.CreateAsync(userToRegister, registerVm.Password);
if (!result.Succeeded)
{
return(new Tuple <bool, string>(false, result.Errors.FirstOrDefault().Description));
}
//SendMail();
return(new Tuple <bool, string>(true, userToRegister.Surname + " " + userToRegister.OtherNames));
}
catch (Exception ex)
{
return(new Tuple <bool, string>(false, "Oops! An error occured"));
}
}
public ActionResult Edit(RegisterVm registerVm)
{
var register = registerVm.data.Where(x => x.id == registerVm.selectedIndex).FirstOrDefault();
var _registerVm = new RegisterVm
{
data = registerVm.data,
register = register
};
ModelState.Clear();
return(View("Index", _registerVm));
}
public void TestMethod1()
{
// Arrange
AccountController controller = new AccountController();
// Act
RegisterVm reg = new RegisterVm();
ViewResult result = controller.Register(reg) as ViewResult;
// Assert
//Assert.AreEqual(, result.ViewBag.Message);
Assert.IsTrue(true);
}
public ActionResult Edit(int SelectedIndex)
{
var data = (List <register>)Session["Ssn:Data"];
var register = data.Where(x => x.id == SelectedIndex).FirstOrDefault();
var registerVm = new RegisterVm
{
data = data,
register = register
};
return(View("Index", registerVm));
}
public async Task <ApiResult> ConfirmEmail(RegisterVm model)
{
var user = await _userService.ConfirmUserEmailAsync(model.UserName, model.VerificationCode);
user.Password = model.Password;
var claim = await _userService.AuthenticateUserAsync(user);
AuthenticationManager.SignIn(new AuthenticationProperties {
IsPersistent = true
}, claim);
return(_mapper.Map <UserVm>(user).AsApiResult());
}
public ActionResult Delete(RegisterVm registerVm)
{
var obj = registerVm.data.Where(x => x.id == registerVm.selectedIndex).FirstOrDefault();
registerVm.data.Remove(obj);
var _registerVm = new RegisterVm
{
data = registerVm.data,
register = null
};
ModelState.Clear();
return(View("Index", _registerVm));
}
public void RegisterVmValidator_IncorrectPassword_ReturnsErrors(string password, int errorCount)
{
var model = new RegisterVm()
{
EmailAddress = "*****@*****.**",
Password = password,
ConfirmPassword = password,
TsAndCsAccepted = true
};
ValidationResult result = _validator.Validate(model);
Assert.AreEqual(false, result.IsValid);
}
public IActionResult Register()
{
if (currentUser.IsAuthenticated)
{
return(RedirectToAction("Index", "Announcement"));
}
var model = new RegisterVm
{
//Counties = GetCounties(),
DateOfBirth = DateTime.Now
};
return(View(model));
}
public void RegisterVmValidator_EmailAddress_MatchesIncorrectEmailAddress_ReturnsErrors(string email, int errorCount)
{
var model = new RegisterVm()
{
EmailAddress = email,
Password = "******",
ConfirmPassword = "******",
TsAndCsAccepted = true,
};
ValidationResult result = _validator.Validate(model);
Assert.AreEqual(false, result.IsValid);
}
public void RegisterVmValidator_CorrectPassword(string password)
{
var model = new RegisterVm()
{
EmailAddress = "*****@*****.**",
Password = password,
ConfirmPassword = password,
TsAndCsAccepted = true
};
ValidationResult result = _validator.Validate(model);
Assert.AreEqual(true, result.IsValid);
}
