Merge branch 'test' of http://110.188.24.182:10023/Fengwo/hotline into test

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

@@ -604,7 +604,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             var expression = queryRequest.GetExpression();
             var questionTable = _repository.Queryable().Where(expression);
 
-            var queryable = questionTable.Select(e => new ExamManageViewResponse
+            var queryable = questionTable.OrderBy(e => e.CreationTime).Select(e => new ExamManageViewResponse
             {
                 Id = e.Id,
                 Code = e.Code,

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

@@ -46,6 +46,8 @@ using Hotline.Exams.Questions;
 using Hotline.Exams.Sourcewares;
 using Hotline.Share.Dtos.Questions;
 using DocumentFormat.OpenXml.Office2010.Excel;
+using System.Linq.Expressions;
+using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
 
 namespace Hotline.Application.Exam.Service.ExamManages
 {
@@ -359,7 +361,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
                 IsJoin = false
             };
 
-            if (userExam.StartTime == null || userExam.ExamStatus == EExamStatus.Complete)
+            if (userExam.ExamStatus == EExamStatus.NoStart || userExam.ExamStatus == EExamStatus.Complete)
                 userExam.StartTime = DateTime.Now;
 
             var startExamViewResponse = await CheckExamValid(userExam, cancellationToken);
@@ -618,6 +620,35 @@ namespace Hotline.Application.Exam.Service.ExamManages
         public async Task<List<GradingExamQuestionDto>> GetGradingExamQuestion(GradingExamRequest gradingExamRequest)
         {
             var expression = gradingExamRequest.GetExpression();
+
+            ISugarQueryable<GradingExamQuestionTempDto> queryable = GetViewExamQuestionTempDtos(expression);
+
+            queryable =
+            queryable.MergeTable().Where((q) => !(q.QuestionType == EQuestionType.Single || q.QuestionType == EQuestionType.Multi || q.QuestionType == EQuestionType.Judge));
+
+            var queryResult = await queryable.ToListAsync();
+
+            var gradingExamQuestionDtos = queryResult.GroupBy(x => new
+            {
+                Id = x.Id,
+                QuestionType = x.QuestionType
+            }).Select(g => new GradingExamQuestionDto
+            {
+                Answer = g.FirstOrDefault().Answer,
+                QuestionType = g.Key.QuestionType,
+                Id = g.Key.Id,
+                QuestionScore = g.FirstOrDefault().QuestionScore,
+                Score = g.FirstOrDefault().Score,
+                Title = g.FirstOrDefault().Title,
+                CorrectAnswer = g.Key.QuestionType.CheckSelectType() ? string.Join(",", g.Where(i => i.IsAnswer).Select(n => n.Label).Distinct()) : g.FirstOrDefault()?.CorrectAnswer
+            }).ToList();
+
+            return gradingExamQuestionDtos;
+        }
+
+        private ISugarQueryable<GradingExamQuestionTempDto> GetViewExamQuestionTempDtos(Expression<Func<ExamUserExam,bool>> expression)
+        {
+           
             var userExamTable = _repository.Queryable().Where(expression);
 
             var questionScoreRepository = new ExamRepository<ExamQuestionScoreBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
@@ -630,14 +661,13 @@ namespace Hotline.Application.Exam.Service.ExamManages
             var testPaperItemAnswerTable = new ExamRepository<ExamQuestionAnswerBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
             var questionScoreTable = questionScoreRepository.Queryable();
 
-            var queryable = userExamTable.InnerJoin(userExamItemTable, (e, i) => e.Id == i.UserExamId)
-                .InnerJoin(questionTable, (e, i, q) => i.QuestionId == q.QuestionId)
+            return userExamTable.InnerJoin(userExamItemTable, (e, i) => e.Id == i.UserExamId)
+                .InnerJoin(questionTable, (e, i, q) => i.QuestionId == q.QuestionId && q.ExamId == e.ExamId )
                 .LeftJoin(userExamItemOptionTable, (e, i, q, o) => i.Id == o.UserExamItemId)
                 .LeftJoin(quesitonOptionTable, (e, i, q, o, qo) => o.QuestionOptionId == qo.Id)
                 .LeftJoin(examAnswerTable, (e, i, q, o, qo, a) => i.Id == a.UserExamItemId)
                 .LeftJoin(testPaperItemAnswerTable, (e, i, q, o, qo, a, ta) => ta.QuestionId == q.QuestionId)
                 .InnerJoin(questionScoreTable, (e, i, q, o, qo, a, ta, s) => q.QuestionType == s.QuestionType && e.ExamId == s.ExamManageId)
-            .Where((e, i, q, o, qo, a, ta, s) => !(q.QuestionType == EQuestionType.Single || q.QuestionType == EQuestionType.Multi || q.QuestionType == EQuestionType.Judge))
             .Select(
             (e, i, q, o, qo, a, ta, s) => new GradingExamQuestionTempDto
             {
@@ -647,6 +677,8 @@ namespace Hotline.Application.Exam.Service.ExamManages
                 Answer = a.Id != null ? a.Answer : string.Empty,
                 Title = q.Title,
                 QuestionOptionId = o.Id,
+                QuestionId = q.QuestionId,
+                ExamQuestionId = q.Id,
                 UserExamItemId = i.Id,
                 Content = qo.Content,
                 Label = qo.Label,
@@ -656,28 +688,8 @@ namespace Hotline.Application.Exam.Service.ExamManages
                 Score = i.Score
             }
                 );
-
-            var queryResult = await queryable.ToListAsync();
-
-            var gradingExamQuestionDtos = queryResult.GroupBy(x => new
-            {
-                Id = x.Id,
-                QuestionType = x.QuestionType
-            }).Select(g => new GradingExamQuestionDto
-            {
-                Answer = g.FirstOrDefault().Answer,
-                QuestionType = g.Key.QuestionType,
-                Id = g.Key.Id,
-                QuestionScore = g.FirstOrDefault().QuestionScore,
-                Score = g.FirstOrDefault().Score,
-                Title = g.FirstOrDefault().Title,
-                CorrectAnswer = g.Key.QuestionType.CheckSelectType() ? string.Join(",", g.Where(i => i.IsAnswer).Select(n => n.Label).Distinct()) : g.FirstOrDefault()?.CorrectAnswer
-            }).ToList();
-
-            return gradingExamQuestionDtos;
         }
 
-
         public async Task<GradingExamQuestionDto> ViewGradingExamQuestion(ViewGradingExamRequest viewGradingExamRequest)
         {
             var gradingExtamItemDto = _mapper.Map<ViewGradingExamRequest, GradingExamItemDto>(viewGradingExamRequest);
@@ -835,6 +847,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
                         QuestionId = u.QuestionId,
                         QuestionType = q.QuestionType,
                         UserExamId = u.UserExamId,
+                        Id = u.Id
                     }).Distinct().ToListAsync();
                 await CalcuteExamItemScore(_userExamItemRepository, userExamItemsInCheck, cancellationToken);
 
@@ -899,31 +912,24 @@ namespace Hotline.Application.Exam.Service.ExamManages
             var userExamIds = addUserExamItemDtos.Select(x => x.UserExamId).ToList();
             var questionTypes = addUserExamItemDtos.Select(x => x.QuestionType).ToList();
 
-            var testPaperItemOptionsRepository = new ExamRepository<ExamQuestionOptionsBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            List<ExamQuestionOptionsBak> examQuestionOptions = await GetQuestionOptionBaks(questionIds, userExamIds,true).ToListAsync();
+
             var userExamItemOptionRepository = new ExamRepository<ExamUserExamItemOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var examManageRepository = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var testPaperItemRepository = new ExamRepository<Exams.ExamManages.ExamQuestionBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var examQuestionScoreRepository = new ExamRepository<ExamQuestionScoreBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var testPaperOptionsTable = testPaperItemOptionsRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId) && x.IsAnswer);
-            var testPaperItemTable = testPaperItemRepository.Queryable().Where(x => x.QuestionType == EQuestionType.Single || x.QuestionType == EQuestionType.Multi || x.QuestionType == EQuestionType.Judge);
             var userExamTable = _repository.Queryable().Where(x => userExamIds.Contains(x.Id));
-            var examManageTable = examManageRepository.Queryable();
-            var testPaperOptionIds = await testPaperOptionsTable.InnerJoin(testPaperItemTable, (t, i) => t.ExamQuestionId == i.Id)
-                .InnerJoin(examManageTable, (t, i, e) => i.ExamId == e.Id)
-                .InnerJoin(userExamTable, (t, i, e, u) => e.Id == u.ExamId)
-                .Select((t, i, e, u) => t.Id).ToListAsync();
 
             var userExamItems = await userExamItemRepository.Queryable().Where(x => userExamIds.Contains(x.UserExamId)).ToListAsync();
             var userExamItemIds = userExamItems.Select(x => x.Id).ToList();
             var userExamItemOptions = await userExamItemOptionRepository.Queryable().Where(x => userExamItemIds.Contains(x.UserExamItemId)).ToListAsync();
             var examQuesiontScores = await examQuestionScoreRepository.Queryable().Where(x => questionTypes.Contains(x.QuestionType))
-                .InnerJoin(userExamTable, (e, u) => e.Id == u.ExamId)
+                .InnerJoin(userExamTable, (e, u) => e.ExamManageId == u.ExamId)
                 .Select((e, u) => e).ToListAsync();
 
 
             foreach (var addUserExamItemDto in addUserExamItemDtos)
             {
-                var isCorrect = userExamItemOptions.Select(x => x.QuestionOptionId).OrderBy(x => x).SequenceEqual(testPaperOptionIds.OrderBy(x => x));
+                var examQuestionOptionIds = examQuestionOptions.Where(x => x.QuestionId == addUserExamItemDto.QuestionId).Select(x => x.Id).ToList();
+                var isCorrect = userExamItemOptions.Where(x => x.UserExamItemId == addUserExamItemDto.Id).Select(x => x.QuestionOptionId).OrderBy(x => x).SequenceEqual(examQuestionOptionIds.OrderBy(x => x));
                 var userExamItem = userExamItems.FirstOrDefault(x => x.QuestionId == addUserExamItemDto.QuestionId);
                 if (userExamItem != null)
                 {
@@ -937,6 +943,32 @@ namespace Hotline.Application.Exam.Service.ExamManages
             await userExamItemRepository.UpdateWithValidateAsync(userExamItems, cancellationToken);
         }
 
+        private ISugarQueryable<ExamQuestionOptionsBak> GetQuestionOptionBaks(List<string> questionIds, List<string> userExamIds,bool isFilterAnswer)
+        {
+            var questionRepository = new ExamRepository<Exams.ExamManages.ExamQuestionBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionTable = questionRepository.Queryable().Where(x => x.QuestionType == EQuestionType.Single || x.QuestionType == EQuestionType.Multi || x.QuestionType == EQuestionType.Judge);
+            var userExamTable = _repository.Queryable().Where(x => userExamIds.Contains(x.Id));
+            var examManageRepository = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var examManageTable = examManageRepository.Queryable();
+            var examQuestionOptionsRepository = new ExamRepository<ExamQuestionOptionsBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var examQuestionOptionsTable = examQuestionOptionsRepository.Queryable()
+                .Where(x => questionIds.Contains(x.QuestionId))
+                .WhereIF(isFilterAnswer,x=>x.IsAnswer);
+            var examQuestionOptions = examQuestionOptionsTable.InnerJoin(questionTable, (t, i) => t.ExamQuestionId == i.Id)
+                .InnerJoin(examManageTable, (t, i, e) => i.ExamId == e.Id)
+                .InnerJoin(userExamTable, (t, i, e, u) => e.Id == u.ExamId)
+                .Select((t, i, e, u) => new ExamQuestionOptionsBak
+                {
+                    Id = t.Id,
+                    Content = t.Content,
+                    IsAnswer = t.IsAnswer,
+                    Label = t.Label,
+                    ExamQuestionId = t.ExamQuestionId,
+                    QuestionId = t.QuestionId
+                });
+            return examQuestionOptions;
+        }
+
         private async Task CalcuteTotalScore(IUserExamItemRepository userExamItemRepository, string userExamId, CancellationToken cancellationToken)
         {
             var userExam = await _repository.GetAsync(x => x.Id == userExamId);
@@ -1327,31 +1359,18 @@ namespace Hotline.Application.Exam.Service.ExamManages
            
             List<ViewExamQuestionDto> viewExamQuestionDtos = await GetViewExamQuestion(id,null);
 
+            var examQuestionIds = viewExamQuestionDtos.Select(x => x.ExamQuestionId).ToList();
             var questionIds = viewExamQuestionDtos.Select(x => x.QuestionId).ToList();
-
-            List<ViewQuestionAnswerDto> questionAnswers = await GetQuestionAnswers(id, questionIds);
-            List<ViewQuestionOptionDto> questionOptions = await GetQuestionOptions( questionIds);
-            List<QuestionKnowladgeDto> questionKnowladges = await GetQuestionKnowladges( questionIds);
-            List<QuestionSourcewareDto> sourcewares = await GetSourcewares(questionIds);
-
-            viewExamQuestionDtos.ForEach(item =>
+            var userExamIds = new List<string>
             {
-                item.QuestionKnowladgeDtos = questionKnowladges.Where(x => x.QuestionId == item.QuestionId).ToList();
-                item.QuestionSourcewareDtos = sourcewares.Where(x => x.QuestionId == item.QuestionId).ToList();
-                if (!item.QuestionType.CheckSelectType())
-                {
-                    var questionAnswer = questionAnswers.FirstOrDefault(x => x.QuestionId == item.QuestionId);
-                    item.Answer = questionAnswer?.Answer ?? string.Empty;
-                    item.CorrectAnswer = questionAnswer?.CorrectAnswer ?? string.Empty;
-                }
-                else
-                {
-                    item.QuestionOptions = questionOptions.Where(x => x.QuestionId == item.QuestionId).ToList();
-                    item.CorrectAnswer = string.Join(",", item.QuestionOptions.Where(x => x.IsAnswer).Select(x => x.Label));
-                }
-                
-            });
+                id
+            };
+            //List<ViewQuestionAnswerDto> questionAnswers = await GetQuestionAnswers(id, questionIds);
+            List<ViewQuestionOptionDto> questionOptions = await GetQuestionOptions(questionIds, userExamIds);
+            List<QuestionKnowladgeDto> questionKnowladges = await GetQuestionKnowladges(examQuestionIds);
+            List<QuestionSourcewareDto> sourcewares = await GetSourcewares(examQuestionIds);
 
+            ResolveExamQuestions(viewExamQuestionDtos, questionOptions, questionKnowladges, sourcewares);
 
             return viewExamQuestionDtos;
 
@@ -1363,33 +1382,36 @@ namespace Hotline.Application.Exam.Service.ExamManages
         {
             List<ViewExamQuestionDto> viewExamQuestionDtos = await GetViewExamQuestion(id, questionId);
 
+            var examQuestionIds = viewExamQuestionDtos.Select(x => x.ExamQuestionId).ToList();
             var questionIds = viewExamQuestionDtos.Select(x => x.QuestionId).ToList();
+            var userExamIds = new List<string>
+            {
+                id
+            };
+            //List<ViewQuestionAnswerDto> questionAnswers = await GetQuestionAnswers(id, questionIds);
+            List<ViewQuestionOptionDto> questionOptions = await GetQuestionOptions(questionIds, userExamIds);
+            List<QuestionKnowladgeDto> questionKnowladges = await GetQuestionKnowladges(examQuestionIds);
+            List<QuestionSourcewareDto> sourcewares = await GetSourcewares(examQuestionIds);
+
+            ResolveExamQuestions(viewExamQuestionDtos, questionOptions, questionKnowladges, sourcewares);
 
-            List<ViewQuestionAnswerDto> questionAnswers = await GetQuestionAnswers(id, questionIds);
-            List<ViewQuestionOptionDto> questionOptions = await GetQuestionOptions(questionIds);
-            List<QuestionKnowladgeDto> questionKnowladges = await GetQuestionKnowladges(questionIds);
-            List<QuestionSourcewareDto> sourcewares = await GetSourcewares(questionIds);
+            return viewExamQuestionDtos.FirstOrDefault();
+        }
 
+        private static void ResolveExamQuestions(List<ViewExamQuestionDto> viewExamQuestionDtos, List<ViewQuestionOptionDto> questionOptions, List<QuestionKnowladgeDto> questionKnowladges, List<QuestionSourcewareDto> sourcewares)
+        {
             viewExamQuestionDtos.ForEach(item =>
             {
-                item.QuestionKnowladgeDtos = questionKnowladges.Where(x => x.QuestionId == item.QuestionId).ToList();
-                item.QuestionSourcewareDtos = sourcewares.Where(x => x.QuestionId == item.QuestionId).ToList();
-                if (!item.QuestionType.CheckSelectType())
+                item.QuestionKnowladgeDtos = questionKnowladges.Where(x => x.QuestionId == item.ExamQuestionId).ToList();
+                item.QuestionSourcewareDtos = sourcewares.Where(x => x.QuestionId == item.ExamQuestionId).ToList();
+                if (item.QuestionType.CheckSelectType())
                 {
-                    var questionAnswer = questionAnswers.FirstOrDefault(x => x.QuestionId == item.QuestionId);
-                    item.Answer = questionAnswer?.Answer ?? string.Empty;
-                    item.CorrectAnswer = questionAnswer?.CorrectAnswer ?? string.Empty;
-                }
-                else
-                {
-                    item.QuestionOptions = questionOptions.Where(x => x.QuestionId == item.QuestionId).ToList();
-                    item.CorrectAnswer = string.Join(",", item.QuestionOptions.Where(x => x.IsAnswer).Select(x => x.Label));
+                    item.QuestionOptions = questionOptions.Where(x => x.QuestionId == item.ExamQuestionId).ToList();
+
+                    item.CorrectAnswer = string.Join(",", item.QuestionOptions.Where(m => m.IsAnswer).Select(m => m.Label).ToArray());
                 }
 
             });
-
-
-            return viewExamQuestionDtos.FirstOrDefault();
         }
 
         private  async Task<List<QuestionSourcewareDto>> GetSourcewares(List<string> questionIds)
@@ -1424,12 +1446,13 @@ namespace Hotline.Application.Exam.Service.ExamManages
             }).ToListAsync();
         }
 
-        private  async Task<List<ViewQuestionOptionDto>> GetQuestionOptions(List<string> questionIds)
+        private  async Task<List<ViewQuestionOptionDto>> GetQuestionOptions(List<string> questionIds,List<string> userExamIds)
         {
+            var selectQuestionOptions = GetQuestionOptionBaks(questionIds, userExamIds,false).MergeTable();
+
             var userExamItemOptionTable = _userExamItemOptionRepository.Queryable();
-            var questionOptionTable = new ExamRepository<ExamQuestionOptionsBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
-            var querable = questionOptionTable.Where(x => questionIds.Contains(x.ExamQuestionId))
+            var querable = selectQuestionOptions 
                 .LeftJoin(userExamItemOptionTable, (op, uio) => op.Id == uio.QuestionOptionId)
                 .Select((op, uio) => new ViewQuestionOptionDto
                 {
@@ -1439,7 +1462,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
                     Label = op.Label,
                     QuestionId = op.ExamQuestionId,
                     IsSelected = uio.Id != null
-                }).MergeTable().OrderBy(x=>x.Label);
+                }).MergeTable().OrderBy(x => x.Label);
 
             return await querable.Distinct()
                 .ToListAsync();
@@ -1470,28 +1493,33 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
         private  async Task<List<ViewExamQuestionDto>> GetViewExamQuestion(string id,string questionId)
         {
-            var userExamTable = _repository.Queryable().Where(x => x.Id == id);
-            var userExamItemTable = _userExamItemRepository.Queryable();
-            var examManageTable = _examManageRepository.Queryable();
-            var questionTable = new ExamRepository<ExamQuestionBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().WhereIF(!string.IsNullOrEmpty(questionId), x => x.QuestionId == questionId);
-            var questionScoreTable = new ExamRepository<ExamQuestionScoreBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var expression = ExpressionableUtility.CreateExpression<ExamUserExam>()
+                .And(x => x.Id == id).ToExpression();
 
+            ISugarQueryable<GradingExamQuestionTempDto> queryable = GetViewExamQuestionTempDtos(expression);
 
-            var querable = userExamItemTable.InnerJoin(userExamTable, (ui, u) => ui.UserExamId == u.Id)
-                            .InnerJoin(questionTable, (ui, u, q) => ui.QuestionId == q.QuestionId && u.ExamId == q.ExamId)
-                            .InnerJoin(examManageTable, (ui, u, q, e) => u.ExamId == e.Id)
-                            .InnerJoin(questionScoreTable, (ui, u, q, e, s) => q.QuestionType == s.QuestionType && s.ExamManageId == e.Id)
-                            .Select((ui, u, q, e, s) => new ViewExamQuestionDto
-                            {
-                                Id = ui.Id,
-                                Score = s.Score,
-                                RealScore = ui.Score,
-                                Title = q.Title,
-                                QuestionType = q.QuestionType,
-                                QuestionId = q.Id,
-                            }).MergeTable().OrderBy(x=>x.QuestionType).OrderBy(x=>x.Id);
-
-            return await querable.Distinct().ToListAsync();
+            queryable = queryable.MergeTable().WhereIF(!string.IsNullOrEmpty(questionId), x => x.QuestionId == questionId);
+
+            var queryResult = await queryable.ToListAsync();
+
+            var viewExamQuestion = queryResult.GroupBy(x => new
+            {
+                Id = x.Id,
+                QuestionType = x.QuestionType
+            }).Select(g => new ViewExamQuestionDto
+            {
+                Answer = g.FirstOrDefault().Answer,
+                QuestionType = g.Key.QuestionType,
+                QuestionId= g.FirstOrDefault().QuestionId,
+                ExamQuestionId = g.FirstOrDefault().ExamQuestionId,
+                Id = g.Key.Id,
+                Score = g.FirstOrDefault().QuestionScore,
+                RealScore = g.FirstOrDefault().Score,
+                Title = g.FirstOrDefault().Title,
+                CorrectAnswer = g.Key.QuestionType.CheckSelectType() ? string.Empty : g.FirstOrDefault()?.CorrectAnswer
+            }).ToList();
+
+            return viewExamQuestion;
         }
         #endregion
 

src/Hotline.Application/Exam/Service/Practices/PracticeService.cs

@@ -670,11 +670,13 @@ namespace Hotline.Application.Exam.Service.Practices
             var tagQuestionTable = tagQuestionRepository.Queryable().Where(expression);
             var questionTable = quesitonRepository.Queryable().Where(questionExpression);
 
-            var taqQuestions = await tagQuestionTable.LeftJoin(questionTable, (t, q) => t.QuestionId == q.Id)
+            var queryable = tagQuestionTable.InnerJoin(questionTable, (t, q) => t.QuestionId == q.Id)
                 .Select((t, q) => new TagQuestionCountViewResponse
                 {
                     TotalCount = SqlFunc.AggregateCount(t.Id)
-                })
+                });
+
+            var taqQuestions = await queryable
                 .ToListAsync();
 
             return taqQuestions.Count() > 0 ? taqQuestions.FirstOrDefault() : new TagQuestionCountViewResponse

src/Hotline.Application/Jobs/ApptaskJob.cs

@@ -1,9 +1,9 @@
 using Hotline.BatchTask;
+using Hotline.BatchTask.Notifications;
 using Quartz;
 using Hotline.Share.Enums.BatchTask;
-using Hotline.Share.Dtos.Order;
 using Microsoft.Extensions.DependencyInjection;
-using Hotline.Application.OrderApp.OrderVisitApp;
+using Hotline.EventBus;
 using Hotline.Share.Dtos.Order.OrderVisit;
 using Hotline.Share.Dtos.Order.OrderDelay;
 
@@ -13,12 +13,16 @@ namespace Hotline.Application.Jobs
     {
         private readonly IApptaskDomainService _apptaskDomainService;
         private readonly IServiceProvider _serviceProvider;
+        private readonly Publisher _publisher;
 
-        public ApptaskJob(IApptaskDomainService apptaskDomainService,
-            IServiceProvider serviceProvider)
+        public ApptaskJob(
+            IApptaskDomainService apptaskDomainService,
+            IServiceProvider serviceProvider,
+            Publisher publisher)
         {
             _apptaskDomainService = apptaskDomainService;
             _serviceProvider = serviceProvider;
+            _publisher = publisher;
         }
 
         public async Task Execute(IJobExecutionContext context)
@@ -26,21 +30,43 @@ namespace Hotline.Application.Jobs
             //Console.WriteLine($"执行ApptaskJob: {DateTime.Now}");
             var task = await _apptaskDomainService.GetWaitingTaskAsync(context.CancellationToken);
             if (task is null) return;
+            ApptaskExecuteResult? result = null;
             switch (task.TaskType)
             {
                 case ETaskType.OrderDelay:
                     var delayExecutor = _serviceProvider.GetService<IApptaskExecutor<OrderDelayReviewRequest>>();
-                    await _apptaskDomainService.ExecuteAsync(delayExecutor, task, context.CancellationToken);
+                    result = await _apptaskDomainService.ExecuteAsync(delayExecutor, task, context.CancellationToken);
                     break;
                 case ETaskType.OrderScreen:
                     break;
                 case ETaskType.VoiceVisit:
                     var vvExecutor = _serviceProvider.GetService<IApptaskExecutor<VoiceVisitRequest>>();
-                    await _apptaskDomainService.ExecuteAsync(vvExecutor, task, context.CancellationToken);
+                    result = await _apptaskDomainService.ExecuteAsync(vvExecutor, task, context.CancellationToken);
                     break;
                 default:
                     throw new ArgumentOutOfRangeException();
             }
+
+            if (result is not null)
+            {
+                if (result.IsSuccess)
+                {
+                    //todo pub single complete suc
+                    await _publisher.PublishAsync(new ApptaskSuccessNotify(task), PublishStrategy.Async, context.CancellationToken);
+
+                    //todo check if task is all complete
+                    //pub all complete
+                    var isCompleted = await _apptaskDomainService.IsCompletedAsync(task.ApptaskId, context.CancellationToken);
+                    if (isCompleted) 
+                        await _publisher.PublishAsync(new ApptaskCompletedNotify(task), PublishStrategy.Async, context.CancellationToken);
+                }
+                else
+                {
+                    //todo pub single complete fail
+                    await _publisher.PublishAsync(new ApptaskFailNotify(task), PublishStrategy.Async, context.CancellationToken);
+                }
+
+            }
         }
 
         /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>

src/Hotline.Application/OrderApp/Handlers/OrderDelayHandler/OrderDelayBatchReviewTaskCompetedHandler.cs

@@ -0,0 +1,62 @@
+using Hotline.BatchTask.Notifications;
+using Hotline.FlowEngine.Notifications;
+using MediatR;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Hotline.BatchTask;
+using Hotline.Share.Enums.BatchTask;
+using Hotline.Article;
+using Hotline.Share.Dtos.Article;
+using Hotline.Share.Enums.Article;
+using XF.Domain.Authentications;
+
+namespace Hotline.Application.OrderApp.Handlers.OrderDelayHandler;
+
+/// <summary>
+/// 延期批量审批任务执行完成
+/// </summary>
+public class OrderDelayBatchReviewTaskCompetedHandler : INotificationHandler<ApptaskCompletedNotify>
+{
+    private readonly IApptaskDomainService _apptaskDomainService;
+    private readonly ICircularRecordDomainService _circularRecordDomainService;
+
+    public OrderDelayBatchReviewTaskCompetedHandler(
+        IApptaskDomainService apptaskDomainService,
+        ICircularRecordDomainService circularRecordDomainService)
+    {
+        _apptaskDomainService = apptaskDomainService;
+        _circularRecordDomainService = circularRecordDomainService;
+    }
+
+    /// <summary>Handles a notification</summary>
+    /// <param name="notification">The notification</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    public async Task Handle(ApptaskCompletedNotify notification, CancellationToken cancellationToken)
+    {
+        if(notification.ApptaskItem.TaskType is not ETaskType.OrderDelay) return;
+
+        var progress = await _apptaskDomainService.GetProgressAsync(notification.ApptaskItem.ApptaskId, cancellationToken);
+        await _circularRecordDomainService.AddCircularMessage(new AddCircularDto
+        {
+            Title = $"{progress.Name} 执行完成",
+            Content = $"总共：{progress.Total}条数据，成功：{progress.Succeeded}条，失败：{progress.Failed}条",
+            CircularTypeId = "5",
+            CircularTypeName = "系统消息",
+            CircularType = ECircularType.Person,
+            IsMustRead = false,
+            SourceOrgId = progress.CreatorId,
+            SourceOrgName = progress.CreatorName,
+            CircularReadGroups = new List<CircularReadGroupDto>
+            {
+                new()
+                {
+                    UserId = progress.CreatorId,
+                    UserName = progress.CreatorName
+                }
+            }
+        }, cancellationToken);
+    }
+}

src/Hotline.Application/OrderApp/OrderDelayApp/OrderDelayApplication.cs

@@ -201,11 +201,22 @@ public class OrderDelayApplication : IOrderDelayApplication, IScopeDependency
             });
         }
 
-        await _apptaskDomainService.AddAsync(new AddApptaskRequest
+        var taskId = await _apptaskDomainService.AddAsync(new AddApptaskRequest
         {
             TaskType = ETaskType.OrderDelay,
             Priority = 0,
             ApptaskItems = apptaskItems
         }, cancellation);
+
+        if (!string.IsNullOrEmpty(taskId))
+        {
+            foreach (var orderDelay in delays)
+            {
+                orderDelay.DelayState = EDelayState.BatchProcessing;
+            }
+            await _orderDelayRepository.Updateable(delays)
+                .UpdateColumns(d=>new {d.DelayState})
+                .ExecuteCommandAsync(cancellation);
+        }
     }
 }

src/Hotline.Application/OrderApp/OrderDelayApp/OrderDelayAuditTaskExecutor.cs → src/Hotline.Application/OrderApp/OrderDelayApp/OrderDelayReviewTaskExecutor.cs

@@ -5,11 +5,11 @@ using XF.Domain.Dependency;
 
 namespace Hotline.Application.OrderApp.OrderDelayApp;
 
-public class OrderDelayAuditTaskExecutor : IApptaskExecutor<OrderDelayReviewRequest>, IScopeDependency
+public class OrderDelayReviewTaskExecutor : IApptaskExecutor<OrderDelayReviewRequest>, IScopeDependency
 {
     private readonly IOrderDelayApplication _orderDelayApplication;
 
-    public OrderDelayAuditTaskExecutor(IOrderDelayApplication orderDelayApplication)
+    public OrderDelayReviewTaskExecutor(IOrderDelayApplication orderDelayApplication)
     {
         _orderDelayApplication = orderDelayApplication;
     }

src/Hotline.Share/Dtos/BatchTask/ApptaskProgressDto.cs

@@ -5,9 +5,15 @@
 /// </summary>
 public class ApptaskProgressDto
 {
+    /// <summary>
+    /// 任务名称
+    /// </summary>
+    public string Name { get; set; }
     public int Total { get; set; }
     public int Waiting { get; set; }
     public int Processing { get; set; }
     public int Succeeded { get; set; }
     public int Failed { get; set; }
+    public string? CreatorId { get; set; }
+    public string? CreatorName { get; set; }
 }

src/Hotline.Share/Dtos/ExamManages/ExamQuestionDto.cs

@@ -61,6 +61,12 @@ namespace Hotline.Share.Dtos.ExamManages
         [Description("试题Id")]
         public string QuestionId { get; set; }
 
+        /// <summary>
+        /// 考试试题Id
+        /// </summary>
+        [Description("考试试题Id")]
+        public string ExamQuestionId { get; set; }
+
         /// <summary>
         /// 试题关联知识
         /// </summary>

src/Hotline.Share/Dtos/ExamManages/GradingExamQuestionDto.cs

@@ -109,6 +109,18 @@ namespace Exam.Application.Interface.Exam
         /// </summary>
         [Description("实际分数")]
         public int? Score { get; set; }
+
+        /// <summary>
+        /// 试题Id
+        /// </summary>
+        [Description("试题Id")]
+        public string QuestionId { get; set; }
+
+        /// <summary>
+        /// 考试试题Id
+        /// </summary>
+        [Description("考试试题Id")]
+        public string ExamQuestionId { get; set; }
     }
 
     public class UserExamQuestionDto : IActionRequest

src/Hotline.Share/Enums/Order/EDelayState.cs

@@ -27,6 +27,12 @@ namespace Hotline.Share.Enums.Order
         /// </summary>
         [Description("撤销")]
         Withdraw = 3,
+
+        /// <summary>
+        /// 批量审批处理中
+        /// </summary>
+        [Description("批量处理中")]
+        BatchProcessing = 9,
     }
 
     public enum EDelayApplyType

src/Hotline.Share/Hotline.Share.csproj

@@ -7,7 +7,7 @@
     <GenerateDocumentationFile>True</GenerateDocumentationFile>
     <NoWarn>$(NoWarn);1591;8618;</NoWarn>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
-    <Version>1.0.122</Version>
+    <Version>1.0.123</Version>
   </PropertyGroup>
 
   <ItemGroup>

src/Hotline/BatchTask/ApptaskDomainService.cs

@@ -4,10 +4,10 @@ using Hotline.Share.Enums.BatchTask;
 using Hotline.Validators.BatchTask;
 using MapsterMapper;
 using Microsoft.Extensions.Logging;
+using XF.Domain.Authentications;
 using XF.Domain.Dependency;
 using XF.Domain.Exceptions;
 using XF.Domain.Repository;
-using static Lucene.Net.Util.Fst.Util;
 
 namespace Hotline.BatchTask;
 
@@ -55,7 +55,7 @@ public class ApptaskDomainService : IApptaskDomainService, IScopeDependency
                 TaskStatus = ETaskStatus.Waiting,
                 TaskParams = d.TaskParams is null ? null : System.Text.Json.JsonSerializer.Serialize(d.TaskParams),
                 TryLimit = request.TryLimit,
-                Priority = priority,
+                Priority = priority
             }).ToList()
         };
 
@@ -83,6 +83,21 @@ public class ApptaskDomainService : IApptaskDomainService, IScopeDependency
         return _mapper.Map<ApptaskProgressDto>(apptask);
     }
 
+    /// <summary>
+    /// 查询当前任务是否全部执行完成
+    /// </summary>
+    /// <param name="taskId"></param>
+    /// <param name="cancellation"></param>
+    /// <returns></returns>
+    public async Task<bool> IsCompletedAsync(string taskId, CancellationToken cancellation)
+    {
+        var anyUnCompleted = await _apptaskItemRepository.Queryable()
+            .AnyAsync(d => d.Tries < d.TryLimit
+                           && (d.TaskStatus == ETaskStatus.Waiting || d.TaskStatus == ETaskStatus.Processing)
+                           && d.ApptaskId == taskId, cancellation);
+        return !anyUnCompleted;
+    }
+
     /// <summary>
     /// 终止任务
     /// </summary>
@@ -146,7 +161,7 @@ public class ApptaskDomainService : IApptaskDomainService, IScopeDependency
     /// <param name="apptaskItem"></param>
     /// <param name="cancellation"></param>
     /// <returns></returns>
-    public async Task ExecuteAsync<TRequest>(IApptaskExecutor<TRequest> executor, ApptaskItem apptaskItem, CancellationToken cancellation)
+    public async Task<ApptaskExecuteResult> ExecuteAsync<TRequest>(IApptaskExecutor<TRequest> executor, ApptaskItem apptaskItem, CancellationToken cancellation)
     {
         try
         {
@@ -161,13 +176,15 @@ public class ApptaskDomainService : IApptaskDomainService, IScopeDependency
             apptaskItem.TaskStatus = result.IsSuccess ? ETaskStatus.Succeeded : ETaskStatus.Failed;
             apptaskItem.Message = result.Message;
             apptaskItem.TaskEndTime = DateTime.Now;
+            return ApptaskExecuteResult.Success();
         }
         catch (Exception e)
         {
-            _logger.LogError("批量任务执行异常：{err}", e.Message);
+            _logger.LogError("批量任务执行异常：taskId: {taskItemId}, {err}", apptaskItem.Id, e.Message);
             apptaskItem.TaskStatus = ETaskStatus.Failed;
             apptaskItem.Message = "批量任务执行异常";
             apptaskItem.TaskEndTime = DateTime.Now;
+            return ApptaskExecuteResult.Fail("批量任务执行异常");
         }
         finally
         {

src/Hotline/BatchTask/IApptaskDomainService.cs

@@ -19,6 +19,14 @@ namespace Hotline.BatchTask
         /// </summary>
         /// <returns></returns>
         Task<ApptaskProgressDto> GetProgressAsync(string taskId, CancellationToken cancellation);
+        
+        /// <summary>
+        /// 查询当前任务是否全部完成
+        /// </summary>
+        /// <param name="taskId"></param>
+        /// <param name="cancellation"></param>
+        /// <returns></returns>
+        Task<bool> IsCompletedAsync(string taskId, CancellationToken cancellation);
 
         /// <summary>
         /// 终止任务
@@ -43,6 +51,6 @@ namespace Hotline.BatchTask
         /// <param name="apptaskItem"></param>
         /// <param name="cancellation"></param>
         /// <returns></returns>
-        Task ExecuteAsync<TRequest>(IApptaskExecutor<TRequest> executor, ApptaskItem apptaskItem, CancellationToken cancellation);
+        Task<ApptaskExecuteResult> ExecuteAsync<TRequest>(IApptaskExecutor<TRequest> executor, ApptaskItem apptaskItem, CancellationToken cancellation);
     }
 }

src/Hotline/BatchTask/Notifications/ApptaskCompletedNotify.cs

@@ -0,0 +1,10 @@
+using MediatR;
+
+namespace Hotline.BatchTask.Notifications;
+
+public class ApptaskCompletedNotify : ApptaskExecutedNotify, INotification
+{
+    public ApptaskCompletedNotify(ApptaskItem apptaskItem) : base(apptaskItem)
+    {
+    }
+}

src/Hotline/BatchTask/Notifications/ApptaskFailNotify.cs

@@ -0,0 +1,20 @@
+using MediatR;
+
+namespace Hotline.BatchTask.Notifications;
+
+public class ApptaskFailNotify : ApptaskExecutedNotify, INotification
+{
+    public ApptaskFailNotify(ApptaskItem apptaskItem) : base(apptaskItem)
+    {
+    }
+}
+
+public class ApptaskExecutedNotify
+{
+    public ApptaskItem ApptaskItem { get; set; }
+
+    public ApptaskExecutedNotify(ApptaskItem apptaskItem)
+    {
+        ApptaskItem = apptaskItem;
+    }
+}

src/Hotline/BatchTask/Notifications/ApptaskSuccessNotify.cs

@@ -0,0 +1,15 @@
+using MediatR;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Hotline.BatchTask.Notifications;
+
+public class ApptaskSuccessNotify : ApptaskExecutedNotify, INotification
+{
+    public ApptaskSuccessNotify(ApptaskItem apptaskItem) : base(apptaskItem)
+    {
+    }
+}