public async Task <IActionResult> Create(UserRegistrationModel model) { if (ModelState.IsValid) { var user = new User { UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, PhoneNumber = model.PhoneNumber, }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } await _userManager.AddToRoleAsync(user, "Visitor"); return(RedirectToAction("ManagerUsers", "ManageUser", new { Areas = "Admin" })); } } return(View(model)); }
public async Task <IActionResult> Register(UserRegistrationModel userModel) { if (!ModelState.IsValid) { return(View(userModel)); } var user = _mapper.Map <User>(userModel); var result = await _userManager.CreateAsync(user, userModel.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(View(userModel)); } var token = await _userManager.GenerateEmailConfirmationTokenAsync(user); var confirmationLink = Url.Action(nameof(ConfirmEmail), "Account", new { token, email = user.Email }, Request.Scheme); var message = new Message(new string[] { user.Email }, "Confirmation email link", confirmationLink, null); await _emailSender.SendEmailAsync(message); await _userManager.AddToRoleAsync(user, "Visitor"); return(RedirectToAction(nameof(SuccessRegistration))); }
public async void Register(UserRegistrationModel registerUser) { var user = new User(registerUser.Email, registerUser.Location, registerUser.Web, registerUser.Bio, registerUser.UserId); await _userDbContext.AddAsync(user); await _userDbContext.SaveChangesAsync(); }
public async Task <IActionResult> Register(UserRegistrationModel model) { if (ModelState.IsValid) { var username = _context.Users.Where(p => p.UserUsername == model.UserUsername).FirstOrDefault(); if (username != null) { ViewBag.Message = "Böyle bir kullanıcı var başka bir kullanıcı adı giriniz."; return(View()); } else { Users user = new Users { UserEmail = model.UserEmail, UserFullname = model.UserFullname, UserPasswd = model.UserPasswd, UserUsername = model.UserUsername, UserJob = model.UserJob, UserPhone = model.UserPhone, UserCity = model.UserCity, UserNeighborhood = model.UserNeighborhood, }; _context.Add(user); await _context.SaveChangesAsync(); } } return(RedirectToAction(nameof(LoginController.Index), "Login")); }
private void AssertUser(UserRegistrationModel model, User user) { Assert.AreEqual(model.LastName, user.Surname); Assert.AreEqual(model.City, user.Address.AddressLine3); Assert.AreEqual(model.SecurityQuestionsAndAnswers.Length, user.SecurityQuestions.Count()); Assert.AreEqual(ExpectedHash(model.Password), user.Password.HashedPassword); }
public IActionResult Register(string returnUrl = null) { ViewData["ReturnUrl"] = returnUrl; UserRegistrationModel userRegistrationModel = new UserRegistrationModel(); return(View()); }
public IActionResult GetEditPartial(int userID) { try { var user = _dbContext.Users.Single(x => x.ID == userID); var userData = new UserRegistrationModel { CreatedBy = user.CreatedBy, CreatedOn = user.CreatedOn, FirstName = user.FirstName, ID = user.ID, IsActive = user.IsActive, IsAdmin = user.IsAdmin, LastModifiedBy = user.LastModifiedBy, LastModifiedOn = user.LastModifiedOn, LastName = user.LastName, UserName = user.UserName }; return(PartialView("_editUserPartial", userData)); } catch (Exception ex) { ModelState.AddModelError("Error", ex.Message); return(View("_editUserPartial")); } }
public async Task <IActionResult> Register(UserRegistrationModel userModel) { if (!ModelState.IsValid) { return(View(userModel)); } //var user = _mapper.Map<User>(userModel); var user = new User { UserName = userModel.Email, Name = userModel.Name, Email = userModel.Email, CarNo = userModel.CarNo, CarType = userModel.CarType, Colour = userModel.CarColor }; var result = await _userManager.CreateAsync(user, userModel.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(View(userModel)); } await _userManager.AddToRoleAsync(user, "Visitor"); return(RedirectToAction(nameof(AccountController.Login), "Account")); }
public async Task <IdentityResult> Register(UserRegistrationModel model) { var user = _mapper.Map <User>(model); var result = await _unit.UserManager.CreateAsync(user, model.Password); return(result); }
public async void RegisterButton() { try { UserRegistrationModel urm = new UserRegistrationModel { FirstName = FirstName, LastName = LastName, UserName = UserName, TCIDNumber = TCIDNumber, PhoneNumber = PhoneNumber, EmailAddress = EmailAddress, Address = Address, Password = Password }; await _apiHelper.RegisterUser(urm); StatusMessage = ("Your account has been created. You are being redirected..."); var tempAuthenticatedUser = await _apiHelper.Authenticate(urm.UserName, urm.Password); _loggedInUserModel.GetData(await _userEnd.GetLoggedInUserInfo(tempAuthenticatedUser.Access_Token)); await _eventAggregator.PublishOnUIThreadAsync(new LogOnEvent()); } catch (Exception ex) { StatusMessage = ex.Message; } }
public async Task <IActionResult> Register(UserRegistrationModel userModel) { if (!ModelState.IsValid) { // return View(userModel); return(NoContent()); } var user = _mapper.Map <User>(userModel); var result = await _userManager.CreateAsync(user, userModel.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } // return (userModel); return(NoContent()); } await _userManager.AddToRoleAsync(user, "Visitor"); return(NoContent()); // return RedirectToAction(nameof(HomeController.Index), "Home"); }
public async Task <IActionResult> Register(UserRegistrationModel userModel) { if (!ModelState.IsValid) { return(View(userModel)); } var user = new User { FirstName = userModel.FirstName, LastName = userModel.LastName, UserName = userModel.Email, Email = userModel.Email }; var result = await _userManager.CreateAsync(user, userModel.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(View(userModel)); } await _userManager.AddToRoleAsync(user, "Visitor"); return(RedirectToAction(nameof(HomeController.Index), "Home")); }
public async Task <IActionResult> Post(UserRegistrationModel registrationModel) { if (string.IsNullOrWhiteSpace(registrationModel.Username) || string.IsNullOrWhiteSpace(registrationModel.Password)) { return(BadRequest()); } var alreadyExist = await _context.Users.AnyAsync(u => u.UserName.Equals(registrationModel.Username)); if (alreadyExist) { return(BadRequest()); } await _context.Users.AddAsync(new UserEntity { Guid = Guid.NewGuid(), UserName = registrationModel.Username, PasswordHash = PasswordUtil.HashPassword(registrationModel.Password), Role = Role.Customer, Email = registrationModel.Email }); await _context.SaveChangesAsync(); return(Ok()); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { var obj = JObject.Load(reader); RegistrationModelBase model; var type = obj["Type"]; if (type == null) { obj["Type"] = ((IdentityTypes)0).ToString(); type = obj["Type"]; } string modelType = type.Value<string>(); IdentityTypes actualType; if (!Enum.TryParse<IdentityTypes>(modelType, out actualType)) throw new NotSupportedException("Invalid AssetType Provided"); switch (actualType) { case IdentityTypes.USER: model = new UserRegistrationModel(); break; case IdentityTypes.ENTERPRISE: model = new EnterpriseUserRegistrationModel(); break; default: model = new AssetRegistrationModel(); break; } serializer.Populate(obj.CreateReader(), model); return model; }
/* * public ActionResult About() * { * ViewBag.Message = "Your application description page."; * * return View(); * } * * public ActionResult Contact() * { * ViewBag.Message = "Your contact page."; * * return View(); * } */ #endregion public ActionResult SignUp() { ViewBag.Message = "Реєстрація користувача"; UserRegistrationModel user = new UserRegistrationModel(); return(View()); }
public ActionResult Register(UserRegistrationModel model) { // validation of the model bool isModelValid = Validate(model); if (isModelValid) { // create user input dto var uid = new UserInputDto { User = new UserDto() { Name = model.Name, Username = model.Username, Occupation = model.Occupation, Password = model.Password.HashMd5() } }; // send registeration request var response = Services.AuthService.Register(uid); if (response != null) { return(RedirectToAction("Index")); } } return(RedirectToAction("Register")); }
public JsonResult Verify(UserRegistrationModel user, string code) { var newuser = new UserModel { Email = user.Email, Password = user.Password, PhoneNumber = user.PhoneNumber }; try { //Todo: Call service to verify var validcode = true; if (validcode) { //Todo: Save to db, save in memory for now. //_context.Add(newuser); //await _context.SaveChangesAsync(); var createduser = _userservice.CreateUser(newuser); //Start Session HttpContext.Session.SetString("SessionState", createduser.Email); return(Json(new { HasError = false, Email = createduser.Email, Code = code })); } else { return(Json(new { HasError = true, ErrorMessage = "Invalid login attempt." })); } } catch { //Todo: Log exception, Audit event return(Json(new { HasError = true, ErrorMessage = "Application Exception. Please try again." })); } }
public IActionResult RegisterUser([FromBody] UserRegistrationModel userRegistration) { if (userRegistration == null || string.IsNullOrEmpty(userRegistration.Email) || string.IsNullOrEmpty(userRegistration.Username) || string.IsNullOrEmpty(userRegistration.Token) || string.IsNullOrEmpty(userRegistration.Password)) { throw new MissingParameterException(); } if (userRegistration?.Email?.Length > Limits.MAX_EMAIL_ADDRESS) { throw new InputValueTooLargeException(); } if (userRegistration?.Username?.Length > Limits.MAX_USERNAME) { throw new InputValueTooLargeException(); } if (userRegistration?.Token?.Length > Limits.MAX_REGISTER_CODE) { throw new InputValueTooLargeException(); } if (userRegistration?.Password?.Length > Limits.MAX_PASSWORD) { throw new InputValueTooLargeException(); } PwdManService.RegisterUser(userRegistration); return(new JsonResult(true)); }
public ActionResult Index(UserRegistrationModel model) { var recaptchaHelper = this.GetRecaptchaVerificationHelper(); if (String.IsNullOrEmpty(recaptchaHelper.Response)) { ModelState.AddModelError("", "Captcha answer cannot be empty."); return(View(model)); } var recaptchaResult = recaptchaHelper.VerifyRecaptchaResponse(); if (!recaptchaResult.Success) { foreach (var err in recaptchaResult.ErrorCodes) { ModelState.AddModelError("", err); } } else { return(RedirectToAction("Welcome")); } return(View(model)); }
public async Task <IActionResult> Register(UserRegistrationModel userModel) { if (!ModelState.IsValid) { return(View(userModel)); } var client = _mapper.Map <Client>(userModel); var result = await _userManager.CreateAsync(client, userModel.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(View(userModel)); } await _userManager.AddToRoleAsync(client, "Visitor"); //NOT SURE WHAT TO DO HERE return(null); }
public async Task <IActionResult> Register(UserRegistrationModel userModel) { if (!ModelState.IsValid) { return(View(userModel)); // daca modelul nu este valid se returneaza acelasi view cu modelul invalidat } var user = _mapper.Map <ApplicationUser>(userModel); var result = await _userManager.CreateAsync(user, userModel.Password); // createAsync are o parolă, execută verificări suplimentare ale utilizatorului și returnează un rezultat. if (!result.Succeeded) //daca se valideaza mapam modelul de inregistrare la utilizator { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(View(userModel)); } if (userModel.esteAdmin) { await _userManager.AddToRoleAsync(user, "Administrator"); return(RedirectToAction("Register", "Account")); } else { await _userManager.AddToRoleAsync(user, "User"); return(RedirectToAction("Register", "Account")); } }
public async Task <IActionResult> Register(UserRegistrationModel registrationModel) { if (!ModelState.IsValid) { return(View(registrationModel)); } var user = _mapper.Map <User>(registrationModel); var result = await _userManager.CreateAsync(user, registrationModel.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(View(registrationModel)); } var token = await _userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.Action(nameof(ConfirmEmail), "Account", new { token, email = user.Email }, Request.Scheme); var message = $"To confirm email click <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>here</a>"; await _emailSender.SendEmailAsync(user.Email, "Email confirmation", message); await _userManager.AddToRoleAsync(user, "Visitor"); return(RedirectToAction(nameof(SuccessRegistration))); }
public IActionResult Register(UserRegistrationModel userModel) { try { if (!ModelState.IsValid) { return(View(userModel)); } List <Account> lstacc = AccountRes.GetAll(); int countAcc = 0; for (int i = 0; i < lstacc.Count; i++) { if (lstacc[i].username == userModel.Username) { countAcc = 1; } } if (countAcc == 1) { ModelState.AddModelError("1", "UserName already exists! Please try another."); } else { int resultAcc = AccountRes.InsertRegisterAccount(userModel.Username, userModel.Password); int resultDetails = AccountRes.InsertRegisterDetails(userModel.Username, userModel.FullName, userModel.Email, userModel.PhoneNumber, userModel.Address, resultAcc); return(RedirectToAction("Index", "HomeDrugstore")); } } catch (Exception ex) { Console.Write(ex); } return(View()); }
public async Task <IActionResult> RegisterStaff(UserRegistrationModel users) { if (!ModelState.IsValid) { return(View(users)); } //var user = _mapper.Map<User>(userModel); var user = new User { UserName = users.Email, Name = users.Name, Email = users.Email, }; var result = await _userManager.CreateAsync(user, users.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(View(users)); } await _userManager.AddToRoleAsync(user, "Staff"); return(RedirectToAction(nameof(AfterloginController.Afterloginhome), "Afterlogin")); }
public async Task <IActionResult> OnPost(UserRegistrationModel model) { if (ModelState.IsValid) { var identityUser = new IdentityUser { Email = model.Email, UserName = model.Login }; var result = await _userManager.CreateAsync(identityUser, model.Password); if (result.Succeeded) { ViewData["OnPostSuccess"] = "OnPostMethodSuccess"; return(RedirectToPage("/index")); } else { ViewData["OnPostSuccess"] = "OnPostMethodUserManagerError"; return(Page()); } } return(Page()); }
public IHttpActionResult Register(UserRegistrationModel userRegistrationModel) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } User user = new User() { UserName = userRegistrationModel.UserName, Password = userRegistrationModel.Password, Email = userRegistrationModel.Email, Phone = userRegistrationModel.Phone }; User result = _userRepository.RegisterUser(user); UnitOfWork.Save(); IHttpActionResult errorResult = GetErrorResult(result); if (errorResult != null) { return(errorResult); } return(Ok()); }
public async Task <IActionResult> Register([FromBody] UserRegistrationModel registrationModel) { if (ModelState.IsValid) { UserResultModel authResponse = await identityService.RegisterAsync(registrationModel.Email, registrationModel.Password); if (!authResponse.Success) { FailedResponseModel badResponse = new FailedResponseModel() { Errors = authResponse.Errors }; return(BadRequest(badResponse)); } UserSuccessResponseModel successResponse = new UserSuccessResponseModel() { Token = authResponse.Token }; return(Ok(successResponse)); } return(BadRequest(new FailedResponseModel { Errors = ModelState.Values.SelectMany(x => x.Errors.Select(y => y.ErrorMessage)) })); }
public async Task <IActionResult> Register(UserRegistrationModel model, string returnUrl = null) { if (ModelState.IsValid)/*Phần đăng ký cho User*/ { //var user = _mapper.Map<User>(model); // Copy data from RegisterViewModel to IdentityUser var user = new User { UserName = model.Email, Email = model.Email }; // Store user data in AspNetUsers database table var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { await _SinInManager.SignInAsync(user, isPersistent : false); return(RedirectToAction("Index", "Home")); } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } await _userManager.AddToRoleAsync(user, "Visitor"); } return(View(model)); }
public async Task <IHttpActionResult> Registrate(UserRegistrationModel userModel) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (!await _userService.IsExistsAsync(userModel.Email)) { try { UserDTO user = _mapper.Map <UserDTO>(userModel); await _userService.CreateUserAsync(user); return(Ok("You were registered")); } catch (Exception ex) { return(InternalServerError(ex)); } } else { return(BadRequest("This user is already created")); } }
public ViewResult Register(UserRegistrationModel model, string returnUrl) { if (ModelState.IsValid) { User existUser = repository.Users.FirstOrDefault(item => item.Username.ToLower() == model.Username.ToLower()); if (existUser == null) { User user = new User(); user.Username = model.Username; user.Password = model.Password; user.Email = model.Email; repository.SaveUser(user); //int UserId = user.ID; ViewBag.returnUrl = returnUrl; return(View("RegistrationCompleted")); } else { ModelState.AddModelError("", "An User with same User name already exists"); // return(View(model)); } } // // If we got this far, something failed, redisplay form! // return(View(model)); }
public void Register(UserRegistrationModel userRegistrationModel) { var user = _mapper.Map <User>(userRegistrationModel); user.UserType = 2; _capstoneContext.Add(user); }
//FIXME: This should be segregated, having the whole usermodel coming here is okay, but not good public UserProfile(UserRegistrationModel userModel) { this.FirstName = userModel.FirstName; this.LastName = userModel.LastName; this.Gender = userModel.Gender; this.Age = userModel.Age; this.InterestedLocalities = userModel.InterestedLocalities; }
public User(UserRegistrationModel model, UserProfile profile) : this(model) { this.Roles = new List<string>(); Roles.Add(RoleNames.ROLE_USER); //FIXME: This has been done because UserModel is just the same here //If we decide to expose different models for different clients things would be a bit different this.Profile = profile; }
public ActionResult UserRegister(UserRegistrationModel model) { AuthenticationProvider ap = new AuthenticationProvider(); if (ap.LoginMach(model.Login)) { ModelState.AddModelError("Login", "Login must be unique"); return View("UserRegister", model); } UserManager um = new UserManager(); UserRegistrationModel urm = new UserRegistrationModel(); if (ModelState.IsValid) { um.Insert(GetUser(model)); } return View("UserRegister", urm); }
public async Task Test_RegisterUser_With_Single_Interested_Locality() { accountManagerMock = new Mock<AccountManager>(userStoreMock.Object); IdentityResult identityResult = new IdentityResult(null); accountManagerMock.Setup(x => x.CreateAsync(It.IsAny<User>())).ReturnsAsync(identityResult); var accountContext = new AccountContext( dbContextMock.Object, mailServiceMock.Object, accountManagerMock.Object, blobServiceMock.Object, jobManagerMock.Object); var registerModel = new UserRegistrationModel() { UserName = "******", Type = IdentityTypes.USER, Password = "******", ConfirmPassword = "******", Email = "*****@*****.**", PhoneNumber = "+88017100000", InterestedLocalities = new List<string>() { "TestLocality" } }; var result = await accountContext.RegisterUser(registerModel); Assert.NotNull(result.User); Assert.AreEqual("testUsername", result.User.UserName); Assert.AreEqual(IdentityTypes.USER, result.User.Type); Assert.AreEqual("*****@*****.**", result.User.Email); Assert.AreEqual(false, result.User.EmailConfirmed); Assert.AreEqual("+88017100000", result.User.PhoneNumber); Assert.AreEqual(false, result.User.PhoneNumberConfirmed); Assert.NotNull(result.User.Profile); Assert.AreEqual(typeof(UserProfile), result.User.Profile.GetType()); Assert.NotNull((result.User.Profile as UserProfile).InterestedLocalities); Assert.AreEqual(1, (result.User.Profile as UserProfile).InterestedLocalities.Count); Assert.AreEqual("TestLocality", (result.User.Profile as UserProfile).InterestedLocalities.First()); }
public ActionResult UserRegister() { UserRegistrationModel urm = new UserRegistrationModel(); return View("UserRegister", urm); }
private User GetUser(UserRegistrationModel model) { User user = new User { Name = model.Name, Surname = model.Surname, MiddleName = model.Middlename, Phone = model.Phone, Login = model.Login, Password = model.Password, Nationality = model.Nationality }; return user; }
protected User(UserRegistrationModel model, UserProfile profile, string role) : this(model, profile) { this.Roles = this.Roles ?? new List<string>(); Roles.Add(role); }