feat(training): Add edit functionality for training module

Tests/Resgrid.Tests/Mocks/MockTrainingAttachmentRepository.cs

@@ -0,0 +1,103 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Resgrid.Model;
+using Resgrid.Model.Repositories;
+
+namespace Resgrid.Tests.Mocks
+{
+	/// <summary>
+	/// In-memory mock for <see cref="ITrainingAttachmentRepository"/>
+	/// </summary>
+	public sealed class MockTrainingAttachmentRepository : ITrainingAttachmentRepository
+	{
+		private readonly List<TrainingAttachment> _attachments = new List<TrainingAttachment>();
+		private int _nextId = 1;
+
+		public Task<IEnumerable<TrainingAttachment>> GetAllAsync()
+			=> Task.FromResult<IEnumerable<TrainingAttachment>>(_attachments.ToList());
+
+		public Task<TrainingAttachment> GetByIdAsync(object id)
+		{
+			var intId = (int)id;
+			var attachment = _attachments.FirstOrDefault(a => a.TrainingAttachmentId == intId);
+			return Task.FromResult(attachment);
+		}
+
+		public Task<IEnumerable<TrainingAttachment>> GetAllByDepartmentIdAsync(int departmentId)
+			=> Task.FromResult<IEnumerable<TrainingAttachment>>(new List<TrainingAttachment>());
+
+		public Task<IEnumerable<TrainingAttachment>> GetAllByUserIdAsync(string userId)
+			=> Task.FromResult<IEnumerable<TrainingAttachment>>(new List<TrainingAttachment>());
+
+		public Task<TrainingAttachment> InsertAsync(TrainingAttachment entity, CancellationToken cancellationToken, bool firstLevelOnly = false)
+		{
+			entity.TrainingAttachmentId = _nextId++;
+			_attachments.Add(entity);
+			return Task.FromResult(entity);
+		}
+
+		public Task<TrainingAttachment> UpdateAsync(TrainingAttachment entity, CancellationToken cancellationToken, bool firstLevelOnly = false)
+		{
+			var existing = _attachments.FirstOrDefault(a => a.TrainingAttachmentId == entity.TrainingAttachmentId);
+			if (existing != null)
+			{
+				_attachments.Remove(existing);
+			}
+			_attachments.Add(entity);
+			return Task.FromResult(entity);
+		}
+
+		public Task<bool> DeleteAsync(TrainingAttachment entity, CancellationToken cancellationToken)
+		{
+			var existing = _attachments.FirstOrDefault(a => a.TrainingAttachmentId == entity.TrainingAttachmentId);
+			if (existing != null)
+			{
+				_attachments.Remove(existing);
+			}
+			return Task.FromResult(true);
+		}
+
+		public Task<TrainingAttachment> SaveOrUpdateAsync(TrainingAttachment entity, CancellationToken cancellationToken, bool firstLevelOnly = false)
+		{
+			if (entity.TrainingAttachmentId == 0)
+			{
+				entity.TrainingAttachmentId = _nextId++;
+				_attachments.Add(entity);
+			}
+			else
+			{
+				var existing = _attachments.FirstOrDefault(a => a.TrainingAttachmentId == entity.TrainingAttachmentId);
+				if (existing != null)
+				{
+					_attachments.Remove(existing);
+				}
+				_attachments.Add(entity);
+			}
+			return Task.FromResult(entity);
+		}
+
+		public Task<bool> DeleteMultipleAsync(TrainingAttachment entity, string parentKeyName, object parentKeyId, List<object> ids, CancellationToken cancellationToken)
+			=> Task.FromResult(true);
+
+		public Task<IEnumerable<TrainingAttachment>> GetTrainingAttachmentsByTrainingIdAsync(int trainingId)
+		{
+			var result = _attachments.Where(a => a.TrainingId == trainingId).ToList();
+			return Task.FromResult<IEnumerable<TrainingAttachment>>(result);
+		}
+
+		public void SeedAttachment(TrainingAttachment attachment)
+		{
+			if (attachment.TrainingAttachmentId == 0)
+			{
+				attachment.TrainingAttachmentId = _nextId++;
+			}
+			else
+			{
+				_nextId = System.Math.Max(_nextId, attachment.TrainingAttachmentId + 1);
+			}
+			_attachments.Add(attachment);
+		}
+	}
+}

Tests/Resgrid.Tests/Mocks/MockTrainingQuestionRepository.cs

@@ -0,0 +1,103 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Resgrid.Model;
+using Resgrid.Model.Repositories;
+
+namespace Resgrid.Tests.Mocks
+{
+	/// <summary>
+	/// In-memory mock for <see cref="ITrainingQuestionRepository"/>
+	/// </summary>
+	public sealed class MockTrainingQuestionRepository : ITrainingQuestionRepository
+	{
+		private readonly List<TrainingQuestion> _questions = new List<TrainingQuestion>();
+		private int _nextId = 1;
+
+		public Task<IEnumerable<TrainingQuestion>> GetAllAsync()
+			=> Task.FromResult<IEnumerable<TrainingQuestion>>(_questions.ToList());
+
+		public Task<TrainingQuestion> GetByIdAsync(object id)
+		{
+			var intId = (int)id;
+			var question = _questions.FirstOrDefault(q => q.TrainingQuestionId == intId);
+			return Task.FromResult(question);
+		}
+
+		public Task<IEnumerable<TrainingQuestion>> GetAllByDepartmentIdAsync(int departmentId)
+			=> Task.FromResult<IEnumerable<TrainingQuestion>>(new List<TrainingQuestion>());
+
+		public Task<IEnumerable<TrainingQuestion>> GetAllByUserIdAsync(string userId)
+			=> Task.FromResult<IEnumerable<TrainingQuestion>>(new List<TrainingQuestion>());
+
+		public Task<TrainingQuestion> InsertAsync(TrainingQuestion entity, CancellationToken cancellationToken, bool firstLevelOnly = false)
+		{
+			entity.TrainingQuestionId = _nextId++;
+			_questions.Add(entity);
+			return Task.FromResult(entity);
+		}
+
+		public Task<TrainingQuestion> UpdateAsync(TrainingQuestion entity, CancellationToken cancellationToken, bool firstLevelOnly = false)
+		{
+			var existing = _questions.FirstOrDefault(q => q.TrainingQuestionId == entity.TrainingQuestionId);
+			if (existing != null)
+			{
+				_questions.Remove(existing);
+			}
+			_questions.Add(entity);
+			return Task.FromResult(entity);
+		}
+
+		public Task<bool> DeleteAsync(TrainingQuestion entity, CancellationToken cancellationToken)
+		{
+			var existing = _questions.FirstOrDefault(q => q.TrainingQuestionId == entity.TrainingQuestionId);
+			if (existing != null)
+			{
+				_questions.Remove(existing);
+			}
+			return Task.FromResult(true);
+		}
+
+		public Task<TrainingQuestion> SaveOrUpdateAsync(TrainingQuestion entity, CancellationToken cancellationToken, bool firstLevelOnly = false)
+		{
+			if (entity.TrainingQuestionId == 0)
+			{
+				entity.TrainingQuestionId = _nextId++;
+				_questions.Add(entity);
+			}
+			else
+			{
+				var existing = _questions.FirstOrDefault(q => q.TrainingQuestionId == entity.TrainingQuestionId);
+				if (existing != null)
+				{
+					_questions.Remove(existing);
+				}
+				_questions.Add(entity);
+			}
+			return Task.FromResult(entity);
+		}
+
+		public Task<bool> DeleteMultipleAsync(TrainingQuestion entity, string parentKeyName, object parentKeyId, List<object> ids, CancellationToken cancellationToken)
+			=> Task.FromResult(true);
+
+		public Task<IEnumerable<TrainingQuestion>> GetTrainingQuestionsByTrainingIdAsync(int trainingId)
+		{
+			var result = _questions.Where(q => q.TrainingId == trainingId).ToList();
+			return Task.FromResult<IEnumerable<TrainingQuestion>>(result);
+		}
+
+		public void SeedQuestion(TrainingQuestion question)
+		{
+			if (question.TrainingQuestionId == 0)
+			{
+				question.TrainingQuestionId = _nextId++;
+			}
+			else
+			{
+				_nextId = System.Math.Max(_nextId, question.TrainingQuestionId + 1);
+			}
+			_questions.Add(question);
+		}
+	}
+}

Tests/Resgrid.Tests/Mocks/MockTrainingRepository.cs

@@ -0,0 +1,121 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Resgrid.Model;
+using Resgrid.Model.Repositories;
+
+namespace Resgrid.Tests.Mocks
+{
+	/// <summary>
+	/// In-memory mock for <see cref="ITrainingRepository"/> that stores trainings
+	/// without requiring a database connection.
+	/// </summary>
+	public sealed class MockTrainingRepository : ITrainingRepository
+	{
+		private readonly List<Training> _trainings = new List<Training>();
+		private int _nextId = 1;
+
+		public List<Training> Trainings => _trainings;
+
+		public Task<IEnumerable<Training>> GetAllAsync()
+			=> Task.FromResult<IEnumerable<Training>>(_trainings.ToList());
+
+		public Task<Training> GetByIdAsync(object id)
+		{
+			var intId = (int)id;
+			var training = _trainings.FirstOrDefault(t => t.TrainingId == intId);
+			return Task.FromResult(training);
+		}
+
+		public Task<IEnumerable<Training>> GetAllByDepartmentIdAsync(int departmentId)
+		{
+			var result = _trainings.Where(t => t.DepartmentId == departmentId).ToList();
+			return Task.FromResult<IEnumerable<Training>>(result);
+		}
+
+		public Task<IEnumerable<Training>> GetAllByUserIdAsync(string userId)
+			=> Task.FromResult<IEnumerable<Training>>(new List<Training>());
+
+		public Task<Training> InsertAsync(Training entity, CancellationToken cancellationToken, bool firstLevelOnly = false)
+		{
+			entity.TrainingId = _nextId++;
+			_trainings.Add(entity);
+			return Task.FromResult(entity);
+		}
+
+		public Task<Training> UpdateAsync(Training entity, CancellationToken cancellationToken, bool firstLevelOnly = false)
+		{
+			var existing = _trainings.FirstOrDefault(t => t.TrainingId == entity.TrainingId);
+			if (existing != null)
+			{
+				_trainings.Remove(existing);
+			}
+			_trainings.Add(entity);
+			return Task.FromResult(entity);
+		}
+
+		public Task<bool> DeleteAsync(Training entity, CancellationToken cancellationToken)
+		{
+			var existing = _trainings.FirstOrDefault(t => t.TrainingId == entity.TrainingId);
+			if (existing != null)
+			{
+				_trainings.Remove(existing);
+			}
+			return Task.FromResult(true);
+		}
+
+		public Task<Training> SaveOrUpdateAsync(Training entity, CancellationToken cancellationToken, bool firstLevelOnly = false)
+		{
+			if (entity.TrainingId == 0)
+			{
+				entity.TrainingId = _nextId++;
+				_trainings.Add(entity);
+			}
+			else
+			{
+				var existing = _trainings.FirstOrDefault(t => t.TrainingId == entity.TrainingId);
+				if (existing != null)
+				{
+					_trainings.Remove(existing);
+				}
+				_trainings.Add(entity);
+			}
+			return Task.FromResult(entity);
+		}
+
+		public Task<bool> DeleteMultipleAsync(Training entity, string parentKeyName, object parentKeyId, List<object> ids, CancellationToken cancellationToken)
+			=> Task.FromResult(true);
+
+		public List<Training> GetAllTrainings()
+			=> _trainings.ToList();
+
+		public Task<IEnumerable<Training>> GetTrainingsByDepartmentIdAsync(int departmentId)
+		{
+			var result = _trainings.Where(t => t.DepartmentId == departmentId).ToList();
+			return Task.FromResult<IEnumerable<Training>>(result);
+		}
+
+		public Task<Training> GetTrainingByTrainingIdAsync(int trainingId)
+		{
+			var training = _trainings.FirstOrDefault(t => t.TrainingId == trainingId);
+			return Task.FromResult(training);
+		}
+
+		/// <summary>
+		/// Helper method to seed test data
+		/// </summary>
+		public void SeedTraining(Training training)
+		{
+			if (training.TrainingId == 0)
+			{
+				training.TrainingId = _nextId++;
+			}
+			else
+			{
+				_nextId = System.Math.Max(_nextId, training.TrainingId + 1);
+			}
+			_trainings.Add(training);
+		}
+	}
+}