public JsonResult ValidateMemberId([Bind(Prefix = "registerModel")] RegisterFormViewModel model)
{
var errorMsg = ValidateMemberIdCore(model.MemberId, model.DateOfBirth);
return(errorMsg == null
? Json(true, JsonRequestBehavior.AllowGet) : Json(errorMsg, JsonRequestBehavior.AllowGet));
}
public ActionResult Register(RegisterFormViewModel registerViewModel, string returnUrl)
{
if (!ModelState.IsValid)
{
registerViewModel.RoleTypes = _context.RoleTypes.ToList();
return(View("RegistrationForm", registerViewModel));
}
else
{
var register = new Registration
{
Username = registerViewModel.Registration.Username,
Password = registerViewModel.Registration.Password,
PasswordConfirmation = registerViewModel.Registration.PasswordConfirmation,
RoleId = registerViewModel.Registration.RoleId
};
FormsAuthentication.SetAuthCookie(register.Username, true);
_context.Registrations.Add(register);
_context.SaveChanges();
if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 &&
returnUrl.StartsWith("/") && !returnUrl.StartsWith("//") &&
!returnUrl.StartsWith("/\\"))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Index", "Account"));
}
}
}
public ActionResult Register(RegisterFormViewModel model)
{
//View model validation for register form
if (ModelState.IsValid)
{
var respondent = new Respondent
{
Date = DateTime.Now,
DoB = model.DoB,
FirstName = model.FirstName,
LastName = model.LastName,
Phone = model.Phone,
IP_Address = GetIpAddress()
};
//Store respondent in Session
AppSession.SetRespondent(respondent);
//Send respondent to Survey
return(RedirectToAction("Survey", "Survey"));
}
//If form invalid return respondent to register form
return(View());
}
public async Task <ActionResult> ChangeInfoUser(RegisterFormViewModel model)
{
if (!ModelState.IsValid)
{
string msg = string.Join(Environment.NewLine
, ModelState.Values.SelectMany(v => v.Errors).Select(v => v.ErrorMessage + " " + v.Exception));
ModelState.AddModelError("", msg);
return(View(model));
}
var identityUser = UserManager.FindById(model.Id);
identityUser = Mapper.Map(model, identityUser);
identityUser.Created = DateTime.UtcNow;
var result = await UserManager.UpdateAsync(identityUser);
if (result.Succeeded)
{
return(RedirectToAction("ChangeInfoUser", "User"));
}
return(View());
}
public List <string> Register(RegisterFormViewModel model)
{
ICollection <string> modelErrors = Validator.ValidateModel(model);
if (this.Data.Users.Any(u => u.Username == model.Username))
{
modelErrors.Add($"User with '{model.Username}' username already exists.");
}
if (this.Data.Users.Any(u => u.Email == model.Email))
{
modelErrors.Add($"User with '{model.Email}' e-mail already exists.");
}
if (modelErrors.Count != 0)
{
return(modelErrors.ToList());
}
var user = new User
{
Username = model.Username,
Password = this.PasswordHasher.GeneratePassword(model.Password),
Email = model.Email,
IsMechanic = model.UserType == "Client" ? false : true,
};
Data.Users.Add(user);
Data.SaveChanges();
return(modelErrors.ToList());
}
public List <string> CreateUser(RegisterFormViewModel model)
{
ICollection <string> modelErrors = Validator.ValidateModel(model);
if (!IsEmailAvailable(model.Email))
{
modelErrors.Add($"User with '{model.Email}' e-mail already exists.");
}
if (!IsUsernameAvailable(model.Username))
{
modelErrors.Add($"User with '{model.Username}' username already exists.");
}
if (modelErrors.Count != 0)
{
return(modelErrors.ToList());
}
var user = new User
{
Username = model.Username,
Password = this.passwordHasher.GeneratePassword(model.Password),
Email = model.Email,
};
Data.Users.Add(user);
Data.SaveChanges();
return(modelErrors.ToList());
}
public async Task <IActionResult> Register(RegisterFormViewModel register, string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new User
{
UserName = register.UserName,
Email = register.Email,
Cpf = register.Cpf,
PhoneNumber = register.PhoneNumber,
Name = register.Name
};
var result = await _userManager.CreateAsync(user, register.Password);
if (result.Succeeded)
{
var role = "Cliente";
await _userManager.AddToRoleAsync(user, role);
await _loginManager.SignInAsync(user, false);
return(RedirectToAction(nameof(Index)));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description.ToString());
}
}
}
return(View(register));
}
public async Task <ActionResult> Create(RegisterFormViewModel model, string ReturnUrl)
{
ActionResult action;
if (!this.ModelState.IsValid)
{
action = this.View();
}
else
{
IdentityUser identityUser = new IdentityUser()
{
UserName = model.UserName,
Address = model.Address,
FirstName = model.FirstName,
LastName = model.LastName,
MiddleName = model.MiddleName,
Phone = model.Phone,
Email = model.Email,
City = model.City,
State = model.State,
IsLockedOut = false,
IsSuperAdmin = false,
Created = DateTime.UtcNow
};
IdentityUser identityUser1 = identityUser;
IdentityResult identityResult = await this._userManager.CreateAsync(identityUser1, model.Password);
IdentityResult identityResult1 = identityResult;
if (identityResult1.Succeeded)
{
if (!model.IsSuperAdmin)
{
string item = this.Request["roles"];
if (!string.IsNullOrEmpty(item))
{
string[] strArrays = item.Split(new char[] { ',' });
await this._userManager.AddToRolesAsync(identityUser1.Id, strArrays);
}
}
this.Response.Cookies.Add(new HttpCookie("system_message", string.Format(MessageUI.CreateSuccess, FormUI.Account)));
if (!this.Url.IsLocalUrl(ReturnUrl) || ReturnUrl.Length <= 1 || !ReturnUrl.StartsWith("/") || ReturnUrl.StartsWith("//") || ReturnUrl.StartsWith("/\\"))
{
action = this.RedirectToAction("Index");
}
else
{
action = this.Redirect(ReturnUrl);
}
}
else
{
this.AddErrors(identityResult1);
action = this.View(model);
}
}
return(action);
}
public ActionResult Register()
{
m.LoadData();
var Roles = m.RoleClaimGetAllStrings();
var form = new RegisterFormViewModel();
form.RoleList = new MultiSelectList(Roles);
return(View(form));
}
public static AccountModel ToAccountModel(this RegisterFormViewModel ViewModel)
{
AccountModel Model = new AccountModel();
Model = Mapper.Map <RegisterFormViewModel, AccountModel>(ViewModel);
Model.Salt = PasswordHasher.GenerateSalt();
Model.Password = PasswordHasher.ComputeHash(ViewModel.Password, Model.Salt);
return(Model);
}
public async Task <ActionResult> Edit(RegisterFormViewModel model, string ReturnUrl)
{
ActionResult action;
try
{
model.Created = null;
IdentityUser identityUser = _userManager.FindById(model.Id);
identityUser = Mapper.Map(model, identityUser);
IdentityResult identityResult = await this._userManager.UpdateAsync(identityUser);
if (identityResult.Succeeded)
{
if (model.IsSuperAdmin)
{
IList <string> roles = this._userManager.GetRoles(model.Id);
this._userManager.RemoveFromRoles <IdentityUser, Guid>(model.Id, roles.ToArray <string>());
}
else
{
string item = this.Request["roles"];
if (!string.IsNullOrEmpty(item))
{
IList <string> lstUserRole = this._userManager.GetRoles(model.Id);
_userManager.RemoveFromRoles(model.Id, lstUserRole.ToArray());
string[] strArrays = item.Split(new char[] { ',' });
this._userManager.AddToRoles(model.Id, strArrays);
}
}
Response.Cookies.Add(new HttpCookie("system_message", string.Format(MessageUI.UpdateSuccess, FormUI.Account)));
if (!this.Url.IsLocalUrl(ReturnUrl) || ReturnUrl.Length <= 1 || !ReturnUrl.StartsWith("/") || ReturnUrl.StartsWith("//") || ReturnUrl.StartsWith("/\\"))
{
action = this.RedirectToAction("Index");
return(action);
}
else
{
action = this.Redirect(ReturnUrl);
return(action);
}
}
else
{
this.AddErrors(identityResult);
action = this.View(model);
return(action);
}
}
catch (Exception exception1)
{
Exception exception = exception1;
ExtentionUtils.Log(string.Concat("Account.Update: ", exception.Message));
}
action = this.View();
return(action);
}
public ActionResult ForgotPassword(RegisterFormViewModel form)
{
var player = m.PlayerGetByEmail(form.Email);
if (player != null)
{
var user = new PassResetAddViewModel();
user.EMAIL = form.Email;
user.TOKENEXPIRY = DateTime.Now.AddHours(24);
user.VERIFIED = false;
var passReset = m.PassResetAdd(user);
if (passReset == 'A')
{
try
{
SendEmailToUser(user.EMAIL, null, 'P', user.TOKEN);
ViewBag.Message = "An email has been sent to the user. Please check your email to change your password.";
return(View(form));
}
catch (Exception)
{
ViewBag.Message = "There was a problem sending the email. Please try again later.";
return(View(form));
}
}
else if (passReset == 'U')
{
try
{
var newUser = m.PassResetGetByEmail(user.EMAIL);
SendEmailToUser(newUser.EMAIL, null, 'P', newUser.TOKEN);
ViewBag.Message = "An email has been sent to the user. Please check your email to change your password.";
return(View(form));
}
catch (Exception)
{
ViewBag.Message = "There was a problem sending the email. Please try again later.";
return(View(form));
}
}
else
{
ViewBag.Message = "There was a problem sending the email. Please try again later.";
return(View(form));
}
}
else
{
ViewBag.Message = "No account found using the providing email used. Please use another email.";
return(View(form));
}
}
public HttpResponse Register(RegisterFormViewModel model)
{
var result = UserService.CreateUser(model);
if (result.Count != 0)
{
return(Error(result));
}
return(Redirect("/Users/Login"));
}
public ActionResult Register()
{
var role = _context.RoleTypes.ToList();
var viewModel = new RegisterFormViewModel
{
Registration = new Registration(),
RoleTypes = role
};
return(View("RegistrationForm", viewModel));
}
public async Task <ActionResult> Edit(RegisterFormViewModel model, string returnUrl)
{
ActionResult action;
try
{
model.Created = null;
var identityUser = UserManager.FindById(model.Id);
identityUser = Mapper.Map(model, identityUser);
var identityResult = await UserManager.UpdateAsync(identityUser);
if (identityResult.Succeeded)
{
if (model.IsSuperAdmin)
{
var roles = UserManager.GetRoles(model.Id);
UserManager.RemoveFromRoles(model.Id, roles.ToArray());
}
else
{
var item = Request["roles"];
if (!string.IsNullOrEmpty(item))
{
var lstUserRole = UserManager.GetRoles(model.Id);
UserManager.RemoveFromRoles(model.Id, lstUserRole.ToArray());
var strArrays = item.Split(',');
UserManager.AddToRoles(model.Id, strArrays);
}
}
Response.Cookies.Add(new HttpCookie("system_message", string.Format(MessageUI.UpdateSuccess, FormUI.Account)));
if (!Url.IsLocalUrl(returnUrl) || returnUrl.Length <= 1 || !returnUrl.StartsWith("/") || returnUrl.StartsWith("//") || returnUrl.StartsWith("/\\"))
{
action = RedirectToAction("Index");
return(action);
}
action = Redirect(returnUrl);
return(action);
}
AddErrors(identityResult);
action = View(model);
return(action);
}
catch (Exception exception1)
{
var exception = exception1;
LogText.Log(string.Concat("Account.Update: ", exception.Message));
}
action = View();
return(action);
}
public ActionResult Confirm(RegisterFormViewModel dto)
{
if (!ModelState.IsValid)
{
var @evt = db.Events.Include(x => x.Template).SingleOrDefault(e => e.Id == dto.EventId);
if (@evt != null)
{
dto.Template = @evt.Template;
}
return(View("Register", dto));
}
var @event = db.Events.Include(x => x.Template).SingleOrDefault(e => e.Id == dto.EventId);
if (@event == null)
{
return(View("EventNotFound"));
}
var guest = db.Guests.Include(e => e.Event).Include(t => t.Event.Template).SingleOrDefault(g => g.Id == dto.GuestId);
var compareGuest = Mapper.Map <Guest>(dto);
if (!guest.Equals(compareGuest))
{
var demoChange = Mapper.Map <DemographicChange>(compareGuest);
demoChange.Source = Source.RSVP;
demoChange.UpdatedBy = "Donor";
db.DemographicChanges.Add(demoChange);
}
Mapper.Map(dto, guest);
@event.RegisterGuest(guest);
@event.SendEmail(guest);
//Need copy of template before discarding changes.
var template = @event.Template.Copy();
//Do not modify template of event.
db.Entry(@event.Template).State = EntityState.Unchanged;
db.Events.AddOrUpdate(@event);
db.Guests.AddOrUpdate(guest);
db.SaveChanges();
var finishFormViewModel = Mapper.Map <FinishFormViewModel>(guest);
finishFormViewModel.Template = template;
return(View("Finish", finishFormViewModel));
}
public async Task <ActionResult> Confirm(RegisterFormViewModel dto)
{
var @event = _eventService.GetEvent(dto.EventId);
if (!ModelState.IsValid)
{
dto.Template = @event.Template;
return(View("Register", dto));
}
var guest = await _context.Guests.FirstOrDefaultAsync(
e => e.FinderNumber == dto.PromoCode && e.EventId == dto.EventId);
var d = Mapper.Map <Guest>(dto);
if (guest != d)
{
var demo = new DemographicChange()
{
LookupId = dto.LookupId,
FinderNumber = dto.PromoCode,
Name = dto.Name,
Email = dto.Email,
Phone = dto.Phone,
Street = dto.Address,
Street2 = dto.Address2,
City = dto.City,
State = dto.State,
Zipcode = dto.Zipcode,
Source = Source.RSVP
};
_context.DemographicChanges.AddOrUpdate(demo);
_context.SaveChanges();
}
Mapper.Map(dto, guest);
@event.RegisterGuest(guest);
await @event.SendEmail(guest);
_context.Events.AddOrUpdate(@event);
_context.Guests.AddOrUpdate(guest);
_context.SaveChanges();
var model = Mapper.Map <FinishFormViewModel>(guest);
var template = @event.Template;
model.Template = TemplateHelper.ParseGuestTemplate(guest, template);
return(View("Finish", model));
}
public IActionResult Register(RegisterFormViewModel user)
{
User newUser = new User
{
Username = user.Username,
Password = user.Password
};
_context.Users.Add(newUser);
_context.SaveChanges();
return(RedirectToAction("Login", "Account"));
}
public RegisterFormViewModel GetRegisterFormView(
int currentPageId,
RegisterFormViewModel model)
{
var regions = _userRepository.GetAllRegions();
model.RegionSelectList = new MultiSelectList(regions, "Key", "Value", regions.Take(1));
model.Agreements = _userRepository.GetAllActiveAgreements();
model.CurrentUmbracoPageId = currentPageId;
model.CurrentPageCulture = Thread.CurrentThread.CurrentCulture;
return(model);
}
public async Task RegisterAsync()
{
var form = _form;
var result = await _apiClient.PostJsonAsync <RegisterFormViewModel>(ApiUrls.RegisterAction, form);
if (!result)
{
MessageBox.Show("Cannot register an user.");
return;
}
MessageBox.Show("Registration succeeded. Please sign in.");
_form = new RegisterFormViewModel();
ChangePageCommand.Execute(this);
}
public RegisterResponse Register(RegisterFormViewModel model)
{
try
{
var errors = ValidateUser(model.UserEmail, model.SelectedRegions, model.Agreements, isNew: true);
if (errors.Any())
{
return new RegisterResponse
{
IsError = true,
ShouldDisplayMessage = true,
Message = _umbracoHelper.GetDictionaryValue("Register.SendEmail.Failure"),
ValidationErrors = errors
}
}
;
var user = _mappingService.Map <RegisterFormViewModel, UserDB>(model);
user.UserPassword = _hashingService.Hash(model.UserPassword);
user.ActivationToken = GenerateActivationToken();
user.Locale = model.CurrentPageCulture.Name;
if (!errors.Any())
{
_userRepository.Insert(user, model.SelectedRegions, model.Agreements);
_emailService.SendRegisterEmail(user);
}
return(new RegisterResponse
{
IsError = false,
Message = _umbracoHelper.GetDictionaryValue("Register.SendEmail.Success"),
ShouldDisplayMessage = true,
ValidationErrors = errors
});
}
catch (Exception exception)
{
Log.Error("Error during registering new account", exception);
return(new RegisterResponse
{
IsError = true,
Message = exception.Message,
ShouldDisplayMessage = true,
ValidationErrors = new List <KeyValuePair <string, string> >()
});
}
}
public ActionResult SubmitRegisterForm(RegisterFormViewModel model)
{
SetCulture(model.CurrentPageCulture);
if (ModelState.IsValid)
{
model.Response = _accountService.Register(model);
if (model.Response.IsError && model.Response.ValidationErrors.Any())
{
MapErrorsToModelState(model.Response.ValidationErrors);
}
}
model = _accountService.GetRegisterFormView(model.CurrentUmbracoPageId, model);
return(PartialView("RegisterFormPartial", model));
}
public HttpResponse Register(RegisterFormViewModel input)
{
if (this.IsUserLoggedIn())
{
return(this.Redirect("/"));
}
if (input.Username.Length < 4 || input.Username.Length > 10)
{
// return this.Error("Username should be between 4 and 20 characters!");
return(this.Redirect("Register"));
}
if (input.Password.Length < 6 || input.Password.Length > 20)
{
//return this.Error("Password should be between 6 and 20 characters!");
return(this.Redirect("Register"));
}
if (input.Password != input.ConfirmPassword)
{
//return this.Error("Password should match.");
return(this.Redirect("Register"));
}
if (string.IsNullOrWhiteSpace(input.Email))
{
//return this.Error("Email cannot be empty!");
return(this.Redirect("Register"));
}
if (this.usersService.EmailExists(input.Email))
{
//return this.Error("Email already in use.");
return(this.Redirect("Register"));
}
if (this.usersService.UsernameExists(input.Username))
{
//return this.Error("Username already in use.");
return(this.Redirect("Register"));
}
this.usersService.CreateUser(input.Username, input.Email, input.Password);
return(this.Redirect("Login"));
}
public async Task <ActionResult> Registration(RegisterFormViewModel model)
{
try
{
if (ModelState.IsValid)
{
var identityUser = new IdentityUser
{
UserName = model.UserName,
Address = model.Address,
FirstName = model.FirstName,
LastName = model.LastName,
MiddleName = model.MiddleName,
Phone = model.Phone,
Email = model.Email,
City = model.City,
State = model.State,
IsLockedOut = false,
IsSuperAdmin = false,
Created = DateTime.UtcNow
};
var identityResult = await UserManager.CreateAsync(identityUser, model.Password);
if (identityResult.Succeeded)
{
ModelState.AddModelError("", "Đăng ký tài khoản thành công.");
}
else
{
var sb = new StringBuilder();
foreach (var item in identityResult.Errors)
{
sb.Append(item);
}
ModelState.AddModelError("", sb.ToString());
//ModelState.AddModelError("", "Đăng ký tài khoản không thành công, Vui lòng thử lại.");
}
}
}
catch (Exception ex)
{
ModelState.AddModelError("Error", ex.Message);
}
return(View(model));
}
public async Task <IActionResult> Register([FromBody] RegisterFormViewModel model)
{
if (ModelState.IsValid)
{
var user = new User {
UserName = model.Username, Name = model.Name, Surname = model.Surname
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(Ok());
}
}
return(BadRequest());
}
public ActionResult Index(int?eventId)
{
if (eventId.HasValue)
{
using (var db = new DataLayer.RegistrationDbContext())
{
var evenx = db.Events.Find(eventId.Value);
if (evenx == null)
{
return(View("Error"));
}
var m = new RegisterFormViewModel();
m.EventId = eventId.Value;
ViewBag.EventTitle = evenx.EName;
return(View(m));
}
}
return(View("Error"));
}
public async Task <IActionResult> Edit(string Id)
{
if (Id == null)
{
return(RedirectToAction(nameof(Error), new { message = "Id nulo" }));
}
var obj = await _userManager.FindByIdAsync(Id);
if (obj == null)
{
return(RedirectToAction(nameof(Error), new { message = "Id não encontrado" }));
}
var viewModel = new RegisterFormViewModel {
Id = obj.Id, Cpf = obj.Cpf, Email = obj.Email, EmailConf = obj.Email, Name = obj.Name, PhoneNumber = obj.PhoneNumber, UserName = obj.UserName
};
return(View(viewModel));
}
public async Task <IActionResult> Edit(RegisterFormViewModel viewModel)
{
var user = await _userManager.FindByIdAsync(viewModel.Id);
user.UserName = viewModel.UserName;
user.Email = viewModel.Email;
user.Cpf = viewModel.Cpf;
user.PhoneNumber = viewModel.PhoneNumber;
user.Name = viewModel.Name;
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
TempData["confirm"] = user.UserName + " atualizado com sucesso.";
return(RedirectToAction(nameof(Index)));
}
TempData["erro"] = "Não foi possível atualizar";
return(RedirectToAction(nameof(Index)));
}
public HttpResponse Register(RegisterFormViewModel input)
{
if (this.IsUserLoggedIn())
{
return(this.Redirect("/"));
}
if (input.Username.Length < 5 || input.Username.Length > 20)
{
return(this.Redirect("Register"));
}
if (input.Password.Length < 6 || input.Password.Length > 20)
{
return(this.Redirect("Register"));
}
if (input.Email != input.Email)
{
return(this.Redirect("Register"));
}
if (string.IsNullOrWhiteSpace(input.Password))
{
return(this.Redirect("Register"));
}
if (this.usersService.EmailExists(input.Email))
{
return(this.Redirect("Register"));
}
if (this.usersService.UsernameExists(input.Username))
{
return(this.Redirect("Register"));
}
this.usersService.CreateUser(input.Username, input.Email, input.Password);
return(this.Redirect("Login"));
}
public async Task <IActionResult> Register([FromBody] RegisterFormViewModel model)
{
if (model == null || !this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState.GetFirstError()));
}
var user = new User {
Email = model.Email, UserName = model.Username
};
var result = await this.userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(this.BadRequest(result.Errors.FirstOrDefault()));
}
this.logger.LogInformation("User registered.");
return(this.Ok());
}
