public ActionResult Start(int id, string courseTC, int?moduleSetId)
{
var test = TestService.GetFullTest(id);
var groupTest = StudentInGroupService.GetUserGroupTest(id);
if (groupTest != null && groupTest.AttemptCount.HasValue)
{
var count = UserTestService.GetUserTests(groupTest)
.Count(x => x.UserId == GetUserId(false));
if (count >= groupTest.AttemptCount.Value)
{
return(BaseView(new PagePart("Вы использовали все попытки для сдачи теста")));
}
}
var userTests = GetCurrentTests();
var userTest = userTests.FirstOrDefault(x => x.TestId == id &&
x.UserId == GetUserId(courseTC != null));
if (userTest == null)
{
var rule = test.TestPassRule;
if (groupTest != null)
{
rule = groupTest.TestPassRule;
}
if (moduleSetId.HasValue)
{
rule = TestModuleSetService.GetValues(moduleSetId.Value,
x => x.TestPassRule);
}
var showAnswers = false;
// if (User.GetOrDefault(x => x.Student_ID) > 0) {
// var paidCourses = StudentService.GetPaidCourseTCs(User.Student_ID.Value);
// showAnswers = test.CourseTCSplitList.Intersect(paidCourses).Any();
// }
userTest = SaveUserTest(id, test, rule, courseTC, moduleSetId, showAnswers);
}
var model = new TestRunVM {
Test = test, UserTest = userTest
};
if (userTest.IsPrerequisite)
{
var otherPretests = CoursePrerequisiteService.GetTestIds(
courseTC).Skip(1).ToList();
if (otherPretests.Any())
{
model.OtherPreTestQuestions = GetQuestions(otherPretests).ToList();
}
}
if (test.TestIds.Any())
{
model.OtherPreTestQuestions = GetQuestions(test.TestIds).ToList();
}
return(BaseView(new TestRunView(), model));
}
private List <int> GetAllTestIds(UserTest userTest)
{
if (userTest.Test.TestIds.Any())
{
return(userTest.Test.TestIds);
}
if (userTest.IsPrerequisite)
{
return(CoursePrerequisiteService.GetTestIds(
userTest.Course_TC).ToList());
}
return(_.List(userTest.TestId));
}
public ActionResult Prerequisites()
{
var courseTCs = CoursePrerequisiteService.GetAll(x => x.Test_ID != null &&
x.Course.IsActive).Select(x =>
x.Course_TC).ToList();
var courses = CourseService.GetAll()
.Where(x => courseTCs.Contains(x.Course_TC)).ToList();
var sectionCourses = GroupVmService.GetSectionCourses(courses).ToList();
return(BaseView(Views.Test.Prerequisites,
new PrerequisiteTestsVM {
Courses = sectionCourses
}));
}
public ActionResult CourseRecommendations(string id)
{
var model = new List <FullCourseCoef>();
if (!id.IsEmpty())
{
var parentTC = CourseService.GetValues(id, x => x.ParentCourse_TC);
var context = new RecRepository().GetContext();
var coefs = GetCoefs(context, parentTC);
if (coefs.Any())
{
var preCourses = CoursePrerequisiteService.GetAll(x => x.Course_TC == id)
.Select(x => x.RequiredCourse.ParentCourse_TC).ToList();
coefs = coefs.Where(x => !preCourses.Contains(x.Item1)).ToList();
model = GetCourses(coefs);
}
}
return(View(model));
}
ActionResult GetDetailsView(int id, string courseTC, int?moduleSetId)
{
var test = TestService.GetByPK(id);
if (courseTC != null && CoursePrerequisiteService.GetTestIds(
courseTC).All(x => x != id))
{
return(NotFound());
}
if (!StudentInGroupService.CalcTestIsActive(test))
{
return(NotFound());
}
return(BaseView(Views.TestRun.Details, new TestRunDetailsVM {
Test = test,
CourseName = DictionaryUtils.GetValueNotDefaultKey(
CourseService.GetAllActiveCourseNames(), courseTC),
ModuleSetId = moduleSetId,
CourseTC = courseTC,
}));
}
public ActionResult Prerequisite(decimal courseId)
{
var course = CourseService.FirstOrDefault(x => x.Course_ID == courseId);
var courseTC = course.Course_TC;
var coursePrerequisite = CoursePrerequisiteService.GetForCourse(courseTC).FirstOrDefault();
if (coursePrerequisite == null)
{
return(null);
}
TestService.LoadWith(x => x.Author);
var test = TestService.GetByPK(coursePrerequisite.Test_ID);
var preCourses = EntityUtils.GetCoursePreCourses(CoursePrerequisiteService, courseTC)
.Select(x => x.RequiredCourse).ToList();
var model = new PrerequisiteTestVM {
Test = test,
CoursePrerequisite = coursePrerequisite,
Course = course,
PrerequisiteCourses = preCourses
};
return(BaseView(Views.Test.Prerequisite, model));
}
private List <Course> GetCourses(string entityCourseTCList, List <string> completeCourseTC)
{
List <Course> courses;
var courseTCs = StringUtils.SafeSplit(entityCourseTCList);
var unStudyCourseTCs = courseTCs
.Where(x => !completeCourseTC.Contains(x)).ToList();
var prerequsisite = CoursePrerequisiteService.GetAll(x =>
unStudyCourseTCs.Contains(x.Course_TC) &&
x.RequiredCourse_TC != null && x.RequiredCourse.IsActive)
.Select(x => new {
x.Course_TC,
x.RequiredCourse_TC
}).ToList().GroupByToDictionary(x => x.Course_TC,
x => x.RequiredCourse_TC);
courseTCs = courseTCs.SelectMany(x =>
_.List(x).AddFluent(prerequsisite.GetValueOrDefault(x)))
.ToList();
courseTCs = courseTCs.Distinct().ToList();
courses = CourseService.GetAll(x => courseTCs.Contains(x.Course_TC))
.ToList();
return(courses);
}
