public async Task <string> GetTokenAsync(int id)
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(AuthorizationConstants.JwtSecretKey);
var user = await _userRepository.GetUserAsync(id);
var specification = new UserRoleFilterSpecification(id);
var role = _roleRepository.GetByIdAsync(_userRoleRepository.FirstOrDefaultAsync(specification).Result.RoleId).Result.Name;
var claims = new List <Claim> {
new Claim(ClaimTypes.NameIdentifier, id.ToString()),
new Claim(ClaimTypes.Name, user.FirstName + " " + user.LastName),
new Claim(ClaimTypes.Email, user.Email)
};
claims.Add(new Claim(ClaimTypes.Role, role));
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims.ToArray()),
IssuedAt = DateTime.UtcNow,
Issuer = "AdminProject",
Expires = DateTime.UtcNow.AddSeconds(_configuration.GetValue <int>("Tokens:Lifetime")),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
return(tokenHandler.WriteToken(token));
}
public async Task <UserRole> GetByIdAsync(int id, CancellationToken cancellationToken = default)
{
var specFilter = new UserRoleFilterSpecification(id);
var results = await _unitOfWork.UserRoleRepository.ListAsync(specFilter, null, cancellationToken);
if (cancellationToken.IsCancellationRequested)
{
throw new Exception("Cancellation token requested");
}
if (results?.Count > 0)
{
return(results[0]);
}
return(null);
}
public async Task <ActionResult> UpdateItemAsync([FromBody] UserRoleDTO userRoleDTO, CancellationToken cancellationToken)
{
var specFilter = new UserRoleFilterSpecification(userRoleDTO.Id.Value);
var rowCount = await _userRoleService.CountAsync(specFilter, cancellationToken);
if (rowCount == 0)
{
throw new EntityNotFoundException(nameof(UserRole), userRoleDTO.Id);
}
// bind to old item
var item = _mapper.Map <UserRole>(userRoleDTO);
var result = await _userRoleService.UpdateAsync(item, cancellationToken);
if (!result)
{
AssignToModelState(_userRoleService.Errors);
return(ValidationProblem());
}
return(CreatedAtAction(nameof(ItemByIdAsync), new { id = item.Id }, null));
}
public async Task <bool> UpdateAsync(UserRole entity, CancellationToken cancellationToken = default)
{
if (!ValidateBase(entity))
{
return(false);
}
// update header
AssignUpdater(entity);
await _unitOfWork.UserRoleRepository.ReplaceAsync(entity, entity.Id, cancellationToken);
if (cancellationToken.IsCancellationRequested)
{
throw new Exception("Cancellation token requested");
}
// ambil old data
var specFilter = new UserRoleFilterSpecification(entity.Id);
var oldEntities = await _unitOfWork.UserRoleRepository.ListAsync(specFilter, null, cancellationToken);
if (cancellationToken.IsCancellationRequested)
{
throw new Exception("Cancellation token requested");
}
var oldEntity = oldEntities.FirstOrDefault();
List <UserRoleDetail> oldEntityToBeDeleted = new List <UserRoleDetail>();
if (oldEntity.UserRoleDetails.Count > 0)
{
foreach (var item in oldEntity.UserRoleDetails)
{
oldEntityToBeDeleted.Add(item);
}
}
// smart update
if (entity.UserRoleDetails.Count > 0)
{
foreach (var item in entity.UserRoleDetails)
{
var hasUpdate = false;
if (oldEntity.UserRoleDetails.Count > 0)
{
var data = oldEntity.UserRoleDetails.SingleOrDefault(p => p.Id == item.Id);
if (data != null)
{
AssignUpdater(item);
await _unitOfWork.UserRoleDetailRepository.ReplaceAsync(item, item.Id, cancellationToken);
oldEntityToBeDeleted.Remove(data);
hasUpdate = true;
}
}
if (!hasUpdate)
{
oldEntity.AddOrReplaceRole(item);
}
}
}
if (oldEntityToBeDeleted.Count > 0)
{
foreach (var item in oldEntityToBeDeleted)
{
oldEntity.RemoveRole(item);
}
}
await _unitOfWork.UserRoleRepository.UpdateAsync(oldEntity);
await _unitOfWork.CommitAsync(cancellationToken);
return(true);
}
