private async Task UpdateAllTenantPermission(CreateOrUpdateRoleInput input) { List <int> tenantId = new List <int>(); if (input.Role.DisplayName == StaticRoleNames.Host.Cruise) { tenantId = TenantManager.Tenants.IgnoreQueryFilters().Where(x => x.TenantType == MultiTenancy.Payments.TenantType.Cruise).Select(x => x.Id).ToList(); } else if (input.Role.DisplayName == StaticRoleNames.Host.Cruise) { tenantId = TenantManager.Tenants.IgnoreQueryFilters().Where(x => x.TenantType == MultiTenancy.Payments.TenantType.Ship).Select(x => x.Id).ToList(); } else if (input.Role.DisplayName == StaticRoleNames.Host.Cruise) { tenantId = TenantManager.Tenants.IgnoreQueryFilters().Where(x => x.TenantType == MultiTenancy.Payments.TenantType.Travel).Select(x => x.Id).ToList(); } foreach (var item in tenantId) { using (UnitOfWorkManager.Current.SetTenantId(item)) { var rolesAdmin = _roleManager.Roles.ToList(); foreach (var item2 in rolesAdmin) { var grantedPermissions = (await _roleManager.GetGrantedPermissionsAsync(item2)).Where(x => x.MultiTenancySides != Abp.MultiTenancy.MultiTenancySides.Host).ToArray(); var d = grantedPermissions.Where(x => input.GrantedPermissionNames.Any(z => z == x.Name)).Select(x => x.Name).ToList(); await UpdateGrantedPermissionsAsync(item2, d); } } } CurrentUnitOfWork.SaveChanges(); }
public async Task Should_Update_Role() { var testRole = await CreateAndGetTestRoleAsync(); var input = new CreateOrUpdateRoleInput { Role = new RoleDto { Id = testRole.Id, Name = "TestRoleName_Edited_" + Guid.NewGuid() }, GrantedPermissionIds = new List <Guid> { DefaultPermissions.MemberAccess.Id } }; var requestMessage = new HttpRequestMessage(HttpMethod.Put, "/api/roles"); requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", _token); requestMessage.Content = input.ToStringContent(Encoding.UTF8, "application/json"); var responseAddRole = await TestServer.CreateClient().SendAsync(requestMessage); Assert.Equal(HttpStatusCode.OK, responseAddRole.StatusCode); var dbContextFromAnotherScope = GetNewScopeServiceProvider().GetService <NucleusDbContext>(); var editedTestRole = await dbContextFromAnotherScope.Roles.FindAsync(testRole.Id); Assert.Contains(editedTestRole.RolePermissions, rp => rp.PermissionId == DefaultPermissions.MemberAccess.Id); }
public async Task Should_Create_Role() { var input = new CreateOrUpdateRoleInput { Role = new RoleDto { Name = "TestRoleName_" + Guid.NewGuid() }, GrantedPermissionIds = new List <Guid> { DefaultPermissions.MemberAccess.Id } }; var requestMessage = new HttpRequestMessage(HttpMethod.Post, "/api/roles"); requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", _token); requestMessage.Content = input.ToStringContent(Encoding.UTF8, "application/json"); var responseAddRole = await TestServer.CreateClient().SendAsync(requestMessage); Assert.Equal(HttpStatusCode.Created, responseAddRole.StatusCode); var insertedRole = await DbContext.Roles.FirstAsync(r => r.Name == input.Role.Name); Assert.NotNull(insertedRole); }
protected virtual async Task UpdateRoleAsync(CreateOrUpdateRoleInput input) { var entity = await _roleManager.GetRoleByIdAsync(input.Role.Id.Value); ObjectMapper.Map(input.Role, entity); CurrentUnitOfWork.SaveChanges(); await UpdateGrantedPermissionsAsync(entity, input.GrantedPermissionNames); }
private async Task UpdateRoleAsync(CreateOrUpdateRoleInput input) { Debug.Assert(input.Role.Id != null, "input.Role.Id should be set."); var role = await _roleManager.GetRoleByIdAsync(input.Role.Id.Value); role.DisplayName = input.Role.DisplayName; role.IsDefault = input.Role.IsDefault; await UpdateGrantedPermissionsAsync(role, input.GrantedPermissionNames); }
public virtual async Task Update(CreateOrUpdateRoleInput input) { if (!input.EntityDto.Id.HasValue) { return; } await _roleManager.UpdateAsync(input.EntityDto.Id, input.EntityDto.DisplayName, input.EntityDto.Description, input.Permissions?.ToArray()); }
public virtual async Task Create(CreateOrUpdateRoleInput input) { await _roleManager.CreateAsync( input.EntityDto.Name, input.EntityDto.DisplayName, input.EntityDto.Description, permissions : input.Permissions?.ToArray() ); }
/// <summary> /// 新增角色 /// </summary> public async Task <RoleEditDto> CreateAsync(CreateOrUpdateRoleInput input) { //TODO: 新增前的逻辑判断,是否允许新增 var entity = input.RoleEditDto.MapTo <Role>(); entity = await _roleRepository.InsertAsync(entity); return(entity.MapTo <RoleEditDto>()); }
protected virtual async Task UpdateRoleAsync(CreateOrUpdateRoleInput input) { RoleManager roleManager = this._roleManager; int? id = input.Role.Id; Role roleByIdAsync = await roleManager.GetRoleByIdAsync(id.Value); roleByIdAsync.DisplayName = input.Role.DisplayName; roleByIdAsync.IsDefault = input.Role.IsDefault; await this.UpdateGrantedPermissionsAsync(roleByIdAsync, input.GrantedPermissionNames); }
/// <summary> /// 更新角色 /// </summary> public async Task UpdateAsync(CreateOrUpdateRoleInput input) { //TODO: 更新前的逻辑判断,是否允许更新 var entity = await _roleRepository.GetAsync(input.RoleEditDto.Id.Value); input.RoleEditDto.MapTo(entity); await _roleRepository.UpdateAsync(entity); }
public async Task CreateOrUpdateRole(CreateOrUpdateRoleInput input) { if (input.Role.Id.HasValue) { await UpdateRoleAsync(input); } else { await CreateRoleAsync(input); } }
/// <summary> /// 新增或编辑角色 /// </summary> /// <param name="input"></param> /// <returns></returns> public async Task <EntityDto> CreateOrUpdateRole(CreateOrUpdateRoleInput input) { if (input.Item.Id.HasValue) { return(await UpdateRoleAsync(input)); } else { return(await CreateRoleAsync(input)); } }
public async Task <int> CreateOrUpdateRole(CreateOrUpdateRoleInput input) { if (input.Role.Id.HasValue) { return(await UpdateRoleAsync(input)); } else { return(await CreateRoleAsync(input)); } }
public async Task <ActionResult> PutRoles([FromBody] CreateOrUpdateRoleInput input) { var identityResult = await _roleAppService.EditRoleAsync(input); if (identityResult.Succeeded) { return(Ok()); } return(BadRequest(identityResult.Errors.Select(e => new NameValueDto(e.Code, e.Description)))); }
protected virtual async Task CreateRoleAsync(CreateOrUpdateRoleInput input) { var role = new Role(AbpSession.TenantId, input.Role.DisplayName) { IsDefault = input.Role.IsDefault }; CheckErrors(await _roleManager.CreateAsync(role)); await CurrentUnitOfWork.SaveChangesAsync(); //It's done to get Id of the role. await UpdateGrantedPermissionsAsync(role, input.GrantedPermissionNames); }
protected virtual async Task <EntityDto> UpdateRoleAsync(CreateOrUpdateRoleInput input) { //Debug.Assert(input.Role.Id != null, "input.Role.Id should be set."); var role = await _roleManager.GetRoleByIdAsync(input.Item.Id.Value); role.DisplayName = input.Item.DisplayName; role.IsDefault = input.Item.IsDefault; await UpdateGrantedPermissionsAsync(role, input.GrantedPermissionNames); return(new EntityDto(role.Id)); }
/// <summary> /// /// </summary> protected virtual async Task UpdateRoleAsync(CreateOrUpdateRoleInput input) { Debug.Assert(input.Role.Id != null, "角色id不可为null"); var role = await _roleManager.GetRoleByIdAsync(input.Role.Id.Value); role.DisplayName = input.Role.DisplayName; role.IsDefault = input.Role.IsDefault; role.IsActive = input.Role.IsActive; role.Description = input.Role.Description; await UpdateGrantedPermissionsAsync(role, input.GrantedPermissionNames); }
public async Task <ActionResult> CreateOrUpdateRole([FromBody] CreateOrUpdateRoleInput input) { if (input.Role.Id == Guid.Empty) { await _roleAppService.AddRoleAsync(input); } else { await _roleAppService.EditRoleAsync(input); } return(Ok(new { success = true })); }
public async Task EditRoleAsync(CreateOrUpdateRoleInput input) { var role = await _roleManager.FindByIdAsync(input.Role.Id.ToString()); role.Name = input.Role.Name; role.RolePermissions.Clear(); var updateRoleResult = await _roleManager.UpdateAsync(role); if (updateRoleResult.Succeeded) { GrantPermissionsToRole(input.GrantedPermissionIds, role); } }
protected virtual async Task CreateRoleAsync(CreateOrUpdateRoleInput input) { Role role = new Role(this.AbpSession.TenantId, input.Role.DisplayName) { IsDefault = input.Role.IsDefault }; Role role1 = role; this.CheckErrors(await this._roleManager.CreateAsync(role1)); await this.CurrentUnitOfWork.SaveChangesAsync(); await this.UpdateGrantedPermissionsAsync(role1, input.GrantedPermissionNames); }
public async Task AddRoleAsync(CreateOrUpdateRoleInput input) { var role = new Role { Id = input.Role.Id, Name = input.Role.Name }; var createRoleResult = await _roleManager.CreateAsync(role); if (createRoleResult.Succeeded) { GrantPermissionsToRole(input.GrantedPermissionIds, role); } }
protected virtual async Task UpdateAsync(CreateOrUpdateRoleInput input) { Debug.Assert(input.Role.Id != null, "input.Role.Id != null"); var role = await _roleManager.GetRoleByIdAsync(input.Role.Id.Value); _mapper.Map(input.Role, role); CheckErrors(await _roleManager.UpdateAsync(role)); var grantedPermissions = PermissionManager .GetAllPermissions() .Where(p => input.GrantedPermissions.Contains(p.Name)) .ToList(); await _roleManager.SetGrantedPermissionsAsync(role, grantedPermissions); }
public async Task <RoleDto> Create(CreateOrUpdateRoleInput input) { CheckCreatePermission(); var role = ObjectMapper.Map <Role>(input.Role); CheckErrors(await _roleManager.CreateAsync(role)); var grantedPermissions = PermissionManager .GetAllPermissions() .Where(p => input.GrantedPermissionNames.Contains(p.Name)) .ToList(); await _roleManager.SetGrantedPermissionsAsync(role, grantedPermissions); return(MapToEntityDto(role)); }
protected virtual async Task CreateAsync(CreateOrUpdateRoleInput input) { var role = _mapper.Map <Role>(input.Role); role.SetNormalizedName(); CheckErrors(await _roleManager.CreateAsync(role)); if (input.GrantedPermissions.Any()) { var grantedPermissions = PermissionManager .GetAllPermissions() .Where(p => input.GrantedPermissions.Contains(p.Name)) .ToList(); await _roleManager.SetGrantedPermissionsAsync(role, grantedPermissions); } }
public async Task <ActionResult> CreateOrUpdateRole([FromBody] CreateOrUpdateRoleInput input) { IdentityResult identityResult; if (input.Role.Id == Guid.Empty) { identityResult = await _roleAppService.AddRoleAsync(input); } else { identityResult = await _roleAppService.EditRoleAsync(input); } if (identityResult.Succeeded) { return(Ok()); } return(BadRequest(identityResult.Errors.Select(e => new NameValueDto(e.Code, e.Description)))); }
public async Task UpdateUserPermissionsUnit(UserPermissionsInput input) { await _userRoleRepository.DeleteAsync(p => p.UserId == input.UserId); CreateOrUpdateRoleInput request = new CreateOrUpdateRoleInput(); request.Role = input.Role; request.GrantedPermissionNames = input.GrantedPermissionNames; int roleId = await _roleAppService.CreateRoleForUserAsync(request); UserRole userrole = new UserRole { RoleId = roleId, UserId = input.UserId.Value }; await _userRoleRepository.InsertAsync(userrole); await _unitOfWorkManager.Current.SaveChangesAsync(); }
public async void Should_Edit_Role() { var testRole = await CreateAndGetTestRoleAsync(); var input = new CreateOrUpdateRoleInput { Role = new RoleDto { Id = testRole.Id, Name = "TestRoleName_Edited_" + Guid.NewGuid() }, GrantedPermissionIds = new List <Guid> { DefaultPermissions.MemberAccess.Id } }; await _roleAppService.EditRoleAsync(input); var editedTestRole = await _dbContext.Roles.FindAsync(testRole.Id); Assert.Contains("TestRoleName_Edited_", editedTestRole.Name); Assert.Contains(editedTestRole.RolePermissions, rp => rp.PermissionId == DefaultPermissions.MemberAccess.Id); }
public async Task <IdentityResult> EditRoleAsync(CreateOrUpdateRoleInput input) { if (await _roleManager.RoleExistsAsync(input.Role.Name)) { return(IdentityResult.Failed(new IdentityError() { Code = "RoleNameAlreadyExist", Description = "Role name '" + input.Role.Name + "' is already taken!" })); } var role = await _roleManager.FindByIdAsync(input.Role.Id.ToString()); role.Name = input.Role.Name; role.RolePermissions.Clear(); var updateRoleResult = await _roleManager.UpdateAsync(role); if (updateRoleResult.Succeeded) { GrantPermissionsToRole(input.GrantedPermissionIds, role); } return(updateRoleResult); }
public async void Should_Add_Role() { var input = new CreateOrUpdateRoleInput { Role = new RoleDto { Id = Guid.NewGuid(), Name = "TestRoleName_" + Guid.NewGuid() }, GrantedPermissionIds = new List <Guid> { DefaultPermissions.MemberAccess.Id } }; await _roleAppService.AddRoleAsync(input); await _dbContext.SaveChangesAsync(); var dbContextFromAnotherScope = TestServer.Host.Services.GetRequiredService <NucleusDbContext>(); var insertedTestRole = await dbContextFromAnotherScope.Roles.FindAsync(input.Role.Id); Assert.NotNull(insertedTestRole); Assert.Equal(1, insertedTestRole.RolePermissions.Count); }
/// <summary> /// 更新角色记录 /// </summary> public async Task UpdateInfRole(CreateOrUpdateRoleInput input) { await UpdateRoleAsync(input); }