调整考试管理修改接口

src/Hotline.Application/Exam/Proxy/ExamManageProxy.cs

@@ -2,6 +2,7 @@
 using Exam.Questions;
 using Exam.Repository.Sqlsugar.Repositories;
 using Hotline.Exams.ExamManages;
+using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.DataPermissions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Exams;
@@ -9,6 +10,7 @@ using Hotline.Repository.SqlSugar.Exam.Interfaces.Questions;
 using Hotline.Repository.SqlSugar.Extensions;
 using Hotline.Repository.SqlSugar.Interface;
 using MapsterMapper;
+using SqlSugar;
 using XF.Domain.Authentications;
 
 namespace Hotline.Application.Exam.Proxy
@@ -25,8 +27,9 @@ namespace Hotline.Application.Exam.Proxy
         private readonly IServiceProvider _serviceProvider;
         private readonly IMapper _mapper;
         private readonly ISessionContext _sessionContext;
+		private readonly ISugarUnitOfWork<HotlineDbContext> _uow;
 
-        public ExamManageProxy(IExamManageRepository repository,
+		public ExamManageProxy(IExamManageRepository repository,
             IExamQuestionRepository examQuestionRepository,
             IExamQuestionAnswerRepository examQuestionAnswerRepository,
             IExamQuestionOptionsRepository examQuestionOptionsRepository,
@@ -46,6 +49,7 @@ namespace Hotline.Application.Exam.Proxy
             this._serviceProvider = serviceProvider;
             this._mapper = mapper;
             this._sessionContext = sessionContext;
+            this._uow = repository.UOW;
         }
 
         #region public method
@@ -114,7 +118,7 @@ namespace Hotline.Application.Exam.Proxy
 
         private async Task<List<ExamQuestionAnswer>> SyncQuestionAnswer(List<ExamQuestion> examQuestions, CancellationToken cancellationToken)
         {
-            var questionAnswersRepository = new ExamRepository<QuestionAnswer>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionAnswersRepository = new ExamRepository<QuestionAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionIds = examQuestions.Select(x => x.QuestionId);
             var questionAnswers = await questionAnswersRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
 
@@ -138,7 +142,7 @@ namespace Hotline.Application.Exam.Proxy
 
         private async Task<List<ExamQuestionKnowladge>> SyncQuestionKnowladge(List<ExamQuestion> examQuestions, CancellationToken cancellationToken)
         {
-            var questionKnowladgesRepository = new ExamRepository<QuestionKnowladge>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionKnowladgesRepository = new ExamRepository<QuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionIds = examQuestions.Select(x => x.QuestionId);
             var questionKnowladges = await questionKnowladgesRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
 
@@ -162,7 +166,7 @@ namespace Hotline.Application.Exam.Proxy
 
         private async Task<List<ExamQuestionSourceware>> SyncQuestionSourcewares(List<ExamQuestion> examQuestions, CancellationToken cancellationToken)
         {
-            var questionSourcewaresRepository = new ExamRepository<QuestionSourceware>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionSourcewaresRepository = new ExamRepository<QuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionIds = examQuestions.Select(x => x.QuestionId);
             var questionSourcewares = await questionSourcewaresRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
 
@@ -186,7 +190,7 @@ namespace Hotline.Application.Exam.Proxy
 
         private async Task<List<ExamQuestionOptions>> SyncQuestionOptions(List<ExamQuestion> examQuestions, CancellationToken cancellationToken)
         {
-            var questionOptionsRepository = new ExamRepository<QuestionOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionOptionsRepository = new ExamRepository<QuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionIds = examQuestions.Select(x => x.QuestionId);
             var questionOptions = await questionOptionsRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
 

src/Hotline.Application/Exam/Proxy/TestPaperProxy.cs

@@ -2,11 +2,13 @@
 using Exam.Repository.Sqlsugar.Repositories;
 using Exam.TestPapers;
 using Hotline.Exams.TestPapers;
+using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.DataPermissions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Questions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.TestPapers;
 using Hotline.Repository.SqlSugar.Extensions;
 using MapsterMapper;
+using SqlSugar;
 using System.Threading;
 using XF.Domain.Authentications;
 using XF.Domain.Repository;
@@ -25,7 +27,7 @@ namespace Hotline.Application.Exam.Proxy
         private readonly IServiceProvider _serviceProvider;
         private readonly IMapper _mapper;
         private readonly ISessionContext _sessionContext;
-
+        private readonly ISugarUnitOfWork<HotlineDbContext> _uow;
         public TestPaperProxy(ITestPaperRepository repository,
             ITestPaperItemRepository testPaperItemRepository,
             ITestPaperItemAnswerRepository testPaperItemAnswerRepository,
@@ -46,6 +48,7 @@ namespace Hotline.Application.Exam.Proxy
             this._serviceProvider = serviceProvider;
             this._mapper = mapper;
             this._sessionContext = sessionContext;
+            this._uow = repository.UOW;
         }
 
         #region public method
@@ -113,7 +116,7 @@ namespace Hotline.Application.Exam.Proxy
 
         private async Task<List<TestPaperItemAnswer>> SyncQuestionAnswer(List<TestPaperItem> testPaperItems, CancellationToken cancellationToken)
         {
-            var questionAnswersRepository = new ExamRepository<QuestionAnswer>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionAnswersRepository = new ExamRepository<QuestionAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionIds = testPaperItems.Select(x => x.QuestionId);
             var questionAnswers = await questionAnswersRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
 
@@ -137,7 +140,7 @@ namespace Hotline.Application.Exam.Proxy
 
         private async Task<List<TestPaperItemKnowladge>> SyncQuestionKnowladge(List<TestPaperItem> testPaperItems, CancellationToken cancellationToken)
         {
-            var questionKnowladgesRepository = new ExamRepository<QuestionKnowladge>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionKnowladgesRepository = new ExamRepository<QuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionIds = testPaperItems.Select(x => x.QuestionId);
             var questionKnowladges = await questionKnowladgesRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
 
@@ -161,7 +164,7 @@ namespace Hotline.Application.Exam.Proxy
 
         private async Task<List<TestPaperItemSourceware>> SyncQuestionSourcewares(List<TestPaperItem> testPaperItems, CancellationToken cancellationToken)
         {
-            var questionSourcewaresRepository = new ExamRepository<QuestionSourceware>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionSourcewaresRepository = new ExamRepository<QuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionIds = testPaperItems.Select(x => x.QuestionId);
             var questionSourcewares = await questionSourcewaresRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
 
@@ -185,7 +188,7 @@ namespace Hotline.Application.Exam.Proxy
 
         private async Task<List<TestPaperItemOptions>> SyncQuestionOptions(List<TestPaperItem> testPaperItems, CancellationToken cancellationToken)
         {
-            var questionOptionsRepository = new ExamRepository<QuestionOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionOptionsRepository = new ExamRepository<QuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionIds = testPaperItems.Select(x => x.QuestionId);
             var questionOptions = await questionOptionsRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
 

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

@@ -233,9 +233,9 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             _addExamManageDto.ExamQuestionScoreDtos = new List<AddExamQuestionScoreDto>();
 
-            actionRequest.UserExamDtos.ForEach(x =>
+			actionRequest.UserExamDtos.ForEach(x =>
             {
-                x.OperationStatus = x.Id != null ? EEOperationStatus.Update : EEOperationStatus.Update;
+                x.OperationStatus = x.Id != null ? EEOperationStatus.Update : EEOperationStatus.Add;
 
                 if(x.OperationStatus== EEOperationStatus.Add)
                 {
@@ -340,7 +340,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
         private async Task<List<Question>> GetQuestions(ExamManage examManage)
         {
-            var questionRepository = new ExamRepository<Question>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionRepository = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var questionTable = questionRepository.Queryable();
             var testPaperItemTable = _testPaperItemRepository.Queryable().Where(x => x.TestPaperId == examManage.TestPaperId);
@@ -353,9 +353,9 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
         private async Task<List<TagQuestion>> GetTagQuestions(ExamManage examManage)
         {
-            var extractRuleRepository = new ExamRepository<ExtractRule>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var ruleTagRepository = new ExamRepository<RuleTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var tagQuestionRepository = new ExamRepository<TagQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var extractRuleRepository = new ExamRepository<ExtractRule>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var ruleTagRepository = new ExamRepository<RuleTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var tagQuestionRepository = new ExamRepository<TagQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
           
             var extractRuleTable = extractRuleRepository.Queryable().Where(x=>x.Id == examManage.ExtractRuleId && x.RuleType == examManage.ExamType);
@@ -551,7 +551,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
         private async Task<List<UserExamDto>> GetUserExams(EntityQueryRequest entityQueryRequest)
         {
-            var userRepository = new ExamRepository<User>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var userRepository = new ExamRepository<User>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var userExams = _userExamRepository.Queryable().Where(x => x.ExamId == entityQueryRequest.Id);
             var userTable = userRepository.Queryable();
 
@@ -582,7 +582,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             if(examManage.Mode == Share.Enums.Exams.EExamMode.Random)
             {
-                var tagQuestionRepository = new ExamRepository<TagQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+                var tagQuestionRepository = new ExamRepository<TagQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
                 var tagQuestionTable = tagQuestionRepository.Queryable().Where(x => x.RuleId == examManage.ExtractRuleId);
 
                 var result = examQuestionScoreDtos.InnerJoin(tagQuestionTable, (e, t) => e.QuestionType == t.QuestionType).Select((e, t) => new ExamQuestionScoreDto
@@ -597,7 +597,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             }
             else
             {
-                var testPaperItemRepository = new ExamRepository<TestPaperItem>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+                var testPaperItemRepository = new ExamRepository<TestPaperItem>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
                 var testPaperItemTable = testPaperItemRepository.Queryable().Where(x => x.TestPaperId == examManage.TestPaperId);
 
                 var result = examQuestionScoreDtos.InnerJoin(testPaperItemTable, (e, t) => e.QuestionType == t.QuestionType)
@@ -662,8 +662,8 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
         private async Task<List<Question>> GetQuestions(List<TagQuestion> tagQuestionCounts)
         {
-            var questionRepository = new ExamRepository<Question>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var questionTagRepository = new ExamRepository<QuestionTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionRepository = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionTagRepository = new ExamRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var questionTable = questionRepository.Queryable();
             var questionTagTable = questionTagRepository.Queryable();

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

@@ -188,8 +188,8 @@ namespace Hotline.Application.Exam.Service.ExamManages
             if (tagQuestionRequest.TagIds.IsNullOrEmpty()) return new List<TagQuestionViewResponse>();
 
             var expression = tagQuestionRequest.GetExpression();
-            var questionTagTable = new ExamRepository<QuestionTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression);
-            var questionTable = new ExamRepository<Question>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var questionTagTable = new ExamRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression);
+            var questionTable = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
             var queryable = questionTagTable.LeftJoin(questionTable, (t, q) => t.QuestionId == q.Id)
                 .GroupBy((t, q) => new { t.TagId, q.QuestionType })
@@ -438,7 +438,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
         {
             var ruleTagTable = _ruleTagRepository.Queryable().Where(x => x.RuleId == entityQueryRequest.Id);
 
-            var examTagTable = new ExamRepository<ExamTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var examTagTable = new ExamRepository<ExamTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
 
             var queryable = ruleTagTable.LeftJoin(examTagTable, (r, e) => r.TagId == e.Id).Select((r, e) => new RuleTagDto
@@ -462,7 +462,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
         {
             var tagQuestionTable = _tagQuestionRepository.Queryable().Where(x => x.RuleId == entityQueryRequest.Id);
 
-            var examTagTable = new ExamRepository<ExamTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var examTagTable = new ExamRepository<ExamTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
 
             var tagQuestionDtos = tagQuestionTable.LeftJoin(examTagTable, (t, e) => t.TagId == e.Id).Select((t, e) => new TagQuestionDto

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

@@ -88,7 +88,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
         public async Task<ExamQuestionDto> GetExamQuestionDto(ExamQuestionRequest examQuestionRequest)
         {
             var expression = examQuestionRequest.GetExpression();
-            var quesetion = await new ExamRepository<ExamQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression).FirstAsync();
+            var quesetion = await new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression).FirstAsync();
 
             if (quesetion != null)
             {
@@ -96,7 +96,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
                 if (examQuestionDto.QuestionType.CheckSelectType())
                 {
-                    var questionOptions = await new ExamRepository<ExamQuestionOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.ExamQuestionId == quesetion.Id).ToListAsync();
+                    var questionOptions = await new ExamRepository<ExamQuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.ExamQuestionId == quesetion.Id).ToListAsync();
 
                     if (questionOptions != null)
                     {
@@ -123,8 +123,8 @@ namespace Hotline.Application.Exam.Service.ExamManages
         public async Task<List<ExamQuestionViewResponse>> GetExamQuestionViewResponses(ExamQuestionGroupRequest examQuestionGroupRequest)
         {
             var expression = examQuestionGroupRequest.GetExpression();
-            var examManageTable = new ExamRepository<ExamManage>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression);
-            var testPaperItemTable = new ExamRepository<ExamQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var examManageTable = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression);
+            var testPaperItemTable = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
             var queryable = await examManageTable.InnerJoin(testPaperItemTable, (e, i) => e.Id == i.ExamId)
                 .Select((e, i) => i).ToListAsync();
@@ -146,13 +146,13 @@ namespace Hotline.Application.Exam.Service.ExamManages
         public async Task<List<GradingQuestionViewResponce>> GetGradingQuestionViewResponces(ExamQuestionGroupRequest examQuestionGroupRequest)
         {
             var expression = examQuestionGroupRequest.GetExpression();
-            var examManageTable = new ExamRepository<ExamManage>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression);
-            var testPaperItemTable = new ExamRepository<ExamQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var examManageTable = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression);
+            var testPaperItemTable = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
             var queryable = await examManageTable.InnerJoin(testPaperItemTable, (e, i) => e.Id == i.ExamId)
                 .Select((e, i) => i).ToListAsync();
 
-            var examQuestionScores = await new ExamRepository<ExamQuestionScore>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.ExamManageId == examQuestionGroupRequest.ExamId).ToListAsync();
+            var examQuestionScores = await new ExamRepository<ExamQuestionScore>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.ExamManageId == examQuestionGroupRequest.ExamId).ToListAsync();
 
             var userExamItemTable = _userExamItemRepository.Queryable();
             var userExamTable = _repository.Queryable().Where(x => x.ExamId == examQuestionGroupRequest.ExamId && x.UserId == examQuestionGroupRequest.UserId);
@@ -229,7 +229,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
         public async Task<StartExamViewResponse> ExamAsync(UpdateUserExamItemDto addUserExamItemDto, CancellationToken cancellationToken)
         {
-            var userExam = await new ExamRepository<UserExam>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.Id == addUserExamItemDto.UserExamId).FirstAsync();
+            var userExam = await new ExamRepository<UserExam>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.Id == addUserExamItemDto.UserExamId).FirstAsync();
 
             var startExamViewResponse = await CheckExamValid(userExam);
 
@@ -238,7 +238,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
                 return startExamViewResponse;
             }
 
-            var userExamRepository = new ExamRepository<UserExamItem>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var userExamRepository = new ExamRepository<UserExamItem>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var hasUserExamItem = userExamRepository.Queryable().Where(x => x.UserExamId == addUserExamItemDto.UserExamId && x.QuestionId == addUserExamItemDto.QuestionId).Any();
 
@@ -289,7 +289,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
         private async Task<StartExamViewResponse> CheckExamValid(UserExam userExam)
         {
-            var examManageRepository = new ExamRepository<ExamManage>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var examManageRepository = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var examManage = await examManageRepository.Queryable().Where(x => x.Id == userExam.ExamId).FirstAsync();
 
@@ -339,7 +339,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             }
             else
             {
-                var count = new ExamRepository<UserExam>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).CountAsync(x => x.ExamId == examManage.Id && x.UserId == userExam.UserId).Result;
+                var count = new ExamRepository<UserExam>(_uow, _dataPermissionFilterBuilder, _serviceProvider).CountAsync(x => x.ExamId == examManage.Id && x.UserId == userExam.UserId).Result;
 
                 var checkStartTime = new CheckValidateCountStrategy(examManage.Count, count)
                 {
@@ -426,7 +426,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
                 var totalScore = userExamItems.Sum(x => x.Score);
                 userExam.Score = totalScore;
 
-                var examManage = await new ExamRepository<ExamManage>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).GetAsync(x => x.Id == userExam.ExamId);
+                var examManage = await new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider).GetAsync(x => x.Id == userExam.ExamId);
                 userExam.IsSuccess = totalScore >= examManage.CutoffScore;
 
                 userExam.ExamStatus = Share.Enums.Exams.EExamStatus.Complete;
@@ -442,14 +442,14 @@ namespace Hotline.Application.Exam.Service.ExamManages
             var expression = gradingExamRequest.GetExpression();
             var userExamTable = _repository.Queryable().Where(expression);
 
-            var questionScoreRepository = new ExamRepository<ExamQuestionScore>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionScoreRepository = new ExamRepository<ExamQuestionScore>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var userExamItemTable = _userExamItemRepository.Queryable();
             var userExamItemOptionTable = _userExamItemOptionRepository.Queryable();
-            var examAnswerTable = new ExamRepository<ExamAnswer>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
-            var questionTable = new ExamRepository<ExamQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
-            var quesitonOptionTable = new ExamRepository<ExamQuestionOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
-            var testPaperItemAnswerTable = new ExamRepository<ExamQuestionAnswer>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var examAnswerTable = new ExamRepository<ExamAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var questionTable = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var quesitonOptionTable = new ExamRepository<ExamQuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var testPaperItemAnswerTable = new ExamRepository<ExamQuestionAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
             var questionScoreTable = questionScoreRepository.Queryable();
 
             var queryResult = await userExamTable.InnerJoin(userExamItemTable, (e, i) => e.Id == i.UserExamId)
@@ -508,8 +508,8 @@ namespace Hotline.Application.Exam.Service.ExamManages
         {
             unExamUserReportPagedRequest.ResoleEndTime();
 
-            var examManageRepository = new ExamRepository<ExamManage>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var userRepository = new ExamRepository<User>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var examManageRepository = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var userRepository = new ExamRepository<User>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var expression = unExamUserReportPagedRequest.GetExpression();
             var userExamExpression = unExamUserReportPagedRequest.GetUserExamExpression();
@@ -541,8 +541,8 @@ namespace Hotline.Application.Exam.Service.ExamManages
         {
             userExamResultReportPagedRequest.ResoleEndTime();
 
-            var examManageRepository = new ExamRepository<ExamManage>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var userRepository = new ExamRepository<User>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var examManageRepository = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var userRepository = new ExamRepository<User>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var expression = userExamResultReportPagedRequest.GetExpression();
             var userExamExpression = userExamResultReportPagedRequest.GetUserExamExpression();
@@ -582,10 +582,10 @@ namespace Hotline.Application.Exam.Service.ExamManages
         {
             if (!addUserExamItemDto.QuestionType.CheckSelectType()) return;
 
-            var testPaperItemOptionsRepository = new ExamRepository<ExamQuestionOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var examManageRepository = new ExamRepository<ExamManage>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var testPaperItemRepository = new ExamRepository<ExamQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var examQuestionScoreRepository = new ExamRepository<ExamQuestionScore>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var testPaperItemOptionsRepository = new ExamRepository<ExamQuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var examManageRepository = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var testPaperItemRepository = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var examQuestionScoreRepository = new ExamRepository<ExamQuestionScore>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var testPaperOptionsTable = testPaperItemOptionsRepository.Queryable().Where(x => x.QuestionId == addUserExamItemDto.QuestionId && x.IsAnswer);
             var testPaperItemTable = testPaperItemRepository.Queryable();
             var userExamTable = _repository.Queryable().Where(x => x.Id == addUserExamItemDto.UserExamId);
@@ -644,7 +644,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             if (userExamItem != null)
             {
-                var testPaperItem = new ExamRepository<ExamQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.Id == userExamItem.Id && !x.QuestionType.CheckSelectType()).First();
+                var testPaperItem = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.Id == userExamItem.Id && !x.QuestionType.CheckSelectType()).First();
 
                 if (testPaperItem == null) return null;
 
@@ -652,9 +652,9 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
                 gradingExamQuestionDto = _mapper.Map<ExamQuestion, GradingExamQuestionDto>(testPaperItem, gradingExamQuestionDto);
 
-                var examAnswer = new ExamRepository<ExamAnswer>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.UserExamItemId == userExamItem.Id).First();
+                var examAnswer = new ExamRepository<ExamAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.UserExamItemId == userExamItem.Id).First();
 
-                var testPaperItemAnswer = await new ExamRepository<ExamQuestionAnswer>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().FirstAsync(x => x.QuestionId == testPaperItem.QuestionId && x.ExamQuestionId == testPaperItem.Id);
+                var testPaperItemAnswer = await new ExamRepository<ExamQuestionAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().FirstAsync(x => x.QuestionId == testPaperItem.QuestionId && x.ExamQuestionId == testPaperItem.Id);
 
                 gradingExamQuestionDto.Answer = examAnswer.Answer ?? string.Empty;
 
@@ -682,7 +682,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             examAnswer.ToInsert(_sessionContext);
 
-            await new ExamRepository<ExamAnswer>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).ValidateAddAsync(examAnswer, cancellationToken);
+            await new ExamRepository<ExamAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider).ValidateAddAsync(examAnswer, cancellationToken);
 
             return examAnswers;
         }
@@ -691,8 +691,8 @@ namespace Hotline.Application.Exam.Service.ExamManages
         private async Task<UserExamQuestionDto> GetNextExamQuestion(AddUserExamItemDto addUserExamItemDto)
         {
             // TODO: 获取未阅卷的第一道题
-            var testPaperItemRepository = new ExamRepository<ExamQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var examRepository = new ExamRepository<ExamManage>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var testPaperItemRepository = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var examRepository = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var userExamTable = _repository.Queryable().Where(x => x.Id == addUserExamItemDto.UserExamId);
             var userExamItemTable = _userExamItemRepository.Queryable().WhereIF(addUserExamItemDto.QuestionId.IsNotNullOrEmpty(), x => x.QuestionId == addUserExamItemDto.QuestionId);
             var examTable = examRepository.Queryable();
@@ -717,7 +717,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
                 if (question.QuestionType.CheckSelectType())
                 {
                     var userExamItemOptionTable = _userExamItemOptionRepository.Queryable().Where(x => x.UserExamItemId == userExamItem.Id);
-                    var quesitonOptionTable = new ExamRepository<ExamQuestionOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+                    var quesitonOptionTable = new ExamRepository<ExamQuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
                     var queryResult = userExamItemOptionTable.InnerJoin(quesitonOptionTable, (u, q) => u.QuestionOptionId == q.Id)
                         .Select((u, q) => new UserExamItemOptionDto
@@ -731,7 +731,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
                 }
                 else
                 {
-                    var examAnswer = new ExamRepository<ExamAnswer>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.UserExamItemId == userExamItem.Id).First();
+                    var examAnswer = new ExamRepository<ExamAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.UserExamItemId == userExamItem.Id).First();
 
                     userExamQuestionDto.Answer = examAnswer.Answer ?? string.Empty;
                 }
@@ -748,7 +748,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
         private async Task<List<ExamAnswer>> UpdateExamAnswer(UpdateUserExamItemDto updateUserExamItemDto, CancellationToken cancellationToken)
         {
-            var repository = new ExamRepository<ExamAnswer>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var repository = new ExamRepository<ExamAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var examAnswerTable = repository.Queryable();
 
@@ -916,7 +916,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             var userExamTable = _repository.Queryable().Where(expression);
 
             var examManageExpression = queryRequest.GetExamManageExpression();
-            var examManageTable = new ExamRepository<ExamManage>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(examManageExpression);
+            var examManageTable = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(examManageExpression);
 
             var queryable = userExamTable.InnerJoin(examManageTable, (u, e) => u.ExamId == e.Id).Select((u, e) => new UserExamResultViewResponse
             {

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

@@ -327,7 +327,7 @@ namespace Hotline.Application.Exam.Service.Practices
 
         private async Task<List<PracticeQuestionKnowladgeDto>> GetPracticeQuestionKnowladge(PracticeQuestionRequest practiceQuestionRequest)
         {
-            var knowledgeRepository = new ExamRepository<KnowledgeBase.Knowledge>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var knowledgeRepository = new ExamRepository<KnowledgeBase.Knowledge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var expression = practiceQuestionRequest.GetExpression();
             var practiceQuestionTable = _practiceQuestionRepository.Queryable().Where(expression);
@@ -349,7 +349,7 @@ namespace Hotline.Application.Exam.Service.Practices
         private async Task<List<PracticeQuestionSourcewareDto>> GetPracticeQuestionSourceware(PracticeQuestionRequest practiceQuestionRequest)
         {
 
-            var sourcewareRepository = new ExamRepository<Sourceware>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var sourcewareRepository = new ExamRepository<Sourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var expression = practiceQuestionRequest.GetExpression();
             var practiceQuestionTable = _practiceQuestionRepository.Queryable().Where(expression);
@@ -402,7 +402,7 @@ namespace Hotline.Application.Exam.Service.Practices
 
         private async Task<List<PracticeQuestionSourceware>> AddPracticeQuestionSourcewareAsync(List<AddPracticeQuestionDto> practiceQuestionDtos, CancellationToken cancellationToken)
         {
-            var questionSourcewareRepository = new ExamRepository<QuestionSourceware>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionSourcewareRepository = new ExamRepository<QuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = practiceQuestionDtos.Select(x => x.QuestionId);
 
@@ -438,7 +438,7 @@ namespace Hotline.Application.Exam.Service.Practices
 
         private async Task<List<PracticeQuestionKnowladge>> AddPracticeQuestionKnowladgeAsync(List<AddPracticeQuestionDto> practiceQuestionDtos, CancellationToken cancellationToken)
         {
-            var questionKnowladgeRepository = new ExamRepository<QuestionKnowladge>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionKnowladgeRepository = new ExamRepository<QuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = practiceQuestionDtos.Select(x => x.QuestionId);
 
@@ -473,7 +473,7 @@ namespace Hotline.Application.Exam.Service.Practices
 
         private async Task<List<PracticeQuestionOptions>> AddPracticeQuestionOptions(List<AddPracticeQuestionDto> practiceQuestionDtos, CancellationToken cancellationToken)
         {
-            var questionOptionRepository = new ExamRepository<QuestionOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionOptionRepository = new ExamRepository<QuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = practiceQuestionDtos.Select(x => x.QuestionId);
 
@@ -553,8 +553,8 @@ namespace Hotline.Application.Exam.Service.Practices
 
             var tagIds = actionRequest.PracticeTagDtos.Select(x => x.TagId).ToList();
 
-            var questionTagRepostiory = new ExamRepository<QuestionTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var questionRepository = new ExamRepository<Question>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionTagRepostiory = new ExamRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionRepository = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var questionTagTable = questionTagRepostiory.Queryable();
             var questionTable = questionRepository.Queryable();

src/Hotline.Application/Exam/Service/Questions/QuestionService.cs

@@ -110,7 +110,7 @@ namespace Hotline.Application.Exam.Service.Questions
             var questionTable = _repository.Queryable().Where(expression);
 
             var questionKnowladgeExpression = queryRequest.GetQuestionKnowladgeExpression();
-            var questionKnowladgeTable = new ExamRepository<QuestionKnowladge>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(questionKnowladgeExpression);
+            var questionKnowladgeTable = new ExamRepository<QuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(questionKnowladgeExpression);
 
             var queryable = questionTable.InnerJoin(questionKnowladgeTable, (q, k) => q.Id == k.QuestionId).Select((q, k) => new QuestionViewResponse
             {
@@ -133,8 +133,8 @@ namespace Hotline.Application.Exam.Service.Questions
             var questionTable = _repository.Queryable().Where(expression);
 
             var questionTagExpression = queryRequest.GetQuestionTagExpression();
-            var questionTagRepository = new BaseRepository<QuestionTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var examTagRepository = new BaseRepository<ExamTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionTagRepository = new BaseRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var examTagRepository = new BaseRepository<ExamTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionTagTable = questionTagRepository.Queryable().Where(questionTagExpression);
 
             var allQuestionTagTable = questionTagRepository.Queryable();
@@ -314,7 +314,7 @@ namespace Hotline.Application.Exam.Service.Questions
                 }
             });
 
-            var repository = new ExamRepository<ExamTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var repository = new ExamRepository<ExamTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             examTags = await repository.Queryable().Where(x => tagNames.Contains(x.Name)).ToListAsync();
 

src/Hotline.Application/Exam/Service/Sourcewares/SourcewareService.cs

@@ -109,7 +109,7 @@ namespace Hotline.Application.Exam.Service.Sourcewares
         /// <returns></returns>
         private async Task SetDefaultCategory(AddSourcewareDto actionRequest)
         {
-            var category = await new BaseRepository<SourcewareCategory>(_repository.UOW, _datePermissionFilterBuilder, _serviceProvider).Queryable().FirstAsync(x => x.Name == InfrastructureConstant.NoCategory);
+            var category = await new BaseRepository<SourcewareCategory>(_uow, _datePermissionFilterBuilder, _serviceProvider).Queryable().FirstAsync(x => x.Name == InfrastructureConstant.NoCategory);
 
             if (actionRequest.CategoryId.IsNullOrEmpty())
             {
@@ -125,7 +125,7 @@ namespace Hotline.Application.Exam.Service.Sourcewares
         {
             var expression = queryRequest.GetExpression();
             var query = _repository.Queryable().Where(expression);
-            var sourcewareCategoryTable = new BaseRepository<SourcewareCategory>(_repository.UOW, _datePermissionFilterBuilder, _serviceProvider).Queryable();
+            var sourcewareCategoryTable = new BaseRepository<SourcewareCategory>(_uow, _datePermissionFilterBuilder, _serviceProvider).Queryable();
             var querable = query.OrderBy(o=>o.SortIndex).Select(m => new SourcewareViewResponse
             {
                 Name = m.Name,

src/Hotline.Application/Exam/Service/TestPapers/TestPaperService.cs

@@ -328,8 +328,8 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
         private async Task<List<SimpleQuestionViewResponse>> GetQuestions(TestPaperQuestionRequest testPaperQuestionRequest)
         {
-            var questionRepository = new ExamRepository<Question>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var questionTagRepository = new ExamRepository<QuestionTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionRepository = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionTagRepository = new ExamRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var expression = testPaperQuestionRequest.GetExpression();
             var questionExpression = testPaperQuestionRequest.GetQuestionExpression();
@@ -355,8 +355,8 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
         private async Task<List<Question>> GetQuestions(GenerateTestPaperRequest generateTestPaperRequest)
         {
-            var questionRepository = new ExamRepository<Question>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var questionTagRepository = new ExamRepository<QuestionTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionRepository = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionTagRepository = new ExamRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var testPaperRuleTable = _testPaperRuleRepository.Queryable().Where(x => x.TestPaperId == generateTestPaperRequest.TestPaperId);
             var testPaperTagTable = _testPaperRuleTagRepository.Queryable();
             var questionTagTable = questionTagRepository.Queryable();
@@ -386,8 +386,8 @@ namespace Hotline.Application.Exam.Service.TestPapers
             var expression = tagQuestionCountRequest.GetExpression();
             var questionExpression = tagQuestionCountRequest.GetQuestionExpression();
 
-            var tagQuestionRepository = new ExamRepository<QuestionTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var quesitonRepository = new ExamRepository<Question>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var tagQuestionRepository = new ExamRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var quesitonRepository = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var tagQuestionTable = tagQuestionRepository.Queryable().Where(expression);
             var questionTable = quesitonRepository.Queryable().Where(questionExpression);
@@ -813,9 +813,9 @@ namespace Hotline.Application.Exam.Service.TestPapers
         private async Task<List<TestPaperQuestionCountViewResponse>> CalcuteRandomQuestionCount(TestPaperQuestionCountRequest testPaperQuestionCountRequest)
         {
             var testPaperQuestionCountViewResponses = new List<TestPaperQuestionCountViewResponse>();
-            var extractRuleRepository = new ExamRepository<ExtractRule>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var ruleTagRepository = new ExamRepository<RuleTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var tagQuestionRepository = new ExamRepository<TagQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var extractRuleRepository = new ExamRepository<ExtractRule>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var ruleTagRepository = new ExamRepository<RuleTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var tagQuestionRepository = new ExamRepository<TagQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
 
             var expression = testPaperQuestionCountRequest.GetExpression();
@@ -868,7 +868,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
         private async Task<List<TestPaperItemOptions>> AddTestPaperItemOptions(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
-            var questionOptionRepository = new ExamRepository<QuestionOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionOptionRepository = new ExamRepository<QuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = actionRequest.TestPaperItemDtos.Select(x => x.QuestionId);
 
@@ -907,7 +907,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
         private async Task<List<TestPaperItemAnswer>> AddTestPaperItemAnswer(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
-            var questionOptionRepository = new ExamRepository<QuestionAnswer>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionOptionRepository = new ExamRepository<QuestionAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = actionRequest.TestPaperItemDtos?.Select(x => x.QuestionId);            
 
@@ -945,7 +945,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
         private async Task<List<TestPaperItemSourceware>> AddTestPaperItemSourcewareAsync(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
-            var questionSourcewareRepository = new ExamRepository<QuestionSourceware>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionSourcewareRepository = new ExamRepository<QuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = actionRequest.TestPaperItemDtos.Select(x => x.QuestionId);
 
@@ -981,7 +981,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
         private async Task<List<TestPaperItemKnowladge>> AddTestPaperItemKnowladgeAsync(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
-            var questionKnowladgeRepository = new ExamRepository<QuestionKnowladge>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionKnowladgeRepository = new ExamRepository<QuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = actionRequest.TestPaperItemDtos.Select(x => x.QuestionId);
 

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

@@ -22,6 +22,7 @@ using Hotline.Repository.SqlSugar.Exam.Interfaces.Trains;
 using Hotline.Repository.SqlSugar.Extensions;
 using Hotline.Share.Dtos.Trains;
 using Hotline.Share.Requests.Train;
+using Hotline.Users;
 using JiebaNet.Segmenter.Common;
 using MapsterMapper;
 using XF.Domain.Authentications;
@@ -34,6 +35,8 @@ namespace Hotline.Application.Exam.Service.Trains
         private readonly ITrainPlanRepository _repository;
         private readonly ITrainPlanTemplateRepository _trainPlanTemplateRepository;
         private readonly ITrainRecordRepository _trainRecordRepository;
+        private readonly IDataPermissionFilterBuilder _dataPermissionFilterBuilder;
+        private readonly IServiceProvider _serviceProvider;
         private readonly ISessionContext _sessionContext;
         private readonly IMapper _mapper;
         private AddTrainPlanDto _addTrainPlanDto;
@@ -41,12 +44,16 @@ namespace Hotline.Application.Exam.Service.Trains
         public TrainPlanService(ITrainPlanRepository repository,
             ITrainPlanTemplateRepository trainPlanTemplateRepository,
             ITrainRecordRepository trainRecordRepository,
+            IDataPermissionFilterBuilder dataPermissionFilterBuilder,
+            IServiceProvider serviceProvider,
             ISessionContext sessionContext,
             IMapper mapper) : base(repository, mapper, sessionContext)
         {
             this._repository = repository;
             this._trainPlanTemplateRepository = trainPlanTemplateRepository;
             this._trainRecordRepository = trainRecordRepository;
+            this._dataPermissionFilterBuilder = dataPermissionFilterBuilder;
+            this._serviceProvider = serviceProvider;
             this._sessionContext = sessionContext;
             this._mapper = mapper;
         }
@@ -208,12 +215,15 @@ namespace Hotline.Application.Exam.Service.Trains
         {
            
             var trainPracticeTable = _trainRecordRepository.Queryable().Where(x => x.TrainPlanId == entityQueryRequest.Id);
+            var userTable = new ExamRepository<User>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
-            var trainPractices = trainPracticeTable.Select(t => new TrainRecordDto
+            var trainPractices = trainPracticeTable.InnerJoin(userTable,(t,u)=>t.UserId == u.Id).Select((t, u) => new TrainRecordDto
             {
                 Id = t.Id,
                 TrainPlanId = t.TrainPlanId,
-                UserId = t.UserId
+                UserId = t.UserId,
+                Name = u.Name,
+                fullOrgName = u.FullOrgName
             });
 
             return await trainPractices.ToListAsync();

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

@@ -129,7 +129,7 @@ namespace Hotline.Application.Exam.Service.Trains
         }
         public async Task<TrainPracticeDto> GetTrainPracticeAsync(TrainPracticeRequest trainPracticeRequest)
         {
-            var trainPracticeRepostitory = new TrainPracticeRepository(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeRepostitory = new TrainPracticeRepository(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var trainPractice = await trainPracticeRepostitory.GetAsync(trainPracticeRequest.TrainPracticeId);
 
@@ -153,10 +153,10 @@ namespace Hotline.Application.Exam.Service.Trains
             var expression = trainResultReportPagedRequest.GetExpression();
             var templateExpression = trainResultReportPagedRequest.GetTemplateExpression();
 
-            var trainTemplateRepostitory = new ExamRepository<TrainTemplate>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var trainPlanRepository = new ExamRepository<TrainPlan>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var trainPlanTemplateRepository = new ExamRepository<TrainPlanTemplate>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var userRepository = new ExamRepository<User>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainTemplateRepostitory = new ExamRepository<TrainTemplate>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPlanRepository = new ExamRepository<TrainPlan>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPlanTemplateRepository = new ExamRepository<TrainPlanTemplate>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var userRepository = new ExamRepository<User>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var trainPlanTable = trainPlanRepository.Queryable().Where(expression);
             var trainTemplateTable = trainTemplateRepostitory.Queryable().Where(templateExpression);
@@ -195,9 +195,9 @@ namespace Hotline.Application.Exam.Service.Trains
             var expression = trainResultReportPagedRequest.GetExpression();
             var templateExpression = trainResultReportPagedRequest.GetTemplateExpression();
 
-            var trainTemplateRepostitory = new ExamRepository<TrainTemplate>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var trainPlanRepository = new ExamRepository<TrainPlan>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var trainPlanTemplateRepository = new ExamRepository<TrainPlanTemplate>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainTemplateRepostitory = new ExamRepository<TrainTemplate>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPlanRepository = new ExamRepository<TrainPlan>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPlanTemplateRepository = new ExamRepository<TrainPlanTemplate>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var trainPlanTable = trainPlanRepository.Queryable().Where(expression);
             var trainTemplateTable = trainTemplateRepostitory.Queryable().Where(templateExpression);
@@ -241,7 +241,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private SqlSugar.ISugarQueryable<TrainRecordViewResponse> QueryResult(TrainRecordPagedRequest queryRequest)
         {
-            var trainPlanRepository = new TrainPlanRepository(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPlanRepository = new TrainPlanRepository(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var expression = queryRequest.GetExpression();
             var trainPlanTable = trainPlanRepository.Queryable().Where(expression);
             var trainRecordTable = _repository.Queryable();
@@ -271,9 +271,9 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private SqlSugar.ISugarQueryable<SimpleQuestionDto> QueryQuestions(EntityQueryRequest entityQueryRequest)
         {
-            var trainPlanRepository = new ExamRepository<TrainPlan>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var trainPracticeRepository = new ExamRepository<TrainPractice>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var trainPlanTemplateRepository = new ExamRepository<TrainPlanTemplate>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPlanRepository = new ExamRepository<TrainPlan>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeRepository = new ExamRepository<TrainPractice>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPlanTemplateRepository = new ExamRepository<TrainPlanTemplate>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var trainRecordTable = _repository.Queryable().Where(x => x.Id == entityQueryRequest.Id);
             var trainPlanTable = trainPlanRepository.Queryable();
@@ -294,8 +294,8 @@ namespace Hotline.Application.Exam.Service.Trains
         private async Task<List<SimpleKnowladgeDto>> GetKnowladges(EntityQueryRequest entityQueryRequest)
         {
             var questionTable = QueryQuestions(entityQueryRequest);
-            var questionSourcewareRepository = new ExamRepository<PracticeQuestionSourceware>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var sourcewareRepository = new ExamRepository<KnowledgeBase.Knowledge>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionSourcewareRepository = new ExamRepository<PracticeQuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var sourcewareRepository = new ExamRepository<KnowledgeBase.Knowledge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionSourcewareTable = questionSourcewareRepository.Queryable();
             var sourcewareTable = sourcewareRepository.Queryable();
 
@@ -329,8 +329,8 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private async Task<TrainPracticeDto> GetTrainQuestionOptions(AddTrainDto addTrainDto)
         {
-            var trainPracticeOptionsRepository = new ExamRepository<TrainPracticeOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var trainPracticeRepository = new ExamRepository<TrainPractice>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeOptionsRepository = new ExamRepository<TrainPracticeOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeRepository = new ExamRepository<TrainPractice>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             // TODO: 获取未答题的第一道题
             var trainPractice = await trainPracticeRepository.Queryable()
@@ -353,7 +353,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private async Task<List<SimpleTrainPracticeOptionsDto>> GetTrainQuestionOptions(TrainPracticeRequest trainPracticeRequest)
         {
-            var trainPracticeRepository = new ExamRepository<TrainPracticeOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeRepository = new ExamRepository<TrainPracticeOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             // TODO: 获取未阅卷的第一道题
             var trainPracticeOptions = trainPracticeRepository.Queryable().Where(x => x.TrainPracticeId == trainPracticeRequest.TrainPracticeId);
 
@@ -369,10 +369,10 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private async Task<List<TrainPracticeKnowladgeDto>> GetTrainPracticeKnowladges(TrainPracticeRequest trainPracticeRequest)
         {
-            var trainPracticeKnowladgeRepository = new ExamRepository<TrainPracticeKnowladge>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var knowledgeRepository = new ExamRepository<KnowledgeBase.Knowledge>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeKnowladgeRepository = new ExamRepository<TrainPracticeKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var knowledgeRepository = new ExamRepository<KnowledgeBase.Knowledge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
-            var trainPracticeRepostitory = new ExamRepository<TrainPractice>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeRepostitory = new ExamRepository<TrainPractice>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var expression = trainPracticeRequest.GetExpression();
             var trainPracticeTable = trainPracticeRepostitory.Queryable().Where(expression);
@@ -393,10 +393,10 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private async Task<List<TrainPracticeSourcewareDto>> GetTrainPracticeSourcewares(TrainPracticeRequest trainPracticeRequest)
         {
-            var trainPracticeSourcewareRepository = new ExamRepository<TrainPracticeSourceware>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var sourcewareRepository = new ExamRepository<Sourceware>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeSourcewareRepository = new ExamRepository<TrainPracticeSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var sourcewareRepository = new ExamRepository<Sourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
-            var trainPracticeRepostitory = new ExamRepository<TrainPractice>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeRepostitory = new ExamRepository<TrainPractice>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var expression = trainPracticeRequest.GetExpression();
             var trainPracticeTable = trainPracticeRepostitory.Queryable().Where(expression);

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

@@ -206,7 +206,7 @@ namespace Hotline.Application.Exam.Service.Trains
         private async Task<List<TrainKnowladgeDto>> GetKnowladges(EntityQueryRequest entityQueryRequest)
         {
             var trainKnowladgeTable = _trainKnowladgeRepository.Queryable().Where(x => x.TrainTemplateId == entityQueryRequest.Id);
-            var knowledgeTable = new ExamRepository<KnowledgeBase.Knowledge>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var knowledgeTable = new ExamRepository<KnowledgeBase.Knowledge>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
             var queseryResult = trainKnowladgeTable.InnerJoin(knowledgeTable, (t, k) => t.KnowladgeId == k.Id).Select((t, k) => new TrainKnowladgeDto
             {
@@ -225,13 +225,16 @@ namespace Hotline.Application.Exam.Service.Trains
 
             var questionIds = actionRequest.TrainPracticeDtos.Where(x => x.QuestionType.CheckSelectType()).Select(x => x.QuestionId).ToList();
 
-            var entityQueryRequest = new EntityQueryRequest
+            if (questionIds.IsNotNullOrEmpty())
             {
-                Expression = ExpressionableUtility.CreateExpression<TrainPracticeOptions>()
-                             .AndIF(questionIds.IsNotNullOrEmpty(), x => questionIds.Contains(x.QuestionId)).ToExpression()
-            };
+				var entityQueryRequest = new EntityQueryRequest
+				{
+					Expression = ExpressionableUtility.CreateExpression<TrainPracticeOptions>()
+							 .AndIF(questionIds.IsNotNullOrEmpty(), x => questionIds.Contains(x.QuestionId)).ToExpression()
+				};
 
-            await DeleteTrainPracticeOptionsAsync(entityQueryRequest, cancellationToken);
+				await DeleteTrainPracticeOptionsAsync(entityQueryRequest, cancellationToken);
+			}            
 
             return await AddTrainPracticeOptionsAsync(_addTrainTemplateDto, cancellationToken);
         }
@@ -245,7 +248,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private async Task<List<TrainPracticeSourceware>> AddTrainPracticeSourcewareAsync(AddTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
-            var questionSourcewareRepository = new ExamRepository<QuestionSourceware>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionSourcewareRepository = new ExamRepository<QuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = actionRequest.TrainPracticeDtos.Select(x => x.QuestionId);
 
@@ -278,7 +281,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private async Task<List<TrainPracticeKnowladge>> AddTrainPracticeKnowladgeAsync(AddTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
-            var questionKnowladgeRepository = new ExamRepository<QuestionKnowladge>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionKnowladgeRepository = new ExamRepository<QuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = actionRequest.TrainPracticeDtos.Select(x => x.QuestionId);
 
@@ -319,13 +322,16 @@ namespace Hotline.Application.Exam.Service.Trains
 
             var questionIds = actionRequest.TrainPracticeDtos.Where(x => x.QuestionType.CheckSelectType()).Select(x => x.QuestionId).ToList();
 
-            var entityQueryRequest = new EntityQueryRequest
+            if (questionIds.IsNotNullOrEmpty())
             {
-                Expression = ExpressionableUtility.CreateExpression<TrainPracticeSourceware>()
-                             .AndIF(questionIds.IsNotNullOrEmpty(), x => questionIds.Contains(x.QuestionId)).ToExpression()
-            };
+				var entityQueryRequest = new EntityQueryRequest
+				{
+					Expression = ExpressionableUtility.CreateExpression<TrainPracticeSourceware>()
+							.AndIF(questionIds.IsNotNullOrEmpty(), x => questionIds.Contains(x.QuestionId)).ToExpression()
+				};
 
-            await DeleteTrainPracticeSourcewareAsync(entityQueryRequest, cancellationToken);
+				await DeleteTrainPracticeSourcewareAsync(entityQueryRequest, cancellationToken);
+			}           
 
             return await AddTrainPracticeSourcewareAsync(_addTrainTemplateDto, cancellationToken);
         }
@@ -341,13 +347,16 @@ namespace Hotline.Application.Exam.Service.Trains
 
             var questionIds = actionRequest.TrainPracticeDtos.Where(x => x.QuestionType.CheckSelectType()).Select(x => x.QuestionId).ToList();
 
-            var entityQueryRequest = new EntityQueryRequest
+            if (questionIds.IsNotNullOrEmpty())
             {
-                Expression = ExpressionableUtility.CreateExpression<TrainPracticeKnowladge>()
-                             .AndIF(questionIds.IsNotNullOrEmpty(), x => questionIds.Contains(x.QuestionId)).ToExpression()
-            };
+				var entityQueryRequest = new EntityQueryRequest
+				{
+					Expression = ExpressionableUtility.CreateExpression<TrainPracticeKnowladge>()
+						  .AndIF(questionIds.IsNotNullOrEmpty(), x => questionIds.Contains(x.QuestionId)).ToExpression()
+				};
 
-            await DeleteTrainPracticeKnowladgeAsync(entityQueryRequest, cancellationToken);
+				await DeleteTrainPracticeKnowladgeAsync(entityQueryRequest, cancellationToken);
+			}        
 
             return await AddTrainPracticeKnowladgeAsync(_addTrainTemplateDto, cancellationToken);
         }
@@ -359,7 +368,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private async Task<List<TrainPracticeOptions>> AddTrainPracticeOptionsAsync(AddTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
-            var questionOptionRepository = new ExamRepository<QuestionOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionOptionRepository = new ExamRepository<QuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = actionRequest.TrainPracticeDtos.Select(x => x.QuestionId);
 
@@ -411,7 +420,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private async Task<List<TrainPracticeDto>> GetTrainPractices(EntityQueryRequest entityQueryRequest)
         {
-            var questionTable = new ExamRepository<Question>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var questionTable = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
             var trainPracticeTable = _trainPracticeRepository.Queryable().Where(x => x.TrainTemplateId == entityQueryRequest.Id);
 
             var trainPractices = trainPracticeTable.InnerJoin(questionTable, (t, q) => t.QuestionId == q.Id).Select((t, q) => new TrainPracticeDto
@@ -504,14 +513,17 @@ namespace Hotline.Application.Exam.Service.Trains
             {
                 var ids = actionRequest.TrainPracticeDtos.Where(x => x.OperationStatus == EEOperationStatus.Delete).Select(x => x.Id).ToList();
 
-                var entityQueryRequest = new EntityQueryRequest
+                if (ids.IsNotNullOrEmpty())
                 {
-                    Expression = ExpressionableUtility.CreateExpression<TrainPractice>()
-                    .AndIF(ids.IsNotEmpty(), x => ids.Contains(x.Id))
-                    .ToExpression()
-                };
-
-                await DeleteTrainPracticeAsync(entityQueryRequest, cancellationToken);
+					var entityQueryRequest = new EntityQueryRequest
+					{
+						Expression = ExpressionableUtility.CreateExpression<TrainPractice>()
+					.AndIF(ids.IsNotEmpty(), x => ids.Contains(x.Id))
+					.ToExpression()
+					};
+
+					await DeleteTrainPracticeAsync(entityQueryRequest, cancellationToken);
+				}                
             }
 
             return trainPractices;
@@ -555,14 +567,18 @@ namespace Hotline.Application.Exam.Service.Trains
             {
                 var ids = actionRequest.TrainKnowladges.Where(x => x.OperationStatus == EEOperationStatus.Delete).Select(x => x.Id).ToList();
 
-                var entityQueryRequest = new EntityQueryRequest
+                if (ids.IsNotNullOrEmpty())
                 {
-                    Expression = ExpressionableUtility.CreateExpression<TrainKnowladge>()
-                    .AndIF(ids.IsNotEmpty(), x => ids.Contains(x.Id))
-                    .ToExpression()
-                };
-
-                await DeleteTrainKnowladgesAsync(entityQueryRequest, cancellationToken);
+					var entityQueryRequest = new EntityQueryRequest
+					{
+						Expression = ExpressionableUtility.CreateExpression<TrainKnowladge>()
+				   .AndIF(ids.IsNotEmpty(), x => ids.Contains(x.Id))
+				   .ToExpression()
+					};
+
+					await DeleteTrainKnowladgesAsync(entityQueryRequest, cancellationToken);
+				}
+               
             }
 
             return trainKnowladges;

src/Hotline.Repository.SqlSugar/Service/ApiService.cs

@@ -33,6 +33,8 @@ namespace Exam.Insfrastructure.Service.Service
         private IMapper _mapper;
         private readonly ISessionContext _sessionContext;
 
+        protected readonly ISugarUnitOfWork<TDBContext> _uow;
+
         public T Entity { get; set; }
 
         public ApiService(IExamRepository<T, TDBContext> repository,IMapper mapper,ISessionContext sessionContext = null)
@@ -41,6 +43,7 @@ namespace Exam.Insfrastructure.Service.Service
             _validator = _repository.Validator;
             _mapper = mapper;
             this._sessionContext = sessionContext;
+            _uow = _repository.UOW;
         } 
         #endregion
 

src/Hotline.Share/Dtos/Trains/TrainRecordDto.cs

@@ -27,6 +27,18 @@ namespace Hotline.Share.Dtos.Trains
         [Description("练习题")]
         public List<SimpleQuestionDto> QuestionDtos { get; set; }
 
+        /// <summary>
+        /// 用户名
+        /// </summary>
+        [Description("用户名")]
+        public string Name { get; set; }
+
+        /// <summary>
+        /// 组织名称
+        /// </summary>
+        [Description("组织名称")]
+        public string fullOrgName { get; set; }
+
     }
 
     /// <summary>