Created CertificationTrainingGroupWorker

FabApprovalWorkerService/Program.cs

@@ -91,13 +91,13 @@ builder.Services.AddQuartz(q => {
         .WithCronSchedule(CronScheduleBuilder.DailyAtHourAndMinute(6, 0))
     );
 
-    JobKey userCertJob = new JobKey("User certification job");
+    JobKey userCertJob = new JobKey("Certification training group job");
-    q.AddJob<UserCertificationWorker>(opts => opts
+    q.AddJob<CertificationTrainingGroupWorker>(opts => opts
         .WithIdentity(userCertJob)
     );
     q.AddTrigger(opts => opts
         .ForJob(userCertJob)
-        .WithIdentity("User certification trigger")
+        .WithIdentity("Certification training group trigger")
         .WithSimpleSchedule(x => x
             .WithIntervalInMinutes(10)
             .RepeatForever()

FabApprovalWorkerService/Services/TrainingService.cs

@@ -1,6 +1,9 @@
 using FabApprovalWorkerService.Models;
 
+using Microsoft.IdentityModel.Tokens;
+
 using System.Text;
+using System.Text.Json;
 
 namespace FabApprovalWorkerService.Services;
 
@@ -15,17 +18,42 @@ public interface ITrainingService {
     Task UpdateTrainingAssignmentLastNotification(int trainingAssignmentId);
     Task<int> GetEcnNumberByTrainingId(int trainingId);
     Task<IEnumerable<int>> GetTrainingAssignmentIdsByUserId(int userId);
+    Task<IEnumerable<UserCertificationRecord>> GetUserCertificationRecords();
+    Task<bool> UpdateTrainingGroupMembership(IEnumerable<UserCertificationRecord> certRecords);
 }
 
 public class TrainingService : ITrainingService {
     private ILogger<TrainingService> _logger;
     private IDalService _dalService;
+    private IUserService _userService;
 
-    public TrainingService(ILogger<TrainingService> logger, IDalService dalService) {
+    private readonly string _userCertRecordsFilePath;
+
+    private readonly string _cleansTrainingGroupName;
+    private readonly string _asmHtrTrainingGroupName;
+    private readonly string _epiProTrainingGroupName;
+    private readonly string _fqaTrainingGroupName;
+    private readonly string _packagingAndLabelingTrainingGroupName;
+
+    public TrainingService(ILogger<TrainingService> logger, IDalService dalService, IUserService userService) {
         _logger = logger ??
             throw new ArgumentNullException("ILogger not injected");
         _dalService = dalService ??
             throw new ArgumentNullException("IDalService not injected");
+        _userService = userService ??
+            throw new ArgumentNullException("IUserService not injected");
+        _userCertRecordsFilePath = Environment.GetEnvironmentVariable("UserCertificationRecordsFilePath") ??
+            throw new ArgumentNullException("UserCertificationRecordsFilePath environment variable not found");
+        _asmHtrTrainingGroupName = Environment.GetEnvironmentVariable("AsmHtrTrainingGroupName") ??
+            throw new ArgumentNullException("AsmHtrTrainingGroupName environment variable not found");
+        _cleansTrainingGroupName = Environment.GetEnvironmentVariable("CleansTrainingGroupName") ??
+            throw new ArgumentNullException("CleansTrainingGroupName environment variable not found");
+        _epiProTrainingGroupName = Environment.GetEnvironmentVariable("EpiProTrainingGroupName") ??
+            throw new ArgumentNullException("EpiProTrainingGroupName environment variable not found");
+        _fqaTrainingGroupName = Environment.GetEnvironmentVariable("FqaTrainingGroupName") ??
+            throw new ArgumentNullException("FqaTrainingGroupName environment variable not found");
+        _packagingAndLabelingTrainingGroupName = Environment.GetEnvironmentVariable("PackagingAndLabelingTrainingGroupName") ??
+            throw new ArgumentNullException("PackagingAndLabelingTrainingGroupName environment variable not found");
     }
 
     public async Task DeleteDocAssignment(int trainingAssignmentId) {
@@ -228,4 +256,142 @@ public class TrainingService : ITrainingService {
             throw;
         }
     }
+
+    public async Task<IEnumerable<UserCertificationRecord>> GetUserCertificationRecords() {
+        try {
+            _logger.LogInformation("Attempting to get user certification records");
+
+            string jsonUserCertRecords = await File.ReadAllTextAsync(_userCertRecordsFilePath);
+
+            IEnumerable<UserCertificationRecord>? records =
+                JsonSerializer.Deserialize<IEnumerable<UserCertificationRecord>>(jsonUserCertRecords);
+
+            if (records is null) throw new Exception("No user certification records found");
+
+            return records;
+        } catch (Exception ex) {
+            StringBuilder errMsgBuilder = new();
+            errMsgBuilder.Append("An exception occurred when attempting to get user certification records. ");
+            errMsgBuilder.Append($"Exception: {ex.Message}");
+            _logger.LogError(errMsgBuilder.ToString());
+            throw;
+        }
+    }
+
+    public async Task<bool> UpdateTrainingGroupMembership(IEnumerable<UserCertificationRecord> certRecords) {
+        try {
+            _logger.LogInformation("Attempting to update certification training group membership.");
+
+            if (certRecords.IsNullOrEmpty())
+                throw new ArgumentNullException("certRecords cannot be null or empty");
+
+            int asmHtrGroupId = await GetGroupId(_asmHtrTrainingGroupName);
+            await DeleteAllUsersFromTrainingGroup(asmHtrGroupId);
+
+            int epiProGroupId = await GetGroupId(_epiProTrainingGroupName);
+            await DeleteAllUsersFromTrainingGroup(epiProGroupId);
+
+            int fqaGroupId = await GetGroupId(_fqaTrainingGroupName);
+            await DeleteAllUsersFromTrainingGroup(fqaGroupId);
+
+            int packagingAndLabelingGroupId = await GetGroupId(_packagingAndLabelingTrainingGroupName);
+            await DeleteAllUsersFromTrainingGroup(packagingAndLabelingGroupId);
+
+            int cleansGroupId = await GetGroupId(_cleansTrainingGroupName);
+            await DeleteAllUsersFromTrainingGroup(cleansGroupId);
+            
+            List<Task> queryTasks = new();
+            foreach (UserCertificationRecord record in certRecords) {
+                if (record is not null) {
+                    User user = null;
+                    try {
+                        user = await _userService.GetUserByEmail(record.Email);
+                    } catch (Exception ex) {
+                        StringBuilder errMsgBuilder = new();
+                        errMsgBuilder.Append($"An exception occurred when attempting to get user for email {record.Email}. ");
+                        errMsgBuilder.Append($"Exception: {ex.Message}");
+                    }
+
+                    if (user is not null) {
+                        if (record.IsEpiProCertified) queryTasks.Add(AddUserToTrainingGroup(epiProGroupId, user));
+                        if (record.IsPackagingLabelingCertified) queryTasks.Add(AddUserToTrainingGroup(packagingAndLabelingGroupId, user));
+                        if (record.IsCleansCertified) queryTasks.Add(AddUserToTrainingGroup(cleansGroupId, user));
+                        if (record.IsFqaCertified) queryTasks.Add(AddUserToTrainingGroup(fqaGroupId, user));
+                        if (record.IsAnyLevelCertified) queryTasks.Add(AddUserToTrainingGroup(asmHtrGroupId, user));
+                    }
+                }
+            }
+
+            await Task.WhenAll(queryTasks);
+
+            return true;
+        } catch (Exception ex) {
+            StringBuilder errMsgBuilder = new();
+            errMsgBuilder.Append("An exception occurred when attempting to update certification training group membership. ");
+            errMsgBuilder.Append($"Exception: {ex.Message}");
+            _logger.LogError(errMsgBuilder.ToString());
+            throw;
+        }
+    }
+
+    private async Task<int> GetGroupId(string groupName) {
+        try {
+            _logger.LogInformation($"Attempting to get {groupName} training group ID");
+
+            StringBuilder queryBuilder = new();
+            queryBuilder.Append("select TrainingGroupID from TrainingGroups ");
+            queryBuilder.Append($"where TrainingGroupName = '{groupName}' collate SQL_Latin1_General_CP1_CI_AS;");
+
+            int groupId = (await _dalService.QueryAsync<int>(queryBuilder.ToString())).FirstOrDefault();
+
+            if (groupId <= 0)
+                throw new Exception($"{groupName} training group ID not found");
+
+            return groupId;
+        } catch (Exception ex) {
+            StringBuilder errMsgBuilder = new();
+            errMsgBuilder.Append($"An exception occurred when attempting to get {groupName} training group ID. ");
+            errMsgBuilder.Append($"Exception: {ex.Message}");
+            throw;
+        }
+    }
+
+    private async Task DeleteAllUsersFromTrainingGroup(int groupId) {
+        try {
+            _logger.LogInformation($"Attempting to delete all members of training group {groupId}");
+
+            if (groupId <= 0) throw new ArgumentException($"{groupId} not a valid training group ID");
+
+            string sql = $"delete from TrainingGroupMembers where TrainingGroupID = {groupId};";
+
+            await _dalService.ExecuteAsync(sql);
+        } catch (Exception ex) {
+            StringBuilder errMsgBuilder = new();
+            errMsgBuilder.Append($"An exception occurred when attempting to delete all members of training group {groupId}. ");
+            errMsgBuilder.Append($"Exception: {ex.Message}");
+            _logger.LogError(errMsgBuilder.ToString());
+            throw;
+        }
+    }
+
+    private async Task AddUserToTrainingGroup(int groupId, User user) {
+        try {
+            _logger.LogInformation($"Attempting to add user to training group {groupId}");
+
+            if (groupId <= 0) throw new ArgumentException($"{groupId} is not a valid training group Id");
+            if (user is null) throw new ArgumentNullException("User cannot be null");
+
+            StringBuilder queryBuilder = new();
+            queryBuilder.Append("insert into TrainingGroupMembers (TrainingGroupID, UserID, FullName) ");
+            queryBuilder.Append($"values ({groupId}, {user.UserID}, '{user.FirstName + " " + user.LastName}');");
+
+            await _dalService.ExecuteAsync(queryBuilder.ToString());
+        } catch (Exception ex) {
+            StringBuilder errMsgBuilder = new();
+            errMsgBuilder.Append($"An exception occurred when attempting to add user to training group {groupId}. ");
+            errMsgBuilder.Append($"Exception: {ex.Message}");
+            _logger.LogError(errMsgBuilder.ToString());
+            throw;
+        }
+    }
 }

FabApprovalWorkerService/Services/UserService.cs

@@ -3,7 +3,6 @@
 using Microsoft.IdentityModel.Tokens;
 
 using System.Text;
-using System.Text.Json;
 
 namespace FabApprovalWorkerService.Services;
 
@@ -23,8 +22,7 @@ public interface IUserService {
     Task<List<User>> GetAllExpiredOOOUsersAsync();
     Task<string> GetUserEmail(int userId);
     Task<User> GetUserById(int userId);
-    Task<IEnumerable<UserCertificationRecord>> GetUserCertificationRecords();
+    Task<User> GetUserByEmail(string email);
-    Task<bool> UpdateUserCertificationData(IEnumerable<UserCertificationRecord> certRecords);
 }
 
 public class UserService : IUserService {
@@ -34,8 +32,6 @@ public class UserService : IUserService {
     private readonly ILogger<UserService> _logger;
     private readonly IDalService _dalService;
 
-    private readonly string _userCertRecordsFilePath;
-
     public UserService(ILogger<UserService> logger, IDalService dalService) {
         _logger = logger;
         if (_logger is null)
@@ -44,9 +40,6 @@ public class UserService : IUserService {
         _dalService = dalService;
         if (_dalService is null)
             throw new ArgumentNullException("IDalService not injected");
-
-        _userCertRecordsFilePath = Environment.GetEnvironmentVariable("UserCertificationRecordsFilePath") ??
-            throw new ArgumentNullException("UserCertificationRecordsFilePath environment variable not found");
     }
 
     public async Task<List<User>> GetAllExpiredOOOUsersAsync() {
@@ -397,63 +390,30 @@ public class UserService : IUserService {
             return user;
         } catch (Exception ex) {
             StringBuilder errMsgBuilder = new();
-            errMsgBuilder.Append($"An exception occurred when attempting to get email for user {userId}. ");
+            errMsgBuilder.Append($"An exception occurred when attempting to get user {userId}. ");
             errMsgBuilder.Append($"Exception: {ex.Message}");
             _logger.LogError(errMsgBuilder.ToString());
             throw;
         }
     }
 
-    public async Task<IEnumerable<UserCertificationRecord>> GetUserCertificationRecords() {
+    public async Task<User> GetUserByEmail(string email) {
         try {
-            _logger.LogInformation("Attempting to get user certification records");
+            _logger.LogInformation($"Attempting to get user by email");
 
-            string jsonUserCertRecords = await File.ReadAllTextAsync(_userCertRecordsFilePath);
+            if (email.IsNullOrEmpty()) throw new ArgumentException("Email cannot be null or empty");
 
-            IEnumerable<UserCertificationRecord>? records =
+            string sql = $"select * from Users where Email = '{email}' collate SQL_Latin1_General_CP1_CI_AS;";
-                JsonSerializer.Deserialize<IEnumerable<UserCertificationRecord>>(jsonUserCertRecords);
 
-            if (records is null) throw new Exception("No user certification records found");
+            User? user = (await _dalService.QueryAsync<User>(sql)).FirstOrDefault();
 
-            return records;
+            if (user is null)
+                throw new Exception($"No user found for email {email}");
+
+            return user;
         } catch (Exception ex) {
             StringBuilder errMsgBuilder = new();
-            errMsgBuilder.Append("An exception occurred when attempting to get user certification records. ");
+            errMsgBuilder.Append("An exception occurred when attempting to get user by email. ");
-            errMsgBuilder.Append($"Exception: {ex.Message}");
-            _logger.LogError(errMsgBuilder.ToString());
-            throw;
-        }
-    }
-
-    public async Task<bool> UpdateUserCertificationData(IEnumerable<UserCertificationRecord> certRecords) {
-        try {
-            _logger.LogInformation("Attempting to update user certification data");
-
-            if (certRecords.IsNullOrEmpty())
-                throw new ArgumentNullException("certRecords cannot be null or empty");
-
-            List<Task> queryTasks = new();
-            foreach (UserCertificationRecord record in certRecords) {
-                StringBuilder queryBuilder = new();
-                queryBuilder.Append("update Users ");
-                queryBuilder.Append($"set IsCleansCertified = {Convert.ToInt32(record.IsCleansCertified)}, ");
-                queryBuilder.Append($"IsAnyLevelCertified = {Convert.ToInt32(record.IsAnyLevelCertified)}, ");
-                queryBuilder.Append($"IsPackagingLabelingCertified = {Convert.ToInt32(record.IsPackagingLabelingCertified)}, ");
-                queryBuilder.Append($"IsEpiProCertified = {Convert.ToInt32(record.IsEpiProCertified)}, ");
-                queryBuilder.Append($"IsFqaCertified = {Convert.ToInt32(record.IsFqaCertified)}, ");
-                queryBuilder.Append($"IsFqaAssessmentCertified = {Convert.ToInt32(record.IsFqaAssessmentCertified)} ");
-                queryBuilder.Append($"where Email = '{record.Email}' collate SQL_Latin1_General_CP1_CI_AS;");
-
-                queryTasks.Add(_dalService.ExecuteAsync(queryBuilder.ToString()));
-            }
-
-            await Task.WhenAll(queryTasks);
-
-            return true;
-
-        } catch (Exception ex) {
-            StringBuilder errMsgBuilder = new();
-            errMsgBuilder.Append("An exception occurred when attempting to update user certification data. ");
             errMsgBuilder.Append($"Exception: {ex.Message}");
             _logger.LogError(errMsgBuilder.ToString());
             throw;

FabApprovalWorkerService/Services/WindowsService.cs

@@ -30,7 +30,7 @@ public class WindowsService : BackgroundService {
         } catch (OperationCanceledException) {
             _logger.LogError("The Windows service has been stopped");
 
-            _monInClient.PostStatus("WindowsService", State.Critical);
+            _monInClient.PostStatus("WindowsService", State.Ok);
         } catch (Exception ex) {
             _logger.LogError($"An exception occurred when running Windows Service. Exception: {ex.Message}");
 

FabApprovalWorkerService/Workers/CertificationTrainingGroupWorker.cs

@@ -9,26 +9,26 @@ using System.Text;
 
 namespace FabApprovalWorkerService.Workers;
 
-public class UserCertificationWorker : IJob {
+public class CertificationTrainingGroupWorker : IJob {
     private static readonly int MAX_RETRIES = 3;
     private static readonly int BACKOFF_SECONDS = 30;
     
-    private readonly ILogger<UserCertificationWorker> _logger;
+    private readonly ILogger<CertificationTrainingGroupWorker> _logger;
-    private readonly IUserService _userService;
+    private readonly ITrainingService _trainingService;
     private readonly IMonInClient _monInClient;
 
-    public UserCertificationWorker(ILogger<UserCertificationWorker> logger,
+    public CertificationTrainingGroupWorker(ILogger<CertificationTrainingGroupWorker> logger,
-                                   IUserService userService,
+                                   ITrainingService trainingService,
                                    IMonInClient monInClient) {
         _logger = logger ?? throw new ArgumentNullException("ILogger not injected");
-        _userService = userService ?? throw new ArgumentNullException("IUserService not injected");
+        _trainingService = trainingService ?? throw new ArgumentNullException("ITrainingService not injected");
         _monInClient = monInClient ?? throw new ArgumentNullException("IMonInClient not injected");
     }
 
     public async Task Execute(IJobExecutionContext context) {
         DateTime start = DateTime.Now;
         bool isInternalError = false;
-        string metricName = "UserCertificationWorker";
+        string metricName = "CertificationTrainingGroupWorker";
 
         try {
             int remainingRetries = MAX_RETRIES;
@@ -37,20 +37,20 @@ public class UserCertificationWorker : IJob {
             while (!isSuccessful && remainingRetries > 0) {
                 await Task.Delay((MAX_RETRIES - remainingRetries--) * BACKOFF_SECONDS);
 
-                _logger.LogInformation($"Attempting to update user certification data. Remaining retries: {remainingRetries}");
+                _logger.LogInformation($"Attempting to update certification training group membership. Remaining retries: {remainingRetries}");
 
-                IEnumerable<UserCertificationRecord> certRecords = await _userService.GetUserCertificationRecords();
+                IEnumerable<UserCertificationRecord> certRecords = await _trainingService.GetUserCertificationRecords();
-                isSuccessful = await _userService.UpdateUserCertificationData(certRecords);
+                isSuccessful = await _trainingService.UpdateTrainingGroupMembership(certRecords);
             }
 
             if (isSuccessful) {
-                _logger.LogInformation("Successfully updated user certification data.");
+                _logger.LogInformation("Successfully updated certification training group membership.");
             } else {
-                throw new Exception("Unable to update user certification data.");
+                throw new Exception("Unable to update certification training group membership.");
             }
         } catch (Exception ex) {
             StringBuilder errMsgBuilder = new();
-            errMsgBuilder.Append("An exception occurred when attempting to update user certification data. ");
+            errMsgBuilder.Append("An exception occurred when attempting to update certification training group membership. ");
             errMsgBuilder.Append($"Exception: {ex.Message}");
             _logger.LogError(errMsgBuilder.ToString());
             isInternalError = true;

FabApprovalWorkerServiceTests/TrainingServiceTests.cs

@@ -10,6 +10,7 @@ namespace FabApprovalWorkerServiceTests;
 public class TrainingServiceTests {
     private Mock<ILogger<TrainingService>> _mockLogger;
     private Mock<IDalService> _mockDalService;
+    private Mock<IUserService> _mockUserService;
 
     private TrainingService _trainingService;
 
@@ -17,21 +18,27 @@ public class TrainingServiceTests {
     public void Setup() {
         _mockLogger = new Mock<ILogger<TrainingService>>();
         _mockDalService = new Mock<IDalService>();
+        _mockUserService = new Mock<IUserService>();
     }
 
     [Test]
     public void TrainingServiceWithNullLoggerShouldThrowException() {
-        Assert.Throws<ArgumentNullException>(() => new TrainingService(null, _mockDalService.Object));
+        Assert.Throws<ArgumentNullException>(() => new TrainingService(null, _mockDalService.Object, _mockUserService.Object));
     }
 
     [Test]
     public void TrainingServiceWithNullDalServiceShouldThrowException() {
-        Assert.Throws<ArgumentNullException>(() => new TrainingService(_mockLogger.Object, null));
+        Assert.Throws<ArgumentNullException>(() => new TrainingService(_mockLogger.Object, null, _mockUserService.Object));
+    }
+
+    [Test]
+    public void TrainingServiceWithNullUserServiceShouldThrowException() {
+        Assert.Throws<ArgumentNullException>(() => new TrainingService(_mockLogger.Object, _mockDalService.Object, null));
     }
 
     [Test]
     public void DeleteDocAssignmentWithInvalidIdShouldThrowException() {
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.DeleteDocAssignment(-1));
     }
@@ -40,7 +47,7 @@ public class TrainingServiceTests {
     public void DeleteDocAssignmentWithDbErrorShouldThrowException() {
         _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Throws(new Exception());
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.DeleteDocAssignment(1));
     }
@@ -49,7 +56,7 @@ public class TrainingServiceTests {
     public async Task DeleteDocAssignmentShouldExecuteSqlQuery() {
         _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(3));
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         await _trainingService.DeleteDocAssignment(3);
 
@@ -58,7 +65,7 @@ public class TrainingServiceTests {
 
     [Test]
     public void DeleteTrainingAssignmentWithInvalidIdShouldThrowException() {
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.DeleteTrainingAssignmentsByTrainingId(-1));
     }
@@ -67,7 +74,7 @@ public class TrainingServiceTests {
     public void DeleteTrainingAssignmentWithDbErrorShouldThrowException() {
         _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Throws(new Exception());
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.DeleteTrainingAssignmentsByTrainingId(1));
     }
@@ -76,7 +83,7 @@ public class TrainingServiceTests {
     public async Task DeleteTrainingAssignmentShouldExecuteSqlQuery() {
         _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(3));
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         await _trainingService.DeleteTrainingAssignmentsByTrainingId(3);
 
@@ -85,7 +92,7 @@ public class TrainingServiceTests {
 
     [Test]
     public void GetTrainingAssignmentIdsForTrainingWithInvalidIdShouldThrowException() {
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<ArgumentException>(async Task () => {
             IEnumerable<int> ids = await _trainingService.GetTrainingAssignmentIdsForTraining(-1);
@@ -96,7 +103,7 @@ public class TrainingServiceTests {
     public void GetTrainingAssignmentIdsForTrainingWithDbErrorShouldThrowException() {
         _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Throws(new Exception());
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.GetTrainingAssignmentIdsForTraining(1));
     }
@@ -107,7 +114,7 @@ public class TrainingServiceTests {
 
         _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Returns(Task.FromResult(expectedIds));
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         IEnumerable<int> actualIds = await _trainingService.GetTrainingAssignmentIdsForTraining(1);
 
@@ -116,7 +123,7 @@ public class TrainingServiceTests {
 
     [Test]
     public void GetTrainingIdsForEcnWithInvalidIdShouldThrowException() {
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<ArgumentException>(async Task () => {
             IEnumerable<int> ids = await _trainingService.GetTrainingIdsForECN(-1);
@@ -127,7 +134,7 @@ public class TrainingServiceTests {
     public void GetTrainingIdsForEcnWithDbErrorShouldThrowException() {
         _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Throws(new Exception());
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.GetTrainingIdsForECN(1));
     }
@@ -138,7 +145,7 @@ public class TrainingServiceTests {
 
         _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Returns(Task.FromResult(expectedIds));
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         IEnumerable<int> actualIds = await _trainingService.GetTrainingIdsForECN(1);
 
@@ -147,7 +154,7 @@ public class TrainingServiceTests {
 
     [Test]
     public void MarkTrainingAsCompleteWithInvalidIdShouldThrowException() {
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<ArgumentException>(async Task() => await _trainingService.MarkTrainingAsComplete(-1));
     }
@@ -156,7 +163,7 @@ public class TrainingServiceTests {
     public void MarkTrainingCompleteWithDbErrorShouldThrowException() {
         _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Throws(new Exception());
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.MarkTrainingAsComplete(1));
     }
@@ -165,7 +172,7 @@ public class TrainingServiceTests {
     public async Task MarkTrainingCompleteShouldExecuteSql() {
         _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         await _trainingService.MarkTrainingAsComplete(1);
 
@@ -197,7 +204,7 @@ public class TrainingServiceTests {
 
         _mockDalService.Setup(d => d.QueryAsync<TrainingAssignment>(It.IsAny<string>())).Returns(Task.FromResult(expectedAssignments));
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         IEnumerable<TrainingAssignment> actualAssignments = await _trainingService.GetActiveTrainingAssignments();
 
@@ -208,14 +215,14 @@ public class TrainingServiceTests {
     public void GetActiveTrainingAssignmentsWithDbErrorShouldThrowException() {
         _mockDalService.Setup(d => d.QueryAsync<TrainingAssignment>(It.IsAny<string>())).Throws(new Exception());
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<Exception>(async Task() => await _trainingService.GetActiveTrainingAssignments());
     }
 
     [Test]
     public void UpdateTrainingAssignmentLastNotificationWithInvalidIdShouldThrowException() {
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.UpdateTrainingAssignmentLastNotification(-1));
     }
@@ -224,14 +231,14 @@ public class TrainingServiceTests {
     public void UpdateTrainingAssignmentLastNotificationDbErrorShouldThrowException() {
         _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Throws(new Exception());
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.UpdateTrainingAssignmentLastNotification(1));
     }
 
     [Test]
     public async Task UpdateTrainingAssignmentLastNotificationShouldExecuteSql() {
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         await _trainingService.UpdateTrainingAssignmentLastNotification(1);
 
@@ -240,7 +247,7 @@ public class TrainingServiceTests {
 
     [Test]
     public void GetEcnNumberByTrainingIdInvalidIdShouldThrowException() {
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.GetEcnNumberByTrainingId(0));
         Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.GetEcnNumberByTrainingId(-1));
@@ -250,7 +257,7 @@ public class TrainingServiceTests {
     public void GetEcnNumberByTrainingIdDbErrorShouldThrowException() {
         _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Throws(new Exception());
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.GetEcnNumberByTrainingId(9));
     }
@@ -261,7 +268,7 @@ public class TrainingServiceTests {
 
         _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Returns(Task.FromResult(expectedIds));
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.GetEcnNumberByTrainingId(9));
     }
@@ -272,7 +279,7 @@ public class TrainingServiceTests {
 
         _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Returns(Task.FromResult(expectedIds));
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         int actualId = await _trainingService.GetEcnNumberByTrainingId(9);
 
@@ -281,7 +288,7 @@ public class TrainingServiceTests {
 
     [Test]
     public void DeleteTrainingAssignmentByIdWithInvalidIdShouldThrowException() {
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.DeleteTrainingAssignmentById(0));
         Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.DeleteTrainingAssignmentById(-7));
@@ -291,14 +298,14 @@ public class TrainingServiceTests {
     public void DeleteTrainingAssignmentByIdWithDbErrorShouldThrowException() {
         _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Throws(new Exception());
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.DeleteTrainingAssignmentById(9));
     }
 
     [Test]
     public async Task DeleteTrainingAssignmentByIdShouldExecuteSql() {
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         await _trainingService.DeleteTrainingAssignmentById(9);
 
@@ -307,7 +314,7 @@ public class TrainingServiceTests {
 
     [Test]
     public void GetTrainingAssignmentIdsByUserIdWithInvalidIdShouldThrowException() {
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.GetTrainingAssignmentIdsByUserId(0));
         Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.GetTrainingAssignmentIdsByUserId(-9));
@@ -317,7 +324,7 @@ public class TrainingServiceTests {
     public void GetTrainingAssignmentIdsByUserIdWithDbErrorShouldThrowException() {
         _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Throws(new Exception());
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.GetTrainingAssignmentIdsByUserId(9));
     }
@@ -328,7 +335,7 @@ public class TrainingServiceTests {
 
         _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Returns(Task.FromResult(expectedIds));
 
-        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);
+        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object, _mockUserService.Object);
 
         IEnumerable<int> actualIds = await _trainingService.GetTrainingAssignmentIdsByUserId(9);