public void FillExamListFromSchedule(ScheduleRepository _sRepo)
        {
            ClearExamLogs();

            ClearAllExams();

            var examDiscs = _sRepo
                .GetFiltredDisciplines(d => d.Attestation == 2 || d.Attestation == 3)
                .ToList();

            foreach (var disc in examDiscs)
            {
                AddExam(new Exam()
                {
                    DisciplineId = disc.DisciplineId,
                    IsActive = true,
                    ConsultationDateTime = Constants.Constants.DefaultEmptyDateForEvent,
                    ExamDateTime = Constants.Constants.DefaultEmptyDateForEvent
                });
            }
        }
        public void RemoveSyncWithSchedule(ScheduleRepository _sRepo)
        {
            var examDiscs = _sRepo
                .GetFiltredDisciplines(d => d.Attestation == 2 || d.Attestation == 3)
                .ToList();

            var examDiscIds = GetAllExams()
                .Select(e => e.DisciplineId)
                .ToList();

            var examsToRemove = new List<int>();

            foreach (var exam in GetAllExams())
            {
                var disc = _sRepo.GetFirstFiltredDisciplines(d => d.DisciplineId == exam.DisciplineId);

                if (disc == null || !(disc.Attestation == 2 || disc.Attestation == 3))
                {
                    examsToRemove.Add(exam.ExamId);
                }
            }

            foreach (var examId in examsToRemove)
            {
                var logIds = GetAllLogEvents()
                    .Where(le => (le.OldExam != null && le.OldExam.ExamId == examId) || (le.NewExam != null && le.NewExam.ExamId == examId))
                    .Select(le => le.LogEventId)
                    .ToList();

                foreach (var logId in logIds)
                {
                    RemoveLogEvent(logId);
                }

                RemoveExam(examId);
            }
        }
        public void AddNewExamsFromSchedule(ScheduleRepository _sRepo)
        {
            var examDiscs = _sRepo
                .GetFiltredDisciplines(d => d.Attestation == 2 || d.Attestation == 3)
                .ToList();

            var examDiscIds = GetAllExams()
                .Select(e => e.DisciplineId)
                .ToList();

            foreach (var disc in examDiscs)
            {
                if (examDiscIds.Contains(disc.DisciplineId))
                {
                    continue;
                }

                AddExam(new Exam()
                {
                    DisciplineId = disc.DisciplineId,
                    IsActive = true,
                    ConsultationDateTime = Constants.Constants.DefaultEmptyDateForEvent,
                    ExamDateTime = Constants.Constants.DefaultEmptyDateForEvent
                });
            }
        }
        public List<Exam> GetGroupActiveExams(ScheduleRepository _sRepo, int groupId, bool limitToExactGroup = true)
        {
            List<int> discIds;

            if (limitToExactGroup)
            {
                discIds = _sRepo
                    .GetFiltredDisciplines(d => d.StudentGroup.StudentGroupId == groupId && (d.Attestation == 2 || d.Attestation == 3))
                    .Select(d => d.DisciplineId)
                    .Distinct()
                    .ToList();
            }
            else
            {
                var studentIds = _sRepo.GetFiltredStudentsInGroups(sig => sig.StudentGroup.StudentGroupId == groupId)
                .ToList()
                .Select(stig => stig.Student.StudentId);

                var groupsListIds = _sRepo.GetFiltredStudentsInGroups(sig => studentIds.Contains(sig.Student.StudentId))
                    .ToList()
                    .Select(stig => stig.StudentGroup.StudentGroupId);

                discIds = _sRepo
                    .GetFiltredDisciplines(d => groupsListIds.Contains(d.StudentGroup.StudentGroupId) && (d.Attestation == 2 || d.Attestation == 3))
                    .Select(d => d.DisciplineId)
                    .Distinct()
                    .ToList();
            }

            return GetFiltredExams(e => discIds.Contains(e.DisciplineId) && e.IsActive)
                .OrderBy(e => e.ConsultationDateTime)
                .ToList();
        }