Рефакторинг функциональности вопросов по задачам (#586)

* [backend] refactor: create TaskQuestionsRepository

* [backend] refactor: create TaskQuestionsService and ITaskQuestionsService; refactor TasksController (remove repository calls from service)

Author: YuriUfimtsev

HwProj.CoursesService/HwProj.CoursesService.API/Controllers/TasksController.cs

@@ -20,16 +20,17 @@ public class TasksController : Controller
     {
         private readonly ITasksService _tasksService;
         private readonly IHomeworksService _homeworksService;
-        private readonly ITaskQuestionsRepository _questionsRepository;
+        private readonly ITaskQuestionsService _taskQuestionsService;
         private readonly ICoursesService _coursesService;
 
         public TasksController(ITasksService tasksService, ICoursesService coursesService,
-            IHomeworksService homeworksService, ITaskQuestionsRepository questionsRepository)
+            IHomeworksService homeworksService, ITaskQuestionsRepository questionsRepository,
+            ITaskQuestionsService taskQuestionsService)
         {
             _tasksService = tasksService;
             _coursesService = coursesService;
             _homeworksService = homeworksService;
-            _questionsRepository = questionsRepository;
+            _taskQuestionsService = taskQuestionsService;
         }
 
         [HttpGet("get/{taskId}")]
@@ -114,7 +115,7 @@ public async Task<IActionResult> AddQuestionForTask([FromBody] AddTaskQuestionDt
             if (!await _coursesService.HasStudent(task.Homework.CourseId, studentId))
                 return Forbid();
 
-            await _questionsRepository.AddAsync(new TaskQuestion
+            await _taskQuestionsService.AddQuestionAsync(new TaskQuestion
             {
                 TaskId = task.Id,
                 StudentId = studentId,
@@ -137,10 +138,11 @@ public async Task<IActionResult> GetQuestionsForTask(long taskId)
             if (!isLecturer && !isStudent)
                 return Forbid();
 
-            var questions = _questionsRepository.FindAll(x => x.TaskId == taskId);
-            questions = isLecturer ? questions : questions.Where(x => !x.IsPrivate || x.StudentId == userId);
+            var questions = isLecturer
+                ? await _taskQuestionsService.GetQuestionsForLecturerAsync(taskId)
+                : await _taskQuestionsService.GetStudentQuestionsAsync(taskId, userId);
 
-            var result = (await questions.ToListAsync()).Select(x => new GetTaskQuestionDto
+            var result = questions.Select(x => new GetTaskQuestionDto
             {
                 Id = x.Id,
                 StudentId = x.StudentId,
@@ -153,15 +155,15 @@ public async Task<IActionResult> GetQuestionsForTask(long taskId)
         }
 
         [HttpPost("addAnswer")]
-        public async Task<IActionResult> GetQuestionsForTask(AddAnswerForQuestionDto answer)
+        public async Task<IActionResult> AddAnswerForQuestion(AddAnswerForQuestionDto answer)
         {
             if (string.IsNullOrEmpty(answer.Answer))
                 return BadRequest("Текст ответа пуст");
 
             var lecturerId = Request.GetUserIdFromHeader();
             if (lecturerId == null) return NotFound();
 
-            var question = await _questionsRepository.FindAsync(x => x.Id == answer.QuestionId);
+            var question = await _taskQuestionsService.GetQuestionAsync(answer.QuestionId);
             if (question == null) return NotFound();
 
             var task = await _tasksService.GetTaskAsync(question.TaskId);
@@ -171,11 +173,7 @@ public async Task<IActionResult> GetQuestionsForTask(AddAnswerForQuestionDto ans
             var isLecturer = (await _coursesService.GetCourseLecturers(courseId)).Contains(lecturerId);
             if (!isLecturer) return Forbid();
 
-            await _questionsRepository.UpdateAsync(question.Id, x => new TaskQuestion
-            {
-                LecturerId = lecturerId,
-                Answer = answer.Answer
-            });
+            await _taskQuestionsService.AddAnswerAsync(question.Id, lecturerId, answer.Answer);
             return Ok();
         }
     }

HwProj.CoursesService/HwProj.CoursesService.API/Repositories/ITaskQuestionsRepository.cs

@@ -6,12 +6,4 @@ namespace HwProj.CoursesService.API.Repositories
     public interface ITaskQuestionsRepository : ICrudRepository<TaskQuestion, long>
     {
     }
-
-    public class TaskQuestionsRepository : CrudRepository<TaskQuestion, long>, ITaskQuestionsRepository
-    {
-        public TaskQuestionsRepository(CourseContext context)
-            : base(context)
-        {
-        }
-    }
 }

HwProj.CoursesService/HwProj.CoursesService.API/Repositories/TaskQuestionsRepository.cs

@@ -0,0 +1,13 @@
+using HwProj.CoursesService.API.Models;
+using HwProj.Repositories;
+
+namespace HwProj.CoursesService.API.Repositories
+{
+    public class TaskQuestionsRepository : CrudRepository<TaskQuestion, long>, ITaskQuestionsRepository
+    {
+        public TaskQuestionsRepository(CourseContext context)
+            : base(context)
+        {
+        }
+    }
+}

HwProj.CoursesService/HwProj.CoursesService.API/Services/ITaskQuestionsService.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using HwProj.CoursesService.API.Models;
+
+namespace HwProj.CoursesService.API.Services
+{
+    public interface ITaskQuestionsService
+    {
+        Task<long> AddQuestionAsync(TaskQuestion taskQuestion);
+        Task<TaskQuestion> GetQuestionAsync(long taskQuestionId);
+        Task<List<TaskQuestion>> GetQuestionsForLecturerAsync(long taskId);
+        Task<List<TaskQuestion>> GetStudentQuestionsAsync(long taskId, string studentId);
+        Task AddAnswerAsync(long questionId, string lecturerId, string answer);
+    }
+}

HwProj.CoursesService/HwProj.CoursesService.API/Services/TaskQuestionsService.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using HwProj.CoursesService.API.Models;
+using HwProj.CoursesService.API.Repositories;
+using Microsoft.EntityFrameworkCore;
+
+namespace HwProj.CoursesService.API.Services
+{
+    public class TaskQuestionsService : ITaskQuestionsService
+    {
+        private readonly ITaskQuestionsRepository _taskQuestionsRepository;
+
+        public TaskQuestionsService(ITaskQuestionsRepository taskQuestionsRepository)
+        {
+            _taskQuestionsRepository = taskQuestionsRepository;
+        }
+
+        public async Task<long> AddQuestionAsync(TaskQuestion taskQuestion)
+            => await _taskQuestionsRepository.AddAsync(taskQuestion);
+
+        public async Task<TaskQuestion> GetQuestionAsync(long taskQuestionId)
+            => await _taskQuestionsRepository.FindAsync(x => x.Id == taskQuestionId);
+
+        public async Task<List<TaskQuestion>> GetQuestionsForLecturerAsync(long taskId)
+            => await GetALlTaskQuestions(taskId).ToListAsync();
+
+        public Task<List<TaskQuestion>> GetStudentQuestionsAsync(long taskId, string studentId)
+        {
+            var allQuestions = GetALlTaskQuestions(taskId);
+            return allQuestions.Where(x => !x.IsPrivate || x.StudentId == studentId).ToListAsync();
+        }
+
+        public async Task AddAnswerAsync(long questionId, string lecturerId, string answer) 
+            => await _taskQuestionsRepository.UpdateAsync(questionId, x => new TaskQuestion
+            {
+                LecturerId = lecturerId,
+                Answer = answer
+            });
+
+        private IQueryable<TaskQuestion> GetALlTaskQuestions(long taskId)
+            => _taskQuestionsRepository.FindAll(x => x.TaskId == taskId);
+    }
+}