public static RoleClaim ToModel(this RoleClaimRequest roleClaimContract)
{
return(new RoleClaim {
RoleId = roleClaimContract.RoleId.Value,
ClaimId = roleClaimContract.ClaimId.Value
});
}
public void Create(RoleClaimRequest request)
{
var claim = new RoleClaim
{
ClaimType = request.ClaimType,
RoleId = request.RoleId,
ClaimValue = request.ClaimValue
};
_roleClaimRepository.Add(claim);
}
public void Remove(RoleClaimRequest request)
{
var claim = new RoleClaim
{
ClaimType = request.ClaimType,
RoleId = request.RoleId,
ClaimValue = request.ClaimValue,
Id = request.Id
};
_roleClaimRepository.Delete(claim);
}
public async Task <Result <string> > SaveAsync(RoleClaimRequest request)
{
if (string.IsNullOrWhiteSpace(request.RoleId))
{
return(await Result <string> .FailAsync(_localizer["Role is required."]));
}
if (request.Id == 0)
{
var existingRoleClaim =
await _db.RoleClaims
.SingleOrDefaultAsync(x =>
x.RoleId == request.RoleId && x.ClaimType == request.Type && x.ClaimValue == request.Value);
if (existingRoleClaim != null)
{
return(await Result <string> .FailAsync(_localizer["Similar Role Claim already exists."]));
}
var roleClaim = _mapper.Map <BlazorHeroRoleClaim>(request);
await _db.RoleClaims.AddAsync(roleClaim);
await _db.SaveChangesAsync(_currentUserService.UserId);
return(await Result <string> .SuccessAsync(string.Format(_localizer["Role Claim {0} created."], request.Value)));
}
else
{
var existingRoleClaim =
await _db.RoleClaims
.Include(x => x.Role)
.SingleOrDefaultAsync(x => x.Id == request.Id);
if (existingRoleClaim == null)
{
return(await Result <string> .SuccessAsync(_localizer["Role Claim does not exist."]));
}
else
{
existingRoleClaim.ClaimType = request.Type;
existingRoleClaim.ClaimValue = request.Value;
existingRoleClaim.Group = request.Group;
existingRoleClaim.Description = request.Description;
existingRoleClaim.RoleId = request.RoleId;
_db.RoleClaims.Update(existingRoleClaim);
await _db.SaveChangesAsync(_currentUserService.UserId);
return(await Result <string> .SuccessAsync(string.Format(_localizer["Role Claim {0} for Role {1} updated."], request.Value, existingRoleClaim.Role.Name)));
}
}
}
public async Task <IActionResult> Create([FromBody] RoleClaimRequest newRoleClaim)
{
if ((await _authorizationService.AuthorizeAsync(User, newRoleClaim.RoleId, HttpContext.ScopeItems(ClaimScope.Role))).Succeeded)
{
var role = _roleController.GetById(newRoleClaim.RoleId.Value);
if (!role.Default)
{
var claimScope = _claimController.Get(newRoleClaim.ClaimId.Value).ClaimScope;
if (role.ClaimScope == claimScope)
{
var claims = _actorClaimController.GetActorClaims(int.Parse(User.Identity.Name)).Select(c => c.ClaimId);
if (claims.Contains(newRoleClaim.ClaimId.Value))
{
var roleClaim = newRoleClaim.ToModel();
_roleClaimCoreController.Create(roleClaim);
var roleContract = roleClaim.ToContract();
return(new ObjectResult(roleContract));
}
}
}
}
return(Forbid());
}
public override Task AddClaimAsync(TRole role, Claim claim, CancellationToken cancellationToken = default)
{
ThrowIfDisposed();
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
if (claim == null)
{
throw new ArgumentNullException(nameof(claim));
}
var roleClaim = CreateRoleClaim(role, claim);
var roleClaimRequest = new RoleClaimRequest
{
ClaimType = roleClaim.ClaimType,
ClaimValue = roleClaim.ClaimValue,
RoleId = roleClaim.RoleId
};
_roleClaimService.Create(roleClaimRequest);
return(Task.FromResult(false));
}
public Task <RoleClaim> CreateAsync(RoleClaimRequest request)
{
return(CommonOperationAsync(async() =>
{
var result = Mapper.Map <RoleClaim>(request);
/******************References Table Check Values****************/
/***************************************************************/
(await _uow.Applications.GetByIdAsync(result.ApplicationId)).CheckRecordIsExist(typeof(Application).Name);
(await _uow.Roles.GetByIdAsync(result.RoleId)).CheckRecordIsExist(typeof(Role).Name);
(await _uow.Claims.GetByIdAsync(result.ClaimId)).CheckRecordIsExist(typeof(Claim).Name);
/***************************************************************/
/***************************************************************/
var tempResult = await _uow.RoleClaims.GetByApplicationIdAndRoleIdAndClaimIdAsync(result.ApplicationId, result.RoleId, result.ClaimId);
tempResult.CheckUniqueValue(GetType().Name);
_uow.RoleClaims.Add(result, GetLoggedInUserId());
await _uow.SaveChangesAsync();
return result;
}, new BusinessBaseRequest {
MethodBase = MethodBase.GetCurrentMethod()
}));
}
public async Task <IResult <string> > SaveAsync(RoleClaimRequest role)
{
var response = await _httpClient.PostAsJsonAsync(Routes.RoleClaimsEndpoints.Save, role);
return(await response.ToResult <string>());
}
public void Remove(RoleClaimRequest request)
{
_roleClaimRepository.Remove(request);
}
public void Create(RoleClaimRequest request)
{
_roleClaimRepository.Create(request);
}
public async Task <IActionResult> Post(RoleClaimRequest request)
{
var response = await _roleClaimService.SaveAsync(request);
return(Ok(response));
}
