Merge branch 'feature/exam' into test

合并冲突

src/Hotline.Api/Controllers/Exam/ExamManageController.cs

@@ -101,5 +101,16 @@ namespace Hotline.Api.Controllers.Exam
         {
             await _examManageService.UpdateStatus(statusActionRequests, HttpContext.RequestAborted);
         }
+
+        /// <summary>
+        /// 更新考试状态
+        /// </summary>
+        /// <param name="entityQueryRequest"></param>
+        /// <returns></returns>
+        [HttpPost(ExamManageApiRoute.UpdateExamStatus)]
+        public async Task UpdateExamStatus([FromBody] EntityQueryRequest entityQueryRequest)
+        {
+            await _examManageService.UpdateExamStatus(entityQueryRequest, HttpContext.RequestAborted);
+        }
     }
 }

src/Hotline.Application/Exam/Constants/ApiRoutes/ExamManageApiRoute.cs

@@ -5,5 +5,7 @@
         public const string ImportExcel = "ImportExcel";
 
         public const string Download = "Download";
+
+        public const string UpdateExamStatus = "UpdateExamStatus";
     }
 }

src/Hotline.Application/Exam/Interface/ExamManages/IExamManageService.cs

@@ -1,4 +1,5 @@
-using Exam.Share;
+using Exam.Infrastructure.Data.Entity;
+using Exam.Share;
 using Exam.Share.ViewResponses.Exam;
 using Hotline.Exams.ExamManages;
 using Hotline.Repository.SqlSugar.Exam.Interface;
@@ -16,6 +17,13 @@ namespace Hotline.Application.Exam.Interface.ExamManages
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
         public Task GenerateTestPaper(GenerateExamTestPaperRequest generateExamTestPaperRequest, CancellationToken cancellationToken);
-
+        
+        /// <summary>
+        /// 更新考试状态
+        /// </summary>
+        /// <param name="entityQueryRequest"></param>
+        /// <param name="requestAborted"></param>
+        /// <returns></returns>
+        public Task UpdateExamStatus(EntityQueryRequest entityQueryRequest, CancellationToken requestAborted);
     }
 }

src/Hotline.Application/Exam/QueryExtensions/ExamManages/UserExamQueryExtensions.cs

@@ -103,7 +103,9 @@ namespace Hotline.Application.Exam.QueryExtensions.ExamManages
 
             expression = ExpressionableUtility.CreateExpression<ExamUserExam>()
             .AndIF(userExamResultReportPagedRequest.MinScore.IsNotNull(), x => x.Score >= userExamResultReportPagedRequest.MinScore)
-            .AndIF(userExamResultReportPagedRequest.MaxScore.IsNotNull(), x => x.Score <= userExamResultReportPagedRequest.MaxScore)
+            .AndIF(userExamResultReportPagedRequest.MaxScore.IsNotNull() && userExamResultReportPagedRequest.MinScore.IsNull(), x => x.Score <= userExamResultReportPagedRequest.MaxScore || x.Score== null)
+            .AndIF(userExamResultReportPagedRequest.MaxScore.IsNotNull() && userExamResultReportPagedRequest.MinScore.IsNotNull(), x => x.Score <= userExamResultReportPagedRequest.MaxScore)
+            .And(x=>x.ExamStatus == Share.Enums.Exams.EExamStatus.Complete)
             .ToExpression();
 
             return expression;

src/Hotline.Application/Exam/Service/ExamManages/ExamManageService.cs

@@ -328,36 +328,11 @@ namespace Hotline.Application.Exam.Service.ExamManages
             }
         }
 
-        private async Task<List<ExamQuestion>> GetQuestions(ExamManage examManage)
-        {
-            var questionRepository = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-
-            var questionTable = questionRepository.Queryable();
-            var testPaperItemTable = _testPaperItemRepository.Queryable().Where(x => x.TestPaperId == examManage.TestPaperId);
-
-            var questions = questionTable.InnerJoin(testPaperItemTable, (q, t) => q.Id == t.QuestionId)
-                .Select((q, t) => q);
-
-            return await questions.ToListAsync();
-        }
-
-        private async Task<List<ExamTagQuestion>> GetTagQuestions(ExamManage examManage)
+        public async Task UpdateExamStatus(EntityQueryRequest entityQueryRequest, CancellationToken requestAborted)
         {
-            var extractRuleRepository = new ExamRepository<ExamExtractRule>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var ruleTagRepository = new ExamRepository<ExamRuleTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var tagQuestionRepository = new ExamRepository<ExamTagQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-
-          
-            var extractRuleTable = extractRuleRepository.Queryable().Where(x=>x.Id == examManage.ExtractRuleId && x.RuleType == examManage.ExamType);
-            var ruleTagTable = ruleTagRepository.Queryable();
-            var tagQuestionTable = tagQuestionRepository.Queryable();
-
-            var tagQuestions = await tagQuestionTable
-                .InnerJoin(ruleTagTable, (q, rt) => q.TagId == rt.TagId)
-                .InnerJoin(extractRuleTable, (q, rt, x) => rt.RuleId == x.Id)
-                .Select((q, rt, x) => q).ToListAsync();
+            List<ExamManage> examManages = await UpdateExamManageStatus(entityQueryRequest, requestAborted);
 
-            return tagQuestions;
+            //await UdpateUserExam(examManages, requestAborted);
 
         }
         #endregion
@@ -679,6 +654,74 @@ namespace Hotline.Application.Exam.Service.ExamManages
             }
 
         }
+
+        private async Task<List<ExamQuestion>> GetQuestions(ExamManage examManage)
+        {
+            var questionRepository = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+
+            var questionTable = questionRepository.Queryable();
+            var testPaperItemTable = _testPaperItemRepository.Queryable().Where(x => x.TestPaperId == examManage.TestPaperId);
+
+            var questions = questionTable.InnerJoin(testPaperItemTable, (q, t) => q.Id == t.QuestionId)
+                .Select((q, t) => q);
+
+            return await questions.ToListAsync();
+        }
+
+        private async Task<List<ExamTagQuestion>> GetTagQuestions(ExamManage examManage)
+        {
+            var extractRuleRepository = new ExamRepository<ExamExtractRule>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var ruleTagRepository = new ExamRepository<ExamRuleTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var tagQuestionRepository = new ExamRepository<ExamTagQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+
+
+            var extractRuleTable = extractRuleRepository.Queryable().Where(x => x.Id == examManage.ExtractRuleId && x.RuleType == examManage.ExamType);
+            var ruleTagTable = ruleTagRepository.Queryable();
+            var tagQuestionTable = tagQuestionRepository.Queryable();
+
+            var tagQuestions = await tagQuestionTable
+                .InnerJoin(ruleTagTable, (q, rt) => q.TagId == rt.TagId)
+                .InnerJoin(extractRuleTable, (q, rt, x) => rt.RuleId == x.Id)
+                .Select((q, rt, x) => q).ToListAsync();
+
+            return tagQuestions;
+
+        }
+
+
+        private async Task UdpateUserExam(List<ExamManage> examManages, CancellationToken requestAborted)
+        {
+            var examIds = examManages.Select(x => x.Id).ToList();
+            var userExams = await _userExamRepository.Queryable().Where(x => examIds.Contains(x.ExamId)).ToListAsync();
+
+            userExams.ForEach(item =>
+            {
+                item.ExamStatus = Share.Enums.Exams.EExamStatus.Complete;
+            });
+
+            userExams.ToUpdate(_sessionContext);
+
+            await _userExamRepository.UpdateWithValidateAsync(userExams, requestAborted);
+        }
+
+        private async Task<List<ExamManage>> UpdateExamManageStatus(EntityQueryRequest entityQueryRequest, CancellationToken requestAborted)
+        {
+            var queryable = _repository.Queryable()
+                .WhereIF(entityQueryRequest != null && entityQueryRequest.Ids != null, x => entityQueryRequest.Ids.Contains(x.Id))
+                .Where(x => x.EndTime < DateTime.Now);
+            var examManages = await queryable.ToListAsync();
+
+            examManages.ForEach(item =>
+            {
+                item.ExamStatus = Share.Enums.Exams.EExamStatus.Complete;
+            });
+
+            examManages.ToUpdate(_sessionContext);
+
+            await _repository.UpdateWithValidateAsync(examManages, requestAborted);
+
+            return examManages;
+        }
         #endregion
     }
 }

src/Hotline.Application/Exam/Service/ExamManages/UserExamService.cs

@@ -644,7 +644,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
         public async Task<UnExamUserPageViewResponse> GetUnExamUsers(UnExamUserReportPagedRequest unExamUserReportPagedRequest)
         {
-            unExamUserReportPagedRequest.ResoleEndTime();
+            unExamUserReportPagedRequest.ResolveEndTime();
 
             var examManageRepository = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var userRepository = new ExamRepository<User>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
@@ -677,7 +677,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
         public async Task<UserExamResultPageViewResponse> GetUserExamResults(UserExamResultReportPagedRequest userExamResultReportPagedRequest)
         {
-            userExamResultReportPagedRequest.ResoleEndTime();
+            userExamResultReportPagedRequest.ResolveEndTime();
 
             var examManageRepository = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var userRepository = new ExamRepository<User>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
@@ -699,7 +699,9 @@ namespace Hotline.Application.Exam.Service.ExamManages
                     CutoffScore = e.CutoffScore,
                     Score = ue.Score ?? 0,
 
-                });
+                })
+                .MergeTable()
+                .OrderByDescending(x => x.Score);
 
             var total = await queryResult.CountAsync();
             var items = await queryResult.ToPageListAsync(userExamResultReportPagedRequest.PageIndex, userExamResultReportPagedRequest.PageSize);

src/Hotline.Application/Exam/Service/Trains/TrainRecordService.cs

@@ -208,7 +208,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
         public async Task<TrainResultPagedViewResponse> AnalysisTrainResult(TrainResultReportPagedRequest trainResultReportPagedRequest)
         {
-            trainResultReportPagedRequest.ResoleEndTime();
+            trainResultReportPagedRequest.ResolveEndTime();
 
             var expression = trainResultReportPagedRequest.GetExpression();
             var templateExpression = trainResultReportPagedRequest.GetTemplateExpression();
@@ -250,7 +250,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
         public async Task<TrainResultRateViewResponse> CalcuteAnalysisRate(TrainResultReportPagedRequest trainResultReportPagedRequest)
         {
-            trainResultReportPagedRequest.ResoleEndTime();
+            trainResultReportPagedRequest.ResolveEndTime();
 
             var expression = trainResultReportPagedRequest.GetExpression();
             var templateExpression = trainResultReportPagedRequest.GetTemplateExpression();

src/Hotline.Repository.SqlSugar/Exam/Validators/ExamManages/ExamManageValidator.cs

@@ -45,7 +45,7 @@ namespace Exam.Application
 
             RuleFor(m => m.Name).NotEmpty().WithMessage(x=>string.Format(ExamErrorMessage.IsRequired,x.GetType().GetDescription(nameof(ExamManage.Name))));
             RuleFor(m => m.Code).NotEmpty().WithMessage(x => string.Format(ExamErrorMessage.IsRequired, x.GetType().GetDescription(nameof(ExamManage.Code))));
-            RuleFor(m => m.CutoffScore).NotEmpty().WithMessage(x => string.Format(ExamErrorMessage.IsRequired, x.GetType().GetDescription(nameof(ExamManage.CutoffScore))));
+            RuleFor(m => m.CutoffScore).NotNull().WithMessage(x => string.Format(ExamErrorMessage.IsRequired, x.GetType().GetDescription(nameof(ExamManage.CutoffScore))));
             RuleFor(m => m.ExamType).NotNull().WithMessage(x => string.Format(ExamErrorMessage.IsRequired, x.GetType().GetDescription(nameof(ExamManage.ExamType))));
             RuleFor(m => m.Method).NotNull().WithMessage(x => string.Format(ExamErrorMessage.IsRequired, x.GetType().GetDescription(nameof(ExamManage.Method))));
             //RuleFor(m => m.TestPaperId).NotEmpty().WithMessage(x => string.Format(ExamErrorMessage.IsRequired, typeof(ExamTestPaper).GetDescription()));
@@ -55,7 +55,7 @@ namespace Exam.Application
             RuleFor(m => m.EndTime).NotNull().WithMessage(x => string.Format(ExamErrorMessage.IsRequired, x.GetType().GetDescription(nameof(ExamManage.EndTime))));
             RuleFor(m => m.EndTime).Must((e, v) => e.ExamType == EExamType.Simulate || e.StartTime < v).WithMessage(x => string.Format(ExamErrorMessage.Greater, x.GetType().GetDescription(nameof(ExamManage.EndTime)), x.GetType().GetDescription(nameof(ExamManage.StartTime))));
             RuleFor(m => m.TotalScore).NotNull().WithMessage(x => string.Format(ExamErrorMessage.IsRequired, x.GetType().GetDescription(nameof(ExamManage.TotalScore))));
-            RuleFor(m => m.CutoffScore).Must((e, v)=> e.TotalScore > v).WithMessage(x => string.Format(ExamErrorMessage.Greater, x.GetType().GetDescription(nameof(ExamManage.CutoffScore)), x.GetType().GetDescription(nameof(ExamManage.TotalScore))));
+            RuleFor(m => m.CutoffScore).Must((e, v)=> e.TotalScore >= v).WithMessage(x => string.Format(ExamErrorMessage.Greater, x.GetType().GetDescription(nameof(ExamManage.CutoffScore)), x.GetType().GetDescription(nameof(ExamManage.TotalScore))));
         }
 
         protected override void ValidateRuleWithAdd()

src/Hotline.Share/Exams/Extensions/ReportPagedRequestExtensions.cs

@@ -4,8 +4,10 @@ namespace Hotline.Share.Exams.Extensions
 {
     public static class ReportPagedRequestExtensions
     {
-        public static void ResoleEndTime<T>(this T analysisReportRequest)where T :AnalysisReportRequest
+        public static void ResolveEndTime<T>(this T analysisReportRequest)where T :AnalysisReportRequest
         {
+            if (analysisReportRequest.StartTime == null) return;
+
             switch (analysisReportRequest.AnlysisType)
             {
                 case Share.Enums.Exams.EAnlysisType.Day:

src/Hotline.Share/Requests/Exam/UserExamResultReportPagedRequest.cs

@@ -9,13 +9,13 @@ namespace Hotline.Share.Requests.Exam
         /// 最小分数
         /// </summary>
         [Description("最小分数")]
-        public int MinScore { get; set; }
+        public int? MinScore { get; set; }
 
         /// <summary>
         /// 最大分数
         /// </summary>
 
         [Description("最大分数")]
-        public int MaxScore { get; set; }
+        public int? MaxScore { get; set; }
     }
 }