public async Task <IActionResult> AddRoleForUser(AddRoleVm addrole)
{
if (!ModelState.IsValid)
{
return(View("Index"));
}
bool userExist = await _auth.UserExist(addrole.Email);
bool roleExist = await _auth.RoleExist(addrole.RoleName);
if (!userExist)
{
ModelState.AddModelError("UserDontExist", "Användaren finns inte! ");
return(View("Index"));
}
else if (!roleExist)
{
await _auth.CreateRole(addrole.RoleName);
await _auth.ConnectRoleToUser(addrole.RoleName, addrole.Email);
}
return(View("SuccessAddRole"));
}
internal async Task <bool> AddRole(AddRoleVm addrole)
{
if (addrole.Role != null)
{
IdentityRole role1 = new IdentityRole(addrole.Role);
var checkRole = await _roleManager.FindByNameAsync(addrole.Role);
var role = await _roleManager.CreateAsync(role1);
if (addrole.Email != null)
{
IdentityUser identityUser = await _userManager.FindByEmailAsync(addrole.Email);
var addRoleToUser = await _userManager.AddToRoleAsync(identityUser, addrole.Role);
}
}
else
{
var role = await _roleManager.FindByIdAsync(addrole.RoleInformation.Id);
IdentityUser identityUser = await _userManager.FindByEmailAsync(addrole.Email);
var addRoleToUser = await _userManager.AddToRoleAsync(identityUser, role.Name);
}
return(true);
}
public async Task <IActionResult> AddRoleForUser(AddRoleVm addrole)
{
bool Userexist = await _auth.UserExist(addrole.Admin.Email);
//ModelState.AddModelError(addrole.Admin.Email);
if (!ModelState.IsValid)
{
return(View("index"));
}
else
{
if (Userexist)
{
bool roleExist = await _auth.RoleExist(addrole.Admin.Role);
if (!roleExist)
{
await _auth.CreateRole(addrole.Admin.Role);
}
await _auth.AddRoleToUser(addrole);
return(View("SuccessAddRole", addrole));
}
else
{
ModelState.AddModelError("UserDontExist", $"User with email {addrole.Admin.Email} doesn't exist");
return(View("index"));
}
}
}
public async Task <IActionResult> AddRoleForUser(AddRoleVm addrole)
{
if (!ModelState.IsValid)
{
return(View("Index"));
}
bool userExist = await _auth.UserExist(addrole.Email);
if (!userExist)
{
ModelState.AddModelError("UserDontExist", $"User with email {addrole.Email} doesn't exist");
return(View("Index"));
}
bool alreadyInRole = await _auth.IsInRoleAsync(addrole.Email, addrole.RoleName);
if (alreadyInRole)
{
ModelState.AddModelError("UserAlreadyInrole", $"{addrole.Email} already belongs to role {addrole.RoleName}");
return(View("Index"));
}
bool roleExist = await _auth.RoleExistsAsync(addrole.RoleName);
if (!roleExist)
{
await _auth.CreateRoleAsync(addrole.RoleName); // todo: hantera oväntat fel
}
await _auth.AddToRoleAsync(addrole.Email, addrole.RoleName);
return(View("SuccessAddRole", addrole));
}
internal async Task AddRoleToUser(AddRoleVm addrole)
{
IdentityUser user = await _userManager.FindByEmailAsync(addrole.Admin.Email);
//IdentityRole role = await _roleManager.FindByNameAsync(addrole.Admin.Role);
await _userManager.AddToRoleAsync(user, addrole.Admin.Role);
}
public async Task <IActionResult> GetUsersInRole(string role)
{
AddRoleVm vm = new AddRoleVm();
var users = await _auth.GetUsersInRole(role);
vm.indentityusers = users;
vm.Role = role;
return(View(vm));
}
public async Task <IActionResult> UpdateRole(AddRoleVm addrole)
{
var role = await _auth.GetRoleById(addrole.RoleInformation.Id);
AddRoleVm vm = new AddRoleVm();
vm.RoleInformation = role;
vm.RoleIdToUpdate = role.Id;
return(View(vm));
}
internal async Task AddRoleToUser(AddRoleVm addrole)
{
if (!await _roleManager.RoleExistsAsync(addrole.Role))
{
await CreateRolesAsync(addrole.Role);
}
IdentityUser user = await _userManager.FindByEmailAsync(addrole.Email);
await _userManager.AddToRoleAsync(user, addrole.Role);
}
public async Task AddRoleToUser(AddRoleVm addrole)
{
IdentityResult roleResult;
var role2 = new IdentityRole(addrole.Role);
roleResult = await _roleManager.CreateAsync(role2);
IdentityUser user = await _userManager.FindByEmailAsync(addrole.Email);
await _userManager.AddToRoleAsync(user, addrole.Role);
}
public IActionResult AllRoles()
{
var listOfRoles = GetAllRoles();
List <string> roles = new List <string>();
foreach (var role in listOfRoles)
{
roles.Add(role.Name);
}
AddRoleVm vm = new AddRoleVm();
vm.roles = roles;
return(View(vm));
}
//[Authorize(Roles = "Admin")]
public IActionResult Index()
{
var vm = new AddRoleVm
{
AllRoles = _context.Roles.Select(role => new SelectListItem()
{
Text = role.Name, Value = role.Name
}),
AllUsers = _context.Users.Select(user => new SelectListItem()
{
Text = user.Email, Value = user.Email
})
};
return(View(vm));
}
public async Task <IActionResult> Delete(string role)
{
var result = await _auth.DeleteRole(role);
var listOfRoles = GetAllRoles();
List <string> roles = new List <string>();
foreach (var item in listOfRoles)
{
roles.Add(item.Name);
}
AddRoleVm vm = new AddRoleVm();
vm.roles = roles;
return(View("AllRoles", vm));
}
public IActionResult AddRole(AddRoleVm rolename)
{
var checkAdd = _auth.AddRole(rolename).Result;
var listOfRoles = GetAllRoles();
List <string> roles = new List <string>();
foreach (var item in listOfRoles)
{
roles.Add(item.Name);
}
AddRoleVm vm = new AddRoleVm();
vm.roles = roles;
return(View("AllRoles", vm));
}
public async Task <JsonResult> AddRole([ModelBinder(typeof(JsonNetBinder)), FromForm] AddRoleVm role)
{
var result = new ResultJsonNoDataInfo();
var respositoryResult = await RoleRespository.AddRole(role, UserToken);
if (string.IsNullOrEmpty(respositoryResult))
{
result.Status = ResultConfig.Ok;
result.Info = ResultConfig.SuccessfulMessage;
}
else
{
result.Status = ResultConfig.Fail;
result.Info = string.IsNullOrEmpty(respositoryResult) ? ResultConfig.FailMessage : respositoryResult;
}
return(Json(result));
}
public async Task <IActionResult> AddRoleForUser(AddRoleVm addrole)
{
if (!ModelState.IsValid)
{
return(View("Index"));
}
bool userExist = await _auth.UserExist(addrole.Email);
if (!userExist)
{
ModelState.AddModelError("InvalidUser", "The user does not exist");
return(View("Index"));
}
await _auth.AddRoleToUser(addrole);
return(View("SuccessAddRole", addrole));
}
public async Task <IActionResult> Update(AddRoleVm x)
{
var oldRole = await _auth.GetRoleById(x.RoleIdToUpdate);
oldRole.Name = x.Role;
var answer = await _auth.Update(oldRole, x.Role);
var listOfRoles = GetAllRoles();
List <string> roles = new List <string>();
foreach (var item in listOfRoles)
{
roles.Add(item.Name);
}
AddRoleVm vm = new AddRoleVm();
vm.roles = roles;
return(View("AllRoles", vm));
}
public async Task <IActionResult> AddRoleForUser(AddRoleVm addrole)
{
bool userExist = await _auth.UserExist(addrole.Email);
if (!ModelState.IsValid)
{
ModelState.AddModelError("UserDontExist", $"User with email {addrole.Email} does not exist");
return(View("Index"));
}
bool roleExist = await _auth.RoleExist(addrole.RoleName);
if (roleExist == false)
{
await _auth.CreateRole(addrole.RoleName);
}
await _auth.AddRoleToUser(addrole.Email, addrole.RoleName);
return(View("SuccessAddRole"));
}
public IActionResult Index()
{
var listofRoles = GetAllRoles();
var list = new List <SelectListItem>();
foreach (var role in listofRoles)
{
list.Add(new SelectListItem
{
Text = role.Name,
Value = role.Id.ToString()
});
}
AddRoleVm vm = new AddRoleVm();
vm.RoleItems = list;
return(View(vm));
}
public async Task <IActionResult> AddRoleForUser(AddRoleVm addrole)
{
if (!ModelState.IsValid)
{
return(View("Index"));
}
bool userexist = await _auth.UserExist(addrole.Email);
bool roleexist = await _auth.RoleExist(addrole.RoleName);
if (!userexist)
{
ModelState.AddModelError("UserDontExist", $"User with email {addrole.Email} doesn't exist");
return(View("Index"));
}
else
{
return(View("SuccessAddRole", addrole));
}
}
public IActionResult AddRoleForUser(AddRoleVm addrole)
{
var userMail = _auth.GetUserMail(addrole.Email).Result;
if (userMail == true)
{
var checkAdd = _auth.AddRole(addrole).Result;
if (checkAdd == true)
{
return(View(addrole));
}
else
{
ViewData["message"] = "Funkade inte";
return(View("AddRole"));
}
}
else
{
ViewData["message"] = "Mail fanns inte";
return(View("AddRole"));
}
}
public async Task <IActionResult> AddRoleForUser(AddRoleVm addrole)
{
if (!ModelState.IsValid)
{
return(View());
}
else if (!await _auth.UserExist(addrole.Email))
{
ModelState.AddModelError("UserExist", "Användaren hittades inte");
return(View());
}
else if (!await _auth.RoleExists(addrole.Role))
{
ModelState.AddModelError("RoleExist", "Rollen hittades inte");
return(View());
}
else if (!await _auth.AddRoleToUser(addrole.Email, addrole.Role))
{
ModelState.AddModelError("CombinationExists", "Användaren har redan denna roll");
return(View());
}
return(View("Success", addrole));
}
public async Task <IActionResult> AddRoleForUser(AddRoleVm addrole)
{
await _auth.AddRoleToUser(addrole);
return(View("SuccesAddRole", addrole));
}
public async Task <IActionResult> AddRoleForUser(AddRoleVm addrole)
{
await _auth.AddToRoleAsync(addrole.Email, addrole.Role);
return(View("SuccessAddRole", addrole));
}
public async Task <string> AddRole(AddRoleVm role, Token user)
{
if (role == null)
{
return(Tip.BadRequest);
}
bool isUpdate = role.Tid > 0;
if (!isUpdate)
{
var en = await this.Entity.FirstOrDefaultAsync(r => r.IsActive && r.RoleName.Equals(role.RoleName.Trim()));
if (en != null)
{
return(Tip.RoleNameIsExists);
}
}
else
{
var en = await this.Entity.FirstOrDefaultAsync(r => r.IsActive && !r.Tid.Equals(role.Tid) && r.RoleName.Equals(role.RoleName.Trim()));
if (en != null)
{
return(Tip.RoleNameIsExists);
}
}
var menuRights = RightsHelper.SumRights(role.Ids.ToList());
var actionList = role.Actions.GroupBy(r => r.MenuId)
.Select(r => new MenuActionSM
{
MenuTid = r.Key,
ActionList = r.Select(y => new ActionSM
{
ActionId = y.ActionId,
ActionName = y.ActionName
}).ToList()
}).ToList();
var systemRole = new SystemRole
{
ActionList = JsonConvert.SerializeObject(actionList),
IsActive = true,
MenuRights = menuRights.ToString(),
RoleName = role.RoleName,
Description = role.RoleDesc,
CreateUser = user.Eid,
CreateRoleTid = user.RoleTid
};
if (!isUpdate)
{
var saveResult = this.Save(systemRole) > 0;
if (!saveResult)
{
return(Tip.InserError);
}
}
else
{
//更新角色
var updateResult = this.Entity.Where(r => r.Tid.Equals(role.Tid))
.Set(r => r.DataChangeLastTime, DateTime.Now)
.Set(r => r.RoleName, systemRole.RoleName)
.Set(r => r.Description, systemRole.Description)
.Set(r => r.MenuRights, systemRole.MenuRights)
.Set(r => r.ActionList, systemRole.ActionList)
.Update() > 0;
if (!updateResult)
{
return(Tip.UpdateError);
}
//更新所有角色下的用户菜单权限
Entitys.SystemUsers.Where(r => r.RoleTid.Equals(role.Tid))
.Set(r => r.MenuRights, systemRole.MenuRights)
.Set(r => r.DataChangeLastTime, DateTime.Now)
.Update();
}
return(string.Empty);
}
