public PagerModel <UserExamSearchResultItem> Search()
{
ThrowExceptionIfValidateFailure();
PagerModel <ExamUsers> searchPager = new PagerModel <ExamUsers>
{
Index = PageIndex,
Size = PageSize
};
//搜索结果
searchPager = ExamUsersAccessor.GetList(searchPager,
userId: StudentId,
examId: ExamId,
markingStatus: Status);
//转换后的结果数据
var resultData = ConvertToSearchResult(searchPager.Table);
//处理并输出结果
return(new PagerModel <UserExamSearchResultItem>
{
Count = searchPager.Count,
Index = searchPager.Index,
Size = searchPager.Size,
Table = resultData != null?resultData.ToList() : new List <UserExamSearchResultItem>()
});
}
/// <summary>
/// 统计我的考卷
/// </summary>
/// <returns></returns>
public ExamStatistics StatisticsForExams()
{
var exams = ExamUsersAccessor.GetListFor(ID);
var result = new ExamStatistics();
//总数
result.TotalExams = exams.Count();
result.TotalReviewed = exams.Where(p => p.MarkingStatus == (int)ExamMarkingStatus.READED).Count();
result.TotalWaitReview = exams.Where(p => p.PostTime.HasValue && p.MarkingStatus == (int)ExamMarkingStatus.DIDNOT_READ).Count();
return(result);
}
/// <summary>
/// 删除用户考卷信息
/// </summary>
/// <param name="deleteUser">执行删除操作的用户ID</param>
/// <returns></returns>
public bool Delete(long deleteUser)
{
ThrowExceptionIfValidateFailure(() =>
{
if (!CanDelete())
{
AddBrokenRule(UserExamMarkingFailureRule.CANNOT_DELETE);
}
else if (UserExam.UserId != deleteUser)
{
AddBrokenRule(UserExamMarkingFailureRule.NOACCESS_DELETE_THE_OTHERS);
}
});
return(ExamUsersAccessor.Remove(UserExam));
}
/// <summary>
/// 保存用户参考的考卷信息
/// </summary>
/// <returns></returns>
public bool Save()
{
ThrowExceptionIfValidateFailure();
//题目及作答结果JSON
string questionResultJson = JsonUtility.JsonSerializeObject(request.QuestionsResults);
//用户参考试卷数据初始化
var examUser = new Data.Entity.ExamUsers
{
Id = ID,
ExamId = request.ExamId,
UserId = request.UserId,
CreateTime = request.CreateTime,
Answer = questionResultJson,
MarkingStatus = (int)ExamMarkingStatus.DIDNOT_READ,
MarkingTime = null,
PostTime = null,
Times = 0,
Total = 0
};
//**调用仓储服务存储，并调用考卷使用事件**
// 1、存储
bool success = ExamUsersAccessor.Insert(examUser);
// 2、调用考卷使用事件
if (success)
{
eventsChannels.Clear();
eventsChannels.AddEvent(new ExamUsedEvent(new ExamUsedEventState {
ExamId = request.ExamId
}));
eventsChannels.Execute();
}
return(success);
}
/// <summary>
/// 提交阅卷成绩
/// </summary>
/// <param name="reviewUserId">阅卷人用户ID</param>
/// <param name="QuestionScores"></param>
/// <returns></returns>
public bool SubmitMarking(long reviewUserId, Dictionary <long, int> QuestionScores)
{
ThrowExceptionIfValidateFailure(() =>
{
if (!CanMarking())
{
AddBrokenRule(UserExamMarkingFailureRule.STATUS_CANNOT_MARKING);
}
else if (QuestionScores == null || QuestionScores.Count() < 1)
{
AddBrokenRule(UserExamMarkingFailureRule.MARKING_QUESTION_SCORES_EXCEPTION);
}
else if (QuestionScores.Count() != QuestionSummaryList.Count())
{
AddBrokenRule(UserExamMarkingFailureRule.MARKING_QUESTION_SCORES_EXCEPTION);
}
//循环遍历每一题的得分并记录，检测到未提交得分或得分异常时抛出异常
foreach (var item in QuestionSummaryList)
{
if (!QuestionScores.ContainsKey(item.QuestionId))
{
AddBrokenRule(UserExamMarkingFailureRule.PARTOF_QUESTION_NO_SCORE);
break;
}
int score = QuestionScores[item.QuestionId];
if (score > item.Score)
{
AddBrokenRule(UserExamMarkingFailureRule.QUESTION_LAST_SCORE_CANNOT_GREATERTHAN_SCORE);
break;
}
item.ActualScore = score;
}
});
//更新用户考卷信息
userExam.MarkingStatus = (int)ExamMarkingStatus.READED;
userExam.MarkingTime = DateTime.Now;
userExam.Answer = JsonUtility.JsonSerializeObject(QuestionSummaryList);
userExam.Total = QuestionSummaryList.Sum(p => p.ActualScore);
//调用仓储服务更新
bool success = ExamUsersAccessor.Update(UserExam);
if (success)
{
//阅卷完成后的通知事件
var @event = new MarkingCompleteNoticeEvent(new MarkingCompleteNoticeEventState
{
ReviewUser = reviewUserId,
Exam = Exam,
UserExam = UserExam
});
eventsChannels.AddEvent(@event);
eventsChannels.Execute();
}
return(success);
}
/// <summary>
/// 提交考卷作答结果
/// </summary>
/// <returns></returns>
public bool SubmitResult()
{
//原考卷的初始化的所有题目信息
List <UserExamQuestionResult> questionResults = null;
//验证业务数据规则
ThrowExceptionIfValidateFailure(() =>
{
//解析出考卷的所有题目
questionResults = JsonUtility.JsonDeserialize <List <UserExamQuestionResult> >(UserExam.Answer);
if (questionResults == null || questionResults.Count() < 1)
{
AddBrokenRule(SubmitExamPaperFailureRule.USER_EXAM_QUTIONS_EXCEPTION);
}
else
{
//题目ID集合
var questionIds = questionResults.Select(p => p.QuestionId).ToArray();
//用户提交答案的题目ID集合
var submitQuestionIds = request.AnswerResults.Keys;
//交集数量
var intersectCount = questionIds.Intersect(submitQuestionIds).Count();
//交卷时的作答题目与考卷的题目不符时，视为错误的交卷
if (intersectCount != questionIds.Count())
{
AddBrokenRule(SubmitExamPaperFailureRule.ANSWERS_RESULT_INCOMPLETE);
}
}
});
//保存答题结果，并触发答题事件
// 1、先逐题记录答案
foreach (var item in questionResults)
{
//本题作答结果
string userAnswer = Request.AnswerResults[item.QuestionId];
//记录到当前题目的答题结果中
item.Result = userAnswer;
}
// 2、保存答题结果
userExam.Answer = JsonUtility.JsonSerializeObject(questionResults);
userExam.PostTime = DateTime.Now;
userExam.Times = unchecked ((int)Math.Floor(DateTime.Now.Subtract(userExam.CreateTime).TotalMinutes)); //交卷时间-考卷创建时间=答题的总分钟数
bool success = ExamUsersAccessor.Update(UserExam);
// 2、触发答题事件
if (success)
{
eventsChannels.Clear();
eventsChannels.AddEvent(new ExamUserSubmitEvent(new ExamUserSubmitEventState
{
UserExamId = Request.UserExamId,
ExamId = UserExam.ExamId,
UserId = Request.UserId
}));
eventsChannels.Execute();
}
return(success);
}
