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);
}
