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);
+ }
+	}
+}