public static RoleModel ToModel(this UserRoleDto role) =>
new RoleModel
{
Id = role.Id,
Name = role.DisplayName,
ProjectId = role.ProjectId
};
public HttpResponseMessage RemoveUserFromRole(UserRoleDto userRoleDto)
{
try
{
Validate(userRoleDto);
HttpResponseMessage response;
var user = GetUser(userRoleDto.UserId, out response);
if (user == null)
{
return(response);
}
RoleController.Instance.UpdateUserRole(PortalId, userRoleDto.UserId, userRoleDto.RoleId,
RoleStatus.Approved, false, true);
return(Request.CreateResponse(HttpStatusCode.OK, new { userRoleDto.UserId, userRoleDto.RoleId }));
}
catch (ArgumentException ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
}
catch (SecurityException ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
}
catch (Exception ex)
{
Logger.Error(ex);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
/// <summary>
/// Removed the user from the given role.
/// </summary>
/// <param name="dto">Contains the user's id and the target role.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">Throws if <paramref name="dto"/> is null.</exception>
/// <exception cref="NotFoundException">Throws if the user or role cannot be found.</exception>
/// <exception cref="ValidationException">Throws if the user cannot be removed from the role.</exception>
public async Task RemoveFromRoleAsync(UserRoleDto dto)
{
if (dto == null)
{
throw new ArgumentNullException(nameof(dto));
}
_logger.LogDebug("Removing user '{0}' from role '{1}'", dto.UserId, dto.RoleId);
var user = await _repository.FindByIdAsync(dto.UserId);
if (user == null)
{
_logger.LogDebug("Could not find user with id '{0}'", dto.UserId);
throw new NotFoundException(ErrorMessages.UserNotFound);
}
var role = await _roleRepository.FindByIdAsNoTrackingAsync(dto.RoleId);
if (role == null)
{
_logger.LogDebug("Could not find role with id '{0}'", dto.RoleId);
throw new NotFoundException(ErrorMessages.RoleNotFound);
}
user.RemoveRole(role.Id);
_logger.LogDebug("Saving the changes to the repository...");
await _repository.SaveChangesAsync();
_logger.LogDebug("Successfully removed the user '{0}' from the role '{1}'", user.Id, role.Id);
}
public async Task <GenericResponse> Put(long id, UserRoleDto dto)
{
if (id != dto.Id)
{
return(GenericResponse.Error(ResultType.Error, "Ids are mismatch!", "UR_PT_01", StatusCodes.Status500InternalServerError));
}
try
{
UserRoleBo bo = UserRoleBo.ConvertToBusinessObject(dto);
ServiceResult serviceResult = await serviceManager.UserRole_Service.UpdateAsync(id, bo);
if (serviceResult.Success)
{
await serviceManager.CommitAsync();
return(GenericResponse.Ok());
}
else
{
return(GenericResponse.Error(ResultType.Error, serviceResult.Error, "UR_PT_02", StatusCodes.Status500InternalServerError));
}
}
catch (Exception ex)
{
Log(ex.Message, LogLevel.Error, this.ControllerContext.RouteData.Values);
return(GenericResponse.Error(ResultType.Error, ex.Message, "UR_PT_03", StatusCodes.Status500InternalServerError));
}
}
public ResultHelper AddUserRole(UserRoleDto userRoleDto)
{
try
{
if (IsThere(userRoleDto))
{
return(new ResultHelper(false, 0, ResultHelper.UnSuccessMessage + "\n" + ResultHelper.IsThereItem));
}
userrole item = new userrole();
item.UserRoleID = userRoleDto.UserRoleID;
item.UserRoleName = userRoleDto.UserRoleName;
item.UserRoleDescription = userRoleDto.UserRoleDescription;
item.Active = userRoleDto.Active;
using (UnitOfWork unitOfWork = new UnitOfWork())
{
unitOfWork.GetRepository <userrole>().Insert(item);
unitOfWork.saveChanges();
return(new ResultHelper(true, item.UserRoleID, ResultHelper.SuccessMessage));
}
}
catch (Exception ex)
{
return(new ResultHelper(false, 0, ResultHelper.UnSuccessMessage));
}
}
public HttpResponseMessage GetSuggestRoles(string keyword, int count)
{
try
{
if (string.IsNullOrEmpty(keyword))
{
return(Request.CreateResponse(HttpStatusCode.OK, new List <UserRoleInfo>()));
}
var isAdmin = Components.UsersController.IsAdmin(PortalSettings);
var roles = RoleController.Instance.GetRoles(PortalId,
x => x.RoleName.ToUpperInvariant().Contains(keyword.ToUpperInvariant()));
var matchedRoles = roles
.Where(
r =>
(isAdmin || r.RoleID != PortalSettings.AdministratorRoleId) &&
r.Status == RoleStatus.Approved)
.ToList().Take(count).Select(u => new UserRoleInfo
{
RoleID = u.RoleID,
RoleName = $"{u.RoleName}",
SecurityMode = u.SecurityMode
});
return(Request.CreateResponse(HttpStatusCode.OK,
matchedRoles.ToList().Select(r => UserRoleDto.FromRoleInfo(PortalSettings, r))));
}
catch (Exception ex)
{
Logger.Error(ex);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public void update(UserRoleDto dto)
{
try
{
_transactionManager.beginTransaction();
var previousAssignedRoles = _userRoleRepo.getByTypeId(dto.type, dto.type_id);
var removedUserRoles = previousAssignedRoles.Where(l1 => !dto.role_ids.Any(role_id => l1.role_id == role_id)).ToList();
foreach (var removedUserRole in removedUserRoles)
{
_userRoleRepo.delete(removedUserRole);
}
var addedRoleIds = dto.role_ids.Where(l1 => !previousAssignedRoles.Any(user_roles => l1 == user_roles.role_id)).ToList();
foreach (var roleId in addedRoleIds.Distinct())
{
UserRole user_role = new UserRole();
user_role.role_id = roleId;
user_role.role = _roleRepo.getById(roleId) ?? throw new ItemNotFoundException($"Role with the role id {roleId} doesnot exist.");
user_role.type = dto.type;
user_role.type_id = dto.type_id;
_userRoleRepo.insert(user_role);
}
_transactionManager.commitTransaction();
}
catch (Exception)
{
_transactionManager.rollbackTransaction();
throw;
}
}
public ActionResult Create(UserRoleDto model)
{
ResultHelper result = JsonConvert.DeserializeObject <ResultHelper>(userRoleService.AddUserRole(model));
ViewBag.Message = Helper.GetResultMessage(result.Result, result.ResultDescription);
return(View());
}
public void AddUserToRoles(UserInfo currentUserInfo, int userId, int portalId, string roleNames, string roleDelimiter = ",", DateTime?effectiveDate = null, DateTime?expiryDate = null)
{
var effDate = effectiveDate.GetValueOrDefault(Null.NullDate);
var expDate = expiryDate.GetValueOrDefault(Null.NullDate);
// get the specified RoleName
var roleController = new RoleController();
var lstRoles = roleNames.Split(roleDelimiter.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
foreach (var curRole in lstRoles)
{
var role = roleController.GetRoleByName(portalId, curRole);
if (role == null)
{
continue;
}
var userRoleDto = new UserRoleDto
{
RoleId = role.RoleID,
UserId = userId,
StartTime = effDate,
ExpiresTime = expDate,
RoleName = curRole
};
Instance.SaveUserRole(portalId, currentUserInfo, userRoleDto, false, false);
}
}
/// <summary>
/// 添加人员 角色
/// </summary>
/// <param name="rp"></param>
/// <returns></returns>
public JsonResult AddUserrole(UserRoleDto rp)
{
string json = Newtonsoft.Json.JsonConvert.SerializeObject(rp);
var result = HelperHttpClient.GetAll("post", "Authorization/AddUserrole", json);
return(Json(result));
}
public UserRoleDto GetUserName(string username, string password)
{
var user = _userRepository.GetUserName(username, password).Result.SingleOrDefault();
if (user == null)
{
return(null);
}
var result = new UserRoleDto
{
Id = user.Id,
UserName = user.UserName,
Email = user.Email
};
if (user.Roles.Any())
{
var roleId = user.Roles.First().RoleId;
var role = _userRepository.GetUserRole
(roleId).Result.SingleOrDefault();
if (role != null)
{
result.Role = role.Name;
}
}
return(result);
}
public async Task <IActionResult> Roles(string search)
{
var user = await _userManager.GetUserAsync(User);
ViewData["CurrentFilter"] = search;
var adminUsers = _adminService.GetAdminUsers().Where(x => x.Username != user.UserName).ToList();
var nonAdminUsers = _adminService.GetNonAdminUsers();
if (!String.IsNullOrEmpty(search))
{
var searchToUpper = search.ToUpper();
nonAdminUsers = nonAdminUsers.Where(u =>
u.FirstName.ToUpper().Contains(searchToUpper) ||
u.LastName.ToUpper().Contains(searchToUpper) ||
u.Username.ToUpper().Contains(searchToUpper));
}
var model = new UserRoleDto
{
Admins = adminUsers.OrderBy(x => x.FirstName),
Users = nonAdminUsers.OrderBy(x => x.FirstName).Take(10)
};
return(View(model));
}
public HttpResponseMessage GetUserRoles(string keyword, int userId, int pageIndex, int pageSize)
{
try
{
HttpResponseMessage response;
var user = GetUser(userId, out response);
if (user == null)
{
return(response);
}
var allUserRoles = RoleController.Instance.GetUserRoles(user, true);
if (!string.IsNullOrEmpty(keyword))
{
allUserRoles =
allUserRoles.Where(
u => u.FullName.StartsWith(keyword, StringComparison.InvariantCultureIgnoreCase))
.ToList();
}
var userRoles = allUserRoles
.Skip(pageIndex * pageSize)
.Take(pageSize)
.Select(r => UserRoleDto.FromRoleInfo(PortalSettings, r));
return(Request.CreateResponse(HttpStatusCode.OK,
new { UserRoles = userRoles, TotalRecords = allUserRoles.Count }));
}
catch (Exception ex)
{
Logger.Error(ex);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public JsonResult Modify(UserRoleDto dto)
{
if (!ModelState.IsValid)
{
return(Json(new MessageResults {
Status = "Error"
}, JsonRequestBehavior.AllowGet));
}
var result = false;
var user = new ApplicationUser();
if (!dto.UserId.Equals("0"))
{
user.Id = dto.UserId;
}
user.Email = dto.Email;
user.PhoneNumber = dto.PhoneNumber;
user.UserName = dto.UserName;
result = _accountService.AddOrUpdateUser(user, dto.ListRole);
if (result)
{
return(Json(new MessageResults {
Status = "Success"
}, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new MessageResults {
Status = "Error"
}, JsonRequestBehavior.AllowGet));
}
}
public ActionResult RemoveUserFromRole(UserRoleDto userRoleDto)
{
ActionResult response = new ActionResult();
try
{
Validate(userRoleDto);
UserInfo user = UserManager.GetUser(userRoleDto.UserId, PortalSettings, UserInfo, out response);
if (user == null)
{
return(response);
}
DotNetNuke.Security.Roles.RoleController.Instance.UpdateUserRole(PortalSettings.PortalId, userRoleDto.UserId, userRoleDto.RoleId,
RoleStatus.Approved, false, true);
response.Data = new { userRoleDto.UserId, userRoleDto.RoleId };
}
catch (ArgumentException ex)
{
response.AddError("HttpStatusCode.BadRequest" + HttpStatusCode.BadRequest, ex.Message);
}
catch (SecurityException ex)
{
response.AddError("HttpStatusCode.BadRequest" + HttpStatusCode.BadRequest, ex.Message);
}
catch (Exception ex)
{
response.AddError("HttpStatusCode.BadRequest" + HttpStatusCode.BadRequest, ex.Message);
}
return(response);
}
public void save(UserRoleDto dto)
{
try
{
_transactionManager.beginTransaction();
//var previousAssignedRoles = _userRoleRepo.getByTypeId(dto.type, dto.type_id);
//bool isRoleAlreadyAssignedToUser = previousAssignedRoles.Count > 0;
////if (isRoleAlreadyAssignedToUser)
////{
//throw new InvalidValueException("Roles have already been assigned to the user.");
//// }
foreach (var roleId in dto.role_ids.Distinct())
{
UserRole user_role = new UserRole();
user_role.role_id = roleId;
user_role.role = _roleRepo.getById(roleId) ?? throw new ItemNotFoundException($"Role with the role id {roleId} doesnot exist.");
user_role.type = dto.type;
user_role.type_id = dto.type_id;
_userRoleRepo.insert(user_role);
_transactionManager.commitTransaction();
}
}
catch (Exception)
{
_transactionManager.rollbackTransaction();
throw;
}
}
public async Task <object> RemoveUserRole(UserRoleDto userRoleDto)
{
var item = await _userRoleRepository.FindAll().FirstOrDefaultAsync(x => x.UserID == userRoleDto.UserID && x.UserID == userRoleDto.UserID);
if (item != null)
{
_userRoleRepository.Remove(item);
try
{
await _userRoleRepository.SaveAll();
return(new
{
status = true,
message = "Delete Successfully!"
});
}
catch (Exception)
{
return(new
{
status = false,
message = "Failed on delete!"
});
}
}
else
{
return(new
{
status = false,
message = ""
});
}
}
public async Task <IActionResult> OnGetAsync(int id)
{
var user = await _userManager.FindByIdAsync(id.ToString());
if (user == null)
{
return(RedirectToPage("Error"));
}
var model = new List <UserRoleDto>();
var roles = _roleManager.Roles.ToList();
foreach (var role in roles)
{
var userRoleDto = new UserRoleDto
{
RoleId = role.Id,
RoleName = role.Name
};
if (await _userManager.IsInRoleAsync(user, role.Name))
{
userRoleDto.IsSelected = true;
}
else
{
userRoleDto.IsSelected = false;
}
model.Add(userRoleDto);
}
Roles = model;
return(Page());
}
public async Task <ServiceResponse> AddUserRole(UserRoleDto _userRole)
{
ServiceResponse response = new ServiceResponse();
try
{
UserRole userRole = new UserRole
{
UserId = _userRole.UserId,
RoleId = _userRole.RoleId
};
var _uRole = unitOfWork.UserRepository.GetRole(userRole.UserId);
if (_uRole == null)
{
unitOfWork.UserRepository.AddRole(userRole);
unitOfWork.Commit();
response.IsSuccess = true;
}
else
{
response.Message = $"User already has assign a role";
response.IsSuccess = false;
}
}
catch (Exception e)
{
response.IsSuccess = false;
}
return(response);
}
public async Task <UserRoleDto> AddAsync(UserRoleDto userRoleDto)
{
var userRole1 = userRoleDto.UserRoleDtoToUserRole();
var userRole2 = await _userRoleRepository.AddAsync(userRole1);
return(userRole2.UserRoleToUserRoleDto());
}
public async Task <IActionResult> RemoveFromRole([FromRoute] UserRoleDto dto)
{
try
{
await _service.RemoveFromRoleAsync(dto);
return(Ok());
}
catch (NotFoundException e)
{
Logger.LogDebug("A resource could not be found: {0}", e.Message);
return(NotFound(e.Message));
}
catch (ValidationException e)
{
Logger.LogDebug("A validation error occured: {0}", e.Message);
return(BadRequest(e.Message));
}
catch (Exception e)
{
Logger.LogError(e, "An error occured while assigning a user to a role.");
return(InternalServerError(e.Message));
}
}
/// <summary>
/// 转换为用户角色实体
/// </summary>
/// <param name="dto">用户角色数据传输对象</param>
public static UserRole ToEntity(this UserRoleDto dto)
{
if (dto == null)
{
return(new UserRole());
}
return(dto.MapTo(new UserRole(dto.Id.ToGuid())));
}
public IActionResult PutUserRole(int id, [FromBody] UserRoleDto userRoleDto)
{
userRoleDto.Id = id;
var userRole = _mapper.Map <UserRole>(userRoleDto);
var result = _userBL.UpdateUserRole(userRole);
return(Ok(result));
}
public static UserRole UserRoleDtoToUserRole(this UserRoleDto userRoleDto)
{
return(new UserRole()
{
RoleId = userRoleDto.RoleId,
UserId = userRoleDto.UserId
});
}
public int AddUserrole([FromBody] string json)
{
UserRoleDto userrole = Newtonsoft.Json.JsonConvert.DeserializeObject <UserRoleDto>(json);
int uid = userrole.Uid;
int[] RoleId = Newtonsoft.Json.JsonConvert.DeserializeObject <int[]>(userrole.RoleId);
return(_authorization.AddUserrole(uid, RoleId));
}
public async Task <IdentityResult> AddToRoleAsync(UserRoleDto dto)
{
var user = await _userManager.FindByIdAsync(dto.UserId);
var result = await _userManager.AddToRoleAsync(user, dto.RoleName);
return(result);
}
public async Task Delete(UserRoleDto userRoleDto)
{
var userRoleToDelete = await _dbContext.UserRoles.Where(ur => ur.RoleId == userRoleDto.RoleId &&
ur.UserId == userRoleDto.UserId)
.SingleOrDefaultAsync();
_dbContext.Remove(userRoleToDelete);
await _dbContext.SaveChangesAsync();
}
public async Task <long> UpdateUserRoleAsync(UserRoleDto userRoleDto)
{
var userRole = new UserRole();
Mapper.Map(userRoleDto, userRole);
var rowsUpdated = await userRoleRepository.UpdateUserRoleAsync(userRole, userRoleDto.MappingScheme);
return(rowsUpdated);
}
public async Task <UserRoleDto> CreateAsync(IGuild guild, IChannel channel, IRole role, IEmote emoji,
String description)
{
var userRole = new UserRoleDto(guild.Id, channel.Id, role.Id, (emoji as Emote)?.Id, emoji.Name, description);
await this.UpdateAsync(userRole);
return(userRole);
}
public string InserirRole(UserRoleDto user)
{
var entity = _contexto.Users.FirstOrDefault(x => x.Id == user.Id);
entity.Role = user.Role;
_contexto.Users.Update(entity);
_contexto.SaveChanges();
return(MensagensErro.Alterar);
}
public async Task<ActionResult> Edit(UserEditDto model, FormCollection collection)
{
if (ModelState.IsValid)
{
try
{
using (var uow = _unitOfWorkManager.Begin())
{
model.IsActive = true;
await _userAppService.UpdateUser(model);
var roles = await _roleAppService.GetRoles(new GetRolesInput());
var list = new List<UserRoleDto>();
foreach (var item in roles.Items)
{
var info = new UserRoleDto();
var chkName = "Role_" + item.Id;
var chkVal = collection[chkName];
var userRole = "UserRole_" + item.Id;
Guid userRoleId;
var status = Guid.TryParse(collection[userRole], out userRoleId);
if (status)
info.Id = userRoleId;
if (chkVal == "on")
{
info.RoleId = item.Id;
info.UserId = model.Id;
info.Status = true;
list.Add(info);
}
else
{
info.RoleId = item.Id;
info.UserId = model.Id;
info.Status = false;
if (status)
list.Add(info);
}
}
await _userAppService.CreateOrUpdate(list);
await uow.CompleteAsync();
}
var lang = string.Format(L("Updated.RecordSucceed").Localize(), model.UserName);
this.AddModelMessage("", lang, MessageTypes.Information);
}
catch (Exception ex)
{
this.AddModelMessage("exception", ex.Message);
}
}
return RedirectToAction("Index");
}
