public IEnumerable<Concept> GetRootElementsBySubject(int subjectId)
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return repositoriesContainer.ConceptRepository.GetRootElementsBySubjectId(subjectId);
     }
 }

 public IEnumerable<Student> GetStudents()
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return repositoriesContainer.StudentsRepository.GetAll(new Query<Student>().Include(e => e.Group).Include(e => e.User)).ToList();
     }
 }

		public List<Subject> GetGroupSubjects(int groupId)
		{
			using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
			{
				return repositoriesContainer.SubjectRepository.GetSubjects(groupId: groupId).Where(e => !e.IsArchive).ToList();
			}
		}

        public void DeleteLabs(int id)
        {
            using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
            {
                var labs =
                    repositoriesContainer.LabsRepository.GetBy(
                        new Query<Labs>(e => e.Id == id).Include(e => e.StudentLabMarks));

                var deleteFiles =
                        repositoriesContainer.AttachmentRepository.GetAll(
                            new Query<Attachment>(e => e.PathName == labs.Attachments)).ToList();

                var studentLabMarks =
                    repositoriesContainer.RepositoryFor<StudentLabMark>()
                        .GetAll(new Query<StudentLabMark>(e => e.LabId == id))
                        .ToList();

                foreach (var attachment in deleteFiles)
                {
                    FilesManagementService.DeleteFileAttachment(attachment);
                }

                foreach (var mark in studentLabMarks)
                {
                    repositoriesContainer.RepositoryFor<StudentLabMark>().Delete(mark);
                }

                repositoriesContainer.ApplyChanges();

                repositoriesContainer.LabsRepository.Delete(labs);

                repositoriesContainer.ApplyChanges();
            }
        }

 public string GetFileDisplayName(string guid)
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return repositoriesContainer.AttachmentRepository.GetBy(new Query<Attachment>(e => e.FileName == guid)).Name;
     }
 }

 public ICollection<Module> GetModules()
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return repositoriesContainer.ModulesRepository.GetAll().ToList();
     }
 }

 public Concept GetById(int id)
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return repositoriesContainer.ConceptRepository.GetById(id);
     }
 }

 public List<Bug> GetBugs()
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return repositoriesContainer.BugsRepository.GetAll().ToList();
     }
 }

 public List<BugLog> GetBugLogs(int bugId)
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return repositoriesContainer.BugLogsRepository.GetAll(new Query<BugLog>(e => e.BugId == bugId).Include(e => e.User)).ToList();
     }
 }

 public Bug GetBug(int bugId)
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return repositoriesContainer.BugsRepository.GetBy(new Query<Bug>(e => e.Id == bugId));
     }
 }

        public User GetUserByName(string firstName, string lastName, string middleName)
        {
            using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
            {
                var checkPatronymic = !string.IsNullOrEmpty(middleName);

                var lecturers = repositoriesContainer.LecturerRepository.GetAll(
                        new Query<Lecturer>(e =>
                            (e.FirstName == firstName && e.LastName == lastName && !checkPatronymic)
                            || (checkPatronymic && (e.MiddleName == middleName && e.FirstName == firstName && e.LastName == lastName))))
                            .Select(l => l.User).ToList();

                if (lecturers.Any())
                {
                    return lecturers.First();
                }

                var students = repositoriesContainer.StudentsRepository.GetAll(
                        new Query<Student>(e =>
                            (e.FirstName == firstName && e.LastName == lastName && !checkPatronymic)
                            || (checkPatronymic && (e.MiddleName == middleName && e.FirstName == firstName && e.LastName == lastName))))
                            .Select(l => l.User);

                return students.Any() ? students.First() : null;
            }
        }

        private int GetRemainingTime(int testId, int questionId, int userId)
        {
            var test = GetTest(testId);
            TestPassResult testPassResult = GetTestPassResult(testId, userId);

            double seconds = 0;

            if (test.SetTimeForAllTest)
            {
                seconds = (test.TimeForCompleting * 60) - (DateTime.UtcNow - testPassResult.StartTime).TotalSeconds;
            }
            else
            {
                if (testPassResult.Comment == questionId.ToString())
                {
                    seconds = test.TimeForCompleting - ((DateTime.UtcNow.Ticks - testPassResult.StartTime.Ticks) / TimeSpan.TicksPerSecond);
                }
                else
                {
                    seconds = test.TimeForCompleting;
                    testPassResult.StartTime = DateTime.UtcNow;
                    testPassResult.Comment = questionId.ToString();
                }

                using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
                {
                    repositoriesContainer.RepositoryFor<TestPassResult>().Save(testPassResult);
                    repositoriesContainer.ApplyChanges();
                }
            }

            return seconds > 0 ? (int)seconds : 0;
        }

 public List<ProjectUser> GetProjectsOfUser(int userId)
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return repositoriesContainer.ProjectUsersRepository.GetAll(new Query<ProjectUser>(e => e.UserId == userId).Include(e => e.Project).Include(e => e.User).Include(e => e.ProjectRole)).ToList();
     }
 }

 public IEnumerable<Concept> GetRootElements(Int32 authorId)
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return repositoriesContainer.ConceptRepository.GetRootElementsByAuthorId(authorId);
     }
 }

 public ProjectUser GetProjectUser(int projectUserId)
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return repositoriesContainer.ProjectUsersRepository.GetBy(new Query<ProjectUser>(e => e.Id == projectUserId).Include(e => e.Project).Include(e => e.User).Include(e => e.ProjectRole));
     }
 }

        public Question SaveQuestion(Question question)
        {
            CheckForTestIsNotLocked(question.TestId);

            ValidateQuestion(question);

            using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
            {
                repositoriesContainer.QuestionsRepository.Save(question);
                Question existingQuestion = GetQuestion(question.Id);
                var answersToDelete = existingQuestion.Answers.Where(a => question.Answers.All(answer => answer.Id != a.Id));

                // TODO: Resolve problem (items are saved only first time)
                foreach (Answer answer in question.Answers)
                {
                    answer.QuestionId = question.Id;
                }

                repositoriesContainer.RepositoryFor<Answer>().Save(question.Answers);
                repositoriesContainer.RepositoryFor<Answer>().Delete(answersToDelete);

                repositoriesContainer.ApplyChanges();
                return question;
            }
        }

 public Group GetGroup(int groupId)
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return repositoriesContainer.GroupsRepository.GetBy(new Query<Group>(e => e.Id == groupId).Include(e => e.Students.Select(x => x.LecturesVisitMarks)));
     }
 }

 public List<Group> GetGroups(IQuery<Group> query = null)
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return repositoriesContainer.GroupsRepository.GetAll(query).ToList();
     }
 }

 public List<Lecturer> GetLecturers()
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return repositoriesContainer.LecturerRepository.GetAll(new Query<Lecturer>().Include(e => e.SubjectLecturers).Include(e => e.User)).ToList();
     }
 }

 public ActionResult GetObjects()
 {
     using (var repositoriesContainer = new LmPlatformRepositoriesContainer())
     {
         return Json(repositoriesContainer.RepositoryFor<ScoObjects>().GetAll(new Query<ScoObjects>(e => !e.IsDeleted)).ToList(), JsonRequestBehavior.AllowGet);
     }
 }