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