/// <summary>
/// Parameterized constructor
/// </summary>
/// <param name="actualsModifier">Actuals modifier</param>
/// <param name="targetRepository">Target repository</param>
/// <param name="dailyActualRepository">Daily actual repository</param>
/// <param name="monthlyActualRepository">Monthly actual repository</param>
/// <param name="goalCalculator">Scorecard goal calculator</param>
public RollupManager(ActualsModifier actualsModifier,
TargetModifier targetModifier,
IBaseRepository <Target> targetRepository,
IBaseRepository <DailyActual> dailyActualRepository,
IBaseRepository <MonthlyActual> monthlyActualRepository,
ScorecardGoalCalculator goalCalculator,
ScorecardRecordablesCalculator recordableCalculator)
{
this.actualsModifier = actualsModifier;
this.targetModifier = targetModifier;
this.targetRepository = targetRepository;
this.dailyActualRepository = dailyActualRepository;
this.monthlyActualRepository = monthlyActualRepository;
this.goalCalculator = goalCalculator;
this.recordablesCalculator = recordableCalculator;
}
public Permission(AccessModifier access, TargetModifier target)
{
TargetModifier = target;
AccessModifier = access;
}
public async Task <ActionResult> AddPermToRole(Guid roleId, AccessModifier access, TargetModifier target)
{
if (roleId.Equals(Guid.Empty))
{
return(this.BadRequest("Role Id is empty"));
}
try
{
await roleService.AddPermissionToRoleAsync(roleId, access, target);
return(Ok());
}
catch (ServiceException ex)
{
return(StatusCode((int)ex.ErrorCode, ex.Message));
}
catch (Exception ex)
{
await _logger.Error(ex.Message);
return(StatusCode(500, "Something went wrong"));
}
}
public async Task <bool> HasPermissionAsync(Guid userId, AccessModifier accessModifier, TargetModifier targetModifier)
{
bool isSuperAdmin = await _context.Set <Entities.UserRoles>()
.Include(ur => ur.Role)
.AnyAsync(ur => ur.Role.Name == AppRoles.SuperAdmin && ur.UserId == userId);
if (isSuperAdmin)
{
return(true);
}
return(await _context.Set <Entities.UserRoles>()
.Include(ur => ur.Role)
.ThenInclude(r => r.RolePermissions)
.ThenInclude(rp => rp.Permission)
.AnyAsync(userRole => userRole.UserId == userId &&
userRole.Role.RolePermissions.Any(rp =>
rp.Permission.AccessModifier.HasFlag(accessModifier) && rp.Permission.TargetModifier == targetModifier
)));
}
public TargetNodeView(Enum componentType) : base(componentType)
{
TargetModifier = (TargetModifier)componentType;
}
public async Task RemovePermissionFromRoleAsync(Guid roleId, AccessModifier access, TargetModifier target)
{
var rolePerm = await _context.Set <Entities.RolePermissions>()
.Include(rp => rp.Permission)
.FirstOrDefaultAsync(rp => rp.RoleId == roleId &&
rp.Permission.TargetModifier == target &&
rp.Permission.AccessModifier == access);
if (rolePerm == null)
{
throw new NotFoundException("Role not found");
}
var permId = rolePerm.PermissionId;
_context.Remove(rolePerm);
var hasAnyRoleWithPerm = await _context.Set <Entities.RolePermissions>()
.AnyAsync(rp => rp.PermissionId == permId);
if (!hasAnyRoleWithPerm)
{
_context.Remove(
await _context.FindAsync <Entities.Permission>(permId)
);
}
await _context.SaveChangesAsync();
}
public async Task AddPermissionToRoleAsync(Guid roleId, AccessModifier access, TargetModifier target)
{
var role = (await _context.FindAsync <Entities.Role>(roleId)) ?? throw new NotFoundException($"Role with Id: { roleId } not found");
var permission = await _context.Set <Entities.Permission>()
.FirstOrDefaultAsync(p => p.TargetModifier == target && p.AccessModifier == access);
if (permission != null)
{
await _context.AddAsync(
new Entities.RolePermissions
{
Permission = permission,
Role = role
}
);
}
else
{
permission = new Entities.Permission
{
AccessModifier = access,
CreatedAt = DateTime.UtcNow,
Id = Guid.NewGuid(),
TargetModifier = target,
UpdatedAt = DateTime.UtcNow
};
await _context.AddAsync(permission);
await _context.AddAsync(
new Entities.RolePermissions
{
Permission = permission,
Role = role
}
);
}
await _context.SaveChangesAsync();
}
public ColorComponent GetSourceForTarget(TargetModifier target)
{
return(CurrentSettings.First(s => s.Value == target).Key);
}
public void SetSourceForTarget(ColorComponent source, TargetModifier target)
{
CurrentSettings[source] = target;
}
