Закрепление домашних работ за студентами

HwProj.APIGateway/HwProj.APIGateway.API/Controllers/CourseGroupsController.cs

@@ -3,6 +3,7 @@
 using System.Threading.Tasks;
 using HwProj.CoursesService.Client;
 using HwProj.Models.CoursesService.ViewModels;
+using HwProj.Models.CoursesService.DTO;
 using HwProj.Models.Roles;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
@@ -30,6 +31,16 @@ public async Task<IActionResult> GetAllCourseGroups(long courseId)
             : Ok(result);
     }
 
+    [HttpGet("{courseId}/getAllWithNames")]
+    [ProducesResponseType(typeof(GroupWithNameDTO[]), (int)HttpStatusCode.OK)]
+    public async Task<IActionResult> GetAllCourseGroupsWithNames(long courseId)
+    {
+        var result = await _coursesClient.GetAllCourseGroupsWithNames(courseId);
+        return result == null
+            ? NotFound()
+            : Ok(result);
+    }
+
     [HttpPost("{courseId}/create")]
     [Authorize(Roles = Roles.LecturerRole)]
     [ProducesResponseType(typeof(long), (int)HttpStatusCode.OK)]

HwProj.Common/HwProj.Models/CoursesService/DTO/GroupWithNameDTO.cs

@@ -0,0 +1,9 @@
+namespace HwProj.Models.CoursesService.DTO
+{
+    public class GroupWithNameDTO
+    {
+        public long Id { get; set; }
+        public string Name { get; set; }
+        public string[] StudentsIds { get; set; }
+    }
+}

HwProj.Common/HwProj.Models/CoursesService/ViewModels/HomeworkViewModels.cs

@@ -27,6 +27,8 @@ public class CreateHomeworkViewModel
         public List<PostTaskViewModel> Tasks { get; set; } = new List<PostTaskViewModel>();
 
         public ActionOptions? ActionOptions { get; set; }
+
+        public long? GroupId { get; set; }
     }
 
     public class HomeworkViewModel
@@ -58,5 +60,7 @@ public class HomeworkViewModel
         public List<string> Tags { get; set; } = new List<string>();
 
         public List<HomeworkTaskViewModel> Tasks { get; set; } = new List<HomeworkTaskViewModel>();
+
+        public long? GroupId { get; set; }
     }
 }

HwProj.CoursesService/HwProj.CoursesService.API/AutomapperProfile.cs

@@ -21,6 +21,10 @@ public AutomapperProfile()
 
             CreateMap<CreateCourseFilterDTO, CreateCourseFilterModel>();
             CreateMap<Filter, CourseFilterDTO>();
+
+            CreateMap<UpdateGroupViewModel, Group>().ReverseMap();
+
+            CreateMap<GroupMateViewModel, GroupMate>().ReverseMap();
         }
     }
 }

HwProj.CoursesService/HwProj.CoursesService.API/Controllers/CourseGroupsController.cs

@@ -1,9 +1,11 @@
-using System.Linq;
+using System;
+using System.Linq;
 using System.Threading.Tasks;
 using AutoMapper;
 using HwProj.CoursesService.API.Filters;
 using HwProj.CoursesService.API.Models;
 using HwProj.CoursesService.API.Services;
+using HwProj.Models.CoursesService.DTO;
 using HwProj.Models.CoursesService.ViewModels;
 using Microsoft.AspNetCore.Mvc;
 
@@ -36,6 +38,19 @@ public async Task<GroupViewModel[]> GetAll(long courseId)
             return result;
         }
 
+        [HttpGet("{courseId}/getAllWithNames")]
+        public async Task<GroupWithNameDTO[]> GetAllWithNames(long courseId)
+        {
+            var groups = await _groupsService.GetAllAsync(courseId);
+            var result = groups.Select(t => new GroupWithNameDTO
+            {
+                Id = t.Id,
+                Name = t.Name,
+                StudentsIds = t.GroupMates.Select(s => s.StudentId).ToArray()
+            }).ToArray();
+            return result;
+        }
+
         [HttpPost("{courseId}/create")]
         public async Task<IActionResult> CreateGroup([FromBody] CreateGroupViewModel groupViewModel)
         {

HwProj.CoursesService/HwProj.CoursesService.API/Domains/MappingExtensions.cs

@@ -32,6 +32,7 @@ public static HomeworkViewModel ToHomeworkViewModel(this Homework homework)
                 IsDeferred = DateTime.UtcNow < homework.PublicationDate,
                 Tasks = homework.Tasks.Select(t => t.ToHomeworkTaskViewModel()).ToList(),
                 Tags = tags.ToList(),
+                GroupId = homework.GroupId,
             };
         }
 
@@ -147,6 +148,7 @@ public static Homework ToHomework(this CreateHomeworkViewModel homework)
                 PublicationDate = homework.PublicationDate,
                 Tasks = homework.Tasks.Select(t => t.ToHomeworkTask()).ToList(),
                 Tags = string.Join(";", homework.Tags),
+                GroupId = homework.GroupId,
             };
 
         public static CourseTemplate ToCourseTemplate(this CreateCourseViewModel createCourseViewModel)

HwProj.CoursesService/HwProj.CoursesService.API/Domains/Validations.cs

@@ -112,6 +112,11 @@ public static List<string> ValidateHomework(CreateHomeworkViewModel homework, Ho
                 errors.Add("Нельзя изменить дату публикации домашнего задания, если она уже показана студента");
             }
 
+            if (previousState.GroupId != homework.GroupId)
+            {
+                errors.Add("Нельзя изменить группу для домашнего задания, если оно уже опубликовано");
+            }
+
             return errors;
         }
     }

HwProj.CoursesService/HwProj.CoursesService.API/Models/Homework.cs

@@ -25,5 +25,7 @@ public class Homework : IEntity<long>
         public long CourseId { get; set; }
 
         public List<HomeworkTask> Tasks { get; set; }
+
+        public long? GroupId { get; set; }
     }
 }

HwProj.CoursesService/HwProj.CoursesService.API/Repositories/HomeworksRepository.cs

@@ -27,6 +27,14 @@ public async Task<Homework[]> GetAllWithTasksByCourseAsync(long courseId)
                 .ToArrayAsync();
         }
 
+        public async Task<Homework[]> GetWithTasksAsync(long[] homeworkIds, bool withCriteria = false)
+        {
+            var query = Context.Set<Homework>().AsNoTracking().Include(h => h.Tasks);
+            return withCriteria
+                ? await query.ThenInclude(x => x.Criteria).Where(h => homeworkIds.Contains(h.Id)).ToArrayAsync()
+                : await query.Where(h => homeworkIds.Contains(h.Id)).ToArrayAsync();
+        }
+
         public async Task<Homework> GetWithTasksAsync(long id, bool withCriteria = false)
         {
             var query = Context.Set<Homework>().AsNoTracking().Include(h => h.Tasks);

HwProj.CoursesService/HwProj.CoursesService.API/Repositories/IHomeworksRepository.cs

@@ -8,6 +8,7 @@ public interface IHomeworksRepository : ICrudRepository<Homework, long>
     {
         Task<Homework[]> GetAllWithTasksAsync();
         Task<Homework[]> GetAllWithTasksByCourseAsync(long courseId);
+        Task<Homework[]> GetWithTasksAsync(long[] homeworkIds, bool withCriteria = false);
         Task<Homework> GetWithTasksAsync(long id, bool withCriteria = false);
     }
 }

HwProj.CoursesService/HwProj.CoursesService.API/Services/CourseFilterService.cs

@@ -6,17 +6,28 @@
 using HwProj.Models.CoursesService.DTO;
 using HwProj.Models.CoursesService.ViewModels;
 using HwProj.Models.Result;
+using System.Collections.Generic;
+using HwProj.CoursesService.API.Domains;
 
 namespace HwProj.CoursesService.API.Services
 {
+    public enum ApplyFilterType
+    {
+        Intersect,
+        Union,
+        Subtract
+    }
     public class CourseFilterService : ICourseFilterService
     {
         private readonly ICourseFilterRepository _courseFilterRepository;
+        private readonly IHomeworksService _homeworksService;
 
         public CourseFilterService(
-            ICourseFilterRepository courseFilterRepository)
+            ICourseFilterRepository courseFilterRepository,
+            IHomeworksService homeworksService)
         {
             _courseFilterRepository = courseFilterRepository;
+            _homeworksService = homeworksService;
         }
 
         public async Task<Result<long>> CreateOrUpdateCourseFilter(CreateCourseFilterModel courseFilterModel)
@@ -59,16 +70,12 @@ public async Task<CourseDTO[]> ApplyFiltersToCourses(string userId, CourseDTO[]
         {
             var courseIds = courses.Select(c => c.Id).ToArray();
 
-            var filters = (await _courseFilterRepository.GetAsync(userId, courseIds))
-                .ToDictionary(x => x.CourseId, x => x.CourseFilter);
-
-            return courses
-                .Select(course =>
-                {
-                    filters.TryGetValue(course.Id, out var courseFilter);
-                    return ApplyFilterInternal(course, courseFilter);
-                })
-                .ToArray();
+            var result = new List<CourseDTO>();
+            foreach (var course in courses)
+            {
+                result.Add(await ApplyFilter(course, userId));
+            }
+            return result.ToArray();
         }
 
         public async Task<CourseDTO> ApplyFilter(CourseDTO courseDto, string userId)
@@ -83,8 +90,21 @@ public async Task<CourseDTO> ApplyFilter(CourseDTO courseDto, string userId)
                 (await _courseFilterRepository.GetAsync(findFiltersFor, courseDto.Id))
                 .ToDictionary(x => x.UserId, x => x.CourseFilter);
 
+            if (!isMentor)
+            {
+                var studentCourse = courseDto;
+                var groupFilter = await _courseFilterRepository.GetAsync("", courseDto.Id); // Глобальный фильтр для вычитания групповых домашних заданий
+                if (groupFilter != null)
+                {
+                    studentCourse = await ApplyFilterInternal(courseDto, groupFilter, ApplyFilterType.Subtract);
+                }
+                return courseFilters.TryGetValue(userId, out var studentFilter)
+                        ? await ApplyFilterInternal(studentCourse, studentFilter, ApplyFilterType.Union)
+                        : studentCourse;
+            }
+
             var course = courseFilters.TryGetValue(userId, out var userFilter)
-                ? ApplyFilterInternal(courseDto, userFilter)
+                ? await ApplyFilterInternal(courseDto, userFilter, ApplyFilterType.Intersect)
                 : courseDto;
             if (isMentor || !isCourseStudent) return course;
 
@@ -123,7 +143,7 @@ private async Task<long> AddCourseFilter(Filter filter, long courseId, string us
             return courseFilterId;
         }
 
-        private CourseDTO ApplyFilterInternal(CourseDTO courseDto, CourseFilter? courseFilter)
+        private async Task<CourseDTO> ApplyFilterInternal(CourseDTO courseDto, CourseFilter? courseFilter, ApplyFilterType filterType)
         {
             var filter = courseFilter?.Filter;
 
@@ -132,6 +152,29 @@ private CourseDTO ApplyFilterInternal(CourseDTO courseDto, CourseFilter? courseF
                 return courseDto;
             }
 
+            var homeworks = filter.HomeworkIds.Any()
+                ? filterType switch
+                {
+                    ApplyFilterType.Intersect => courseDto.Homeworks
+                        .Where(hw => filter.HomeworkIds.Contains(hw.Id))
+                        .ToArray(),
+
+                    ApplyFilterType.Subtract => courseDto.Homeworks
+                        .Where(hw => !filter.HomeworkIds.Contains(hw.Id))
+                        .ToArray(),
+
+                    ApplyFilterType.Union => courseDto.Homeworks
+                        .Concat((await _homeworksService.GetHomeworksAsync(filter.HomeworkIds.ToArray()))
+                            .Where(hw => hw != null)
+                            .Select(hw => hw.ToHomeworkViewModel()))
+                        .GroupBy(hw => hw.Id)
+                        .Select(g => g.First())
+                        .ToArray(),
+
+                    _ => courseDto.Homeworks
+                }
+                : courseDto.Homeworks;
+
             return new CourseDTO
             {
                 Id = courseDto.Id,
@@ -164,10 +207,7 @@ private CourseDTO ApplyFilterInternal(CourseDTO courseDto, CourseFilter? courseF
                         ? courseDto.CourseMates
                             .Where(mate => !mate.IsAccepted || filter.StudentIds.Contains(mate.StudentId)).ToArray()
                         : courseDto.CourseMates,
-                Homeworks =
-                    filter.HomeworkIds.Any()
-                        ? courseDto.Homeworks.Where(hw => filter.HomeworkIds.Contains(hw.Id)).ToArray()
-                        : courseDto.Homeworks
+                Homeworks = homeworks.OrderBy(hw => hw.PublicationDate).ToArray()
             };
         }
     }

HwProj.CoursesService/HwProj.CoursesService.API/Services/GroupsService.cs

@@ -1,4 +1,6 @@
-using System.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using AutoMapper;
 using HwProj.CoursesService.API.Models;
@@ -28,7 +30,10 @@ public GroupsService(IGroupsRepository groupsRepository,
 
         public async Task<Group[]> GetAllAsync(long courseId)
         {
-            return await _groupsRepository.GetGroupsWithGroupMatesByCourse(courseId).ToArrayAsync().ConfigureAwait(false);
+            return await _groupsRepository.GetGroupsWithGroupMatesByCourse(courseId)
+                .AsNoTracking()
+                .ToArrayAsync()
+                .ConfigureAwait(false);
         }
 
         public async Task<Group[]> GetGroupsAsync(params long[] groupIds)
@@ -63,19 +68,33 @@ public async Task DeleteGroupAsync(long groupId)
 
         public async Task UpdateAsync(long groupId, Group updated)
         {
-            var group = await _groupsRepository.GetAsync(groupId);
-            group.GroupMates.RemoveAll(cm => true);
-            group.Tasks.RemoveAll(cm => true);
+            var group = (await _groupsRepository.GetGroupsWithGroupMatesAsync(new[] { groupId }))
+                .FirstOrDefault() ?? throw new InvalidOperationException($"Group with id {groupId} not found");
 
-            updated.GroupMates.ForEach(cm => cm.GroupId = groupId);
-            updated.Tasks.ForEach(cm => cm.GroupId = groupId);
-            var mateTasks = updated.GroupMates.Select(cm => _groupMatesRepository.AddAsync(cm));
-            var idTasks = updated.Tasks.Select(cm => _taskModelsRepository.AddAsync(cm));
+            foreach (var groupMate in group.GroupMates.ToList())
+            {
+                await _groupMatesRepository.DeleteAsync(groupMate.Id);
+            }
+
+            foreach (var task in group.Tasks.ToList())
+            {
+                await _taskModelsRepository.DeleteAsync(task.Id);
+            }
+
+            updated.GroupMates?.ForEach(cm => cm.GroupId = groupId);
+            updated.Tasks?.ForEach(cm => cm.GroupId = groupId);
 
             group.Name = updated.Name;
 
-            await Task.WhenAll(mateTasks);
-            await Task.WhenAll(idTasks);
+            if (updated.GroupMates != null && updated.GroupMates.Count > 0)
+            {
+                await _groupMatesRepository.AddRangeAsync(updated.GroupMates).ConfigureAwait(false);
+            }
+
+            if (updated.Tasks != null && updated.Tasks.Count > 0)
+            {
+                await _taskModelsRepository.AddRangeAsync(updated.Tasks).ConfigureAwait(false);
+            }
         }
 
         public async Task<bool> DeleteGroupMateAsync(long groupId, string studentId)
@@ -107,13 +126,14 @@ public async Task<UserGroupDescription[]> GetStudentGroupsAsync(long courseId, s
                 .ToArrayAsync()
                 .ConfigureAwait(false);
 
-            var getStudentGroupsTask = studentGroupsIds
-                .Select(async id => await _groupsRepository.GetAsync(id).ConfigureAwait(false))
-                .Where(cm => cm.Result.CourseId == courseId)
-                .ToArray();
-            var studentGroups = await Task.WhenAll(getStudentGroupsTask).ConfigureAwait(false);
+            var studentGroups = await _groupsRepository
+                .GetGroupsWithGroupMatesAsync(studentGroupsIds)
+                .ConfigureAwait(false);
 
-            return studentGroups.Select(c => _mapper.Map<UserGroupDescription>(c)).ToArray();
+            return studentGroups
+                .Where(g => g.CourseId == courseId)
+                .Select(c => _mapper.Map<UserGroupDescription>(c))
+                .ToArray();
         }
     }
 }