/// <summary>
/// 计算出学习计划的学习进度
/// </summary>
/// <param name="studentId">学员用户ID</param>
/// <param name="plans">学员的学习计划</param>
/// <param name="chapters">学员学习过的课程章节</param>
/// <returns></returns>
private Dictionary <long, float> CalculatePlanProgress(long studentId, List <PlanCoursesModel> plans, Dictionary <CourseStatusModel, List <ChapterStatusModel> > chapters)
{
Dictionary <long, float> planProgress = new Dictionary <long, float>();
//当前用户计划下的课程ID集合
var studentCourseIds = GetCourseIdsFor(new[] { plans });
//获取用户相关课程下学习过的章节ID集合
var studiedChapterIds = StudyRecordAccessor.GetChapterIdsFor(studentId, studentCourseIds);
//进度计算器
StudyProgressComputer computer = null;
//遍历计划，计算对应的计划学习进度
foreach (var plan in plans)
{
var planCourseIds = plan.Courses;
var planCourseChapters = chapters.Where(p => planCourseIds.Contains(p.Key.CourseId)).ToDictionary(k => k.Key, v => v.Value);
computer = new StudyProgressComputer(new StudyProgressComputerState
{
PlanId = plan.PlanId,
CourseChapters = planCourseChapters,
StudiedChapterIds = studiedChapterIds
});
var progress = computer.Calculate();
planProgress.Add(plan.PlanId, progress);
}
return(planProgress);
}
/// <summary>
/// 如果检测到该课程已学习完成，将更新用户课程完成数量
/// </summary>
public override void Execute()
{
Validate();
var state = State as CourseStudyFinishedCheckEventState;
//获取课程下的所有章节状态信息
var courseChapters = ChapterAccessor.GetChaptersAllFor(state.CoureseId);
//有效的课程章节
var enableChapters = courseChapters.Where(p => p.Status == (int)ChapterStatus.ENABLED);
//有效的课程章节ID集合
var enabledChapterIds = enableChapters.Select(p => p.ChapterId);
//有效的课程章节数
var enabledCount = enableChapters != null?enableChapters.Count() : 0;
//获取用户当前课程学习过的章节信息
var studiedChapters = StudyRecordAccessor.GetChapterIdsFor(state.StudentId, state.CoureseId);
//已学习过的课程章节数
var studiedCount = studiedChapters.Count(p => enabledChapterIds.Contains(p));
//如果：课程中开启的章节数均已学习完成，则更新用户课程完成数
if (enabledCount == studiedCount)
{
UserStudyAccessor.UpdateReadedCourse(state.StudentId, 1);
}
}
private void InitData()
{
if (Chapter != null)
{
//尝试获取该课程章节的学习记录
Record = StudyRecordAccessor.GetStudyRecord(StudentId, Chapter.ChapterId);
ID = Record != null ? Record.RecordId : IDProvider.NewId;
}
}
/// <summary>
/// 添加学习记录
/// </summary>
/// <returns></returns>
private bool Add()
{
var record = new StudyRecord
{
RecordId = ID,
UserId = StudentId,
CourseId = Chapter.CourseId,
ChapterId = Chapter.ChapterId,
ReadCount = 1,
CreateTime = DateTime.Now,
UpdateTime = DateTime.Now
};
return(StudyRecordAccessor.Insert(record));
}
public override void Execute()
{
var state = State as StudyRecordTimesUpdateEventState;
Validate();
//获取章节的所有父级章节ID
var chapterIds = ChapterAccessor.GetParentsIds(state.ChapterId);
if (state.IncludeMySelf)
{
chapterIds.Add(state.ChapterId);
}
StudyRecordAccessor.AddOnceTimesForStudy(state.StudentId, chapterIds);
}
/// <summary>
/// 计算课程的学习进度
/// </summary>
/// <returns></returns>
public float Calculate()
{
//获取用户学习过的章节数
long[] studied = StudyRecordAccessor.GetChapterIdsFor(UserId, CourseId);
//当前课程未学习过任何章节，学习进度为0
if (studied == null || studied.Length == 0)
{
return(0F);
}
//获取课程下的章节数
var chapters = ChapterAccessor.GetChaptersAllFor(CourseId);
//有效的章节（即状态为启用的章节）
var effectIds = chapters.Where(p => p.Status == (int)ChapterStatus.ENABLED).Select(p => p.ChapterId);
//有效章节的学习数量
var studiedCount = (decimal)effectIds.Intersect(studied).Count();
return((float)Math.Round(studiedCount / effectIds.Count(), 2, MidpointRounding.ToEven));
}
/// <summary>
/// 更新学习次数
/// </summary>
/// <returns></returns>
private bool Update()
{
return(StudyRecordAccessor.AddOnceTimesForStudy(ID));
}
/// <summary>
/// 获取学员学习过的章节集合
/// </summary>
/// <param name="studentId">学员ID</param>
/// <returns></returns>
public long[] GetStudiedChapterIds(long studentId)
{
return(StudyRecordAccessor.GetChapterIdsFor(studentId, ID));
}
