合并冲突

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

@@ -0,0 +1,232 @@
+using Exam.ExamManages;
+using Exam.Questions;
+using Exam.Repository.Sqlsugar.Repositories;
+using Hotline.Exams.ExamManages;
+using Hotline.Repository.SqlSugar.DataPermissions;
+using Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages;
+using Hotline.Repository.SqlSugar.Exam.Interfaces.Exams;
+using Hotline.Repository.SqlSugar.Exam.Interfaces.Questions;
+using Hotline.Repository.SqlSugar.Extensions;
+using Hotline.Repository.SqlSugar.Interface;
+using MapsterMapper;
+using XF.Domain.Authentications;
+
+namespace Hotline.Application.Exam.Proxy
+{
+    public class ExamManageProxy
+    {
+        private readonly IExamManageRepository _repository;
+        private readonly IExamQuestionRepository _examQuestionRepository;
+        private readonly IExamQuestionAnswerRepository _examQuestionAnswerRepository;
+        private readonly IExamQuestionOptionsRepository _examQuestionOptionsRepository;
+        private readonly IExamQuestionSourcewareRepository _examQuestionSourcewareRepository;
+        private readonly IExamQuestionKnowladgeRepository _examQuestionKnowladgeRepository;
+        private readonly IDataPermissionFilterBuilder _dataPermissionFilterBuilder;
+        private readonly IServiceProvider _serviceProvider;
+        private readonly IMapper _mapper;
+        private readonly ISessionContext _sessionContext;
+
+        public ExamManageProxy(IExamManageRepository repository,
+            IExamQuestionRepository examQuestionRepository,
+            IExamQuestionAnswerRepository examQuestionAnswerRepository,
+            IExamQuestionOptionsRepository examQuestionOptionsRepository,
+            IExamQuestionSourcewareRepository examQuestionSourcewareRepository,
+            IExamQuestionKnowladgeRepository examQuestionKnowladgeRepository,
+            IDataPermissionFilterBuilder dataPermissionFilterBuilder,
+            IServiceProvider serviceProvider,
+            IMapper mapper, ISessionContext sessionContext)
+        {
+            this._repository = repository;
+            this._examQuestionRepository = examQuestionRepository;
+            this._examQuestionAnswerRepository = examQuestionAnswerRepository;
+            this._examQuestionOptionsRepository = examQuestionOptionsRepository;
+            this._examQuestionSourcewareRepository = examQuestionSourcewareRepository;
+            this._examQuestionKnowladgeRepository = examQuestionKnowladgeRepository;
+            this._dataPermissionFilterBuilder = dataPermissionFilterBuilder;
+            this._serviceProvider = serviceProvider;
+            this._mapper = mapper;
+            this._sessionContext = sessionContext;
+        }
+
+        #region public method
+        public async Task GenerateQuestion(List<Question> questions, string testPaperId, CancellationToken cancellationToken)
+        {
+            List<ExamQuestion> examQuestions = await SyncQuestion(questions, testPaperId, cancellationToken);
+
+            var examQuestionOptionses = await SyncQuestionOptions(examQuestions, cancellationToken);
+            var examQuestionSourcewares = await SyncQuestionSourcewares(examQuestions, cancellationToken);
+            var examQuestionKnowladges = await SyncQuestionKnowladge(examQuestions, cancellationToken);
+            var examQuestionAnswers = await SyncQuestionAnswer(examQuestions, cancellationToken);
+
+            examQuestions.ForEach(item =>
+            {
+                item.ExamQuestionOptionses = examQuestionOptionses.Where(x => item.QuestionId == x.QuestionId).ToList();
+                item.ExamQuestionOptionses.ForEach(x =>
+                {
+                    x.ExamQuestionId = item.Id;
+                });
+                item.ExamQuestionSourcewares = examQuestionSourcewares.Where(x => item.QuestionId == x.QuestionId).ToList();
+                item.ExamQuestionSourcewares.ForEach(x =>
+                {
+                    x.ExamQuestionId = item.Id;
+                });
+                item.ExamQuestionKnowladges = examQuestionKnowladges.Where(x => item.QuestionId == x.QuestionId).ToList();
+                item.ExamQuestionKnowladges.ForEach(x =>
+                {
+                    x.ExamQuestionId = item.Id;
+                });
+                
+                item.ExamQuestionAnswers = examQuestionAnswers.Where(x => item.QuestionId == x.QuestionId).ToList();
+                item.ExamQuestionAnswers.ForEach(x =>
+                {
+                    x.ExamQuestionId = item.Id;
+                });
+            });
+
+            await _examQuestionRepository.AddNav(examQuestions)
+                .Include(x => x.ExamQuestionAnswers)
+                .Include(x => x.ExamQuestionKnowladges)
+                .Include(x => x.ExamQuestionOptionses)
+                .Include(x => x.ExamQuestionSourcewares)
+                .ExecuteCommandAsync();
+        }
+
+
+        public async Task DeleteExamQuestions(string testPaperId, CancellationToken cancellationToken)
+        {
+            var examQuestionIds = await _examQuestionRepository.Queryable().Where(x => x.ExamId == testPaperId).Select(x => x.Id).ToListAsync();
+
+            await _examQuestionRepository.RemoveAsync(x => examQuestionIds.Contains(x.Id));
+
+            await _examQuestionAnswerRepository.RemoveAsync(x => examQuestionIds.Contains(x.ExamQuestionId));
+
+            await _examQuestionKnowladgeRepository.RemoveAsync(x => examQuestionIds.Contains(x.ExamQuestionId));
+
+            await _examQuestionOptionsRepository.RemoveAsync(x => examQuestionIds.Contains(x.ExamQuestionId));
+
+            await _examQuestionSourcewareRepository.RemoveAsync(x => examQuestionIds.Contains(x.ExamQuestionId));
+        }
+
+        #endregion
+
+        #region private method
+
+
+        private async Task<List<ExamQuestionAnswer>> SyncQuestionAnswer(List<ExamQuestion> examQuestions, CancellationToken cancellationToken)
+        {
+            var questionAnswersRepository = new ExamRepository<QuestionAnswer>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionIds = examQuestions.Select(x => x.QuestionId);
+            var questionAnswers = await questionAnswersRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
+
+            var examQuestionAnswers = new List<ExamQuestionAnswer>();
+
+            questionAnswers.ForEach(item =>
+            {
+                var examQuestionAnswer = _mapper.Map<ExamQuestionAnswer>(item);
+                var examQuestion = examQuestions.FirstOrDefault(x => x.QuestionId == item.QuestionId);
+                examQuestionAnswer.QuestionAnswerId = item.Id;
+                examQuestionAnswer.ExamQuestionId = examQuestion?.Id ?? string.Empty;
+                examQuestionAnswers.Add(examQuestionAnswer);
+            });
+
+            examQuestionAnswers.ToInsert(_sessionContext);
+
+            await _examQuestionAnswerRepository.ValidateAddAsync(examQuestionAnswers, cancellationToken);
+
+            return examQuestionAnswers;
+        }
+
+        private async Task<List<ExamQuestionKnowladge>> SyncQuestionKnowladge(List<ExamQuestion> examQuestions, CancellationToken cancellationToken)
+        {
+            var questionKnowladgesRepository = new ExamRepository<QuestionKnowladge>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionIds = examQuestions.Select(x => x.QuestionId);
+            var questionKnowladges = await questionKnowladgesRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
+
+            var examQuestionKnowladges = new List<ExamQuestionKnowladge>();
+
+            questionKnowladges.ForEach(item =>
+            {
+                var examQuestionKnowladge = _mapper.Map<ExamQuestionKnowladge>(item);
+                var examQuestion = examQuestions.FirstOrDefault(x => x.QuestionId == item.QuestionId);
+                examQuestionKnowladge.KnowladgeId = item.Id;
+                examQuestionKnowladge.ExamQuestionId = examQuestion?.Id ?? string.Empty;
+                examQuestionKnowladges.Add(examQuestionKnowladge);
+            });
+
+            examQuestionKnowladges.ToInsert(_sessionContext);
+
+            await _examQuestionKnowladgeRepository.ValidateAddAsync(examQuestionKnowladges, cancellationToken);
+
+            return examQuestionKnowladges;
+        }
+
+        private async Task<List<ExamQuestionSourceware>> SyncQuestionSourcewares(List<ExamQuestion> examQuestions, CancellationToken cancellationToken)
+        {
+            var questionSourcewaresRepository = new ExamRepository<QuestionSourceware>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionIds = examQuestions.Select(x => x.QuestionId);
+            var questionSourcewares = await questionSourcewaresRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
+
+            var examQuestionSourcewares = new List<ExamQuestionSourceware>();
+
+            questionSourcewares.ForEach(item =>
+            {
+                var examQuestionSourceware = _mapper.Map<ExamQuestionSourceware>(item);
+                var examQuestion = examQuestions.FirstOrDefault(x => x.QuestionId == item.QuestionId);
+                examQuestionSourceware.SourcewareId = item.Id;
+                examQuestionSourceware.ExamQuestionId = examQuestion?.Id ?? string.Empty;
+                examQuestionSourcewares.Add(examQuestionSourceware);
+            });
+
+            examQuestionSourcewares.ToInsert(_sessionContext);
+
+            await _examQuestionSourcewareRepository.ValidateAddAsync(examQuestionSourcewares, cancellationToken);
+
+            return examQuestionSourcewares;
+        }
+
+        private async Task<List<ExamQuestionOptions>> SyncQuestionOptions(List<ExamQuestion> examQuestions, CancellationToken cancellationToken)
+        {
+            var questionOptionsRepository = new ExamRepository<QuestionOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionIds = examQuestions.Select(x => x.QuestionId);
+            var questionOptions = await questionOptionsRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
+
+            var examQuestionOptions = new List<ExamQuestionOptions>();
+
+            questionOptions.ForEach(item =>
+            {
+                var examQuestionOption = _mapper.Map<ExamQuestionOptions>(item);
+                var examQuestion = examQuestions.FirstOrDefault(x => x.QuestionId == item.QuestionId);
+                examQuestionOption.QuestionOptionId = item.Id;
+                examQuestionOption.ExamQuestionId = examQuestion?.Id ?? string.Empty;
+                examQuestionOptions.Add(examQuestionOption);
+            });
+
+            examQuestionOptions.ToInsert(_sessionContext);
+
+            await _examQuestionOptionsRepository.ValidateAddAsync(examQuestionOptions, cancellationToken);
+
+            return examQuestionOptions;
+        }
+
+        private async Task<List<ExamQuestion>> SyncQuestion(List<Question> questions, string testPaperId, CancellationToken cancellationToken)
+        {
+
+            var examQuestions = new List<ExamQuestion>();
+
+            questions.ForEach(item =>
+            {
+                var examQuestion = _mapper.Map<ExamQuestion>(item);
+                examQuestion.ExamId = testPaperId;
+                examQuestion.QuestionId = item.Id;
+                examQuestions.Add(examQuestion);
+            });
+
+            examQuestions.ToInsert(_sessionContext);
+
+            await _examQuestionRepository.ValidateAddAsync(examQuestions, cancellationToken);
+
+            return examQuestions;
+        }
+        #endregion
+    }
+}

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

@@ -89,6 +89,23 @@ namespace Hotline.Application.Exam.Proxy
                 .Include(x => x.TestPaperItemSourcewares)
                 .ExecuteCommandAsync();
         }
+       
+        
+        public async Task DeleteTestPaperItems(string testPaperId, CancellationToken cancellationToken)
+        {
+            var testPaperItemIds = await _testPaperItemRepository.Queryable().Where(x => x.TestPaperId == testPaperId).Select(x=>x.Id).ToListAsync();
+
+            await _testPaperItemRepository.RemoveAsync(x => testPaperItemIds.Contains(x.Id));
+
+            await _testPaperItemAnswerRepository.RemoveAsync(x => testPaperItemIds.Contains(x.TestPaperItemId));
+
+            await _testPaperItemKnowladgeRepository.RemoveAsync(x => testPaperItemIds.Contains(x.TestPaperItemId));
+
+            await _testPaperItemOptionsRepository.RemoveAsync(x => testPaperItemIds.Contains(x.TestPaperItemId));
+
+            await _testPaperItemSourcewareRepository.RemoveAsync(x => testPaperItemIds.Contains(x.TestPaperItemId));
+        }
+
         #endregion
 
         #region private method
@@ -106,7 +123,7 @@ namespace Hotline.Application.Exam.Proxy
             {
                 var testPaperItemAnswer = _mapper.Map<TestPaperItemAnswer>(item);
                 var testPaperItem = testPaperItems.FirstOrDefault(x => x.QuestionId == item.QuestionId);
-                testPaperItemAnswer.QueswerAnswerId = item.Id;
+                testPaperItemAnswer.QuestionAnswerId = item.Id;
                 testPaperItemAnswer.TestPaperItemId = testPaperItem?.Id ?? string.Empty;
                 testPaperItemAnswers.Add(testPaperItemAnswer);
             });

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

@@ -27,9 +27,8 @@ namespace Hotline.Application.Exam.QueryExtensions.ExamManages
             Expression<Func<ExamManage, bool>> expression = m => m.Id != null;
 
             expression = ExpressionableUtility.CreateExpression<ExamManage>()
-                         .AndIF(generateExamTestPaperRequest.ExamManageId.IsNotNullOrEmpty(), x => x.Id.Contains(generateExamTestPaperRequest.ExamManageId))
-                         .AndIF(generateExamTestPaperRequest.TestPaperId.IsNotNullOrEmpty(), x => x.TestPaperId.Contains(generateExamTestPaperRequest.TestPaperId))
-                         .And(x=>x.Mode == Share.Enums.Exams.EExamMode.Random)
+                         .AndIF(generateExamTestPaperRequest.ExamManageId.IsNotNullOrEmpty(), x => x.Id == generateExamTestPaperRequest.ExamManageId)
+                         .AndIF(generateExamTestPaperRequest.TestPaperId.IsNotNullOrEmpty(), x => x.TestPaperId == generateExamTestPaperRequest.TestPaperId)
                          .ToExpression();
 
             return expression;

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

@@ -26,11 +26,11 @@ namespace Hotline.Application.Exam.QueryExtensions.ExamManages
             return expression;
         }
 
-        public static Expression<Func<TestPaperItem, bool>> GetExpression(this ExamQuestionRequest examQuestionRequest)
+        public static Expression<Func<ExamQuestion, bool>> GetExpression(this ExamQuestionRequest examQuestionRequest)
         {
-            Expression<Func<TestPaperItem, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamQuestion, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<TestPaperItem>()
+            expression = ExpressionableUtility.CreateExpression<ExamQuestion>()
                 .AndIF(examQuestionRequest.QuestionId.IsNotNullOrEmpty(), x => x.QuestionId == examQuestionRequest.QuestionId).ToExpression();
 
             return expression;

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

@@ -39,6 +39,9 @@ using Hotline.Repository.SqlSugar.Exam.Interfaces.Questions;
 using Microsoft.AspNetCore.Http;
 using Hotline.Tools;
 using Hotline.Users;
+using System.Buffers;
+using Exam.Repository.Sqlsugar.Repositories.TestPapers;
+using Hotline.Repository.SqlSugar.Exam.Interfaces.Exams;
 
 namespace Hotline.Application.Exam.Service.ExamManages
 {
@@ -54,10 +57,16 @@ namespace Hotline.Application.Exam.Service.ExamManages
         private readonly ITestPaperItemOptionsRepository _testPaperItemOptionsRepository;
         private readonly ITestPaperItemSourcewareRepository _testPaperItemSourcewareRepository;
         private readonly ITestPaperItemKnowladgeRepository _testPaperItemKnowladgeRepository;
+        private readonly IExamQuestionRepository _examQuestionRepository;
+        private readonly IExamQuestionAnswerRepository _examQuestionAnswerRepository;
+        private readonly IExamQuestionOptionsRepository _examQuestionOptionsRepository;
+        private readonly IExamQuestionSourcewareRepository _examQuestionSourcewareRepository;
+        private readonly IExamQuestionKnowladgeRepository _examQuestionKnowladgeRepository;
         private readonly IServiceProvider _serviceProvider;
         private readonly IMapper _mapper;
         private readonly ISessionContext _sessionContext;
         private TestPaperProxy _testPaperProxy;
+        private ExamManageProxy _examManageProxy;
         private AddExamManageDto _addExamManageDto;
 
         public ExamManageService(IExamManageRepository repository,
@@ -69,6 +78,11 @@ namespace Hotline.Application.Exam.Service.ExamManages
             ITestPaperItemOptionsRepository testPaperItemOptionsRepository,
             ITestPaperItemSourcewareRepository testPaperItemSourcewareRepository,
             ITestPaperItemKnowladgeRepository testPaperItemKnowladgeRepository,
+            IExamQuestionRepository examQuestionRepository,
+            IExamQuestionAnswerRepository examQuestionAnswerRepository,
+            IExamQuestionOptionsRepository examQuestionOptionsRepository,
+            IExamQuestionSourcewareRepository examQuestionSourcewareRepository,
+            IExamQuestionKnowladgeRepository examQuestionKnowladgeRepository,
             IDataPermissionFilterBuilder dataPermissionFilterBuilder, IServiceProvider serviceProvider,
             IMapper mapper, ISessionContext sessionContext) : base(repository, mapper, sessionContext)
         {
@@ -82,6 +96,11 @@ namespace Hotline.Application.Exam.Service.ExamManages
             this._testPaperItemOptionsRepository = testPaperItemOptionsRepository;
             this._testPaperItemSourcewareRepository = testPaperItemSourcewareRepository;
             this._testPaperItemKnowladgeRepository = testPaperItemKnowladgeRepository;
+            this._examQuestionRepository = examQuestionRepository;
+            this._examQuestionAnswerRepository = examQuestionAnswerRepository;
+            this._examQuestionOptionsRepository = examQuestionOptionsRepository;
+            this._examQuestionSourcewareRepository = examQuestionSourcewareRepository;
+            this._examQuestionKnowladgeRepository = examQuestionKnowladgeRepository;
             _serviceProvider = serviceProvider;
             this._mapper = mapper;
             this._sessionContext = sessionContext;
@@ -147,6 +166,11 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             await base.Complete(base.Entity, OperationConstant.Create);
 
+            await GenerateExamQuestion(new GenerateExamTestPaperRequest { 
+                TestPaperId = actionRequest.TestPaperId ,
+                ExamManageId = id
+            }, cancellationToken);
+
             return id;
         }
 
@@ -160,13 +184,50 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             ResolveQuestionId(actionRequest, actionRequest.Id);
 
-            _addExamManageDto = _mapper.Map<AddExamManageDto>(actionRequest);
+            MapAddUpdateExamManage(actionRequest);
 
             base.Entity.ExamQuestionScores = await ModifyExamQuestionScores(actionRequest, cancellationToken);
 
             base.Entity.UserExams = await ModifyUserExam(actionRequest, cancellationToken);
 
             await base.Complete(base.Entity, OperationConstant.Update);
+
+            await GenerateExamQuestion(new GenerateExamTestPaperRequest { 
+                TestPaperId = actionRequest.TestPaperId, 
+               ExamManageId = actionRequest.Id
+            }, cancellationToken);
+
+        }
+
+        private void MapAddUpdateExamManage(UpdateExamManageDto actionRequest)
+        {
+
+            _addExamManageDto = _mapper.Map<AddExamManageDto>(actionRequest);
+
+            _addExamManageDto.UserExamDtos = new List<AddUserExamDto>();
+
+            _addExamManageDto.ExamQuestionScoreDtos = new List<AddExamQuestionScoreDto>();
+
+            actionRequest.UserExamDtos.ForEach(x =>
+            {
+                x.OperationStatus = x.Id != null ? EEOperationStatus.Update : EEOperationStatus.Update;
+
+                if(x.OperationStatus== EEOperationStatus.Add)
+                {
+                    _addExamManageDto.UserExamDtos.Add(_mapper.Map<AddUserExamDto>(x));
+                }
+
+            });
+            actionRequest.ExamQuestionScoreDtos.ForEach(x =>
+            {
+                x.OperationStatus = x.Id != null ? EEOperationStatus.Update : EEOperationStatus.Add;
+
+                if (x.OperationStatus == EEOperationStatus.Add)
+                {
+                    _addExamManageDto.ExamQuestionScoreDtos.Add(_mapper.Map<AddExamQuestionScoreDto>(x));
+                }
+            });
+
         }
 
         public override async Task DeleteAsync(EntityQueryRequest entityQueryRequest, CancellationToken cancellationToken)
@@ -210,38 +271,59 @@ namespace Hotline.Application.Exam.Service.ExamManages
                     _sessionContext
                     );
 
+                await _testPaperProxy.DeleteTestPaperItems(generateExamTestPaperRequest.TestPaperId, cancellationToken);
+
                 await _testPaperProxy.GenerateQuestion(questions, generateExamTestPaperRequest.TestPaperId, cancellationToken);
             }
         }
 
-        private async Task<List<Question>> GetQuestions(List<TagQuestion> tagQuestionCounts)
+        public async Task GenerateExamQuestion(GenerateExamTestPaperRequest generateExamTestPaperRequest, CancellationToken cancellationToken)
         {
-            var questionRepository = new ExamRepository<Question>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var questionTagRepository = new ExamRepository<QuestionTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-
-            var questionTable = questionRepository.Queryable();
-            var questionTagTable = questionTagRepository.Queryable();
-
-            if (tagQuestionCounts != null)
+            var expression = generateExamTestPaperRequest.GetExpression();
+            var examManages = await _repository.Queryable().Where(expression).ToListAsync();
+            var examManage = examManages.FirstOrDefault();
+            if (examManage != null)
             {
-                var questionQuerables = new List<ISugarQueryable<Question>>();
-                tagQuestionCounts.ForEach(item =>
+                var questions = new List<Question>();
+                if (examManage.Mode == Share.Enums.Exams.EExamMode.Random)
                 {
-                    ISugarQueryable<Question> queryable = questionTable.InnerJoin(questionTagTable, (q, t) => t.Id == t.QuestionId)
-                        .Where((q, t) => q.QuestionType == item.QuestionType && t.TagId == item.TagId).Take(item.Count).Select((q, t)=>q);
-
-                    questionQuerables.Add(queryable);
-                });
+                    var tagQuestionCounts = await GetTagQuestions(examManage);
+                    questions = await GetQuestions(tagQuestionCounts);
+                }
+                else
+                {
+                    questions = await GetQuestions(examManage);
+                }
+
+                _examManageProxy = new ExamManageProxy(_repository,
+                    _examQuestionRepository,
+                    _examQuestionAnswerRepository,
+                    _examQuestionOptionsRepository,
+                    _examQuestionSourcewareRepository,
+                    _examQuestionKnowladgeRepository,
+                    _dataPermissionFilterBuilder,
+                    _serviceProvider,
+                    _mapper,
+                    _sessionContext
+                    );
 
-                var queryResult = questionRepository.UnionAll(questionQuerables.ToArray());
+                await _examManageProxy.DeleteExamQuestions(generateExamTestPaperRequest.TestPaperId, cancellationToken);
 
-                return await queryResult.ToListAsync();
-            }
-            else
-            {
-                return null;
+                await _examManageProxy.GenerateQuestion(questions, generateExamTestPaperRequest.TestPaperId, cancellationToken);
             }
+        }
+
+        private async Task<List<Question>> GetQuestions(ExamManage examManage)
+        {
+            var questionRepository = new ExamRepository<Question>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+
+            var questionTable = questionRepository.Queryable();
+            var testPaperItemTable = _testPaperItemRepository.Queryable().Where(x => x.TestPaperId == examManage.TestPaperId);
+
+            var questions = questionTable.InnerJoin(testPaperItemTable, (q, t) => q.Id == t.QuestionId)
+                .Select((q, t) => q);
 
+            return await questions.ToListAsync();
         }
 
         private async Task<List<TagQuestion>> GetTagQuestions(ExamManage examManage)
@@ -250,6 +332,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             var ruleTagRepository = new ExamRepository<RuleTag>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
             var tagQuestionRepository = new ExamRepository<TagQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
 
+          
             var extractRuleTable = extractRuleRepository.Queryable().Where(x=>x.Id == examManage.ExtractRuleId && x.RuleType == examManage.ExamType);
             var ruleTagTable = ruleTagRepository.Queryable();
             var tagQuestionTable = tagQuestionRepository.Queryable();
@@ -336,7 +419,9 @@ namespace Hotline.Application.Exam.Service.ExamManages
             userExams.ForEach(item =>
             {
                 var userExamDto = userExamDtos.FirstOrDefault(x => x.Id == item.Id);
-                _mapper.Map<UpdateUserExamDto, UserExam>(userExamDto, item);
+
+                if (userExamDto != null)
+                    _mapper.Map<UpdateUserExamDto, UserExam>(userExamDto, item);
             });
 
             userExams.ToUpdate(_sessionContext);
@@ -356,7 +441,14 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             var examQuestionScores = all.Where(x => ids.Contains(x.Id)).ToList();
 
-            examQuestionScores = _mapper.Map<List<UpdateExamQuestionScoreDto>, List<ExamQuestionScore>>(examQuestionScoreDtos, examQuestionScores);
+            //examQuestionScores = _mapper.Map<List<UpdateExamQuestionScoreDto>, List<ExamQuestionScore>>(examQuestionScoreDtos, examQuestionScores);
+
+            examQuestionScores.ForEach(item =>
+            {
+                var examQuestionScoreDto = examQuestionScoreDtos.FirstOrDefault(x => x.Id == item.Id);
+                if (examQuestionScoreDto != null)
+                    item = _mapper.Map<UpdateExamQuestionScoreDto, ExamQuestionScore>(examQuestionScoreDto, item);
+            });
 
             examQuestionScores.ToUpdate(_sessionContext);
 
@@ -504,6 +596,37 @@ namespace Hotline.Application.Exam.Service.ExamManages
             });
             return queryable;
         }
+
+
+        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 questionTable = questionRepository.Queryable();
+            var questionTagTable = questionTagRepository.Queryable();
+
+            if (tagQuestionCounts != null && tagQuestionCounts.Any())
+            {
+                var questionQuerables = new List<ISugarQueryable<Question>>();
+                tagQuestionCounts.ForEach(item =>
+                {
+                    ISugarQueryable<Question> queryable = questionTable.InnerJoin(questionTagTable, (q, t) => t.Id == t.QuestionId)
+                        .Where((q, t) => q.QuestionType == item.QuestionType && t.TagId == item.TagId).Take(item.Count).Select((q, t) => q);
+
+                    questionQuerables.Add(queryable);
+                });
+
+                var queryResult = questionRepository.UnionAll(questionQuerables.ToArray());
+
+                return await queryResult.ToListAsync();
+            }
+            else
+            {
+                return null;
+            }
+
+        }
         #endregion
     }
 }

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<TestPaperItem>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression).FirstAsync();
+            var quesetion = await new ExamRepository<ExamQuestion>(_repository.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<TestPaperItemOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.QuestionId == quesetion.Id).ToListAsync();
+                    var questionOptions = await new ExamRepository<ExamQuestionOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.ExamQuestionId == quesetion.Id).ToListAsync();
 
                     if (questionOptions != null)
                     {
@@ -124,9 +124,9 @@ namespace Hotline.Application.Exam.Service.ExamManages
         {
             var expression = examQuestionGroupRequest.GetExpression();
             var examManageTable = new ExamRepository<ExamManage>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression);
-            var testPaperItemTable = new ExamRepository<TestPaperItem>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var testPaperItemTable = new ExamRepository<ExamQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
-            var queryable = await examManageTable.InnerJoin(testPaperItemTable, (e, i) => e.TestPaperId == i.TestPaperId)
+            var queryable = await examManageTable.InnerJoin(testPaperItemTable, (e, i) => e.Id == i.ExamId)
                 .Select((e, i) => i).ToListAsync();
 
             var result = queryable.GroupBy(x => x.QuestionType).Select(m => new ExamQuestionViewResponse
@@ -147,9 +147,9 @@ namespace Hotline.Application.Exam.Service.ExamManages
         {
             var expression = examQuestionGroupRequest.GetExpression();
             var examManageTable = new ExamRepository<ExamManage>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression);
-            var testPaperItemTable = new ExamRepository<TestPaperItem>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var testPaperItemTable = new ExamRepository<ExamQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
-            var queryable = await examManageTable.InnerJoin(testPaperItemTable, (e, i) => e.TestPaperId == i.TestPaperId)
+            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();
@@ -173,7 +173,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             return result;
         }
 
-        private bool CheckCorrect(TestPaperItem n, List<ExamQuestionScore> examQuestionScores, List<UserExamItem> userExamItems)
+        private bool CheckCorrect(ExamQuestion n, List<ExamQuestionScore> examQuestionScores, List<UserExamItem> userExamItems)
         {
             var examQuestionScore = examQuestionScores.FirstOrDefault(x => x.QuestionType == n.QuestionType);
             var userItem = userExamItems.FirstOrDefault(x => x.QuestionId == n.QuestionId);
@@ -447,9 +447,9 @@ namespace Hotline.Application.Exam.Service.ExamManages
             var userExamItemTable = _userExamItemRepository.Queryable();
             var userExamItemOptionTable = _userExamItemOptionRepository.Queryable();
             var examAnswerTable = new ExamRepository<ExamAnswer>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
-            var questionTable = new ExamRepository<TestPaperItem>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
-            var quesitonOptionTable = new ExamRepository<TestPaperItemOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
-            var testPaperItemAnswerTable = new ExamRepository<TestPaperItemAnswer>(_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 questionScoreTable = questionScoreRepository.Queryable();
 
             var queryResult = await userExamTable.InnerJoin(userExamItemTable, (e, i) => e.Id == i.UserExamId)
@@ -582,16 +582,16 @@ namespace Hotline.Application.Exam.Service.ExamManages
         {
             if (!addUserExamItemDto.QuestionType.CheckSelectType()) return;
 
-            var testPaperItemOptionsRepository = new ExamRepository<TestPaperItemOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var testPaperItemOptionsRepository = new ExamRepository<ExamQuestionOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
             var examManageRepository = new ExamRepository<ExamManage>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
-            var testPaperItemRepository = new ExamRepository<TestPaperItem>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var testPaperItemRepository = new ExamRepository<ExamQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
             var examQuestionScoreRepository = new ExamRepository<ExamQuestionScore>(_repository.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);
             var examManageTable = examManageRepository.Queryable();
-            var testPaperOptionIds = await testPaperOptionsTable.InnerJoin(testPaperItemTable, (t, i) => t.TestPaperItemId == i.Id)
-                .InnerJoin(examManageTable, (t, i, e) => i.TestPaperId == e.TestPaperId)
+            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();
 
@@ -644,17 +644,17 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             if (userExamItem != null)
             {
-                var testPaperItem = new ExamRepository<TestPaperItem>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.Id == userExamItem.Id && !x.QuestionType.CheckSelectType()).First();
+                var testPaperItem = new ExamRepository<ExamQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.Id == userExamItem.Id && !x.QuestionType.CheckSelectType()).First();
 
                 if (testPaperItem == null) return null;
 
                 var gradingExamQuestionDto = new GradingExamQuestionDto();
 
-                gradingExamQuestionDto = _mapper.Map<TestPaperItem, GradingExamQuestionDto>(testPaperItem, gradingExamQuestionDto);
+                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 testPaperItemAnswer = await new ExamRepository<TestPaperItemAnswer>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().FirstAsync(x => x.QuestionId == testPaperItem.QuestionId && x.TestPaperItemId == testPaperItem.Id);
+                var testPaperItemAnswer = await new ExamRepository<ExamQuestionAnswer>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable().FirstAsync(x => x.QuestionId == testPaperItem.QuestionId && x.ExamQuestionId == testPaperItem.Id);
 
                 gradingExamQuestionDto.Answer = examAnswer.Answer ?? string.Empty;
 
@@ -691,13 +691,13 @@ namespace Hotline.Application.Exam.Service.ExamManages
         private async Task<UserExamQuestionDto> GetNextExamQuestion(AddUserExamItemDto addUserExamItemDto)
         {
             // TODO: 获取未阅卷的第一道题
-            var testPaperItemRepository = new ExamRepository<TestPaperItem>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
+            var testPaperItemRepository = new ExamRepository<ExamQuestion>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider);
             var examRepository = new ExamRepository<ExamManage>(_repository.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();
             var testPaperItemTable = testPaperItemRepository.Queryable();
-            var current = examTable.InnerJoin(testPaperItemTable, (e, t) => e.TestPaperId == t.TestPaperId)
+            var current = examTable.InnerJoin(testPaperItemTable, (e, t) => e.Id == t.ExamId)
                 .InnerJoin(userExamTable, (e, t, u) => e.Id == u.ExamId)
                 .InnerJoin(userExamItemTable, (e, t, u, i) => t.QuestionId == i.QuestionId).Select((e, t, u, i) => t);
             var nextTable = testPaperItemTable.InnerJoin(current, (t, c) => t.SortIndex > c.SortIndex).OrderBy((t, c) => t.SortIndex).Select((t, c) => t);
@@ -712,12 +712,12 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
                 var userExamQuestionDto = new UserExamQuestionDto();
 
-                userExamQuestionDto = _mapper.Map<TestPaperItem, UserExamQuestionDto>(question, userExamQuestionDto);
+                userExamQuestionDto = _mapper.Map<ExamQuestion, UserExamQuestionDto>(question, userExamQuestionDto);
 
                 if (question.QuestionType.CheckSelectType())
                 {
                     var userExamItemOptionTable = _userExamItemOptionRepository.Queryable().Where(x => x.UserExamItemId == userExamItem.Id);
-                    var quesitonOptionTable = new ExamRepository<TestPaperItemOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+                    var quesitonOptionTable = new ExamRepository<ExamQuestionOptions>(_repository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
                     var queryResult = userExamItemOptionTable.InnerJoin(quesitonOptionTable, (u, q) => u.QuestionOptionId == q.Id)
                         .Select((u, q) => new UserExamItemOptionDto

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

@@ -176,6 +176,8 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
             await base.Complete(base.Entity, OperationConstant.Create);
 
+            //await GenerateTestPaper(new GenerateTestPaperRequest { TestPaperId = id }, cancellationToken);
+
             return id;
         }
 
@@ -213,17 +215,9 @@ namespace Hotline.Application.Exam.Service.TestPapers
                 item.TestPaperItemOptionses = testPaperItemOptions.Where(x => item.Id == x.TestPaperItemId).ToList();
             });
 
-            //base.Entity.TestPaperRules = await ModifyTestPaperRules(actionRequest, cancellationToken);
-
-            //var testPaperRuleTags = await ModifyTestPaperRuleTags(actionRequest, cancellationToken);
-
-            //base.Entity.TestPaperRules.ForEach(item =>
-            //{
-
-            //    item.TestPaperRuleTags = testPaperRuleTags.Where(x => item.Id == x.TestPaperRuleId).ToList();
-            //});
-
             await base.Complete(base.Entity, OperationConstant.Update);
+
+            //await GenerateTestPaper(new GenerateTestPaperRequest { TestPaperId = actionRequest.Id }, cancellationToken);
         }
 
 
@@ -323,6 +317,9 @@ namespace Hotline.Application.Exam.Service.TestPapers
                         _mapper,
                         _sessionContext);
 
+                    //删除已经生成的试卷试题
+                    await _testPaperProxy.DeleteTestPaperItems(generateTestPaperRequest.TestPaperId, cancellationToken);
+
                     await _testPaperProxy.GenerateQuestion(questions, generateTestPaperRequest.TestPaperId, cancellationToken);
                 }
             }
@@ -930,7 +927,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
                     testPaperItemAnswer.TestPaperItemId = testPaperItem?.Id;
 
-                    testPaperItemAnswer.QueswerAnswerId = item.Id;
+                    testPaperItemAnswer.QuestionAnswerId = item.Id;
 
                     testPaperItemAnswer.ToInsert(_sessionContext);
 

src/Hotline.Repository.SqlSugar/Exam/Interfaces/ExamManages/IExamQuestionAnswerRepository.cs

@@ -0,0 +1,17 @@
+using Hotline.Exams.ExamManages;
+using Hotline.Exams.TestPapers;
+using Hotline.Repository.SqlSugar.Interface;
+using System.ComponentModel;
+using XF.Domain.Repository;
+
+namespace Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages
+{
+    /// <summary>
+    /// 考试答案仓储接口
+    /// </summary>
+    [Description("考试答案仓储接口")]
+    public interface IExamQuestionAnswerRepository : IRepository<ExamQuestionAnswer>, IExamRepository<ExamQuestionAnswer, HotlineDbContext>
+    {
+
+    }
+}

src/Hotline.Repository.SqlSugar/Exam/Interfaces/ExamManages/IExamQuestionKnowladgeRepository.cs

@@ -0,0 +1,20 @@
+
+using SqlSugar;
+using XF.Domain.Repository;
+using System.ComponentModel;
+using Exam.Questions;
+using Hotline.Repository.SqlSugar.Interface;
+
+namespace Hotline.Repository.SqlSugar.Exam.Interfaces.Questions
+{
+    /// <summary>
+    /// 关联知识仓储接口
+    /// </summary>
+    [Description("关联知识仓储接口")]
+    public interface IExamQuestionKnowladgeRepository:IRepository<ExamQuestionKnowladge>,IExamRepository<ExamQuestionKnowladge, HotlineDbContext>
+    {
+       
+    }
+}
+
+

src/Hotline.Repository.SqlSugar/Exam/Interfaces/ExamManages/IExamQuestionOptionsRepository.cs

@@ -0,0 +1,10 @@
+using Hotline.Exams.ExamManages;
+using Hotline.Repository.SqlSugar.Interface;
+using XF.Domain.Repository;
+
+namespace Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages
+{
+    public interface IExamQuestionOptionsRepository : IRepository<ExamQuestionOptions>, IExamRepository<ExamQuestionOptions, HotlineDbContext>
+    {
+    }
+}

src/Hotline.Repository.SqlSugar/Exam/Interfaces/ExamManages/IExamQuestionRepository.cs

@@ -0,0 +1,18 @@
+using Exam.ExamManages;
+using Hotline.Repository.SqlSugar.Interface;
+using System.ComponentModel;
+using XF.Domain.Repository;
+
+namespace Hotline.Repository.SqlSugar.Exam.Interfaces.Exams
+{
+    /// <summary>
+    /// 考试题目仓储接口
+    /// </summary>
+    [Description("考试题目仓储接口")]
+    public interface IExamQuestionRepository:IRepository<ExamQuestion>,IExamRepository<ExamQuestion,HotlineDbContext>
+    {
+       
+    }
+}
+
+

src/Hotline.Repository.SqlSugar/Exam/Interfaces/ExamManages/IExamQuestionSourcewareRepository.cs

@@ -0,0 +1,21 @@
+
+using SqlSugar;
+using XF.Domain.Repository;
+using System.ComponentModel;
+using Exam.Questions;
+using Hotline.Repository.SqlSugar.Interface;
+using Exam.ExamManages;
+
+namespace Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages
+{
+    /// <summary>
+    /// 关联课件仓储接口
+    /// </summary>
+    [Description("关联课件仓储接口")]
+    public interface IExamQuestionSourcewareRepository:IRepository<ExamQuestionSourceware>,IExamRepository<ExamQuestionSourceware, HotlineDbContext>
+    {
+       
+    }
+}
+
+

src/Hotline.Repository.SqlSugar/Exam/Repositories/ExamManages/ExamQuestionAnswerRepository.cs

@@ -0,0 +1,27 @@
+using Exam.Repository.Sqlsugar.Repositories;
+using Exam.TestPapers;
+using Hotline.Exams.ExamManages;
+using Hotline.Exams.TestPapers;
+using Hotline.Repository.SqlSugar.DataPermissions;
+using Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages;
+using Hotline.Repository.SqlSugar.Exam.Interfaces.TestPapers;
+using Hotline.Repository.SqlSugar.Exam.Validators.ExamManages;
+using Hotline.Repository.SqlSugar.Exam.Validators.TestPapers;
+using SqlSugar;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using XF.Domain.Dependency;
+
+namespace Hotline.Repository.SqlSugar.Exam.Repositories.ExamManages
+{
+    public class ExamQuestionAnswerRepository : ExamRepository<ExamQuestionAnswer>, IExamQuestionAnswerRepository, IScopeDependency
+    {
+        public ExamQuestionAnswerRepository(ISugarUnitOfWork<HotlineDbContext> uow, IDataPermissionFilterBuilder dataPermissionFilterBuilder, IServiceProvider serviceProvider) : base(uow, dataPermissionFilterBuilder, serviceProvider)
+        {
+            Validator = new ExamQuestionAnswerValidator();
+        }
+    }
+}

src/Hotline.Repository.SqlSugar/Exam/Repositories/ExamManages/ExamQuestionKnowladgeRepository.cs

@@ -0,0 +1,26 @@
+using Exam.Questions;
+using Exam.Repository.Sqlsugar.Repositories;
+using Exam.Repository.Sqlsugar.Validators.ExamManages;
+using Exam.Repository.Sqlsugar.Validators.Questions;
+using Hotline.Repository.SqlSugar;
+using Hotline.Repository.SqlSugar.DataPermissions;
+using Hotline.Repository.SqlSugar.Exam.Interfaces.Questions;
+using SqlSugar;
+using System.ComponentModel;
+using XF.Domain.Dependency;
+
+namespace Exam.Repository.Sqlsugar
+{
+    /// <summary>
+    /// 关联知识仓储
+    /// </summary>
+    [Description("关联知识仓储")]
+    public class ExamQuestionKnowladgeRepository : ExamRepository<ExamQuestionKnowladge>, IExamQuestionKnowladgeRepository, IScopeDependency
+    {
+        public ExamQuestionKnowladgeRepository(ISugarUnitOfWork<HotlineDbContext> uow, IDataPermissionFilterBuilder dataPermissionFilterBuilder, IServiceProvider serviceProvider) : base(uow, dataPermissionFilterBuilder, serviceProvider)
+        {
+            Validator = new ExamQuestionKnowladgeValidator();
+        }
+    }
+}
+

src/Hotline.Repository.SqlSugar/Exam/Repositories/ExamManages/ExamQuestionOptionsRepository.cs

@@ -0,0 +1,18 @@
+using Exam.Repository.Sqlsugar.Repositories;
+using Hotline.Exams.ExamManages;
+using Hotline.Repository.SqlSugar.DataPermissions;
+using Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages;
+using Hotline.Repository.SqlSugar.Exam.Validators.ExamManages;
+using SqlSugar;
+using XF.Domain.Dependency;
+
+namespace Hotline.Repository.SqlSugar.Exam.Repositories.Exams
+{
+    public class ExamQuestionOptionsRepository : ExamRepository<ExamQuestionOptions>, IExamQuestionOptionsRepository, IScopeDependency
+    {
+        public ExamQuestionOptionsRepository(ISugarUnitOfWork<HotlineDbContext> uow, IDataPermissionFilterBuilder dataPermissionFilterBuilder, IServiceProvider serviceProvider) : base(uow, dataPermissionFilterBuilder, serviceProvider)
+        {
+            Validator = new ExamQuestionOptionsValidator();
+        }
+    }
+}

src/Hotline.Repository.SqlSugar/Exam/Repositories/ExamManages/ExamQuestionRepository.cs

@@ -0,0 +1,24 @@
+using Exam.ExamManages;
+using Exam.Repository.Sqlsugar.Validators.ExamManages;
+using Hotline.Repository.SqlSugar;
+using Hotline.Repository.SqlSugar.DataPermissions;
+using Hotline.Repository.SqlSugar.Exam.Interfaces.Exams;
+using SqlSugar;
+using System.ComponentModel;
+using XF.Domain.Dependency;
+
+namespace Exam.Repository.Sqlsugar.Repositories.Exams
+{
+    /// <summary>
+    /// 练习题目仓储
+    /// </summary>
+    [Description("练习题目仓储")]
+    public class ExamQuestionRepository : ExamRepository<ExamQuestion>, IExamQuestionRepository,IScopeDependency
+    {
+        public ExamQuestionRepository(ISugarUnitOfWork<HotlineDbContext> uow, IDataPermissionFilterBuilder dataPermissionFilterBuilder, IServiceProvider serviceProvider) : base(uow, dataPermissionFilterBuilder, serviceProvider)
+        {
+            Validator = new ExamQuestionValidator();
+        }
+    }
+}
+

src/Hotline.Repository.SqlSugar/Exam/Repositories/ExamManages/ExamQuestionSourcewareRepository.cs

@@ -0,0 +1,25 @@
+using Exam.ExamManages;
+using Exam.Repository.Sqlsugar.Repositories;
+using Exam.Repository.Sqlsugar.Validators.Questions;
+using Hotline.Repository.SqlSugar;
+using Hotline.Repository.SqlSugar.DataPermissions;
+using Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages;
+using SqlSugar;
+using System.ComponentModel;
+using XF.Domain.Dependency;
+
+namespace Exam.Repository.Sqlsugar
+{
+    /// <summary>
+    /// 关联课件仓储
+    /// </summary>
+    [Description("关联课件仓储")]
+    public class ExamQuestionSourcewareRepository : ExamRepository<ExamQuestionSourceware>, IExamQuestionSourcewareRepository,IScopeDependency
+    {
+        public ExamQuestionSourcewareRepository(ISugarUnitOfWork<HotlineDbContext> uow, IDataPermissionFilterBuilder dataPermissionFilterBuilder, IServiceProvider serviceProvider) : base(uow, dataPermissionFilterBuilder, serviceProvider)
+        {
+            Validator = new ExamQuestionSourcewareValidator();
+        }
+    }
+}
+

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

@@ -0,0 +1,48 @@
+using Exam.Infrastructure.Extensions;
+using Exam.Infrastructure.Validation.Validation;
+using Exam.ExamManages;
+using FluentValidation;
+using Hotline.Exams.ExamManages;
+using Hotline.Repository.SqlSugar.Validate;
+
+namespace Hotline.Repository.SqlSugar.Exam.Validators.ExamManages
+{
+    public class ExamQuestionAnswerValidator : BaseValidator<ExamQuestionAnswer>
+    {
+        public ExamQuestionAnswerValidator()
+        {
+            RuleSet(ValidatorTypeConstants.Create, () =>
+            {
+                BaseValidateRule();
+
+                ValidateRuleWithAdd();
+            });
+
+            RuleSet(ValidatorTypeConstants.Modify, () =>
+            {
+                BaseValidateRule();
+
+                ValidateRuleWithModify();
+            });
+        }
+
+        protected override void BaseValidateRule()
+        {
+            base.BaseValidateRule();
+
+        }
+
+        protected override void ValidateRuleWithAdd()
+        {
+            base.ValidateRuleWithAdd();
+            RuleFor(m => m.CreationTime).NotEmpty().WithMessage(x => string.Format(ErrorMessage.IsRequired, x.GetType().GetDescription(nameof(ExamQuestion.CreationTime))));
+        }
+
+        protected override void ValidateRuleWithModify()
+        {
+            base.ValidateRuleWithModify();
+            RuleFor(m => m.LastModificationTime).NotEmpty().WithMessage(x => string.Format(ErrorMessage.IsRequired, x.GetType().GetDescription(nameof(ExamQuestion.LastModificationTime))));
+
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+using Exam.Infrastructure.Extensions;
+using Exam.Infrastructure.Validation.Validation;
+using Exam.Questions;
+using FluentValidation;
+using Hotline.KnowledgeBase;
+using Hotline.Repository.SqlSugar.Validate;
+
+namespace Exam.Repository.Sqlsugar.Validators.ExamManages
+{
+    public class ExamQuestionKnowladgeValidator:BaseValidator<ExamQuestionKnowladge>
+    {
+        public ExamQuestionKnowladgeValidator()
+        {
+            RuleSet(ValidatorTypeConstants.Create, () =>
+            {
+                BaseValidateRule();
+
+                ValidateRuleWithAdd();
+            });
+
+            RuleSet(ValidatorTypeConstants.Modify, () =>
+            {
+                BaseValidateRule();
+
+                ValidateRuleWithModify();
+            });
+        }
+
+        protected override void BaseValidateRule()
+        {
+            base.BaseValidateRule();
+            RuleFor(m => m.KnowladgeId).NotEmpty().WithMessage(x => string.Format(ErrorMessage.IsRequired, typeof(Knowledge).GetDescription()));
+            RuleFor(m => m.QuestionId).NotEmpty().WithMessage(x => string.Format(ErrorMessage.IsRequired, typeof(Question).GetDescription()));
+        }
+
+        protected override void ValidateRuleWithAdd()
+        {
+            base.ValidateRuleWithAdd();
+            RuleFor(m => m.CreationTime).NotEmpty().WithMessage(x => string.Format(ErrorMessage.IsRequired, x.GetType().GetDescription(nameof(QuestionKnowladge.CreationTime))));
+        }
+
+        protected override void ValidateRuleWithModify()
+        {
+            base.ValidateRuleWithModify();
+            RuleFor(m => m.LastModificationTime).NotEmpty().WithMessage(x => string.Format(ErrorMessage.IsRequired, x.GetType().GetDescription(nameof(QuestionKnowladge.LastModificationTime))));
+
+        }
+
+    }
+}

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

@@ -0,0 +1,47 @@
+using Exam.ExamManages;
+using Exam.Infrastructure.Extensions;
+using Exam.Infrastructure.Validation.Validation;
+using FluentValidation;
+using Hotline.Exams.ExamManages;
+using Hotline.Repository.SqlSugar.Validate;
+
+namespace Hotline.Repository.SqlSugar.Exam.Validators.ExamManages
+{
+    public class ExamQuestionOptionsValidator : BaseValidator<ExamQuestionOptions>
+    {
+        public ExamQuestionOptionsValidator()
+        {
+            RuleSet(ValidatorTypeConstants.Create, () =>
+            {
+                BaseValidateRule();
+
+                ValidateRuleWithAdd();
+            });
+
+            RuleSet(ValidatorTypeConstants.Modify, () =>
+            {
+                BaseValidateRule();
+
+                ValidateRuleWithModify();
+            });
+        }
+
+        protected override void BaseValidateRule()
+        {
+            base.BaseValidateRule();
+        }
+
+        protected override void ValidateRuleWithAdd()
+        {
+            base.ValidateRuleWithAdd();
+            RuleFor(m => m.CreationTime).NotEmpty().WithMessage(x => string.Format(ErrorMessage.IsRequired, x.GetType().GetDescription(nameof(ExamAnswer.CreationTime))));
+        }
+
+        protected override void ValidateRuleWithModify()
+        {
+            base.ValidateRuleWithModify();
+            RuleFor(m => m.LastModificationTime).NotEmpty().WithMessage(x => string.Format(ErrorMessage.IsRequired, x.GetType().GetDescription(nameof(ExamAnswer.LastModificationTime))));
+
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+using Exam.ExamManages;
+using Exam.Infrastructure.Extensions;
+using Exam.Infrastructure.Validation.Validation;
+using Exam.Questions;
+using FluentValidation;
+using Hotline.Exams.Sourcewares;
+using Hotline.Repository.SqlSugar.Validate;
+
+namespace Exam.Repository.Sqlsugar.Validators.Questions
+{
+    public class ExamQuestionSourcewareValidator:BaseValidator<ExamQuestionSourceware>
+    {
+        public ExamQuestionSourcewareValidator()
+        {
+            RuleSet(ValidatorTypeConstants.Create, () =>
+            {
+                BaseValidateRule();
+
+                ValidateRuleWithAdd();
+            });
+
+            RuleSet(ValidatorTypeConstants.Modify, () =>
+            {
+                BaseValidateRule();
+
+                ValidateRuleWithModify();
+            });
+        }
+
+        protected override void BaseValidateRule()
+        {
+            base.BaseValidateRule();
+            RuleFor(m => m.SourcewareId).NotEmpty().WithMessage(x => string.Format(ErrorMessage.IsRequired, typeof(Sourceware).GetDescription()));
+            RuleFor(m => m.QuestionId).NotEmpty().WithMessage(x => string.Format(ErrorMessage.IsRequired, typeof(Question).GetDescription()));
+        }
+
+        protected override void ValidateRuleWithAdd()
+        {
+            base.ValidateRuleWithAdd();
+            RuleFor(m => m.CreationTime).NotEmpty().WithMessage(x => string.Format(ErrorMessage.IsRequired, x.GetType().GetDescription(nameof(QuestionSourceware.CreationTime))));
+        }
+
+        protected override void ValidateRuleWithModify()
+        {
+            base.ValidateRuleWithModify();
+            RuleFor(m => m.LastModificationTime).NotEmpty().WithMessage(x => string.Format(ErrorMessage.IsRequired, x.GetType().GetDescription(nameof(QuestionSourceware.LastModificationTime))));
+
+        }
+
+    }
+}

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

@@ -0,0 +1,47 @@
+using Exam.ExamManages;
+using Exam.Infrastructure.Extensions;
+using Exam.Infrastructure.Validation.Validation;
+using FluentValidation;
+using Hotline.Repository.SqlSugar.Validate;
+
+namespace Exam.Repository.Sqlsugar.Validators.ExamManages
+{
+    public class ExamQuestionValidator:BaseValidator<ExamQuestion>
+    {
+        public ExamQuestionValidator()
+        {
+            RuleSet(ValidatorTypeConstants.Create, () =>
+            {
+                BaseValidateRule();
+
+                ValidateRuleWithAdd();
+            });
+
+            RuleSet(ValidatorTypeConstants.Modify, () =>
+            {
+                BaseValidateRule();
+
+                ValidateRuleWithModify();
+            });
+        }
+
+        protected override void BaseValidateRule()
+        {
+            base.BaseValidateRule();
+        }
+
+        protected override void ValidateRuleWithAdd()
+        {
+            base.ValidateRuleWithAdd();
+            RuleFor(m => m.CreationTime).NotEmpty().WithMessage(x => string.Format(ErrorMessage.IsRequired, x.GetType().GetDescription(nameof(ExamQuestion.CreationTime))));
+        }
+
+        protected override void ValidateRuleWithModify()
+        {
+            base.ValidateRuleWithModify();
+            RuleFor(m => m.LastModificationTime).NotEmpty().WithMessage(x => string.Format(ErrorMessage.IsRequired, x.GetType().GetDescription(nameof(ExamQuestion.LastModificationTime))));
+
+        }
+
+    }
+}

src/Hotline.Repository.SqlSugar/Extensions/SqlSugarStartupExtensions.cs

@@ -147,7 +147,6 @@ namespace Hotline.Repository.SqlSugar.Extensions
 
                 var types = typeof(User).Assembly.GetTypes()
                     .Where(d => d.GetInterfaces().Any(x => x == typeof(ITable) && !d.IsAbstract))
-                    //.Where(d => d.Name != "Order" && d.Name != "OrderCopy" && d.Name != "Workflow" && d.Name != "WorkflowStep" && d.Name != "WorkflowTrace")
                     .Distinct()
                     .ToArray();
 

src/Hotline/Exams/ExamManages/ExamQuestion.cs

@@ -0,0 +1,64 @@
+using Exam.Questions;
+using Hotline.Exams.Base;
+using Hotline.Exams.ExamManages;
+using Hotline.Share.Enums.Exams;
+using SqlSugar;
+using System.ComponentModel;
+
+namespace Exam.ExamManages
+{
+    /// <summary>
+    /// 考试题目
+    /// </summary>
+    [Description("考试题目")]
+    public class ExamQuestion : BusinessEntity
+    {
+        /// <summary>
+        /// 练习Id
+        /// </summary>
+        [SugarColumn(ColumnDescription ="考试Id")]
+        [Description("考试Id")]
+        public string ExamId { get; set; }
+
+        /// <summary>
+        /// 试题Id
+        /// </summary>
+        [SugarColumn(ColumnDescription ="试题Id")]
+        [Description("试题Id")]
+        public string QuestionId { get; set; }
+
+        /// <summary>
+        /// 题干
+        /// </summary>
+        [SugarColumn(ColumnDescription = "题干")]
+        [Description("题干")]
+        public string Title { get; set; }
+
+        /// <summary>
+        /// 题型
+        /// </summary>
+        [SugarColumn(ColumnDescription = "题型")]
+        [Description("题型")]
+        public EQuestionType QuestionType { get; set; }
+
+        /// <summary>
+        /// 难易程度
+        /// </summary>
+        [SugarColumn(ColumnDescription = "难易程度")]
+        [Description("难易程度")]
+        public EDifficultyLevel DifficultyLevel { get; set; }
+
+
+        [Navigate(NavigateType.OneToMany, nameof(ExamQuestionOptions.ExamQuestionId))]
+        public List<ExamQuestionOptions> ExamQuestionOptionses { get; set; }
+
+        [Navigate(NavigateType.OneToMany,nameof(ExamQuestionSourceware.ExamQuestionId))]
+        public List<ExamQuestionSourceware> ExamQuestionSourcewares { get; set; }
+
+        [Navigate(NavigateType.OneToMany,nameof(ExamQuestionKnowladge.ExamQuestionId))]
+        public List<ExamQuestionKnowladge> ExamQuestionKnowladges { get; set; }
+
+        [Navigate(NavigateType.OneToMany, nameof(ExamQuestionKnowladge.ExamQuestionId))]
+        public List<ExamQuestionAnswer> ExamQuestionAnswers { get; set; }
+    }
+}

src/Hotline/Exams/ExamManages/ExamQuestionAnswer.cs

@@ -0,0 +1,41 @@
+using Hotline.Exams.Base;
+using SqlSugar;
+using System.ComponentModel;
+
+namespace Hotline.Exams.ExamManages
+{
+    /// <summary>
+    /// 考试试题答案
+    /// </summary>
+    [Description("考试试题答案")]
+    public class ExamQuestionAnswer:BusinessEntity
+    {
+        /// <summary>
+        /// 考试明细Id
+        /// </summary>
+        [SugarColumn(ColumnDescription = "考试明细Id")]
+        [Description("考试明细Id")]
+        public string ExamQuestionId { get; set; }
+
+        /// <summary>
+        /// 题库Id
+        /// </summary>
+        [Description("题库Id")]
+        [SugarColumn(ColumnDescription = "题库Id")]
+        public string QuestionId { get; set; }
+
+        /// <summary>
+        /// 答案
+        /// </summary>
+        [SugarColumn(ColumnDescription = "答案")]
+        [Description("答案")]
+        public string? Answer { get; set; }
+
+        /// <summary>
+        /// 题库答案Id
+        /// </summary>
+        [SugarColumn(ColumnDescription = "题库答案Id")]
+        [Description("题库答案Id")]
+        public string QuestionAnswerId { get; set; }
+    }
+}

src/Hotline/Exams/ExamManages/ExamQuestionKnowladge.cs

@@ -0,0 +1,42 @@
+using System.ComponentModel;
+using Hotline.Exams.Base;
+using SqlSugar;
+
+namespace Exam.Questions
+{
+    /// <summary>
+    /// 考试关联知识
+    /// </summary>
+    [Description("考试关联知识")]
+    public class ExamQuestionKnowladge:BusinessEntity
+    {
+        /// <summary>
+        /// 试题Id
+        /// </summary>
+        [SugarColumn(ColumnDescription ="试题Id")]
+        [Description("试题Id")]
+        public string QuestionId { get; set; }
+
+        /// <summary>
+        /// 知识Id
+        /// </summary>
+        [SugarColumn(ColumnDescription ="知识Id")]
+        [Description("知识Id")]
+        public string KnowladgeId { get; set; }
+
+        /// <summary>
+        /// 标题
+        /// </summary>
+        [SugarColumn(ColumnDescription = "标题")]
+        [Description("标题")]
+        public string Title { get; set; }
+
+        /// <summary>
+        /// 练习习题Id
+        /// </summary>
+        [SugarColumn(ColumnDescription = "练习习题Id")]
+        [Description("练习习题Id")]
+
+        public string ExamQuestionId { get; set; }
+    }
+}

src/Hotline/Exams/ExamManages/ExamQuestionOptions.cs

@@ -0,0 +1,52 @@
+using Hotline.Exams.Base;
+using SqlSugar;
+using System.ComponentModel;
+
+namespace Hotline.Exams.ExamManages
+{
+    [Description("考试习题选项")]
+    public class ExamQuestionOptions:BusinessEntity
+    {
+        /// <summary>
+        /// 考试试题Id
+        /// </summary>
+        [SugarColumn(ColumnDescription = "考试试题Id")]
+        [Description("考试试题Id")]
+        public string ExamQuestionId { get; set; }
+
+        /// <summary>
+        /// 题库试题Id
+        /// </summary>
+        [SugarColumn(ColumnDescription = "题库试题Id")]
+        [Description("题库试题Id")]
+        public string QuestionId { get; set; }
+
+        /// <summary>
+        /// 题库试题选项Id
+        /// </summary>
+        [SugarColumn(ColumnDescription = "题库试题选项Id")]
+        [Description("题库试题选项Id")]
+        public string QuestionOptionId { get; set; }
+
+        /// <summary>
+        /// 选项
+        /// </summary>
+        [SugarColumn(ColumnDescription = "选项")]
+        [Description("选项")]
+        public string Content { get; set; }
+
+        /// <summary>
+        /// 是否答案
+        /// </summary>
+        [SugarColumn(ColumnDescription = "是否答案")]
+        [Description("是否答案")]
+        public bool IsAnswer { get; set; }
+
+        /// <summary>
+        /// 选项题标
+        /// </summary>
+        [SugarColumn(ColumnDescription = "选项题标")]
+        [Description("选项题标")]
+        public string Label { get; set; }
+    }
+}

src/Hotline/Exams/ExamManages/ExamQuestionSourceware.cs

@@ -0,0 +1,35 @@
+using System.ComponentModel;
+using Hotline.Exams.Base;
+using SqlSugar;
+
+namespace Exam.ExamManages
+{
+    /// <summary>
+    /// 关联课件
+    /// </summary>
+    [Description("关联课件")]
+    public class ExamQuestionSourceware:BusinessEntity
+    {
+        /// <summary>
+        /// 试题Id
+        /// </summary>
+        [SugarColumn(ColumnDescription ="试题Id")]
+        [Description("试题Id")]
+        public string QuestionId { get; set; }
+
+        /// <summary>
+        /// 课件Id
+        /// </summary>
+        [SugarColumn(ColumnDescription = "课件Id")]
+        [Description("课件Id")]
+        public string SourcewareId { get; set; }
+
+        /// <summary>
+        /// 练习习题Id
+        /// </summary>
+        [SugarColumn(ColumnDescription = "练习习题Id")]
+        [Description("练习习题Id")]
+
+        public string ExamQuestionId { get; set; }
+    }
+}

src/Hotline/Exams/TestPapers/TestPaperItemAnswer.cs

@@ -42,6 +42,6 @@ namespace Hotline.Exams.TestPapers
         /// </summary>
         [SugarColumn(ColumnDescription = "题库答案Id")]
         [Description("题库答案Id")]
-        public string QueswerAnswerId { get; set; }
+        public string QuestionAnswerId { get; set; }
     }
 }