public ICollection <string> ValidateUser(RegisterFormModel model)
{
var errors = new List <string>();
if (string.IsNullOrEmpty(model.Username) ||
model.Username.Length < UserMinUsername ||
model.Username.Length > DefaultMaxLength)
{
errors.Add($"Username '{model.Username}' is not valid. It must be between {UserMinUsername} and {DefaultMaxLength} characters long.");
}
if (!Regex.IsMatch(model.Email, UserEmailRegularExpression))
{
errors.Add($"Email {model.Email} is not a valid e-mail address.");
}
if (model.Password.Length < UserMinPassword || model.Password.Length > DefaultMaxLength)
{
errors.Add($"The provided password is not valid. It must be between {UserMinPassword} and {DefaultMaxLength} characters long.");
}
if (model.Password != model.ConfirmPassword)
{
errors.Add($"Password and its confirmation are different.");
}
return(errors);
}
public async Task <IActionResult> Index(RegisterFormModel model)
{
if (ModelState.IsValid)
{
HttpResponseMessage response;
RegisterResponseModel responseModel;
model.PhoneNumber = FormatPhoneNumber(model.PhoneNumber);
response = await GetHttpResponseMessageRegister(model);
if (response.StatusCode == HttpStatusCode.OK)
{
responseModel = await GetResponseModel <RegisterResponseModel>(response);
if (responseModel.code == REGISTER_SUCCESS_CODE)
{
return(RedirectToAction("RegisterSuccess", "Form", new { messages = RegisterMessage(REGISTER_SUCCESS_MESSAGE), email = model.Email }));
}
else if (responseModel.code == NOT_VERIFIED_CODE)
{
return(RedirectToAction("RegisterSuccess", "Form", new { messages = RegisterMessage(REGISTER_NOT_VERIFIED), email = model.Email }));
}
else
{
ViewData["email-registered"] = EMAIL_REGISTERED;
return(View(model));
}
}
}
return(View(model));
}
public async void Register()
{
var registerModel = new RegisterFormModel
{
Username = Username,
Email = Email,
Password = Password,
ConfirmPassword = ConfirmPassword,
FirstName = FirstName,
LastName = LastName
};
var result = _registerValidator.Validate(registerModel);
if (result.IsValid)
{
if (await _registerService.Register(registerModel))
{
_events.PublishOnUIThread(new UserHasRegisteredEvent());
this.TryClose();
}
else
{
MessageBox.Show("Wystąpił błąd. Spróbuj ponownie");
}
}
else
{
MessageBox.Show("Błąd walidacji danych.");
}
}
public ActionResult Register(RegisterFormModel formModel)
{
if (ModelState.IsValid)
{
// Hash the user's password.
string hashedPassword = BCrypt.Net.BCrypt.HashPassword(formModel.Password, 12);
// Create an instance of the user database model.
User user = new User()
{
Email = formModel.Email,
HashedPassword = hashedPassword,
Name = formModel.Name
};
// TODO Save the user to the database.
// Create the authentication ticket (i.e. HTTP cookie).
FormsAuthentication.SetAuthCookie(formModel.Email, false);
// Redirect the user to the "Home" page.
return(RedirectToAction("Index", "Home"));
}
return(View(formModel));
}
public HttpResponseMessage Register([FromBody] RegisterFormModel registerData)
{
try
{
if (registerData == null)
{
return(HttpResponseFactory.Response200Json(new ErrorJson {
Error = ErrorMessages.ERR_NO_REGISTER_DATA
}));
}
this.dataAccess.RegisterUser(registerData.Name, registerData.Password, registerData.Email, this.Request.GetRemoteIPAddress());
return(HttpResponseFactory.Response200Json(new ResultJson {
Result = StatusMessages.STR_SUCCESS
}));
}
catch (PR2Exception ex)
{
return(HttpResponseFactory.Response200Json(new ErrorJson {
Error = ex.Message
}));
}
catch (Exception ex)
{
return(HttpResponseFactory.Response500Plain(ex.Message));
}
}
public async Task <IActionResult> Register(RegisterFormModel model)
=> await this.Handle(
async() =>
{
var result = await this.identityService
.Register(this.mapper.Map <RegisterUserInputModel>(model));
},
success : this.RedirectToAction(nameof(this.Login)),
failure : this.View(model));
public IActionResult Register(RegisterFormModel model)
{
if (ModelState.IsValid)
{
_service.Register(model.toLocal());
return(RedirectToAction("Index", "Movie"));
}
return(View(model));
}
public void Configure(string buttonName, EventHandler <RegisterFormModel> buttonClick, RegisterFormModel form)
{
_form = form;
_buttonClick = buttonClick;
UIButtonExtensions.SetupButtonAppearance(_button, Colors.White, 16f, buttonName);
this.BackgroundColor = Colors.MainBlue;
_button.TouchUpInside -= OnButton_TouchUpInside;
_button.TouchUpInside += OnButton_TouchUpInside;
}
public async Task <bool> Register(RegisterFormModel registerForm)
{
bool output = false;
var account = createAccountObject(registerForm);
output = await _accountRepo.CreateAccount(account);
return(output);
}
public async Task <ActionResult> Index(RegisterFormModel userInput)
{
if (StateHelper.GetUserFromCookie(Request) != null)
{
return(RedirectToAction(nameof(Index)));
}
if (!ModelState.IsValid || !userInput.IsValid())
{
return(View("Login"));
}
try
{
var ual = new UserAccessLayer();
var user = await ual.GetUserByUsername(userInput.Username);
if (user == null)
{
ViewData["Error"] = "Invalid username or password.";
return(View("Login"));
}
if (user.LoginAttempts > 3)
{
ViewData["Error"] = "Account has been locked.";
return(View("Login"));
}
var passwordHash = Crypto.CalculateArgon2Hash(userInput.Password, user.HashSalt);
if (!Crypto.SecureCompareByteArrays(passwordHash, user.PasswordHash))
{
ViewData["Error"] = "Invalid username or password.";
user.LoginAttempts++;
await ual.UpdateUser(user);
return(View("Login"));
}
user.Token = StateHelper.GenerateUniqueToken();
user.TokenDate = DateTime.Now.AddMinutes(StateHelper.ValidTokenDuration);
user.LoginAttempts = 0;
await ual.UpdateUser(user);
StateHelper.SetUserCookie(user, Response);
return(RedirectToAction(nameof(Index)));
}
catch
{
ViewData["Error"] = "An unknown error has occured.";
return(View("Login"));
}
}
public async Task <ActionResult> Register(RegisterFormModel formModel)
{
var form = Service.GetForm(SiteContext.Current, formModel.Id);
if (form != null)
{
var formErrors = GetFormErrors(ModelState);
if (formErrors == null)
{
form.PostedSuccessfully = true;
var user = new ApplicationUser
{
Email = formModel.Email,
Password = formModel.Password,
UserName = formModel.Email
};
var result = await SecurityService.CreateUserAsync(user);
if (result.Succeeded)
{
user = await SecurityService.GetUserByNameAsync(user.UserName);
Context.Customer = await this.CustomerService.CreateCustomerAsync(
formModel.Email, formModel.FirstName, formModel.LastName, user.Id, null);
await SecurityService.PasswordSingInAsync(formModel.Email, formModel.Password, false);
var identity = SecurityService.CreateClaimsIdentity(formModel.Email);
AuthenticationManager.SignIn(identity);
return(RedirectToAction("Index", "Account"));
}
else
{
form.Errors = new SubmitFormErrors("form", result.Errors.First());
form.PostedSuccessfully = false;
}
}
else
{
form.Errors = formErrors;
form.PostedSuccessfully = false;
}
}
else
{
return(View("error"));
}
return(View("customers/register"));
}
private Task <Dictionary <string, string> > GenerateParametersApiRegister(RegisterFormModel model)
{
return(Task.FromResult(new Dictionary <string, string>
{
{ KEY_PARAMETER_EMAIL, model.Email },
{ KEY_PARAMETER_PASSWORD, model.Password },
{ KEY_PARAMETER_CONFIRM_PASSWORD, model.ConfirmPassword },
{ KEY_PARAMETER_PHONE_NUMBER, model.PhoneNumber },
{ KEY_PARAMETER_REGISTER_URI, GetAbsoluteUri(model).Result }
}));
}
public void Create(RegisterFormModel model)
{
var user = new User
{
Username = model.Username,
Email = model.Email,
Password = this.passwordHasher.HashPassword(model.Password)
};
this.db.Users.Add(user);
this.db.SaveChanges();
}
public ActionResult Register(RegisterFormModel model)
{
if (ModelState.IsValid)
{
UserService service = new UserService();
service.Insert(model.Map <User>());
TempData["SuccessMessage"] = "User successfully created";
return(RedirectToAction("Home", "Default"));
}
ViewBag.ErrorMessage = "Error Occured. Please check the form.";
return(View(model));
}
public bool Register(RegisterFormModel registerForm)
{
bool output = false;
var account = createAccountObject(registerForm);
if (account != null)
{
// TODO: Register account in database
}
return(output);
}
public async Task <IActionResult> Register(RegisterFormModel model)
=> await this.Handle(
async() =>
{
var mdl = new UserInputModel()
{
Email = model.Email, Password = model.Password
};
var result = await this.identityService
.Register(mdl);
},
success : RedirectToAction(nameof(UsersController.Login), "Users"),
failure : View("../Users/Register", model));
private Account createAccountObject(RegisterFormModel registerForm)
{
var account = new Account
{
Username = registerForm.Username,
Email = registerForm.Email,
Password = CalculateHash(registerForm.Password, registerForm.Username),
IsActive = false,
FirstName = registerForm.FirstName,
LastName = registerForm.LastName,
Balance = 0
};
return(account);
}
public AutomationPracticeRegistration FillWith(RegisterFormModel model)
{
this.FirstName.TypeText(model.FirstName);
this.LastName.TypeText(model.LastName);
this.Password.TypeText(model.Password);
this.City.TypeText(model.City);
this.PostCode.TypeText(model.PostCode);
this.Phone.TypeText(model.Phone);
this.Address.TypeText(model.Address);
var stateDropdown = new SelectElement(this.StateDropDown.NativeElement);
stateDropdown.SelectByIndex(1);
return(this);
}
public ActionResult Register(RegisterFormModel rfm)
{
if (ModelState.IsValid)
{
if (!IsResumeFileExtensionValid(rfm.PersonalDetail.ResumeFile))
{
ModelState.AddModelError("ResumeFile", "File with extension .txt, .doc, .docx or .pdf is allowed.");
return(View(rfm));
}
//save to db
SaveUser(rfm);
return(RedirectToAction("Login", "Account"));
}
return(View("Register1", rfm));
}
public async Task <ActionResult> Register(RegisterFormModel model)
{
var userDto = Mapper.Map <RegisterFormModel, DutUser>(model);
var details = await UserService.Create(userDto, model.Password);
if (!details.Successed)
{
return(Json(new { model = "failed", modelList = new[] { details.Message } }, JsonRequestBehavior.AllowGet));
}
var claim = await Task.Run(() => UserService.Authenticate(model.UserName, model.Password));
AuthenticationManager.SignOut();
AuthenticationManager.SignIn(new AuthenticationProperties {
IsPersistent = true
}, claim);
return(Json(new { model = "confirmed", href = "/dashboard/welcome" }, JsonRequestBehavior.AllowGet));
}
public void ChangeTab(string name)
{
if (name == "PreviousRaceModel")
{
DataContext = new PreviousRaceModel();
}
if (name == "MainScreen")
{
DataContext = new MainScreen();
}
if (name == "RegisterFormModel")
{
DataContext = new RegisterFormModel();
}
if (name == "SponsorARunnerModel")
{
DataContext = new SponsorARunnerModel();
}
}
//[Route("/Register")]
public async Task <ActionResult> Register(string returnUrl, RegisterFormModel registerFormModel)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new IdentityUser {
UserName = registerFormModel.Email, Email = registerFormModel.Email
};
var result = await _userManager.CreateAsync(user, registerFormModel.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(registerFormModel.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginRegisterViewModel viewModel = new LoginRegisterViewModel();
viewModel.ReturnUrl = returnUrl;
// If we got this far, something failed, redisplay form
return(View("LoginRegister", viewModel));
}
public async Task <ActionResult> Register([FromBody] RegisterFormModel model)
{
var person = new Person()
{
PublicId = Guid.NewGuid().ToString(),
UserName = model.UserName,
Email = model.Email
};
var result = await _userManager.CreateAsync(person, model.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
return(BadRequest(ModelState));
}
}
return(Accepted());
}
private Account createAccountObject(RegisterFormModel registerForm)
{
Account account = null;
var user = new UserProfile
{
Username = registerForm.Username,
Email = registerForm.Email,
Password = CalculateHash(registerForm.Password, registerForm.Username),
IsActive = false
};
account = new Account
{
FirstName = registerForm.FirstName,
LastName = registerForm.LastName,
User = user,
Balance = 0
};
return(account);
}
public HttpResponse Register(RegisterFormModel model)
{
var modelErrors = this.validator.ValidateUser(model);
if (modelErrors.Any())
{
return(Error(modelErrors));
}
if (!this.usersService.IsEmailAvailable(model.Email))
{
return(Error("Email exists. Please use another one."));
}
if (!this.usersService.IsUsernameAvailable(model.Username))
{
return(Error("Username exists. Please use another one."));
}
this.usersService.Create(model);
return(Redirect("/Users/Login"));
}
public ActionResult Register(RegisterFormModel formModel)
{
if (ModelState.IsValid)
{
// Create an instance of the user database model.
User user = new User()
{
Email = formModel.Email,
HashedPassword = formModel.Password,
Name = formModel.Name
};
// TODO Save the user to the database.
var userRepo = new UserRepo(context);
userRepo.Insert(user);
// Create the authentication ticket (i.e. HTTP cookie).
FormsAuthentication.SetAuthCookie(formModel.Email, false);
// Redirect the user to the "Home" page.
return(RedirectToAction("Index", "Bench"));
}
return(View(formModel));
}
private void SaveUser(RegisterFormModel rfm)
{
var fileName = DateTime.Now.ToString("yyyymmddMMss") +
rfm.PersonalDetail.FirstName +
rfm.PersonalDetail.LastName +
System.IO.Path.GetExtension(rfm.PersonalDetail.ResumeFile.FileName); //datetime needed?
var user = new User()
{
FirstName = rfm.PersonalDetail.FirstName,
LastName = rfm.PersonalDetail.LastName,
Password = rfm.PersonalDetail.Password, //must encrypt
Email = rfm.PersonalDetail.Email,
ContactNumber = rfm.PersonalDetail.ContactNumber,
Role = _context.Role.First(ut => ut.Type == "JobSeeker"),
ResumeFileName = fileName,
DOB = rfm.PersonalDetail.DOB,
CreatedDate = DateTime.Now
};
_context.User.Add(user);
SaveFile(rfm.PersonalDetail.ResumeFile, fileName);
foreach (var ed in rfm.ExperienceDetails)
{
var experienceDetail = new ExperienceDetails()
{
Seeker = user,
CompanyName = ed.CompanyName,
JobTitle = ed.JobTitle,
StartDate = ed.StartDate,
EndDate = ed.EndDate,
Type = ed.Type
};
_context.ExperienceDetails.Add(experienceDetail);
_context.SaveChanges();
foreach (var skill in ed.SkillId)
{
//experienceDetail.Skills.Add(new Skill() { Id = Convert.ToInt32(skill) });
_context.UserExperienceSkill.Add(new UserExperienceSkill {
SeekerId = user.Id,
ExperienceDetailId = experienceDetail.Id,
SkillId = Convert.ToInt32(skill)
});
}
}
var eduDetail = new EducationDetails()
{
Seeker = user,
HighestQualification = rfm.EducationDetail.HighestQualification,
InstituteOrUniversityName = rfm.EducationDetail.InstituteOrUniversityName,
MajorBranch = rfm.EducationDetail.MajorBranch,
Percentage = rfm.EducationDetail.Percentage,
EducationTypeId = Convert.ToInt32(rfm.EducationDetail.Type)
};
_context.EducationDetails.Add(eduDetail);
_context.SaveChanges();
}
public IActionResult Register(RegisterFormModel model)
{
DatabaseService.AddUserEntry(_db, model.Username, model.Email, model.Password);
return(Content($"Hello {model.Username}"));
}
public async Task<ActionResult> Register(RegisterFormModel formModel)
{
var form = Service.GetForm(SiteContext.Current, formModel.Id);
if (form != null)
{
var formErrors = GetFormErrors(ModelState);
if (formErrors == null)
{
form.PostedSuccessfully = true;
var user = new ApplicationUser
{
Email = formModel.Email,
Password = formModel.Password,
UserName = formModel.Email
};
var result = await SecurityService.CreateUserAsync(user);
if (result.Succeeded)
{
user = await SecurityService.GetUserByNameAsync(user.UserName);
Context.Customer = await this.CustomerService.CreateCustomerAsync(
formModel.Email, formModel.FirstName, formModel.LastName, user.Id, null);
await SecurityService.PasswordSingInAsync(formModel.Email, formModel.Password, false);
var identity = SecurityService.CreateClaimsIdentity(formModel.Email);
AuthenticationManager.SignIn(identity);
return RedirectToAction("Index", "Account");
}
else
{
form.Errors = new SubmitFormErrors("form", result.Errors.First());
form.PostedSuccessfully = false;
}
}
else
{
form.Errors = formErrors;
form.PostedSuccessfully = false;
}
}
else
{
return View("error");
}
return View("customers/register");
}
private Task <string> GetAbsoluteUri(RegisterFormModel registerModel)
{
return(Task.FromResult(string.Format("{0}://{1}{2}", Request.Scheme, Request.Host, Request.Path)));
}
private Task <HttpResponseMessage> GetHttpResponseMessageRegister(RegisterFormModel model)
{
return(HttpClientRequest.PostAsync(ApiEndpoints.Register, GenerateParametersApiRegister(model).Result));
}
