public async Task <ActionResult> Create([Bind(Include = "Id,Name,Greeting")] Household household)
{
if (ModelState.IsValid)
{
if (User.IsInRole("Guest"))
{
var userId = User.Identity.GetUserId();
var user = db.Users.Find(userId);
roleHelper.RemoveUserFromRole(user.Id, "Guest");
household.Created = DateTime.Now;
db.Households.Add(household);
user.HouseholdId = household.Id;
roleHelper.AddUserToRole(user.Id, "Head of Household");
db.SaveChanges();
await ControllerContext.HttpContext.RefreshAuthentication(user);
return(RedirectToAction("Details", "Households", new { id = household.Id }));
}
}
return(View(household));
}
public async Task <ActionResult> Create([Bind(Include = "Id,Name,Greeting,Created")] Household household)
{
if (ModelState.IsValid)
{
household.Created = DateTime.Now;
db.Households.Add(household);
db.SaveChanges();
//Update User Record to indicate they are in a household
var userId = User.Identity.GetUserId();
var user = db.Users.Find(userId);
user.Household = household;
db.SaveChanges();
//Update role to Head Of Household if Memeber Creates New Household
roleHelper.RemoveUserFromRole(userId, "Guest");
roleHelper.AddUserToRole(userId, "HeadOfHousehold");
await ControllerContext.HttpContext.RefreshAuthentication(user);
return(RedirectToAction("Index"));
}
return(View(household));
}
public ActionResult ManageUserRole(string userId, string userRole)
{
foreach (var role in roleHelper.ListUserRoles(userId))
{
roleHelper.RemoveUserFromRole(userId, role);
}
if (!string.IsNullOrEmpty(userRole))
{
roleHelper.AddUserToRole(userId, userRole);
}
return(RedirectToAction("UserIndex"));
}
public ActionResult ManageRoles(string users, string roles)
{
//I want to ensure who i select occupies that role
foreach (var role in roleHelper.ListUserRoles(users))
{
roleHelper.RemoveUserFromRole(users, role);
}
//newly selected role to user
roleHelper.AddUserToRole(users, roles);
return(RedirectToAction("UserIndex", "Admin"));
}
public async Task <ActionResult> Leave(string successor)
{
var user = db.Users.Find(User.Identity.GetUserId());
var newHead = db.Users.Find(successor);
user.HouseholdId = null;
db.SaveChanges();
roleHelper.RemoveUserFromRole(user.Id, "Head_Of_House");
roleHelper.RemoveUserFromRole(newHead.Id, "Member");
roleHelper.AddUserToRole(newHead.Id, "Head_Of_House");
await ControllerContext.HttpContext.RefreshAuthentication(user);
TempData["Appointed"] = $"You have successfully left your household, and have appointed {newHead.FullName} as new head of your household.";
return(RedirectToAction("Index", "Home"));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
RoleHelper roleHelp = new RoleHelper();
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email, firstName = model.FirstName, lastName = model.LastName, avatar = "/Avatar/default-avatar.png"
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
roleHelp.AddUserToRole(user.Id, "Submitter");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Profile"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
private void btnEditProfile_Click(object sender, EventArgs e)
{
if (this.Page.IsValid)
{
SiteManager siteManager = ManagerHelper.GetManager(this.userId);
siteManager.Email = this.txtprivateEmail.Text;
if (this.ValidationManageEamilr(siteManager))
{
foreach (string str in RoleHelper.GetUserRoleNames(siteManager.Username))
{
if (!RoleHelper.IsBuiltInRole(str) || (string.Compare(str, "SystemAdministrator") == 0))
{
RoleHelper.RemoveUserFromRole(siteManager.Username, str);
}
}
string text = this.dropRole.SelectedItem.Text;
if (string.Compare(text, "超级管理员") == 0)
{
text = "SystemAdministrator";
}
RoleHelper.AddUserToRole(siteManager.Username, text);
if (ManagerHelper.Update(siteManager))
{
this.ShowMsg("成功修改了当前管理员的个人资料", true);
}
else
{
this.ShowMsg("当前管理员的个人信息修改失败", false);
}
}
}
}
public ActionResult ManageRoles(List <string> userIds, string role)
{
var currentUserId = User.Identity.GetUserId();
var currentUserRoles = _roleHelper.ListUserRolesByUserId(currentUserId);
if (!currentUserRoles.Contains("Admin"))
{
return(RedirectToAction("ManageRoles", "ManageUsers"));
}
foreach (var userId in userIds)
{
foreach (var currentlyAssignedRole in _roleHelper.ListUserRolesByUserId(userId))
{
_roleHelper.RemoveUserFromRole(userId, currentlyAssignedRole);
}
}
if (String.IsNullOrWhiteSpace(role))
{
return(RedirectToAction("ManageRoles", "ManageUsers"));
}
foreach (var userId in userIds)
{
_roleHelper.AddUserToRole(userId, role);
}
return(RedirectToAction("ManageRoles", "ManageUsers"));
}
public ActionResult Create([Bind(Include = "Id,Name")] Household household)
{
if (ModelState.IsValid)
{
var role = new RoleHelper();
var currentUser = db.Users.Find(User.Identity.GetUserId());
if (currentUser.HouseholdId != null)
{
if (User.IsInRole("Head"))
{
TempData["InHouse"] = "Head";
return(RedirectToAction("Create", "Households"));
}
TempData["JoiningHouse"] = household.Id;
TempData["InHouse"] = "Yes";
return(RedirectToAction("Create", "Households"));
}
if (!User.IsInRole("Admin"))
{
role.AddUserToRole(User.Identity.GetUserId(), "Head");
}
currentUser.HouseholdId = household.Id;
db.households.Add(household);
db.SaveChanges();
return(RedirectToAction("Details", "Households", new { household.Id }));
}
return(View(household));
}
public ActionResult ManageUserRoles(string users, string roles)
{
ViewBag.Users = new SelectList(db.Users.ToList(), "Id", "FullContactInfo");
ViewBag.Roles = new SelectList(db.Roles.ToList(), "Name", "Name");
//i need to remove the user from all projects and tickets they've been assigned to, since their responsibilities have changed
var userId = db.Users.Find(users).Id;
if (roleHelper.IsUserInRole(userId, "Developer") == true)
{
var myTickets = db.Tickets.Where(t => t.AssignedToUserId == userId).ToList();
foreach (var ticket in myTickets)
{
ticket.AssignedToUserId = null;
var unassigned = db.TicketStatuses.FirstOrDefault(s => s.Name == "Unassigned");
ticket.TicketStatusId = unassigned.Id;
}
}
db.SaveChanges();
//i want to ensure that the person i selected occupies only one role. therefore the first thing ill do is remove the user from a current role.
foreach (var role in roleHelper.ListUserRoles(users))
{
roleHelper.RemoveUserFromRole(users, role);
}
roleHelper.AddUserToRole(users, roles);
return(RedirectToAction("UserIndex", "Admin"));
}
public ActionResult AssignUserToRole(string userName, string roleName)
{
var user = _userRepository.GetUserByUserName(userName);
if (user == null)
{
SetErrorMessage("User doesn't exist!");
}
var role = _roleRepository.GetRoleByName(roleName);
if (role == null)
{
SetErrorMessage("Role doesn't exist!");
}
bool isRoleAssigned = RoleHelper.AddUserToRole(userName, roleName);
if (isRoleAssigned)
{
SetSucceedMessage("User added to role successfully");
}
//var viewModel = user.MapTo<UserEditingViewModel>();
//viewModel.Roles.Add(roleId);
return(View());
}
public ActionResult Create([Bind(Include = "Id,Name,Greeting,Created")] Household household)
{
if (ModelState.IsValid)
{
var user = db.Users.Find(User.Identity.GetUserId());
household.OwnerUserId = User.Identity.GetUserId();
household.Created = DateTime.Now;
roleHelper.AddUserToRole(user.Id, "HeadOfHouse");
user.Household = household;
db.Households.Add(household);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(household));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
DisplayName = $"{model.FirstName} {model.LastName}"
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
roleHelper.AddUserToRole(user.Id, "Submitter");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code }, protocol: Request.Url.Scheme);
await EmailHelper.ComposeEmailAsync(model, callbackUrl);
return(RedirectToAction("NewRegister", "Account"));
}
AddErrors(result);
}
return(View(model));
}
public ActionResult ManageRoles(string users, string roles)
{
//I want to ensure that the person I selected occupies one and only 1 role
//Therefore the first thing I am going to do is remove the user from any role
//they currently occupy
//Step 1: Remove any roles currently occupied by the user. We can do this by
// looping over the roles currently occupied by the user using the roleHelper
foreach (var role in roleHelper.ListUserRoles(users))
{
roleHelper.RemoveUserFromRole(users, role);
}
//Step 2: Add the newly selected role to the user
roleHelper.AddUserToRole(users, roles);
return(RedirectToAction("UserIndex", "Admin"));
}
public ActionResult Create([Bind(Include = "Id,Name,Greeting")] Household household)
{
if (ModelState.IsValid)
{
db.Households.Add(household);
household.Created = DateTime.Now;
household.Users.Add(db.Users.Find(User.Identity.GetUserId()));
roleHelper.RemoveUserFromRole(User.Identity.GetUserId(), "UnAssigned");
roleHelper.AddUserToRole(User.Identity.GetUserId(), "HeadOfHousehold");
var userr = User.Identity.GetUserId();
if (!roleHelper.IsDemoUser(userr))
{
db.SaveChanges();
}
return(RedirectToAction("Index", "Home"));
}
return(RedirectToAction("Details", "Households", new { id = household.Id }));
}
public async Task <ActionResult> ApointSuccessor(string newHOH)
{
if (string.IsNullOrEmpty(newHOH))
{
return(RedirectToAction("Dashboard", "Home"));
}
var me = db.Users.Find(User.Identity.GetUserId());
me.HouseholdId = null;
db.SaveChanges();
roleHelper.RemoveUserFromRole(me.Id, "HouseholdHead");
await ControllerContext.HttpContext.RefreshAuthentication(me);
roleHelper.RemoveUserFromRole(newHOH, "Member");
roleHelper.AddUserToRole(newHOH, "HouseholdHead");
return(RedirectToAction("Dashboard", "Home"));
}
public ActionResult Create([Bind(Include = "Id,Name,Description")] Household household)
{
if (ModelState.IsValid)
{
db.Households.Add(household);
var userId = User.Identity.GetUserId();
foreach (var role in roleHelper.ListUserRoles(userId))
{
roleHelper.RemoveUserFromRole(userId, role);
}
roleHelper.AddUserToRole(userId, "HeadofHousehold");
var user = db.Users.Find(userId);
user.HouseholdId = household.Id;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(household));
}
public async Task <ActionResult> Create([Bind(Include = "Id,Name,Greeting")] Household household)
{
if (ModelState.IsValid)
{
if (!User.IsInRole("Admin"))
{
rHelp.RemoveUserFromRole(User.Identity.GetUserId(), rHelp.ListUserRoles(User.Identity.GetUserId()).FirstOrDefault());
}
rHelp.AddUserToRole(User.Identity.GetUserId(), "Head of Household");
household.Created = DateTime.Now;
db.Households.Add(household);
db.Users.Find(User.Identity.GetUserId()).HouseholdId = household.Id;
db.SaveChanges();
await ControllerContext.HttpContext.RefreshAuthentication(db.Users.Find(User.Identity.GetUserId()));
return(RedirectToAction("Index"));
}
return(View(household));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var LobbyId = db.Households.AsNoTracking().FirstOrDefault(h => h.Name == "The Lobby").Id;
var user = new ApplicationUser
{
FirstName = model.FirstName,
LastName = model.LastName,
Nickname = model.Nickname,
UserName = model.Email,
Email = model.Email,
HouseholdId = LobbyId
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
roleHelper.AddUserToRole(user.Id, "Lobbyist");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Lobby", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> Create([Bind(Include = "Id,Name,Greeting")] Household household)
{
if (ModelState.IsValid)
{
household.Established = DateTime.Now;
db.Households.Add(household);
var userId = User.Identity.GetUserId();
var user = db.Users.Find(userId);
user.HouseholdId = household.Id;
db.SaveChanges();
roleHelper.RemoveUserFromRole(userId, PortalRole.Lobbyist);
roleHelper.AddUserToRole(userId, PortalRole.HeadofHousehold);
await AdminHelper.ReauthorizeUserAsync(userId);
return(RedirectToAction("Dashboard"));
}
return(View(household));
}
public ActionResult ManageUserRole(string id, string roleName)
{
foreach (var role in roleHelper.ListUserRoles(id))
{
roleHelper.RemoveUserFromRole(id, role);
}
if (!String.IsNullOrEmpty(roleName))
{
roleHelper.AddUserToRole(id, roleName);
}
return(RedirectToAction("ManageUserRole", new { id }));
}
public ActionResult ManageRoles(string userId, string roleName)
{
foreach (var role in rolesHelper.ListUserRoles(userId).ToList())
{
rolesHelper.RemoveUserFromRole(userId, role);
}
if (!string.IsNullOrEmpty(roleName))
{
rolesHelper.AddUserToRole(userId, roleName);
}
return(Redirect(Request.UrlReferrer.ToString()));
}
public ActionResult ManageUserRole(string id, string roleName)
{
//spin through all roles for user and remove them
foreach (var role in roleHelper.ListUserRoles(id))
{
roleHelper.RemoveUserFromRole(id, role);
}
//if a role is chosen, add user to that role
if (!string.IsNullOrEmpty(roleName))
{
roleHelper.AddUserToRole(id, roleName);
}
//now that the new role is assigned, redirect to the page from which they came
return(RedirectToAction("Index", "Users"));
}
public ActionResult Create([Bind(Include = "Id,Name")] Household household)
{
if (ModelState.IsValid)
{
db.Households.Add(household);
db.SaveChanges();
var houseHead = User.Identity.GetUserId();
HouseholdHelper.AddUserToHousehold(houseHead, household.Id);
RoleHelper.AddUserToRole(houseHead, "HoH");
household.CreatedByUserId = houseHead;
return(RedirectToAction("Index"));
}
return(View(household));
}
public ActionResult ManageRoles(List <string> userIds, string roleName)
{
if (userIds != null)
{
foreach (var userId in userIds)
{
var userRole = roleHelper.ListUserRoles(userId).FirstOrDefault();
if (userRole != null)
{
roleHelper.RemoveUserFromRole(userId, userRole);
}
roleHelper.AddUserToRole(userId, roleName);
}
}
return(RedirectToAction("ManageRoles"));
}
public ActionResult Create([Bind(Include = "Id,Name")] Household household)
{
if (ModelState.IsValid)
{
var userId = User.Identity.GetUserId();
var CurrentUser = db.Users.Find(userId);
roleHelper.AddUserToRole(userId, "Head");
household.Members.Add(CurrentUser);
db.Households.Add(household);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(household));
}
//POST: EditUser
public ActionResult EditUser(AdminUserViewModel model)
{
var user = db.Users.Find(model.User.Id);
RoleHelper helper = new RoleHelper();
foreach (var rolermv in db.Roles.Select(r => r.Id).ToList())
{
helper.RemoveUserFromRole(user.Id, rolermv);
}
foreach (var roleadd in db.Roles.Select(r => r.Id).ToList())
{
helper.AddUserToRole(user.Id, roleadd);
}
return(RedirectToAction("Index"));
}
public ActionResult ManageRoles(List <string> personnel, string roleName)
{
if (personnel != null)
{
foreach (var person in personnel)
{
var personRole = roleHelper.ListUserRoles(person).FirstOrDefault();
if (!String.IsNullOrEmpty(personRole))
{
roleHelper.RemoveUserFromRole(person, personRole);
}
if (!String.IsNullOrEmpty(roleName))
{
roleHelper.AddUserToRole(person, roleName);
}
}
}
return(RedirectToAction("ManageRoles"));
}
public async Task <ActionResult> CreateAsync([Bind(Include = "Name,Greeting")] Household household)
{
if (ModelState.IsValid)
{
household.Created = DateTimeOffset.UtcNow.ToLocalTime();
db.Households.Add(household);
db.SaveChanges();
var userId = User.Identity.GetUserId();
var user = db.Users.Find(userId);
user.HouseholdId = household.Id;
db.SaveChanges();
roleHelper.RemoveUserFromRole(userId, "LobbyMember");
roleHelper.AddUserToRole(userId, "HeadofHouse");
await AdminHelper.ReathorizeUserAsync(userId);
return(RedirectToAction("Dashboard"));
}
return(View(household));
}
public async Task <ActionResult> Leave(int id)
{
var userId = User.Identity.GetUserId();
var user = db.Users.Find(userId);
RoleHelper roleHelper = new RoleHelper();
if (User.IsInRole("Head of Household"))
{
Household household = db.Households.Find(id);
db.Households.Remove(household);
roleHelper.RemoveUserFromRole(user.Id, "Head of Household");
roleHelper.AddUserToRole(user.Id, "Guest");
db.SaveChanges();
await ControllerContext.HttpContext.RefreshAuthentication(user);
return(RedirectToAction("Dashboard", "Home"));
}
return(RedirectToAction("Dashboard", "Home"));
}
