public IActionResult Register(RegisterViewModel model) { ChushkaUser user = new ChushkaUser() { UserName = model.Username, PasswordHash = model.Password, FullName = model.FullName, Email = model.Email, EmailConfirmed = true, IsLoggedIn = true //ConfirmPassword/?? }; this.service.AddUser(user); //return this.View(); return(this.RedirectPermanent("/")); }
public IActionResult Register(RegisterViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = new ChushkaUser() { Email = model.Email, FullName = model.FullName, UserName = model.Username }; var result = this.signInManager.UserManager.CreateAsync(user, model.Password).Result; if (this.signInManager.UserManager.Users.Count() == 1) { var roleResult = this.signInManager.UserManager.AddToRoleAsync(user, "Administrator").Result; if (roleResult.Errors.Any()) { return(this.View()); } } if (result.Succeeded) { return(this.RedirectToAction("Login")); } return(View()); }
public async Task <IActionResult> OnPostAsync(string returnUrl = null) { returnUrl = returnUrl ?? Url.Content("~/"); ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList(); if (ModelState.IsValid) { var user = new ChushkaUser { Id = Guid.NewGuid().ToString(), UserName = Input.Username, Email = Input.Email }; var result = await _userManager.CreateAsync(user, Input.Password); if (result.Succeeded) { if (this.chushkaDbContext.Users.Count() == 1) { await _userManager.AddToRoleAsync(user, "Admin"); } else { await _userManager.AddToRoleAsync(user, "User"); } await _signInManager.SignInAsync(user, isPersistent : false); return(LocalRedirect(returnUrl)); } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } // If we got this far, something failed, redisplay form return(Page()); }
public async Task <IActionResult> Register(RegisterViewModel model) { var user = new ChushkaUser() { Email = model.Email, FullName = model.FullName, UserName = model.Username }; var result = this.signIn.UserManager.CreateAsync(user, model.Password).Result; if (result.Succeeded) { await signIn.SignInAsync(user, isPersistent : false); if (signIn.UserManager.Users.Count() == 1) { await signIn.UserManager.AddToRoleAsync(user, "Admin"); } else { await signIn.UserManager.AddToRoleAsync(user, "User"); } return(RedirectToAction("Index", "Home")); } return(this.View()); }
public async Task <IActionResult> Register(RegisterViewModel model) { if (this.User.Identity.Name != null) { await signInManager.SignOutAsync(); } var isUsernameExists = userManager.Users.FirstOrDefault(u => u.UserName == model.Username); if (isUsernameExists != null || model.Password != model.ConfirmPassword) { return(RedirectToAction("Register", "Users", model)); } //if (isUsernameExists != null && model.Password == model.ConfirmPassword) //{ // return RedirectToAction("Register", "Users", model); //} var user = new ChushkaUser() { FullName = model.FullName, Email = model.Email, UserName = model.Username }; await userManager.CreateAsync(user, model.Password); await userManager.AddToRoleAsync(user, "User"); return(RedirectToAction("Login", "Index")); }
public IActionResult Register(RegisterViewModel viewModel) { var user = new ChushkaUser() { Email = viewModel.Email, FullName = viewModel.FullName, UserName = viewModel.Username }; var result = this.singInManager.UserManager.CreateAsync(user, viewModel.Password).Result; string roleToAdd = RoleNames.User; if (this.singInManager.UserManager.Users.Count() == 1) { roleToAdd = RoleNames.Administrator; } var roleResult = this.singInManager.UserManager.AddToRoleAsync(user, roleToAdd).Result; if (result.Succeeded) { this.singInManager.SignInAsync(user, true).Wait(); return(this.RedirectToAction("Index", "Home")); } return(this.View()); }
public void AddUser(ChushkaUser user) { if (GetUser(user.UserName) == null) { user.CustomRole = !IsAnyUserInContext() ? CustomRole.Admin : CustomRole.User; context.Users.Add(user); context.SaveChanges(); } }
private static void CreateAdminAndUser(UserManager <ChushkaUser> userManager, RoleManager <IdentityRole> roleManager) { Task.Run(async() => { var adminName = "Admin"; var userName = "******"; var adminRoleExists = await roleManager.RoleExistsAsync(adminName); var userRoleExists = await roleManager.RoleExistsAsync(userName); if (!adminRoleExists) { await roleManager.CreateAsync(new IdentityRole { Name = adminName }); var adminUser = await userManager.FindByNameAsync(adminName); if (adminUser == null) { adminUser = new ChushkaUser { UserName = adminName, Email = "*****@*****.**" }; await userManager.CreateAsync(adminUser, "123456"); await userManager.AddToRoleAsync(adminUser, adminName); } } if (!userRoleExists) { await roleManager.CreateAsync(new IdentityRole { Name = userName }); var userUser = await userManager.FindByNameAsync(userName); if (userUser == null) { userUser = new ChushkaUser { UserName = userName, Email = "*****@*****.**" }; await userManager.CreateAsync(userUser, "123456"); await userManager.AddToRoleAsync(userUser, userName); } } }).Wait(); }
public IActionResult Order(int id) { ChushkaUser user = context.Users.Include(x => x.Orders).FirstOrDefault(x => x.UserName == User.Identity.Name); if (!context.Products.Where(x => !x.IsDeleted).Any(x => x.Id == id)) { return(View("Error", new ErrorViewModel("Unfound Product"))); } user.Orders.Add(new Order { ProductId = id, OrderedOn = DateTime.UtcNow }); context.SaveChanges(); return(RedirectToAction("Index", "Home")); }
public async Task <IActionResult> Login(LoginViewModel model) { ChushkaUser user = signIn.UserManager.Users.FirstOrDefault(u => u.UserName == model.Username); var result = this.signIn.PasswordSignInAsync(user, model.Password, isPersistent: false, lockoutOnFailure: false).Result; if (result.Succeeded) { return(RedirectToAction("Index", "Home")); } return(this.View()); }
public async Task <bool> Register(string username, string password, string confirmPassword, string email, string fullName) { if (username == null || password == null || confirmPassword == null || email == null || fullName == null) { return(false); } if (password != confirmPassword) { return(false); } var user = new ChushkaUser { UserName = username, Email = email, FullName = fullName }; var userCreateResult = await this.usernManager.CreateAsync(user, password); if (!userCreateResult.Succeeded) { return(false); } IdentityResult addRoleResult = null; if (this.usernManager.Users.Count() == 1) { addRoleResult = await this.usernManager.AddToRoleAsync(user, "Admin"); } else { addRoleResult = await this.usernManager.AddToRoleAsync(user, "User"); } if (!addRoleResult.Succeeded) { return(false); } return(true); }
public IActionResult OrderProduct(Product product, ChushkaUser user) { var order = new Order() { Product = product, ProductId = product.Id, Client = user, ClientId = user.Id, OrderedOn = DateTime.UtcNow }; this.dbContext.Orders.Add(order); this.dbContext.SaveChanges(); return(this.Redirect("/")); }
public async Task <IActionResult> OnPostAsync(string returnUrl = null) { returnUrl = returnUrl ?? Url.Content("~/"); if (ModelState.IsValid) { var user = new ChushkaUser { UserName = Input.Email, Email = Input.Email }; var result = await _userManager.CreateAsync(user, Input.Password); if (result.Succeeded) { if (this.dbContext.Users.Count() == 1) { await this._userManager.AddToRoleAsync(user, "Admin"); } else { await this._userManager.AddToRoleAsync(user, "User"); } _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(Input.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); } } // If we got this far, something failed, redisplay form return(Page()); }
public async Task <IActionResult> OnPostAsync(string returnUrl = null) { returnUrl = returnUrl ?? this.Url.Content("~/"); if (this.ModelState.IsValid) { var user = new ChushkaUser { UserName = this.Input.Username, Email = this.Input.Email, FullName = this.Input.FullName }; var result = await this.userManager.CreateAsync(user, this.Input.Password); if (result.Succeeded) { this.logger.LogInformation("User created a new account with password."); // var code = await this.userManager.GenerateEmailConfirmationTokenAsync(user); // var callbackUrl = this.Url.Page( // "/Account/ConfirmEmail", // pageHandler: null, // values: new { userId = user.Id, code = code }, // protocol: this.Request.Scheme); // // await this.emailSender.SendEmailAsync(this.Input.Email, "Confirm your email", // $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>."); if (this.userManager.Users.Count() == 1) { await this.userManager.AddToRoleAsync(user, GlobalConstants.AdminRoleName); } await this.signInManager.SignInAsync(user, isPersistent : true); return(this.LocalRedirect(returnUrl)); } foreach (var error in result.Errors) { this.ModelState.AddModelError(string.Empty, error.Description); } } // If we got this far, something failed, redisplay form return(this.Page()); }
public IActionResult Register(RegisterViewModel model) { if (this.Db.Users.Any(u => u.UserName == model.Username)) { return(this.View()); } if (model.Password != model.ConfirmPassword) { return(this.View()); } var user = new ChushkaUser { UserName = model.Username, Email = model.Email, FullName = model.FullName }; var result = this.signIn.UserManager.CreateAsync(user, model.Password).Result; if (this.signIn.UserManager.Users.Count() == 1) { var roleResult = this.signIn.UserManager.AddToRoleAsync(user, "Admin").Result; if (roleResult.Errors.Any()) { return(this.View()); } } else if (this.signIn.UserManager.Users.Count() > 1) { var roleResult = this.signIn.UserManager.AddToRoleAsync(user, "User").Result; if (roleResult.Errors.Any()) { return(this.View()); } } if (result.Succeeded) { return(this.RedirectToAction("Login", "Users")); } return(this.View()); }
public IActionResult Order(string id) { Product product = this.productService.GetProduct(id); ChushkaUser user = this.accountService.GetUser(this.User.Identity.Name); if (user == null) { return(this.BadRequest("Invalid user id.")); } if (product == null) { return(this.BadRequest("Invalid product id.")); } return(this.orderService.OrderProduct(product, user)); }
public IActionResult Register(RegisterInputModel model) { if (this.User.Identity.IsAuthenticated) { return(this.RedirectToAction("Index", "Home")); } if (ModelState.IsValid) { var user = new ChushkaUser { Email = model.Email, FullName = model.FullName, UserName = model.Username }; var result = this.userManager.CreateAsync(user, model.Password).Result; if (this.userManager.Users.Count() == 1) { var roleResult = this.userManager.AddToRoleAsync(user, "Administrator").Result; if (roleResult.Errors.Any()) { return(this.View()); } } else { var roleResult = this.userManager.AddToRoleAsync(user, "User").Result; if (roleResult.Errors.Any()) { return(this.View()); } } if (result.Succeeded) { this.signIn.SignInAsync(user, true).Wait(); return(this.RedirectToAction("Index", "Home")); } } return(this.View()); }
public async Task <IActionResult> Register(UserRegister viewModel) { var user = new ChushkaUser { UserName = viewModel.Username, Email = viewModel.Email, FullName = viewModel.FullName }; var result = await this.userManager.CreateAsync(user, viewModel.Password); if (result.Succeeded) { await this.signInManager.SignInAsync(user, isPersistent : false); return(this.Redirect(GlobalConstants.HomeIndexUrl)); } return(this.View()); }
public async Task <IActionResult> Login(LoginModel model) { if (ModelState.IsValid) { ChushkaUser user = await userManager.FindByNameAsync(model.Username); if (user != null) { await signInManager.SignOutAsync(); Microsoft.AspNetCore.Identity.SignInResult result = await signInManager.PasswordSignInAsync(user, model.Password, true, false); if (result.Succeeded) { return(Redirect("/")); } } } return(RedirectToAction("Login", "Users")); }
public async Task <IActionResult> Register(inputUserRegisterDTO dto) { if (ModelState.IsValid) { Seeder.SeedRoles(roleManager, context); if (dto.Password != dto.VerifyPassword) { return(View("Error", new ErrorViewModel("Passwords Missmatch!"))); } if (context.Users.Any(x => x.UserName == dto.UserName)) { return(View("Error", new ErrorViewModel("UserNameTaken"))); } ChushkaUser newUser = mapper.Map <ChushkaUser>(dto); var isAdded = await _userManager.CreateAsync(newUser, dto.Password); if (isAdded.Succeeded) { if (context.Users.Count() <= 1) { await _userManager.AddToRoleAsync(newUser, "Admin"); } await _userManager.AddToRoleAsync(newUser, "User"); await _signInManager.SignInAsync(newUser, true); } else { foreach (var error in isAdded.Errors) { ModelState.AddModelError("", error.Description); } return(View()); } } return(RedirectToAction("Index", "Home")); }
private async Task <IActionResult> OnRegisterPostAsync(RegisterUserViewModel model) { if (!ModelState.IsValid) { return(Page()); } var user = new ChushkaUser { UserName = model.Username, FullName = model.FullName, Email = model.Email }; var result = await userManager.CreateAsync(user, model.Password); if (result.Succeeded) { if (this.dbContext.Users.Count() == 1) { await this.userManager.AddToRoleAsync(user, "Admin"); } else { await this.userManager.AddToRoleAsync(user, "User"); } logger.LogInformation("User created a new account with password."); var code = await userManager.GenerateEmailConfirmationTokenAsync(user); await signInManager.SignInAsync(user, isPersistent : false); return(this.Redirect("/")); } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } // If we got this far, something failed, redisplay form return(Page()); }
private static async Task CreatePowerUser(IConfiguration configuration, UserManager <ChushkaUser> userManager) { var powerUser = new ChushkaUser { UserName = configuration.GetSection("UserSettings")["Username"], Email = configuration.GetSection("UserSettings")["UserEmail"] }; string userPassword = configuration.GetSection("UserSettings")["UserPassword"]; var user = await userManager.FindByEmailAsync(configuration.GetSection("UserSettings")["UserEmail"]); if (user == null) { var createPowerUser = await userManager.CreateAsync(powerUser, userPassword); if (createPowerUser.Succeeded) { //here we tie the new user to the "Administrator" role await userManager.AddToRoleAsync(powerUser, GlobalConstants.AdministratorRole); } } }
public IActionResult Login(LoginViewModel model) { //var a = this.signInManager.Context.User.Identity.IsAuthenticated; var b = service.GetUser(model.Username); if (b != null && b.IsLoggedIn) { this.ViewData["Message"] = "You are Logged In!"; } else { ChushkaUser user = this.service.GetUser(model.Username); if (user != null) { user.IsLoggedIn = true; } //var a = manager.SupportsUserLogin; } return(RedirectPermanent("/")); }
public ChushkaUser GetUser(string username) { ChushkaUser user = this.dbContext.Users.FirstOrDefault(x => x.UserName == username); return(user); }