/// <summary>
/// The background task started by dotnet core framework
/// </summary>
/// <param name="stoppingToken">Token used when stopping the application</param>
protected async override Task ExecuteAsync(CancellationToken stoppingToken)
{
while (false == stoppingToken.IsCancellationRequested)
{
// Get next tigger call information
var triggerCall = await _notificationQueue.DequeueAsync(stoppingToken);
try
{
// create new db context
using var scope = _serviceProvider.CreateScope();
// Create entry in history
ITriggerHistoryManager triggerHistoryManager = scope.ServiceProvider.GetRequiredService <ITriggerHistoryManager>();
await TriggerHistoryEntryAsync(triggerCall, triggerHistoryManager);
// evaludate notification rules and send messages
INotificationRulesManager notificationRulesManager = scope.ServiceProvider.GetRequiredService <INotificationRulesManager>();
await EvaluateNotificationRulesAsync(triggerCall, notificationRulesManager);
}
catch (Exception ex)
{
this._logger.LogError(ex, $"Error occurred executing {nameof(triggerCall)}.");
}
}
}
public HomeController(ILogger <HomeController> logger,
ITriggerHistoryManager triggerHistoryManager,
INotificationRulesManager notificationRulesManager,
INotificationHistoryManager notificationHistoryManager)
{
_logger = logger;
_triggerHistoryManager = triggerHistoryManager;
_notificationRulesManager = notificationRulesManager;
_notificationHistoryManager = notificationHistoryManager;
}
/// <summary>
/// Finds all notification rules for a trigger call and sends the notifications
/// </summary>
/// <param name="call">Trigger call</param>
/// <returns></returns>
private async Task EvaluateNotificationRulesAsync(TriggerCall call, INotificationRulesManager notificationRulesManager)
{
// Get all rules for the rigger
var triggerRules = await notificationRulesManager.GetRulesOwnedTiggerType(call.Type).ToListAsync();
// Apply filters
var filteredRules = _conditionEval.EvalFilterAsync(triggerRules, call.EnvironmentVars, call.Input);
// Send them notifications for each rule
await foreach (var rule in filteredRules)
{
// Send notifications in parallel
await RunRuleAsync(rule, call);
}
}
public RulesController(ILogger <RulesController> logger,
PncDbContext dbContect,
IAuthorizationService authorizationService,
UserManager <User> userManager,
RoleManager <Role> roleManager,
INotificationRulesManager notificationRulesManager,
ITriggerHistoryManager triggerHistoryManager)
{
_logger = logger;
_authorizationService = authorizationService;
_userManager = userManager;
_roleManager = roleManager;
_notificationRulesManager = notificationRulesManager;
_triggerHistoryManager = triggerHistoryManager;
}
public AdminController(ILogger <AdminController> logger,
UserManager <User> userManager,
RoleManager <Role> roleManager,
IAuthorizationService authorizationService,
ILdapService ldapService,
IAppSettingsManager appSettingsManager,
INotificationRulesManager rulesManager)
{
_logger = logger;
_userManager = userManager;
_roleManager = roleManager;
_authorizationService = authorizationService;
_ldapService = ldapService;
_appSettingsManager = appSettingsManager;
_rulesManager = rulesManager;
}
/// <summary>
/// Deletes a role (group) and all recipient entries for this group
/// </summary>
/// <param name="roleManager">UserManager instance</param>
/// <param name="id">ID of user to delete</param>
/// <param name="rulesManager">NotificationRulesManager instance</param>
/// <exception cref="System.Collections.Generic.KeyNotFoundException">Thrown when role is not found by ID</exception>
/// <exception cref="System.InvalidOperationException">Thrown when role can't be deleted</exception>
public static async Task DeleteByIdAsync(this RoleManager <Role> roleManager, string id, INotificationRulesManager rulesManager)
{
// Find user by ID
var role = await roleManager.FindByIdAsync(id);
if (role == null)
{
throw new KeyNotFoundException("Role was not found");
}
if (role.IsBuildIn)
{
throw new InvalidOperationException("Build-In groups can't be deleted");
}
// Delete rule recipielt entries
await rulesManager.DeleteRoleRecipientAsync(role);
// Delete role
if (!(await roleManager.DeleteAsync(role)).Succeeded)
{
throw new InvalidOperationException("Group can't be deleted");
}
}
/// <summary>
/// Deletes a user and all recipient entries for this user
/// </summary>
/// <param name="userManager">UserManager instance</param>
/// <param name="id">ID of user to delete</param>
/// <param name="rulesManager">NotificationRulesManager instance</param>
/// <exception cref="System.InvalidOperationException">Thrown when user can't be deleted</exception>
public static async Task DeleteByIdAsync(this UserManager <User> userManager, string id, INotificationRulesManager rulesManager)
{
// Find user by ID
var user = await userManager.FindByIdAsync(id);
if (user == null)
{
throw new KeyNotFoundException("User was not found");
}
// Delete rule recipielt entries
await rulesManager.DeleteUserRecipientAsync(user);
// Delete user
if (!(await userManager.DeleteAsync(user)).Succeeded)
{
throw new InvalidOperationException("User can't be deleted");
}
}
