public async Task <object> Register([FromBody] RegisterEmployeeVM model)
{
var token = Request.Headers["Authorization"].ToString().Replace("Bearer ", "");
if (!PatManagerVerify.CheckIfManager(token, context))
{
//if the user isn't a manager then quit the method. Only managers are able to hire new people
return(null);
}
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//add the user to the role of employee straight after being added by the manager
UserRoleRepo repo = new UserRoleRepo(service);
await repo.AddUserRole(model.Email, "employee");
//now add the user details
UserRepo userRepo = new UserRepo(context, service);
userRepo.AddUserDetails(user.Id, model.FirstName, model.LastName);
//The user is never signed in when they are registered. As they are only ever registered through the manager
//creating the new user
//await signInManager.SignInAsync(user, false);
return(await GenerateJwtToken(model.Email, user));
}
throw new ApplicationException("UNKNOWN_ERROR");
}
public UserRoleController(ApplicationDbContext context, IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
_userRepo = new UserRepo(context);
_roleRepo = new RoleRepo(context);
_userRoleRepo = new UserRoleRepo(_serviceProvider);
}
public static void ClassStart(TestContext context)
{
var config = GeneralHelpers.InitConfiguration();
UserRoleRepo a = new UserRoleRepo(config);
_testRepo = a;
}
public async Task <RoleVM> getRole([FromBody] EmailVM email)
{
UserRoleRepo repo = new UserRoleRepo(service);
RoleVM role = await repo.GetUserRole(email.Email);
return(role);
}
public async Task <IActionResult> Create(string Email, string Password, string ConfirmPass, [Bind("VendorID,Name,Address,City,Province,Monthly,Priority,Website,PostalCode,AdPosted")] Vendor vendor)
{
UserRoleRepo userRoleRepo = new UserRoleRepo(_serviceProvider);
if (Password != ConfirmPass)
{
return(View(vendor));
}
var user = new ApplicationUser {
UserName = Email, Email = Email
};
var result = await _userManager.CreateAsync(user, Password);
if (result.Succeeded)
{
var userID = user.Id;
vendor.UserID = userID;
var addUR = await userRoleRepo.AddUserRole(user.Email, "Vendor");
}
if (ModelState.IsValid)
{
_context.Add(vendor);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", new { id = vendor.VendorID }));
}
return(View(vendor));
}
public void MakeUserManager([FromBody] EmployeeIdVM employee)
{
//This method simply strips the Employee role from the user and then adds on the Manager role
UserRoleRepo repo = new UserRoleRepo(service);
repo.RemoveUserRole(employee.Email, "Employee").Wait();
repo.AddUserRole(employee.Email, "Manager").Wait();
}
public ActionResult Delete(string email, string roleName)
{
UserRoleRepo userRoleRepo = new UserRoleRepo(_serviceProvider);
userRoleRepo.RemoveUserRole(email, roleName);
return(RedirectToAction("Detail", "UserRole",
new { userName = email }));
}
// Show all roles for a specific user.
public async Task <IActionResult> Detail(string userName)
{
UserRoleRepo userRoleRepo = new UserRoleRepo(_serviceProvider, _context1);
var roles = await userRoleRepo.GetUserRoles(userName);
ViewBag.UserName = userName;
return(View(roles));
}
public async Task <IActionResult> Role()
{
var user = await _userManager.GetUserAsync(User);
String userName = user.Email;
UserRoleRepo userRoleRepo = new UserRoleRepo(_serviceProvider);
var roles = await userRoleRepo.GetUserRoles(userName);
return(Ok(roles));
}
public async Task <IActionResult> Create(VendorSignInVM thisModel)
{
UserRoleRepo userRoleRepo = new UserRoleRepo(_serviceProvider);
System.Threading.Thread.Sleep(2000);
var user = new ApplicationUser {
UserName = thisModel.RegisterVM.Email, Email = thisModel.RegisterVM.Email
};
var vendorUser = new Vendor {
Name = thisModel.Vendor.Name, Address = thisModel.Vendor.Address, City = thisModel.Vendor.City, Province = thisModel.Vendor.Province, Monthly = thisModel.Vendor.Monthly, Priority = thisModel.Vendor.Priority, Website = thisModel.Vendor.Website, PostalCode = thisModel.Vendor.PostalCode
};
if (ModelState.IsValid)
{
var result = await _userManager.CreateAsync(user, thisModel.RegisterVM.Password);
if (result.Succeeded)
{
var userID = user.Id;
vendorUser.UserID = userID;
_context.Add(vendorUser);
await _context.SaveChangesAsync();
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Link("Default", new { Controller = "Login", Action = "ConfirmEmail", userId = user.Id, code = code });
await _emailSender.SendEmailAsync(thisModel.RegisterVM.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
// here we assign the new user the "Vendor" role
await _userManager.AddToRoleAsync(user, "Vendor");
ViewBag.Email = thisModel.RegisterVM.Email;
return(View("Create", thisModel));
}
var errorList = new List <string>();
foreach (var errors in result.Errors)
{
errorList.Add(errors.Description);
}
ViewBag.ErrorMessage = errorList;
// Reset the site key if there is an error.
ViewData["SiteKey"] = _configuration["Authentication:Recaptcha:SiteKey"];
return(View("Index", thisModel));
}
else
{
ViewData["SiteKey"] = _configuration["Authentication:Recaptcha:SiteKey"];
}
return(View("Index", thisModel));
}
public async Task <IActionResult> DeleteUserRole(string email, string roleName)
{
if (ModelState.IsValid)
{
UserRoleRepo userRoleRepo = new UserRoleRepo(_serviceProvider);
var success = await userRoleRepo.RemoveUserRole(email, roleName);
if (success)
{
return(RedirectToAction(nameof(Index)));
}
}
ViewBag.Error = "An error occurred while deleting this role. Please try again.";
return(View());
}
private async Task <bool> AddRole(string userName, string role)
{
UserRoleRepo userRoleRepo = new UserRoleRepo(_serviceProvider);
if (ModelState.IsValid)
{
var addUR = await userRoleRepo.AddUserRole(userName, role);
if (addUR)
{
return(true);
}
}
return(false);
}
public async Task <IActionResult> SuperRegister(RegisterViewModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
//this code is written by myself to add user to Account table.
_context.Accounts.Add(new Account
{
Id = user.Id,
});
_context.SaveChanges();
UserRoleRepo userRoleRepo = new UserRoleRepo(_serviceProvider, _context);
if (ModelState.IsValid)
{
await userRoleRepo.AddUserRole(model.Email, _context.Roles.FirstOrDefault().ToString());
}
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created a new account with password.");
//this code is written by myself to make this user to be the admin
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
//return RedirectToAction("ShowGoods", "Home");
}
public async Task <IActionResult> Create(UserRoleVM userRoleVM)
{
UserRoleRepo userRoleRepo = new UserRoleRepo(_serviceProvider);
if (ModelState.IsValid)
{
var addUR = await userRoleRepo.AddUserRole(userRoleVM.Email,
userRoleVM.Role);
}
try {
return(RedirectToAction("Detail", "UserRole",
new { userName = userRoleVM.Email }));
}
catch {
return(View());
}
}
public IActionResult Create(HomeVM home)
{
HouseholdRepo householdRepo = new HouseholdRepo(_context);
if (householdRepo.CreateHousehold(home))
{
var _home = householdRepo.GetHouseholdByName(home.homeName);
//Role Assignment
UserRoleRepo userRoleRepo = new UserRoleRepo(_serviceProvider);
userRoleRepo.AddUserRole(User.Identity.Name, "HomeAdmin");
return(RedirectToAction("Join", _home));
}
return(RedirectToAction(nameof(JoinCreateHousehold), new { errorMessage = "Failed to create the household. Try a new name, please." }));
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new IdentityUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
UserRoleRepo userRoleRepo = new UserRoleRepo(_serviceProvider, _context);
userRoleRepo.AddUserRole(user.Email, "Member");
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 IActionResult Join(HomeVM home)
{
HouseholdRepo householdRepo = new HouseholdRepo(_context);
var _home = householdRepo.GetHouseholdByName(home.homeName);
if (_home != null)
{
if (_home.HomeId == home.homeId)
{
UserRepo userRepo = new UserRepo(_context);
var currentUserEmail = User.Identity.Name;
var userId = userRepo.FindUserId(currentUserEmail);
householdRepo.AddRoommateToHome(userId, _home.HomeId);
//Role Assignment
UserRoleRepo userRoleRepo = new UserRoleRepo(_serviceProvider);
userRoleRepo.AddUserRole(currentUserEmail, "Roommate");
return(RedirectToAction(nameof(HomeController.Index), "Home"));
}
}
return(RedirectToAction(nameof(JoinCreateHousehold), new { errorMessage = "Failed to join the household. Make sure the Home Name and Household Password are correct, please." }));
}
public async Task SeedDataAsync()
{
var users = context.Users;
if (users.Count() > 0)
{
return;
}
string password = "******";
var manager = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
var result = await userManager.CreateAsync(manager, password);
if (result.Succeeded)
{
UserRoleRepo repo = new UserRoleRepo(service);
await repo.AddUserRole(manager.Email, "Manager");
UserRepo userRepo = new UserRepo(context, service);
userRepo.AddUserDetails(manager.Id, "Default", "Manager");
}
var user1 = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
var result1 = await userManager.CreateAsync(user1, password);
if (result1.Succeeded)
{
UserRoleRepo repo = new UserRoleRepo(service);
await repo.AddUserRole(user1.Email, "Employee");
UserRepo userRepo = new UserRepo(context, service);
userRepo.AddUserDetails(user1.Id, "Jack", "Employee");
}
var user2 = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
var result2 = await userManager.CreateAsync(user2, password);
if (result2.Succeeded)
{
UserRoleRepo repo = new UserRoleRepo(service);
await repo.AddUserRole(user2.Email, "Employee");
UserRepo userRepo = new UserRepo(context, service);
userRepo.AddUserDetails(user2.Id, "Matthew", "Employee");
}
var user3 = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
var result3 = await userManager.CreateAsync(user3, password);
if (result3.Succeeded)
{
UserRoleRepo repo = new UserRoleRepo(service);
await repo.AddUserRole(user3.Email, "Employee");
UserRepo userRepo = new UserRepo(context, service);
userRepo.AddUserDetails(user3.Id, "Chris", "Employee");
}
}
