public RoleResponseDto GetRoles()
{
RoleResponseDto roleResponseDto;
try
{
roleResponseDto = reportAuthentication.GetRoles();
roleResponseDto.ServiceResponseStatus = 1;
}
catch (SSException exception)
{
roleResponseDto = new RoleResponseDto
{
ServiceResponseStatus = 0,
ErrorMessage = exception.Message,
ErrorCode = exception.ExceptionCode
};
}
catch (Exception exception)
{
roleResponseDto = new RoleResponseDto
{
ServiceResponseStatus = 0,
ErrorCode = ExceptionAttributes.ExceptionCodes.InternalServerError,
ErrorMessage = exception.Message
};
}
return(roleResponseDto);
}
private static RoleResponseDto RolesMapper(List <RoleResponseModel> list, RoleResponseDto roleResponseDto)
{
Mapper.CreateMap <RoleResponseModel, RoleResponse>();
roleResponseDto.roleList =
Mapper.Map <List <RoleResponseModel>, List <RoleResponse> >(list);
return(roleResponseDto);
}
public RoleResponseDto GetRoles()
{
var response = new RoleResponseDto();
var model = authenticationRepository.GetRoles();
if (model != null)
{
response = RolesMapper((List <RoleResponseModel>)model.roleList, response);
}
return(response);
}
public async Task <IActionResult> FindRolesAsync([FromRoute] Guid scopeId)
{
List <Role> roles;
if (this.UserHasScope(ScopeScopes.Admin))
{
roles = await _getRolesService.GetByScopeIdAsync(scopeId);
}
else
{
roles = await _getRolesService.GetByScopeIdAsync(scopeId, this.GetUserId());
}
var found = roles.Select(r => RoleResponseDto.FromRole(r, false));
return(Ok(found));
}
public async Task <IActionResult> DeleteRoleRelationAsync([FromRoute] Guid userId, [FromRoute] Guid roleId)
{
List <Role> roles;
if (this.UserHasScope(UserScopes.Admin) || userId == this.GetUserId())
{
roles = await _deleteUserRoleRelationService.DeleteRoleRelationAsync(userId, roleId);
}
else
{
throw new ForbiddenException();
}
var remaining = roles.Select(r => RoleResponseDto.FromRole(r, false));
return(Ok(remaining));
}
public async Task <IActionResult> GetRolesAsync([FromRoute] Guid userId)
{
List <Role> roles;
if (this.UserHasScope(UserScopes.Admin) || userId == this.GetUserId())
{
roles = await _getRolesService.GetByUserIdAsync(userId);
}
else
{
throw new ForbiddenException();
}
var found = roles.Select(a => RoleResponseDto.FromRole(a, false));
return(Ok(found));
}
public async Task <IActionResult> GetRoles()
{
var data = await identityService.GetRoles();
if (data == null)
{
return(NotFound(new BaseResponse(false, 404, "Previous request data was not found")));
}
RoleResponseDto response = new RoleResponseDto()
{
Data = mapper.Map <IEnumerable <ApplicationRole>, IEnumerable <RoleDto> >(data),
TotalRecord = data.Count(),
IsSuccess = true,
StatusCode = (int)HttpStatusCode.OK,
ResponseMessage = "Request has been complited successfully"
};
return(Ok(response));
}
public async Task <ResponseDto <IEnumerable <RoleResponseDto> > > GetAll()
{
var roleModelList = new List <RoleResponseDto>();
var roles = _roleManager.Roles.ToList();
foreach (var role in roles)
{
var roleModel = new RoleResponseDto()
{
RoleId = role.Id, RoleName = role.Name
};
roleModelList.Add(roleModel);
}
return(new ResponseDto <IEnumerable <RoleResponseDto> >()
{
Data = roleModelList,
Success = true,
StatusCode = HttpStatusCode.OK,
});
}
public static ApplicationResponseDto FromApplication(Application application, bool includeChildren)
{
var dto = new ApplicationResponseDto
{
application_id = application.ApplicationId,
name = application.Name,
description = application.Description,
type = application.Type,
homepage_uri = application.HomepageUri,
redirect_uri = application.RedirectUri,
client_id = application.ClientId,
user_id = application.UserId,
created_date = application.CreatedDateTime,
modified_date = application.ModifiedDateTime
};
if (includeChildren)
{
dto.roles = application.Roles?.Select(r =>
RoleResponseDto.FromRole(r, true)).ToList();
}
return(dto);
}
