private void UpdateNewAssignedGroups(IEnumerable <ModulesViewModel> modules, List <int> groupIds)
 {
     if (modules.Any(e => e.Type == ModuleType.YeManagment))
     {
         CPManagementService.SetSelectedGroupsToCourseProjects(SubjectId, groupIds);
     }
 }
Beispiel #2
0
        public bool DeleteUser(int id)
        {
            using var repositoriesContainer = new LmPlatformRepositoriesContainer();

            var query = new Query <User>().AddFilterClause(u => u.Id == id).Include(u => u.ProjectUsers).Include(u => u.Student);
            var user  = repositoriesContainer.UsersRepository.GetBy(query);

            repositoriesContainer.MessageRepository.DeleteUserMessages(user.Id);

            var projects = user.ProjectUsers.DistinctBy(e => e.ProjectId).Select(e => e.ProjectId);

            foreach (var projectId in projects)
            {
                ProjectManagementService.DeleteUserFromProject(id, projectId);
            }

            if (user.Student != null)
            {
                var acp = user.Student.AssignedCourseProjects.Select(e => e.CourseProjectId);
                foreach (var acpId in acp)
                {
                    CPManagementService.DeleteUserFromAcpProject(id, acpId);
                }

                var subjects = repositoriesContainer.RepositoryFor <SubjectStudent>()
                               .GetAll(new Query <SubjectStudent>(e => e.StudentId == id));

                foreach (var subjectS in subjects)
                {
                    repositoriesContainer.RepositoryFor <SubjectStudent>().Delete(subjectS);
                }

                var diplomas = Context.AssignedDiplomProjects.Where(e => e.StudentId == id).ToList();

                var diplomasRessList = Context.DiplomPercentagesResults.Where(e => e.StudentId == id).ToList();

                foreach (var diploma in diplomas)
                {
                    Context.AssignedDiplomProjects.Remove(diploma);
                    Context.SaveChanges();
                }

                foreach (var diplomasRes in diplomasRessList)
                {
                    Context.DiplomPercentagesResults.Remove(diplomasRes);
                    Context.SaveChanges();
                }
            }

            CPManagementService.DeletePercenageAndVisitStatsForUser(id);

            repositoriesContainer.ApplyChanges();
            var result = AccountManagementService.DeleteAccount(user.UserName);

            repositoriesContainer.ApplyChanges();

            return(result);
        }
        public void Save(int userId, string color)
        {
            var subject = new Subject
            {
                Id               = SubjectId,
                Name             = DisplayName,
                ShortName        = ShortName,
                Color            = color,
                SubjectModules   = new Collection <SubjectModule>(),
                SubjectLecturers = new Collection <SubjectLecturer>()
            };

            foreach (var module in Modules)
            {
                if (module.Checked)
                {
                    if (module.Type == ModuleType.Labs)
                    {
                        subject.SubjectModules.Add(new SubjectModule
                        {
                            ModuleId = ModulesManagementService.GetModules()
                                       .First(e => e.ModuleType == ModuleType.ScheduleProtection).Id,
                            SubjectId = SubjectId
                        });
                        subject.SubjectModules.Add(new SubjectModule
                        {
                            ModuleId = ModulesManagementService.GetModules()
                                       .First(e => e.ModuleType == ModuleType.StatisticsVisits).Id,
                            SubjectId = SubjectId
                        });
                        subject.SubjectModules.Add(new SubjectModule
                        {
                            ModuleId = ModulesManagementService.GetModules()
                                       .First(e => e.ModuleType == ModuleType.Results).Id,
                            SubjectId = SubjectId
                        });
                    }

                    subject.SubjectModules.Add(new SubjectModule
                    {
                        ModuleId  = module.ModuleId,
                        SubjectId = SubjectId
                    });
                }
            }

            subject.SubjectLecturers.Add(new SubjectLecturer
            {
                SubjectId  = SubjectId,
                LecturerId = userId
            });

            var selectedGroupdsOld = new List <SubjectGroup>();

            if (SubjectId != 0)
            {
                selectedGroupdsOld = SubjectManagementService
                                     .GetSubject(new Query <Subject>(e => e.Id == SubjectId).Include(e => e.SubjectGroups)).SubjectGroups
                                     .ToList();
            }

            var oldGroupIds = selectedGroupdsOld.Select(x => x.GroupId);

            if (SelectedGroups != null)
            {
                UpdateNewAssignedGroups(Modules.Where(e => e.Checked),
                                        SelectedGroups.Where(e => !oldGroupIds.Contains(e)).ToList());
                subject.SubjectGroups = SelectedGroups.Select(e => new SubjectGroup
                {
                    GroupId   = e,
                    SubjectId = SubjectId,
                    IsActiveOnCurrentGroup = true
                }).ToList();
            }
            else
            {
                subject.SubjectGroups = new Collection <SubjectGroup>();
            }

            foreach (var subjectSubjectGroup in selectedGroupdsOld)
            {
                if (subject.SubjectGroups.Any(e => e.GroupId == subjectSubjectGroup.GroupId))
                {
                    continue;
                }

                TestsManagementService.UnlockAllTestForGroup(subjectSubjectGroup.GroupId);
                SubjectManagementService.DeleteNonReceivedUserFiles(subjectSubjectGroup.GroupId);
            }

            var acp = Context.AssignedCourseProjects.Include("Student")
                      .Where(x => x.CourseProject.SubjectId == subject.Id);

            foreach (var a in acp)
            {
                var flag = subject.SubjectGroups.Any(s => s.GroupId == a.Student.GroupId);

                if (!flag)
                {
                    Context.AssignedCourseProjects.Remove(a);
                }
                CPManagementService.DeletePercenageAndVisitStatsForUser(a.StudentId);
            }

            var cpg = Context.CourseProjectGroups.Where(x => x.CourseProject.SubjectId == subject.Id);

            foreach (var a in cpg)
            {
                var flag = subject.SubjectGroups.Any(s => s.GroupId == a.GroupId);

                if (!flag)
                {
                    Context.CourseProjectGroups.Remove(a);
                }
            }

            Context.SaveChanges();

            var sub = SubjectManagementService.SaveSubject(subject);

            SubjectId = sub.Id;
            CreateOrUpdateSubGroups();

            foreach (var module in sub.SubjectModules)
            {
                if (module.ModuleId == 9)
                {
                    MaterialsManagementService.CreateRootFolder(module.Id, sub.Name);
                }
            }
        }