public async Task <IActionResult> PostRole(string app, [FromBody] AddRoleDto request)
{
var command = request.ToCommand();
var context = await CommandBus.PublishAsync(command);
return(NoContent());
}
private async Task SynchronizeRolesAsync(AppModel model, SyncOptions options, ISession session)
{
var current = await session.Apps.GetRolesAsync(session.App);
if (options.Delete)
{
foreach (var role in current.Items)
{
if (model.Roles.ContainsKey(role.Name) ||
role.IsDefaultRole ||
role.NumClients > 0 ||
role.NumContributors > 0)
{
continue;
}
await log.DoSafeAsync($"Role '{role.Name}' deleting", async() =>
{
await session.Apps.DeleteRoleAsync(session.App, role.Name);
});
}
}
foreach (var(roleName, _) in model.Roles)
{
var existing = current.Items.Find(x => x.Name == roleName);
if (existing != null)
{
continue;
}
await log.DoSafeAsync($"Role '{roleName}' creating", async() =>
{
var request = new AddRoleDto {
Name = roleName
};
current = await session.Apps.PostRoleAsync(session.App, request);
});
}
foreach (var(roleName, role) in model.Roles)
{
var existing = current.Items.Find(x => x.Name == roleName);
if (existing == null || existing.IsDefaultRole)
{
continue;
}
await log.DoSafeAsync($"Role '{roleName}' updating", async() =>
{
var request = role.ToUpdate();
await session.Apps.PutRoleAsync(session.App, roleName, request);
});
}
}
public async Task <IActionResult> PostRole(string app, [FromBody] AddRoleDto request)
{
var command = request.ToCommand();
var response = await InvokeCommandAsync(command);
return(CreatedAtAction(nameof(GetRoles), new { app }, response));
}
public async Task <JsonResult> Add(AddRoleDto model)
{
var result = await _roleAppService.AddAsync(model);
OutputModel outputModel = new OutputModel();
outputModel.Data = result;
return(new JsonResult(outputModel));
}
public async Task AddRoleAsyncTest()
{
var addRoleDto = new AddRoleDto
{
Name = DefaultApplicationRoles.Basic
};
var rs = await _roleService.AddRoleAsync(addRoleDto);
Assert.AreEqual(true, rs.Succeeded);
}
public async Task <ActionResult> AddDepartment([FromBody] AddRoleDto roleDto)
{
if (!IsAvailableOperation())
{
return(BadRequest());
}
await _roleService.Add(roleDto);
AddLog(Enums.LogType.Create, LogMessage.CreateSuccessByNameMessage(LogMessage.RoleEntityName, roleDto.Name, LogMessage.CreateAction, UserId));
return(Ok());
}
public IActionResult Post([FromBody] AddRoleDto dto)
{
try
{
_addRoleCommand.Execute(dto);
return(StatusCode(201, "Successfully added a new role."));
}
catch
{
return(StatusCode(422, "Error while trying to add a new role."));
}
}
private async Task <RoleDto> CreateRoleAsync(string name)
{
var createRequest = new AddRoleDto
{
Name = name
};
var roles = await _.Apps.PostRoleAsync(_.AppName, createRequest);
var role = roles.Items.Find(x => x.Name == name);
return(role);
}
public async Task <Response <string> > AddRoleAsync(AddRoleDto addRoleDto)
{
if (await _roleManager.GetRoleAsync(addRoleDto.Name) != null)
{
return(Response <string> .Fail("The role already exists. Please try a different one!"));
}
var appRole = _mapper.Map <ApplicationRole>(addRoleDto);
var rs = await _roleManager.AddRoleAsync(appRole);
return(rs.Succeeded
? Response <string> .Success(appRole.Id, "New role has been created")
: Response <string> .Fail("Failed to create new role"));
}
public IActionResult Put(int id, [FromBody] AddRoleDto dto)
{
try
{
dto.Id = id;
_editRoleCommand.Execute(dto);
return(StatusCode(204, "Successfully updated user."));
}
catch
{
return(StatusCode(422, "Error while trying to update user."));
}
}
public async Task AddRole(AddRoleDto data)
{
var user = _userManager.FindByNameAsync(data.UserName).Result;
if (user == null)
{
throw new ValidationException($"User: {data.UserName} is not found.");
}
await EnsureRoleIsExists(data.RoleName);
await _userManager.AddToRoleAsync(user, data.RoleName);
}
public void Execute(AddRoleDto request)
{
if (Context.Roles.Any(r => r.Name == request.Name))
{
throw new EntityAlreadyExistsException();
}
Context.Roles.Add(new Role
{
Name = request.Name
});
Context.SaveChanges();
}
public async Task <ActionResult <RoleDto> > AddRole(AddRoleDto addRole)
{
addRole.ThrowBusinessExceptionIfNull("AddRole was null");
addRole.Role.ThrowBusinessExceptionIfNull("Role was null");
if (!addRole.PermissionIds.Any())
{
throw new BusinessLayerException("Permission Ids was empty");
}
var entity = addRole.Role.Adapt <Role>();
var createdRole = await RoleService.AddRole(entity, addRole.PermissionIds);
return(Ok(createdRole.Adapt <RoleDto>()));
}
public IActionResult Post([FromBody] AddRoleDto dto
, [FromServices] IAddRoleCommand command
, [FromServices] AddRoleValidator addRoleValidator)
{
var result = addRoleValidator.Validate(dto);
if (result.IsValid)
{
Role role = _mapper.Map <Role>(dto);
_useCaseExecutor.ExecuteCommand(command, role);
return(Ok("Role created successfully"));
}
return(UnprocessableEntity(UnprocessableEntityResponse.Message(result.Errors)));
}
public async Task <IActionResult> PostRoleAsync([FromBody] AddRoleDto dto)
{
string openId = GetOpenId();
try
{
await _roleServices.PostRoleAsync(dto, openId);
return(AddSuccessMsg());
}
catch (Exception err)
{
_logger.Error(typeof(SettingController), "添加角色失败!", new Exception(err.Message));
return(FailedMsg("添加角色失败！" + err.Message));
}
}
public async Task <IActionResult> Add(AddRoleDto addRoleDto)
{
if (!ModelState.IsValid)
{
return(View(addRoleDto));
}
var rs = await _roleService.AddRoleAsync(addRoleDto);
if (rs.Succeeded)
{
return(RedirectToAction("Index", "Role",
new { area = "Admin", id = rs.Data, succeeded = rs.Succeeded, message = rs.Message }));
}
ModelState.AddModelError(string.Empty, rs.Message);
return(View(addRoleDto));
}
/// <summary>
/// 修改角色
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <HeaderResult <string> > EditRole(AddRoleDto input)
{
var role = await _roleRepository.WhereLoadEntityAsync(e => e.Id == input.RoleId);
role?.EditRole(input.RoleName, input.RoleType, input.RoleDescription);
_roleRepository.UpdateEntity(role);
await _roleRepository.CommitAsync();
HeaderResult <string> result = new HeaderResult <string>
{
IsSucceed = true,
Message = "修改成功!"
};
return(result);
}
public void Execute(AddRoleDto request)
{
var role = Context.Roles.Find(request.Id);
if (role == null)
{
throw new EntityNotFoundException();
}
if (request.Name != role.Name && Context.Roles.Any(r => r.Name == request.Name))
{
throw new EntityAlreadyExistsException();
}
role.Name = request.Name;
Context.SaveChanges();
}
public async Task <IActionResult> AddRole(AddRoleDto addRole)
{
try
{
var add = await mediator.Send(new CreateRoleCommand(addRole.Name, addRole.Description));
if (add.Success)
{
return(Ok(_localizer[RoleControllerShared.AddSuccessRole].Value));
}
return(BadRequest(add.ErrorMessage));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task Add(AddRoleDto roleDto)
{
var role = await _roleManager.Roles.FirstOrDefaultAsync(x => x.Name.Equals(roleDto.Name) && x.IsActive);
if (role != null)
{
throw new FoundSameObjectException("Role", roleDto.Name);
}
role = new Role {
Name = roleDto.Name,
RoleType = Enums.RoleType.Employee,
IsActive = true
};
var result = await _roleManager.CreateAsync(role);
if (!result.Succeeded)
{
throw new RoleManagerException("add", role.Name);
}
}
/// <summary>
/// 添加角色
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <HeaderResult <string> > AddRole(AddRoleDto input)
{
var roleInfo = await _roleRepository.LoadEntityMaxSortAsync(e => e.RoleShot);
var shotIndex = 1;
if (roleInfo != null)
{
shotIndex = roleInfo.RoleShot + 1;
}
var userRoleEntity = new RoleInfo().CreateRole(input.RoleName, input.RoleType, input.RoleDescription, shotIndex);
await _roleRepository.AddEntityAsync(userRoleEntity);
await _roleRepository.CommitAsync();
HeaderResult <string> result = new HeaderResult <string>
{
IsSucceed = true,
Message = "添加成功!"
};
return(result);
}
/// <summary>
/// 添加角色
/// </summary>
/// <param name="dto"></param>
/// <param name="openId"></param>
/// <returns></returns>
public async Task <bool> PostRoleAsync(AddRoleDto dto, string openId)
{
if (dto.TeamId == null)
{
throw new Exception("团队Id为空！");
}
var UserId = db.Queryable <Wx_UserInfo>().Where(a => a.OpenId == openId).First()?.ID; //找到UserId
Role role = iMapper.Map <Role>(dto);
role.ID = IdHelper.CreateGuid();
role.CreatorUserId = UserId;
role.IsDeleted = false;
role.IsEnabled = true;
return(await Task.Run(() =>
{
var result = db.Insertable(role).ExecuteCommand();
return result > 0;
}));
}
public async Task AddRole()
{
var roleDto = new RoleDto
{
Description = "Super Role",
Name = "Super Super"
};
var addRoleDto = new AddRoleDto()
{
Role = roleDto,
PermissionIds = new List <int> {
1
}
};
var controllerResult = await _controller.AddRole(addRoleDto);
var response = HttpResponseTest.CheckForValid200HttpResponseAndReturnValue(controllerResult);
Assert.Equal(roleDto.Description, response.Description);
Assert.Equal(roleDto.Name, response.Name);
Assert.NotEqual(roleDto.Id, response.Id);
}
public async Task <HeaderResult <string> > EditRole([FromBody] AddRoleDto input)
{
return(await _userAppService.EditRole(input));
}
public void AddRole([FromBody] AddRoleDto addRoleDto)
{
this.personManagementRepository.AddRoleToPerson(addRoleDto.role, addRoleDto.PersonId);
}
/// <summary>
/// 添加角色
/// </summary>
/// <param name="dto"></param>
/// <param name="openId"></param>
/// <returns></returns>
public async Task <bool> PostRoleAsync(AddRoleDto dto, string openId)
{
return(await _roleDal.PostRoleAsync(dto, openId));
}
public async Task <IActionResult> AddRole([FromBody] AddRoleDto data)
{
await _userService.AddRole(data);
return(Ok());
}
public async Task Should_manage_roles()
{
// Use role name with hash to test previous bug.
var roleName = $"{Guid.NewGuid()}/1";
var roleClient = Guid.NewGuid().ToString();
var roleContributor1 = "*****@*****.**";
var roleContributor2 = "*****@*****.**";
// STEP 1: Add role.
var createRequest = new AddRoleDto {
Name = roleName
};
var roles_1 = await _.Apps.PostRoleAsync(_.AppName, createRequest);
var role_1 = roles_1.Items.Single(x => x.Name == roleName);
// Should return role with correct name.
Assert.Empty(role_1.Permissions);
// STEP 2: Update role.
var updateRequest = new UpdateRoleDto {
Permissions = new List <string> {
"a", "b"
}
};
var roles_2 = await _.Apps.PutRoleAsync(_.AppName, roleName, updateRequest);
var role_2 = roles_2.Items.Single(x => x.Name == roleName);
// Should return role with correct name.
Assert.Equal(updateRequest.Permissions, role_2.Permissions);
// STEP 3: Assign client and contributor.
await _.Apps.PostClientAsync(_.AppName, new CreateClientDto { Id = roleClient });
await _.Apps.PutClientAsync(_.AppName, roleClient, new UpdateClientDto { Role = roleName });
await _.Apps.PostContributorAsync(_.AppName, new AssignContributorDto { ContributorId = roleContributor1, Role = roleName, Invite = true });
await _.Apps.PostContributorAsync(_.AppName, new AssignContributorDto { ContributorId = roleContributor2, Role = roleName, Invite = true });
var roles_3 = await _.Apps.GetRolesAsync(_.AppName);
var role_3 = roles_3.Items.Single(x => x.Name == roleName);
// Should return role with correct number of users and clients.
Assert.Equal(1, role_3.NumClients);
Assert.Equal(2, role_3.NumContributors);
// STEP 4: Try to delete role.
var ex = await Assert.ThrowsAsync <SquidexManagementException <ErrorDto> >(() =>
{
return(_.Apps.DeleteRoleAsync(_.AppName, roleName));
});
Assert.Equal(400, ex.StatusCode);
// STEP 5: Remove after client and contributor removed.
var fallbackRole = "Developer";
await _.Apps.PutClientAsync(_.AppName, roleClient, new UpdateClientDto { Role = fallbackRole });
await _.Apps.PostContributorAsync(_.AppName, new AssignContributorDto { ContributorId = roleContributor1, Role = fallbackRole });
await _.Apps.PostContributorAsync(_.AppName, new AssignContributorDto { ContributorId = roleContributor2, Role = fallbackRole });
await _.Apps.DeleteRoleAsync(_.AppName, roleName);
var roles_4 = await _.Apps.GetRolesAsync(_.AppName);
// Should not return deleted role.
Assert.DoesNotContain(roles_4.Items, x => x.Name == roleName);
}
public async Task <Result> AddAsync(AddRoleDto dto)
{
return(await _roleService.Add(_mapper.Map <Rolepermission>(dto)));
}
